Merged changes from trunk r58324-58419.
[blender.git] / source / blender / editors / space_graph / graph_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_graph/graph_buttons.c
28  *  \ingroup spgraph
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 #include "DNA_object_types.h"
39 #include "DNA_scene_types.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "BLI_math.h"
44 #include "BLI_blenlib.h"
45 #include "BLI_utildefines.h"
46
47 #include "BLF_translation.h"
48
49 #include "BKE_context.h"
50 #include "BKE_depsgraph.h"
51 #include "BKE_fcurve.h"
52 #include "BKE_main.h"
53 #include "BKE_screen.h"
54 #include "BKE_unit.h"
55
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "RNA_access.h"
61
62 #include "ED_anim_api.h"
63 #include "ED_keyframing.h"
64 #include "ED_screen.h"
65
66 #include "UI_interface.h"
67 #include "UI_resources.h"
68
69 #include "graph_intern.h"   // own include
70
71 /* ******************* graph editor space & buttons ************** */
72
73 #define B_REDR 1
74
75 /* -------------- */
76
77 static void do_graph_region_buttons(bContext *UNUSED(C), void *UNUSED(arg), int event)
78 {
79         //Scene *scene = CTX_data_scene(C);
80         
81         switch (event) {
82
83         }
84         
85         /* default for now */
86         //WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, ob);
87 }
88
89 /* -------------- */
90
91 static int graph_panel_context(const bContext *C, bAnimListElem **ale, FCurve **fcu)
92 {
93         bAnimContext ac;
94         bAnimListElem *elem = NULL;
95         
96         /* for now, only draw if we could init the anim-context info (necessary for all animation-related tools) 
97          * to work correctly is able to be correctly retrieved. There's no point showing empty panels?
98          */
99         if (ANIM_animdata_get_context(C, &ac) == 0) 
100                 return 0;
101         
102         /* try to find 'active' F-Curve */
103         elem = get_active_fcurve_channel(&ac);
104         if (elem == NULL) 
105                 return 0;
106         
107         if (fcu)
108                 *fcu = (FCurve *)elem->data;
109         if (ale)
110                 *ale = elem;
111         else
112                 MEM_freeN(elem);
113         
114         return 1;
115 }
116
117 static int graph_panel_poll(const bContext *C, PanelType *UNUSED(pt))
118 {
119         return graph_panel_context(C, NULL, NULL);
120 }
121
122 /* -------------- */
123
124 /* Graph Editor View Settings */
125 static void graph_panel_view(const bContext *C, Panel *pa)
126 {
127         bScreen *sc = CTX_wm_screen(C);
128         SpaceIpo *sipo = CTX_wm_space_graph(C);
129         Scene *scene = CTX_data_scene(C);
130         PointerRNA spaceptr, sceneptr;
131         uiLayout *col, *sub, *row;
132         
133         /* get RNA pointers for use when creating the UI elements */
134         RNA_id_pointer_create(&scene->id, &sceneptr);
135         RNA_pointer_create(&sc->id, &RNA_SpaceGraphEditor, sipo, &spaceptr);
136
137         /* 2D-Cursor */
138         col = uiLayoutColumn(pa->layout, FALSE);
139         uiItemR(col, &spaceptr, "show_cursor", 0, NULL, ICON_NONE);
140                 
141         sub = uiLayoutColumn(col, TRUE);
142         uiLayoutSetActive(sub, RNA_boolean_get(&spaceptr, "show_cursor"));
143         uiItemO(sub, IFACE_("Cursor from Selection"), ICON_NONE, "GRAPH_OT_frame_jump");
144
145         sub = uiLayoutColumn(col, TRUE);
146         uiLayoutSetActive(sub, RNA_boolean_get(&spaceptr, "show_cursor"));
147         row = uiLayoutSplit(sub, 0.7f, TRUE);
148         uiItemR(row, &sceneptr, "frame_current", 0, IFACE_("Cursor X"), ICON_NONE);
149         uiItemEnumO(row, "GRAPH_OT_snap", IFACE_("To Keys"), 0, "type", GRAPHKEYS_SNAP_CFRA);
150         
151         row = uiLayoutSplit(sub, 0.7f, TRUE);
152         uiItemR(row, &spaceptr, "cursor_position_y", 0, IFACE_("Cursor Y"), ICON_NONE);
153         uiItemEnumO(row, "GRAPH_OT_snap", IFACE_("To Keys"), 0, "type", GRAPHKEYS_SNAP_VALUE);
154 }
155
156 /* ******************* active F-Curve ************** */
157
158 static void graph_panel_properties(const bContext *C, Panel *pa)
159 {
160         bAnimListElem *ale;
161         FCurve *fcu;
162         PointerRNA fcu_ptr;
163         uiLayout *layout = pa->layout;
164         uiLayout *col, *row, *sub;
165         uiBlock *block;
166         char name[256];
167         int icon = 0;
168
169         if (!graph_panel_context(C, &ale, &fcu))
170                 return;
171         
172         block = uiLayoutGetBlock(layout);
173         uiBlockSetHandleFunc(block, do_graph_region_buttons, NULL);
174         
175         /* F-Curve pointer */
176         RNA_pointer_create(ale->id, &RNA_FCurve, fcu, &fcu_ptr);
177         
178         /* user-friendly 'name' for F-Curve */
179         /* TODO: only show the path if this is invalid? */
180         col = uiLayoutColumn(layout, FALSE);
181         icon = getname_anim_fcurve(name, ale->id, fcu);
182         uiItemL(col, name, icon);
183                 
184         /* RNA-Path Editing - only really should be enabled when things aren't working */
185         col = uiLayoutColumn(layout, TRUE);
186         uiLayoutSetEnabled(col, (fcu->flag & FCURVE_DISABLED) != 0);
187         uiItemR(col, &fcu_ptr, "data_path", 0, "", ICON_RNA);
188         uiItemR(col, &fcu_ptr, "array_index", 0, NULL, ICON_NONE);
189                 
190         /* color settings */
191         col = uiLayoutColumn(layout, TRUE);
192         uiItemL(col, IFACE_("Display Color:"), ICON_NONE);
193                 
194         row = uiLayoutRow(col, TRUE);
195         uiItemR(row, &fcu_ptr, "color_mode", 0, "", ICON_NONE);
196                         
197         sub = uiLayoutRow(row, TRUE);
198         uiLayoutSetEnabled(sub, (fcu->color_mode == FCURVE_COLOR_CUSTOM));
199         uiItemR(sub, &fcu_ptr, "color", 0, "", ICON_NONE);
200         
201         MEM_freeN(ale);
202 }
203
204 /* ******************* active Keyframe ************** */
205
206 /* get 'active' keyframe for panel editing */
207 static short get_active_fcurve_keyframe_edit(FCurve *fcu, BezTriple **bezt, BezTriple **prevbezt)
208 {
209         BezTriple *b;
210         int i;
211         
212         /* zero the pointers */
213         *bezt = *prevbezt = NULL;
214         
215         /* sanity checks */
216         if ((fcu->bezt == NULL) || (fcu->totvert == 0))
217                 return 0;
218                 
219         /* find first selected keyframe for now, and call it the active one 
220          *      - this is a reasonable assumption, given that whenever anyone 
221          *        wants to edit numerically, there is likely to only be 1 vert selected
222          */
223         for (i = 0, b = fcu->bezt; i < fcu->totvert; i++, b++) {
224                 if (BEZSELECTED(b)) {
225                         /* found 
226                          *      - 'previous' is either the one before, of the keyframe itself (which is still fine)
227                          *              XXX: we can just make this null instead if needed
228                          */
229                         *prevbezt = (i > 0) ? b - 1 : b;
230                         *bezt = b;
231                         
232                         return 1;
233                 }
234         }
235         
236         /* not found */
237         return 0;
238 }
239
240 /* update callback for active keyframe properties - base updates stuff */
241 static void graphedit_activekey_update_cb(bContext *C, void *fcu_ptr, void *UNUSED(bezt_ptr))
242 {
243         SpaceIpo *sipo = CTX_wm_space_graph(C);
244         const short use_handle = !(sipo->flag & SIPO_NOHANDLES);
245         FCurve *fcu = (FCurve *)fcu_ptr;
246         
247         /* make sure F-Curve and its handles are still valid after this editing */
248         sort_time_fcurve(fcu);
249         testhandles_fcurve(fcu, use_handle);
250 }
251
252 /* update callback for active keyframe properties - handle-editing wrapper */
253 static void graphedit_activekey_handles_cb(bContext *C, void *fcu_ptr, void *bezt_ptr)
254 {
255         BezTriple *bezt = (BezTriple *)bezt_ptr;
256         
257         /* since editing the handles, make sure they're set to types which are receptive to editing 
258          * see transform_conversions.c :: createTransGraphEditData(), last step in second loop
259          */
260         if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) && ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) {
261                 /* by changing to aligned handles, these can now be moved... */
262                 bezt->h1 = HD_ALIGN;
263                 bezt->h2 = HD_ALIGN;
264         }
265         
266         /* now call standard updates */
267         graphedit_activekey_update_cb(C, fcu_ptr, bezt_ptr);
268 }
269
270 static void graph_panel_key_properties(const bContext *C, Panel *pa)
271 {
272         bAnimListElem *ale;
273         FCurve *fcu;
274         BezTriple *bezt, *prevbezt;
275         
276         uiLayout *layout = pa->layout;
277         uiLayout *col;
278         uiBlock *block;
279
280         if (!graph_panel_context(C, &ale, &fcu))
281                 return;
282         
283         block = uiLayoutGetBlock(layout);
284         uiBlockSetHandleFunc(block, do_graph_region_buttons, NULL);
285         
286         /* only show this info if there are keyframes to edit */
287         if (get_active_fcurve_keyframe_edit(fcu, &bezt, &prevbezt)) {
288                 PointerRNA bezt_ptr, id_ptr, fcu_prop_ptr;
289                 PropertyRNA *fcu_prop = NULL;
290                 uiBut *but;
291                 int unit = B_UNIT_NONE;
292                 
293                 /* RNA pointer to keyframe, to allow editing */
294                 RNA_pointer_create(ale->id, &RNA_Keyframe, bezt, &bezt_ptr);
295                 
296                 /* get property that F-Curve affects, for some unit-conversion magic */
297                 RNA_id_pointer_create(ale->id, &id_ptr);
298                 if (RNA_path_resolve_property(&id_ptr, fcu->rna_path, &fcu_prop_ptr, &fcu_prop)) {
299                         /* determine the unit for this property */
300                         unit = RNA_SUBTYPE_UNIT(RNA_property_subtype(fcu_prop));
301                 }
302                 
303                 /* interpolation */
304                 col = uiLayoutColumn(layout, FALSE);
305                 uiItemR(col, &bezt_ptr, "interpolation", 0, NULL, ICON_NONE);
306                         
307                 /* numerical coordinate editing 
308                  *  - we use the button-versions of the calls so that we can attach special update handlers
309                  *    and unit conversion magic that cannot be achieved using a purely RNA-approach
310                  */
311                 col = uiLayoutColumn(layout, TRUE);
312                 /* keyframe itself */
313                 {
314                         uiItemL(col, IFACE_("Key:"), ICON_NONE);
315                         
316                         but = uiDefButR(block, NUM, B_REDR, IFACE_("Frame"), 0, 0, UI_UNIT_X, UI_UNIT_Y,
317                                         &bezt_ptr, "co", 0, 0, 0, -1, -1, NULL);
318                         uiButSetFunc(but, graphedit_activekey_update_cb, fcu, bezt);
319                         
320                         but = uiDefButR(block, NUM, B_REDR, IFACE_("Value"), 0, 0, UI_UNIT_X, UI_UNIT_Y,
321                                         &bezt_ptr, "co", 1, 0, 0, -1, -1, NULL);
322                         uiButSetFunc(but, graphedit_activekey_update_cb, fcu, bezt);
323                         uiButSetUnitType(but, unit);
324                 }
325                 
326                 /* previous handle - only if previous was Bezier interpolation */
327                 if ((prevbezt) && (prevbezt->ipo == BEZT_IPO_BEZ)) {
328                         uiItemL(col, IFACE_("Left Handle:"), ICON_NONE);
329                         
330                         but = uiDefButR(block, NUM, B_REDR, "X", 0, 0, UI_UNIT_X, UI_UNIT_Y,
331                                         &bezt_ptr, "handle_left", 0, 0, 0, -1, -1, NULL);
332                         uiButSetFunc(but, graphedit_activekey_handles_cb, fcu, bezt);
333                         
334                         but = uiDefButR(block, NUM, B_REDR, "Y", 0, 0, UI_UNIT_X, UI_UNIT_Y,
335                                         &bezt_ptr, "handle_left", 1, 0, 0, -1, -1, NULL);
336                         uiButSetFunc(but, graphedit_activekey_handles_cb, fcu, bezt);
337                         uiButSetUnitType(but, unit);
338                 }
339                 
340                 /* next handle - only if current is Bezier interpolation */
341                 if (bezt->ipo == BEZT_IPO_BEZ) {
342                         uiItemL(col, IFACE_("Right Handle:"), ICON_NONE);
343                         
344                         but = uiDefButR(block, NUM, B_REDR, "X", 0, 0, UI_UNIT_X, UI_UNIT_Y,
345                                         &bezt_ptr, "handle_right", 0, 0, 0, -1, -1, NULL);
346                         uiButSetFunc(but, graphedit_activekey_handles_cb, fcu, bezt);
347                         
348                         but = uiDefButR(block, NUM, B_REDR, "Y", 0, 0, UI_UNIT_X, UI_UNIT_Y,
349                                         &bezt_ptr, "handle_right", 1, 0, 0, -1, -1, NULL);
350                         uiButSetFunc(but, graphedit_activekey_handles_cb, fcu, bezt);
351                         uiButSetUnitType(but, unit);
352                 }
353         }
354         else {
355                 if ((fcu->bezt == NULL) && (fcu->modifiers.first)) {
356                         /* modifiers only - so no keyframes to be active */
357                         uiItemL(layout, IFACE_("F-Curve only has F-Modifiers"), ICON_NONE);
358                         uiItemL(layout, IFACE_("See Modifiers panel below"), ICON_INFO);
359                 }
360                 else if (fcu->fpt) {
361                         /* samples only */
362                         uiItemL(layout, IFACE_("F-Curve doesn't have any keyframes as it only contains sampled points"),
363                                 ICON_NONE);
364                 }
365                 else
366                         uiItemL(layout, IFACE_("No active keyframe on F-Curve"), ICON_NONE);
367         }
368         
369         MEM_freeN(ale);
370 }
371
372 /* ******************* drivers ******************************** */
373
374 #define B_IPO_DEPCHANGE     10
375
376 static void do_graph_region_driver_buttons(bContext *C, void *UNUSED(arg), int event)
377 {
378         Main *bmain = CTX_data_main(C);
379         Scene *scene = CTX_data_scene(C);
380         
381         switch (event) {
382                 case B_IPO_DEPCHANGE:
383                 {
384                         /* rebuild depsgraph for the new deps */
385                         DAG_relations_tag_update(bmain);
386                         break;
387                 }
388         }
389         
390         /* default for now */
391         WM_event_add_notifier(C, NC_SCENE | ND_FRAME, scene); // XXX could use better notifier
392 }
393
394 /* callback to remove the active driver */
395 static void driver_remove_cb(bContext *C, void *ale_v, void *UNUSED(arg))
396 {
397         bAnimListElem *ale = (bAnimListElem *)ale_v;
398         ID *id = ale->id;
399         FCurve *fcu = ale->data;
400         ReportList *reports = CTX_wm_reports(C);
401         
402         /* try to get F-Curve that driver lives on, and ID block which has this AnimData */
403         if (ELEM(NULL, id, fcu))
404                 return;
405         
406         /* call API method to remove this driver  */
407         ANIM_remove_driver(reports, id, fcu->rna_path, fcu->array_index, 0);
408 }
409
410 /* callback to add a target variable to the active driver */
411 static void driver_add_var_cb(bContext *UNUSED(C), void *driver_v, void *UNUSED(arg))
412 {
413         ChannelDriver *driver = (ChannelDriver *)driver_v;
414         
415         /* add a new variable */
416         driver_add_new_variable(driver);
417 }
418
419 /* callback to remove target variable from active driver */
420 static void driver_delete_var_cb(bContext *UNUSED(C), void *driver_v, void *dvar_v)
421 {
422         ChannelDriver *driver = (ChannelDriver *)driver_v;
423         DriverVar *dvar = (DriverVar *)dvar_v;
424         
425         /* remove the active variable */
426         driver_free_variable(driver, dvar);
427 }
428
429 /* callback to reset the driver's flags */
430 static void driver_update_flags_cb(bContext *UNUSED(C), void *fcu_v, void *UNUSED(arg))
431 {
432         FCurve *fcu = (FCurve *)fcu_v;
433         ChannelDriver *driver = fcu->driver;
434         
435         /* clear invalid flags */
436         fcu->flag &= ~FCURVE_DISABLED;
437         driver->flag &= ~DRIVER_FLAG_INVALID;
438 }
439
440 /* drivers panel poll */
441 static int graph_panel_drivers_poll(const bContext *C, PanelType *UNUSED(pt))
442 {
443         SpaceIpo *sipo = CTX_wm_space_graph(C);
444
445         if (sipo->mode != SIPO_MODE_DRIVERS)
446                 return 0;
447
448         return graph_panel_context(C, NULL, NULL);
449 }
450
451 /* settings for 'single property' driver variable type */
452 static void graph_panel_driverVar__singleProp(uiLayout *layout, ID *id, DriverVar *dvar)
453 {
454         DriverTarget *dtar = &dvar->targets[0];
455         PointerRNA dtar_ptr;
456         uiLayout *row, *col;
457         
458         /* initialize RNA pointer to the target */
459         RNA_pointer_create(id, &RNA_DriverTarget, dtar, &dtar_ptr); 
460         
461         /* Target ID */
462         row = uiLayoutRow(layout, FALSE);
463         uiLayoutSetRedAlert(row, ((dtar->flag & DTAR_FLAG_INVALID) && !dtar->id));
464         uiTemplateAnyID(row, &dtar_ptr, "id", "id_type", IFACE_("Prop:"));
465         
466         /* Target Property */
467         if (dtar->id) {
468                 PointerRNA root_ptr;
469                 
470                 /* get pointer for resolving the property selected */
471                 RNA_id_pointer_create(dtar->id, &root_ptr);
472                 
473                 /* rna path */
474                 col = uiLayoutColumn(layout, TRUE);
475                 uiLayoutSetRedAlert(col, (dtar->flag & DTAR_FLAG_INVALID));
476                 uiTemplatePathBuilder(col, &dtar_ptr, "data_path", &root_ptr, IFACE_("Path"));
477         }
478 }
479
480 /* settings for 'rotation difference' driver variable type */
481 static void graph_panel_driverVar__rotDiff(uiLayout *layout, ID *id, DriverVar *dvar)
482 {
483         DriverTarget *dtar = &dvar->targets[0];
484         DriverTarget *dtar2 = &dvar->targets[1];
485         Object *ob1 = (Object *)dtar->id;
486         Object *ob2 = (Object *)dtar2->id;
487         PointerRNA dtar_ptr, dtar2_ptr;
488         uiLayout *col;
489         
490         /* initialize RNA pointer to the target */
491         RNA_pointer_create(id, &RNA_DriverTarget, dtar, &dtar_ptr); 
492         RNA_pointer_create(id, &RNA_DriverTarget, dtar2, &dtar2_ptr); 
493         
494         /* Bone 1 */
495         col = uiLayoutColumn(layout, TRUE);
496         uiLayoutSetRedAlert(col, (dtar->flag & DTAR_FLAG_INVALID)); /* XXX: per field... */
497         uiTemplateAnyID(col, &dtar_ptr, "id", "id_type", IFACE_("Bone 1:"));
498         
499         if (dtar->id && ob1->pose) {
500                 PointerRNA tar_ptr;
501                 
502                 RNA_pointer_create(dtar->id, &RNA_Pose, ob1->pose, &tar_ptr);
503                 uiItemPointerR(col, &dtar_ptr, "bone_target", &tar_ptr, "bones", "", ICON_BONE_DATA);
504         }
505         
506         col = uiLayoutColumn(layout, TRUE);
507         uiLayoutSetRedAlert(col, (dtar2->flag & DTAR_FLAG_INVALID)); /* XXX: per field... */
508         uiTemplateAnyID(col, &dtar2_ptr, "id", "id_type", IFACE_("Bone 2:"));
509                 
510         if (dtar2->id && ob2->pose) {
511                 PointerRNA tar_ptr;
512                 
513                 RNA_pointer_create(dtar2->id, &RNA_Pose, ob2->pose, &tar_ptr);
514                 uiItemPointerR(col, &dtar2_ptr, "bone_target", &tar_ptr, "bones", "", ICON_BONE_DATA);
515         }
516 }
517
518 /* settings for 'location difference' driver variable type */
519 static void graph_panel_driverVar__locDiff(uiLayout *layout, ID *id, DriverVar *dvar)
520 {
521         DriverTarget *dtar  = &dvar->targets[0];
522         DriverTarget *dtar2 = &dvar->targets[1];
523         Object *ob1 = (Object *)dtar->id;
524         Object *ob2 = (Object *)dtar2->id;
525         PointerRNA dtar_ptr, dtar2_ptr;
526         uiLayout *col;
527         
528         /* initialize RNA pointer to the target */
529         RNA_pointer_create(id, &RNA_DriverTarget, dtar,  &dtar_ptr); 
530         RNA_pointer_create(id, &RNA_DriverTarget, dtar2, &dtar2_ptr); 
531         
532         /* Bone 1 */
533         col = uiLayoutColumn(layout, TRUE);
534         uiLayoutSetRedAlert(col, (dtar->flag & DTAR_FLAG_INVALID)); /* XXX: per field... */
535         uiTemplateAnyID(col, &dtar_ptr, "id", "id_type", IFACE_("Ob/Bone 1:"));
536                 
537         if (dtar->id && ob1->pose) {
538                 PointerRNA tar_ptr;
539                 
540                 RNA_pointer_create(dtar->id, &RNA_Pose, ob1->pose, &tar_ptr);
541                 uiItemPointerR(col, &dtar_ptr, "bone_target", &tar_ptr, "bones", "", ICON_BONE_DATA);
542         }
543         
544         uiLayoutSetRedAlert(col, false); /* we can clear it again now - it's only needed when creating the ID/Bone fields */
545         uiItemR(col, &dtar_ptr, "transform_space", 0, NULL, ICON_NONE);
546         
547         col = uiLayoutColumn(layout, TRUE);
548         uiLayoutSetRedAlert(col, (dtar2->flag & DTAR_FLAG_INVALID)); /* XXX: per field... */
549         uiTemplateAnyID(col, &dtar2_ptr, "id", "id_type", IFACE_("Ob/Bone 2:"));
550                 
551         if (dtar2->id && ob2->pose) {
552                 PointerRNA tar_ptr;
553                 
554                 RNA_pointer_create(dtar2->id, &RNA_Pose, ob2->pose, &tar_ptr);
555                 uiItemPointerR(col, &dtar2_ptr, "bone_target", &tar_ptr, "bones", "", ICON_BONE_DATA);
556         }
557                 
558         uiLayoutSetRedAlert(col, false); /* we can clear it again now - it's only needed when creating the ID/Bone fields */
559         uiItemR(col, &dtar2_ptr, "transform_space", 0, NULL, ICON_NONE);
560 }
561
562 /* settings for 'transform channel' driver variable type */
563 static void graph_panel_driverVar__transChan(uiLayout *layout, ID *id, DriverVar *dvar)
564 {
565         DriverTarget *dtar = &dvar->targets[0];
566         Object *ob = (Object *)dtar->id;
567         PointerRNA dtar_ptr;
568         uiLayout *col, *sub;
569         
570         /* initialize RNA pointer to the target */
571         RNA_pointer_create(id, &RNA_DriverTarget, dtar, &dtar_ptr); 
572         
573         /* properties */
574         col = uiLayoutColumn(layout, TRUE);
575         uiLayoutSetRedAlert(col, (dtar->flag & DTAR_FLAG_INVALID)); /* XXX: per field... */
576         uiTemplateAnyID(col, &dtar_ptr, "id", "id_type", IFACE_("Ob/Bone:"));
577                 
578         if (dtar->id && ob->pose) {
579                 PointerRNA tar_ptr;
580                 
581                 RNA_pointer_create(dtar->id, &RNA_Pose, ob->pose, &tar_ptr);
582                 uiItemPointerR(col, &dtar_ptr, "bone_target", &tar_ptr, "bones", "", ICON_BONE_DATA);
583         }
584                 
585         sub = uiLayoutColumn(layout, TRUE);
586         uiItemR(sub, &dtar_ptr, "transform_type", 0, NULL, ICON_NONE);
587         uiItemR(sub, &dtar_ptr, "transform_space", 0, IFACE_("Space"), ICON_NONE);
588 }
589
590 /* driver settings for active F-Curve (only for 'Drivers' mode) */
591 static void graph_panel_drivers(const bContext *C, Panel *pa)
592 {
593         bAnimListElem *ale;
594         FCurve *fcu;
595         ChannelDriver *driver;
596         DriverVar *dvar;
597         
598         PointerRNA driver_ptr;
599         uiLayout *col;
600         uiBlock *block;
601         uiBut *but;
602         
603         /* Get settings from context */
604         if (!graph_panel_context(C, &ale, &fcu))
605                 return;
606         driver = fcu->driver;
607         
608         /* set event handler for panel */
609         block = uiLayoutGetBlock(pa->layout); // xxx?
610         uiBlockSetHandleFunc(block, do_graph_region_driver_buttons, NULL);
611         
612         /* general actions - management */
613         col = uiLayoutColumn(pa->layout, FALSE);
614         block = uiLayoutGetBlock(col);
615         but = uiDefBut(block, BUT, B_IPO_DEPCHANGE, IFACE_("Update Dependencies"), 0, 0, 10 * UI_UNIT_X, 22,
616                        NULL, 0.0, 0.0, 0, 0, TIP_("Force updates of dependencies"));
617         uiButSetFunc(but, driver_update_flags_cb, fcu, NULL);
618
619         but = uiDefBut(block, BUT, B_IPO_DEPCHANGE, IFACE_("Remove Driver"), 0, 0, 10 * UI_UNIT_X, 18,
620                        NULL, 0.0, 0.0, 0, 0, TIP_("Remove this driver"));
621         uiButSetNFunc(but, driver_remove_cb, MEM_dupallocN(ale), NULL);
622                 
623         /* driver-level settings - type, expressions, and errors */
624         RNA_pointer_create(ale->id, &RNA_Driver, driver, &driver_ptr);
625         
626         col = uiLayoutColumn(pa->layout, TRUE);
627         block = uiLayoutGetBlock(col);
628         uiItemR(col, &driver_ptr, "type", 0, NULL, ICON_NONE);
629
630         /* show expression box if doing scripted drivers, and/or error messages when invalid drivers exist */
631         if (driver->type == DRIVER_TYPE_PYTHON) {
632                 /* expression */
633                 uiItemR(col, &driver_ptr, "expression", 0, IFACE_("Expr"), ICON_NONE);
634                 
635                 /* errors? */
636                 if (driver->flag & DRIVER_FLAG_INVALID)
637                         uiItemL(col, IFACE_("ERROR: Invalid Python expression"), ICON_ERROR);
638         }
639         else {
640                 /* errors? */
641                 if (driver->flag & DRIVER_FLAG_INVALID)
642                         uiItemL(col, IFACE_("ERROR: Invalid target channel(s)"), ICON_ERROR);
643         }
644                 
645         col = uiLayoutColumn(pa->layout, TRUE);
646         /* debug setting */
647         uiItemR(col, &driver_ptr, "show_debug_info", 0, NULL, ICON_NONE);
648                 
649         /* value of driver */
650         if (driver->flag & DRIVER_FLAG_SHOWDEBUG) {
651                 uiLayout *row = uiLayoutRow(col, TRUE);
652                 char valBuf[32];
653                         
654                 uiItemL(row, IFACE_("Driver Value:"), ICON_NONE);
655                         
656                 BLI_snprintf(valBuf, sizeof(valBuf), "%.3f", driver->curval);
657                 uiItemL(row, valBuf, ICON_NONE);
658         }
659         
660         /* add driver variables */
661         col = uiLayoutColumn(pa->layout, FALSE);
662         block = uiLayoutGetBlock(col);
663         but = uiDefBut(block, BUT, B_IPO_DEPCHANGE, IFACE_("Add Variable"), 0, 0, 10 * UI_UNIT_X, UI_UNIT_Y,
664                        NULL, 0.0, 0.0, 0, 0, TIP_("Add a new target variable for this Driver"));
665         uiButSetFunc(but, driver_add_var_cb, driver, NULL);
666         
667         /* loop over targets, drawing them */
668         for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
669                 PointerRNA dvar_ptr;
670                 uiLayout *box, *row;
671                 
672                 /* sub-layout column for this variable's settings */
673                 col = uiLayoutColumn(pa->layout, TRUE);
674                 
675                 /* header panel */
676                 box = uiLayoutBox(col);
677                 /* first row context info for driver */
678                 RNA_pointer_create(ale->id, &RNA_DriverVariable, dvar, &dvar_ptr);
679                 
680                 row = uiLayoutRow(box, FALSE);
681                 block = uiLayoutGetBlock(row);
682                 /* variable name */
683                 uiItemR(row, &dvar_ptr, "name", 0, "", ICON_NONE);
684                 
685                 /* remove button */
686                 uiBlockSetEmboss(block, UI_EMBOSSN);
687                 but = uiDefIconBut(block, BUT, B_IPO_DEPCHANGE, ICON_X, 290, 0, UI_UNIT_X, UI_UNIT_Y,
688                                    NULL, 0.0, 0.0, 0.0, 0.0, IFACE_("Delete target variable"));
689                 uiButSetFunc(but, driver_delete_var_cb, driver, dvar);
690                 uiBlockSetEmboss(block, UI_EMBOSS);
691                 
692                 /* variable type */
693                 row = uiLayoutRow(box, FALSE);
694                 uiItemR(row, &dvar_ptr, "type", 0, "", ICON_NONE);
695                                 
696                 /* variable type settings */
697                 box = uiLayoutBox(col);
698                 /* controls to draw depends on the type of variable */
699                 switch (dvar->type) {
700                         case DVAR_TYPE_SINGLE_PROP:     /* single property */
701                                 graph_panel_driverVar__singleProp(box, ale->id, dvar);
702                                 break;
703                         case DVAR_TYPE_ROT_DIFF:     /* rotational difference */
704                                 graph_panel_driverVar__rotDiff(box, ale->id, dvar);
705                                 break;
706                         case DVAR_TYPE_LOC_DIFF:     /* location difference */
707                                 graph_panel_driverVar__locDiff(box, ale->id, dvar);
708                                 break;
709                         case DVAR_TYPE_TRANSFORM_CHAN:     /* transform channel */
710                                 graph_panel_driverVar__transChan(box, ale->id, dvar);
711                                 break;
712                 }
713                 
714                 /* value of variable */
715                 if (driver->flag & DRIVER_FLAG_SHOWDEBUG) {
716                         char valBuf[32];
717                         
718                         box = uiLayoutBox(col);
719                         row = uiLayoutRow(box, TRUE);
720                         uiItemL(row, IFACE_("Value:"), ICON_NONE);
721                         
722                         if ((dvar->type == DVAR_TYPE_ROT_DIFF) ||
723                             (dvar->type == DVAR_TYPE_TRANSFORM_CHAN &&
724                              dvar->targets[0].transChan >= DTAR_TRANSCHAN_ROTX &&
725                              dvar->targets[0].transChan < DTAR_TRANSCHAN_SCALEX))
726                         {
727                                 BLI_snprintf(valBuf, sizeof(valBuf), "%.3f (%4.1f°)", dvar->curval, RAD2DEGF(dvar->curval));
728                         }
729                         else {
730                                 BLI_snprintf(valBuf, sizeof(valBuf), "%.3f", dvar->curval);
731                         }
732                         
733                         uiItemL(row, valBuf, ICON_NONE);
734                 }
735         }
736         
737         /* cleanup */
738         MEM_freeN(ale);
739 }
740
741 /* ******************* F-Modifiers ******************************** */
742 /* All the drawing code is in editors/animation/fmodifier_ui.c */
743
744 #define B_FMODIFIER_REDRAW      20
745
746 static void do_graph_region_modifier_buttons(bContext *C, void *UNUSED(arg), int event)
747 {
748         switch (event) {
749                 case B_FMODIFIER_REDRAW: // XXX this should send depsgraph updates too
750                         WM_event_add_notifier(C, NC_ANIMATION, NULL); // XXX need a notifier specially for F-Modifiers
751                         break;
752         }
753 }
754
755 static void graph_panel_modifiers(const bContext *C, Panel *pa) 
756 {
757         bAnimListElem *ale;
758         FCurve *fcu;
759         FModifier *fcm;
760         uiLayout *col, *row;
761         uiBlock *block;
762         
763         if (!graph_panel_context(C, &ale, &fcu))
764                 return;
765         
766         block = uiLayoutGetBlock(pa->layout);
767         uiBlockSetHandleFunc(block, do_graph_region_modifier_buttons, NULL);
768         
769         /* 'add modifier' button at top of panel */
770         {
771                 row = uiLayoutRow(pa->layout, FALSE);
772                 block = uiLayoutGetBlock(row);
773                 
774                 /* this is an operator button which calls a 'add modifier' operator... 
775                  * a menu might be nicer but would be tricky as we need some custom filtering
776                  */
777                 uiDefButO(block, BUT, "GRAPH_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, IFACE_("Add Modifier"),
778                           0.5 * UI_UNIT_X, 0, 7.5 * UI_UNIT_X, UI_UNIT_Y, TIP_("Adds a new F-Curve Modifier for the active F-Curve"));
779                 
780                 /* copy/paste (as sub-row)*/
781                 row = uiLayoutRow(row, TRUE);
782                 uiItemO(row, "", ICON_COPYDOWN, "GRAPH_OT_fmodifier_copy");
783                 uiItemO(row, "", ICON_PASTEDOWN, "GRAPH_OT_fmodifier_paste");
784         }
785         
786         /* draw each modifier */
787         for (fcm = fcu->modifiers.first; fcm; fcm = fcm->next) {
788                 col = uiLayoutColumn(pa->layout, TRUE);
789                 
790                 ANIM_uiTemplate_fmodifier_draw(col, ale->id, &fcu->modifiers, fcm);
791         }
792
793         MEM_freeN(ale);
794 }
795
796 /* ******************* general ******************************** */
797
798 void graph_buttons_register(ARegionType *art)
799 {
800         PanelType *pt;
801
802         pt = MEM_callocN(sizeof(PanelType), "spacetype graph panel view");
803         strcpy(pt->idname, "GRAPH_PT_view");
804         strcpy(pt->label, N_("View Properties"));
805         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
806         pt->draw = graph_panel_view;
807         pt->flag |= PNL_DEFAULT_CLOSED;
808         BLI_addtail(&art->paneltypes, pt);
809         
810         pt = MEM_callocN(sizeof(PanelType), "spacetype graph panel properties");
811         strcpy(pt->idname, "GRAPH_PT_properties");
812         strcpy(pt->label, N_("Active F-Curve"));
813         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
814         pt->draw = graph_panel_properties;
815         pt->poll = graph_panel_poll;
816         BLI_addtail(&art->paneltypes, pt);
817         
818         pt = MEM_callocN(sizeof(PanelType), "spacetype graph panel properties");
819         strcpy(pt->idname, "GRAPH_PT_key_properties");
820         strcpy(pt->label, N_("Active Keyframe"));
821         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
822         pt->draw = graph_panel_key_properties;
823         pt->poll = graph_panel_poll;
824         BLI_addtail(&art->paneltypes, pt);
825
826
827         pt = MEM_callocN(sizeof(PanelType), "spacetype graph panel drivers");
828         strcpy(pt->idname, "GRAPH_PT_drivers");
829         strcpy(pt->label, N_("Drivers"));
830         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
831         pt->draw = graph_panel_drivers;
832         pt->poll = graph_panel_drivers_poll;
833         BLI_addtail(&art->paneltypes, pt);
834
835         pt = MEM_callocN(sizeof(PanelType), "spacetype graph panel modifiers");
836         strcpy(pt->idname, "GRAPH_PT_modifiers");
837         strcpy(pt->label, N_("Modifiers"));
838         strcpy(pt->translation_context, BLF_I18NCONTEXT_DEFAULT_BPYRNA);
839         pt->draw = graph_panel_modifiers;
840         pt->poll = graph_panel_poll;
841         BLI_addtail(&art->paneltypes, pt);
842 }
843
844 static int graph_properties(bContext *C, wmOperator *UNUSED(op))
845 {
846         ScrArea *sa = CTX_wm_area(C);
847         ARegion *ar = graph_has_buttons_region(sa);
848         
849         if (ar)
850                 ED_region_toggle_hidden(C, ar);
851
852         return OPERATOR_FINISHED;
853 }
854
855 void GRAPH_OT_properties(wmOperatorType *ot)
856 {
857         ot->name = "Properties";
858         ot->idname = "GRAPH_OT_properties";
859         ot->description = "Toggle display properties panel";
860         
861         ot->exec = graph_properties;
862         ot->poll = ED_operator_graphedit_active;
863
864         /* flags */
865         ot->flag = 0;
866 }