2.50: svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r17853...
[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 Action Channels, with temporary
242  *      IPO-blocks, and also temporary IpoCurves which only contain the selected keyframes.
243  * - Only pastes between compatable data is possible (i.e. same achan->name, ipo-curve type, etc.)
244  *      Unless there is only one element in the buffer, names are also tested to check for compatability.
245  * - All pasted frames are offset by the same amount. This is calculated as the difference in the times of
246  *      the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
247  * - The earliest frame is calculated per copy operation.
248  */
249
250 /* globals for copy/paste data (like for other copy/paste buffers) */
251 ListBase actcopybuf = {NULL, NULL};
252 static float actcopy_firstframe= 999999999.0f;
253
254 /* This function frees any MEM_calloc'ed copy/paste buffer data */
255 // XXX find some header to put this in!
256 void free_actcopybuf ()
257 {
258         FCurve *fcu, *fcn;
259         
260         /* free_fcurve() frees F-Curve memory too, but we don't need to do remlink first, as we're freeing all 
261          * channels anyway, and the freeing func only cares about the data it's given
262          */
263         for (fcu= actcopybuf.first; fcu; fcu= fcn) {
264                 fcn= fcu->next;
265                 free_fcurve(fcu);
266         }
267         
268         actcopybuf.first= actcopybuf.last= NULL;
269         actcopy_firstframe= 999999999.0f;
270 }
271
272 /* ------------------- */
273
274 /* This function adds data to the copy/paste buffer, freeing existing data first
275  * Only the selected action channels gets their selected keyframes copied.
276  */
277 static short copy_action_keys (bAnimContext *ac)
278 {       
279 #if 0 // XXX old animation system
280         ListBase anim_data = {NULL, NULL};
281         bAnimListElem *ale;
282         int filter;
283         
284         /* clear buffer first */
285         free_actcopybuf();
286         
287         /* filter data */
288         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_IPOKEYS);
289         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
290         
291         /* assume that each of these is an ipo-block */
292         for (ale= anim_data.first; ale; ale= ale->next) {
293                 bActionChannel *achan;
294                 Ipo *ipo= ale->key_data;
295                 Ipo *ipn;
296                 IpoCurve *icu, *icn;
297                 BezTriple *bezt;
298                 int i;
299                 
300                 /* coerce an action-channel out of owner */
301                 if (ale->ownertype == ANIMTYPE_ACHAN) {
302                         bActionChannel *achanO= ale->owner;
303                         achan= MEM_callocN(sizeof(bActionChannel), "ActCopyPasteAchan");
304                         strcpy(achan->name, achanO->name);
305                 }
306                 else if (ale->ownertype == ANIMTYPE_SHAPEKEY) {
307                         achan= MEM_callocN(sizeof(bActionChannel), "ActCopyPasteAchan");
308                         strcpy(achan->name, "#ACP_ShapeKey");
309                 }
310                 else
311                         continue;
312                 BLI_addtail(&actcopybuf, achan);
313                 
314                 /* add constraint channel if needed, then add new ipo-block */
315                 if (ale->type == ANIMTYPE_CONCHAN) {
316                         bConstraintChannel *conchanO= ale->data;
317                         bConstraintChannel *conchan;
318                         
319                         conchan= MEM_callocN(sizeof(bConstraintChannel), "ActCopyPasteConchan");
320                         strcpy(conchan->name, conchanO->name);
321                         BLI_addtail(&achan->constraintChannels, conchan);
322                         
323                         conchan->ipo= ipn= MEM_callocN(sizeof(Ipo), "ActCopyPasteIpo");
324                 }
325                 else {
326                         achan->ipo= ipn= MEM_callocN(sizeof(Ipo), "ActCopyPasteIpo");
327                 }
328                 ipn->blocktype = ipo->blocktype;
329                 
330                 /* now loop through curves, and only copy selected keyframes */
331                 for (icu= ipo->curve.first; icu; icu= icu->next) {
332                         /* allocate a new curve */
333                         icn= MEM_callocN(sizeof(IpoCurve), "ActCopyPasteIcu");
334                         icn->blocktype = icu->blocktype;
335                         icn->adrcode = icu->adrcode;
336                         BLI_addtail(&ipn->curve, icn);
337                         
338                         /* find selected BezTriples to add to the buffer (and set first frame) */
339                         for (i=0, bezt=icu->bezt; i < icu->totvert; i++, bezt++) {
340                                 if (BEZSELECTED(bezt)) {
341                                         /* add to buffer ipo-curve */
342                                         //insert_bezt_icu(icn, bezt); // XXX
343                                         
344                                         /* check if this is the earliest frame encountered so far */
345                                         if (bezt->vec[1][0] < actcopy_firstframe)
346                                                 actcopy_firstframe= bezt->vec[1][0];
347                                 }
348                         }
349                 }
350         }
351         
352         /* check if anything ended up in the buffer */
353         if (ELEM(NULL, actcopybuf.first, actcopybuf.last))
354         //      error("Nothing copied to buffer");
355                 return -1;
356         
357         /* free temp memory */
358         BLI_freelistN(&anim_data);
359 #endif // XXX old animation system
360         
361         /* everything went fine */
362         return 0;
363 }
364
365 static short paste_action_keys (bAnimContext *ac)
366 {
367 #if 0 // XXX old animation system
368         ListBase anim_data = {NULL, NULL};
369         bAnimListElem *ale;
370         int filter;
371         
372         const Scene *scene= (ac->scene);
373         const float offset = (float)(CFRA - actcopy_firstframe);
374         char *actname = NULL, *conname = NULL;
375         short no_name= 0;
376         
377         /* check if buffer is empty */
378         if (ELEM(NULL, actcopybuf.first, actcopybuf.last)) {
379                 //error("No data in buffer to paste");
380                 return -1;
381         }
382         /* check if single channel in buffer (disregard names if so)  */
383         if (actcopybuf.first == actcopybuf.last)
384                 no_name= 1;
385         
386         /* filter data */
387         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_IPOKEYS);
388         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
389         
390         /* from selected channels */
391         for (ale= anim_data.first; ale; ale= ale->next) {
392                 Ipo *ipo_src = NULL;
393                 bActionChannel *achan;
394                 IpoCurve *ico, *icu;
395                 BezTriple *bezt;
396                 int i;
397                 
398                 /* find suitable IPO-block from buffer to paste from */
399                 for (achan= actcopybuf.first; achan; achan= achan->next) {
400                         /* try to match data */
401                         if (ale->ownertype == ANIMTYPE_ACHAN) {
402                                 bActionChannel *achant= ale->owner;
403                                 
404                                 /* check if we have a corresponding action channel */
405                                 if ((no_name) || (strcmp(achan->name, achant->name)==0)) {
406                                         actname= achant->name;
407                                         
408                                         /* check if this is a constraint channel */
409                                         if (ale->type == ANIMTYPE_CONCHAN) {
410                                                 bConstraintChannel *conchant= ale->data;
411                                                 bConstraintChannel *conchan;
412                                                 
413                                                 for (conchan=achan->constraintChannels.first; conchan; conchan=conchan->next) {
414                                                         if (strcmp(conchan->name, conchant->name)==0) {
415                                                                 conname= conchant->name;
416                                                                 ipo_src= conchan->ipo;
417                                                                 break;
418                                                         }
419                                                 }
420                                                 if (ipo_src) break;
421                                         }
422                                         else {
423                                                 ipo_src= achan->ipo;
424                                                 break;
425                                         }
426                                 }
427                         }
428                         else if (ale->ownertype == ANIMTYPE_SHAPEKEY) {
429                                 /* check if this action channel is "#ACP_ShapeKey" */
430                                 if ((no_name) || (strcmp(achan->name, "#ACP_ShapeKey")==0)) {
431                                         actname= NULL;
432                                         ipo_src= achan->ipo;
433                                         break;
434                                 }
435                         }       
436                 }
437                 
438                 /* this shouldn't happen, but it might */
439                 if (ipo_src == NULL)
440                         continue;
441                 
442                 /* loop over curves, pasting keyframes */
443                 for (ico= ipo_src->curve.first; ico; ico= ico->next) {
444                         /* get IPO-curve to paste to (IPO-curve might not exist for destination, so gets created) */
445                         //icu= verify_ipocurve(ale->id, ico->blocktype, actname, conname, NULL, ico->adrcode, 1);
446                         
447                         
448                         if (icu) {
449                                 /* just start pasting, with the the first keyframe on the current frame, and so on */
450                                 for (i=0, bezt=ico->bezt; i < ico->totvert; i++, bezt++) {                                              
451                                         /* temporarily apply offset to src beztriple while copying */
452                                         bezt->vec[0][0] += offset;
453                                         bezt->vec[1][0] += offset;
454                                         bezt->vec[2][0] += offset;
455                                         
456                                         /* insert the keyframe */
457                                         //insert_bezt_icu(icu, bezt); // XXX
458                                         
459                                         /* un-apply offset from src beztriple after copying */
460                                         bezt->vec[0][0] -= offset;
461                                         bezt->vec[1][0] -= offset;
462                                         bezt->vec[2][0] -= offset;
463                                 }
464                                 
465                                 /* recalculate channel's handles? */
466                                 //calchandles_fcurve(fcu);
467                         }
468                 }
469         }
470         
471         /* free temp memory */
472         BLI_freelistN(&anim_data);
473         
474         /* do depsgraph updates (for 3d-view)? */
475 #if 0
476         if ((ob) && (G.saction->pin==0)) {
477                 if (ob->type == OB_ARMATURE)
478                         DAG_object_flush_update(G.scene, ob, OB_RECALC_OB|OB_RECALC_DATA);
479                 else
480                         DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
481         }
482 #endif
483
484 #endif // XXX old animation system
485
486         return 0;
487 }
488
489 /* ------------------- */
490
491 static int actkeys_copy_exec(bContext *C, wmOperator *op)
492 {
493         bAnimContext ac;
494         
495         /* get editor data */
496         if (ANIM_animdata_get_context(C, &ac) == 0)
497                 return OPERATOR_CANCELLED;
498         
499         /* copy keyframes */
500         if (ac.datatype == ANIMCONT_GPENCIL) {
501                 // FIXME...
502         }
503         else {
504                 if (copy_action_keys(&ac)) {    
505                         // XXX errors - need a way to inform the user 
506                         printf("Action Copy: No keyframes copied to copy-paste buffer\n");
507                 }
508         }
509         
510         /* set notifier tha things have changed */
511         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
512         
513         return OPERATOR_FINISHED;
514 }
515  
516 void ACT_OT_keyframes_copy (wmOperatorType *ot)
517 {
518         /* identifiers */
519         ot->name= "Copy Keyframes";
520         ot->idname= "ACT_OT_keyframes_copy";
521         
522         /* api callbacks */
523         ot->exec= actkeys_copy_exec;
524         ot->poll= ED_operator_areaactive;
525         
526         /* flags */
527         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
528 }
529
530
531
532 static int actkeys_paste_exec(bContext *C, wmOperator *op)
533 {
534         bAnimContext ac;
535         
536         /* get editor data */
537         if (ANIM_animdata_get_context(C, &ac) == 0)
538                 return OPERATOR_CANCELLED;
539         
540         /* paste keyframes */
541         if (ac.datatype == ANIMCONT_GPENCIL) {
542                 // FIXME...
543         }
544         else {
545                 if (paste_action_keys(&ac)) {
546                         // XXX errors - need a way to inform the user 
547                         printf("Action Paste: Nothing to paste, as Copy-Paste buffer was empty.\n");
548                 }
549         }
550         
551         /* validate keyframes after editing */
552         ANIM_editkeyframes_refresh(&ac);
553         
554         /* set notifier tha things have changed */
555         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
556         
557         return OPERATOR_FINISHED;
558 }
559  
560 void ACT_OT_keyframes_paste (wmOperatorType *ot)
561 {
562         /* identifiers */
563         ot->name= "Paste Keyframes";
564         ot->idname= "ACT_OT_keyframes_paste";
565         
566         /* api callbacks */
567         ot->exec= actkeys_paste_exec;
568         ot->poll= ED_operator_areaactive;
569         
570         /* flags */
571         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
572 }
573
574 /* ******************** Delete Keyframes Operator ************************* */
575
576 static void delete_action_keys (bAnimContext *ac)
577 {
578         ListBase anim_data = {NULL, NULL};
579         bAnimListElem *ale;
580         int filter;
581         
582         /* filter data */
583         if (ac->datatype == ANIMCONT_GPENCIL)
584                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
585         else
586                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
587         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
588         
589         /* loop through filtered data and delete selected keys */
590         for (ale= anim_data.first; ale; ale= ale->next) {
591                 //if (ale->type == ANIMTYPE_GPLAYER)
592                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
593                 //else
594                         delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
595         }
596         
597         /* free filtered list */
598         BLI_freelistN(&anim_data);
599 }
600
601 /* ------------------- */
602
603 static int actkeys_delete_exec(bContext *C, wmOperator *op)
604 {
605         bAnimContext ac;
606         
607         /* get editor data */
608         if (ANIM_animdata_get_context(C, &ac) == 0)
609                 return OPERATOR_CANCELLED;
610                 
611         /* delete keyframes */
612         delete_action_keys(&ac);
613         
614         /* validate keyframes after editing */
615         ANIM_editkeyframes_refresh(&ac);
616         
617         /* set notifier tha things have changed */
618         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
619         
620         return OPERATOR_FINISHED;
621 }
622  
623 void ACT_OT_keyframes_delete (wmOperatorType *ot)
624 {
625         /* identifiers */
626         ot->name= "Delete Keyframes";
627         ot->idname= "ACT_OT_keyframes_delete";
628         
629         /* api callbacks */
630         ot->exec= actkeys_delete_exec;
631         ot->poll= ED_operator_areaactive;
632         
633         /* flags */
634         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
635 }
636
637 /* ******************** Clean Keyframes Operator ************************* */
638
639 static void clean_action_keys (bAnimContext *ac, float thresh)
640 {       
641         ListBase anim_data = {NULL, NULL};
642         bAnimListElem *ale;
643         int filter;
644         
645         /* filter data */
646         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
647         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
648         
649         /* loop through filtered data and clean curves */
650         for (ale= anim_data.first; ale; ale= ale->next)
651                 clean_fcurve((FCurve *)ale->key_data, thresh);
652         
653         /* free temp data */
654         BLI_freelistN(&anim_data);
655 }
656
657 /* ------------------- */
658
659 static int actkeys_clean_exec(bContext *C, wmOperator *op)
660 {
661         bAnimContext ac;
662         float thresh;
663         
664         /* get editor data */
665         if (ANIM_animdata_get_context(C, &ac) == 0)
666                 return OPERATOR_CANCELLED;
667         if (ac.datatype == ANIMCONT_GPENCIL)
668                 return OPERATOR_PASS_THROUGH;
669                 
670         /* get cleaning threshold */
671         thresh= RNA_float_get(op->ptr, "threshold");
672         
673         /* clean keyframes */
674         clean_action_keys(&ac, thresh);
675         
676         /* validate keyframes after editing */
677         ANIM_editkeyframes_refresh(&ac);
678         
679         /* set notifier tha things have changed */
680         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
681         
682         return OPERATOR_FINISHED;
683 }
684  
685 void ACT_OT_keyframes_clean (wmOperatorType *ot)
686 {
687         /* identifiers */
688         ot->name= "Clean Keyframes";
689         ot->idname= "ACT_OT_keyframes_clean";
690         
691         /* api callbacks */
692         //ot->invoke=  // XXX we need that number popup for this! 
693         ot->exec= actkeys_clean_exec;
694         ot->poll= ED_operator_areaactive;
695         
696         /* flags */
697         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
698         
699         /* properties */
700         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
701 }
702
703 /* ******************** Sample Keyframes Operator *********************** */
704
705 /* little cache for values... */
706 typedef struct tempFrameValCache {
707         float frame, val;
708 } tempFrameValCache;
709
710 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
711 static void sample_action_keys (bAnimContext *ac)
712 {       
713         ListBase anim_data = {NULL, NULL};
714         bAnimListElem *ale;
715         int filter;
716         
717         /* filter data */
718         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
719         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
720         
721         /* loop through filtered data and add keys between selected keyframes on every frame  */
722         for (ale= anim_data.first; ale; ale= ale->next) {
723                 FCurve *fcu= (FCurve *)ale->key_data;
724                 BezTriple *bezt, *start=NULL, *end=NULL;
725                 tempFrameValCache *value_cache, *fp;
726                 int sfra, range;
727                 int i, n;
728                 
729                 /* find selected keyframes... once pair has been found, add keyframes  */
730                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
731                         /* check if selected, and which end this is */
732                         if (BEZSELECTED(bezt)) {
733                                 if (start) {
734                                         /* set end */
735                                         end= bezt;
736                                         
737                                         /* cache values then add keyframes using these values, as adding
738                                          * keyframes while sampling will affect the outcome...
739                                          */
740                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
741                                         sfra= (int)( floor(start->vec[1][0]) );
742                                         
743                                         if (range) {
744                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
745                                                 
746                                                 /*      sample values   */
747                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
748                                                         fp->frame= (float)(sfra + n);
749                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
750                                                 }
751                                                 
752                                                 /*      add keyframes with these        */
753                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
754                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
755                                                 }
756                                                 
757                                                 /* free temp cache */
758                                                 MEM_freeN(value_cache);
759                                                 
760                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
761                                                 bezt = fcu->bezt + i + range - 1;
762                                                 i += (range - 1);
763                                         }
764                                         
765                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
766                                         start= bezt;
767                                         end= NULL;
768                                 }
769                                 else {
770                                         /* just set start keyframe */
771                                         start= bezt;
772                                         end= NULL;
773                                 }
774                         }
775                 }
776                 
777                 /* recalculate channel's handles? */
778                 calchandles_fcurve(fcu);
779         }
780         
781         /* admin and redraws */
782         BLI_freelistN(&anim_data);
783 }
784
785 /* ------------------- */
786
787 static int actkeys_sample_exec(bContext *C, wmOperator *op)
788 {
789         bAnimContext ac;
790         
791         /* get editor data */
792         if (ANIM_animdata_get_context(C, &ac) == 0)
793                 return OPERATOR_CANCELLED;
794         if (ac.datatype == ANIMCONT_GPENCIL)
795                 return OPERATOR_PASS_THROUGH;
796         
797         /* sample keyframes */
798         sample_action_keys(&ac);
799         
800         /* validate keyframes after editing */
801         ANIM_editkeyframes_refresh(&ac);
802         
803         /* set notifier tha things have changed */
804         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
805         
806         return OPERATOR_FINISHED;
807 }
808  
809 void ACT_OT_keyframes_sample (wmOperatorType *ot)
810 {
811         /* identifiers */
812         ot->name= "Sample Keyframes";
813         ot->idname= "ACT_OT_keyframes_sample";
814         
815         /* api callbacks */
816         ot->exec= actkeys_sample_exec;
817         ot->poll= ED_operator_areaactive;
818         
819         /* flags */
820         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
821 }
822
823 /* ************************************************************************** */
824 /* SETTINGS STUFF */
825
826 /* ******************** Set Extrapolation-Type Operator *********************** */
827
828 // XXX rename this operator...
829
830 /* defines for set extrapolation-type for selected keyframes tool */
831 EnumPropertyItem prop_actkeys_expo_types[] = {
832         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
833         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
834         {0, NULL, NULL, NULL}
835 };
836
837 /* this function is responsible for setting extrapolation mode for keyframes */
838 static void setexpo_action_keys(bAnimContext *ac, short mode) 
839 {
840         ListBase anim_data = {NULL, NULL};
841         bAnimListElem *ale;
842         int filter;
843         
844         /* filter data */
845         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
846         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
847         
848         /* loop through setting mode per F-Curve */
849         for (ale= anim_data.first; ale; ale= ale->next) {
850                 FCurve *fcu= (FCurve *)ale->data;
851                 fcu->extend= mode;
852         }
853         
854         /* cleanup */
855         BLI_freelistN(&anim_data);
856 }
857
858 /* ------------------- */
859
860 static int actkeys_expo_exec(bContext *C, wmOperator *op)
861 {
862         bAnimContext ac;
863         short mode;
864         
865         /* get editor data */
866         if (ANIM_animdata_get_context(C, &ac) == 0)
867                 return OPERATOR_CANCELLED;
868         if (ac.datatype == ANIMCONT_GPENCIL) 
869                 return OPERATOR_PASS_THROUGH;
870                 
871         /* get handle setting mode */
872         mode= RNA_enum_get(op->ptr, "type");
873         
874         /* set handle type */
875         setexpo_action_keys(&ac, mode);
876         
877         /* validate keyframes after editing */
878         ANIM_editkeyframes_refresh(&ac);
879         
880         /* set notifier tha things have changed */
881         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
882         
883         return OPERATOR_FINISHED;
884 }
885  
886 void ACT_OT_keyframes_expotype (wmOperatorType *ot)
887 {
888         /* identifiers */
889         ot->name= "Set Keyframe Extrapolation";
890         ot->idname= "ACT_OT_keyframes_expotype";
891         
892         /* api callbacks */
893         ot->invoke= WM_menu_invoke;
894         ot->exec= actkeys_expo_exec;
895         ot->poll= ED_operator_areaactive;
896         
897         /* flags */
898         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
899         
900         /* id-props */
901         RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
902 }
903
904 /* ******************** Set Interpolation-Type Operator *********************** */
905
906 /* defines for set ipo-type for selected keyframes tool */
907 EnumPropertyItem prop_actkeys_ipo_types[] = {
908         {BEZT_IPO_CONST, "CONSTANT", "Constant Interpolation", ""},
909         {BEZT_IPO_LIN, "LINEAR", "Linear Interpolation", ""},
910         {BEZT_IPO_BEZ, "BEZIER", "Bezier Interpolation", ""},
911         {0, NULL, NULL, NULL}
912 };
913
914 /* this function is responsible for setting interpolation mode for keyframes */
915 static void setipo_action_keys(bAnimContext *ac, short mode) 
916 {
917         ListBase anim_data = {NULL, NULL};
918         bAnimListElem *ale;
919         int filter;
920         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
921         
922         /* filter data */
923         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
924         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
925         
926         /* loop through setting BezTriple interpolation
927          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
928          */
929         for (ale= anim_data.first; ale; ale= ale->next)
930                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
931         
932         /* cleanup */
933         BLI_freelistN(&anim_data);
934 }
935
936 /* ------------------- */
937
938 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
939 {
940         bAnimContext ac;
941         short mode;
942         
943         /* get editor data */
944         if (ANIM_animdata_get_context(C, &ac) == 0)
945                 return OPERATOR_CANCELLED;
946         if (ac.datatype == ANIMCONT_GPENCIL) 
947                 return OPERATOR_PASS_THROUGH;
948                 
949         /* get handle setting mode */
950         mode= RNA_enum_get(op->ptr, "type");
951         
952         /* set handle type */
953         setipo_action_keys(&ac, mode);
954         
955         /* validate keyframes after editing */
956         ANIM_editkeyframes_refresh(&ac);
957         
958         /* set notifier tha things have changed */
959         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
960         
961         return OPERATOR_FINISHED;
962 }
963  
964 void ACT_OT_keyframes_ipotype (wmOperatorType *ot)
965 {
966         /* identifiers */
967         ot->name= "Set Keyframe Interpolation";
968         ot->idname= "ACT_OT_keyframes_ipotype";
969         
970         /* api callbacks */
971         ot->invoke= WM_menu_invoke;
972         ot->exec= actkeys_ipo_exec;
973         ot->poll= ED_operator_areaactive;
974         
975         /* flags */
976         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
977         
978         /* id-props */
979         RNA_def_enum(ot->srna, "type", prop_actkeys_ipo_types, 0, "Type", "");
980 }
981
982 /* ******************** Set Handle-Type Operator *********************** */
983
984 /* defines for set handle-type for selected keyframes tool */
985 EnumPropertyItem prop_actkeys_handletype_types[] = {
986         {HD_AUTO, "AUTO", "Auto Handles", ""},
987         {HD_VECT, "VECTOR", "Vector Handles", ""},
988         {HD_FREE, "FREE", "Free Handles", ""},
989         {HD_ALIGN, "ALIGN", "Aligned Handles", ""},
990 //      {-1, "TOGGLE", "Toggle between Free and Aligned Handles", ""},
991         {0, NULL, NULL, NULL}
992 };
993
994 /* this function is responsible for setting handle-type of selected keyframes */
995 static void sethandles_action_keys(bAnimContext *ac, short mode) 
996 {
997         ListBase anim_data = {NULL, NULL};
998         bAnimListElem *ale;
999         int filter;
1000         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
1001         
1002         /* filter data */
1003         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1004         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1005         
1006         /* loop through setting flags for handles 
1007          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
1008          */
1009         for (ale= anim_data.first; ale; ale= ale->next) {
1010                 if (mode == -1) {       
1011                         BeztEditFunc toggle_cb;
1012                         
1013                         /* check which type of handle to set (free or aligned) 
1014                          *      - check here checks for handles with free alignment already
1015                          */
1016                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
1017                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
1018                         else
1019                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
1020                                 
1021                         /* set handle-type */
1022                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
1023                 }
1024                 else {
1025                         /* directly set handle-type */
1026                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1027                 }
1028         }
1029         
1030         /* cleanup */
1031         BLI_freelistN(&anim_data);
1032 }
1033
1034 /* ------------------- */
1035
1036 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
1037 {
1038         bAnimContext ac;
1039         short mode;
1040         
1041         /* get editor data */
1042         if (ANIM_animdata_get_context(C, &ac) == 0)
1043                 return OPERATOR_CANCELLED;
1044         if (ac.datatype == ANIMCONT_GPENCIL) 
1045                 return OPERATOR_PASS_THROUGH;
1046                 
1047         /* get handle setting mode */
1048         mode= RNA_enum_get(op->ptr, "type");
1049         
1050         /* set handle type */
1051         sethandles_action_keys(&ac, mode);
1052         
1053         /* validate keyframes after editing */
1054         ANIM_editkeyframes_refresh(&ac);
1055         
1056         /* set notifier tha things have changed */
1057         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1058         
1059         return OPERATOR_FINISHED;
1060 }
1061  
1062 void ACT_OT_keyframes_handletype (wmOperatorType *ot)
1063 {
1064         /* identifiers */
1065         ot->name= "Set Keyframe Handle Type";
1066         ot->idname= "ACT_OT_keyframes_handletype";
1067         
1068         /* api callbacks */
1069         ot->invoke= WM_menu_invoke;
1070         ot->exec= actkeys_handletype_exec;
1071         ot->poll= ED_operator_areaactive;
1072         
1073         /* flags */
1074         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
1075         
1076         /* id-props */
1077         RNA_def_enum(ot->srna, "type", prop_actkeys_handletype_types, 0, "Type", "");
1078 }
1079
1080 /* ************************************************************************** */
1081 /* TRANSFORM STUFF */
1082
1083 /* ***************** Snap Current Frame Operator *********************** */
1084
1085 /* helper callback for actkeys_cfrasnap_exec() -> used to help get the average time of all selected beztriples */
1086 // TODO: if some other code somewhere needs this, it'll be time to port this over to keyframes_edit.c!!!
1087 static short bezt_calc_average(BeztEditData *bed, BezTriple *bezt)
1088 {
1089         /* only if selected */
1090         if (bezt->f2 & SELECT) {
1091                 /* store average time in float (only do rounding at last step */
1092                 bed->f1 += bezt->vec[1][0];
1093                 
1094                 /* increment number of items */
1095                 bed->i1++;
1096         }
1097         
1098         return 0;
1099 }
1100
1101 /* snap current-frame indicator to 'average time' of selected keyframe */
1102 static int actkeys_cfrasnap_exec(bContext *C, wmOperator *op)
1103 {
1104         bAnimContext ac;
1105         ListBase anim_data= {NULL, NULL};
1106         bAnimListElem *ale;
1107         int filter;
1108         BeztEditData bed;
1109         
1110         /* get editor data */
1111         if (ANIM_animdata_get_context(C, &ac) == 0)
1112                 return OPERATOR_CANCELLED;
1113         
1114         /* init edit data */
1115         memset(&bed, 0, sizeof(BeztEditData));
1116         
1117         /* loop over action data, averaging values */
1118         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
1119         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1120         
1121         for (ale= anim_data.first; ale; ale= ale->next)
1122                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1123         
1124         BLI_freelistN(&anim_data);
1125         
1126         /* set the new current frame value, based on the average time */
1127         if (bed.i1) {
1128                 Scene *scene= ac.scene;
1129                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1130         }
1131         
1132         /* set notifier tha things have changed */
1133         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1134         
1135         return OPERATOR_FINISHED;
1136 }
1137
1138 void ACT_OT_keyframes_cfrasnap (wmOperatorType *ot)
1139 {
1140         /* identifiers */
1141         ot->name= "Snap Current Frame to Keys";
1142         ot->idname= "ACT_OT_keyframes_cfrasnap";
1143         
1144         /* api callbacks */
1145         ot->exec= actkeys_cfrasnap_exec;
1146         ot->poll= ED_operator_areaactive;
1147         
1148         /* flags */
1149         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
1150 }
1151
1152 /* ******************** Snap Keyframes Operator *********************** */
1153
1154 /* defines for snap keyframes tool */
1155 EnumPropertyItem prop_actkeys_snap_types[] = {
1156         {ACTKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1157         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1158         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1159         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1160         {0, NULL, NULL, NULL}
1161 };
1162
1163 /* this function is responsible for snapping keyframes to frame-times */
1164 static void snap_action_keys(bAnimContext *ac, short mode) 
1165 {
1166         ListBase anim_data = {NULL, NULL};
1167         bAnimListElem *ale;
1168         int filter;
1169         
1170         BeztEditData bed;
1171         BeztEditFunc edit_cb;
1172         
1173         /* filter data */
1174         if (ac->datatype == ANIMCONT_GPENCIL)
1175                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1176         else
1177                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1178         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1179         
1180         /* get beztriple editing callbacks */
1181         edit_cb= ANIM_editkeyframes_snap(mode);
1182         
1183         memset(&bed, 0, sizeof(BeztEditData)); 
1184         bed.scene= ac->scene;
1185         
1186         /* snap keyframes */
1187         for (ale= anim_data.first; ale; ale= ale->next) {
1188                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1189                 
1190                 if (nob) {
1191                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1192                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1193                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1194                 }
1195                 //else if (ale->type == ACTTYPE_GPLAYER)
1196                 //      snap_gplayer_frames(ale->data, mode);
1197                 else 
1198                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1199         }
1200         BLI_freelistN(&anim_data);
1201 }
1202
1203 /* ------------------- */
1204
1205 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1206 {
1207         bAnimContext ac;
1208         short mode;
1209         
1210         /* get editor data */
1211         if (ANIM_animdata_get_context(C, &ac) == 0)
1212                 return OPERATOR_CANCELLED;
1213                 
1214         /* get snapping mode */
1215         mode= RNA_enum_get(op->ptr, "type");
1216         
1217         /* snap keyframes */
1218         snap_action_keys(&ac, mode);
1219         
1220         /* validate keyframes after editing */
1221         ANIM_editkeyframes_refresh(&ac);
1222         
1223         /* set notifier tha things have changed */
1224         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1225         
1226         return OPERATOR_FINISHED;
1227 }
1228  
1229 void ACT_OT_keyframes_snap (wmOperatorType *ot)
1230 {
1231         /* identifiers */
1232         ot->name= "Snap Keys";
1233         ot->idname= "ACT_OT_keyframes_snap";
1234         
1235         /* api callbacks */
1236         ot->invoke= WM_menu_invoke;
1237         ot->exec= actkeys_snap_exec;
1238         ot->poll= ED_operator_areaactive;
1239         
1240         /* flags */
1241         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
1242         
1243         /* id-props */
1244         RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1245 }
1246
1247 /* ******************** Mirror Keyframes Operator *********************** */
1248
1249 /* defines for mirror keyframes tool */
1250 EnumPropertyItem prop_actkeys_mirror_types[] = {
1251         {ACTKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1252         {ACTKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1253         {ACTKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1254         {ACTKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1255         {0, NULL, NULL, NULL}
1256 };
1257
1258 /* this function is responsible for mirroring keyframes */
1259 static void mirror_action_keys(bAnimContext *ac, short mode) 
1260 {
1261         ListBase anim_data = {NULL, NULL};
1262         bAnimListElem *ale;
1263         int filter;
1264         
1265         BeztEditData bed;
1266         BeztEditFunc edit_cb;
1267         
1268         /* get beztriple editing callbacks */
1269         edit_cb= ANIM_editkeyframes_mirror(mode);
1270         
1271         memset(&bed, 0, sizeof(BeztEditData)); 
1272         bed.scene= ac->scene;
1273         
1274         /* for 'first selected marker' mode, need to find first selected marker first! */
1275         // XXX should this be made into a helper func in the API?
1276         if (mode == ACTKEYS_MIRROR_MARKER) {
1277                 Scene *scene= ac->scene;
1278                 TimeMarker *marker= NULL;
1279                 
1280                 /* find first selected marker */
1281                 for (marker= scene->markers.first; marker; marker=marker->next) {
1282                         if (marker->flag & SELECT) {
1283                                 break;
1284                         }
1285                 }
1286                 
1287                 /* store marker's time (if available) */
1288                 if (marker)
1289                         bed.f1= (float)marker->frame;
1290                 else
1291                         return;
1292         }
1293         
1294         /* filter data */
1295         if (ac->datatype == ANIMCONT_GPENCIL)
1296                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1297         else
1298                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1299         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1300         
1301         /* mirror keyframes */
1302         for (ale= anim_data.first; ale; ale= ale->next) {
1303                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1304                 
1305                 if (nob) {
1306                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1307                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1308                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1309                 }
1310                 //else if (ale->type == ACTTYPE_GPLAYER)
1311                 //      snap_gplayer_frames(ale->data, mode);
1312                 else 
1313                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1314         }
1315         BLI_freelistN(&anim_data);
1316 }
1317
1318 /* ------------------- */
1319
1320 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1321 {
1322         bAnimContext ac;
1323         short mode;
1324         
1325         /* get editor data */
1326         if (ANIM_animdata_get_context(C, &ac) == 0)
1327                 return OPERATOR_CANCELLED;
1328                 
1329         /* get mirroring mode */
1330         mode= RNA_enum_get(op->ptr, "type");
1331         
1332         /* mirror keyframes */
1333         mirror_action_keys(&ac, mode);
1334         
1335         /* validate keyframes after editing */
1336         ANIM_editkeyframes_refresh(&ac);
1337         
1338         /* set notifier tha things have changed */
1339         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1340         
1341         return OPERATOR_FINISHED;
1342 }
1343  
1344 void ACT_OT_keyframes_mirror (wmOperatorType *ot)
1345 {
1346         /* identifiers */
1347         ot->name= "Mirror Keys";
1348         ot->idname= "ACT_OT_keyframes_mirror";
1349         
1350         /* api callbacks */
1351         ot->invoke= WM_menu_invoke;
1352         ot->exec= actkeys_mirror_exec;
1353         ot->poll= ED_operator_areaactive;
1354         
1355         /* flags */
1356         ot->flag= OPTYPE_REGISTER/*|OPTYPE_UNDO*/;
1357         
1358         /* id-props */
1359         RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1360 }
1361
1362 /* ************************************************************************** */