Graph Editor Bugfix: 'HomeKey' (View All) wasn't correctly calculating y-extents
[blender.git] / source / blender / editors / space_graph / graph_edit.c
1 /**
2  * $Id: editaction.c 17746 2008-12-08 11:19:44Z aligorith $
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_object.h"
71 #include "BKE_context.h"
72 #include "BKE_report.h"
73 #include "BKE_utildefines.h"
74
75 #include "UI_view2d.h"
76
77 #include "BIF_transform.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
86 #include "WM_api.h"
87 #include "WM_types.h"
88
89 #include "graph_intern.h"
90
91 /* ************************************************************************** */
92 /* KEYFRAME-RANGE STUFF */
93
94 /* *************************** Calculate Range ************************** */
95
96 /* Get the min/max keyframes*/
97 static void get_graph_keyframe_extents (bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax)
98 {
99         ListBase anim_data = {NULL, NULL};
100         bAnimListElem *ale;
101         int filter;
102         
103         /* get data to filter, from Dopesheet */
104         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
105         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
106         
107         /* set large values to try to override */
108         if (xmin) *xmin= 999999999.0f;
109         if (xmax) *xmax= -999999999.0f;
110         if (ymin) *ymin= 999999999.0f;
111         if (ymax) *ymax= -999999999.0f;
112         
113         /* check if any channels to set range with */
114         if (anim_data.first) {
115                 /* go through channels, finding max extents */
116                 for (ale= anim_data.first; ale; ale= ale->next) {
117                         Object *nob= NULL; //ANIM_nla_mapping_get(ac, ale);
118                         FCurve *fcu= (FCurve *)ale->key_data;
119                         float txmin, txmax, tymin, tymax;
120                         
121                         /* get range and apply necessary scaling before */
122                         calc_fcurve_bounds(fcu, &txmin, &txmax, &tymin, &tymax);
123                         
124                         if (nob) {
125                                 txmin= get_action_frame_inv(nob, txmin);
126                                 txmax= get_action_frame_inv(nob, txmax);
127                         }
128                         
129                         /* try to set cur using these values, if they're more extreme than previously set values */
130                         if ((xmin) && (txmin < *xmin))          *xmin= txmin;
131                         if ((xmax) && (txmax > *xmax))          *xmax= txmax;
132                         if ((ymin) && (tymin < *ymin))          *ymin= tymin;
133                         if ((ymax) && (tymax > *ymax))          *ymax= tymax;
134                 }
135                 
136                 /* free memory */
137                 BLI_freelistN(&anim_data);
138         }
139         else {
140                 /* set default range */
141                 if (ac->scene) {
142                         if (xmin) *xmin= (float)ac->scene->r.sfra;
143                         if (xmax) *xmax= (float)ac->scene->r.efra;
144                 }
145                 else {
146                         if (xmin) *xmin= -5;
147                         if (xmax) *xmax= 100;
148                 }
149                 
150                 if (ymin) *ymin= -5;
151                 if (ymax) *ymax= 5;
152         }
153 }
154
155 /* ****************** Automatic Preview-Range Operator ****************** */
156
157 static int graphkeys_previewrange_exec(bContext *C, wmOperator *op)
158 {
159         bAnimContext ac;
160         Scene *scene;
161         float min, max;
162         
163         /* get editor data */
164         if (ANIM_animdata_get_context(C, &ac) == 0)
165                 return OPERATOR_CANCELLED;
166         if (ac.scene == NULL)
167                 return OPERATOR_CANCELLED;
168         else
169                 scene= ac.scene;
170         
171         /* set the range directly */
172         get_graph_keyframe_extents(&ac, &min, &max, NULL, NULL);
173         scene->r.psfra= (int)floor(min + 0.5f);
174         scene->r.pefra= (int)floor(max + 0.5f);
175         
176         /* set notifier that things have changed */
177         // XXX err... there's nothing for frame ranges yet, but this should do fine too
178         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
179         
180         return OPERATOR_FINISHED;
181 }
182  
183 void GRAPHEDIT_OT_previewrange_set (wmOperatorType *ot)
184 {
185         /* identifiers */
186         ot->name= "Auto-Set Preview Range";
187         ot->idname= "GRAPHEDIT_OT_previewrange_set";
188         
189         /* api callbacks */
190         ot->exec= graphkeys_previewrange_exec;
191         ot->poll= ED_operator_areaactive;
192         
193         /* flags */
194         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
195 }
196
197 /* ****************** View-All Operator ****************** */
198
199 static int graphkeys_viewall_exec(bContext *C, wmOperator *op)
200 {
201         bAnimContext ac;
202         View2D *v2d;
203         float extra;
204         
205         /* get editor data */
206         if (ANIM_animdata_get_context(C, &ac) == 0)
207                 return OPERATOR_CANCELLED;
208         v2d= &ac.ar->v2d;
209         
210         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
211         get_graph_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, &v2d->cur.ymin, &v2d->cur.ymax);
212         
213         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
214         v2d->cur.xmin -= extra;
215         v2d->cur.xmax += extra;
216         
217         extra= 0.1f * (v2d->cur.ymax - v2d->cur.ymin);
218         v2d->cur.ymin -= extra;
219         v2d->cur.ymax += extra;
220         
221         /* do View2D syncing */
222         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
223         
224         /* set notifier that things have changed */
225         ED_area_tag_redraw(CTX_wm_area(C));
226         
227         return OPERATOR_FINISHED;
228 }
229  
230 void GRAPHEDIT_OT_view_all (wmOperatorType *ot)
231 {
232         /* identifiers */
233         ot->name= "View All";
234         ot->idname= "GRAPHEDIT_OT_view_all";
235         
236         /* api callbacks */
237         ot->exec= graphkeys_viewall_exec;
238         ot->poll= ED_operator_areaactive;
239         
240         /* flags */
241         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
242 }
243
244 /* ******************** Create Ghost-Curves Operator *********************** */
245 /* This operator samples the data of the selected F-Curves to F-Points, storing them
246  * as 'ghost curves' in the active Graph Editor
247  */
248
249 /* Bake each F-Curve into a set of samples, and store as a ghost curve */
250 static void create_ghost_curves (bAnimContext *ac, int start, int end)
251 {       
252         SpaceIpo *sipo= (SpaceIpo *)ac->sa->spacedata.first;
253         ListBase anim_data = {NULL, NULL};
254         bAnimListElem *ale;
255         int filter;
256         
257         /* free existing ghost curves */
258         free_fcurves(&sipo->ghostCurves);
259         
260         /* sanity check */
261         if (start >= end) {
262                 printf("Error: Frame range for Ghost F-Curve creation is inappropriate \n");
263                 return;
264         }
265         
266         /* filter data */
267         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
268         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
269         
270         /* loop through filtered data and add keys between selected keyframes on every frame  */
271         for (ale= anim_data.first; ale; ale= ale->next) {
272                 FCurve *fcu= (FCurve *)ale->key_data;
273                 FCurve *gcu= MEM_callocN(sizeof(FCurve), "Ghost FCurve");
274                 ChannelDriver *driver= fcu->driver;
275                 FPoint *fpt;
276                 int cfra;               
277                 
278                 /* disable driver so that it don't muck up the sampling process */
279                 fcu->driver= NULL;
280                 
281                 /* create samples, but store them in a new curve 
282                  *      - we cannot use fcurve_store_samples() as that will only overwrite the original curve 
283                  */
284                 gcu->fpt= fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "Ghost FPoint Samples");
285                 gcu->totvert= end - start + 1;
286                 
287                 /* use the sampling callback at 1-frame intervals from start to end frames */
288                 for (cfra= start; cfra <= end; cfra++, fpt++) {
289                         fpt->vec[0]= (float)cfra;
290                         fpt->vec[1]= fcurve_samplingcb_evalcurve(fcu, NULL, (float)cfra);
291                 }
292                 
293                 /* set color of ghost curve 
294                  *      - make the color slightly darker
295                  */
296                 gcu->color[0]= fcu->color[0] - 0.07f;
297                 gcu->color[1]= fcu->color[1] - 0.07f;
298                 gcu->color[2]= fcu->color[2] - 0.07f;
299                 
300                 /* store new ghost curve */
301                 BLI_addtail(&sipo->ghostCurves, gcu);
302                 
303                 /* restore driver */
304                 fcu->driver= driver;
305         }
306         
307         /* admin and redraws */
308         BLI_freelistN(&anim_data);
309 }
310
311 /* ------------------- */
312
313 static int graphkeys_create_ghostcurves_exec(bContext *C, wmOperator *op)
314 {
315         bAnimContext ac;
316         View2D *v2d;
317         int start, end;
318         
319         /* get editor data */
320         if (ANIM_animdata_get_context(C, &ac) == 0)
321                 return OPERATOR_CANCELLED;
322                 
323         /* ghost curves are snapshots of the visible portions of the curves, so set range to be the visible range */
324         v2d= &ac.ar->v2d;
325         start= (int)v2d->cur.xmin;
326         end= (int)v2d->cur.xmax;
327         
328         /* bake selected curves into a ghost curve */
329         create_ghost_curves(&ac, start, end);
330         
331         /* update this editor only */
332         ED_area_tag_redraw(CTX_wm_area(C));
333         
334         return OPERATOR_FINISHED;
335 }
336  
337 void GRAPHEDIT_OT_ghost_curves_create (wmOperatorType *ot)
338 {
339         /* identifiers */
340         ot->name= "Create Ghost Curves";
341         ot->idname= "GRAPHEDIT_OT_ghost_curves_create";
342         ot->description= "Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor.";
343         
344         /* api callbacks */
345         ot->exec= graphkeys_create_ghostcurves_exec;
346         ot->poll= ED_operator_areaactive;
347         
348         /* flags */
349         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
350         
351         // todo: add props for start/end frames
352 }
353
354 /* ******************** Clear Ghost-Curves Operator *********************** */
355 /* This operator clears the 'ghost curves' for the active Graph Editor */
356
357 static int graphkeys_clear_ghostcurves_exec(bContext *C, wmOperator *op)
358 {
359         bAnimContext ac;
360         SpaceIpo *sipo;
361         
362         /* get editor data */
363         if (ANIM_animdata_get_context(C, &ac) == 0)
364                 return OPERATOR_CANCELLED;
365         sipo= (SpaceIpo *)ac.sa->spacedata.first;
366                 
367         /* if no ghost curves, don't do anything */
368         if (sipo->ghostCurves.first == NULL)
369                 return OPERATOR_CANCELLED;
370         
371         /* free ghost curves */
372         free_fcurves(&sipo->ghostCurves);
373         
374         /* update this editor only */
375         ED_area_tag_redraw(CTX_wm_area(C));
376         
377         return OPERATOR_FINISHED;
378 }
379  
380 void GRAPHEDIT_OT_ghost_curves_clear (wmOperatorType *ot)
381 {
382         /* identifiers */
383         ot->name= "Create Ghost Curves";
384         ot->idname= "GRAPHEDIT_OT_ghost_curves_clear";
385         ot->description= "Clear F-Curve snapshots (Ghosts) for active Graph Editor.";
386         
387         /* api callbacks */
388         ot->exec= graphkeys_clear_ghostcurves_exec;
389         ot->poll= ED_operator_areaactive;
390         
391         /* flags */
392         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
393 }
394
395 /* ************************************************************************** */
396 /* GENERAL STUFF */
397
398 // TODO: insertkey
399
400 /* ******************** Click-Insert Keyframes Operator ************************* */
401
402 static int graphkeys_click_insert_exec (bContext *C, wmOperator *op)
403 {
404         bAnimContext ac;
405         bAnimListElem *ale;
406         float frame, val;
407         
408         /* get animation context */
409         if (ANIM_animdata_get_context(C, &ac) == 0)
410                 return OPERATOR_CANCELLED;
411         
412         /* get active F-Curve 'anim-list-element' */
413         ale= get_active_fcurve_channel(&ac);
414         if (ELEM(NULL, ale, ale->data)) {
415                 if (ale) MEM_freeN(ale);
416                 return OPERATOR_CANCELLED;
417         }
418                 
419         /* get frame and value from props */
420         frame= RNA_float_get(op->ptr, "frame");
421         val= RNA_float_get(op->ptr, "value");
422         
423         /* insert keyframe on the specified frame + value */
424         insert_vert_fcurve((FCurve *)ale->data, frame, val, 0);
425         
426         /* free temp data */
427         MEM_freeN(ale);
428         
429         /* set notifier that things have changed */
430         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
431         
432         /* done */
433         return OPERATOR_FINISHED;
434 }
435
436 static int graphkeys_click_insert_invoke (bContext *C, wmOperator *op, wmEvent *evt)
437 {
438         bAnimContext ac;
439         ARegion *ar;
440         View2D *v2d;
441         int mval[2];
442         float x, y;
443         
444         /* get animation context */
445         if (ANIM_animdata_get_context(C, &ac) == 0)
446                 return OPERATOR_CANCELLED;
447         
448         /* store mouse coordinates in View2D space, into the operator's properties */
449         ar= ac.ar;
450         v2d= &ar->v2d;
451         
452         mval[0]= (evt->x - ar->winrct.xmin);
453         mval[1]= (evt->y - ar->winrct.ymin);
454         
455         UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y);
456         
457         RNA_float_set(op->ptr, "frame", x);
458         RNA_float_set(op->ptr, "value", y);
459         
460         /* run exec now */
461         return graphkeys_click_insert_exec(C, op);
462 }
463
464 void GRAPHEDIT_OT_keyframes_click_insert (wmOperatorType *ot)
465 {
466         /* identifiers */
467         ot->name= "Click-Insert Keyframes";
468         ot->idname= "GRAPHEDIT_OT_keyframes_click_insert";
469         
470         /* api callbacks */
471         ot->invoke= graphkeys_click_insert_invoke;
472         ot->exec= graphkeys_click_insert_exec;
473         ot->poll= ED_operator_areaactive; // XXX active + editable poll
474         
475         /* flags */
476         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
477         
478         /* properties */
479         RNA_def_float(ot->srna, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame Number", "Frame to insert keyframe on", 0, 100);
480         RNA_def_float(ot->srna, "value", 1.0f, -FLT_MAX, FLT_MAX, "Value", "Value for keyframe on", 0, 100);
481 }
482
483 /* ******************** Copy/Paste Keyframes Operator ************************* */
484 /* NOTE: the backend code for this is shared with the dopesheet editor */
485
486 static short copy_graph_keys (bAnimContext *ac)
487 {       
488         ListBase anim_data = {NULL, NULL};
489         int filter, ok=0;
490         
491         /* clear buffer first */
492         free_anim_copybuf();
493         
494         /* filter data */
495         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
496         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
497         
498         /* copy keyframes */
499         ok= copy_animedit_keys(ac, &anim_data);
500         
501         /* clean up */
502         BLI_freelistN(&anim_data);
503
504         return ok;
505 }
506
507 static short paste_graph_keys (bAnimContext *ac)
508 {       
509         ListBase anim_data = {NULL, NULL};
510         int filter, ok=0;
511         
512         /* filter data */
513         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
514         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
515         
516         /* paste keyframes */
517         ok= paste_animedit_keys(ac, &anim_data);
518         
519         /* clean up */
520         BLI_freelistN(&anim_data);
521
522         return ok;
523 }
524
525 /* ------------------- */
526
527 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
528 {
529         bAnimContext ac;
530         
531         /* get editor data */
532         if (ANIM_animdata_get_context(C, &ac) == 0)
533                 return OPERATOR_CANCELLED;
534         
535         /* copy keyframes */
536         if (copy_graph_keys(&ac)) {     
537                 BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
538                 return OPERATOR_CANCELLED;
539         }
540         
541         /* set notifier that things have changed */
542         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
543         
544         return OPERATOR_FINISHED;
545 }
546  
547 void GRAPHEDIT_OT_keyframes_copy (wmOperatorType *ot)
548 {
549         /* identifiers */
550         ot->name= "Copy Keyframes";
551         ot->idname= "GRAPHEDIT_OT_keyframes_copy";
552         
553         /* api callbacks */
554         ot->exec= graphkeys_copy_exec;
555         ot->poll= ED_operator_areaactive;
556         
557         /* flags */
558         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
559 }
560
561
562
563 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
564 {
565         bAnimContext ac;
566         
567         /* get editor data */
568         if (ANIM_animdata_get_context(C, &ac) == 0)
569                 return OPERATOR_CANCELLED;
570         
571         /* paste keyframes */
572         if (paste_graph_keys(&ac)) {
573                 BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
574                 return OPERATOR_CANCELLED;
575         }
576         
577         /* validate keyframes after editing */
578         ANIM_editkeyframes_refresh(&ac);
579         
580         /* set notifier that things have changed */
581         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
582         
583         return OPERATOR_FINISHED;
584 }
585  
586 void GRAPHEDIT_OT_keyframes_paste (wmOperatorType *ot)
587 {
588         /* identifiers */
589         ot->name= "Paste Keyframes";
590         ot->idname= "GRAPHEDIT_OT_keyframes_paste";
591         
592         /* api callbacks */
593         ot->exec= graphkeys_paste_exec;
594         ot->poll= ED_operator_areaactive;
595         
596         /* flags */
597         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
598 }
599
600 /* ******************** Duplicate Keyframes Operator ************************* */
601
602 static void duplicate_graph_keys (bAnimContext *ac)
603 {
604         ListBase anim_data = {NULL, NULL};
605         bAnimListElem *ale;
606         int filter;
607         
608         /* filter data */
609         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
610         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
611         
612         /* loop through filtered data and delete selected keys */
613         for (ale= anim_data.first; ale; ale= ale->next) {
614                 duplicate_fcurve_keys((FCurve *)ale->key_data);
615         }
616         
617         /* free filtered list */
618         BLI_freelistN(&anim_data);
619 }
620
621 /* ------------------- */
622
623 static int graphkeys_duplicate_exec(bContext *C, wmOperator *op)
624 {
625         bAnimContext ac;
626         
627         /* get editor data */
628         if (ANIM_animdata_get_context(C, &ac) == 0)
629                 return OPERATOR_CANCELLED;
630                 
631         /* duplicate keyframes */
632         duplicate_graph_keys(&ac);
633         
634         /* validate keyframes after editing */
635         ANIM_editkeyframes_refresh(&ac);
636         
637         /* set notifier that things have changed */
638         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
639         
640         return OPERATOR_FINISHED;
641 }
642
643 static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
644 {
645         graphkeys_duplicate_exec(C, op);
646         
647         RNA_int_set(op->ptr, "mode", TFM_TRANSLATION);
648         WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
649
650         return OPERATOR_FINISHED;
651 }
652  
653 void GRAPHEDIT_OT_keyframes_duplicate (wmOperatorType *ot)
654 {
655         /* identifiers */
656         ot->name= "Duplicate Keyframes";
657         ot->idname= "GRAPHEDIT_OT_keyframes_duplicate";
658         
659         /* api callbacks */
660         ot->invoke= graphkeys_duplicate_invoke;
661         ot->exec= graphkeys_duplicate_exec;
662         ot->poll= ED_operator_areaactive;
663         
664         /* flags */
665         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
666         
667         /* to give to transform */
668         RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
669 }
670
671 /* ******************** Delete Keyframes Operator ************************* */
672
673 static void delete_graph_keys (bAnimContext *ac)
674 {
675         ListBase anim_data = {NULL, NULL};
676         bAnimListElem *ale;
677         int filter;
678         
679         /* filter data */
680         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
681         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
682         
683         /* loop through filtered data and delete selected keys */
684         for (ale= anim_data.first; ale; ale= ale->next) {
685                 delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
686         }
687         
688         /* free filtered list */
689         BLI_freelistN(&anim_data);
690 }
691
692 /* ------------------- */
693
694 static int graphkeys_delete_exec(bContext *C, wmOperator *op)
695 {
696         bAnimContext ac;
697         
698         /* get editor data */
699         if (ANIM_animdata_get_context(C, &ac) == 0)
700                 return OPERATOR_CANCELLED;
701                 
702         /* delete keyframes */
703         delete_graph_keys(&ac);
704         
705         /* validate keyframes after editing */
706         ANIM_editkeyframes_refresh(&ac);
707         
708         /* set notifier that things have changed */
709         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
710         
711         return OPERATOR_FINISHED;
712 }
713  
714 void GRAPHEDIT_OT_keyframes_delete (wmOperatorType *ot)
715 {
716         /* identifiers */
717         ot->name= "Delete Keyframes";
718         ot->idname= "GRAPHEDIT_OT_keyframes_delete";
719         
720         /* api callbacks */
721         ot->invoke= WM_operator_confirm;
722         ot->exec= graphkeys_delete_exec;
723         ot->poll= ED_operator_areaactive;
724         
725         /* flags */
726         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
727 }
728
729 /* ******************** Clean Keyframes Operator ************************* */
730
731 static void clean_graph_keys (bAnimContext *ac, float thresh)
732 {       
733         ListBase anim_data = {NULL, NULL};
734         bAnimListElem *ale;
735         int filter;
736         
737         /* filter data */
738         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
739         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
740         
741         /* loop through filtered data and clean curves */
742         for (ale= anim_data.first; ale; ale= ale->next)
743                 clean_fcurve((FCurve *)ale->key_data, thresh);
744         
745         /* free temp data */
746         BLI_freelistN(&anim_data);
747 }
748
749 /* ------------------- */
750
751 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
752 {
753         bAnimContext ac;
754         float thresh;
755         
756         /* get editor data */
757         if (ANIM_animdata_get_context(C, &ac) == 0)
758                 return OPERATOR_CANCELLED;
759                 
760         /* get cleaning threshold */
761         thresh= RNA_float_get(op->ptr, "threshold");
762         
763         /* clean keyframes */
764         clean_graph_keys(&ac, thresh);
765         
766         /* validate keyframes after editing */
767         ANIM_editkeyframes_refresh(&ac);
768         
769         /* set notifier that things have changed */
770         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
771         
772         return OPERATOR_FINISHED;
773 }
774  
775 void GRAPHEDIT_OT_keyframes_clean (wmOperatorType *ot)
776 {
777         /* identifiers */
778         ot->name= "Clean Keyframes";
779         ot->idname= "GRAPHEDIT_OT_keyframes_clean";
780         
781         /* api callbacks */
782         //ot->invoke=  // XXX we need that number popup for this! 
783         ot->exec= graphkeys_clean_exec;
784         ot->poll= ED_operator_areaactive;
785         
786         /* flags */
787         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
788         
789         /* properties */
790         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
791 }
792
793 /* ******************** Bake F-Curve Operator *********************** */
794 /* This operator bakes the data of the selected F-Curves to F-Points */
795
796 /* Bake each F-Curve into a set of samples */
797 static void bake_graph_curves (bAnimContext *ac, int start, int end)
798 {       
799         ListBase anim_data = {NULL, NULL};
800         bAnimListElem *ale;
801         int filter;
802         
803         /* filter data */
804         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
805         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
806         
807         /* loop through filtered data and add keys between selected keyframes on every frame  */
808         for (ale= anim_data.first; ale; ale= ale->next) {
809                 FCurve *fcu= (FCurve *)ale->key_data;
810                 ChannelDriver *driver= fcu->driver;
811                 
812                 /* disable driver so that it don't muck up the sampling process */
813                 fcu->driver= NULL;
814                 
815                 /* create samples */
816                 fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
817                 
818                 /* restore driver */
819                 fcu->driver= driver;
820         }
821         
822         /* admin and redraws */
823         BLI_freelistN(&anim_data);
824 }
825
826 /* ------------------- */
827
828 static int graphkeys_bake_exec(bContext *C, wmOperator *op)
829 {
830         bAnimContext ac;
831         Scene *scene= NULL;
832         int start, end;
833         
834         /* get editor data */
835         if (ANIM_animdata_get_context(C, &ac) == 0)
836                 return OPERATOR_CANCELLED;
837                 
838         /* for now, init start/end from preview-range extents */
839         // TODO: add properties for this 
840         scene= ac.scene;
841         start= PSFRA;
842         end= PEFRA;
843         
844         /* bake keyframes */
845         bake_graph_curves(&ac, start, end);
846         
847         /* validate keyframes after editing */
848         ANIM_editkeyframes_refresh(&ac);
849         
850         /* set notifier that things have changed */
851         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
852         
853         return OPERATOR_FINISHED;
854 }
855  
856 void GRAPHEDIT_OT_keyframes_bake (wmOperatorType *ot)
857 {
858         /* identifiers */
859         ot->name= "Bake Curve";
860         ot->idname= "GRAPHEDIT_OT_keyframes_bake";
861         
862         /* api callbacks */
863         ot->invoke= WM_operator_confirm; // FIXME...
864         ot->exec= graphkeys_bake_exec;
865         ot->poll= ED_operator_areaactive;
866         
867         /* flags */
868         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
869         
870         // todo: add props for start/end frames
871 }
872
873 /* ******************** Sample Keyframes Operator *********************** */
874 /* This operator 'bakes' the values of the curve into new keyframes between pairs
875  * of selected keyframes. It is useful for creating keyframes for tweaking overlap.
876  */
877
878 // XXX some of the common parts (with DopeSheet) should be unified in animation module...
879
880 /* little cache for values... */
881 typedef struct tempFrameValCache {
882         float frame, val;
883 } tempFrameValCache;
884
885 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
886 static void sample_graph_keys (bAnimContext *ac)
887 {       
888         ListBase anim_data = {NULL, NULL};
889         bAnimListElem *ale;
890         int filter;
891         
892         /* filter data */
893         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
894         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
895         
896         /* loop through filtered data and add keys between selected keyframes on every frame  */
897         for (ale= anim_data.first; ale; ale= ale->next) {
898                 FCurve *fcu= (FCurve *)ale->key_data;
899                 BezTriple *bezt, *start=NULL, *end=NULL;
900                 tempFrameValCache *value_cache, *fp;
901                 int sfra, range;
902                 int i, n;
903                 
904                 /* find selected keyframes... once pair has been found, add keyframes  */
905                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
906                         /* check if selected, and which end this is */
907                         if (BEZSELECTED(bezt)) {
908                                 if (start) {
909                                         /* set end */
910                                         end= bezt;
911                                         
912                                         /* cache values then add keyframes using these values, as adding
913                                          * keyframes while sampling will affect the outcome...
914                                          */
915                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
916                                         sfra= (int)( floor(start->vec[1][0]) );
917                                         
918                                         if (range) {
919                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
920                                                 
921                                                 /*      sample values   */
922                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
923                                                         fp->frame= (float)(sfra + n);
924                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
925                                                 }
926                                                 
927                                                 /*      add keyframes with these        */
928                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
929                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
930                                                 }
931                                                 
932                                                 /* free temp cache */
933                                                 MEM_freeN(value_cache);
934                                                 
935                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
936                                                 bezt = fcu->bezt + i + range - 1;
937                                                 i += (range - 1);
938                                         }
939                                         
940                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
941                                         start= bezt;
942                                         end= NULL;
943                                 }
944                                 else {
945                                         /* just set start keyframe */
946                                         start= bezt;
947                                         end= NULL;
948                                 }
949                         }
950                 }
951                 
952                 /* recalculate channel's handles? */
953                 calchandles_fcurve(fcu);
954         }
955         
956         /* admin and redraws */
957         BLI_freelistN(&anim_data);
958 }
959
960 /* ------------------- */
961
962 static int graphkeys_sample_exec(bContext *C, wmOperator *op)
963 {
964         bAnimContext ac;
965         
966         /* get editor data */
967         if (ANIM_animdata_get_context(C, &ac) == 0)
968                 return OPERATOR_CANCELLED;
969         
970         /* sample keyframes */
971         sample_graph_keys(&ac);
972         
973         /* validate keyframes after editing */
974         ANIM_editkeyframes_refresh(&ac);
975         
976         /* set notifier that things have changed */
977         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
978         
979         return OPERATOR_FINISHED;
980 }
981  
982 void GRAPHEDIT_OT_keyframes_sample (wmOperatorType *ot)
983 {
984         /* identifiers */
985         ot->name= "Sample Keyframes";
986         ot->idname= "GRAPHEDIT_OT_keyframes_sample";
987         
988         /* api callbacks */
989         ot->exec= graphkeys_sample_exec;
990         ot->poll= ED_operator_areaactive;
991         
992         /* flags */
993         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
994 }
995
996
997 /* ************************************************************************** */
998 /* SETTINGS STUFF */
999
1000 /* ******************** Set Extrapolation-Type Operator *********************** */
1001
1002 /* defines for set extrapolation-type for selected keyframes tool */
1003 EnumPropertyItem prop_graphkeys_expo_types[] = {
1004         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
1005         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
1006         {0, NULL, NULL, NULL}
1007 };
1008
1009 /* this function is responsible for setting extrapolation mode for keyframes */
1010 static void setexpo_graph_keys(bAnimContext *ac, short mode) 
1011 {
1012         ListBase anim_data = {NULL, NULL};
1013         bAnimListElem *ale;
1014         int filter;
1015         
1016         /* filter data */
1017         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1018         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1019         
1020         /* loop through setting mode per F-Curve */
1021         for (ale= anim_data.first; ale; ale= ale->next) {
1022                 FCurve *fcu= (FCurve *)ale->data;
1023                 fcu->extend= mode;
1024         }
1025         
1026         /* cleanup */
1027         BLI_freelistN(&anim_data);
1028 }
1029
1030 /* ------------------- */
1031
1032 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
1033 {
1034         bAnimContext ac;
1035         short mode;
1036         
1037         /* get editor data */
1038         if (ANIM_animdata_get_context(C, &ac) == 0)
1039                 return OPERATOR_CANCELLED;
1040                 
1041         /* get handle setting mode */
1042         mode= RNA_enum_get(op->ptr, "type");
1043         
1044         /* set handle type */
1045         setexpo_graph_keys(&ac, mode);
1046         
1047         /* validate keyframes after editing */
1048         ANIM_editkeyframes_refresh(&ac);
1049         
1050         /* set notifier that things have changed */
1051         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1052         
1053         return OPERATOR_FINISHED;
1054 }
1055  
1056 void GRAPHEDIT_OT_keyframes_extrapolation_type (wmOperatorType *ot)
1057 {
1058         /* identifiers */
1059         ot->name= "Set Keyframe Extrapolation";
1060         ot->idname= "GRAPHEDIT_OT_keyframes_extrapolation_type";
1061         
1062         /* api callbacks */
1063         ot->invoke= WM_menu_invoke;
1064         ot->exec= graphkeys_expo_exec;
1065         ot->poll= ED_operator_areaactive;
1066         
1067         /* flags */
1068         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1069         
1070         /* id-props */
1071         RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
1072 }
1073
1074 /* ******************** Set Interpolation-Type Operator *********************** */
1075
1076 /* this function is responsible for setting interpolation mode for keyframes */
1077 static void setipo_graph_keys(bAnimContext *ac, short mode) 
1078 {
1079         ListBase anim_data = {NULL, NULL};
1080         bAnimListElem *ale;
1081         int filter;
1082         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
1083         
1084         /* filter data */
1085         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1086         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1087         
1088         /* loop through setting BezTriple interpolation
1089          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1090          */
1091         for (ale= anim_data.first; ale; ale= ale->next)
1092                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1093         
1094         /* cleanup */
1095         BLI_freelistN(&anim_data);
1096 }
1097
1098 /* ------------------- */
1099
1100 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
1101 {
1102         bAnimContext ac;
1103         short mode;
1104         
1105         /* get editor data */
1106         if (ANIM_animdata_get_context(C, &ac) == 0)
1107                 return OPERATOR_CANCELLED;
1108                 
1109         /* get handle setting mode */
1110         mode= RNA_enum_get(op->ptr, "type");
1111         
1112         /* set handle type */
1113         setipo_graph_keys(&ac, mode);
1114         
1115         /* validate keyframes after editing */
1116         ANIM_editkeyframes_refresh(&ac);
1117         
1118         /* set notifier that things have changed */
1119         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1120         
1121         return OPERATOR_FINISHED;
1122 }
1123  
1124 void GRAPHEDIT_OT_keyframes_interpolation_type (wmOperatorType *ot)
1125 {
1126         /* identifiers */
1127         ot->name= "Set Keyframe Interpolation";
1128         ot->idname= "GRAPHEDIT_OT_keyframes_interpolation_type";
1129         
1130         /* api callbacks */
1131         ot->invoke= WM_menu_invoke;
1132         ot->exec= graphkeys_ipo_exec;
1133         ot->poll= ED_operator_areaactive;
1134         
1135         /* flags */
1136         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1137         
1138         /* id-props */
1139         RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
1140 }
1141
1142 /* ******************** Set Handle-Type Operator *********************** */
1143
1144 /* this function is responsible for setting handle-type of selected keyframes */
1145 static void sethandles_graph_keys(bAnimContext *ac, short mode) 
1146 {
1147         ListBase anim_data = {NULL, NULL};
1148         bAnimListElem *ale;
1149         int filter;
1150         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
1151         
1152         /* filter data */
1153         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1154         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1155         
1156         /* loop through setting flags for handles 
1157          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1158          */
1159         // XXX we might need to supply BeztEditData to get it to only affect selected handles
1160         for (ale= anim_data.first; ale; ale= ale->next) {
1161                 if (mode == -1) {       
1162                         BeztEditFunc toggle_cb;
1163                         
1164                         /* check which type of handle to set (free or aligned) 
1165                          *      - check here checks for handles with free alignment already
1166                          */
1167                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
1168                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
1169                         else
1170                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
1171                                 
1172                         /* set handle-type */
1173                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
1174                 }
1175                 else {
1176                         /* directly set handle-type */
1177                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1178                 }
1179         }
1180         
1181         /* cleanup */
1182         BLI_freelistN(&anim_data);
1183 }
1184
1185 /* ------------------- */
1186
1187 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
1188 {
1189         bAnimContext ac;
1190         short mode;
1191         
1192         /* get editor data */
1193         if (ANIM_animdata_get_context(C, &ac) == 0)
1194                 return OPERATOR_CANCELLED;
1195                 
1196         /* get handle setting mode */
1197         mode= RNA_enum_get(op->ptr, "type");
1198         
1199         /* set handle type */
1200         sethandles_graph_keys(&ac, mode);
1201         
1202         /* validate keyframes after editing */
1203         ANIM_editkeyframes_refresh(&ac);
1204         
1205         /* set notifier that things have changed */
1206         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1207         
1208         return OPERATOR_FINISHED;
1209 }
1210  
1211 void GRAPHEDIT_OT_keyframes_handletype (wmOperatorType *ot)
1212 {
1213         /* identifiers */
1214         ot->name= "Set Keyframe Handle Type";
1215         ot->idname= "GRAPHEDIT_OT_keyframes_handletype";
1216         
1217         /* api callbacks */
1218         ot->invoke= WM_menu_invoke;
1219         ot->exec= graphkeys_handletype_exec;
1220         ot->poll= ED_operator_areaactive;
1221         
1222         /* flags */
1223         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1224         
1225         /* id-props */
1226         RNA_def_enum(ot->srna, "type", beztriple_handle_type_items, 0, "Type", "");
1227 }
1228
1229 /* ************************************************************************** */
1230 /* TRANSFORM STUFF */
1231
1232 /* ***************** 'Euler Filter' Operator **************************** */
1233 /* Euler filter tools (as seen in Maya), are necessary for working with 'baked'
1234  * rotation curves (with Euler rotations). The main purpose of such tools is to
1235  * resolve any discontinuities that may arise in the curves due to the clamping
1236  * of values to -180 degrees to 180 degrees.
1237  */
1238
1239 #if 0 // XXX this is not ready for the primetime yet
1240  
1241 /* set of three euler-rotation F-Curves */
1242 typedef struct tEulerFilter {
1243         ID *id;                                                 /* ID-block which owns the channels */
1244         FCurve *fcu1, *fcu2, *fcu3;             /* x,y,z rotation curves */
1245         int i1, i2, i3;                                 /* current index for each curve */
1246 } tEulerFilter;
1247  
1248 static int graphkeys_euler_filter_exec (bContext *C, wmOperator *op)
1249 {
1250         bAnimContext ac;
1251         
1252         ListBase anim_data= {NULL, NULL};
1253         bAnimListElem *ale;
1254         int filter;
1255         
1256         ListBase eulers = {NULL, NULL};
1257         tEulerFilter *euf= NULL;        
1258         
1259         /* get editor data */
1260         if (ANIM_animdata_get_context(C, &ac) == 0)
1261                 return OPERATOR_CANCELLED;
1262                 
1263         /* The process is done in two passes:
1264          *       1) Sets of three related rotation curves are identified from the selected channels,
1265          *              and are stored as a single 'operation unit' for the next step
1266          *       2) Each set of three F-Curves is processed for each keyframe, with the values being
1267          *              processed according to one of several ways.
1268          */
1269          
1270         /* step 1: extract only the rotation f-curves */
1271         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
1272         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1273         
1274         for (ale= anim_data.first; ale; ale= ale->next) {
1275                 FCurve *fcu = (FCurve *)ale->data;
1276                 
1277                 /* check if this is an appropriate F-Curve 
1278                  *      - only rotation curves
1279                  *      - for pchan curves, make sure we're only using the euler curves
1280                  */
1281                 if (ELEM(0, fcu->rna_path, strstr(fcu->rna_path, "rotation")))
1282                         continue;
1283                 if (strstr(fcu->rna_path, "pose.pose_channels")) {
1284                         if (strstr(fcu->rna_path, "euler_rotation") == 0)
1285                                 continue;
1286                 }
1287                 
1288                 /* check if current set of 3-curves is suitable to add this curve to 
1289                  *      - things like whether the current set of curves is 'full' should be checked later only
1290                  *      - first check if id-blocks are compatible
1291                  */
1292                 if ((euf) && (ale->id != euf->id)) {
1293                         
1294                 }
1295         }
1296         
1297         // XXX for now
1298         return OPERATOR_CANCELLED;
1299 }
1300  
1301 void GRAPHEDIT_OT_keyframes_euler_filter (wmOperatorType *ot)
1302 {
1303         /* identifiers */
1304         ot->name= "Euler Filter";
1305         ot->idname= "GRAPHEDIT_OT_keyframes_euler_filter";
1306         
1307         /* api callbacks */
1308         ot->exec= graphkeys_euler_filter_exec;
1309         ot->poll= ED_operator_areaactive;
1310         
1311         /* flags */
1312         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1313 }
1314
1315 #endif // XXX this is not ready for the primetime yet
1316
1317 /* ***************** Snap Current Frame Operator *********************** */
1318
1319 /* snap current-frame indicator to 'average time' of selected keyframe */
1320 static int graphkeys_cfrasnap_exec(bContext *C, wmOperator *op)
1321 {
1322         bAnimContext ac;
1323         ListBase anim_data= {NULL, NULL};
1324         bAnimListElem *ale;
1325         int filter;
1326         BeztEditData bed;
1327         
1328         /* get editor data */
1329         if (ANIM_animdata_get_context(C, &ac) == 0)
1330                 return OPERATOR_CANCELLED;
1331         
1332         /* init edit data */
1333         memset(&bed, 0, sizeof(BeztEditData));
1334         
1335         /* loop over action data, averaging values */
1336         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_CURVESONLY);
1337         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1338         
1339         for (ale= anim_data.first; ale; ale= ale->next)
1340                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1341         
1342         BLI_freelistN(&anim_data);
1343         
1344         /* set the new current frame value, based on the average time */
1345         if (bed.i1) {
1346                 Scene *scene= ac.scene;
1347                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1348         }
1349         
1350         /* set notifier that things have changed */
1351         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1352         
1353         return OPERATOR_FINISHED;
1354 }
1355
1356 void GRAPHEDIT_OT_keyframes_cfrasnap (wmOperatorType *ot)
1357 {
1358         /* identifiers */
1359         ot->name= "Snap Current Frame to Keys";
1360         ot->idname= "GRAPHEDIT_OT_keyframes_cfrasnap";
1361         
1362         /* api callbacks */
1363         ot->exec= graphkeys_cfrasnap_exec;
1364         ot->poll= ED_operator_areaactive;
1365         
1366         /* flags */
1367         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1368 }
1369
1370 /* ******************** Snap Keyframes Operator *********************** */
1371
1372 /* defines for snap keyframes tool */
1373 EnumPropertyItem prop_graphkeys_snap_types[] = {
1374         {GRAPHKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1375         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1376         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1377         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1378         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", "Flatten Handles", ""},
1379         {0, NULL, NULL, NULL}
1380 };
1381
1382 /* this function is responsible for snapping keyframes to frame-times */
1383 static void snap_graph_keys(bAnimContext *ac, short mode) 
1384 {
1385         ListBase anim_data = {NULL, NULL};
1386         bAnimListElem *ale;
1387         int filter;
1388         
1389         BeztEditData bed;
1390         BeztEditFunc edit_cb;
1391         
1392         /* filter data */
1393         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1394         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1395         
1396         /* get beztriple editing callbacks */
1397         edit_cb= ANIM_editkeyframes_snap(mode);
1398         
1399         memset(&bed, 0, sizeof(BeztEditData)); 
1400         bed.scene= ac->scene;
1401         if (mode == GRAPHKEYS_SNAP_NEAREST_MARKER) {
1402                 bed.list.first= (ac->markers) ? ac->markers->first : NULL;
1403                 bed.list.last= (ac->markers) ? ac->markers->last : NULL;
1404         }
1405         
1406         /* snap keyframes */
1407         for (ale= anim_data.first; ale; ale= ale->next) {
1408                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1409                 
1410                 if (nob) {
1411                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1412                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1413                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1414                 }
1415                 else 
1416                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1417         }
1418         BLI_freelistN(&anim_data);
1419 }
1420
1421 /* ------------------- */
1422
1423 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
1424 {
1425         bAnimContext ac;
1426         short mode;
1427         
1428         /* get editor data */
1429         if (ANIM_animdata_get_context(C, &ac) == 0)
1430                 return OPERATOR_CANCELLED;
1431                 
1432         /* get snapping mode */
1433         mode= RNA_enum_get(op->ptr, "type");
1434         
1435         /* snap keyframes */
1436         snap_graph_keys(&ac, mode);
1437         
1438         /* validate keyframes after editing */
1439         ANIM_editkeyframes_refresh(&ac);
1440         
1441         /* set notifier that things have changed */
1442         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1443         
1444         return OPERATOR_FINISHED;
1445 }
1446  
1447 void GRAPHEDIT_OT_keyframes_snap (wmOperatorType *ot)
1448 {
1449         /* identifiers */
1450         ot->name= "Snap Keys";
1451         ot->idname= "GRAPHEDIT_OT_keyframes_snap";
1452         
1453         /* api callbacks */
1454         ot->invoke= WM_menu_invoke;
1455         ot->exec= graphkeys_snap_exec;
1456         ot->poll= ED_operator_areaactive;
1457         
1458         /* flags */
1459         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1460         
1461         /* id-props */
1462         RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
1463 }
1464
1465 /* ******************** Mirror Keyframes Operator *********************** */
1466
1467 /* defines for mirror keyframes tool */
1468 EnumPropertyItem prop_graphkeys_mirror_types[] = {
1469         {GRAPHKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1470         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1471         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1472         {GRAPHKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1473         {0, NULL, NULL, NULL}
1474 };
1475
1476 /* this function is responsible for mirroring keyframes */
1477 static void mirror_graph_keys(bAnimContext *ac, short mode) 
1478 {
1479         ListBase anim_data = {NULL, NULL};
1480         bAnimListElem *ale;
1481         int filter;
1482         
1483         BeztEditData bed;
1484         BeztEditFunc edit_cb;
1485         
1486         /* get beztriple editing callbacks */
1487         edit_cb= ANIM_editkeyframes_mirror(mode);
1488         
1489         memset(&bed, 0, sizeof(BeztEditData)); 
1490         bed.scene= ac->scene;
1491         
1492         /* for 'first selected marker' mode, need to find first selected marker first! */
1493         // XXX should this be made into a helper func in the API?
1494         if (mode == GRAPHKEYS_MIRROR_MARKER) {
1495                 TimeMarker *marker= NULL;
1496                 
1497                 /* find first selected marker */
1498                 if (ac->markers) {
1499                         for (marker= ac->markers->first; marker; marker=marker->next) {
1500                                 if (marker->flag & SELECT) {
1501                                         break;
1502                                 }
1503                         }
1504                 }
1505                 
1506                 /* store marker's time (if available) */
1507                 if (marker)
1508                         bed.f1= (float)marker->frame;
1509                 else
1510                         return;
1511         }
1512         
1513         /* filter data */
1514         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1515         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1516         
1517         /* mirror keyframes */
1518         for (ale= anim_data.first; ale; ale= ale->next) {
1519                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1520                 
1521                 if (nob) {
1522                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1523                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1524                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1525                 }
1526                 else 
1527                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1528         }
1529         BLI_freelistN(&anim_data);
1530 }
1531
1532 /* ------------------- */
1533
1534 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
1535 {
1536         bAnimContext ac;
1537         short mode;
1538         
1539         /* get editor data */
1540         if (ANIM_animdata_get_context(C, &ac) == 0)
1541                 return OPERATOR_CANCELLED;
1542                 
1543         /* get mirroring mode */
1544         mode= RNA_enum_get(op->ptr, "type");
1545         
1546         /* mirror keyframes */
1547         mirror_graph_keys(&ac, mode);
1548         
1549         /* validate keyframes after editing */
1550         ANIM_editkeyframes_refresh(&ac);
1551         
1552         /* set notifier that things have changed */
1553         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1554         
1555         return OPERATOR_FINISHED;
1556 }
1557  
1558 void GRAPHEDIT_OT_keyframes_mirror (wmOperatorType *ot)
1559 {
1560         /* identifiers */
1561         ot->name= "Mirror Keys";
1562         ot->idname= "GRAPHEDIT_OT_keyframes_mirror";
1563         
1564         /* api callbacks */
1565         ot->invoke= WM_menu_invoke;
1566         ot->exec= graphkeys_mirror_exec;
1567         ot->poll= ED_operator_areaactive;
1568         
1569         /* flags */
1570         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1571         
1572         /* id-props */
1573         RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
1574 }
1575
1576 /* ******************** Smooth Keyframes Operator *********************** */
1577
1578 static int graphkeys_smooth_exec(bContext *C, wmOperator *op)
1579 {
1580         bAnimContext ac;
1581         ListBase anim_data = {NULL, NULL};
1582         bAnimListElem *ale;
1583         int filter;
1584         
1585         /* get editor data */
1586         if (ANIM_animdata_get_context(C, &ac) == 0)
1587                 return OPERATOR_CANCELLED;
1588         
1589         /* filter data */
1590         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1591         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1592         
1593         /* smooth keyframes */
1594         for (ale= anim_data.first; ale; ale= ale->next) {
1595                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
1596                  * Perhaps the mode argument could be removed, as that functionality is offerred through 
1597                  * Snap->Flatten Handles anyway.
1598                  */
1599                 smooth_fcurve(ale->key_data);
1600         }
1601         BLI_freelistN(&anim_data);
1602         
1603         /* validate keyframes after editing */
1604         ANIM_editkeyframes_refresh(&ac);
1605         
1606         /* set notifier that things have changed */
1607         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1608         
1609         return OPERATOR_FINISHED;
1610 }
1611  
1612 void GRAPHEDIT_OT_keyframes_smooth (wmOperatorType *ot)
1613 {
1614         /* identifiers */
1615         ot->name= "Smooth Keys";
1616         ot->idname= "GRAPHEDIT_OT_keyframes_smooth";
1617         
1618         /* api callbacks */
1619         ot->exec= graphkeys_smooth_exec;
1620         ot->poll= ED_operator_areaactive;
1621         
1622         /* flags */
1623         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1624 }
1625
1626 /* ************************************************************************** */
1627 /* F-CURVE MODIFIERS */
1628
1629 /* ******************** Add F-Curve Modifier Operator *********************** */
1630
1631 static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
1632 {
1633         bAnimContext ac;
1634         bAnimListElem *ale;
1635         FCurve *fcu;
1636         FModifier *fcm;
1637         short type;
1638         
1639         /* get editor data */
1640         if (ANIM_animdata_get_context(C, &ac) == 0)
1641                 return OPERATOR_CANCELLED;
1642                 
1643                 // xxx call the raw methods here instead?
1644         ale= get_active_fcurve_channel(&ac);
1645         if (ale == NULL) 
1646                 return OPERATOR_CANCELLED;
1647         
1648         fcu= (FCurve *)ale->data;
1649         MEM_freeN(ale);
1650         if (fcu == NULL) 
1651                 return OPERATOR_CANCELLED;
1652                 
1653         /* get type of modifier to add */
1654         type= RNA_enum_get(op->ptr, "type");
1655         
1656         /* add F-Modifier of specified type to active F-Curve, and make it the active one */
1657         fcm= fcurve_add_modifier(fcu, type);
1658         if (fcm)
1659                 fcurve_set_active_modifier(fcu, fcm);
1660         else {
1661                 BKE_report(op->reports, RPT_ERROR, "Modifier couldn't be added. See console for details.");
1662                 return OPERATOR_CANCELLED;
1663         }
1664         
1665         /* validate keyframes after editing */
1666         ANIM_editkeyframes_refresh(&ac);
1667         
1668         /* set notifier that things have changed */
1669         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_BOTH);
1670         
1671         return OPERATOR_FINISHED;
1672 }
1673  
1674 void GRAPHEDIT_OT_fmodifier_add (wmOperatorType *ot)
1675 {
1676         /* identifiers */
1677         ot->name= "Add F-Curve Modifier";
1678         ot->idname= "GRAPHEDIT_OT_fmodifier_add";
1679         
1680         /* api callbacks */
1681         ot->invoke= WM_menu_invoke;
1682         ot->exec= graph_fmodifier_add_exec;
1683         ot->poll= ED_operator_areaactive; // XXX need active F-Curve
1684         
1685         /* flags */
1686         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1687         
1688         /* id-props */
1689         RNA_def_enum(ot->srna, "type", fmodifier_type_items, 0, "Type", "");
1690 }
1691
1692 /* ************************************************************************** */