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