Action Editor - Added back ID browsing buttons. Only browse/delete works for now.
[blender.git] / source / blender / editors / space_action / action_edit.c
1 /**
2  * $Id: editaction.c 17746 2008-12-08 11:19:44Z aligorith $
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <math.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <float.h>
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #include "MEM_guardedalloc.h"
40
41 #include "BLI_blenlib.h"
42 #include "BLI_arithb.h"
43
44 #include "DNA_anim_types.h"
45 #include "DNA_action_types.h"
46 #include "DNA_armature_types.h"
47 #include "DNA_camera_types.h"
48 #include "DNA_curve_types.h"
49 #include "DNA_object_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_scene_types.h"
52 #include "DNA_space_types.h"
53 #include "DNA_constraint_types.h"
54 #include "DNA_key_types.h"
55 #include "DNA_lamp_types.h"
56 #include "DNA_material_types.h"
57 #include "DNA_userdef_types.h"
58 #include "DNA_gpencil_types.h"
59 #include "DNA_windowmanager_types.h"
60
61 #include "RNA_access.h"
62 #include "RNA_define.h"
63
64 #include "BKE_action.h"
65 #include "BKE_depsgraph.h"
66 #include "BKE_fcurve.h"
67 #include "BKE_key.h"
68 #include "BKE_material.h"
69 #include "BKE_object.h"
70 #include "BKE_context.h"
71 #include "BKE_utildefines.h"
72
73 #include "UI_view2d.h"
74
75 #include "ED_anim_api.h"
76 #include "ED_keyframing.h"
77 #include "ED_keyframes_draw.h"
78 #include "ED_keyframes_edit.h"
79 #include "ED_screen.h"
80 #include "ED_space_api.h"
81
82 #include "WM_api.h"
83 #include "WM_types.h"
84
85 #include "action_intern.h"
86
87 /* ************************************************************************** */
88 /* KEYFRAME-RANGE STUFF */
89
90 /* *************************** Calculate Range ************************** */
91
92 /* Get the min/max keyframes*/
93 static void get_keyframe_extents (bAnimContext *ac, float *min, float *max)
94 {
95         ListBase anim_data = {NULL, NULL};
96         bAnimListElem *ale;
97         int filter;
98         
99         /* get data to filter, from Action or Dopesheet */
100         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
101         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
102         
103         /* set large values to try to override */
104         *min= 999999999.0f;
105         *max= -999999999.0f;
106         
107         /* check if any channels to set range with */
108         if (anim_data.first) {
109                 /* go through channels, finding max extents */
110                 for (ale= anim_data.first; ale; ale= ale->next) {
111                         Object *nob= ANIM_nla_mapping_get(ac, ale);
112                         FCurve *fcu= (FCurve *)ale->key_data;
113                         float tmin, tmax;
114                         
115                         /* get range and apply necessary scaling before */
116                         calc_fcurve_range(fcu, &tmin, &tmax);
117                         tmin= tmax= 0.0f; // xxx
118                         
119                         if (nob) {
120                                 tmin= get_action_frame_inv(nob, tmin);
121                                 tmax= get_action_frame_inv(nob, tmax);
122                         }
123                         
124                         /* try to set cur using these values, if they're more extreme than previously set values */
125                         *min= MIN2(*min, tmin);
126                         *max= MAX2(*max, tmax);
127                 }
128                 
129                 /* free memory */
130                 BLI_freelistN(&anim_data);
131         }
132         else {
133                 /* set default range */
134                 if (ac->scene) {
135                         *min= (float)ac->scene->r.sfra;
136                         *max= (float)ac->scene->r.efra;
137                 }
138                 else {
139                         *min= -5;
140                         *max= 100;
141                 }
142         }
143 }
144
145 /* ****************** Automatic Preview-Range Operator ****************** */
146
147 static int actkeys_previewrange_exec(bContext *C, wmOperator *op)
148 {
149         bAnimContext ac;
150         Scene *scene;
151         float min, max;
152         
153         /* get editor data */
154         if (ANIM_animdata_get_context(C, &ac) == 0)
155                 return OPERATOR_CANCELLED;
156         if (ac.scene == NULL)
157                 return OPERATOR_CANCELLED;
158         else
159                 scene= ac.scene;
160         
161         /* set the range directly */
162         get_keyframe_extents(&ac, &min, &max);
163         scene->r.psfra= (int)floor(min + 0.5f);
164         scene->r.pefra= (int)floor(max + 0.5f);
165         
166         /* set notifier that things have changed */
167         // XXX err... there's nothing for frame ranges yet, but this should do fine too
168         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
169         
170         return OPERATOR_FINISHED;
171 }
172  
173 void ACT_OT_set_previewrange (wmOperatorType *ot)
174 {
175         /* identifiers */
176         ot->name= "Auto-Set Preview Range";
177         ot->idname= "ACT_OT_set_previewrange";
178         
179         /* api callbacks */
180         ot->exec= actkeys_previewrange_exec;
181         ot->poll= ED_operator_areaactive;
182         
183         /* flags */
184         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
185 }
186
187 /* ****************** View-All Operator ****************** */
188
189 static int actkeys_viewall_exec(bContext *C, wmOperator *op)
190 {
191         bAnimContext ac;
192         View2D *v2d;
193         float extra;
194         
195         /* get editor data */
196         if (ANIM_animdata_get_context(C, &ac) == 0)
197                 return OPERATOR_CANCELLED;
198         v2d= &ac.ar->v2d;
199         
200         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
201         get_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax);
202         
203         extra= 0.05f * (v2d->cur.xmax - v2d->cur.xmin);
204         v2d->cur.xmin -= extra;
205         v2d->cur.xmax += extra;
206         
207         /* set vertical range */
208         v2d->cur.ymax= 0.0f;
209         v2d->cur.ymin= (float)-(v2d->mask.ymax - v2d->mask.ymin);
210         
211         /* do View2D syncing */
212         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
213         
214         /* set notifier that things have changed */
215         ED_area_tag_redraw(CTX_wm_area(C));
216         
217         return OPERATOR_FINISHED;
218 }
219  
220 void ACT_OT_view_all (wmOperatorType *ot)
221 {
222         /* identifiers */
223         ot->name= "View All";
224         ot->idname= "ACT_OT_view_all";
225         
226         /* api callbacks */
227         ot->exec= actkeys_viewall_exec;
228         ot->poll= ED_operator_areaactive;
229         
230         /* flags */
231         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
232 }
233
234 /* ************************************************************************** */
235 /* GENERAL STUFF */
236
237 // TODO:
238 //      - insert key
239
240 /* ******************** Copy/Paste Keyframes Operator ************************* */
241 /* - The copy/paste buffer currently stores a set of temporary F-Curves containing only the keyframes 
242  *   that were selected in each of the original F-Curves
243  * - All pasted frames are offset by the same amount. This is calculated as the difference in the times of
244  *      the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
245  * - The earliest frame is calculated per copy operation.
246  */
247
248 /* globals for copy/paste data (like for other copy/paste buffers) */
249 ListBase actcopybuf = {NULL, NULL};
250 static float actcopy_firstframe= 999999999.0f;
251
252 /* This function frees any MEM_calloc'ed copy/paste buffer data */
253 // XXX find some header to put this in!
254 void free_actcopybuf ()
255 {
256         FCurve *fcu, *fcn;
257         
258         /* free_fcurve() frees F-Curve memory too, but we don't need to do remlink first, as we're freeing all 
259          * channels anyway, and the freeing func only cares about the data it's given
260          */
261         for (fcu= actcopybuf.first; fcu; fcu= fcn) {
262                 fcn= fcu->next;
263                 free_fcurve(fcu);
264         }
265         
266         actcopybuf.first= actcopybuf.last= NULL;
267         actcopy_firstframe= 999999999.0f;
268 }
269
270 /* ------------------- */
271
272 /* This function adds data to the copy/paste buffer, freeing existing data first
273  * Only the selected action channels gets their selected keyframes copied.
274  */
275 static short copy_action_keys (bAnimContext *ac)
276 {       
277         ListBase anim_data = {NULL, NULL};
278         bAnimListElem *ale;
279         int filter;
280         
281         /* clear buffer first */
282         free_actcopybuf();
283         
284         /* filter data */
285         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
286         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
287         
288         /* assume that each of these is an ipo-block */
289         for (ale= anim_data.first; ale; ale= ale->next) {
290 #if 0
291                 bActionChannel *achan;
292                 Ipo *ipo= ale->key_data;
293                 Ipo *ipn;
294                 IpoCurve *icu, *icn;
295                 BezTriple *bezt;
296                 int i;
297                 
298                 /* coerce an action-channel out of owner */
299                 if (ale->ownertype == ANIMTYPE_ACHAN) {
300                         bActionChannel *achanO= ale->owner;
301                         achan= MEM_callocN(sizeof(bActionChannel), "ActCopyPasteAchan");
302                         strcpy(achan->name, achanO->name);
303                 }
304                 else if (ale->ownertype == ANIMTYPE_SHAPEKEY) {
305                         achan= MEM_callocN(sizeof(bActionChannel), "ActCopyPasteAchan");
306                         strcpy(achan->name, "#ACP_ShapeKey");
307                 }
308                 else
309                         continue;
310                 BLI_addtail(&actcopybuf, achan);
311                 
312                 /* add constraint channel if needed, then add new ipo-block */
313                 if (ale->type == ANIMTYPE_CONCHAN) {
314                         bConstraintChannel *conchanO= ale->data;
315                         bConstraintChannel *conchan;
316                         
317                         conchan= MEM_callocN(sizeof(bConstraintChannel), "ActCopyPasteConchan");
318                         strcpy(conchan->name, conchanO->name);
319                         BLI_addtail(&achan->constraintChannels, conchan);
320                         
321                         conchan->ipo= ipn= MEM_callocN(sizeof(Ipo), "ActCopyPasteIpo");
322                 }
323                 else {
324                         achan->ipo= ipn= MEM_callocN(sizeof(Ipo), "ActCopyPasteIpo");
325                 }
326                 ipn->blocktype = ipo->blocktype;
327                 
328                 /* now loop through curves, and only copy selected keyframes */
329                 for (icu= ipo->curve.first; icu; icu= icu->next) {
330                         /* allocate a new curve */
331                         icn= MEM_callocN(sizeof(IpoCurve), "ActCopyPasteIcu");
332                         icn->blocktype = icu->blocktype;
333                         icn->adrcode = icu->adrcode;
334                         BLI_addtail(&ipn->curve, icn);
335                         
336                         /* find selected BezTriples to add to the buffer (and set first frame) */
337                         for (i=0, bezt=icu->bezt; i < icu->totvert; i++, bezt++) {
338                                 if (BEZSELECTED(bezt)) {
339                                         /* add to buffer ipo-curve */
340                                         //insert_bezt_icu(icn, bezt); // XXX
341                                         
342                                         /* check if this is the earliest frame encountered so far */
343                                         if (bezt->vec[1][0] < actcopy_firstframe)
344                                                 actcopy_firstframe= bezt->vec[1][0];
345                                 }
346                         }
347                 }
348 #endif
349                 //FCurve *fcu= (FCurve *)ale->key_data;
350                 //FCurve *fcn;
351                 //BezTriple *bezt;
352                 //int i;
353                 
354                 
355         }
356         
357         /* check if anything ended up in the buffer */
358         if (ELEM(NULL, actcopybuf.first, actcopybuf.last))
359                 return -1;
360         
361         /* free temp memory */
362         BLI_freelistN(&anim_data);
363         
364         /* everything went fine */
365         return 0;
366 }
367
368 static short paste_action_keys (bAnimContext *ac)
369 {
370 #if 0 // XXX old animation system
371         ListBase anim_data = {NULL, NULL};
372         bAnimListElem *ale;
373         int filter;
374         
375         const Scene *scene= (ac->scene);
376         const float offset = (float)(CFRA - actcopy_firstframe);
377         char *actname = NULL, *conname = NULL;
378         short no_name= 0;
379         
380         /* check if buffer is empty */
381         if (ELEM(NULL, actcopybuf.first, actcopybuf.last)) {
382                 //error("No data in buffer to paste");
383                 return -1;
384         }
385         /* check if single channel in buffer (disregard names if so)  */
386         if (actcopybuf.first == actcopybuf.last)
387                 no_name= 1;
388         
389         /* filter data */
390         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_IPOKEYS);
391         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
392         
393         /* from selected channels */
394         for (ale= anim_data.first; ale; ale= ale->next) {
395                 Ipo *ipo_src = NULL;
396                 bActionChannel *achan;
397                 IpoCurve *ico, *icu;
398                 BezTriple *bezt;
399                 int i;
400                 
401                 /* find suitable IPO-block from buffer to paste from */
402                 for (achan= actcopybuf.first; achan; achan= achan->next) {
403                         /* try to match data */
404                         if (ale->ownertype == ANIMTYPE_ACHAN) {
405                                 bActionChannel *achant= ale->owner;
406                                 
407                                 /* check if we have a corresponding action channel */
408                                 if ((no_name) || (strcmp(achan->name, achant->name)==0)) {
409                                         actname= achant->name;
410                                         
411                                         /* check if this is a constraint channel */
412                                         if (ale->type == ANIMTYPE_CONCHAN) {
413                                                 bConstraintChannel *conchant= ale->data;
414                                                 bConstraintChannel *conchan;
415                                                 
416                                                 for (conchan=achan->constraintChannels.first; conchan; conchan=conchan->next) {
417                                                         if (strcmp(conchan->name, conchant->name)==0) {
418                                                                 conname= conchant->name;
419                                                                 ipo_src= conchan->ipo;
420                                                                 break;
421                                                         }
422                                                 }
423                                                 if (ipo_src) break;
424                                         }
425                                         else {
426                                                 ipo_src= achan->ipo;
427                                                 break;
428                                         }
429                                 }
430                         }
431                         else if (ale->ownertype == ANIMTYPE_SHAPEKEY) {
432                                 /* check if this action channel is "#ACP_ShapeKey" */
433                                 if ((no_name) || (strcmp(achan->name, "#ACP_ShapeKey")==0)) {
434                                         actname= NULL;
435                                         ipo_src= achan->ipo;
436                                         break;
437                                 }
438                         }       
439                 }
440                 
441                 /* this shouldn't happen, but it might */
442                 if (ipo_src == NULL)
443                         continue;
444                 
445                 /* loop over curves, pasting keyframes */
446                 for (ico= ipo_src->curve.first; ico; ico= ico->next) {
447                         /* get IPO-curve to paste to (IPO-curve might not exist for destination, so gets created) */
448                         //icu= verify_ipocurve(ale->id, ico->blocktype, actname, conname, NULL, ico->adrcode, 1);
449                         
450                         
451                         if (icu) {
452                                 /* just start pasting, with the the first keyframe on the current frame, and so on */
453                                 for (i=0, bezt=ico->bezt; i < ico->totvert; i++, bezt++) {                                              
454                                         /* temporarily apply offset to src beztriple while copying */
455                                         bezt->vec[0][0] += offset;
456                                         bezt->vec[1][0] += offset;
457                                         bezt->vec[2][0] += offset;
458                                         
459                                         /* insert the keyframe */
460                                         //insert_bezt_icu(icu, bezt); // XXX
461                                         
462                                         /* un-apply offset from src beztriple after copying */
463                                         bezt->vec[0][0] -= offset;
464                                         bezt->vec[1][0] -= offset;
465                                         bezt->vec[2][0] -= offset;
466                                 }
467                                 
468                                 /* recalculate channel's handles? */
469                                 //calchandles_fcurve(fcu);
470                         }
471                 }
472         }
473         
474         /* free temp memory */
475         BLI_freelistN(&anim_data);
476         
477         /* do depsgraph updates (for 3d-view)? */
478 #if 0
479         if ((ob) && (G.saction->pin==0)) {
480                 if (ob->type == OB_ARMATURE)
481                         DAG_object_flush_update(G.scene, ob, OB_RECALC_OB|OB_RECALC_DATA);
482                 else
483                         DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
484         }
485 #endif
486
487 #endif // XXX old animation system
488
489         return 0;
490 }
491
492 /* ------------------- */
493
494 static int actkeys_copy_exec(bContext *C, wmOperator *op)
495 {
496         bAnimContext ac;
497         
498         /* get editor data */
499         if (ANIM_animdata_get_context(C, &ac) == 0)
500                 return OPERATOR_CANCELLED;
501         
502         /* copy keyframes */
503         if (ac.datatype == ANIMCONT_GPENCIL) {
504                 // FIXME...
505         }
506         else {
507                 if (copy_action_keys(&ac)) {    
508                         // XXX errors - need a way to inform the user 
509                         printf("Action Copy: No keyframes copied to copy-paste buffer\n");
510                 }
511         }
512         
513         /* set notifier tha things have changed */
514         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
515         
516         return OPERATOR_FINISHED;
517 }
518  
519 void ACT_OT_keyframes_copy (wmOperatorType *ot)
520 {
521         /* identifiers */
522         ot->name= "Copy Keyframes";
523         ot->idname= "ACT_OT_keyframes_copy";
524         
525         /* api callbacks */
526         ot->exec= actkeys_copy_exec;
527         ot->poll= ED_operator_areaactive;
528         
529         /* flags */
530         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
531 }
532
533
534
535 static int actkeys_paste_exec(bContext *C, wmOperator *op)
536 {
537         bAnimContext ac;
538         
539         /* get editor data */
540         if (ANIM_animdata_get_context(C, &ac) == 0)
541                 return OPERATOR_CANCELLED;
542         
543         /* paste keyframes */
544         if (ac.datatype == ANIMCONT_GPENCIL) {
545                 // FIXME...
546         }
547         else {
548                 if (paste_action_keys(&ac)) {
549                         // XXX errors - need a way to inform the user 
550                         printf("Action Paste: Nothing to paste, as Copy-Paste buffer was empty.\n");
551                 }
552         }
553         
554         /* validate keyframes after editing */
555         ANIM_editkeyframes_refresh(&ac);
556         
557         /* set notifier tha things have changed */
558         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
559         
560         return OPERATOR_FINISHED;
561 }
562  
563 void ACT_OT_keyframes_paste (wmOperatorType *ot)
564 {
565         /* identifiers */
566         ot->name= "Paste Keyframes";
567         ot->idname= "ACT_OT_keyframes_paste";
568         
569         /* api callbacks */
570         ot->exec= actkeys_paste_exec;
571         ot->poll= ED_operator_areaactive;
572         
573         /* flags */
574         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
575 }
576
577 /* ******************** Delete Keyframes Operator ************************* */
578
579 static void delete_action_keys (bAnimContext *ac)
580 {
581         ListBase anim_data = {NULL, NULL};
582         bAnimListElem *ale;
583         int filter;
584         
585         /* filter data */
586         if (ac->datatype == ANIMCONT_GPENCIL)
587                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
588         else
589                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
590         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
591         
592         /* loop through filtered data and delete selected keys */
593         for (ale= anim_data.first; ale; ale= ale->next) {
594                 //if (ale->type == ANIMTYPE_GPLAYER)
595                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
596                 //else
597                         delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
598         }
599         
600         /* free filtered list */
601         BLI_freelistN(&anim_data);
602 }
603
604 /* ------------------- */
605
606 static int actkeys_delete_exec(bContext *C, wmOperator *op)
607 {
608         bAnimContext ac;
609         
610         /* get editor data */
611         if (ANIM_animdata_get_context(C, &ac) == 0)
612                 return OPERATOR_CANCELLED;
613                 
614         /* delete keyframes */
615         delete_action_keys(&ac);
616         
617         /* validate keyframes after editing */
618         ANIM_editkeyframes_refresh(&ac);
619         
620         /* set notifier tha things have changed */
621         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
622         
623         return OPERATOR_FINISHED;
624 }
625  
626 void ACT_OT_keyframes_delete (wmOperatorType *ot)
627 {
628         /* identifiers */
629         ot->name= "Delete Keyframes";
630         ot->idname= "ACT_OT_keyframes_delete";
631         
632         /* api callbacks */
633         ot->invoke= WM_operator_confirm;
634         ot->exec= actkeys_delete_exec;
635         ot->poll= ED_operator_areaactive;
636         
637         /* flags */
638         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
639 }
640
641 /* ******************** Clean Keyframes Operator ************************* */
642
643 static void clean_action_keys (bAnimContext *ac, float thresh)
644 {       
645         ListBase anim_data = {NULL, NULL};
646         bAnimListElem *ale;
647         int filter;
648         
649         /* filter data */
650         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
651         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
652         
653         /* loop through filtered data and clean curves */
654         for (ale= anim_data.first; ale; ale= ale->next)
655                 clean_fcurve((FCurve *)ale->key_data, thresh);
656         
657         /* free temp data */
658         BLI_freelistN(&anim_data);
659 }
660
661 /* ------------------- */
662
663 static int actkeys_clean_exec(bContext *C, wmOperator *op)
664 {
665         bAnimContext ac;
666         float thresh;
667         
668         /* get editor data */
669         if (ANIM_animdata_get_context(C, &ac) == 0)
670                 return OPERATOR_CANCELLED;
671         if (ac.datatype == ANIMCONT_GPENCIL)
672                 return OPERATOR_PASS_THROUGH;
673                 
674         /* get cleaning threshold */
675         thresh= RNA_float_get(op->ptr, "threshold");
676         
677         /* clean keyframes */
678         clean_action_keys(&ac, thresh);
679         
680         /* validate keyframes after editing */
681         ANIM_editkeyframes_refresh(&ac);
682         
683         /* set notifier tha things have changed */
684         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
685         
686         return OPERATOR_FINISHED;
687 }
688  
689 void ACT_OT_keyframes_clean (wmOperatorType *ot)
690 {
691         /* identifiers */
692         ot->name= "Clean Keyframes";
693         ot->idname= "ACT_OT_keyframes_clean";
694         
695         /* api callbacks */
696         //ot->invoke=  // XXX we need that number popup for this! 
697         ot->exec= actkeys_clean_exec;
698         ot->poll= ED_operator_areaactive;
699         
700         /* flags */
701         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
702         
703         /* properties */
704         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
705 }
706
707 /* ******************** Sample Keyframes Operator *********************** */
708
709 /* little cache for values... */
710 typedef struct tempFrameValCache {
711         float frame, val;
712 } tempFrameValCache;
713
714 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
715 static void sample_action_keys (bAnimContext *ac)
716 {       
717         ListBase anim_data = {NULL, NULL};
718         bAnimListElem *ale;
719         int filter;
720         
721         /* filter data */
722         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
723         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
724         
725         /* loop through filtered data and add keys between selected keyframes on every frame  */
726         for (ale= anim_data.first; ale; ale= ale->next) {
727                 FCurve *fcu= (FCurve *)ale->key_data;
728                 BezTriple *bezt, *start=NULL, *end=NULL;
729                 tempFrameValCache *value_cache, *fp;
730                 int sfra, range;
731                 int i, n;
732                 
733                 /* find selected keyframes... once pair has been found, add keyframes  */
734                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
735                         /* check if selected, and which end this is */
736                         if (BEZSELECTED(bezt)) {
737                                 if (start) {
738                                         /* set end */
739                                         end= bezt;
740                                         
741                                         /* cache values then add keyframes using these values, as adding
742                                          * keyframes while sampling will affect the outcome...
743                                          */
744                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
745                                         sfra= (int)( floor(start->vec[1][0]) );
746                                         
747                                         if (range) {
748                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
749                                                 
750                                                 /*      sample values   */
751                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
752                                                         fp->frame= (float)(sfra + n);
753                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
754                                                 }
755                                                 
756                                                 /*      add keyframes with these        */
757                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
758                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
759                                                 }
760                                                 
761                                                 /* free temp cache */
762                                                 MEM_freeN(value_cache);
763                                                 
764                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
765                                                 bezt = fcu->bezt + i + range - 1;
766                                                 i += (range - 1);
767                                         }
768                                         
769                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
770                                         start= bezt;
771                                         end= NULL;
772                                 }
773                                 else {
774                                         /* just set start keyframe */
775                                         start= bezt;
776                                         end= NULL;
777                                 }
778                         }
779                 }
780                 
781                 /* recalculate channel's handles? */
782                 calchandles_fcurve(fcu);
783         }
784         
785         /* admin and redraws */
786         BLI_freelistN(&anim_data);
787 }
788
789 /* ------------------- */
790
791 static int actkeys_sample_exec(bContext *C, wmOperator *op)
792 {
793         bAnimContext ac;
794         
795         /* get editor data */
796         if (ANIM_animdata_get_context(C, &ac) == 0)
797                 return OPERATOR_CANCELLED;
798         if (ac.datatype == ANIMCONT_GPENCIL)
799                 return OPERATOR_PASS_THROUGH;
800         
801         /* sample keyframes */
802         sample_action_keys(&ac);
803         
804         /* validate keyframes after editing */
805         ANIM_editkeyframes_refresh(&ac);
806         
807         /* set notifier tha things have changed */
808         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
809         
810         return OPERATOR_FINISHED;
811 }
812  
813 void ACT_OT_keyframes_sample (wmOperatorType *ot)
814 {
815         /* identifiers */
816         ot->name= "Sample Keyframes";
817         ot->idname= "ACT_OT_keyframes_sample";
818         
819         /* api callbacks */
820         ot->exec= actkeys_sample_exec;
821         ot->poll= ED_operator_areaactive;
822         
823         /* flags */
824         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
825 }
826
827 /* ************************************************************************** */
828 /* SETTINGS STUFF */
829
830 /* ******************** Set Extrapolation-Type Operator *********************** */
831
832 /* defines for set extrapolation-type for selected keyframes tool */
833 EnumPropertyItem prop_actkeys_expo_types[] = {
834         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
835         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
836         {0, NULL, NULL, NULL}
837 };
838
839 /* this function is responsible for setting extrapolation mode for keyframes */
840 static void setexpo_action_keys(bAnimContext *ac, short mode) 
841 {
842         ListBase anim_data = {NULL, NULL};
843         bAnimListElem *ale;
844         int filter;
845         
846         /* filter data */
847         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
848         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
849         
850         /* loop through setting mode per F-Curve */
851         for (ale= anim_data.first; ale; ale= ale->next) {
852                 FCurve *fcu= (FCurve *)ale->data;
853                 fcu->extend= mode;
854         }
855         
856         /* cleanup */
857         BLI_freelistN(&anim_data);
858 }
859
860 /* ------------------- */
861
862 static int actkeys_expo_exec(bContext *C, wmOperator *op)
863 {
864         bAnimContext ac;
865         short mode;
866         
867         /* get editor data */
868         if (ANIM_animdata_get_context(C, &ac) == 0)
869                 return OPERATOR_CANCELLED;
870         if (ac.datatype == ANIMCONT_GPENCIL) 
871                 return OPERATOR_PASS_THROUGH;
872                 
873         /* get handle setting mode */
874         mode= RNA_enum_get(op->ptr, "type");
875         
876         /* set handle type */
877         setexpo_action_keys(&ac, mode);
878         
879         /* validate keyframes after editing */
880         ANIM_editkeyframes_refresh(&ac);
881         
882         /* set notifier tha things have changed */
883         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
884         
885         return OPERATOR_FINISHED;
886 }
887  
888 void ACT_OT_keyframes_extrapolation_type (wmOperatorType *ot)
889 {
890         /* identifiers */
891         ot->name= "Set Keyframe Extrapolation";
892         ot->idname= "ACT_OT_keyframes_extrapolation_type";
893         
894         /* api callbacks */
895         ot->invoke= WM_menu_invoke;
896         ot->exec= actkeys_expo_exec;
897         ot->poll= ED_operator_areaactive;
898         
899         /* flags */
900         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
901         
902         /* id-props */
903         RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
904 }
905
906 /* ******************** Set Interpolation-Type Operator *********************** */
907
908 /* defines for set ipo-type for selected keyframes tool */
909 EnumPropertyItem prop_actkeys_ipo_types[] = {
910         {BEZT_IPO_CONST, "CONSTANT", "Constant Interpolation", ""},
911         {BEZT_IPO_LIN, "LINEAR", "Linear Interpolation", ""},
912         {BEZT_IPO_BEZ, "BEZIER", "Bezier Interpolation", ""},
913         {0, NULL, NULL, NULL}
914 };
915
916 /* this function is responsible for setting interpolation mode for keyframes */
917 static void setipo_action_keys(bAnimContext *ac, short mode) 
918 {
919         ListBase anim_data = {NULL, NULL};
920         bAnimListElem *ale;
921         int filter;
922         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
923         
924         /* filter data */
925         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
926         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
927         
928         /* loop through setting BezTriple interpolation
929          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
930          */
931         for (ale= anim_data.first; ale; ale= ale->next)
932                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
933         
934         /* cleanup */
935         BLI_freelistN(&anim_data);
936 }
937
938 /* ------------------- */
939
940 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
941 {
942         bAnimContext ac;
943         short mode;
944         
945         /* get editor data */
946         if (ANIM_animdata_get_context(C, &ac) == 0)
947                 return OPERATOR_CANCELLED;
948         if (ac.datatype == ANIMCONT_GPENCIL) 
949                 return OPERATOR_PASS_THROUGH;
950                 
951         /* get handle setting mode */
952         mode= RNA_enum_get(op->ptr, "type");
953         
954         /* set handle type */
955         setipo_action_keys(&ac, mode);
956         
957         /* validate keyframes after editing */
958         ANIM_editkeyframes_refresh(&ac);
959         
960         /* set notifier tha things have changed */
961         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
962         
963         return OPERATOR_FINISHED;
964 }
965  
966 void ACT_OT_keyframes_interpolation_type (wmOperatorType *ot)
967 {
968         /* identifiers */
969         ot->name= "Set Keyframe Interpolation";
970         ot->idname= "ACT_OT_keyframes_interpolation_type";
971         
972         /* api callbacks */
973         ot->invoke= WM_menu_invoke;
974         ot->exec= actkeys_ipo_exec;
975         ot->poll= ED_operator_areaactive;
976         
977         /* flags */
978         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
979         
980         /* id-props */
981         RNA_def_enum(ot->srna, "type", prop_actkeys_ipo_types, 0, "Type", "");
982 }
983
984 /* ******************** Set Handle-Type Operator *********************** */
985
986 /* defines for set handle-type for selected keyframes tool */
987 EnumPropertyItem prop_actkeys_handletype_types[] = {
988         {HD_AUTO, "AUTO", "Auto Handles", ""},
989         {HD_VECT, "VECTOR", "Vector Handles", ""},
990         {HD_FREE, "FREE", "Free Handles", ""},
991         {HD_ALIGN, "ALIGN", "Aligned Handles", ""},
992 //      {-1, "TOGGLE", "Toggle between Free and Aligned Handles", ""},
993         {0, NULL, NULL, NULL}
994 };
995
996 /* this function is responsible for setting handle-type of selected keyframes */
997 static void sethandles_action_keys(bAnimContext *ac, short mode) 
998 {
999         ListBase anim_data = {NULL, NULL};
1000         bAnimListElem *ale;
1001         int filter;
1002         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
1003         
1004         /* filter data */
1005         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1006         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1007         
1008         /* loop through setting flags for handles 
1009          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1010          */
1011         for (ale= anim_data.first; ale; ale= ale->next) {
1012                 if (mode == -1) {       
1013                         BeztEditFunc toggle_cb;
1014                         
1015                         /* check which type of handle to set (free or aligned) 
1016                          *      - check here checks for handles with free alignment already
1017                          */
1018                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
1019                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
1020                         else
1021                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
1022                                 
1023                         /* set handle-type */
1024                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
1025                 }
1026                 else {
1027                         /* directly set handle-type */
1028                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1029                 }
1030         }
1031         
1032         /* cleanup */
1033         BLI_freelistN(&anim_data);
1034 }
1035
1036 /* ------------------- */
1037
1038 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
1039 {
1040         bAnimContext ac;
1041         short mode;
1042         
1043         /* get editor data */
1044         if (ANIM_animdata_get_context(C, &ac) == 0)
1045                 return OPERATOR_CANCELLED;
1046         if (ac.datatype == ANIMCONT_GPENCIL) 
1047                 return OPERATOR_PASS_THROUGH;
1048                 
1049         /* get handle setting mode */
1050         mode= RNA_enum_get(op->ptr, "type");
1051         
1052         /* set handle type */
1053         sethandles_action_keys(&ac, mode);
1054         
1055         /* validate keyframes after editing */
1056         ANIM_editkeyframes_refresh(&ac);
1057         
1058         /* set notifier tha things have changed */
1059         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1060         
1061         return OPERATOR_FINISHED;
1062 }
1063  
1064 void ACT_OT_keyframes_handletype (wmOperatorType *ot)
1065 {
1066         /* identifiers */
1067         ot->name= "Set Keyframe Handle Type";
1068         ot->idname= "ACT_OT_keyframes_handletype";
1069         
1070         /* api callbacks */
1071         ot->invoke= WM_menu_invoke;
1072         ot->exec= actkeys_handletype_exec;
1073         ot->poll= ED_operator_areaactive;
1074         
1075         /* flags */
1076         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1077         
1078         /* id-props */
1079         RNA_def_enum(ot->srna, "type", prop_actkeys_handletype_types, 0, "Type", "");
1080 }
1081
1082 /* ************************************************************************** */
1083 /* TRANSFORM STUFF */
1084
1085 /* ***************** Snap Current Frame Operator *********************** */
1086
1087 /* helper callback for actkeys_cfrasnap_exec() -> used to help get the average time of all selected beztriples */
1088 // TODO: if some other code somewhere needs this, it'll be time to port this over to keyframes_edit.c!!!
1089 static short bezt_calc_average(BeztEditData *bed, BezTriple *bezt)
1090 {
1091         /* only if selected */
1092         if (bezt->f2 & SELECT) {
1093                 /* store average time in float (only do rounding at last step */
1094                 bed->f1 += bezt->vec[1][0];
1095                 
1096                 /* increment number of items */
1097                 bed->i1++;
1098         }
1099         
1100         return 0;
1101 }
1102
1103 /* snap current-frame indicator to 'average time' of selected keyframe */
1104 static int actkeys_cfrasnap_exec(bContext *C, wmOperator *op)
1105 {
1106         bAnimContext ac;
1107         ListBase anim_data= {NULL, NULL};
1108         bAnimListElem *ale;
1109         int filter;
1110         BeztEditData bed;
1111         
1112         /* get editor data */
1113         if (ANIM_animdata_get_context(C, &ac) == 0)
1114                 return OPERATOR_CANCELLED;
1115         
1116         /* init edit data */
1117         memset(&bed, 0, sizeof(BeztEditData));
1118         
1119         /* loop over action data, averaging values */
1120         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
1121         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1122         
1123         for (ale= anim_data.first; ale; ale= ale->next)
1124                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1125         
1126         BLI_freelistN(&anim_data);
1127         
1128         /* set the new current frame value, based on the average time */
1129         if (bed.i1) {
1130                 Scene *scene= ac.scene;
1131                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1132         }
1133         
1134         /* set notifier tha things have changed */
1135         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1136         
1137         return OPERATOR_FINISHED;
1138 }
1139
1140 void ACT_OT_keyframes_cfrasnap (wmOperatorType *ot)
1141 {
1142         /* identifiers */
1143         ot->name= "Snap Current Frame to Keys";
1144         ot->idname= "ACT_OT_keyframes_cfrasnap";
1145         
1146         /* api callbacks */
1147         ot->exec= actkeys_cfrasnap_exec;
1148         ot->poll= ED_operator_areaactive;
1149         
1150         /* flags */
1151         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1152 }
1153
1154 /* ******************** Snap Keyframes Operator *********************** */
1155
1156 /* defines for snap keyframes tool */
1157 EnumPropertyItem prop_actkeys_snap_types[] = {
1158         {ACTKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1159         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1160         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1161         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1162         {0, NULL, NULL, NULL}
1163 };
1164
1165 /* this function is responsible for snapping keyframes to frame-times */
1166 static void snap_action_keys(bAnimContext *ac, short mode) 
1167 {
1168         ListBase anim_data = {NULL, NULL};
1169         bAnimListElem *ale;
1170         int filter;
1171         
1172         BeztEditData bed;
1173         BeztEditFunc edit_cb;
1174         
1175         /* filter data */
1176         if (ac->datatype == ANIMCONT_GPENCIL)
1177                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1178         else
1179                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1180         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1181         
1182         /* get beztriple editing callbacks */
1183         edit_cb= ANIM_editkeyframes_snap(mode);
1184         
1185         memset(&bed, 0, sizeof(BeztEditData)); 
1186         bed.scene= ac->scene;
1187         
1188         /* snap keyframes */
1189         for (ale= anim_data.first; ale; ale= ale->next) {
1190                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1191                 
1192                 if (nob) {
1193                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1194                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1195                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1196                 }
1197                 //else if (ale->type == ACTTYPE_GPLAYER)
1198                 //      snap_gplayer_frames(ale->data, mode);
1199                 else 
1200                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1201         }
1202         BLI_freelistN(&anim_data);
1203 }
1204
1205 /* ------------------- */
1206
1207 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1208 {
1209         bAnimContext ac;
1210         short mode;
1211         
1212         /* get editor data */
1213         if (ANIM_animdata_get_context(C, &ac) == 0)
1214                 return OPERATOR_CANCELLED;
1215                 
1216         /* get snapping mode */
1217         mode= RNA_enum_get(op->ptr, "type");
1218         
1219         /* snap keyframes */
1220         snap_action_keys(&ac, mode);
1221         
1222         /* validate keyframes after editing */
1223         ANIM_editkeyframes_refresh(&ac);
1224         
1225         /* set notifier tha things have changed */
1226         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1227         
1228         return OPERATOR_FINISHED;
1229 }
1230  
1231 void ACT_OT_keyframes_snap (wmOperatorType *ot)
1232 {
1233         /* identifiers */
1234         ot->name= "Snap Keys";
1235         ot->idname= "ACT_OT_keyframes_snap";
1236         
1237         /* api callbacks */
1238         ot->invoke= WM_menu_invoke;
1239         ot->exec= actkeys_snap_exec;
1240         ot->poll= ED_operator_areaactive;
1241         
1242         /* flags */
1243         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1244         
1245         /* id-props */
1246         RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1247 }
1248
1249 /* ******************** Mirror Keyframes Operator *********************** */
1250
1251 /* defines for mirror keyframes tool */
1252 EnumPropertyItem prop_actkeys_mirror_types[] = {
1253         {ACTKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1254         {ACTKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1255         {ACTKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1256         {ACTKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1257         {0, NULL, NULL, NULL}
1258 };
1259
1260 /* this function is responsible for mirroring keyframes */
1261 static void mirror_action_keys(bAnimContext *ac, short mode) 
1262 {
1263         ListBase anim_data = {NULL, NULL};
1264         bAnimListElem *ale;
1265         int filter;
1266         
1267         BeztEditData bed;
1268         BeztEditFunc edit_cb;
1269         
1270         /* get beztriple editing callbacks */
1271         edit_cb= ANIM_editkeyframes_mirror(mode);
1272         
1273         memset(&bed, 0, sizeof(BeztEditData)); 
1274         bed.scene= ac->scene;
1275         
1276         /* for 'first selected marker' mode, need to find first selected marker first! */
1277         // XXX should this be made into a helper func in the API?
1278         if (mode == ACTKEYS_MIRROR_MARKER) {
1279                 Scene *scene= ac->scene;
1280                 TimeMarker *marker= NULL;
1281                 
1282                 /* find first selected marker */
1283                 for (marker= scene->markers.first; marker; marker=marker->next) {
1284                         if (marker->flag & SELECT) {
1285                                 break;
1286                         }
1287                 }
1288                 
1289                 /* store marker's time (if available) */
1290                 if (marker)
1291                         bed.f1= (float)marker->frame;
1292                 else
1293                         return;
1294         }
1295         
1296         /* filter data */
1297         if (ac->datatype == ANIMCONT_GPENCIL)
1298                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1299         else
1300                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1301         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1302         
1303         /* mirror keyframes */
1304         for (ale= anim_data.first; ale; ale= ale->next) {
1305                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1306                 
1307                 if (nob) {
1308                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1309                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1310                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1311                 }
1312                 //else if (ale->type == ACTTYPE_GPLAYER)
1313                 //      snap_gplayer_frames(ale->data, mode);
1314                 else 
1315                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1316         }
1317         BLI_freelistN(&anim_data);
1318 }
1319
1320 /* ------------------- */
1321
1322 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1323 {
1324         bAnimContext ac;
1325         short mode;
1326         
1327         /* get editor data */
1328         if (ANIM_animdata_get_context(C, &ac) == 0)
1329                 return OPERATOR_CANCELLED;
1330                 
1331         /* get mirroring mode */
1332         mode= RNA_enum_get(op->ptr, "type");
1333         
1334         /* mirror keyframes */
1335         mirror_action_keys(&ac, mode);
1336         
1337         /* validate keyframes after editing */
1338         ANIM_editkeyframes_refresh(&ac);
1339         
1340         /* set notifier tha things have changed */
1341         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1342         
1343         return OPERATOR_FINISHED;
1344 }
1345  
1346 void ACT_OT_keyframes_mirror (wmOperatorType *ot)
1347 {
1348         /* identifiers */
1349         ot->name= "Mirror Keys";
1350         ot->idname= "ACT_OT_keyframes_mirror";
1351         
1352         /* api callbacks */
1353         ot->invoke= WM_menu_invoke;
1354         ot->exec= actkeys_mirror_exec;
1355         ot->poll= ED_operator_areaactive;
1356         
1357         /* flags */
1358         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1359         
1360         /* id-props */
1361         RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1362 }
1363
1364 /* ************************************************************************** */