Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / space_graph / graph_edit.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) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Joshua Leung
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_graph/graph_edit.c
29  *  \ingroup spgraph
30  */
31
32
33 #include <math.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <float.h>
37
38 #ifdef WITH_AUDASPACE
39 #  include <AUD_Special.h>
40 #endif
41
42 #include "MEM_guardedalloc.h"
43
44 #include "BLI_blenlib.h"
45 #include "BLI_math.h"
46 #include "BLI_utildefines.h"
47
48 #include "DNA_anim_types.h"
49 #include "DNA_scene_types.h"
50
51 #include "RNA_access.h"
52 #include "RNA_define.h"
53 #include "RNA_enum_types.h"
54
55 #include "BLT_translation.h"
56
57 #include "BKE_fcurve.h"
58 #include "BKE_global.h"
59 #include "BKE_nla.h"
60 #include "BKE_context.h"
61 #include "BKE_report.h"
62
63 #include "DEG_depsgraph_build.h"
64
65 #include "UI_view2d.h"
66
67 #include "ED_anim_api.h"
68 #include "ED_keyframing.h"
69 #include "ED_keyframes_edit.h"
70 #include "ED_screen.h"
71 #include "ED_transform.h"
72 #include "ED_markers.h"
73
74 #include "WM_api.h"
75 #include "WM_types.h"
76
77 #include "graph_intern.h"
78
79 /* ************************************************************************** */
80 /* KEYFRAME-RANGE STUFF */
81
82 /* *************************** Calculate Range ************************** */
83
84 /* Get the min/max keyframes*/
85 /* note: it should return total boundbox, filter for selection only can be argument... */
86 void get_graph_keyframe_extents(bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax, 
87                                 const bool do_sel_only, const bool include_handles)
88 {
89         Scene *scene = ac->scene;
90         
91         ListBase anim_data = {NULL, NULL};
92         bAnimListElem *ale;
93         int filter;
94         
95         /* get data to filter, from Dopesheet */
96         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
97         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
98         
99         /* set large values initial values that will be easy to override */
100         if (xmin) *xmin = 999999999.0f;
101         if (xmax) *xmax = -999999999.0f;
102         if (ymin) *ymin = 999999999.0f;
103         if (ymax) *ymax = -999999999.0f;
104         
105         /* check if any channels to set range with */
106         if (anim_data.first) {
107                 bool foundBounds = false;
108                 
109                 /* go through channels, finding max extents */
110                 for (ale = anim_data.first; ale; ale = ale->next) {
111                         AnimData *adt = ANIM_nla_mapping_get(ac, ale);
112                         FCurve *fcu = (FCurve *)ale->key_data;
113                         float txmin, txmax, tymin, tymax;
114                         float unitFac, offset;
115                         
116                         /* get range */
117                         if (calc_fcurve_bounds(fcu, &txmin, &txmax, &tymin, &tymax, do_sel_only, include_handles)) {
118                                 short mapping_flag = ANIM_get_normalization_flags(ac);
119
120                                 /* apply NLA scaling */
121                                 if (adt) {
122                                         txmin = BKE_nla_tweakedit_remap(adt, txmin, NLATIME_CONVERT_MAP);
123                                         txmax = BKE_nla_tweakedit_remap(adt, txmax, NLATIME_CONVERT_MAP);
124                                 }
125                                 
126                                 /* apply unit corrections */
127                                 unitFac = ANIM_unit_mapping_get_factor(ac->scene, ale->id, fcu, mapping_flag, &offset);
128                                 tymin += offset;
129                                 tymax += offset;
130                                 tymin *= unitFac;
131                                 tymax *= unitFac;
132                                 
133                                 /* try to set cur using these values, if they're more extreme than previously set values */
134                                 if ((xmin) && (txmin < *xmin)) *xmin = txmin;
135                                 if ((xmax) && (txmax > *xmax)) *xmax = txmax;
136                                 if ((ymin) && (tymin < *ymin)) *ymin = tymin;
137                                 if ((ymax) && (tymax > *ymax)) *ymax = tymax;
138                                 
139                                 foundBounds = true;
140                         }
141                 }
142                 
143                 /* ensure that the extents are not too extreme that view implodes...*/
144                 if (foundBounds) {
145                         if ((xmin && xmax) && (fabsf(*xmax - *xmin) < 0.001f)) {
146                                 *xmin -= 0.0005f;
147                                 *xmax += 0.0005f;
148                         }
149                         if ((ymin && ymax) && (fabsf(*ymax - *ymin) < 0.001f)) {
150                                 *ymax -= 0.0005f;
151                                 *ymax += 0.0005f;
152                         }
153                 }
154                 else {
155                         if (xmin) *xmin = (float)PSFRA;
156                         if (xmax) *xmax = (float)PEFRA;
157                         if (ymin) *ymin = -5;
158                         if (ymax) *ymax = 5;
159                 }
160                 
161                 /* free memory */
162                 ANIM_animdata_freelist(&anim_data);
163         }
164         else {
165                 /* set default range */
166                 if (ac->scene) {
167                         if (xmin) *xmin = (float)PSFRA;
168                         if (xmax) *xmax = (float)PEFRA;
169                 }
170                 else {
171                         if (xmin) *xmin = -5;
172                         if (xmax) *xmax = 100;
173                 }
174                 
175                 if (ymin) *ymin = -5;
176                 if (ymax) *ymax = 5;
177         }
178 }
179
180 /* ****************** Automatic Preview-Range Operator ****************** */
181
182 static int graphkeys_previewrange_exec(bContext *C, wmOperator *UNUSED(op))
183 {
184         bAnimContext ac;
185         Scene *scene;
186         float min, max;
187         
188         /* get editor data */
189         if (ANIM_animdata_get_context(C, &ac) == 0)
190                 return OPERATOR_CANCELLED;
191         if (ac.scene == NULL)
192                 return OPERATOR_CANCELLED;
193         else
194                 scene = ac.scene;
195         
196         /* set the range directly */
197         get_graph_keyframe_extents(&ac, &min, &max, NULL, NULL, false, false);
198         scene->r.flag |= SCER_PRV_RANGE;
199         scene->r.psfra = round_fl_to_int(min);
200         scene->r.pefra = round_fl_to_int(max);
201         
202         /* set notifier that things have changed */
203         // XXX err... there's nothing for frame ranges yet, but this should do fine too
204         WM_event_add_notifier(C, NC_SCENE | ND_FRAME, ac.scene);
205         
206         return OPERATOR_FINISHED;
207 }
208  
209 void GRAPH_OT_previewrange_set(wmOperatorType *ot)
210 {
211         /* identifiers */
212         ot->name = "Auto-Set Preview Range";
213         ot->idname = "GRAPH_OT_previewrange_set";
214         ot->description = "Automatically set Preview Range based on range of keyframes";
215         
216         /* api callbacks */
217         ot->exec = graphkeys_previewrange_exec;
218         ot->poll = ED_operator_graphedit_active; // XXX: unchecked poll to get fsamples working too, but makes modifier damage trickier...
219         
220         /* flags */
221         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
222 }
223
224 /* ****************** View-All Operator ****************** */
225
226 static int graphkeys_viewall(bContext *C, const bool do_sel_only, const bool include_handles,
227                              const int smooth_viewtx)
228 {
229         bAnimContext ac;
230         rctf cur_new;
231         
232         /* get editor data */
233         if (ANIM_animdata_get_context(C, &ac) == 0)
234                 return OPERATOR_CANCELLED;
235         
236         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
237         get_graph_keyframe_extents(&ac,
238                                    &cur_new.xmin, &cur_new.xmax,
239                                    &cur_new.ymin, &cur_new.ymax,
240                                    do_sel_only, include_handles);
241
242         BLI_rctf_scale(&cur_new, 1.1f);
243         
244         UI_view2d_smooth_view(C, ac.ar, &cur_new, smooth_viewtx);
245         
246         return OPERATOR_FINISHED;
247 }
248
249 /* ......... */
250
251 static int graphkeys_viewall_exec(bContext *C, wmOperator *op)
252 {
253         const bool include_handles = RNA_boolean_get(op->ptr, "include_handles");
254         const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
255         
256         /* whole range */
257         return graphkeys_viewall(C, false, include_handles, smooth_viewtx);
258 }
259  
260 static int graphkeys_view_selected_exec(bContext *C, wmOperator *op)
261 {
262         const bool include_handles = RNA_boolean_get(op->ptr, "include_handles");
263         const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
264         
265         /* only selected */
266         return graphkeys_viewall(C, true, include_handles, smooth_viewtx);
267 }
268
269 /* ......... */
270
271 void GRAPH_OT_view_all(wmOperatorType *ot)
272 {
273         /* identifiers */
274         ot->name = "View All";
275         ot->idname = "GRAPH_OT_view_all";
276         ot->description = "Reset viewable area to show full keyframe range";
277         
278         /* api callbacks */
279         ot->exec = graphkeys_viewall_exec;
280         ot->poll = ED_operator_graphedit_active; /* XXX: unchecked poll to get fsamples working too, but makes modifier damage trickier... */
281         
282         /* flags */
283         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
284         
285         /* props */
286         ot->prop = RNA_def_boolean(ot->srna, "include_handles", true, "Include Handles", 
287                                    "Include handles of keyframes when calculating extents");
288 }
289
290 void GRAPH_OT_view_selected(wmOperatorType *ot)
291 {
292         /* identifiers */
293         ot->name = "View Selected";
294         ot->idname = "GRAPH_OT_view_selected";
295         ot->description = "Reset viewable area to show selected keyframe range";
296
297         /* api callbacks */
298         ot->exec = graphkeys_view_selected_exec;
299         ot->poll = ED_operator_graphedit_active; /* XXX: unchecked poll to get fsamples working too, but makes modifier damage trickier... */
300
301         /* flags */
302         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
303         
304         /* props */
305         ot->prop = RNA_def_boolean(ot->srna, "include_handles", true, "Include Handles", 
306                                    "Include handles of keyframes when calculating extents");
307 }
308
309 /* ********************** View Frame Operator ****************************** */
310
311 static int graphkeys_view_frame_exec(bContext *C, wmOperator *op)
312 {
313         const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
314         ANIM_center_frame(C, smooth_viewtx);
315         return OPERATOR_FINISHED;
316 }
317
318 void GRAPH_OT_view_frame(wmOperatorType *ot)
319 {
320         /* identifiers */
321         ot->name = "View Frame";
322         ot->idname = "GRAPH_OT_view_frame";
323         ot->description = "Reset viewable area to show range around current frame";
324         
325         /* api callbacks */
326         ot->exec = graphkeys_view_frame_exec;
327         ot->poll = ED_operator_graphedit_active;
328         
329         /* flags */
330         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
331 }
332
333 /* ******************** Create Ghost-Curves Operator *********************** */
334 /* This operator samples the data of the selected F-Curves to F-Points, storing them
335  * as 'ghost curves' in the active Graph Editor
336  */
337
338 /* Bake each F-Curve into a set of samples, and store as a ghost curve */
339 static void create_ghost_curves(bAnimContext *ac, int start, int end)
340 {       
341         SpaceIpo *sipo = (SpaceIpo *)ac->sl;
342         ListBase anim_data = {NULL, NULL};
343         bAnimListElem *ale;
344         int filter;
345         
346         /* free existing ghost curves */
347         free_fcurves(&sipo->ghostCurves);
348         
349         /* sanity check */
350         if (start >= end) {
351                 printf("Error: Frame range for Ghost F-Curve creation is inappropriate\n");
352                 return;
353         }
354         
355         /* filter data */
356         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);
357         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
358         
359         /* loop through filtered data and add keys between selected keyframes on every frame  */
360         for (ale = anim_data.first; ale; ale = ale->next) {
361                 FCurve *fcu = (FCurve *)ale->key_data;
362                 FCurve *gcu = MEM_callocN(sizeof(FCurve), "Ghost FCurve");
363                 AnimData *adt = ANIM_nla_mapping_get(ac, ale);
364                 ChannelDriver *driver = fcu->driver;
365                 FPoint *fpt;
366                 float unitFac, offset;
367                 int cfra;
368                 short mapping_flag = ANIM_get_normalization_flags(ac);
369                 
370                 /* disable driver so that it don't muck up the sampling process */
371                 fcu->driver = NULL;
372                 
373                 /* calculate unit-mapping factor */
374                 unitFac = ANIM_unit_mapping_get_factor(ac->scene, ale->id, fcu, mapping_flag, &offset);
375                 
376                 /* create samples, but store them in a new curve 
377                  *      - we cannot use fcurve_store_samples() as that will only overwrite the original curve 
378                  */
379                 gcu->fpt = fpt = MEM_callocN(sizeof(FPoint) * (end - start + 1), "Ghost FPoint Samples");
380                 gcu->totvert = end - start + 1;
381                 
382                 /* use the sampling callback at 1-frame intervals from start to end frames */
383                 for (cfra = start; cfra <= end; cfra++, fpt++) {
384                         float cfrae = BKE_nla_tweakedit_remap(adt, cfra, NLATIME_CONVERT_UNMAP);
385                         
386                         fpt->vec[0] = cfrae;
387                         fpt->vec[1] = (fcurve_samplingcb_evalcurve(fcu, NULL, cfrae) + offset) * unitFac;
388                 }
389                 
390                 /* set color of ghost curve 
391                  *      - make the color slightly darker
392                  */
393                 gcu->color[0] = fcu->color[0] - 0.07f;
394                 gcu->color[1] = fcu->color[1] - 0.07f;
395                 gcu->color[2] = fcu->color[2] - 0.07f;
396                 
397                 /* store new ghost curve */
398                 BLI_addtail(&sipo->ghostCurves, gcu);
399                 
400                 /* restore driver */
401                 fcu->driver = driver;
402         }
403         
404         /* admin and redraws */
405         ANIM_animdata_freelist(&anim_data);
406 }
407
408 /* ------------------- */
409
410 static int graphkeys_create_ghostcurves_exec(bContext *C, wmOperator *UNUSED(op))
411 {
412         bAnimContext ac;
413         View2D *v2d;
414         int start, end;
415         
416         /* get editor data */
417         if (ANIM_animdata_get_context(C, &ac) == 0)
418                 return OPERATOR_CANCELLED;
419                 
420         /* ghost curves are snapshots of the visible portions of the curves, so set range to be the visible range */
421         v2d = &ac.ar->v2d;
422         start = (int)v2d->cur.xmin;
423         end = (int)v2d->cur.xmax;
424         
425         /* bake selected curves into a ghost curve */
426         create_ghost_curves(&ac, start, end);
427         
428         /* update this editor only */
429         ED_area_tag_redraw(CTX_wm_area(C));
430         
431         return OPERATOR_FINISHED;
432 }
433  
434 void GRAPH_OT_ghost_curves_create(wmOperatorType *ot)
435 {
436         /* identifiers */
437         ot->name = "Create Ghost Curves";
438         ot->idname = "GRAPH_OT_ghost_curves_create";
439         ot->description = "Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor";
440         
441         /* api callbacks */
442         ot->exec = graphkeys_create_ghostcurves_exec;
443         ot->poll = graphop_visible_keyframes_poll;
444         
445         /* flags */
446         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
447         
448         // todo: add props for start/end frames
449 }
450
451 /* ******************** Clear Ghost-Curves Operator *********************** */
452 /* This operator clears the 'ghost curves' for the active Graph Editor */
453
454 static int graphkeys_clear_ghostcurves_exec(bContext *C, wmOperator *UNUSED(op))
455 {
456         bAnimContext ac;
457         SpaceIpo *sipo;
458         
459         /* get editor data */
460         if (ANIM_animdata_get_context(C, &ac) == 0)
461                 return OPERATOR_CANCELLED;
462         sipo = (SpaceIpo *)ac.sl;
463                 
464         /* if no ghost curves, don't do anything */
465         if (BLI_listbase_is_empty(&sipo->ghostCurves))
466                 return OPERATOR_CANCELLED;
467         
468         /* free ghost curves */
469         free_fcurves(&sipo->ghostCurves);
470         
471         /* update this editor only */
472         ED_area_tag_redraw(CTX_wm_area(C));
473         
474         return OPERATOR_FINISHED;
475 }
476  
477 void GRAPH_OT_ghost_curves_clear(wmOperatorType *ot)
478 {
479         /* identifiers */
480         ot->name = "Clear Ghost Curves";
481         ot->idname = "GRAPH_OT_ghost_curves_clear";
482         ot->description = "Clear F-Curve snapshots (Ghosts) for active Graph Editor";
483         
484         /* api callbacks */
485         ot->exec = graphkeys_clear_ghostcurves_exec;
486         ot->poll = ED_operator_graphedit_active;
487         
488         /* flags */
489         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
490 }
491
492 /* ************************************************************************** */
493 /* GENERAL STUFF */
494
495 /* ******************** Insert Keyframes Operator ************************* */
496
497 /* Mode defines for insert keyframes tool */
498 typedef enum eGraphKeys_InsertKey_Types {
499         GRAPHKEYS_INSERTKEY_ALL    = (1 << 0),
500         GRAPHKEYS_INSERTKEY_SEL    = (1 << 1),
501         GRAPHKEYS_INSERTKEY_CURSOR = (1 << 2),
502         GRAPHKEYS_INSERTKEY_ACTIVE = (1 << 3),
503 } eGraphKeys_InsertKey_Types;
504
505 /* RNA mode types for insert keyframes tool */
506 static const EnumPropertyItem prop_graphkeys_insertkey_types[] = {
507         {GRAPHKEYS_INSERTKEY_ALL,   "ALL", 0, "All Channels",
508          "Insert a keyframe on all visible and editable F-Curves using each curve's current value"},
509         {GRAPHKEYS_INSERTKEY_SEL,   "SEL", 0, "Only Selected Channels",
510          "Insert a keyframe on selected F-Curves using each curve's current value"},
511         {0, "", 0, "", ""},
512         {GRAPHKEYS_INSERTKEY_ACTIVE | GRAPHKEYS_INSERTKEY_CURSOR, "CURSOR_ACTIVE", 0,
513          "Active Channels At Cursor", "Insert a keyframe for the active F-Curve at the cursor point"},
514         {GRAPHKEYS_INSERTKEY_SEL | GRAPHKEYS_INSERTKEY_CURSOR, "CURSOR_SEL", 0,
515          "Selected Channels At Cursor", "Insert a keyframe for selected F-Curves at the cursor point"},
516         {0, NULL, 0, NULL, NULL}
517 };
518
519 /* this function is responsible for snapping keyframes to frame-times */
520 static void insert_graph_keys(bAnimContext *ac, eGraphKeys_InsertKey_Types mode) 
521 {
522         ListBase anim_data = {NULL, NULL};
523         bAnimListElem *ale;
524         int filter;
525         size_t num_items;
526         
527         ReportList *reports = ac->reports;
528         SpaceIpo *sipo = (SpaceIpo *)ac->sl;
529         Scene *scene = ac->scene;
530         ToolSettings *ts = scene->toolsettings;
531         short flag = 0;
532         
533         /* filter data */
534         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
535         if (mode & GRAPHKEYS_INSERTKEY_SEL)
536                 filter |= ANIMFILTER_SEL;
537         else if (mode & GRAPHKEYS_INSERTKEY_ACTIVE)
538                 filter |= ANIMFILTER_ACTIVE;
539         
540         num_items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
541         if (num_items == 0) {
542                 if (mode & GRAPHKEYS_INSERTKEY_ACTIVE)
543                         BKE_report(reports, RPT_ERROR, "No active F-Curve to add a keyframe to. Select an editable F-Curve first");
544                 else if (mode & GRAPHKEYS_INSERTKEY_SEL)
545                         BKE_report(reports, RPT_ERROR, "No selected F-Curves to add keyframes to");
546                 else
547                         BKE_report(reports, RPT_ERROR, "No channels to add keyframes to");
548                 
549                 return;
550         }
551         
552         /* init keyframing flag */
553         flag = ANIM_get_keyframing_flags(scene, 1);
554         
555         /* insert keyframes */
556         if (mode & GRAPHKEYS_INSERTKEY_CURSOR) {
557                 for (ale = anim_data.first; ale; ale = ale->next) {
558                         AnimData *adt = ANIM_nla_mapping_get(ac, ale);
559                         FCurve *fcu = (FCurve *)ale->key_data;
560                         
561                         short mapping_flag = ANIM_get_normalization_flags(ac);
562                         float offset;
563                         float unit_scale = ANIM_unit_mapping_get_factor(ac->scene, ale->id, ale->key_data, mapping_flag, &offset);
564                         
565                         float x, y;
566                         
567                         
568                         /* perform time remapping for x-coordinate (if necessary) */
569                         if ((sipo) && (sipo->mode == SIPO_MODE_DRIVERS))
570                                 x = sipo->cursorTime;
571                         else if (adt)
572                                 x = BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
573                         else
574                                 x = (float)CFRA;
575                         
576                         /* normalise units of cursor's value */
577                         if (sipo)
578                                 y = (sipo->cursorVal / unit_scale) - offset;
579                         else
580                                 y = 0.0f;
581                                 
582                         /* insert keyframe directly into the F-Curve */
583                         insert_vert_fcurve(fcu, x, y, ts->keyframe_type, 0);
584                         
585                         ale->update |= ANIM_UPDATE_DEFAULT;
586                 }
587         }
588         else {
589                 for (ale = anim_data.first; ale; ale = ale->next) {
590                         AnimData *adt = ANIM_nla_mapping_get(ac, ale);
591                         FCurve *fcu = (FCurve *)ale->key_data;
592                         float cfra;
593                         
594                         /* adjust current frame for NLA-mapping */
595                         if ((sipo) && (sipo->mode == SIPO_MODE_DRIVERS))
596                                 cfra = sipo->cursorTime;
597                         else if (adt)
598                                 cfra = BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
599                         else 
600                                 cfra = (float)CFRA;
601                                 
602                         /* read value from property the F-Curve represents, or from the curve only?
603                          * - ale->id != NULL:    Typically, this means that we have enough info to try resolving the path
604                          * - ale->owner != NULL: If this is set, then the path may not be resolvable from the ID alone,
605                          *                       so it's easier for now to just read the F-Curve directly.
606                          *                       (TODO: add the full-blown PointerRNA relative parsing case here...)
607                          * - fcu->driver != NULL: If this is set, then it's a driver. If we don't check for this, we'd end
608                          *                        up adding the keyframes on a new F-Curve in the action data instead.
609                          */
610                         if (ale->id && !ale->owner && !fcu->driver) {
611                                 insert_keyframe(reports, ale->id, NULL, ((fcu->grp) ? (fcu->grp->name) : (NULL)), fcu->rna_path, fcu->array_index, cfra, ts->keyframe_type, flag);
612                         }
613                         else {
614                                 const float curval = evaluate_fcurve(fcu, cfra);
615                                 insert_vert_fcurve(fcu, cfra, curval, ts->keyframe_type, 0);
616                         }
617                         
618                         ale->update |= ANIM_UPDATE_DEFAULT;
619                 }
620         }
621         
622         ANIM_animdata_update(ac, &anim_data);
623         ANIM_animdata_freelist(&anim_data);
624 }
625
626 /* ------------------- */
627
628 static int graphkeys_insertkey_exec(bContext *C, wmOperator *op)
629 {
630         bAnimContext ac;
631         eGraphKeys_InsertKey_Types mode;
632         
633         /* get editor data */
634         if (ANIM_animdata_get_context(C, &ac) == 0)
635                 return OPERATOR_CANCELLED;
636                 
637         /* which channels to affect? */
638         mode = RNA_enum_get(op->ptr, "type");
639         
640         /* insert keyframes */
641         insert_graph_keys(&ac, mode);
642         
643         /* set notifier that keyframes have changed */
644         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_ADDED, NULL);
645         
646         return OPERATOR_FINISHED;
647 }
648
649 void GRAPH_OT_keyframe_insert(wmOperatorType *ot)
650 {
651         /* identifiers */
652         ot->name = "Insert Keyframes";
653         ot->idname = "GRAPH_OT_keyframe_insert";
654         ot->description = "Insert keyframes for the specified channels";
655         
656         /* api callbacks */
657         ot->invoke = WM_menu_invoke;
658         ot->exec = graphkeys_insertkey_exec;
659         ot->poll = graphop_editable_keyframes_poll;
660         
661         /* flags */
662         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
663         
664         /* id-props */
665         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_insertkey_types, 0, "Type", "");
666 }
667
668 /* ******************** Click-Insert Keyframes Operator ************************* */
669
670 static int graphkeys_click_insert_exec(bContext *C, wmOperator *op)
671 {
672         bAnimContext ac;
673         bAnimListElem *ale;
674         AnimData *adt;
675         FCurve *fcu;
676         float frame, val;
677         
678         /* get animation context */
679         if (ANIM_animdata_get_context(C, &ac) == 0)
680                 return OPERATOR_CANCELLED;
681         
682         /* get active F-Curve 'anim-list-element' */
683         ale = get_active_fcurve_channel(&ac);
684         if (ELEM(NULL, ale, ale->data)) {
685                 if (ale) MEM_freeN(ale);
686                 return OPERATOR_CANCELLED;
687         }
688         fcu = ale->data;
689         
690         /* when there are F-Modifiers on the curve, only allow adding
691          * keyframes if these will be visible after doing so...
692          */
693         if (fcurve_is_keyframable(fcu)) {
694                 ListBase anim_data;
695                 ToolSettings *ts = ac.scene->toolsettings;
696                 
697                 short mapping_flag = ANIM_get_normalization_flags(&ac);
698                 float scale, offset;
699                 
700                 /* preserve selection? */
701                 if (RNA_boolean_get(op->ptr, "extend") == false) {
702                         /* deselect all keyframes first, so that we can immediately start manipulating the newly added one(s)
703                          * - only affect the keyframes themselves, as we don't want channels popping in and out...
704                          */
705                         deselect_graph_keys(&ac, false, SELECT_SUBTRACT, false);
706                 }
707                 
708                 /* get frame and value from props */
709                 frame = RNA_float_get(op->ptr, "frame");
710                 val = RNA_float_get(op->ptr, "value");
711                 
712                 /* apply inverse NLA-mapping to frame to get correct time in un-scaled action */
713                 adt = ANIM_nla_mapping_get(&ac, ale);
714                 frame = BKE_nla_tweakedit_remap(adt, frame, NLATIME_CONVERT_UNMAP);
715                 
716                 /* apply inverse unit-mapping to value to get correct value for F-Curves */
717                 scale = ANIM_unit_mapping_get_factor(ac.scene, ale->id, fcu, mapping_flag | ANIM_UNITCONV_RESTORE, &offset);
718                 
719                 val = val * scale - offset;
720                 
721                 /* insert keyframe on the specified frame + value */
722                 insert_vert_fcurve(fcu, frame, val, ts->keyframe_type, 0);
723                 
724                 ale->update |= ANIM_UPDATE_DEPS;
725                 
726                 BLI_listbase_clear(&anim_data);
727                 BLI_addtail(&anim_data, ale);
728                 
729                 ANIM_animdata_update(&ac, &anim_data);
730         }
731         else {
732                 /* warn about why this can't happen */
733                 if (fcu->fpt)
734                         BKE_report(op->reports, RPT_ERROR, "Keyframes cannot be added to sampled F-Curves");
735                 else if (fcu->flag & FCURVE_PROTECTED)
736                         BKE_report(op->reports, RPT_ERROR, "Active F-Curve is not editable");
737                 else
738                         BKE_report(op->reports, RPT_ERROR, "Remove F-Modifiers from F-Curve to add keyframes");
739         }
740         
741         /* free temp data */
742         MEM_freeN(ale);
743         
744         /* set notifier that keyframes have changed */
745         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
746         
747         /* done */
748         return OPERATOR_FINISHED;
749 }
750
751 static int graphkeys_click_insert_invoke(bContext *C, wmOperator *op, const wmEvent *event)
752 {
753         bAnimContext ac;
754         ARegion *ar;
755         View2D *v2d;
756         int mval[2];
757         float x, y;
758         
759         /* get animation context */
760         if (ANIM_animdata_get_context(C, &ac) == 0)
761                 return OPERATOR_CANCELLED;
762         
763         /* store mouse coordinates in View2D space, into the operator's properties */
764         ar = ac.ar;
765         v2d = &ar->v2d;
766         
767         mval[0] = (event->x - ar->winrct.xmin);
768         mval[1] = (event->y - ar->winrct.ymin);
769         
770         UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y);
771         
772         RNA_float_set(op->ptr, "frame", x);
773         RNA_float_set(op->ptr, "value", y);
774         
775         /* run exec now */
776         return graphkeys_click_insert_exec(C, op);
777 }
778
779 void GRAPH_OT_click_insert(wmOperatorType *ot)
780 {
781         /* identifiers */
782         ot->name = "Click-Insert Keyframes";
783         ot->idname = "GRAPH_OT_click_insert";
784         ot->description = "Insert new keyframe at the cursor position for the active F-Curve";
785         
786         /* api callbacks */
787         ot->invoke = graphkeys_click_insert_invoke;
788         ot->exec = graphkeys_click_insert_exec;
789         ot->poll = graphop_active_fcurve_poll;
790         
791         /* flags */
792         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
793         
794         /* properties */
795         RNA_def_float(ot->srna, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame Number", "Frame to insert keyframe on", 0, 100);
796         RNA_def_float(ot->srna, "value", 1.0f, -FLT_MAX, FLT_MAX, "Value", "Value for keyframe on", 0, 100);
797         
798         RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend selection instead of deselecting everything first");
799 }
800
801 /* ******************** Copy/Paste Keyframes Operator ************************* */
802 /* NOTE: the backend code for this is shared with the dopesheet editor */
803
804 static short copy_graph_keys(bAnimContext *ac)
805 {       
806         ListBase anim_data = {NULL, NULL};
807         int filter, ok = 0;
808         
809         /* clear buffer first */
810         ANIM_fcurves_copybuf_free();
811         
812         /* filter data */
813         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
814         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
815         
816         /* copy keyframes */
817         ok = copy_animedit_keys(ac, &anim_data);
818         
819         /* clean up */
820         ANIM_animdata_freelist(&anim_data);
821
822         return ok;
823 }
824
825 static short paste_graph_keys(bAnimContext *ac,
826                               const eKeyPasteOffset offset_mode, const eKeyMergeMode merge_mode, bool flip)
827 {       
828         ListBase anim_data = {NULL, NULL};
829         int filter, ok = 0;
830         
831         /* filter data 
832          * - First time we try to filter more strictly, allowing only selected channels 
833          *   to allow copying animation between channels
834          * - Second time, we loosen things up if nothing was found the first time, allowing
835          *   users to just paste keyframes back into the original curve again [#31670]
836          */
837         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
838         
839         if (ANIM_animdata_filter(ac, &anim_data, filter | ANIMFILTER_SEL, ac->data, ac->datatype) == 0)
840                 ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
841         
842         /* paste keyframes */
843         ok = paste_animedit_keys(ac, &anim_data, offset_mode, merge_mode, flip);
844
845         /* clean up */
846         ANIM_animdata_freelist(&anim_data);
847
848         return ok;
849 }
850
851 /* ------------------- */
852
853 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
854 {
855         bAnimContext ac;
856         
857         /* get editor data */
858         if (ANIM_animdata_get_context(C, &ac) == 0)
859                 return OPERATOR_CANCELLED;
860         
861         /* copy keyframes */
862         if (copy_graph_keys(&ac)) {
863                 BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
864                 return OPERATOR_CANCELLED;
865         }
866         
867         /* just return - no operator needed here (no changes) */
868         return OPERATOR_FINISHED;
869 }
870  
871 void GRAPH_OT_copy(wmOperatorType *ot)
872 {
873         /* identifiers */
874         ot->name = "Copy Keyframes";
875         ot->idname = "GRAPH_OT_copy";
876         ot->description = "Copy selected keyframes to the copy/paste buffer";
877         
878         /* api callbacks */
879         ot->exec = graphkeys_copy_exec;
880         ot->poll = graphop_editable_keyframes_poll;
881         
882         /* flags */
883         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
884 }
885
886
887
888 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
889 {
890         bAnimContext ac;
891
892         const eKeyPasteOffset offset_mode = RNA_enum_get(op->ptr, "offset");
893         const eKeyMergeMode merge_mode = RNA_enum_get(op->ptr, "merge");
894         const bool flipped = RNA_boolean_get(op->ptr, "flipped");
895         
896         /* get editor data */
897         if (ANIM_animdata_get_context(C, &ac) == 0)
898                 return OPERATOR_CANCELLED;
899         
900         /* ac.reports by default will be the global reports list, which won't show warnings */
901         ac.reports = op->reports;
902
903         /* paste keyframes - non-zero return means an error occurred while trying to paste */
904         if (paste_graph_keys(&ac, offset_mode, merge_mode, flipped)) {
905                 return OPERATOR_CANCELLED;
906         }
907         
908         /* set notifier that keyframes have changed */
909         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
910         
911         return OPERATOR_FINISHED;
912 }
913  
914 void GRAPH_OT_paste(wmOperatorType *ot)
915 {
916         PropertyRNA *prop;
917         
918         /* identifiers */
919         ot->name = "Paste Keyframes";
920         ot->idname = "GRAPH_OT_paste";
921         ot->description = "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame";
922         
923         /* api callbacks */
924 //      ot->invoke = WM_operator_props_popup; // better wait for graph redo panel
925         ot->exec = graphkeys_paste_exec;
926         ot->poll = graphop_editable_keyframes_poll;
927         
928         /* flags */
929         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
930         
931         /* props */
932         RNA_def_enum(ot->srna, "offset", rna_enum_keyframe_paste_offset_items, KEYFRAME_PASTE_OFFSET_CFRA_START, "Offset", "Paste time offset of keys");
933         RNA_def_enum(ot->srna, "merge", rna_enum_keyframe_paste_merge_items, KEYFRAME_PASTE_MERGE_MIX, "Type", "Method of merging pasted keys and existing");
934         prop = RNA_def_boolean(ot->srna, "flipped", false, "Flipped", "Paste keyframes from mirrored bones if they exist");
935         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
936 }
937
938 /* ******************** Duplicate Keyframes Operator ************************* */
939
940 static void duplicate_graph_keys(bAnimContext *ac)
941 {
942         ListBase anim_data = {NULL, NULL};
943         bAnimListElem *ale;
944         int filter;
945         
946         /* filter data */
947         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
948         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
949         
950         /* loop through filtered data and delete selected keys */
951         for (ale = anim_data.first; ale; ale = ale->next) {
952                 duplicate_fcurve_keys((FCurve *)ale->key_data);
953
954                 ale->update |= ANIM_UPDATE_DEFAULT;
955         }
956
957         ANIM_animdata_update(ac, &anim_data);
958         ANIM_animdata_freelist(&anim_data);
959 }
960
961 /* ------------------- */
962
963 static int graphkeys_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
964 {
965         bAnimContext ac;
966         
967         /* get editor data */
968         if (ANIM_animdata_get_context(C, &ac) == 0)
969                 return OPERATOR_CANCELLED;
970                 
971         /* duplicate keyframes */
972         duplicate_graph_keys(&ac);
973         
974         /* set notifier that keyframes have changed */
975         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_ADDED, NULL);
976         
977         return OPERATOR_FINISHED;
978 }
979
980 void GRAPH_OT_duplicate(wmOperatorType *ot)
981 {
982         /* identifiers */
983         ot->name = "Duplicate Keyframes";
984         ot->idname = "GRAPH_OT_duplicate";
985         ot->description = "Make a copy of all selected keyframes";
986         
987         /* api callbacks */
988         ot->exec = graphkeys_duplicate_exec;
989         ot->poll = graphop_editable_keyframes_poll;
990         
991         /* flags */
992         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
993         
994         /* to give to transform */
995         RNA_def_enum(ot->srna, "mode", rna_enum_transform_mode_types, TFM_TRANSLATION, "Mode", "");
996 }
997
998 /* ******************** Delete Keyframes Operator ************************* */
999
1000 static bool delete_graph_keys(bAnimContext *ac)
1001 {
1002         ListBase anim_data = {NULL, NULL};
1003         bAnimListElem *ale;
1004         int filter;
1005         bool changed_final = false;
1006         
1007         /* filter data */
1008         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1009         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1010         
1011         /* loop through filtered data and delete selected keys */
1012         for (ale = anim_data.first; ale; ale = ale->next) {
1013                 FCurve *fcu = (FCurve *)ale->key_data;
1014                 AnimData *adt = ale->adt;
1015                 bool changed;
1016                 
1017                 /* delete selected keyframes only */
1018                 changed = delete_fcurve_keys(fcu);
1019
1020                 if (changed) {
1021                         ale->update |= ANIM_UPDATE_DEFAULT;
1022                         changed_final = true;
1023                 }
1024                 
1025                 /* Only delete curve too if it won't be doing anything anymore */
1026                 if ((fcu->totvert == 0) &&
1027                     (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0) &&
1028                     (fcu->driver == NULL))
1029                 {
1030                         ANIM_fcurve_delete_from_animdata(ac, adt, fcu);
1031                         ale->key_data = NULL;
1032                 }
1033         }
1034
1035         ANIM_animdata_update(ac, &anim_data);
1036         ANIM_animdata_freelist(&anim_data);
1037
1038         return changed_final;
1039 }
1040
1041 /* ------------------- */
1042
1043 static int graphkeys_delete_exec(bContext *C, wmOperator *UNUSED(op))
1044 {
1045         bAnimContext ac;
1046         
1047         /* get editor data */
1048         if (ANIM_animdata_get_context(C, &ac) == 0)
1049                 return OPERATOR_CANCELLED;
1050                 
1051         /* delete keyframes */
1052         if (!delete_graph_keys(&ac))
1053                 return OPERATOR_CANCELLED;
1054         
1055         /* set notifier that keyframes have changed */
1056         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_REMOVED, NULL);
1057         
1058         return OPERATOR_FINISHED;
1059 }
1060  
1061 void GRAPH_OT_delete(wmOperatorType *ot)
1062 {
1063         /* identifiers */
1064         ot->name = "Delete Keyframes";
1065         ot->idname = "GRAPH_OT_delete";
1066         ot->description = "Remove all selected keyframes";
1067         
1068         /* api callbacks */
1069         ot->invoke = WM_operator_confirm;
1070         ot->exec = graphkeys_delete_exec;
1071         ot->poll = graphop_editable_keyframes_poll;
1072         
1073         /* flags */
1074         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1075 }
1076
1077 /* ******************** Clean Keyframes Operator ************************* */
1078
1079 static void clean_graph_keys(bAnimContext *ac, float thresh, bool clean_chan)
1080 {       
1081         ListBase anim_data = {NULL, NULL};
1082         bAnimListElem *ale;
1083         int filter;
1084         
1085         /* filter data */
1086         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);
1087         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1088         
1089         /* loop through filtered data and clean curves */
1090         for (ale = anim_data.first; ale; ale = ale->next) {
1091                 clean_fcurve(ac, ale, thresh, clean_chan);
1092
1093                 ale->update |= ANIM_UPDATE_DEFAULT;
1094         }
1095
1096         ANIM_animdata_update(ac, &anim_data);
1097         ANIM_animdata_freelist(&anim_data);
1098 }
1099
1100 /* ------------------- */
1101
1102 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
1103 {
1104         bAnimContext ac;
1105         float thresh;
1106         bool clean_chan;
1107         
1108         /* get editor data */
1109         if (ANIM_animdata_get_context(C, &ac) == 0)
1110                 return OPERATOR_CANCELLED;
1111                 
1112         /* get cleaning threshold */
1113         thresh = RNA_float_get(op->ptr, "threshold");
1114         clean_chan = RNA_boolean_get(op->ptr, "channels");
1115         /* clean keyframes */
1116         clean_graph_keys(&ac, thresh, clean_chan);
1117         
1118         /* set notifier that keyframes have changed */
1119         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1120         
1121         return OPERATOR_FINISHED;
1122 }
1123  
1124 void GRAPH_OT_clean(wmOperatorType *ot)
1125 {
1126         /* identifiers */
1127         ot->name = "Clean Keyframes";
1128         ot->idname = "GRAPH_OT_clean";
1129         ot->description = "Simplify F-Curves by removing closely spaced keyframes";
1130         
1131         /* api callbacks */
1132         //ot->invoke =  // XXX we need that number popup for this! 
1133         ot->exec = graphkeys_clean_exec;
1134         ot->poll = graphop_editable_keyframes_poll;
1135         
1136         /* flags */
1137         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1138         
1139         /* properties */
1140         ot->prop = RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
1141         RNA_def_boolean(ot->srna, "channels", false, "Channels", "");
1142 }
1143
1144 /* ******************** Bake F-Curve Operator *********************** */
1145 /* This operator bakes the data of the selected F-Curves to F-Points */
1146
1147 /* Bake each F-Curve into a set of samples */
1148 static void bake_graph_curves(bAnimContext *ac, int start, int end)
1149 {       
1150         ListBase anim_data = {NULL, NULL};
1151         bAnimListElem *ale;
1152         int filter;
1153         
1154         /* filter data */
1155         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1156         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1157         
1158         /* loop through filtered data and add keys between selected keyframes on every frame  */
1159         for (ale = anim_data.first; ale; ale = ale->next) {
1160                 FCurve *fcu = (FCurve *)ale->key_data;
1161                 ChannelDriver *driver = fcu->driver;
1162                 
1163                 /* disable driver so that it don't muck up the sampling process */
1164                 fcu->driver = NULL;
1165                 
1166                 /* create samples */
1167                 fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
1168                 
1169                 /* restore driver */
1170                 fcu->driver = driver;
1171
1172                 ale->update |= ANIM_UPDATE_DEPS;
1173         }
1174
1175         ANIM_animdata_update(ac, &anim_data);
1176         ANIM_animdata_freelist(&anim_data);
1177 }
1178
1179 /* ------------------- */
1180
1181 static int graphkeys_bake_exec(bContext *C, wmOperator *UNUSED(op))
1182 {
1183         bAnimContext ac;
1184         Scene *scene = NULL;
1185         int start, end;
1186         
1187         /* get editor data */
1188         if (ANIM_animdata_get_context(C, &ac) == 0)
1189                 return OPERATOR_CANCELLED;
1190                 
1191         /* for now, init start/end from preview-range extents */
1192         // TODO: add properties for this 
1193         scene = ac.scene;
1194         start = PSFRA;
1195         end = PEFRA;
1196         
1197         /* bake keyframes */
1198         bake_graph_curves(&ac, start, end);
1199         
1200         /* set notifier that keyframes have changed */
1201         // NOTE: some distinction between order/number of keyframes and type should be made?
1202         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1203         
1204         return OPERATOR_FINISHED;
1205 }
1206  
1207 void GRAPH_OT_bake(wmOperatorType *ot)
1208 {
1209         /* identifiers */
1210         ot->name = "Bake Curve";
1211         ot->idname = "GRAPH_OT_bake";
1212         ot->description = "Bake selected F-Curves to a set of sampled points defining a similar curve";
1213         
1214         /* api callbacks */
1215         ot->invoke = WM_operator_confirm; // FIXME...
1216         ot->exec = graphkeys_bake_exec;
1217         ot->poll = graphop_selected_fcurve_poll; 
1218         
1219         /* flags */
1220         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1221         
1222         // todo: add props for start/end frames
1223 }
1224
1225 #ifdef WITH_AUDASPACE
1226
1227 /* ******************** Sound Bake F-Curve Operator *********************** */
1228 /* This operator bakes the given sound to the selected F-Curves */
1229
1230 /* ------------------- */
1231
1232 /* Custom data storage passed to the F-Sample-ing function,
1233  * which provides the necessary info for baking the sound
1234  */
1235 typedef struct tSoundBakeInfo {
1236         float *samples;
1237         int length;
1238         int cfra;
1239 } tSoundBakeInfo;
1240
1241 /* ------------------- */
1242
1243 /* Sampling callback used to determine the value from the sound to
1244  * save in the F-Curve at the specified frame
1245  */
1246 static float fcurve_samplingcb_sound(FCurve *UNUSED(fcu), void *data, float evaltime)
1247 {
1248         tSoundBakeInfo *sbi = (tSoundBakeInfo *)data;
1249
1250         int position = evaltime - sbi->cfra;
1251         if ((position < 0) || (position >= sbi->length))
1252                 return 0.0f;
1253
1254         return sbi->samples[position];
1255 }
1256
1257 /* ------------------- */
1258
1259 static int graphkeys_sound_bake_exec(bContext *C, wmOperator *op)
1260 {
1261         bAnimContext ac;
1262         ListBase anim_data = {NULL, NULL};
1263         bAnimListElem *ale;
1264         int filter;
1265
1266         tSoundBakeInfo sbi;
1267         Scene *scene = NULL;
1268         int start, end;
1269
1270         char path[FILE_MAX];
1271
1272         /* get editor data */
1273         if (ANIM_animdata_get_context(C, &ac) == 0)
1274                 return OPERATOR_CANCELLED;
1275
1276         RNA_string_get(op->ptr, "filepath", path);
1277
1278         if (!BLI_is_file(path)) {
1279                 BKE_reportf(op->reports, RPT_ERROR, "File not found '%s'", path);
1280                 return OPERATOR_CANCELLED;
1281         }
1282
1283         scene = ac.scene;    /* current scene */
1284
1285         /* store necessary data for the baking steps */
1286         sbi.samples = AUD_readSoundBuffer(path,
1287                                           RNA_float_get(op->ptr, "low"),
1288                                           RNA_float_get(op->ptr, "high"),
1289                                           RNA_float_get(op->ptr, "attack"),
1290                                           RNA_float_get(op->ptr, "release"),
1291                                           RNA_float_get(op->ptr, "threshold"),
1292                                           RNA_boolean_get(op->ptr, "use_accumulate"),
1293                                           RNA_boolean_get(op->ptr, "use_additive"),
1294                                           RNA_boolean_get(op->ptr, "use_square"),
1295                                           RNA_float_get(op->ptr, "sthreshold"),
1296                                           FPS, &sbi.length);
1297
1298         if (sbi.samples == NULL) {
1299                 BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
1300                 return OPERATOR_CANCELLED;
1301         }
1302
1303         /* determine extents of the baking */
1304         sbi.cfra = start = CFRA;
1305         end = CFRA + sbi.length - 1;
1306
1307         /* filter anim channels */
1308         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1309         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1310
1311         /* loop through all selected F-Curves, replacing its data with the sound samples */
1312         for (ale = anim_data.first; ale; ale = ale->next) {
1313                 FCurve *fcu = (FCurve *)ale->key_data;
1314                 
1315                 /* sample the sound */
1316                 fcurve_store_samples(fcu, &sbi, start, end, fcurve_samplingcb_sound);
1317
1318                 ale->update |= ANIM_UPDATE_DEFAULT;
1319         }
1320
1321         /* free sample data */
1322         free(sbi.samples);
1323
1324         /* validate keyframes after editing */
1325         ANIM_animdata_update(&ac, &anim_data);
1326         ANIM_animdata_freelist(&anim_data);
1327
1328         /* set notifier that 'keyframes' have changed */
1329         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1330
1331         return OPERATOR_FINISHED;
1332 }
1333
1334 #else //WITH_AUDASPACE
1335
1336 static int graphkeys_sound_bake_exec(bContext *UNUSED(C), wmOperator *op)
1337 {
1338         BKE_report(op->reports, RPT_ERROR, "Compiled without sound support");
1339
1340         return OPERATOR_CANCELLED;
1341 }
1342
1343 #endif //WITH_AUDASPACE
1344
1345 static int graphkeys_sound_bake_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1346 {
1347         bAnimContext ac;
1348
1349         /* verify editor data */
1350         if (ANIM_animdata_get_context(C, &ac) == 0)
1351                 return OPERATOR_CANCELLED;
1352
1353         return WM_operator_filesel(C, op, event);
1354 }
1355
1356 void GRAPH_OT_sound_bake(wmOperatorType *ot)
1357 {
1358         /* identifiers */
1359         ot->name = "Bake Sound to F-Curves";
1360         ot->idname = "GRAPH_OT_sound_bake";
1361         ot->description = "Bakes a sound wave to selected F-Curves";
1362
1363         /* api callbacks */
1364         ot->invoke = graphkeys_sound_bake_invoke;
1365         ot->exec = graphkeys_sound_bake_exec;
1366         ot->poll = graphop_selected_fcurve_poll;
1367
1368         /* flags */
1369         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1370
1371         /* properties */
1372         WM_operator_properties_filesel(
1373                 ot, FILE_TYPE_FOLDER | FILE_TYPE_SOUND | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_OPENFILE,
1374                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
1375         RNA_def_float(ot->srna, "low", 0.0f, 0.0, 100000.0, "Lowest frequency",
1376                       "Cutoff frequency of a high-pass filter that is applied to the audio data", 0.1, 1000.00);
1377         RNA_def_float(ot->srna, "high", 100000.0, 0.0, 100000.0, "Highest frequency",
1378                       "Cutoff frequency of a low-pass filter that is applied to the audio data", 0.1, 1000.00);
1379         RNA_def_float(ot->srna, "attack", 0.005, 0.0, 2.0, "Attack time",
1380                       "Value for the hull curve calculation that tells how fast the hull curve can rise "
1381                       "(the lower the value the steeper it can rise)", 0.01, 0.1);
1382         RNA_def_float(ot->srna, "release", 0.2, 0.0, 5.0, "Release time",
1383                       "Value for the hull curve calculation that tells how fast the hull curve can fall "
1384                       "(the lower the value the steeper it can fall)", 0.01, 0.2);
1385         RNA_def_float(ot->srna, "threshold", 0.0, 0.0, 1.0, "Threshold",
1386                       "Minimum amplitude value needed to influence the hull curve", 0.01, 0.1);
1387         RNA_def_boolean(ot->srna, "use_accumulate", 0, "Accumulate",
1388                         "Only the positive differences of the hull curve amplitudes are summarized to produce the output");
1389         RNA_def_boolean(ot->srna, "use_additive", 0, "Additive",
1390                         "The amplitudes of the hull curve are summarized (or, when Accumulate is enabled, "
1391                         "both positive and negative differences are accumulated)");
1392         RNA_def_boolean(ot->srna, "use_square", 0, "Square",
1393                         "The output is a square curve (negative values always result in -1, and positive ones in 1)");
1394         RNA_def_float(ot->srna, "sthreshold", 0.1, 0.0, 1.0, "Square Threshold",
1395                       "Square only: all values with an absolute amplitude lower than that result in 0", 0.01, 0.1);
1396 }
1397
1398 /* ******************** Sample Keyframes Operator *********************** */
1399 /* This operator 'bakes' the values of the curve into new keyframes between pairs
1400  * of selected keyframes. It is useful for creating keyframes for tweaking overlap.
1401  */
1402
1403 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
1404 static void sample_graph_keys(bAnimContext *ac)
1405 {       
1406         ListBase anim_data = {NULL, NULL};
1407         bAnimListElem *ale;
1408         int filter;
1409         
1410         /* filter data */
1411         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1412         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1413         
1414         /* loop through filtered data and add keys between selected keyframes on every frame  */
1415         for (ale = anim_data.first; ale; ale = ale->next) {
1416                 sample_fcurve((FCurve *)ale->key_data);
1417
1418                 ale->update |= ANIM_UPDATE_DEPS;
1419         }
1420
1421         ANIM_animdata_update(ac, &anim_data);
1422         ANIM_animdata_freelist(&anim_data);
1423 }
1424
1425 /* ------------------- */
1426
1427 static int graphkeys_sample_exec(bContext *C, wmOperator *UNUSED(op))
1428 {
1429         bAnimContext ac;
1430         
1431         /* get editor data */
1432         if (ANIM_animdata_get_context(C, &ac) == 0)
1433                 return OPERATOR_CANCELLED;
1434         
1435         /* sample keyframes */
1436         sample_graph_keys(&ac);
1437         
1438         /* set notifier that keyframes have changed */
1439         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1440         
1441         return OPERATOR_FINISHED;
1442 }
1443  
1444 void GRAPH_OT_sample(wmOperatorType *ot)
1445 {
1446         /* identifiers */
1447         ot->name = "Sample Keyframes";
1448         ot->idname = "GRAPH_OT_sample";
1449         ot->description = "Add keyframes on every frame between the selected keyframes";
1450         
1451         /* api callbacks */
1452         ot->exec = graphkeys_sample_exec;
1453         ot->poll = graphop_editable_keyframes_poll;
1454         
1455         /* flags */
1456         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1457 }
1458
1459
1460 /* ************************************************************************** */
1461 /* SETTINGS STUFF */
1462
1463 /* ******************** Set Extrapolation-Type Operator *********************** */
1464
1465 /* defines for make/clear cyclic extrapolation tools */
1466 #define MAKE_CYCLIC_EXPO    -1
1467 #define CLEAR_CYCLIC_EXPO   -2
1468
1469 /* defines for set extrapolation-type for selected keyframes tool */
1470 static const EnumPropertyItem prop_graphkeys_expo_types[] = {
1471         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", "Values on endpoint keyframes are held"},
1472         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", "Straight-line slope of end segments are extended past the endpoint keyframes"},
1473         
1474         {MAKE_CYCLIC_EXPO, "MAKE_CYCLIC", 0, "Make Cyclic (F-Modifier)", "Add Cycles F-Modifier if one doesn't exist already"},
1475         {CLEAR_CYCLIC_EXPO, "CLEAR_CYCLIC", 0, "Clear Cyclic (F-Modifier)", "Remove Cycles F-Modifier if not needed anymore"},
1476         {0, NULL, 0, NULL, NULL}
1477 };
1478
1479 /* this function is responsible for setting extrapolation mode for keyframes */
1480 static void setexpo_graph_keys(bAnimContext *ac, short mode) 
1481 {
1482         ListBase anim_data = {NULL, NULL};
1483         bAnimListElem *ale;
1484         int filter;
1485         
1486         /* filter data */
1487         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1488         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1489         
1490         /* loop through setting mode per F-Curve */
1491         for (ale = anim_data.first; ale; ale = ale->next) {
1492                 FCurve *fcu = (FCurve *)ale->data;
1493                 
1494                 if (mode >= 0) {
1495                         /* just set mode setting */
1496                         fcu->extend = mode;
1497
1498                         ale->update |= ANIM_UPDATE_HANDLES;
1499                 }
1500                 else {
1501                         /* shortcuts for managing Cycles F-Modifiers to make it easier to toggle cyclic animation 
1502                          * without having to go through FModifier UI in Graph Editor to do so
1503                          */
1504                         if (mode == MAKE_CYCLIC_EXPO) {
1505                                 /* only add if one doesn't exist */
1506                                 if (list_has_suitable_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, -1) == 0) {
1507                                         // TODO: add some more preset versions which set different extrapolation options?
1508                                         add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, fcu);
1509                                 }
1510                         }
1511                         else if (mode == CLEAR_CYCLIC_EXPO) {
1512                                 /* remove all the modifiers fitting this description */
1513                                 FModifier *fcm, *fcn = NULL;
1514                                 
1515                                 for (fcm = fcu->modifiers.first; fcm; fcm = fcn) {
1516                                         fcn = fcm->next;
1517                                         
1518                                         if (fcm->type == FMODIFIER_TYPE_CYCLES)
1519                                                 remove_fmodifier(&fcu->modifiers, fcm);
1520                                 }
1521                         }
1522                 }
1523
1524                 ale->update |= ANIM_UPDATE_DEPS;
1525         }
1526
1527         ANIM_animdata_update(ac, &anim_data);
1528         ANIM_animdata_freelist(&anim_data);
1529 }
1530
1531 /* ------------------- */
1532
1533 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
1534 {
1535         bAnimContext ac;
1536         short mode;
1537         
1538         /* get editor data */
1539         if (ANIM_animdata_get_context(C, &ac) == 0)
1540                 return OPERATOR_CANCELLED;
1541                 
1542         /* get handle setting mode */
1543         mode = RNA_enum_get(op->ptr, "type");
1544         
1545         /* set handle type */
1546         setexpo_graph_keys(&ac, mode);
1547         
1548         /* set notifier that keyframe properties have changed */
1549         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1550         
1551         return OPERATOR_FINISHED;
1552 }
1553  
1554 void GRAPH_OT_extrapolation_type(wmOperatorType *ot)
1555 {
1556         /* identifiers */
1557         ot->name = "Set Keyframe Extrapolation";
1558         ot->idname = "GRAPH_OT_extrapolation_type";
1559         ot->description = "Set extrapolation mode for selected F-Curves";
1560         
1561         /* api callbacks */
1562         ot->invoke = WM_menu_invoke;
1563         ot->exec = graphkeys_expo_exec;
1564         ot->poll = graphop_editable_keyframes_poll;
1565         
1566         /* flags */
1567         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1568         
1569         /* id-props */
1570         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
1571 }
1572
1573 /* ******************** Set Interpolation-Type Operator *********************** */
1574
1575 /* this function is responsible for setting interpolation mode for keyframes */
1576 static void setipo_graph_keys(bAnimContext *ac, short mode) 
1577 {
1578         ListBase anim_data = {NULL, NULL};
1579         bAnimListElem *ale;
1580         int filter;
1581         KeyframeEditFunc set_cb = ANIM_editkeyframes_ipo(mode);
1582         
1583         /* filter data */
1584         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1585         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1586         
1587         /* loop through setting BezTriple interpolation
1588          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1589          */
1590         for (ale = anim_data.first; ale; ale = ale->next) {
1591                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1592
1593                 ale->update |= ANIM_UPDATE_DEFAULT_NOHANDLES;
1594         }
1595
1596         ANIM_animdata_update(ac, &anim_data);
1597         ANIM_animdata_freelist(&anim_data);
1598 }
1599
1600 /* ------------------- */
1601
1602 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
1603 {
1604         bAnimContext ac;
1605         short mode;
1606         
1607         /* get editor data */
1608         if (ANIM_animdata_get_context(C, &ac) == 0)
1609                 return OPERATOR_CANCELLED;
1610                 
1611         /* get handle setting mode */
1612         mode = RNA_enum_get(op->ptr, "type");
1613         
1614         /* set handle type */
1615         setipo_graph_keys(&ac, mode);
1616         
1617         /* set notifier that keyframe properties have changed */
1618         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1619         
1620         return OPERATOR_FINISHED;
1621 }
1622  
1623 void GRAPH_OT_interpolation_type(wmOperatorType *ot)
1624 {
1625         /* identifiers */
1626         ot->name = "Set Keyframe Interpolation";
1627         ot->idname = "GRAPH_OT_interpolation_type";
1628         ot->description = "Set interpolation mode for the F-Curve segments starting from the selected keyframes";
1629         
1630         /* api callbacks */
1631         ot->invoke = WM_menu_invoke;
1632         ot->exec = graphkeys_ipo_exec;
1633         ot->poll = graphop_editable_keyframes_poll;
1634         
1635         /* flags */
1636         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1637         
1638         /* id-props */
1639         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_beztriple_interpolation_mode_items, 0, "Type", "");
1640 }
1641
1642 /* ******************** Set Easing Operator *********************** */
1643
1644 static void seteasing_graph_keys(bAnimContext *ac, short mode)
1645 {
1646         ListBase anim_data = {NULL, NULL};
1647         bAnimListElem *ale;
1648         int filter;
1649         KeyframeEditFunc set_cb = ANIM_editkeyframes_easing(mode);
1650         
1651         /* filter data */
1652         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1653         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1654         
1655         /* loop through setting BezTriple easing
1656          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1657          */
1658         for (ale = anim_data.first; ale; ale = ale->next) {
1659                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1660
1661                 ale->update |= ANIM_UPDATE_DEFAULT_NOHANDLES;
1662         }
1663
1664         ANIM_animdata_update(ac, &anim_data);
1665         ANIM_animdata_freelist(&anim_data);
1666 }
1667
1668 static int graphkeys_easing_exec(bContext *C, wmOperator *op)
1669 {
1670         bAnimContext ac;
1671         short mode;
1672         
1673         /* get editor data */
1674         if (ANIM_animdata_get_context(C, &ac) == 0)
1675                 return OPERATOR_CANCELLED;
1676         
1677         /* get handle setting mode */
1678         mode = RNA_enum_get(op->ptr, "type");
1679         
1680         /* set handle type */
1681         seteasing_graph_keys(&ac, mode);
1682         
1683         /* set notifier that keyframe properties have changed */
1684         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1685         
1686         return OPERATOR_FINISHED;
1687 }
1688
1689 void GRAPH_OT_easing_type(wmOperatorType *ot)
1690 {
1691         /* identifiers */
1692         ot->name = "Set Keyframe Easing Type";
1693         ot->idname = "GRAPH_OT_easing_type";
1694         ot->description = "Set easing type for the F-Curve segments starting from the selected keyframes";
1695         
1696         /* api callbacks */
1697         ot->invoke = WM_menu_invoke;
1698         ot->exec = graphkeys_easing_exec;
1699         ot->poll = graphop_editable_keyframes_poll;
1700         
1701         /* flags */
1702         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1703         
1704         /* id-props */
1705         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_beztriple_interpolation_easing_items, 0, "Type", "");
1706 }
1707
1708 /* ******************** Set Handle-Type Operator *********************** */
1709
1710 /* this function is responsible for setting handle-type of selected keyframes */
1711 static void sethandles_graph_keys(bAnimContext *ac, short mode) 
1712 {
1713         ListBase anim_data = {NULL, NULL};
1714         bAnimListElem *ale;
1715         int filter;
1716         
1717         KeyframeEditFunc edit_cb = ANIM_editkeyframes_handles(mode);
1718         KeyframeEditFunc sel_cb = ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
1719         
1720         /* filter data */
1721         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1722         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1723         
1724         /* loop through setting flags for handles 
1725          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1726          */
1727         for (ale = anim_data.first; ale; ale = ale->next) {
1728                 FCurve *fcu = (FCurve *)ale->key_data;
1729                 
1730                 /* any selected keyframes for editing? */
1731                 if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, sel_cb, NULL)) {
1732                         /* change type of selected handles */
1733                         ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, edit_cb, calchandles_fcurve);
1734
1735                         ale->update |= ANIM_UPDATE_DEFAULT;
1736                 }
1737         }
1738
1739         ANIM_animdata_update(ac, &anim_data);
1740         ANIM_animdata_freelist(&anim_data);
1741 }
1742 /* ------------------- */
1743
1744 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
1745 {
1746         bAnimContext ac;
1747         short mode;
1748         
1749         /* get editor data */
1750         if (ANIM_animdata_get_context(C, &ac) == 0)
1751                 return OPERATOR_CANCELLED;
1752                 
1753         /* get handle setting mode */
1754         mode = RNA_enum_get(op->ptr, "type");
1755         
1756         /* set handle type */
1757         sethandles_graph_keys(&ac, mode);
1758         
1759         /* set notifier that keyframe properties have changed */
1760         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1761         
1762         return OPERATOR_FINISHED;
1763 }
1764  
1765 void GRAPH_OT_handle_type(wmOperatorType *ot)
1766 {
1767         /* identifiers */
1768         ot->name = "Set Keyframe Handle Type";
1769         ot->idname = "GRAPH_OT_handle_type";
1770         ot->description = "Set type of handle for selected keyframes";
1771         
1772         /* api callbacks */
1773         ot->invoke = WM_menu_invoke;
1774         ot->exec = graphkeys_handletype_exec;
1775         ot->poll = graphop_editable_keyframes_poll;
1776         
1777         /* flags */
1778         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1779         
1780         /* id-props */
1781         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_keyframe_handle_type_items, 0, "Type", "");
1782 }
1783
1784 /* ************************************************************************** */
1785 /* TRANSFORM STUFF */
1786
1787 /* ***************** 'Euler Filter' Operator **************************** */
1788 /* Euler filter tools (as seen in Maya), are necessary for working with 'baked'
1789  * rotation curves (with Euler rotations). The main purpose of such tools is to
1790  * resolve any discontinuities that may arise in the curves due to the clamping
1791  * of values to -180 degrees to 180 degrees.
1792  */
1793
1794 /* set of three euler-rotation F-Curves */
1795 typedef struct tEulerFilter {
1796         struct tEulerFilter *next, *prev;
1797         
1798         ID *id;                         /* ID-block which owns the channels */
1799         FCurve *(fcurves[3]);           /* 3 Pointers to F-Curves */
1800         const char *rna_path;           /* Pointer to one of the RNA Path's used by one of the F-Curves */
1801 } tEulerFilter;
1802  
1803 static int graphkeys_euler_filter_exec(bContext *C, wmOperator *op)
1804 {
1805         bAnimContext ac;
1806         
1807         ListBase anim_data = {NULL, NULL};
1808         bAnimListElem *ale;
1809         int filter;
1810         
1811         ListBase eulers = {NULL, NULL};
1812         tEulerFilter *euf = NULL;
1813         int groups = 0, failed = 0;
1814         
1815         /* get editor data */
1816         if (ANIM_animdata_get_context(C, &ac) == 0)
1817                 return OPERATOR_CANCELLED;
1818                 
1819         /* The process is done in two passes:
1820          *   1) Sets of three related rotation curves are identified from the selected channels,
1821          *              and are stored as a single 'operation unit' for the next step
1822          *       2) Each set of three F-Curves is processed for each keyframe, with the values being
1823          *      processed as necessary
1824          */
1825          
1826         /* step 1: extract only the rotation f-curves */
1827         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1828         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1829         
1830         for (ale = anim_data.first; ale; ale = ale->next) {
1831                 FCurve *fcu = (FCurve *)ale->data;
1832                 
1833                 /* check if this is an appropriate F-Curve 
1834                  *      - only rotation curves
1835                  *      - for pchan curves, make sure we're only using the euler curves
1836                  */
1837                 if (strstr(fcu->rna_path, "rotation_euler") == NULL)
1838                         continue;
1839                 else if (ELEM(fcu->array_index, 0, 1, 2) == 0) {
1840                         BKE_reportf(op->reports, RPT_WARNING,
1841                                     "Euler Rotation F-Curve has invalid index (ID='%s', Path='%s', Index=%d)",
1842                                     (ale->id) ? ale->id->name : TIP_("<No ID>"), fcu->rna_path, fcu->array_index);
1843                         continue;
1844                 }
1845                 
1846                 /* optimization: assume that xyz curves will always be stored consecutively,
1847                  * so if the paths or the ID's don't match up, then a curve needs to be added 
1848                  * to a new group
1849                  */
1850                 if ((euf) && (euf->id == ale->id) && (STREQ(euf->rna_path, fcu->rna_path))) {
1851                         /* this should be fine to add to the existing group then */
1852                         euf->fcurves[fcu->array_index] = fcu;
1853                 }
1854                 else {
1855                         /* just add to a new block */
1856                         euf = MEM_callocN(sizeof(tEulerFilter), "tEulerFilter");
1857                         BLI_addtail(&eulers, euf);
1858                         groups++;
1859                         
1860                         euf->id = ale->id;
1861                         euf->rna_path = fcu->rna_path; /* this should be safe, since we're only using it for a short time */
1862                         euf->fcurves[fcu->array_index] = fcu;
1863                 }
1864
1865                 ale->update |= ANIM_UPDATE_DEFAULT;
1866         }
1867
1868         if (groups == 0) {
1869                 ANIM_animdata_freelist(&anim_data);
1870                 BKE_report(op->reports, RPT_WARNING, "No Euler Rotation F-Curves to fix up");
1871                 return OPERATOR_CANCELLED;
1872         }
1873         
1874         /* step 2: go through each set of curves, processing the values at each keyframe 
1875          *      - it is assumed that there must be a full set of keyframes at each keyframe position
1876          */
1877         for (euf = eulers.first; euf; euf = euf->next) {
1878                 int f;
1879                 
1880                 /* sanity check: ensure that there are enough F-Curves to work on in this group */
1881                 /* TODO: also enforce assumption that there be a full set of keyframes at each position by ensuring that totvert counts are same? */
1882                 if (ELEM(NULL, euf->fcurves[0], euf->fcurves[1], euf->fcurves[2])) {
1883                         /* report which components are missing */
1884                         BKE_reportf(op->reports, RPT_WARNING,
1885                                     "Missing %s%s%s component(s) of euler rotation for ID='%s' and RNA-Path='%s'",
1886                                     (euf->fcurves[0] == NULL) ? "X" : "",
1887                                     (euf->fcurves[1] == NULL) ? "Y" : "",
1888                                     (euf->fcurves[2] == NULL) ? "Z" : "",
1889                                     euf->id->name, euf->rna_path);
1890                                 
1891                         /* keep track of number of failed sets, and carry on to next group */
1892                         failed++;
1893                         continue;
1894                 }
1895
1896                 /* simple method: just treat any difference between keys of greater than 180 degrees as being a flip */
1897                 /* FIXME: there are more complicated methods that will be needed to fix more cases than just some */
1898                 for (f = 0; f < 3; f++) {
1899                         FCurve *fcu = euf->fcurves[f];
1900                         BezTriple *bezt, *prev;
1901                         unsigned int i;
1902                         
1903                         /* skip if not enough vets to do a decent analysis of... */
1904                         if (fcu->totvert <= 2)
1905                                 continue;
1906                         
1907                         /* prev follows bezt, bezt = "current" point to be fixed */
1908                         /* our method depends on determining a "difference" from the previous vert */
1909                         for (i = 1, prev = fcu->bezt, bezt = fcu->bezt + 1; i < fcu->totvert; i++, prev = bezt++) {
1910                                 const float sign = (prev->vec[1][1] > bezt->vec[1][1]) ? 1.0f : -1.0f;
1911                                 
1912                                 /* > 180 degree flip? */
1913                                 if ((sign * (prev->vec[1][1] - bezt->vec[1][1])) >= (float)M_PI) {
1914                                         /* 360 degrees to add/subtract frame value until difference is acceptably small that there's no more flip */
1915                                         const float fac = sign * 2.0f * (float)M_PI;
1916                                         
1917                                         while ((sign * (prev->vec[1][1] - bezt->vec[1][1])) >= (float)M_PI) {
1918                                                 bezt->vec[0][1] += fac;
1919                                                 bezt->vec[1][1] += fac;
1920                                                 bezt->vec[2][1] += fac;
1921                                         }
1922                                 }
1923                         }
1924                 }
1925         }
1926         BLI_freelistN(&eulers);
1927         
1928         ANIM_animdata_update(&ac, &anim_data);
1929         ANIM_animdata_freelist(&anim_data);
1930
1931         /* updates + finishing warnings */
1932         if (failed == groups) {
1933                 BKE_report(op->reports, RPT_ERROR, 
1934                            "No Euler Rotations could be corrected, ensure each rotation has keys for all components, "
1935                            "and that F-Curves for these are in consecutive XYZ order and selected");
1936                 return OPERATOR_CANCELLED;
1937         }
1938         else {
1939                 if (failed) {
1940                         BKE_report(op->reports, RPT_ERROR,
1941                                    "Some Euler Rotations could not be corrected due to missing/unselected/out-of-order F-Curves, "
1942                                    "ensure each rotation has keys for all components, and that F-Curves for these are in "
1943                                    "consecutive XYZ order and selected");
1944                 }
1945                 
1946                 /* set notifier that keyframes have changed */
1947                 WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1948                 
1949                 /* done at last */
1950                 return OPERATOR_FINISHED;
1951         }
1952 }
1953  
1954 void GRAPH_OT_euler_filter(wmOperatorType *ot)
1955 {
1956         /* identifiers */
1957         ot->name = "Euler Discontinuity Filter";
1958         ot->idname = "GRAPH_OT_euler_filter";
1959         ot->description = "Fix large jumps and flips in the selected "
1960                           "Euler Rotation F-Curves arising from rotation "
1961                           "values being clipped when baking physics";
1962         
1963         /* api callbacks */
1964         ot->exec = graphkeys_euler_filter_exec;
1965         ot->poll = graphop_editable_keyframes_poll;
1966         
1967         /* flags */
1968         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1969 }
1970
1971 /* ***************** Jump to Selected Frames Operator *********************** */
1972
1973 static int graphkeys_framejump_poll(bContext *C)
1974 {
1975         /* prevent changes during render */
1976         if (G.is_rendering)
1977                 return 0;
1978
1979         return graphop_visible_keyframes_poll(C);
1980 }
1981
1982 /* snap current-frame indicator to 'average time' of selected keyframe */
1983 static int graphkeys_framejump_exec(bContext *C, wmOperator *UNUSED(op))
1984 {
1985         bAnimContext ac;
1986         ListBase anim_data = {NULL, NULL};
1987         bAnimListElem *ale;
1988         int filter;
1989         KeyframeEditData ked;
1990         
1991         /* get editor data */
1992         if (ANIM_animdata_get_context(C, &ac) == 0)
1993                 return OPERATOR_CANCELLED;
1994         
1995         /* init edit data */
1996         memset(&ked, 0, sizeof(KeyframeEditData));
1997         
1998         /* loop over action data, averaging values */
1999         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
2000         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2001         
2002         for (ale = anim_data.first; ale; ale = ale->next) {
2003                 AnimData *adt = ANIM_nla_mapping_get(&ac, ale);
2004                 short mapping_flag = ANIM_get_normalization_flags(&ac);
2005                 KeyframeEditData current_ked;
2006                 float offset;
2007                 float unit_scale = ANIM_unit_mapping_get_factor(ac.scene, ale->id, ale->key_data, mapping_flag | ANIM_UNITCONV_ONLYKEYS, &offset);
2008
2009                 memset(&current_ked, 0, sizeof(current_ked));
2010
2011                 if (adt) {
2012                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
2013                         ANIM_fcurve_keyframes_loop(&current_ked, ale->key_data, NULL, bezt_calc_average, NULL);
2014                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1); 
2015                 }
2016                 else
2017                         ANIM_fcurve_keyframes_loop(&current_ked, ale->key_data, NULL, bezt_calc_average, NULL);
2018
2019                 ked.f1 += current_ked.f1;
2020                 ked.i1 += current_ked.i1;
2021                 ked.f2 += (current_ked.f2 + offset) * unit_scale;
2022                 ked.i2 += current_ked.i2;
2023         }
2024         
2025         ANIM_animdata_freelist(&anim_data);
2026         
2027         /* set the new current frame and cursor values, based on the average time and value */
2028         if (ked.i1) {
2029                 SpaceIpo *sipo = (SpaceIpo *)ac.sl;
2030                 Scene *scene = ac.scene;
2031                 
2032                 /* take the average values, rounding to the nearest int as necessary for int results */
2033                 if (sipo->mode == SIPO_MODE_DRIVERS) {
2034                         /* Drivers Mode - Affects cursor (float) */
2035                         sipo->cursorTime = ked.f1 / (float)ked.i1;
2036                         sipo->cursorVal  = ked.f2 / (float)ked.i1;
2037                 }
2038                 else {
2039                         /* Animation Mode - Affects current frame (int) */
2040                         CFRA = round_fl_to_int(ked.f1 / ked.i1);
2041                         SUBFRA = 0.f;
2042                         sipo->cursorVal = ked.f2 / (float)ked.i1;
2043                 }
2044         }
2045         
2046         /* set notifier that things have changed */
2047         WM_event_add_notifier(C, NC_SCENE | ND_FRAME, ac.scene);
2048         
2049         return OPERATOR_FINISHED;
2050 }
2051
2052 void GRAPH_OT_frame_jump(wmOperatorType *ot)
2053 {
2054         /* identifiers */
2055         ot->name = "Jump to Keyframes";
2056         ot->idname = "GRAPH_OT_frame_jump";
2057         ot->description = "Place the cursor on the midpoint of selected keyframes";
2058         
2059         /* api callbacks */
2060         ot->exec = graphkeys_framejump_exec;
2061         ot->poll = graphkeys_framejump_poll;
2062         
2063         /* flags */
2064         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2065 }
2066
2067 /* ******************** Snap Keyframes Operator *********************** */
2068
2069 /* defines for snap keyframes tool */
2070 static const EnumPropertyItem prop_graphkeys_snap_types[] = {
2071         {GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current Frame",
2072          "Snap selected keyframes to the current frame"},
2073         {GRAPHKEYS_SNAP_VALUE, "VALUE", 0, "Cursor Value",
2074          "Set values of selected keyframes to the cursor value (Y/Horizontal component)"},
2075         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame",
2076          "Snap selected keyframes to the nearest (whole) frame (use to fix accidental sub-frame offsets)"},
2077         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second",
2078          "Snap selected keyframes to the nearest second"},
2079         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker",
2080          "Snap selected keyframes to the nearest marker"},
2081         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles",
2082          "Flatten handles for a smoother transition"},
2083         {0, NULL, 0, NULL, NULL}
2084 };
2085
2086 /* this function is responsible for snapping keyframes to frame-times */
2087 static void snap_graph_keys(bAnimContext *ac, short mode) 
2088 {
2089         ListBase anim_data = {NULL, NULL};
2090         bAnimListElem *ale;
2091         int filter;
2092         
2093         SpaceIpo *sipo = (SpaceIpo *)ac->sl;
2094         KeyframeEditData ked;
2095         KeyframeEditFunc edit_cb;
2096         float cursor_value = 0.0f;
2097         
2098         /* filter data */
2099         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2100         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
2101         
2102         /* init custom data for iterating over keyframes */
2103         memset(&ked, 0, sizeof(KeyframeEditData)); 
2104         ked.scene = ac->scene;
2105         if (mode == GRAPHKEYS_SNAP_NEAREST_MARKER) {
2106                 ked.list.first = (ac->markers) ? ac->markers->first : NULL;
2107                 ked.list.last = (ac->markers) ? ac->markers->last : NULL;
2108         }
2109         else if (mode == GRAPHKEYS_SNAP_VALUE) {
2110                 cursor_value = (sipo) ? sipo->cursorVal : 0.0f;
2111         }
2112         else if (mode == GRAPHKEYS_SNAP_CFRA) {
2113                 /* In drivers mode, use the cursor value instead
2114                  * (We need to use a different callback for that though)
2115                  */
2116                 if (sipo->mode == SIPO_MODE_DRIVERS) {
2117                         ked.f1 = sipo->cursorTime;
2118                         mode = SNAP_KEYS_TIME;
2119                 }
2120         }
2121         
2122         /* get beztriple editing callbacks */
2123         edit_cb = ANIM_editkeyframes_snap(mode);
2124         
2125         /* snap keyframes */
2126         for (ale = anim_data.first; ale; ale = ale->next) {
2127                 AnimData *adt = ANIM_nla_mapping_get(ac, ale);
2128                 
2129                 /* normalise cursor value (for normalised F-Curves display) */
2130                 if (mode == GRAPHKEYS_SNAP_VALUE) {
2131                         short mapping_flag = ANIM_get_normalization_flags(ac);
2132                         float offset;
2133                         float unit_scale = ANIM_unit_mapping_get_factor(ac->scene, ale->id, ale->key_data, mapping_flag, &offset);
2134                         
2135                         ked.f1 = (cursor_value / unit_scale) - offset;
2136                 }
2137                 
2138                 /* perform snapping */
2139                 if (adt) {
2140                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 0); 
2141                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
2142                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 0);
2143                 }
2144                 else 
2145                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
2146                 
2147                 ale->update |= ANIM_UPDATE_DEFAULT;
2148         }
2149
2150         ANIM_animdata_update(ac, &anim_data);
2151         ANIM_animdata_freelist(&anim_data);
2152 }
2153
2154 /* ------------------- */
2155
2156 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
2157 {
2158         bAnimContext ac;
2159         short mode;
2160         
2161         /* get editor data */
2162         if (ANIM_animdata_get_context(C, &ac) == 0)
2163                 return OPERATOR_CANCELLED;
2164                 
2165         /* get snapping mode */
2166         mode = RNA_enum_get(op->ptr, "type");
2167         
2168         /* snap keyframes */
2169         snap_graph_keys(&ac, mode);
2170         
2171         /* set notifier that keyframes have changed */
2172         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
2173         
2174         return OPERATOR_FINISHED;
2175 }
2176  
2177 void GRAPH_OT_snap(wmOperatorType *ot)
2178 {
2179         /* identifiers */
2180         ot->name = "Snap Keys";
2181         ot->idname = "GRAPH_OT_snap";
2182         ot->description = "Snap selected keyframes to the chosen times/values";
2183         
2184         /* api callbacks */
2185         ot->invoke = WM_menu_invoke;
2186         ot->exec = graphkeys_snap_exec;
2187         ot->poll = graphop_editable_keyframes_poll;
2188         
2189         /* flags */
2190         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2191         
2192         /* id-props */
2193         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
2194 }
2195
2196 /* ******************** Mirror Keyframes Operator *********************** */
2197
2198 /* defines for mirror keyframes tool */
2199 static const EnumPropertyItem prop_graphkeys_mirror_types[] = {
2200         {GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current Frame",
2201          "Flip times of selected keyframes using the current frame as the mirror line"},
2202         {GRAPHKEYS_MIRROR_VALUE, "VALUE", 0, "By Values over Cursor Value",
2203          "Flip values of selected keyframes using the cursor value (Y/Horizontal component) as the mirror line"},
2204         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "By Times over Time=0",
2205          "Flip times of selected keyframes, effectively reversing the order they appear in"},
2206         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0",
2207          "Flip values of selected keyframes (i.e. negative values become positive, and vice versa)"},
2208         {GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker",
2209          "Flip times of selected keyframes using the first selected marker as the reference point"},
2210         {0, NULL, 0, NULL, NULL}
2211 };
2212
2213 /* this function is responsible for mirroring keyframes */
2214 static void mirror_graph_keys(bAnimContext *ac, short mode) 
2215 {
2216         ListBase anim_data = {NULL, NULL};
2217         bAnimListElem *ale;
2218         int filter;
2219         
2220         SpaceIpo *sipo = (SpaceIpo *)ac->sl;
2221         KeyframeEditData ked;
2222         KeyframeEditFunc edit_cb;
2223         float cursor_value = 0.0f;
2224
2225         /* init custom data for looping over keyframes */
2226         memset(&ked, 0, sizeof(KeyframeEditData)); 
2227         ked.scene = ac->scene;
2228         
2229         /* store mode-specific custom data... */
2230         if (mode == GRAPHKEYS_MIRROR_MARKER) {
2231                 TimeMarker *marker = NULL;
2232                 
2233                 /* find first selected marker */
2234                 marker = ED_markers_get_first_selected(ac->markers);
2235                 
2236                 /* store marker's time (if available) */
2237                 if (marker)
2238                         ked.f1 = (float)marker->frame;
2239                 else
2240                         return;
2241         }
2242         else if (mode == GRAPHKEYS_MIRROR_VALUE) {
2243                 cursor_value = (sipo) ? sipo->cursorVal : 0.0f;
2244         }
2245         else if (mode == GRAPHKEYS_MIRROR_CFRA) {
2246                 /* In drivers mode, use the cursor value instead
2247                  * (We need to use a different callback for that though)
2248                  */
2249                 if (sipo->mode == SIPO_MODE_DRIVERS) {
2250                         ked.f1 = sipo->cursorTime;
2251                         mode = MIRROR_KEYS_TIME;
2252                 }
2253         }
2254         
2255         /* get beztriple editing callbacks */
2256         edit_cb = ANIM_editkeyframes_mirror(mode);
2257         
2258         /* filter data */
2259         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2260         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
2261         
2262         /* mirror keyframes */
2263         for (ale = anim_data.first; ale; ale = ale->next) {
2264                 AnimData *adt = ANIM_nla_mapping_get(ac, ale);
2265                 
2266                 /* apply unit corrections */
2267                 if (mode == GRAPHKEYS_MIRROR_VALUE) {
2268                         short mapping_flag = ANIM_get_normalization_flags(ac);
2269                         float offset;
2270                         float unit_scale = ANIM_unit_mapping_get_factor(ac->scene, ale->id, ale->key_data, mapping_flag | ANIM_UNITCONV_ONLYKEYS, &offset);
2271                         
2272                         ked.f1 = (cursor_value + offset) * unit_scale;
2273                 }
2274                 
2275                 /* perform actual mirroring */
2276                 if (adt) {
2277                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 0); 
2278                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
2279                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 0);
2280                 }
2281                 else 
2282                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
2283                 
2284                 ale->update |= ANIM_UPDATE_DEFAULT;
2285         }
2286
2287         ANIM_animdata_update(ac, &anim_data);
2288         ANIM_animdata_freelist(&anim_data);
2289 }
2290
2291 /* ------------------- */
2292
2293 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
2294 {
2295         bAnimContext ac;
2296         short mode;
2297         
2298         /* get editor data */
2299         if (ANIM_animdata_get_context(C, &ac) == 0)
2300                 return OPERATOR_CANCELLED;
2301                 
2302         /* get mirroring mode */
2303         mode = RNA_enum_get(op->ptr, "type");
2304         
2305         /* mirror keyframes */
2306         mirror_graph_keys(&ac, mode);
2307         
2308         /* set notifier that keyframes have changed */
2309         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
2310         
2311         return OPERATOR_FINISHED;
2312 }
2313  
2314 void GRAPH_OT_mirror(wmOperatorType *ot)
2315 {
2316         /* identifiers */
2317         ot->name = "Mirror Keys";
2318         ot->idname = "GRAPH_OT_mirror";
2319         ot->description = "Flip selected keyframes over the selected mirror line";
2320         
2321         /* api callbacks */
2322         ot->invoke = WM_menu_invoke;
2323         ot->exec = graphkeys_mirror_exec;
2324         ot->poll = graphop_editable_keyframes_poll;
2325         
2326         /* flags */
2327         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2328         
2329         /* id-props */
2330         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
2331 }
2332
2333 /* ******************** Smooth Keyframes Operator *********************** */
2334
2335 static int graphkeys_smooth_exec(bContext *C, wmOperator *UNUSED(op))
2336 {
2337         bAnimContext ac;
2338         ListBase anim_data = {NULL, NULL};
2339         bAnimListElem *ale;
2340         int filter;
2341         
2342         /* get editor data */
2343         if (ANIM_animdata_get_context(C, &ac) == 0)
2344                 return OPERATOR_CANCELLED;
2345         
2346         /* filter data */
2347         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2348         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2349         
2350         /* smooth keyframes */
2351         for (ale = anim_data.first; ale; ale = ale->next) {
2352                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
2353                  * Perhaps the mode argument could be removed, as that functionality is offered through
2354                  * Snap->Flatten Handles anyway.
2355                  */
2356                 smooth_fcurve(ale->key_data);
2357
2358                 ale->update |= ANIM_UPDATE_DEFAULT;
2359         }
2360
2361         ANIM_animdata_update(&ac, &anim_data);
2362         ANIM_animdata_freelist(&anim_data);
2363         
2364         /* set notifier that keyframes have changed */
2365         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
2366         
2367         return OPERATOR_FINISHED;
2368 }
2369  
2370 void GRAPH_OT_smooth(wmOperatorType *ot)
2371 {
2372         /* identifiers */
2373         ot->name = "Smooth Keys";
2374         ot->idname = "GRAPH_OT_smooth";
2375         ot->description = "Apply weighted moving means to make selected F-Curves less bumpy";
2376         
2377         /* api callbacks */
2378         ot->exec = graphkeys_smooth_exec;
2379         ot->poll = graphop_editable_keyframes_poll;
2380         
2381         /* flags */
2382         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2383 }
2384
2385 /* ************************************************************************** */
2386 /* F-CURVE MODIFIERS */
2387
2388 /* ******************** Add F-Modifier Operator *********************** */
2389
2390 static const EnumPropertyItem *graph_fmodifier_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2391 {
2392         EnumPropertyItem *item = NULL;
2393         int totitem = 0;
2394         int i = 0;
2395         
2396         if (C == NULL) {
2397                 return rna_enum_fmodifier_type_items;
2398         }
2399         
2400         /* start from 1 to skip the 'Invalid' modifier type */
2401         for (i = 1; i < FMODIFIER_NUM_TYPES; i++) {
2402                 const FModifierTypeInfo *fmi = get_fmodifier_typeinfo(i);
2403                 int index;
2404                 
2405                 /* check if modifier is valid for this context */
2406                 if (fmi == NULL)
2407                         continue;
2408                 
2409                 index = RNA_enum_from_value(rna_enum_fmodifier_type_items, fmi->type);
2410                 if (index != -1) {  /* Not all types are implemented yet... */
2411                         RNA_enum_item_add(&item, &totitem, &rna_enum_fmodifier_type_items[index]);
2412                 }
2413         }
2414         
2415         RNA_enum_item_end(&item, &totitem);
2416         *r_free = true;
2417         
2418         return item;
2419 }
2420
2421 static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
2422 {
2423         bAnimContext ac;
2424         ListBase anim_data = {NULL, NULL};
2425         bAnimListElem *ale;
2426         int filter;
2427         short type;
2428         
2429         /* get editor data */
2430         if (ANIM_animdata_get_context(C, &ac) == 0)
2431                 return OPERATOR_CANCELLED;
2432         
2433         /* get type of modifier to add */
2434         type = RNA_enum_get(op->ptr, "type");
2435         
2436         /* filter data */
2437         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2438         if (RNA_boolean_get(op->ptr, "only_active"))
2439                 filter |= ANIMFILTER_ACTIVE;  // FIXME: enforce in this case only a single channel to get handled?
2440         else
2441                 filter |= (ANIMFILTER_SEL | ANIMFILTER_CURVE_VISIBLE);
2442         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2443         
2444         /* add f-modifier to each curve */
2445         for (ale = anim_data.first; ale; ale = ale->next) {
2446                 FCurve *fcu = (FCurve *)ale->data;
2447                 FModifier *fcm;
2448                 
2449                 /* add F-Modifier of specified type to active F-Curve, and make it the active one */
2450                 fcm = add_fmodifier(&fcu->modifiers, type, fcu);
2451                 if (fcm) {
2452                         set_active_fmodifier(&fcu->modifiers, fcm);
2453                 }
2454                 else {
2455                         BKE_report(op->reports, RPT_ERROR, "Modifier could not be added (see console for details)");
2456                         break;
2457                 }
2458                 
2459                 ale->update |= ANIM_UPDATE_DEPS;
2460         }
2461         
2462         ANIM_animdata_update(&ac, &anim_data);
2463         ANIM_animdata_freelist(&anim_data);
2464         
2465         /* set notifier that things have changed */
2466         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
2467         
2468         return OPERATOR_FINISHED;
2469 }
2470  
2471 void GRAPH_OT_fmodifier_add(wmOperatorType *ot)
2472 {
2473         PropertyRNA *prop;
2474         
2475         /* identifiers */
2476         ot->name = "Add F-Curve Modifier";
2477         ot->idname = "GRAPH_OT_fmodifier_add";
2478         ot->description = "Add F-Modifier to the active/selected F-Curves";
2479         
2480         /* api callbacks */
2481         ot->invoke = WM_menu_invoke;
2482         ot->exec = graph_fmodifier_add_exec;
2483         ot->poll = graphop_selected_fcurve_poll; 
2484         
2485         /* flags */
2486         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2487         
2488         /* id-props */
2489         prop = RNA_def_enum(ot->srna, "type", rna_enum_fmodifier_type_items, 0, "Type", "");
2490         RNA_def_enum_funcs(prop, graph_fmodifier_itemf);
2491         ot->prop = prop;
2492         
2493         RNA_def_boolean(ot->srna, "only_active", 1, "Only Active", "Only add F-Modifier to active F-Curve");
2494 }
2495
2496 /* ******************** Copy F-Modifiers Operator *********************** */
2497
2498 static int graph_fmodifier_copy_exec(bContext *C, wmOperator *op)
2499 {
2500         bAnimContext ac;
2501         bAnimListElem *ale;
2502         bool ok = false;
2503         
2504         /* get editor data */
2505         if (ANIM_animdata_get_context(C, &ac) == 0)
2506                 return OPERATOR_CANCELLED;
2507         
2508         /* clear buffer first */
2509         ANIM_fmodifiers_copybuf_free();
2510         
2511         /* get the active F-Curve */
2512         ale = get_active_fcurve_channel(&ac);
2513         
2514         /* if this exists, call the copy F-Modifiers API function */
2515         if (ale && ale->data) {
2516                 FCurve *fcu = (FCurve *)ale->data;
2517                 
2518                 /* TODO: when 'active' vs 'all' boolean is added, change last param! */
2519                 ok = ANIM_fmodifiers_copy_to_buf(&fcu->modifiers, 0);
2520                 
2521                 /* free temp data now */
2522                 MEM_freeN(ale);
2523         }
2524         
2525         /* successful or not? */
2526         if (ok == 0) {
2527                 BKE_report(op->reports, RPT_ERROR, "No F-Modifiers available to be copied");
2528                 return OPERATOR_CANCELLED;
2529         }
2530         else
2531                 return OPERATOR_FINISHED;
2532 }
2533  
2534 void GRAPH_OT_fmodifier_copy(wmOperatorType *ot)
2535 {
2536         /* identifiers */
2537         ot->name = "Copy F-Modifiers";
2538         ot->idname = "GRAPH_OT_fmodifier_copy";
2539         ot->description = "Copy the F-Modifier(s) of the active F-Curve";
2540         
2541         /* api callbacks */
2542         ot->exec = graph_fmodifier_copy_exec;
2543         ot->poll = graphop_active_fcurve_poll; 
2544         
2545         /* flags */
2546         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2547         
2548         /* id-props */
2549         //ot->prop = RNA_def_boolean(ot->srna, "all", 1, "All F-Modifiers", "Copy all the F-Modifiers, instead of just the active one");
2550 }
2551
2552 /* ******************** Paste F-Modifiers Operator *********************** */
2553
2554 static int graph_fmodifier_paste_exec(bContext *C, wmOperator *op)
2555 {
2556         bAnimContext ac;
2557         
2558         ListBase anim_data = {NULL, NULL};
2559         bAnimListElem *ale;
2560         int filter;
2561         
2562         const bool replace = RNA_boolean_get(op->ptr, "replace");
2563         bool ok = false;
2564         
2565         /* get editor data */
2566         if (ANIM_animdata_get_context(C, &ac) == 0)
2567                 return OPERATOR_CANCELLED;
2568         
2569         /* filter data */
2570         if (RNA_boolean_get(op->ptr, "only_active")) {
2571                 /* This should be the default (for buttons) - Just paste to the active FCurve */
2572                 filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_ACTIVE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2573         }
2574         else {
2575                 /* This is only if the operator gets called from a hotkey or search - Paste to all visible curves */
2576                 filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2577         }
2578         
2579         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2580         
2581         /* paste modifiers */
2582         for (ale = anim_data.first; ale; ale = ale->next) {
2583                 FCurve *fcu = (FCurve *)ale->data;
2584                 int tot;
2585                 
2586                 tot = ANIM_fmodifiers_paste_from_buf(&fcu->modifiers, replace, fcu);
2587                 
2588                 if (tot) {
2589                         ale->update |= ANIM_UPDATE_DEPS;
2590                         ok = true;
2591                 }
2592         }
2593         
2594         if (ok) {
2595                 ANIM_animdata_update(&ac, &anim_data);
2596         }
2597         ANIM_animdata_freelist(&anim_data);
2598         
2599         /* successful or not? */
2600         if (ok) {
2601                 /* set notifier that keyframes have changed */
2602                 WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
2603                 
2604                 return OPERATOR_FINISHED;
2605         }
2606         else {
2607                 BKE_report(op->reports, RPT_ERROR, "No F-Modifiers to paste");
2608                 return OPERATOR_CANCELLED;
2609         }
2610 }
2611  
2612 void GRAPH_OT_fmodifier_paste(wmOperatorType *ot)
2613 {
2614         /* identifiers */
2615         ot->name = "Paste F-Modifiers";
2616         ot->idname = "GRAPH_OT_fmodifier_paste";
2617         ot->description = "Add copied F-Modifiers to the selected F-Curves";
2618         
2619         /* api callbacks */
2620         ot->exec = graph_fmodifier_paste_exec;
2621         ot->poll = graphop_active_fcurve_poll;
2622         
2623         /* flags */
2624         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2625         
2626         /* properties */
2627         RNA_def_boolean(ot->srna, "only_active", true, "Only Active", "Only paste F-Modifiers on active F-Curve");
2628         RNA_def_boolean(ot->srna, "replace", false, "Replace Existing", 
2629                         "Replace existing F-Modifiers, instead of just appending to the end of the existing list");
2630 }
2631
2632 /* ************************************************************************** */
2633 /* Drivers */
2634
2635 /* ******************** Copy Driver Vars Operator *********************** */
2636
2637 static int graph_driver_vars_copy_exec(bContext *C, wmOperator *op)
2638 {
2639         bAnimContext ac;
2640         bAnimListElem *ale;
2641         bool ok = false;
2642         
2643         /* get editor data */
2644         if (ANIM_animdata_get_context(C, &ac) == 0)
2645                 return OPERATOR_CANCELLED;
2646         
2647         /* clear buffer first */
2648         ANIM_driver_vars_copybuf_free();
2649         
2650         /* get the active F-Curve */
2651         ale = get_active_fcurve_channel(&ac);
2652         
2653         /* if this exists, call the copy driver vars API function */
2654         if (ale && ale->data) {
2655                 FCurve *fcu = (FCurve *)ale->data;
2656                 
2657                 ok = ANIM_driver_vars_copy(op->reports, fcu);
2658                 
2659                 /* free temp data now */
2660                 MEM_freeN(ale);
2661         }
2662         
2663         /* successful or not? */
2664         if (ok)
2665                 return OPERATOR_FINISHED;
2666         else
2667                 return OPERATOR_CANCELLED;
2668 }
2669  
2670 void GRAPH_OT_driver_variables_copy(wmOperatorType *ot)
2671 {
2672         /* identifiers */
2673         ot->name = "Copy Driver Variables";
2674         ot->idname = "GRAPH_OT_driver_variables_copy";
2675         ot->description = "Copy the driver variables of the active F-Curve";
2676         
2677         /* api callbacks */
2678         ot->exec = graph_driver_vars_copy_exec;
2679         ot->poll = graphop_active_fcurve_poll; 
2680         
2681         /* flags */
2682         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2683 }
2684
2685 /* ******************** Paste Driver Vars Operator *********************** */
2686
2687 static int graph_driver_vars_paste_exec(bContext *C, wmOperator *op)
2688 {
2689         bAnimContext ac;
2690         
2691         ListBase anim_data = {NULL, NULL};
2692         bAnimListElem *ale;
2693         int filter;
2694         
2695         const bool replace = RNA_boolean_get(op->ptr, "replace");
2696         bool ok = false;
2697         
2698         /* get editor data */
2699         if (ANIM_animdata_get_context(C, &ac) == 0)
2700                 return OPERATOR_CANCELLED;
2701         
2702         /* filter data */
2703         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_ACTIVE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2704         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2705         
2706         /* paste variables */
2707         for (ale = anim_data.first; ale; ale = ale->next) {
2708                 FCurve *fcu = (FCurve *)ale->data;
2709                 ok |= ANIM_driver_vars_paste(op->reports, fcu, replace);
2710         }
2711         
2712         /* cleanup */
2713         ANIM_animdata_freelist(&anim_data);
2714         
2715         /* successful or not? */
2716         if (ok) {
2717                 /* rebuild depsgraph, now that there are extra deps here */
2718                 DEG_relations_tag_update(CTX_data_main(C));
2719                 
2720                 /* set notifier that keyframes have changed */
2721                 WM_event_add_notifier(C, NC_SCENE | ND_FRAME, CTX_data_scene(C));
2722                 
2723                 return OPERATOR_FINISHED;
2724         }
2725         else {
2726                 return OPERATOR_CANCELLED;
2727         }
2728 }
2729  
2730 void GRAPH_OT_driver_variables_paste(wmOperatorType *ot)
2731 {
2732         /* identifiers */
2733         ot->name = "Paste Driver Variables";
2734         ot->idname = "GRAPH_OT_driver_variables_paste";
2735         ot->description = "Add copied driver variables to the active driver";
2736         
2737         /* api callbacks */
2738         ot->exec = graph_driver_vars_paste_exec;
2739         ot->poll = graphop_active_fcurve_poll;
2740         
2741         /* flags */
2742         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2743         
2744         /* properties */
2745         RNA_def_boolean(ot->srna, "replace", false, "Replace Existing", 
2746                         "Replace existing driver variables, instead of just appending to the end of the existing list");
2747 }
2748
2749 /* ************************************************************************** */
2750
2751 static int graph_driver_delete_invalid_exec(bContext *C, wmOperator *op)
2752 {
2753         bAnimContext ac;
2754         ListBase anim_data = {NULL, NULL};
2755         bAnimListElem *ale;
2756         int filter;
2757         bool ok = false;
2758         unsigned int deleted = 0;
2759
2760         /* get editor data */
2761         if (ANIM_animdata_get_context(C, &ac) == 0)
2762                 return OPERATOR_CANCELLED;
2763
2764         /* NOTE: we might need a scene update to evaluate the driver flags */
2765
2766         /* filter data */
2767         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
2768         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2769
2770         /* find invalid drivers */
2771         for (ale = anim_data.first; ale; ale = ale->next) {
2772                 FCurve *fcu = (FCurve *)ale->data;
2773                 if (ELEM(NULL, fcu, fcu->driver)) {
2774                         continue;
2775                 }
2776                 if (!(fcu->driver->flag & DRIVER_FLAG_INVALID)) {
2777                         continue;
2778                 }
2779
2780                 ok |= ANIM_remove_driver(op->reports, ale->id, fcu->rna_path, fcu->array_index, 0);
2781                 if (!ok) {
2782                         break;
2783                 }
2784                 deleted += 1;
2785         }
2786
2787         /* cleanup */
2788         ANIM_animdata_freelist(&anim_data);
2789
2790         if (deleted > 0) {
2791                 /* notify the world of any changes */
2792                 DEG_relations_tag_update(CTX_data_main(C));
2793                 WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_REMOVED, NULL);
2794                 WM_reportf(RPT_INFO, "Deleted %u drivers", deleted);
2795         }
2796         else {
2797                 WM_report(RPT_INFO, "No drivers deleted");
2798         }
2799
2800         /* successful or not? */
2801         if (!ok) {
2802                 return OPERATOR_CANCELLED;
2803         }
2804
2805         return OPERATOR_FINISHED;
2806 }
2807
2808 static int graph_driver_delete_invalid_poll(bContext *C)
2809 {
2810         bAnimContext ac;
2811         ScrArea *sa = CTX_wm_area(C);
2812
2813         /* firstly, check if in Graph Editor */
2814         if ((sa == NULL) || (sa->spacetype != SPACE_IPO))
2815                 return 0;
2816
2817         /* try to init Anim-Context stuff ourselves and check */
2818         return ANIM_animdata_get_context(C, &ac) != 0;
2819 }
2820
2821
2822 void GRAPH_OT_driver_delete_invalid(wmOperatorType *ot)
2823 {
2824         /* identifiers */
2825         ot->name = "Delete Invalid Drivers";
2826         ot->idname = "GRAPH_OT_driver_delete_invalid";
2827         ot->description = "Delete all visible drivers considered invalid";
2828
2829         /* api callbacks */
2830         ot->exec = graph_driver_delete_invalid_exec;
2831         ot->poll = graph_driver_delete_invalid_poll;
2832
2833         /* flags */
2834         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2835 }