4bd738fca95f1aecd2657955ef73359db8f94a17
[blender.git] / source / blender / editors / space_graph / graph_select.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation
17  */
18
19 /** \file
20  * \ingroup spgraph
21  */
22
23 #include <math.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <float.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_blenlib.h"
31 #include "BLI_math.h"
32 #include "BLI_utildefines.h"
33 #include "BLI_lasso_2d.h"
34
35 #include "DNA_anim_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_space_types.h"
39
40 #include "RNA_access.h"
41 #include "RNA_define.h"
42
43 #include "BKE_fcurve.h"
44 #include "BKE_nla.h"
45 #include "BKE_context.h"
46
47 #include "UI_view2d.h"
48
49 #include "ED_anim_api.h"
50 #include "ED_keyframes_edit.h"
51 #include "ED_markers.h"
52 #include "ED_select_utils.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "graph_intern.h"
58
59 /* ************************************************************************** */
60 /* KEYFRAMES STUFF */
61
62 /* temp info for caching handle vertices close */
63 typedef struct tNearestVertInfo {
64   struct tNearestVertInfo *next, *prev;
65
66   FCurve *fcu; /* F-Curve that keyframe comes from */
67
68   BezTriple *bezt; /* keyframe to consider */
69   FPoint *fpt;     /* sample point to consider */
70
71   short hpoint; /* the handle index that we hit (eHandleIndex) */
72   short sel;    /* whether the handle is selected or not */
73   int dist;     /* distance from mouse to vert */
74
75   eAnim_ChannelType ctype; /* type of animation channel this FCurve comes from */
76
77   float frame; /* frame that point was on when it matched (global time) */
78 } tNearestVertInfo;
79
80 /* Tags for the type of graph vert that we have */
81 typedef enum eGraphVertIndex {
82   NEAREST_HANDLE_LEFT = -1,
83   NEAREST_HANDLE_KEY,
84   NEAREST_HANDLE_RIGHT,
85 } eGraphVertIndex;
86
87 /* Tolerance for absolute radius (in pixels) of the vert from the cursor to use */
88 // TODO: perhaps this should depend a bit on the size that the user set the vertices to be?
89 #define GVERTSEL_TOL (10 * U.pixelsize)
90
91 /* ....... */
92
93 /* check if its ok to select a handle */
94 // XXX also need to check for int-values only?
95 static bool fcurve_handle_sel_check(SpaceGraph *sipo, BezTriple *bezt)
96 {
97   if (sipo->flag & SIPO_NOHANDLES) {
98     return 0;
99   }
100   if ((sipo->flag & SIPO_SELVHANDLESONLY) && BEZT_ISSEL_ANY(bezt) == 0) {
101     return 0;
102   }
103   return 1;
104 }
105
106 /* check if the given vertex is within bounds or not */
107 // TODO: should we return if we hit something?
108 static void nearest_fcurve_vert_store(ListBase *matches,
109                                       View2D *v2d,
110                                       FCurve *fcu,
111                                       eAnim_ChannelType ctype,
112                                       BezTriple *bezt,
113                                       FPoint *fpt,
114                                       short hpoint,
115                                       const int mval[2],
116                                       float unit_scale,
117                                       float offset)
118 {
119   /* Keyframes or Samples? */
120   if (bezt) {
121     int screen_co[2], dist;
122
123     /* convert from data-space to screen coordinates
124      * NOTE: hpoint+1 gives us 0,1,2 respectively for each handle,
125      *  needed to access the relevant vertex coordinates in the 3x3
126      *  'vec' matrix
127      */
128     if (UI_view2d_view_to_region_clip(v2d,
129                                       bezt->vec[hpoint + 1][0],
130                                       (bezt->vec[hpoint + 1][1] + offset) * unit_scale,
131                                       &screen_co[0],
132                                       &screen_co[1]) &&
133         /* check if distance from mouse cursor to vert in screen space is within tolerance */
134         ((dist = len_v2v2_int(mval, screen_co)) <= GVERTSEL_TOL)) {
135       tNearestVertInfo *nvi = (tNearestVertInfo *)matches->last;
136       bool replace = false;
137
138       /* If there is already a point for the F-Curve,
139        * check if this point is closer than that was. */
140       if ((nvi) && (nvi->fcu == fcu)) {
141         /* replace if we are closer, or if equal and that one wasn't selected but we are... */
142         if ((nvi->dist > dist) || ((nvi->sel == 0) && BEZT_ISSEL_ANY(bezt))) {
143           replace = 1;
144         }
145       }
146       /* add new if not replacing... */
147       if (replace == 0) {
148         nvi = MEM_callocN(sizeof(tNearestVertInfo), "Nearest Graph Vert Info - Bezt");
149       }
150
151       /* store values */
152       nvi->fcu = fcu;
153       nvi->ctype = ctype;
154
155       nvi->bezt = bezt;
156       nvi->hpoint = hpoint;
157       nvi->dist = dist;
158
159       nvi->frame = bezt->vec[1][0]; /* currently in global time... */
160
161       nvi->sel = BEZT_ISSEL_ANY(bezt);  // XXX... should this use the individual verts instead?
162
163       /* add to list of matches if appropriate... */
164       if (replace == 0) {
165         BLI_addtail(matches, nvi);
166       }
167     }
168   }
169   else if (fpt) {
170     /* TODO... */
171   }
172 }
173
174 /* helper for find_nearest_fcurve_vert() - build the list of nearest matches */
175 static void get_nearest_fcurve_verts_list(bAnimContext *ac, const int mval[2], ListBase *matches)
176 {
177   ListBase anim_data = {NULL, NULL};
178   bAnimListElem *ale;
179   int filter;
180
181   SpaceGraph *sipo = (SpaceGraph *)ac->sl;
182   View2D *v2d = &ac->ar->v2d;
183   short mapping_flag = 0;
184
185   /* get curves to search through
186    * - if the option to only show keyframes that belong to selected F-Curves is enabled,
187    *   include the 'only selected' flag...
188    */
189   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
190   if (sipo->flag &
191       SIPO_SELCUVERTSONLY) {  // FIXME: this should really be check for by the filtering code...
192     filter |= ANIMFILTER_SEL;
193   }
194   mapping_flag |= ANIM_get_normalization_flags(ac);
195   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
196
197   for (ale = anim_data.first; ale; ale = ale->next) {
198     FCurve *fcu = (FCurve *)ale->key_data;
199     AnimData *adt = ANIM_nla_mapping_get(ac, ale);
200     float offset;
201     float unit_scale = ANIM_unit_mapping_get_factor(
202         ac->scene, ale->id, fcu, mapping_flag, &offset);
203
204     /* apply NLA mapping to all the keyframes */
205     if (adt) {
206       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 0);
207     }
208
209     if (fcu->bezt) {
210       BezTriple *bezt1 = fcu->bezt, *prevbezt = NULL;
211       int i;
212
213       for (i = 0; i < fcu->totvert; i++, prevbezt = bezt1, bezt1++) {
214         /* keyframe */
215         nearest_fcurve_vert_store(matches,
216                                   v2d,
217                                   fcu,
218                                   ale->type,
219                                   bezt1,
220                                   NULL,
221                                   NEAREST_HANDLE_KEY,
222                                   mval,
223                                   unit_scale,
224                                   offset);
225
226         /* handles - only do them if they're visible */
227         if (fcurve_handle_sel_check(sipo, bezt1) && (fcu->totvert > 1)) {
228           /* first handle only visible if previous segment had handles */
229           if ((!prevbezt && (bezt1->ipo == BEZT_IPO_BEZ)) ||
230               (prevbezt && (prevbezt->ipo == BEZT_IPO_BEZ))) {
231             nearest_fcurve_vert_store(matches,
232                                       v2d,
233                                       fcu,
234                                       ale->type,
235                                       bezt1,
236                                       NULL,
237                                       NEAREST_HANDLE_LEFT,
238                                       mval,
239                                       unit_scale,
240                                       offset);
241           }
242
243           /* second handle only visible if this segment is bezier */
244           if (bezt1->ipo == BEZT_IPO_BEZ) {
245             nearest_fcurve_vert_store(matches,
246                                       v2d,
247                                       fcu,
248                                       ale->type,
249                                       bezt1,
250                                       NULL,
251                                       NEAREST_HANDLE_RIGHT,
252                                       mval,
253                                       unit_scale,
254                                       offset);
255           }
256         }
257       }
258     }
259     else if (fcu->fpt) {
260       // TODO; do this for samples too
261     }
262
263     /* un-apply NLA mapping from all the keyframes */
264     if (adt) {
265       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 0);
266     }
267   }
268
269   /* free channels */
270   ANIM_animdata_freelist(&anim_data);
271 }
272
273 /* helper for find_nearest_fcurve_vert() - get the best match to use */
274 static tNearestVertInfo *get_best_nearest_fcurve_vert(ListBase *matches)
275 {
276   tNearestVertInfo *nvi = NULL;
277   short found = 0;
278
279   /* abort if list is empty */
280   if (BLI_listbase_is_empty(matches)) {
281     return NULL;
282   }
283
284   /* if list only has 1 item, remove it from the list and return */
285   if (BLI_listbase_is_single(matches)) {
286     /* need to remove from the list, otherwise it gets freed and then we can't return it */
287     return BLI_pophead(matches);
288   }
289
290   /* try to find the first selected F-Curve vert, then take the one after it */
291   for (nvi = matches->first; nvi; nvi = nvi->next) {
292     /* which mode of search are we in: find first selected, or find vert? */
293     if (found) {
294       /* Just take this vert now that we've found the selected one
295        * - We'll need to remove this from the list
296        *   so that it can be returned to the original caller.
297        */
298       BLI_remlink(matches, nvi);
299       return nvi;
300     }
301     else {
302       /* if vert is selected, we've got what we want... */
303       if (nvi->sel) {
304         found = 1;
305       }
306     }
307   }
308
309   /* if we're still here, this means that we failed to find anything appropriate in the first pass,
310    * so just take the first item now...
311    */
312   return BLI_pophead(matches);
313 }
314
315 /**
316  * Find the nearest vertices (either a handle or the keyframe)
317  * that are nearest to the mouse cursor (in area coordinates)
318  *
319  * \note the match info found must still be freed.
320  */
321 static tNearestVertInfo *find_nearest_fcurve_vert(bAnimContext *ac, const int mval[2])
322 {
323   ListBase matches = {NULL, NULL};
324   tNearestVertInfo *nvi;
325
326   /* step 1: get the nearest verts */
327   get_nearest_fcurve_verts_list(ac, mval, &matches);
328
329   /* step 2: find the best vert */
330   nvi = get_best_nearest_fcurve_vert(&matches);
331
332   BLI_freelistN(&matches);
333
334   /* return the best vert found */
335   return nvi;
336 }
337
338 /* ******************** Deselect All Operator ***************************** */
339 /* This operator works in one of three ways:
340  * 1) (de)select all (AKEY) - test if select all or deselect all
341  * 2) invert all (CTRL-IKEY) - invert selection of all keyframes
342  * 3) (de)select all - no testing is done; only for use internal tools as normal function...
343  */
344
345 /* Deselects keyframes in the Graph Editor
346  * - This is called by the deselect all operator, as well as other ones!
347  *
348  * - test: check if select or deselect all
349  * - sel: how to select keyframes
350  *   0 = deselect
351  *   1 = select
352  *   2 = invert
353  * - do_channels: whether to affect selection status of channels
354  */
355 void deselect_graph_keys(bAnimContext *ac, bool test, short sel, bool do_channels)
356 {
357   ListBase anim_data = {NULL, NULL};
358   bAnimListElem *ale;
359   int filter;
360
361   SpaceGraph *sipo = (SpaceGraph *)ac->sl;
362   KeyframeEditData ked = {{NULL}};
363   KeyframeEditFunc test_cb, sel_cb;
364
365   /* determine type-based settings */
366   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
367
368   /* filter data */
369   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
370
371   /* init BezTriple looping data */
372   test_cb = ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
373
374   /* See if we should be selecting or deselecting */
375   if (test) {
376     for (ale = anim_data.first; ale; ale = ale->next) {
377       if (ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, test_cb, NULL)) {
378         sel = SELECT_SUBTRACT;
379         break;
380       }
381     }
382   }
383
384   /* convert sel to selectmode, and use that to get editor */
385   sel_cb = ANIM_editkeyframes_select(sel);
386
387   /* Now set the flags */
388   for (ale = anim_data.first; ale; ale = ale->next) {
389     FCurve *fcu = (FCurve *)ale->key_data;
390
391     /* Keyframes First */
392     ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, sel_cb, NULL);
393
394     /* affect channel selection status? */
395     if (do_channels) {
396       /* Only change selection of channel when the visibility of keyframes
397        * doesn't depend on this. */
398       if ((sipo->flag & SIPO_SELCUVERTSONLY) == 0) {
399         /* deactivate the F-Curve, and deselect if deselecting keyframes.
400          * otherwise select the F-Curve too since we've selected all the keyframes
401          */
402         if (sel == SELECT_SUBTRACT) {
403           fcu->flag &= ~FCURVE_SELECTED;
404         }
405         else {
406           fcu->flag |= FCURVE_SELECTED;
407         }
408       }
409
410       /* always deactivate all F-Curves if we perform batch ops for selection */
411       fcu->flag &= ~FCURVE_ACTIVE;
412     }
413   }
414
415   /* Cleanup */
416   ANIM_animdata_freelist(&anim_data);
417 }
418
419 /* ------------------- */
420
421 static int graphkeys_deselectall_exec(bContext *C, wmOperator *op)
422 {
423   bAnimContext ac;
424   bAnimListElem *ale_active = NULL;
425
426   /* get editor data */
427   if (ANIM_animdata_get_context(C, &ac) == 0) {
428     return OPERATOR_CANCELLED;
429   }
430
431   /* find active F-Curve, and preserve this for later
432    * or else it becomes annoying with the current active
433    * curve keeps fading out even while you're editing it
434    */
435   ale_active = get_active_fcurve_channel(&ac);
436
437   /* 'standard' behavior - check if selected, then apply relevant selection */
438   const int action = RNA_enum_get(op->ptr, "action");
439   switch (action) {
440     case SEL_TOGGLE:
441       deselect_graph_keys(&ac, 1, SELECT_ADD, true);
442       break;
443     case SEL_SELECT:
444       deselect_graph_keys(&ac, 0, SELECT_ADD, true);
445       break;
446     case SEL_DESELECT:
447       deselect_graph_keys(&ac, 0, SELECT_SUBTRACT, true);
448       break;
449     case SEL_INVERT:
450       deselect_graph_keys(&ac, 0, SELECT_INVERT, true);
451       break;
452     default:
453       BLI_assert(0);
454       break;
455   }
456
457   /* restore active F-Curve... */
458   if (ale_active) {
459     FCurve *fcu = (FCurve *)ale_active->data;
460
461     /* all others should not be disabled, so we should be able to just set this directly...
462      * - selection needs to be set too, or else this won't work...
463      */
464     fcu->flag |= (FCURVE_SELECTED | FCURVE_ACTIVE);
465
466     MEM_freeN(ale_active);
467     ale_active = NULL;
468   }
469
470   /* set notifier that things have changed */
471   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
472
473   return OPERATOR_FINISHED;
474 }
475
476 void GRAPH_OT_select_all(wmOperatorType *ot)
477 {
478   /* identifiers */
479   ot->name = "Select All";
480   ot->idname = "GRAPH_OT_select_all";
481   ot->description = "Toggle selection of all keyframes";
482
483   /* api callbacks */
484   ot->exec = graphkeys_deselectall_exec;
485   ot->poll = graphop_visible_keyframes_poll;
486
487   /* flags */
488   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
489
490   /* properties */
491   WM_operator_properties_select_all(ot);
492 }
493
494 /* ******************** Box Select Operator **************************** */
495 /* This operator currently works in one of three ways:
496  * -> BKEY     - 1) all keyframes within region are selected (validation with BEZT_OK_REGION)
497  * -> ALT-BKEY - depending on which axis of the region was larger...
498  *    -> 2) x-axis, so select all frames within frame range (validation with BEZT_OK_FRAMERANGE)
499  *    -> 3) y-axis, so select all frames within channels that region included
500  *          (validation with BEZT_OK_VALUERANGE).
501  *
502  * The selection backend is also reused for the Lasso and Circle select operators.
503  */
504
505 /* Box Select only selects keyframes now, as overshooting handles often get caught too,
506  * which means that they may be inadvertently moved as well. However, incl_handles overrides
507  * this, and allow handles to be considered independently too.
508  * Also, for convenience, handles should get same status as keyframe (if it was within bounds).
509  */
510 static void box_select_graphkeys(bAnimContext *ac,
511                                  const rctf *rectf_view,
512                                  short mode,
513                                  short selectmode,
514                                  bool incl_handles,
515                                  void *data)
516 {
517   ListBase anim_data = {NULL, NULL};
518   bAnimListElem *ale;
519   int filter, mapping_flag;
520
521   SpaceGraph *sipo = (SpaceGraph *)ac->sl;
522   KeyframeEditData ked;
523   KeyframeEditFunc ok_cb, select_cb;
524   View2D *v2d = &ac->ar->v2d;
525   rctf rectf, scaled_rectf;
526
527   /* Convert mouse coordinates to frame ranges and
528    * channel coordinates corrected for view pan/zoom. */
529   UI_view2d_region_to_view_rctf(v2d, rectf_view, &rectf);
530
531   /* filter data */
532   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
533   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
534
535   /* get beztriple editing/validation funcs  */
536   select_cb = ANIM_editkeyframes_select(selectmode);
537   ok_cb = ANIM_editkeyframes_ok(mode);
538
539   /* init editing data */
540   memset(&ked, 0, sizeof(KeyframeEditData));
541   if (mode == BEZT_OK_REGION_LASSO) {
542     KeyframeEdit_LassoData *data_lasso = data;
543     data_lasso->rectf_scaled = &scaled_rectf;
544     ked.data = data_lasso;
545   }
546   else if (mode == BEZT_OK_REGION_CIRCLE) {
547     KeyframeEdit_CircleData *data_circle = data;
548     data_circle->rectf_scaled = &scaled_rectf;
549     ked.data = data;
550   }
551   else {
552     ked.data = &scaled_rectf;
553   }
554
555   /* treat handles separately? */
556   if (incl_handles) {
557     ked.iterflags |= KEYFRAME_ITER_INCL_HANDLES;
558     mapping_flag = 0;
559   }
560   else {
561     mapping_flag = ANIM_UNITCONV_ONLYKEYS;
562   }
563
564   mapping_flag |= ANIM_get_normalization_flags(ac);
565
566   /* loop over data, doing box select */
567   for (ale = anim_data.first; ale; ale = ale->next) {
568     AnimData *adt = ANIM_nla_mapping_get(ac, ale);
569     FCurve *fcu = (FCurve *)ale->key_data;
570     float offset;
571     float unit_scale = ANIM_unit_mapping_get_factor(
572         ac->scene, ale->id, fcu, mapping_flag, &offset);
573
574     /* apply NLA mapping to all the keyframes, since it's easier than trying to
575      * guess when a callback might use something different
576      */
577     if (adt) {
578       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, incl_handles == 0);
579     }
580
581     scaled_rectf.xmin = rectf.xmin;
582     scaled_rectf.xmax = rectf.xmax;
583     scaled_rectf.ymin = rectf.ymin / unit_scale - offset;
584     scaled_rectf.ymax = rectf.ymax / unit_scale - offset;
585
586     /* set horizontal range (if applicable)
587      * NOTE: these values are only used for x-range and y-range but not region
588      *      (which uses ked.data, i.e. rectf)
589      */
590     if (mode != BEZT_OK_VALUERANGE) {
591       ked.f1 = rectf.xmin;
592       ked.f2 = rectf.xmax;
593     }
594     else {
595       ked.f1 = rectf.ymin;
596       ked.f2 = rectf.ymax;
597     }
598
599     /* firstly, check if any keyframes will be hit by this */
600     if (ANIM_fcurve_keyframes_loop(&ked, fcu, NULL, ok_cb, NULL)) {
601       /* select keyframes that are in the appropriate places */
602       ANIM_fcurve_keyframes_loop(&ked, fcu, ok_cb, select_cb, NULL);
603
604       /* Only change selection of channel when the visibility of keyframes
605        * doesn't depend on this. */
606       if ((sipo->flag & SIPO_SELCUVERTSONLY) == 0) {
607         /* select the curve too now that curve will be touched */
608         if (selectmode == SELECT_ADD) {
609           fcu->flag |= FCURVE_SELECTED;
610         }
611       }
612     }
613
614     /* un-apply NLA mapping from all the keyframes */
615     if (adt) {
616       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, incl_handles == 0);
617     }
618   }
619
620   /* cleanup */
621   ANIM_animdata_freelist(&anim_data);
622 }
623
624 /* ------------------- */
625
626 static int graphkeys_box_select_invoke(bContext *C, wmOperator *op, const wmEvent *event)
627 {
628   bAnimContext ac;
629   if (ANIM_animdata_get_context(C, &ac) == 0) {
630     return OPERATOR_CANCELLED;
631   }
632
633   if (RNA_boolean_get(op->ptr, "tweak")) {
634     tNearestVertInfo *under_mouse = find_nearest_fcurve_vert(&ac, event->mval);
635     bool mouse_is_over_element = under_mouse != NULL;
636     if (under_mouse) {
637       MEM_freeN(under_mouse);
638     }
639
640     if (mouse_is_over_element) {
641       return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
642     }
643   }
644
645   return WM_gesture_box_invoke(C, op, event);
646 }
647
648 static int graphkeys_box_select_exec(bContext *C, wmOperator *op)
649 {
650   bAnimContext ac;
651   rcti rect;
652   rctf rect_fl;
653   short mode = 0;
654
655   /* get editor data */
656   if (ANIM_animdata_get_context(C, &ac) == 0) {
657     return OPERATOR_CANCELLED;
658   }
659
660   const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
661   const int selectmode = (sel_op != SEL_OP_SUB) ? SELECT_ADD : SELECT_SUBTRACT;
662   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
663     deselect_graph_keys(&ac, 1, SELECT_SUBTRACT, true);
664   }
665
666   /* 'include_handles' from the operator specifies whether to include handles in the selection. */
667   const bool incl_handles = RNA_boolean_get(op->ptr, "include_handles");
668
669   /* get settings from operator */
670   WM_operator_properties_border_to_rcti(op, &rect);
671
672   /* selection 'mode' depends on whether box_select region only matters on one axis */
673   if (RNA_boolean_get(op->ptr, "axis_range")) {
674     /* mode depends on which axis of the range is larger to determine which axis to use
675      * - Checking this in region-space is fine, as it's fundamentally still going to be a
676      *   different rect size.
677      * - The frame-range select option is favored over the channel one (x over y),
678      *   as frame-range one is often used for tweaking timing when "blocking",
679      *   while channels is not that useful.
680      */
681     if ((BLI_rcti_size_x(&rect)) >= (BLI_rcti_size_y(&rect))) {
682       mode = BEZT_OK_FRAMERANGE;
683     }
684     else {
685       mode = BEZT_OK_VALUERANGE;
686     }
687   }
688   else {
689     mode = BEZT_OK_REGION;
690   }
691
692   BLI_rctf_rcti_copy(&rect_fl, &rect);
693
694   /* apply box_select action */
695   box_select_graphkeys(&ac, &rect_fl, mode, selectmode, incl_handles, NULL);
696
697   /* send notifier that keyframe selection has changed */
698   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
699
700   return OPERATOR_FINISHED;
701 }
702
703 void GRAPH_OT_select_box(wmOperatorType *ot)
704 {
705   /* identifiers */
706   ot->name = "Box Select";
707   ot->idname = "GRAPH_OT_select_box";
708   ot->description = "Select all keyframes within the specified region";
709
710   /* api callbacks */
711   ot->invoke = graphkeys_box_select_invoke;
712   ot->exec = graphkeys_box_select_exec;
713   ot->modal = WM_gesture_box_modal;
714   ot->cancel = WM_gesture_box_cancel;
715
716   ot->poll = graphop_visible_keyframes_poll;
717
718   /* flags */
719   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
720
721   /* properties */
722   ot->prop = RNA_def_boolean(ot->srna, "axis_range", 0, "Axis Range", "");
723   RNA_def_boolean(ot->srna,
724                   "include_handles",
725                   0,
726                   "Include Handles",
727                   "Are handles tested individually against the selection criteria");
728
729   PropertyRNA *prop = RNA_def_boolean(
730       ot->srna, "tweak", 0, "Tweak", "Operator has been activated using a tweak event");
731   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
732
733   WM_operator_properties_gesture_box(ot);
734   WM_operator_properties_select_operation_simple(ot);
735 }
736
737 /* ------------------- */
738
739 static int graphkeys_lassoselect_exec(bContext *C, wmOperator *op)
740 {
741   bAnimContext ac;
742
743   KeyframeEdit_LassoData data_lasso = {0};
744   rcti rect;
745   rctf rect_fl;
746
747   bool incl_handles;
748
749   /* get editor data */
750   if (ANIM_animdata_get_context(C, &ac) == 0) {
751     return OPERATOR_CANCELLED;
752   }
753
754   data_lasso.rectf_view = &rect_fl;
755   data_lasso.mcords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcords_tot);
756   if (data_lasso.mcords == NULL) {
757     return OPERATOR_CANCELLED;
758   }
759
760   const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
761   const short selectmode = (sel_op != SEL_OP_SUB) ? SELECT_ADD : SELECT_SUBTRACT;
762   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
763     deselect_graph_keys(&ac, 0, SELECT_SUBTRACT, true);
764   }
765
766   {
767     SpaceGraph *sipo = (SpaceGraph *)ac.sl;
768     if (selectmode == SELECT_ADD) {
769       incl_handles = ((sipo->flag & SIPO_SELVHANDLESONLY) || (sipo->flag & SIPO_NOHANDLES)) == 0;
770     }
771     else {
772       incl_handles = (sipo->flag & SIPO_NOHANDLES) == 0;
773     }
774   }
775
776   /* get settings from operator */
777   BLI_lasso_boundbox(&rect, data_lasso.mcords, data_lasso.mcords_tot);
778   BLI_rctf_rcti_copy(&rect_fl, &rect);
779
780   /* apply box_select action */
781   box_select_graphkeys(&ac, &rect_fl, BEZT_OK_REGION_LASSO, selectmode, incl_handles, &data_lasso);
782
783   MEM_freeN((void *)data_lasso.mcords);
784
785   /* send notifier that keyframe selection has changed */
786   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
787
788   return OPERATOR_FINISHED;
789 }
790
791 void GRAPH_OT_select_lasso(wmOperatorType *ot)
792 {
793   /* identifiers */
794   ot->name = "Lasso Select";
795   ot->description = "Select keyframe points using lasso selection";
796   ot->idname = "GRAPH_OT_select_lasso";
797
798   /* api callbacks */
799   ot->invoke = WM_gesture_lasso_invoke;
800   ot->modal = WM_gesture_lasso_modal;
801   ot->exec = graphkeys_lassoselect_exec;
802   ot->poll = graphop_visible_keyframes_poll;
803   ot->cancel = WM_gesture_lasso_cancel;
804
805   /* flags */
806   ot->flag = OPTYPE_UNDO;
807
808   /* properties */
809   WM_operator_properties_gesture_lasso(ot);
810   WM_operator_properties_select_operation_simple(ot);
811 }
812
813 /* ------------------- */
814
815 static int graph_circle_select_exec(bContext *C, wmOperator *op)
816 {
817   bAnimContext ac;
818   bool incl_handles = false;
819
820   KeyframeEdit_CircleData data = {0};
821   rctf rect_fl;
822
823   float x = RNA_int_get(op->ptr, "x");
824   float y = RNA_int_get(op->ptr, "y");
825   float radius = RNA_int_get(op->ptr, "radius");
826
827   /* get editor data */
828   if (ANIM_animdata_get_context(C, &ac) == 0) {
829     return OPERATOR_CANCELLED;
830   }
831
832   const eSelectOp sel_op = ED_select_op_modal(RNA_enum_get(op->ptr, "mode"),
833                                               WM_gesture_is_modal_first(op->customdata));
834   const short selectmode = (sel_op != SEL_OP_SUB) ? SELECT_ADD : SELECT_SUBTRACT;
835   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
836     deselect_graph_keys(&ac, 0, SELECT_SUBTRACT, true);
837   }
838
839   data.mval[0] = x;
840   data.mval[1] = y;
841   data.radius_squared = radius * radius;
842   data.rectf_view = &rect_fl;
843
844   rect_fl.xmin = x - radius;
845   rect_fl.xmax = x + radius;
846   rect_fl.ymin = y - radius;
847   rect_fl.ymax = y + radius;
848
849   {
850     SpaceGraph *sipo = (SpaceGraph *)ac.sl;
851     if (selectmode == SELECT_ADD) {
852       incl_handles = ((sipo->flag & SIPO_SELVHANDLESONLY) || (sipo->flag & SIPO_NOHANDLES)) == 0;
853     }
854     else {
855       incl_handles = (sipo->flag & SIPO_NOHANDLES) == 0;
856     }
857   }
858
859   /* apply box_select action */
860   box_select_graphkeys(&ac, &rect_fl, BEZT_OK_REGION_CIRCLE, selectmode, incl_handles, &data);
861
862   /* send notifier that keyframe selection has changed */
863   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
864
865   return OPERATOR_FINISHED;
866 }
867
868 void GRAPH_OT_select_circle(wmOperatorType *ot)
869 {
870   ot->name = "Circle Select";
871   ot->description = "Select keyframe points using circle selection";
872   ot->idname = "GRAPH_OT_select_circle";
873
874   ot->invoke = WM_gesture_circle_invoke;
875   ot->modal = WM_gesture_circle_modal;
876   ot->exec = graph_circle_select_exec;
877   ot->poll = graphop_visible_keyframes_poll;
878   ot->cancel = WM_gesture_circle_cancel;
879
880   /* flags */
881   ot->flag = OPTYPE_UNDO;
882
883   /* properties */
884   WM_operator_properties_gesture_circle(ot);
885   WM_operator_properties_select_operation_simple(ot);
886 }
887
888 /* ******************** Column Select Operator **************************** */
889 /* This operator works in one of four ways:
890  * - 1) select all keyframes in the same frame as a selected one  (KKEY)
891  * - 2) select all keyframes in the same frame as the current frame marker (CTRL-KKEY)
892  * - 3) select all keyframes in the same frame as a selected markers (SHIFT-KKEY)
893  * - 4) select all keyframes that occur between selected markers (ALT-KKEY)
894  */
895
896 /* defines for column-select mode */
897 static const EnumPropertyItem prop_column_select_types[] = {
898     {GRAPHKEYS_COLUMNSEL_KEYS, "KEYS", 0, "On Selected Keyframes", ""},
899     {GRAPHKEYS_COLUMNSEL_CFRA, "CFRA", 0, "On Current Frame", ""},
900     {GRAPHKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", 0, "On Selected Markers", ""},
901     {GRAPHKEYS_COLUMNSEL_MARKERS_BETWEEN,
902      "MARKERS_BETWEEN",
903      0,
904      "Between Min/Max Selected Markers",
905      ""},
906     {0, NULL, 0, NULL, NULL},
907 };
908
909 /* ------------------- */
910
911 /* Selects all visible keyframes between the specified markers */
912 /* TODO, this is almost an _exact_ duplicate of a function of the same name in action_select.c
913  * should de-duplicate - campbell */
914 static void markers_selectkeys_between(bAnimContext *ac)
915 {
916   ListBase anim_data = {NULL, NULL};
917   bAnimListElem *ale;
918   int filter;
919
920   KeyframeEditFunc ok_cb, select_cb;
921   KeyframeEditData ked = {{NULL}};
922   float min, max;
923
924   /* get extreme markers */
925   ED_markers_get_minmax(ac->markers, 1, &min, &max);
926   min -= 0.5f;
927   max += 0.5f;
928
929   /* get editing funcs + data */
930   ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAMERANGE);
931   select_cb = ANIM_editkeyframes_select(SELECT_ADD);
932
933   ked.f1 = min;
934   ked.f2 = max;
935
936   /* filter data */
937   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
938   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
939
940   /* select keys in-between */
941   for (ale = anim_data.first; ale; ale = ale->next) {
942     AnimData *adt = ANIM_nla_mapping_get(ac, ale);
943
944     if (adt) {
945       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
946       ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);
947       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
948     }
949     else {
950       ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);
951     }
952   }
953
954   /* Cleanup */
955   ANIM_animdata_freelist(&anim_data);
956 }
957
958 /* Selects all visible keyframes in the same frames as the specified elements */
959 static void columnselect_graph_keys(bAnimContext *ac, short mode)
960 {
961   ListBase anim_data = {NULL, NULL};
962   bAnimListElem *ale;
963   int filter;
964
965   Scene *scene = ac->scene;
966   CfraElem *ce;
967   KeyframeEditFunc select_cb, ok_cb;
968   KeyframeEditData ked;
969
970   /* initialize keyframe editing data */
971   memset(&ked, 0, sizeof(KeyframeEditData));
972
973   /* build list of columns */
974   switch (mode) {
975     case GRAPHKEYS_COLUMNSEL_KEYS: /* list of selected keys */
976       filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
977       ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
978
979       for (ale = anim_data.first; ale; ale = ale->next) {
980         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_to_cfraelem, NULL);
981       }
982
983       ANIM_animdata_freelist(&anim_data);
984       break;
985
986     case GRAPHKEYS_COLUMNSEL_CFRA: /* current frame */
987       /* make a single CfraElem for storing this */
988       ce = MEM_callocN(sizeof(CfraElem), "cfraElem");
989       BLI_addtail(&ked.list, ce);
990
991       ce->cfra = (float)CFRA;
992       break;
993
994     case GRAPHKEYS_COLUMNSEL_MARKERS_COLUMN: /* list of selected markers */
995       ED_markers_make_cfra_list(ac->markers, &ked.list, SELECT);
996       break;
997
998     default: /* invalid option */
999       return;
1000   }
1001
1002   /* set up BezTriple edit callbacks */
1003   select_cb = ANIM_editkeyframes_select(SELECT_ADD);
1004   ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAME);
1005
1006   /* loop through all of the keys and select additional keyframes
1007    * based on the keys found to be selected above
1008    */
1009   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
1010   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1011
1012   for (ale = anim_data.first; ale; ale = ale->next) {
1013     AnimData *adt = ANIM_nla_mapping_get(ac, ale);
1014
1015     /* loop over cfraelems (stored in the KeyframeEditData->list)
1016      * - we need to do this here, as we can apply fewer NLA-mapping conversions
1017      */
1018     for (ce = ked.list.first; ce; ce = ce->next) {
1019       /* set frame for validation callback to refer to */
1020       ked.f1 = BKE_nla_tweakedit_remap(adt, ce->cfra, NLATIME_CONVERT_UNMAP);
1021
1022       /* select elements with frame number matching cfraelem */
1023       ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);
1024     }
1025   }
1026
1027   /* free elements */
1028   BLI_freelistN(&ked.list);
1029   ANIM_animdata_freelist(&anim_data);
1030 }
1031
1032 /* ------------------- */
1033
1034 static int graphkeys_columnselect_exec(bContext *C, wmOperator *op)
1035 {
1036   bAnimContext ac;
1037   short mode;
1038
1039   /* get editor data */
1040   if (ANIM_animdata_get_context(C, &ac) == 0) {
1041     return OPERATOR_CANCELLED;
1042   }
1043
1044   /* action to take depends on the mode */
1045   mode = RNA_enum_get(op->ptr, "mode");
1046
1047   if (mode == GRAPHKEYS_COLUMNSEL_MARKERS_BETWEEN) {
1048     markers_selectkeys_between(&ac);
1049   }
1050   else {
1051     columnselect_graph_keys(&ac, mode);
1052   }
1053
1054   /* set notifier that keyframe selection has changed */
1055   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1056
1057   return OPERATOR_FINISHED;
1058 }
1059
1060 void GRAPH_OT_select_column(wmOperatorType *ot)
1061 {
1062   /* identifiers */
1063   ot->name = "Select All";
1064   ot->idname = "GRAPH_OT_select_column";
1065   ot->description = "Select all keyframes on the specified frame(s)";
1066
1067   /* api callbacks */
1068   ot->exec = graphkeys_columnselect_exec;
1069   ot->poll = graphop_visible_keyframes_poll;
1070
1071   /* flags */
1072   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1073
1074   /* props */
1075   ot->prop = RNA_def_enum(ot->srna, "mode", prop_column_select_types, 0, "Mode", "");
1076 }
1077
1078 /* ******************** Select Linked Operator *********************** */
1079
1080 static int graphkeys_select_linked_exec(bContext *C, wmOperator *UNUSED(op))
1081 {
1082   bAnimContext ac;
1083
1084   ListBase anim_data = {NULL, NULL};
1085   bAnimListElem *ale;
1086   int filter;
1087
1088   KeyframeEditFunc ok_cb = ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
1089   KeyframeEditFunc sel_cb = ANIM_editkeyframes_select(SELECT_ADD);
1090
1091   /* get editor data */
1092   if (ANIM_animdata_get_context(C, &ac) == 0) {
1093     return OPERATOR_CANCELLED;
1094   }
1095
1096   /* loop through all of the keys and select additional keyframes based on these */
1097   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
1098   ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1099
1100   for (ale = anim_data.first; ale; ale = ale->next) {
1101     FCurve *fcu = (FCurve *)ale->key_data;
1102
1103     /* check if anything selected? */
1104     if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, ok_cb, NULL)) {
1105       /* select every keyframe in this curve then */
1106       ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, sel_cb, NULL);
1107     }
1108   }
1109
1110   /* Cleanup */
1111   ANIM_animdata_freelist(&anim_data);
1112
1113   /* set notifier that keyframe selection has changed */
1114   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1115
1116   return OPERATOR_FINISHED;
1117 }
1118
1119 void GRAPH_OT_select_linked(wmOperatorType *ot)
1120 {
1121   /* identifiers */
1122   ot->name = "Select Linked";
1123   ot->idname = "GRAPH_OT_select_linked";
1124   ot->description = "Select keyframes occurring in the same F-Curves as selected ones";
1125
1126   /* api callbacks */
1127   ot->exec = graphkeys_select_linked_exec;
1128   ot->poll = graphop_visible_keyframes_poll;
1129
1130   /* flags */
1131   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1132 }
1133
1134 /* ******************** Select More/Less Operators *********************** */
1135
1136 /* Common code to perform selection */
1137 static void select_moreless_graph_keys(bAnimContext *ac, short mode)
1138 {
1139   ListBase anim_data = {NULL, NULL};
1140   bAnimListElem *ale;
1141   int filter;
1142
1143   KeyframeEditData ked;
1144   KeyframeEditFunc build_cb;
1145
1146   /* init selmap building data */
1147   build_cb = ANIM_editkeyframes_buildselmap(mode);
1148   memset(&ked, 0, sizeof(KeyframeEditData));
1149
1150   /* loop through all of the keys and select additional keyframes based on these */
1151   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
1152   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1153
1154   for (ale = anim_data.first; ale; ale = ale->next) {
1155     FCurve *fcu = (FCurve *)ale->key_data;
1156
1157     /* only continue if F-Curve has keyframes */
1158     if (fcu->bezt == NULL) {
1159       continue;
1160     }
1161
1162     /* build up map of whether F-Curve's keyframes should be selected or not */
1163     ked.data = MEM_callocN(fcu->totvert, "selmap graphEdit");
1164     ANIM_fcurve_keyframes_loop(&ked, fcu, NULL, build_cb, NULL);
1165
1166     /* based on this map, adjust the selection status of the keyframes */
1167     ANIM_fcurve_keyframes_loop(&ked, fcu, NULL, bezt_selmap_flush, NULL);
1168
1169     /* free the selmap used here */
1170     MEM_freeN(ked.data);
1171     ked.data = NULL;
1172   }
1173
1174   /* Cleanup */
1175   ANIM_animdata_freelist(&anim_data);
1176 }
1177
1178 /* ----------------- */
1179
1180 static int graphkeys_select_more_exec(bContext *C, wmOperator *UNUSED(op))
1181 {
1182   bAnimContext ac;
1183
1184   /* get editor data */
1185   if (ANIM_animdata_get_context(C, &ac) == 0) {
1186     return OPERATOR_CANCELLED;
1187   }
1188
1189   /* perform select changes */
1190   select_moreless_graph_keys(&ac, SELMAP_MORE);
1191
1192   /* set notifier that keyframe selection has changed */
1193   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1194
1195   return OPERATOR_FINISHED;
1196 }
1197
1198 void GRAPH_OT_select_more(wmOperatorType *ot)
1199 {
1200   /* identifiers */
1201   ot->name = "Select More";
1202   ot->idname = "GRAPH_OT_select_more";
1203   ot->description = "Select keyframes beside already selected ones";
1204
1205   /* api callbacks */
1206   ot->exec = graphkeys_select_more_exec;
1207   ot->poll = graphop_visible_keyframes_poll;
1208
1209   /* flags */
1210   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1211 }
1212
1213 /* ----------------- */
1214
1215 static int graphkeys_select_less_exec(bContext *C, wmOperator *UNUSED(op))
1216 {
1217   bAnimContext ac;
1218
1219   /* get editor data */
1220   if (ANIM_animdata_get_context(C, &ac) == 0) {
1221     return OPERATOR_CANCELLED;
1222   }
1223
1224   /* perform select changes */
1225   select_moreless_graph_keys(&ac, SELMAP_LESS);
1226
1227   /* set notifier that keyframe selection has changed */
1228   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1229
1230   return OPERATOR_FINISHED;
1231 }
1232
1233 void GRAPH_OT_select_less(wmOperatorType *ot)
1234 {
1235   /* identifiers */
1236   ot->name = "Select Less";
1237   ot->idname = "GRAPH_OT_select_less";
1238   ot->description = "Deselect keyframes on ends of selection islands";
1239
1240   /* api callbacks */
1241   ot->exec = graphkeys_select_less_exec;
1242   ot->poll = graphop_visible_keyframes_poll;
1243
1244   /* flags */
1245   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1246 }
1247
1248 /* ******************** Select Left/Right Operator ************************* */
1249 /* Select keyframes left/right of the current frame indicator */
1250
1251 /* defines for left-right select tool */
1252 static const EnumPropertyItem prop_graphkeys_leftright_select_types[] = {
1253     {GRAPHKEYS_LRSEL_TEST, "CHECK", 0, "Check if Select Left or Right", ""},
1254     {GRAPHKEYS_LRSEL_LEFT, "LEFT", 0, "Before current frame", ""},
1255     {GRAPHKEYS_LRSEL_RIGHT, "RIGHT", 0, "After current frame", ""},
1256     {0, NULL, 0, NULL, NULL},
1257 };
1258
1259 /* --------------------------------- */
1260
1261 static void graphkeys_select_leftright(bAnimContext *ac, short leftright, short select_mode)
1262 {
1263   ListBase anim_data = {NULL, NULL};
1264   bAnimListElem *ale;
1265   int filter;
1266
1267   KeyframeEditFunc ok_cb, select_cb;
1268   KeyframeEditData ked = {{NULL}};
1269   Scene *scene = ac->scene;
1270
1271   /* if select mode is replace, deselect all keyframes (and channels) first */
1272   if (select_mode == SELECT_REPLACE) {
1273     select_mode = SELECT_ADD;
1274
1275     /* - deselect all other keyframes, so that just the newly selected remain
1276      * - channels aren't deselected, since we don't re-select any as a consequence
1277      */
1278     deselect_graph_keys(ac, 0, SELECT_SUBTRACT, false);
1279   }
1280
1281   /* set callbacks and editing data */
1282   ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAMERANGE);
1283   select_cb = ANIM_editkeyframes_select(select_mode);
1284
1285   if (leftright == GRAPHKEYS_LRSEL_LEFT) {
1286     ked.f1 = MINAFRAMEF;
1287     ked.f2 = (float)(CFRA + 0.1f);
1288   }
1289   else {
1290     ked.f1 = (float)(CFRA - 0.1f);
1291     ked.f2 = MAXFRAMEF;
1292   }
1293
1294   /* filter data */
1295   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_NODUPLIS);
1296   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1297
1298   /* select keys */
1299   for (ale = anim_data.first; ale; ale = ale->next) {
1300     AnimData *adt = ANIM_nla_mapping_get(ac, ale);
1301
1302     if (adt) {
1303       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
1304       ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);
1305       ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1306     }
1307     else {
1308       ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);
1309     }
1310   }
1311
1312   /* Cleanup */
1313   ANIM_animdata_freelist(&anim_data);
1314 }
1315
1316 /* ----------------- */
1317
1318 static int graphkeys_select_leftright_exec(bContext *C, wmOperator *op)
1319 {
1320   bAnimContext ac;
1321   short leftright = RNA_enum_get(op->ptr, "mode");
1322   short selectmode;
1323
1324   /* get editor data */
1325   if (ANIM_animdata_get_context(C, &ac) == 0) {
1326     return OPERATOR_CANCELLED;
1327   }
1328
1329   /* select mode is either replace (deselect all, then add) or add/extend */
1330   if (RNA_boolean_get(op->ptr, "extend")) {
1331     selectmode = SELECT_INVERT;
1332   }
1333   else {
1334     selectmode = SELECT_REPLACE;
1335   }
1336
1337   /* if "test" mode is set, we don't have any info to set this with */
1338   if (leftright == GRAPHKEYS_LRSEL_TEST) {
1339     return OPERATOR_CANCELLED;
1340   }
1341
1342   /* do the selecting now */
1343   graphkeys_select_leftright(&ac, leftright, selectmode);
1344
1345   /* set notifier that keyframe selection (and channels too) have changed */
1346   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1347   WM_event_add_notifier(C, NC_ANIMATION | ND_ANIMCHAN | NA_SELECTED, NULL);
1348
1349   return OPERATOR_FINISHED;
1350 }
1351
1352 static int graphkeys_select_leftright_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1353 {
1354   bAnimContext ac;
1355   short leftright = RNA_enum_get(op->ptr, "mode");
1356
1357   /* get editor data */
1358   if (ANIM_animdata_get_context(C, &ac) == 0) {
1359     return OPERATOR_CANCELLED;
1360   }
1361
1362   /* handle mode-based testing */
1363   if (leftright == GRAPHKEYS_LRSEL_TEST) {
1364     Scene *scene = ac.scene;
1365     ARegion *ar = ac.ar;
1366     View2D *v2d = &ar->v2d;
1367     float x;
1368
1369     /* determine which side of the current frame mouse is on */
1370     x = UI_view2d_region_to_view_x(v2d, event->mval[0]);
1371     if (x < CFRA) {
1372       RNA_enum_set(op->ptr, "mode", GRAPHKEYS_LRSEL_LEFT);
1373     }
1374     else {
1375       RNA_enum_set(op->ptr, "mode", GRAPHKEYS_LRSEL_RIGHT);
1376     }
1377   }
1378
1379   /* perform selection */
1380   return graphkeys_select_leftright_exec(C, op);
1381 }
1382
1383 void GRAPH_OT_select_leftright(wmOperatorType *ot)
1384 {
1385   PropertyRNA *prop;
1386
1387   /* identifiers */
1388   ot->name = "Select Left/Right";
1389   ot->idname = "GRAPH_OT_select_leftright";
1390   ot->description = "Select keyframes to the left or the right of the current frame";
1391
1392   /* api callbacks  */
1393   ot->invoke = graphkeys_select_leftright_invoke;
1394   ot->exec = graphkeys_select_leftright_exec;
1395   ot->poll = graphop_visible_keyframes_poll;
1396
1397   /* flags */
1398   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1399
1400   /* id-props */
1401   ot->prop = RNA_def_enum(
1402       ot->srna, "mode", prop_graphkeys_leftright_select_types, GRAPHKEYS_LRSEL_TEST, "Mode", "");
1403   RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
1404
1405   prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
1406   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1407 }
1408
1409 /* ******************** Mouse-Click Select Operator *********************** */
1410 /* This operator works in one of three ways:
1411  * - 1) keyframe under mouse - no special modifiers
1412  * - 2) all keyframes on the same side of current frame indicator as mouse - ALT modifier
1413  * - 3) column select all keyframes in frame under mouse - CTRL modifier
1414  *
1415  * In addition to these basic options, the SHIFT modifier can be used to toggle the
1416  * selection mode between replacing the selection (without) and inverting the selection (with).
1417  */
1418
1419 /* option 1) select keyframe directly under mouse */
1420 static void mouse_graph_keys(bAnimContext *ac,
1421                              const int mval[2],
1422                              short select_mode,
1423                              const bool deselect_all,
1424                              const bool curves_only)
1425 {
1426   SpaceGraph *sipo = (SpaceGraph *)ac->sl;
1427   tNearestVertInfo *nvi;
1428   BezTriple *bezt = NULL;
1429
1430   /* find the beztriple that we're selecting, and the handle that was clicked on */
1431   nvi = find_nearest_fcurve_vert(ac, mval);
1432
1433   /* For replacing selection, if we have something to select, we have to clear existing selection.
1434    * The same goes if we found nothing to select, and deselect_all is true
1435    * (deselect on nothing behavior). */
1436   if ((nvi != NULL && select_mode == SELECT_REPLACE) || (nvi == NULL && deselect_all)) {
1437     /* reset selection mode */
1438     select_mode = SELECT_ADD;
1439
1440     /* deselect all other keyframes (+ F-Curves too) */
1441     deselect_graph_keys(ac, 0, SELECT_SUBTRACT, true);
1442
1443     /* deselect other channels too, but only only do this if
1444      * selection of channel when the visibility of keyframes
1445      * doesn't depend on this
1446      */
1447     if ((sipo->flag & SIPO_SELCUVERTSONLY) == 0) {
1448       ANIM_deselect_anim_channels(ac, ac->data, ac->datatype, 0, ACHANNEL_SETFLAG_CLEAR);
1449     }
1450   }
1451
1452   if (nvi == NULL) {
1453     return;
1454   }
1455
1456   /* if points can be selected on this F-Curve */
1457   // TODO: what about those with no keyframes?
1458   if (!curves_only && ((nvi->fcu->flag & FCURVE_PROTECTED) == 0)) {
1459     /* only if there's keyframe */
1460     if (nvi->bezt) {
1461       bezt = nvi->bezt; /* used to check bezt seletion is set */
1462       /* depends on selection mode */
1463       if (select_mode == SELECT_INVERT) {
1464         /* keyframe - invert select of all */
1465         if (nvi->hpoint == NEAREST_HANDLE_KEY) {
1466           if (BEZT_ISSEL_ANY(bezt)) {
1467             BEZT_DESEL_ALL(bezt);
1468           }
1469           else {
1470             BEZT_SEL_ALL(bezt);
1471           }
1472         }
1473
1474         /* handles - toggle selection of relevant handle */
1475         else if (nvi->hpoint == NEAREST_HANDLE_LEFT) {
1476           /* toggle selection */
1477           bezt->f1 ^= SELECT;
1478         }
1479         else {
1480           /* toggle selection */
1481           bezt->f3 ^= SELECT;
1482         }
1483       }
1484       else {
1485         /* if the keyframe was clicked on, select all verts of given beztriple */
1486         if (nvi->hpoint == NEAREST_HANDLE_KEY) {
1487           BEZT_SEL_ALL(bezt);
1488         }
1489         /* otherwise, select the handle that applied */
1490         else if (nvi->hpoint == NEAREST_HANDLE_LEFT) {
1491           bezt->f1 |= SELECT;
1492         }
1493         else {
1494           bezt->f3 |= SELECT;
1495         }
1496       }
1497     }
1498     else if (nvi->fpt) {
1499       // TODO: need to handle sample points
1500     }
1501   }
1502   else {
1503     KeyframeEditFunc select_cb;
1504     KeyframeEditData ked;
1505
1506     /* initialize keyframe editing data */
1507     memset(&ked, 0, sizeof(KeyframeEditData));
1508
1509     /* set up BezTriple edit callbacks */
1510     select_cb = ANIM_editkeyframes_select(select_mode);
1511
1512     /* select all keyframes */
1513     ANIM_fcurve_keyframes_loop(&ked, nvi->fcu, NULL, select_cb, NULL);
1514   }
1515
1516   /* only change selection of channel when the visibility of keyframes doesn't depend on this */
1517   if ((sipo->flag & SIPO_SELCUVERTSONLY) == 0) {
1518     /* select or deselect curve? */
1519     if (bezt) {
1520       /* take selection status from item that got hit, to prevent flip/flop on channel
1521        * selection status when shift-selecting (i.e. "SELECT_INVERT") points
1522        */
1523       if (BEZT_ISSEL_ANY(bezt)) {
1524         nvi->fcu->flag |= FCURVE_SELECTED;
1525       }
1526       else {
1527         nvi->fcu->flag &= ~FCURVE_SELECTED;
1528       }
1529     }
1530     else {
1531       /* Didn't hit any channel,
1532        * so just apply that selection mode to the curve's selection status. */
1533       if (select_mode == SELECT_INVERT) {
1534         nvi->fcu->flag ^= FCURVE_SELECTED;
1535       }
1536       else if (select_mode == SELECT_ADD) {
1537         nvi->fcu->flag |= FCURVE_SELECTED;
1538       }
1539     }
1540   }
1541
1542   /* set active F-Curve (NOTE: sync the filter flags with findnearest_fcurve_vert) */
1543   /* needs to be called with (sipo->flag & SIPO_SELCUVERTSONLY)
1544    * otherwise the active flag won't be set T26452. */
1545   if (nvi->fcu->flag & FCURVE_SELECTED) {
1546     int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
1547     ANIM_set_active_channel(ac, ac->data, ac->datatype, filter, nvi->fcu, nvi->ctype);
1548   }
1549
1550   /* free temp sample data for filtering */
1551   MEM_freeN(nvi);
1552 }
1553
1554 /* Option 2) Selects all the keyframes on either side of the current frame
1555  * (depends on which side the mouse is on) */
1556 /* (see graphkeys_select_leftright) */
1557
1558 /* Option 3) Selects all visible keyframes in the same frame as the mouse click */
1559 static void graphkeys_mselect_column(bAnimContext *ac, const int mval[2], short select_mode)
1560 {
1561   ListBase anim_data = {NULL, NULL};
1562   bAnimListElem *ale;
1563   int filter;
1564
1565   KeyframeEditFunc select_cb, ok_cb;
1566   KeyframeEditData ked;
1567   tNearestVertInfo *nvi;
1568   float selx = (float)ac->scene->r.cfra;
1569
1570   /* find the beztriple that we're selecting, and the handle that was clicked on */
1571   nvi = find_nearest_fcurve_vert(ac, mval);
1572
1573   /* check if anything to select */
1574   if (nvi == NULL) {
1575     return;
1576   }
1577
1578   /* get frame number on which elements should be selected */
1579   // TODO: should we restrict to integer frames only?
1580   selx = nvi->frame;
1581
1582   /* if select mode is replace, deselect all keyframes first */
1583   if (select_mode == SELECT_REPLACE) {
1584     /* reset selection mode to add to selection */
1585     select_mode = SELECT_ADD;
1586
1587     /* - deselect all other keyframes, so that just the newly selected remain
1588      * - channels aren't deselected, since we don't re-select any as a consequence
1589      */
1590     deselect_graph_keys(ac, 0, SELECT_SUBTRACT, false);
1591   }
1592
1593   /* initialize keyframe editing data */
1594   memset(&ked, 0, sizeof(KeyframeEditData));
1595
1596   /* set up BezTriple edit callbacks */
1597   select_cb = ANIM_editkeyframes_select(select_mode);
1598   ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAME);
1599
1600   /* loop through all of the keys and select additional keyframes
1601    * based on the keys found to be selected above
1602    */
1603   filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
1604   ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1605
1606   for (ale = anim_data.first; ale; ale = ale->next) {
1607     AnimData *adt = ANIM_nla_mapping_get(ac, ale);
1608
1609     /* set frame for validation callback to refer to */
1610     if (adt) {
1611       ked.f1 = BKE_nla_tweakedit_remap(adt, selx, NLATIME_CONVERT_UNMAP);
1612     }
1613     else {
1614       ked.f1 = selx;
1615     }
1616
1617     /* select elements with frame number matching cfra */
1618     ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);
1619   }
1620
1621   /* free elements */
1622   MEM_freeN(nvi);
1623   BLI_freelistN(&ked.list);
1624   ANIM_animdata_freelist(&anim_data);
1625 }
1626
1627 /* ------------------- */
1628
1629 /* handle clicking */
1630 static int graphkeys_clickselect_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1631 {
1632   bAnimContext ac;
1633
1634   /* get editor data */
1635   if (ANIM_animdata_get_context(C, &ac) == 0) {
1636     return OPERATOR_CANCELLED;
1637   }
1638
1639   /* select mode is either replace (deselect all, then add) or add/extend */
1640   const short selectmode = RNA_boolean_get(op->ptr, "extend") ? SELECT_INVERT : SELECT_REPLACE;
1641   const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all");
1642
1643   /* figure out action to take */
1644   if (RNA_boolean_get(op->ptr, "column")) {
1645     /* select all keyframes in the same frame as the one that was under the mouse */
1646     graphkeys_mselect_column(&ac, event->mval, selectmode);
1647   }
1648   else if (RNA_boolean_get(op->ptr, "curves")) {
1649     /* select all keyframes in the same F-Curve as the one under the mouse */
1650     mouse_graph_keys(&ac, event->mval, selectmode, deselect_all, true);
1651   }
1652   else {
1653     /* select keyframe under mouse */
1654     mouse_graph_keys(&ac, event->mval, selectmode, deselect_all, false);
1655   }
1656
1657   /* set notifier that keyframe selection (and also channel selection in some cases) has changed */
1658   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1659   WM_event_add_notifier(C, NC_ANIMATION | ND_ANIMCHAN | NA_SELECTED, NULL);
1660
1661   /* for tweak grab to work */
1662   return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
1663 }
1664
1665 void GRAPH_OT_clickselect(wmOperatorType *ot)
1666 {
1667   PropertyRNA *prop;
1668
1669   /* identifiers */
1670   ot->name = "Select Keyframes";
1671   ot->idname = "GRAPH_OT_clickselect";
1672   ot->description = "Select keyframes by clicking on them";
1673
1674   /* callbacks */
1675   ot->invoke = graphkeys_clickselect_invoke;
1676   ot->poll = graphop_visible_keyframes_poll;
1677
1678   /* flags */
1679   ot->flag = OPTYPE_UNDO;
1680
1681   /* properties */
1682   prop = RNA_def_boolean(
1683       ot->srna,
1684       "extend",
1685       0,
1686       "Extend Select",
1687       "Toggle keyframe selection instead of leaving newly selected keyframes only");  // SHIFTKEY
1688   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1689
1690   prop = RNA_def_boolean(ot->srna,
1691                          "deselect_all",
1692                          false,
1693                          "Deselect On Nothing",
1694                          "Deselect all when nothing under the cursor");
1695   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1696
1697   prop = RNA_def_boolean(
1698       ot->srna,
1699       "column",
1700       0,
1701       "Column Select",
1702       "Select all keyframes that occur on the same frame as the one under the mouse");  // ALTKEY
1703   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1704
1705   prop = RNA_def_boolean(ot->srna,
1706                          "curves",
1707                          0,
1708                          "Only Curves",
1709                          "Select all the keyframes in the curve");  // CTRLKEY + ALTKEY
1710   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1711 }
1712
1713 /* ************************************************************************** */