Cleanup: use variable names based on term gizmo

11 files changed, 490 insertions, 490 deletions

diff --git a/source/blender/editors/space_view3d/space_view3d.c b/source/blender/editors/space_view3d/space_view3d.c
index 6d4009e9d2b..dca4b3f4f76 100644
--- a/source/blender/editors/space_view3d/space_view3d.c
+++ b/source/blender/editors/space_view3d/space_view3d.c
@@ -716,26 +716,26 @@ static void view3d_dropboxes(void)
 
 static void view3d_widgets(void)
 {
-	wmGizmoMapType *mmap_type = WM_gizmomaptype_ensure(
+	wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(
 	        &(const struct wmGizmoMapType_Params){SPACE_VIEW3D, RGN_TYPE_WINDOW});
 
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_lamp_spot);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_lamp_area);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_lamp_target);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_force_field);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_camera);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_camera_view);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_empty_image);
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_armature_spline);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_lamp_spot);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_lamp_area);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_lamp_target);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_force_field);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera_view);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_empty_image);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_armature_spline);
 
-	WM_gizmogrouptype_append(TRANSFORM_WGT_gizmo);
-	WM_gizmogrouptype_append(VIEW3D_WGT_xform_cage);
+	WM_gizmogrouptype_append(TRANSFORM_GGT_gizmo);
+	WM_gizmogrouptype_append(VIEW3D_GGT_xform_cage);
 
-	WM_gizmogrouptype_append(VIEW3D_WGT_ruler);
-	WM_gizmotype_append(VIEW3D_WT_ruler_item);
+	WM_gizmogrouptype_append(VIEW3D_GGT_ruler);
+	WM_gizmotype_append(VIEW3D_GT_ruler_item);
 
-	WM_gizmogrouptype_append_and_link(mmap_type, VIEW3D_WGT_navigate);
-	WM_gizmotype_append(VIEW3D_WT_navigate_rotate);
+	WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_navigate);
+	WM_gizmotype_append(VIEW3D_GT_navigate_rotate);
 }
 
 
@@ -815,13 +815,13 @@ static void view3d_main_region_listener(
 {
 	View3D *v3d = sa->spacedata.first;
 	RegionView3D *rv3d = ar->regiondata;
-	wmGizmoMap *mmap = ar->gizmo_map;
+	wmGizmoMap *gzmap = ar->gizmo_map;
 
 	/* context changes */
 	switch (wmn->category) {
 		case NC_WM:
 			if (ELEM(wmn->data, ND_UNDO)) {
-				WM_gizmomap_tag_refresh(mmap);
+				WM_gizmomap_tag_refresh(gzmap);
 			}
 			break;
 		case NC_ANIMATION:
@@ -848,14 +848,14 @@ static void view3d_main_region_listener(
 					if (wmn->reference)
 						view3d_recalc_used_layers(ar, wmn, wmn->reference);
 					ED_region_tag_redraw(ar);
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					break;
 				case ND_LAYER:
 					if (wmn->reference) {
 						BKE_screen_view3d_sync(v3d, wmn->reference);
 					}
 					ED_region_tag_redraw(ar);
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					break;
 				case ND_OB_ACTIVE:
 				case ND_OB_SELECT:
@@ -867,7 +867,7 @@ static void view3d_main_region_listener(
 				case ND_MARKERS:
 				case ND_MODE:
 					ED_region_tag_redraw(ar);
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					break;
 				case ND_WORLD:
 					/* handled by space_view3d_listener() for v3d access */
@@ -899,7 +899,7 @@ static void view3d_main_region_listener(
 				case ND_POINTCACHE:
 				case ND_LOD:
 					ED_region_tag_redraw(ar);
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					break;
 			}
 			switch (wmn->action) {
@@ -912,7 +912,7 @@ static void view3d_main_region_listener(
 			switch (wmn->data) {
 				case ND_SELECT:
 				{
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					ATTR_FALLTHROUGH;
 				}
 				case ND_DATA:
@@ -993,7 +993,7 @@ static void view3d_main_region_listener(
 					break;
 				case ND_LIGHTING_DRAW:
 					ED_region_tag_redraw(ar);
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					break;
 			}
 			break;
@@ -1019,7 +1019,7 @@ static void view3d_main_region_listener(
 					rv3d->rflag |= RV3D_GPULIGHT_UPDATE;
 				}
 				ED_region_tag_redraw(ar);
-				WM_gizmomap_tag_refresh(mmap);
+				WM_gizmomap_tag_refresh(gzmap);
 			}
 			break;
 		case NC_ID:
@@ -1035,7 +1035,7 @@ static void view3d_main_region_listener(
 				case ND_LAYOUTBROWSE:
 				case ND_LAYOUTDELETE:
 				case ND_LAYOUTSET:
-					WM_gizmomap_tag_refresh(mmap);
+					WM_gizmomap_tag_refresh(gzmap);
 					ED_region_tag_redraw(ar);
 					break;
 				case ND_LAYER:
diff --git a/source/blender/editors/space_view3d/view3d_draw.c b/source/blender/editors/space_view3d/view3d_draw.c
index be79cef182d..89d01727d9b 100644
--- a/source/blender/editors/space_view3d/view3d_draw.c
+++ b/source/blender/editors/space_view3d/view3d_draw.c
@@ -1207,7 +1207,7 @@ void view3d_draw_region_info(const bContext *C, ARegion *ar, const int UNUSED(of
 	if ((U.uiflag & USER_SHOW_GIZMO_AXIS) ||
 	    (v3d->flag2 & V3D_RENDER_OVERRIDE) ||
 	    /* No need to display gizmo and this info. */
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE)))
 	{
 		/* pass */
 	}
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_armature.c b/source/blender/editors/space_view3d/view3d_gizmo_armature.c
index c7b12529798..88a95e89bd8 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_armature.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_armature.c
@@ -80,14 +80,14 @@ struct BoneSplineWidgetGroup {
 };
 
 static void gizmo_bbone_offset_get(
-        const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop,
+        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
         void *value_p)
 {
-	struct BoneSplineHandle *bh = mpr_prop->custom_func.user_data;
+	struct BoneSplineHandle *bh = gz_prop->custom_func.user_data;
 	bPoseChannel *pchan = bh->pchan;
 
 	float *value = value_p;
-	BLI_assert(mpr_prop->type->array_length == 3);
+	BLI_assert(gz_prop->type->array_length == 3);
 
 	if (bh->index == 0) {
 		bh->co[1] = pchan->bone->ease1 / BBONE_SCALE_Y;
@@ -103,15 +103,15 @@ static void gizmo_bbone_offset_get(
 }
 
 static void gizmo_bbone_offset_set(
-        const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop,
+        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
         const void *value_p)
 {
-	struct BoneSplineHandle *bh = mpr_prop->custom_func.user_data;
+	struct BoneSplineHandle *bh = gz_prop->custom_func.user_data;
 	bPoseChannel *pchan = bh->pchan;
 
 	const float *value = value_p;
 
-	BLI_assert(mpr_prop->type->array_length == 3);
+	BLI_assert(gz_prop->type->array_length == 3);
 	copy_v3_v3(bh->co, value);
 
 	if (bh->index == 0) {
@@ -127,7 +127,7 @@ static void gizmo_bbone_offset_set(
 
 }
 
-static bool WIDGETGROUP_armature_spline_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_armature_spline_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
 	if (ob != NULL) {
@@ -136,7 +136,7 @@ static bool WIDGETGROUP_armature_spline_poll(const bContext *C, wmGizmoGroupType
 			if (arm->act_bone && arm->act_bone->segments > 1) {
 				View3D *v3d = CTX_wm_view3d(C);
 				if ((v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-				    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
+				    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
 				{
 					/* pass */
 				}
@@ -150,59 +150,59 @@ static bool WIDGETGROUP_armature_spline_poll(const bContext *C, wmGizmoGroupType
 }
 
 
-static void WIDGETGROUP_armature_spline_setup(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_armature_spline_setup(const bContext *C, wmGizmoGroup *gzgroup)
 {
 	Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
 	bPoseChannel *pchan = BKE_pose_channel_active(ob);
 
-	const wmGizmoType *wt_grab = WM_gizmotype_find("GIZMO_WT_grab_3d", true);
+	const wmGizmoType *gzt_grab = WM_gizmotype_find("GIZMO_GT_grab_3d", true);
 
 	struct BoneSplineWidgetGroup *bspline_group = MEM_callocN(sizeof(struct BoneSplineWidgetGroup), __func__);
-	mgroup->customdata = bspline_group;
+	gzgroup->customdata = bspline_group;
 
 	/* Handles */
 	for (int i = 0; i < ARRAY_SIZE(bspline_group->handles); i++) {
-		wmGizmo *mpr;
-		mpr = bspline_group->handles[i].gizmo = WM_gizmo_new_ptr(wt_grab, mgroup, NULL);
-		RNA_enum_set(mpr->ptr, "draw_style", ED_GIZMO_GRAB_STYLE_RING_2D);
-		RNA_enum_set(mpr->ptr, "draw_options",
+		wmGizmo *gz;
+		gz = bspline_group->handles[i].gizmo = WM_gizmo_new_ptr(gzt_grab, gzgroup, NULL);
+		RNA_enum_set(gz->ptr, "draw_style", ED_GIZMO_GRAB_STYLE_RING_2D);
+		RNA_enum_set(gz->ptr, "draw_options",
 		             ED_GIZMO_GRAB_DRAW_FLAG_FILL | ED_GIZMO_GRAB_DRAW_FLAG_ALIGN_VIEW);
-		WM_gizmo_set_flag(mpr, WM_GIZMO_DRAW_VALUE, true);
+		WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_VALUE, true);
 
-		UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-		UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+		UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+		UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 
-		mpr->scale_basis = 0.06f;
+		gz->scale_basis = 0.06f;
 
 		if (i == 0) {
-			copy_v3_v3(mpr->matrix_basis[3], pchan->loc);
+			copy_v3_v3(gz->matrix_basis[3], pchan->loc);
 		}
 	}
 }
 
-static void WIDGETGROUP_armature_spline_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_armature_spline_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
 	Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
 
-	if (!mgroup->customdata)
+	if (!gzgroup->customdata)
 		return;
 
-	struct BoneSplineWidgetGroup *bspline_group = mgroup->customdata;
+	struct BoneSplineWidgetGroup *bspline_group = gzgroup->customdata;
 	bPoseChannel *pchan = BKE_pose_channel_active(ob);
 
 	/* Handles */
 	for (int i = 0; i < ARRAY_SIZE(bspline_group->handles); i++) {
-		wmGizmo *mpr = bspline_group->handles[i].gizmo;
+		wmGizmo *gz = bspline_group->handles[i].gizmo;
 		bspline_group->handles[i].pchan = pchan;
 		bspline_group->handles[i].index = i;
 
 		float mat[4][4];
 		mul_m4_m4m4(mat, ob->obmat, (i == 0) ? pchan->disp_mat : pchan->disp_tail_mat);
-		copy_m4_m4(mpr->matrix_space, mat);
+		copy_m4_m4(gz->matrix_space, mat);
 
 		/* need to set property here for undo. TODO would prefer to do this in _init */
 		WM_gizmo_target_property_def_func(
-		        mpr, "offset",
+		        gz, "offset",
 		        &(const struct wmGizmoPropertyFnParams) {
 		            .value_get_fn = gizmo_bbone_offset_get,
 		            .value_set_fn = gizmo_bbone_offset_set,
@@ -212,17 +212,17 @@ static void WIDGETGROUP_armature_spline_refresh(const bContext *C, wmGizmoGroup
 	}
 }
 
-void VIEW3D_WGT_armature_spline(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_armature_spline(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Armature Spline Widgets";
-	wgt->idname = "VIEW3D_WGT_armature_spline";
+	gzgt->name = "Armature Spline Widgets";
+	gzgt->idname = "VIEW3D_GGT_armature_spline";
 
-	wgt->flag = (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag = (WM_GIZMOGROUPTYPE_PERSISTENT |
 	             WM_GIZMOGROUPTYPE_3D);
 
-	wgt->poll = WIDGETGROUP_armature_spline_poll;
-	wgt->setup = WIDGETGROUP_armature_spline_setup;
-	wgt->refresh = WIDGETGROUP_armature_spline_refresh;
+	gzgt->poll = WIDGETGROUP_armature_spline_poll;
+	gzgt->setup = WIDGETGROUP_armature_spline_setup;
+	gzgt->refresh = WIDGETGROUP_armature_spline_refresh;
 }
 
 /** \} */
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_camera.c b/source/blender/editors/space_view3d/view3d_gizmo_camera.c
index b011e6e2e21..87b11f5d7a3 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_camera.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_camera.c
@@ -61,11 +61,11 @@ struct CameraWidgetGroup {
 	wmGizmo *ortho_scale;
 };
 
-static bool WIDGETGROUP_camera_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_camera_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
 	{
 		return false;
 	}
@@ -81,57 +81,57 @@ static bool WIDGETGROUP_camera_poll(const bContext *C, wmGizmoGroupType *UNUSED(
 	return false;
 }
 
-static void WIDGETGROUP_camera_setup(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_camera_setup(const bContext *C, wmGizmoGroup *gzgroup)
 {
 	Object *ob = CTX_data_active_object(C);
 	float dir[3];
 
-	const wmGizmoType *wt_arrow = WM_gizmotype_find("GIZMO_WT_arrow_3d", true);
+	const wmGizmoType *gzt_arrow = WM_gizmotype_find("GIZMO_GT_arrow_3d", true);
 
-	struct CameraWidgetGroup *camgroup = MEM_callocN(sizeof(struct CameraWidgetGroup), __func__);
-	mgroup->customdata = camgroup;
+	struct CameraWidgetGroup *cagzgroup = MEM_callocN(sizeof(struct CameraWidgetGroup), __func__);
+	gzgroup->customdata = cagzgroup;
 
 	negate_v3_v3(dir, ob->obmat[2]);
 
 	/* dof distance */
 	{
-		wmGizmo *mpr;
-		mpr = camgroup->dop_dist = WM_gizmo_new_ptr(wt_arrow, mgroup, NULL);
-		RNA_enum_set(mpr->ptr, "draw_style",  ED_GIZMO_ARROW_STYLE_CROSS);
-		WM_gizmo_set_flag(mpr, WM_GIZMO_DRAW_HOVER, true);
+		wmGizmo *gz;
+		gz = cagzgroup->dop_dist = WM_gizmo_new_ptr(gzt_arrow, gzgroup, NULL);
+		RNA_enum_set(gz->ptr, "draw_style",  ED_GIZMO_ARROW_STYLE_CROSS);
+		WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_HOVER, true);
 
-		UI_GetThemeColor3fv(TH_GIZMO_A, mpr->color);
-		UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+		UI_GetThemeColor3fv(TH_GIZMO_A, gz->color);
+		UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 	}
 
 	/* focal length
 	 * - logic/calculations are similar to BKE_camera_view_frame_ex, better keep in sync */
 	{
-		wmGizmo *mpr;
-		mpr = camgroup->focal_len = WM_gizmo_new_ptr(wt_arrow, mgroup, NULL);
-		mpr->flag |= WM_GIZMO_DRAW_NO_SCALE;
-		RNA_enum_set(mpr->ptr, "draw_style",  ED_GIZMO_ARROW_STYLE_CONE);
-		RNA_enum_set(mpr->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_CONSTRAINED);
-
-		UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-		UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
-
-		mpr = camgroup->ortho_scale = WM_gizmo_new_ptr(wt_arrow, mgroup, NULL);
-		mpr->flag |= WM_GIZMO_DRAW_NO_SCALE;
-		RNA_enum_set(mpr->ptr, "draw_style",  ED_GIZMO_ARROW_STYLE_CONE);
-		RNA_enum_set(mpr->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_CONSTRAINED);
-
-		UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-		UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+		wmGizmo *gz;
+		gz = cagzgroup->focal_len = WM_gizmo_new_ptr(gzt_arrow, gzgroup, NULL);
+		gz->flag |= WM_GIZMO_DRAW_NO_SCALE;
+		RNA_enum_set(gz->ptr, "draw_style",  ED_GIZMO_ARROW_STYLE_CONE);
+		RNA_enum_set(gz->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_CONSTRAINED);
+
+		UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+		UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
+
+		gz = cagzgroup->ortho_scale = WM_gizmo_new_ptr(gzt_arrow, gzgroup, NULL);
+		gz->flag |= WM_GIZMO_DRAW_NO_SCALE;
+		RNA_enum_set(gz->ptr, "draw_style",  ED_GIZMO_ARROW_STYLE_CONE);
+		RNA_enum_set(gz->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_CONSTRAINED);
+
+		UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+		UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 	}
 }
 
-static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	if (!mgroup->customdata)
+	if (!gzgroup->customdata)
 		return;
 
-	struct CameraWidgetGroup *camgroup = mgroup->customdata;
+	struct CameraWidgetGroup *cagzgroup = gzgroup->customdata;
 	Object *ob = CTX_data_active_object(C);
 	Camera *ca = ob->data;
 	PointerRNA camera_ptr;
@@ -149,16 +149,16 @@ static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *mgroup)
 	negate_v3_v3(dir, ob->obmat[2]);
 
 	if (ca->flag & CAM_SHOWLIMITS) {
-		WM_gizmo_set_matrix_location(camgroup->dop_dist, ob->obmat[3]);
-		WM_gizmo_set_matrix_rotation_from_yz_axis(camgroup->dop_dist, ob->obmat[1], dir);
-		WM_gizmo_set_scale(camgroup->dop_dist, ca->drawsize);
-		WM_gizmo_set_flag(camgroup->dop_dist, WM_GIZMO_HIDDEN, false);
+		WM_gizmo_set_matrix_location(cagzgroup->dop_dist, ob->obmat[3]);
+		WM_gizmo_set_matrix_rotation_from_yz_axis(cagzgroup->dop_dist, ob->obmat[1], dir);
+		WM_gizmo_set_scale(cagzgroup->dop_dist, ca->drawsize);
+		WM_gizmo_set_flag(cagzgroup->dop_dist, WM_GIZMO_HIDDEN, false);
 
 		/* need to set property here for undo. TODO would prefer to do this in _init */
-		WM_gizmo_target_property_def_rna(camgroup->dop_dist, "offset", &camera_ptr, "dof_distance", -1);
+		WM_gizmo_target_property_def_rna(cagzgroup->dop_dist, "offset", &camera_ptr, "dof_distance", -1);
 	}
 	else {
-		WM_gizmo_set_flag(camgroup->dop_dist, WM_GIZMO_HIDDEN, true);
+		WM_gizmo_set_flag(cagzgroup->dop_dist, WM_GIZMO_HIDDEN, true);
 	}
 
 	/* TODO - make focal length/ortho ob_scale_inv widget optional */
@@ -167,14 +167,14 @@ static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *mgroup)
 	const float aspy = (float)scene->r.ysch * scene->r.yasp;
 	const bool is_ortho = (ca->type == CAM_ORTHO);
 	const int sensor_fit = BKE_camera_sensor_fit(ca->sensor_fit, aspx, aspy);
-	wmGizmo *widget = is_ortho ? camgroup->ortho_scale : camgroup->focal_len;
+	wmGizmo *widget = is_ortho ? cagzgroup->ortho_scale : cagzgroup->focal_len;
 	float scale_matrix;
 	if (true) {
 		float offset[3];
 		float aspect[2];
 
 		WM_gizmo_set_flag(widget, WM_GIZMO_HIDDEN, false);
-		WM_gizmo_set_flag(is_ortho ? camgroup->focal_len : camgroup->ortho_scale, WM_GIZMO_HIDDEN, true);
+		WM_gizmo_set_flag(is_ortho ? cagzgroup->focal_len : cagzgroup->ortho_scale, WM_GIZMO_HIDDEN, true);
 
 
 		/* account for lens shifting */
@@ -208,9 +208,9 @@ static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *mgroup)
 	{
 		const char *propname = is_ortho ? "ortho_scale" : "lens";
 		PropertyRNA *prop = RNA_struct_find_property(&camera_ptr, propname);
-		const wmGizmoPropertyType *mpr_prop_type = WM_gizmotype_target_property_find(widget->type, "offset");
+		const wmGizmoPropertyType *gz_prop_type = WM_gizmotype_target_property_find(widget->type, "offset");
 
-		WM_gizmo_target_property_clear_rna_ptr(widget, mpr_prop_type);
+		WM_gizmo_target_property_clear_rna_ptr(widget, gz_prop_type);
 
 		float min, max, range;
 		float step, precision;
@@ -226,21 +226,21 @@ static void WIDGETGROUP_camera_refresh(const bContext *C, wmGizmoGroup *mgroup)
 		         /* Half sensor, intentionally use sensor from camera and not calculated above. */
 		         (0.5f * ((ca->sensor_fit == CAMERA_SENSOR_FIT_HOR) ? ca->sensor_x : ca->sensor_x))));
 
-		WM_gizmo_target_property_def_rna_ptr(widget, mpr_prop_type, &camera_ptr, prop, -1);
+		WM_gizmo_target_property_def_rna_ptr(widget, gz_prop_type, &camera_ptr, prop, -1);
 	}
 
 }
 
 static void WIDGETGROUP_camera_message_subscribe(
-        const bContext *C, wmGizmoGroup *mgroup, struct wmMsgBus *mbus)
+        const bContext *C, wmGizmoGroup *gzgroup, struct wmMsgBus *mbus)
 {
 	ARegion *ar = CTX_wm_region(C);
 	Object *ob = CTX_data_active_object(C);
 	Camera *ca = ob->data;
 
-	wmMsgSubscribeValue msg_sub_value_mpr_tag_refresh = {
+	wmMsgSubscribeValue msg_sub_value_gz_tag_refresh = {
 		.owner = ar,
-		.user_data = mgroup->parent_mmap,
+		.user_data = gzgroup->parent_gzmap,
 		.notify = WM_gizmo_do_msg_notify_tag_refresh,
 	};
 
@@ -270,32 +270,32 @@ static void WIDGETGROUP_camera_message_subscribe(
 		RNA_id_pointer_create(&ca->id, &idptr);
 
 		for (int i = 0; i < ARRAY_SIZE(props); i++) {
-			WM_msg_subscribe_rna(mbus, &idptr, props[i], &msg_sub_value_mpr_tag_refresh, __func__);
+			WM_msg_subscribe_rna(mbus, &idptr, props[i], &msg_sub_value_gz_tag_refresh, __func__);
 		}
 	}
 
 	/* Subscribe to render settings */
 	{
-		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, resolution_x, &msg_sub_value_mpr_tag_refresh);
-		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, resolution_y, &msg_sub_value_mpr_tag_refresh);
-		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, pixel_aspect_x, &msg_sub_value_mpr_tag_refresh);
-		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, pixel_aspect_y, &msg_sub_value_mpr_tag_refresh);
+		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, resolution_x, &msg_sub_value_gz_tag_refresh);
+		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, resolution_y, &msg_sub_value_gz_tag_refresh);
+		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, pixel_aspect_x, &msg_sub_value_gz_tag_refresh);
+		WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, pixel_aspect_y, &msg_sub_value_gz_tag_refresh);
 	}
 }
 
-void VIEW3D_WGT_camera(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_camera(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Camera Widgets";
-	wgt->idname = "VIEW3D_WGT_camera";
+	gzgt->name = "Camera Widgets";
+	gzgt->idname = "VIEW3D_GGT_camera";
 
-	wgt->flag = (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag = (WM_GIZMOGROUPTYPE_PERSISTENT |
 	             WM_GIZMOGROUPTYPE_3D |
 	             WM_GIZMOGROUPTYPE_DEPTH_3D);
 
-	wgt->poll = WIDGETGROUP_camera_poll;
-	wgt->setup = WIDGETGROUP_camera_setup;
-	wgt->refresh = WIDGETGROUP_camera_refresh;
-	wgt->message_subscribe = WIDGETGROUP_camera_message_subscribe;
+	gzgt->poll = WIDGETGROUP_camera_poll;
+	gzgt->setup = WIDGETGROUP_camera_setup;
+	gzgt->refresh = WIDGETGROUP_camera_refresh;
+	gzgt->message_subscribe = WIDGETGROUP_camera_message_subscribe;
 }
 
 /** \} */
@@ -316,12 +316,12 @@ struct CameraViewWidgetGroup {
 
 /* scale callbacks */
 static void gizmo_render_border_prop_matrix_get(
-        const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop,
+        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
         void *value_p)
 {
 	float (*matrix)[4] = value_p;
-	BLI_assert(mpr_prop->type->array_length == 16);
-	struct CameraViewWidgetGroup *viewgroup = mpr_prop->custom_func.user_data;
+	BLI_assert(gz_prop->type->array_length == 16);
+	struct CameraViewWidgetGroup *viewgroup = gz_prop->custom_func.user_data;
 	const rctf *border = viewgroup->state.edit_border;
 
 	unit_m4(matrix);
@@ -332,20 +332,20 @@ static void gizmo_render_border_prop_matrix_get(
 }
 
 static void gizmo_render_border_prop_matrix_set(
-        const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop,
+        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
         const void *value_p)
 {
 	const float (*matrix)[4] = value_p;
-	struct CameraViewWidgetGroup *viewgroup = mpr_prop->custom_func.user_data;
+	struct CameraViewWidgetGroup *viewgroup = gz_prop->custom_func.user_data;
 	rctf *border = viewgroup->state.edit_border;
-	BLI_assert(mpr_prop->type->array_length == 16);
+	BLI_assert(gz_prop->type->array_length == 16);
 
 	BLI_rctf_resize(border, len_v3(matrix[0]), len_v3(matrix[1]));
 	BLI_rctf_recenter(border, matrix[3][0], matrix[3][1]);
 	BLI_rctf_isect(&(rctf){.xmin = 0, .ymin = 0, .xmax = 1, .ymax = 1}, border, border);
 }
 
-static bool WIDGETGROUP_camera_view_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_camera_view_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	Scene *scene = CTX_data_scene(C);
 
@@ -361,7 +361,7 @@ static bool WIDGETGROUP_camera_view_poll(const bContext *C, wmGizmoGroupType *UN
 
 	View3D *v3d = CTX_wm_view3d(C);
 	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
 	{
 		return false;
 	}
@@ -382,11 +382,11 @@ static bool WIDGETGROUP_camera_view_poll(const bContext *C, wmGizmoGroupType *UN
 	return false;
 }
 
-static void WIDGETGROUP_camera_view_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_camera_view_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
 	struct CameraViewWidgetGroup *viewgroup = MEM_mallocN(sizeof(struct CameraViewWidgetGroup), __func__);
 
-	viewgroup->border = WM_gizmo_new("GIZMO_WT_cage_2d", mgroup, NULL);
+	viewgroup->border = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
 
 	RNA_enum_set(viewgroup->border->ptr, "transform",
 	             ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE | ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE);
@@ -394,12 +394,12 @@ static void WIDGETGROUP_camera_view_setup(const bContext *UNUSED(C), wmGizmoGrou
 	RNA_enum_set(viewgroup->border->ptr, "draw_style", ED_GIZMO_CAGE2D_STYLE_BOX);
 
 
-	mgroup->customdata = viewgroup;
+	gzgroup->customdata = viewgroup;
 }
 
-static void WIDGETGROUP_camera_view_draw_prepare(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_camera_view_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	struct CameraViewWidgetGroup *viewgroup = mgroup->customdata;
+	struct CameraViewWidgetGroup *viewgroup = gzgroup->customdata;
 
 	ARegion *ar = CTX_wm_region(C);
 	struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
@@ -413,17 +413,17 @@ static void WIDGETGROUP_camera_view_draw_prepare(const bContext *C, wmGizmoGroup
 		viewgroup->state.view_border = (rctf){.xmin = 0, .ymin = 0, .xmax = ar->winx, .ymax = ar->winy};
 	}
 
-	wmGizmo *mpr = viewgroup->border;
-	unit_m4(mpr->matrix_space);
-	mul_v3_fl(mpr->matrix_space[0], BLI_rctf_size_x(&viewgroup->state.view_border));
-	mul_v3_fl(mpr->matrix_space[1], BLI_rctf_size_y(&viewgroup->state.view_border));
-	mpr->matrix_space[3][0] = viewgroup->state.view_border.xmin;
-	mpr->matrix_space[3][1] = viewgroup->state.view_border.ymin;
+	wmGizmo *gz = viewgroup->border;
+	unit_m4(gz->matrix_space);
+	mul_v3_fl(gz->matrix_space[0], BLI_rctf_size_x(&viewgroup->state.view_border));
+	mul_v3_fl(gz->matrix_space[1], BLI_rctf_size_y(&viewgroup->state.view_border));
+	gz->matrix_space[3][0] = viewgroup->state.view_border.xmin;
+	gz->matrix_space[3][1] = viewgroup->state.view_border.ymin;
 }
 
-static void WIDGETGROUP_camera_view_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_camera_view_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	struct CameraViewWidgetGroup *viewgroup = mgroup->customdata;
+	struct CameraViewWidgetGroup *viewgroup = gzgroup->customdata;
 
 	View3D *v3d = CTX_wm_view3d(C);
 	ARegion *ar = CTX_wm_region(C);
@@ -431,8 +431,8 @@ static void WIDGETGROUP_camera_view_refresh(const bContext *C, wmGizmoGroup *mgr
 	Scene *scene = CTX_data_scene(C);
 
 	{
-		wmGizmo *mpr = viewgroup->border;
-		WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
+		wmGizmo *gz = viewgroup->border;
+		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
 
 		RNA_enum_set(viewgroup->border->ptr, "transform",
 		             ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE | ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE);
@@ -445,7 +445,7 @@ static void WIDGETGROUP_camera_view_refresh(const bContext *C, wmGizmoGroup *mgr
 		}
 
 		WM_gizmo_target_property_def_func(
-		        mpr, "matrix",
+		        gz, "matrix",
 		        &(const struct wmGizmoPropertyFnParams) {
 		            .value_get_fn = gizmo_render_border_prop_matrix_get,
 		            .value_set_fn = gizmo_render_border_prop_matrix_set,
@@ -456,18 +456,18 @@ static void WIDGETGROUP_camera_view_refresh(const bContext *C, wmGizmoGroup *mgr
 
 }
 
-void VIEW3D_WGT_camera_view(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_camera_view(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Camera View Widgets";
-	wgt->idname = "VIEW3D_WGT_camera_view";
+	gzgt->name = "Camera View Widgets";
+	gzgt->idname = "VIEW3D_GGT_camera_view";
 
-	wgt->flag = (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag = (WM_GIZMOGROUPTYPE_PERSISTENT |
 	             WM_GIZMOGROUPTYPE_SCALE);
 
-	wgt->poll = WIDGETGROUP_camera_view_poll;
-	wgt->setup = WIDGETGROUP_camera_view_setup;
-	wgt->draw_prepare = WIDGETGROUP_camera_view_draw_prepare;
-	wgt->refresh = WIDGETGROUP_camera_view_refresh;
+	gzgt->poll = WIDGETGROUP_camera_view_poll;
+	gzgt->setup = WIDGETGROUP_camera_view_setup;
+	gzgt->draw_prepare = WIDGETGROUP_camera_view_draw_prepare;
+	gzgt->refresh = WIDGETGROUP_camera_view_refresh;
 }
 
 /** \} */
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_empty.c b/source/blender/editors/space_view3d/view3d_gizmo_empty.c
index 3b51af5ca15..2913ba245e7 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_empty.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_empty.c
@@ -63,20 +63,20 @@ struct EmptyImageWidgetGroup {
 
 /* translate callbacks */
 static void gizmo_empty_image_prop_matrix_get(
-        const wmGizmo *mpr, wmGizmoProperty *mpr_prop,
+        const wmGizmo *gz, wmGizmoProperty *gz_prop,
         void *value_p)
 {
 	float (*matrix)[4] = value_p;
-	BLI_assert(mpr_prop->type->array_length == 16);
-	struct EmptyImageWidgetGroup *imgroup = mpr_prop->custom_func.user_data;
-	const Object *ob = imgroup->state.ob;
+	BLI_assert(gz_prop->type->array_length == 16);
+	struct EmptyImageWidgetGroup *igzgroup = gz_prop->custom_func.user_data;
+	const Object *ob = igzgroup->state.ob;
 
 	unit_m4(matrix);
 	matrix[0][0] = ob->empty_drawsize;
 	matrix[1][1] = ob->empty_drawsize;
 
 	float dims[2] = {0.0f, 0.0f};
-	RNA_float_get_array(mpr->ptr, "dimensions", dims);
+	RNA_float_get_array(gz->ptr, "dimensions", dims);
 	dims[0] *= ob->empty_drawsize;
 	dims[1] *= ob->empty_drawsize;
 
@@ -85,18 +85,18 @@ static void gizmo_empty_image_prop_matrix_get(
 }
 
 static void gizmo_empty_image_prop_matrix_set(
-        const wmGizmo *mpr, wmGizmoProperty *mpr_prop,
+        const wmGizmo *gz, wmGizmoProperty *gz_prop,
         const void *value_p)
 {
 	const float (*matrix)[4] = value_p;
-	BLI_assert(mpr_prop->type->array_length == 16);
-	struct EmptyImageWidgetGroup *imgroup = mpr_prop->custom_func.user_data;
-	Object *ob = imgroup->state.ob;
+	BLI_assert(gz_prop->type->array_length == 16);
+	struct EmptyImageWidgetGroup *igzgroup = gz_prop->custom_func.user_data;
+	Object *ob = igzgroup->state.ob;
 
 	ob->empty_drawsize = matrix[0][0];
 
 	float dims[2];
-	RNA_float_get_array(mpr->ptr, "dimensions", dims);
+	RNA_float_get_array(gz->ptr, "dimensions", dims);
 	dims[0] *= ob->empty_drawsize;
 	dims[1] *= ob->empty_drawsize;
 
@@ -104,12 +104,12 @@ static void gizmo_empty_image_prop_matrix_set(
 	ob->ima_ofs[1] = (matrix[3][1] - (0.5f * dims[1])) / dims[1];
 }
 
-static bool WIDGETGROUP_empty_image_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_empty_image_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 
 	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
 	{
 		return false;
 	}
@@ -122,36 +122,36 @@ static bool WIDGETGROUP_empty_image_poll(const bContext *C, wmGizmoGroupType *UN
 	return false;
 }
 
-static void WIDGETGROUP_empty_image_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_empty_image_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
-	struct EmptyImageWidgetGroup *imgroup = MEM_mallocN(sizeof(struct EmptyImageWidgetGroup), __func__);
-	imgroup->gizmo = WM_gizmo_new("GIZMO_WT_cage_2d", mgroup, NULL);
-	wmGizmo *mpr = imgroup->gizmo;
-	RNA_enum_set(mpr->ptr, "transform",
+	struct EmptyImageWidgetGroup *igzgroup = MEM_mallocN(sizeof(struct EmptyImageWidgetGroup), __func__);
+	igzgroup->gizmo = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
+	wmGizmo *gz = igzgroup->gizmo;
+	RNA_enum_set(gz->ptr, "transform",
 	             ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE);
 
-	mgroup->customdata = imgroup;
+	gzgroup->customdata = igzgroup;
 
-	WM_gizmo_set_flag(mpr, WM_GIZMO_DRAW_HOVER, true);
+	WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_HOVER, true);
 
-	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-	UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+	UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 }
 
-static void WIDGETGROUP_empty_image_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_empty_image_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	struct EmptyImageWidgetGroup *imgroup = mgroup->customdata;
+	struct EmptyImageWidgetGroup *igzgroup = gzgroup->customdata;
 	Object *ob = CTX_data_active_object(C);
-	wmGizmo *mpr = imgroup->gizmo;
+	wmGizmo *gz = igzgroup->gizmo;
 
-	copy_m4_m4(mpr->matrix_basis, ob->obmat);
+	copy_m4_m4(gz->matrix_basis, ob->obmat);
 
-	RNA_enum_set(mpr->ptr, "transform",
+	RNA_enum_set(gz->ptr, "transform",
 	             ED_GIZMO_CAGE2D_XFORM_FLAG_TRANSLATE |
 	             ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE |
 	             ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE_UNIFORM);
 
-	imgroup->state.ob = ob;
+	igzgroup->state.ob = ob;
 
 	/* Use dimensions for aspect. */
 	if (ob->data != NULL) {
@@ -169,36 +169,36 @@ static void WIDGETGROUP_empty_image_refresh(const bContext *C, wmGizmoGroup *mgr
 		}
 
 		const float dims_max = max_ff(size[0], size[1]);
-		imgroup->state.dims[0] = size[0] / dims_max;
-		imgroup->state.dims[1] = size[1] / dims_max;
+		igzgroup->state.dims[0] = size[0] / dims_max;
+		igzgroup->state.dims[1] = size[1] / dims_max;
 	}
 	else {
-		copy_v2_fl(imgroup->state.dims, 1.0f);
+		copy_v2_fl(igzgroup->state.dims, 1.0f);
 	}
-	RNA_float_set_array(mpr->ptr, "dimensions", imgroup->state.dims);
+	RNA_float_set_array(gz->ptr, "dimensions", igzgroup->state.dims);
 
 	WM_gizmo_target_property_def_func(
-	        mpr, "matrix",
+	        gz, "matrix",
 	        &(const struct wmGizmoPropertyFnParams) {
 	            .value_get_fn = gizmo_empty_image_prop_matrix_get,
 	            .value_set_fn = gizmo_empty_image_prop_matrix_set,
 	            .range_get_fn = NULL,
-	            .user_data = imgroup,
+	            .user_data = igzgroup,
 	        });
 }
 
-void VIEW3D_WGT_empty_image(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_empty_image(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Area Light Widgets";
-	wgt->idname = "VIEW3D_WGT_empty_image";
+	gzgt->name = "Area Light Widgets";
+	gzgt->idname = "VIEW3D_GGT_empty_image";
 
-	wgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
 	              WM_GIZMOGROUPTYPE_3D |
 	              WM_GIZMOGROUPTYPE_DEPTH_3D);
 
-	wgt->poll = WIDGETGROUP_empty_image_poll;
-	wgt->setup = WIDGETGROUP_empty_image_setup;
-	wgt->refresh = WIDGETGROUP_empty_image_refresh;
+	gzgt->poll = WIDGETGROUP_empty_image_poll;
+	gzgt->setup = WIDGETGROUP_empty_image_setup;
+	gzgt->refresh = WIDGETGROUP_empty_image_refresh;
 }
 
 /** \} */
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_forcefield.c b/source/blender/editors/space_view3d/view3d_gizmo_forcefield.c
index d4605bb0c7d..e2a8d2802e7 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_forcefield.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_forcefield.c
@@ -52,12 +52,12 @@
 /** \name Force Field Gizmos
  * \{ */
 
-static bool WIDGETGROUP_forcefield_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_forcefield_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 
 	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
 	{
 		return false;
 	}
@@ -67,26 +67,26 @@ static bool WIDGETGROUP_forcefield_poll(const bContext *C, wmGizmoGroupType *UNU
 	return (ob && ob->pd && ob->pd->forcefield);
 }
 
-static void WIDGETGROUP_forcefield_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_forcefield_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
 	/* only wind effector for now */
 	wmGizmoWrapper *wwrapper = MEM_mallocN(sizeof(wmGizmoWrapper), __func__);
-	mgroup->customdata = wwrapper;
+	gzgroup->customdata = wwrapper;
 
-	wwrapper->gizmo = WM_gizmo_new("GIZMO_WT_arrow_3d", mgroup, NULL);
-	wmGizmo *mpr = wwrapper->gizmo;
-	RNA_enum_set(mpr->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_CONSTRAINED);
-	ED_gizmo_arrow3d_set_ui_range(mpr, -200.0f, 200.0f);
-	ED_gizmo_arrow3d_set_range_fac(mpr, 6.0f);
+	wwrapper->gizmo = WM_gizmo_new("GIZMO_GT_arrow_3d", gzgroup, NULL);
+	wmGizmo *gz = wwrapper->gizmo;
+	RNA_enum_set(gz->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_CONSTRAINED);
+	ED_gizmo_arrow3d_set_ui_range(gz, -200.0f, 200.0f);
+	ED_gizmo_arrow3d_set_range_fac(gz, 6.0f);
 
-	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-	UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+	UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 }
 
-static void WIDGETGROUP_forcefield_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_forcefield_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	wmGizmoWrapper *wwrapper = mgroup->customdata;
-	wmGizmo *mpr = wwrapper->gizmo;
+	wmGizmoWrapper *wwrapper = gzgroup->customdata;
+	wmGizmo *gz = wwrapper->gizmo;
 	Object *ob = CTX_data_active_object(C);
 	PartDeflect *pd = ob->pd;
 
@@ -96,30 +96,30 @@ static void WIDGETGROUP_forcefield_refresh(const bContext *C, wmGizmoGroup *mgro
 		PointerRNA field_ptr;
 
 		RNA_pointer_create(&ob->id, &RNA_FieldSettings, pd, &field_ptr);
-		WM_gizmo_set_matrix_location(mpr, ob->obmat[3]);
-		WM_gizmo_set_matrix_rotation_from_z_axis(mpr, ob->obmat[2]);
-		WM_gizmo_set_matrix_offset_location(mpr, ofs);
-		WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
-		WM_gizmo_target_property_def_rna(mpr, "offset", &field_ptr, "strength", -1);
+		WM_gizmo_set_matrix_location(gz, ob->obmat[3]);
+		WM_gizmo_set_matrix_rotation_from_z_axis(gz, ob->obmat[2]);
+		WM_gizmo_set_matrix_offset_location(gz, ofs);
+		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
+		WM_gizmo_target_property_def_rna(gz, "offset", &field_ptr, "strength", -1);
 	}
 	else {
-		WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, true);
+		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
 	}
 }
 
-void VIEW3D_WGT_force_field(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_force_field(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Force Field Widgets";
-	wgt->idname = "VIEW3D_WGT_force_field";
+	gzgt->name = "Force Field Widgets";
+	gzgt->idname = "VIEW3D_GGT_force_field";
 
-	wgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
 	              WM_GIZMOGROUPTYPE_3D |
 	              WM_GIZMOGROUPTYPE_SCALE |
 	              WM_GIZMOGROUPTYPE_DEPTH_3D);
 
-	wgt->poll = WIDGETGROUP_forcefield_poll;
-	wgt->setup = WIDGETGROUP_forcefield_setup;
-	wgt->refresh = WIDGETGROUP_forcefield_refresh;
+	gzgt->poll = WIDGETGROUP_forcefield_poll;
+	gzgt->setup = WIDGETGROUP_forcefield_setup;
+	gzgt->refresh = WIDGETGROUP_forcefield_refresh;
 }
 
 /** \} */
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_lamp.c b/source/blender/editors/space_view3d/view3d_gizmo_lamp.c
index a872cc96172..057c085b69d 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_lamp.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_lamp.c
@@ -52,11 +52,11 @@
 /** \name Spot Lamp Gizmos
  * \{ */
 
-static bool WIDGETGROUP_lamp_spot_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_lamp_spot_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_CONTEXT)))
 	{
 		return false;
 	}
@@ -70,53 +70,53 @@ static bool WIDGETGROUP_lamp_spot_poll(const bContext *C, wmGizmoGroupType *UNUS
 	return false;
 }
 
-static void WIDGETGROUP_lamp_spot_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_lamp_spot_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
 	wmGizmoWrapper *wwrapper = MEM_mallocN(sizeof(wmGizmoWrapper), __func__);
 
-	wwrapper->gizmo = WM_gizmo_new("GIZMO_WT_arrow_3d", mgroup, NULL);
-	wmGizmo *mpr = wwrapper->gizmo;
-	RNA_enum_set(mpr->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_INVERTED);
+	wwrapper->gizmo = WM_gizmo_new("GIZMO_GT_arrow_3d", gzgroup, NULL);
+	wmGizmo *gz = wwrapper->gizmo;
+	RNA_enum_set(gz->ptr, "transform",  ED_GIZMO_ARROW_XFORM_FLAG_INVERTED);
 
-	mgroup->customdata = wwrapper;
+	gzgroup->customdata = wwrapper;
 
-	ED_gizmo_arrow3d_set_range_fac(mpr, 4.0f);
+	ED_gizmo_arrow3d_set_range_fac(gz, 4.0f);
 
-	UI_GetThemeColor3fv(TH_GIZMO_SECONDARY, mpr->color);
+	UI_GetThemeColor3fv(TH_GIZMO_SECONDARY, gz->color);
 }
 
-static void WIDGETGROUP_lamp_spot_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_lamp_spot_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	wmGizmoWrapper *wwrapper = mgroup->customdata;
-	wmGizmo *mpr = wwrapper->gizmo;
+	wmGizmoWrapper *wwrapper = gzgroup->customdata;
+	wmGizmo *gz = wwrapper->gizmo;
 	Object *ob = CTX_data_active_object(C);
 	Lamp *la = ob->data;
 	float dir[3];
 
 	negate_v3_v3(dir, ob->obmat[2]);
 
-	WM_gizmo_set_matrix_rotation_from_z_axis(mpr, dir);
-	WM_gizmo_set_matrix_location(mpr, ob->obmat[3]);
+	WM_gizmo_set_matrix_rotation_from_z_axis(gz, dir);
+	WM_gizmo_set_matrix_location(gz, ob->obmat[3]);
 
 	/* need to set property here for undo. TODO would prefer to do this in _init */
 	PointerRNA lamp_ptr;
 	const char *propname = "spot_size";
 	RNA_pointer_create(&la->id, &RNA_Light, la, &lamp_ptr);
-	WM_gizmo_target_property_def_rna(mpr, "offset", &lamp_ptr, propname, -1);
+	WM_gizmo_target_property_def_rna(gz, "offset", &lamp_ptr, propname, -1);
 }
 
-void VIEW3D_WGT_lamp_spot(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_lamp_spot(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Spot Light Widgets";
-	wgt->idname = "VIEW3D_WGT_lamp_spot";
+	gzgt->name = "Spot Light Widgets";
+	gzgt->idname = "VIEW3D_GGT_lamp_spot";
 
-	wgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
 	              WM_GIZMOGROUPTYPE_3D |
 	              WM_GIZMOGROUPTYPE_DEPTH_3D);
 
-	wgt->poll = WIDGETGROUP_lamp_spot_poll;
-	wgt->setup = WIDGETGROUP_lamp_spot_setup;
-	wgt->refresh = WIDGETGROUP_lamp_spot_refresh;
+	gzgt->poll = WIDGETGROUP_lamp_spot_poll;
+	gzgt->setup = WIDGETGROUP_lamp_spot_setup;
+	gzgt->refresh = WIDGETGROUP_lamp_spot_refresh;
 }
 
 /** \} */
@@ -128,24 +128,24 @@ void VIEW3D_WGT_lamp_spot(wmGizmoGroupType *wgt)
 
 /* scale callbacks */
 static void gizmo_area_lamp_prop_matrix_get(
-        const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop,
+        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
         void *value_p)
 {
-	BLI_assert(mpr_prop->type->array_length == 16);
+	BLI_assert(gz_prop->type->array_length == 16);
 	float (*matrix)[4] = value_p;
-	const Lamp *la = mpr_prop->custom_func.user_data;
+	const Lamp *la = gz_prop->custom_func.user_data;
 
 	matrix[0][0] = la->area_size;
 	matrix[1][1] = ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_ELLIPSE) ? la->area_sizey : la->area_size;
 }
 
 static void gizmo_area_lamp_prop_matrix_set(
-        const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop,
+        const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop,
         const void *value_p)
 {
 	const float (*matrix)[4] = value_p;
-	BLI_assert(mpr_prop->type->array_length == 16);
-	Lamp *la = mpr_prop->custom_func.user_data;
+	BLI_assert(gz_prop->type->array_length == 16);
+	Lamp *la = gz_prop->custom_func.user_data;
 
 	if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_ELLIPSE)) {
 		la->area_size = len_v3(matrix[0]);
@@ -156,7 +156,7 @@ static void gizmo_area_lamp_prop_matrix_set(
 	}
 }
 
-static bool WIDGETGROUP_lamp_area_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_lamp_area_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 	if (v3d->flag2 & V3D_RENDER_OVERRIDE) {
@@ -171,40 +171,40 @@ static bool WIDGETGROUP_lamp_area_poll(const bContext *C, wmGizmoGroupType *UNUS
 	return false;
 }
 
-static void WIDGETGROUP_lamp_area_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_lamp_area_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
 	wmGizmoWrapper *wwrapper = MEM_mallocN(sizeof(wmGizmoWrapper), __func__);
-	wwrapper->gizmo = WM_gizmo_new("GIZMO_WT_cage_2d", mgroup, NULL);
-	wmGizmo *mpr = wwrapper->gizmo;
-	RNA_enum_set(mpr->ptr, "transform",
+	wwrapper->gizmo = WM_gizmo_new("GIZMO_GT_cage_2d", gzgroup, NULL);
+	wmGizmo *gz = wwrapper->gizmo;
+	RNA_enum_set(gz->ptr, "transform",
 	             ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE);
 
-	mgroup->customdata = wwrapper;
+	gzgroup->customdata = wwrapper;
 
-	WM_gizmo_set_flag(mpr, WM_GIZMO_DRAW_HOVER, true);
+	WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_HOVER, true);
 
-	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-	UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+	UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 }
 
-static void WIDGETGROUP_lamp_area_refresh(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_lamp_area_refresh(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	wmGizmoWrapper *wwrapper = mgroup->customdata;
+	wmGizmoWrapper *wwrapper = gzgroup->customdata;
 	Object *ob = CTX_data_active_object(C);
 	Lamp *la = ob->data;
-	wmGizmo *mpr = wwrapper->gizmo;
+	wmGizmo *gz = wwrapper->gizmo;
 
-	copy_m4_m4(mpr->matrix_basis, ob->obmat);
+	copy_m4_m4(gz->matrix_basis, ob->obmat);
 
 	int flag = ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE;
 	if (ELEM(la->area_shape, LA_AREA_SQUARE, LA_AREA_DISK)) {
 		flag |= ED_GIZMO_CAGE2D_XFORM_FLAG_SCALE_UNIFORM;
 	}
-	RNA_enum_set(mpr->ptr, "transform", flag);
+	RNA_enum_set(gz->ptr, "transform", flag);
 
 	/* need to set property here for undo. TODO would prefer to do this in _init */
 	WM_gizmo_target_property_def_func(
-	        mpr, "matrix",
+	        gz, "matrix",
 	        &(const struct wmGizmoPropertyFnParams) {
 	            .value_get_fn = gizmo_area_lamp_prop_matrix_get,
 	            .value_set_fn = gizmo_area_lamp_prop_matrix_set,
@@ -213,18 +213,18 @@ static void WIDGETGROUP_lamp_area_refresh(const bContext *C, wmGizmoGroup *mgrou
 	        });
 }
 
-void VIEW3D_WGT_lamp_area(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_lamp_area(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Area Light Widgets";
-	wgt->idname = "VIEW3D_WGT_lamp_area";
+	gzgt->name = "Area Light Widgets";
+	gzgt->idname = "VIEW3D_GGT_lamp_area";
 
-	wgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
 	              WM_GIZMOGROUPTYPE_3D |
 	              WM_GIZMOGROUPTYPE_DEPTH_3D);
 
-	wgt->poll = WIDGETGROUP_lamp_area_poll;
-	wgt->setup = WIDGETGROUP_lamp_area_setup;
-	wgt->refresh = WIDGETGROUP_lamp_area_refresh;
+	gzgt->poll = WIDGETGROUP_lamp_area_poll;
+	gzgt->setup = WIDGETGROUP_lamp_area_setup;
+	gzgt->refresh = WIDGETGROUP_lamp_area_refresh;
 }
 
 /** \} */
@@ -235,7 +235,7 @@ void VIEW3D_WGT_lamp_area(wmGizmoGroupType *wgt)
 /** \name Lamp Target Gizmo
  * \{ */
 
-static bool WIDGETGROUP_lamp_target_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_lamp_target_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 	if (v3d->flag2 & V3D_RENDER_OVERRIDE) {
@@ -258,50 +258,50 @@ static bool WIDGETGROUP_lamp_target_poll(const bContext *C, wmGizmoGroupType *UN
 	return false;
 }
 
-static void WIDGETGROUP_lamp_target_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_lamp_target_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
 	wmGizmoWrapper *wwrapper = MEM_mallocN(sizeof(wmGizmoWrapper), __func__);
-	wwrapper->gizmo = WM_gizmo_new("GIZMO_WT_grab_3d", mgroup, NULL);
-	wmGizmo *mpr = wwrapper->gizmo;
+	wwrapper->gizmo = WM_gizmo_new("GIZMO_GT_grab_3d", gzgroup, NULL);
+	wmGizmo *gz = wwrapper->gizmo;
 
-	mgroup->customdata = wwrapper;
+	gzgroup->customdata = wwrapper;
 
-	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, mpr->color);
-	UI_GetThemeColor3fv(TH_GIZMO_HI, mpr->color_hi);
+	UI_GetThemeColor3fv(TH_GIZMO_PRIMARY, gz->color);
+	UI_GetThemeColor3fv(TH_GIZMO_HI, gz->color_hi);
 
-	mpr->scale_basis = 0.06f;
+	gz->scale_basis = 0.06f;
 
 	wmOperatorType *ot = WM_operatortype_find("OBJECT_OT_transform_axis_target", true);
 
-	RNA_enum_set(mpr->ptr, "draw_options",
+	RNA_enum_set(gz->ptr, "draw_options",
 	             ED_GIZMO_GRAB_DRAW_FLAG_FILL | ED_GIZMO_GRAB_DRAW_FLAG_ALIGN_VIEW);
 
-	WM_gizmo_operator_set(mpr, 0, ot, NULL);
+	WM_gizmo_operator_set(gz, 0, ot, NULL);
 }
 
-static void WIDGETGROUP_lamp_target_draw_prepare(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_lamp_target_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	wmGizmoWrapper *wwrapper = mgroup->customdata;
+	wmGizmoWrapper *wwrapper = gzgroup->customdata;
 	Object *ob = CTX_data_active_object(C);
-	wmGizmo *mpr = wwrapper->gizmo;
+	wmGizmo *gz = wwrapper->gizmo;
 
-	copy_m4_m4(mpr->matrix_basis, ob->obmat);
-	unit_m4(mpr->matrix_offset);
-	mpr->matrix_offset[3][2] = -2.4f / mpr->scale_basis;
-	WM_gizmo_set_flag(mpr, WM_GIZMO_DRAW_OFFSET_SCALE, true);
+	copy_m4_m4(gz->matrix_basis, ob->obmat);
+	unit_m4(gz->matrix_offset);
+	gz->matrix_offset[3][2] = -2.4f / gz->scale_basis;
+	WM_gizmo_set_flag(gz, WM_GIZMO_DRAW_OFFSET_SCALE, true);
 }
 
-void VIEW3D_WGT_lamp_target(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_lamp_target(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Target Light Widgets";
-	wgt->idname = "VIEW3D_WGT_lamp_target";
+	gzgt->name = "Target Light Widgets";
+	gzgt->idname = "VIEW3D_GGT_lamp_target";
 
-	wgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
 	              WM_GIZMOGROUPTYPE_3D);
 
-	wgt->poll = WIDGETGROUP_lamp_target_poll;
-	wgt->setup = WIDGETGROUP_lamp_target_setup;
-	wgt->draw_prepare = WIDGETGROUP_lamp_target_draw_prepare;
+	gzgt->poll = WIDGETGROUP_lamp_target_poll;
+	gzgt->setup = WIDGETGROUP_lamp_target_setup;
+	gzgt->draw_prepare = WIDGETGROUP_lamp_target_draw_prepare;
 }
 
 /** \} */
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_navigate.c b/source/blender/editors/space_view3d/view3d_gizmo_navigate.c
index f4a8bad7e30..388d9a29eff 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_navigate.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_navigate.c
@@ -134,28 +134,28 @@ struct NavigateGizmoInfo {
 struct NavigateGizmoInfo g_navigate_params[MPR_TOTAL] = {
 	{
 		.opname = "VIEW3D_OT_move",
-		.gizmo = "GIZMO_WT_button_2d",
+		.gizmo = "GIZMO_GT_button_2d",
 		.SHAPE_VARS(shape_pan),
 	}, {
 		.opname = "VIEW3D_OT_rotate",
-		.gizmo = "VIEW3D_WT_navigate_rotate",
+		.gizmo = "VIEW3D_GT_navigate_rotate",
 		.shape = NULL,
 		.shape_size = 0,
 	}, {
 		.opname = "VIEW3D_OT_zoom",
-		.gizmo = "GIZMO_WT_button_2d",
+		.gizmo = "GIZMO_GT_button_2d",
 		.SHAPE_VARS(shape_zoom),
 	}, {
 		.opname = "VIEW3D_OT_view_persportho",
-		.gizmo = "GIZMO_WT_button_2d",
+		.gizmo = "GIZMO_GT_button_2d",
 		.SHAPE_VARS(shape_persp),
 	}, {
 		.opname = "VIEW3D_OT_view_persportho",
-		.gizmo = "GIZMO_WT_button_2d",
+		.gizmo = "GIZMO_GT_button_2d",
 		.SHAPE_VARS(shape_ortho),
 	}, {
 		.opname = "VIEW3D_OT_view_camera",
-		.gizmo = "GIZMO_WT_button_2d",
+		.gizmo = "GIZMO_GT_button_2d",
 		.SHAPE_VARS(shape_camera),
 	},
 };
@@ -163,7 +163,7 @@ struct NavigateGizmoInfo g_navigate_params[MPR_TOTAL] = {
 #undef SHAPE_VARS
 
 struct NavigateWidgetGroup {
-	wmGizmo *mpr_array[MPR_TOTAL];
+	wmGizmo *gz_array[MPR_TOTAL];
 	/* Store the view state to check for changes. */
 	struct {
 		rcti rect_visible;
@@ -176,12 +176,12 @@ struct NavigateWidgetGroup {
 	int region_size[2];
 };
 
-static bool WIDGETGROUP_navigate_poll(const bContext *C, wmGizmoGroupType *UNUSED(wgt))
+static bool WIDGETGROUP_navigate_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
 {
 	View3D *v3d = CTX_wm_view3d(C);
 	if (((U.uiflag & USER_SHOW_GIZMO_AXIS) == 0) ||
 	    (v3d->flag2 & V3D_RENDER_OVERRIDE) ||
-	    (v3d->mpr_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE)))
+	    (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE)))
 	{
 		return false;
 	}
@@ -189,7 +189,7 @@ static bool WIDGETGROUP_navigate_poll(const bContext *C, wmGizmoGroupType *UNUSE
 
 }
 
-static void WIDGETGROUP_navigate_setup(const bContext *UNUSED(C), wmGizmoGroup *mgroup)
+static void WIDGETGROUP_navigate_setup(const bContext *UNUSED(C), wmGizmoGroup *gzgroup)
 {
 	struct NavigateWidgetGroup *navgroup = MEM_callocN(sizeof(struct NavigateWidgetGroup), __func__);
 
@@ -201,53 +201,53 @@ static void WIDGETGROUP_navigate_setup(const bContext *UNUSED(C), wmGizmoGroup *
 
 	for (int i = 0; i < MPR_TOTAL; i++) {
 		const struct NavigateGizmoInfo *info = &g_navigate_params[i];
-		navgroup->mpr_array[i] = WM_gizmo_new(info->gizmo, mgroup, NULL);
-		wmGizmo *mpr = navgroup->mpr_array[i];
-		mpr->flag |= WM_GIZMO_GRAB_CURSOR | WM_GIZMO_DRAW_MODAL;
-		mpr->color[3] = 0.2f;
-		mpr->color_hi[3] = 0.4f;
+		navgroup->gz_array[i] = WM_gizmo_new(info->gizmo, gzgroup, NULL);
+		wmGizmo *gz = navgroup->gz_array[i];
+		gz->flag |= WM_GIZMO_GRAB_CURSOR | WM_GIZMO_DRAW_MODAL;
+		gz->color[3] = 0.2f;
+		gz->color_hi[3] = 0.4f;
 
 		/* may be overwritten later */
-		mpr->scale_basis = (GIZMO_SIZE * GIZMO_MINI_FAC) / 2;
+		gz->scale_basis = (GIZMO_SIZE * GIZMO_MINI_FAC) / 2;
 		if (info->shape != NULL) {
-			PropertyRNA *prop = RNA_struct_find_property(mpr->ptr, "shape");
+			PropertyRNA *prop = RNA_struct_find_property(gz->ptr, "shape");
 			RNA_property_string_set_bytes(
-			        mpr->ptr, prop,
+			        gz->ptr, prop,
 			        (const char *)info->shape, info->shape_size);
-			RNA_enum_set(mpr->ptr, "draw_options", ED_GIZMO_BUTTON_SHOW_OUTLINE);
+			RNA_enum_set(gz->ptr, "draw_options", ED_GIZMO_BUTTON_SHOW_OUTLINE);
 		}
 
 		wmOperatorType *ot = WM_operatortype_find(info->opname, true);
-		WM_gizmo_operator_set(mpr, 0, ot, NULL);
+		WM_gizmo_operator_set(gz, 0, ot, NULL);
 	}
 
 	{
-		wmGizmo *mpr = navgroup->mpr_array[MPR_CAMERA];
-		WM_gizmo_operator_set(mpr, 0, ot_view_camera, NULL);
+		wmGizmo *gz = navgroup->gz_array[MPR_CAMERA];
+		WM_gizmo_operator_set(gz, 0, ot_view_camera, NULL);
 	}
 
 	/* Click only buttons (not modal). */
 	{
-		int mpr_ids[] = {MPR_PERSP, MPR_ORTHO, MPR_CAMERA};
-		for (int i = 0; i < ARRAY_SIZE(mpr_ids); i++) {
-			wmGizmo *mpr = navgroup->mpr_array[mpr_ids[i]];
-			RNA_boolean_set(mpr->ptr, "show_drag", false);
+		int gz_ids[] = {MPR_PERSP, MPR_ORTHO, MPR_CAMERA};
+		for (int i = 0; i < ARRAY_SIZE(gz_ids); i++) {
+			wmGizmo *gz = navgroup->gz_array[gz_ids[i]];
+			RNA_boolean_set(gz->ptr, "show_drag", false);
 		}
 	}
 
 	/* Modal operators, don't use initial mouse location since we're clicking on a button. */
 	{
-		int mpr_ids[] = {MPR_MOVE, MPR_ROTATE, MPR_ZOOM};
-		for (int i = 0; i < ARRAY_SIZE(mpr_ids); i++) {
-			wmGizmo *mpr = navgroup->mpr_array[mpr_ids[i]];
-			wmGizmoOpElem *mpop = WM_gizmo_operator_get(mpr, 0);
+		int gz_ids[] = {MPR_MOVE, MPR_ROTATE, MPR_ZOOM};
+		for (int i = 0; i < ARRAY_SIZE(gz_ids); i++) {
+			wmGizmo *gz = navgroup->gz_array[gz_ids[i]];
+			wmGizmoOpElem *mpop = WM_gizmo_operator_get(gz, 0);
 			RNA_boolean_set(&mpop->ptr, "use_mouse_init", false);
 		}
 	}
 
 	{
-		wmGizmo *mpr = navgroup->mpr_array[MPR_ROTATE];
-		mpr->scale_basis = GIZMO_SIZE / 2;
+		wmGizmo *gz = navgroup->gz_array[MPR_ROTATE];
+		gz->scale_basis = GIZMO_SIZE / 2;
 		char mapping[6] = {
 			RV3D_VIEW_LEFT,
 			RV3D_VIEW_RIGHT,
@@ -258,25 +258,25 @@ static void WIDGETGROUP_navigate_setup(const bContext *UNUSED(C), wmGizmoGroup *
 		};
 
 		for (int part_index = 0; part_index < 6; part_index += 1) {
-			PointerRNA *ptr = WM_gizmo_operator_set(mpr, part_index + 1, ot_view_axis, NULL);
+			PointerRNA *ptr = WM_gizmo_operator_set(gz, part_index + 1, ot_view_axis, NULL);
 			RNA_enum_set(ptr, "type", mapping[part_index]);
 		}
 
 		/* When dragging an axis, use this instead. */
-		mpr->drag_part = 0;
+		gz->drag_part = 0;
 	}
 
-	mgroup->customdata = navgroup;
+	gzgroup->customdata = navgroup;
 }
 
-static void WIDGETGROUP_navigate_draw_prepare(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_navigate_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
 {
-	struct NavigateWidgetGroup *navgroup = mgroup->customdata;
+	struct NavigateWidgetGroup *navgroup = gzgroup->customdata;
 	ARegion *ar = CTX_wm_region(C);
 	const RegionView3D *rv3d = ar->regiondata;
 
 	for (int i = 0; i < 3; i++) {
-		copy_v3_v3(navgroup->mpr_array[MPR_ROTATE]->matrix_offset[i], rv3d->viewmat[i]);
+		copy_v3_v3(navgroup->gz_array[MPR_ROTATE]->matrix_offset[i], rv3d->viewmat[i]);
 	}
 
 	rcti rect_visible;
@@ -312,60 +312,60 @@ static void WIDGETGROUP_navigate_draw_prepare(const bContext *C, wmGizmoGroup *m
 		rect_visible.ymax - icon_offset_mini * 0.75f,
 	};
 
-	wmGizmo *mpr;
+	wmGizmo *gz;
 
-	for (uint i = 0; i < ARRAY_SIZE(navgroup->mpr_array); i++) {
-		mpr = navgroup->mpr_array[i];
-		WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, true);
+	for (uint i = 0; i < ARRAY_SIZE(navgroup->gz_array); i++) {
+		gz = navgroup->gz_array[i];
+		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
 	}
 
 	/* RV3D_LOCKED or Camera: only show supported buttons. */
 	if (show_rotate) {
-		mpr = navgroup->mpr_array[MPR_ROTATE];
-		mpr->matrix_basis[3][0] = co_rotate[0];
-		mpr->matrix_basis[3][1] = co_rotate[1];
-		WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
+		gz = navgroup->gz_array[MPR_ROTATE];
+		gz->matrix_basis[3][0] = co_rotate[0];
+		gz->matrix_basis[3][1] = co_rotate[1];
+		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
 	}
 
 	int icon_mini_slot = 0;
 
-	mpr = navgroup->mpr_array[MPR_ZOOM];
-	mpr->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
-	mpr->matrix_basis[3][1] = co[1];
-	WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
+	gz = navgroup->gz_array[MPR_ZOOM];
+	gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
+	gz->matrix_basis[3][1] = co[1];
+	WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
 
-	mpr = navgroup->mpr_array[MPR_MOVE];
-	mpr->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
-	mpr->matrix_basis[3][1] = co[1];
-	WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
+	gz = navgroup->gz_array[MPR_MOVE];
+	gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
+	gz->matrix_basis[3][1] = co[1];
+	WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
 
 	if ((rv3d->viewlock & RV3D_LOCKED) == 0) {
-		mpr = navgroup->mpr_array[MPR_CAMERA];
-		mpr->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
-		mpr->matrix_basis[3][1] = co[1];
-		WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
+		gz = navgroup->gz_array[MPR_CAMERA];
+		gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
+		gz->matrix_basis[3][1] = co[1];
+		WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
 
 		if (navgroup->state.rv3d.is_camera == false) {
-			mpr = navgroup->mpr_array[rv3d->is_persp ? MPR_PERSP : MPR_ORTHO];
-			mpr->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
-			mpr->matrix_basis[3][1] = co[1];
-			WM_gizmo_set_flag(mpr, WM_GIZMO_HIDDEN, false);
+			gz = navgroup->gz_array[rv3d->is_persp ? MPR_PERSP : MPR_ORTHO];
+			gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
+			gz->matrix_basis[3][1] = co[1];
+			WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
 		}
 	}
 }
 
-void VIEW3D_WGT_navigate(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_navigate(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "View3D Navigate";
-	wgt->idname = "VIEW3D_WGT_navigate";
+	gzgt->name = "View3D Navigate";
+	gzgt->idname = "VIEW3D_GGT_navigate";
 
-	wgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
+	gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT |
 	              WM_GIZMOGROUPTYPE_SCALE |
 	              WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL);
 
-	wgt->poll = WIDGETGROUP_navigate_poll;
-	wgt->setup = WIDGETGROUP_navigate_setup;
-	wgt->draw_prepare = WIDGETGROUP_navigate_draw_prepare;
+	gzgt->poll = WIDGETGROUP_navigate_poll;
+	gzgt->setup = WIDGETGROUP_navigate_setup;
+	gzgt->draw_prepare = WIDGETGROUP_navigate_draw_prepare;
 }
 
 /** \} */
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_navigate_type.c b/source/blender/editors/space_view3d/view3d_gizmo_navigate_type.c
index 041fe343526..f296c2ee874 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_navigate_type.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_navigate_type.c
@@ -168,9 +168,9 @@ static void draw_xyz_wire(
 	immEnd();
 }
 
-static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool UNUSED(select))
+static void axis_geom_draw(const wmGizmo *gz, const float color[4], const bool UNUSED(select))
 {
-	GPU_line_width(mpr->line_width);
+	GPU_line_width(gz->line_width);
 
 	Gwn_VertFormat *format = immVertexFormat();
 	const uint pos_id = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 3, GWN_FETCH_FLOAT);
@@ -182,12 +182,12 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 		char axis;
 		char is_pos;
 	} axis_order[6] = {
-		{-mpr->matrix_offset[0][2], 0, 0, false},
-		{+mpr->matrix_offset[0][2], 1, 0, true},
-		{-mpr->matrix_offset[1][2], 2, 1, false},
-		{+mpr->matrix_offset[1][2], 3, 1, true},
-		{-mpr->matrix_offset[2][2], 4, 2, false},
-		{+mpr->matrix_offset[2][2], 5, 2, true},
+		{-gz->matrix_offset[0][2], 0, 0, false},
+		{+gz->matrix_offset[0][2], 1, 0, true},
+		{-gz->matrix_offset[1][2], 2, 1, false},
+		{+gz->matrix_offset[1][2], 3, 1, true},
+		{-gz->matrix_offset[2][2], 4, 2, false},
+		{+gz->matrix_offset[2][2], 5, 2, true},
 	};
 	qsort(&axis_order, ARRAY_SIZE(axis_order), sizeof(axis_order[0]), BLI_sortutil_cmp_float);
 
@@ -196,13 +196,13 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 	static const float axis_black[4] = {0, 0, 0, 1};
 	static float axis_color[3][4];
 	gpuPushMatrix();
-	gpuMultMatrix(mpr->matrix_offset);
+	gpuMultMatrix(gz->matrix_offset);
 
 	bool draw_center_done = false;
 
 	int axis_align = -1;
 	for (int axis = 0; axis < 3; axis++) {
-		if (len_squared_v2(mpr->matrix_offset[axis]) < 1e-6f) {
+		if (len_squared_v2(gz->matrix_offset[axis]) < 1e-6f) {
 			axis_align = axis;
 			break;
 		}
@@ -212,7 +212,7 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 		const int index = axis_order[axis_index].index;
 		const int axis = axis_order[axis_index].axis;
 		const bool is_pos = axis_order[axis_index].is_pos;
-		const bool is_highlight = index + 1 == mpr->highlight_part;
+		const bool is_highlight = index + 1 == gz->highlight_part;
 
 		/* Draw slightly before, so axis aligned arrows draw ontop. */
 		if ((draw_center_done == false) && (axis_order[axis_index].depth > -0.01f)) {
@@ -223,7 +223,7 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 				immUniformColor4fv(color);
 				imm_draw_circle_fill_3d(pos_id, 0, 0, 1.0f, DIAL_RESOLUTION);
 				gpuPushMatrix();
-				gpuMultMatrix(mpr->matrix_offset);
+				gpuMultMatrix(gz->matrix_offset);
 			}
 			draw_center_done = true;
 		}
@@ -237,7 +237,7 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 		bool ok = true;
 
 		/* skip view align axis */
-		if ((axis_align == axis) && (mpr->matrix_offset[axis][2] > 0.0f) == is_pos) {
+		if ((axis_align == axis) && (gz->matrix_offset[axis][2] > 0.0f) == is_pos) {
 			ok = false;
 		}
 		if (ok) {
@@ -291,7 +291,7 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 			if (is_pos) {
 				GPU_line_width(1.0f);
 				float m3[3][3];
-				copy_m3_m4(m3, mpr->matrix_offset);
+				copy_m3_m4(m3, gz->matrix_offset);
 				immUniformColor4fv(is_highlight ? axis_black : axis_highlight);
 				draw_xyz_wire(pos_id, m3, v_final, 1.0, axis);
 			}
@@ -303,17 +303,17 @@ static void axis_geom_draw(const wmGizmo *mpr, const float color[4], const bool
 }
 
 static void axis3d_draw_intern(
-        const bContext *UNUSED(C), wmGizmo *mpr,
+        const bContext *UNUSED(C), wmGizmo *gz,
         const bool select, const bool highlight)
 {
-	const float *color = highlight ? mpr->color_hi : mpr->color;
+	const float *color = highlight ? gz->color_hi : gz->color;
 	float matrix_final[4][4];
 	float matrix_unit[4][4];
 
 	unit_m4(matrix_unit);
 
 	WM_gizmo_calc_matrix_final_params(
-	        mpr,
+	        gz,
 	        &((struct WM_GizmoMatrixParams) {
 	            .matrix_offset = matrix_unit,
 	        }), matrix_final);
@@ -322,29 +322,29 @@ static void axis3d_draw_intern(
 	gpuMultMatrix(matrix_final);
 
 	GPU_blend(true);
-	axis_geom_draw(mpr, color, select);
+	axis_geom_draw(gz, color, select);
 	GPU_blend(false);
 	gpuPopMatrix();
 }
 
-static void gizmo_axis_draw(const bContext *C, wmGizmo *mpr)
+static void gizmo_axis_draw(const bContext *C, wmGizmo *gz)
 {
-	const bool is_modal = mpr->state & WM_GIZMO_STATE_MODAL;
-	const bool is_highlight = (mpr->state & WM_GIZMO_STATE_HIGHLIGHT) != 0;
+	const bool is_modal = gz->state & WM_GIZMO_STATE_MODAL;
+	const bool is_highlight = (gz->state & WM_GIZMO_STATE_HIGHLIGHT) != 0;
 
 	(void)is_modal;
 
 	GPU_blend(true);
-	axis3d_draw_intern(C, mpr, false, is_highlight);
+	axis3d_draw_intern(C, gz, false, is_highlight);
 	GPU_blend(false);
 }
 
 static int gizmo_axis_test_select(
-        bContext *UNUSED(C), wmGizmo *mpr, const wmEvent *event)
+        bContext *UNUSED(C), wmGizmo *gz, const wmEvent *event)
 {
 	float point_local[2] = {UNPACK2(event->mval)};
-	sub_v2_v2(point_local, mpr->matrix_basis[3]);
-	mul_v2_fl(point_local, 1.0f / (mpr->scale_basis * UI_DPI_FAC));
+	sub_v2_v2(point_local, gz->matrix_basis[3]);
+	mul_v2_fl(point_local, 1.0f / (gz->scale_basis * UI_DPI_FAC));
 
 	const float len_sq = len_squared_v2(point_local);
 	if (len_sq > 1.0) {
@@ -358,14 +358,14 @@ static int gizmo_axis_test_select(
 	for (int i = 0; i < 3; i++) {
 		for (int is_pos = 0; is_pos < 2; is_pos++) {
 			float co[2] = {
-				mpr->matrix_offset[i][0] * (is_pos ? 1 : -1),
-				mpr->matrix_offset[i][1] * (is_pos ? 1 : -1),
+				gz->matrix_offset[i][0] * (is_pos ? 1 : -1),
+				gz->matrix_offset[i][1] * (is_pos ? 1 : -1),
 			};
 
 			bool ok = true;
 
 			/* Check if we're viewing on an axis, there is no point to clicking on the current axis so show the reverse. */
-			if (len_squared_v2(co) < 1e-6f && (mpr->matrix_offset[i][2] > 0.0f) == is_pos) {
+			if (len_squared_v2(co) < 1e-6f && (gz->matrix_offset[i][2] > 0.0f) == is_pos) {
 				ok = false;
 			}
 
@@ -384,7 +384,7 @@ static int gizmo_axis_test_select(
 		return part_best;
 	}
 
-	/* The 'mpr->scale_final' is already applied when projecting. */
+	/* The 'gz->scale_final' is already applied when projecting. */
 	if (len_sq < 1.0f) {
 		return 0;
 	}
@@ -392,23 +392,23 @@ static int gizmo_axis_test_select(
 	return -1;
 }
 
-static int gizmo_axis_cursor_get(wmGizmo *mpr)
+static int gizmo_axis_cursor_get(wmGizmo *gz)
 {
-	if (mpr->highlight_part > 0) {
+	if (gz->highlight_part > 0) {
 		return CURSOR_EDIT;
 	}
 	return BC_NSEW_SCROLLCURSOR;
 }
 
-void VIEW3D_WT_navigate_rotate(wmGizmoType *wt)
+void VIEW3D_GT_navigate_rotate(wmGizmoType *gzt)
 {
 	/* identifiers */
-	wt->idname = "VIEW3D_WT_navigate_rotate";
+	gzt->idname = "VIEW3D_GT_navigate_rotate";
 
 	/* api callbacks */
-	wt->draw = gizmo_axis_draw;
-	wt->test_select = gizmo_axis_test_select;
-	wt->cursor_get = gizmo_axis_cursor_get;
+	gzt->draw = gizmo_axis_draw;
+	gzt->test_select = gizmo_axis_test_select;
+	gzt->cursor_get = gizmo_axis_cursor_get;
 
-	wt->struct_size = sizeof(wmGizmo);
+	gzt->struct_size = sizeof(wmGizmo);
 }
diff --git a/source/blender/editors/space_view3d/view3d_gizmo_ruler.c b/source/blender/editors/space_view3d/view3d_gizmo_ruler.c
index ac6a984bea5..db7ba040b3b 100644
--- a/source/blender/editors/space_view3d/view3d_gizmo_ruler.c
+++ b/source/blender/editors/space_view3d/view3d_gizmo_ruler.c
@@ -68,7 +68,7 @@
 #include "BLF_api.h"
 
 
-static const char *view3d_wgt_ruler_id = "VIEW3D_WGT_ruler";
+static const char *view3d_gzgt_ruler_id = "VIEW3D_GGT_ruler";
 
 
 #define MVAL_MAX_PX_DIST 12.0f
@@ -123,7 +123,7 @@ typedef struct RulerInfo {
 /* Ruler Item (two or three points) */
 
 typedef struct RulerItem {
-	wmGizmo mpr;
+	wmGizmo gz;
 
 	/* worldspace coords, middle being optional */
 	float co[3][3];
@@ -143,18 +143,18 @@ typedef struct RulerInteraction {
 /** \name Internal Ruler Utilities
  * \{ */
 
-static RulerItem *ruler_item_add(wmGizmoGroup *mgroup)
+static RulerItem *ruler_item_add(wmGizmoGroup *gzgroup)
 {
 	/* could pass this as an arg */
-	const wmGizmoType *wt_ruler = WM_gizmotype_find("VIEW3D_WT_ruler_item", true);
-	RulerItem *ruler_item = (RulerItem *)WM_gizmo_new_ptr(wt_ruler, mgroup, NULL);
-	WM_gizmo_set_flag(&ruler_item->mpr, WM_GIZMO_DRAW_MODAL, true);
+	const wmGizmoType *gzt_ruler = WM_gizmotype_find("VIEW3D_GT_ruler_item", true);
+	RulerItem *ruler_item = (RulerItem *)WM_gizmo_new_ptr(gzt_ruler, gzgroup, NULL);
+	WM_gizmo_set_flag(&ruler_item->gz, WM_GIZMO_DRAW_MODAL, true);
 	return ruler_item;
 }
 
-static void ruler_item_remove(bContext *C, wmGizmoGroup *mgroup, RulerItem *ruler_item)
+static void ruler_item_remove(bContext *C, wmGizmoGroup *gzgroup, RulerItem *ruler_item)
 {
-	WM_gizmo_unlink(&mgroup->gizmos, mgroup->parent_mmap, &ruler_item->mpr, C);
+	WM_gizmo_unlink(&gzgroup->gizmos, gzgroup->parent_gzmap, &ruler_item->gz, C);
 }
 
 static void ruler_item_as_string(RulerItem *ruler_item, UnitSettings *unit,
@@ -192,10 +192,10 @@ static void ruler_item_as_string(RulerItem *ruler_item, UnitSettings *unit,
 }
 
 static bool view3d_ruler_pick(
-        wmGizmoGroup *mgroup, RulerItem *ruler_item, const float mval[2],
+        wmGizmoGroup *gzgroup, RulerItem *ruler_item, const float mval[2],
         int *r_co_index)
 {
-	RulerInfo *ruler_info = mgroup->customdata;
+	RulerInfo *ruler_info = gzgroup->customdata;
 	ARegion *ar = ruler_info->ar;
 	bool found = false;
 
@@ -304,7 +304,7 @@ static bool view3d_ruler_item_mousemove(
         RulerInfo *ruler_info, RulerItem *ruler_item, const int mval[2],
         const bool do_thickness, const bool do_snap)
 {
-	RulerInteraction *inter = ruler_item->mpr.interaction_data;
+	RulerInteraction *inter = ruler_item->gz.interaction_data;
 	const float eps_bias = 0.0002f;
 	float dist_px = MVAL_MAX_PX_DIST * U.pixelsize;  /* snap dist */
 
@@ -380,9 +380,9 @@ static bool view3d_ruler_item_mousemove(
  * \{ */
 
 #define RULER_ID "RulerData3D"
-static bool view3d_ruler_to_gpencil(bContext *C, wmGizmoGroup *mgroup)
+static bool view3d_ruler_to_gpencil(bContext *C, wmGizmoGroup *gzgroup)
 {
-	// RulerInfo *ruler_info = mgroup->customdata;
+	// RulerInfo *ruler_info = gzgroup->customdata;
 	Main *bmain = CTX_data_main(C);
 	Scene *scene = CTX_data_scene(C);
 	bGPDlayer *gpl;
@@ -419,7 +419,7 @@ static bool view3d_ruler_to_gpencil(bContext *C, wmGizmoGroup *mgroup)
 	gpf = BKE_gpencil_layer_getframe(gpl, CFRA, true);
 	BKE_gpencil_free_strokes(gpf);
 
-	for (ruler_item = mgroup->gizmos.first; ruler_item; ruler_item = (RulerItem *)ruler_item->mpr.next) {
+	for (ruler_item = gzgroup->gizmos.first; ruler_item; ruler_item = (RulerItem *)ruler_item->gz.next) {
 		bGPDspoint *pt;
 		int j;
 
@@ -457,7 +457,7 @@ static bool view3d_ruler_to_gpencil(bContext *C, wmGizmoGroup *mgroup)
 	return changed;
 }
 
-static bool view3d_ruler_from_gpencil(const bContext *C, wmGizmoGroup *mgroup)
+static bool view3d_ruler_from_gpencil(const bContext *C, wmGizmoGroup *gzgroup)
 {
 	Scene *scene = CTX_data_scene(C);
 	bool changed = false;
@@ -476,7 +476,7 @@ static bool view3d_ruler_from_gpencil(const bContext *C, wmGizmoGroup *mgroup)
 					int j;
 					RulerItem *ruler_item = NULL;
 					if (gps->totpoints == 3) {
-						ruler_item = ruler_item_add(mgroup);
+						ruler_item = ruler_item_add(gzgroup);
 						for (j = 0; j < 3; j++) {
 							copy_v3_v3(ruler_item->co[j], &pt->x);
 							pt++;
@@ -485,7 +485,7 @@ static bool view3d_ruler_from_gpencil(const bContext *C, wmGizmoGroup *mgroup)
 						changed = true;
 					}
 					else if (gps->totpoints == 2) {
-						ruler_item = ruler_item_add(mgroup);
+						ruler_item = ruler_item_add(gzgroup);
 						for (j = 0; j < 3; j += 2) {
 							copy_v3_v3(ruler_item->co[j], &pt->x);
 							pt++;
@@ -506,12 +506,12 @@ static bool view3d_ruler_from_gpencil(const bContext *C, wmGizmoGroup *mgroup)
 /** \name Ruler Item Gizmo Type
  * \{ */
 
-static void gizmo_ruler_draw(const bContext *C, wmGizmo *mpr)
+static void gizmo_ruler_draw(const bContext *C, wmGizmo *gz)
 {
 	Scene *scene = CTX_data_scene(C);
 	UnitSettings *unit = &scene->unit;
-	RulerInfo *ruler_info = mpr->parent_mgroup->customdata;
-	RulerItem *ruler_item = (RulerItem *)mpr;
+	RulerInfo *ruler_info = gz->parent_gzgroup->customdata;
+	RulerItem *ruler_item = (RulerItem *)gz;
 	ARegion *ar = ruler_info->ar;
 	RegionView3D *rv3d = ar->regiondata;
 	const float cap_size = 4.0f;
@@ -536,7 +536,7 @@ static void gizmo_ruler_draw(const bContext *C, wmGizmo *mpr)
 	UI_GetThemeColor3ubv(TH_TEXT, color_text);
 	UI_GetThemeColor3ubv(TH_WIRE, color_wire);
 
-	const bool is_act = (mpr->flag & WM_GIZMO_DRAW_HOVER);
+	const bool is_act = (gz->flag & WM_GIZMO_DRAW_HOVER);
 	float dir_ruler[2];
 	float co_ss[3][2];
 	int j;
@@ -785,9 +785,9 @@ static void gizmo_ruler_draw(const bContext *C, wmGizmo *mpr)
 	/* draw snap */
 	if ((ruler_info->snap_flag & RULER_SNAP_OK) &&
 	    (ruler_info->state == RULER_STATE_DRAG) &&
-	    (ruler_item->mpr.interaction_data != NULL))
+	    (ruler_item->gz.interaction_data != NULL))
 	{
-		RulerInteraction *inter = ruler_item->mpr.interaction_data;
+		RulerInteraction *inter = ruler_item->gz.interaction_data;
 		/* size from drawSnapping */
 		const float size = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE);
 		float co_ss_snap[3];
@@ -805,14 +805,14 @@ static void gizmo_ruler_draw(const bContext *C, wmGizmo *mpr)
 }
 
 static int gizmo_ruler_test_select(
-        bContext *UNUSED(C), wmGizmo *mpr, const wmEvent *event)
+        bContext *UNUSED(C), wmGizmo *gz, const wmEvent *event)
 {
-	RulerItem *ruler_item_pick = (RulerItem *)mpr;
+	RulerItem *ruler_item_pick = (RulerItem *)gz;
 	float mval_fl[2] = {UNPACK2(event->mval)};
 	int co_index;
 
 	/* select and drag */
-	if (view3d_ruler_pick(mpr->parent_mgroup, ruler_item_pick, mval_fl, &co_index)) {
+	if (view3d_ruler_pick(gz->parent_gzgroup, ruler_item_pick, mval_fl, &co_index)) {
 		if (co_index == -1) {
 			if ((ruler_item_pick->flag & RULERITEM_USE_ANGLE) == 0) {
 				return PART_LINE;
@@ -826,14 +826,14 @@ static int gizmo_ruler_test_select(
 }
 
 static int gizmo_ruler_modal(
-        bContext *C, wmGizmo *mpr, const wmEvent *event,
+        bContext *C, wmGizmo *gz, const wmEvent *event,
         eWM_GizmoFlagTweak UNUSED(tweak_flag))
 {
 	bool do_draw = false;
 	int exit_code = OPERATOR_RUNNING_MODAL;
-	RulerInfo *ruler_info = mpr->parent_mgroup->customdata;
-	RulerItem *ruler_item = (RulerItem *)mpr;
-	RulerInteraction *inter = ruler_item->mpr.interaction_data;
+	RulerInfo *ruler_info = gz->parent_gzgroup->customdata;
+	RulerItem *ruler_item = (RulerItem *)gz;
+	RulerInteraction *inter = ruler_item->gz.interaction_data;
 	ARegion *ar = CTX_wm_region(C);
 
 	ruler_info->ar = ar;
@@ -860,20 +860,20 @@ static int gizmo_ruler_modal(
 }
 
 static int gizmo_ruler_invoke(
-        bContext *C, wmGizmo *mpr, const wmEvent *event)
+        bContext *C, wmGizmo *gz, const wmEvent *event)
 {
-	wmGizmoGroup *mgroup = mpr->parent_mgroup;
-	RulerInfo *ruler_info = mgroup->customdata;
-	RulerItem *ruler_item_pick = (RulerItem *)mpr;
+	wmGizmoGroup *gzgroup = gz->parent_gzgroup;
+	RulerInfo *ruler_info = gzgroup->customdata;
+	RulerItem *ruler_item_pick = (RulerItem *)gz;
 	RulerInteraction *inter = MEM_callocN(sizeof(RulerInteraction), __func__);
-	mpr->interaction_data = inter;
+	gz->interaction_data = inter;
 
 	ARegion *ar = ruler_info->ar;
 
 	const float mval_fl[2] = {UNPACK2(event->mval)};
 
 	/* select and drag */
-	if (mpr->highlight_part == PART_LINE) {
+	if (gz->highlight_part == PART_LINE) {
 		if ((ruler_item_pick->flag & RULERITEM_USE_ANGLE) == 0) {
 			/* Add Center Point */
 			ruler_item_pick->flag |= RULERITEM_USE_ANGLE;
@@ -903,7 +903,7 @@ static int gizmo_ruler_invoke(
 		}
 	}
 	else {
-		inter->co_index = mpr->highlight_part;
+		inter->co_index = gz->highlight_part;
 		ruler_state_set(C, ruler_info, RULER_STATE_DRAG);
 
 		/* store the initial depth */
@@ -913,15 +913,15 @@ static int gizmo_ruler_invoke(
 	return OPERATOR_RUNNING_MODAL;
 }
 
-static void gizmo_ruler_exit(bContext *C, wmGizmo *mpr, const bool cancel)
+static void gizmo_ruler_exit(bContext *C, wmGizmo *gz, const bool cancel)
 {
-	wmGizmoGroup *mgroup = mpr->parent_mgroup;
-	RulerInfo *ruler_info = mgroup->customdata;
+	wmGizmoGroup *gzgroup = gz->parent_gzgroup;
+	RulerInfo *ruler_info = gzgroup->customdata;
 
 	if (!cancel) {
 		if (ruler_info->state == RULER_STATE_DRAG) {
-			RulerItem *ruler_item = (RulerItem *)mpr;
-			RulerInteraction *inter = mpr->interaction_data;
+			RulerItem *ruler_item = (RulerItem *)gz;
+			RulerInteraction *inter = gz->interaction_data;
 			/* rubber-band angle removal */
 			if (!inter->inside_region) {
 				if ((inter->co_index == 1) && (ruler_item->flag & RULERITEM_USE_ANGLE)) {
@@ -930,9 +930,9 @@ static void gizmo_ruler_exit(bContext *C, wmGizmo *mpr, const bool cancel)
 				else {
 					/* Not ideal, since the ruler isn't a mode and we don't want to override delete key
 					 * use dragging out of the view for removal. */
-					ruler_item_remove(C, mgroup, ruler_item);
+					ruler_item_remove(C, gzgroup, ruler_item);
 					ruler_item = NULL;
-					mpr = NULL;
+					gz = NULL;
 					inter = NULL;
 				}
 			}
@@ -942,38 +942,38 @@ static void gizmo_ruler_exit(bContext *C, wmGizmo *mpr, const bool cancel)
 			ruler_state_set(C, ruler_info, RULER_STATE_NORMAL);
 		}
 		/* We could convert only the current gizmo, for now just re-generate. */
-		view3d_ruler_to_gpencil(C, mgroup);
+		view3d_ruler_to_gpencil(C, gzgroup);
 	}
 
-	if (mpr) {
-		MEM_SAFE_FREE(mpr->interaction_data);
+	if (gz) {
+		MEM_SAFE_FREE(gz->interaction_data);
 	}
 
 	ruler_state_set(C, ruler_info, RULER_STATE_NORMAL);
 }
 
-static int gizmo_ruler_cursor_get(wmGizmo *mpr)
+static int gizmo_ruler_cursor_get(wmGizmo *gz)
 {
-	if (mpr->highlight_part == PART_LINE) {
+	if (gz->highlight_part == PART_LINE) {
 		return BC_CROSSCURSOR;
 	}
 	return BC_NSEW_SCROLLCURSOR;
 }
 
-void VIEW3D_WT_ruler_item(wmGizmoType *wt)
+void VIEW3D_GT_ruler_item(wmGizmoType *gzt)
 {
 	/* identifiers */
-	wt->idname = "VIEW3D_WT_ruler_item";
+	gzt->idname = "VIEW3D_GT_ruler_item";
 
 	/* api callbacks */
-	wt->draw = gizmo_ruler_draw;
-	wt->test_select = gizmo_ruler_test_select;
-	wt->modal = gizmo_ruler_modal;
-	wt->invoke = gizmo_ruler_invoke;
-	wt->exit = gizmo_ruler_exit;
-	wt->cursor_get = gizmo_ruler_cursor_get;
-
-	wt->struct_size = sizeof(RulerItem);
+	gzt->draw = gizmo_ruler_draw;
+	gzt->test_select = gizmo_ruler_test_select;
+	gzt->modal = gizmo_ruler_modal;
+	gzt->invoke = gizmo_ruler_invoke;
+	gzt->exit = gizmo_ruler_exit;
+	gzt->cursor_get = gizmo_ruler_cursor_get;
+
+	gzt->struct_size = sizeof(RulerItem);
 }
 
 /** \} */
@@ -982,23 +982,23 @@ void VIEW3D_WT_ruler_item(wmGizmoType *wt)
 /** \name Ruler Gizmo Group
  * \{ */
 
-static bool WIDGETGROUP_ruler_poll(const bContext *C, wmGizmoGroupType *wgt)
+static bool WIDGETGROUP_ruler_poll(const bContext *C, wmGizmoGroupType *gzgt)
 {
 	bToolRef_Runtime *tref_rt = WM_toolsystem_runtime_from_context((bContext *)C);
 	if ((tref_rt == NULL) ||
-	    !STREQ(wgt->idname, tref_rt->gizmo_group))
+	    !STREQ(gzgt->idname, tref_rt->gizmo_group))
 	{
-		WM_gizmo_group_type_unlink_delayed_ptr(wgt);
+		WM_gizmo_group_type_unlink_delayed_ptr(gzgt);
 		return false;
 	}
 	return true;
 }
 
-static void WIDGETGROUP_ruler_setup(const bContext *C, wmGizmoGroup *mgroup)
+static void WIDGETGROUP_ruler_setup(const bContext *C, wmGizmoGroup *gzgroup)
 {
 	RulerInfo *ruler_info = MEM_callocN(sizeof(RulerInfo), __func__);
 
-	if (view3d_ruler_from_gpencil(C, mgroup)) {
+	if (view3d_ruler_from_gpencil(C, gzgroup)) {
 		/* nop */
 	}
 
@@ -1009,21 +1009,21 @@ static void WIDGETGROUP_ruler_setup(const bContext *C, wmGizmoGroup *mgroup)
 	ruler_info->sa = sa;
 	ruler_info->ar = ar;
 
-	mgroup->customdata = ruler_info;
+	gzgroup->customdata = ruler_info;
 }
 
-void VIEW3D_WGT_ruler(wmGizmoGroupType *wgt)
+void VIEW3D_GGT_ruler(wmGizmoGroupType *gzgt)
 {
-	wgt->name = "Ruler Widgets";
-	wgt->idname = view3d_wgt_ruler_id;
+	gzgt->name = "Ruler Widgets";
+	gzgt->idname = view3d_gzgt_ruler_id;
 
-	wgt->flag |= WM_GIZMOGROUPTYPE_SCALE | WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL;
+	gzgt->flag |= WM_GIZMOGROUPTYPE_SCALE | WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL;
 
-	wgt->mmap_params.spaceid = SPACE_VIEW3D;
-	wgt->mmap_params.regionid = RGN_TYPE_WINDOW;
+	gzgt->gzmap_params.spaceid = SPACE_VIEW3D;
+	gzgt->gzmap_params.regionid = RGN_TYPE_WINDOW;
 
-	wgt->poll = WIDGETGROUP_ruler_poll;
-	wgt->setup = WIDGETGROUP_ruler_setup;
+	gzgt->poll = WIDGETGROUP_ruler_poll;
+	gzgt->setup = WIDGETGROUP_ruler_setup;
 }
 
 /** \} */
@@ -1036,7 +1036,7 @@ static bool view3d_ruler_poll(bContext *C)
 {
 	bToolRef_Runtime *tref_rt = WM_toolsystem_runtime_from_context((bContext *)C);
 	if ((tref_rt == NULL) ||
-	    !STREQ(view3d_wgt_ruler_id, tref_rt->gizmo_group) ||
+	    !STREQ(view3d_gzgt_ruler_id, tref_rt->gizmo_group) ||
 	    CTX_wm_region_view3d(C) == NULL)
 	{
 		return false;
@@ -1050,22 +1050,22 @@ static int view3d_ruler_add_invoke(bContext *C, wmOperator *UNUSED(op), const wm
 	View3D *v3d = CTX_wm_view3d(C);
 	RegionView3D *rv3d = ar->regiondata;
 
-	wmGizmoMap *mmap = ar->gizmo_map;
-	wmGizmoGroup *mgroup = WM_gizmomap_group_find(mmap, view3d_wgt_ruler_id);
+	wmGizmoMap *gzmap = ar->gizmo_map;
+	wmGizmoGroup *gzgroup = WM_gizmomap_group_find(gzmap, view3d_gzgt_ruler_id);
 	const bool use_depth = (v3d->drawtype >= OB_SOLID);
 
 	/* Create new line */
 	RulerItem *ruler_item;
-	ruler_item = ruler_item_add(mgroup);
+	ruler_item = ruler_item_add(gzgroup);
 
 	/* This is a little weak, but there is no real good way to tweak directly. */
-	WM_gizmo_highlight_set(mmap, &ruler_item->mpr);
+	WM_gizmo_highlight_set(gzmap, &ruler_item->gz);
 	if (WM_operator_name_call(
 	        C, "GIZMOGROUP_OT_gizmo_tweak",
 	        WM_OP_INVOKE_REGION_WIN, NULL) == OPERATOR_RUNNING_MODAL)
 	{
-		RulerInfo *ruler_info = mgroup->customdata;
-		RulerInteraction *inter = ruler_item->mpr.interaction_data;
+		RulerInfo *ruler_info = gzgroup->customdata;
+		RulerInteraction *inter = ruler_item->gz.interaction_data;
 		if (use_depth) {
 			/* snap the first point added, not essential but handy */
 			inter->co_index = 0;
@@ -1079,7 +1079,7 @@ static int view3d_ruler_add_invoke(bContext *C, wmOperator *UNUSED(op), const wm
 		}
 
 		copy_v3_v3(ruler_item->co[2], ruler_item->co[0]);
-		ruler_item->mpr.highlight_part = inter->co_index = 2;
+		ruler_item->gz.highlight_part = inter->co_index = 2;
 	}
 	return OPERATOR_FINISHED;
 }
diff --git a/source/blender/editors/space_view3d/view3d_intern.h b/source/blender/editors/space_view3d/view3d_intern.h
index 89dd254c130..5796014571a 100644
--- a/source/blender/editors/space_view3d/view3d_intern.h
+++ b/source/blender/editors/space_view3d/view3d_intern.h
@@ -254,21 +254,21 @@ ARegion *view3d_has_tools_region(ScrArea *sa);
 extern const char *view3d_context_dir[]; /* doc access */
 
 /* view3d_widgets.c */
-void VIEW3D_WGT_lamp_spot(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_lamp_area(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_lamp_target(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_camera(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_camera_view(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_force_field(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_empty_image(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_armature_spline(struct wmGizmoGroupType *wgt);
-void VIEW3D_WGT_navigate(struct wmGizmoGroupType *wgt);
-
-void VIEW3D_WGT_ruler(struct wmGizmoGroupType *wgt);
-void VIEW3D_WT_ruler_item(struct wmGizmoType *wt);
+void VIEW3D_GGT_lamp_spot(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_lamp_area(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_lamp_target(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_camera(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_camera_view(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_force_field(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_empty_image(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_armature_spline(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GGT_navigate(struct wmGizmoGroupType *gzgt);
+
+void VIEW3D_GGT_ruler(struct wmGizmoGroupType *gzgt);
+void VIEW3D_GT_ruler_item(struct wmGizmoType *gzt);
 void VIEW3D_OT_ruler_add(struct wmOperatorType *ot);
 
-void VIEW3D_WT_navigate_rotate(struct wmGizmoType *wt);
+void VIEW3D_GT_navigate_rotate(struct wmGizmoType *gzt);
 
 /* draw_volume.c */
 void draw_smoke_volume(struct SmokeDomainSettings *sds, struct Object *ob,