Keyframing Bugfixes and Feature Requests:
[blender.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 #include <math.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <float.h>
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #include "MEM_guardedalloc.h"
40
41 #include "BLI_blenlib.h"
42 #include "BLI_math.h"
43
44 #include "DNA_anim_types.h"
45 #include "DNA_action_types.h"
46 #include "DNA_armature_types.h"
47 #include "DNA_camera_types.h"
48 #include "DNA_curve_types.h"
49 #include "DNA_object_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_scene_types.h"
52 #include "DNA_space_types.h"
53 #include "DNA_constraint_types.h"
54 #include "DNA_key_types.h"
55 #include "DNA_lamp_types.h"
56 #include "DNA_material_types.h"
57 #include "DNA_userdef_types.h"
58 #include "DNA_gpencil_types.h"
59 #include "DNA_windowmanager_types.h"
60
61 #include "RNA_access.h"
62 #include "RNA_define.h"
63 #include "RNA_enum_types.h"
64
65 #include "BKE_action.h"
66 #include "BKE_depsgraph.h"
67 #include "BKE_fcurve.h"
68 #include "BKE_key.h"
69 #include "BKE_material.h"
70 #include "BKE_nla.h"
71 #include "BKE_object.h"
72 #include "BKE_context.h"
73 #include "BKE_report.h"
74 #include "BKE_utildefines.h"
75
76 #include "UI_interface.h"
77 #include "UI_view2d.h"
78
79 #include "ED_anim_api.h"
80 #include "ED_keyframing.h"
81 #include "ED_keyframes_draw.h"
82 #include "ED_keyframes_edit.h"
83 #include "ED_screen.h"
84 #include "ED_space_api.h"
85 #include "ED_transform.h"
86
87 #include "WM_api.h"
88 #include "WM_types.h"
89
90 #include "graph_intern.h"
91
92 /* ************************************************************************** */
93 /* KEYFRAME-RANGE STUFF */
94
95 /* *************************** Calculate Range ************************** */
96
97 /* Get the min/max keyframes*/
98 /* note: it should return total boundbox, filter for selection only can be argument... */
99 void get_graph_keyframe_extents (bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax)
100 {
101         ListBase anim_data = {NULL, NULL};
102         bAnimListElem *ale;
103         int filter;
104         
105         /* get data to filter, from Dopesheet */
106         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
107         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
108         
109         /* set large values to try to override */
110         if (xmin) *xmin= 999999999.0f;
111         if (xmax) *xmax= -999999999.0f;
112         if (ymin) *ymin= 999999999.0f;
113         if (ymax) *ymax= -999999999.0f;
114         
115         /* check if any channels to set range with */
116         if (anim_data.first) {
117                 /* go through channels, finding max extents */
118                 for (ale= anim_data.first; ale; ale= ale->next) {
119                         AnimData *adt= ANIM_nla_mapping_get(ac, ale);
120                         FCurve *fcu= (FCurve *)ale->key_data;
121                         float txmin, txmax, tymin, tymax;
122                         
123                         /* get range and apply necessary scaling before */
124                         calc_fcurve_bounds(fcu, &txmin, &txmax, &tymin, &tymax);
125                         
126                         if (adt) {
127                                 txmin= BKE_nla_tweakedit_remap(adt, txmin, NLATIME_CONVERT_MAP);
128                                 txmax= BKE_nla_tweakedit_remap(adt, txmax, NLATIME_CONVERT_MAP);
129                         }
130                         
131                         /* try to set cur using these values, if they're more extreme than previously set values */
132                         if ((xmin) && (txmin < *xmin))          *xmin= txmin;
133                         if ((xmax) && (txmax > *xmax))          *xmax= txmax;
134                         if ((ymin) && (tymin < *ymin))          *ymin= tymin;
135                         if ((ymax) && (tymax > *ymax))          *ymax= tymax;
136                 }
137                 
138                 /* free memory */
139                 BLI_freelistN(&anim_data);
140         }
141         else {
142                 /* set default range */
143                 if (ac->scene) {
144                         if (xmin) *xmin= (float)ac->scene->r.sfra;
145                         if (xmax) *xmax= (float)ac->scene->r.efra;
146                 }
147                 else {
148                         if (xmin) *xmin= -5;
149                         if (xmax) *xmax= 100;
150                 }
151                 
152                 if (ymin) *ymin= -5;
153                 if (ymax) *ymax= 5;
154         }
155 }
156
157 /* ****************** Automatic Preview-Range Operator ****************** */
158
159 static int graphkeys_previewrange_exec(bContext *C, wmOperator *op)
160 {
161         bAnimContext ac;
162         Scene *scene;
163         float min, max;
164         
165         /* get editor data */
166         if (ANIM_animdata_get_context(C, &ac) == 0)
167                 return OPERATOR_CANCELLED;
168         if (ac.scene == NULL)
169                 return OPERATOR_CANCELLED;
170         else
171                 scene= ac.scene;
172         
173         /* set the range directly */
174         get_graph_keyframe_extents(&ac, &min, &max, NULL, NULL);
175         scene->r.psfra= (int)floor(min + 0.5f);
176         scene->r.pefra= (int)floor(max + 0.5f);
177         
178         /* set notifier that things have changed */
179         // XXX err... there's nothing for frame ranges yet, but this should do fine too
180         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
181         
182         return OPERATOR_FINISHED;
183 }
184  
185 void GRAPH_OT_previewrange_set (wmOperatorType *ot)
186 {
187         /* identifiers */
188         ot->name= "Auto-Set Preview Range";
189         ot->idname= "GRAPH_OT_previewrange_set";
190         
191         /* api callbacks */
192         ot->exec= graphkeys_previewrange_exec;
193         ot->poll= graphop_visible_keyframes_poll;
194         
195         /* flags */
196         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
197 }
198
199 /* ****************** View-All Operator ****************** */
200
201 static int graphkeys_viewall_exec(bContext *C, wmOperator *op)
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);
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 void GRAPH_OT_view_all (wmOperatorType *ot)
233 {
234         /* identifiers */
235         ot->name= "View All";
236         ot->idname= "GRAPH_OT_view_all";
237         ot->description= "Reset viewable area to show full keyframe range.";
238         
239         /* api callbacks */
240         ot->exec= graphkeys_viewall_exec;
241         ot->poll= graphop_visible_keyframes_poll;
242         
243         /* flags */
244         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
245 }
246
247 /* ******************** Create Ghost-Curves Operator *********************** */
248 /* This operator samples the data of the selected F-Curves to F-Points, storing them
249  * as 'ghost curves' in the active Graph Editor
250  */
251
252 /* Bake each F-Curve into a set of samples, and store as a ghost curve */
253 static void create_ghost_curves (bAnimContext *ac, int start, int end)
254 {       
255         SpaceIpo *sipo= (SpaceIpo *)ac->sa->spacedata.first;
256         ListBase anim_data = {NULL, NULL};
257         bAnimListElem *ale;
258         int filter;
259         
260         /* free existing ghost curves */
261         free_fcurves(&sipo->ghostCurves);
262         
263         /* sanity check */
264         if (start >= end) {
265                 printf("Error: Frame range for Ghost F-Curve creation is inappropriate \n");
266                 return;
267         }
268         
269         /* filter data */
270         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
271         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
272         
273         /* loop through filtered data and add keys between selected keyframes on every frame  */
274         for (ale= anim_data.first; ale; ale= ale->next) {
275                 FCurve *fcu= (FCurve *)ale->key_data;
276                 FCurve *gcu= MEM_callocN(sizeof(FCurve), "Ghost FCurve");
277                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
278                 ChannelDriver *driver= fcu->driver;
279                 FPoint *fpt;
280                 int cfra;               
281                 
282                 /* disable driver so that it don't muck up the sampling process */
283                 fcu->driver= NULL;
284                 
285                 /* create samples, but store them in a new curve 
286                  *      - we cannot use fcurve_store_samples() as that will only overwrite the original curve 
287                  */
288                 gcu->fpt= fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "Ghost FPoint Samples");
289                 gcu->totvert= end - start + 1;
290                 
291                 /* use the sampling callback at 1-frame intervals from start to end frames */
292                 for (cfra= start; cfra <= end; cfra++, fpt++) {
293                         float cfrae= BKE_nla_tweakedit_remap(adt, cfra, NLATIME_CONVERT_UNMAP);
294                         
295                         fpt->vec[0]= cfrae;
296                         fpt->vec[1]= fcurve_samplingcb_evalcurve(fcu, NULL, cfrae);
297                 }
298                 
299                 /* set color of ghost curve 
300                  *      - make the color slightly darker
301                  */
302                 gcu->color[0]= fcu->color[0] - 0.07f;
303                 gcu->color[1]= fcu->color[1] - 0.07f;
304                 gcu->color[2]= fcu->color[2] - 0.07f;
305                 
306                 /* store new ghost curve */
307                 BLI_addtail(&sipo->ghostCurves, gcu);
308                 
309                 /* restore driver */
310                 fcu->driver= driver;
311         }
312         
313         /* admin and redraws */
314         BLI_freelistN(&anim_data);
315 }
316
317 /* ------------------- */
318
319 static int graphkeys_create_ghostcurves_exec(bContext *C, wmOperator *op)
320 {
321         bAnimContext ac;
322         View2D *v2d;
323         int start, end;
324         
325         /* get editor data */
326         if (ANIM_animdata_get_context(C, &ac) == 0)
327                 return OPERATOR_CANCELLED;
328                 
329         /* ghost curves are snapshots of the visible portions of the curves, so set range to be the visible range */
330         v2d= &ac.ar->v2d;
331         start= (int)v2d->cur.xmin;
332         end= (int)v2d->cur.xmax;
333         
334         /* bake selected curves into a ghost curve */
335         create_ghost_curves(&ac, start, end);
336         
337         /* update this editor only */
338         ED_area_tag_redraw(CTX_wm_area(C));
339         
340         return OPERATOR_FINISHED;
341 }
342  
343 void GRAPH_OT_ghost_curves_create (wmOperatorType *ot)
344 {
345         /* identifiers */
346         ot->name= "Create Ghost Curves";
347         ot->idname= "GRAPH_OT_ghost_curves_create";
348         ot->description= "Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor.";
349         
350         /* api callbacks */
351         ot->exec= graphkeys_create_ghostcurves_exec;
352         ot->poll= graphop_visible_keyframes_poll;
353         
354         /* flags */
355         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
356         
357         // todo: add props for start/end frames
358 }
359
360 /* ******************** Clear Ghost-Curves Operator *********************** */
361 /* This operator clears the 'ghost curves' for the active Graph Editor */
362
363 static int graphkeys_clear_ghostcurves_exec(bContext *C, wmOperator *op)
364 {
365         bAnimContext ac;
366         SpaceIpo *sipo;
367         
368         /* get editor data */
369         if (ANIM_animdata_get_context(C, &ac) == 0)
370                 return OPERATOR_CANCELLED;
371         sipo= (SpaceIpo *)ac.sa->spacedata.first;
372                 
373         /* if no ghost curves, don't do anything */
374         if (sipo->ghostCurves.first == NULL)
375                 return OPERATOR_CANCELLED;
376         
377         /* free ghost curves */
378         free_fcurves(&sipo->ghostCurves);
379         
380         /* update this editor only */
381         ED_area_tag_redraw(CTX_wm_area(C));
382         
383         return OPERATOR_FINISHED;
384 }
385  
386 void GRAPH_OT_ghost_curves_clear (wmOperatorType *ot)
387 {
388         /* identifiers */
389         ot->name= "Clear Ghost Curves";
390         ot->idname= "GRAPH_OT_ghost_curves_clear";
391         ot->description= "Clear F-Curve snapshots (Ghosts) for active Graph Editor.";
392         
393         /* api callbacks */
394         ot->exec= graphkeys_clear_ghostcurves_exec;
395         ot->poll= ED_operator_ipo_active;
396         
397         /* flags */
398         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
399 }
400
401 /* ************************************************************************** */
402 /* GENERAL STUFF */
403
404 /* ******************** Insert Keyframes Operator ************************* */
405
406 /* defines for insert keyframes tool */
407 EnumPropertyItem prop_graphkeys_insertkey_types[] = {
408         {1, "ALL", 0, "All Channels", ""},
409         {2, "SEL", 0, "Only Selected Channels", ""},
410         {0, NULL, 0, NULL, NULL}
411 };
412
413 /* this function is responsible for snapping keyframes to frame-times */
414 static void insert_graph_keys(bAnimContext *ac, short mode) 
415 {
416         ListBase anim_data = {NULL, NULL};
417         bAnimListElem *ale;
418         int filter;
419         
420         Scene *scene= ac->scene;
421         float cfra= (float)CFRA;
422         short flag = 0;
423         
424         /* filter data */
425         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
426         if (mode == 2) filter |= ANIMFILTER_SEL;
427         
428         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
429         
430         /* init keyframing flag */
431         flag = ANIM_get_keyframing_flags(scene, 1);
432         
433         /* insert keyframes */
434         for (ale= anim_data.first; ale; ale= ale->next) {
435                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
436                 FCurve *fcu= (FCurve *)ale->key_data;
437                 
438                 /* adjust current frame for NLA-mapping */
439                 if (adt)
440                         cfra= BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
441                 else 
442                         cfra= (float)CFRA;
443                         
444                 /* if there's an id */
445                 if (ale->id)
446                         insert_keyframe(ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
447                 else
448                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
449         }
450         
451         BLI_freelistN(&anim_data);
452 }
453
454 /* ------------------- */
455
456 static int graphkeys_insertkey_exec(bContext *C, wmOperator *op)
457 {
458         bAnimContext ac;
459         short mode;
460         
461         /* get editor data */
462         if (ANIM_animdata_get_context(C, &ac) == 0)
463                 return OPERATOR_CANCELLED;
464         if (ac.datatype == ANIMCONT_GPENCIL)
465                 return OPERATOR_CANCELLED;
466                 
467         /* which channels to affect? */
468         mode= RNA_enum_get(op->ptr, "type");
469         
470         /* insert keyframes */
471         insert_graph_keys(&ac, mode);
472         
473         /* validate keyframes after editing */
474         ANIM_editkeyframes_refresh(&ac);
475         
476         /* set notifier that keyframes have changed */
477         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
478         
479         return OPERATOR_FINISHED;
480 }
481
482 void GRAPH_OT_keyframe_insert (wmOperatorType *ot)
483 {
484         /* identifiers */
485         ot->name= "Insert Keyframes";
486         ot->idname= "GRAPH_OT_keyframe_insert";
487         ot->description= "Insert keyframes for the specified channels.";
488         
489         /* api callbacks */
490         ot->invoke= WM_menu_invoke;
491         ot->exec= graphkeys_insertkey_exec;
492         ot->poll= graphop_editable_keyframes_poll;
493         
494         /* flags */
495         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
496         
497         /* id-props */
498         RNA_def_enum(ot->srna, "type", prop_graphkeys_insertkey_types, 0, "Type", "");
499 }
500
501 /* ******************** Click-Insert Keyframes Operator ************************* */
502
503 static int graphkeys_click_insert_exec (bContext *C, wmOperator *op)
504 {
505         bAnimContext ac;
506         bAnimListElem *ale;
507         AnimData *adt;
508         float frame, val;
509         
510         /* get animation context */
511         if (ANIM_animdata_get_context(C, &ac) == 0)
512                 return OPERATOR_CANCELLED;
513         
514         /* get active F-Curve 'anim-list-element' */
515         ale= get_active_fcurve_channel(&ac);
516         if (ELEM(NULL, ale, ale->data)) {
517                 if (ale) MEM_freeN(ale);
518                 return OPERATOR_CANCELLED;
519         }
520                 
521         /* get frame and value from props */
522         frame= RNA_float_get(op->ptr, "frame");
523         val= RNA_float_get(op->ptr, "value");
524         
525         /* apply inverse NLA-mapping to frame to get correct time in un-scaled action */
526         adt= ANIM_nla_mapping_get(&ac, ale);
527         frame= BKE_nla_tweakedit_remap(adt, frame, NLATIME_CONVERT_UNMAP);
528         
529         /* insert keyframe on the specified frame + value */
530         insert_vert_fcurve((FCurve *)ale->data, frame, val, 0);
531         
532         /* free temp data */
533         MEM_freeN(ale);
534         
535         /* set notifier that keyframes have changed */
536         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
537         
538         /* done */
539         return OPERATOR_FINISHED;
540 }
541
542 static int graphkeys_click_insert_invoke (bContext *C, wmOperator *op, wmEvent *evt)
543 {
544         bAnimContext ac;
545         ARegion *ar;
546         View2D *v2d;
547         int mval[2];
548         float x, y;
549         
550         /* get animation context */
551         if (ANIM_animdata_get_context(C, &ac) == 0)
552                 return OPERATOR_CANCELLED;
553         
554         /* store mouse coordinates in View2D space, into the operator's properties */
555         ar= ac.ar;
556         v2d= &ar->v2d;
557         
558         mval[0]= (evt->x - ar->winrct.xmin);
559         mval[1]= (evt->y - ar->winrct.ymin);
560         
561         UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y);
562         
563         RNA_float_set(op->ptr, "frame", x);
564         RNA_float_set(op->ptr, "value", y);
565         
566         /* run exec now */
567         return graphkeys_click_insert_exec(C, op);
568 }
569
570 void GRAPH_OT_click_insert (wmOperatorType *ot)
571 {
572         /* identifiers */
573         ot->name= "Click-Insert Keyframes";
574         ot->idname= "GRAPH_OT_click_insert";
575         ot->description= "Insert new keyframe at the cursor position for the active F-Curve.";
576         
577         /* api callbacks */
578         ot->invoke= graphkeys_click_insert_invoke;
579         ot->exec= graphkeys_click_insert_exec;
580         ot->poll= graphop_active_fcurve_poll;
581         
582         /* flags */
583         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
584         
585         /* properties */
586         RNA_def_float(ot->srna, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame Number", "Frame to insert keyframe on", 0, 100);
587         RNA_def_float(ot->srna, "value", 1.0f, -FLT_MAX, FLT_MAX, "Value", "Value for keyframe on", 0, 100);
588 }
589
590 /* ******************** Copy/Paste Keyframes Operator ************************* */
591 /* NOTE: the backend code for this is shared with the dopesheet editor */
592
593 static short copy_graph_keys (bAnimContext *ac)
594 {       
595         ListBase anim_data = {NULL, NULL};
596         int filter, ok=0;
597         
598         /* clear buffer first */
599         free_anim_copybuf();
600         
601         /* filter data */
602         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
603         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
604         
605         /* copy keyframes */
606         ok= copy_animedit_keys(ac, &anim_data);
607         
608         /* clean up */
609         BLI_freelistN(&anim_data);
610
611         return ok;
612 }
613
614 static short paste_graph_keys (bAnimContext *ac)
615 {       
616         ListBase anim_data = {NULL, NULL};
617         int filter, ok=0;
618         
619         /* filter data */
620         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
621         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
622         
623         /* paste keyframes */
624         ok= paste_animedit_keys(ac, &anim_data);
625         
626         /* clean up */
627         BLI_freelistN(&anim_data);
628
629         return ok;
630 }
631
632 /* ------------------- */
633
634 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
635 {
636         bAnimContext ac;
637         
638         /* get editor data */
639         if (ANIM_animdata_get_context(C, &ac) == 0)
640                 return OPERATOR_CANCELLED;
641         
642         /* copy keyframes */
643         if (copy_graph_keys(&ac)) {     
644                 BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
645                 return OPERATOR_CANCELLED;
646         }
647         
648         /* just return - no operator needed here (no changes) */
649         return OPERATOR_FINISHED;
650 }
651  
652 void GRAPH_OT_copy (wmOperatorType *ot)
653 {
654         /* identifiers */
655         ot->name= "Copy Keyframes";
656         ot->idname= "GRAPH_OT_copy";
657         ot->description= "Copy selected keyframes to the copy/paste buffer.";
658         
659         /* api callbacks */
660         ot->exec= graphkeys_copy_exec;
661         ot->poll= graphop_editable_keyframes_poll;
662         
663         /* flags */
664         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
665 }
666
667
668
669 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
670 {
671         bAnimContext ac;
672         
673         /* get editor data */
674         if (ANIM_animdata_get_context(C, &ac) == 0)
675                 return OPERATOR_CANCELLED;
676         
677         /* paste keyframes */
678         if (paste_graph_keys(&ac)) {
679                 BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
680                 return OPERATOR_CANCELLED;
681         }
682         
683         /* validate keyframes after editing */
684         ANIM_editkeyframes_refresh(&ac);
685         
686         /* set notifier that keyframes have changed */
687         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
688         
689         return OPERATOR_FINISHED;
690 }
691  
692 void GRAPH_OT_paste (wmOperatorType *ot)
693 {
694         /* identifiers */
695         ot->name= "Paste Keyframes";
696         ot->idname= "GRAPH_OT_paste";
697         ot->description= "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame.";
698         
699         /* api callbacks */
700         ot->exec= graphkeys_paste_exec;
701         ot->poll= graphop_editable_keyframes_poll;
702         
703         /* flags */
704         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
705 }
706
707 /* ******************** Duplicate Keyframes Operator ************************* */
708
709 static void duplicate_graph_keys (bAnimContext *ac)
710 {
711         ListBase anim_data = {NULL, NULL};
712         bAnimListElem *ale;
713         int filter;
714         
715         /* filter data */
716         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
717         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
718         
719         /* loop through filtered data and delete selected keys */
720         for (ale= anim_data.first; ale; ale= ale->next) {
721                 duplicate_fcurve_keys((FCurve *)ale->key_data);
722         }
723         
724         /* free filtered list */
725         BLI_freelistN(&anim_data);
726 }
727
728 /* ------------------- */
729
730 static int graphkeys_duplicate_exec(bContext *C, wmOperator *op)
731 {
732         bAnimContext ac;
733         
734         /* get editor data */
735         if (ANIM_animdata_get_context(C, &ac) == 0)
736                 return OPERATOR_CANCELLED;
737                 
738         /* duplicate keyframes */
739         duplicate_graph_keys(&ac);
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_EDIT, NULL);
746         
747         return OPERATOR_FINISHED;
748 }
749
750 static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
751 {
752         graphkeys_duplicate_exec(C, op);
753         
754         RNA_int_set(op->ptr, "mode", TFM_TRANSLATION);
755         WM_operator_name_call(C, "TRANSFORM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
756
757         return OPERATOR_FINISHED;
758 }
759  
760 void GRAPH_OT_duplicate (wmOperatorType *ot)
761 {
762         /* identifiers */
763         ot->name= "Duplicate Keyframes";
764         ot->idname= "GRAPH_OT_duplicate";
765         ot->description= "Make a copy of all selected keyframes.";
766         
767         /* api callbacks */
768         ot->invoke= graphkeys_duplicate_invoke;
769         ot->exec= graphkeys_duplicate_exec;
770         ot->poll= graphop_editable_keyframes_poll;
771         
772         /* flags */
773         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
774         
775         /* to give to transform */
776         RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
777 }
778
779 /* ******************** Delete Keyframes Operator ************************* */
780
781 static void delete_graph_keys (bAnimContext *ac)
782 {
783         ListBase anim_data = {NULL, NULL};
784         bAnimListElem *ale;
785         int filter;
786         
787         /* filter data */
788         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
789         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
790         
791         /* loop through filtered data and delete selected keys */
792         for (ale= anim_data.first; ale; ale= ale->next) {
793                 FCurve *fcu= (FCurve *)ale->key_data;
794                 AnimData *adt= ale->adt;
795                 
796                 /* delete selected keyframes only */
797                 delete_fcurve_keys(fcu); 
798                 
799                 /* Only delete curve too if it won't be doing anything anymore */
800                 if ((fcu->totvert == 0) && (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0))
801                         ANIM_fcurve_delete_from_animdata(ac, adt, fcu);
802         }
803         
804         /* free filtered list */
805         BLI_freelistN(&anim_data);
806 }
807
808 /* ------------------- */
809
810 static int graphkeys_delete_exec(bContext *C, wmOperator *op)
811 {
812         bAnimContext ac;
813         
814         /* get editor data */
815         if (ANIM_animdata_get_context(C, &ac) == 0)
816                 return OPERATOR_CANCELLED;
817                 
818         /* delete keyframes */
819         delete_graph_keys(&ac);
820         
821         /* validate keyframes after editing */
822         ANIM_editkeyframes_refresh(&ac);
823         
824         /* set notifier that keyframes have changed */
825         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
826         
827         return OPERATOR_FINISHED;
828 }
829  
830 void GRAPH_OT_delete (wmOperatorType *ot)
831 {
832         /* identifiers */
833         ot->name= "Delete Keyframes";
834         ot->idname= "GRAPH_OT_delete";
835         ot->description= "Remove all selected keyframes.";
836         
837         /* api callbacks */
838         ot->invoke= WM_operator_confirm;
839         ot->exec= graphkeys_delete_exec;
840         ot->poll= graphop_editable_keyframes_poll;
841         
842         /* flags */
843         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
844 }
845
846 /* ******************** Clean Keyframes Operator ************************* */
847
848 static void clean_graph_keys (bAnimContext *ac, float thresh)
849 {       
850         ListBase anim_data = {NULL, NULL};
851         bAnimListElem *ale;
852         int filter;
853         
854         /* filter data */
855         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
856         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
857         
858         /* loop through filtered data and clean curves */
859         for (ale= anim_data.first; ale; ale= ale->next)
860                 clean_fcurve((FCurve *)ale->key_data, thresh);
861         
862         /* free temp data */
863         BLI_freelistN(&anim_data);
864 }
865
866 /* ------------------- */
867
868 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
869 {
870         bAnimContext ac;
871         float thresh;
872         
873         /* get editor data */
874         if (ANIM_animdata_get_context(C, &ac) == 0)
875                 return OPERATOR_CANCELLED;
876                 
877         /* get cleaning threshold */
878         thresh= RNA_float_get(op->ptr, "threshold");
879         
880         /* clean keyframes */
881         clean_graph_keys(&ac, thresh);
882         
883         /* validate keyframes after editing */
884         ANIM_editkeyframes_refresh(&ac);
885         
886         /* set notifier that keyframes have changed */
887         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
888         
889         return OPERATOR_FINISHED;
890 }
891  
892 void GRAPH_OT_clean (wmOperatorType *ot)
893 {
894         /* identifiers */
895         ot->name= "Clean Keyframes";
896         ot->idname= "GRAPH_OT_clean";
897         ot->description= "Simplify F-Curves by removing closely spaced keyframes.";
898         
899         /* api callbacks */
900         //ot->invoke=  // XXX we need that number popup for this! 
901         ot->exec= graphkeys_clean_exec;
902         ot->poll= graphop_editable_keyframes_poll;
903         
904         /* flags */
905         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
906         
907         /* properties */
908         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
909 }
910
911 /* ******************** Bake F-Curve Operator *********************** */
912 /* This operator bakes the data of the selected F-Curves to F-Points */
913
914 /* Bake each F-Curve into a set of samples */
915 static void bake_graph_curves (bAnimContext *ac, int start, int end)
916 {       
917         ListBase anim_data = {NULL, NULL};
918         bAnimListElem *ale;
919         int filter;
920         
921         /* filter data */
922         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
923         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
924         
925         /* loop through filtered data and add keys between selected keyframes on every frame  */
926         for (ale= anim_data.first; ale; ale= ale->next) {
927                 FCurve *fcu= (FCurve *)ale->key_data;
928                 ChannelDriver *driver= fcu->driver;
929                 
930                 /* disable driver so that it don't muck up the sampling process */
931                 fcu->driver= NULL;
932                 
933                 /* create samples */
934                 fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
935                 
936                 /* restore driver */
937                 fcu->driver= driver;
938         }
939         
940         /* admin and redraws */
941         BLI_freelistN(&anim_data);
942 }
943
944 /* ------------------- */
945
946 static int graphkeys_bake_exec(bContext *C, wmOperator *op)
947 {
948         bAnimContext ac;
949         Scene *scene= NULL;
950         int start, end;
951         
952         /* get editor data */
953         if (ANIM_animdata_get_context(C, &ac) == 0)
954                 return OPERATOR_CANCELLED;
955                 
956         /* for now, init start/end from preview-range extents */
957         // TODO: add properties for this 
958         scene= ac.scene;
959         start= PSFRA;
960         end= PEFRA;
961         
962         /* bake keyframes */
963         bake_graph_curves(&ac, start, end);
964         
965         /* validate keyframes after editing */
966         ANIM_editkeyframes_refresh(&ac);
967         
968         /* set notifier that keyframes have changed */
969         // NOTE: some distinction between order/number of keyframes and type should be made?
970         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
971         
972         return OPERATOR_FINISHED;
973 }
974  
975 void GRAPH_OT_bake (wmOperatorType *ot)
976 {
977         /* identifiers */
978         ot->name= "Bake Curve";
979         ot->idname= "GRAPH_OT_bake";
980         ot->description= "Bake selected F-Curves to a set of sampled points defining a similar curve.";
981         
982         /* api callbacks */
983         ot->invoke= WM_operator_confirm; // FIXME...
984         ot->exec= graphkeys_bake_exec;
985         ot->poll= graphop_selected_fcurve_poll; 
986         
987         /* flags */
988         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
989         
990         // todo: add props for start/end frames
991 }
992
993 /* ******************** Sample Keyframes Operator *********************** */
994 /* This operator 'bakes' the values of the curve into new keyframes between pairs
995  * of selected keyframes. It is useful for creating keyframes for tweaking overlap.
996  */
997
998 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
999 static void sample_graph_keys (bAnimContext *ac)
1000 {       
1001         ListBase anim_data = {NULL, NULL};
1002         bAnimListElem *ale;
1003         int filter;
1004         
1005         /* filter data */
1006         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1007         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1008         
1009         /* loop through filtered data and add keys between selected keyframes on every frame  */
1010         for (ale= anim_data.first; ale; ale= ale->next)
1011                 sample_fcurve((FCurve *)ale->key_data);
1012         
1013         /* admin and redraws */
1014         BLI_freelistN(&anim_data);
1015 }
1016
1017 /* ------------------- */
1018
1019 static int graphkeys_sample_exec(bContext *C, wmOperator *op)
1020 {
1021         bAnimContext ac;
1022         
1023         /* get editor data */
1024         if (ANIM_animdata_get_context(C, &ac) == 0)
1025                 return OPERATOR_CANCELLED;
1026         
1027         /* sample keyframes */
1028         sample_graph_keys(&ac);
1029         
1030         /* validate keyframes after editing */
1031         ANIM_editkeyframes_refresh(&ac);
1032         
1033         /* set notifier that keyframes have changed */
1034         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1035         
1036         return OPERATOR_FINISHED;
1037 }
1038  
1039 void GRAPH_OT_sample (wmOperatorType *ot)
1040 {
1041         /* identifiers */
1042         ot->name= "Sample Keyframes";
1043         ot->idname= "GRAPH_OT_sample";
1044         ot->description= "Add keyframes on every frame between the selected keyframes.";
1045         
1046         /* api callbacks */
1047         ot->exec= graphkeys_sample_exec;
1048         ot->poll= graphop_editable_keyframes_poll;
1049         
1050         /* flags */
1051         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1052 }
1053
1054
1055 /* ************************************************************************** */
1056 /* SETTINGS STUFF */
1057
1058 /* ******************** Set Extrapolation-Type Operator *********************** */
1059
1060 /* defines for set extrapolation-type for selected keyframes tool */
1061 EnumPropertyItem prop_graphkeys_expo_types[] = {
1062         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
1063         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
1064         {0, NULL, 0, NULL, NULL}
1065 };
1066
1067 /* this function is responsible for setting extrapolation mode for keyframes */
1068 static void setexpo_graph_keys(bAnimContext *ac, short mode) 
1069 {
1070         ListBase anim_data = {NULL, NULL};
1071         bAnimListElem *ale;
1072         int filter;
1073         
1074         /* filter data */
1075         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1076         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1077         
1078         /* loop through setting mode per F-Curve */
1079         for (ale= anim_data.first; ale; ale= ale->next) {
1080                 FCurve *fcu= (FCurve *)ale->data;
1081                 fcu->extend= mode;
1082         }
1083         
1084         /* cleanup */
1085         BLI_freelistN(&anim_data);
1086 }
1087
1088 /* ------------------- */
1089
1090 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
1091 {
1092         bAnimContext ac;
1093         short mode;
1094         
1095         /* get editor data */
1096         if (ANIM_animdata_get_context(C, &ac) == 0)
1097                 return OPERATOR_CANCELLED;
1098                 
1099         /* get handle setting mode */
1100         mode= RNA_enum_get(op->ptr, "type");
1101         
1102         /* set handle type */
1103         setexpo_graph_keys(&ac, mode);
1104         
1105         /* validate keyframes after editing */
1106         ANIM_editkeyframes_refresh(&ac);
1107         
1108         /* set notifier that keyframe properties have changed */
1109         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1110         
1111         return OPERATOR_FINISHED;
1112 }
1113  
1114 void GRAPH_OT_extrapolation_type (wmOperatorType *ot)
1115 {
1116         /* identifiers */
1117         ot->name= "Set Keyframe Extrapolation";
1118         ot->idname= "GRAPH_OT_extrapolation_type";
1119         ot->description= "Set extrapolation mode for selected F-Curves.";
1120         
1121         /* api callbacks */
1122         ot->invoke= WM_menu_invoke;
1123         ot->exec= graphkeys_expo_exec;
1124         ot->poll= graphop_editable_keyframes_poll;
1125         
1126         /* flags */
1127         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1128         
1129         /* id-props */
1130         RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
1131 }
1132
1133 /* ******************** Set Interpolation-Type Operator *********************** */
1134
1135 /* this function is responsible for setting interpolation mode for keyframes */
1136 static void setipo_graph_keys(bAnimContext *ac, short mode) 
1137 {
1138         ListBase anim_data = {NULL, NULL};
1139         bAnimListElem *ale;
1140         int filter;
1141         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
1142         
1143         /* filter data */
1144         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1145         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1146         
1147         /* loop through setting BezTriple interpolation
1148          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1149          */
1150         for (ale= anim_data.first; ale; ale= ale->next)
1151                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1152         
1153         /* cleanup */
1154         BLI_freelistN(&anim_data);
1155 }
1156
1157 /* ------------------- */
1158
1159 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
1160 {
1161         bAnimContext ac;
1162         short mode;
1163         
1164         /* get editor data */
1165         if (ANIM_animdata_get_context(C, &ac) == 0)
1166                 return OPERATOR_CANCELLED;
1167                 
1168         /* get handle setting mode */
1169         mode= RNA_enum_get(op->ptr, "type");
1170         
1171         /* set handle type */
1172         setipo_graph_keys(&ac, mode);
1173         
1174         /* validate keyframes after editing */
1175         ANIM_editkeyframes_refresh(&ac);
1176         
1177         /* set notifier that keyframe properties have changed */
1178         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1179         
1180         return OPERATOR_FINISHED;
1181 }
1182  
1183 void GRAPH_OT_interpolation_type (wmOperatorType *ot)
1184 {
1185         /* identifiers */
1186         ot->name= "Set Keyframe Interpolation";
1187         ot->idname= "GRAPH_OT_interpolation_type";
1188         ot->description= "Set interpolation mode for the F-Curve segments starting from the selected keyframes.";
1189         
1190         /* api callbacks */
1191         ot->invoke= WM_menu_invoke;
1192         ot->exec= graphkeys_ipo_exec;
1193         ot->poll= graphop_editable_keyframes_poll;
1194         
1195         /* flags */
1196         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1197         
1198         /* id-props */
1199         RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
1200 }
1201
1202 /* ******************** Set Handle-Type Operator *********************** */
1203
1204 /* this function is responsible for setting handle-type of selected keyframes */
1205 static void sethandles_graph_keys(bAnimContext *ac, short mode) 
1206 {
1207         ListBase anim_data = {NULL, NULL};
1208         bAnimListElem *ale;
1209         int filter;
1210         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
1211         
1212         /* filter data */
1213         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1214         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1215         
1216         /* loop through setting flags for handles 
1217          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1218          */
1219         // XXX we might need to supply BeztEditData to get it to only affect selected handles
1220         for (ale= anim_data.first; ale; ale= ale->next) {
1221                 if (mode == -1) {       
1222                         BeztEditFunc toggle_cb;
1223                         
1224                         /* check which type of handle to set (free or aligned) 
1225                          *      - check here checks for handles with free alignment already
1226                          */
1227                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
1228                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
1229                         else
1230                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
1231                                 
1232                         /* set handle-type */
1233                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
1234                 }
1235                 else {
1236                         /* directly set handle-type */
1237                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1238                 }
1239         }
1240         
1241         /* cleanup */
1242         BLI_freelistN(&anim_data);
1243 }
1244
1245 /* ------------------- */
1246
1247 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
1248 {
1249         bAnimContext ac;
1250         short mode;
1251         
1252         /* get editor data */
1253         if (ANIM_animdata_get_context(C, &ac) == 0)
1254                 return OPERATOR_CANCELLED;
1255                 
1256         /* get handle setting mode */
1257         mode= RNA_enum_get(op->ptr, "type");
1258         
1259         /* set handle type */
1260         sethandles_graph_keys(&ac, mode);
1261         
1262         /* validate keyframes after editing */
1263         ANIM_editkeyframes_refresh(&ac);
1264         
1265         /* set notifier that things have changed */
1266         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1267         
1268         return OPERATOR_FINISHED;
1269 }
1270  
1271 void GRAPH_OT_handle_type (wmOperatorType *ot)
1272 {
1273         /* identifiers */
1274         ot->name= "Set Keyframe Handle Type";
1275         ot->idname= "GRAPH_OT_handle_type";
1276         ot->description= "Set type of handle for selected keyframes.";
1277         
1278         /* api callbacks */
1279         ot->invoke= WM_menu_invoke;
1280         ot->exec= graphkeys_handletype_exec;
1281         ot->poll= graphop_editable_keyframes_poll;
1282         
1283         /* flags */
1284         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1285         
1286         /* id-props */
1287         RNA_def_enum(ot->srna, "type", beztriple_handle_type_items, 0, "Type", "");
1288 }
1289
1290 /* ************************************************************************** */
1291 /* TRANSFORM STUFF */
1292
1293 /* ***************** 'Euler Filter' Operator **************************** */
1294 /* Euler filter tools (as seen in Maya), are necessary for working with 'baked'
1295  * rotation curves (with Euler rotations). The main purpose of such tools is to
1296  * resolve any discontinuities that may arise in the curves due to the clamping
1297  * of values to -180 degrees to 180 degrees.
1298  */
1299
1300 #if 0 // XXX this is not ready for the primetime yet
1301  
1302 /* set of three euler-rotation F-Curves */
1303 typedef struct tEulerFilter {
1304         ID *id;                                                 /* ID-block which owns the channels */
1305         FCurve (*fcurves)[3];                   /* 3 Pointers to F-Curves */                            
1306 } tEulerFilter;
1307  
1308 static int graphkeys_euler_filter_exec (bContext *C, wmOperator *op)
1309 {
1310         bAnimContext ac;
1311         
1312         ListBase anim_data= {NULL, NULL};
1313         bAnimListElem *ale;
1314         int filter;
1315         
1316         ListBase eulers = {NULL, NULL};
1317         tEulerFilter *euf= NULL;        
1318         
1319         /* get editor data */
1320         if (ANIM_animdata_get_context(C, &ac) == 0)
1321                 return OPERATOR_CANCELLED;
1322                 
1323         /* The process is done in two passes:
1324          *       1) Sets of three related rotation curves are identified from the selected channels,
1325          *              and are stored as a single 'operation unit' for the next step
1326          *       2) Each set of three F-Curves is processed for each keyframe, with the values being
1327          *              processed according to one of several ways.
1328          */
1329          
1330         /* step 1: extract only the rotation f-curves */
1331         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY | ANIMFILTER_FOREDIT);
1332         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1333         
1334         for (ale= anim_data.first; ale; ale= ale->next) {
1335                 FCurve *fcu = (FCurve *)ale->data;
1336                 
1337                 /* check if this is an appropriate F-Curve 
1338                  *      - only rotation curves
1339                  *      - for pchan curves, make sure we're only using the euler curves
1340                  */
1341                 if (strstr(fcu->rna_path, "rotation_euler") == 0)
1342                         continue;
1343                 
1344                 /* check if current set of 3-curves is suitable to add this curve to 
1345                  *      - things like whether the current set of curves is 'full' should be checked later only
1346                  *      - first check if id-blocks are compatible
1347                  */
1348                 if ((euf) && (ale->id != euf->id)) {
1349                         /* if the paths match, add this curve to the set of curves */
1350                         // NOTE: simple string compare for now... could be a bit more fancy...
1351                         
1352                 }
1353                 else {
1354                         /* just add to a new block */
1355                         euf= MEM_callocN(sizeof(tEulerFilter), "tEulerFilter");
1356                         BLI_addtail(&eulers, euf);
1357                         
1358                         euf->id= ale->id;
1359                         euf->fcurves[fcu->array_index]= fcu;
1360                 }
1361         }
1362         BLI_freelistN(&anim_data);
1363         
1364         /* step 2: go through each set of curves, processing the values at each keyframe 
1365          *      - it is assumed that there must be a full set of keyframes at each keyframe position
1366          */
1367         for (euf= eulers.first; euf; euf= euf->next) {
1368                 
1369         }
1370         BLI_freelistN(&eulers);
1371         
1372         return OPERATOR_FINISHED;
1373 }
1374  
1375 void GRAPH_OT_euler_filter (wmOperatorType *ot)
1376 {
1377         /* identifiers */
1378         ot->name= "Euler Filter";
1379         ot->idname= "GRAPH_OT_euler_filter";
1380         
1381         /* api callbacks */
1382         ot->exec= graphkeys_euler_filter_exec;
1383         ot->poll= graphop_editable_keyframes_poll;
1384         
1385         /* flags */
1386         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1387 }
1388
1389 #endif // XXX this is not ready for the primetime yet
1390
1391 /* ***************** Jump to Selected Frames Operator *********************** */
1392
1393 /* snap current-frame indicator to 'average time' of selected keyframe */
1394 static int graphkeys_framejump_exec(bContext *C, wmOperator *op)
1395 {
1396         bAnimContext ac;
1397         ListBase anim_data= {NULL, NULL};
1398         bAnimListElem *ale;
1399         int filter;
1400         BeztEditData bed;
1401         
1402         /* get editor data */
1403         if (ANIM_animdata_get_context(C, &ac) == 0)
1404                 return OPERATOR_CANCELLED;
1405         
1406         /* init edit data */
1407         memset(&bed, 0, sizeof(BeztEditData));
1408         
1409         /* loop over action data, averaging values */
1410         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
1411         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1412         
1413         for (ale= anim_data.first; ale; ale= ale->next) {
1414                 AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
1415                 
1416                 if (adt) {
1417                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1418                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1419                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1); 
1420                 }
1421                 else
1422                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1423                 
1424         }
1425         
1426         BLI_freelistN(&anim_data);
1427         
1428         /* set the new current frame and cursor values, based on the average time and value */
1429         if (bed.i1) {
1430                 SpaceIpo *sipo= ac.sa->spacedata.first;
1431                 Scene *scene= ac.scene;
1432                 
1433                 /* take the average values, rounding to the nearest int for the current frame */
1434                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1435                 sipo->cursorVal= bed.f2 / (float)bed.i1;
1436         }
1437         
1438         /* set notifier that things have changed */
1439         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1440         
1441         return OPERATOR_FINISHED;
1442 }
1443
1444 void GRAPH_OT_frame_jump (wmOperatorType *ot)
1445 {
1446         /* identifiers */
1447         ot->name= "Jump to Frame";
1448         ot->idname= "GRAPH_OT_frame_jump";
1449         ot->description= "Set the current frame to the average frame of the selected keyframes.";
1450         
1451         /* api callbacks */
1452         ot->exec= graphkeys_framejump_exec;
1453         ot->poll= graphop_visible_keyframes_poll;
1454         
1455         /* flags */
1456         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1457 }
1458
1459 /* ******************** Snap Keyframes Operator *********************** */
1460
1461 /* defines for snap keyframes tool */
1462 EnumPropertyItem prop_graphkeys_snap_types[] = {
1463         {GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current Frame", ""},
1464         {GRAPHKEYS_SNAP_VALUE, "VALUE", 0, "Cursor Value", ""},
1465         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
1466         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
1467         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
1468         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles", ""},
1469         {0, NULL, 0, NULL, NULL}
1470 };
1471
1472 /* this function is responsible for snapping keyframes to frame-times */
1473 static void snap_graph_keys(bAnimContext *ac, short mode) 
1474 {
1475         ListBase anim_data = {NULL, NULL};
1476         bAnimListElem *ale;
1477         int filter;
1478         
1479         BeztEditData bed;
1480         BeztEditFunc edit_cb;
1481         
1482         /* filter data */
1483         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1484         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1485         
1486         /* get beztriple editing callbacks */
1487         edit_cb= ANIM_editkeyframes_snap(mode);
1488         
1489         memset(&bed, 0, sizeof(BeztEditData)); 
1490         bed.scene= ac->scene;
1491         if (mode == GRAPHKEYS_SNAP_NEAREST_MARKER) {
1492                 bed.list.first= (ac->markers) ? ac->markers->first : NULL;
1493                 bed.list.last= (ac->markers) ? ac->markers->last : NULL;
1494         }
1495         else if (mode == GRAPHKEYS_SNAP_VALUE) {
1496                 SpaceIpo *sipo= (SpaceIpo *)ac->sa->spacedata.first;
1497                 bed.f1= (sipo) ? sipo->cursorVal : 0.0f;
1498         }
1499         
1500         /* snap keyframes */
1501         for (ale= anim_data.first; ale; ale= ale->next) {
1502                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1503                 
1504                 if (adt) {
1505                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1506                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1507                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1508                 }
1509                 else 
1510                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1511         }
1512         BLI_freelistN(&anim_data);
1513 }
1514
1515 /* ------------------- */
1516
1517 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
1518 {
1519         bAnimContext ac;
1520         short mode;
1521         
1522         /* get editor data */
1523         if (ANIM_animdata_get_context(C, &ac) == 0)
1524                 return OPERATOR_CANCELLED;
1525                 
1526         /* get snapping mode */
1527         mode= RNA_enum_get(op->ptr, "type");
1528         
1529         /* snap keyframes */
1530         snap_graph_keys(&ac, mode);
1531         
1532         /* validate keyframes after editing */
1533         ANIM_editkeyframes_refresh(&ac);
1534         
1535         /* set notifier that keyframes have changed */
1536         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1537         
1538         return OPERATOR_FINISHED;
1539 }
1540  
1541 void GRAPH_OT_snap (wmOperatorType *ot)
1542 {
1543         /* identifiers */
1544         ot->name= "Snap Keys";
1545         ot->idname= "GRAPH_OT_snap";
1546         ot->description= "Snap selected keyframes to the times specified.";
1547         
1548         /* api callbacks */
1549         ot->invoke= WM_menu_invoke;
1550         ot->exec= graphkeys_snap_exec;
1551         ot->poll= graphop_editable_keyframes_poll;
1552         
1553         /* flags */
1554         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1555         
1556         /* id-props */
1557         RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
1558 }
1559
1560 /* ******************** Mirror Keyframes Operator *********************** */
1561
1562 /* defines for mirror keyframes tool */
1563 EnumPropertyItem prop_graphkeys_mirror_types[] = {
1564         {GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current Frame", ""},
1565         {GRAPHKEYS_MIRROR_VALUE, "VALUE", 0, "By Values over Cursor Value", ""},
1566         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "By Times over Time=0", ""},
1567         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0", ""},
1568         {GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker", ""},
1569         {0, NULL, 0, NULL, NULL}
1570 };
1571
1572 /* this function is responsible for mirroring keyframes */
1573 static void mirror_graph_keys(bAnimContext *ac, short mode) 
1574 {
1575         ListBase anim_data = {NULL, NULL};
1576         bAnimListElem *ale;
1577         int filter;
1578         
1579         BeztEditData bed;
1580         BeztEditFunc edit_cb;
1581         
1582         /* get beztriple editing callbacks */
1583         edit_cb= ANIM_editkeyframes_mirror(mode);
1584         
1585         memset(&bed, 0, sizeof(BeztEditData)); 
1586         bed.scene= ac->scene;
1587         
1588         /* for 'first selected marker' mode, need to find first selected marker first! */
1589         // XXX should this be made into a helper func in the API?
1590         if (mode == GRAPHKEYS_MIRROR_MARKER) {
1591                 TimeMarker *marker= NULL;
1592                 
1593                 /* find first selected marker */
1594                 if (ac->markers) {
1595                         for (marker= ac->markers->first; marker; marker=marker->next) {
1596                                 if (marker->flag & SELECT) {
1597                                         break;
1598                                 }
1599                         }
1600                 }
1601                 
1602                 /* store marker's time (if available) */
1603                 if (marker)
1604                         bed.f1= (float)marker->frame;
1605                 else
1606                         return;
1607         }
1608         else if (mode == GRAPHKEYS_MIRROR_VALUE) {
1609                 SpaceIpo *sipo= (SpaceIpo *)ac->sa->spacedata.first;
1610                 bed.f1= (sipo) ? sipo->cursorVal : 0.0f;
1611         }
1612         
1613         /* filter data */
1614         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1615         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1616         
1617         /* mirror keyframes */
1618         for (ale= anim_data.first; ale; ale= ale->next) {
1619                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1620                 
1621                 if (adt) {
1622                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1623                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1624                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1625                 }
1626                 else 
1627                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1628         }
1629         BLI_freelistN(&anim_data);
1630 }
1631
1632 /* ------------------- */
1633
1634 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
1635 {
1636         bAnimContext ac;
1637         short mode;
1638         
1639         /* get editor data */
1640         if (ANIM_animdata_get_context(C, &ac) == 0)
1641                 return OPERATOR_CANCELLED;
1642                 
1643         /* get mirroring mode */
1644         mode= RNA_enum_get(op->ptr, "type");
1645         
1646         /* mirror keyframes */
1647         mirror_graph_keys(&ac, mode);
1648         
1649         /* validate keyframes after editing */
1650         ANIM_editkeyframes_refresh(&ac);
1651         
1652         /* set notifier that keyframes have changed */
1653         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1654         
1655         return OPERATOR_FINISHED;
1656 }
1657  
1658 void GRAPH_OT_mirror (wmOperatorType *ot)
1659 {
1660         /* identifiers */
1661         ot->name= "Mirror Keys";
1662         ot->idname= "GRAPH_OT_mirror";
1663         ot->description= "Flip selected keyframes over the selected mirror line.";
1664         
1665         /* api callbacks */
1666         ot->invoke= WM_menu_invoke;
1667         ot->exec= graphkeys_mirror_exec;
1668         ot->poll= graphop_editable_keyframes_poll;
1669         
1670         /* flags */
1671         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1672         
1673         /* id-props */
1674         RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
1675 }
1676
1677 /* ******************** Smooth Keyframes Operator *********************** */
1678
1679 static int graphkeys_smooth_exec(bContext *C, wmOperator *op)
1680 {
1681         bAnimContext ac;
1682         ListBase anim_data = {NULL, NULL};
1683         bAnimListElem *ale;
1684         int filter;
1685         
1686         /* get editor data */
1687         if (ANIM_animdata_get_context(C, &ac) == 0)
1688                 return OPERATOR_CANCELLED;
1689         
1690         /* filter data */
1691         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1692         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1693         
1694         /* smooth keyframes */
1695         for (ale= anim_data.first; ale; ale= ale->next) {
1696                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
1697                  * Perhaps the mode argument could be removed, as that functionality is offerred through 
1698                  * Snap->Flatten Handles anyway.
1699                  */
1700                 smooth_fcurve(ale->key_data);
1701         }
1702         BLI_freelistN(&anim_data);
1703         
1704         /* validate keyframes after editing */
1705         ANIM_editkeyframes_refresh(&ac);
1706         
1707         /* set notifier that keyframes have changed */
1708         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1709         
1710         return OPERATOR_FINISHED;
1711 }
1712  
1713 void GRAPH_OT_smooth (wmOperatorType *ot)
1714 {
1715         /* identifiers */
1716         ot->name= "Smooth Keys";
1717         ot->idname= "GRAPH_OT_smooth";
1718         ot->description= "Apply weighted moving means to make selected F-Curves less bumpy.";
1719         
1720         /* api callbacks */
1721         ot->exec= graphkeys_smooth_exec;
1722         ot->poll= graphop_editable_keyframes_poll;
1723         
1724         /* flags */
1725         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1726 }
1727
1728 /* ************************************************************************** */
1729 /* F-CURVE MODIFIERS */
1730
1731 /* ******************** Add F-Modifier Operator *********************** */
1732
1733 /* present a special customised popup menu for this, with some filtering */
1734 static int graph_fmodifier_add_invoke (bContext *C, wmOperator *op, wmEvent *event)
1735 {
1736         uiPopupMenu *pup;
1737         uiLayout *layout;
1738         int i;
1739         
1740         pup= uiPupMenuBegin(C, "Add F-Curve Modifier", 0);
1741         layout= uiPupMenuLayout(pup);
1742         
1743         /* start from 1 to skip the 'Invalid' modifier type */
1744         for (i = 1; i < FMODIFIER_NUM_TYPES; i++) {
1745                 FModifierTypeInfo *fmi= get_fmodifier_typeinfo(i);
1746                 PointerRNA props_ptr;
1747                 
1748                 /* check if modifier is valid for this context */
1749                 if (fmi == NULL)
1750                         continue;
1751                 
1752                 /* create operator menu item with relevant properties filled in */
1753                 props_ptr= uiItemFullO(layout, fmi->name, 0, "GRAPH_OT_fmodifier_add", NULL, WM_OP_EXEC_REGION_WIN, UI_ITEM_O_RETURN_PROPS);
1754                         /* the only thing that gets set from the menu is the type of F-Modifier to add */
1755                 RNA_enum_set(&props_ptr, "type", i);
1756                         /* the following properties are just repeats of existing ones... */
1757                 RNA_boolean_set(&props_ptr, "only_active", RNA_boolean_get(op->ptr, "only_active"));
1758         }
1759         uiItemS(layout);
1760         
1761         uiPupMenuEnd(C, pup);
1762         
1763         return OPERATOR_CANCELLED;
1764 }
1765
1766 static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
1767 {
1768         bAnimContext ac;
1769         ListBase anim_data = {NULL, NULL};
1770         bAnimListElem *ale;
1771         int filter;
1772         short type;
1773         
1774         /* get editor data */
1775         if (ANIM_animdata_get_context(C, &ac) == 0)
1776                 return OPERATOR_CANCELLED;
1777         
1778         /* get type of modifier to add */
1779         type= RNA_enum_get(op->ptr, "type");
1780         
1781         /* filter data */
1782         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1783         if (RNA_boolean_get(op->ptr, "only_active"))
1784                 filter |= ANIMFILTER_ACTIVE;
1785         else
1786                 filter |= ANIMFILTER_SEL;
1787         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1788         
1789         /* smooth keyframes */
1790         for (ale= anim_data.first; ale; ale= ale->next) {
1791                 FCurve *fcu= (FCurve *)ale->data;
1792                 FModifier *fcm;
1793                 
1794                 /* add F-Modifier of specified type to active F-Curve, and make it the active one */
1795                 fcm= add_fmodifier(&fcu->modifiers, type);
1796                 if (fcm)
1797                         set_active_fmodifier(&fcu->modifiers, fcm);
1798                 else { // TODO: stop when this happens?
1799                         BKE_report(op->reports, RPT_ERROR, "Modifier couldn't be added. See console for details.");
1800                         break;
1801                 }
1802         }
1803         BLI_freelistN(&anim_data);
1804         
1805         /* validate keyframes after editing */
1806         ANIM_editkeyframes_refresh(&ac);
1807         
1808         /* set notifier that things have changed */
1809         // FIXME: this really isn't the best description for it...
1810         WM_event_add_notifier(C, NC_ANIMATION, NULL);
1811         
1812         return OPERATOR_FINISHED;
1813 }
1814  
1815 void GRAPH_OT_fmodifier_add (wmOperatorType *ot)
1816 {
1817         /* identifiers */
1818         ot->name= "Add F-Curve Modifier";
1819         ot->idname= "GRAPH_OT_fmodifier_add";
1820         ot->description= "Add F-Modifiers to the selected F-Curves.";
1821         
1822         /* api callbacks */
1823         ot->invoke= graph_fmodifier_add_invoke;
1824         ot->exec= graph_fmodifier_add_exec;
1825         ot->poll= graphop_selected_fcurve_poll; 
1826         
1827         /* flags */
1828         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1829         
1830         /* id-props */
1831         RNA_def_enum(ot->srna, "type", fmodifier_type_items, 0, "Type", "");
1832         RNA_def_boolean(ot->srna, "only_active", 1, "Only Active", "Only add F-Modifier to active F-Curve.");
1833 }
1834
1835 /* ************************************************************************** */