2.50: svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r19323...
[blender.git] / source / blender / editors / space_action / action_edit.c
1 /**
2  * $Id: editaction.c 17746 2008-12-08 11:19:44Z aligorith $
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <math.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <float.h>
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #include "MEM_guardedalloc.h"
40
41 #include "BLI_blenlib.h"
42 #include "BLI_arithb.h"
43
44 #include "DNA_anim_types.h"
45 #include "DNA_action_types.h"
46 #include "DNA_armature_types.h"
47 #include "DNA_camera_types.h"
48 #include "DNA_curve_types.h"
49 #include "DNA_object_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_scene_types.h"
52 #include "DNA_space_types.h"
53 #include "DNA_constraint_types.h"
54 #include "DNA_key_types.h"
55 #include "DNA_lamp_types.h"
56 #include "DNA_material_types.h"
57 #include "DNA_userdef_types.h"
58 #include "DNA_gpencil_types.h"
59 #include "DNA_windowmanager_types.h"
60
61 #include "RNA_access.h"
62 #include "RNA_define.h"
63
64 #include "BKE_action.h"
65 #include "BKE_depsgraph.h"
66 #include "BKE_fcurve.h"
67 #include "BKE_key.h"
68 #include "BKE_material.h"
69 #include "BKE_object.h"
70 #include "BKE_context.h"
71 #include "BKE_report.h"
72 #include "BKE_utildefines.h"
73
74 #include "UI_view2d.h"
75
76 #include "BIF_transform.h"
77
78 #include "ED_anim_api.h"
79 #include "ED_keyframing.h"
80 #include "ED_keyframes_draw.h"
81 #include "ED_keyframes_edit.h"
82 #include "ED_screen.h"
83 #include "ED_space_api.h"
84
85 #include "WM_api.h"
86 #include "WM_types.h"
87
88 #include "action_intern.h"
89
90 /* ************************************************************************** */
91 /* KEYFRAME-RANGE STUFF */
92
93 /* *************************** Calculate Range ************************** */
94
95 /* Get the min/max keyframes*/
96 static void get_keyframe_extents (bAnimContext *ac, float *min, float *max)
97 {
98         ListBase anim_data = {NULL, NULL};
99         bAnimListElem *ale;
100         int filter;
101         
102         /* get data to filter, from Action or Dopesheet */
103         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
104         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
105         
106         /* set large values to try to override */
107         *min= 999999999.0f;
108         *max= -999999999.0f;
109         
110         /* check if any channels to set range with */
111         if (anim_data.first) {
112                 /* go through channels, finding max extents */
113                 for (ale= anim_data.first; ale; ale= ale->next) {
114                         Object *nob= ANIM_nla_mapping_get(ac, ale);
115                         FCurve *fcu= (FCurve *)ale->key_data;
116                         float tmin, tmax;
117                         
118                         /* get range and apply necessary scaling before */
119                         calc_fcurve_range(fcu, &tmin, &tmax);
120                         
121                         if (nob) {
122                                 tmin= get_action_frame_inv(nob, tmin);
123                                 tmax= get_action_frame_inv(nob, tmax);
124                         }
125                         
126                         /* try to set cur using these values, if they're more extreme than previously set values */
127                         *min= MIN2(*min, tmin);
128                         *max= MAX2(*max, tmax);
129                 }
130                 
131                 /* free memory */
132                 BLI_freelistN(&anim_data);
133         }
134         else {
135                 /* set default range */
136                 if (ac->scene) {
137                         *min= (float)ac->scene->r.sfra;
138                         *max= (float)ac->scene->r.efra;
139                 }
140                 else {
141                         *min= -5;
142                         *max= 100;
143                 }
144         }
145 }
146
147 /* ****************** Automatic Preview-Range Operator ****************** */
148
149 static int actkeys_previewrange_exec(bContext *C, wmOperator *op)
150 {
151         bAnimContext ac;
152         Scene *scene;
153         float min, max;
154         
155         /* get editor data */
156         if (ANIM_animdata_get_context(C, &ac) == 0)
157                 return OPERATOR_CANCELLED;
158         if (ac.scene == NULL)
159                 return OPERATOR_CANCELLED;
160         else
161                 scene= ac.scene;
162         
163         /* set the range directly */
164         get_keyframe_extents(&ac, &min, &max);
165         scene->r.psfra= (int)floor(min + 0.5f);
166         scene->r.pefra= (int)floor(max + 0.5f);
167         
168         /* set notifier that things have changed */
169         // XXX err... there's nothing for frame ranges yet, but this should do fine too
170         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
171         
172         return OPERATOR_FINISHED;
173 }
174  
175 void ACT_OT_previewrange_set (wmOperatorType *ot)
176 {
177         /* identifiers */
178         ot->name= "Auto-Set Preview Range";
179         ot->idname= "ACT_OT_previewrange_set";
180         
181         /* api callbacks */
182         ot->exec= actkeys_previewrange_exec;
183         ot->poll= ED_operator_areaactive;
184         
185         /* flags */
186         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
187 }
188
189 /* ****************** View-All Operator ****************** */
190
191 static int actkeys_viewall_exec(bContext *C, wmOperator *op)
192 {
193         bAnimContext ac;
194         View2D *v2d;
195         float extra;
196         
197         /* get editor data */
198         if (ANIM_animdata_get_context(C, &ac) == 0)
199                 return OPERATOR_CANCELLED;
200         v2d= &ac.ar->v2d;
201         
202         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
203         get_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax);
204         
205         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
206         v2d->cur.xmin -= extra;
207         v2d->cur.xmax += extra;
208         
209         /* set vertical range */
210         v2d->cur.ymax= 0.0f;
211         v2d->cur.ymin= (float)-(v2d->mask.ymax - v2d->mask.ymin);
212         
213         /* do View2D syncing */
214         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
215         
216         /* set notifier that things have changed */
217         ED_area_tag_redraw(CTX_wm_area(C));
218         
219         return OPERATOR_FINISHED;
220 }
221  
222 void ACT_OT_view_all (wmOperatorType *ot)
223 {
224         /* identifiers */
225         ot->name= "View All";
226         ot->idname= "ACT_OT_view_all";
227         
228         /* api callbacks */
229         ot->exec= actkeys_viewall_exec;
230         ot->poll= ED_operator_areaactive;
231         
232         /* flags */
233         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
234 }
235
236 /* ************************************************************************** */
237 /* GENERAL STUFF */
238
239 /* ******************** Copy/Paste Keyframes Operator ************************* */
240 /* NOTE: the backend code for this is shared with the graph editor */
241
242 static short copy_action_keys (bAnimContext *ac)
243 {       
244         ListBase anim_data = {NULL, NULL};
245         int filter, ok=0;
246         
247         /* clear buffer first */
248         free_anim_copybuf();
249         
250         /* filter data */
251         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
252         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
253         
254         /* copy keyframes */
255         ok= copy_animedit_keys(ac, &anim_data);
256         
257         /* clean up */
258         BLI_freelistN(&anim_data);
259
260         return ok;
261 }
262
263
264 static short paste_action_keys (bAnimContext *ac)
265 {       
266         ListBase anim_data = {NULL, NULL};
267         int filter, ok=0;
268         
269         /* filter data */
270         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
271         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
272         
273         /* paste keyframes */
274         ok= paste_animedit_keys(ac, &anim_data);
275         
276         /* clean up */
277         BLI_freelistN(&anim_data);
278
279         return ok;
280 }
281
282 /* ------------------- */
283
284 static int actkeys_copy_exec(bContext *C, wmOperator *op)
285 {
286         bAnimContext ac;
287         
288         /* get editor data */
289         if (ANIM_animdata_get_context(C, &ac) == 0)
290                 return OPERATOR_CANCELLED;
291         
292         /* copy keyframes */
293         if (ac.datatype == ANIMCONT_GPENCIL) {
294                 // FIXME...
295         }
296         else {
297                 if (copy_action_keys(&ac)) {    
298                         BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
299                         return OPERATOR_CANCELLED;
300                 }
301         }
302         
303         /* set notifier that things have changed */
304         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
305         
306         return OPERATOR_FINISHED;
307 }
308  
309 void ACT_OT_keyframes_copy (wmOperatorType *ot)
310 {
311         /* identifiers */
312         ot->name= "Copy Keyframes";
313         ot->idname= "ACT_OT_keyframes_copy";
314         
315         /* api callbacks */
316         ot->exec= actkeys_copy_exec;
317         ot->poll= ED_operator_areaactive;
318         
319         /* flags */
320         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
321 }
322
323
324
325 static int actkeys_paste_exec(bContext *C, wmOperator *op)
326 {
327         bAnimContext ac;
328         
329         /* get editor data */
330         if (ANIM_animdata_get_context(C, &ac) == 0)
331                 return OPERATOR_CANCELLED;
332         
333         /* paste keyframes */
334         if (ac.datatype == ANIMCONT_GPENCIL) {
335                 // FIXME...
336         }
337         else {
338                 if (paste_action_keys(&ac)) {
339                         BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
340                         return OPERATOR_CANCELLED;
341                 }
342         }
343         
344         /* validate keyframes after editing */
345         ANIM_editkeyframes_refresh(&ac);
346         
347         /* set notifier that things have changed */
348         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
349         
350         return OPERATOR_FINISHED;
351 }
352  
353 void ACT_OT_keyframes_paste (wmOperatorType *ot)
354 {
355         /* identifiers */
356         ot->name= "Paste Keyframes";
357         ot->idname= "ACT_OT_keyframes_paste";
358         
359         /* api callbacks */
360         ot->exec= actkeys_paste_exec;
361         ot->poll= ED_operator_areaactive;
362         
363         /* flags */
364         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
365 }
366
367 /* ******************** Insert Keyframes Operator ************************* */
368
369 /* defines for insert keyframes tool */
370 EnumPropertyItem prop_actkeys_insertkey_types[] = {
371         {1, "ALL", "All Channels", ""},
372         {2, "SEL", "Only Selected Channels", ""},
373         {3, "GROUP", "In Active Group", ""}, // xxx not in all cases
374         {0, NULL, NULL, NULL}
375 };
376
377 /* this function is responsible for snapping keyframes to frame-times */
378 static void insert_action_keys(bAnimContext *ac, short mode) 
379 {
380         ListBase anim_data = {NULL, NULL};
381         bAnimListElem *ale;
382         int filter;
383         
384         Scene *scene= ac->scene;
385         float cfra= (float)CFRA;
386         short flag = 0;
387         
388         /* filter data */
389         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
390         if (mode == 2)                  filter |= ANIMFILTER_SEL;
391         else if (mode == 3)     filter |= ANIMFILTER_ACTGROUPED;
392         
393         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
394         
395         /* init keyframing flag */
396         if (IS_AUTOKEY_FLAG(AUTOMATKEY)) flag |= INSERTKEY_MATRIX;
397         if (IS_AUTOKEY_FLAG(INSERTNEEDED)) flag |= INSERTKEY_NEEDED;
398         // if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE;
399         
400         /* insert keyframes */
401         for (ale= anim_data.first; ale; ale= ale->next) {
402                 //Object *nob= ANIM_nla_mapping_get(ac, ale);
403                 FCurve *fcu= (FCurve *)ale->key_data;
404                 
405                 /* adjust current frame for NLA-scaling */
406                 //if (nob)
407                 //      cfra= get_action_frame(nob, CFRA);
408                 //else 
409                 //      cfra= (float)CFRA;
410                         
411                 /* if there's an id */
412                 if (ale->id)
413                         insert_keyframe(ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
414                 else
415                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
416         }
417         
418         BLI_freelistN(&anim_data);
419 }
420
421 /* ------------------- */
422
423 static int actkeys_insertkey_exec(bContext *C, wmOperator *op)
424 {
425         bAnimContext ac;
426         short mode;
427         
428         /* get editor data */
429         if (ANIM_animdata_get_context(C, &ac) == 0)
430                 return OPERATOR_CANCELLED;
431         if (ac.datatype == ANIMCONT_GPENCIL)
432                 return OPERATOR_CANCELLED;
433                 
434         /* get snapping mode */
435         mode= RNA_enum_get(op->ptr, "type");
436         
437         /* snap keyframes */
438         insert_action_keys(&ac, mode);
439         
440         /* validate keyframes after editing */
441         ANIM_editkeyframes_refresh(&ac);
442         
443         /* set notifier that things have changed */
444         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
445         
446         return OPERATOR_FINISHED;
447 }
448
449 void ACT_OT_keyframes_insert (wmOperatorType *ot)
450 {
451         /* identifiers */
452         ot->name= "Insert Keyframes";
453         ot->idname= "ACT_OT_keyframes_insert";
454         
455         /* api callbacks */
456         ot->invoke= WM_menu_invoke;
457         ot->exec= actkeys_insertkey_exec;
458         ot->poll= ED_operator_areaactive;
459         
460         /* flags */
461         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
462         
463         /* id-props */
464         RNA_def_enum(ot->srna, "type", prop_actkeys_insertkey_types, 0, "Type", "");
465 }
466
467 /* ******************** Duplicate Keyframes Operator ************************* */
468
469 static void duplicate_action_keys (bAnimContext *ac)
470 {
471         ListBase anim_data = {NULL, NULL};
472         bAnimListElem *ale;
473         int filter;
474         
475         /* filter data */
476         if (ac->datatype == ANIMCONT_GPENCIL)
477                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
478         else
479                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
480         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
481         
482         /* loop through filtered data and delete selected keys */
483         for (ale= anim_data.first; ale; ale= ale->next) {
484                 //if (ale->type == ANIMTYPE_GPLAYER)
485                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
486                 //else
487                         duplicate_fcurve_keys((FCurve *)ale->key_data);
488         }
489         
490         /* free filtered list */
491         BLI_freelistN(&anim_data);
492 }
493
494 /* ------------------- */
495
496 static int actkeys_duplicate_exec(bContext *C, wmOperator *op)
497 {
498         bAnimContext ac;
499         
500         /* get editor data */
501         if (ANIM_animdata_get_context(C, &ac) == 0)
502                 return OPERATOR_CANCELLED;
503                 
504         /* duplicate keyframes */
505         duplicate_action_keys(&ac);
506         
507         /* validate keyframes after editing */
508         ANIM_editkeyframes_refresh(&ac);
509         
510         /* set notifier that things have changed */
511         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
512         
513         return OPERATOR_FINISHED; // xxx - start transform
514 }
515
516 static int actkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
517 {
518         actkeys_duplicate_exec(C, op);
519         
520         RNA_int_set(op->ptr, "mode", TFM_TIME_TRANSLATE);
521         WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
522
523         return OPERATOR_FINISHED;
524 }
525  
526 void ACT_OT_keyframes_duplicate (wmOperatorType *ot)
527 {
528         /* identifiers */
529         ot->name= "Duplicate Keyframes";
530         ot->idname= "ACT_OT_keyframes_duplicate";
531         
532         /* api callbacks */
533         ot->invoke= actkeys_duplicate_invoke;
534         ot->exec= actkeys_duplicate_exec;
535         ot->poll= ED_operator_areaactive;
536         
537         /* flags */
538         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
539         
540         /* to give to transform */
541         RNA_def_int(ot->srna, "mode", TFM_TIME_TRANSLATE, 0, INT_MAX, "Mode", "", 0, INT_MAX);
542 }
543
544 /* ******************** Delete Keyframes Operator ************************* */
545
546 static void delete_action_keys (bAnimContext *ac)
547 {
548         ListBase anim_data = {NULL, NULL};
549         bAnimListElem *ale;
550         int filter;
551         
552         /* filter data */
553         if (ac->datatype == ANIMCONT_GPENCIL)
554                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
555         else
556                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
557         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
558         
559         /* loop through filtered data and delete selected keys */
560         for (ale= anim_data.first; ale; ale= ale->next) {
561                 //if (ale->type == ANIMTYPE_GPLAYER)
562                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
563                 //else
564                         delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
565         }
566         
567         /* free filtered list */
568         BLI_freelistN(&anim_data);
569 }
570
571 /* ------------------- */
572
573 static int actkeys_delete_exec(bContext *C, wmOperator *op)
574 {
575         bAnimContext ac;
576         
577         /* get editor data */
578         if (ANIM_animdata_get_context(C, &ac) == 0)
579                 return OPERATOR_CANCELLED;
580                 
581         /* delete keyframes */
582         delete_action_keys(&ac);
583         
584         /* validate keyframes after editing */
585         ANIM_editkeyframes_refresh(&ac);
586         
587         /* set notifier that things have changed */
588         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
589         
590         return OPERATOR_FINISHED;
591 }
592  
593 void ACT_OT_keyframes_delete (wmOperatorType *ot)
594 {
595         /* identifiers */
596         ot->name= "Delete Keyframes";
597         ot->idname= "ACT_OT_keyframes_delete";
598         
599         /* api callbacks */
600         ot->invoke= WM_operator_confirm;
601         ot->exec= actkeys_delete_exec;
602         ot->poll= ED_operator_areaactive;
603         
604         /* flags */
605         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
606 }
607
608 /* ******************** Clean Keyframes Operator ************************* */
609
610 static void clean_action_keys (bAnimContext *ac, float thresh)
611 {       
612         ListBase anim_data = {NULL, NULL};
613         bAnimListElem *ale;
614         int filter;
615         
616         /* filter data */
617         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
618         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
619         
620         /* loop through filtered data and clean curves */
621         for (ale= anim_data.first; ale; ale= ale->next)
622                 clean_fcurve((FCurve *)ale->key_data, thresh);
623         
624         /* free temp data */
625         BLI_freelistN(&anim_data);
626 }
627
628 /* ------------------- */
629
630 static int actkeys_clean_exec(bContext *C, wmOperator *op)
631 {
632         bAnimContext ac;
633         float thresh;
634         
635         /* get editor data */
636         if (ANIM_animdata_get_context(C, &ac) == 0)
637                 return OPERATOR_CANCELLED;
638         if (ac.datatype == ANIMCONT_GPENCIL)
639                 return OPERATOR_PASS_THROUGH;
640                 
641         /* get cleaning threshold */
642         thresh= RNA_float_get(op->ptr, "threshold");
643         
644         /* clean keyframes */
645         clean_action_keys(&ac, thresh);
646         
647         /* validate keyframes after editing */
648         ANIM_editkeyframes_refresh(&ac);
649         
650         /* set notifier that things have changed */
651         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
652         
653         return OPERATOR_FINISHED;
654 }
655  
656 void ACT_OT_keyframes_clean (wmOperatorType *ot)
657 {
658         /* identifiers */
659         ot->name= "Clean Keyframes";
660         ot->idname= "ACT_OT_keyframes_clean";
661         
662         /* api callbacks */
663         //ot->invoke=  // XXX we need that number popup for this! 
664         ot->exec= actkeys_clean_exec;
665         ot->poll= ED_operator_areaactive;
666         
667         /* flags */
668         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
669         
670         /* properties */
671         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
672 }
673
674 /* ******************** Sample Keyframes Operator *********************** */
675
676 /* little cache for values... */
677 typedef struct tempFrameValCache {
678         float frame, val;
679 } tempFrameValCache;
680
681 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
682 static void sample_action_keys (bAnimContext *ac)
683 {       
684         ListBase anim_data = {NULL, NULL};
685         bAnimListElem *ale;
686         int filter;
687         
688         /* filter data */
689         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
690         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
691         
692         /* loop through filtered data and add keys between selected keyframes on every frame  */
693         for (ale= anim_data.first; ale; ale= ale->next) {
694                 FCurve *fcu= (FCurve *)ale->key_data;
695                 BezTriple *bezt, *start=NULL, *end=NULL;
696                 tempFrameValCache *value_cache, *fp;
697                 int sfra, range;
698                 int i, n;
699                 
700                 /* find selected keyframes... once pair has been found, add keyframes  */
701                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
702                         /* check if selected, and which end this is */
703                         if (BEZSELECTED(bezt)) {
704                                 if (start) {
705                                         /* set end */
706                                         end= bezt;
707                                         
708                                         /* cache values then add keyframes using these values, as adding
709                                          * keyframes while sampling will affect the outcome...
710                                          */
711                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
712                                         sfra= (int)( floor(start->vec[1][0]) );
713                                         
714                                         if (range) {
715                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
716                                                 
717                                                 /*      sample values   */
718                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
719                                                         fp->frame= (float)(sfra + n);
720                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
721                                                 }
722                                                 
723                                                 /*      add keyframes with these        */
724                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
725                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
726                                                 }
727                                                 
728                                                 /* free temp cache */
729                                                 MEM_freeN(value_cache);
730                                                 
731                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
732                                                 bezt = fcu->bezt + i + range - 1;
733                                                 i += (range - 1);
734                                         }
735                                         
736                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
737                                         start= bezt;
738                                         end= NULL;
739                                 }
740                                 else {
741                                         /* just set start keyframe */
742                                         start= bezt;
743                                         end= NULL;
744                                 }
745                         }
746                 }
747                 
748                 /* recalculate channel's handles? */
749                 calchandles_fcurve(fcu);
750         }
751         
752         /* admin and redraws */
753         BLI_freelistN(&anim_data);
754 }
755
756 /* ------------------- */
757
758 static int actkeys_sample_exec(bContext *C, wmOperator *op)
759 {
760         bAnimContext ac;
761         
762         /* get editor data */
763         if (ANIM_animdata_get_context(C, &ac) == 0)
764                 return OPERATOR_CANCELLED;
765         if (ac.datatype == ANIMCONT_GPENCIL)
766                 return OPERATOR_PASS_THROUGH;
767         
768         /* sample keyframes */
769         sample_action_keys(&ac);
770         
771         /* validate keyframes after editing */
772         ANIM_editkeyframes_refresh(&ac);
773         
774         /* set notifier that things have changed */
775         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
776         
777         return OPERATOR_FINISHED;
778 }
779  
780 void ACT_OT_keyframes_sample (wmOperatorType *ot)
781 {
782         /* identifiers */
783         ot->name= "Sample Keyframes";
784         ot->idname= "ACT_OT_keyframes_sample";
785         
786         /* api callbacks */
787         ot->exec= actkeys_sample_exec;
788         ot->poll= ED_operator_areaactive;
789         
790         /* flags */
791         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
792 }
793
794 /* ************************************************************************** */
795 /* SETTINGS STUFF */
796
797 /* ******************** Set Extrapolation-Type Operator *********************** */
798
799 /* defines for set extrapolation-type for selected keyframes tool */
800 EnumPropertyItem prop_actkeys_expo_types[] = {
801         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
802         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
803         {0, NULL, NULL, NULL}
804 };
805
806 /* this function is responsible for setting extrapolation mode for keyframes */
807 static void setexpo_action_keys(bAnimContext *ac, short mode) 
808 {
809         ListBase anim_data = {NULL, NULL};
810         bAnimListElem *ale;
811         int filter;
812         
813         /* filter data */
814         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
815         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
816         
817         /* loop through setting mode per F-Curve */
818         for (ale= anim_data.first; ale; ale= ale->next) {
819                 FCurve *fcu= (FCurve *)ale->data;
820                 fcu->extend= mode;
821         }
822         
823         /* cleanup */
824         BLI_freelistN(&anim_data);
825 }
826
827 /* ------------------- */
828
829 static int actkeys_expo_exec(bContext *C, wmOperator *op)
830 {
831         bAnimContext ac;
832         short mode;
833         
834         /* get editor data */
835         if (ANIM_animdata_get_context(C, &ac) == 0)
836                 return OPERATOR_CANCELLED;
837         if (ac.datatype == ANIMCONT_GPENCIL) 
838                 return OPERATOR_PASS_THROUGH;
839                 
840         /* get handle setting mode */
841         mode= RNA_enum_get(op->ptr, "type");
842         
843         /* set handle type */
844         setexpo_action_keys(&ac, mode);
845         
846         /* validate keyframes after editing */
847         ANIM_editkeyframes_refresh(&ac);
848         
849         /* set notifier that things have changed */
850         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
851         
852         return OPERATOR_FINISHED;
853 }
854  
855 void ACT_OT_keyframes_extrapolation_type_set (wmOperatorType *ot)
856 {
857         /* identifiers */
858         ot->name= "Set Keyframe Extrapolation";
859         ot->idname= "ACT_OT_keyframes_extrapolation_type_set";
860         
861         /* api callbacks */
862         ot->invoke= WM_menu_invoke;
863         ot->exec= actkeys_expo_exec;
864         ot->poll= ED_operator_areaactive;
865         
866         /* flags */
867         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
868         
869         /* id-props */
870         RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
871 }
872
873 /* ******************** Set Interpolation-Type Operator *********************** */
874
875 /* defines for set ipo-type for selected keyframes tool */
876 EnumPropertyItem prop_actkeys_ipo_types[] = {
877         {BEZT_IPO_CONST, "CONSTANT", "Constant Interpolation", ""},
878         {BEZT_IPO_LIN, "LINEAR", "Linear Interpolation", ""},
879         {BEZT_IPO_BEZ, "BEZIER", "Bezier Interpolation", ""},
880         {0, NULL, NULL, NULL}
881 };
882
883 /* this function is responsible for setting interpolation mode for keyframes */
884 static void setipo_action_keys(bAnimContext *ac, short mode) 
885 {
886         ListBase anim_data = {NULL, NULL};
887         bAnimListElem *ale;
888         int filter;
889         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
890         
891         /* filter data */
892         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
893         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
894         
895         /* loop through setting BezTriple interpolation
896          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
897          */
898         for (ale= anim_data.first; ale; ale= ale->next)
899                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
900         
901         /* cleanup */
902         BLI_freelistN(&anim_data);
903 }
904
905 /* ------------------- */
906
907 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
908 {
909         bAnimContext ac;
910         short mode;
911         
912         /* get editor data */
913         if (ANIM_animdata_get_context(C, &ac) == 0)
914                 return OPERATOR_CANCELLED;
915         if (ac.datatype == ANIMCONT_GPENCIL) 
916                 return OPERATOR_PASS_THROUGH;
917                 
918         /* get handle setting mode */
919         mode= RNA_enum_get(op->ptr, "type");
920         
921         /* set handle type */
922         setipo_action_keys(&ac, mode);
923         
924         /* validate keyframes after editing */
925         ANIM_editkeyframes_refresh(&ac);
926         
927         /* set notifier that things have changed */
928         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
929         
930         return OPERATOR_FINISHED;
931 }
932  
933 void ACT_OT_keyframes_interpolation_type (wmOperatorType *ot)
934 {
935         /* identifiers */
936         ot->name= "Set Keyframe Interpolation";
937         ot->idname= "ACT_OT_keyframes_interpolation_type";
938         
939         /* api callbacks */
940         ot->invoke= WM_menu_invoke;
941         ot->exec= actkeys_ipo_exec;
942         ot->poll= ED_operator_areaactive;
943         
944         /* flags */
945         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
946         
947         /* id-props */
948         RNA_def_enum(ot->srna, "type", prop_actkeys_ipo_types, 0, "Type", "");
949 }
950
951 /* ******************** Set Handle-Type Operator *********************** */
952
953 /* defines for set handle-type for selected keyframes tool */
954 EnumPropertyItem prop_actkeys_handletype_types[] = {
955         {HD_AUTO, "AUTO", "Auto Handles", ""},
956         {HD_VECT, "VECTOR", "Vector Handles", ""},
957         {HD_FREE, "FREE", "Free Handles", ""},
958         {HD_ALIGN, "ALIGN", "Aligned Handles", ""},
959 //      {-1, "TOGGLE", "Toggle between Free and Aligned Handles", ""},
960         {0, NULL, NULL, NULL}
961 };
962
963 /* this function is responsible for setting handle-type of selected keyframes */
964 static void sethandles_action_keys(bAnimContext *ac, short mode) 
965 {
966         ListBase anim_data = {NULL, NULL};
967         bAnimListElem *ale;
968         int filter;
969         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
970         
971         /* filter data */
972         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
973         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
974         
975         /* loop through setting flags for handles 
976          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
977          */
978         for (ale= anim_data.first; ale; ale= ale->next) {
979                 if (mode == -1) {       
980                         BeztEditFunc toggle_cb;
981                         
982                         /* check which type of handle to set (free or aligned) 
983                          *      - check here checks for handles with free alignment already
984                          */
985                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
986                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
987                         else
988                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
989                                 
990                         /* set handle-type */
991                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
992                 }
993                 else {
994                         /* directly set handle-type */
995                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
996                 }
997         }
998         
999         /* cleanup */
1000         BLI_freelistN(&anim_data);
1001 }
1002
1003 /* ------------------- */
1004
1005 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
1006 {
1007         bAnimContext ac;
1008         short mode;
1009         
1010         /* get editor data */
1011         if (ANIM_animdata_get_context(C, &ac) == 0)
1012                 return OPERATOR_CANCELLED;
1013         if (ac.datatype == ANIMCONT_GPENCIL) 
1014                 return OPERATOR_PASS_THROUGH;
1015                 
1016         /* get handle setting mode */
1017         mode= RNA_enum_get(op->ptr, "type");
1018         
1019         /* set handle type */
1020         sethandles_action_keys(&ac, mode);
1021         
1022         /* validate keyframes after editing */
1023         ANIM_editkeyframes_refresh(&ac);
1024         
1025         /* set notifier that things have changed */
1026         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1027         
1028         return OPERATOR_FINISHED;
1029 }
1030  
1031 void ACT_OT_keyframes_handle_type_set (wmOperatorType *ot)
1032 {
1033         /* identifiers */
1034         ot->name= "Set Keyframe Handle Type";
1035         ot->idname= "ACT_OT_keyframes_handle_type_set";
1036         
1037         /* api callbacks */
1038         ot->invoke= WM_menu_invoke;
1039         ot->exec= actkeys_handletype_exec;
1040         ot->poll= ED_operator_areaactive;
1041         
1042         /* flags */
1043         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1044         
1045         /* id-props */
1046         RNA_def_enum(ot->srna, "type", prop_actkeys_handletype_types, 0, "Type", "");
1047 }
1048
1049 /* ************************************************************************** */
1050 /* TRANSFORM STUFF */
1051
1052 /* ***************** Snap Current Frame Operator *********************** */
1053
1054 /* snap current-frame indicator to 'average time' of selected keyframe */
1055 static int actkeys_cfrasnap_exec(bContext *C, wmOperator *op)
1056 {
1057         bAnimContext ac;
1058         ListBase anim_data= {NULL, NULL};
1059         bAnimListElem *ale;
1060         int filter;
1061         BeztEditData bed;
1062         
1063         /* get editor data */
1064         if (ANIM_animdata_get_context(C, &ac) == 0)
1065                 return OPERATOR_CANCELLED;
1066         
1067         /* init edit data */
1068         memset(&bed, 0, sizeof(BeztEditData));
1069         
1070         /* loop over action data, averaging values */
1071         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
1072         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1073         
1074         for (ale= anim_data.first; ale; ale= ale->next)
1075                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1076         
1077         BLI_freelistN(&anim_data);
1078         
1079         /* set the new current frame value, based on the average time */
1080         if (bed.i1) {
1081                 Scene *scene= ac.scene;
1082                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1083         }
1084         
1085         /* set notifier that things have changed */
1086         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1087         
1088         return OPERATOR_FINISHED;
1089 }
1090
1091 void ACT_OT_keyframes_cfrasnap (wmOperatorType *ot)
1092 {
1093         /* identifiers */
1094         ot->name= "Snap Current Frame to Keys";
1095         ot->idname= "ACT_OT_keyframes_cfrasnap";
1096         
1097         /* api callbacks */
1098         ot->exec= actkeys_cfrasnap_exec;
1099         ot->poll= ED_operator_areaactive;
1100         
1101         /* flags */
1102         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1103 }
1104
1105 /* ******************** Snap Keyframes Operator *********************** */
1106
1107 /* defines for snap keyframes tool */
1108 EnumPropertyItem prop_actkeys_snap_types[] = {
1109         {ACTKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1110         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1111         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1112         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1113         {0, NULL, NULL, NULL}
1114 };
1115
1116 /* this function is responsible for snapping keyframes to frame-times */
1117 static void snap_action_keys(bAnimContext *ac, short mode) 
1118 {
1119         ListBase anim_data = {NULL, NULL};
1120         bAnimListElem *ale;
1121         int filter;
1122         
1123         BeztEditData bed;
1124         BeztEditFunc edit_cb;
1125         
1126         /* filter data */
1127         if (ac->datatype == ANIMCONT_GPENCIL)
1128                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1129         else
1130                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1131         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1132         
1133         /* get beztriple editing callbacks */
1134         edit_cb= ANIM_editkeyframes_snap(mode);
1135         
1136         memset(&bed, 0, sizeof(BeztEditData)); 
1137         bed.scene= ac->scene;
1138         
1139         /* snap keyframes */
1140         for (ale= anim_data.first; ale; ale= ale->next) {
1141                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1142                 
1143                 if (nob) {
1144                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1145                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1146                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1147                 }
1148                 //else if (ale->type == ACTTYPE_GPLAYER)
1149                 //      snap_gplayer_frames(ale->data, mode);
1150                 else 
1151                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1152         }
1153         BLI_freelistN(&anim_data);
1154 }
1155
1156 /* ------------------- */
1157
1158 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1159 {
1160         bAnimContext ac;
1161         short mode;
1162         
1163         /* get editor data */
1164         if (ANIM_animdata_get_context(C, &ac) == 0)
1165                 return OPERATOR_CANCELLED;
1166                 
1167         /* get snapping mode */
1168         mode= RNA_enum_get(op->ptr, "type");
1169         
1170         /* snap keyframes */
1171         snap_action_keys(&ac, mode);
1172         
1173         /* validate keyframes after editing */
1174         ANIM_editkeyframes_refresh(&ac);
1175         
1176         /* set notifier that things have changed */
1177         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1178         
1179         return OPERATOR_FINISHED;
1180 }
1181  
1182 void ACT_OT_keyframes_snap (wmOperatorType *ot)
1183 {
1184         /* identifiers */
1185         ot->name= "Snap Keys";
1186         ot->idname= "ACT_OT_keyframes_snap";
1187         
1188         /* api callbacks */
1189         ot->invoke= WM_menu_invoke;
1190         ot->exec= actkeys_snap_exec;
1191         ot->poll= ED_operator_areaactive;
1192         
1193         /* flags */
1194         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1195         
1196         /* id-props */
1197         RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1198 }
1199
1200 /* ******************** Mirror Keyframes Operator *********************** */
1201
1202 /* defines for mirror keyframes tool */
1203 EnumPropertyItem prop_actkeys_mirror_types[] = {
1204         {ACTKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1205         {ACTKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1206         {ACTKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1207         {ACTKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1208         {0, NULL, NULL, NULL}
1209 };
1210
1211 /* this function is responsible for mirroring keyframes */
1212 static void mirror_action_keys(bAnimContext *ac, short mode) 
1213 {
1214         ListBase anim_data = {NULL, NULL};
1215         bAnimListElem *ale;
1216         int filter;
1217         
1218         BeztEditData bed;
1219         BeztEditFunc edit_cb;
1220         
1221         /* get beztriple editing callbacks */
1222         edit_cb= ANIM_editkeyframes_mirror(mode);
1223         
1224         memset(&bed, 0, sizeof(BeztEditData)); 
1225         bed.scene= ac->scene;
1226         
1227         /* for 'first selected marker' mode, need to find first selected marker first! */
1228         // XXX should this be made into a helper func in the API?
1229         if (mode == ACTKEYS_MIRROR_MARKER) {
1230                 Scene *scene= ac->scene;
1231                 TimeMarker *marker= NULL;
1232                 
1233                 /* find first selected marker */
1234                 for (marker= scene->markers.first; marker; marker=marker->next) {
1235                         if (marker->flag & SELECT) {
1236                                 break;
1237                         }
1238                 }
1239                 
1240                 /* store marker's time (if available) */
1241                 if (marker)
1242                         bed.f1= (float)marker->frame;
1243                 else
1244                         return;
1245         }
1246         
1247         /* filter data */
1248         if (ac->datatype == ANIMCONT_GPENCIL)
1249                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1250         else
1251                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1252         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1253         
1254         /* mirror keyframes */
1255         for (ale= anim_data.first; ale; ale= ale->next) {
1256                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1257                 
1258                 if (nob) {
1259                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1260                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1261                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1262                 }
1263                 //else if (ale->type == ACTTYPE_GPLAYER)
1264                 //      snap_gplayer_frames(ale->data, mode);
1265                 else 
1266                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1267         }
1268         BLI_freelistN(&anim_data);
1269 }
1270
1271 /* ------------------- */
1272
1273 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1274 {
1275         bAnimContext ac;
1276         short mode;
1277         
1278         /* get editor data */
1279         if (ANIM_animdata_get_context(C, &ac) == 0)
1280                 return OPERATOR_CANCELLED;
1281                 
1282         /* get mirroring mode */
1283         mode= RNA_enum_get(op->ptr, "type");
1284         
1285         /* mirror keyframes */
1286         mirror_action_keys(&ac, mode);
1287         
1288         /* validate keyframes after editing */
1289         ANIM_editkeyframes_refresh(&ac);
1290         
1291         /* set notifier that things have changed */
1292         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1293         
1294         return OPERATOR_FINISHED;
1295 }
1296  
1297 void ACT_OT_keyframes_mirror (wmOperatorType *ot)
1298 {
1299         /* identifiers */
1300         ot->name= "Mirror Keys";
1301         ot->idname= "ACT_OT_keyframes_mirror";
1302         
1303         /* api callbacks */
1304         ot->invoke= WM_menu_invoke;
1305         ot->exec= actkeys_mirror_exec;
1306         ot->poll= ED_operator_areaactive;
1307         
1308         /* flags */
1309         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1310         
1311         /* id-props */
1312         RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1313 }
1314
1315 /* ************************************************************************** */