Text Editor: remove text marker functionality. Patch [#33251]
[blender.git] / source / blender / editors / space_nla / nla_buttons.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.
19  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Blender Foundation, Joshua Leung
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/space_nla/nla_buttons.c
28  *  \ingroup spnla
29  */
30
31
32 #include <string.h>
33 #include <stdio.h>
34 #include <math.h>
35 #include <float.h>
36
37 #include "DNA_anim_types.h"
38
39 #include "BLI_utildefines.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "BLI_math.h"
44 #include "BLI_blenlib.h"
45 #include "BLI_rand.h"
46
47 #include "BLF_translation.h"
48
49 #include "BKE_nla.h"
50 #include "BKE_context.h"
51 #include "BKE_screen.h"
52
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "RNA_access.h"
58
59 #include "ED_anim_api.h"
60 #include "ED_screen.h"
61
62 #include "UI_interface.h"
63 #include "UI_resources.h"
64
65 #include "nla_intern.h" // own include
66
67
68 /* ******************* nla editor space & buttons ************** */
69
70 /* -------------- */
71
72 static void do_nla_region_buttons(bContext *C, void *UNUSED(arg), int event)
73 {
74         //Scene *scene = CTX_data_scene(C);
75         
76         switch (event) {
77
78         }
79         
80         /* default for now */
81         WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
82         WM_event_add_notifier(C, NC_SCENE | ND_TRANSFORM, NULL);
83 }
84
85 static int nla_panel_context(const bContext *C, PointerRNA *adt_ptr, PointerRNA *nlt_ptr, PointerRNA *strip_ptr)
86 {
87         bAnimContext ac;
88         bAnimListElem *ale = NULL;
89         ListBase anim_data = {NULL, NULL};
90         short found = 0;
91         int filter;
92         
93         /* for now, only draw if we could init the anim-context info (necessary for all animation-related tools) 
94          * to work correctly is able to be correctly retrieved. There's no point showing empty panels?
95          */
96         if (ANIM_animdata_get_context(C, &ac) == 0) 
97                 return 0;
98         
99         /* extract list of active channel(s), of which we should only take the first one 
100          *      - we need the channels flag to get the active AnimData block when there are no NLA Tracks
101          */
102         // XXX: double-check active!
103         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_ACTIVE | ANIMFILTER_LIST_CHANNELS);
104         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
105         
106         for (ale = anim_data.first; ale; ale = ale->next) {
107                 switch (ale->type) {
108                         case ANIMTYPE_NLATRACK: /* NLA Track - The primary data type which should get caught */
109                         {
110                                 NlaTrack *nlt = (NlaTrack *)ale->data;
111                                 AnimData *adt = ale->adt;
112                                 
113                                 /* found it, now set the pointers */
114                                 if (adt_ptr) {
115                                         /* AnimData pointer */
116                                         RNA_pointer_create(ale->id, &RNA_AnimData, adt, adt_ptr);
117                                 }
118                                 if (nlt_ptr) {
119                                         /* NLA-Track pointer */
120                                         RNA_pointer_create(ale->id, &RNA_NlaTrack, nlt, nlt_ptr);
121                                 }
122                                 if (strip_ptr) {
123                                         /* NLA-Strip pointer */
124                                         NlaStrip *strip = BKE_nlastrip_find_active(nlt);
125                                         RNA_pointer_create(ale->id, &RNA_NlaStrip, strip, strip_ptr);
126                                 }
127                                 
128                                 found = 1;
129                         }
130                         break;
131                                 
132                         case ANIMTYPE_SCENE:    /* Top-Level Widgets doubling up as datablocks */
133                         case ANIMTYPE_OBJECT:
134                         case ANIMTYPE_FILLACTD: /* Action Expander */
135                         case ANIMTYPE_DSMAT:    /* Datablock AnimData Expanders */
136                         case ANIMTYPE_DSLAM:
137                         case ANIMTYPE_DSCAM:
138                         case ANIMTYPE_DSCUR:
139                         case ANIMTYPE_DSSKEY:
140                         case ANIMTYPE_DSWOR:
141                         case ANIMTYPE_DSNTREE:
142                         case ANIMTYPE_DSPART:
143                         case ANIMTYPE_DSMBALL:
144                         case ANIMTYPE_DSARM:
145                         case ANIMTYPE_DSSPK:
146                         {
147                                 /* for these channels, we only do AnimData */
148                                 if (ale->id && ale->adt) {
149                                         if (adt_ptr) {
150                                                 /* AnimData pointer */
151                                                 RNA_pointer_create(ale->id, &RNA_AnimData, ale->adt, adt_ptr);
152                                                 
153                                                 /* set found status to -1, since setting to 1 would break the loop 
154                                                  * and potentially skip an active NLA-Track in some cases...
155                                                  */
156                                                 found = -1;
157                                         }
158                                 }
159                         }
160                         break;
161                 }
162                 
163                 if (found > 0)
164                         break;
165         }
166         
167         /* free temp data */
168         BLI_freelistN(&anim_data);
169         
170         return found;
171 }
172
173 #if 0
174 static int nla_panel_poll(const bContext *C, PanelType *pt)
175 {
176         return nla_panel_context(C, NULL, NULL);
177 }
178 #endif
179
180 static int nla_animdata_panel_poll(const bContext *C, PanelType *UNUSED(pt))
181 {
182         PointerRNA ptr;
183         return (nla_panel_context(C, &ptr, NULL, NULL) && (ptr.data != NULL));
184 }
185
186 static int nla_track_panel_poll(const bContext *C, PanelType *UNUSED(pt))
187 {
188         PointerRNA ptr;
189         return (nla_panel_context(C, NULL, &ptr, NULL) && (ptr.data != NULL));
190 }
191
192 static int nla_strip_panel_poll(const bContext *C, PanelType *UNUSED(pt))
193 {
194         PointerRNA ptr;
195         return (nla_panel_context(C, NULL, NULL, &ptr) && (ptr.data != NULL));
196 }
197
198 static int nla_strip_actclip_panel_poll(const bContext *C, PanelType *UNUSED(pt))
199 {
200         PointerRNA ptr;
201         NlaStrip *strip;
202         
203         if (!nla_panel_context(C, NULL, NULL, &ptr))
204                 return 0;
205         if (ptr.data == NULL)
206                 return 0;
207         
208         strip = ptr.data;
209         return (strip->type == NLASTRIP_TYPE_CLIP);
210 }
211
212 static int nla_strip_eval_panel_poll(const bContext *C, PanelType *UNUSED(pt))
213 {
214         PointerRNA ptr;
215         NlaStrip *strip;
216         
217         if (!nla_panel_context(C, NULL, NULL, &ptr))
218                 return 0;
219         if (ptr.data == NULL)
220                 return 0;
221         
222         strip = ptr.data;
223         
224         if (strip->type == NLASTRIP_TYPE_SOUND)
225                 return 0;
226                 
227         return 1;
228 }
229
230 /* -------------- */
231
232 /* active AnimData */
233 static void nla_panel_animdata(const bContext *C, Panel *pa)
234 {
235         PointerRNA adt_ptr;
236         /* AnimData *adt; */
237         uiLayout *layout = pa->layout;
238         uiLayout *row;
239         uiBlock *block;
240         
241         /* check context and also validity of pointer */
242         if (!nla_panel_context(C, &adt_ptr, NULL, NULL))
243                 return;
244
245         /* adt = adt_ptr.data; */
246         
247         block = uiLayoutGetBlock(layout);
248         uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
249         
250         /* Active Action Properties ------------------------------------- */
251         /* action */
252         row = uiLayoutRow(layout, TRUE);
253         uiTemplateID(row, (bContext *)C, &adt_ptr, "action", "ACTION_OT_new", NULL, NULL /*"ACTION_OT_unlink"*/);     // XXX: need to make these operators
254         
255         /* extrapolation */
256         row = uiLayoutRow(layout, TRUE);
257         uiItemR(row, &adt_ptr, "action_extrapolation", 0, NULL, ICON_NONE);
258         
259         /* blending */
260         row = uiLayoutRow(layout, TRUE);
261         uiItemR(row, &adt_ptr, "action_blend_type", 0, NULL, ICON_NONE);
262                 
263         /* influence */
264         row = uiLayoutRow(layout, TRUE);
265         uiItemR(row, &adt_ptr, "action_influence", 0, NULL, ICON_NONE);
266 }
267
268 /* active NLA-Track */
269 static void nla_panel_track(const bContext *C, Panel *pa)
270 {
271         PointerRNA nlt_ptr;
272         uiLayout *layout = pa->layout;
273         uiLayout *row;
274         uiBlock *block;
275         
276         /* check context and also validity of pointer */
277         if (!nla_panel_context(C, NULL, &nlt_ptr, NULL))
278                 return;
279         
280         block = uiLayoutGetBlock(layout);
281         uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
282         
283         /* Info - Active NLA-Context:Track ----------------------  */
284         row = uiLayoutRow(layout, TRUE);
285         uiItemR(row, &nlt_ptr, "name", 0, NULL, ICON_NLA);
286 }
287
288 /* generic settings for active NLA-Strip */
289 static void nla_panel_properties(const bContext *C, Panel *pa)
290 {
291         PointerRNA strip_ptr;
292         uiLayout *layout = pa->layout;
293         uiLayout *column, *row, *sub;
294         uiBlock *block;
295         short showEvalProps = 1;
296         
297         if (!nla_panel_context(C, NULL, NULL, &strip_ptr))
298                 return;
299         
300         block = uiLayoutGetBlock(layout);
301         uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
302         
303         /* Strip Properties ------------------------------------- */
304         /* strip type */
305         row = uiLayoutColumn(layout, TRUE);
306         uiItemR(row, &strip_ptr, "name", 0, NULL, ICON_NLA);     // XXX icon?
307         uiItemR(row, &strip_ptr, "type", 0, NULL, ICON_NONE);
308         
309         /* strip extents */
310         column = uiLayoutColumn(layout, TRUE);
311         uiItemL(column, "Strip Extents:", ICON_NONE);
312         uiItemR(column, &strip_ptr, "frame_start", 0, NULL, ICON_NONE);
313         uiItemR(column, &strip_ptr, "frame_end", 0, NULL, ICON_NONE);
314         
315         /* Evaluation-Related Strip Properties ------------------ */
316         
317         /* sound properties strips don't have these settings */
318         if (RNA_enum_get(&strip_ptr, "type") == NLASTRIP_TYPE_SOUND)
319                 showEvalProps = 0;
320         
321         /* only show if allowed to... */
322         if (showEvalProps) {
323                 /* extrapolation */
324                 row = uiLayoutRow(layout, TRUE);
325                 uiItemR(row, &strip_ptr, "extrapolation", 0, NULL, ICON_NONE);
326                 
327                 /* blending */
328                 row = uiLayoutRow(layout, TRUE);
329                 uiItemR(row, &strip_ptr, "blend_type", 0, NULL, ICON_NONE);
330                         
331                 /* blend in/out + autoblending
332                  *      - blend in/out can only be set when autoblending is off
333                  */
334                 column = uiLayoutColumn(layout, TRUE);
335                 uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "use_animated_influence") == FALSE);
336                 uiItemR(column, &strip_ptr, "use_auto_blend", 0, NULL, ICON_NONE);     // XXX as toggle?
337
338                 sub = uiLayoutColumn(column, TRUE);
339                 uiLayoutSetActive(sub, RNA_boolean_get(&strip_ptr, "use_auto_blend") == FALSE);
340                 uiItemR(sub, &strip_ptr, "blend_in", 0, NULL, ICON_NONE);
341                 uiItemR(sub, &strip_ptr, "blend_out", 0, NULL, ICON_NONE);
342                         
343                 /* settings */
344                 column = uiLayoutColumn(layout, TRUE);
345                 uiLayoutSetActive(column, !(RNA_boolean_get(&strip_ptr, "use_animated_influence") || RNA_boolean_get(&strip_ptr, "use_animated_time")));
346                 uiItemL(column, "Playback Settings:", ICON_NONE);
347                 uiItemR(column, &strip_ptr, "mute", 0, NULL, ICON_NONE);
348                 uiItemR(column, &strip_ptr, "use_reverse", 0, NULL, ICON_NONE);
349         }
350 }
351
352
353 /* action-clip only settings for active NLA-Strip */
354 static void nla_panel_actclip(const bContext *C, Panel *pa)
355 {
356         PointerRNA strip_ptr;
357         uiLayout *layout = pa->layout;
358         uiLayout *column, *row;
359         uiBlock *block;
360
361         /* check context and also validity of pointer */
362         if (!nla_panel_context(C, NULL, NULL, &strip_ptr))
363                 return;
364         
365         block = uiLayoutGetBlock(layout);
366         uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
367                 
368         /* Strip Properties ------------------------------------- */
369         /* action pointer */
370         row = uiLayoutRow(layout, TRUE);
371         uiItemR(row, &strip_ptr, "action", 0, NULL, ICON_ACTION);
372                 
373         /* action extents */
374         // XXX custom names were used here (to avoid the prefixes)... probably not necessary in future?
375         column = uiLayoutColumn(layout, TRUE);
376         uiItemL(column, "Action Extents:", ICON_NONE);
377         uiItemR(column, &strip_ptr, "action_frame_start", 0, "Start Frame", ICON_NONE);
378         uiItemR(column, &strip_ptr, "action_frame_end", 0, "End Frame", ICON_NONE);
379         uiItemO(column, NULL, ICON_NONE, "NLA_OT_action_sync_length");
380                 
381         /* action usage */
382         column = uiLayoutColumn(layout, TRUE);
383         uiLayoutSetActive(column, RNA_boolean_get(&strip_ptr, "use_animated_time") == FALSE);
384         uiItemL(column, "Playback Settings:", ICON_NONE);
385         uiItemR(column, &strip_ptr, "scale", 0, NULL, ICON_NONE);
386         uiItemR(column, &strip_ptr, "repeat", 0, NULL, ICON_NONE);
387 }
388
389 /* evaluation settings for active NLA-Strip */
390 static void nla_panel_evaluation(const bContext *C, Panel *pa)
391 {
392         PointerRNA strip_ptr;
393         uiLayout *layout = pa->layout;
394         uiLayout *col, *sub;
395         uiBlock *block;
396
397         /* check context and also validity of pointer */
398         if (!nla_panel_context(C, NULL, NULL, &strip_ptr))
399                 return;
400                 
401         block = uiLayoutGetBlock(layout);
402         uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
403                 
404         col = uiLayoutColumn(layout, TRUE);
405         uiItemR(col, &strip_ptr, "use_animated_influence", 0, NULL, ICON_NONE);
406         
407         sub = uiLayoutColumn(col, TRUE);
408         uiLayoutSetEnabled(sub, RNA_boolean_get(&strip_ptr, "use_animated_influence"));
409         uiItemR(sub, &strip_ptr, "influence", 0, NULL, ICON_NONE);
410
411         col = uiLayoutColumn(layout, TRUE);
412         sub = uiLayoutRow(col, FALSE);
413         uiItemR(sub, &strip_ptr, "use_animated_time", 0, NULL, ICON_NONE);
414         uiItemR(sub, &strip_ptr, "use_animated_time_cyclic", 0, NULL, ICON_NONE);
415
416         sub = uiLayoutRow(col, FALSE);
417         uiLayoutSetEnabled(sub, RNA_boolean_get(&strip_ptr, "use_animated_time"));
418         uiItemR(sub, &strip_ptr, "strip_time", 0, NULL, ICON_NONE);
419 }
420
421 /* F-Modifiers for active NLA-Strip */
422 static void nla_panel_modifiers(const bContext *C, Panel *pa)
423 {
424         PointerRNA strip_ptr;
425         NlaStrip *strip;
426         FModifier *fcm;
427         uiLayout *col, *row;
428         uiBlock *block;
429
430         /* check context and also validity of pointer */
431         if (!nla_panel_context(C, NULL, NULL, &strip_ptr))
432                 return;
433         strip = strip_ptr.data;
434                 
435         block = uiLayoutGetBlock(pa->layout);
436         uiBlockSetHandleFunc(block, do_nla_region_buttons, NULL);
437         
438         /* 'add modifier' button at top of panel */
439         {
440                 row = uiLayoutRow(pa->layout, FALSE);
441                 block = uiLayoutGetBlock(row);
442                 
443                 // XXX for now, this will be a operator button which calls a temporary 'add modifier' operator
444                 // FIXME: we need to set the only-active property so that this will only add modifiers for the active strip (not all selected)
445                 uiDefButO(block, BUT, "NLA_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, IFACE_("Add Modifier"), 10, 0, 150, 20,
446                           TIP_("Adds a new F-Modifier for the active NLA Strip"));
447                 
448                 /* copy/paste (as sub-row)*/
449                 row = uiLayoutRow(row, TRUE);
450                 uiItemO(row, "", ICON_COPYDOWN, "NLA_OT_fmodifier_copy");
451                 uiItemO(row, "", ICON_PASTEDOWN, "NLA_OT_fmodifier_paste");
452         }
453         
454         /* draw each modifier */
455         for (fcm = strip->modifiers.first; fcm; fcm = fcm->next) {
456                 col = uiLayoutColumn(pa->layout, TRUE);
457                 
458                 ANIM_uiTemplate_fmodifier_draw(col, strip_ptr.id.data, &strip->modifiers, fcm);
459         }
460 }
461
462 /* ******************* general ******************************** */
463
464
465 void nla_buttons_register(ARegionType *art)
466 {
467         PanelType *pt;
468         
469         pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel animdata");
470         strcpy(pt->idname, "NLA_PT_animdata");
471         strcpy(pt->label, "Animation Data");
472         pt->draw = nla_panel_animdata;
473         pt->poll = nla_animdata_panel_poll;
474         pt->flag = PNL_DEFAULT_CLOSED;
475         BLI_addtail(&art->paneltypes, pt);
476         
477         pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel track");
478         strcpy(pt->idname, "NLA_PT_track");
479         strcpy(pt->label, "Active Track");
480         pt->draw = nla_panel_track;
481         pt->poll = nla_track_panel_poll;
482         BLI_addtail(&art->paneltypes, pt);
483         
484         pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel properties");
485         strcpy(pt->idname, "NLA_PT_properties");
486         strcpy(pt->label, "Active Strip");
487         pt->draw = nla_panel_properties;
488         pt->poll = nla_strip_panel_poll;
489         BLI_addtail(&art->paneltypes, pt);
490         
491         pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel properties");
492         strcpy(pt->idname, "NLA_PT_actionclip");
493         strcpy(pt->label, "Action Clip");
494         pt->draw = nla_panel_actclip;
495         pt->poll = nla_strip_actclip_panel_poll;
496         BLI_addtail(&art->paneltypes, pt);
497         
498         pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel evaluation");
499         strcpy(pt->idname, "NLA_PT_evaluation");
500         strcpy(pt->label, "Evaluation");
501         pt->draw = nla_panel_evaluation;
502         pt->poll = nla_strip_eval_panel_poll;
503         BLI_addtail(&art->paneltypes, pt);
504         
505         pt = MEM_callocN(sizeof(PanelType), "spacetype nla panel modifiers");
506         strcpy(pt->idname, "NLA_PT_modifiers");
507         strcpy(pt->label, "Modifiers");
508         pt->draw = nla_panel_modifiers;
509         pt->poll = nla_strip_eval_panel_poll;
510         BLI_addtail(&art->paneltypes, pt);
511 }
512
513 static int nla_properties(bContext *C, wmOperator *UNUSED(op))
514 {
515         ScrArea *sa = CTX_wm_area(C);
516         ARegion *ar = nla_has_buttons_region(sa);
517         
518         if (ar)
519                 ED_region_toggle_hidden(C, ar);
520
521         return OPERATOR_FINISHED;
522 }
523
524 void NLA_OT_properties(wmOperatorType *ot)
525 {
526         ot->name = "Properties";
527         ot->idname = "NLA_OT_properties";
528         ot->description = "Toggle display properties panel";
529         
530         ot->exec = nla_properties;
531         ot->poll = ED_operator_nla_active;
532
533         /* flags */
534         ot->flag = 0;
535 }