Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / space_nla / nla_buttons.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2009 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spnla
22  */
23
24 #include <string.h>
25 #include <stdio.h>
26 #include <math.h>
27 #include <float.h>
28
29 #include "DNA_anim_types.h"
30
31 #include "BLI_utildefines.h"
32
33 #include "MEM_guardedalloc.h"
34
35 #include "BLI_blenlib.h"
36
37 #include "BLT_translation.h"
38
39 #include "BKE_nla.h"
40 #include "BKE_context.h"
41 #include "BKE_screen.h"
42
43 #include "WM_api.h"
44 #include "WM_types.h"
45
46 #include "RNA_access.h"
47
48 #include "ED_anim_api.h"
49 #include "ED_screen.h"
50
51 #include "UI_interface.h"
52 #include "UI_resources.h"
53
54 #include "nla_intern.h"  // own include
55
56 /* ******************* nla editor space & buttons ************** */
57
58 /* -------------- */
59
60 static void do_nla_region_buttons(bContext *C, void *UNUSED(arg), int UNUSED(event))
61 {
62   //Scene *scene = CTX_data_scene(C);
63 #if 0
64   switch (event) {
65     /* pass */
66   }
67 #endif
68   /* default for now */
69   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
70   WM_event_add_notifier(C, NC_SCENE | ND_TRANSFORM, NULL);
71 }
72
73 bool nla_panel_context(const bContext *C,
74                        PointerRNA *adt_ptr,
75                        PointerRNA *nlt_ptr,
76                        PointerRNA *strip_ptr)
77 {
78   bAnimContext ac;
79   bAnimListElem *ale = NULL;
80   ListBase anim_data = {NULL, NULL};
81   short found = 0; /* not bool, since we need to indicate "found but not ideal" status */
82   int filter;
83
84   /* For now, only draw if we could init the anim-context info
85    * (necessary for all animation-related tools)
86    * to work correctly is able to be correctly retrieved. There's no point showing empty panels? */
87   if (ANIM_animdata_get_context(C, &ac) == 0) {
88     return false;
89   }
90
91   /* extract list of active channel(s), of which we should only take the first one
92    * - we need the channels flag to get the active AnimData block when there are no NLA Tracks
93    */
94   // XXX: double-check active!
95   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_ACTIVE |
96             ANIMFILTER_LIST_CHANNELS);
97   ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
98
99   for (ale = anim_data.first; ale; ale = ale->next) {
100     switch (ale->type) {
101       case ANIMTYPE_NLATRACK: /* NLA Track - The primary data type which should get caught */
102       {
103         NlaTrack *nlt = (NlaTrack *)ale->data;
104         AnimData *adt = ale->adt;
105
106         /* found it, now set the pointers */
107         if (adt_ptr) {
108           /* AnimData pointer */
109           RNA_pointer_create(ale->id, &RNA_AnimData, adt, adt_ptr);
110         }
111         if (nlt_ptr) {
112           /* NLA-Track pointer */
113           RNA_pointer_create(ale->id, &RNA_NlaTrack, nlt, nlt_ptr);
114         }
115         if (strip_ptr) {
116           /* NLA-Strip pointer */
117           NlaStrip *strip = BKE_nlastrip_find_active(nlt);
118           RNA_pointer_create(ale->id, &RNA_NlaStrip, strip, strip_ptr);
119         }
120
121         found = 1;
122         break;
123       }
124       case ANIMTYPE_SCENE: /* Top-Level Widgets doubling up as datablocks */
125       case ANIMTYPE_OBJECT:
126       case ANIMTYPE_DSMAT: /* Datablock AnimData Expanders */
127       case ANIMTYPE_DSLAM:
128       case ANIMTYPE_DSCAM:
129       case ANIMTYPE_DSCACHEFILE:
130       case ANIMTYPE_DSCUR:
131       case ANIMTYPE_DSSKEY:
132       case ANIMTYPE_DSWOR:
133       case ANIMTYPE_DSNTREE:
134       case ANIMTYPE_DSPART:
135       case ANIMTYPE_DSMBALL:
136       case ANIMTYPE_DSARM:
137       case ANIMTYPE_DSMESH:
138       case ANIMTYPE_DSTEX:
139       case ANIMTYPE_DSLAT:
140       case ANIMTYPE_DSLINESTYLE:
141       case ANIMTYPE_DSSPK:
142       case ANIMTYPE_DSGPENCIL:
143       case ANIMTYPE_PALETTE: {
144         /* for these channels, we only do AnimData */
145         if (ale->adt && adt_ptr) {
146           ID *id;
147
148           if ((ale->data == NULL) || (ale->type == ANIMTYPE_OBJECT)) {
149             /* ale->data is not an ID block! */
150             id = ale->id;
151           }
152           else {
153             /* ale->data is always the proper ID block we need,
154              * but ale->id may not be (i.e. for textures) */
155             id = (ID *)ale->data;
156           }
157
158           /* AnimData pointer */
159           if (adt_ptr) {
160             RNA_pointer_create(id, &RNA_AnimData, ale->adt, adt_ptr);
161           }
162
163           /* set found status to -1, since setting to 1 would break the loop
164            * and potentially skip an active NLA-Track in some cases...
165            */
166           found = -1;
167         }
168         break;
169       }
170     }
171
172     if (found > 0) {
173       break;
174     }
175   }
176
177   /* free temp data */
178   ANIM_animdata_freelist(&anim_data);
179
180   return (found != 0);
181 }
182
183 #if 0
184 static bool nla_panel_poll(const bContext *C, PanelType *pt)
185 {
186   return nla_panel_context(C, NULL, NULL);
187 }
188 #endif
189
190 static bool nla_animdata_panel_poll(const bContext *C, PanelType *UNUSED(pt))
191 {
192   PointerRNA ptr;
193   return (nla_panel_context(C, &ptr, NULL, NULL) && (ptr.data != NULL));
194 }
195
196 static bool nla_track_panel_poll(const bContext *C, PanelType *UNUSED(pt))
197 {
198   PointerRNA ptr;
199   return (nla_panel_context(C, NULL, &ptr, NULL) && (ptr.data != NULL));
200 }
201
202 static bool nla_strip_panel_poll(const bContext *C, PanelType *UNUSED(pt))
203 {
204   PointerRNA ptr;
205   return (nla_panel_context(C, NULL, NULL, &ptr) && (ptr.data != NULL));
206 }
207
208 static bool nla_strip_actclip_panel_poll(const bContext *C, PanelType *UNUSED(pt))
209 {
210   PointerRNA ptr;
211   NlaStrip *strip;
212
213   if (!nla_panel_context(C, NULL, NULL, &ptr)) {
214     return 0;
215   }
216   if (ptr.data == NULL) {
217     return 0;
218   }
219
220   strip = ptr.data;
221   return (strip->type == NLASTRIP_TYPE_CLIP);
222 }
223
224 static bool nla_strip_eval_panel_poll(const bContext *C, PanelType *UNUSED(pt))
225 {
226   PointerRNA ptr;
227   NlaStrip *strip;
228
229   if (!nla_panel_context(C, NULL, NULL, &ptr)) {
230     return 0;
231   }
232   if (ptr.data == NULL) {
233     return 0;
234   }
235
236   strip = ptr.data;
237
238   if (strip->type == NLASTRIP_TYPE_SOUND) {
239     return 0;
240   }
241
242   return 1;
243 }
244
245 /* -------------- */
246
247 /* active AnimData */
248 static void nla_panel_animdata(const bContext *C, Panel *pa)
249 {
250   PointerRNA adt_ptr;
251   /* AnimData *adt; */
252   uiLayout *layout = pa->layout;
253   uiLayout *row;
254   uiBlock *block;
255
256   /* check context and also validity of pointer */
257   if (!nla_panel_context(C, &adt_ptr, NULL, NULL)) {
258     return;
259   }
260
261   /* adt = adt_ptr.data; */
262
263   block = uiLayoutGetBlock(layout);
264   UI_block_func_handle_set(block, do_nla_region_buttons, NULL);
265
266   /* AnimData Source Properties ----------------------------------- */
267
268   /* icon + id-block name of block where AnimData came from to prevent
269    * accidentally changing the properties of the wrong action
270    */
271   if (adt_ptr.id.data) {
272     ID *id = adt_ptr.id.data;
273     PointerRNA id_ptr;
274
275     RNA_id_pointer_create(id, &id_ptr);
276
277     /* ID-block name > AnimData */
278     row = uiLayoutRow(layout, true);
279     uiLayoutSetAlignment(row, UI_LAYOUT_ALIGN_LEFT);
280
281     uiItemL(row, id->name + 2, RNA_struct_ui_icon(id_ptr.type)); /* id-block (src) */
282     uiItemL(row, "", ICON_SMALL_TRI_RIGHT_VEC);                  /* expander */
283     uiItemL(row, IFACE_("Animation Data"), ICON_ANIM_DATA);      /* animdata */
284
285     uiItemS(layout);
286   }
287
288   /* Active Action Properties ------------------------------------- */
289   /* action */
290   row = uiLayoutRow(layout, true);
291   uiTemplateID(row,
292                (bContext *)C,
293                &adt_ptr,
294                "action",
295                "ACTION_OT_new",
296                NULL,
297                "NLA_OT_action_unlink",
298                UI_TEMPLATE_ID_FILTER_ALL,
299                false);
300
301   /* extrapolation */
302   row = uiLayoutRow(layout, true);
303   uiItemR(row, &adt_ptr, "action_extrapolation", 0, NULL, ICON_NONE);
304
305   /* blending */
306   row = uiLayoutRow(layout, true);
307   uiItemR(row, &adt_ptr, "action_blend_type", 0, NULL, ICON_NONE);
308
309   /* influence */
310   row = uiLayoutRow(layout, true);
311   uiItemR(row, &adt_ptr, "action_influence", 0, NULL, ICON_NONE);
312 }
313
314 /* active NLA-Track */
315 static void nla_panel_track(const bContext *C, Panel *pa)
316 {
317   PointerRNA nlt_ptr;
318   uiLayout *layout = pa->layout;
319   uiLayout *row;
320   uiBlock *block;
321
322   /* check context and also validity of pointer */
323   if (!nla_panel_context(C, NULL, &nlt_ptr, NULL)) {
324     return;
325   }
326
327   block = uiLayoutGetBlock(layout);
328   UI_block_func_handle_set(block, do_nla_region_buttons, NULL);
329
330   /* Info - Active NLA-Context:Track ----------------------  */
331   row = uiLayoutRow(layout, true);
332   uiItemR(row, &nlt_ptr, "name", 0, NULL, ICON_NLA);
333 }
334
335 /* generic settings for active NLA-Strip */
336 static void nla_panel_properties(const bContext *C, Panel *pa)
337 {
338   PointerRNA strip_ptr;
339   uiLayout *layout = pa->layout;
340   uiLayout *column, *row, *sub;
341   uiBlock *block;
342   short showEvalProps = 1;
343
344   if (!nla_panel_context(C, NULL, NULL, &strip_ptr)) {
345     return;
346   }
347
348   block = uiLayoutGetBlock(layout);
349   UI_block_func_handle_set(block, do_nla_region_buttons, NULL);
350
351   /* Strip Properties ------------------------------------- */
352   /* strip type */
353   row = uiLayoutColumn(layout, true);
354   uiItemR(row, &strip_ptr, "name", 0, NULL, ICON_NLA);  // XXX icon?
355   uiItemR(row, &strip_ptr, "type", 0, NULL, ICON_NONE);
356
357   /* strip extents */
358   column = uiLayoutColumn(layout, true);
359   uiItemL(column, IFACE_("Strip Extents:"), ICON_NONE);
360   uiItemR(column, &strip_ptr, "frame_start", 0, NULL, ICON_NONE);
361   uiItemR(column, &strip_ptr, "frame_end", 0, NULL, ICON_NONE);
362
363   /* Evaluation-Related Strip Properties ------------------ */
364
365   /* sound properties strips don't have these settings */
366   if (RNA_enum_get(&strip_ptr, "type") == NLASTRIP_TYPE_SOUND) {
367     showEvalProps = 0;
368   }
369
370   /* only show if allowed to... */
371   if (showEvalProps) {
372     /* extrapolation */
373     row = uiLayoutRow(layout, true);
374     uiItemR(row, &strip_ptr, "extrapolation", 0, NULL, ICON_NONE);
375
376     /* blending */
377     row = uiLayoutRow(layout, true);
378     uiItemR(row, &strip_ptr, "blend_type", 0, NULL, ICON_NONE);
379
380     /* Blend in/out + auto-blending:
381      * - blend in/out can only be set when autoblending is off
382      */
383     column = uiLayoutColumn(layout, true);
384     uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "use_animated_influence") == false);
385     uiItemR(column, &strip_ptr, "use_auto_blend", 0, NULL, ICON_NONE);  // XXX as toggle?
386
387     sub = uiLayoutColumn(column, true);
388     uiLayoutSetActive(sub, RNA_boolean_get(&strip_ptr, "use_auto_blend") == false);
389     uiItemR(sub, &strip_ptr, "blend_in", 0, NULL, ICON_NONE);
390     uiItemR(sub, &strip_ptr, "blend_out", 0, NULL, ICON_NONE);
391
392     /* settings */
393     column = uiLayoutColumn(layout, true);
394     uiLayoutSetActive(column,
395                       !(RNA_boolean_get(&strip_ptr, "use_animated_influence") ||
396                         RNA_boolean_get(&strip_ptr, "use_animated_time")));
397     uiItemL(column, IFACE_("Playback Settings:"), ICON_NONE);
398     uiItemR(column, &strip_ptr, "mute", 0, NULL, ICON_NONE);
399     uiItemR(column, &strip_ptr, "use_reverse", 0, NULL, ICON_NONE);
400   }
401 }
402
403 /* action-clip only settings for active NLA-Strip */
404 static void nla_panel_actclip(const bContext *C, Panel *pa)
405 {
406   PointerRNA strip_ptr;
407   uiLayout *layout = pa->layout;
408   uiLayout *column, *row;
409   uiBlock *block;
410
411   /* check context and also validity of pointer */
412   if (!nla_panel_context(C, NULL, NULL, &strip_ptr)) {
413     return;
414   }
415
416   block = uiLayoutGetBlock(layout);
417   UI_block_func_handle_set(block, do_nla_region_buttons, NULL);
418
419   /* Strip Properties ------------------------------------- */
420   /* action pointer */
421   row = uiLayoutRow(layout, true);
422   uiItemR(row, &strip_ptr, "action", 0, NULL, ICON_ACTION);
423
424   /* action extents */
425   // XXX custom names were used here (to avoid the prefixes)... probably not necessary in future?
426   column = uiLayoutColumn(layout, true);
427   uiItemL(column, IFACE_("Action Extents:"), ICON_NONE);
428   uiItemR(column, &strip_ptr, "action_frame_start", 0, IFACE_("Start Frame"), ICON_NONE);
429   uiItemR(column, &strip_ptr, "action_frame_end", 0, IFACE_("End Frame"), ICON_NONE);
430
431   /* XXX: this layout may actually be too abstract and confusing,
432    * and may be better using standard column layout. */
433   row = uiLayoutRow(layout, false);
434   uiItemR(row, &strip_ptr, "use_sync_length", 0, IFACE_("Sync Length"), ICON_NONE);
435   uiItemO(row, IFACE_("Now"), ICON_FILE_REFRESH, "NLA_OT_action_sync_length");
436
437   /* action usage */
438   column = uiLayoutColumn(layout, true);
439   uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "use_animated_time") == false);
440   uiItemL(column, IFACE_("Playback Settings:"), ICON_NONE);
441   uiItemR(column, &strip_ptr, "scale", 0, NULL, ICON_NONE);
442   uiItemR(column, &strip_ptr, "repeat", 0, NULL, ICON_NONE);
443 }
444
445 /* evaluation settings for active NLA-Strip */
446 static void nla_panel_evaluation(const bContext *C, Panel *pa)
447 {
448   PointerRNA strip_ptr;
449   uiLayout *layout = pa->layout;
450   uiLayout *col, *sub;
451   uiBlock *block;
452
453   /* check context and also validity of pointer */
454   if (!nla_panel_context(C, NULL, NULL, &strip_ptr)) {
455     return;
456   }
457
458   block = uiLayoutGetBlock(layout);
459   UI_block_func_handle_set(block, do_nla_region_buttons, NULL);
460
461   col = uiLayoutColumn(layout, true);
462   uiItemR(col, &strip_ptr, "use_animated_influence", 0, NULL, ICON_NONE);
463
464   sub = uiLayoutColumn(col, true);
465   uiLayoutSetEnabled(sub, RNA_boolean_get(&strip_ptr, "use_animated_influence"));
466   uiItemR(sub, &strip_ptr, "influence", 0, NULL, ICON_NONE);
467
468   col = uiLayoutColumn(layout, true);
469   sub = uiLayoutRow(col, false);
470   uiItemR(sub, &strip_ptr, "use_animated_time", 0, NULL, ICON_NONE);
471   uiItemR(sub, &strip_ptr, "use_animated_time_cyclic", 0, NULL, ICON_NONE);
472
473   sub = uiLayoutRow(col, false);
474   uiLayoutSetEnabled(sub, RNA_boolean_get(&strip_ptr, "use_animated_time"));
475   uiItemR(sub, &strip_ptr, "strip_time", 0, NULL, ICON_NONE);
476 }
477
478 /* F-Modifiers for active NLA-Strip */
479 static void nla_panel_modifiers(const bContext *C, Panel *pa)
480 {
481   PointerRNA strip_ptr;
482   NlaStrip *strip;
483   FModifier *fcm;
484   uiLayout *col, *row;
485   uiBlock *block;
486
487   /* check context and also validity of pointer */
488   if (!nla_panel_context(C, NULL, NULL, &strip_ptr)) {
489     return;
490   }
491   strip = strip_ptr.data;
492
493   block = uiLayoutGetBlock(pa->layout);
494   UI_block_func_handle_set(block, do_nla_region_buttons, NULL);
495
496   /* 'add modifier' button at top of panel */
497   {
498     row = uiLayoutRow(pa->layout, false);
499     block = uiLayoutGetBlock(row);
500
501     // FIXME: we need to set the only-active property so that this
502     // will only add modifiers for the active strip (not all selected).
503     uiItemMenuEnumO(
504         row, (bContext *)C, "NLA_OT_fmodifier_add", "type", IFACE_("Add Modifier"), ICON_NONE);
505
506     /* copy/paste (as sub-row) */
507     row = uiLayoutRow(row, true);
508     uiItemO(row, "", ICON_COPYDOWN, "NLA_OT_fmodifier_copy");
509     uiItemO(row, "", ICON_PASTEDOWN, "NLA_OT_fmodifier_paste");
510   }
511
512   /* draw each modifier */
513   for (fcm = strip->modifiers.first; fcm; fcm = fcm->next) {
514     col = uiLayoutColumn(pa->layout, true);
515
516     ANIM_uiTemplate_fmodifier_draw(col, strip_ptr.id.data, &strip->modifiers, fcm);
517   }
518 }
519
520 /* ******************* general ******************************** */
521
522 void nla_buttons_register(ARegionType *art)
523 {
524   PanelType *pt;
525
526   pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel animdata");
527   strcpy(pt->idname, "NLA_PT_animdata");
528   strcpy(pt->label, N_("Animation Data"));
529   strcpy(pt->category, "Animations");
530   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
531   pt->draw = nla_panel_animdata;
532   pt->poll = nla_animdata_panel_poll;
533   pt->flag = PNL_DEFAULT_CLOSED;
534   BLI_addtail(&art->paneltypes, pt);
535
536   pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel track");
537   strcpy(pt->idname, "NLA_PT_track");
538   strcpy(pt->label, N_("Active Track"));
539   strcpy(pt->category, "Animations");
540   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
541   pt->draw = nla_panel_track;
542   pt->poll = nla_track_panel_poll;
543   BLI_addtail(&art->paneltypes, pt);
544
545   pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel properties");
546   strcpy(pt->idname, "NLA_PT_properties");
547   strcpy(pt->label, N_("Active Strip"));
548   strcpy(pt->category, "Animations");
549   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
550   pt->draw = nla_panel_properties;
551   pt->poll = nla_strip_panel_poll;
552   BLI_addtail(&art->paneltypes, pt);
553
554   pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel properties");
555   strcpy(pt->idname, "NLA_PT_actionclip");
556   strcpy(pt->label, N_("Action Clip"));
557   strcpy(pt->category, "Animations");
558   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
559   pt->draw = nla_panel_actclip;
560   pt->poll = nla_strip_actclip_panel_poll;
561   BLI_addtail(&art->paneltypes, pt);
562
563   pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel evaluation");
564   strcpy(pt->idname, "NLA_PT_evaluation");
565   strcpy(pt->label, N_("Evaluation"));
566   strcpy(pt->category, "Animations");
567   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
568   pt->draw = nla_panel_evaluation;
569   pt->poll = nla_strip_eval_panel_poll;
570   BLI_addtail(&art->paneltypes, pt);
571
572   pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel modifiers");
573   strcpy(pt->idname, "NLA_PT_modifiers");
574   strcpy(pt->label, N_("Modifiers"));
575   strcpy(pt->category, "Modifiers");
576   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
577   pt->draw = nla_panel_modifiers;
578   pt->poll = nla_strip_eval_panel_poll;
579   BLI_addtail(&art->paneltypes, pt);
580 }