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