132beec85c97c43ef73109d266001a2c1f4933f4
[blender.git] / source / blender / editors / space_graph / graph_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 "graph_intern.h"
88
89 /* ************************************************************************** */
90 /* KEYFRAME-RANGE STUFF */
91
92 /* *************************** Calculate Range ************************** */
93
94 /* Get the min/max keyframes*/
95 static void get_graph_keyframe_extents (bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax)
96 {
97         ListBase anim_data = {NULL, NULL};
98         bAnimListElem *ale;
99         int filter;
100         
101         /* get data to filter, from Dopesheet */
102         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | 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         if (xmin) *xmin= 999999999.0f;
107         if (xmax) *xmax= -999999999.0f;
108         if (ymin) *ymin= 999999999.0f;
109         if (ymax) *ymax= -999999999.0f;
110         
111         /* check if any channels to set range with */
112         if (anim_data.first) {
113                 /* go through channels, finding max extents */
114                 for (ale= anim_data.first; ale; ale= ale->next) {
115                         Object *nob= NULL; //ANIM_nla_mapping_get(ac, ale);
116                         FCurve *fcu= (FCurve *)ale->key_data;
117                         float tmin, tmax;
118                         
119                         /* get range and apply necessary scaling before */
120                         calc_fcurve_bounds(fcu, &tmin, &tmax, ymin, ymax);
121                         
122                         if (nob) {
123                                 tmin= get_action_frame_inv(nob, tmin);
124                                 tmax= get_action_frame_inv(nob, tmax);
125                         }
126                         
127                         /* try to set cur using these values, if they're more extreme than previously set values */
128                         if (xmin) *xmin= MIN2(*xmin, tmin);
129                         if (xmax) *xmax= MAX2(*xmax, tmax);
130                 }
131                 
132                 /* free memory */
133                 BLI_freelistN(&anim_data);
134         }
135         else {
136                 /* set default range */
137                 if (ac->scene) {
138                         if (xmin) *xmin= (float)ac->scene->r.sfra;
139                         if (xmax) *xmax= (float)ac->scene->r.efra;
140                 }
141                 else {
142                         if (xmin) *xmin= -5;
143                         if (xmax) *xmax= 100;
144                 }
145                 
146                 if (ymin) *ymin= -5;
147                 if (ymax) *ymax= 5;
148         }
149 }
150
151 /* ****************** Automatic Preview-Range Operator ****************** */
152
153 static int graphkeys_previewrange_exec(bContext *C, wmOperator *op)
154 {
155         bAnimContext ac;
156         Scene *scene;
157         float min, max;
158         
159         /* get editor data */
160         if (ANIM_animdata_get_context(C, &ac) == 0)
161                 return OPERATOR_CANCELLED;
162         if (ac.scene == NULL)
163                 return OPERATOR_CANCELLED;
164         else
165                 scene= ac.scene;
166         
167         /* set the range directly */
168         get_graph_keyframe_extents(&ac, &min, &max, NULL, NULL);
169         scene->r.psfra= (int)floor(min + 0.5f);
170         scene->r.pefra= (int)floor(max + 0.5f);
171         
172         /* set notifier that things have changed */
173         // XXX err... there's nothing for frame ranges yet, but this should do fine too
174         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene); 
175         
176         return OPERATOR_FINISHED;
177 }
178  
179 void GRAPHEDIT_OT_set_previewrange (wmOperatorType *ot)
180 {
181         /* identifiers */
182         ot->name= "Auto-Set Preview Range";
183         ot->idname= "GRAPHEDIT_OT_set_previewrange";
184         
185         /* api callbacks */
186         ot->exec= graphkeys_previewrange_exec;
187         ot->poll= ED_operator_areaactive;
188         
189         /* flags */
190         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
191 }
192
193 /* ****************** View-All Operator ****************** */
194
195 static int graphkeys_viewall_exec(bContext *C, wmOperator *op)
196 {
197         bAnimContext ac;
198         View2D *v2d;
199         float extra;
200         
201         /* get editor data */
202         if (ANIM_animdata_get_context(C, &ac) == 0)
203                 return OPERATOR_CANCELLED;
204         v2d= &ac.ar->v2d;
205         
206         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
207         get_graph_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, &v2d->cur.ymin, &v2d->cur.ymax);
208         
209         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
210         v2d->cur.xmin -= extra;
211         v2d->cur.xmax += extra;
212         
213         extra= 0.1f * (v2d->cur.ymax - v2d->cur.ymin);
214         v2d->cur.ymin -= extra;
215         v2d->cur.ymax += extra;
216         
217         /* do View2D syncing */
218         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
219         
220         /* set notifier that things have changed */
221         ED_area_tag_redraw(CTX_wm_area(C));
222         
223         return OPERATOR_FINISHED;
224 }
225  
226 void GRAPHEDIT_OT_view_all (wmOperatorType *ot)
227 {
228         /* identifiers */
229         ot->name= "View All";
230         ot->idname= "GRAPHEDIT_OT_view_all";
231         
232         /* api callbacks */
233         ot->exec= graphkeys_viewall_exec;
234         ot->poll= ED_operator_areaactive;
235         
236         /* flags */
237         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
238 }
239
240
241 /* ************************************************************************** */
242 /* GENERAL STUFF */
243
244 // TODO: insertkey
245
246 /* ******************** Copy/Paste Keyframes Operator ************************* */
247 /* NOTE: the backend code for this is shared with the dopesheet editor */
248
249 static short copy_graph_keys (bAnimContext *ac)
250 {       
251         ListBase anim_data = {NULL, NULL};
252         int filter, ok=0;
253         
254         /* clear buffer first */
255         free_anim_copybuf();
256         
257         /* filter data */
258         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
259         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
260         
261         /* copy keyframes */
262         ok= copy_animedit_keys(ac, &anim_data);
263         
264         /* clean up */
265         BLI_freelistN(&anim_data);
266 }
267
268
269 static short paste_graph_keys (bAnimContext *ac)
270 {       
271         ListBase anim_data = {NULL, NULL};
272         int filter, ok=0;
273         
274         /* filter data */
275         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
276         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
277         
278         /* paste keyframes */
279         ok= paste_animedit_keys(ac, &anim_data);
280         
281         /* clean up */
282         BLI_freelistN(&anim_data);
283 }
284
285 /* ------------------- */
286
287 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
288 {
289         bAnimContext ac;
290         
291         /* get editor data */
292         if (ANIM_animdata_get_context(C, &ac) == 0)
293                 return OPERATOR_CANCELLED;
294         
295         /* copy keyframes */
296         if (copy_graph_keys(&ac)) {     
297                 // XXX errors - need a way to inform the user 
298                 printf("Graph Copy: No keyframes copied to copy-paste buffer\n");
299         }
300         
301         /* set notifier tha things have changed */
302         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
303         
304         return OPERATOR_FINISHED;
305 }
306  
307 void GRAPHEDIT_OT_keyframes_copy (wmOperatorType *ot)
308 {
309         /* identifiers */
310         ot->name= "Copy Keyframes";
311         ot->idname= "GRAPHEDIT_OT_keyframes_copy";
312         
313         /* api callbacks */
314         ot->exec= graphkeys_copy_exec;
315         ot->poll= ED_operator_areaactive;
316         
317         /* flags */
318         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
319 }
320
321
322
323 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
324 {
325         bAnimContext ac;
326         
327         /* get editor data */
328         if (ANIM_animdata_get_context(C, &ac) == 0)
329                 return OPERATOR_CANCELLED;
330         
331         /* paste keyframes */
332         if (paste_graph_keys(&ac)) {
333                 // XXX errors - need a way to inform the user 
334                 printf("Graph Paste: Nothing to paste, as Copy-Paste buffer was empty.\n");
335         }
336         
337         /* validate keyframes after editing */
338         ANIM_editkeyframes_refresh(&ac);
339         
340         /* set notifier tha things have changed */
341         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
342         
343         return OPERATOR_FINISHED;
344 }
345  
346 void GRAPHEDIT_OT_keyframes_paste (wmOperatorType *ot)
347 {
348         /* identifiers */
349         ot->name= "Paste Keyframes";
350         ot->idname= "GRAPHEDIT_OT_keyframes_paste";
351         
352         /* api callbacks */
353         ot->exec= graphkeys_paste_exec;
354         ot->poll= ED_operator_areaactive;
355         
356         /* flags */
357         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
358 }
359
360 /* ******************** Duplicate Keyframes Operator ************************* */
361
362 static void duplicate_graph_keys (bAnimContext *ac)
363 {
364         ListBase anim_data = {NULL, NULL};
365         bAnimListElem *ale;
366         int filter;
367         
368         /* filter data */
369         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
370         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
371         
372         /* loop through filtered data and delete selected keys */
373         for (ale= anim_data.first; ale; ale= ale->next) {
374                 duplicate_fcurve_keys((FCurve *)ale->key_data);
375         }
376         
377         /* free filtered list */
378         BLI_freelistN(&anim_data);
379 }
380
381 /* ------------------- */
382
383 static int graphkeys_duplicate_exec(bContext *C, wmOperator *op)
384 {
385         bAnimContext ac;
386         
387         /* get editor data */
388         if (ANIM_animdata_get_context(C, &ac) == 0)
389                 return OPERATOR_CANCELLED;
390                 
391         /* duplicate keyframes */
392         duplicate_graph_keys(&ac);
393         
394         /* validate keyframes after editing */
395         ANIM_editkeyframes_refresh(&ac);
396         
397         /* set notifier tha things have changed */
398         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
399         
400         return OPERATOR_FINISHED;
401 }
402
403 static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
404 {
405         graphkeys_duplicate_exec(C, op);
406         
407         RNA_int_set(op->ptr, "mode", TFM_TRANSLATION);
408         WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
409
410         return OPERATOR_FINISHED;
411 }
412  
413 void GRAPHEDIT_OT_keyframes_duplicate (wmOperatorType *ot)
414 {
415         /* identifiers */
416         ot->name= "Duplicate Keyframes";
417         ot->idname= "GRAPHEDIT_OT_keyframes_duplicate";
418         
419         /* api callbacks */
420         ot->invoke= graphkeys_duplicate_invoke;
421         ot->exec= graphkeys_duplicate_exec;
422         ot->poll= ED_operator_areaactive;
423         
424         /* flags */
425         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
426         
427         /* to give to transform */
428         RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
429 }
430
431 /* ******************** Delete Keyframes Operator ************************* */
432
433 static void delete_graph_keys (bAnimContext *ac)
434 {
435         ListBase anim_data = {NULL, NULL};
436         bAnimListElem *ale;
437         int filter;
438         
439         /* filter data */
440         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
441         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
442         
443         /* loop through filtered data and delete selected keys */
444         for (ale= anim_data.first; ale; ale= ale->next) {
445                 delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
446         }
447         
448         /* free filtered list */
449         BLI_freelistN(&anim_data);
450 }
451
452 /* ------------------- */
453
454 static int graphkeys_delete_exec(bContext *C, wmOperator *op)
455 {
456         bAnimContext ac;
457         
458         /* get editor data */
459         if (ANIM_animdata_get_context(C, &ac) == 0)
460                 return OPERATOR_CANCELLED;
461                 
462         /* delete keyframes */
463         delete_graph_keys(&ac);
464         
465         /* validate keyframes after editing */
466         ANIM_editkeyframes_refresh(&ac);
467         
468         /* set notifier tha things have changed */
469         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
470         
471         return OPERATOR_FINISHED;
472 }
473  
474 void GRAPHEDIT_OT_keyframes_delete (wmOperatorType *ot)
475 {
476         /* identifiers */
477         ot->name= "Delete Keyframes";
478         ot->idname= "GRAPHEDIT_OT_keyframes_delete";
479         
480         /* api callbacks */
481         ot->invoke= WM_operator_confirm;
482         ot->exec= graphkeys_delete_exec;
483         ot->poll= ED_operator_areaactive;
484         
485         /* flags */
486         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
487 }
488
489 /* ******************** Clean Keyframes Operator ************************* */
490
491 static void clean_graph_keys (bAnimContext *ac, float thresh)
492 {       
493         ListBase anim_data = {NULL, NULL};
494         bAnimListElem *ale;
495         int filter;
496         
497         /* filter data */
498         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
499         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
500         
501         /* loop through filtered data and clean curves */
502         for (ale= anim_data.first; ale; ale= ale->next)
503                 clean_fcurve((FCurve *)ale->key_data, thresh);
504         
505         /* free temp data */
506         BLI_freelistN(&anim_data);
507 }
508
509 /* ------------------- */
510
511 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
512 {
513         bAnimContext ac;
514         float thresh;
515         
516         /* get editor data */
517         if (ANIM_animdata_get_context(C, &ac) == 0)
518                 return OPERATOR_CANCELLED;
519                 
520         /* get cleaning threshold */
521         thresh= RNA_float_get(op->ptr, "threshold");
522         
523         /* clean keyframes */
524         clean_graph_keys(&ac, thresh);
525         
526         /* validate keyframes after editing */
527         ANIM_editkeyframes_refresh(&ac);
528         
529         /* set notifier tha things have changed */
530         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
531         
532         return OPERATOR_FINISHED;
533 }
534  
535 void GRAPHEDIT_OT_keyframes_clean (wmOperatorType *ot)
536 {
537         /* identifiers */
538         ot->name= "Clean Keyframes";
539         ot->idname= "GRAPHEDIT_OT_keyframes_clean";
540         
541         /* api callbacks */
542         //ot->invoke=  // XXX we need that number popup for this! 
543         ot->exec= graphkeys_clean_exec;
544         ot->poll= ED_operator_areaactive;
545         
546         /* flags */
547         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
548         
549         /* properties */
550         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
551 }
552
553 /* ******************** Sample Keyframes Operator *********************** */
554
555 // XXX some of the common parts (with DopeSheet) should be unified in animation module...
556
557 /* little cache for values... */
558 typedef struct tempFrameValCache {
559         float frame, val;
560 } tempFrameValCache;
561
562 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
563 static void sample_graph_keys (bAnimContext *ac)
564 {       
565         ListBase anim_data = {NULL, NULL};
566         bAnimListElem *ale;
567         int filter;
568         
569         /* filter data */
570         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
571         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
572         
573         /* loop through filtered data and add keys between selected keyframes on every frame  */
574         for (ale= anim_data.first; ale; ale= ale->next) {
575                 FCurve *fcu= (FCurve *)ale->key_data;
576                 BezTriple *bezt, *start=NULL, *end=NULL;
577                 tempFrameValCache *value_cache, *fp;
578                 int sfra, range;
579                 int i, n;
580                 
581                 /* find selected keyframes... once pair has been found, add keyframes  */
582                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
583                         /* check if selected, and which end this is */
584                         if (BEZSELECTED(bezt)) {
585                                 if (start) {
586                                         /* set end */
587                                         end= bezt;
588                                         
589                                         /* cache values then add keyframes using these values, as adding
590                                          * keyframes while sampling will affect the outcome...
591                                          */
592                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
593                                         sfra= (int)( floor(start->vec[1][0]) );
594                                         
595                                         if (range) {
596                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
597                                                 
598                                                 /*      sample values   */
599                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
600                                                         fp->frame= (float)(sfra + n);
601                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
602                                                 }
603                                                 
604                                                 /*      add keyframes with these        */
605                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
606                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
607                                                 }
608                                                 
609                                                 /* free temp cache */
610                                                 MEM_freeN(value_cache);
611                                                 
612                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
613                                                 bezt = fcu->bezt + i + range - 1;
614                                                 i += (range - 1);
615                                         }
616                                         
617                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
618                                         start= bezt;
619                                         end= NULL;
620                                 }
621                                 else {
622                                         /* just set start keyframe */
623                                         start= bezt;
624                                         end= NULL;
625                                 }
626                         }
627                 }
628                 
629                 /* recalculate channel's handles? */
630                 calchandles_fcurve(fcu);
631         }
632         
633         /* admin and redraws */
634         BLI_freelistN(&anim_data);
635 }
636
637 /* ------------------- */
638
639 static int graphkeys_sample_exec(bContext *C, wmOperator *op)
640 {
641         bAnimContext ac;
642         
643         /* get editor data */
644         if (ANIM_animdata_get_context(C, &ac) == 0)
645                 return OPERATOR_CANCELLED;
646         
647         /* sample keyframes */
648         sample_graph_keys(&ac);
649         
650         /* validate keyframes after editing */
651         ANIM_editkeyframes_refresh(&ac);
652         
653         /* set notifier tha things have changed */
654         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
655         
656         return OPERATOR_FINISHED;
657 }
658  
659 void GRAPHEDIT_OT_keyframes_sample (wmOperatorType *ot)
660 {
661         /* identifiers */
662         ot->name= "Sample Keyframes";
663         ot->idname= "GRAPHEDIT_OT_keyframes_sample";
664         
665         /* api callbacks */
666         ot->exec= graphkeys_sample_exec;
667         ot->poll= ED_operator_areaactive;
668         
669         /* flags */
670         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
671 }
672
673
674 /* ************************************************************************** */
675 /* SETTINGS STUFF */
676
677 /* ******************** Set Extrapolation-Type Operator *********************** */
678
679 /* defines for set extrapolation-type for selected keyframes tool */
680 EnumPropertyItem prop_graphkeys_expo_types[] = {
681         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
682         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
683         {0, NULL, NULL, NULL}
684 };
685
686 /* this function is responsible for setting extrapolation mode for keyframes */
687 static void setexpo_graph_keys(bAnimContext *ac, short mode) 
688 {
689         ListBase anim_data = {NULL, NULL};
690         bAnimListElem *ale;
691         int filter;
692         
693         /* filter data */
694         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
695         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
696         
697         /* loop through setting mode per F-Curve */
698         for (ale= anim_data.first; ale; ale= ale->next) {
699                 FCurve *fcu= (FCurve *)ale->data;
700                 fcu->extend= mode;
701         }
702         
703         /* cleanup */
704         BLI_freelistN(&anim_data);
705 }
706
707 /* ------------------- */
708
709 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
710 {
711         bAnimContext ac;
712         short mode;
713         
714         /* get editor data */
715         if (ANIM_animdata_get_context(C, &ac) == 0)
716                 return OPERATOR_CANCELLED;
717                 
718         /* get handle setting mode */
719         mode= RNA_enum_get(op->ptr, "type");
720         
721         /* set handle type */
722         setexpo_graph_keys(&ac, mode);
723         
724         /* validate keyframes after editing */
725         ANIM_editkeyframes_refresh(&ac);
726         
727         /* set notifier tha things have changed */
728         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
729         
730         return OPERATOR_FINISHED;
731 }
732  
733 void GRAPHEDIT_OT_keyframes_extrapolation_type (wmOperatorType *ot)
734 {
735         /* identifiers */
736         ot->name= "Set Keyframe Extrapolation";
737         ot->idname= "GRAPHEDIT_OT_keyframes_extrapolation_type";
738         
739         /* api callbacks */
740         ot->invoke= WM_menu_invoke;
741         ot->exec= graphkeys_expo_exec;
742         ot->poll= ED_operator_areaactive;
743         
744         /* flags */
745         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
746         
747         /* id-props */
748         RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
749 }
750
751 /* ******************** Set Interpolation-Type Operator *********************** */
752
753 /* defines for set ipo-type for selected keyframes tool */
754 EnumPropertyItem prop_graphkeys_ipo_types[] = {
755         {BEZT_IPO_CONST, "CONSTANT", "Constant Interpolation", ""},
756         {BEZT_IPO_LIN, "LINEAR", "Linear Interpolation", ""},
757         {BEZT_IPO_BEZ, "BEZIER", "Bezier Interpolation", ""},
758         {0, NULL, NULL, NULL}
759 };
760
761 /* this function is responsible for setting interpolation mode for keyframes */
762 static void setipo_graph_keys(bAnimContext *ac, short mode) 
763 {
764         ListBase anim_data = {NULL, NULL};
765         bAnimListElem *ale;
766         int filter;
767         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
768         
769         /* filter data */
770         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
771         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
772         
773         /* loop through setting BezTriple interpolation
774          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
775          */
776         for (ale= anim_data.first; ale; ale= ale->next)
777                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
778         
779         /* cleanup */
780         BLI_freelistN(&anim_data);
781 }
782
783 /* ------------------- */
784
785 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
786 {
787         bAnimContext ac;
788         short mode;
789         
790         /* get editor data */
791         if (ANIM_animdata_get_context(C, &ac) == 0)
792                 return OPERATOR_CANCELLED;
793                 
794         /* get handle setting mode */
795         mode= RNA_enum_get(op->ptr, "type");
796         
797         /* set handle type */
798         setipo_graph_keys(&ac, mode);
799         
800         /* validate keyframes after editing */
801         ANIM_editkeyframes_refresh(&ac);
802         
803         /* set notifier tha things have changed */
804         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
805         
806         return OPERATOR_FINISHED;
807 }
808  
809 void GRAPHEDIT_OT_keyframes_interpolation_type (wmOperatorType *ot)
810 {
811         /* identifiers */
812         ot->name= "Set Keyframe Interpolation";
813         ot->idname= "GRAPHEDIT_OT_keyframes_interpolation_type";
814         
815         /* api callbacks */
816         ot->invoke= WM_menu_invoke;
817         ot->exec= graphkeys_ipo_exec;
818         ot->poll= ED_operator_areaactive;
819         
820         /* flags */
821         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
822         
823         /* id-props */
824         RNA_def_enum(ot->srna, "type", prop_graphkeys_ipo_types, 0, "Type", "");
825 }
826
827 /* ******************** Set Handle-Type Operator *********************** */
828
829 /* defines for set handle-type for selected keyframes tool */
830 EnumPropertyItem prop_graphkeys_handletype_types[] = {
831         {HD_AUTO, "AUTO", "Auto Handles", ""},
832         {HD_VECT, "VECTOR", "Vector Handles", ""},
833         {HD_FREE, "FREE", "Free Handles", ""},
834         {HD_ALIGN, "ALIGN", "Aligned Handles", ""},
835 //      {-1, "TOGGLE", "Toggle between Free and Aligned Handles", ""},
836         {0, NULL, NULL, NULL}
837 };
838
839 /* this function is responsible for setting handle-type of selected keyframes */
840 static void sethandles_graph_keys(bAnimContext *ac, short mode) 
841 {
842         ListBase anim_data = {NULL, NULL};
843         bAnimListElem *ale;
844         int filter;
845         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
846         
847         /* filter data */
848         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
849         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
850         
851         /* loop through setting flags for handles 
852          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
853          */
854         // XXX we might need to supply BeztEditData to get it to only affect selected handles
855         for (ale= anim_data.first; ale; ale= ale->next) {
856                 if (mode == -1) {       
857                         BeztEditFunc toggle_cb;
858                         
859                         /* check which type of handle to set (free or aligned) 
860                          *      - check here checks for handles with free alignment already
861                          */
862                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
863                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
864                         else
865                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
866                                 
867                         /* set handle-type */
868                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
869                 }
870                 else {
871                         /* directly set handle-type */
872                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
873                 }
874         }
875         
876         /* cleanup */
877         BLI_freelistN(&anim_data);
878 }
879
880 /* ------------------- */
881
882 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
883 {
884         bAnimContext ac;
885         short mode;
886         
887         /* get editor data */
888         if (ANIM_animdata_get_context(C, &ac) == 0)
889                 return OPERATOR_CANCELLED;
890                 
891         /* get handle setting mode */
892         mode= RNA_enum_get(op->ptr, "type");
893         
894         /* set handle type */
895         sethandles_graph_keys(&ac, mode);
896         
897         /* validate keyframes after editing */
898         ANIM_editkeyframes_refresh(&ac);
899         
900         /* set notifier tha things have changed */
901         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
902         
903         return OPERATOR_FINISHED;
904 }
905  
906 void GRAPHEDIT_OT_keyframes_handletype (wmOperatorType *ot)
907 {
908         /* identifiers */
909         ot->name= "Set Keyframe Handle Type";
910         ot->idname= "GRAPHEDIT_OT_keyframes_handletype";
911         
912         /* api callbacks */
913         ot->invoke= WM_menu_invoke;
914         ot->exec= graphkeys_handletype_exec;
915         ot->poll= ED_operator_areaactive;
916         
917         /* flags */
918         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
919         
920         /* id-props */
921         RNA_def_enum(ot->srna, "type", prop_graphkeys_handletype_types, 0, "Type", "");
922 }
923
924 /* ************************************************************************** */
925 /* TRANSFORM STUFF */
926
927 /* ***************** Snap Current Frame Operator *********************** */
928
929 /* helper callback for graphkeys_cfrasnap_exec() -> used to help get the average time of all selected beztriples */
930 // TODO: if some other code somewhere needs this, it'll be time to port this over to keyframes_edit.c!!!
931 static short bezt_calc_average(BeztEditData *bed, BezTriple *bezt)
932 {
933         /* only if selected */
934         if (bezt->f2 & SELECT) {
935                 /* store average time in float (only do rounding at last step */
936                 bed->f1 += bezt->vec[1][0];
937                 
938                 /* increment number of items */
939                 bed->i1++;
940         }
941         
942         return 0;
943 }
944
945 /* snap current-frame indicator to 'average time' of selected keyframe */
946 static int graphkeys_cfrasnap_exec(bContext *C, wmOperator *op)
947 {
948         bAnimContext ac;
949         ListBase anim_data= {NULL, NULL};
950         bAnimListElem *ale;
951         int filter;
952         BeztEditData bed;
953         
954         /* get editor data */
955         if (ANIM_animdata_get_context(C, &ac) == 0)
956                 return OPERATOR_CANCELLED;
957         
958         /* init edit data */
959         memset(&bed, 0, sizeof(BeztEditData));
960         
961         /* loop over action data, averaging values */
962         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_CURVESONLY);
963         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
964         
965         for (ale= anim_data.first; ale; ale= ale->next)
966                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
967         
968         BLI_freelistN(&anim_data);
969         
970         /* set the new current frame value, based on the average time */
971         if (bed.i1) {
972                 Scene *scene= ac.scene;
973                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
974         }
975         
976         /* set notifier tha things have changed */
977         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
978         
979         return OPERATOR_FINISHED;
980 }
981
982 void GRAPHEDIT_OT_keyframes_cfrasnap (wmOperatorType *ot)
983 {
984         /* identifiers */
985         ot->name= "Snap Current Frame to Keys";
986         ot->idname= "GRAPHEDIT_OT_keyframes_cfrasnap";
987         
988         /* api callbacks */
989         ot->exec= graphkeys_cfrasnap_exec;
990         ot->poll= ED_operator_areaactive;
991         
992         /* flags */
993         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
994 }
995
996 /* ******************** Snap Keyframes Operator *********************** */
997
998 /* defines for snap keyframes tool */
999 EnumPropertyItem prop_graphkeys_snap_types[] = {
1000         {GRAPHKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1001         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1002         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1003         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1004         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", "Flatten Handles", ""},
1005         {0, NULL, NULL, NULL}
1006 };
1007
1008 /* this function is responsible for snapping keyframes to frame-times */
1009 static void snap_graph_keys(bAnimContext *ac, short mode) 
1010 {
1011         ListBase anim_data = {NULL, NULL};
1012         bAnimListElem *ale;
1013         int filter;
1014         
1015         BeztEditData bed;
1016         BeztEditFunc edit_cb;
1017         
1018         /* filter data */
1019         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1020         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1021         
1022         /* get beztriple editing callbacks */
1023         edit_cb= ANIM_editkeyframes_snap(mode);
1024         
1025         memset(&bed, 0, sizeof(BeztEditData)); 
1026         bed.scene= ac->scene;
1027         
1028         /* snap keyframes */
1029         for (ale= anim_data.first; ale; ale= ale->next) {
1030                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1031                 
1032                 if (nob) {
1033                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1034                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1035                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1036                 }
1037                 else 
1038                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1039         }
1040         BLI_freelistN(&anim_data);
1041 }
1042
1043 /* ------------------- */
1044
1045 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
1046 {
1047         bAnimContext ac;
1048         short mode;
1049         
1050         /* get editor data */
1051         if (ANIM_animdata_get_context(C, &ac) == 0)
1052                 return OPERATOR_CANCELLED;
1053                 
1054         /* get snapping mode */
1055         mode= RNA_enum_get(op->ptr, "type");
1056         
1057         /* snap keyframes */
1058         snap_graph_keys(&ac, mode);
1059         
1060         /* validate keyframes after editing */
1061         ANIM_editkeyframes_refresh(&ac);
1062         
1063         /* set notifier tha things have changed */
1064         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1065         
1066         return OPERATOR_FINISHED;
1067 }
1068  
1069 void GRAPHEDIT_OT_keyframes_snap (wmOperatorType *ot)
1070 {
1071         /* identifiers */
1072         ot->name= "Snap Keys";
1073         ot->idname= "GRAPHEDIT_OT_keyframes_snap";
1074         
1075         /* api callbacks */
1076         ot->invoke= WM_menu_invoke;
1077         ot->exec= graphkeys_snap_exec;
1078         ot->poll= ED_operator_areaactive;
1079         
1080         /* flags */
1081         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1082         
1083         /* id-props */
1084         RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
1085 }
1086
1087 /* ******************** Mirror Keyframes Operator *********************** */
1088
1089 /* defines for mirror keyframes tool */
1090 EnumPropertyItem prop_graphkeys_mirror_types[] = {
1091         {GRAPHKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1092         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1093         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1094         {GRAPHKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1095         {0, NULL, NULL, NULL}
1096 };
1097
1098 /* this function is responsible for mirroring keyframes */
1099 static void mirror_graph_keys(bAnimContext *ac, short mode) 
1100 {
1101         ListBase anim_data = {NULL, NULL};
1102         bAnimListElem *ale;
1103         int filter;
1104         
1105         BeztEditData bed;
1106         BeztEditFunc edit_cb;
1107         
1108         /* get beztriple editing callbacks */
1109         edit_cb= ANIM_editkeyframes_mirror(mode);
1110         
1111         memset(&bed, 0, sizeof(BeztEditData)); 
1112         bed.scene= ac->scene;
1113         
1114         /* for 'first selected marker' mode, need to find first selected marker first! */
1115         // XXX should this be made into a helper func in the API?
1116         if (mode == GRAPHKEYS_MIRROR_MARKER) {
1117                 Scene *scene= ac->scene;
1118                 TimeMarker *marker= NULL;
1119                 
1120                 /* find first selected marker */
1121                 for (marker= scene->markers.first; marker; marker=marker->next) {
1122                         if (marker->flag & SELECT) {
1123                                 break;
1124                         }
1125                 }
1126                 
1127                 /* store marker's time (if available) */
1128                 if (marker)
1129                         bed.f1= (float)marker->frame;
1130                 else
1131                         return;
1132         }
1133         
1134         /* filter data */
1135         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1136         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1137         
1138         /* mirror keyframes */
1139         for (ale= anim_data.first; ale; ale= ale->next) {
1140                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1141                 
1142                 if (nob) {
1143                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1); 
1144                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1145                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1146                 }
1147                 else 
1148                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1149         }
1150         BLI_freelistN(&anim_data);
1151 }
1152
1153 /* ------------------- */
1154
1155 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
1156 {
1157         bAnimContext ac;
1158         short mode;
1159         
1160         /* get editor data */
1161         if (ANIM_animdata_get_context(C, &ac) == 0)
1162                 return OPERATOR_CANCELLED;
1163                 
1164         /* get mirroring mode */
1165         mode= RNA_enum_get(op->ptr, "type");
1166         
1167         /* mirror keyframes */
1168         mirror_graph_keys(&ac, mode);
1169         
1170         /* validate keyframes after editing */
1171         ANIM_editkeyframes_refresh(&ac);
1172         
1173         /* set notifier tha things have changed */
1174         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1175         
1176         return OPERATOR_FINISHED;
1177 }
1178  
1179 void GRAPHEDIT_OT_keyframes_mirror (wmOperatorType *ot)
1180 {
1181         /* identifiers */
1182         ot->name= "Mirror Keys";
1183         ot->idname= "GRAPHEDIT_OT_keyframes_mirror";
1184         
1185         /* api callbacks */
1186         ot->invoke= WM_menu_invoke;
1187         ot->exec= graphkeys_mirror_exec;
1188         ot->poll= ED_operator_areaactive;
1189         
1190         /* flags */
1191         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1192         
1193         /* id-props */
1194         RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
1195 }
1196
1197 /* ******************** Smooth Keyframes Operator *********************** */
1198
1199 static int graphkeys_smooth_exec(bContext *C, wmOperator *op)
1200 {
1201         bAnimContext ac;
1202         ListBase anim_data = {NULL, NULL};
1203         bAnimListElem *ale;
1204         int filter;
1205         
1206         /* get editor data */
1207         if (ANIM_animdata_get_context(C, &ac) == 0)
1208                 return OPERATOR_CANCELLED;
1209         
1210         /* filter data */
1211         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1212         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1213         
1214         /* smooth keyframes */
1215         for (ale= anim_data.first; ale; ale= ale->next) {
1216                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
1217                  * Perhaps the mode argument could be removed, as that functionality is offerred through 
1218                  * Snap->Flatten Handles anyway.
1219                  */
1220                 smooth_fcurve(ale->key_data);
1221         }
1222         BLI_freelistN(&anim_data);
1223         
1224         /* validate keyframes after editing */
1225         ANIM_editkeyframes_refresh(&ac);
1226         
1227         /* set notifier tha things have changed */
1228         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1229         
1230         return OPERATOR_FINISHED;
1231 }
1232  
1233 void GRAPHEDIT_OT_keyframes_smooth (wmOperatorType *ot)
1234 {
1235         /* identifiers */
1236         ot->name= "Smooth Keys";
1237         ot->idname= "GRAPHEDIT_OT_keyframes_smooth";
1238         
1239         /* api callbacks */
1240         ot->exec= graphkeys_smooth_exec;
1241         ot->poll= ED_operator_areaactive;
1242         
1243         /* flags */
1244         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1245 }
1246
1247 /* ************************************************************************** */