soc-2008-mxcurioni: merged changes to revision 23516
[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_arithb.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= "Create 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         if (IS_AUTOKEY_FLAG(AUTOMATKEY)) flag |= INSERTKEY_MATRIX;
432         if (IS_AUTOKEY_FLAG(INSERTNEEDED)) flag |= INSERTKEY_NEEDED;
433         if (IS_AUTOKEY_MODE(scene, EDITKEYS)) flag |= INSERTKEY_REPLACE;
434         
435         /* insert keyframes */
436         for (ale= anim_data.first; ale; ale= ale->next) {
437                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
438                 FCurve *fcu= (FCurve *)ale->key_data;
439                 
440                 /* adjust current frame for NLA-mapping */
441                 if (adt)
442                         cfra= BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
443                 else 
444                         cfra= (float)CFRA;
445                         
446                 /* if there's an id */
447                 if (ale->id)
448                         insert_keyframe(ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
449                 else
450                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
451         }
452         
453         BLI_freelistN(&anim_data);
454 }
455
456 /* ------------------- */
457
458 static int graphkeys_insertkey_exec(bContext *C, wmOperator *op)
459 {
460         bAnimContext ac;
461         short mode;
462         
463         /* get editor data */
464         if (ANIM_animdata_get_context(C, &ac) == 0)
465                 return OPERATOR_CANCELLED;
466         if (ac.datatype == ANIMCONT_GPENCIL)
467                 return OPERATOR_CANCELLED;
468                 
469         /* which channels to affect? */
470         mode= RNA_enum_get(op->ptr, "type");
471         
472         /* insert keyframes */
473         insert_graph_keys(&ac, mode);
474         
475         /* validate keyframes after editing */
476         ANIM_editkeyframes_refresh(&ac);
477         
478         /* set notifier that keyframes have changed */
479         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
480         
481         return OPERATOR_FINISHED;
482 }
483
484 void GRAPH_OT_insert_keyframe (wmOperatorType *ot)
485 {
486         /* identifiers */
487         ot->name= "Insert Keyframes";
488         ot->idname= "GRAPH_OT_insert_keyframe";
489         ot->description= "Insert keyframes for the specified channels.";
490         
491         /* api callbacks */
492         ot->invoke= WM_menu_invoke;
493         ot->exec= graphkeys_insertkey_exec;
494         ot->poll= graphop_editable_keyframes_poll;
495         
496         /* flags */
497         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
498         
499         /* id-props */
500         RNA_def_enum(ot->srna, "type", prop_graphkeys_insertkey_types, 0, "Type", "");
501 }
502
503 /* ******************** Click-Insert Keyframes Operator ************************* */
504
505 static int graphkeys_click_insert_exec (bContext *C, wmOperator *op)
506 {
507         bAnimContext ac;
508         bAnimListElem *ale;
509         AnimData *adt;
510         float frame, val;
511         
512         /* get animation context */
513         if (ANIM_animdata_get_context(C, &ac) == 0)
514                 return OPERATOR_CANCELLED;
515         
516         /* get active F-Curve 'anim-list-element' */
517         ale= get_active_fcurve_channel(&ac);
518         if (ELEM(NULL, ale, ale->data)) {
519                 if (ale) MEM_freeN(ale);
520                 return OPERATOR_CANCELLED;
521         }
522                 
523         /* get frame and value from props */
524         frame= RNA_float_get(op->ptr, "frame");
525         val= RNA_float_get(op->ptr, "value");
526         
527         /* apply inverse NLA-mapping to frame to get correct time in un-scaled action */
528         adt= ANIM_nla_mapping_get(&ac, ale);
529         frame= BKE_nla_tweakedit_remap(adt, frame, NLATIME_CONVERT_UNMAP);
530         
531         /* insert keyframe on the specified frame + value */
532         insert_vert_fcurve((FCurve *)ale->data, frame, val, 0);
533         
534         /* free temp data */
535         MEM_freeN(ale);
536         
537         /* set notifier that keyframes have changed */
538         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
539         
540         /* done */
541         return OPERATOR_FINISHED;
542 }
543
544 static int graphkeys_click_insert_invoke (bContext *C, wmOperator *op, wmEvent *evt)
545 {
546         bAnimContext ac;
547         ARegion *ar;
548         View2D *v2d;
549         int mval[2];
550         float x, y;
551         
552         /* get animation context */
553         if (ANIM_animdata_get_context(C, &ac) == 0)
554                 return OPERATOR_CANCELLED;
555         
556         /* store mouse coordinates in View2D space, into the operator's properties */
557         ar= ac.ar;
558         v2d= &ar->v2d;
559         
560         mval[0]= (evt->x - ar->winrct.xmin);
561         mval[1]= (evt->y - ar->winrct.ymin);
562         
563         UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y);
564         
565         RNA_float_set(op->ptr, "frame", x);
566         RNA_float_set(op->ptr, "value", y);
567         
568         /* run exec now */
569         return graphkeys_click_insert_exec(C, op);
570 }
571
572 void GRAPH_OT_click_insert (wmOperatorType *ot)
573 {
574         /* identifiers */
575         ot->name= "Click-Insert Keyframes";
576         ot->idname= "GRAPH_OT_click_insert";
577         ot->description= "Insert new keyframe at the cursor position for the active F-Curve.";
578         
579         /* api callbacks */
580         ot->invoke= graphkeys_click_insert_invoke;
581         ot->exec= graphkeys_click_insert_exec;
582         ot->poll= graphop_active_fcurve_poll;
583         
584         /* flags */
585         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
586         
587         /* properties */
588         RNA_def_float(ot->srna, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame Number", "Frame to insert keyframe on", 0, 100);
589         RNA_def_float(ot->srna, "value", 1.0f, -FLT_MAX, FLT_MAX, "Value", "Value for keyframe on", 0, 100);
590 }
591
592 /* ******************** Copy/Paste Keyframes Operator ************************* */
593 /* NOTE: the backend code for this is shared with the dopesheet editor */
594
595 static short copy_graph_keys (bAnimContext *ac)
596 {       
597         ListBase anim_data = {NULL, NULL};
598         int filter, ok=0;
599         
600         /* clear buffer first */
601         free_anim_copybuf();
602         
603         /* filter data */
604         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
605         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
606         
607         /* copy keyframes */
608         ok= copy_animedit_keys(ac, &anim_data);
609         
610         /* clean up */
611         BLI_freelistN(&anim_data);
612
613         return ok;
614 }
615
616 static short paste_graph_keys (bAnimContext *ac)
617 {       
618         ListBase anim_data = {NULL, NULL};
619         int filter, ok=0;
620         
621         /* filter data */
622         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
623         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
624         
625         /* paste keyframes */
626         ok= paste_animedit_keys(ac, &anim_data);
627         
628         /* clean up */
629         BLI_freelistN(&anim_data);
630
631         return ok;
632 }
633
634 /* ------------------- */
635
636 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
637 {
638         bAnimContext ac;
639         
640         /* get editor data */
641         if (ANIM_animdata_get_context(C, &ac) == 0)
642                 return OPERATOR_CANCELLED;
643         
644         /* copy keyframes */
645         if (copy_graph_keys(&ac)) {     
646                 BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
647                 return OPERATOR_CANCELLED;
648         }
649         
650         /* just return - no operator needed here (no changes) */
651         return OPERATOR_FINISHED;
652 }
653  
654 void GRAPH_OT_copy (wmOperatorType *ot)
655 {
656         /* identifiers */
657         ot->name= "Copy Keyframes";
658         ot->idname= "GRAPH_OT_copy";
659         ot->description= "Copy selected keyframes to the copy/paste buffer.";
660         
661         /* api callbacks */
662         ot->exec= graphkeys_copy_exec;
663         ot->poll= graphop_editable_keyframes_poll;
664         
665         /* flags */
666         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
667 }
668
669
670
671 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
672 {
673         bAnimContext ac;
674         
675         /* get editor data */
676         if (ANIM_animdata_get_context(C, &ac) == 0)
677                 return OPERATOR_CANCELLED;
678         
679         /* paste keyframes */
680         if (paste_graph_keys(&ac)) {
681                 BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
682                 return OPERATOR_CANCELLED;
683         }
684         
685         /* validate keyframes after editing */
686         ANIM_editkeyframes_refresh(&ac);
687         
688         /* set notifier that keyframes have changed */
689         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
690         
691         return OPERATOR_FINISHED;
692 }
693  
694 void GRAPH_OT_paste (wmOperatorType *ot)
695 {
696         /* identifiers */
697         ot->name= "Paste Keyframes";
698         ot->idname= "GRAPH_OT_paste";
699         ot->description= "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame.";
700         
701         /* api callbacks */
702         ot->exec= graphkeys_paste_exec;
703         ot->poll= graphop_editable_keyframes_poll;
704         
705         /* flags */
706         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
707 }
708
709 /* ******************** Duplicate Keyframes Operator ************************* */
710
711 static void duplicate_graph_keys (bAnimContext *ac)
712 {
713         ListBase anim_data = {NULL, NULL};
714         bAnimListElem *ale;
715         int filter;
716         
717         /* filter data */
718         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
719         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
720         
721         /* loop through filtered data and delete selected keys */
722         for (ale= anim_data.first; ale; ale= ale->next) {
723                 duplicate_fcurve_keys((FCurve *)ale->key_data);
724         }
725         
726         /* free filtered list */
727         BLI_freelistN(&anim_data);
728 }
729
730 /* ------------------- */
731
732 static int graphkeys_duplicate_exec(bContext *C, wmOperator *op)
733 {
734         bAnimContext ac;
735         
736         /* get editor data */
737         if (ANIM_animdata_get_context(C, &ac) == 0)
738                 return OPERATOR_CANCELLED;
739                 
740         /* duplicate keyframes */
741         duplicate_graph_keys(&ac);
742         
743         /* validate keyframes after editing */
744         ANIM_editkeyframes_refresh(&ac);
745         
746         /* set notifier that keyframes have changed */
747         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
748         
749         return OPERATOR_FINISHED;
750 }
751
752 static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
753 {
754         graphkeys_duplicate_exec(C, op);
755         
756         RNA_int_set(op->ptr, "mode", TFM_TRANSLATION);
757         WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
758
759         return OPERATOR_FINISHED;
760 }
761  
762 void GRAPH_OT_duplicate (wmOperatorType *ot)
763 {
764         /* identifiers */
765         ot->name= "Duplicate Keyframes";
766         ot->idname= "GRAPH_OT_duplicate";
767         ot->description= "Make a copy of all selected keyframes.";
768         
769         /* api callbacks */
770         ot->invoke= graphkeys_duplicate_invoke;
771         ot->exec= graphkeys_duplicate_exec;
772         ot->poll= graphop_editable_keyframes_poll;
773         
774         /* flags */
775         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
776         
777         /* to give to transform */
778         RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
779 }
780
781 /* ******************** Delete Keyframes Operator ************************* */
782
783 static void delete_graph_keys (bAnimContext *ac)
784 {
785         ListBase anim_data = {NULL, NULL};
786         bAnimListElem *ale;
787         int filter;
788         
789         /* filter data */
790         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
791         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
792         
793         /* loop through filtered data and delete selected keys */
794         for (ale= anim_data.first; ale; ale= ale->next) {
795                 delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
796         }
797         
798         /* free filtered list */
799         BLI_freelistN(&anim_data);
800 }
801
802 /* ------------------- */
803
804 static int graphkeys_delete_exec(bContext *C, wmOperator *op)
805 {
806         bAnimContext ac;
807         
808         /* get editor data */
809         if (ANIM_animdata_get_context(C, &ac) == 0)
810                 return OPERATOR_CANCELLED;
811                 
812         /* delete keyframes */
813         delete_graph_keys(&ac);
814         
815         /* validate keyframes after editing */
816         ANIM_editkeyframes_refresh(&ac);
817         
818         /* set notifier that keyframes have changed */
819         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
820         
821         return OPERATOR_FINISHED;
822 }
823  
824 void GRAPH_OT_delete (wmOperatorType *ot)
825 {
826         /* identifiers */
827         ot->name= "Delete Keyframes";
828         ot->idname= "GRAPH_OT_delete";
829         ot->description= "Remove all selected keyframes.";
830         
831         /* api callbacks */
832         ot->invoke= WM_operator_confirm;
833         ot->exec= graphkeys_delete_exec;
834         ot->poll= graphop_editable_keyframes_poll;
835         
836         /* flags */
837         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
838 }
839
840 /* ******************** Clean Keyframes Operator ************************* */
841
842 static void clean_graph_keys (bAnimContext *ac, float thresh)
843 {       
844         ListBase anim_data = {NULL, NULL};
845         bAnimListElem *ale;
846         int filter;
847         
848         /* filter data */
849         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
850         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
851         
852         /* loop through filtered data and clean curves */
853         for (ale= anim_data.first; ale; ale= ale->next)
854                 clean_fcurve((FCurve *)ale->key_data, thresh);
855         
856         /* free temp data */
857         BLI_freelistN(&anim_data);
858 }
859
860 /* ------------------- */
861
862 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
863 {
864         bAnimContext ac;
865         float thresh;
866         
867         /* get editor data */
868         if (ANIM_animdata_get_context(C, &ac) == 0)
869                 return OPERATOR_CANCELLED;
870                 
871         /* get cleaning threshold */
872         thresh= RNA_float_get(op->ptr, "threshold");
873         
874         /* clean keyframes */
875         clean_graph_keys(&ac, thresh);
876         
877         /* validate keyframes after editing */
878         ANIM_editkeyframes_refresh(&ac);
879         
880         /* set notifier that keyframes have changed */
881         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
882         
883         return OPERATOR_FINISHED;
884 }
885  
886 void GRAPH_OT_clean (wmOperatorType *ot)
887 {
888         /* identifiers */
889         ot->name= "Clean Keyframes";
890         ot->idname= "GRAPH_OT_clean";
891         ot->description= "Simplify F-Curves by removing closely spaced keyframes.";
892         
893         /* api callbacks */
894         //ot->invoke=  // XXX we need that number popup for this! 
895         ot->exec= graphkeys_clean_exec;
896         ot->poll= graphop_editable_keyframes_poll;
897         
898         /* flags */
899         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
900         
901         /* properties */
902         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
903 }
904
905 /* ******************** Bake F-Curve Operator *********************** */
906 /* This operator bakes the data of the selected F-Curves to F-Points */
907
908 /* Bake each F-Curve into a set of samples */
909 static void bake_graph_curves (bAnimContext *ac, int start, int end)
910 {       
911         ListBase anim_data = {NULL, NULL};
912         bAnimListElem *ale;
913         int filter;
914         
915         /* filter data */
916         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
917         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
918         
919         /* loop through filtered data and add keys between selected keyframes on every frame  */
920         for (ale= anim_data.first; ale; ale= ale->next) {
921                 FCurve *fcu= (FCurve *)ale->key_data;
922                 ChannelDriver *driver= fcu->driver;
923                 
924                 /* disable driver so that it don't muck up the sampling process */
925                 fcu->driver= NULL;
926                 
927                 /* create samples */
928                 fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
929                 
930                 /* restore driver */
931                 fcu->driver= driver;
932         }
933         
934         /* admin and redraws */
935         BLI_freelistN(&anim_data);
936 }
937
938 /* ------------------- */
939
940 static int graphkeys_bake_exec(bContext *C, wmOperator *op)
941 {
942         bAnimContext ac;
943         Scene *scene= NULL;
944         int start, end;
945         
946         /* get editor data */
947         if (ANIM_animdata_get_context(C, &ac) == 0)
948                 return OPERATOR_CANCELLED;
949                 
950         /* for now, init start/end from preview-range extents */
951         // TODO: add properties for this 
952         scene= ac.scene;
953         start= PSFRA;
954         end= PEFRA;
955         
956         /* bake keyframes */
957         bake_graph_curves(&ac, start, end);
958         
959         /* validate keyframes after editing */
960         ANIM_editkeyframes_refresh(&ac);
961         
962         /* set notifier that keyframes have changed */
963         // NOTE: some distinction between order/number of keyframes and type should be made?
964         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
965         
966         return OPERATOR_FINISHED;
967 }
968  
969 void GRAPH_OT_bake (wmOperatorType *ot)
970 {
971         /* identifiers */
972         ot->name= "Bake Curve";
973         ot->idname= "GRAPH_OT_bake";
974         ot->description= "Bake selected F-Curves to a set of sampled points defining a similar curve.";
975         
976         /* api callbacks */
977         ot->invoke= WM_operator_confirm; // FIXME...
978         ot->exec= graphkeys_bake_exec;
979         ot->poll= graphop_editable_keyframes_poll;
980         
981         /* flags */
982         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
983         
984         // todo: add props for start/end frames
985 }
986
987 /* ******************** Sample Keyframes Operator *********************** */
988 /* This operator 'bakes' the values of the curve into new keyframes between pairs
989  * of selected keyframes. It is useful for creating keyframes for tweaking overlap.
990  */
991
992 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
993 static void sample_graph_keys (bAnimContext *ac)
994 {       
995         ListBase anim_data = {NULL, NULL};
996         bAnimListElem *ale;
997         int filter;
998         
999         /* filter data */
1000         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1001         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1002         
1003         /* loop through filtered data and add keys between selected keyframes on every frame  */
1004         for (ale= anim_data.first; ale; ale= ale->next)
1005                 sample_fcurve((FCurve *)ale->key_data);
1006         
1007         /* admin and redraws */
1008         BLI_freelistN(&anim_data);
1009 }
1010
1011 /* ------------------- */
1012
1013 static int graphkeys_sample_exec(bContext *C, wmOperator *op)
1014 {
1015         bAnimContext ac;
1016         
1017         /* get editor data */
1018         if (ANIM_animdata_get_context(C, &ac) == 0)
1019                 return OPERATOR_CANCELLED;
1020         
1021         /* sample keyframes */
1022         sample_graph_keys(&ac);
1023         
1024         /* validate keyframes after editing */
1025         ANIM_editkeyframes_refresh(&ac);
1026         
1027         /* set notifier that keyframes have changed */
1028         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1029         
1030         return OPERATOR_FINISHED;
1031 }
1032  
1033 void GRAPH_OT_sample (wmOperatorType *ot)
1034 {
1035         /* identifiers */
1036         ot->name= "Sample Keyframes";
1037         ot->idname= "GRAPH_OT_sample";
1038         ot->description= "Add keyframes on every frame between the selected keyframes.";
1039         
1040         /* api callbacks */
1041         ot->exec= graphkeys_sample_exec;
1042         ot->poll= graphop_editable_keyframes_poll;
1043         
1044         /* flags */
1045         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1046 }
1047
1048
1049 /* ************************************************************************** */
1050 /* SETTINGS STUFF */
1051
1052 /* ******************** Set Extrapolation-Type Operator *********************** */
1053
1054 /* defines for set extrapolation-type for selected keyframes tool */
1055 EnumPropertyItem prop_graphkeys_expo_types[] = {
1056         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
1057         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
1058         {0, NULL, 0, NULL, NULL}
1059 };
1060
1061 /* this function is responsible for setting extrapolation mode for keyframes */
1062 static void setexpo_graph_keys(bAnimContext *ac, short mode) 
1063 {
1064         ListBase anim_data = {NULL, NULL};
1065         bAnimListElem *ale;
1066         int filter;
1067         
1068         /* filter data */
1069         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1070         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1071         
1072         /* loop through setting mode per F-Curve */
1073         for (ale= anim_data.first; ale; ale= ale->next) {
1074                 FCurve *fcu= (FCurve *)ale->data;
1075                 fcu->extend= mode;
1076         }
1077         
1078         /* cleanup */
1079         BLI_freelistN(&anim_data);
1080 }
1081
1082 /* ------------------- */
1083
1084 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
1085 {
1086         bAnimContext ac;
1087         short mode;
1088         
1089         /* get editor data */
1090         if (ANIM_animdata_get_context(C, &ac) == 0)
1091                 return OPERATOR_CANCELLED;
1092                 
1093         /* get handle setting mode */
1094         mode= RNA_enum_get(op->ptr, "type");
1095         
1096         /* set handle type */
1097         setexpo_graph_keys(&ac, mode);
1098         
1099         /* validate keyframes after editing */
1100         ANIM_editkeyframes_refresh(&ac);
1101         
1102         /* set notifier that keyframe properties have changed */
1103         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1104         
1105         return OPERATOR_FINISHED;
1106 }
1107  
1108 void GRAPH_OT_extrapolation_type (wmOperatorType *ot)
1109 {
1110         /* identifiers */
1111         ot->name= "Set Keyframe Extrapolation";
1112         ot->idname= "GRAPH_OT_extrapolation_type";
1113         ot->description= "Set extrapolation mode for selected F-Curves.";
1114         
1115         /* api callbacks */
1116         ot->invoke= WM_menu_invoke;
1117         ot->exec= graphkeys_expo_exec;
1118         ot->poll= graphop_editable_keyframes_poll;
1119         
1120         /* flags */
1121         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1122         
1123         /* id-props */
1124         RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
1125 }
1126
1127 /* ******************** Set Interpolation-Type Operator *********************** */
1128
1129 /* this function is responsible for setting interpolation mode for keyframes */
1130 static void setipo_graph_keys(bAnimContext *ac, short mode) 
1131 {
1132         ListBase anim_data = {NULL, NULL};
1133         bAnimListElem *ale;
1134         int filter;
1135         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
1136         
1137         /* filter data */
1138         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1139         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1140         
1141         /* loop through setting BezTriple interpolation
1142          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1143          */
1144         for (ale= anim_data.first; ale; ale= ale->next)
1145                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1146         
1147         /* cleanup */
1148         BLI_freelistN(&anim_data);
1149 }
1150
1151 /* ------------------- */
1152
1153 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
1154 {
1155         bAnimContext ac;
1156         short mode;
1157         
1158         /* get editor data */
1159         if (ANIM_animdata_get_context(C, &ac) == 0)
1160                 return OPERATOR_CANCELLED;
1161                 
1162         /* get handle setting mode */
1163         mode= RNA_enum_get(op->ptr, "type");
1164         
1165         /* set handle type */
1166         setipo_graph_keys(&ac, mode);
1167         
1168         /* validate keyframes after editing */
1169         ANIM_editkeyframes_refresh(&ac);
1170         
1171         /* set notifier that keyframe properties have changed */
1172         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1173         
1174         return OPERATOR_FINISHED;
1175 }
1176  
1177 void GRAPH_OT_interpolation_type (wmOperatorType *ot)
1178 {
1179         /* identifiers */
1180         ot->name= "Set Keyframe Interpolation";
1181         ot->idname= "GRAPH_OT_interpolation_type";
1182         ot->description= "Set interpolation mode for the F-Curve segments starting from the selected keyframes.";
1183         
1184         /* api callbacks */
1185         ot->invoke= WM_menu_invoke;
1186         ot->exec= graphkeys_ipo_exec;
1187         ot->poll= graphop_editable_keyframes_poll;
1188         
1189         /* flags */
1190         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1191         
1192         /* id-props */
1193         RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
1194 }
1195
1196 /* ******************** Set Handle-Type Operator *********************** */
1197
1198 /* this function is responsible for setting handle-type of selected keyframes */
1199 static void sethandles_graph_keys(bAnimContext *ac, short mode) 
1200 {
1201         ListBase anim_data = {NULL, NULL};
1202         bAnimListElem *ale;
1203         int filter;
1204         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
1205         
1206         /* filter data */
1207         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1208         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1209         
1210         /* loop through setting flags for handles 
1211          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1212          */
1213         // XXX we might need to supply BeztEditData to get it to only affect selected handles
1214         for (ale= anim_data.first; ale; ale= ale->next) {
1215                 if (mode == -1) {       
1216                         BeztEditFunc toggle_cb;
1217                         
1218                         /* check which type of handle to set (free or aligned) 
1219                          *      - check here checks for handles with free alignment already
1220                          */
1221                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
1222                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
1223                         else
1224                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
1225                                 
1226                         /* set handle-type */
1227                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
1228                 }
1229                 else {
1230                         /* directly set handle-type */
1231                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1232                 }
1233         }
1234         
1235         /* cleanup */
1236         BLI_freelistN(&anim_data);
1237 }
1238
1239 /* ------------------- */
1240
1241 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
1242 {
1243         bAnimContext ac;
1244         short mode;
1245         
1246         /* get editor data */
1247         if (ANIM_animdata_get_context(C, &ac) == 0)
1248                 return OPERATOR_CANCELLED;
1249                 
1250         /* get handle setting mode */
1251         mode= RNA_enum_get(op->ptr, "type");
1252         
1253         /* set handle type */
1254         sethandles_graph_keys(&ac, mode);
1255         
1256         /* validate keyframes after editing */
1257         ANIM_editkeyframes_refresh(&ac);
1258         
1259         /* set notifier that things have changed */
1260         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1261         
1262         return OPERATOR_FINISHED;
1263 }
1264  
1265 void GRAPH_OT_handle_type (wmOperatorType *ot)
1266 {
1267         /* identifiers */
1268         ot->name= "Set Keyframe Handle Type";
1269         ot->idname= "GRAPH_OT_handle_type";
1270         ot->description= "Set type of handle for selected keyframes.";
1271         
1272         /* api callbacks */
1273         ot->invoke= WM_menu_invoke;
1274         ot->exec= graphkeys_handletype_exec;
1275         ot->poll= graphop_editable_keyframes_poll;
1276         
1277         /* flags */
1278         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1279         
1280         /* id-props */
1281         RNA_def_enum(ot->srna, "type", beztriple_handle_type_items, 0, "Type", "");
1282 }
1283
1284 /* ************************************************************************** */
1285 /* TRANSFORM STUFF */
1286
1287 /* ***************** 'Euler Filter' Operator **************************** */
1288 /* Euler filter tools (as seen in Maya), are necessary for working with 'baked'
1289  * rotation curves (with Euler rotations). The main purpose of such tools is to
1290  * resolve any discontinuities that may arise in the curves due to the clamping
1291  * of values to -180 degrees to 180 degrees.
1292  */
1293
1294 #if 0 // XXX this is not ready for the primetime yet
1295  
1296 /* set of three euler-rotation F-Curves */
1297 typedef struct tEulerFilter {
1298         ID *id;                                                 /* ID-block which owns the channels */
1299         FCurve (*fcurves)[3];                   /* 3 Pointers to F-Curves */                            
1300 } tEulerFilter;
1301  
1302 static int graphkeys_euler_filter_exec (bContext *C, wmOperator *op)
1303 {
1304         bAnimContext ac;
1305         
1306         ListBase anim_data= {NULL, NULL};
1307         bAnimListElem *ale;
1308         int filter;
1309         
1310         ListBase eulers = {NULL, NULL};
1311         tEulerFilter *euf= NULL;        
1312         
1313         /* get editor data */
1314         if (ANIM_animdata_get_context(C, &ac) == 0)
1315                 return OPERATOR_CANCELLED;
1316                 
1317         /* The process is done in two passes:
1318          *       1) Sets of three related rotation curves are identified from the selected channels,
1319          *              and are stored as a single 'operation unit' for the next step
1320          *       2) Each set of three F-Curves is processed for each keyframe, with the values being
1321          *              processed according to one of several ways.
1322          */
1323          
1324         /* step 1: extract only the rotation f-curves */
1325         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY | ANIMFILTER_FOREDIT);
1326         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1327         
1328         for (ale= anim_data.first; ale; ale= ale->next) {
1329                 FCurve *fcu = (FCurve *)ale->data;
1330                 
1331                 /* check if this is an appropriate F-Curve 
1332                  *      - only rotation curves
1333                  *      - for pchan curves, make sure we're only using the euler curves
1334                  */
1335                 if (ELEM(0, fcu->rna_path, strstr(fcu->rna_path, "rotation")))
1336                         continue;
1337                 if (strstr(fcu->rna_path, "pose.pose_channels")) {
1338                         if (strstr(fcu->rna_path, "euler_rotation") == 0)
1339                                 continue;
1340                 }
1341                 
1342                 /* check if current set of 3-curves is suitable to add this curve to 
1343                  *      - things like whether the current set of curves is 'full' should be checked later only
1344                  *      - first check if id-blocks are compatible
1345                  */
1346                 if ((euf) && (ale->id != euf->id)) {
1347                         /* if the paths match, add this curve to the set of curves */
1348                         // NOTE: simple string compare for now... could be a bit more fancy...
1349                         
1350                 }
1351                 else {
1352                         /* just add to a new block */
1353                         euf= MEM_callocN(sizeof(tEulerFilter), "tEulerFilter");
1354                         BLI_addtail(&eulers, euf);
1355                         
1356                         euf->id= ale->id;
1357                         euf->fcurves[fcu->array_index]= fcu;
1358                 }
1359         }
1360         BLI_freelistN(&anim_data);
1361         
1362         /* step 2: go through each set of curves, processing the values at each keyframe 
1363          *      - it is assumed that there must be a full set of keyframes at each keyframe position
1364          */
1365         for (euf= eulers.first; euf; euf= euf->next) {
1366                 
1367         }
1368         BLI_freelistN(&eulers);
1369         
1370         return OPERATOR_FINISHED;
1371 }
1372  
1373 void GRAPH_OT_euler_filter (wmOperatorType *ot)
1374 {
1375         /* identifiers */
1376         ot->name= "Euler Filter";
1377         ot->idname= "GRAPH_OT_euler_filter";
1378         
1379         /* api callbacks */
1380         ot->exec= graphkeys_euler_filter_exec;
1381         ot->poll= graphop_editable_keyframes_poll;
1382         
1383         /* flags */
1384         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1385 }
1386
1387 #endif // XXX this is not ready for the primetime yet
1388
1389 /* ***************** Jump to Selected Frames Operator *********************** */
1390
1391 /* snap current-frame indicator to 'average time' of selected keyframe */
1392 static int graphkeys_framejump_exec(bContext *C, wmOperator *op)
1393 {
1394         bAnimContext ac;
1395         ListBase anim_data= {NULL, NULL};
1396         bAnimListElem *ale;
1397         int filter;
1398         BeztEditData bed;
1399         
1400         /* get editor data */
1401         if (ANIM_animdata_get_context(C, &ac) == 0)
1402                 return OPERATOR_CANCELLED;
1403         
1404         /* init edit data */
1405         memset(&bed, 0, sizeof(BeztEditData));
1406         
1407         /* loop over action data, averaging values */
1408         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
1409         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1410         
1411         for (ale= anim_data.first; ale; ale= ale->next) {
1412                 AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
1413                 
1414                 if (adt) {
1415                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1416                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1417                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1); 
1418                 }
1419                 else
1420                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1421                 
1422         }
1423         
1424         BLI_freelistN(&anim_data);
1425         
1426         /* set the new current frame value, based on the average time */
1427         if (bed.i1) {
1428                 Scene *scene= ac.scene;
1429                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1430         }
1431         
1432         /* set notifier that things have changed */
1433         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1434         
1435         return OPERATOR_FINISHED;
1436 }
1437
1438 void GRAPH_OT_frame_jump (wmOperatorType *ot)
1439 {
1440         /* identifiers */
1441         ot->name= "Jump to Frame";
1442         ot->idname= "GRAPH_OT_frame_jump";
1443         ot->description= "Set the current frame to the average frame of the selected keyframes.";
1444         
1445         /* api callbacks */
1446         ot->exec= graphkeys_framejump_exec;
1447         ot->poll= graphop_visible_keyframes_poll;
1448         
1449         /* flags */
1450         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1451 }
1452
1453 /* ******************** Snap Keyframes Operator *********************** */
1454
1455 /* defines for snap keyframes tool */
1456 EnumPropertyItem prop_graphkeys_snap_types[] = {
1457         {GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
1458         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
1459         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
1460         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
1461         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles", ""},
1462         {0, NULL, 0, NULL, NULL}
1463 };
1464
1465 /* this function is responsible for snapping keyframes to frame-times */
1466 static void snap_graph_keys(bAnimContext *ac, short mode) 
1467 {
1468         ListBase anim_data = {NULL, NULL};
1469         bAnimListElem *ale;
1470         int filter;
1471         
1472         BeztEditData bed;
1473         BeztEditFunc edit_cb;
1474         
1475         /* filter data */
1476         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1477         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1478         
1479         /* get beztriple editing callbacks */
1480         edit_cb= ANIM_editkeyframes_snap(mode);
1481         
1482         memset(&bed, 0, sizeof(BeztEditData)); 
1483         bed.scene= ac->scene;
1484         if (mode == GRAPHKEYS_SNAP_NEAREST_MARKER) {
1485                 bed.list.first= (ac->markers) ? ac->markers->first : NULL;
1486                 bed.list.last= (ac->markers) ? ac->markers->last : NULL;
1487         }
1488         
1489         /* snap keyframes */
1490         for (ale= anim_data.first; ale; ale= ale->next) {
1491                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1492                 
1493                 if (adt) {
1494                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1495                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1496                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1497                 }
1498                 else 
1499                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1500         }
1501         BLI_freelistN(&anim_data);
1502 }
1503
1504 /* ------------------- */
1505
1506 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
1507 {
1508         bAnimContext ac;
1509         short mode;
1510         
1511         /* get editor data */
1512         if (ANIM_animdata_get_context(C, &ac) == 0)
1513                 return OPERATOR_CANCELLED;
1514                 
1515         /* get snapping mode */
1516         mode= RNA_enum_get(op->ptr, "type");
1517         
1518         /* snap keyframes */
1519         snap_graph_keys(&ac, mode);
1520         
1521         /* validate keyframes after editing */
1522         ANIM_editkeyframes_refresh(&ac);
1523         
1524         /* set notifier that keyframes have changed */
1525         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1526         
1527         return OPERATOR_FINISHED;
1528 }
1529  
1530 void GRAPH_OT_snap (wmOperatorType *ot)
1531 {
1532         /* identifiers */
1533         ot->name= "Snap Keys";
1534         ot->idname= "GRAPH_OT_snap";
1535         ot->description= "Snap selected keyframes to the times specified.";
1536         
1537         /* api callbacks */
1538         ot->invoke= WM_menu_invoke;
1539         ot->exec= graphkeys_snap_exec;
1540         ot->poll= graphop_editable_keyframes_poll;
1541         
1542         /* flags */
1543         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1544         
1545         /* id-props */
1546         RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
1547 }
1548
1549 /* ******************** Mirror Keyframes Operator *********************** */
1550
1551 /* defines for mirror keyframes tool */
1552 EnumPropertyItem prop_graphkeys_mirror_types[] = {
1553         {GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current frame", ""},
1554         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "By Times over Time=0", ""},
1555         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0", ""},
1556         {GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker", ""},
1557         {0, NULL, 0, NULL, NULL}
1558 };
1559
1560 /* this function is responsible for mirroring keyframes */
1561 static void mirror_graph_keys(bAnimContext *ac, short mode) 
1562 {
1563         ListBase anim_data = {NULL, NULL};
1564         bAnimListElem *ale;
1565         int filter;
1566         
1567         BeztEditData bed;
1568         BeztEditFunc edit_cb;
1569         
1570         /* get beztriple editing callbacks */
1571         edit_cb= ANIM_editkeyframes_mirror(mode);
1572         
1573         memset(&bed, 0, sizeof(BeztEditData)); 
1574         bed.scene= ac->scene;
1575         
1576         /* for 'first selected marker' mode, need to find first selected marker first! */
1577         // XXX should this be made into a helper func in the API?
1578         if (mode == GRAPHKEYS_MIRROR_MARKER) {
1579                 TimeMarker *marker= NULL;
1580                 
1581                 /* find first selected marker */
1582                 if (ac->markers) {
1583                         for (marker= ac->markers->first; marker; marker=marker->next) {
1584                                 if (marker->flag & SELECT) {
1585                                         break;
1586                                 }
1587                         }
1588                 }
1589                 
1590                 /* store marker's time (if available) */
1591                 if (marker)
1592                         bed.f1= (float)marker->frame;
1593                 else
1594                         return;
1595         }
1596         
1597         /* filter data */
1598         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1599         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1600         
1601         /* mirror keyframes */
1602         for (ale= anim_data.first; ale; ale= ale->next) {
1603                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1604                 
1605                 if (adt) {
1606                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1607                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1608                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1609                 }
1610                 else 
1611                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1612         }
1613         BLI_freelistN(&anim_data);
1614 }
1615
1616 /* ------------------- */
1617
1618 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
1619 {
1620         bAnimContext ac;
1621         short mode;
1622         
1623         /* get editor data */
1624         if (ANIM_animdata_get_context(C, &ac) == 0)
1625                 return OPERATOR_CANCELLED;
1626                 
1627         /* get mirroring mode */
1628         mode= RNA_enum_get(op->ptr, "type");
1629         
1630         /* mirror keyframes */
1631         mirror_graph_keys(&ac, mode);
1632         
1633         /* validate keyframes after editing */
1634         ANIM_editkeyframes_refresh(&ac);
1635         
1636         /* set notifier that keyframes have changed */
1637         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1638         
1639         return OPERATOR_FINISHED;
1640 }
1641  
1642 void GRAPH_OT_mirror (wmOperatorType *ot)
1643 {
1644         /* identifiers */
1645         ot->name= "Mirror Keys";
1646         ot->idname= "GRAPH_OT_mirror";
1647         ot->description= "Flip selected keyframes over the selected mirror line.";
1648         
1649         /* api callbacks */
1650         ot->invoke= WM_menu_invoke;
1651         ot->exec= graphkeys_mirror_exec;
1652         ot->poll= graphop_editable_keyframes_poll;
1653         
1654         /* flags */
1655         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1656         
1657         /* id-props */
1658         RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
1659 }
1660
1661 /* ******************** Smooth Keyframes Operator *********************** */
1662
1663 static int graphkeys_smooth_exec(bContext *C, wmOperator *op)
1664 {
1665         bAnimContext ac;
1666         ListBase anim_data = {NULL, NULL};
1667         bAnimListElem *ale;
1668         int filter;
1669         
1670         /* get editor data */
1671         if (ANIM_animdata_get_context(C, &ac) == 0)
1672                 return OPERATOR_CANCELLED;
1673         
1674         /* filter data */
1675         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1676         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1677         
1678         /* smooth keyframes */
1679         for (ale= anim_data.first; ale; ale= ale->next) {
1680                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
1681                  * Perhaps the mode argument could be removed, as that functionality is offerred through 
1682                  * Snap->Flatten Handles anyway.
1683                  */
1684                 smooth_fcurve(ale->key_data);
1685         }
1686         BLI_freelistN(&anim_data);
1687         
1688         /* validate keyframes after editing */
1689         ANIM_editkeyframes_refresh(&ac);
1690         
1691         /* set notifier that keyframes have changed */
1692         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
1693         
1694         return OPERATOR_FINISHED;
1695 }
1696  
1697 void GRAPH_OT_smooth (wmOperatorType *ot)
1698 {
1699         /* identifiers */
1700         ot->name= "Smooth Keys";
1701         ot->idname= "GRAPH_OT_smooth";
1702         ot->description= "Apply weighted moving means to make selected F-Curves less bumpy.";
1703         
1704         /* api callbacks */
1705         ot->exec= graphkeys_smooth_exec;
1706         ot->poll= graphop_editable_keyframes_poll;
1707         
1708         /* flags */
1709         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1710 }
1711
1712 /* ************************************************************************** */
1713 /* F-CURVE MODIFIERS */
1714
1715 /* ******************** Add F-Modifier Operator *********************** */
1716
1717 /* present a special customised popup menu for this, with some filtering */
1718 static int graph_fmodifier_add_invoke (bContext *C, wmOperator *op, wmEvent *event)
1719 {
1720         uiPopupMenu *pup;
1721         uiLayout *layout;
1722         int i;
1723         
1724         pup= uiPupMenuBegin(C, "Add F-Curve Modifier", 0);
1725         layout= uiPupMenuLayout(pup);
1726         
1727         /* start from 1 to skip the 'Invalid' modifier type */
1728         for (i = 1; i < FMODIFIER_NUM_TYPES; i++) {
1729                 FModifierTypeInfo *fmi= get_fmodifier_typeinfo(i);
1730                 PointerRNA props_ptr;
1731                 
1732                 /* check if modifier is valid for this context */
1733                 if (fmi == NULL)
1734                         continue;
1735                 
1736                 /* create operator menu item with relevant properties filled in */
1737                 props_ptr= uiItemFullO(layout, fmi->name, 0, "GRAPH_OT_fmodifier_add", NULL, WM_OP_EXEC_REGION_WIN, UI_ITEM_O_RETURN_PROPS);
1738                         /* the only thing that gets set from the menu is the type of F-Modifier to add */
1739                 RNA_enum_set(&props_ptr, "type", i);
1740                         /* the following properties are just repeats of existing ones... */
1741                 RNA_boolean_set(&props_ptr, "only_active", RNA_boolean_get(op->ptr, "only_active"));
1742         }
1743         uiItemS(layout);
1744         
1745         uiPupMenuEnd(C, pup);
1746         
1747         return OPERATOR_CANCELLED;
1748 }
1749
1750 static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
1751 {
1752         bAnimContext ac;
1753         ListBase anim_data = {NULL, NULL};
1754         bAnimListElem *ale;
1755         int filter;
1756         short type;
1757         
1758         /* get editor data */
1759         if (ANIM_animdata_get_context(C, &ac) == 0)
1760                 return OPERATOR_CANCELLED;
1761         
1762         /* get type of modifier to add */
1763         type= RNA_enum_get(op->ptr, "type");
1764         
1765         /* filter data */
1766         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1767         if (RNA_boolean_get(op->ptr, "only_active"))
1768                 filter |= ANIMFILTER_ACTIVE;
1769         else
1770                 filter |= ANIMFILTER_SEL;
1771         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1772         
1773         /* smooth keyframes */
1774         for (ale= anim_data.first; ale; ale= ale->next) {
1775                 FCurve *fcu= (FCurve *)ale->data;
1776                 FModifier *fcm;
1777                 
1778                 /* add F-Modifier of specified type to active F-Curve, and make it the active one */
1779                 fcm= add_fmodifier(&fcu->modifiers, type);
1780                 if (fcm)
1781                         set_active_fmodifier(&fcu->modifiers, fcm);
1782                 else { // TODO: stop when this happens?
1783                         BKE_report(op->reports, RPT_ERROR, "Modifier couldn't be added. See console for details.");
1784                         break;
1785                 }
1786         }
1787         BLI_freelistN(&anim_data);
1788         
1789         /* validate keyframes after editing */
1790         ANIM_editkeyframes_refresh(&ac);
1791         
1792         /* set notifier that things have changed */
1793         // FIXME: this really isn't the best description for it...
1794         WM_event_add_notifier(C, NC_ANIMATION, NULL);
1795         
1796         return OPERATOR_FINISHED;
1797 }
1798  
1799 void GRAPH_OT_fmodifier_add (wmOperatorType *ot)
1800 {
1801         /* identifiers */
1802         ot->name= "Add F-Curve Modifier";
1803         ot->idname= "GRAPH_OT_fmodifier_add";
1804         ot->description= "Add F-Modifiers to the selected F-Curves.";
1805         
1806         /* api callbacks */
1807         ot->invoke= graph_fmodifier_add_invoke;
1808         ot->exec= graph_fmodifier_add_exec;
1809         ot->poll= graphop_selected_fcurve_poll; 
1810         
1811         /* flags */
1812         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1813         
1814         /* id-props */
1815         RNA_def_enum(ot->srna, "type", fmodifier_type_items, 0, "Type", "");
1816         RNA_def_boolean(ot->srna, "only_active", 1, "Only Active", "Only add F-Modifier to active F-Curve.");
1817 }
1818
1819 /* ************************************************************************** */