Merging r40960 through r40989 from trunk into soc-2011-tomato
[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         //      Commented it, was breaking things (eg. the "auto preview range" tool).
237         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_SEL *//*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
238         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
239         
240         /* set large values to try to override */
241         *min= 999999999.0f;
242         *max= -999999999.0f;
243         
244         /* check if any channels to set range with */
245         if (anim_data.first) {
246                 /* go through channels, finding max extents */
247                 for (ale= anim_data.first; ale; ale= ale->next) {
248                         AnimData *adt= ANIM_nla_mapping_get(ac, ale);
249                         if (ale->datatype == ALE_GPFRAME) {
250                                 bGPDlayer *gpl= ale->data;
251                                 bGPDframe *gpf;
252
253                                 /* find gp-frame which is less than or equal to cframe */
254                                 for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
255                                         *min= MIN2(*min, gpf->framenum);
256                                         *max= MAX2(*max, gpf->framenum);
257                                 }
258                         }
259                         else {
260                                 FCurve *fcu= (FCurve *)ale->key_data;
261                                 float tmin, tmax;
262
263                                 /* get range and apply necessary scaling before processing */
264                                 calc_fcurve_range(fcu, &tmin, &tmax, onlySel);
265
266                                 if (adt) {
267                                         tmin= BKE_nla_tweakedit_remap(adt, tmin, NLATIME_CONVERT_MAP);
268                                         tmax= BKE_nla_tweakedit_remap(adt, tmax, NLATIME_CONVERT_MAP);
269                                 }
270
271                                 /* try to set cur using these values, if they're more extreme than previously set values */
272                                 *min= MIN2(*min, tmin);
273                                 *max= MAX2(*max, tmax);
274                         }
275                 }
276                 
277                 /* free memory */
278                 BLI_freelistN(&anim_data);
279         }
280         else {
281                 /* set default range */
282                 if (ac->scene) {
283                         *min= (float)ac->scene->r.sfra;
284                         *max= (float)ac->scene->r.efra;
285                 }
286                 else {
287                         *min= -5;
288                         *max= 100;
289                 }
290         }
291 }
292
293 /* ****************** Automatic Preview-Range Operator ****************** */
294
295 static int actkeys_previewrange_exec(bContext *C, wmOperator *UNUSED(op))
296 {
297         bAnimContext ac;
298         Scene *scene;
299         float min, max;
300         
301         /* get editor data */
302         if (ANIM_animdata_get_context(C, &ac) == 0)
303                 return OPERATOR_CANCELLED;
304         if (ac.scene == NULL)
305                 return OPERATOR_CANCELLED;
306         else
307                 scene= ac.scene;
308         
309         /* set the range directly */
310         get_keyframe_extents(&ac, &min, &max, FALSE);
311         scene->r.flag |= SCER_PRV_RANGE;
312         scene->r.psfra= (int)floor(min + 0.5f);
313         scene->r.pefra= (int)floor(max + 0.5f);
314         
315         /* set notifier that things have changed */
316         // XXX err... there's nothing for frame ranges yet, but this should do fine too
317         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
318         
319         return OPERATOR_FINISHED;
320 }
321  
322 void ACTION_OT_previewrange_set (wmOperatorType *ot)
323 {
324         /* identifiers */
325         ot->name= "Auto-Set Preview Range";
326         ot->idname= "ACTION_OT_previewrange_set";
327         ot->description= "Set Preview Range based on extents of selected Keyframes";
328         
329         /* api callbacks */
330         ot->exec= actkeys_previewrange_exec;
331         ot->poll= ED_operator_action_active;
332         
333         /* flags */
334         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
335 }
336
337 /* ****************** View-All Operator ****************** */
338
339 static int actkeys_viewall(bContext *C, const short onlySel)
340 {
341         bAnimContext ac;
342         View2D *v2d;
343         float extra;
344         
345         /* get editor data */
346         if (ANIM_animdata_get_context(C, &ac) == 0)
347                 return OPERATOR_CANCELLED;
348         v2d= &ac.ar->v2d;
349         
350         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
351         get_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, onlySel);
352         
353         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
354         v2d->cur.xmin -= extra;
355         v2d->cur.xmax += extra;
356         
357         /* set vertical range */
358         v2d->cur.ymax= 0.0f;
359         v2d->cur.ymin= (float)-(v2d->mask.ymax - v2d->mask.ymin);
360         
361         /* do View2D syncing */
362         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
363         
364         /* just redraw this view */
365         ED_area_tag_redraw(CTX_wm_area(C));
366         
367         return OPERATOR_FINISHED;
368 }
369
370 /* ......... */
371
372 static int actkeys_viewall_exec(bContext *C, wmOperator *UNUSED(op))
373 {       
374         /* whole range */
375         return actkeys_viewall(C, FALSE);
376 }
377
378 static int actkeys_viewsel_exec(bContext *C, wmOperator *UNUSED(op))
379 {
380         /* only selected */
381         return actkeys_viewall(C, TRUE);
382 }
383  
384 void ACTION_OT_view_all (wmOperatorType *ot)
385 {
386         /* identifiers */
387         ot->name= "View All";
388         ot->idname= "ACTION_OT_view_all";
389         ot->description= "Reset viewable area to show full keyframe range";
390         
391         /* api callbacks */
392         ot->exec= actkeys_viewall_exec;
393         ot->poll= ED_operator_action_active;
394         
395         /* flags */
396         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
397 }
398
399 void ACTION_OT_view_selected (wmOperatorType *ot)
400 {
401         /* identifiers */
402         ot->name= "View Selected";
403         ot->idname= "ACTION_OT_view_selected";
404         ot->description= "Reset viewable area to show selected keyframes range";
405         
406         /* api callbacks */
407         ot->exec= actkeys_viewsel_exec;
408         ot->poll= ED_operator_action_active;
409         
410         /* flags */
411         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
412 }
413
414 /* ************************************************************************** */
415 /* GENERAL STUFF */
416
417 /* ******************** Copy/Paste Keyframes Operator ************************* */
418 /* NOTE: the backend code for this is shared with the graph editor */
419
420 static short copy_action_keys (bAnimContext *ac)
421 {       
422         ListBase anim_data = {NULL, NULL};
423         int filter, ok=0;
424         
425         /* clear buffer first */
426         free_anim_copybuf();
427         
428         /* filter data */
429         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
430         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
431         
432         /* copy keyframes */
433         ok= copy_animedit_keys(ac, &anim_data);
434         
435         /* clean up */
436         BLI_freelistN(&anim_data);
437
438         return ok;
439 }
440
441
442 static short paste_action_keys (bAnimContext *ac,
443         const eKeyPasteOffset offset_mode, const eKeyMergeMode merge_mode)
444 {       
445         ListBase anim_data = {NULL, NULL};
446         int filter, ok=0;
447         
448         /* filter data */
449         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
450         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
451         
452         /* paste keyframes */
453         ok= paste_animedit_keys(ac, &anim_data, offset_mode, merge_mode);
454         
455         /* clean up */
456         BLI_freelistN(&anim_data);
457
458         return ok;
459 }
460
461 /* ------------------- */
462
463 static int actkeys_copy_exec(bContext *C, wmOperator *op)
464 {
465         bAnimContext ac;
466         
467         /* get editor data */
468         if (ANIM_animdata_get_context(C, &ac) == 0)
469                 return OPERATOR_CANCELLED;
470         
471         /* copy keyframes */
472         if (ac.datatype == ANIMCONT_GPENCIL) {
473                 // FIXME...
474                 BKE_report(op->reports, RPT_ERROR, "Keyframe pasting is not available for Grease Pencil mode");
475                 return OPERATOR_CANCELLED;
476         }
477         else {
478                 if (copy_action_keys(&ac)) {    
479                         BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
480                         return OPERATOR_CANCELLED;
481                 }
482         }
483         
484         return OPERATOR_FINISHED;
485 }
486  
487 void ACTION_OT_copy (wmOperatorType *ot)
488 {
489         /* identifiers */
490         ot->name= "Copy Keyframes";
491         ot->idname= "ACTION_OT_copy";
492         ot->description= "Copy selected keyframes to the copy/paste buffer";
493         
494         /* api callbacks */
495 //      ot->invoke= WM_operator_props_popup; // better wait for graph redo panel
496         ot->exec= actkeys_copy_exec;
497         ot->poll= ED_operator_action_active;
498
499         /* flags */
500         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
501 }
502
503 static int actkeys_paste_exec(bContext *C, wmOperator *op)
504 {
505         bAnimContext ac;
506
507         const eKeyPasteOffset offset_mode= RNA_enum_get(op->ptr, "offset");
508         const eKeyMergeMode merge_mode= RNA_enum_get(op->ptr, "merge");
509         
510         /* get editor data */
511         if (ANIM_animdata_get_context(C, &ac) == 0)
512                 return OPERATOR_CANCELLED;
513         
514         if (ac.reports==NULL) {
515                 ac.reports= op->reports;
516         }
517         
518         /* paste keyframes */
519         if (ac.datatype == ANIMCONT_GPENCIL) {
520                 // FIXME...
521                 BKE_report(op->reports, RPT_ERROR, "Keyframe pasting is not available for Grease Pencil mode");
522                 return OPERATOR_CANCELLED;
523         }
524         else {
525                 if (paste_action_keys(&ac, offset_mode, merge_mode)) {
526                         BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
527                         return OPERATOR_CANCELLED;
528                 }
529         }
530         
531         /* validate keyframes after editing */
532         ANIM_editkeyframes_refresh(&ac);
533         
534         /* set notifier that keyframes have changed */
535         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
536         
537         return OPERATOR_FINISHED;
538 }
539  
540 void ACTION_OT_paste (wmOperatorType *ot)
541 {
542         /* identifiers */
543         ot->name= "Paste Keyframes";
544         ot->idname= "ACTION_OT_paste";
545         ot->description= "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame";
546         
547         /* api callbacks */
548         ot->exec= actkeys_paste_exec;
549         ot->poll= ED_operator_action_active;
550         
551         /* flags */
552         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
553
554         RNA_def_enum(ot->srna, "offset", keyframe_paste_offset_items, KEYFRAME_PASTE_OFFSET_CFRA_START, "Offset", "Paste time offset of keys");
555         RNA_def_enum(ot->srna, "merge", keyframe_paste_merge_items, KEYFRAME_PASTE_MERGE_MIX, "Type", "Method of merging pasted keys and existing");
556 }
557
558 /* ******************** Insert Keyframes Operator ************************* */
559
560 /* defines for insert keyframes tool */
561 static EnumPropertyItem prop_actkeys_insertkey_types[] = {
562         {1, "ALL", 0, "All Channels", ""},
563         {2, "SEL", 0, "Only Selected Channels", ""},
564         {3, "GROUP", 0, "In Active Group", ""}, // xxx not in all cases
565         {0, NULL, 0, NULL, NULL}
566 };
567
568 /* this function is responsible for snapping keyframes to frame-times */
569 static void insert_action_keys(bAnimContext *ac, short mode) 
570 {
571         ListBase anim_data = {NULL, NULL};
572         bAnimListElem *ale;
573         int filter;
574         
575         ReportList *reports = ac->reports;
576         Scene *scene= ac->scene;
577         short flag = 0;
578         
579         /* filter data */
580         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
581         if (mode == 2)                  filter |= ANIMFILTER_SEL;
582         else if (mode == 3)     filter |= ANIMFILTER_ACTGROUPED;
583         
584         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
585         
586         /* init keyframing flag */
587         flag = ANIM_get_keyframing_flags(scene, 1);
588         
589         /* insert keyframes */
590         for (ale= anim_data.first; ale; ale= ale->next) {
591                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
592                 FCurve *fcu= (FCurve *)ale->key_data;
593                 float cfra;
594                 
595                 /* adjust current frame for NLA-scaling */
596                 if (adt)
597                         cfra= BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
598                 else 
599                         cfra= (float)CFRA;
600                         
601                 /* if there's an id */
602                 if (ale->id)
603                         insert_keyframe(reports, ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
604                 else
605                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
606         }
607         
608         BLI_freelistN(&anim_data);
609 }
610
611 /* ------------------- */
612
613 static int actkeys_insertkey_exec(bContext *C, wmOperator *op)
614 {
615         bAnimContext ac;
616         short mode;
617         
618         /* get editor data */
619         if (ANIM_animdata_get_context(C, &ac) == 0)
620                 return OPERATOR_CANCELLED;
621         if (ac.datatype == ANIMCONT_GPENCIL)
622                 return OPERATOR_CANCELLED;
623                 
624         /* what channels to affect? */
625         mode= RNA_enum_get(op->ptr, "type");
626         
627         /* insert keyframes */
628         insert_action_keys(&ac, mode);
629         
630         /* validate keyframes after editing */
631         ANIM_editkeyframes_refresh(&ac);
632         
633         /* set notifier that keyframes have changed */
634         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
635         
636         return OPERATOR_FINISHED;
637 }
638
639 void ACTION_OT_keyframe_insert (wmOperatorType *ot)
640 {
641         /* identifiers */
642         ot->name= "Insert Keyframes";
643         ot->idname= "ACTION_OT_keyframe_insert";
644         ot->description= "Insert keyframes for the specified channels";
645         
646         /* api callbacks */
647         ot->invoke= WM_menu_invoke;
648         ot->exec= actkeys_insertkey_exec;
649         ot->poll= ED_operator_action_active;
650         
651         /* flags */
652         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
653         
654         /* id-props */
655         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_insertkey_types, 0, "Type", "");
656 }
657
658 /* ******************** Duplicate Keyframes Operator ************************* */
659
660 static void duplicate_action_keys (bAnimContext *ac)
661 {
662         ListBase anim_data = {NULL, NULL};
663         bAnimListElem *ale;
664         int filter;
665         
666         /* filter data */
667         if (ac->datatype == ANIMCONT_GPENCIL)
668                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
669         else
670                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
671         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
672         
673         /* loop through filtered data and delete selected keys */
674         for (ale= anim_data.first; ale; ale= ale->next) {
675                 if (ale->type == ANIMTYPE_FCURVE)
676                         duplicate_fcurve_keys((FCurve *)ale->key_data);
677                 else
678                         duplicate_gplayer_frames((bGPDlayer *)ale->data);
679         }
680         
681         /* free filtered list */
682         BLI_freelistN(&anim_data);
683 }
684
685 /* ------------------- */
686
687 static int actkeys_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
688 {
689         bAnimContext ac;
690         
691         /* get editor data */
692         if (ANIM_animdata_get_context(C, &ac) == 0)
693                 return OPERATOR_CANCELLED;
694                 
695         /* duplicate keyframes */
696         duplicate_action_keys(&ac);
697         
698         /* validate keyframes after editing */
699         if (ac.datatype != ANIMCONT_GPENCIL)
700                 ANIM_editkeyframes_refresh(&ac);
701         
702         /* set notifier that keyframes have changed */
703         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
704         
705         return OPERATOR_FINISHED;
706 }
707
708 static int actkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
709 {
710         actkeys_duplicate_exec(C, op);
711         
712         return OPERATOR_FINISHED;
713 }
714  
715 void ACTION_OT_duplicate (wmOperatorType *ot)
716 {
717         /* identifiers */
718         ot->name= "Duplicate Keyframes";
719         ot->idname= "ACTION_OT_duplicate";
720         ot->description= "Make a copy of all selected keyframes";
721         
722         /* api callbacks */
723         ot->invoke= actkeys_duplicate_invoke;
724         ot->exec= actkeys_duplicate_exec;
725         ot->poll= ED_operator_action_active;
726         
727         /* flags */
728         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
729 }
730
731 /* ******************** Delete Keyframes Operator ************************* */
732
733 static void delete_action_keys (bAnimContext *ac)
734 {
735         ListBase anim_data = {NULL, NULL};
736         bAnimListElem *ale;
737         int filter;
738         
739         /* filter data */
740         if (ac->datatype == ANIMCONT_GPENCIL)
741                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
742         else
743                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
744         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
745         
746         /* loop through filtered data and delete selected keys */
747         for (ale= anim_data.first; ale; ale= ale->next) {
748                 if (ale->type != ANIMTYPE_GPLAYER) {
749                         FCurve *fcu= (FCurve *)ale->key_data;
750                         AnimData *adt= ale->adt;
751                         
752                         /* delete selected keyframes only */
753                         delete_fcurve_keys(fcu); 
754                         
755                         /* Only delete curve too if it won't be doing anything anymore */
756                         if ((fcu->totvert == 0) && (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0))
757                                 ANIM_fcurve_delete_from_animdata(ac, adt, fcu);
758                 }
759                 else
760                         delete_gplayer_frames((bGPDlayer *)ale->data);
761         }
762         
763         /* free filtered list */
764         BLI_freelistN(&anim_data);
765 }
766
767 /* ------------------- */
768
769 static int actkeys_delete_exec(bContext *C, wmOperator *UNUSED(op))
770 {
771         bAnimContext ac;
772         
773         /* get editor data */
774         if (ANIM_animdata_get_context(C, &ac) == 0)
775                 return OPERATOR_CANCELLED;
776                 
777         /* delete keyframes */
778         delete_action_keys(&ac);
779         
780         /* validate keyframes after editing */
781         if (ac.datatype != ANIMCONT_GPENCIL)
782                 ANIM_editkeyframes_refresh(&ac);
783         
784         /* set notifier that keyframes have changed */
785         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
786         
787         return OPERATOR_FINISHED;
788 }
789  
790 void ACTION_OT_delete (wmOperatorType *ot)
791 {
792         /* identifiers */
793         ot->name= "Delete Keyframes";
794         ot->idname= "ACTION_OT_delete";
795         ot->description= "Remove all selected keyframes";
796         
797         /* api callbacks */
798         ot->invoke= WM_operator_confirm;
799         ot->exec= actkeys_delete_exec;
800         ot->poll= ED_operator_action_active;
801         
802         /* flags */
803         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
804 }
805
806 /* ******************** Clean Keyframes Operator ************************* */
807
808 static void clean_action_keys (bAnimContext *ac, float thresh)
809 {       
810         ListBase anim_data = {NULL, NULL};
811         bAnimListElem *ale;
812         int filter;
813         
814         /* filter data */
815         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
816         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
817         
818         /* loop through filtered data and clean curves */
819         for (ale= anim_data.first; ale; ale= ale->next)
820                 clean_fcurve((FCurve *)ale->key_data, thresh);
821         
822         /* free temp data */
823         BLI_freelistN(&anim_data);
824 }
825
826 /* ------------------- */
827
828 static int actkeys_clean_exec(bContext *C, wmOperator *op)
829 {
830         bAnimContext ac;
831         float thresh;
832         
833         /* get editor data */
834         if (ANIM_animdata_get_context(C, &ac) == 0)
835                 return OPERATOR_CANCELLED;
836         if (ac.datatype == ANIMCONT_GPENCIL)
837                 return OPERATOR_PASS_THROUGH;
838                 
839         /* get cleaning threshold */
840         thresh= RNA_float_get(op->ptr, "threshold");
841         
842         /* clean keyframes */
843         clean_action_keys(&ac, thresh);
844         
845         /* validate keyframes after editing */
846         ANIM_editkeyframes_refresh(&ac);
847         
848         /* set notifier that keyframes have changed */
849         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
850         
851         return OPERATOR_FINISHED;
852 }
853  
854 void ACTION_OT_clean (wmOperatorType *ot)
855 {
856         /* identifiers */
857         ot->name= "Clean Keyframes";
858         ot->idname= "ACTION_OT_clean";
859         ot->description= "Simplify F-Curves by removing closely spaced keyframes";
860         
861         /* api callbacks */
862         //ot->invoke=  // XXX we need that number popup for this! 
863         ot->exec= actkeys_clean_exec;
864         ot->poll= ED_operator_action_active;
865         
866         /* flags */
867         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
868         
869         /* properties */
870         ot->prop= RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
871 }
872
873 /* ******************** Sample Keyframes Operator *********************** */
874
875 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
876 static void sample_action_keys (bAnimContext *ac)
877 {       
878         ListBase anim_data = {NULL, NULL};
879         bAnimListElem *ale;
880         int filter;
881         
882         /* filter data */
883         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
884         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
885         
886         /* loop through filtered data and add keys between selected keyframes on every frame  */
887         for (ale= anim_data.first; ale; ale= ale->next)
888                 sample_fcurve((FCurve *)ale->key_data);
889         
890         /* admin and redraws */
891         BLI_freelistN(&anim_data);
892 }
893
894 /* ------------------- */
895
896 static int actkeys_sample_exec(bContext *C, wmOperator *UNUSED(op))
897 {
898         bAnimContext ac;
899         
900         /* get editor data */
901         if (ANIM_animdata_get_context(C, &ac) == 0)
902                 return OPERATOR_CANCELLED;
903         if (ac.datatype == ANIMCONT_GPENCIL)
904                 return OPERATOR_PASS_THROUGH;
905         
906         /* sample keyframes */
907         sample_action_keys(&ac);
908         
909         /* validate keyframes after editing */
910         ANIM_editkeyframes_refresh(&ac);
911         
912         /* set notifier that keyframes have changed */
913         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
914         
915         return OPERATOR_FINISHED;
916 }
917  
918 void ACTION_OT_sample (wmOperatorType *ot)
919 {
920         /* identifiers */
921         ot->name= "Sample Keyframes";
922         ot->idname= "ACTION_OT_sample";
923         ot->description= "Add keyframes on every frame between the selected keyframes";
924         
925         /* api callbacks */
926         ot->exec= actkeys_sample_exec;
927         ot->poll= ED_operator_action_active;
928         
929         /* flags */
930         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
931 }
932
933 /* ************************************************************************** */
934 /* SETTINGS STUFF */
935
936 /* ******************** Set Extrapolation-Type Operator *********************** */
937
938 /* defines for make/clear cyclic extrapolation tools */
939 #define MAKE_CYCLIC_EXPO        -1
940 #define CLEAR_CYCLIC_EXPO       -2
941
942 /* defines for set extrapolation-type for selected keyframes tool */
943 static EnumPropertyItem prop_actkeys_expo_types[] = {
944         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
945         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
946         
947         {MAKE_CYCLIC_EXPO, "MAKE_CYCLIC", 0, "Make Cyclic (F-Modifier)", "Add Cycles F-Modifier if one doesn't exist already"},
948         {CLEAR_CYCLIC_EXPO, "CLEAR_CYCLIC", 0, "Clear Cyclic (F-Modifier)", "Remove Cycles F-Modifier if not needed anymore"},
949         {0, NULL, 0, NULL, NULL}
950 };
951
952 /* this function is responsible for setting extrapolation mode for keyframes */
953 static void setexpo_action_keys(bAnimContext *ac, short mode) 
954 {
955         ListBase anim_data = {NULL, NULL};
956         bAnimListElem *ale;
957         int filter;
958         
959         /* filter data */
960         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
961         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
962         
963         /* loop through setting mode per F-Curve */
964         for (ale= anim_data.first; ale; ale= ale->next) {
965                 FCurve *fcu= (FCurve *)ale->data;
966                 
967                 if (mode >= 0) {
968                         /* just set mode setting */
969                         fcu->extend= mode;
970                 }
971                 else {
972                         /* shortcuts for managing Cycles F-Modifiers to make it easier to toggle cyclic animation 
973                          * without having to go through FModifier UI in Graph Editor to do so
974                          */
975                         if (mode == MAKE_CYCLIC_EXPO) {
976                                 /* only add if one doesn't exist */
977                                 if (list_has_suitable_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, -1) == 0) {
978                                         // TODO: add some more preset versions which set different extrapolation options?
979                                         add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES);
980                                 }
981                         }
982                         else if (mode == CLEAR_CYCLIC_EXPO) {
983                                 /* remove all the modifiers fitting this description */
984                                 FModifier *fcm, *fcn=NULL;
985                                 
986                                 for (fcm = fcu->modifiers.first; fcm; fcm = fcn) {
987                                         fcn = fcm->next;
988                                         
989                                         if (fcm->type == FMODIFIER_TYPE_CYCLES)
990                                                 remove_fmodifier(&fcu->modifiers, fcm);
991                                 }
992                         }
993                 }
994         }
995         
996         /* cleanup */
997         BLI_freelistN(&anim_data);
998 }
999
1000 /* ------------------- */
1001
1002 static int actkeys_expo_exec(bContext *C, wmOperator *op)
1003 {
1004         bAnimContext ac;
1005         short mode;
1006         
1007         /* get editor data */
1008         if (ANIM_animdata_get_context(C, &ac) == 0)
1009                 return OPERATOR_CANCELLED;
1010         if (ac.datatype == ANIMCONT_GPENCIL) 
1011                 return OPERATOR_PASS_THROUGH;
1012                 
1013         /* get handle setting mode */
1014         mode= RNA_enum_get(op->ptr, "type");
1015         
1016         /* set handle type */
1017         setexpo_action_keys(&ac, mode);
1018         
1019         /* validate keyframes after editing */
1020         ANIM_editkeyframes_refresh(&ac);
1021         
1022         /* set notifier that keyframe properties have changed */
1023         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1024         
1025         return OPERATOR_FINISHED;
1026 }
1027  
1028 void ACTION_OT_extrapolation_type (wmOperatorType *ot)
1029 {
1030         /* identifiers */
1031         ot->name= "Set Keyframe Extrapolation";
1032         ot->idname= "ACTION_OT_extrapolation_type";
1033         ot->description= "Set extrapolation mode for selected F-Curves";
1034         
1035         /* api callbacks */
1036         ot->invoke= WM_menu_invoke;
1037         ot->exec= actkeys_expo_exec;
1038         ot->poll= ED_operator_action_active;
1039         
1040         /* flags */
1041         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1042         
1043         /* id-props */
1044         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
1045 }
1046
1047 /* ******************** Set Interpolation-Type Operator *********************** */
1048
1049 /* this function is responsible for setting interpolation mode for keyframes */
1050 static void setipo_action_keys(bAnimContext *ac, short mode) 
1051 {
1052         ListBase anim_data = {NULL, NULL};
1053         bAnimListElem *ale;
1054         int filter;
1055         KeyframeEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
1056         
1057         /* filter data */
1058         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1059         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1060         
1061         /* loop through setting BezTriple interpolation
1062          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1063          */
1064         for (ale= anim_data.first; ale; ale= ale->next)
1065                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1066         
1067         /* cleanup */
1068         BLI_freelistN(&anim_data);
1069 }
1070
1071 /* ------------------- */
1072
1073 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
1074 {
1075         bAnimContext ac;
1076         short mode;
1077         
1078         /* get editor data */
1079         if (ANIM_animdata_get_context(C, &ac) == 0)
1080                 return OPERATOR_CANCELLED;
1081         if (ac.datatype == ANIMCONT_GPENCIL) 
1082                 return OPERATOR_PASS_THROUGH;
1083                 
1084         /* get handle setting mode */
1085         mode= RNA_enum_get(op->ptr, "type");
1086         
1087         /* set handle type */
1088         setipo_action_keys(&ac, mode);
1089         
1090         /* validate keyframes after editing */
1091         ANIM_editkeyframes_refresh(&ac);
1092         
1093         /* set notifier that keyframe properties have changed */
1094         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1095         
1096         return OPERATOR_FINISHED;
1097 }
1098  
1099 void ACTION_OT_interpolation_type (wmOperatorType *ot)
1100 {
1101         /* identifiers */
1102         ot->name= "Set Keyframe Interpolation";
1103         ot->idname= "ACTION_OT_interpolation_type";
1104         ot->description= "Set interpolation mode for the F-Curve segments starting from the selected keyframes";
1105         
1106         /* api callbacks */
1107         ot->invoke= WM_menu_invoke;
1108         ot->exec= actkeys_ipo_exec;
1109         ot->poll= ED_operator_action_active;
1110         
1111         /* flags */
1112         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1113         
1114         /* id-props */
1115         ot->prop= RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
1116 }
1117
1118 /* ******************** Set Handle-Type Operator *********************** */
1119
1120 /* this function is responsible for setting handle-type of selected keyframes */
1121 static void sethandles_action_keys(bAnimContext *ac, short mode) 
1122 {
1123         ListBase anim_data = {NULL, NULL};
1124         bAnimListElem *ale;
1125         int filter;
1126         
1127         KeyframeEditFunc edit_cb= ANIM_editkeyframes_handles(mode);
1128         KeyframeEditFunc sel_cb= ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
1129         
1130         /* filter data */
1131         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1132         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1133         
1134         /* loop through setting flags for handles 
1135          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1136          */
1137         for (ale= anim_data.first; ale; ale= ale->next) {
1138                 FCurve *fcu= (FCurve *)ale->key_data;
1139                 
1140                 /* any selected keyframes for editing? */
1141                 if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, sel_cb, NULL)) {
1142                         /* change type of selected handles */
1143                         ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, edit_cb, calchandles_fcurve);
1144                 }
1145         }
1146         
1147         /* cleanup */
1148         BLI_freelistN(&anim_data);
1149 }
1150
1151 /* ------------------- */
1152
1153 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
1154 {
1155         bAnimContext ac;
1156         short mode;
1157         
1158         /* get editor data */
1159         if (ANIM_animdata_get_context(C, &ac) == 0)
1160                 return OPERATOR_CANCELLED;
1161         if (ac.datatype == ANIMCONT_GPENCIL) 
1162                 return OPERATOR_PASS_THROUGH;
1163                 
1164         /* get handle setting mode */
1165         mode= RNA_enum_get(op->ptr, "type");
1166         
1167         /* set handle type */
1168         sethandles_action_keys(&ac, mode);
1169         
1170         /* validate keyframes after editing */
1171         ANIM_editkeyframes_refresh(&ac);
1172         
1173         /* set notifier that keyframe properties have changed */
1174         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1175         
1176         return OPERATOR_FINISHED;
1177 }
1178  
1179 void ACTION_OT_handle_type (wmOperatorType *ot)
1180 {
1181         /* identifiers */
1182         ot->name= "Set Keyframe Handle Type";
1183         ot->idname= "ACTION_OT_handle_type";
1184         ot->description= "Set type of handle for selected keyframes";
1185         
1186         /* api callbacks */
1187         ot->invoke= WM_menu_invoke;
1188         ot->exec= actkeys_handletype_exec;
1189         ot->poll= ED_operator_action_active;
1190         
1191         /* flags */
1192         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1193         
1194         /* id-props */
1195         ot->prop= RNA_def_enum(ot->srna, "type", keyframe_handle_type_items, 0, "Type", "");
1196 }
1197
1198 /* ******************** Set Keyframe-Type Operator *********************** */
1199
1200 /* this function is responsible for setting interpolation mode for keyframes */
1201 static void setkeytype_action_keys(bAnimContext *ac, short mode) 
1202 {
1203         ListBase anim_data = {NULL, NULL};
1204         bAnimListElem *ale;
1205         int filter;
1206         KeyframeEditFunc set_cb= ANIM_editkeyframes_keytype(mode);
1207         
1208         /* filter data */
1209         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1210         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1211         
1212         /* loop through setting BezTriple interpolation
1213          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1214          */
1215         for (ale= anim_data.first; ale; ale= ale->next)
1216                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, NULL);
1217         
1218         /* cleanup */
1219         BLI_freelistN(&anim_data);
1220 }
1221
1222 /* ------------------- */
1223
1224 static int actkeys_keytype_exec(bContext *C, wmOperator *op)
1225 {
1226         bAnimContext ac;
1227         short mode;
1228         
1229         /* get editor data */
1230         if (ANIM_animdata_get_context(C, &ac) == 0)
1231                 return OPERATOR_CANCELLED;
1232         if (ac.datatype == ANIMCONT_GPENCIL) 
1233                 return OPERATOR_PASS_THROUGH;
1234                 
1235         /* get handle setting mode */
1236         mode= RNA_enum_get(op->ptr, "type");
1237         
1238         /* set handle type */
1239         setkeytype_action_keys(&ac, mode);
1240         
1241         /* validate keyframes after editing */
1242         ANIM_editkeyframes_refresh(&ac);
1243         
1244         /* set notifier that keyframe properties have changed */
1245         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1246         
1247         return OPERATOR_FINISHED;
1248 }
1249  
1250 void ACTION_OT_keyframe_type (wmOperatorType *ot)
1251 {
1252         /* identifiers */
1253         ot->name= "Set Keyframe Type";
1254         ot->idname= "ACTION_OT_keyframe_type";
1255         ot->description= "Set type of keyframe for the selected keyframes";
1256         
1257         /* api callbacks */
1258         ot->invoke= WM_menu_invoke;
1259         ot->exec= actkeys_keytype_exec;
1260         ot->poll= ED_operator_action_active;
1261         
1262         /* flags */
1263         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1264         
1265         /* id-props */
1266         ot->prop= RNA_def_enum(ot->srna, "type", beztriple_keyframe_type_items, 0, "Type", "");
1267 }
1268
1269 /* ************************************************************************** */
1270 /* TRANSFORM STUFF */
1271
1272 /* ***************** Jump to Selected Frames Operator *********************** */
1273
1274 /* snap current-frame indicator to 'average time' of selected keyframe */
1275 static int actkeys_framejump_exec(bContext *C, wmOperator *UNUSED(op))
1276 {
1277         bAnimContext ac;
1278         ListBase anim_data= {NULL, NULL};
1279         bAnimListElem *ale;
1280         int filter;
1281         KeyframeEditData ked= {{NULL}};
1282         
1283         /* get editor data */
1284         if (ANIM_animdata_get_context(C, &ac) == 0)
1285                 return OPERATOR_CANCELLED;
1286         
1287         /* init edit data */    
1288         /* loop over action data, averaging values */
1289         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);
1290         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1291         
1292         for (ale= anim_data.first; ale; ale= ale->next) {
1293                 AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
1294                 if (adt) {
1295                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1296                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);
1297                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1298                 }
1299                 else
1300                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);
1301         }
1302         
1303         BLI_freelistN(&anim_data);
1304         
1305         /* set the new current frame value, based on the average time */
1306         if (ked.i1) {
1307                 Scene *scene= ac.scene;
1308                 CFRA= (int)floor((ked.f1 / ked.i1) + 0.5f);
1309                 SUBFRA= 0.f;
1310         }
1311         
1312         /* set notifier that things have changed */
1313         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1314         
1315         return OPERATOR_FINISHED;
1316 }
1317
1318 void ACTION_OT_frame_jump (wmOperatorType *ot)
1319 {
1320         /* identifiers */
1321         ot->name= "Jump to Frame";
1322         ot->idname= "ACTION_OT_frame_jump";
1323         ot->description= "Set the current frame to the average frame of the selected keyframes";
1324         
1325         /* api callbacks */
1326         ot->exec= actkeys_framejump_exec;
1327         ot->poll= ED_operator_action_active;
1328         
1329         /* flags */
1330         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1331 }
1332
1333 /* ******************** Snap Keyframes Operator *********************** */
1334
1335 /* defines for snap keyframes tool */
1336 static EnumPropertyItem prop_actkeys_snap_types[] = {
1337         {ACTKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
1338         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
1339         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
1340         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
1341         {0, NULL, 0, NULL, NULL}
1342 };
1343
1344 /* this function is responsible for snapping keyframes to frame-times */
1345 static void snap_action_keys(bAnimContext *ac, short mode) 
1346 {
1347         ListBase anim_data = {NULL, NULL};
1348         bAnimListElem *ale;
1349         int filter;
1350         
1351         KeyframeEditData ked= {{NULL}};
1352         KeyframeEditFunc edit_cb;
1353         
1354         /* filter data */
1355         if (ac->datatype == ANIMCONT_GPENCIL)
1356                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT);
1357         else
1358                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1359         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1360         
1361         /* get beztriple editing callbacks */
1362         edit_cb= ANIM_editkeyframes_snap(mode);
1363
1364         ked.scene= ac->scene;
1365         if (mode == ACTKEYS_SNAP_NEAREST_MARKER) {
1366                 ked.list.first= (ac->markers) ? ac->markers->first : NULL;
1367                 ked.list.last= (ac->markers) ? ac->markers->last : NULL;
1368         }
1369         
1370         /* snap keyframes */
1371         for (ale= anim_data.first; ale; ale= ale->next) {
1372                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1373                 
1374                 if (adt) {
1375                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1376                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1377                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1378                 }
1379                 //else if (ale->type == ACTTYPE_GPLAYER)
1380                 //      snap_gplayer_frames(ale->data, mode);
1381                 else 
1382                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1383         }
1384         
1385         BLI_freelistN(&anim_data);
1386 }
1387
1388 /* ------------------- */
1389
1390 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1391 {
1392         bAnimContext ac;
1393         short mode;
1394         
1395         /* get editor data */
1396         if (ANIM_animdata_get_context(C, &ac) == 0)
1397                 return OPERATOR_CANCELLED;
1398                 
1399         // XXX...
1400         if (ac.datatype == ANIMCONT_GPENCIL)
1401                 return OPERATOR_PASS_THROUGH;
1402                 
1403         /* get snapping mode */
1404         mode= RNA_enum_get(op->ptr, "type");
1405         
1406         /* snap keyframes */
1407         snap_action_keys(&ac, mode);
1408         
1409         /* validate keyframes after editing */
1410         ANIM_editkeyframes_refresh(&ac);
1411         
1412         /* set notifier that keyframes have changed */
1413         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1414         
1415         return OPERATOR_FINISHED;
1416 }
1417  
1418 void ACTION_OT_snap (wmOperatorType *ot)
1419 {
1420         /* identifiers */
1421         ot->name= "Snap Keys";
1422         ot->idname= "ACTION_OT_snap";
1423         ot->description= "Snap selected keyframes to the times specified";
1424         
1425         /* api callbacks */
1426         ot->invoke= WM_menu_invoke;
1427         ot->exec= actkeys_snap_exec;
1428         ot->poll= ED_operator_action_active;
1429         
1430         /* flags */
1431         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1432         
1433         /* id-props */
1434         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1435 }
1436
1437 /* ******************** Mirror Keyframes Operator *********************** */
1438
1439 /* defines for mirror keyframes tool */
1440 static EnumPropertyItem prop_actkeys_mirror_types[] = {
1441         {ACTKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current frame", ""},
1442         {ACTKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0", ""},
1443         {ACTKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker", ""},
1444         {0, NULL, 0, NULL, NULL}
1445 };
1446
1447 /* this function is responsible for mirroring keyframes */
1448 static void mirror_action_keys(bAnimContext *ac, short mode) 
1449 {
1450         ListBase anim_data = {NULL, NULL};
1451         bAnimListElem *ale;
1452         int filter;
1453         
1454         KeyframeEditData ked= {{NULL}};
1455         KeyframeEditFunc edit_cb;
1456         
1457         /* get beztriple editing callbacks */
1458         edit_cb= ANIM_editkeyframes_mirror(mode);
1459
1460         ked.scene= ac->scene;
1461         
1462         /* for 'first selected marker' mode, need to find first selected marker first! */
1463         // XXX should this be made into a helper func in the API?
1464         if (mode == ACTKEYS_MIRROR_MARKER) {
1465                 TimeMarker *marker= NULL;
1466                 
1467                 /* find first selected marker */
1468                 marker= ED_markers_get_first_selected(ac->markers);
1469                 
1470                 /* store marker's time (if available) */
1471                 if (marker)
1472                         ked.f1= (float)marker->frame;
1473                 else
1474                         return;
1475         }
1476         
1477         /* filter data */
1478         if (ac->datatype == ANIMCONT_GPENCIL)
1479                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1480         else
1481                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1482         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1483         
1484         /* mirror keyframes */
1485         for (ale= anim_data.first; ale; ale= ale->next) {
1486                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1487                 
1488                 if (adt) {
1489                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 
1490                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1491                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1492                 }
1493                 //else if (ale->type == ACTTYPE_GPLAYER)
1494                 //      snap_gplayer_frames(ale->data, mode);
1495                 else 
1496                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1497         }
1498         
1499         BLI_freelistN(&anim_data);
1500 }
1501
1502 /* ------------------- */
1503
1504 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1505 {
1506         bAnimContext ac;
1507         short mode;
1508         
1509         /* get editor data */
1510         if (ANIM_animdata_get_context(C, &ac) == 0)
1511                 return OPERATOR_CANCELLED;
1512                 
1513         // XXX...
1514         if (ac.datatype == ANIMCONT_GPENCIL)
1515                 return OPERATOR_PASS_THROUGH;
1516                 
1517         /* get mirroring mode */
1518         mode= RNA_enum_get(op->ptr, "type");
1519         
1520         /* mirror keyframes */
1521         mirror_action_keys(&ac, mode);
1522         
1523         /* validate keyframes after editing */
1524         ANIM_editkeyframes_refresh(&ac);
1525         
1526         /* set notifier that keyframes have changed */
1527         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1528         
1529         return OPERATOR_FINISHED;
1530 }
1531  
1532 void ACTION_OT_mirror (wmOperatorType *ot)
1533 {
1534         /* identifiers */
1535         ot->name= "Mirror Keys";
1536         ot->idname= "ACTION_OT_mirror";
1537         ot->description= "Flip selected keyframes over the selected mirror line";
1538         
1539         /* api callbacks */
1540         ot->invoke= WM_menu_invoke;
1541         ot->exec= actkeys_mirror_exec;
1542         ot->poll= ED_operator_action_active;
1543         
1544         /* flags */
1545         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1546         
1547         /* id-props */
1548         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1549 }
1550
1551 /* ************************************************************************** */