ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 395 insertions, 374 deletions

diff --git a/source/blender/editors/space_node/node_gizmo.c b/source/blender/editors/space_node/node_gizmo.c
index a511d6b9bd4..dbbef222250 100644
--- a/source/blender/editors/space_node/node_gizmo.c
+++ b/source/blender/editors/space_node/node_gizmo.c
@@ -43,153 +43,154 @@
 
 #include "node_intern.h"
 
-
 /* -------------------------------------------------------------------- */
 /** \name Local Utilities
  * \{ */
 
-static void node_gizmo_calc_matrix_space(
-        const SpaceNode *snode, const ARegion *ar, float matrix_space[4][4])
+static void node_gizmo_calc_matrix_space(const SpaceNode *snode,
+                                         const ARegion *ar,
+                                         float matrix_space[4][4])
 {
-	unit_m4(matrix_space);
-	mul_v3_fl(matrix_space[0], snode->zoom);
-	mul_v3_fl(matrix_space[1], snode->zoom);
-	matrix_space[3][0] = (ar->winx / 2) + snode->xof;
-	matrix_space[3][1] = (ar->winy / 2) + snode->yof;
+  unit_m4(matrix_space);
+  mul_v3_fl(matrix_space[0], snode->zoom);
+  mul_v3_fl(matrix_space[1], snode->zoom);
+  matrix_space[3][0] = (ar->winx / 2) + snode->xof;
+  matrix_space[3][1] = (ar->winy / 2) + snode->yof;
 }
 
-static void node_gizmo_calc_matrix_space_with_image_dims(
-        const SpaceNode *snode, const ARegion *ar, const float image_dims[2], float matrix_space[4][4])
+static void node_gizmo_calc_matrix_space_with_image_dims(const SpaceNode *snode,
+                                                         const ARegion *ar,
+                                                         const float image_dims[2],
+                                                         float matrix_space[4][4])
 {
-	unit_m4(matrix_space);
-	mul_v3_fl(matrix_space[0], snode->zoom * image_dims[0]);
-	mul_v3_fl(matrix_space[1], snode->zoom * image_dims[1]);
-	matrix_space[3][0] = ((ar->winx / 2) + snode->xof) - ((image_dims[0] / 2.0f) * snode->zoom);
-	matrix_space[3][1] = ((ar->winy / 2) + snode->yof) - ((image_dims[1] / 2.0f) * snode->zoom);
+  unit_m4(matrix_space);
+  mul_v3_fl(matrix_space[0], snode->zoom * image_dims[0]);
+  mul_v3_fl(matrix_space[1], snode->zoom * image_dims[1]);
+  matrix_space[3][0] = ((ar->winx / 2) + snode->xof) - ((image_dims[0] / 2.0f) * snode->zoom);
+  matrix_space[3][1] = ((ar->winy / 2) + snode->yof) - ((image_dims[1] / 2.0f) * snode->zoom);
 }
 
 /** \} */
 
-
-
 /* -------------------------------------------------------------------- */
 /** \name Backdrop Gizmo
  * \{ */
 
-static void gizmo_node_backdrop_prop_matrix_get(
-        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
-        void *value_p)
+static void gizmo_node_backdrop_prop_matrix_get(const wmGizmo *UNUSED(gz),
+                                                wmGizmoProperty *gz_prop,
+                                                void *value_p)
 {
-	float (*matrix)[4] = value_p;
-	BLI_assert(gz_prop->type->array_length == 16);
-	const SpaceNode *snode = gz_prop->custom_func.user_data;
-	matrix[0][0] = snode->zoom;
-	matrix[1][1] = snode->zoom;
-	matrix[3][0] = snode->xof;
-	matrix[3][1] = snode->yof;
+  float(*matrix)[4] = value_p;
+  BLI_assert(gz_prop->type->array_length == 16);
+  const SpaceNode *snode = gz_prop->custom_func.user_data;
+  matrix[0][0] = snode->zoom;
+  matrix[1][1] = snode->zoom;
+  matrix[3][0] = snode->xof;
+  matrix[3][1] = snode->yof;
 }
 
-static void gizmo_node_backdrop_prop_matrix_set(
-        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
-        const void *value_p)
+static void gizmo_node_backdrop_prop_matrix_set(const wmGizmo *UNUSED(gz),
+                                                wmGizmoProperty *gz_prop,
+                                                const void *value_p)
 {
-	const float (*matrix)[4] = value_p;
-	BLI_assert(gz_prop->type->array_length == 16);
-	SpaceNode *snode = gz_prop->custom_func.user_data;
-	snode->zoom = matrix[0][0];
-	snode->zoom = matrix[1][1];
-	snode->xof  = matrix[3][0];
-	snode->yof  = matrix[3][1];
+  const float(*matrix)[4] = value_p;
+  BLI_assert(gz_prop->type->array_length == 16);
+  SpaceNode *snode = gz_prop->custom_func.user_data;
+  snode->zoom = matrix[0][0];
+  snode->zoom = matrix[1][1];
+  snode->xof = matrix[3][0];
+  snode->yof = matrix[3][1];
 }
 
 static bool WIDGETGROUP_node_transform_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	if ((snode->flag & SNODE_BACKDRAW) == 0) {
-		return false;
-	}
+  if ((snode->flag & SNODE_BACKDRAW) == 0) {
+    return false;
+  }
 
-	if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
-		bNode *node = nodeGetActive(snode->edittree);
+  if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
+    bNode *node = nodeGetActive(snode->edittree);
 
-		if (node && ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
-			return true;
-		}
-	}
+    if (node && ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void WIDGETGROUP_node_transform_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
-	wmGizmoWrapper *wwrapper = MEM_mallocN(sizeof(wmGizmoWrapper), __func__);
+  wmGizmoWrapper *wwrapper = MEM_mallocN(sizeof(wmGizmoWrapper), __func__);
 
-	wwrapper->gizmo = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
+  wwrapper->gizmo = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
 
-	RNA_enum_set(wwrapper->gizmo->ptr, "transform",
-	             ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE | ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE_UNIFORM);
+  RNA_enum_set(wwrapper->gizmo->ptr,
+               "transform",
+               ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE | ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE_UNIFORM);
 
-	gzgroup->customdata = wwrapper;
+  gzgroup->customdata = wwrapper;
 }
 
 static void WIDGETGROUP_node_transform_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	Main *bmain = CTX_data_main(C);
-	wmGizmo *cage = ((wmGizmoWrapper *)gzgroup->customdata)->gizmo;
-	const ARegion *ar = CTX_wm_region(C);
-	/* center is always at the origin */
-	const float origin[3] = {ar->winx / 2, ar->winy / 2};
-
-	void *lock;
-	Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
-	ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
-
-	if (ibuf) {
-		const float dims[2] = {
-			(ibuf->x > 0) ? ibuf->x : 64.0f,
-			(ibuf->y > 0) ? ibuf->y : 64.0f,
-		};
-
-		RNA_float_set_array(cage->ptr, "dimensions", dims);
-		WM_gizmo_set_matrix_location(cage, origin);
-		WM_gizmo_set_flag(cage, WM_GIZMO_HIDDEN, false);
-
-		/* need to set property here for undo. TODO would prefer to do this in _init */
-		SpaceNode *snode = CTX_wm_space_node(C);
+  Main *bmain = CTX_data_main(C);
+  wmGizmo *cage = ((wmGizmoWrapper *)gzgroup->customdata)->gizmo;
+  const ARegion *ar = CTX_wm_region(C);
+  /* center is always at the origin */
+  const float origin[3] = {ar->winx / 2, ar->winy / 2};
+
+  void *lock;
+  Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
+  ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+
+  if (ibuf) {
+    const float dims[2] = {
+        (ibuf->x > 0) ? ibuf->x : 64.0f,
+        (ibuf->y > 0) ? ibuf->y : 64.0f,
+    };
+
+    RNA_float_set_array(cage->ptr, "dimensions", dims);
+    WM_gizmo_set_matrix_location(cage, origin);
+    WM_gizmo_set_flag(cage, WM_GIZMO_HIDDEN, false);
+
+    /* need to set property here for undo. TODO would prefer to do this in _init */
+    SpaceNode *snode = CTX_wm_space_node(C);
 #if 0
-		PointerRNA nodeptr;
-		RNA_pointer_create(snode->id, &RNA_SpaceNodeEditor, snode, &nodeptr);
-		WM_gizmo_target_property_def_rna(cage, "offset", &nodeptr, "backdrop_offset", -1);
-		WM_gizmo_target_property_def_rna(cage, "scale", &nodeptr, "backdrop_zoom", -1);
+    PointerRNA nodeptr;
+    RNA_pointer_create(snode->id, &RNA_SpaceNodeEditor, snode, &nodeptr);
+    WM_gizmo_target_property_def_rna(cage, "offset", &nodeptr, "backdrop_offset", -1);
+    WM_gizmo_target_property_def_rna(cage, "scale", &nodeptr, "backdrop_zoom", -1);
 #endif
 
-		WM_gizmo_target_property_def_func(
-		        cage, "matrix",
-		        &(const struct wmGizmoPropertyFnParams) {
-		            .value_get_fn = gizmo_node_backdrop_prop_matrix_get,
-		            .value_set_fn = gizmo_node_backdrop_prop_matrix_set,
-		            .range_get_fn = NULL,
-		            .user_data = snode,
-		        });
-	}
-	else {
-		WM_gizmo_set_flag(cage, WM_GIZMO_HIDDEN, true);
-	}
-
-	BKE_image_release_ibuf(ima, ibuf, lock);
+    WM_gizmo_target_property_def_func(cage,
+                                      "matrix",
+                                      &(const struct wmGizmoPropertyFnParams){
+                                          .value_get_fn = gizmo_node_backdrop_prop_matrix_get,
+                                          .value_set_fn = gizmo_node_backdrop_prop_matrix_set,
+                                          .range_get_fn = NULL,
+                                          .user_data = snode,
+                                      });
+  }
+  else {
+    WM_gizmo_set_flag(cage, WM_GIZMO_HIDDEN, true);
+  }
+
+  BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
 void NODE_GGT_backdrop_transform(wmGizmoGroupType *gzgt)
 {
-	gzgt->name = "Backdrop Transform Widget";
-	gzgt->idname = "NODE_GGT_backdrop_transform";
+  gzgt->name = "Backdrop Transform Widget";
+  gzgt->idname = "NODE_GGT_backdrop_transform";
 
-	gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
+  gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
 
-	gzgt->poll = WIDGETGROUP_node_transform_poll;
-	gzgt->setup = WIDGETGROUP_node_transform_setup;
-	gzgt->refresh = WIDGETGROUP_node_transform_refresh;
+  gzgt->poll = WIDGETGROUP_node_transform_poll;
+  gzgt->setup = WIDGETGROUP_node_transform_setup;
+  gzgt->refresh = WIDGETGROUP_node_transform_refresh;
 }
 
 /** \} */
@@ -199,199 +200,218 @@ void NODE_GGT_backdrop_transform(wmGizmoGroupType *gzgt)
  * \{ */
 
 struct NodeCropWidgetGroup {
-	wmGizmo *border;
+  wmGizmo *border;
 
-	struct {
-		float dims[2];
-	} state;
+  struct {
+    float dims[2];
+  } state;
 
-	struct {
-		PointerRNA ptr;
-		PropertyRNA *prop;
-		bContext *context;
-	} update_data;
+  struct {
+    PointerRNA ptr;
+    PropertyRNA *prop;
+    bContext *context;
+  } update_data;
 };
 
 static void gizmo_node_crop_update(struct NodeCropWidgetGroup *crop_group)
 {
-	RNA_property_update(crop_group->update_data.context, &crop_group->update_data.ptr, crop_group->update_data.prop);
+  RNA_property_update(
+      crop_group->update_data.context, &crop_group->update_data.ptr, crop_group->update_data.prop);
 }
 
-static void two_xy_to_rect(const NodeTwoXYs *nxy, rctf *rect, const float dims[2], bool is_relative)
+static void two_xy_to_rect(const NodeTwoXYs *nxy,
+                           rctf *rect,
+                           const float dims[2],
+                           bool is_relative)
 {
-	if (is_relative) {
-		rect->xmin = nxy->fac_x1;
-		rect->xmax = nxy->fac_x2;
-		rect->ymin = nxy->fac_y1;
-		rect->ymax = nxy->fac_y2;
-	}
-	else {
-		rect->xmin = nxy->x1 / dims[0];
-		rect->xmax = nxy->x2 / dims[0];
-		rect->ymin = nxy->y1 / dims[1];
-		rect->ymax = nxy->y2 / dims[1];
-	}
+  if (is_relative) {
+    rect->xmin = nxy->fac_x1;
+    rect->xmax = nxy->fac_x2;
+    rect->ymin = nxy->fac_y1;
+    rect->ymax = nxy->fac_y2;
+  }
+  else {
+    rect->xmin = nxy->x1 / dims[0];
+    rect->xmax = nxy->x2 / dims[0];
+    rect->ymin = nxy->y1 / dims[1];
+    rect->ymax = nxy->y2 / dims[1];
+  }
 }
 
-static void two_xy_from_rect(NodeTwoXYs *nxy, const rctf *rect, const float dims[2], bool is_relative)
+static void two_xy_from_rect(NodeTwoXYs *nxy,
+                             const rctf *rect,
+                             const float dims[2],
+                             bool is_relative)
 {
-	if (is_relative) {
-		nxy->fac_x1 = rect->xmin;
-		nxy->fac_x2 = rect->xmax;
-		nxy->fac_y1 = rect->ymin;
-		nxy->fac_y2 = rect->ymax;
-	}
-	else {
-		nxy->x1 = rect->xmin * dims[0];
-		nxy->x2 = rect->xmax * dims[0];
-		nxy->y1 = rect->ymin * dims[1];
-		nxy->y2 = rect->ymax * dims[1];
-	}
+  if (is_relative) {
+    nxy->fac_x1 = rect->xmin;
+    nxy->fac_x2 = rect->xmax;
+    nxy->fac_y1 = rect->ymin;
+    nxy->fac_y2 = rect->ymax;
+  }
+  else {
+    nxy->x1 = rect->xmin * dims[0];
+    nxy->x2 = rect->xmax * dims[0];
+    nxy->y1 = rect->ymin * dims[1];
+    nxy->y2 = rect->ymax * dims[1];
+  }
 }
 
 /* scale callbacks */
-static void gizmo_node_crop_prop_matrix_get(
-        const wmGizmo *gz, wmGizmoProperty *gz_prop,
-        void *value_p)
+static void gizmo_node_crop_prop_matrix_get(const wmGizmo *gz,
+                                            wmGizmoProperty *gz_prop,
+                                            void *value_p)
 {
-	float (*matrix)[4] = value_p;
-	BLI_assert(gz_prop->type->array_length == 16);
-	struct NodeCropWidgetGroup *crop_group = gz->parent_gzgroup->customdata;
-	const float *dims = crop_group->state.dims;
-	const bNode *node = gz_prop->custom_func.user_data;
-	const NodeTwoXYs *nxy = node->storage;
-	bool is_relative = (bool)node->custom2;
-	rctf rct;
-	two_xy_to_rect(nxy, &rct, dims, is_relative);
-	matrix[0][0] = fabsf(BLI_rctf_size_x(&rct));
-	matrix[1][1] = fabsf(BLI_rctf_size_y(&rct));
-	matrix[3][0] = (BLI_rctf_cent_x(&rct) - 0.5f) * dims[0];
-	matrix[3][1] = (BLI_rctf_cent_y(&rct) - 0.5f) * dims[1];
+  float(*matrix)[4] = value_p;
+  BLI_assert(gz_prop->type->array_length == 16);
+  struct NodeCropWidgetGroup *crop_group = gz->parent_gzgroup->customdata;
+  const float *dims = crop_group->state.dims;
+  const bNode *node = gz_prop->custom_func.user_data;
+  const NodeTwoXYs *nxy = node->storage;
+  bool is_relative = (bool)node->custom2;
+  rctf rct;
+  two_xy_to_rect(nxy, &rct, dims, is_relative);
+  matrix[0][0] = fabsf(BLI_rctf_size_x(&rct));
+  matrix[1][1] = fabsf(BLI_rctf_size_y(&rct));
+  matrix[3][0] = (BLI_rctf_cent_x(&rct) - 0.5f) * dims[0];
+  matrix[3][1] = (BLI_rctf_cent_y(&rct) - 0.5f) * dims[1];
 }
 
-static void gizmo_node_crop_prop_matrix_set(
-        const wmGizmo *gz, wmGizmoProperty *gz_prop,
-        const void *value_p)
+static void gizmo_node_crop_prop_matrix_set(const wmGizmo *gz,
+                                            wmGizmoProperty *gz_prop,
+                                            const void *value_p)
 {
-	const float (*matrix)[4] = value_p;
-	BLI_assert(gz_prop->type->array_length == 16);
-	struct NodeCropWidgetGroup *crop_group = gz->parent_gzgroup->customdata;
-	const float *dims = crop_group->state.dims;
-	bNode *node = gz_prop->custom_func.user_data;
-	NodeTwoXYs *nxy = node->storage;
-	bool is_relative = (bool)node->custom2;
-	rctf rct;
-	two_xy_to_rect(nxy, &rct, dims, is_relative);
-	const bool nx = rct.xmin > rct.xmax;
-	const bool ny = rct.ymin > rct.ymax;
-	BLI_rctf_resize(&rct, fabsf(matrix[0][0]), fabsf(matrix[1][1]));
-	BLI_rctf_recenter(&rct, (matrix[3][0] / dims[0]) + 0.5f, (matrix[3][1] / dims[1]) + 0.5f);
-	BLI_rctf_isect(&(rctf){ .xmin = 0, .ymin = 0, .xmax = 1, .ymax = 1, }, &rct, &rct);
-	if (nx) {
-		SWAP(float, rct.xmin, rct.xmax);
-	}
-	if (ny) {
-		SWAP(float, rct.ymin, rct.ymax);
-	}
-	two_xy_from_rect(nxy, &rct, dims, is_relative);
-	gizmo_node_crop_update(crop_group);
+  const float(*matrix)[4] = value_p;
+  BLI_assert(gz_prop->type->array_length == 16);
+  struct NodeCropWidgetGroup *crop_group = gz->parent_gzgroup->customdata;
+  const float *dims = crop_group->state.dims;
+  bNode *node = gz_prop->custom_func.user_data;
+  NodeTwoXYs *nxy = node->storage;
+  bool is_relative = (bool)node->custom2;
+  rctf rct;
+  two_xy_to_rect(nxy, &rct, dims, is_relative);
+  const bool nx = rct.xmin > rct.xmax;
+  const bool ny = rct.ymin > rct.ymax;
+  BLI_rctf_resize(&rct, fabsf(matrix[0][0]), fabsf(matrix[1][1]));
+  BLI_rctf_recenter(&rct, (matrix[3][0] / dims[0]) + 0.5f, (matrix[3][1] / dims[1]) + 0.5f);
+  BLI_rctf_isect(
+      &(rctf){
+          .xmin = 0,
+          .ymin = 0,
+          .xmax = 1,
+          .ymax = 1,
+      },
+      &rct,
+      &rct);
+  if (nx) {
+    SWAP(float, rct.xmin, rct.xmax);
+  }
+  if (ny) {
+    SWAP(float, rct.ymin, rct.ymax);
+  }
+  two_xy_from_rect(nxy, &rct, dims, is_relative);
+  gizmo_node_crop_update(crop_group);
 }
 
 static bool WIDGETGROUP_node_crop_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	if ((snode->flag & SNODE_BACKDRAW) == 0) {
-		return false;
-	}
+  if ((snode->flag & SNODE_BACKDRAW) == 0) {
+    return false;
+  }
 
-	if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
-		bNode *node = nodeGetActive(snode->edittree);
+  if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
+    bNode *node = nodeGetActive(snode->edittree);
 
-		if (node && ELEM(node->type, CMP_NODE_CROP)) {
-			/* ignore 'use_crop_size', we can't usefully edit the crop in this case. */
-			if ((node->custom1 & (1 << 0)) == 0) {
-				return true;
-			}
-		}
-	}
+    if (node && ELEM(node->type, CMP_NODE_CROP)) {
+      /* ignore 'use_crop_size', we can't usefully edit the crop in this case. */
+      if ((node->custom1 & (1 << 0)) == 0) {
+        return true;
+      }
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void WIDGETGROUP_node_crop_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
-	struct NodeCropWidgetGroup *crop_group = MEM_mallocN(sizeof(struct NodeCropWidgetGroup), __func__);
+  struct NodeCropWidgetGroup *crop_group = MEM_mallocN(sizeof(struct NodeCropWidgetGroup),
+                                                       __func__);
 
-	crop_group->border = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
+  crop_group->border = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
 
-	RNA_enum_set(crop_group->border->ptr, "transform",
-	             ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE | ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE);
+  RNA_enum_set(crop_group->border->ptr,
+               "transform",
+               ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE | ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE);
 
-	gzgroup->customdata = crop_group;
+  gzgroup->customdata = crop_group;
 }
 
 static void WIDGETGROUP_node_crop_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	ARegion *ar = CTX_wm_region(C);
-	wmGizmo *gz = gzgroup->gizmos.first;
+  ARegion *ar = CTX_wm_region(C);
+  wmGizmo *gz = gzgroup->gizmos.first;
 
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	node_gizmo_calc_matrix_space(snode, ar, gz->matrix_space);
+  node_gizmo_calc_matrix_space(snode, ar, gz->matrix_space);
 }
 
 static void WIDGETGROUP_node_crop_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	Main *bmain = CTX_data_main(C);
-	struct NodeCropWidgetGroup *crop_group = gzgroup->customdata;
-	wmGizmo *gz = crop_group->border;
-
-	void *lock;
-	Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
-	ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
-
-	if (ibuf) {
-		crop_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
-		crop_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
-
-		RNA_float_set_array(gz->ptr, "dimensions", crop_group->state.dims);
-		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
-
-		SpaceNode *snode = CTX_wm_space_node(C);
-		bNode *node = nodeGetActive(snode->edittree);
-
-		crop_group->update_data.context = (bContext *)C;
-		RNA_pointer_create((ID *)snode->edittree, &RNA_CompositorNodeCrop, node, &crop_group->update_data.ptr);
-		crop_group->update_data.prop = RNA_struct_find_property(&crop_group->update_data.ptr, "relative");
-
-		WM_gizmo_target_property_def_func(
-		        gz, "matrix",
-		        &(const struct wmGizmoPropertyFnParams) {
-		            .value_get_fn = gizmo_node_crop_prop_matrix_get,
-		            .value_set_fn = gizmo_node_crop_prop_matrix_set,
-		            .range_get_fn = NULL,
-		            .user_data = node,
-		        });
-	}
-	else {
-		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
-	}
-
-	BKE_image_release_ibuf(ima, ibuf, lock);
+  Main *bmain = CTX_data_main(C);
+  struct NodeCropWidgetGroup *crop_group = gzgroup->customdata;
+  wmGizmo *gz = crop_group->border;
+
+  void *lock;
+  Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
+  ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+
+  if (ibuf) {
+    crop_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
+    crop_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
+
+    RNA_float_set_array(gz->ptr, "dimensions", crop_group->state.dims);
+    WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
+
+    SpaceNode *snode = CTX_wm_space_node(C);
+    bNode *node = nodeGetActive(snode->edittree);
+
+    crop_group->update_data.context = (bContext *)C;
+    RNA_pointer_create(
+        (ID *)snode->edittree, &RNA_CompositorNodeCrop, node, &crop_group->update_data.ptr);
+    crop_group->update_data.prop = RNA_struct_find_property(&crop_group->update_data.ptr,
+                                                            "relative");
+
+    WM_gizmo_target_property_def_func(gz,
+                                      "matrix",
+                                      &(const struct wmGizmoPropertyFnParams){
+                                          .value_get_fn = gizmo_node_crop_prop_matrix_get,
+                                          .value_set_fn = gizmo_node_crop_prop_matrix_set,
+                                          .range_get_fn = NULL,
+                                          .user_data = node,
+                                      });
+  }
+  else {
+    WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
+  }
+
+  BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
 void NODE_GGT_backdrop_crop(wmGizmoGroupType *gzgt)
 {
-	gzgt->name = "Backdrop Crop Widget";
-	gzgt->idname = "NODE_GGT_backdrop_crop";
+  gzgt->name = "Backdrop Crop Widget";
+  gzgt->idname = "NODE_GGT_backdrop_crop";
 
-	gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
+  gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
 
-	gzgt->poll = WIDGETGROUP_node_crop_poll;
-	gzgt->setup = WIDGETGROUP_node_crop_setup;
-	gzgt->draw_prepare = WIDGETGROUP_node_crop_draw_prepare;
-	gzgt->refresh = WIDGETGROUP_node_crop_refresh;
+  gzgt->poll = WIDGETGROUP_node_crop_poll;
+  gzgt->setup = WIDGETGROUP_node_crop_setup;
+  gzgt->draw_prepare = WIDGETGROUP_node_crop_draw_prepare;
+  gzgt->refresh = WIDGETGROUP_node_crop_refresh;
 }
 
 /** \} */
@@ -401,220 +421,221 @@ void NODE_GGT_backdrop_crop(wmGizmoGroupType *gzgt)
  * \{ */
 
 struct NodeSunBeamsWidgetGroup {
-	wmGizmo *gizmo;
+  wmGizmo *gizmo;
 
-	struct {
-		float dims[2];
-	} state;
+  struct {
+    float dims[2];
+  } state;
 };
 
 static bool WIDGETGROUP_node_sbeam_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	if ((snode->flag & SNODE_BACKDRAW) == 0) {
-		return false;
-	}
+  if ((snode->flag & SNODE_BACKDRAW) == 0) {
+    return false;
+  }
 
-	if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
-		bNode *node = nodeGetActive(snode->edittree);
+  if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
+    bNode *node = nodeGetActive(snode->edittree);
 
-		if (node && ELEM(node->type, CMP_NODE_SUNBEAMS)) {
-			return true;
-		}
-	}
+    if (node && ELEM(node->type, CMP_NODE_SUNBEAMS)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void WIDGETGROUP_node_sbeam_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
-	struct NodeSunBeamsWidgetGroup *sbeam_group = MEM_mallocN(sizeof(struct NodeSunBeamsWidgetGroup), __func__);
+  struct NodeSunBeamsWidgetGroup *sbeam_group = MEM_mallocN(sizeof(struct NodeSunBeamsWidgetGroup),
+                                                            __func__);
 
-	sbeam_group->gizmo = WM_gizmo_new("GIZMO_GT_move_3d", gzgroup, NULL);
-	wmGizmo *gz = sbeam_group->gizmo;
+  sbeam_group->gizmo = WM_gizmo_new("GIZMO_GT_move_3d", gzgroup, NULL);
+  wmGizmo *gz = sbeam_group->gizmo;
 
-	RNA_enum_set(gz->ptr, "draw_style",  ED_GIZMO_MOVE_STYLE_CROSS_2D);
+  RNA_enum_set(gz->ptr, "draw_style", ED_GIZMO_MOVE_STYLE_CROSS_2D);
 
-	gz->scale_basis = 0.05f;
+  gz->scale_basis = 0.05f;
 
-	gzgroup->customdata = sbeam_group;
+  gzgroup->customdata = sbeam_group;
 }
 
 static void WIDGETGROUP_node_sbeam_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	struct NodeSunBeamsWidgetGroup *sbeam_group = gzgroup->customdata;
-	ARegion *ar = CTX_wm_region(C);
-	wmGizmo *gz = gzgroup->gizmos.first;
+  struct NodeSunBeamsWidgetGroup *sbeam_group = gzgroup->customdata;
+  ARegion *ar = CTX_wm_region(C);
+  wmGizmo *gz = gzgroup->gizmos.first;
 
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	node_gizmo_calc_matrix_space_with_image_dims(snode, ar, sbeam_group->state.dims, gz->matrix_space);
+  node_gizmo_calc_matrix_space_with_image_dims(
+      snode, ar, sbeam_group->state.dims, gz->matrix_space);
 }
 
 static void WIDGETGROUP_node_sbeam_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	Main *bmain = CTX_data_main(C);
-	struct NodeSunBeamsWidgetGroup *sbeam_group = gzgroup->customdata;
-	wmGizmo *gz = sbeam_group->gizmo;
+  Main *bmain = CTX_data_main(C);
+  struct NodeSunBeamsWidgetGroup *sbeam_group = gzgroup->customdata;
+  wmGizmo *gz = sbeam_group->gizmo;
 
-	void *lock;
-	Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
-	ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+  void *lock;
+  Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
+  ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
 
-	if (ibuf) {
-		sbeam_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
-		sbeam_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
+  if (ibuf) {
+    sbeam_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
+    sbeam_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
 
-		SpaceNode *snode = CTX_wm_space_node(C);
-		bNode *node = nodeGetActive(snode->edittree);
+    SpaceNode *snode = CTX_wm_space_node(C);
+    bNode *node = nodeGetActive(snode->edittree);
 
-		/* need to set property here for undo. TODO would prefer to do this in _init */
-		PointerRNA nodeptr;
-		RNA_pointer_create((ID *)snode->edittree, &RNA_CompositorNodeSunBeams, node, &nodeptr);
-		WM_gizmo_target_property_def_rna(gz, "offset", &nodeptr, "source", -1);
+    /* need to set property here for undo. TODO would prefer to do this in _init */
+    PointerRNA nodeptr;
+    RNA_pointer_create((ID *)snode->edittree, &RNA_CompositorNodeSunBeams, node, &nodeptr);
+    WM_gizmo_target_property_def_rna(gz, "offset", &nodeptr, "source", -1);
 
-		WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_MODAL, true);
-	}
-	else {
-		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
-	}
+    WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_MODAL, true);
+  }
+  else {
+    WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
+  }
 
-	BKE_image_release_ibuf(ima, ibuf, lock);
+  BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
 void NODE_GGT_backdrop_sun_beams(wmGizmoGroupType *gzgt)
 {
-	gzgt->name = "Sun Beams Widget";
-	gzgt->idname = "NODE_GGT_sbeam";
+  gzgt->name = "Sun Beams Widget";
+  gzgt->idname = "NODE_GGT_sbeam";
 
-	gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
+  gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
 
-	gzgt->poll = WIDGETGROUP_node_sbeam_poll;
-	gzgt->setup = WIDGETGROUP_node_sbeam_setup;
-	gzgt->draw_prepare = WIDGETGROUP_node_sbeam_draw_prepare;
-	gzgt->refresh = WIDGETGROUP_node_sbeam_refresh;
+  gzgt->poll = WIDGETGROUP_node_sbeam_poll;
+  gzgt->setup = WIDGETGROUP_node_sbeam_setup;
+  gzgt->draw_prepare = WIDGETGROUP_node_sbeam_draw_prepare;
+  gzgt->refresh = WIDGETGROUP_node_sbeam_refresh;
 }
 
 /** \} */
 
-
-
 /* -------------------------------------------------------------------- */
 /** \name Corner Pin
  * \{ */
 
 struct NodeCornerPinWidgetGroup {
-	wmGizmo *gizmos[4];
+  wmGizmo *gizmos[4];
 
-	struct {
-		float dims[2];
-	} state;
+  struct {
+    float dims[2];
+  } state;
 };
 
 static bool WIDGETGROUP_node_corner_pin_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	if ((snode->flag & SNODE_BACKDRAW) == 0) {
-		return false;
-	}
+  if ((snode->flag & SNODE_BACKDRAW) == 0) {
+    return false;
+  }
 
-	if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
-		bNode *node = nodeGetActive(snode->edittree);
+  if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
+    bNode *node = nodeGetActive(snode->edittree);
 
-		if (node && ELEM(node->type, CMP_NODE_CORNERPIN)) {
-			return true;
-		}
-	}
+    if (node && ELEM(node->type, CMP_NODE_CORNERPIN)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void WIDGETGROUP_node_corner_pin_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
-	struct NodeCornerPinWidgetGroup *cpin_group = MEM_mallocN(sizeof(struct NodeCornerPinWidgetGroup), __func__);
-	const wmGizmoType *gzt_move_3d = WM_gizmotype_find("GIZMO_GT_move_3d", false);
+  struct NodeCornerPinWidgetGroup *cpin_group = MEM_mallocN(
+      sizeof(struct NodeCornerPinWidgetGroup), __func__);
+  const wmGizmoType *gzt_move_3d = WM_gizmotype_find("GIZMO_GT_move_3d", false);
 
-	for (int i = 0; i < 4; i++) {
-		cpin_group->gizmos[i] = WM_gizmo_new_ptr(gzt_move_3d, gzgroup, NULL);
-		wmGizmo *gz = cpin_group->gizmos[i];
+  for (int i = 0; i < 4; i++) {
+    cpin_group->gizmos[i] = WM_gizmo_new_ptr(gzt_move_3d, gzgroup, NULL);
+    wmGizmo *gz = cpin_group->gizmos[i];
 
-		RNA_enum_set(gz->ptr, "draw_style",  ED_GIZMO_MOVE_STYLE_CROSS_2D);
+    RNA_enum_set(gz->ptr, "draw_style", ED_GIZMO_MOVE_STYLE_CROSS_2D);
 
-		gz->scale_basis = 0.01f;
-	}
+    gz->scale_basis = 0.01f;
+  }
 
-	gzgroup->customdata = cpin_group;
+  gzgroup->customdata = cpin_group;
 }
 
 static void WIDGETGROUP_node_corner_pin_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	struct NodeCornerPinWidgetGroup *cpin_group = gzgroup->customdata;
-	ARegion *ar = CTX_wm_region(C);
+  struct NodeCornerPinWidgetGroup *cpin_group = gzgroup->customdata;
+  ARegion *ar = CTX_wm_region(C);
 
-	SpaceNode *snode = CTX_wm_space_node(C);
+  SpaceNode *snode = CTX_wm_space_node(C);
 
-	float matrix_space[4][4];
-	node_gizmo_calc_matrix_space_with_image_dims(snode, ar, cpin_group->state.dims, matrix_space);
+  float matrix_space[4][4];
+  node_gizmo_calc_matrix_space_with_image_dims(snode, ar, cpin_group->state.dims, matrix_space);
 
-	for (int i = 0; i < 4; i++) {
-		wmGizmo *gz = cpin_group->gizmos[i];
-		copy_m4_m4(gz->matrix_space, matrix_space);
-	}
+  for (int i = 0; i < 4; i++) {
+    wmGizmo *gz = cpin_group->gizmos[i];
+    copy_m4_m4(gz->matrix_space, matrix_space);
+  }
 }
 
 static void WIDGETGROUP_node_corner_pin_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	Main *bmain = CTX_data_main(C);
-	struct NodeCornerPinWidgetGroup *cpin_group = gzgroup->customdata;
-
-	void *lock;
-	Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
-	ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
-
-	if (ibuf) {
-		cpin_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
-		cpin_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
-
-		SpaceNode *snode = CTX_wm_space_node(C);
-		bNode *node = nodeGetActive(snode->edittree);
-
-		/* need to set property here for undo. TODO would prefer to do this in _init */
-		int i = 0;
-		for (bNodeSocket *sock = node->inputs.first; sock && i < 4; sock = sock->next) {
-			if (sock->type == SOCK_VECTOR) {
-				wmGizmo *gz = cpin_group->gizmos[i++];
-
-				PointerRNA sockptr;
-				RNA_pointer_create((ID *)snode->edittree, &RNA_NodeSocket, sock, &sockptr);
-				WM_gizmo_target_property_def_rna(gz, "offset", &sockptr, "default_value", -1);
-
-				WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_MODAL, true);
-			}
-		}
-	}
-	else {
-		for (int i = 0; i < 4; i++) {
-			wmGizmo *gz = cpin_group->gizmos[i];
-			WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
-		}
-	}
-
-	BKE_image_release_ibuf(ima, ibuf, lock);
+  Main *bmain = CTX_data_main(C);
+  struct NodeCornerPinWidgetGroup *cpin_group = gzgroup->customdata;
+
+  void *lock;
+  Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
+  ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
+
+  if (ibuf) {
+    cpin_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
+    cpin_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
+
+    SpaceNode *snode = CTX_wm_space_node(C);
+    bNode *node = nodeGetActive(snode->edittree);
+
+    /* need to set property here for undo. TODO would prefer to do this in _init */
+    int i = 0;
+    for (bNodeSocket *sock = node->inputs.first; sock && i < 4; sock = sock->next) {
+      if (sock->type == SOCK_VECTOR) {
+        wmGizmo *gz = cpin_group->gizmos[i++];
+
+        PointerRNA sockptr;
+        RNA_pointer_create((ID *)snode->edittree, &RNA_NodeSocket, sock, &sockptr);
+        WM_gizmo_target_property_def_rna(gz, "offset", &sockptr, "default_value", -1);
+
+        WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_MODAL, true);
+      }
+    }
+  }
+  else {
+    for (int i = 0; i < 4; i++) {
+      wmGizmo *gz = cpin_group->gizmos[i];
+      WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
+    }
+  }
+
+  BKE_image_release_ibuf(ima, ibuf, lock);
 }
 
 void NODE_GGT_backdrop_corner_pin(wmGizmoGroupType *gzgt)
 {
-	gzgt->name = "Corner Pin Widget";
-	gzgt->idname = "NODE_GGT_backdrop_corner_pin";
+  gzgt->name = "Corner Pin Widget";
+  gzgt->idname = "NODE_GGT_backdrop_corner_pin";
 
-	gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
+  gzgt->flag |= WM_GIZMOGROUPTYPE_PERSISTENT;
 
-	gzgt->poll = WIDGETGROUP_node_corner_pin_poll;
-	gzgt->setup = WIDGETGROUP_node_corner_pin_setup;
-	gzgt->draw_prepare = WIDGETGROUP_node_corner_pin_draw_prepare;
-	gzgt->refresh = WIDGETGROUP_node_corner_pin_refresh;
+  gzgt->poll = WIDGETGROUP_node_corner_pin_poll;
+  gzgt->setup = WIDGETGROUP_node_corner_pin_setup;
+  gzgt->draw_prepare = WIDGETGROUP_node_corner_pin_draw_prepare;
+  gzgt->refresh = WIDGETGROUP_node_corner_pin_refresh;
 }
 
 /** \} */