05987087288f2ba061553a43261117794a85517b
[blender.git] / source / blender / editors / space_graph / graph_buttons.c
1 /**
2  * $Id:
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation, Joshua Leung
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include <string.h>
30 #include <stdio.h>
31 #include <math.h>
32 #include <float.h>
33
34 #include "DNA_anim_types.h"
35 #include "DNA_action_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_space_types.h"
38 #include "DNA_scene_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_userdef_types.h"
41
42 #include "MEM_guardedalloc.h"
43
44 #include "BLI_math.h"
45 #include "BLI_blenlib.h"
46 #include "BLI_editVert.h"
47 #include "BLI_rand.h"
48
49 #include "BKE_action.h"
50 #include "BKE_animsys.h"
51 #include "BKE_context.h"
52 #include "BKE_curve.h"
53 #include "BKE_customdata.h"
54 #include "BKE_depsgraph.h"
55 #include "BKE_fcurve.h"
56 #include "BKE_library.h"
57 #include "BKE_main.h"
58 #include "BKE_object.h"
59 #include "BKE_scene.h"
60 #include "BKE_screen.h"
61 #include "BKE_utildefines.h"
62
63 #include "BIF_gl.h"
64
65 #include "WM_api.h"
66 #include "WM_types.h"
67
68 #include "RNA_access.h"
69 #include "RNA_define.h"
70
71 #include "ED_anim_api.h"
72 #include "ED_keyframing.h"
73 #include "ED_screen.h"
74 #include "ED_types.h"
75 #include "ED_util.h"
76
77 #include "UI_interface.h"
78 #include "UI_resources.h"
79 #include "UI_view2d.h"
80
81 #include "graph_intern.h"       // own include
82
83 /* XXX */
84
85 /* temporary definition for limits of float number buttons (FLT_MAX tends to infinity with old system) */
86 #define UI_FLT_MAX      10000.0f
87
88
89 /* ******************* graph editor space & buttons ************** */
90
91 #define B_NOP           1
92 #define B_REDR          2
93
94 /* -------------- */
95
96 static void do_graph_region_buttons(bContext *C, void *arg, int event)
97 {
98         //Scene *scene= CTX_data_scene(C);
99         
100         switch(event) {
101
102         }
103         
104         /* default for now */
105         //WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, ob);
106 }
107
108 /* -------------- */
109
110 static int graph_panel_context(const bContext *C, bAnimListElem **ale, FCurve **fcu)
111 {
112         bAnimContext ac;
113         bAnimListElem *elem= NULL;
114         
115         /* for now, only draw if we could init the anim-context info (necessary for all animation-related tools) 
116          * to work correctly is able to be correctly retrieved. There's no point showing empty panels?
117          */
118         if (ANIM_animdata_get_context(C, &ac) == 0) 
119                 return 0;
120         
121         /* try to find 'active' F-Curve */
122         elem= get_active_fcurve_channel(&ac);
123         if(elem == NULL) 
124                 return 0;
125         
126         if(fcu)
127                 *fcu= (FCurve*)elem->data;
128         if(ale)
129                 *ale= elem;
130         else
131                 MEM_freeN(elem);
132         
133         return 1;
134 }
135
136 static int graph_panel_poll(const bContext *C, PanelType *pt)
137 {
138         return graph_panel_context(C, NULL, NULL);
139 }
140
141 /* -------------- */
142
143 /* Graph Editor View Settings */
144 static void graph_panel_view(const bContext *C, Panel *pa)
145 {
146         bScreen *sc= CTX_wm_screen(C);
147         SpaceIpo *sipo= CTX_wm_space_graph(C);
148         Scene *scene= CTX_data_scene(C);
149         PointerRNA spaceptr, sceneptr;
150         uiLayout *col, *subcol;
151         
152         /* get RNA pointers for use when creating the UI elements */
153         RNA_id_pointer_create(&scene->id, &sceneptr);
154         RNA_pointer_create(&sc->id, &RNA_SpaceGraphEditor, sipo, &spaceptr);
155
156         /* 2D-Cursor */
157         col= uiLayoutColumn(pa->layout, 0);
158                 uiItemR(col, NULL, 0, &spaceptr, "show_cursor", 0);
159                 
160                 subcol= uiLayoutColumn(col, 1);
161                 uiLayoutSetActive(subcol, RNA_boolean_get(&spaceptr, "show_cursor")); 
162                         uiItemR(subcol, "Cursor X", 0, &sceneptr, "current_frame", 0);
163                         uiItemR(subcol, "Cursor Y", 0, &spaceptr, "cursor_value", 0);
164                         
165                 subcol= uiLayoutColumn(col, 1);
166                 uiLayoutSetActive(subcol, RNA_boolean_get(&spaceptr, "show_cursor")); 
167                         uiItemO(subcol, "Cursor from Selection", 0, "GRAPH_OT_frame_jump");
168 }
169
170 /* ******************* active F-Curve ************** */
171
172 static void graph_panel_properties(const bContext *C, Panel *pa)
173 {
174         bAnimListElem *ale;
175         FCurve *fcu;
176         PointerRNA fcu_ptr;
177         uiLayout *layout = pa->layout;
178         uiLayout *col, *row, *subrow;
179         uiBlock *block;
180         char name[256];
181         int icon = 0;
182
183         if (!graph_panel_context(C, &ale, &fcu))
184                 return;
185         
186         block= uiLayoutGetBlock(layout);
187         uiBlockSetHandleFunc(block, do_graph_region_buttons, NULL);
188         
189         /* F-Curve pointer */
190         RNA_pointer_create(ale->id, &RNA_FCurve, fcu, &fcu_ptr);
191         
192         /* user-friendly 'name' for F-Curve */
193         // TODO: only show the path if this is invalid?
194         col= uiLayoutColumn(layout, 0);
195                 icon= getname_anim_fcurve(name, ale->id, fcu);
196                 uiItemL(col, name, icon);
197                 
198         /* RNA-Path Editing - only really should be enabled when things aren't working */
199         col= uiLayoutColumn(layout, 1);
200                 uiLayoutSetEnabled(col, (fcu->flag & FCURVE_DISABLED)); 
201                 uiItemR(col, "", ICON_RNA, &fcu_ptr, "rna_path", 0);
202                 uiItemR(col, NULL, 0, &fcu_ptr, "array_index", 0);
203                 
204         /* color settings */
205         col= uiLayoutColumn(layout, 1);
206                 uiItemL(col, "Display Color:", 0);
207                 
208                 row= uiLayoutRow(col, 1);
209                         uiItemR(row, "", 0, &fcu_ptr, "color_mode", 0);
210                         
211                         subrow= uiLayoutRow(row, 1);
212                                 uiLayoutSetEnabled(subrow, (fcu->color_mode==FCURVE_COLOR_CUSTOM));
213                                 uiItemR(subrow, "", 0, &fcu_ptr, "color", 0);
214         
215         /* TODO: the following settings could be added here
216          *      - Access details (ID-block + RNA-Path + Array Index)
217          *      - ...
218          */
219
220         MEM_freeN(ale);
221 }
222
223 /* ******************* drivers ******************************** */
224
225 #define B_IPO_DEPCHANGE         10
226
227 static void do_graph_region_driver_buttons(bContext *C, void *arg, int event)
228 {
229         Scene *scene= CTX_data_scene(C);
230         
231         switch (event) {
232                 case B_IPO_DEPCHANGE:
233                 {
234                         /* rebuild depsgraph for the new deps */
235                         DAG_scene_sort(scene);
236                         
237                         /* force an update of depsgraph */
238                         DAG_ids_flush_update(0);
239                 }
240                         break;
241         }
242         
243         /* default for now */
244         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene); // XXX could use better notifier
245 }
246
247 /* callback to remove the active driver */
248 static void driver_remove_cb (bContext *C, void *ale_v, void *dummy_v)
249 {
250         bAnimListElem *ale= (bAnimListElem *)ale_v;
251         ID *id= ale->id;
252         FCurve *fcu= ale->data;
253         
254         /* try to get F-Curve that driver lives on, and ID block which has this AnimData */
255         if (ELEM(NULL, id, fcu))
256                 return;
257         
258         /* call API method to remove this driver  */    
259         ANIM_remove_driver(id, fcu->rna_path, fcu->array_index, 0);
260 }
261
262 /* callback to add a target variable to the active driver */
263 static void driver_add_var_cb (bContext *C, void *driver_v, void *dummy_v)
264 {
265         ChannelDriver *driver= (ChannelDriver *)driver_v;
266         
267         /* add a new var */
268         driver_add_new_target(driver);
269 }
270
271 /* callback to remove target variable from active driver */
272 static void driver_delete_var_cb (bContext *C, void *driver_v, void *dtar_v)
273 {
274         ChannelDriver *driver= (ChannelDriver *)driver_v;
275         DriverTarget *dtar= (DriverTarget *)dtar_v;
276         
277         /* remove the active target */
278         driver_free_target(driver, dtar);
279 }
280
281 /* callback to reset the driver's flags */
282 static void driver_update_flags_cb (bContext *C, void *fcu_v, void *dummy_v)
283 {
284         FCurve *fcu= (FCurve *)fcu_v;
285         ChannelDriver *driver= fcu->driver;
286         
287         /* clear invalid flags */
288         fcu->flag &= ~FCURVE_DISABLED; // XXX?
289         driver->flag &= ~DRIVER_FLAG_INVALID;
290 }
291
292 /* drivers panel poll */
293 static int graph_panel_drivers_poll(const bContext *C, PanelType *pt)
294 {
295         SpaceIpo *sipo= CTX_wm_space_graph(C);
296
297         if(sipo->mode != SIPO_MODE_DRIVERS)
298                 return 0;
299
300         return graph_panel_context(C, NULL, NULL);
301 }
302
303
304 /* driver settings for active F-Curve (only for 'Drivers' mode) */
305 static void graph_panel_drivers(const bContext *C, Panel *pa)
306 {
307         bAnimListElem *ale;
308         FCurve *fcu;
309         ChannelDriver *driver;
310         DriverTarget *dtar;
311         
312         PointerRNA driver_ptr;
313         uiLayout *col;
314         uiBlock *block;
315         uiBut *but;
316         
317         /* Get settings from context */
318         if (!graph_panel_context(C, &ale, &fcu))
319                 return;
320         driver= fcu->driver;
321         
322         /* set event handler for panel */
323         block= uiLayoutGetBlock(pa->layout); // xxx?
324         uiBlockSetHandleFunc(block, do_graph_region_driver_buttons, NULL);
325         
326         /* general actions - management */
327         col= uiLayoutColumn(pa->layout, 0);
328         block= uiLayoutGetBlock(col);
329                 but= uiDefBut(block, BUT, B_IPO_DEPCHANGE, "Update Dependencies", 0, 0, 10*UI_UNIT_X, 22, NULL, 0.0, 0.0, 0, 0, "Force updates of dependencies");
330                 uiButSetFunc(but, driver_update_flags_cb, fcu, NULL);
331                 
332                 but= uiDefBut(block, BUT, B_IPO_DEPCHANGE, "Remove Driver", 0, 0, 10*UI_UNIT_X, 18, NULL, 0.0, 0.0, 0, 0, "Remove this driver");
333                 uiButSetNFunc(but, driver_remove_cb, MEM_dupallocN(ale), NULL);
334                 
335         /* driver-level settings - type, expressions, and errors */
336         RNA_pointer_create(ale->id, &RNA_Driver, driver, &driver_ptr);
337         
338         col= uiLayoutColumn(pa->layout, 1);
339         block= uiLayoutGetBlock(col);
340                 uiItemR(col, NULL, 0, &driver_ptr, "type", 0);
341                 
342                 /* show expression box if doing scripted drivers, and/or error messages when invalid drivers exist */
343                 if (driver->type == DRIVER_TYPE_PYTHON) {
344                         /* expression */
345                         uiItemR(col, "Expr", 0, &driver_ptr, "expression", 0);
346                         
347                         /* errors? */
348                         if (driver->flag & DRIVER_FLAG_INVALID)
349                                 uiItemL(col, "ERROR: invalid Python expression", ICON_ERROR);
350                 }
351                 else {
352                         /* errors? */
353                         if (driver->flag & DRIVER_FLAG_INVALID)
354                                 uiItemL(col, "ERROR: invalid target channel(s)", ICON_ERROR);
355                 }
356         
357         /* add driver target variables */
358         col= uiLayoutColumn(pa->layout, 0);
359         block= uiLayoutGetBlock(col);
360                 but= uiDefBut(block, BUT, B_IPO_DEPCHANGE, "Add Target", 0, 0, 10*UI_UNIT_X, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "Add a new target variable for this Driver");
361                 uiButSetFunc(but, driver_add_var_cb, driver, NULL);
362         
363         /* loop over targets, drawing them */
364         for (dtar= driver->targets.first; dtar; dtar= dtar->next) {
365                 PointerRNA dtar_ptr;
366                 uiLayout *box, *row;
367                 
368                 /* panel holding the buttons */
369                 box= uiLayoutBox(pa->layout);
370                 
371                 /* first row context info for driver */
372                 RNA_pointer_create(ale->id, &RNA_DriverTarget, dtar, &dtar_ptr);
373                 
374                 row= uiLayoutRow(box, 0);
375                 block= uiLayoutGetBlock(row);
376                         /* variable name */
377                         uiItemR(row, "", 0, &dtar_ptr, "name", 0);
378                         
379                         /* remove button */
380                         but= uiDefIconBut(block, BUT, B_IPO_DEPCHANGE, ICON_X, 290, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0.0, 0.0, 0.0, 0.0, "Delete target variable.");
381                         uiButSetFunc(but, driver_delete_var_cb, driver, dtar);
382                 
383                 
384                 /* Target ID */
385                 row= uiLayoutRow(box, 0);
386                         uiTemplateAnyID(row, (bContext *)C, &dtar_ptr, "id", "id_type", "Value:");
387                 
388                 /* Target Property */
389                 // TODO: make this less technical...
390                 if (dtar->id) {
391                         PointerRNA root_ptr;
392                         
393                         /* get pointer for resolving the property selected */
394                         RNA_id_pointer_create(dtar->id, &root_ptr);
395                         
396                         col= uiLayoutColumn(box, 1);
397                         block= uiLayoutGetBlock(col);
398                                 /* rna path */
399                                 uiTemplatePathBuilder(col, (bContext *)C, &dtar_ptr, "rna_path", &root_ptr, "Path");
400                                 
401                                 /* array index */
402                                 // TODO: this needs selector which limits it to ok values
403                                 // NOTE: for for now, the array index box still gets shown when non-zero (i.e. for tweaking rigs as necessary)
404                                 if (dtar->array_index)
405                                         uiItemR(col, "Index", 0, &dtar_ptr, "array_index", 0);
406                 }
407         }
408         
409         /* cleanup */
410         MEM_freeN(ale);
411 }
412
413 /* ******************* f-modifiers ******************************** */
414 /* all the drawing code is in editors/animation/fmodifier_ui.c */
415
416 #define B_FMODIFIER_REDRAW              20
417
418 static void do_graph_region_modifier_buttons(bContext *C, void *arg, int event)
419 {
420         switch (event) {
421                 case B_REDR:
422                 case B_FMODIFIER_REDRAW: // XXX this should send depsgraph updates too
423                         WM_event_add_notifier(C, NC_ANIMATION, NULL); // XXX need a notifier specially for F-Modifiers
424                         break;
425         }
426 }
427
428 static void graph_panel_modifiers(const bContext *C, Panel *pa) 
429 {
430         bAnimListElem *ale;
431         FCurve *fcu;
432         FModifier *fcm;
433         uiLayout *col, *row;
434         uiBlock *block;
435         
436         if (!graph_panel_context(C, &ale, &fcu))
437                 return;
438         
439         block= uiLayoutGetBlock(pa->layout);
440         uiBlockSetHandleFunc(block, do_graph_region_modifier_buttons, NULL);
441         
442         /* 'add modifier' button at top of panel */
443         {
444                 row= uiLayoutRow(pa->layout, 0);
445                 block= uiLayoutGetBlock(row);
446                 
447                 // XXX for now, this will be a operator button which calls a temporary 'add modifier' operator
448                 uiDefButO(block, BUT, "GRAPH_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, "Add Modifier", 10, 0, 150, 20, "Adds a new F-Curve Modifier for the active F-Curve");
449         }
450         
451         /* draw each modifier */
452         for (fcm= fcu->modifiers.first; fcm; fcm= fcm->next) {
453                 col= uiLayoutColumn(pa->layout, 1);
454                 
455                 ANIM_uiTemplate_fmodifier_draw(C, col, ale->id, &fcu->modifiers, fcm);
456         }
457
458         MEM_freeN(ale);
459 }
460
461 /* ******************* general ******************************** */
462
463 void graph_buttons_register(ARegionType *art)
464 {
465         PanelType *pt;
466
467         pt= MEM_callocN(sizeof(PanelType), "spacetype graph panel view");
468         strcpy(pt->idname, "GRAPH_PT_view");
469         strcpy(pt->label, "View Properties");
470         pt->draw= graph_panel_view;
471         BLI_addtail(&art->paneltypes, pt);
472         
473         pt= MEM_callocN(sizeof(PanelType), "spacetype graph panel properties");
474         strcpy(pt->idname, "GRAPH_PT_properties");
475         strcpy(pt->label, "Active F-Curve");
476         pt->draw= graph_panel_properties;
477         pt->poll= graph_panel_poll;
478         BLI_addtail(&art->paneltypes, pt);
479
480         pt= MEM_callocN(sizeof(PanelType), "spacetype graph panel drivers");
481         strcpy(pt->idname, "GRAPH_PT_drivers");
482         strcpy(pt->label, "Drivers");
483         pt->draw= graph_panel_drivers;
484         pt->poll= graph_panel_drivers_poll;
485         BLI_addtail(&art->paneltypes, pt);
486
487         pt= MEM_callocN(sizeof(PanelType), "spacetype graph panel modifiers");
488         strcpy(pt->idname, "GRAPH_PT_modifiers");
489         strcpy(pt->label, "Modifiers");
490         pt->draw= graph_panel_modifiers;
491         pt->poll= graph_panel_poll;
492         BLI_addtail(&art->paneltypes, pt);
493 }
494
495 static int graph_properties(bContext *C, wmOperator *op)
496 {
497         ScrArea *sa= CTX_wm_area(C);
498         ARegion *ar= graph_has_buttons_region(sa);
499         
500         if(ar)
501                 ED_region_toggle_hidden(C, ar);
502
503         return OPERATOR_FINISHED;
504 }
505
506 void GRAPH_OT_properties(wmOperatorType *ot)
507 {
508         ot->name= "Properties";
509         ot->idname= "GRAPH_OT_properties";
510         
511         ot->exec= graph_properties;
512         ot->poll= ED_operator_ipo_active; // xxx
513         
514         /* flags */
515         ot->flag= 0;
516 }