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