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