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