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