Masking: Cleanup, naming of mask layer

1 files changed, 92 insertions, 91 deletions

diff --git a/source/blender/editors/mask/mask_editaction.c b/source/blender/editors/mask/mask_editaction.c
index 985fa58cace..33f4bab14ec 100644
--- a/source/blender/editors/mask/mask_editaction.c
+++ b/source/blender/editors/mask/mask_editaction.c
@@ -53,22 +53,22 @@
 /* Generics - Loopers */
 
 /* Loops over the mask-frames for a mask-layer, and applies the given callback */
-bool ED_masklayer_frames_looper(MaskLayer *masklay,
+bool ED_masklayer_frames_looper(MaskLayer *mask_layer,
                                 Scene *scene,
-                                short (*masklay_shape_cb)(MaskLayerShape *, Scene *))
+                                short (*mask_layer_shape_cb)(MaskLayerShape *, Scene *))
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
 
   /* error checker */
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return false;
   }
 
   /* do loop */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape->next) {
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape->next) {
     /* execute callback */
-    if (masklay_shape_cb(masklay_shape, scene)) {
+    if (mask_layer_shape_cb(mask_layer_shape, scene)) {
       return true;
     }
   }
@@ -81,24 +81,24 @@ bool ED_masklayer_frames_looper(MaskLayer *masklay,
 /* Data Conversion Tools */
 
 /* make a listing all the mask-frames in a layer as cfraelems */
-void ED_masklayer_make_cfra_list(MaskLayer *masklay, ListBase *elems, bool onlysel)
+void ED_masklayer_make_cfra_list(MaskLayer *mask_layer, ListBase *elems, bool onlysel)
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
   CfraElem *ce;
 
   /* error checking */
-  if (ELEM(NULL, masklay, elems)) {
+  if (ELEM(NULL, mask_layer, elems)) {
     return;
   }
 
   /* loop through mask-frames, adding */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape->next) {
-    if ((onlysel == false) || (masklay_shape->flag & MASK_SHAPE_SELECT)) {
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape->next) {
+    if ((onlysel == false) || (mask_layer_shape->flag & MASK_SHAPE_SELECT)) {
       ce = MEM_callocN(sizeof(CfraElem), "CfraElem");
 
-      ce->cfra = (float)masklay_shape->frame;
-      ce->sel = (masklay_shape->flag & MASK_SHAPE_SELECT) ? 1 : 0;
+      ce->cfra = (float)mask_layer_shape->frame;
+      ce->sel = (mask_layer_shape->flag & MASK_SHAPE_SELECT) ? 1 : 0;
 
       BLI_addtail(elems, ce);
     }
@@ -109,19 +109,19 @@ void ED_masklayer_make_cfra_list(MaskLayer *masklay, ListBase *elems, bool onlys
 /* Selection Tools */
 
 /* check if one of the frames in this layer is selected */
-bool ED_masklayer_frame_select_check(MaskLayer *masklay)
+bool ED_masklayer_frame_select_check(MaskLayer *mask_layer)
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
 
   /* error checking */
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return 0;
   }
 
   /* stop at the first one found */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape->next) {
-    if (masklay_shape->flag & MASK_SHAPE_SELECT) {
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape->next) {
+    if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
       return 1;
     }
   }
@@ -131,120 +131,120 @@ bool ED_masklayer_frame_select_check(MaskLayer *masklay)
 }
 
 /* helper function - select mask-frame based on SELECT_* mode */
-static void masklayshape_select(MaskLayerShape *masklay_shape, short select_mode)
+static void mask_layer_shape_select(MaskLayerShape *mask_layer_shape, short select_mode)
 {
-  if (masklay_shape == NULL) {
+  if (mask_layer_shape == NULL) {
     return;
   }
 
   switch (select_mode) {
     case SELECT_ADD:
-      masklay_shape->flag |= MASK_SHAPE_SELECT;
+      mask_layer_shape->flag |= MASK_SHAPE_SELECT;
       break;
     case SELECT_SUBTRACT:
-      masklay_shape->flag &= ~MASK_SHAPE_SELECT;
+      mask_layer_shape->flag &= ~MASK_SHAPE_SELECT;
       break;
     case SELECT_INVERT:
-      masklay_shape->flag ^= MASK_SHAPE_SELECT;
+      mask_layer_shape->flag ^= MASK_SHAPE_SELECT;
       break;
   }
 }
 
 /* set all/none/invert select (like above, but with SELECT_* modes) */
-void ED_mask_select_frames(MaskLayer *masklay, short select_mode)
+void ED_mask_select_frames(MaskLayer *mask_layer, short select_mode)
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
 
   /* error checking */
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return;
   }
 
   /* handle according to mode */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape->next) {
-    masklayshape_select(masklay_shape, select_mode);
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape->next) {
+    mask_layer_shape_select(mask_layer_shape, select_mode);
   }
 }
 
 /* set all/none/invert select */
-void ED_masklayer_frame_select_set(MaskLayer *masklay, short mode)
+void ED_masklayer_frame_select_set(MaskLayer *mask_layer, short mode)
 {
   /* error checking */
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return;
   }
 
   /* now call the standard function */
-  ED_mask_select_frames(masklay, mode);
+  ED_mask_select_frames(mask_layer, mode);
 }
 
 /* select the frame in this layer that occurs on this frame (there should only be one at most) */
-void ED_mask_select_frame(MaskLayer *masklay, int selx, short select_mode)
+void ED_mask_select_frame(MaskLayer *mask_layer, int selx, short select_mode)
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
 
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return;
   }
 
-  masklay_shape = BKE_mask_layer_shape_find_frame(masklay, selx);
+  mask_layer_shape = BKE_mask_layer_shape_find_frame(mask_layer, selx);
 
-  if (masklay_shape) {
-    masklayshape_select(masklay_shape, select_mode);
+  if (mask_layer_shape) {
+    mask_layer_shape_select(mask_layer_shape, select_mode);
   }
 }
 
 /* select the frames in this layer that occur within the bounds specified */
-void ED_masklayer_frames_select_box(MaskLayer *masklay, float min, float max, short select_mode)
+void ED_masklayer_frames_select_box(MaskLayer *mask_layer, float min, float max, short select_mode)
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
 
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return;
   }
 
   /* only select those frames which are in bounds */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape->next) {
-    if (IN_RANGE(masklay_shape->frame, min, max)) {
-      masklayshape_select(masklay_shape, select_mode);
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape->next) {
+    if (IN_RANGE(mask_layer_shape->frame, min, max)) {
+      mask_layer_shape_select(mask_layer_shape, select_mode);
     }
   }
 }
 
 /* select the frames in this layer that occur within the lasso/circle region specified */
 void ED_masklayer_frames_select_region(KeyframeEditData *ked,
-                                       MaskLayer *masklay,
+                                       MaskLayer *mask_layer,
                                        short tool,
                                        short select_mode)
 {
-  MaskLayerShape *masklay_shape;
+  MaskLayerShape *mask_layer_shape;
 
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return;
   }
 
   /* only select frames which are within the region */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape->next) {
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape->next) {
     /* construct a dummy point coordinate to do this testing with */
     float pt[2] = {0};
 
-    pt[0] = masklay_shape->frame;
+    pt[0] = mask_layer_shape->frame;
     pt[1] = ked->channel_y;
 
     /* check the necessary regions */
     if (tool == BEZT_OK_CHANNEL_LASSO) {
       /* Lasso */
       if (keyframe_region_lasso_test(ked->data, pt)) {
-        masklayshape_select(masklay_shape, select_mode);
+        mask_layer_shape_select(mask_layer_shape, select_mode);
       }
     }
     else if (tool == BEZT_OK_CHANNEL_CIRCLE) {
       /* Circle */
       if (keyframe_region_circle_test(ked->data, pt)) {
-        masklayshape_select(masklay_shape, select_mode);
+        mask_layer_shape_select(mask_layer_shape, select_mode);
       }
     }
   }
@@ -254,23 +254,23 @@ void ED_masklayer_frames_select_region(KeyframeEditData *ked,
 /* Frame Editing Tools */
 
 /* Delete selected frames */
-bool ED_masklayer_frames_delete(MaskLayer *masklay)
+bool ED_masklayer_frames_delete(MaskLayer *mask_layer)
 {
-  MaskLayerShape *masklay_shape, *masklay_shape_next;
+  MaskLayerShape *mask_layer_shape, *mask_layer_shape_next;
   bool changed = false;
 
   /* error checking */
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return false;
   }
 
   /* check for frames to delete */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-       masklay_shape = masklay_shape_next) {
-    masklay_shape_next = masklay_shape->next;
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = mask_layer_shape_next) {
+    mask_layer_shape_next = mask_layer_shape->next;
 
-    if (masklay_shape->flag & MASK_SHAPE_SELECT) {
-      BKE_mask_layer_shape_unlink(masklay, masklay_shape);
+    if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
+      BKE_mask_layer_shape_unlink(mask_layer, mask_layer_shape);
       changed = true;
     }
   }
@@ -279,29 +279,30 @@ bool ED_masklayer_frames_delete(MaskLayer *masklay)
 }
 
 /* Duplicate selected frames from given mask-layer */
-void ED_masklayer_frames_duplicate(MaskLayer *masklay)
+void ED_masklayer_frames_duplicate(MaskLayer *mask_layer)
 {
-  MaskLayerShape *masklay_shape, *gpfn;
+  MaskLayerShape *mask_layer_shape, *gpfn;
 
   /* error checking */
-  if (masklay == NULL) {
+  if (mask_layer == NULL) {
     return;
   }
 
   /* duplicate selected frames  */
-  for (masklay_shape = masklay->splines_shapes.first; masklay_shape; masklay_shape = gpfn) {
-    gpfn = masklay_shape->next;
+  for (mask_layer_shape = mask_layer->splines_shapes.first; mask_layer_shape;
+       mask_layer_shape = gpfn) {
+    gpfn = mask_layer_shape->next;
 
     /* duplicate this frame */
-    if (masklay_shape->flag & MASK_SHAPE_SELECT) {
+    if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
       MaskLayerShape *mask_shape_dupe;
 
       /* duplicate frame, and deselect self */
-      mask_shape_dupe = BKE_mask_layer_shape_duplicate(masklay_shape);
-      masklay_shape->flag &= ~MASK_SHAPE_SELECT;
+      mask_shape_dupe = BKE_mask_layer_shape_duplicate(mask_layer_shape);
+      mask_layer_shape->flag &= ~MASK_SHAPE_SELECT;
 
       /* XXX - how to handle duplicate frames? */
-      BLI_insertlinkafter(&masklay->splines_shapes, masklay_shape, mask_shape_dupe);
+      BLI_insertlinkafter(&mask_layer->splines_shapes, mask_layer_shape, mask_shape_dupe);
     }
   }
 }
@@ -309,55 +310,55 @@ void ED_masklayer_frames_duplicate(MaskLayer *masklay)
 /* -------------------------------------- */
 /* Snap Tools */
 
-static short snap_masklayer_nearest(MaskLayerShape *masklay_shape, Scene *UNUSED(scene))
+static short snap_mask_layer_nearest(MaskLayerShape *mask_layer_shape, Scene *UNUSED(scene))
 {
-  if (masklay_shape->flag & MASK_SHAPE_SELECT) {
-    masklay_shape->frame = (int)(floor(masklay_shape->frame + 0.5));
+  if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
+    mask_layer_shape->frame = (int)(floor(mask_layer_shape->frame + 0.5));
   }
   return 0;
 }
 
-static short snap_masklayer_nearestsec(MaskLayerShape *masklay_shape, Scene *scene)
+static short snap_mask_layer_nearestsec(MaskLayerShape *mask_layer_shape, Scene *scene)
 {
   float secf = (float)FPS;
-  if (masklay_shape->flag & MASK_SHAPE_SELECT) {
-    masklay_shape->frame = (int)(floorf(masklay_shape->frame / secf + 0.5f) * secf);
+  if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
+    mask_layer_shape->frame = (int)(floorf(mask_layer_shape->frame / secf + 0.5f) * secf);
   }
   return 0;
 }
 
-static short snap_masklayer_cframe(MaskLayerShape *masklay_shape, Scene *scene)
+static short snap_mask_layer_cframe(MaskLayerShape *mask_layer_shape, Scene *scene)
 {
-  if (masklay_shape->flag & MASK_SHAPE_SELECT) {
-    masklay_shape->frame = (int)CFRA;
+  if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
+    mask_layer_shape->frame = (int)CFRA;
   }
   return 0;
 }
 
-static short snap_masklayer_nearmarker(MaskLayerShape *masklay_shape, Scene *scene)
+static short snap_mask_layer_nearmarker(MaskLayerShape *mask_layer_shape, Scene *scene)
 {
-  if (masklay_shape->flag & MASK_SHAPE_SELECT) {
-    masklay_shape->frame = (int)ED_markers_find_nearest_marker_time(&scene->markers,
-                                                                    (float)masklay_shape->frame);
+  if (mask_layer_shape->flag & MASK_SHAPE_SELECT) {
+    mask_layer_shape->frame = (int)ED_markers_find_nearest_marker_time(
+        &scene->markers, (float)mask_layer_shape->frame);
   }
   return 0;
 }
 
 /* snap selected frames to ... */
-void ED_masklayer_snap_frames(MaskLayer *masklay, Scene *scene, short mode)
+void ED_masklayer_snap_frames(MaskLayer *mask_layer, Scene *scene, short mode)
 {
   switch (mode) {
     case SNAP_KEYS_NEARFRAME: /* snap to nearest frame */
-      ED_masklayer_frames_looper(masklay, scene, snap_masklayer_nearest);
+      ED_masklayer_frames_looper(mask_layer, scene, snap_mask_layer_nearest);
       break;
     case SNAP_KEYS_CURFRAME: /* snap to current frame */
-      ED_masklayer_frames_looper(masklay, scene, snap_masklayer_cframe);
+      ED_masklayer_frames_looper(mask_layer, scene, snap_mask_layer_cframe);
       break;
     case SNAP_KEYS_NEARMARKER: /* snap to nearest marker */
-      ED_masklayer_frames_looper(masklay, scene, snap_masklayer_nearmarker);
+      ED_masklayer_frames_looper(mask_layer, scene, snap_mask_layer_nearmarker);
       break;
     case SNAP_KEYS_NEARSEC: /* snap to nearest second */
-      ED_masklayer_frames_looper(masklay, scene, snap_masklayer_nearestsec);
+      ED_masklayer_frames_looper(mask_layer, scene, snap_mask_layer_nearestsec);
       break;
     default: /* just in case */
       break;