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