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