Cleanup: comment line length (editors)
[blender.git] / source / blender / editors / animation / keyframes_edit.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008 Blender Foundation
19  *
20  * Contributor(s): Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/animation/keyframes_edit.c
26  *  \ingroup edanimation
27  */
28
29
30 #include <stdlib.h>
31 #include <string.h>
32 #include <math.h>
33 #include <float.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BLI_blenlib.h"
38 #include "BLI_utildefines.h"
39 #include "BLI_lasso_2d.h"
40 #include "BLI_math.h"
41
42 #include "DNA_anim_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_scene_types.h"
45
46 #include "BKE_fcurve.h"
47 #include "BKE_nla.h"
48
49 #include "ED_anim_api.h"
50 #include "ED_keyframes_edit.h"
51 #include "ED_markers.h"
52
53 /* This file defines an API and set of callback-operators for non-destructive editing of keyframe data.
54  *
55  * Two API functions are defined for actually performing the operations on the data:
56  * ANIM_fcurve_keyframes_loop()
57  * which take the data they operate on, a few callbacks defining what operations to perform.
58  *
59  * As operators which work on keyframes usually apply the same operation on all BezTriples in
60  * every channel, the code has been optimized providing a set of functions which will get the
61  * appropriate bezier-modify function to set. These functions (ANIM_editkeyframes_*) will need
62  * to be called before getting any channels.
63  *
64  * A set of 'validation' callbacks are provided for checking if a BezTriple should be operated on.
65  * These should only be used when using a 'general' BezTriple editor (i.e. selection setters which
66  * don't check existing selection status).
67  *
68  * - Joshua Leung, Dec 2008
69  */
70
71 /* ************************************************************************** */
72 /* Keyframe Editing Loops - Exposed API */
73
74 /* --------------------------- Base Functions ------------------------------------ */
75
76 /* This function is used to loop over BezTriples in the given F-Curve, applying a given
77  * operation on them, and optionally applies an F-Curve validation function afterwards.
78  */
79 // TODO: make this function work on samples too...
80 short ANIM_fcurve_keyframes_loop(KeyframeEditData *ked, FCurve *fcu, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
81 {
82         BezTriple *bezt;
83         short ok = 0;
84         unsigned int i;
85
86         /* sanity check */
87         if (ELEM(NULL, fcu, fcu->bezt))
88                 return 0;
89
90         /* set the F-Curve into the editdata so that it can be accessed */
91         if (ked) {
92                 ked->fcu = fcu;
93                 ked->curIndex = 0;
94                 ked->curflags = ok;
95         }
96
97         /* if function to apply to bezier curves is set, then loop through executing it on beztriples */
98         if (key_cb) {
99                 /* if there's a validation func, include that check in the loop
100                  * (this is should be more efficient than checking for it in every loop)
101                  */
102                 if (key_ok) {
103                         for (bezt = fcu->bezt, i = 0; i < fcu->totvert; bezt++, i++) {
104                                 if (ked) {
105                                         /* advance the index, and reset the ok flags (to not influence the result) */
106                                         ked->curIndex = i;
107                                         ked->curflags = 0;
108                                 }
109
110                                 /* Only operate on this BezTriple if it fulfills the criteria of the validation func */
111                                 if ((ok = key_ok(ked, bezt))) {
112                                         if (ked) ked->curflags = ok;
113
114                                         /* Exit with return-code '1' if function returns positive
115                                          * This is useful if finding if some BezTriple satisfies a condition.
116                                          */
117                                         if (key_cb(ked, bezt)) return 1;
118                                 }
119                         }
120                 }
121                 else {
122                         for (bezt = fcu->bezt, i = 0; i < fcu->totvert; bezt++, i++) {
123                                 if (ked) ked->curIndex = i;
124
125                                 /* Exit with return-code '1' if function returns positive
126                                  * This is useful if finding if some BezTriple satisfies a condition.
127                                  */
128                                 if (key_cb(ked, bezt)) return 1;
129                         }
130                 }
131         }
132
133         /* unset the F-Curve from the editdata now that it's done */
134         if (ked) {
135                 ked->fcu = NULL;
136                 ked->curIndex = 0;
137                 ked->curflags = 0;
138         }
139
140         /* if fcu_cb (F-Curve post-editing callback) has been specified then execute it */
141         if (fcu_cb)
142                 fcu_cb(fcu);
143
144         /* done */
145         return 0;
146 }
147
148 /* -------------------------------- Further Abstracted (Not Exposed Directly) ----------------------------- */
149
150 /* This function is used to loop over the keyframe data in an Action Group */
151 static short agrp_keyframes_loop(KeyframeEditData *ked, bActionGroup *agrp, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
152 {
153         FCurve *fcu;
154
155         /* sanity check */
156         if (agrp == NULL)
157                 return 0;
158
159         /* only iterate over the F-Curves that are in this group */
160         for (fcu = agrp->channels.first; fcu && fcu->grp == agrp; fcu = fcu->next) {
161                 if (ANIM_fcurve_keyframes_loop(ked, fcu, key_ok, key_cb, fcu_cb))
162                         return 1;
163         }
164
165         return 0;
166 }
167
168 /* This function is used to loop over the keyframe data in an Action */
169 static short act_keyframes_loop(KeyframeEditData *ked, bAction *act, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
170 {
171         FCurve *fcu;
172
173         /* sanity check */
174         if (act == NULL)
175                 return 0;
176
177         /* just loop through all F-Curves */
178         for (fcu = act->curves.first; fcu; fcu = fcu->next) {
179                 if (ANIM_fcurve_keyframes_loop(ked, fcu, key_ok, key_cb, fcu_cb))
180                         return 1;
181         }
182
183         return 0;
184 }
185
186 /* This function is used to loop over the keyframe data in an Object */
187 static short ob_keyframes_loop(KeyframeEditData *ked, bDopeSheet *ads, Object *ob, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
188 {
189         bAnimContext ac = {NULL};
190         ListBase anim_data = {NULL, NULL};
191         bAnimListElem *ale;
192         int filter;
193         int ret = 0;
194
195         bAnimListElem dummychan = {NULL};
196         Base dummybase = {NULL};
197
198         if (ob == NULL)
199                 return 0;
200
201         /* create a dummy wrapper data to work with */
202         dummybase.object = ob;
203
204         dummychan.type = ANIMTYPE_OBJECT;
205         dummychan.data = &dummybase;
206         dummychan.id = &ob->id;
207         dummychan.adt = ob->adt;
208
209         ac.ads = ads;
210         ac.data = &dummychan;
211         ac.datatype = ANIMCONT_CHANNEL;
212
213         /* get F-Curves to take keyframes from */
214         filter = ANIMFILTER_DATA_VISIBLE; // curves only
215         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
216
217         /* loop through each F-Curve, applying the operation as required, but stopping on the first one */
218         for (ale = anim_data.first; ale; ale = ale->next) {
219                 if (ANIM_fcurve_keyframes_loop(ked, (FCurve *)ale->data, key_ok, key_cb, fcu_cb)) {
220                         ret = 1;
221                         break;
222                 }
223         }
224
225         ANIM_animdata_freelist(&anim_data);
226
227         /* return return code - defaults to zero if nothing happened */
228         return ret;
229 }
230
231 /* This function is used to loop over the keyframe data in a Scene */
232 static short scene_keyframes_loop(KeyframeEditData *ked, bDopeSheet *ads, Scene *sce, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
233 {
234         bAnimContext ac = {NULL};
235         ListBase anim_data = {NULL, NULL};
236         bAnimListElem *ale;
237         int filter;
238         int ret = 0;
239
240         bAnimListElem dummychan = {NULL};
241
242         if (sce == NULL)
243                 return 0;
244
245         /* create a dummy wrapper data to work with */
246         dummychan.type = ANIMTYPE_SCENE;
247         dummychan.data = sce;
248         dummychan.id = &sce->id;
249         dummychan.adt = sce->adt;
250
251         ac.ads = ads;
252         ac.data = &dummychan;
253         ac.datatype = ANIMCONT_CHANNEL;
254
255         /* get F-Curves to take keyframes from */
256         filter = ANIMFILTER_DATA_VISIBLE; // curves only
257         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
258
259         /* loop through each F-Curve, applying the operation as required, but stopping on the first one */
260         for (ale = anim_data.first; ale; ale = ale->next) {
261                 if (ANIM_fcurve_keyframes_loop(ked, (FCurve *)ale->data, key_ok, key_cb, fcu_cb)) {
262                         ret = 1;
263                         break;
264                 }
265         }
266
267         ANIM_animdata_freelist(&anim_data);
268
269         /* return return code - defaults to zero if nothing happened */
270         return ret;
271 }
272
273 /* This function is used to loop over the keyframe data in a DopeSheet summary */
274 static short summary_keyframes_loop(KeyframeEditData *ked, bAnimContext *ac, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
275 {
276         ListBase anim_data = {NULL, NULL};
277         bAnimListElem *ale;
278         int filter, ret_code = 0;
279
280         /* sanity check */
281         if (ac == NULL)
282                 return 0;
283
284         /* get F-Curves to take keyframes from */
285         filter = ANIMFILTER_DATA_VISIBLE;
286         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
287
288         /* loop through each F-Curve, working on the keyframes until the first curve aborts */
289         for (ale = anim_data.first; ale; ale = ale->next) {
290                 switch (ale->datatype) {
291                         case ALE_MASKLAY:
292                         case ALE_GPFRAME:
293                                 break;
294
295                         case ALE_FCURVE:
296                         default:
297                         {
298                                 if (ked && ked->iterflags) {
299                                         /* make backups of the current values, so that a localised fix
300                                          * (e.g. NLA time remapping) can be applied to these values
301                                          */
302                                         float f1 = ked->f1;
303                                         float f2 = ked->f2;
304
305                                         if (ked->iterflags & (KED_F1_NLA_UNMAP | KED_F2_NLA_UNMAP)) {
306                                                 AnimData *adt = ANIM_nla_mapping_get(ac, ale);
307
308                                                 if (ked->iterflags & KED_F1_NLA_UNMAP)
309                                                         ked->f1 = BKE_nla_tweakedit_remap(adt, f1, NLATIME_CONVERT_UNMAP);
310                                                 if (ked->iterflags & KED_F2_NLA_UNMAP)
311                                                         ked->f2 = BKE_nla_tweakedit_remap(adt, f2, NLATIME_CONVERT_UNMAP);
312                                         }
313
314                                         /* now operate on the channel as per normal */
315                                         ret_code = ANIM_fcurve_keyframes_loop(ked, ale->data, key_ok, key_cb, fcu_cb);
316
317                                         /* reset */
318                                         ked->f1 = f1;
319                                         ked->f2 = f2;
320                                 }
321                                 else {
322                                         /* no special handling required... */
323                                         ret_code = ANIM_fcurve_keyframes_loop(ked, ale->data, key_ok, key_cb, fcu_cb);
324                                 }
325                                 break;
326                         }
327                 }
328
329                 if (ret_code)
330                         break;
331         }
332
333         ANIM_animdata_freelist(&anim_data);
334
335         return ret_code;
336 }
337
338 /* --- */
339
340 /* This function is used to apply operation to all keyframes, regardless of the type */
341 short ANIM_animchannel_keyframes_loop(KeyframeEditData *ked, bDopeSheet *ads, bAnimListElem *ale, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
342 {
343         /* sanity checks */
344         if (ale == NULL)
345                 return 0;
346
347         /* method to use depends on the type of keyframe data */
348         switch (ale->datatype) {
349                 /* direct keyframe data (these loops are exposed) */
350                 case ALE_FCURVE: /* F-Curve */
351                         return ANIM_fcurve_keyframes_loop(ked, ale->key_data, key_ok, key_cb, fcu_cb);
352
353                 /* indirect 'summaries' (these are not exposed directly)
354                  * NOTE: must keep this code in sync with the drawing code and also the filtering code!
355                  */
356                 case ALE_GROUP: /* action group */
357                         return agrp_keyframes_loop(ked, (bActionGroup *)ale->data, key_ok, key_cb, fcu_cb);
358                 case ALE_ACT: /* action */
359                         return act_keyframes_loop(ked, (bAction *)ale->key_data, key_ok, key_cb, fcu_cb);
360
361                 case ALE_OB: /* object */
362                         return ob_keyframes_loop(ked, ads, (Object *)ale->key_data, key_ok, key_cb, fcu_cb);
363                 case ALE_SCE: /* scene */
364                         return scene_keyframes_loop(ked, ads, (Scene *)ale->data, key_ok, key_cb, fcu_cb);
365                 case ALE_ALL: /* 'all' (DopeSheet summary) */
366                         return summary_keyframes_loop(ked, (bAnimContext *)ale->data, key_ok, key_cb, fcu_cb);
367         }
368
369         return 0;
370 }
371
372 /* This function is used to apply operation to all keyframes,
373  * regardless of the type without needed an AnimListElem wrapper */
374 short ANIM_animchanneldata_keyframes_loop(KeyframeEditData *ked, bDopeSheet *ads, void *data, int keytype, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb)
375 {
376         /* sanity checks */
377         if (data == NULL)
378                 return 0;
379
380         /* method to use depends on the type of keyframe data */
381         switch (keytype) {
382                 /* direct keyframe data (these loops are exposed) */
383                 case ALE_FCURVE: /* F-Curve */
384                         return ANIM_fcurve_keyframes_loop(ked, data, key_ok, key_cb, fcu_cb);
385
386                 /* indirect 'summaries' (these are not exposed directly)
387                  * NOTE: must keep this code in sync with the drawing code and also the filtering code!
388                  */
389                 case ALE_GROUP: /* action group */
390                         return agrp_keyframes_loop(ked, (bActionGroup *)data, key_ok, key_cb, fcu_cb);
391                 case ALE_ACT: /* action */
392                         return act_keyframes_loop(ked, (bAction *)data, key_ok, key_cb, fcu_cb);
393
394                 case ALE_OB: /* object */
395                         return ob_keyframes_loop(ked, ads, (Object *)data, key_ok, key_cb, fcu_cb);
396                 case ALE_SCE: /* scene */
397                         return scene_keyframes_loop(ked, ads, (Scene *)data, key_ok, key_cb, fcu_cb);
398                 case ALE_ALL: /* 'all' (DopeSheet summary) */
399                         return summary_keyframes_loop(ked, (bAnimContext *)data, key_ok, key_cb, fcu_cb);
400         }
401
402         return 0;
403 }
404
405 /* ************************************************************************** */
406 /* Keyframe Integrity Tools */
407
408 /* Rearrange keyframes if some are out of order */
409 // used to be recalc_*_ipos() where * was object or action
410 void ANIM_editkeyframes_refresh(bAnimContext *ac)
411 {
412         ListBase anim_data = {NULL, NULL};
413         bAnimListElem *ale;
414         int filter;
415
416         /* filter animation data */
417         filter = ANIMFILTER_DATA_VISIBLE;
418         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
419
420         /* loop over F-Curves that are likely to have been edited, and check them */
421         for (ale = anim_data.first; ale; ale = ale->next) {
422                 FCurve *fcu = ale->key_data;
423
424                 /* make sure keyframes in F-Curve are all in order, and handles are in valid positions */
425                 sort_time_fcurve(fcu);
426                 calchandles_fcurve(fcu);
427         }
428
429         /* free temp data */
430         ANIM_animdata_freelist(&anim_data);
431 }
432
433 /* ************************************************************************** */
434 /* BezTriple Validation Callbacks */
435
436 /* ------------------------ */
437 /* Some macros to make this easier... */
438
439 /* run the given check on the 3 handles
440  * - check should be a macro, which takes the handle index as its single arg, which it substitutes later
441  * - requires that a var, of type short, is named 'ok', and has been initialized to 0
442  */
443 #define KEYFRAME_OK_CHECKS(check) \
444         { \
445                 CHECK_TYPE(ok, short); \
446                 if (check(1)) \
447                         ok |= KEYFRAME_OK_KEY; \
448                  \
449                 if (ked && (ked->iterflags & KEYFRAME_ITER_INCL_HANDLES)) { \
450                         if (check(0)) \
451                                 ok |= KEYFRAME_OK_H1; \
452                         if (check(2)) \
453                                 ok |= KEYFRAME_OK_H2; \
454                 } \
455         } (void)0
456
457 /* ------------------------ */
458
459 static short ok_bezier_frame(KeyframeEditData *ked, BezTriple *bezt)
460 {
461         short ok = 0;
462
463         /* frame is stored in f1 property (this float accuracy check may need to be dropped?) */
464 #define KEY_CHECK_OK(_index) IS_EQF(bezt->vec[_index][0], ked->f1)
465         KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
466 #undef KEY_CHECK_OK
467
468         /* return ok flags */
469         return ok;
470 }
471
472 static short ok_bezier_framerange(KeyframeEditData *ked, BezTriple *bezt)
473 {
474         short ok = 0;
475
476         /* frame range is stored in float properties */
477 #define KEY_CHECK_OK(_index) ((bezt->vec[_index][0] > ked->f1) && (bezt->vec[_index][0] < ked->f2))
478         KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
479 #undef KEY_CHECK_OK
480
481         /* return ok flags */
482         return ok;
483 }
484
485 static short ok_bezier_selected(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
486 {
487         /* this macro checks all beztriple handles for selection...
488          * only one of the verts has to be selected for this to be ok...
489          */
490         if (BEZT_ISSEL_ANY(bezt))
491                 return KEYFRAME_OK_ALL;
492         else
493                 return 0;
494 }
495
496 static short ok_bezier_value(KeyframeEditData *ked, BezTriple *bezt)
497 {
498         short ok = 0;
499
500         /* value is stored in f1 property
501          * - this float accuracy check may need to be dropped?
502          * - should value be stored in f2 instead so that we won't have conflicts when using f1 for frames too?
503          */
504 #define KEY_CHECK_OK(_index) IS_EQF(bezt->vec[_index][1], ked->f1)
505         KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
506 #undef KEY_CHECK_OK
507
508         /* return ok flags */
509         return ok;
510 }
511
512 static short ok_bezier_valuerange(KeyframeEditData *ked, BezTriple *bezt)
513 {
514         short ok = 0;
515
516         /* value range is stored in float properties */
517 #define KEY_CHECK_OK(_index) ((bezt->vec[_index][1] > ked->f1) && (bezt->vec[_index][1] < ked->f2))
518         KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
519 #undef KEY_CHECK_OK
520
521         /* return ok flags */
522         return ok;
523 }
524
525 static short ok_bezier_region(KeyframeEditData *ked, BezTriple *bezt)
526 {
527         /* rect is stored in data property (it's of type rectf, but may not be set) */
528         if (ked->data) {
529                 short ok = 0;
530
531 #define KEY_CHECK_OK(_index) BLI_rctf_isect_pt_v(ked->data, bezt->vec[_index])
532                 KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
533 #undef KEY_CHECK_OK
534
535                 /* return ok flags */
536                 return ok;
537         }
538         else
539                 return 0;
540 }
541
542 /**
543  * Called from #ok_bezier_region_lasso and #ok_bezier_channel_lasso
544  */
545 bool keyframe_region_lasso_test(
546         const KeyframeEdit_LassoData *data_lasso,
547         const float xy[2])
548 {
549         if (BLI_rctf_isect_pt_v(data_lasso->rectf_scaled, xy)) {
550                 float xy_view[2];
551
552                 BLI_rctf_transform_pt_v(data_lasso->rectf_view, data_lasso->rectf_scaled, xy_view, xy);
553
554                 if (BLI_lasso_is_point_inside(data_lasso->mcords, data_lasso->mcords_tot, xy_view[0], xy_view[1], INT_MAX)) {
555                         return true;
556                 }
557         }
558
559         return false;
560 }
561
562 static short ok_bezier_region_lasso(KeyframeEditData *ked, BezTriple *bezt)
563 {
564         /* check for lasso customdata (KeyframeEdit_LassoData) */
565         if (ked->data) {
566                 short ok = 0;
567
568 #define KEY_CHECK_OK(_index) keyframe_region_lasso_test(ked->data, bezt->vec[_index])
569                 KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
570 #undef KEY_CHECK_OK
571
572                 /* return ok flags */
573                 return ok;
574         }
575         else
576                 return 0;
577 }
578
579 static short ok_bezier_channel_lasso(KeyframeEditData *ked, BezTriple *bezt)
580 {
581         /* check for lasso customdata (KeyframeEdit_LassoData) */
582         if (ked->data) {
583                 KeyframeEdit_LassoData *data = ked->data;
584                 float pt[2];
585
586                 /* late-binding remap of the x values (for summary channels) */
587                 /* XXX: Ideally we reset, but it should be fine just leaving it as-is
588                  * as the next channel will reset it properly, while the next summary-channel
589                  * curve will also reset by itself...
590                  */
591                 if (ked->iterflags & (KED_F1_NLA_UNMAP | KED_F2_NLA_UNMAP)) {
592                         data->rectf_scaled->xmin = ked->f1;
593                         data->rectf_scaled->xmax = ked->f2;
594                 }
595
596                 /* only use the x-coordinate of the point; the y is the channel range... */
597                 pt[0] = bezt->vec[1][0];
598                 pt[1] = ked->channel_y;
599
600                 if (keyframe_region_lasso_test(data, pt))
601                         return KEYFRAME_OK_KEY;
602         }
603         return 0;
604 }
605
606 /**
607  * Called from #ok_bezier_region_circle and #ok_bezier_channel_circle
608  */
609 bool keyframe_region_circle_test(
610         const KeyframeEdit_CircleData *data_circle,
611         const float xy[2])
612 {
613         if (BLI_rctf_isect_pt_v(data_circle->rectf_scaled, xy)) {
614                 float xy_view[2];
615
616                 BLI_rctf_transform_pt_v(data_circle->rectf_view, data_circle->rectf_scaled, xy_view, xy);
617
618                 xy_view[0] = xy_view[0] - data_circle->mval[0];
619                 xy_view[1] = xy_view[1] - data_circle->mval[1];
620                 return len_squared_v2(xy_view) < data_circle->radius_squared;
621         }
622
623         return false;
624 }
625
626
627 static short ok_bezier_region_circle(KeyframeEditData *ked, BezTriple *bezt)
628 {
629         /* check for circle select customdata (KeyframeEdit_CircleData) */
630         if (ked->data) {
631                 short ok = 0;
632
633 #define KEY_CHECK_OK(_index) keyframe_region_circle_test(ked->data, bezt->vec[_index])
634                 KEYFRAME_OK_CHECKS(KEY_CHECK_OK);
635 #undef KEY_CHECK_OK
636
637                 /* return ok flags */
638                 return ok;
639         }
640         else
641                 return 0;
642 }
643
644 static short ok_bezier_channel_circle(KeyframeEditData *ked, BezTriple *bezt)
645 {
646         /* check for circle select customdata (KeyframeEdit_CircleData) */
647         if (ked->data) {
648                 KeyframeEdit_CircleData *data = ked->data;
649                 float pt[2];
650
651                 /* late-binding remap of the x values (for summary channels) */
652                 /* XXX: Ideally we reset, but it should be fine just leaving it as-is
653                  * as the next channel will reset it properly, while the next summary-channel
654                  * curve will also reset by itself...
655                  */
656                 if (ked->iterflags & (KED_F1_NLA_UNMAP | KED_F2_NLA_UNMAP)) {
657                         data->rectf_scaled->xmin = ked->f1;
658                         data->rectf_scaled->xmax = ked->f2;
659                 }
660
661                 /* only use the x-coordinate of the point; the y is the channel range... */
662                 pt[0] = bezt->vec[1][0];
663                 pt[1] = ked->channel_y;
664
665                 if (keyframe_region_circle_test(data, pt))
666                         return KEYFRAME_OK_KEY;
667         }
668         return 0;
669 }
670
671
672 KeyframeEditFunc ANIM_editkeyframes_ok(short mode)
673 {
674         /* eEditKeyframes_Validate */
675         switch (mode) {
676                 case BEZT_OK_FRAME:
677                         /* only if bezt falls on the right frame (float) */
678                         return ok_bezier_frame;
679                 case BEZT_OK_FRAMERANGE:
680                         /* only if bezt falls within the specified frame range (floats) */
681                         return ok_bezier_framerange;
682                 case BEZT_OK_SELECTED:
683                         /* only if bezt is selected (self) */
684                         return ok_bezier_selected;
685                 case BEZT_OK_VALUE:
686                         /* only if bezt value matches (float) */
687                         return ok_bezier_value;
688                 case BEZT_OK_VALUERANGE:
689                         /* only if bezier falls within the specified value range (floats) */
690                         return ok_bezier_valuerange;
691                 case BEZT_OK_REGION:
692                         /* only if bezier falls within the specified rect (data -> rectf) */
693                         return ok_bezier_region;
694                 case BEZT_OK_REGION_LASSO:
695                         /* only if the point falls within KeyframeEdit_LassoData defined data */
696                         return ok_bezier_region_lasso;
697                 case BEZT_OK_REGION_CIRCLE:
698                         /* only if the point falls within KeyframeEdit_CircleData defined data */
699                         return ok_bezier_region_circle;
700                 case BEZT_OK_CHANNEL_LASSO:
701                         /* same as BEZT_OK_REGION_LASSO, but we're only using the x-value of the points */
702                         return ok_bezier_channel_lasso;
703                 case BEZT_OK_CHANNEL_CIRCLE:
704                         /* same as BEZT_OK_REGION_CIRCLE, but we're only using the x-value of the points */
705                         return ok_bezier_channel_circle;
706                 default: /* nothing was ok */
707                         return NULL;
708         }
709 }
710
711 /* ******************************************* */
712 /* Assorted Utility Functions */
713
714 /**
715  * Helper callback for <animeditor>_cfrasnap_exec() ->
716  * used to help get the average time of all selected beztriples
717  */
718 short bezt_calc_average(KeyframeEditData *ked, BezTriple *bezt)
719 {
720         /* only if selected */
721         if (bezt->f2 & SELECT) {
722                 /* store average time in float 1 (only do rounding at last step) */
723                 ked->f1 += bezt->vec[1][0];
724
725                 /* store average value in float 2 (only do rounding at last step)
726                  * - this isn't always needed, but some operators may also require this
727                  */
728                 ked->f2 += bezt->vec[1][1];
729
730                 /* increment number of items */
731                 ked->i1++;
732         }
733
734         return 0;
735 }
736
737 /* helper callback for columnselect_<animeditor>_keys() -> populate
738  * list CfraElems with frame numbers from selected beztriples */
739 short bezt_to_cfraelem(KeyframeEditData *ked, BezTriple *bezt)
740 {
741         /* only if selected */
742         if (bezt->f2 & SELECT) {
743                 CfraElem *ce = MEM_callocN(sizeof(CfraElem), "cfraElem");
744                 BLI_addtail(&ked->list, ce);
745
746                 ce->cfra = bezt->vec[1][0];
747         }
748
749         return 0;
750 }
751
752 /* used to remap times from one range to another
753  * requires:  ked->data = KeyframeEditCD_Remap
754  */
755 void bezt_remap_times(KeyframeEditData *ked, BezTriple *bezt)
756 {
757         KeyframeEditCD_Remap *rmap = (KeyframeEditCD_Remap *)ked->data;
758         const float scale = (rmap->newMax - rmap->newMin) / (rmap->oldMax - rmap->oldMin);
759
760         /* perform transform on all three handles unless indicated otherwise */
761         // TODO: need to include some checks for that
762
763         bezt->vec[0][0] = scale * (bezt->vec[0][0] - rmap->oldMin) + rmap->newMin;
764         bezt->vec[1][0] = scale * (bezt->vec[1][0] - rmap->oldMin) + rmap->newMin;
765         bezt->vec[2][0] = scale * (bezt->vec[2][0] - rmap->oldMin) + rmap->newMin;
766 }
767
768 /* ******************************************* */
769 /* Transform */
770
771 /* snaps the keyframe to the nearest frame */
772 static short snap_bezier_nearest(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
773 {
774         if (bezt->f2 & SELECT)
775                 bezt->vec[1][0] = (float)(floorf(bezt->vec[1][0] + 0.5f));
776         return 0;
777 }
778
779 /* snaps the keyframe to the nearest second */
780 static short snap_bezier_nearestsec(KeyframeEditData *ked, BezTriple *bezt)
781 {
782         const Scene *scene = ked->scene;
783         const float secf = (float)FPS;
784
785         if (bezt->f2 & SELECT)
786                 bezt->vec[1][0] = (floorf(bezt->vec[1][0] / secf + 0.5f) * secf);
787         return 0;
788 }
789
790 /* snaps the keyframe to the current frame */
791 static short snap_bezier_cframe(KeyframeEditData *ked, BezTriple *bezt)
792 {
793         const Scene *scene = ked->scene;
794         if (bezt->f2 & SELECT)
795                 bezt->vec[1][0] = (float)CFRA;
796         return 0;
797 }
798
799 /* snaps the keyframe time to the nearest marker's frame */
800 static short snap_bezier_nearmarker(KeyframeEditData *ked, BezTriple *bezt)
801 {
802         if (bezt->f2 & SELECT)
803                 bezt->vec[1][0] = (float)ED_markers_find_nearest_marker_time(&ked->list, bezt->vec[1][0]);
804         return 0;
805 }
806
807 /* make the handles have the same value as the key */
808 static short snap_bezier_horizontal(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
809 {
810         if (bezt->f2 & SELECT) {
811                 bezt->vec[0][1] = bezt->vec[2][1] = bezt->vec[1][1];
812
813                 if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM, HD_VECT)) bezt->h1 = HD_ALIGN;
814                 if (ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM, HD_VECT)) bezt->h2 = HD_ALIGN;
815         }
816         return 0;
817 }
818
819 /* frame to snap to is stored in the custom data -> first float value slot */
820 static short snap_bezier_time(KeyframeEditData *ked, BezTriple *bezt)
821 {
822         if (bezt->f2 & SELECT)
823                 bezt->vec[1][0] = ked->f1;
824         return 0;
825 }
826
827 /* value to snap to is stored in the custom data -> first float value slot */
828 static short snap_bezier_value(KeyframeEditData *ked, BezTriple *bezt)
829 {
830         if (bezt->f2 & SELECT)
831                 bezt->vec[1][1] = ked->f1;
832         return 0;
833 }
834
835 KeyframeEditFunc ANIM_editkeyframes_snap(short type)
836 {
837         /* eEditKeyframes_Snap */
838         switch (type) {
839                 case SNAP_KEYS_NEARFRAME: /* snap to nearest frame */
840                         return snap_bezier_nearest;
841                 case SNAP_KEYS_CURFRAME: /* snap to current frame */
842                         return snap_bezier_cframe;
843                 case SNAP_KEYS_NEARMARKER: /* snap to nearest marker */
844                         return snap_bezier_nearmarker;
845                 case SNAP_KEYS_NEARSEC: /* snap to nearest second */
846                         return snap_bezier_nearestsec;
847                 case SNAP_KEYS_HORIZONTAL: /* snap handles to same value */
848                         return snap_bezier_horizontal;
849                 case SNAP_KEYS_TIME: /* snap to given frame/time */
850                         return snap_bezier_time;
851                 case SNAP_KEYS_VALUE: /* snap to given value */
852                         return snap_bezier_value;
853                 default: /* just in case */
854                         return snap_bezier_nearest;
855         }
856 }
857
858 /* --------- */
859
860 static void mirror_bezier_xaxis_ex(BezTriple *bezt, const float center)
861 {
862         float diff;
863         int i;
864
865         for (i = 0; i < 3; i++) {
866                 diff = (center - bezt->vec[i][0]);
867                 bezt->vec[i][0] = (center + diff);
868         }
869         swap_v3_v3(bezt->vec[0], bezt->vec[2]);
870
871         SWAP(char, bezt->h1, bezt->h2);
872         SWAP(char, bezt->f1, bezt->f3);
873 }
874
875 static void mirror_bezier_yaxis_ex(BezTriple *bezt, const float center)
876 {
877         float diff;
878         int i;
879
880         for (i = 0; i < 3; i++) {
881                 diff = (center - bezt->vec[i][1]);
882                 bezt->vec[i][1] = (center + diff);
883         }
884 }
885
886 static short mirror_bezier_cframe(KeyframeEditData *ked, BezTriple *bezt)
887 {
888         const Scene *scene = ked->scene;
889
890         if (bezt->f2 & SELECT) {
891                 mirror_bezier_xaxis_ex(bezt, CFRA);
892         }
893
894         return 0;
895 }
896
897 static short mirror_bezier_yaxis(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
898 {
899         if (bezt->f2 & SELECT) {
900                 /* Yes, names are inverted, we are mirroring across y axis, hence along x axis... */
901                 mirror_bezier_xaxis_ex(bezt, 0.0f);
902         }
903
904         return 0;
905 }
906
907 static short mirror_bezier_xaxis(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
908 {
909         if (bezt->f2 & SELECT) {
910                 /* Yes, names are inverted, we are mirroring across x axis, hence along y axis... */
911                 mirror_bezier_yaxis_ex(bezt, 0.0f);
912         }
913
914         return 0;
915 }
916
917 static short mirror_bezier_marker(KeyframeEditData *ked, BezTriple *bezt)
918 {
919         /* mirroring time stored in f1 */
920         if (bezt->f2 & SELECT) {
921                 mirror_bezier_xaxis_ex(bezt, ked->f1);
922         }
923
924         return 0;
925 }
926
927 static short mirror_bezier_time(KeyframeEditData *ked, BezTriple *bezt)
928 {
929         /* value to mirror over is stored in f1 */
930         if (bezt->f2 & SELECT) {
931                 mirror_bezier_xaxis_ex(bezt, ked->f1);
932         }
933
934         return 0;
935 }
936
937 static short mirror_bezier_value(KeyframeEditData *ked, BezTriple *bezt)
938 {
939         /* value to mirror over is stored in the custom data -> first float value slot */
940         if (bezt->f2 & SELECT) {
941                 mirror_bezier_yaxis_ex(bezt, ked->f1);
942         }
943
944         return 0;
945 }
946
947 /* Note: for markers and 'value', the values to use must be supplied as the first float value */
948 // calchandles_fcurve
949 KeyframeEditFunc ANIM_editkeyframes_mirror(short type)
950 {
951         switch (type) {
952                 case MIRROR_KEYS_CURFRAME: /* mirror over current frame */
953                         return mirror_bezier_cframe;
954                 case MIRROR_KEYS_YAXIS: /* mirror over frame 0 */
955                         return mirror_bezier_yaxis;
956                 case MIRROR_KEYS_XAXIS: /* mirror over value 0 */
957                         return mirror_bezier_xaxis;
958                 case MIRROR_KEYS_MARKER: /* mirror over marker */
959                         return mirror_bezier_marker;
960                 case MIRROR_KEYS_TIME: /* mirror over frame/time */
961                         return mirror_bezier_time;
962                 case MIRROR_KEYS_VALUE: /* mirror over given value */
963                         return mirror_bezier_value;
964                 default: /* just in case */
965                         return mirror_bezier_yaxis;
966         }
967 }
968
969 /* ******************************************* */
970 /* Settings */
971
972 /* standard validation step for a few of these (implemented as macro for inlining without fn-call overhead):
973  * "if the handles are not of the same type, set them to type free"
974  */
975 #define ENSURE_HANDLES_MATCH(bezt)                                            \
976         if (bezt->h1 != bezt->h2) {                                               \
977                 if (ELEM(bezt->h1, HD_ALIGN, HD_AUTO, HD_AUTO_ANIM))                  \
978                         bezt->h1 = HD_FREE;                                               \
979                 if (ELEM(bezt->h2, HD_ALIGN, HD_AUTO, HD_AUTO_ANIM))                  \
980                         bezt->h2 = HD_FREE;                                               \
981         } (void)0
982
983 /* Sets the selected bezier handles to type 'auto' */
984 static short set_bezier_auto(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
985 {
986         if ((bezt->f1 & SELECT) || (bezt->f3 & SELECT)) {
987                 if (bezt->f1 & SELECT) bezt->h1 = HD_AUTO;
988                 if (bezt->f3 & SELECT) bezt->h2 = HD_AUTO;
989
990                 ENSURE_HANDLES_MATCH(bezt);
991         }
992         return 0;
993 }
994
995 /* Sets the selected bezier handles to type 'auto-clamped'
996  * NOTE: this is like auto above, but they're handled a bit different
997  */
998 static short set_bezier_auto_clamped(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
999 {
1000         if ((bezt->f1 & SELECT) || (bezt->f3 & SELECT)) {
1001                 if (bezt->f1 & SELECT) bezt->h1 = HD_AUTO_ANIM;
1002                 if (bezt->f3 & SELECT) bezt->h2 = HD_AUTO_ANIM;
1003
1004                 ENSURE_HANDLES_MATCH(bezt);
1005         }
1006         return 0;
1007 }
1008
1009 /* Sets the selected bezier handles to type 'vector'  */
1010 static short set_bezier_vector(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1011 {
1012         if (bezt->f1 & SELECT) bezt->h1 = HD_VECT;
1013         if (bezt->f3 & SELECT) bezt->h2 = HD_VECT;
1014         return 0;
1015 }
1016
1017 /* Queries if the handle should be set to 'free' or 'align' */
1018 // NOTE: this was used for the 'toggle free/align' option
1019 //              currently this isn't used, but may be restored later
1020 static short bezier_isfree(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1021 {
1022         if ((bezt->f1 & SELECT) && (bezt->h1)) return 1;
1023         if ((bezt->f3 & SELECT) && (bezt->h2)) return 1;
1024         return 0;
1025 }
1026
1027 /* Sets selected bezier handles to type 'align' */
1028 static short set_bezier_align(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1029 {
1030         if (bezt->f1 & SELECT) bezt->h1 = HD_ALIGN;
1031         if (bezt->f3 & SELECT) bezt->h2 = HD_ALIGN;
1032         return 0;
1033 }
1034
1035 /* Sets selected bezier handles to type 'free'  */
1036 static short set_bezier_free(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1037 {
1038         if (bezt->f1 & SELECT) bezt->h1 = HD_FREE;
1039         if (bezt->f3 & SELECT) bezt->h2 = HD_FREE;
1040         return 0;
1041 }
1042
1043 /* Set all selected Bezier Handles to a single type */
1044 // calchandles_fcurve
1045 KeyframeEditFunc ANIM_editkeyframes_handles(short code)
1046 {
1047         switch (code) {
1048                 case HD_AUTO: /* auto */
1049                         return set_bezier_auto;
1050                 case HD_AUTO_ANIM: /* auto clamped */
1051                         return set_bezier_auto_clamped;
1052
1053                 case HD_VECT: /* vector */
1054                         return set_bezier_vector;
1055                 case HD_FREE: /* free */
1056                         return set_bezier_free;
1057                 case HD_ALIGN: /* align */
1058                         return set_bezier_align;
1059
1060                 default: /* check for toggle free or align? */
1061                         return bezier_isfree;
1062         }
1063 }
1064
1065 /* ------- */
1066
1067 static short set_bezt_constant(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1068 {
1069         if (bezt->f2 & SELECT)
1070                 bezt->ipo = BEZT_IPO_CONST;
1071         return 0;
1072 }
1073
1074 static short set_bezt_linear(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1075 {
1076         if (bezt->f2 & SELECT)
1077                 bezt->ipo = BEZT_IPO_LIN;
1078         return 0;
1079 }
1080
1081 static short set_bezt_bezier(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1082 {
1083         if (bezt->f2 & SELECT)
1084                 bezt->ipo = BEZT_IPO_BEZ;
1085         return 0;
1086 }
1087
1088 static short set_bezt_back(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1089 {
1090         if (bezt->f2 & SELECT)
1091                 bezt->ipo = BEZT_IPO_BACK;
1092         return 0;
1093 }
1094
1095 static short set_bezt_bounce(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1096 {
1097         if (bezt->f2 & SELECT)
1098                 bezt->ipo = BEZT_IPO_BOUNCE;
1099         return 0;
1100 }
1101
1102 static short set_bezt_circle(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1103 {
1104         if (bezt->f2 & SELECT)
1105                 bezt->ipo = BEZT_IPO_CIRC;
1106         return 0;
1107 }
1108
1109 static short set_bezt_cubic(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1110 {
1111         if (bezt->f2 & SELECT)
1112                 bezt->ipo = BEZT_IPO_CUBIC;
1113         return 0;
1114 }
1115
1116 static short set_bezt_elastic(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1117 {
1118         if (bezt->f2 & SELECT)
1119                 bezt->ipo = BEZT_IPO_ELASTIC;
1120         return 0;
1121 }
1122
1123 static short set_bezt_expo(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1124 {
1125         if (bezt->f2 & SELECT)
1126                 bezt->ipo = BEZT_IPO_EXPO;
1127         return 0;
1128 }
1129
1130 static short set_bezt_quad(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1131 {
1132         if (bezt->f2 & SELECT)
1133                 bezt->ipo = BEZT_IPO_QUAD;
1134         return 0;
1135 }
1136
1137 static short set_bezt_quart(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1138 {
1139         if (bezt->f2 & SELECT)
1140                 bezt->ipo = BEZT_IPO_QUART;
1141         return 0;
1142 }
1143
1144 static short set_bezt_quint(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1145 {
1146         if (bezt->f2 & SELECT)
1147                 bezt->ipo = BEZT_IPO_QUINT;
1148         return 0;
1149 }
1150
1151 static short set_bezt_sine(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1152 {
1153         if (bezt->f2 & SELECT)
1154                 bezt->ipo = BEZT_IPO_SINE;
1155         return 0;
1156 }
1157
1158 /* Set the interpolation type of the selected BezTriples in each F-Curve to the specified one */
1159 // ANIM_editkeyframes_ipocurve_ipotype() !
1160 KeyframeEditFunc ANIM_editkeyframes_ipo(short code)
1161 {
1162         switch (code) {
1163                 /* interpolation */
1164                 case BEZT_IPO_CONST: /* constant */
1165                         return set_bezt_constant;
1166                 case BEZT_IPO_LIN: /* linear */
1167                         return set_bezt_linear;
1168
1169                 /* easing */
1170                 case BEZT_IPO_BACK:
1171                         return set_bezt_back;
1172                 case BEZT_IPO_BOUNCE:
1173                         return set_bezt_bounce;
1174                 case BEZT_IPO_CIRC:
1175                         return set_bezt_circle;
1176                 case BEZT_IPO_CUBIC:
1177                         return set_bezt_cubic;
1178                 case BEZT_IPO_ELASTIC:
1179                         return set_bezt_elastic;
1180                 case BEZT_IPO_EXPO:
1181                         return set_bezt_expo;
1182                 case BEZT_IPO_QUAD:
1183                         return set_bezt_quad;
1184                 case BEZT_IPO_QUART:
1185                         return set_bezt_quart;
1186                 case BEZT_IPO_QUINT:
1187                         return set_bezt_quint;
1188                 case BEZT_IPO_SINE:
1189                         return set_bezt_sine;
1190
1191                 default: /* bezier */
1192                         return set_bezt_bezier;
1193         }
1194 }
1195
1196 /* ------- */
1197
1198 static short set_keytype_keyframe(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1199 {
1200         if (bezt->f2 & SELECT)
1201                 BEZKEYTYPE(bezt) = BEZT_KEYTYPE_KEYFRAME;
1202         return 0;
1203 }
1204
1205 static short set_keytype_breakdown(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1206 {
1207         if (bezt->f2 & SELECT)
1208                 BEZKEYTYPE(bezt) = BEZT_KEYTYPE_BREAKDOWN;
1209         return 0;
1210 }
1211
1212 static short set_keytype_extreme(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1213 {
1214         if (bezt->f2 & SELECT)
1215                 BEZKEYTYPE(bezt) = BEZT_KEYTYPE_EXTREME;
1216         return 0;
1217 }
1218
1219 static short set_keytype_jitter(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1220 {
1221         if (bezt->f2 & SELECT)
1222                 BEZKEYTYPE(bezt) = BEZT_KEYTYPE_JITTER;
1223         return 0;
1224 }
1225
1226 static short set_keytype_moving_hold(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1227 {
1228         if (bezt->f2 & SELECT)
1229                 BEZKEYTYPE(bezt) = BEZT_KEYTYPE_MOVEHOLD;
1230         return 0;
1231 }
1232
1233 /* Set the interpolation type of the selected BezTriples in each F-Curve to the specified one */
1234 KeyframeEditFunc ANIM_editkeyframes_keytype(short code)
1235 {
1236         switch (code) {
1237                 case BEZT_KEYTYPE_BREAKDOWN: /* breakdown */
1238                         return set_keytype_breakdown;
1239
1240                 case BEZT_KEYTYPE_EXTREME: /* extreme keyframe */
1241                         return set_keytype_extreme;
1242
1243                 case BEZT_KEYTYPE_JITTER: /* jitter keyframe */
1244                         return set_keytype_jitter;
1245
1246                 case BEZT_KEYTYPE_MOVEHOLD: /* moving hold */
1247                         return set_keytype_moving_hold;
1248
1249                 case BEZT_KEYTYPE_KEYFRAME: /* proper keyframe */
1250                 default:
1251                         return set_keytype_keyframe;
1252         }
1253 }
1254
1255 /* ------- */
1256
1257 static short set_easingtype_easein(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1258 {
1259         if (bezt->f2 & SELECT)
1260                 bezt->easing = BEZT_IPO_EASE_IN;
1261         return 0;
1262 }
1263
1264 static short set_easingtype_easeout(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1265 {
1266         if (bezt->f2 & SELECT)
1267                 bezt->easing = BEZT_IPO_EASE_OUT;
1268         return 0;
1269 }
1270
1271 static short set_easingtype_easeinout(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1272 {
1273         if (bezt->f2 & SELECT)
1274                 bezt->easing = BEZT_IPO_EASE_IN_OUT;
1275         return 0;
1276 }
1277
1278 static short set_easingtype_easeauto(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1279 {
1280         if (bezt->f2 & SELECT)
1281                 bezt->easing = BEZT_IPO_EASE_AUTO;
1282         return 0;
1283 }
1284
1285 /* Set the easing type of the selected BezTriples in each F-Curve to the specified one */
1286 KeyframeEditFunc ANIM_editkeyframes_easing(short mode)
1287 {
1288         switch (mode) {
1289                 case BEZT_IPO_EASE_IN: /* ease in */
1290                         return set_easingtype_easein;
1291
1292                 case BEZT_IPO_EASE_OUT: /* ease out */
1293                         return set_easingtype_easeout;
1294
1295                 case BEZT_IPO_EASE_IN_OUT: /* both */
1296                         return set_easingtype_easeinout;
1297
1298                 default: /* auto */
1299                         return set_easingtype_easeauto;
1300         }
1301 }
1302
1303 /* ******************************************* */
1304 /* Selection */
1305
1306 static short select_bezier_add(KeyframeEditData *ked, BezTriple *bezt)
1307 {
1308         /* if we've got info on what to select, use it, otherwise select all */
1309         if ((ked) && (ked->iterflags & KEYFRAME_ITER_INCL_HANDLES)) {
1310                 if (ked->curflags & KEYFRAME_OK_KEY)
1311                         bezt->f2 |= SELECT;
1312                 if (ked->curflags & KEYFRAME_OK_H1)
1313                         bezt->f1 |= SELECT;
1314                 if (ked->curflags & KEYFRAME_OK_H2)
1315                         bezt->f3 |= SELECT;
1316         }
1317         else {
1318                 BEZT_SEL_ALL(bezt);
1319         }
1320
1321         return 0;
1322 }
1323
1324 static short select_bezier_subtract(KeyframeEditData *ked, BezTriple *bezt)
1325 {
1326         /* if we've got info on what to deselect, use it, otherwise deselect all */
1327         if ((ked) && (ked->iterflags & KEYFRAME_ITER_INCL_HANDLES)) {
1328                 if (ked->curflags & KEYFRAME_OK_KEY)
1329                         bezt->f2 &= ~SELECT;
1330                 if (ked->curflags & KEYFRAME_OK_H1)
1331                         bezt->f1 &= ~SELECT;
1332                 if (ked->curflags & KEYFRAME_OK_H2)
1333                         bezt->f3 &= ~SELECT;
1334         }
1335         else {
1336                 BEZT_DESEL_ALL(bezt);
1337         }
1338
1339         return 0;
1340 }
1341
1342 static short select_bezier_invert(KeyframeEditData *UNUSED(ked), BezTriple *bezt)
1343 {
1344         /* Invert the selection for the whole bezier triple */
1345         bezt->f2 ^= SELECT;
1346         if (bezt->f2 & SELECT) {
1347                 bezt->f1 |= SELECT;
1348                 bezt->f3 |= SELECT;
1349         }
1350         else {
1351                 bezt->f1 &= ~SELECT;
1352                 bezt->f3 &= ~SELECT;
1353         }
1354         return 0;
1355 }
1356
1357 KeyframeEditFunc ANIM_editkeyframes_select(short selectmode)
1358 {
1359         switch (selectmode) {
1360                 case SELECT_ADD: /* add */
1361                         return select_bezier_add;
1362                 case SELECT_SUBTRACT: /* subtract */
1363                         return select_bezier_subtract;
1364                 case SELECT_INVERT: /* invert */
1365                         return select_bezier_invert;
1366                 default: /* replace (need to clear all, then add) */
1367                         return select_bezier_add;
1368         }
1369 }
1370
1371 /* ******************************************* */
1372 /* Selection Maps */
1373
1374 /* Selection maps are simply fancy names for char arrays that store on/off
1375  * info for whether the selection status. The main purpose for these is to
1376  * allow extra info to be tagged to the keyframes without influencing their
1377  * values or having to be removed later.
1378  */
1379
1380 /* ----------- */
1381
1382 static short selmap_build_bezier_more(KeyframeEditData *ked, BezTriple *bezt)
1383 {
1384         FCurve *fcu = ked->fcu;
1385         char *map = ked->data;
1386         int i = ked->curIndex;
1387
1388         /* if current is selected, just make sure it stays this way */
1389         if (BEZT_ISSEL_ANY(bezt)) {
1390                 map[i] = 1;
1391                 return 0;
1392         }
1393
1394         /* if previous is selected, that means that selection should extend across */
1395         if (i > 0) {
1396                 BezTriple *prev = bezt - 1;
1397
1398                 if (BEZT_ISSEL_ANY(prev)) {
1399                         map[i] = 1;
1400                         return 0;
1401                 }
1402         }
1403
1404         /* if next is selected, that means that selection should extend across */
1405         if (i < (fcu->totvert - 1)) {
1406                 BezTriple *next = bezt + 1;
1407
1408                 if (BEZT_ISSEL_ANY(next)) {
1409                         map[i] = 1;
1410                         return 0;
1411                 }
1412         }
1413
1414         return 0;
1415 }
1416
1417 static short selmap_build_bezier_less(KeyframeEditData *ked, BezTriple *bezt)
1418 {
1419         FCurve *fcu = ked->fcu;
1420         char *map = ked->data;
1421         int i = ked->curIndex;
1422
1423         /* if current is selected, check the left/right keyframes
1424          * since it might need to be deselected (but otherwise no)
1425          */
1426         if (BEZT_ISSEL_ANY(bezt)) {
1427                 /* if previous is not selected, we're on the tip of an iceberg */
1428                 if (i > 0) {
1429                         BezTriple *prev = bezt - 1;
1430
1431                         if (BEZT_ISSEL_ANY(prev) == 0)
1432                                 return 0;
1433                 }
1434                 else if (i == 0) {
1435                         /* current keyframe is selected at an endpoint, so should get deselected */
1436                         return 0;
1437                 }
1438
1439                 /* if next is not selected, we're on the tip of an iceberg */
1440                 if (i < (fcu->totvert - 1)) {
1441                         BezTriple *next = bezt + 1;
1442
1443                         if (BEZT_ISSEL_ANY(next) == 0)
1444                                 return 0;
1445                 }
1446                 else if (i == (fcu->totvert - 1)) {
1447                         /* current keyframe is selected at an endpoint, so should get deselected */
1448                         return 0;
1449                 }
1450
1451                 /* if we're still here, that means that keyframe should remain untouched */
1452                 map[i] = 1;
1453         }
1454
1455         return 0;
1456 }
1457
1458 /* Get callback for building selection map */
1459 KeyframeEditFunc ANIM_editkeyframes_buildselmap(short mode)
1460 {
1461         switch (mode) {
1462                 case SELMAP_LESS: /* less */
1463                         return selmap_build_bezier_less;
1464
1465                 case SELMAP_MORE: /* more */
1466                 default:
1467                         return selmap_build_bezier_more;
1468         }
1469 }
1470
1471 /* ----------- */
1472
1473 /* flush selection map values to the given beztriple */
1474 short bezt_selmap_flush(KeyframeEditData *ked, BezTriple *bezt)
1475 {
1476         const char *map = ked->data;
1477         short on = map[ked->curIndex];
1478
1479         /* select or deselect based on whether the map allows it or not */
1480         if (on) {
1481                 BEZT_SEL_ALL(bezt);
1482         }
1483         else {
1484                 BEZT_DESEL_ALL(bezt);
1485         }
1486
1487         return 0;
1488 }