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