svn merge -r39781:39792 https://svn.blender.org/svnroot/bf-blender/trunk/blender...
[blender-staging.git] / source / blender / editors / space_graph / graph_edit.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 /** \file blender/editors/space_graph/graph_edit.c
31  *  \ingroup spgraph
32  */
33
34
35 #include <math.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <float.h>
39
40 #ifdef WITH_AUDASPACE
41 #  include "AUD_C-API.h"
42 #endif
43
44 #include "MEM_guardedalloc.h"
45
46 #include "BLI_blenlib.h"
47 #include "BLI_math.h"
48 #include "BLI_utildefines.h"
49
50 #include "DNA_anim_types.h"
51 #include "DNA_object_types.h"
52 #include "DNA_scene_types.h"
53
54 #include "RNA_access.h"
55 #include "RNA_define.h"
56 #include "RNA_enum_types.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         if(ac.reports==NULL) {
733                 ac.reports= op->reports;
734         }
735
736         /* paste keyframes */
737         if (paste_graph_keys(&ac, offset_mode, merge_mode)) {
738                 return OPERATOR_CANCELLED;
739         }
740         
741         /* validate keyframes after editing */
742         ANIM_editkeyframes_refresh(&ac);
743         
744         /* set notifier that keyframes have changed */
745         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
746         
747         return OPERATOR_FINISHED;
748 }
749  
750 void GRAPH_OT_paste (wmOperatorType *ot)
751 {
752         /* identifiers */
753         ot->name= "Paste Keyframes";
754         ot->idname= "GRAPH_OT_paste";
755         ot->description= "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame";
756         
757         /* api callbacks */
758 //      ot->invoke= WM_operator_props_popup; // better wait for graph redo panel
759         ot->exec= graphkeys_paste_exec;
760         ot->poll= graphop_editable_keyframes_poll;
761         
762         /* flags */
763         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
764
765         RNA_def_enum(ot->srna, "offset", keyframe_paste_offset_items, KEYFRAME_PASTE_OFFSET_CFRA_START, "Offset", "Paste time offset of keys");
766         RNA_def_enum(ot->srna, "merge", keyframe_paste_merge_items, KEYFRAME_PASTE_MERGE_MIX, "Type", "Method of merking pasted keys and existing");
767 }
768
769 /* ******************** Duplicate Keyframes Operator ************************* */
770
771 static void duplicate_graph_keys (bAnimContext *ac)
772 {
773         ListBase anim_data = {NULL, NULL};
774         bAnimListElem *ale;
775         int filter;
776         
777         /* filter data */
778         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
779         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
780         
781         /* loop through filtered data and delete selected keys */
782         for (ale= anim_data.first; ale; ale= ale->next) {
783                 duplicate_fcurve_keys((FCurve *)ale->key_data);
784         }
785         
786         /* free filtered list */
787         BLI_freelistN(&anim_data);
788 }
789
790 /* ------------------- */
791
792 static int graphkeys_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
793 {
794         bAnimContext ac;
795         
796         /* get editor data */
797         if (ANIM_animdata_get_context(C, &ac) == 0)
798                 return OPERATOR_CANCELLED;
799                 
800         /* duplicate keyframes */
801         duplicate_graph_keys(&ac);
802         
803         /* validate keyframes after editing */
804         ANIM_editkeyframes_refresh(&ac);
805         
806         /* set notifier that keyframes have changed */
807         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
808         
809         return OPERATOR_FINISHED;
810 }
811
812 static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
813 {
814         graphkeys_duplicate_exec(C, op);
815
816         return OPERATOR_FINISHED;
817 }
818  
819 void GRAPH_OT_duplicate (wmOperatorType *ot)
820 {
821         /* identifiers */
822         ot->name= "Duplicate Keyframes";
823         ot->idname= "GRAPH_OT_duplicate";
824         ot->description= "Make a copy of all selected keyframes";
825         
826         /* api callbacks */
827         ot->invoke= graphkeys_duplicate_invoke;
828         ot->exec= graphkeys_duplicate_exec;
829         ot->poll= graphop_editable_keyframes_poll;
830         
831         /* flags */
832         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
833         
834         /* to give to transform */
835         RNA_def_enum(ot->srna, "mode", transform_mode_types, TFM_TRANSLATION, "Mode", "");
836 }
837
838 /* ******************** Delete Keyframes Operator ************************* */
839
840 static void delete_graph_keys (bAnimContext *ac)
841 {
842         ListBase anim_data = {NULL, NULL};
843         bAnimListElem *ale;
844         int filter;
845         
846         /* filter data */
847         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
848         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
849         
850         /* loop through filtered data and delete selected keys */
851         for (ale= anim_data.first; ale; ale= ale->next) {
852                 FCurve *fcu= (FCurve *)ale->key_data;
853                 AnimData *adt= ale->adt;
854                 
855                 /* delete selected keyframes only */
856                 delete_fcurve_keys(fcu); 
857                 
858                 /* Only delete curve too if it won't be doing anything anymore */
859                 if ((fcu->totvert == 0) && (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0))
860                         ANIM_fcurve_delete_from_animdata(ac, adt, fcu);
861         }
862         
863         /* free filtered list */
864         BLI_freelistN(&anim_data);
865 }
866
867 /* ------------------- */
868
869 static int graphkeys_delete_exec(bContext *C, wmOperator *UNUSED(op))
870 {
871         bAnimContext ac;
872         
873         /* get editor data */
874         if (ANIM_animdata_get_context(C, &ac) == 0)
875                 return OPERATOR_CANCELLED;
876                 
877         /* delete keyframes */
878         delete_graph_keys(&ac);
879         
880         /* validate keyframes after editing */
881         ANIM_editkeyframes_refresh(&ac);
882         
883         /* set notifier that keyframes have changed */
884         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
885         
886         return OPERATOR_FINISHED;
887 }
888  
889 void GRAPH_OT_delete (wmOperatorType *ot)
890 {
891         /* identifiers */
892         ot->name= "Delete Keyframes";
893         ot->idname= "GRAPH_OT_delete";
894         ot->description= "Remove all selected keyframes";
895         
896         /* api callbacks */
897         ot->invoke= WM_operator_confirm;
898         ot->exec= graphkeys_delete_exec;
899         ot->poll= graphop_editable_keyframes_poll;
900         
901         /* flags */
902         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
903 }
904
905 /* ******************** Clean Keyframes Operator ************************* */
906
907 static void clean_graph_keys (bAnimContext *ac, float thresh)
908 {       
909         ListBase anim_data = {NULL, NULL};
910         bAnimListElem *ale;
911         int filter;
912         
913         /* filter data */
914         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);
915         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
916         
917         /* loop through filtered data and clean curves */
918         for (ale= anim_data.first; ale; ale= ale->next)
919                 clean_fcurve((FCurve *)ale->key_data, thresh);
920         
921         /* free temp data */
922         BLI_freelistN(&anim_data);
923 }
924
925 /* ------------------- */
926
927 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
928 {
929         bAnimContext ac;
930         float thresh;
931         
932         /* get editor data */
933         if (ANIM_animdata_get_context(C, &ac) == 0)
934                 return OPERATOR_CANCELLED;
935                 
936         /* get cleaning threshold */
937         thresh= RNA_float_get(op->ptr, "threshold");
938         
939         /* clean keyframes */
940         clean_graph_keys(&ac, thresh);
941         
942         /* validate keyframes after editing */
943         ANIM_editkeyframes_refresh(&ac);
944         
945         /* set notifier that keyframes have changed */
946         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
947         
948         return OPERATOR_FINISHED;
949 }
950  
951 void GRAPH_OT_clean (wmOperatorType *ot)
952 {
953         /* identifiers */
954         ot->name= "Clean Keyframes";
955         ot->idname= "GRAPH_OT_clean";
956         ot->description= "Simplify F-Curves by removing closely spaced keyframes";
957         
958         /* api callbacks */
959         //ot->invoke=  // XXX we need that number popup for this! 
960         ot->exec= graphkeys_clean_exec;
961         ot->poll= graphop_editable_keyframes_poll;
962         
963         /* flags */
964         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
965         
966         /* properties */
967         ot->prop= RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
968 }
969
970 /* ******************** Bake F-Curve Operator *********************** */
971 /* This operator bakes the data of the selected F-Curves to F-Points */
972
973 /* Bake each F-Curve into a set of samples */
974 static void bake_graph_curves (bAnimContext *ac, int start, int end)
975 {       
976         ListBase anim_data = {NULL, NULL};
977         bAnimListElem *ale;
978         int filter;
979         
980         /* filter data */
981         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
982         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
983         
984         /* loop through filtered data and add keys between selected keyframes on every frame  */
985         for (ale= anim_data.first; ale; ale= ale->next) {
986                 FCurve *fcu= (FCurve *)ale->key_data;
987                 ChannelDriver *driver= fcu->driver;
988                 
989                 /* disable driver so that it don't muck up the sampling process */
990                 fcu->driver= NULL;
991                 
992                 /* create samples */
993                 fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
994                 
995                 /* restore driver */
996                 fcu->driver= driver;
997         }
998         
999         /* admin and redraws */
1000         BLI_freelistN(&anim_data);
1001 }
1002
1003 /* ------------------- */
1004
1005 static int graphkeys_bake_exec(bContext *C, wmOperator *UNUSED(op))
1006 {
1007         bAnimContext ac;
1008         Scene *scene= NULL;
1009         int start, end;
1010         
1011         /* get editor data */
1012         if (ANIM_animdata_get_context(C, &ac) == 0)
1013                 return OPERATOR_CANCELLED;
1014                 
1015         /* for now, init start/end from preview-range extents */
1016         // TODO: add properties for this 
1017         scene= ac.scene;
1018         start= PSFRA;
1019         end= PEFRA;
1020         
1021         /* bake keyframes */
1022         bake_graph_curves(&ac, start, end);
1023         
1024         /* validate keyframes after editing */
1025         ANIM_editkeyframes_refresh(&ac);
1026         
1027         /* set notifier that keyframes have changed */
1028         // NOTE: some distinction between order/number of keyframes and type should be made?
1029         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1030         
1031         return OPERATOR_FINISHED;
1032 }
1033  
1034 void GRAPH_OT_bake (wmOperatorType *ot)
1035 {
1036         /* identifiers */
1037         ot->name= "Bake Curve";
1038         ot->idname= "GRAPH_OT_bake";
1039         ot->description= "Bake selected F-Curves to a set of sampled points defining a similar curve";
1040         
1041         /* api callbacks */
1042         ot->invoke= WM_operator_confirm; // FIXME...
1043         ot->exec= graphkeys_bake_exec;
1044         ot->poll= graphop_selected_fcurve_poll; 
1045         
1046         /* flags */
1047         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1048         
1049         // todo: add props for start/end frames
1050 }
1051
1052 /* ******************** Sound Bake F-Curve Operator *********************** */
1053 /* This operator bakes the given sound to the selected F-Curves */
1054
1055 /* ------------------- */
1056
1057 /* Custom data storage passed to the F-Sample-ing function,
1058  * which provides the necessary info for baking the sound
1059  */
1060 typedef struct tSoundBakeInfo {
1061         float *samples;
1062         int length;
1063         int cfra;
1064 } tSoundBakeInfo;
1065
1066 /* ------------------- */
1067
1068 /* Sampling callback used to determine the value from the sound to
1069  * save in the F-Curve at the specified frame
1070  */
1071 static float fcurve_samplingcb_sound (FCurve *UNUSED(fcu), void *data, float evaltime)
1072 {
1073         tSoundBakeInfo *sbi= (tSoundBakeInfo *)data;
1074
1075         int position = evaltime - sbi->cfra;
1076         if((position < 0) || (position >= sbi->length))
1077                 return 0.0f;
1078
1079         return sbi->samples[position];
1080 }
1081
1082 /* ------------------- */
1083
1084 #ifdef WITH_AUDASPACE
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);
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                 /* optimisation: 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         uiPopupMenu *pup;
2075         uiLayout *layout;
2076         int i;
2077         
2078         pup= uiPupMenuBegin(C, "Add F-Curve Modifier", ICON_NONE);
2079         layout= uiPupMenuLayout(pup);
2080         
2081         /* start from 1 to skip the 'Invalid' modifier type */
2082         for (i = 1; i < FMODIFIER_NUM_TYPES; i++) {
2083                 FModifierTypeInfo *fmi= get_fmodifier_typeinfo(i);
2084                 PointerRNA props_ptr;
2085                 
2086                 /* check if modifier is valid for this context */
2087                 if (fmi == NULL)
2088                         continue;
2089                 
2090                 /* create operator menu item with relevant properties filled in */
2091                 props_ptr= uiItemFullO(layout, "GRAPH_OT_fmodifier_add", fmi->name, ICON_NONE, NULL, WM_OP_EXEC_REGION_WIN, UI_ITEM_O_RETURN_PROPS);
2092                         /* the only thing that gets set from the menu is the type of F-Modifier to add */
2093                 RNA_enum_set(&props_ptr, "type", i);
2094                         /* the following properties are just repeats of existing ones... */
2095                 RNA_boolean_set(&props_ptr, "only_active", RNA_boolean_get(op->ptr, "only_active"));
2096         }
2097         uiItemS(layout);
2098         
2099         uiPupMenuEnd(C, pup);
2100         
2101         return OPERATOR_CANCELLED;
2102 }
2103
2104 static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
2105 {
2106         bAnimContext ac;
2107         ListBase anim_data = {NULL, NULL};
2108         bAnimListElem *ale;
2109         int filter;
2110         short type;
2111         
2112         /* get editor data */
2113         if (ANIM_animdata_get_context(C, &ac) == 0)
2114                 return OPERATOR_CANCELLED;
2115         
2116         /* get type of modifier to add */
2117         type= RNA_enum_get(op->ptr, "type");
2118         
2119         /* filter data */
2120         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
2121         if (RNA_boolean_get(op->ptr, "only_active"))
2122                 filter |= ANIMFILTER_ACTIVE; // FIXME: enforce in this case only a single channel to get handled?
2123         else
2124                 filter |= (ANIMFILTER_SEL|ANIMFILTER_CURVE_VISIBLE);
2125         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2126         
2127         /* add f-modifier to each curve */
2128         for (ale= anim_data.first; ale; ale= ale->next) {
2129                 FCurve *fcu= (FCurve *)ale->data;
2130                 FModifier *fcm;
2131                 
2132                 /* add F-Modifier of specified type to active F-Curve, and make it the active one */
2133                 fcm= add_fmodifier(&fcu->modifiers, type);
2134                 if (fcm)
2135                         set_active_fmodifier(&fcu->modifiers, fcm);
2136                 else {
2137                         BKE_report(op->reports, RPT_ERROR, "Modifier couldn't be added. See console for details.");
2138                         break;
2139                 }
2140         }
2141         BLI_freelistN(&anim_data);
2142         
2143         /* validate keyframes after editing */
2144         ANIM_editkeyframes_refresh(&ac);
2145         
2146         /* set notifier that things have changed */
2147         // FIXME: this really isn't the best description for it...
2148         WM_event_add_notifier(C, NC_ANIMATION, NULL);
2149         
2150         return OPERATOR_FINISHED;
2151 }
2152  
2153 void GRAPH_OT_fmodifier_add (wmOperatorType *ot)
2154 {
2155         /* identifiers */
2156         ot->name= "Add F-Curve Modifier";
2157         ot->idname= "GRAPH_OT_fmodifier_add";
2158         ot->description= "Add F-Modifiers to the selected F-Curves";
2159         
2160         /* api callbacks */
2161         ot->invoke= graph_fmodifier_add_invoke;
2162         ot->exec= graph_fmodifier_add_exec;
2163         ot->poll= graphop_selected_fcurve_poll; 
2164         
2165         /* flags */
2166         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2167         
2168         /* id-props */
2169         ot->prop= RNA_def_enum(ot->srna, "type", fmodifier_type_items, 0, "Type", "");
2170         RNA_def_boolean(ot->srna, "only_active", 1, "Only Active", "Only add F-Modifier to active F-Curve.");
2171 }
2172
2173 /* ******************** Copy F-Modifiers Operator *********************** */
2174
2175 static int graph_fmodifier_copy_exec(bContext *C, wmOperator *op)
2176 {
2177         bAnimContext ac;
2178         bAnimListElem *ale;
2179         short ok = 0;
2180         
2181         /* get editor data */
2182         if (ANIM_animdata_get_context(C, &ac) == 0)
2183                 return OPERATOR_CANCELLED;
2184         
2185         /* clear buffer first */
2186         free_fmodifiers_copybuf();
2187         
2188         /* get the active F-Curve */
2189         ale= get_active_fcurve_channel(&ac);
2190         
2191         /* if this exists, call the copy F-Modifiers API function */
2192         if (ale && ale->data) {
2193                 FCurve *fcu= (FCurve *)ale->data;
2194                 
2195                 // TODO: when 'active' vs 'all' boolean is added, change last param!
2196                 ok= ANIM_fmodifiers_copy_to_buf(&fcu->modifiers, 0);
2197                 
2198                 /* free temp data now */
2199                 MEM_freeN(ale);
2200         }
2201         
2202         /* successful or not? */
2203         if (ok == 0) {
2204                 BKE_report(op->reports, RPT_ERROR, "No F-Modifiers available to be copied");
2205                 return OPERATOR_CANCELLED;
2206         }
2207         else
2208                 return OPERATOR_FINISHED;
2209 }
2210  
2211 void GRAPH_OT_fmodifier_copy (wmOperatorType *ot)
2212 {
2213         /* identifiers */
2214         ot->name= "Copy F-Modifiers";
2215         ot->idname= "GRAPH_OT_fmodifier_copy";
2216         ot->description= "Copy the F-Modifier(s) of the active F-Curve.";
2217         
2218         /* api callbacks */
2219         ot->exec= graph_fmodifier_copy_exec;
2220         ot->poll= graphop_active_fcurve_poll; 
2221         
2222         /* flags */
2223         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2224         
2225         /* id-props */
2226         //ot->prop = RNA_def_boolean(ot->srna, "all", 1, "All F-Modifiers", "Copy all the F-Modifiers, instead of just the active one");
2227 }
2228
2229 /* ******************** Paste F-Modifiers Operator *********************** */
2230
2231 static int graph_fmodifier_paste_exec(bContext *C, wmOperator *op)
2232 {
2233         bAnimContext ac;
2234         ListBase anim_data = {NULL, NULL};
2235         bAnimListElem *ale;
2236         int filter, ok=0;
2237         
2238         /* get editor data */
2239         if (ANIM_animdata_get_context(C, &ac) == 0)
2240                 return OPERATOR_CANCELLED;
2241         
2242         /* filter data */
2243         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT);
2244         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2245         
2246         /* paste modifiers */
2247         for (ale = anim_data.first; ale; ale = ale->next) {
2248                 FCurve *fcu= (FCurve *)ale->data;
2249                 
2250                 // TODO: do we want to replace existing modifiers? add user pref for that!
2251                 ok += ANIM_fmodifiers_paste_from_buf(&fcu->modifiers, 0);
2252         }
2253         
2254         /* clean up */
2255         BLI_freelistN(&anim_data);
2256         
2257         /* successful or not? */
2258         if (ok) {
2259                 /* validate keyframes after editing */
2260                 ANIM_editkeyframes_refresh(&ac);
2261                 
2262                 /* set notifier that keyframes have changed */
2263                 WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
2264                 
2265                 return OPERATOR_FINISHED;
2266         }
2267         else {
2268                 BKE_report(op->reports, RPT_ERROR, "No F-Modifiers to paste");
2269                 return OPERATOR_CANCELLED;
2270         }
2271 }
2272  
2273 void GRAPH_OT_fmodifier_paste (wmOperatorType *ot)
2274 {
2275         /* identifiers */
2276         ot->name= "Paste F-Modifiers";
2277         ot->idname= "GRAPH_OT_fmodifier_paste";
2278         ot->description= "Add copied F-Modifiers to the selected F-Curves";
2279         
2280         /* api callbacks */
2281         ot->exec= graph_fmodifier_paste_exec;
2282         ot->poll= graphop_active_fcurve_poll;
2283         
2284         /* flags */
2285         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2286 }
2287
2288 /* ************************************************************************** */