style cleanup: follow style guide for formatting of if/for/while loops, and else...
[blender.git] / source / blender / editors / space_graph / graph_edit.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Joshua Leung
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_graph/graph_edit.c
29  *  \ingroup spgraph
30  */
31
32
33 #include <math.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <float.h>
37
38 #ifdef WITH_AUDASPACE
39 #  include "AUD_C-API.h"
40 #endif
41
42 #include "MEM_guardedalloc.h"
43
44 #include "BLI_blenlib.h"
45 #include "BLI_math.h"
46 #include "BLI_utildefines.h"
47
48 #include "DNA_anim_types.h"
49 #include "DNA_object_types.h"
50 #include "DNA_scene_types.h"
51
52 #include "RNA_access.h"
53 #include "RNA_define.h"
54 #include "RNA_enum_types.h"
55
56 #include "BLF_translation.h"
57
58 #include "BKE_fcurve.h"
59 #include "BKE_nla.h"
60 #include "BKE_context.h"
61 #include "BKE_report.h"
62
63 #include "UI_interface.h"
64 #include "UI_resources.h"
65 #include "UI_view2d.h"
66
67 #include "ED_anim_api.h"
68 #include "ED_keyframing.h"
69 #include "ED_keyframes_edit.h"
70 #include "ED_screen.h"
71 #include "ED_transform.h"
72 #include "ED_markers.h"
73
74 #include "WM_api.h"
75 #include "WM_types.h"
76
77 #include "graph_intern.h"
78
79 /* ************************************************************************** */
80 /* KEYFRAME-RANGE STUFF */
81
82 /* *************************** Calculate Range ************************** */
83
84 /* Get the min/max keyframes*/
85 /* note: it should return total boundbox, filter for selection only can be argument... */
86 void get_graph_keyframe_extents (bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax, const short selOnly)
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 to try to override */
97         if (xmin) *xmin= 999999999.0f;
98         if (xmax) *xmax= -999999999.0f;
99         if (ymin) *ymin= 999999999.0f;
100         if (ymax) *ymax= -999999999.0f;
101         
102         /* check if any channels to set range with */
103         if (anim_data.first) {
104                 /* go through channels, finding max extents */
105                 for (ale= anim_data.first; ale; ale= ale->next) {
106                         AnimData *adt= ANIM_nla_mapping_get(ac, ale);
107                         FCurve *fcu= (FCurve *)ale->key_data;
108                         float txmin, txmax, tymin, tymax;
109                         float unitFac;
110                         
111                         /* get range */
112                         calc_fcurve_bounds(fcu, &txmin, &txmax, &tymin, &tymax, selOnly);
113                         
114                         /* apply NLA scaling */
115                         if (adt) {
116                                 txmin= BKE_nla_tweakedit_remap(adt, txmin, NLATIME_CONVERT_MAP);
117                                 txmax= BKE_nla_tweakedit_remap(adt, txmax, NLATIME_CONVERT_MAP);
118                         }
119                         
120                         /* apply unit corrections */
121                         unitFac= ANIM_unit_mapping_get_factor(ac->scene, ale->id, fcu, 0);
122                         tymin *= unitFac;
123                         tymax *= unitFac;
124                         
125                         /* try to set cur using these values, if they're more extreme than previously set values */
126                         if ((xmin) && (txmin < *xmin))          *xmin= txmin;
127                         if ((xmax) && (txmax > *xmax))          *xmax= txmax;
128                         if ((ymin) && (tymin < *ymin))          *ymin= tymin;
129                         if ((ymax) && (tymax > *ymax))          *ymax= tymax;
130                 }
131                 
132                 /* ensure that the extents are not too extreme that view implodes...*/
133                 if ((xmin && xmax) && (fabsf(*xmax - *xmin) < 0.1f)) *xmax += 0.1f;
134                 if ((ymin && ymax) && (fabsf(*ymax - *ymin) < 0.1f)) *ymax += 0.1f;
135                 
136                 /* free memory */
137                 BLI_freelistN(&anim_data);
138         }
139         else {
140                 /* set default range */
141                 if (ac->scene) {
142                         if (xmin) *xmin= (float)ac->scene->r.sfra;
143                         if (xmax) *xmax= (float)ac->scene->r.efra;
144                 }
145                 else {
146                         if (xmin) *xmin= -5;
147                         if (xmax) *xmax= 100;
148                 }
149                 
150                 if (ymin) *ymin= -5;
151                 if (ymax) *ymax= 5;
152         }
153 }
154
155 /* ****************** Automatic Preview-Range Operator ****************** */
156
157 static int graphkeys_previewrange_exec(bContext *C, wmOperator *UNUSED(op))
158 {
159         bAnimContext ac;
160         Scene *scene;
161         float min, max;
162         
163         /* get editor data */
164         if (ANIM_animdata_get_context(C, &ac) == 0)
165                 return OPERATOR_CANCELLED;
166         if (ac.scene == NULL)
167                 return OPERATOR_CANCELLED;
168         else
169                 scene= ac.scene;
170         
171         /* set the range directly */
172         get_graph_keyframe_extents(&ac, &min, &max, NULL, NULL, FALSE);
173         scene->r.flag |= SCER_PRV_RANGE;
174         scene->r.psfra= (int)floor(min + 0.5f);
175         scene->r.pefra= (int)floor(max + 0.5f);
176         
177         /* set notifier that things have changed */
178         // XXX err... there's nothing for frame ranges yet, but this should do fine too
179         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
180         
181         return OPERATOR_FINISHED;
182 }
183  
184 void GRAPH_OT_previewrange_set (wmOperatorType *ot)
185 {
186         /* identifiers */
187         ot->name = "Auto-Set Preview Range";
188         ot->idname = "GRAPH_OT_previewrange_set";
189         ot->description = "Automatically set Preview Range based on range of keyframes";
190         
191         /* api callbacks */
192         ot->exec = graphkeys_previewrange_exec;
193         ot->poll = ED_operator_graphedit_active; // XXX: unchecked poll to get fsamples working too, but makes modifier damage trickier...
194         
195         /* flags */
196         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
197 }
198
199 /* ****************** View-All Operator ****************** */
200
201 static int graphkeys_viewall(bContext *C, const short selOnly)
202 {
203         bAnimContext ac;
204         View2D *v2d;
205         float extra;
206
207         /* get editor data */
208         if (ANIM_animdata_get_context(C, &ac) == 0)
209                 return OPERATOR_CANCELLED;
210         v2d= &ac.ar->v2d;
211
212         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
213         get_graph_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, &v2d->cur.ymin, &v2d->cur.ymax, selOnly);
214
215         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
216         v2d->cur.xmin -= extra;
217         v2d->cur.xmax += extra;
218
219         extra= 0.1f * (v2d->cur.ymax - v2d->cur.ymin);
220         v2d->cur.ymin -= extra;
221         v2d->cur.ymax += extra;
222
223         /* do View2D syncing */
224         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
225
226         /* set notifier that things have changed */
227         ED_area_tag_redraw(CTX_wm_area(C));
228
229         return OPERATOR_FINISHED;
230 }
231
232 /* ......... */
233
234 static int graphkeys_viewall_exec(bContext *C, wmOperator *UNUSED(op))
235 {
236         /* whole range */
237         return graphkeys_viewall(C, FALSE);
238 }
239  
240 static int graphkeys_view_selected_exec(bContext *C, wmOperator *UNUSED(op))
241 {
242         /* only selected */
243         return graphkeys_viewall(C, TRUE);
244 }
245
246 void GRAPH_OT_view_all (wmOperatorType *ot)
247 {
248         /* identifiers */
249         ot->name = "View All";
250         ot->idname = "GRAPH_OT_view_all";
251         ot->description = "Reset viewable area to show full keyframe range";
252         
253         /* api callbacks */
254         ot->exec = graphkeys_viewall_exec;
255         ot->poll = ED_operator_graphedit_active; // XXX: unchecked poll to get fsamples working too, but makes modifier damage trickier...
256         
257         /* flags */
258         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
259 }
260
261 void GRAPH_OT_view_selected (wmOperatorType *ot)
262 {
263         /* identifiers */
264         ot->name = "View Selected";
265         ot->idname = "GRAPH_OT_view_selected";
266         ot->description = "Reset viewable area to show selected keyframe range";
267
268         /* api callbacks */
269         ot->exec = graphkeys_view_selected_exec;
270         ot->poll = ED_operator_graphedit_active; // XXX: unchecked poll to get fsamples working too, but makes modifier damage trickier...
271
272         /* flags */
273         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
274 }
275
276 /* ******************** Create Ghost-Curves Operator *********************** */
277 /* This operator samples the data of the selected F-Curves to F-Points, storing them
278  * as 'ghost curves' in the active Graph Editor
279  */
280
281 /* Bake each F-Curve into a set of samples, and store as a ghost curve */
282 static void create_ghost_curves (bAnimContext *ac, int start, int end)
283 {       
284         SpaceIpo *sipo= (SpaceIpo *)ac->sl;
285         ListBase anim_data = {NULL, NULL};
286         bAnimListElem *ale;
287         int filter;
288         
289         /* free existing ghost curves */
290         free_fcurves(&sipo->ghostCurves);
291         
292         /* sanity check */
293         if (start >= end) {
294                 printf("Error: Frame range for Ghost F-Curve creation is inappropriate \n");
295                 return;
296         }
297         
298         /* filter data */
299         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);
300         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
301         
302         /* loop through filtered data and add keys between selected keyframes on every frame  */
303         for (ale= anim_data.first; ale; ale= ale->next) {
304                 FCurve *fcu= (FCurve *)ale->key_data;
305                 FCurve *gcu= MEM_callocN(sizeof(FCurve), "Ghost FCurve");
306                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
307                 ChannelDriver *driver= fcu->driver;
308                 FPoint *fpt;
309                 float unitFac;
310                 int cfra;               
311                 
312                 /* disable driver so that it don't muck up the sampling process */
313                 fcu->driver= NULL;
314                 
315                 /* calculate unit-mapping factor */
316                 unitFac= ANIM_unit_mapping_get_factor(ac->scene, ale->id, fcu, 0);
317                 
318                 /* create samples, but store them in a new curve 
319                  *      - we cannot use fcurve_store_samples() as that will only overwrite the original curve 
320                  */
321                 gcu->fpt= fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "Ghost FPoint Samples");
322                 gcu->totvert= end - start + 1;
323                 
324                 /* use the sampling callback at 1-frame intervals from start to end frames */
325                 for (cfra= start; cfra <= end; cfra++, fpt++) {
326                         float cfrae= BKE_nla_tweakedit_remap(adt, cfra, NLATIME_CONVERT_UNMAP);
327                         
328                         fpt->vec[0]= cfrae;
329                         fpt->vec[1]= fcurve_samplingcb_evalcurve(fcu, NULL, cfrae) * unitFac;
330                 }
331                 
332                 /* set color of ghost curve 
333                  *      - make the color slightly darker
334                  */
335                 gcu->color[0]= fcu->color[0] - 0.07f;
336                 gcu->color[1]= fcu->color[1] - 0.07f;
337                 gcu->color[2]= fcu->color[2] - 0.07f;
338                 
339                 /* store new ghost curve */
340                 BLI_addtail(&sipo->ghostCurves, gcu);
341                 
342                 /* restore driver */
343                 fcu->driver= driver;
344         }
345         
346         /* admin and redraws */
347         BLI_freelistN(&anim_data);
348 }
349
350 /* ------------------- */
351
352 static int graphkeys_create_ghostcurves_exec(bContext *C, wmOperator *UNUSED(op))
353 {
354         bAnimContext ac;
355         View2D *v2d;
356         int start, end;
357         
358         /* get editor data */
359         if (ANIM_animdata_get_context(C, &ac) == 0)
360                 return OPERATOR_CANCELLED;
361                 
362         /* ghost curves are snapshots of the visible portions of the curves, so set range to be the visible range */
363         v2d= &ac.ar->v2d;
364         start= (int)v2d->cur.xmin;
365         end= (int)v2d->cur.xmax;
366         
367         /* bake selected curves into a ghost curve */
368         create_ghost_curves(&ac, start, end);
369         
370         /* update this editor only */
371         ED_area_tag_redraw(CTX_wm_area(C));
372         
373         return OPERATOR_FINISHED;
374 }
375  
376 void GRAPH_OT_ghost_curves_create (wmOperatorType *ot)
377 {
378         /* identifiers */
379         ot->name = "Create Ghost Curves";
380         ot->idname = "GRAPH_OT_ghost_curves_create";
381         ot->description = "Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor";
382         
383         /* api callbacks */
384         ot->exec = graphkeys_create_ghostcurves_exec;
385         ot->poll = graphop_visible_keyframes_poll;
386         
387         /* flags */
388         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
389         
390         // todo: add props for start/end frames
391 }
392
393 /* ******************** Clear Ghost-Curves Operator *********************** */
394 /* This operator clears the 'ghost curves' for the active Graph Editor */
395
396 static int graphkeys_clear_ghostcurves_exec(bContext *C, wmOperator *UNUSED(op))
397 {
398         bAnimContext ac;
399         SpaceIpo *sipo;
400         
401         /* get editor data */
402         if (ANIM_animdata_get_context(C, &ac) == 0)
403                 return OPERATOR_CANCELLED;
404         sipo= (SpaceIpo *)ac.sl;
405                 
406         /* if no ghost curves, don't do anything */
407         if (sipo->ghostCurves.first == NULL)
408                 return OPERATOR_CANCELLED;
409         
410         /* free ghost curves */
411         free_fcurves(&sipo->ghostCurves);
412         
413         /* update this editor only */
414         ED_area_tag_redraw(CTX_wm_area(C));
415         
416         return OPERATOR_FINISHED;
417 }
418  
419 void GRAPH_OT_ghost_curves_clear (wmOperatorType *ot)
420 {
421         /* identifiers */
422         ot->name = "Clear Ghost Curves";
423         ot->idname = "GRAPH_OT_ghost_curves_clear";
424         ot->description = "Clear F-Curve snapshots (Ghosts) for active Graph Editor";
425         
426         /* api callbacks */
427         ot->exec = graphkeys_clear_ghostcurves_exec;
428         ot->poll = ED_operator_graphedit_active;
429         
430         /* flags */
431         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
432 }
433
434 /* ************************************************************************** */
435 /* GENERAL STUFF */
436
437 /* ******************** Insert Keyframes Operator ************************* */
438
439 /* defines for insert keyframes tool */
440 static EnumPropertyItem prop_graphkeys_insertkey_types[] = {
441         {1, "ALL", 0, "All Channels", ""},
442         {2, "SEL", 0, "Only Selected Channels", ""},
443         {0, NULL, 0, NULL, NULL}
444 };
445
446 /* this function is responsible for snapping keyframes to frame-times */
447 static void insert_graph_keys(bAnimContext *ac, short mode) 
448 {
449         ListBase anim_data = {NULL, NULL};
450         bAnimListElem *ale;
451         int filter;
452         
453         ReportList *reports = ac->reports;
454         Scene *scene= ac->scene;
455         short flag = 0;
456         
457         /* filter data */
458         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
459         if (mode == 2) filter |= ANIMFILTER_SEL;
460         
461         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
462         
463         /* init keyframing flag */
464         flag = ANIM_get_keyframing_flags(scene, 1);
465         
466         /* insert keyframes */
467         for (ale= anim_data.first; ale; ale= ale->next) {
468                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
469                 FCurve *fcu= (FCurve *)ale->key_data;
470                 float cfra;
471                 
472                 /* adjust current frame for NLA-mapping */
473                 if (adt)
474                         cfra= BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
475                 else 
476                         cfra= (float)CFRA;
477                         
478                 /* if there's an id */
479                 if (ale->id)
480                         insert_keyframe(reports, ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
481                 else
482                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
483         }
484         
485         BLI_freelistN(&anim_data);
486 }
487
488 /* ------------------- */
489
490 static int graphkeys_insertkey_exec(bContext *C, wmOperator *op)
491 {
492         bAnimContext ac;
493         short mode;
494         
495         /* get editor data */
496         if (ANIM_animdata_get_context(C, &ac) == 0)
497                 return OPERATOR_CANCELLED;
498                 
499         /* which channels to affect? */
500         mode= RNA_enum_get(op->ptr, "type");
501         
502         /* insert keyframes */
503         insert_graph_keys(&ac, mode);
504         
505         /* validate keyframes after editing */
506         ANIM_editkeyframes_refresh(&ac);
507         
508         /* set notifier that keyframes have changed */
509         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
510         
511         return OPERATOR_FINISHED;
512 }
513
514 void GRAPH_OT_keyframe_insert (wmOperatorType *ot)
515 {
516         /* identifiers */
517         ot->name = "Insert Keyframes";
518         ot->idname = "GRAPH_OT_keyframe_insert";
519         ot->description = "Insert keyframes for the specified channels";
520         
521         /* api callbacks */
522         ot->invoke = WM_menu_invoke;
523         ot->exec = graphkeys_insertkey_exec;
524         ot->poll = graphop_editable_keyframes_poll;
525         
526         /* flags */
527         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
528         
529         /* id-props */
530         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_insertkey_types, 0, "Type", "");
531 }
532
533 /* ******************** Click-Insert Keyframes Operator ************************* */
534
535 static int graphkeys_click_insert_exec (bContext *C, wmOperator *op)
536 {
537         bAnimContext ac;
538         bAnimListElem *ale;
539         AnimData *adt;
540         FCurve *fcu;
541         float frame, val;
542         
543         /* get animation context */
544         if (ANIM_animdata_get_context(C, &ac) == 0)
545                 return OPERATOR_CANCELLED;
546         
547         /* get active F-Curve 'anim-list-element' */
548         ale= get_active_fcurve_channel(&ac);
549         if (ELEM(NULL, ale, ale->data)) {
550                 if (ale) MEM_freeN(ale);
551                 return OPERATOR_CANCELLED;
552         }
553         fcu = ale->data;
554         
555         /* when there are F-Modifiers on the curve, only allow adding
556          * keyframes if these will be visible after doing so...
557          */
558         if (fcurve_is_keyframable(fcu)) {
559                 /* get frame and value from props */
560                 frame= RNA_float_get(op->ptr, "frame");
561                 val= RNA_float_get(op->ptr, "value");
562                 
563                 /* apply inverse NLA-mapping to frame to get correct time in un-scaled action */
564                 adt= ANIM_nla_mapping_get(&ac, ale);
565                 frame= BKE_nla_tweakedit_remap(adt, frame, NLATIME_CONVERT_UNMAP);
566                 
567                 /* apply inverse unit-mapping to value to get correct value for F-Curves */
568                 val *= ANIM_unit_mapping_get_factor(ac.scene, ale->id, fcu, 1);
569                 
570                 /* insert keyframe on the specified frame + value */
571                 insert_vert_fcurve(fcu, frame, val, 0);
572         }
573         else {
574                 /* warn about why this can't happen */
575                 if (fcu->fpt)
576                         BKE_report(op->reports, RPT_ERROR, "Keyframes cannot be added to sampled F-Curves");
577                 else if (fcu->flag & FCURVE_PROTECTED)
578                         BKE_report(op->reports, RPT_ERROR, "Active F-Curve is not editable");
579                 else
580                         BKE_report(op->reports, RPT_ERROR, "Remove F-Modifiers from F-Curve to add keyframes");
581         }
582         
583         /* free temp data */
584         MEM_freeN(ale);
585         
586         /* set notifier that keyframes have changed */
587         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
588         
589         /* done */
590         return OPERATOR_FINISHED;
591 }
592
593 static int graphkeys_click_insert_invoke (bContext *C, wmOperator *op, wmEvent *evt)
594 {
595         bAnimContext ac;
596         ARegion *ar;
597         View2D *v2d;
598         int mval[2];
599         float x, y;
600         
601         /* get animation context */
602         if (ANIM_animdata_get_context(C, &ac) == 0)
603                 return OPERATOR_CANCELLED;
604         
605         /* store mouse coordinates in View2D space, into the operator's properties */
606         ar= ac.ar;
607         v2d= &ar->v2d;
608         
609         mval[0]= (evt->x - ar->winrct.xmin);
610         mval[1]= (evt->y - ar->winrct.ymin);
611         
612         UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y);
613         
614         RNA_float_set(op->ptr, "frame", x);
615         RNA_float_set(op->ptr, "value", y);
616         
617         /* run exec now */
618         return graphkeys_click_insert_exec(C, op);
619 }
620
621 void GRAPH_OT_click_insert (wmOperatorType *ot)
622 {
623         /* identifiers */
624         ot->name = "Click-Insert Keyframes";
625         ot->idname = "GRAPH_OT_click_insert";
626         ot->description = "Insert new keyframe at the cursor position for the active F-Curve";
627         
628         /* api callbacks */
629         ot->invoke = graphkeys_click_insert_invoke;
630         ot->exec = graphkeys_click_insert_exec;
631         ot->poll = graphop_active_fcurve_poll;
632         
633         /* flags */
634         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
635         
636         /* properties */
637         RNA_def_float(ot->srna, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame Number", "Frame to insert keyframe on", 0, 100);
638         RNA_def_float(ot->srna, "value", 1.0f, -FLT_MAX, FLT_MAX, "Value", "Value for keyframe on", 0, 100);
639 }
640
641 /* ******************** Copy/Paste Keyframes Operator ************************* */
642 /* NOTE: the backend code for this is shared with the dopesheet editor */
643
644 static short copy_graph_keys (bAnimContext *ac)
645 {       
646         ListBase anim_data = {NULL, NULL};
647         int filter, ok=0;
648         
649         /* clear buffer first */
650         free_anim_copybuf();
651         
652         /* filter data */
653         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
654         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
655         
656         /* copy keyframes */
657         ok= copy_animedit_keys(ac, &anim_data);
658         
659         /* clean up */
660         BLI_freelistN(&anim_data);
661
662         return ok;
663 }
664
665 static short paste_graph_keys (bAnimContext *ac,
666         const eKeyPasteOffset offset_mode, const eKeyMergeMode merge_mode)
667 {       
668         ListBase anim_data = {NULL, NULL};
669         int filter, ok=0;
670         
671         /* filter data */
672         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
673         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
674         
675         /* paste keyframes */
676         ok= paste_animedit_keys(ac, &anim_data, offset_mode, merge_mode);
677         
678         /* clean up */
679         BLI_freelistN(&anim_data);
680
681         return ok;
682 }
683
684 /* ------------------- */
685
686 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
687 {
688         bAnimContext ac;
689         
690         /* get editor data */
691         if (ANIM_animdata_get_context(C, &ac) == 0)
692                 return OPERATOR_CANCELLED;
693         
694         /* copy keyframes */
695         if (copy_graph_keys(&ac)) {     
696                 BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
697                 return OPERATOR_CANCELLED;
698         }
699         
700         /* just return - no operator needed here (no changes) */
701         return OPERATOR_FINISHED;
702 }
703  
704 void GRAPH_OT_copy (wmOperatorType *ot)
705 {
706         /* identifiers */
707         ot->name = "Copy Keyframes";
708         ot->idname = "GRAPH_OT_copy";
709         ot->description = "Copy selected keyframes to the copy/paste buffer";
710         
711         /* api callbacks */
712         ot->exec = graphkeys_copy_exec;
713         ot->poll = graphop_editable_keyframes_poll;
714         
715         /* flags */
716         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
717 }
718
719
720
721 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
722 {
723         bAnimContext ac;
724
725         const eKeyPasteOffset offset_mode= RNA_enum_get(op->ptr, "offset");
726         const eKeyMergeMode merge_mode= RNA_enum_get(op->ptr, "merge");
727         
728         /* get editor data */
729         if (ANIM_animdata_get_context(C, &ac) == 0)
730                 return OPERATOR_CANCELLED;
731         
732         /* ac.reports by default will be the global reports list, which won't show warnings */
733         ac.reports= op->reports;
734
735         /* paste keyframes - non-zero return means an error occurred while trying to paste */
736         if (paste_graph_keys(&ac, offset_mode, merge_mode)) {
737                 return OPERATOR_CANCELLED;
738         }
739         
740         /* validate keyframes after editing */
741         ANIM_editkeyframes_refresh(&ac);
742         
743         /* set notifier that keyframes have changed */
744         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
745         
746         return OPERATOR_FINISHED;
747 }
748  
749 void GRAPH_OT_paste (wmOperatorType *ot)
750 {
751         /* identifiers */
752         ot->name = "Paste Keyframes";
753         ot->idname = "GRAPH_OT_paste";
754         ot->description = "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame";
755         
756         /* api callbacks */
757 //      ot->invoke = WM_operator_props_popup; // better wait for graph redo panel
758         ot->exec = graphkeys_paste_exec;
759         ot->poll = graphop_editable_keyframes_poll;
760         
761         /* flags */
762         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
763
764         RNA_def_enum(ot->srna, "offset", keyframe_paste_offset_items, KEYFRAME_PASTE_OFFSET_CFRA_START, "Offset", "Paste time offset of keys");
765         RNA_def_enum(ot->srna, "merge", keyframe_paste_merge_items, KEYFRAME_PASTE_MERGE_MIX, "Type", "Method of merging pasted keys and existing");
766 }
767
768 /* ******************** Duplicate Keyframes Operator ************************* */
769
770 static void duplicate_graph_keys (bAnimContext *ac)
771 {
772         ListBase anim_data = {NULL, NULL};
773         bAnimListElem *ale;
774         int filter;
775         
776         /* filter data */
777         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
778         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
779         
780         /* loop through filtered data and delete selected keys */
781         for (ale= anim_data.first; ale; ale= ale->next) {
782                 duplicate_fcurve_keys((FCurve *)ale->key_data);
783         }
784         
785         /* free filtered list */
786         BLI_freelistN(&anim_data);
787 }
788
789 /* ------------------- */
790
791 static int graphkeys_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
792 {
793         bAnimContext ac;
794         
795         /* get editor data */
796         if (ANIM_animdata_get_context(C, &ac) == 0)
797                 return OPERATOR_CANCELLED;
798                 
799         /* duplicate keyframes */
800         duplicate_graph_keys(&ac);
801         
802         /* validate keyframes after editing */
803         ANIM_editkeyframes_refresh(&ac);
804         
805         /* set notifier that keyframes have changed */
806         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
807         
808         return OPERATOR_FINISHED;
809 }
810
811 static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
812 {
813         graphkeys_duplicate_exec(C, op);
814
815         return OPERATOR_FINISHED;
816 }
817  
818 void GRAPH_OT_duplicate (wmOperatorType *ot)
819 {
820         /* identifiers */
821         ot->name = "Duplicate Keyframes";
822         ot->idname = "GRAPH_OT_duplicate";
823         ot->description = "Make a copy of all selected keyframes";
824         
825         /* api callbacks */
826         ot->invoke = graphkeys_duplicate_invoke;
827         ot->exec = graphkeys_duplicate_exec;
828         ot->poll = graphop_editable_keyframes_poll;
829         
830         /* flags */
831         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
832         
833         /* to give to transform */
834         RNA_def_enum(ot->srna, "mode", transform_mode_types, TFM_TRANSLATION, "Mode", "");
835 }
836
837 /* ******************** Delete Keyframes Operator ************************* */
838
839 static void delete_graph_keys (bAnimContext *ac)
840 {
841         ListBase anim_data = {NULL, NULL};
842         bAnimListElem *ale;
843         int filter;
844         
845         /* filter data */
846         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
847         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
848         
849         /* loop through filtered data and delete selected keys */
850         for (ale= anim_data.first; ale; ale= ale->next) {
851                 FCurve *fcu= (FCurve *)ale->key_data;
852                 AnimData *adt= ale->adt;
853                 
854                 /* delete selected keyframes only */
855                 delete_fcurve_keys(fcu); 
856                 
857                 /* Only delete curve too if it won't be doing anything anymore */
858                 if ((fcu->totvert == 0) && (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0))
859                         ANIM_fcurve_delete_from_animdata(ac, adt, fcu);
860         }
861         
862         /* free filtered list */
863         BLI_freelistN(&anim_data);
864 }
865
866 /* ------------------- */
867
868 static int graphkeys_delete_exec(bContext *C, wmOperator *UNUSED(op))
869 {
870         bAnimContext ac;
871         
872         /* get editor data */
873         if (ANIM_animdata_get_context(C, &ac) == 0)
874                 return OPERATOR_CANCELLED;
875                 
876         /* delete keyframes */
877         delete_graph_keys(&ac);
878         
879         /* validate keyframes after editing */
880         ANIM_editkeyframes_refresh(&ac);
881         
882         /* set notifier that keyframes have changed */
883         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
884         
885         return OPERATOR_FINISHED;
886 }
887  
888 void GRAPH_OT_delete (wmOperatorType *ot)
889 {
890         /* identifiers */
891         ot->name = "Delete Keyframes";
892         ot->idname = "GRAPH_OT_delete";
893         ot->description = "Remove all selected keyframes";
894         
895         /* api callbacks */
896         ot->invoke = WM_operator_confirm;
897         ot->exec = graphkeys_delete_exec;
898         ot->poll = graphop_editable_keyframes_poll;
899         
900         /* flags */
901         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
902 }
903
904 /* ******************** Clean Keyframes Operator ************************* */
905
906 static void clean_graph_keys (bAnimContext *ac, float thresh)
907 {       
908         ListBase anim_data = {NULL, NULL};
909         bAnimListElem *ale;
910         int filter;
911         
912         /* filter data */
913         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);
914         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
915         
916         /* loop through filtered data and clean curves */
917         for (ale= anim_data.first; ale; ale= ale->next)
918                 clean_fcurve((FCurve *)ale->key_data, thresh);
919         
920         /* free temp data */
921         BLI_freelistN(&anim_data);
922 }
923
924 /* ------------------- */
925
926 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
927 {
928         bAnimContext ac;
929         float thresh;
930         
931         /* get editor data */
932         if (ANIM_animdata_get_context(C, &ac) == 0)
933                 return OPERATOR_CANCELLED;
934                 
935         /* get cleaning threshold */
936         thresh= RNA_float_get(op->ptr, "threshold");
937         
938         /* clean keyframes */
939         clean_graph_keys(&ac, thresh);
940         
941         /* validate keyframes after editing */
942         ANIM_editkeyframes_refresh(&ac);
943         
944         /* set notifier that keyframes have changed */
945         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
946         
947         return OPERATOR_FINISHED;
948 }
949  
950 void GRAPH_OT_clean (wmOperatorType *ot)
951 {
952         /* identifiers */
953         ot->name = "Clean Keyframes";
954         ot->idname = "GRAPH_OT_clean";
955         ot->description = "Simplify F-Curves by removing closely spaced keyframes";
956         
957         /* api callbacks */
958         //ot->invoke =  // XXX we need that number popup for this! 
959         ot->exec = graphkeys_clean_exec;
960         ot->poll = graphop_editable_keyframes_poll;
961         
962         /* flags */
963         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
964         
965         /* properties */
966         ot->prop = RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
967 }
968
969 /* ******************** Bake F-Curve Operator *********************** */
970 /* This operator bakes the data of the selected F-Curves to F-Points */
971
972 /* Bake each F-Curve into a set of samples */
973 static void bake_graph_curves (bAnimContext *ac, int start, int end)
974 {       
975         ListBase anim_data = {NULL, NULL};
976         bAnimListElem *ale;
977         int filter;
978         
979         /* filter data */
980         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
981         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
982         
983         /* loop through filtered data and add keys between selected keyframes on every frame  */
984         for (ale= anim_data.first; ale; ale= ale->next) {
985                 FCurve *fcu= (FCurve *)ale->key_data;
986                 ChannelDriver *driver= fcu->driver;
987                 
988                 /* disable driver so that it don't muck up the sampling process */
989                 fcu->driver= NULL;
990                 
991                 /* create samples */
992                 fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
993                 
994                 /* restore driver */
995                 fcu->driver= driver;
996         }
997         
998         /* admin and redraws */
999         BLI_freelistN(&anim_data);
1000 }
1001
1002 /* ------------------- */
1003
1004 static int graphkeys_bake_exec(bContext *C, wmOperator *UNUSED(op))
1005 {
1006         bAnimContext ac;
1007         Scene *scene= NULL;
1008         int start, end;
1009         
1010         /* get editor data */
1011         if (ANIM_animdata_get_context(C, &ac) == 0)
1012                 return OPERATOR_CANCELLED;
1013                 
1014         /* for now, init start/end from preview-range extents */
1015         // TODO: add properties for this 
1016         scene= ac.scene;
1017         start= PSFRA;
1018         end= PEFRA;
1019         
1020         /* bake keyframes */
1021         bake_graph_curves(&ac, start, end);
1022         
1023         /* validate keyframes after editing */
1024         ANIM_editkeyframes_refresh(&ac);
1025         
1026         /* set notifier that keyframes have changed */
1027         // NOTE: some distinction between order/number of keyframes and type should be made?
1028         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1029         
1030         return OPERATOR_FINISHED;
1031 }
1032  
1033 void GRAPH_OT_bake (wmOperatorType *ot)
1034 {
1035         /* identifiers */
1036         ot->name = "Bake Curve";
1037         ot->idname = "GRAPH_OT_bake";
1038         ot->description = "Bake selected F-Curves to a set of sampled points defining a similar curve";
1039         
1040         /* api callbacks */
1041         ot->invoke = WM_operator_confirm; // FIXME...
1042         ot->exec = graphkeys_bake_exec;
1043         ot->poll = graphop_selected_fcurve_poll; 
1044         
1045         /* flags */
1046         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1047         
1048         // todo: add props for start/end frames
1049 }
1050
1051 #ifdef WITH_AUDASPACE
1052
1053 /* ******************** Sound Bake F-Curve Operator *********************** */
1054 /* This operator bakes the given sound to the selected F-Curves */
1055
1056 /* ------------------- */
1057
1058 /* Custom data storage passed to the F-Sample-ing function,
1059  * which provides the necessary info for baking the sound
1060  */
1061 typedef struct tSoundBakeInfo {
1062         float *samples;
1063         int length;
1064         int cfra;
1065 } tSoundBakeInfo;
1066
1067 /* ------------------- */
1068
1069 /* Sampling callback used to determine the value from the sound to
1070  * save in the F-Curve at the specified frame
1071  */
1072 static float fcurve_samplingcb_sound (FCurve *UNUSED(fcu), void *data, float evaltime)
1073 {
1074         tSoundBakeInfo *sbi= (tSoundBakeInfo *)data;
1075
1076         int position = evaltime - sbi->cfra;
1077         if ((position < 0) || (position >= sbi->length))
1078                 return 0.0f;
1079
1080         return sbi->samples[position];
1081 }
1082
1083 /* ------------------- */
1084
1085 static int graphkeys_sound_bake_exec(bContext *C, wmOperator *op)
1086 {
1087         bAnimContext ac;
1088         ListBase anim_data = {NULL, NULL};
1089         bAnimListElem *ale;
1090         int filter;
1091
1092         tSoundBakeInfo sbi;
1093         Scene *scene= NULL;
1094         int start, end;
1095
1096         char path[FILE_MAX];
1097
1098         /* get editor data */
1099         if (ANIM_animdata_get_context(C, &ac) == 0)
1100                 return OPERATOR_CANCELLED;
1101
1102         RNA_string_get(op->ptr, "filepath", path);
1103
1104         scene= ac.scene;        /* current scene */
1105
1106         /* store necessary data for the baking steps */
1107         sbi.samples = AUD_readSoundBuffer(path,
1108                                                                           RNA_float_get(op->ptr, "low"),
1109                                                                           RNA_float_get(op->ptr, "high"),
1110                                                                           RNA_float_get(op->ptr, "attack"),
1111                                                                           RNA_float_get(op->ptr, "release"),
1112                                                                           RNA_float_get(op->ptr, "threshold"),
1113                                                                           RNA_boolean_get(op->ptr, "accumulate"),
1114                                                                           RNA_boolean_get(op->ptr, "use_additive"),
1115                                                                           RNA_boolean_get(op->ptr, "square"),
1116                                                                           RNA_float_get(op->ptr, "sthreshold"),
1117                                                                           FPS, &sbi.length);
1118
1119         if (sbi.samples == NULL) {
1120                 BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
1121                 return OPERATOR_CANCELLED;
1122         }
1123
1124         /* determine extents of the baking */
1125         sbi.cfra = start = CFRA;
1126         end = CFRA + sbi.length - 1;
1127
1128         /* filter anim channels */
1129         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1130         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1131
1132         /* loop through all selected F-Curves, replacing its data with the sound samples */
1133         for (ale= anim_data.first; ale; ale= ale->next) {
1134                 FCurve *fcu= (FCurve *)ale->key_data;
1135                 
1136                 /* sample the sound */
1137                 fcurve_store_samples(fcu, &sbi, start, end, fcurve_samplingcb_sound);
1138         }
1139
1140         /* free sample data */
1141         free(sbi.samples);
1142
1143         /* admin and redraws */
1144         BLI_freelistN(&anim_data);
1145
1146         /* validate keyframes after editing */
1147         ANIM_editkeyframes_refresh(&ac);
1148
1149         /* set notifier that 'keyframes' have changed */
1150         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1151
1152         return OPERATOR_FINISHED;
1153 }
1154
1155 #else //WITH_AUDASPACE
1156
1157 static int graphkeys_sound_bake_exec(bContext *UNUSED(C), wmOperator *op)
1158 {
1159         BKE_report(op->reports, RPT_ERROR, "Compiled without sound support");
1160
1161         return OPERATOR_CANCELLED;
1162 }
1163
1164 #endif //WITH_AUDASPACE
1165
1166 static int graphkeys_sound_bake_invoke (bContext *C, wmOperator *op, wmEvent *event)
1167 {
1168         bAnimContext ac;
1169
1170         /* verify editor data */
1171         if (ANIM_animdata_get_context(C, &ac) == 0)
1172                 return OPERATOR_CANCELLED;
1173
1174         return WM_operator_filesel(C, op, event);
1175 }
1176
1177 void GRAPH_OT_sound_bake (wmOperatorType *ot)
1178 {
1179         /* identifiers */
1180         ot->name = "Bake Sound to F-Curves";
1181         ot->idname = "GRAPH_OT_sound_bake";
1182         ot->description = "Bakes a sound wave to selected F-Curves";
1183
1184         /* api callbacks */
1185         ot->invoke = graphkeys_sound_bake_invoke;
1186         ot->exec = graphkeys_sound_bake_exec;
1187         ot->poll = graphop_selected_fcurve_poll;
1188
1189         /* flags */
1190         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1191
1192         /* properties */
1193         WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY);
1194         RNA_def_float(ot->srna, "low", 0.0f, 0.0, 100000.0, "Lowest frequency", "", 0.1, 1000.00);
1195         RNA_def_float(ot->srna, "high", 100000.0, 0.0, 100000.0, "Highest frequency", "", 0.1, 1000.00);
1196         RNA_def_float(ot->srna, "attack", 0.005, 0.0, 2.0, "Attack time", "", 0.01, 0.1);
1197         RNA_def_float(ot->srna, "release", 0.2, 0.0, 5.0, "Release time", "", 0.01, 0.2);
1198         RNA_def_float(ot->srna, "threshold", 0.0, 0.0, 1.0, "Threshold", "", 0.01, 0.1);
1199         RNA_def_boolean(ot->srna, "accumulate", 0, "Accumulate", "");
1200         RNA_def_boolean(ot->srna, "use_additive", 0, "Additive", "");
1201         RNA_def_boolean(ot->srna, "square", 0, "Square", "");
1202         RNA_def_float(ot->srna, "sthreshold", 0.1, 0.0, 1.0, "Square Threshold", "", 0.01, 0.1);
1203 }
1204
1205 /* ******************** Sample Keyframes Operator *********************** */
1206 /* This operator 'bakes' the values of the curve into new keyframes between pairs
1207  * of selected keyframes. It is useful for creating keyframes for tweaking overlap.
1208  */
1209
1210 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
1211 static void sample_graph_keys (bAnimContext *ac)
1212 {       
1213         ListBase anim_data = {NULL, NULL};
1214         bAnimListElem *ale;
1215         int filter;
1216         
1217         /* filter data */
1218         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1219         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1220         
1221         /* loop through filtered data and add keys between selected keyframes on every frame  */
1222         for (ale= anim_data.first; ale; ale= ale->next)
1223                 sample_fcurve((FCurve *)ale->key_data);
1224         
1225         /* admin and redraws */
1226         BLI_freelistN(&anim_data);
1227 }
1228
1229 /* ------------------- */
1230
1231 static int graphkeys_sample_exec(bContext *C, wmOperator *UNUSED(op))
1232 {
1233         bAnimContext ac;
1234         
1235         /* get editor data */
1236         if (ANIM_animdata_get_context(C, &ac) == 0)
1237                 return OPERATOR_CANCELLED;
1238         
1239         /* sample keyframes */
1240         sample_graph_keys(&ac);
1241         
1242         /* validate keyframes after editing */
1243         ANIM_editkeyframes_refresh(&ac);
1244         
1245         /* set notifier that keyframes have changed */
1246         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1247         
1248         return OPERATOR_FINISHED;
1249 }
1250  
1251 void GRAPH_OT_sample (wmOperatorType *ot)
1252 {
1253         /* identifiers */
1254         ot->name = "Sample Keyframes";
1255         ot->idname = "GRAPH_OT_sample";
1256         ot->description = "Add keyframes on every frame between the selected keyframes";
1257         
1258         /* api callbacks */
1259         ot->exec = graphkeys_sample_exec;
1260         ot->poll = graphop_editable_keyframes_poll;
1261         
1262         /* flags */
1263         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1264 }
1265
1266
1267 /* ************************************************************************** */
1268 /* SETTINGS STUFF */
1269
1270 /* ******************** Set Extrapolation-Type Operator *********************** */
1271
1272 /* defines for make/clear cyclic extrapolation tools */
1273 #define MAKE_CYCLIC_EXPO        -1
1274 #define CLEAR_CYCLIC_EXPO       -2
1275
1276 /* defines for set extrapolation-type for selected keyframes tool */
1277 static EnumPropertyItem prop_graphkeys_expo_types[] = {
1278         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
1279         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
1280         
1281         {MAKE_CYCLIC_EXPO, "MAKE_CYCLIC", 0, "Make Cyclic (F-Modifier)", "Add Cycles F-Modifier if one doesn't exist already"},
1282         {CLEAR_CYCLIC_EXPO, "CLEAR_CYCLIC", 0, "Clear Cyclic (F-Modifier)", "Remove Cycles F-Modifier if not needed anymore"},
1283         {0, NULL, 0, NULL, NULL}
1284 };
1285
1286 /* this function is responsible for setting extrapolation mode for keyframes */
1287 static void setexpo_graph_keys(bAnimContext *ac, short mode) 
1288 {
1289         ListBase anim_data = {NULL, NULL};
1290         bAnimListElem *ale;
1291         int filter;
1292         
1293         /* filter data */
1294         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1295         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1296         
1297         /* loop through setting mode per F-Curve */
1298         for (ale= anim_data.first; ale; ale= ale->next) {
1299                 FCurve *fcu= (FCurve *)ale->data;
1300                 
1301                 if (mode >= 0) {
1302                         /* just set mode setting */
1303                         fcu->extend= mode;
1304                 }
1305                 else {
1306                         /* shortcuts for managing Cycles F-Modifiers to make it easier to toggle cyclic animation 
1307                          * without having to go through FModifier UI in Graph Editor to do so
1308                          */
1309                         if (mode == MAKE_CYCLIC_EXPO) {
1310                                 /* only add if one doesn't exist */
1311                                 if (list_has_suitable_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, -1) == 0) {
1312                                         // TODO: add some more preset versions which set different extrapolation options?
1313                                         add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES);
1314                                 }
1315                         }
1316                         else if (mode == CLEAR_CYCLIC_EXPO) {
1317                                 /* remove all the modifiers fitting this description */
1318                                 FModifier *fcm, *fcn=NULL;
1319                                 
1320                                 for (fcm = fcu->modifiers.first; fcm; fcm = fcn) {
1321                                         fcn = fcm->next;
1322                                         
1323                                         if (fcm->type == FMODIFIER_TYPE_CYCLES)
1324                                                 remove_fmodifier(&fcu->modifiers, fcm);
1325                                 }
1326                         }
1327                 }
1328         }
1329         
1330         /* cleanup */
1331         BLI_freelistN(&anim_data);
1332 }
1333
1334 /* ------------------- */
1335
1336 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
1337 {
1338         bAnimContext ac;
1339         short mode;
1340         
1341         /* get editor data */
1342         if (ANIM_animdata_get_context(C, &ac) == 0)
1343                 return OPERATOR_CANCELLED;
1344                 
1345         /* get handle setting mode */
1346         mode= RNA_enum_get(op->ptr, "type");
1347         
1348         /* set handle type */
1349         setexpo_graph_keys(&ac, mode);
1350         
1351         /* validate keyframes after editing */
1352         ANIM_editkeyframes_refresh(&ac);
1353         
1354         /* set notifier that keyframe properties have changed */
1355         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1356         
1357         return OPERATOR_FINISHED;
1358 }
1359  
1360 void GRAPH_OT_extrapolation_type (wmOperatorType *ot)
1361 {
1362         /* identifiers */
1363         ot->name = "Set Keyframe Extrapolation";
1364         ot->idname = "GRAPH_OT_extrapolation_type";
1365         ot->description = "Set extrapolation mode for selected F-Curves";
1366         
1367         /* api callbacks */
1368         ot->invoke = WM_menu_invoke;
1369         ot->exec = graphkeys_expo_exec;
1370         ot->poll = graphop_editable_keyframes_poll;
1371         
1372         /* flags */
1373         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1374         
1375         /* id-props */
1376         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
1377 }
1378
1379 /* ******************** Set Interpolation-Type Operator *********************** */
1380
1381 /* this function is responsible for setting interpolation mode for keyframes */
1382 static void setipo_graph_keys(bAnimContext *ac, short mode) 
1383 {
1384         ListBase anim_data = {NULL, NULL};
1385         bAnimListElem *ale;
1386         int filter;
1387         KeyframeEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
1388         
1389         /* filter data */
1390         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1391         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1392         
1393         /* loop through setting BezTriple interpolation
1394          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1395          */
1396         for (ale= anim_data.first; ale; ale= ale->next)
1397                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1398         
1399         /* cleanup */
1400         BLI_freelistN(&anim_data);
1401 }
1402
1403 /* ------------------- */
1404
1405 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
1406 {
1407         bAnimContext ac;
1408         short mode;
1409         
1410         /* get editor data */
1411         if (ANIM_animdata_get_context(C, &ac) == 0)
1412                 return OPERATOR_CANCELLED;
1413                 
1414         /* get handle setting mode */
1415         mode= RNA_enum_get(op->ptr, "type");
1416         
1417         /* set handle type */
1418         setipo_graph_keys(&ac, mode);
1419         
1420         /* validate keyframes after editing */
1421         ANIM_editkeyframes_refresh(&ac);
1422         
1423         /* set notifier that keyframe properties have changed */
1424         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1425         
1426         return OPERATOR_FINISHED;
1427 }
1428  
1429 void GRAPH_OT_interpolation_type (wmOperatorType *ot)
1430 {
1431         /* identifiers */
1432         ot->name = "Set Keyframe Interpolation";
1433         ot->idname = "GRAPH_OT_interpolation_type";
1434         ot->description = "Set interpolation mode for the F-Curve segments starting from the selected keyframes";
1435         
1436         /* api callbacks */
1437         ot->invoke = WM_menu_invoke;
1438         ot->exec = graphkeys_ipo_exec;
1439         ot->poll = graphop_editable_keyframes_poll;
1440         
1441         /* flags */
1442         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1443         
1444         /* id-props */
1445         ot->prop = RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
1446 }
1447
1448 /* ******************** Set Handle-Type Operator *********************** */
1449
1450 /* this function is responsible for setting handle-type of selected keyframes */
1451 static void sethandles_graph_keys(bAnimContext *ac, short mode) 
1452 {
1453         ListBase anim_data = {NULL, NULL};
1454         bAnimListElem *ale;
1455         int filter;
1456         
1457         KeyframeEditFunc edit_cb= ANIM_editkeyframes_handles(mode);
1458         KeyframeEditFunc sel_cb= ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
1459         
1460         /* filter data */
1461         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1462         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1463         
1464         /* loop through setting flags for handles 
1465          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1466          */
1467         for (ale= anim_data.first; ale; ale= ale->next) {
1468                 FCurve *fcu= (FCurve *)ale->key_data;
1469                 
1470                 /* any selected keyframes for editing? */
1471                 if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, sel_cb, NULL)) {
1472                         /* change type of selected handles */
1473                         ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, edit_cb, calchandles_fcurve);
1474                 }
1475         }
1476         
1477         /* cleanup */
1478         BLI_freelistN(&anim_data);
1479 }
1480 /* ------------------- */
1481
1482 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
1483 {
1484         bAnimContext ac;
1485         short mode;
1486         
1487         /* get editor data */
1488         if (ANIM_animdata_get_context(C, &ac) == 0)
1489                 return OPERATOR_CANCELLED;
1490                 
1491         /* get handle setting mode */
1492         mode= RNA_enum_get(op->ptr, "type");
1493         
1494         /* set handle type */
1495         sethandles_graph_keys(&ac, mode);
1496         
1497         /* validate keyframes after editing */
1498         ANIM_editkeyframes_refresh(&ac);
1499         
1500         /* set notifier that keyframe properties have changed */
1501         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1502         
1503         return OPERATOR_FINISHED;
1504 }
1505  
1506  void GRAPH_OT_handle_type (wmOperatorType *ot)
1507 {
1508         /* identifiers */
1509         ot->name = "Set Keyframe Handle Type";
1510         ot->idname = "GRAPH_OT_handle_type";
1511         ot->description = "Set type of handle for selected keyframes";
1512         
1513         /* api callbacks */
1514         ot->invoke = WM_menu_invoke;
1515         ot->exec = graphkeys_handletype_exec;
1516         ot->poll = graphop_editable_keyframes_poll;
1517         
1518         /* flags */
1519         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1520         
1521         /* id-props */
1522         ot->prop = RNA_def_enum(ot->srna, "type", keyframe_handle_type_items, 0, "Type", "");
1523 }
1524
1525 /* ************************************************************************** */
1526 /* TRANSFORM STUFF */
1527
1528 /* ***************** 'Euler Filter' Operator **************************** */
1529 /* Euler filter tools (as seen in Maya), are necessary for working with 'baked'
1530  * rotation curves (with Euler rotations). The main purpose of such tools is to
1531  * resolve any discontinuities that may arise in the curves due to the clamping
1532  * of values to -180 degrees to 180 degrees.
1533  */
1534
1535 /* set of three euler-rotation F-Curves */
1536 typedef struct tEulerFilter {
1537         struct tEulerFilter *next, *prev;
1538         
1539         ID *id;                                                 /* ID-block which owns the channels */
1540         FCurve *(fcurves[3]);                   /* 3 Pointers to F-Curves */    
1541         char *rna_path;                                 /* Pointer to one of the RNA Path's used by one of the F-Curves */
1542 } tEulerFilter;
1543  
1544 static int graphkeys_euler_filter_exec (bContext *C, wmOperator *op)
1545 {
1546         bAnimContext ac;
1547         
1548         ListBase anim_data= {NULL, NULL};
1549         bAnimListElem *ale;
1550         int filter;
1551         
1552         ListBase eulers = {NULL, NULL};
1553         tEulerFilter *euf= NULL;
1554         int groups=0, failed=0;
1555         
1556         /* get editor data */
1557         if (ANIM_animdata_get_context(C, &ac) == 0)
1558                 return OPERATOR_CANCELLED;
1559                 
1560         /* The process is done in two passes:
1561          *       1) Sets of three related rotation curves are identified from the selected channels,
1562          *              and are stored as a single 'operation unit' for the next step
1563          *       2) Each set of three F-Curves is processed for each keyframe, with the values being
1564          *              processed as necessary
1565          */
1566          
1567         /* step 1: extract only the rotation f-curves */
1568         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1569         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1570         
1571         for (ale= anim_data.first; ale; ale= ale->next) {
1572                 FCurve *fcu = (FCurve *)ale->data;
1573                 
1574                 /* check if this is an appropriate F-Curve 
1575                  *      - only rotation curves
1576                  *      - for pchan curves, make sure we're only using the euler curves
1577                  */
1578                 if (strstr(fcu->rna_path, "rotation_euler") == NULL)
1579                         continue;
1580                 else if (ELEM3(fcu->array_index, 0, 1, 2) == 0) {
1581                         BKE_reportf(op->reports, RPT_WARNING,
1582                                 "Euler Rotation F-Curve has invalid index (ID='%s', Path='%s', Index=%d)", 
1583                                 (ale->id)? ale->id->name:"<No ID>", fcu->rna_path, fcu->array_index);
1584                         continue;
1585                 }
1586                 
1587                 /* optimization: assume that xyz curves will always be stored consecutively,
1588                  * so if the paths or the ID's don't match up, then a curve needs to be added 
1589                  * to a new group
1590                  */
1591                 if ((euf) && (euf->id == ale->id) && (strcmp(euf->rna_path, fcu->rna_path)==0)) {
1592                         /* this should be fine to add to the existing group then */
1593                         euf->fcurves[fcu->array_index]= fcu;
1594                 }
1595                 else {
1596                         /* just add to a new block */
1597                         euf= MEM_callocN(sizeof(tEulerFilter), "tEulerFilter");
1598                         BLI_addtail(&eulers, euf);
1599                         groups++;
1600                         
1601                         euf->id= ale->id;
1602                         euf->rna_path = fcu->rna_path; /* this should be safe, since we're only using it for a short time */
1603                         euf->fcurves[fcu->array_index]= fcu;
1604                 }
1605         }
1606         BLI_freelistN(&anim_data);
1607         
1608         if (groups == 0) {
1609                 BKE_report(op->reports, RPT_WARNING, "No Euler Rotation F-Curves to fix up");
1610                 return OPERATOR_CANCELLED;
1611         }
1612         
1613         /* step 2: go through each set of curves, processing the values at each keyframe 
1614          *      - it is assumed that there must be a full set of keyframes at each keyframe position
1615          */
1616         for (euf= eulers.first; euf; euf= euf->next) {
1617                 int f;
1618                 
1619                 /* sanity check: ensure that there are enough F-Curves to work on in this group */
1620                 // TODO: also enforce assumption that there be a full set of keyframes at each position by ensuring that totvert counts are same?
1621                 if (ELEM3(NULL, euf->fcurves[0], euf->fcurves[1], euf->fcurves[2])) {
1622                         /* report which components are missing */
1623                         BKE_reportf(op->reports, RPT_WARNING,
1624                                 "Missing %s%s%s component(s) of euler rotation for ID='%s' and RNA-Path='%s'",
1625                                 (euf->fcurves[0]==NULL)? "X":"",
1626                                 (euf->fcurves[1]==NULL)? "Y":"",
1627                                 (euf->fcurves[2]==NULL)? "Z":"",
1628                                 euf->id->name, euf->rna_path);
1629                                 
1630                         /* keep track of number of failed sets, and carry on to next group */
1631                         failed++;
1632                         continue;
1633                 }
1634                 
1635                 /* simple method: just treat any difference between keys of greater than 180 degrees as being a flip */
1636                 // FIXME: there are more complicated methods that will be needed to fix more cases than just some
1637                 for (f = 0; f < 3; f++) {
1638                         FCurve *fcu = euf->fcurves[f];
1639                         BezTriple *bezt, *prev=NULL;
1640                         unsigned int i;
1641                         
1642                         /* skip if not enough vets to do a decent analysis of... */
1643                         if (fcu->totvert <= 2)
1644                                 continue;
1645                         
1646                         /* prev follows bezt, bezt = "current" point to be fixed */
1647                         for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, prev=bezt, bezt++) {
1648                                 /* our method depends on determining a "difference" from the previous vert */
1649                                 if (prev == NULL)
1650                                         continue;
1651                                 
1652                                 /* > 180 degree flip? */
1653                                 if (fabs(prev->vec[1][1] - bezt->vec[1][1]) >= M_PI) {
1654                                         /* 360 degrees to add/subtract frame value until difference is acceptably small that there's no more flip */
1655                                         const float fac = 2.0f * (float)M_PI;
1656                                         
1657                                         if (prev->vec[1][1] > bezt->vec[1][1]) {
1658                                                 while (fabsf(bezt->vec[1][1] - prev->vec[1][1]) >= (float)M_PI) {
1659                                                         bezt->vec[0][1] += fac;
1660                                                         bezt->vec[1][1] += fac;
1661                                                         bezt->vec[2][1] += fac;
1662                                                 }
1663                                         }
1664                                         else /* if (prev->vec[1][1] < bezt->vec[1][1]) */ {
1665                                                 while (fabsf(bezt->vec[1][1] - prev->vec[1][1]) >= (float)M_PI) {
1666                                                         bezt->vec[0][1] -= fac;
1667                                                         bezt->vec[1][1] -= fac;
1668                                                         bezt->vec[2][1] -= fac;
1669                                                 }
1670                                         }
1671                                 }
1672                         }
1673                 }
1674         }
1675         BLI_freelistN(&eulers);
1676         
1677         /* updates + finishing warnings */
1678         if (failed == groups) {
1679                 BKE_report(op->reports, RPT_ERROR, 
1680                         "No Euler Rotations could be corrected, ensure each rotation has keys for all components, and that F-Curves for these are in consecutive XYZ order and selected");
1681                 return OPERATOR_CANCELLED;
1682         }
1683         else {
1684                 if (failed) {
1685                         BKE_report(op->reports, RPT_ERROR,
1686                                 "Some Euler Rotations couldn't be corrected due to missing/unselected/out-of-order F-Curves, ensure each rotation has keys for all components, and that F-Curves for these are in consecutive XYZ order and selected");
1687                 }
1688                 
1689                 /* validate keyframes after editing */
1690                 ANIM_editkeyframes_refresh(&ac);
1691                 
1692                 /* set notifier that keyframes have changed */
1693                 WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1694                 
1695                 /* done at last */
1696                 return OPERATOR_FINISHED;
1697         }
1698 }
1699  
1700 void GRAPH_OT_euler_filter (wmOperatorType *ot)
1701 {
1702         /* identifiers */
1703         ot->name = "Euler Discontinuity Filter";
1704         ot->idname = "GRAPH_OT_euler_filter";
1705         ot->description = "Fixes the most common causes of gimbal lock in the selected Euler Rotation F-Curves";
1706         
1707         /* api callbacks */
1708         ot->exec = graphkeys_euler_filter_exec;
1709         ot->poll = graphop_editable_keyframes_poll;
1710         
1711         /* flags */
1712         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1713 }
1714
1715 /* ***************** Jump to Selected Frames Operator *********************** */
1716
1717 /* snap current-frame indicator to 'average time' of selected keyframe */
1718 static int graphkeys_framejump_exec(bContext *C, wmOperator *UNUSED(op))
1719 {
1720         bAnimContext ac;
1721         ListBase anim_data= {NULL, NULL};
1722         bAnimListElem *ale;
1723         int filter;
1724         KeyframeEditData ked;
1725         
1726         /* get editor data */
1727         if (ANIM_animdata_get_context(C, &ac) == 0)
1728                 return OPERATOR_CANCELLED;
1729         
1730         /* init edit data */
1731         memset(&ked, 0, sizeof(KeyframeEditData));
1732         
1733         /* loop over action data, averaging values */
1734         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
1735         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1736         
1737         for (ale= anim_data.first; ale; ale= ale->next) {
1738                 AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
1739                 
1740                 /* apply unit corrections */
1741                 ANIM_unit_mapping_apply_fcurve(ac.scene, ale->id, ale->key_data, ANIM_UNITCONV_ONLYKEYS);
1742                 
1743                 if (adt) {
1744                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1745                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);
1746                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1); 
1747                 }
1748                 else
1749                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);
1750                 
1751                 /* unapply unit corrections */
1752                 ANIM_unit_mapping_apply_fcurve(ac.scene, ale->id, ale->key_data, ANIM_UNITCONV_RESTORE|ANIM_UNITCONV_ONLYKEYS);
1753         }
1754         
1755         BLI_freelistN(&anim_data);
1756         
1757         /* set the new current frame and cursor values, based on the average time and value */
1758         if (ked.i1) {
1759                 SpaceIpo *sipo= (SpaceIpo *)ac.sl;
1760                 Scene *scene= ac.scene;
1761                 
1762                 /* take the average values, rounding to the nearest int for the current frame */
1763                 CFRA= (int)floor((ked.f1 / ked.i1) + 0.5f);
1764                 SUBFRA= 0.f;
1765                 sipo->cursorVal= ked.f2 / (float)ked.i1;
1766         }
1767         
1768         /* set notifier that things have changed */
1769         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1770         
1771         return OPERATOR_FINISHED;
1772 }
1773
1774 void GRAPH_OT_frame_jump (wmOperatorType *ot)
1775 {
1776         /* identifiers */
1777         ot->name = "Jump to Frame";
1778         ot->idname = "GRAPH_OT_frame_jump";
1779         ot->description = "Set the current frame to the average frame of the selected keyframes";
1780         
1781         /* api callbacks */
1782         ot->exec = graphkeys_framejump_exec;
1783         ot->poll = graphop_visible_keyframes_poll;
1784         
1785         /* flags */
1786         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1787 }
1788
1789 /* ******************** Snap Keyframes Operator *********************** */
1790
1791 /* defines for snap keyframes tool */
1792 static EnumPropertyItem prop_graphkeys_snap_types[] = {
1793         {GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current Frame", ""},
1794         {GRAPHKEYS_SNAP_VALUE, "VALUE", 0, "Cursor Value", ""},
1795         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
1796         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
1797         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
1798         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles", ""},
1799         {0, NULL, 0, NULL, NULL}
1800 };
1801
1802 /* this function is responsible for snapping keyframes to frame-times */
1803 static void snap_graph_keys(bAnimContext *ac, short mode) 
1804 {
1805         ListBase anim_data = {NULL, NULL};
1806         bAnimListElem *ale;
1807         int filter;
1808         
1809         KeyframeEditData ked;
1810         KeyframeEditFunc edit_cb;
1811         
1812         /* filter data */
1813         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1814         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1815         
1816         /* get beztriple editing callbacks */
1817         edit_cb= ANIM_editkeyframes_snap(mode);
1818         
1819         memset(&ked, 0, sizeof(KeyframeEditData)); 
1820         ked.scene= ac->scene;
1821         if (mode == GRAPHKEYS_SNAP_NEAREST_MARKER) {
1822                 ked.list.first= (ac->markers) ? ac->markers->first : NULL;
1823                 ked.list.last= (ac->markers) ? ac->markers->last : NULL;
1824         }
1825         else if (mode == GRAPHKEYS_SNAP_VALUE) {
1826                 SpaceIpo *sipo= (SpaceIpo *)ac->sl;
1827                 ked.f1= (sipo) ? sipo->cursorVal : 0.0f;
1828         }
1829         
1830         /* snap keyframes */
1831         for (ale= anim_data.first; ale; ale= ale->next) {
1832                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1833                 
1834                 /* apply unit corrections */
1835                 ANIM_unit_mapping_apply_fcurve(ac->scene, ale->id, ale->key_data, 0);
1836                 
1837                 if (adt) {
1838                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1839                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1840                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1841                 }
1842                 else 
1843                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1844                         
1845                 /* apply unit corrections */
1846                 ANIM_unit_mapping_apply_fcurve(ac->scene, ale->id, ale->key_data, ANIM_UNITCONV_RESTORE);
1847         }
1848         
1849         BLI_freelistN(&anim_data);
1850 }
1851
1852 /* ------------------- */
1853
1854 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
1855 {
1856         bAnimContext ac;
1857         short mode;
1858         
1859         /* get editor data */
1860         if (ANIM_animdata_get_context(C, &ac) == 0)
1861                 return OPERATOR_CANCELLED;
1862                 
1863         /* get snapping mode */
1864         mode= RNA_enum_get(op->ptr, "type");
1865         
1866         /* snap keyframes */
1867         snap_graph_keys(&ac, mode);
1868         
1869         /* validate keyframes after editing */
1870         ANIM_editkeyframes_refresh(&ac);
1871         
1872         /* set notifier that keyframes have changed */
1873         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1874         
1875         return OPERATOR_FINISHED;
1876 }
1877  
1878 void GRAPH_OT_snap (wmOperatorType *ot)
1879 {
1880         /* identifiers */
1881         ot->name = "Snap Keys";
1882         ot->idname = "GRAPH_OT_snap";
1883         ot->description = "Snap selected keyframes to the chosen times/values";
1884         
1885         /* api callbacks */
1886         ot->invoke = WM_menu_invoke;
1887         ot->exec = graphkeys_snap_exec;
1888         ot->poll = graphop_editable_keyframes_poll;
1889         
1890         /* flags */
1891         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1892         
1893         /* id-props */
1894         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
1895 }
1896
1897 /* ******************** Mirror Keyframes Operator *********************** */
1898
1899 /* defines for mirror keyframes tool */
1900 static EnumPropertyItem prop_graphkeys_mirror_types[] = {
1901         {GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current Frame", ""},
1902         {GRAPHKEYS_MIRROR_VALUE, "VALUE", 0, "By Values over Cursor Value", ""},
1903         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "By Times over Time=0", ""},
1904         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0", ""},
1905         {GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker", ""},
1906         {0, NULL, 0, NULL, NULL}
1907 };
1908
1909 /* this function is responsible for mirroring keyframes */
1910 static void mirror_graph_keys(bAnimContext *ac, short mode) 
1911 {
1912         ListBase anim_data = {NULL, NULL};
1913         bAnimListElem *ale;
1914         int filter;
1915         
1916         KeyframeEditData ked;
1917         KeyframeEditFunc edit_cb;
1918         
1919         /* get beztriple editing callbacks */
1920         edit_cb= ANIM_editkeyframes_mirror(mode);
1921         
1922         memset(&ked, 0, sizeof(KeyframeEditData)); 
1923         ked.scene= ac->scene;
1924         
1925         /* for 'first selected marker' mode, need to find first selected marker first! */
1926         // XXX should this be made into a helper func in the API?
1927         if (mode == GRAPHKEYS_MIRROR_MARKER) {
1928                 TimeMarker *marker= NULL;
1929                 
1930                 /* find first selected marker */
1931                 marker= ED_markers_get_first_selected(ac->markers);
1932                 
1933                 /* store marker's time (if available) */
1934                 if (marker)
1935                         ked.f1= (float)marker->frame;
1936                 else
1937                         return;
1938         }
1939         else if (mode == GRAPHKEYS_MIRROR_VALUE) {
1940                 SpaceIpo *sipo= (SpaceIpo *)ac->sl;
1941                 ked.f1= (sipo) ? sipo->cursorVal : 0.0f;
1942         }
1943         
1944         /* filter data */
1945         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1946         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1947         
1948         /* mirror keyframes */
1949         for (ale= anim_data.first; ale; ale= ale->next) {
1950                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1951                 
1952                 /* apply unit corrections */
1953                 ANIM_unit_mapping_apply_fcurve(ac->scene, ale->id, ale->key_data, ANIM_UNITCONV_ONLYKEYS);
1954                 
1955                 if (adt) {
1956                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1957                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1958                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1959                 }
1960                 else 
1961                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1962                         
1963                 /* unapply unit corrections */
1964                 ANIM_unit_mapping_apply_fcurve(ac->scene, ale->id, ale->key_data, ANIM_UNITCONV_ONLYKEYS|ANIM_UNITCONV_RESTORE);
1965         }
1966         
1967         BLI_freelistN(&anim_data);
1968 }
1969
1970 /* ------------------- */
1971
1972 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
1973 {
1974         bAnimContext ac;
1975         short mode;
1976         
1977         /* get editor data */
1978         if (ANIM_animdata_get_context(C, &ac) == 0)
1979                 return OPERATOR_CANCELLED;
1980                 
1981         /* get mirroring mode */
1982         mode= RNA_enum_get(op->ptr, "type");
1983         
1984         /* mirror keyframes */
1985         mirror_graph_keys(&ac, mode);
1986         
1987         /* validate keyframes after editing */
1988         ANIM_editkeyframes_refresh(&ac);
1989         
1990         /* set notifier that keyframes have changed */
1991         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1992         
1993         return OPERATOR_FINISHED;
1994 }
1995  
1996 void GRAPH_OT_mirror (wmOperatorType *ot)
1997 {
1998         /* identifiers */
1999         ot->name = "Mirror Keys";
2000         ot->idname = "GRAPH_OT_mirror";
2001         ot->description = "Flip selected keyframes over the selected mirror line";
2002         
2003         /* api callbacks */
2004         ot->invoke = WM_menu_invoke;
2005         ot->exec = graphkeys_mirror_exec;
2006         ot->poll = graphop_editable_keyframes_poll;
2007         
2008         /* flags */
2009         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
2010         
2011         /* id-props */
2012         ot->prop = RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
2013 }
2014
2015 /* ******************** Smooth Keyframes Operator *********************** */
2016
2017 static int graphkeys_smooth_exec(bContext *C, wmOperator *UNUSED(op))
2018 {
2019         bAnimContext ac;
2020         ListBase anim_data = {NULL, NULL};
2021         bAnimListElem *ale;
2022         int filter;
2023         
2024         /* get editor data */
2025         if (ANIM_animdata_get_context(C, &ac) == 0)
2026                 return OPERATOR_CANCELLED;
2027         
2028         /* filter data */
2029         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2030         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2031         
2032         /* smooth keyframes */
2033         for (ale= anim_data.first; ale; ale= ale->next) {
2034                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
2035                  * Perhaps the mode argument could be removed, as that functionality is offerred through 
2036                  * Snap->Flatten Handles anyway.
2037                  */
2038                 smooth_fcurve(ale->key_data);
2039         }
2040         BLI_freelistN(&anim_data);
2041         
2042         /* validate keyframes after editing */
2043         ANIM_editkeyframes_refresh(&ac);
2044         
2045         /* set notifier that keyframes have changed */
2046         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
2047         
2048         return OPERATOR_FINISHED;
2049 }
2050  
2051 void GRAPH_OT_smooth (wmOperatorType *ot)
2052 {
2053         /* identifiers */
2054         ot->name = "Smooth Keys";
2055         ot->idname = "GRAPH_OT_smooth";
2056         ot->description = "Apply weighted moving means to make selected F-Curves less bumpy";
2057         
2058         /* api callbacks */
2059         ot->exec = graphkeys_smooth_exec;
2060         ot->poll = graphop_editable_keyframes_poll;
2061         
2062         /* flags */
2063         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
2064 }
2065
2066 /* ************************************************************************** */
2067 /* F-CURVE MODIFIERS */
2068
2069 /* ******************** Add F-Modifier Operator *********************** */
2070
2071 /* present a special customised popup menu for this, with some filtering */
2072 static int graph_fmodifier_add_invoke (bContext *C, wmOperator *op, wmEvent *UNUSED(event))
2073 {
2074         wmOperatorType *ot = WM_operatortype_find("GRAPH_OT_fmodifier_add", 1);
2075         uiPopupMenu *pup;
2076         uiLayout *layout;
2077         int i;
2078         
2079         pup= uiPupMenuBegin(C, IFACE_("Add F-Curve Modifier"), ICON_NONE);
2080         layout= uiPupMenuLayout(pup);
2081         
2082         /* start from 1 to skip the 'Invalid' modifier type */
2083         for (i = 1; i < FMODIFIER_NUM_TYPES; i++) {
2084                 FModifierTypeInfo *fmi= get_fmodifier_typeinfo(i);
2085                 PointerRNA props_ptr;
2086                 
2087                 /* check if modifier is valid for this context */
2088                 if (fmi == NULL)
2089                         continue;
2090                 
2091                 /* create operator menu item with relevant properties filled in */
2092                 props_ptr= uiItemFullO_ptr(layout, ot, IFACE_(fmi->name), ICON_NONE,
2093                                            NULL, WM_OP_EXEC_REGION_WIN, UI_ITEM_O_RETURN_PROPS);
2094                         /* the only thing that gets set from the menu is the type of F-Modifier to add */
2095                 RNA_enum_set(&props_ptr, "type", i);
2096                         /* the following properties are just repeats of existing ones... */
2097                 RNA_boolean_set(&props_ptr, "only_active", RNA_boolean_get(op->ptr, "only_active"));
2098         }
2099         uiItemS(layout);
2100         
2101         uiPupMenuEnd(C, pup);
2102         
2103         return OPERATOR_CANCELLED;
2104 }
2105
2106 static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
2107 {
2108         bAnimContext ac;
2109         ListBase anim_data = {NULL, NULL};
2110         bAnimListElem *ale;
2111         int filter;
2112         short type;
2113         
2114         /* get editor data */
2115         if (ANIM_animdata_get_context(C, &ac) == 0)
2116                 return OPERATOR_CANCELLED;
2117         
2118         /* get type of modifier to add */
2119         type= RNA_enum_get(op->ptr, "type");
2120         
2121         /* filter data */
2122         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2123         if (RNA_boolean_get(op->ptr, "only_active"))
2124                 filter |= ANIMFILTER_ACTIVE; // FIXME: enforce in this case only a single channel to get handled?
2125         else
2126                 filter |= (ANIMFILTER_SEL|ANIMFILTER_CURVE_VISIBLE);
2127         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2128         
2129         /* add f-modifier to each curve */
2130         for (ale= anim_data.first; ale; ale= ale->next) {
2131                 FCurve *fcu= (FCurve *)ale->data;
2132                 FModifier *fcm;
2133                 
2134                 /* add F-Modifier of specified type to active F-Curve, and make it the active one */
2135                 fcm= add_fmodifier(&fcu->modifiers, type);
2136                 if (fcm)
2137                         set_active_fmodifier(&fcu->modifiers, fcm);
2138                 else {
2139                         BKE_report(op->reports, RPT_ERROR, "Modifier couldn't be added, see console for details");
2140                         break;
2141                 }
2142         }
2143         BLI_freelistN(&anim_data);
2144         
2145         /* validate keyframes after editing */
2146         ANIM_editkeyframes_refresh(&ac);
2147         
2148         /* set notifier that things have changed */
2149         // FIXME: this really isn't the best description for it...
2150         WM_event_add_notifier(C, NC_ANIMATION, NULL);
2151         
2152         return OPERATOR_FINISHED;
2153 }
2154  
2155 void GRAPH_OT_fmodifier_add (wmOperatorType *ot)
2156 {
2157         /* identifiers */
2158         ot->name = "Add F-Curve Modifier";
2159         ot->idname = "GRAPH_OT_fmodifier_add";
2160         ot->description = "Add F-Modifiers to the selected F-Curves";
2161         
2162         /* api callbacks */
2163         ot->invoke = graph_fmodifier_add_invoke;
2164         ot->exec = graph_fmodifier_add_exec;
2165         ot->poll = graphop_selected_fcurve_poll; 
2166         
2167         /* flags */
2168         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
2169         
2170         /* id-props */
2171         ot->prop = RNA_def_enum(ot->srna, "type", fmodifier_type_items, 0, "Type", "");
2172         RNA_def_boolean(ot->srna, "only_active", 1, "Only Active", "Only add F-Modifier to active F-Curve");
2173 }
2174
2175 /* ******************** Copy F-Modifiers Operator *********************** */
2176
2177 static int graph_fmodifier_copy_exec(bContext *C, wmOperator *op)
2178 {
2179         bAnimContext ac;
2180         bAnimListElem *ale;
2181         short ok = 0;
2182         
2183         /* get editor data */
2184         if (ANIM_animdata_get_context(C, &ac) == 0)
2185                 return OPERATOR_CANCELLED;
2186         
2187         /* clear buffer first */
2188         free_fmodifiers_copybuf();
2189         
2190         /* get the active F-Curve */
2191         ale= get_active_fcurve_channel(&ac);
2192         
2193         /* if this exists, call the copy F-Modifiers API function */
2194         if (ale && ale->data) {
2195                 FCurve *fcu= (FCurve *)ale->data;
2196                 
2197                 // TODO: when 'active' vs 'all' boolean is added, change last param!
2198                 ok= ANIM_fmodifiers_copy_to_buf(&fcu->modifiers, 0);
2199                 
2200                 /* free temp data now */
2201                 MEM_freeN(ale);
2202         }
2203         
2204         /* successful or not? */
2205         if (ok == 0) {
2206                 BKE_report(op->reports, RPT_ERROR, "No F-Modifiers available to be copied");
2207                 return OPERATOR_CANCELLED;
2208         }
2209         else
2210                 return OPERATOR_FINISHED;
2211 }
2212  
2213 void GRAPH_OT_fmodifier_copy (wmOperatorType *ot)
2214 {
2215         /* identifiers */
2216         ot->name = "Copy F-Modifiers";
2217         ot->idname = "GRAPH_OT_fmodifier_copy";
2218         ot->description = "Copy the F-Modifier(s) of the active F-Curve";
2219         
2220         /* api callbacks */
2221         ot->exec = graph_fmodifier_copy_exec;
2222         ot->poll = graphop_active_fcurve_poll; 
2223         
2224         /* flags */
2225         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
2226         
2227         /* id-props */
2228         //ot->prop = RNA_def_boolean(ot->srna, "all", 1, "All F-Modifiers", "Copy all the F-Modifiers, instead of just the active one");
2229 }
2230
2231 /* ******************** Paste F-Modifiers Operator *********************** */
2232
2233 static int graph_fmodifier_paste_exec(bContext *C, wmOperator *op)
2234 {
2235         bAnimContext ac;
2236         ListBase anim_data = {NULL, NULL};
2237         bAnimListElem *ale;
2238         int filter, ok=0;
2239         
2240         /* get editor data */
2241         if (ANIM_animdata_get_context(C, &ac) == 0)
2242                 return OPERATOR_CANCELLED;
2243         
2244         /* filter data */
2245         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT);
2246         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2247         
2248         /* paste modifiers */
2249         for (ale = anim_data.first; ale; ale = ale->next) {
2250                 FCurve *fcu= (FCurve *)ale->data;
2251                 
2252                 // TODO: do we want to replace existing modifiers? add user pref for that!
2253                 ok += ANIM_fmodifiers_paste_from_buf(&fcu->modifiers, 0);
2254         }
2255         
2256         /* clean up */
2257         BLI_freelistN(&anim_data);
2258         
2259         /* successful or not? */
2260         if (ok) {
2261                 /* validate keyframes after editing */
2262                 ANIM_editkeyframes_refresh(&ac);
2263                 
2264                 /* set notifier that keyframes have changed */
2265                 WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
2266                 
2267                 return OPERATOR_FINISHED;
2268         }
2269         else {
2270                 BKE_report(op->reports, RPT_ERROR, "No F-Modifiers to paste");
2271                 return OPERATOR_CANCELLED;
2272         }
2273 }
2274  
2275 void GRAPH_OT_fmodifier_paste (wmOperatorType *ot)
2276 {
2277         /* identifiers */
2278         ot->name = "Paste F-Modifiers";
2279         ot->idname = "GRAPH_OT_fmodifier_paste";
2280         ot->description = "Add copied F-Modifiers to the selected F-Curves";
2281         
2282         /* api callbacks */
2283         ot->exec = graph_fmodifier_paste_exec;
2284         ot->poll = graphop_active_fcurve_poll;
2285         
2286         /* flags */
2287         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
2288 }
2289
2290 /* ************************************************************************** */