NLA SoC: Merge from 2.5 - 21146 to 21178
[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 "BIF_transform.h"
79
80 #include "ED_anim_api.h"
81 #include "ED_keyframing.h"
82 #include "ED_keyframes_draw.h"
83 #include "ED_keyframes_edit.h"
84 #include "ED_screen.h"
85 #include "ED_space_api.h"
86
87 #include "WM_api.h"
88 #include "WM_types.h"
89
90 #include "action_intern.h"
91
92 /* ************************************************************************** */
93 /* KEYFRAME-RANGE STUFF */
94
95 /* *************************** Calculate Range ************************** */
96
97 /* Get the min/max keyframes*/
98 static void get_keyframe_extents (bAnimContext *ac, float *min, float *max)
99 {
100         ListBase anim_data = {NULL, NULL};
101         bAnimListElem *ale;
102         int filter;
103         
104         /* get data to filter, from Action or Dopesheet */
105         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
106         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
107         
108         /* set large values to try to override */
109         *min= 999999999.0f;
110         *max= -999999999.0f;
111         
112         /* check if any channels to set range with */
113         if (anim_data.first) {
114                 /* go through channels, finding max extents */
115                 for (ale= anim_data.first; ale; ale= ale->next) {
116                         AnimData *adt= ANIM_nla_mapping_get(ac, ale);
117                         FCurve *fcu= (FCurve *)ale->key_data;
118                         float tmin, tmax;
119                         
120                         /* get range and apply necessary scaling before */
121                         calc_fcurve_range(fcu, &tmin, &tmax);
122                         
123                         if (adt) {
124                                 tmin= BKE_nla_tweakedit_remap(adt, tmin, 1);
125                                 tmax= BKE_nla_tweakedit_remap(adt, tmax, 1);
126                         }
127                         
128                         /* try to set cur using these values, if they're more extreme than previously set values */
129                         *min= MIN2(*min, tmin);
130                         *max= MAX2(*max, tmax);
131                 }
132                 
133                 /* free memory */
134                 BLI_freelistN(&anim_data);
135         }
136         else {
137                 /* set default range */
138                 if (ac->scene) {
139                         *min= (float)ac->scene->r.sfra;
140                         *max= (float)ac->scene->r.efra;
141                 }
142                 else {
143                         *min= -5;
144                         *max= 100;
145                 }
146         }
147 }
148
149 /* ****************** Automatic Preview-Range Operator ****************** */
150
151 static int actkeys_previewrange_exec(bContext *C, wmOperator *op)
152 {
153         bAnimContext ac;
154         Scene *scene;
155         float min, max;
156         
157         /* get editor data */
158         if (ANIM_animdata_get_context(C, &ac) == 0)
159                 return OPERATOR_CANCELLED;
160         if (ac.scene == NULL)
161                 return OPERATOR_CANCELLED;
162         else
163                 scene= ac.scene;
164         
165         /* set the range directly */
166         get_keyframe_extents(&ac, &min, &max);
167         scene->r.psfra= (int)floor(min + 0.5f);
168         scene->r.pefra= (int)floor(max + 0.5f);
169         
170         /* set notifier that things have changed */
171         // XXX err... there's nothing for frame ranges yet, but this should do fine too
172         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
173         
174         return OPERATOR_FINISHED;
175 }
176  
177 void ACT_OT_previewrange_set (wmOperatorType *ot)
178 {
179         /* identifiers */
180         ot->name= "Auto-Set Preview Range";
181         ot->idname= "ACT_OT_previewrange_set";
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         /* set notifier that things have changed */
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         
230         /* api callbacks */
231         ot->exec= actkeys_viewall_exec;
232         ot->poll= ED_operator_action_active;
233         
234         /* flags */
235         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
236 }
237
238 /* ************************************************************************** */
239 /* GENERAL STUFF */
240
241 /* ******************** Copy/Paste Keyframes Operator ************************* */
242 /* NOTE: the backend code for this is shared with the graph editor */
243
244 static short copy_action_keys (bAnimContext *ac)
245 {       
246         ListBase anim_data = {NULL, NULL};
247         int filter, ok=0;
248         
249         /* clear buffer first */
250         free_anim_copybuf();
251         
252         /* filter data */
253         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
254         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
255         
256         /* copy keyframes */
257         ok= copy_animedit_keys(ac, &anim_data);
258         
259         /* clean up */
260         BLI_freelistN(&anim_data);
261
262         return ok;
263 }
264
265
266 static short paste_action_keys (bAnimContext *ac)
267 {       
268         ListBase anim_data = {NULL, NULL};
269         int filter, ok=0;
270         
271         /* filter data */
272         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
273         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
274         
275         /* paste keyframes */
276         ok= paste_animedit_keys(ac, &anim_data);
277         
278         /* clean up */
279         BLI_freelistN(&anim_data);
280
281         return ok;
282 }
283
284 /* ------------------- */
285
286 static int actkeys_copy_exec(bContext *C, wmOperator *op)
287 {
288         bAnimContext ac;
289         
290         /* get editor data */
291         if (ANIM_animdata_get_context(C, &ac) == 0)
292                 return OPERATOR_CANCELLED;
293         
294         /* copy keyframes */
295         if (ac.datatype == ANIMCONT_GPENCIL) {
296                 // FIXME...
297         }
298         else {
299                 if (copy_action_keys(&ac)) {    
300                         BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
301                         return OPERATOR_CANCELLED;
302                 }
303         }
304         
305         /* set notifier that things have changed */
306         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
307         
308         return OPERATOR_FINISHED;
309 }
310  
311 void ACT_OT_copy (wmOperatorType *ot)
312 {
313         /* identifiers */
314         ot->name= "Copy Keyframes";
315         ot->idname= "ACT_OT_copy";
316         
317         /* api callbacks */
318         ot->exec= actkeys_copy_exec;
319         ot->poll= ED_operator_action_active;
320         
321         /* flags */
322         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
323 }
324
325
326
327 static int actkeys_paste_exec(bContext *C, wmOperator *op)
328 {
329         bAnimContext ac;
330         
331         /* get editor data */
332         if (ANIM_animdata_get_context(C, &ac) == 0)
333                 return OPERATOR_CANCELLED;
334         
335         /* paste keyframes */
336         if (ac.datatype == ANIMCONT_GPENCIL) {
337                 // FIXME...
338         }
339         else {
340                 if (paste_action_keys(&ac)) {
341                         BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
342                         return OPERATOR_CANCELLED;
343                 }
344         }
345         
346         /* validate keyframes after editing */
347         ANIM_editkeyframes_refresh(&ac);
348         
349         /* set notifier that things have changed */
350         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
351         
352         return OPERATOR_FINISHED;
353 }
354  
355 void ACT_OT_paste (wmOperatorType *ot)
356 {
357         /* identifiers */
358         ot->name= "Paste Keyframes";
359         ot->idname= "ACT_OT_paste";
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, 0);
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         /* get snapping mode */
437         mode= RNA_enum_get(op->ptr, "type");
438         
439         /* snap keyframes */
440         insert_action_keys(&ac, mode);
441         
442         /* validate keyframes after editing */
443         ANIM_editkeyframes_refresh(&ac);
444         
445         /* set notifier that things have changed */
446         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
447         
448         return OPERATOR_FINISHED;
449 }
450
451 void ACT_OT_insert (wmOperatorType *ot)
452 {
453         /* identifiers */
454         ot->name= "Insert Keyframes";
455         ot->idname= "ACT_OT_insert";
456         
457         /* api callbacks */
458         ot->invoke= WM_menu_invoke;
459         ot->exec= actkeys_insertkey_exec;
460         ot->poll= ED_operator_action_active;
461         
462         /* flags */
463         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
464         
465         /* id-props */
466         RNA_def_enum(ot->srna, "type", prop_actkeys_insertkey_types, 0, "Type", "");
467 }
468
469 /* ******************** Duplicate Keyframes Operator ************************* */
470
471 static void duplicate_action_keys (bAnimContext *ac)
472 {
473         ListBase anim_data = {NULL, NULL};
474         bAnimListElem *ale;
475         int filter;
476         
477         /* filter data */
478         if (ac->datatype == ANIMCONT_GPENCIL)
479                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
480         else
481                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
482         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
483         
484         /* loop through filtered data and delete selected keys */
485         for (ale= anim_data.first; ale; ale= ale->next) {
486                 //if (ale->type == ANIMTYPE_GPLAYER)
487                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
488                 //else
489                         duplicate_fcurve_keys((FCurve *)ale->key_data);
490         }
491         
492         /* free filtered list */
493         BLI_freelistN(&anim_data);
494 }
495
496 /* ------------------- */
497
498 static int actkeys_duplicate_exec(bContext *C, wmOperator *op)
499 {
500         bAnimContext ac;
501         
502         /* get editor data */
503         if (ANIM_animdata_get_context(C, &ac) == 0)
504                 return OPERATOR_CANCELLED;
505                 
506         /* duplicate keyframes */
507         duplicate_action_keys(&ac);
508         
509         /* validate keyframes after editing */
510         ANIM_editkeyframes_refresh(&ac);
511         
512         /* set notifier that things have changed */
513         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
514         
515         return OPERATOR_FINISHED; // xxx - start transform
516 }
517
518 static int actkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
519 {
520         actkeys_duplicate_exec(C, op);
521         
522         RNA_int_set(op->ptr, "mode", TFM_TIME_TRANSLATE);
523         WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
524
525         return OPERATOR_FINISHED;
526 }
527  
528 void ACT_OT_duplicate (wmOperatorType *ot)
529 {
530         /* identifiers */
531         ot->name= "Duplicate Keyframes";
532         ot->idname= "ACT_OT_duplicate";
533         
534         /* api callbacks */
535         ot->invoke= actkeys_duplicate_invoke;
536         ot->exec= actkeys_duplicate_exec;
537         ot->poll= ED_operator_action_active;
538         
539         /* flags */
540         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
541         
542         /* to give to transform */
543         RNA_def_int(ot->srna, "mode", TFM_TIME_TRANSLATE, 0, INT_MAX, "Mode", "", 0, INT_MAX);
544 }
545
546 /* ******************** Delete Keyframes Operator ************************* */
547
548 static void delete_action_keys (bAnimContext *ac)
549 {
550         ListBase anim_data = {NULL, NULL};
551         bAnimListElem *ale;
552         int filter;
553         
554         /* filter data */
555         if (ac->datatype == ANIMCONT_GPENCIL)
556                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
557         else
558                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
559         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
560         
561         /* loop through filtered data and delete selected keys */
562         for (ale= anim_data.first; ale; ale= ale->next) {
563                 //if (ale->type == ANIMTYPE_GPLAYER)
564                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
565                 //else
566                         delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
567         }
568         
569         /* free filtered list */
570         BLI_freelistN(&anim_data);
571 }
572
573 /* ------------------- */
574
575 static int actkeys_delete_exec(bContext *C, wmOperator *op)
576 {
577         bAnimContext ac;
578         
579         /* get editor data */
580         if (ANIM_animdata_get_context(C, &ac) == 0)
581                 return OPERATOR_CANCELLED;
582                 
583         /* delete keyframes */
584         delete_action_keys(&ac);
585         
586         /* validate keyframes after editing */
587         ANIM_editkeyframes_refresh(&ac);
588         
589         /* set notifier that things have changed */
590         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
591         
592         return OPERATOR_FINISHED;
593 }
594  
595 void ACT_OT_delete (wmOperatorType *ot)
596 {
597         /* identifiers */
598         ot->name= "Delete Keyframes";
599         ot->idname= "ACT_OT_delete";
600         
601         /* api callbacks */
602         ot->invoke= WM_operator_confirm;
603         ot->exec= actkeys_delete_exec;
604         ot->poll= ED_operator_action_active;
605         
606         /* flags */
607         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
608 }
609
610 /* ******************** Clean Keyframes Operator ************************* */
611
612 static void clean_action_keys (bAnimContext *ac, float thresh)
613 {       
614         ListBase anim_data = {NULL, NULL};
615         bAnimListElem *ale;
616         int filter;
617         
618         /* filter data */
619         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
620         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
621         
622         /* loop through filtered data and clean curves */
623         for (ale= anim_data.first; ale; ale= ale->next)
624                 clean_fcurve((FCurve *)ale->key_data, thresh);
625         
626         /* free temp data */
627         BLI_freelistN(&anim_data);
628 }
629
630 /* ------------------- */
631
632 static int actkeys_clean_exec(bContext *C, wmOperator *op)
633 {
634         bAnimContext ac;
635         float thresh;
636         
637         /* get editor data */
638         if (ANIM_animdata_get_context(C, &ac) == 0)
639                 return OPERATOR_CANCELLED;
640         if (ac.datatype == ANIMCONT_GPENCIL)
641                 return OPERATOR_PASS_THROUGH;
642                 
643         /* get cleaning threshold */
644         thresh= RNA_float_get(op->ptr, "threshold");
645         
646         /* clean keyframes */
647         clean_action_keys(&ac, thresh);
648         
649         /* validate keyframes after editing */
650         ANIM_editkeyframes_refresh(&ac);
651         
652         /* set notifier that things have changed */
653         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
654         
655         return OPERATOR_FINISHED;
656 }
657  
658 void ACT_OT_clean (wmOperatorType *ot)
659 {
660         /* identifiers */
661         ot->name= "Clean Keyframes";
662         ot->idname= "ACT_OT_clean";
663         
664         /* api callbacks */
665         //ot->invoke=  // XXX we need that number popup for this! 
666         ot->exec= actkeys_clean_exec;
667         ot->poll= ED_operator_action_active;
668         
669         /* flags */
670         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
671         
672         /* properties */
673         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
674 }
675
676 /* ******************** Sample Keyframes Operator *********************** */
677
678 /* little cache for values... */
679 typedef struct tempFrameValCache {
680         float frame, val;
681 } tempFrameValCache;
682
683 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
684 static void sample_action_keys (bAnimContext *ac)
685 {       
686         ListBase anim_data = {NULL, NULL};
687         bAnimListElem *ale;
688         int filter;
689         
690         /* filter data */
691         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
692         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
693         
694         /* loop through filtered data and add keys between selected keyframes on every frame  */
695         for (ale= anim_data.first; ale; ale= ale->next) {
696                 FCurve *fcu= (FCurve *)ale->key_data;
697                 BezTriple *bezt, *start=NULL, *end=NULL;
698                 tempFrameValCache *value_cache, *fp;
699                 int sfra, range;
700                 int i, n;
701                 
702                 /* find selected keyframes... once pair has been found, add keyframes  */
703                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
704                         /* check if selected, and which end this is */
705                         if (BEZSELECTED(bezt)) {
706                                 if (start) {
707                                         /* set end */
708                                         end= bezt;
709                                         
710                                         /* cache values then add keyframes using these values, as adding
711                                          * keyframes while sampling will affect the outcome...
712                                          */
713                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
714                                         sfra= (int)( floor(start->vec[1][0]) );
715                                         
716                                         if (range) {
717                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
718                                                 
719                                                 /*      sample values   */
720                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
721                                                         fp->frame= (float)(sfra + n);
722                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
723                                                 }
724                                                 
725                                                 /*      add keyframes with these        */
726                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
727                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
728                                                 }
729                                                 
730                                                 /* free temp cache */
731                                                 MEM_freeN(value_cache);
732                                                 
733                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
734                                                 bezt = fcu->bezt + i + range - 1;
735                                                 i += (range - 1);
736                                         }
737                                         
738                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
739                                         start= bezt;
740                                         end= NULL;
741                                 }
742                                 else {
743                                         /* just set start keyframe */
744                                         start= bezt;
745                                         end= NULL;
746                                 }
747                         }
748                 }
749                 
750                 /* recalculate channel's handles? */
751                 calchandles_fcurve(fcu);
752         }
753         
754         /* admin and redraws */
755         BLI_freelistN(&anim_data);
756 }
757
758 /* ------------------- */
759
760 static int actkeys_sample_exec(bContext *C, wmOperator *op)
761 {
762         bAnimContext ac;
763         
764         /* get editor data */
765         if (ANIM_animdata_get_context(C, &ac) == 0)
766                 return OPERATOR_CANCELLED;
767         if (ac.datatype == ANIMCONT_GPENCIL)
768                 return OPERATOR_PASS_THROUGH;
769         
770         /* sample keyframes */
771         sample_action_keys(&ac);
772         
773         /* validate keyframes after editing */
774         ANIM_editkeyframes_refresh(&ac);
775         
776         /* set notifier that things have changed */
777         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
778         
779         return OPERATOR_FINISHED;
780 }
781  
782 void ACT_OT_sample (wmOperatorType *ot)
783 {
784         /* identifiers */
785         ot->name= "Sample Keyframes";
786         ot->idname= "ACT_OT_sample";
787         
788         /* api callbacks */
789         ot->exec= actkeys_sample_exec;
790         ot->poll= ED_operator_action_active;
791         
792         /* flags */
793         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
794 }
795
796 /* ************************************************************************** */
797 /* SETTINGS STUFF */
798
799 /* ******************** Set Extrapolation-Type Operator *********************** */
800
801 /* defines for set extrapolation-type for selected keyframes tool */
802 EnumPropertyItem prop_actkeys_expo_types[] = {
803         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
804         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
805         {0, NULL, 0, NULL, NULL}
806 };
807
808 /* this function is responsible for setting extrapolation mode for keyframes */
809 static void setexpo_action_keys(bAnimContext *ac, short mode) 
810 {
811         ListBase anim_data = {NULL, NULL};
812         bAnimListElem *ale;
813         int filter;
814         
815         /* filter data */
816         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
817         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
818         
819         /* loop through setting mode per F-Curve */
820         for (ale= anim_data.first; ale; ale= ale->next) {
821                 FCurve *fcu= (FCurve *)ale->data;
822                 fcu->extend= mode;
823         }
824         
825         /* cleanup */
826         BLI_freelistN(&anim_data);
827 }
828
829 /* ------------------- */
830
831 static int actkeys_expo_exec(bContext *C, wmOperator *op)
832 {
833         bAnimContext ac;
834         short mode;
835         
836         /* get editor data */
837         if (ANIM_animdata_get_context(C, &ac) == 0)
838                 return OPERATOR_CANCELLED;
839         if (ac.datatype == ANIMCONT_GPENCIL) 
840                 return OPERATOR_PASS_THROUGH;
841                 
842         /* get handle setting mode */
843         mode= RNA_enum_get(op->ptr, "type");
844         
845         /* set handle type */
846         setexpo_action_keys(&ac, mode);
847         
848         /* validate keyframes after editing */
849         ANIM_editkeyframes_refresh(&ac);
850         
851         /* set notifier that things have changed */
852         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
853         
854         return OPERATOR_FINISHED;
855 }
856  
857 void ACT_OT_extrapolation_type (wmOperatorType *ot)
858 {
859         /* identifiers */
860         ot->name= "Set Keyframe Extrapolation";
861         ot->idname= "ACT_OT_extrapolation_type";
862         
863         /* api callbacks */
864         ot->invoke= WM_menu_invoke;
865         ot->exec= actkeys_expo_exec;
866         ot->poll= ED_operator_action_active;
867         
868         /* flags */
869         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
870         
871         /* id-props */
872         RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
873 }
874
875 /* ******************** Set Interpolation-Type Operator *********************** */
876
877 /* this function is responsible for setting interpolation mode for keyframes */
878 static void setipo_action_keys(bAnimContext *ac, short mode) 
879 {
880         ListBase anim_data = {NULL, NULL};
881         bAnimListElem *ale;
882         int filter;
883         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
884         
885         /* filter data */
886         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
887         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
888         
889         /* loop through setting BezTriple interpolation
890          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
891          */
892         for (ale= anim_data.first; ale; ale= ale->next)
893                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
894         
895         /* cleanup */
896         BLI_freelistN(&anim_data);
897 }
898
899 /* ------------------- */
900
901 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
902 {
903         bAnimContext ac;
904         short mode;
905         
906         /* get editor data */
907         if (ANIM_animdata_get_context(C, &ac) == 0)
908                 return OPERATOR_CANCELLED;
909         if (ac.datatype == ANIMCONT_GPENCIL) 
910                 return OPERATOR_PASS_THROUGH;
911                 
912         /* get handle setting mode */
913         mode= RNA_enum_get(op->ptr, "type");
914         
915         /* set handle type */
916         setipo_action_keys(&ac, mode);
917         
918         /* validate keyframes after editing */
919         ANIM_editkeyframes_refresh(&ac);
920         
921         /* set notifier that things have changed */
922         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
923         
924         return OPERATOR_FINISHED;
925 }
926  
927 void ACT_OT_interpolation_type (wmOperatorType *ot)
928 {
929         /* identifiers */
930         ot->name= "Set Keyframe Interpolation";
931         ot->idname= "ACT_OT_interpolation_type";
932         
933         /* api callbacks */
934         ot->invoke= WM_menu_invoke;
935         ot->exec= actkeys_ipo_exec;
936         ot->poll= ED_operator_action_active;
937         
938         /* flags */
939         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
940         
941         /* id-props */
942         RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
943 }
944
945 /* ******************** Set Handle-Type Operator *********************** */
946
947 /* this function is responsible for setting handle-type of selected keyframes */
948 static void sethandles_action_keys(bAnimContext *ac, short mode) 
949 {
950         ListBase anim_data = {NULL, NULL};
951         bAnimListElem *ale;
952         int filter;
953         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
954         
955         /* filter data */
956         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
957         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
958         
959         /* loop through setting flags for handles 
960          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
961          */
962         for (ale= anim_data.first; ale; ale= ale->next) {
963                 if (mode == -1) {       
964                         BeztEditFunc toggle_cb;
965                         
966                         /* check which type of handle to set (free or aligned) 
967                          *      - check here checks for handles with free alignment already
968                          */
969                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
970                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
971                         else
972                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
973                                 
974                         /* set handle-type */
975                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
976                 }
977                 else {
978                         /* directly set handle-type */
979                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
980                 }
981         }
982         
983         /* cleanup */
984         BLI_freelistN(&anim_data);
985 }
986
987 /* ------------------- */
988
989 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
990 {
991         bAnimContext ac;
992         short mode;
993         
994         /* get editor data */
995         if (ANIM_animdata_get_context(C, &ac) == 0)
996                 return OPERATOR_CANCELLED;
997         if (ac.datatype == ANIMCONT_GPENCIL) 
998                 return OPERATOR_PASS_THROUGH;
999                 
1000         /* get handle setting mode */
1001         mode= RNA_enum_get(op->ptr, "type");
1002         
1003         /* set handle type */
1004         sethandles_action_keys(&ac, mode);
1005         
1006         /* validate keyframes after editing */
1007         ANIM_editkeyframes_refresh(&ac);
1008         
1009         /* set notifier that things have changed */
1010         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1011         
1012         return OPERATOR_FINISHED;
1013 }
1014  
1015 void ACT_OT_handle_type (wmOperatorType *ot)
1016 {
1017         /* identifiers */
1018         ot->name= "Set Keyframe Handle Type";
1019         ot->idname= "ACT_OT_handle_type";
1020         
1021         /* api callbacks */
1022         ot->invoke= WM_menu_invoke;
1023         ot->exec= actkeys_handletype_exec;
1024         ot->poll= ED_operator_action_active;
1025         
1026         /* flags */
1027         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1028         
1029         /* id-props */
1030         RNA_def_enum(ot->srna, "type", beztriple_handle_type_items, 0, "Type", "");
1031 }
1032
1033 /* ************************************************************************** */
1034 /* TRANSFORM STUFF */
1035
1036 /* ***************** Jump to Selected Frames Operator *********************** */
1037
1038 /* snap current-frame indicator to 'average time' of selected keyframe */
1039 static int actkeys_framejump_exec(bContext *C, wmOperator *op)
1040 {
1041         bAnimContext ac;
1042         ListBase anim_data= {NULL, NULL};
1043         bAnimListElem *ale;
1044         int filter;
1045         BeztEditData bed;
1046         
1047         /* get editor data */
1048         if (ANIM_animdata_get_context(C, &ac) == 0)
1049                 return OPERATOR_CANCELLED;
1050         
1051         /* init edit data */
1052         memset(&bed, 0, sizeof(BeztEditData));
1053         
1054         /* loop over action data, averaging values */
1055         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
1056         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1057         
1058         for (ale= anim_data.first; ale; ale= ale->next) {
1059                 AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
1060                 
1061                 if (adt) {
1062                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1063                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1064                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1065                 }
1066                 else
1067                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1068         }
1069         
1070         BLI_freelistN(&anim_data);
1071         
1072         /* set the new current frame value, based on the average time */
1073         if (bed.i1) {
1074                 Scene *scene= ac.scene;
1075                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1076         }
1077         
1078         /* set notifier that things have changed */
1079         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1080         
1081         return OPERATOR_FINISHED;
1082 }
1083
1084 void ACT_OT_frame_jump (wmOperatorType *ot)
1085 {
1086         /* identifiers */
1087         ot->name= "Jump to Frame";
1088         ot->idname= "ACT_OT_frame_jump";
1089         
1090         /* api callbacks */
1091         ot->exec= actkeys_framejump_exec;
1092         ot->poll= ED_operator_action_active;
1093         
1094         /* flags */
1095         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1096 }
1097
1098 /* ******************** Snap Keyframes Operator *********************** */
1099
1100 /* defines for snap keyframes tool */
1101 EnumPropertyItem prop_actkeys_snap_types[] = {
1102         {ACTKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
1103         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
1104         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
1105         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
1106         {0, NULL, 0, NULL, NULL}
1107 };
1108
1109 /* this function is responsible for snapping keyframes to frame-times */
1110 static void snap_action_keys(bAnimContext *ac, short mode) 
1111 {
1112         ListBase anim_data = {NULL, NULL};
1113         bAnimListElem *ale;
1114         int filter;
1115         
1116         BeztEditData bed;
1117         BeztEditFunc edit_cb;
1118         
1119         /* filter data */
1120         if (ac->datatype == ANIMCONT_GPENCIL)
1121                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1122         else
1123                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1124         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1125         
1126         /* get beztriple editing callbacks */
1127         edit_cb= ANIM_editkeyframes_snap(mode);
1128         
1129         memset(&bed, 0, sizeof(BeztEditData)); 
1130         bed.scene= ac->scene;
1131         if (mode == ACTKEYS_SNAP_NEAREST_MARKER) {
1132                 bed.list.first= (ac->markers) ? ac->markers->first : NULL;
1133                 bed.list.last= (ac->markers) ? ac->markers->last : NULL;
1134         }
1135         
1136         /* snap keyframes */
1137         for (ale= anim_data.first; ale; ale= ale->next) {
1138                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1139                 
1140                 if (adt) {
1141                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1142                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1143                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1144                 }
1145                 //else if (ale->type == ACTTYPE_GPLAYER)
1146                 //      snap_gplayer_frames(ale->data, mode);
1147                 else 
1148                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1149         }
1150         BLI_freelistN(&anim_data);
1151 }
1152
1153 /* ------------------- */
1154
1155 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1156 {
1157         bAnimContext ac;
1158         short mode;
1159         
1160         /* get editor data */
1161         if (ANIM_animdata_get_context(C, &ac) == 0)
1162                 return OPERATOR_CANCELLED;
1163                 
1164         /* get snapping mode */
1165         mode= RNA_enum_get(op->ptr, "type");
1166         
1167         /* snap keyframes */
1168         snap_action_keys(&ac, mode);
1169         
1170         /* validate keyframes after editing */
1171         ANIM_editkeyframes_refresh(&ac);
1172         
1173         /* set notifier that things have changed */
1174         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1175         
1176         return OPERATOR_FINISHED;
1177 }
1178  
1179 void ACT_OT_snap (wmOperatorType *ot)
1180 {
1181         /* identifiers */
1182         ot->name= "Snap Keys";
1183         ot->idname= "ACT_OT_snap";
1184         
1185         /* api callbacks */
1186         ot->invoke= WM_menu_invoke;
1187         ot->exec= actkeys_snap_exec;
1188         ot->poll= ED_operator_action_active;
1189         
1190         /* flags */
1191         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1192         
1193         /* id-props */
1194         RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1195 }
1196
1197 /* ******************** Mirror Keyframes Operator *********************** */
1198
1199 /* defines for mirror keyframes tool */
1200 EnumPropertyItem prop_actkeys_mirror_types[] = {
1201         {ACTKEYS_MIRROR_CFRA, "CFRA", 0, "Current frame", ""},
1202         {ACTKEYS_MIRROR_YAXIS, "YAXIS", 0, "Vertical Axis", ""},
1203         {ACTKEYS_MIRROR_XAXIS, "XAXIS", 0, "Horizontal Axis", ""},
1204         {ACTKEYS_MIRROR_MARKER, "MARKER", 0, "First Selected Marker", ""},
1205         {0, NULL, 0, NULL, NULL}
1206 };
1207
1208 /* this function is responsible for mirroring keyframes */
1209 static void mirror_action_keys(bAnimContext *ac, short mode) 
1210 {
1211         ListBase anim_data = {NULL, NULL};
1212         bAnimListElem *ale;
1213         int filter;
1214         
1215         BeztEditData bed;
1216         BeztEditFunc edit_cb;
1217         
1218         /* get beztriple editing callbacks */
1219         edit_cb= ANIM_editkeyframes_mirror(mode);
1220         
1221         memset(&bed, 0, sizeof(BeztEditData)); 
1222         bed.scene= ac->scene;
1223         
1224         /* for 'first selected marker' mode, need to find first selected marker first! */
1225         // XXX should this be made into a helper func in the API?
1226         if (mode == ACTKEYS_MIRROR_MARKER) {
1227                 TimeMarker *marker= NULL;
1228                 
1229                 /* find first selected marker */
1230                 if (ac->markers) {
1231                         for (marker= ac->markers->first; marker; marker=marker->next) {
1232                                 if (marker->flag & SELECT) {
1233                                         break;
1234                                 }
1235                         }
1236                 }
1237                 
1238                 /* store marker's time (if available) */
1239                 if (marker)
1240                         bed.f1= (float)marker->frame;
1241                 else
1242                         return;
1243         }
1244         
1245         /* filter data */
1246         if (ac->datatype == ANIMCONT_GPENCIL)
1247                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1248         else
1249                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1250         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1251         
1252         /* mirror keyframes */
1253         for (ale= anim_data.first; ale; ale= ale->next) {
1254                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1255                 
1256                 if (adt) {
1257                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1258                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1259                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1260                 }
1261                 //else if (ale->type == ACTTYPE_GPLAYER)
1262                 //      snap_gplayer_frames(ale->data, mode);
1263                 else 
1264                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1265         }
1266         BLI_freelistN(&anim_data);
1267 }
1268
1269 /* ------------------- */
1270
1271 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1272 {
1273         bAnimContext ac;
1274         short mode;
1275         
1276         /* get editor data */
1277         if (ANIM_animdata_get_context(C, &ac) == 0)
1278                 return OPERATOR_CANCELLED;
1279                 
1280         /* get mirroring mode */
1281         mode= RNA_enum_get(op->ptr, "type");
1282         
1283         /* mirror keyframes */
1284         mirror_action_keys(&ac, mode);
1285         
1286         /* validate keyframes after editing */
1287         ANIM_editkeyframes_refresh(&ac);
1288         
1289         /* set notifier that things have changed */
1290         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1291         
1292         return OPERATOR_FINISHED;
1293 }
1294  
1295 void ACT_OT_mirror (wmOperatorType *ot)
1296 {
1297         /* identifiers */
1298         ot->name= "Mirror Keys";
1299         ot->idname= "ACT_OT_mirror";
1300         
1301         /* api callbacks */
1302         ot->invoke= WM_menu_invoke;
1303         ot->exec= actkeys_mirror_exec;
1304         ot->poll= ED_operator_action_active;
1305         
1306         /* flags */
1307         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1308         
1309         /* id-props */
1310         RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1311 }
1312
1313 /* ************************************************************************** */