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