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