Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / mask / mask_editaction.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  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup edmask
22  */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <stdlib.h>
27 #include <stddef.h>
28 #include <math.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "BLI_blenlib.h"
33 #include "BLI_utildefines.h"
34
35 #include "DNA_mask_types.h"
36 #include "DNA_scene_types.h"
37
38 #include "BKE_fcurve.h"
39 #include "BKE_mask.h"
40
41 #include "ED_anim_api.h"
42 #include "ED_keyframes_edit.h"
43 #include "ED_mask.h" /* own include */
44 #include "ED_markers.h"
45
46 /* ***************************************** */
47 /* NOTE ABOUT THIS FILE:
48  * This file contains code for editing Mask data in the Action Editor
49  * as a 'keyframes', so that a user can adjust the timing of Mask shapekeys.
50  * Therefore, this file mostly contains functions for selecting Mask frames (shapekeys).
51  */
52 /* ***************************************** */
53 /* Generics - Loopers */
54
55 /* Loops over the mask-frames for a mask-layer, and applies the given callback */
56 bool ED_masklayer_frames_looper(MaskLayer *masklay,
57                                 Scene *scene,
58                                 short (*masklay_shape_cb)(MaskLayerShape *, Scene *))
59 {
60   MaskLayerShape *masklay_shape;
61
62   /* error checker */
63   if (masklay == NULL) {
64     return false;
65   }
66
67   /* do loop */
68   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
69        masklay_shape = masklay_shape->next) {
70     /* execute callback */
71     if (masklay_shape_cb(masklay_shape, scene)) {
72       return true;
73     }
74   }
75
76   /* nothing to return */
77   return false;
78 }
79
80 /* ****************************************** */
81 /* Data Conversion Tools */
82
83 /* make a listing all the mask-frames in a layer as cfraelems */
84 void ED_masklayer_make_cfra_list(MaskLayer *masklay, ListBase *elems, bool onlysel)
85 {
86   MaskLayerShape *masklay_shape;
87   CfraElem *ce;
88
89   /* error checking */
90   if (ELEM(NULL, masklay, elems)) {
91     return;
92   }
93
94   /* loop through mask-frames, adding */
95   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
96        masklay_shape = masklay_shape->next) {
97     if ((onlysel == false) || (masklay_shape->flag & MASK_SHAPE_SELECT)) {
98       ce = MEM_callocN(sizeof(CfraElem), "CfraElem");
99
100       ce->cfra = (float)masklay_shape->frame;
101       ce->sel = (masklay_shape->flag & MASK_SHAPE_SELECT) ? 1 : 0;
102
103       BLI_addtail(elems, ce);
104     }
105   }
106 }
107
108 /* ***************************************** */
109 /* Selection Tools */
110
111 /* check if one of the frames in this layer is selected */
112 bool ED_masklayer_frame_select_check(MaskLayer *masklay)
113 {
114   MaskLayerShape *masklay_shape;
115
116   /* error checking */
117   if (masklay == NULL) {
118     return 0;
119   }
120
121   /* stop at the first one found */
122   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
123        masklay_shape = masklay_shape->next) {
124     if (masklay_shape->flag & MASK_SHAPE_SELECT) {
125       return 1;
126     }
127   }
128
129   /* not found */
130   return 0;
131 }
132
133 /* helper function - select mask-frame based on SELECT_* mode */
134 static void masklayshape_select(MaskLayerShape *masklay_shape, short select_mode)
135 {
136   if (masklay_shape == NULL) {
137     return;
138   }
139
140   switch (select_mode) {
141     case SELECT_ADD:
142       masklay_shape->flag |= MASK_SHAPE_SELECT;
143       break;
144     case SELECT_SUBTRACT:
145       masklay_shape->flag &= ~MASK_SHAPE_SELECT;
146       break;
147     case SELECT_INVERT:
148       masklay_shape->flag ^= MASK_SHAPE_SELECT;
149       break;
150   }
151 }
152
153 /* set all/none/invert select (like above, but with SELECT_* modes) */
154 void ED_mask_select_frames(MaskLayer *masklay, short select_mode)
155 {
156   MaskLayerShape *masklay_shape;
157
158   /* error checking */
159   if (masklay == NULL) {
160     return;
161   }
162
163   /* handle according to mode */
164   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
165        masklay_shape = masklay_shape->next) {
166     masklayshape_select(masklay_shape, select_mode);
167   }
168 }
169
170 /* set all/none/invert select */
171 void ED_masklayer_frame_select_set(MaskLayer *masklay, short mode)
172 {
173   /* error checking */
174   if (masklay == NULL) {
175     return;
176   }
177
178   /* now call the standard function */
179   ED_mask_select_frames(masklay, mode);
180 }
181
182 /* select the frame in this layer that occurs on this frame (there should only be one at most) */
183 void ED_mask_select_frame(MaskLayer *masklay, int selx, short select_mode)
184 {
185   MaskLayerShape *masklay_shape;
186
187   if (masklay == NULL) {
188     return;
189   }
190
191   masklay_shape = BKE_mask_layer_shape_find_frame(masklay, selx);
192
193   if (masklay_shape) {
194     masklayshape_select(masklay_shape, select_mode);
195   }
196 }
197
198 /* select the frames in this layer that occur within the bounds specified */
199 void ED_masklayer_frames_select_box(MaskLayer *masklay, float min, float max, short select_mode)
200 {
201   MaskLayerShape *masklay_shape;
202
203   if (masklay == NULL) {
204     return;
205   }
206
207   /* only select those frames which are in bounds */
208   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
209        masklay_shape = masklay_shape->next) {
210     if (IN_RANGE(masklay_shape->frame, min, max)) {
211       masklayshape_select(masklay_shape, select_mode);
212     }
213   }
214 }
215
216 /* select the frames in this layer that occur within the lasso/circle region specified */
217 void ED_masklayer_frames_select_region(KeyframeEditData *ked,
218                                        MaskLayer *masklay,
219                                        short tool,
220                                        short select_mode)
221 {
222   MaskLayerShape *masklay_shape;
223
224   if (masklay == NULL) {
225     return;
226   }
227
228   /* only select frames which are within the region */
229   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
230        masklay_shape = masklay_shape->next) {
231     /* construct a dummy point coordinate to do this testing with */
232     float pt[2] = {0};
233
234     pt[0] = masklay_shape->frame;
235     pt[1] = ked->channel_y;
236
237     /* check the necessary regions */
238     if (tool == BEZT_OK_CHANNEL_LASSO) {
239       /* Lasso */
240       if (keyframe_region_lasso_test(ked->data, pt)) {
241         masklayshape_select(masklay_shape, select_mode);
242       }
243     }
244     else if (tool == BEZT_OK_CHANNEL_CIRCLE) {
245       /* Circle */
246       if (keyframe_region_circle_test(ked->data, pt)) {
247         masklayshape_select(masklay_shape, select_mode);
248       }
249     }
250   }
251 }
252
253 /* ***************************************** */
254 /* Frame Editing Tools */
255
256 /* Delete selected frames */
257 bool ED_masklayer_frames_delete(MaskLayer *masklay)
258 {
259   MaskLayerShape *masklay_shape, *masklay_shape_next;
260   bool changed = false;
261
262   /* error checking */
263   if (masklay == NULL) {
264     return false;
265   }
266
267   /* check for frames to delete */
268   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
269        masklay_shape = masklay_shape_next) {
270     masklay_shape_next = masklay_shape->next;
271
272     if (masklay_shape->flag & MASK_SHAPE_SELECT) {
273       BKE_mask_layer_shape_unlink(masklay, masklay_shape);
274       changed = true;
275     }
276   }
277
278   return changed;
279 }
280
281 /* Duplicate selected frames from given mask-layer */
282 void ED_masklayer_frames_duplicate(MaskLayer *masklay)
283 {
284   MaskLayerShape *masklay_shape, *gpfn;
285
286   /* error checking */
287   if (masklay == NULL) {
288     return;
289   }
290
291   /* duplicate selected frames  */
292   for (masklay_shape = masklay->splines_shapes.first; masklay_shape; masklay_shape = gpfn) {
293     gpfn = masklay_shape->next;
294
295     /* duplicate this frame */
296     if (masklay_shape->flag & MASK_SHAPE_SELECT) {
297       MaskLayerShape *mask_shape_dupe;
298
299       /* duplicate frame, and deselect self */
300       mask_shape_dupe = BKE_mask_layer_shape_duplicate(masklay_shape);
301       masklay_shape->flag &= ~MASK_SHAPE_SELECT;
302
303       /* XXX - how to handle duplicate frames? */
304       BLI_insertlinkafter(&masklay->splines_shapes, masklay_shape, mask_shape_dupe);
305     }
306   }
307 }
308
309 /* -------------------------------------- */
310 /* Snap Tools */
311
312 static short snap_masklayer_nearest(MaskLayerShape *masklay_shape, Scene *UNUSED(scene))
313 {
314   if (masklay_shape->flag & MASK_SHAPE_SELECT) {
315     masklay_shape->frame = (int)(floor(masklay_shape->frame + 0.5));
316   }
317   return 0;
318 }
319
320 static short snap_masklayer_nearestsec(MaskLayerShape *masklay_shape, Scene *scene)
321 {
322   float secf = (float)FPS;
323   if (masklay_shape->flag & MASK_SHAPE_SELECT) {
324     masklay_shape->frame = (int)(floorf(masklay_shape->frame / secf + 0.5f) * secf);
325   }
326   return 0;
327 }
328
329 static short snap_masklayer_cframe(MaskLayerShape *masklay_shape, Scene *scene)
330 {
331   if (masklay_shape->flag & MASK_SHAPE_SELECT) {
332     masklay_shape->frame = (int)CFRA;
333   }
334   return 0;
335 }
336
337 static short snap_masklayer_nearmarker(MaskLayerShape *masklay_shape, Scene *scene)
338 {
339   if (masklay_shape->flag & MASK_SHAPE_SELECT) {
340     masklay_shape->frame = (int)ED_markers_find_nearest_marker_time(&scene->markers,
341                                                                     (float)masklay_shape->frame);
342   }
343   return 0;
344 }
345
346 /* snap selected frames to ... */
347 void ED_masklayer_snap_frames(MaskLayer *masklay, Scene *scene, short mode)
348 {
349   switch (mode) {
350     case SNAP_KEYS_NEARFRAME: /* snap to nearest frame */
351       ED_masklayer_frames_looper(masklay, scene, snap_masklayer_nearest);
352       break;
353     case SNAP_KEYS_CURFRAME: /* snap to current frame */
354       ED_masklayer_frames_looper(masklay, scene, snap_masklayer_cframe);
355       break;
356     case SNAP_KEYS_NEARMARKER: /* snap to nearest marker */
357       ED_masklayer_frames_looper(masklay, scene, snap_masklayer_nearmarker);
358       break;
359     case SNAP_KEYS_NEARSEC: /* snap to nearest second */
360       ED_masklayer_frames_looper(masklay, scene, snap_masklayer_nearestsec);
361       break;
362     default: /* just in case */
363       break;
364   }
365 }