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