BLI_string: add BLI_snprintf_rlen
[blender-staging.git] / source / blender / editors / space_nla / nla_draw.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
19  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Joshua Leung (major recode)
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/space_nla/nla_draw.c
28  *  \ingroup spnla
29  */
30
31
32 #include <string.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <math.h>
36 #include <float.h>
37
38 #include "DNA_anim_types.h"
39 #include "DNA_node_types.h"
40 #include "DNA_screen_types.h"
41 #include "DNA_space_types.h"
42 #include "DNA_windowmanager_types.h"
43
44 #include "BLI_blenlib.h"
45 #include "BLI_dlrbTree.h"
46 #include "BLI_utildefines.h"
47
48 #include "BKE_fcurve.h"
49 #include "BKE_nla.h"
50 #include "BKE_context.h"
51 #include "BKE_screen.h"
52
53 #include "ED_anim_api.h"
54 #include "ED_keyframes_draw.h"
55
56 #include "BIF_gl.h"
57 #include "BIF_glutil.h"
58
59 #include "WM_types.h"
60
61 #include "UI_interface.h"
62 #include "UI_resources.h"
63 #include "UI_view2d.h"
64
65
66 #include "nla_intern.h" /* own include */
67
68
69 /* *********************************************** */
70 /* Strips */
71
72 /* Action-Line ---------------------- */
73
74 /* get colors for drawing Action-Line 
75  * NOTE: color returned includes fine-tuned alpha!
76  */
77 void nla_action_get_color(AnimData *adt, bAction *act, float color[4])
78 {
79         if (adt && (adt->flag & ADT_NLA_EDIT_ON)) {
80                 /* greenish color (same as tweaking strip) */
81                 UI_GetThemeColor4fv(TH_NLA_TWEAK, color);
82         }
83         else {
84                 if (act) {
85                         /* reddish color - same as dopesheet summary */
86                         UI_GetThemeColor4fv(TH_ANIM_ACTIVE, color);
87                 }
88                 else {
89                         /* grayish-red color */
90                         UI_GetThemeColor4fv(TH_ANIM_INACTIVE, color);
91                 }
92         }
93         
94         /* when an NLA track is tagged "solo", action doesn't contribute, so shouldn't be as prominent */
95         if (adt && (adt->flag & ADT_NLA_SOLO_TRACK))
96                 color[3] *= 0.15f;
97 }
98
99 /* draw the keyframes in the specified Action */
100 static void nla_action_draw_keyframes(AnimData *adt, bAction *act, View2D *v2d, float y, float ymin, float ymax)
101 {
102         DLRBT_Tree keys;
103         ActKeyColumn *ak;
104         float xscale, f1, f2;
105         float color[4];
106         
107         /* get a list of the keyframes with NLA-scaling applied */
108         BLI_dlrbTree_init(&keys);
109         action_to_keylist(adt, act, &keys, NULL);
110         BLI_dlrbTree_linkedlist_sync(&keys);
111         
112         if (ELEM(NULL, act, keys.first))
113                 return;
114         
115         /* draw a darkened region behind the strips 
116          *      - get and reset the background color, this time without the alpha to stand out better 
117          *        (amplified alpha is used instead)
118          */
119         nla_action_get_color(adt, act, color);
120         color[3] *= 2.5f;
121         
122         glColor4fv(color);
123         /*  - draw a rect from the first to the last frame (no extra overlaps for now)
124          *        that is slightly stumpier than the track background (hardcoded 2-units here)
125          */
126         f1 = ((ActKeyColumn *)keys.first)->cfra;
127         f2 = ((ActKeyColumn *)keys.last)->cfra;
128         
129         glRectf(f1, ymin + 2, f2, ymax - 2);
130         
131         
132         /* get View2D scaling factor */
133         UI_view2d_scale_get(v2d, &xscale, NULL);
134         
135         /* for now, color is hardcoded to be black */
136         glColor3f(0.0f, 0.0f, 0.0f);
137         
138         /* just draw each keyframe as a simple dot (regardless of the selection status) 
139          *      - size is 3.0f which is smaller than the editable keyframes, so that there is a distinction
140          */
141         for (ak = keys.first; ak; ak = ak->next)
142                 draw_keyframe_shape(ak->cfra, y, xscale, 3.0f, 0, ak->key_type, KEYFRAME_SHAPE_FRAME, 1.0f);
143         
144         /* free icons */
145         BLI_dlrbTree_free(&keys);
146 }
147
148 /* Strips (Proper) ---------------------- */
149
150 /* get colors for drawing NLA-Strips */
151 static void nla_strip_get_color_inside(AnimData *adt, NlaStrip *strip, float color[3])
152 {
153         if (strip->type == NLASTRIP_TYPE_TRANSITION) {
154                 /* Transition Clip */
155                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
156                         /* selected - use a bright blue color */
157                         UI_GetThemeColor3fv(TH_NLA_TRANSITION_SEL, color);
158                 }
159                 else {
160                         /* normal, unselected strip - use (hardly noticeable) blue tinge */
161                         UI_GetThemeColor3fv(TH_NLA_TRANSITION, color);
162                 }
163         }
164         else if (strip->type == NLASTRIP_TYPE_META) {
165                 /* Meta Clip */
166                 // TODO: should temporary metas get different colors too?
167                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
168                         /* selected - use a bold purple color */
169                         UI_GetThemeColor3fv(TH_NLA_META_SEL, color);
170                 }
171                 else {
172                         /* normal, unselected strip - use (hardly noticeable) dark purple tinge */
173                         UI_GetThemeColor3fv(TH_NLA_META, color);
174                 }
175         }
176         else if (strip->type == NLASTRIP_TYPE_SOUND) {
177                 /* Sound Clip */
178                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
179                         /* selected - use a bright teal color */
180                         UI_GetThemeColor3fv(TH_NLA_SOUND_SEL, color);
181                 }
182                 else {
183                         /* normal, unselected strip - use (hardly noticeable) teal tinge */
184                         UI_GetThemeColor3fv(TH_NLA_SOUND, color);
185                 }
186         }
187         else {
188                 /* Action Clip (default/normal type of strip) */
189                 if (adt && (adt->flag & ADT_NLA_EDIT_ON) && (adt->actstrip == strip)) {
190                         /* active strip should be drawn green when it is acting as the tweaking strip.
191                          * however, this case should be skipped for when not in EditMode...
192                          */
193                         UI_GetThemeColor3fv(TH_NLA_TWEAK, color);
194                 }
195                 else if (strip->flag & NLASTRIP_FLAG_TWEAKUSER) {
196                         /* alert user that this strip is also used by the tweaking track (this is set when going into
197                          * 'editmode' for that strip), since the edits made here may not be what the user anticipated
198                          */
199                         UI_GetThemeColor3fv(TH_NLA_TWEAK_DUPLI, color);
200                 }
201                 else if (strip->flag & NLASTRIP_FLAG_SELECT) {
202                         /* selected strip - use theme color for selected */
203                         UI_GetThemeColor3fv(TH_STRIP_SELECT, color);
204                 }
205                 else {
206                         /* normal, unselected strip - use standard strip theme color */
207                         UI_GetThemeColor3fv(TH_STRIP, color);
208                 }
209         }
210 }
211
212 /* helper call for drawing influence/time control curves for a given NLA-strip */
213 static void nla_draw_strip_curves(NlaStrip *strip, float yminc, float ymaxc)
214 {
215         const float yheight = ymaxc - yminc;
216         
217         /* drawing color is simply a light-gray */
218         // TODO: is this color suitable?
219         // XXX nasty hacked color for now... which looks quite bad too...
220         glColor3f(0.7f, 0.7f, 0.7f);
221         
222         /* draw with AA'd line */
223         glEnable(GL_LINE_SMOOTH);
224         glEnable(GL_BLEND);
225         
226         /* influence -------------------------- */
227         if (strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) {
228                 FCurve *fcu = list_find_fcurve(&strip->fcurves, "influence", 0);
229                 float cfra;
230                 
231                 /* plot the curve (over the strip's main region) */
232                 glBegin(GL_LINE_STRIP);
233                 /* sample at 1 frame intervals, and draw
234                  *      - min y-val is yminc, max is y-maxc, so clamp in those regions
235                  */
236                 for (cfra = strip->start; cfra <= strip->end; cfra += 1.0f) {
237                         float y = evaluate_fcurve(fcu, cfra);    // assume this to be in 0-1 range
238                         glVertex2f(cfra, ((y * yheight) + yminc));
239                 }
240                 glEnd(); // GL_LINE_STRIP
241         }
242         else {
243                 /* use blend in/out values only if both aren't zero */
244                 if ((IS_EQF(strip->blendin, 0.0f) && IS_EQF(strip->blendout, 0.0f)) == 0) {
245                         glBegin(GL_LINE_STRIP);
246                         /* start of strip - if no blendin, start straight at 1, otherwise from 0 to 1 over blendin frames */
247                         if (IS_EQF(strip->blendin, 0.0f) == 0) {
248                                 glVertex2f(strip->start,                    yminc);
249                                 glVertex2f(strip->start + strip->blendin,   ymaxc);
250                         }
251                         else
252                                 glVertex2f(strip->start, ymaxc);
253                                         
254                         /* end of strip */
255                         if (IS_EQF(strip->blendout, 0.0f) == 0) {
256                                 glVertex2f(strip->end - strip->blendout,    ymaxc);
257                                 glVertex2f(strip->end,                      yminc);
258                         }
259                         else
260                                 glVertex2f(strip->end, ymaxc);
261                         glEnd(); // GL_LINE_STRIP
262                 }
263         }
264         
265         /* time -------------------------- */
266         // XXX do we want to draw this curve? in a different color too?
267         
268         /* turn off AA'd lines */
269         glDisable(GL_LINE_SMOOTH);
270         glDisable(GL_BLEND);
271 }
272
273 /* main call for drawing a single NLA-strip */
274 static void nla_draw_strip(SpaceNla *snla, AnimData *adt, NlaTrack *nlt, NlaStrip *strip, View2D *v2d, float yminc, float ymaxc)
275 {
276         short nonSolo = ((adt && (adt->flag & ADT_NLA_SOLO_TRACK)) && (nlt->flag & NLATRACK_SOLO) == 0);
277         float color[3];
278         
279         /* get color of strip */
280         nla_strip_get_color_inside(adt, strip, color);
281         
282         /* draw extrapolation info first (as backdrop)
283          *      - but this should only be drawn if track has some contribution
284          */
285         if ((strip->extendmode != NLASTRIP_EXTEND_NOTHING) && (nonSolo == 0)) {
286                 /* enable transparency... */
287                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
288                 glEnable(GL_BLEND);
289                 
290                 switch (strip->extendmode) {
291                         /* since this does both sides, only do the 'before' side, and leave the rest to the next case */
292                         case NLASTRIP_EXTEND_HOLD: 
293                                 /* only need to draw here if there's no strip before since 
294                                  * it only applies in such a situation 
295                                  */
296                                 if (strip->prev == NULL) {
297                                         /* set the drawing color to the color of the strip, but with very faint alpha */
298                                         glColor4f(color[0], color[1], color[2], 0.15f);
299                                         
300                                         /* draw the rect to the edge of the screen */
301                                         glBegin(GL_QUADS);
302                                         glVertex2f(v2d->cur.xmin, yminc);
303                                         glVertex2f(v2d->cur.xmin, ymaxc);
304                                         glVertex2f(strip->start, ymaxc);
305                                         glVertex2f(strip->start, yminc);
306                                         glEnd();
307                                 }
308                                 /* fall-through */
309
310                         /* this only draws after the strip */
311                         case NLASTRIP_EXTEND_HOLD_FORWARD: 
312                                 /* only need to try and draw if the next strip doesn't occur immediately after */
313                                 if ((strip->next == NULL) || (IS_EQF(strip->next->start, strip->end) == 0)) {
314                                         /* set the drawing color to the color of the strip, but this time less faint */
315                                         glColor4f(color[0], color[1], color[2], 0.3f);
316                                         
317                                         /* draw the rect to the next strip or the edge of the screen */
318                                         glBegin(GL_QUADS);
319                                         glVertex2f(strip->end, yminc);
320                                         glVertex2f(strip->end, ymaxc);
321                                                 
322                                         if (strip->next) {
323                                                 glVertex2f(strip->next->start, ymaxc);
324                                                 glVertex2f(strip->next->start, yminc);
325                                         }
326                                         else {
327                                                 glVertex2f(v2d->cur.xmax, ymaxc);
328                                                 glVertex2f(v2d->cur.xmax, yminc);
329                                         }
330                                         glEnd();
331                                 }
332                                 break;
333                 }
334                 
335                 glDisable(GL_BLEND);
336         }
337         
338         
339         /* draw 'inside' of strip itself */
340         if (nonSolo == 0) {
341                 /* strip is in normal track */
342                 glColor3fv(color);
343                 UI_draw_roundbox_corner_set(UI_CNR_ALL); /* all corners rounded */
344                 
345                 UI_draw_roundbox_shade_x(GL_POLYGON, strip->start, yminc, strip->end, ymaxc, 0.0, 0.5, 0.1);
346         }
347         else {
348                 /* strip is in disabled track - make less visible */
349                 glColor4f(color[0], color[1], color[2], 0.1f);
350                 
351                 glEnable(GL_BLEND);
352                 glRectf(strip->start, yminc, strip->end, ymaxc);
353                 glDisable(GL_BLEND);
354         }
355         
356         
357         /* draw strip's control 'curves'
358          *      - only if user hasn't hidden them...
359          */
360         if ((snla->flag & SNLA_NOSTRIPCURVES) == 0)
361                 nla_draw_strip_curves(strip, yminc, ymaxc);
362         
363         
364         /* draw strip outline 
365          *      - color used here is to indicate active vs non-active
366          */
367         if (strip->flag & NLASTRIP_FLAG_ACTIVE) {
368                 /* strip should appear 'sunken', so draw a light border around it */
369                 glColor3f(0.9f, 1.0f, 0.9f); // FIXME: hardcoded temp-hack colors
370         }
371         else {
372                 /* strip should appear to stand out, so draw a dark border around it */
373                 glColor3f(0.0f, 0.0f, 0.0f);
374         }
375         
376         /* - line style: dotted for muted */
377         if ((nlt->flag & NLATRACK_MUTED) || (strip->flag & NLASTRIP_FLAG_MUTED))
378                 setlinestyle(4);
379                 
380         /* draw outline */
381         UI_draw_roundbox_shade_x(GL_LINE_LOOP, strip->start, yminc, strip->end, ymaxc, 0.0, 0.0, 0.1);
382         
383         /* if action-clip strip, draw lines delimiting repeats too (in the same color as outline) */
384         if ((strip->type == NLASTRIP_TYPE_CLIP) && IS_EQF(strip->repeat, 1.0f) == 0) {
385                 float repeatLen = (strip->actend - strip->actstart) * strip->scale;
386                 int i;
387                 
388                 /* only draw lines for whole-numbered repeats, starting from the first full-repeat
389                  * up to the last full repeat (but not if it lies on the end of the strip)
390                  */
391                 for (i = 1; i < strip->repeat; i++) {
392                         float repeatPos = strip->start + (repeatLen * i);
393                         
394                         /* don't draw if line would end up on or after the end of the strip */
395                         if (repeatPos < strip->end)
396                                 fdrawline(repeatPos, yminc + 4, repeatPos, ymaxc - 4);
397                 }
398         }
399         /* or if meta-strip, draw lines delimiting extents of sub-strips (in same color as outline, if more than 1 exists) */
400         else if ((strip->type == NLASTRIP_TYPE_META) && (strip->strips.first != strip->strips.last)) {
401                 NlaStrip *cs;
402                 float y = (ymaxc - yminc) / 2.0f + yminc;
403                 
404                 /* only draw first-level of child-strips, but don't draw any lines on the endpoints */
405                 for (cs = strip->strips.first; cs; cs = cs->next) {
406                         /* draw start-line if not same as end of previous (and only if not the first strip) 
407                          *      - on upper half of strip
408                          */
409                         if ((cs->prev) && IS_EQF(cs->prev->end, cs->start) == 0)
410                                 fdrawline(cs->start, y, cs->start, ymaxc);
411                                 
412                         /* draw end-line if not the last strip
413                          *      - on lower half of strip
414                          */
415                         if (cs->next) 
416                                 fdrawline(cs->end, yminc, cs->end, y);
417                 }
418         }
419         
420         /* reset linestyle */
421         setlinestyle(0);
422
423
424 /* add the relevant text to the cache of text-strings to draw in pixelspace */
425 static void nla_draw_strip_text(AnimData *adt, NlaTrack *nlt, NlaStrip *strip, int index, View2D *v2d, float yminc, float ymaxc)
426 {
427         short notSolo = ((adt && (adt->flag & ADT_NLA_SOLO_TRACK)) && (nlt->flag & NLATRACK_SOLO) == 0);
428         char str[256];
429         size_t str_len;
430         char col[4];
431         float xofs;
432         rctf rect;
433         
434         /* just print the name and the range */
435         if (strip->flag & NLASTRIP_FLAG_TEMP_META) {
436                 str_len = BLI_snprintf_rlen(str, sizeof(str), "%d) Temp-Meta", index);
437         }
438         else {
439                 str_len = BLI_strncpy_rlen(str, strip->name, sizeof(str));
440         }
441         
442         /* set text color - if colors (see above) are light, draw black text, otherwise draw white */
443         if (strip->flag & (NLASTRIP_FLAG_ACTIVE | NLASTRIP_FLAG_SELECT | NLASTRIP_FLAG_TWEAKUSER)) {
444                 col[0] = col[1] = col[2] = 0;
445         }
446         else {
447                 col[0] = col[1] = col[2] = 255;
448         }
449         
450         /* text opacity depends on whether if there's a solo'd track, this isn't it */
451         if (notSolo == 0)
452                 col[3] = 255;
453         else
454                 col[3] = 128;
455         
456         /* determine the amount of padding required - cannot be constant otherwise looks weird in some cases */
457         if ((strip->end - strip->start) <= 5.0f)
458                 xofs = 0.5f;
459         else
460                 xofs = 1.0f;
461         
462         /* set bounding-box for text 
463          *      - padding of 2 'units' on either side
464          */
465         // TODO: make this centered?
466         rect.xmin = strip->start + xofs;
467         rect.ymin = yminc;
468         rect.xmax = strip->end - xofs;
469         rect.ymax = ymaxc;
470         
471         /* add this string to the cache of texts to draw */
472         UI_view2d_text_cache_add_rectf(v2d, &rect, str, str_len, col);
473 }
474
475 /* add frame extents to cache of text-strings to draw in pixelspace
476  * for now, only used when transforming strips
477  */
478 static void nla_draw_strip_frames_text(NlaTrack *UNUSED(nlt), NlaStrip *strip, View2D *v2d, float UNUSED(yminc), float ymaxc)
479 {
480         const float ytol = 1.0f; /* small offset to vertical positioning of text, for legibility */
481         const char col[4] = {220, 220, 220, 255}; /* light gray */
482         char numstr[32];
483         size_t numstr_len;
484         
485         
486         /* Always draw times above the strip, whereas sequencer drew below + above.
487          * However, we should be fine having everything on top, since these tend to be 
488          * quite spaced out. 
489          *      - 1 dp is compromise between lack of precision (ints only, as per sequencer)
490          *        while also preserving some accuracy, since we do use floats
491          */
492         /* start frame */
493         numstr_len = BLI_snprintf_rlen(numstr, sizeof(numstr), "%.1f", strip->start);
494         UI_view2d_text_cache_add(v2d, strip->start - 1.0f, ymaxc + ytol, numstr, numstr_len, col);
495         
496         /* end frame */
497         numstr_len = BLI_snprintf_rlen(numstr, sizeof(numstr), "%.1f", strip->end);
498         UI_view2d_text_cache_add(v2d, strip->end, ymaxc + ytol, numstr, numstr_len, col);
499 }
500
501 /* ---------------------- */
502
503 void draw_nla_main_data(bAnimContext *ac, SpaceNla *snla, ARegion *ar)
504 {
505         ListBase anim_data = {NULL, NULL};
506         bAnimListElem *ale;
507         int filter;
508         
509         View2D *v2d = &ar->v2d;
510         float y = 0.0f;
511         size_t items;
512         int height;
513         
514         /* build list of channels to draw */
515         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
516         items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
517         
518         /* Update max-extent of channels here (taking into account scrollers):
519          *  - this is done to allow the channel list to be scrollable, but must be done here
520          *    to avoid regenerating the list again and/or also because channels list is drawn first
521          *      - offset of NLACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
522          *        start of list offset, and the second is as a correction for the scrollers.
523          */
524         height = ((items * NLACHANNEL_STEP(snla)) + (NLACHANNEL_HEIGHT(snla) * 2));
525         /* don't use totrect set, as the width stays the same 
526          * (NOTE: this is ok here, the configuration is pretty straightforward) 
527          */
528         v2d->tot.ymin = (float)(-height);
529         
530         /* loop through channels, and set up drawing depending on their type  */
531         y = (float)(-NLACHANNEL_HEIGHT(snla));
532         
533         for (ale = anim_data.first; ale; ale = ale->next) {
534                 const float yminc = (float)(y - NLACHANNEL_HEIGHT_HALF(snla));
535                 const float ymaxc = (float)(y + NLACHANNEL_HEIGHT_HALF(snla));
536                 
537                 /* check if visible */
538                 if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
539                     IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
540                 {
541                         /* data to draw depends on the type of channel */
542                         switch (ale->type) {
543                                 case ANIMTYPE_NLATRACK:
544                                 {
545                                         AnimData *adt = ale->adt;
546                                         NlaTrack *nlt = (NlaTrack *)ale->data;
547                                         NlaStrip *strip;
548                                         int index;
549                                         
550                                         /* draw each strip in the track (if visible) */
551                                         for (strip = nlt->strips.first, index = 1; strip; strip = strip->next, index++) {
552                                                 if (BKE_nlastrip_within_bounds(strip, v2d->cur.xmin, v2d->cur.xmax)) {
553                                                         /* draw the visualization of the strip */
554                                                         nla_draw_strip(snla, adt, nlt, strip, v2d, yminc, ymaxc);
555                                                         
556                                                         /* add the text for this strip to the cache */
557                                                         nla_draw_strip_text(adt, nlt, strip, index, v2d, yminc, ymaxc);
558                                                         
559                                                         /* if transforming strips (only real reason for temp-metas currently), 
560                                                          * add to the cache the frame numbers of the strip's extents
561                                                          */
562                                                         if (strip->flag & NLASTRIP_FLAG_TEMP_META)
563                                                                 nla_draw_strip_frames_text(nlt, strip, v2d, yminc, ymaxc);
564                                                 }
565                                         }
566                                         break;
567                                 }
568                                 case ANIMTYPE_NLAACTION:
569                                 {
570                                         AnimData *adt = ale->adt;
571                                         float color[4];
572                                         
573                                         /* just draw a semi-shaded rect spanning the width of the viewable area if there's data,
574                                          * and a second darker rect within which we draw keyframe indicator dots if there's data
575                                          */
576                                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
577                                         glEnable(GL_BLEND);
578                                                 
579                                         /* get colors for drawing */
580                                         nla_action_get_color(adt, ale->data, color);
581                                         glColor4fv(color);
582                                         
583                                         /* draw slightly shifted up for greater separation from standard channels,
584                                          * but also slightly shorter for some more contrast when viewing the strips
585                                          */
586                                         glRectf(v2d->cur.xmin, yminc + NLACHANNEL_SKIP, v2d->cur.xmax, ymaxc - NLACHANNEL_SKIP);
587                                         
588                                         /* draw keyframes in the action */
589                                         nla_action_draw_keyframes(adt, ale->data, v2d, y, yminc + NLACHANNEL_SKIP, ymaxc - NLACHANNEL_SKIP);
590                                         
591                                         /* draw 'embossed' lines above and below the strip for effect */
592                                         /* white base-lines */
593                                         glLineWidth(2.0f);
594                                         glColor4f(1.0f, 1.0f, 1.0f, 0.3);
595                                         fdrawline(v2d->cur.xmin, yminc + NLACHANNEL_SKIP, v2d->cur.xmax, yminc + NLACHANNEL_SKIP);
596                                         fdrawline(v2d->cur.xmin, ymaxc - NLACHANNEL_SKIP, v2d->cur.xmax, ymaxc - NLACHANNEL_SKIP);
597                                         
598                                         /* black top-lines */
599                                         glLineWidth(1.0f);
600                                         glColor3f(0.0f, 0.0f, 0.0f);
601                                         fdrawline(v2d->cur.xmin, yminc + NLACHANNEL_SKIP, v2d->cur.xmax, yminc + NLACHANNEL_SKIP);
602                                         fdrawline(v2d->cur.xmin, ymaxc - NLACHANNEL_SKIP, v2d->cur.xmax, ymaxc - NLACHANNEL_SKIP);
603                                         
604                                         glDisable(GL_BLEND);
605                                         break;
606                                 }
607                         }
608                 }
609                 
610                 /* adjust y-position for next one */
611                 y -= NLACHANNEL_STEP(snla);
612         }
613         
614         /* free tempolary channels */
615         ANIM_animdata_freelist(&anim_data);
616 }
617
618 /* *********************************************** */
619 /* Channel List */
620
621 void draw_nla_channel_list(const bContext *C, bAnimContext *ac, ARegion *ar)
622 {
623         ListBase anim_data = {NULL, NULL};
624         bAnimListElem *ale;
625         int filter;
626         
627         SpaceNla *snla = (SpaceNla *)ac->sl;
628         View2D *v2d = &ar->v2d;
629         float y = 0.0f;
630         size_t items;
631         int height;
632         
633         /* build list of channels to draw */
634         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
635         items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
636         
637         /* Update max-extent of channels here (taking into account scrollers):
638          *  - this is done to allow the channel list to be scrollable, but must be done here
639          *    to avoid regenerating the list again and/or also because channels list is drawn first
640          *      - offset of NLACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
641          *        start of list offset, and the second is as a correction for the scrollers.
642          */
643         height = ((items * NLACHANNEL_STEP(snla)) + (NLACHANNEL_HEIGHT(snla) * 2));
644         /* don't use totrect set, as the width stays the same 
645          * (NOTE: this is ok here, the configuration is pretty straightforward) 
646          */
647         v2d->tot.ymin = (float)(-height);
648         /* need to do a view-sync here, so that the keys area doesn't jump around (it must copy this) */
649         UI_view2d_sync(NULL, ac->sa, v2d, V2D_LOCK_COPY);
650         
651         /* draw channels */
652         {   /* first pass: just the standard GL-drawing for backdrop + text */
653                 size_t channel_index = 0;
654                 
655                 y = (float)(-NLACHANNEL_HEIGHT(snla));
656                 
657                 for (ale = anim_data.first; ale; ale = ale->next) {
658                         float yminc = (float)(y -  NLACHANNEL_HEIGHT_HALF(snla));
659                         float ymaxc = (float)(y +  NLACHANNEL_HEIGHT_HALF(snla));
660                         
661                         /* check if visible */
662                         if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
663                             IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
664                         {
665                                 /* draw all channels using standard channel-drawing API */
666                                 ANIM_channel_draw(ac, ale, yminc, ymaxc, channel_index);
667                         }
668                         
669                         /* adjust y-position for next one */
670                         y -= NLACHANNEL_STEP(snla);
671                         channel_index++;
672                 }
673         }
674         {   /* second pass: UI widgets */
675                 uiBlock *block = UI_block_begin(C, ar, __func__, UI_EMBOSS);
676                 size_t channel_index = 0;
677                 
678                 y = (float)(-NLACHANNEL_HEIGHT(snla));
679                 
680                 /* set blending again, as may not be set in previous step */
681                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
682                 glEnable(GL_BLEND);
683                 
684                 /* loop through channels, and set up drawing depending on their type  */
685                 for (ale = anim_data.first; ale; ale = ale->next) {
686                         const float yminc = (float)(y - NLACHANNEL_HEIGHT_HALF(snla));
687                         const float ymaxc = (float)(y + NLACHANNEL_HEIGHT_HALF(snla));
688                         
689                         /* check if visible */
690                         if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
691                             IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
692                         {
693                                 /* draw all channels using standard channel-drawing API */
694                                 ANIM_channel_draw_widgets(C, ac, ale, block, yminc, ymaxc, channel_index);
695                         }
696                         
697                         /* adjust y-position for next one */
698                         y -= NLACHANNEL_STEP(snla);
699                         channel_index++;
700                 }
701                 
702                 UI_block_end(C, block);
703                 UI_block_draw(C, block);
704                 
705                 glDisable(GL_BLEND);
706         }
707         
708         /* free temporary channels */
709         ANIM_animdata_freelist(&anim_data);
710 }
711
712 /* *********************************************** */