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