Refactor: arrange transform convert functions in 'TransConvertTypeInfo'

Simplify the transform code by bundling the TransData creation, Data
recalculation, and special updates into a single struct.

So similar functions and parameters can be accessed without special
type checks.

Differential Revision: https://developer.blender.org/D15494

31 files changed, 493 insertions, 639 deletions

diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index 6e47b30ae9d..8dcbf07b776 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -525,7 +525,8 @@ static void viewRedrawPost(bContext *C, TransInfo *t)
                                          UVCALC_TRANSFORM_CORRECT_SLIDE :
                                          UVCALC_TRANSFORM_CORRECT;
 
-    if ((t->data_type == TC_MESH_VERTS) && (t->settings->uvcalc_flag & uvcalc_correct_flag)) {
+    if ((t->data_type == &TransConvertType_Mesh) &&
+        (t->settings->uvcalc_flag & uvcalc_correct_flag)) {
       WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
     }
 
@@ -847,7 +848,7 @@ static bool transform_event_modal_constraint(TransInfo *t, short modal_type)
       return false;
     }
 
-    if (t->data_type == TC_SEQ_IMAGE_DATA) {
+    if (t->data_type == &TransConvertType_SequencerImage) {
       /* Setup the 2d msg string so it writes out the transform space. */
       msg_2d = msg_3d;
 
diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index b01affc7307..fc59787e1ec 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -38,6 +38,7 @@ struct ReportList;
 struct Scene;
 struct ScrArea;
 struct SnapObjectContext;
+struct TransConvertTypeInfo;
 struct TransDataContainer;
 struct TransInfo;
 struct TransSnap;
@@ -204,37 +205,6 @@ typedef enum {
   HLP_TRACKBALL = 6,
 } eTHelpline;
 
-typedef enum {
-  TC_NONE = 0,
-  TC_ACTION_DATA,
-  TC_POSE,
-  TC_ARMATURE_VERTS,
-  TC_CURSOR_IMAGE,
-  TC_CURSOR_SEQUENCER,
-  TC_CURSOR_VIEW3D,
-  TC_CURVE_VERTS,
-  TC_GRAPH_EDIT_DATA,
-  TC_GPENCIL,
-  TC_LATTICE_VERTS,
-  TC_MASKING_DATA,
-  TC_MBALL_VERTS,
-  TC_MESH_VERTS,
-  TC_MESH_EDGES,
-  TC_MESH_SKIN,
-  TC_MESH_UV,
-  TC_MESH_VERT_CDATA,
-  TC_NLA_DATA,
-  TC_NODE_DATA,
-  TC_OBJECT,
-  TC_OBJECT_TEXSPACE,
-  TC_PAINT_CURVE_VERTS,
-  TC_PARTICLE_VERTS,
-  TC_SCULPT,
-  TC_SEQ_DATA,
-  TC_SEQ_IMAGE_DATA,
-  TC_TRACKING_DATA,
-} eTConvertType;
-
 /** \} */
 
 /* -------------------------------------------------------------------- */
@@ -519,7 +489,7 @@ typedef struct TransInfo {
   int data_len_all;
 
   /** TODO: It should be a member of #TransDataContainer. */
-  eTConvertType data_type;
+  struct TransConvertTypeInfo *data_type;
 
   /** Current context/options for transform. */
   eTContext options;
diff --git a/source/blender/editors/transform/transform_convert.c b/source/blender/editors/transform/transform_convert.c
index b0148ce508c..e6cf2dd47d9 100644
--- a/source/blender/editors/transform/transform_convert.c
+++ b/source/blender/editors/transform/transform_convert.c
@@ -776,63 +776,12 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
     return;
   }
 
-  BLI_assert(CTX_data_main(t->context) == CTX_data_main(C));
-  switch (t->data_type) {
-    case TC_ACTION_DATA:
-      special_aftertrans_update__actedit(C, t);
-      break;
-    case TC_POSE:
-      special_aftertrans_update__pose(C, t);
-      break;
-    case TC_GRAPH_EDIT_DATA:
-      special_aftertrans_update__graph(C, t);
-      break;
-    case TC_MASKING_DATA:
-      special_aftertrans_update__mask(C, t);
-      break;
-    case TC_MESH_VERTS:
-    case TC_MESH_EDGES:
-      special_aftertrans_update__mesh(C, t);
-      break;
-    case TC_NLA_DATA:
-      special_aftertrans_update__nla(C, t);
-      break;
-    case TC_NODE_DATA:
-      special_aftertrans_update__node(C, t);
-      break;
-    case TC_OBJECT:
-      special_aftertrans_update__object(C, t);
-      break;
-    case TC_SCULPT:
-      special_aftertrans_update__sculpt(C, t);
-      break;
-    case TC_SEQ_DATA:
-      special_aftertrans_update__sequencer(C, t);
-      break;
-    case TC_SEQ_IMAGE_DATA:
-      special_aftertrans_update__sequencer_image(C, t);
-      break;
-    case TC_TRACKING_DATA:
-      special_aftertrans_update__movieclip(C, t);
-      break;
-    case TC_ARMATURE_VERTS:
-    case TC_CURSOR_IMAGE:
-    case TC_CURSOR_SEQUENCER:
-    case TC_CURSOR_VIEW3D:
-    case TC_CURVE_VERTS:
-    case TC_GPENCIL:
-    case TC_LATTICE_VERTS:
-    case TC_MBALL_VERTS:
-    case TC_MESH_VERT_CDATA:
-    case TC_MESH_UV:
-    case TC_MESH_SKIN:
-    case TC_OBJECT_TEXSPACE:
-    case TC_PAINT_CURVE_VERTS:
-    case TC_PARTICLE_VERTS:
-    case TC_NONE:
-    default:
-      break;
+  if (!t->data_type || !t->data_type->special_aftertrans_update) {
+    return;
   }
+
+  BLI_assert(CTX_data_main(t->context) == CTX_data_main(C));
+  t->data_type->special_aftertrans_update(C, t);
 }
 
 int special_transform_moving(TransInfo *t)
@@ -893,55 +842,44 @@ static int countAndCleanTransDataContainer(TransInfo *t)
 
 static void init_proportional_edit(TransInfo *t)
 {
-  eTConvertType convert_type = t->data_type;
-  switch (convert_type) {
-    case TC_ACTION_DATA:
-    case TC_CURVE_VERTS:
-    case TC_GRAPH_EDIT_DATA:
-    case TC_GPENCIL:
-    case TC_LATTICE_VERTS:
-    case TC_MASKING_DATA:
-    case TC_MBALL_VERTS:
-    case TC_MESH_VERTS:
-    case TC_MESH_EDGES:
-    case TC_MESH_SKIN:
-    case TC_MESH_UV:
-    case TC_MESH_VERT_CDATA:
-    case TC_NODE_DATA:
-    case TC_OBJECT:
-    case TC_PARTICLE_VERTS:
-      break;
-    case TC_POSE: /* Disable PET, its not usable in pose mode yet T32444. */
-    case TC_ARMATURE_VERTS:
-    case TC_CURSOR_IMAGE:
-    case TC_CURSOR_SEQUENCER:
-    case TC_CURSOR_VIEW3D:
-    case TC_NLA_DATA:
-    case TC_OBJECT_TEXSPACE:
-    case TC_PAINT_CURVE_VERTS:
-    case TC_SCULPT:
-    case TC_SEQ_DATA:
-    case TC_SEQ_IMAGE_DATA:
-    case TC_TRACKING_DATA:
-    case TC_NONE:
-    default:
-      t->options |= CTX_NO_PET;
-      t->flag &= ~T_PROP_EDIT_ALL;
-      return;
+  /* NOTE: PET is not usable in pose mode yet T32444. */
+  if (!ELEM(t->data_type,
+            &TransConvertType_Action,
+            &TransConvertType_Curve,
+            &TransConvertType_Graph,
+            &TransConvertType_GPencil,
+            &TransConvertType_Lattice,
+            &TransConvertType_Mask,
+            &TransConvertType_MBall,
+            &TransConvertType_Mesh,
+            &TransConvertType_MeshEdge,
+            &TransConvertType_MeshSkin,
+            &TransConvertType_MeshUV,
+            &TransConvertType_MeshVertCData,
+            &TransConvertType_Node,
+            &TransConvertType_Object,
+            &TransConvertType_Particle)) {
+    /* Disable PET */
+    t->options |= CTX_NO_PET;
+    t->flag &= ~T_PROP_EDIT_ALL;
+    return;
   }
 
   if (t->data_len_all && (t->flag & T_PROP_EDIT)) {
-    if (convert_type == TC_OBJECT) {
+    if (t->data_type == &TransConvertType_Object) {
       /* Selected objects are already first, no need to presort. */
     }
     else {
       sort_trans_data_selected_first(t);
     }
 
-    if (ELEM(convert_type, TC_ACTION_DATA, TC_GRAPH_EDIT_DATA)) {
+    if (ELEM(t->data_type, &TransConvertType_Action, &TransConvertType_Graph)) {
       /* Distance has already been set. */
     }
-    else if (ELEM(convert_type, TC_MESH_VERTS, TC_MESH_SKIN, TC_MESH_VERT_CDATA)) {
+    else if (ELEM(t->data_type,
+                  &TransConvertType_Mesh,
+                  &TransConvertType_MeshSkin,
+                  &TransConvertType_MeshVertCData)) {
       if (t->flag & T_PROP_CONNECTED) {
         /* Already calculated by transform_convert_mesh_connectivity_distance. */
       }
@@ -949,10 +887,10 @@ static void init_proportional_edit(TransInfo *t)
         set_prop_dist(t, false);
       }
     }
-    else if (convert_type == TC_MESH_UV && t->flag & T_PROP_CONNECTED) {
+    else if (t->data_type == &TransConvertType_MeshUV && t->flag & T_PROP_CONNECTED) {
       /* Already calculated by uv_set_connectivity_distance. */
     }
-    else if (convert_type == TC_CURVE_VERTS) {
+    else if (t->data_type == &TransConvertType_Curve) {
       BLI_assert(t->obedit_type == OB_CURVES_LEGACY);
       set_prop_dist(t, false);
     }
@@ -975,45 +913,26 @@ static void init_TransDataContainers(TransInfo *t,
                                      Object **objects,
                                      uint objects_len)
 {
-  switch (t->data_type) {
-    case TC_POSE:
-    case TC_ARMATURE_VERTS:
-    case TC_CURVE_VERTS:
-    case TC_GPENCIL:
-    case TC_LATTICE_VERTS:
-    case TC_MBALL_VERTS:
-    case TC_MESH_VERTS:
-    case TC_MESH_EDGES:
-    case TC_MESH_SKIN:
-    case TC_MESH_UV:
-    case TC_MESH_VERT_CDATA:
-      break;
-    case TC_ACTION_DATA:
-    case TC_GRAPH_EDIT_DATA:
-    case TC_CURSOR_IMAGE:
-    case TC_CURSOR_SEQUENCER:
-    case TC_CURSOR_VIEW3D:
-    case TC_MASKING_DATA:
-    case TC_NLA_DATA:
-    case TC_NODE_DATA:
-    case TC_OBJECT:
-    case TC_OBJECT_TEXSPACE:
-    case TC_PAINT_CURVE_VERTS:
-    case TC_PARTICLE_VERTS:
-    case TC_SCULPT:
-    case TC_SEQ_DATA:
-    case TC_SEQ_IMAGE_DATA:
-    case TC_TRACKING_DATA:
-    case TC_NONE:
-    default:
-      /* Does not support Multi object editing. */
-      return;
+  if (!ELEM(t->data_type,
+            &TransConvertType_Pose,
+            &TransConvertType_EditArmature,
+            &TransConvertType_Curve,
+            &TransConvertType_GPencil,
+            &TransConvertType_Lattice,
+            &TransConvertType_MBall,
+            &TransConvertType_Mesh,
+            &TransConvertType_MeshEdge,
+            &TransConvertType_MeshSkin,
+            &TransConvertType_MeshUV,
+            &TransConvertType_MeshVertCData)) {
+    /* Does not support Multi object editing. */
+    return;
   }
 
   const eObjectMode object_mode = obact ? obact->mode : OB_MODE_OBJECT;
   const short object_type = obact ? obact->type : -1;
 
-  if ((object_mode & OB_MODE_EDIT) || (t->data_type == TC_GPENCIL) ||
+  if ((object_mode & OB_MODE_EDIT) || (t->data_type == &TransConvertType_GPencil) ||
       ((object_mode & OB_MODE_POSE) && (object_type == OB_ARMATURE))) {
     if (t->data_container) {
       MEM_freeN(t->data_container);
@@ -1055,7 +974,7 @@ static void init_TransDataContainers(TransInfo *t,
         tc->poseobj = objects[i];
         tc->use_local_mat = true;
       }
-      else if (t->data_type == TC_GPENCIL) {
+      else if (t->data_type == &TransConvertType_GPencil) {
         tc->use_local_mat = true;
       }
 
@@ -1078,177 +997,131 @@ static void init_TransDataContainers(TransInfo *t,
   }
 }
 
-static eTFlag flags_from_data_type(eTConvertType data_type)
-{
-  switch (data_type) {
-    case TC_ACTION_DATA:
-    case TC_GRAPH_EDIT_DATA:
-    case TC_MASKING_DATA:
-    case TC_NLA_DATA:
-    case TC_NODE_DATA:
-    case TC_PAINT_CURVE_VERTS:
-    case TC_SEQ_DATA:
-    case TC_SEQ_IMAGE_DATA:
-    case TC_TRACKING_DATA:
-      return T_POINTS | T_2D_EDIT;
-    case TC_ARMATURE_VERTS:
-    case TC_CURVE_VERTS:
-    case TC_GPENCIL:
-    case TC_LATTICE_VERTS:
-    case TC_MBALL_VERTS:
-    case TC_MESH_VERTS:
-    case TC_MESH_SKIN:
-    case TC_MESH_VERT_CDATA:
-      return T_EDIT | T_POINTS;
-    case TC_MESH_EDGES:
-      return T_EDIT;
-    case TC_MESH_UV:
-      return T_EDIT | T_POINTS | T_2D_EDIT;
-    case TC_CURSOR_IMAGE:
-    case TC_CURSOR_SEQUENCER:
-      return T_2D_EDIT;
-    case TC_PARTICLE_VERTS:
-      return T_POINTS;
-    case TC_POSE:
-    case TC_CURSOR_VIEW3D:
-    case TC_OBJECT:
-    case TC_OBJECT_TEXSPACE:
-    case TC_SCULPT:
-    case TC_NONE:
-    default:
-      break;
-  }
-  return 0;
-}
-
-static eTConvertType convert_type_get(const TransInfo *t, Object **r_obj_armature)
+static TransConvertTypeInfo *convert_type_get(const TransInfo *t, Object **r_obj_armature)
 {
   ViewLayer *view_layer = t->view_layer;
   Object *ob = OBACT(view_layer);
-  eTConvertType convert_type = TC_NONE;
 
   /* if tests must match recalcData for correct updates */
   if (t->options & CTX_CURSOR) {
     if (t->spacetype == SPACE_IMAGE) {
-      convert_type = TC_CURSOR_IMAGE;
+      return &TransConvertType_CursorImage;
     }
-    else if (t->spacetype == SPACE_SEQ) {
-      convert_type = TC_CURSOR_SEQUENCER;
-    }
-    else {
-      convert_type = TC_CURSOR_VIEW3D;
+
+    if (t->spacetype == SPACE_SEQ) {
+      return &TransConvertType_CursorSequencer;
     }
+
+    return &TransConvertType_Cursor3D;
   }
-  else if (!(t->options & CTX_PAINT_CURVE) && (t->spacetype == SPACE_VIEW3D) && ob &&
-           (ob->mode == OB_MODE_SCULPT) && ob->sculpt) {
-    convert_type = TC_SCULPT;
+  if (!(t->options & CTX_PAINT_CURVE) && (t->spacetype == SPACE_VIEW3D) && ob &&
+      (ob->mode == OB_MODE_SCULPT) && ob->sculpt) {
+    return &TransConvertType_Sculpt;
   }
-  else if (t->options & CTX_TEXTURE_SPACE) {
-    convert_type = TC_OBJECT_TEXSPACE;
+  if (t->options & CTX_TEXTURE_SPACE) {
+    return &TransConvertType_ObjectTexSpace;
   }
-  else if (t->options & CTX_EDGE_DATA) {
-    convert_type = TC_MESH_EDGES;
+  if (t->options & CTX_EDGE_DATA) {
+    return &TransConvertType_MeshEdge;
   }
-  else if (t->options & CTX_GPENCIL_STROKES) {
-    convert_type = TC_GPENCIL;
+  if (t->options & CTX_GPENCIL_STROKES) {
+    return &TransConvertType_GPencil;
   }
-  else if (t->spacetype == SPACE_IMAGE) {
+  if (t->spacetype == SPACE_IMAGE) {
     if (t->options & CTX_MASK) {
-      convert_type = TC_MASKING_DATA;
+      return &TransConvertType_Mask;
     }
-    else if (t->options & CTX_PAINT_CURVE) {
+    if (t->options & CTX_PAINT_CURVE) {
       if (!ELEM(t->mode, TFM_SHEAR, TFM_SHRINKFATTEN)) {
-        convert_type = TC_PAINT_CURVE_VERTS;
+        return &TransConvertType_PaintCurve;
       }
     }
     else if (t->obedit_type == OB_MESH) {
-      convert_type = TC_MESH_UV;
+      return &TransConvertType_MeshUV;
     }
+    return NULL;
   }
-  else if (t->spacetype == SPACE_ACTION) {
-    convert_type = TC_ACTION_DATA;
+  if (t->spacetype == SPACE_ACTION) {
+    return &TransConvertType_Action;
   }
-  else if (t->spacetype == SPACE_NLA) {
-    convert_type = TC_NLA_DATA;
+  if (t->spacetype == SPACE_NLA) {
+    return &TransConvertType_NLA;
   }
-  else if (t->spacetype == SPACE_SEQ) {
+  if (t->spacetype == SPACE_SEQ) {
     if (t->options & CTX_SEQUENCER_IMAGE) {
-      convert_type = TC_SEQ_IMAGE_DATA;
-    }
-    else {
-      convert_type = TC_SEQ_DATA;
+      return &TransConvertType_SequencerImage;
     }
+    return &TransConvertType_Sequencer;
   }
-  else if (t->spacetype == SPACE_GRAPH) {
-    convert_type = TC_GRAPH_EDIT_DATA;
+  if (t->spacetype == SPACE_GRAPH) {
+    return &TransConvertType_Graph;
   }
-  else if (t->spacetype == SPACE_NODE) {
-    convert_type = TC_NODE_DATA;
+  if (t->spacetype == SPACE_NODE) {
+    return &TransConvertType_Graph;
   }
-  else if (t->spacetype == SPACE_CLIP) {
+  if (t->spacetype == SPACE_CLIP) {
     if (t->options & CTX_MOVIECLIP) {
-      convert_type = TC_TRACKING_DATA;
+      return &TransConvertType_Tracking;
     }
-    else if (t->options & CTX_MASK) {
-      convert_type = TC_MASKING_DATA;
+    if (t->options & CTX_MASK) {
+      return &TransConvertType_Mask;
     }
+    return NULL;
   }
-  else if (t->obedit_type != -1) {
+  if (t->obedit_type != -1) {
     if (t->obedit_type == OB_MESH) {
       if (t->mode == TFM_SKIN_RESIZE) {
-        convert_type = TC_MESH_SKIN;
+        return &TransConvertType_MeshSkin;
       }
-      else if (ELEM(t->mode, TFM_BWEIGHT, TFM_VERT_CREASE)) {
-        convert_type = TC_MESH_VERT_CDATA;
-      }
-      else {
-        convert_type = TC_MESH_VERTS;
+      if (ELEM(t->mode, TFM_BWEIGHT, TFM_VERT_CREASE)) {
+        return &TransConvertType_MeshVertCData;
       }
+      return &TransConvertType_Mesh;
     }
-    else if (ELEM(t->obedit_type, OB_CURVES_LEGACY, OB_SURF)) {
-      convert_type = TC_CURVE_VERTS;
+    if (ELEM(t->obedit_type, OB_CURVES_LEGACY, OB_SURF)) {
+      return &TransConvertType_Curve;
     }
-    else if (t->obedit_type == OB_LATTICE) {
-      convert_type = TC_LATTICE_VERTS;
+    if (t->obedit_type == OB_LATTICE) {
+      return &TransConvertType_Lattice;
     }
-    else if (t->obedit_type == OB_MBALL) {
-      convert_type = TC_MBALL_VERTS;
+    if (t->obedit_type == OB_MBALL) {
+      return &TransConvertType_MBall;
     }
-    else if (t->obedit_type == OB_ARMATURE) {
-      convert_type = TC_ARMATURE_VERTS;
+    if (t->obedit_type == OB_ARMATURE) {
+      return &TransConvertType_EditArmature;
     }
+    return NULL;
   }
-  else if (ob && (ob->mode & OB_MODE_POSE)) {
-    convert_type = TC_POSE;
+  if (ob && (ob->mode & OB_MODE_POSE)) {
+    return &TransConvertType_Pose;
   }
-  else if (ob && (ob->mode & OB_MODE_ALL_WEIGHT_PAINT) && !(t->options & CTX_PAINT_CURVE)) {
+  if (ob && (ob->mode & OB_MODE_ALL_WEIGHT_PAINT) && !(t->options & CTX_PAINT_CURVE)) {
     Object *ob_armature = transform_object_deform_pose_armature_get(t, ob);
     if (ob_armature) {
       *r_obj_armature = ob_armature;
-      convert_type = TC_POSE;
+      return &TransConvertType_Pose;
     }
+    return NULL;
   }
-  else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT) &&
-           PE_start_edit(PE_get_current(t->depsgraph, t->scene, ob))) {
-    convert_type = TC_PARTICLE_VERTS;
+  if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT) &&
+      PE_start_edit(PE_get_current(t->depsgraph, t->scene, ob))) {
+    return &TransConvertType_Particle;
   }
-  else if (ob && (ob->mode & OB_MODE_ALL_PAINT)) {
+  if (ob && (ob->mode & OB_MODE_ALL_PAINT)) {
     if ((t->options & CTX_PAINT_CURVE) && !ELEM(t->mode, TFM_SHEAR, TFM_SHRINKFATTEN)) {
-      convert_type = TC_PAINT_CURVE_VERTS;
+      return &TransConvertType_PaintCurve;
     }
+    return NULL;
   }
-  else if ((ob) && (ELEM(ob->mode,
-                         OB_MODE_PAINT_GPENCIL,
-                         OB_MODE_SCULPT_GPENCIL,
-                         OB_MODE_WEIGHT_GPENCIL,
-                         OB_MODE_VERTEX_GPENCIL))) {
+  if ((ob) && (ELEM(ob->mode,
+                    OB_MODE_PAINT_GPENCIL,
+                    OB_MODE_SCULPT_GPENCIL,
+                    OB_MODE_WEIGHT_GPENCIL,
+                    OB_MODE_VERTEX_GPENCIL))) {
     /* In grease pencil all transformations must be canceled if not Object or Edit. */
+    return NULL;
   }
-  else {
-    convert_type = TC_OBJECT;
-  }
-
-  return convert_type;
+  return &TransConvertType_Object;
 }
 
 void createTransData(bContext *C, TransInfo *t)
@@ -1257,7 +1130,14 @@ void createTransData(bContext *C, TransInfo *t)
 
   Object *ob_armature = NULL;
   t->data_type = convert_type_get(t, &ob_armature);
-  t->flag |= flags_from_data_type(t->data_type);
+  if (t->data_type == NULL) {
+    printf("edit type not implemented!\n");
+    BLI_assert(t->data_len_all == -1);
+    t->data_len_all = 0;
+    return;
+  }
+
+  t->flag |= t->data_type->flags;
 
   if (ob_armature) {
     init_TransDataContainers(t, ob_armature, &ob_armature, 1);
@@ -1268,125 +1148,46 @@ void createTransData(bContext *C, TransInfo *t)
     init_TransDataContainers(t, ob, NULL, 0);
   }
 
-  switch (t->data_type) {
-    case TC_ACTION_DATA:
-      createTransActionData(C, t);
-      break;
-    case TC_POSE:
-      t->options |= CTX_POSE_BONE;
+  if (t->data_type == &TransConvertType_Object) {
+    t->options |= CTX_OBJECT;
 
-      /* XXX active-layer checking isn't done
-       * as that should probably be checked through context instead. */
-      createTransPose(t);
-      break;
-    case TC_ARMATURE_VERTS:
-      createTransArmatureVerts(t);
-      break;
-    case TC_CURSOR_IMAGE:
-      createTransCursor_image(t);
-      break;
-    case TC_CURSOR_SEQUENCER:
-      createTransCursor_sequencer(t);
-      break;
-    case TC_CURSOR_VIEW3D:
-      createTransCursor_view3d(t);
-      break;
-    case TC_CURVE_VERTS:
-      createTransCurveVerts(t);
-      break;
-    case TC_GRAPH_EDIT_DATA:
-      createTransGraphEditData(C, t);
-      break;
-    case TC_GPENCIL:
-      createTransGPencil(C, t);
-      break;
-    case TC_LATTICE_VERTS:
-      createTransLatticeVerts(t);
-      break;
-    case TC_MASKING_DATA:
-      createTransMaskingData(C, t);
-      break;
-    case TC_MBALL_VERTS:
-      createTransMBallVerts(t);
-      break;
-    case TC_MESH_VERTS:
-      createTransEditVerts(t);
-      break;
-    case TC_MESH_EDGES:
-      createTransEdge(t);
-      break;
-    case TC_MESH_SKIN:
-      createTransMeshSkin(t);
-      break;
-    case TC_MESH_UV:
-      createTransUVs(C, t);
-      break;
-    case TC_NLA_DATA:
-      createTransNlaData(C, t);
-      break;
-    case TC_MESH_VERT_CDATA:
-      createTransMeshVertCData(t);
-      break;
-    case TC_NODE_DATA:
-      createTransNodeData(t);
-      break;
-    case TC_OBJECT:
-      t->options |= CTX_OBJECT;
-
-      /* Needed for correct Object.obmat after duplication, see: T62135. */
-      BKE_scene_graph_evaluated_ensure(t->depsgraph, CTX_data_main(t->context));
-
-      if ((t->settings->transform_flag & SCE_XFORM_DATA_ORIGIN) != 0) {
-        t->options |= CTX_OBMODE_XFORM_OBDATA;
-      }
-      if ((t->settings->transform_flag & SCE_XFORM_SKIP_CHILDREN) != 0) {
-        t->options |= CTX_OBMODE_XFORM_SKIP_CHILDREN;
-      }
-      createTransObject(C, t);
-      /* Check if we're transforming the camera from the camera */
-      if ((t->spacetype == SPACE_VIEW3D) && (t->region->regiontype == RGN_TYPE_WINDOW)) {
-        View3D *v3d = t->view;
-        RegionView3D *rv3d = t->region->regiondata;
-        if ((rv3d->persp == RV3D_CAMOB) && v3d->camera) {
-          /* we could have a flag to easily check an object is being transformed */
-          if (v3d->camera->id.tag & LIB_TAG_DOIT) {
-            t->options |= CTX_CAMERA;
-          }
-        }
-        else if (v3d->ob_center && v3d->ob_center->id.tag & LIB_TAG_DOIT) {
+    /* Needed for correct Object.obmat after duplication, see: T62135. */
+    BKE_scene_graph_evaluated_ensure(t->depsgraph, CTX_data_main(t->context));
+
+    if ((t->settings->transform_flag & SCE_XFORM_DATA_ORIGIN) != 0) {
+      t->options |= CTX_OBMODE_XFORM_OBDATA;
+    }
+    if ((t->settings->transform_flag & SCE_XFORM_SKIP_CHILDREN) != 0) {
+      t->options |= CTX_OBMODE_XFORM_SKIP_CHILDREN;
+    }
+    TransConvertType_Object.createTransData(C, t);
+    /* Check if we're transforming the camera from the camera */
+    if ((t->spacetype == SPACE_VIEW3D) && (t->region->regiontype == RGN_TYPE_WINDOW)) {
+      View3D *v3d = t->view;
+      RegionView3D *rv3d = t->region->regiondata;
+      if ((rv3d->persp == RV3D_CAMOB) && v3d->camera) {
+        /* we could have a flag to easily check an object is being transformed */
+        if (v3d->camera->id.tag & LIB_TAG_DOIT) {
           t->options |= CTX_CAMERA;
         }
       }
-      break;
-    case TC_OBJECT_TEXSPACE:
-      createTransTexspace(t);
-      break;
-    case TC_PAINT_CURVE_VERTS:
-      createTransPaintCurveVerts(C, t);
-      break;
-    case TC_PARTICLE_VERTS:
-      createTransParticleVerts(t);
-      break;
-    case TC_SCULPT:
-      createTransSculpt(C, t);
-      break;
-    case TC_SEQ_DATA:
-      t->num.flag |= NUM_NO_FRACTION; /* sequencer has no use for floating point transform. */
-      createTransSeqData(t);
-      break;
-    case TC_SEQ_IMAGE_DATA:
+      else if (v3d->ob_center && v3d->ob_center->id.tag & LIB_TAG_DOIT) {
+        t->options |= CTX_CAMERA;
+      }
+    }
+  }
+  else {
+    if (t->data_type == &TransConvertType_Pose) {
+      t->options |= CTX_POSE_BONE;
+    }
+    else if (t->data_type == &TransConvertType_Sequencer) {
+      /* Sequencer has no use for floating point transform. */
+      t->num.flag |= NUM_NO_FRACTION;
+    }
+    else if (t->data_type == &TransConvertType_SequencerImage) {
       t->obedit_type = -1;
-      createTransSeqImageData(t);
-      break;
-    case TC_TRACKING_DATA:
-      createTransTrackingData(C, t);
-      break;
-    case TC_NONE:
-    default:
-      printf("edit type not implemented!\n");
-      BLI_assert(t->data_len_all == -1);
-      t->data_len_all = 0;
-      return;
+    }
+    t->data_type->createTransData(C, t);
   }
 
   countAndCleanTransDataContainer(t);
@@ -1590,92 +1391,10 @@ void transform_convert_flush_handle2D(TransData *td, TransData2D *td2d, const fl
 
 void recalcData(TransInfo *t)
 {
-  switch (t->data_type) {
-    case TC_ACTION_DATA:
-      recalcData_actedit(t);
-      break;
-    case TC_POSE:
-      recalcData_pose(t);
-      break;
-    case TC_ARMATURE_VERTS:
-      recalcData_edit_armature(t);
-      break;
-    case TC_CURVE_VERTS:
-      recalcData_curve(t);
-      break;
-    case TC_CURSOR_IMAGE:
-      recalcData_cursor_image(t);
-      break;
-    case TC_CURSOR_SEQUENCER:
-      recalcData_cursor_sequencer(t);
-      break;
-    case TC_CURSOR_VIEW3D:
-      recalcData_cursor_view3d(t);
-      break;
-    case TC_GRAPH_EDIT_DATA:
-      recalcData_graphedit(t);
-      break;
-    case TC_GPENCIL:
-      recalcData_gpencil_strokes(t);
-      break;
-    case TC_MASKING_DATA:
-      recalcData_mask_common(t);
-      break;
-    case TC_MESH_VERTS:
-      recalcData_mesh(t);
-      break;
-    case TC_MESH_EDGES:
-      recalcData_mesh_edge(t);
-      break;
-    case TC_MESH_SKIN:
-      recalcData_mesh_skin(t);
-      break;
-    case TC_MESH_UV:
-      recalcData_uv(t);
-      break;
-    case TC_MESH_VERT_CDATA:
-      recalcData_mesh_cdata(t);
-      break;
-    case TC_NLA_DATA:
-      recalcData_nla(t);
-      break;
-    case TC_NODE_DATA:
-      flushTransNodes(t);
-      break;
-    case TC_OBJECT:
-      recalcData_objects(t);
-      break;
-    case TC_OBJECT_TEXSPACE:
-      recalcData_texspace(t);
-      break;
-    case TC_PAINT_CURVE_VERTS:
-      flushTransPaintCurve(t);
-      break;
-    case TC_SCULPT:
-      recalcData_sculpt(t);
-      break;
-    case TC_SEQ_DATA:
-      recalcData_sequencer(t);
-      break;
-    case TC_SEQ_IMAGE_DATA:
-      recalcData_sequencer_image(t);
-      break;
-    case TC_TRACKING_DATA:
-      recalcData_tracking(t);
-      break;
-    case TC_MBALL_VERTS:
-      recalcData_mball(t);
-      break;
-    case TC_LATTICE_VERTS:
-      recalcData_lattice(t);
-      break;
-    case TC_PARTICLE_VERTS:
-      recalcData_particles(t);
-      break;
-    case TC_NONE:
-    default:
-      break;
+  if (!t->data_type || !t->data_type->recalcData) {
+    return;
   }
+  t->data_type->recalcData(t);
 }
 
 /** \} */
diff --git a/source/blender/editors/transform/transform_convert.h b/source/blender/editors/transform/transform_convert.h
index 1b7c33e443c..f32bff6dcff 100644
--- a/source/blender/editors/transform/transform_convert.h
+++ b/source/blender/editors/transform/transform_convert.h
@@ -21,6 +21,25 @@ struct TransDataCurveHandleFlags;
 struct TransInfo;
 struct bContext;
 
+typedef struct TransConvertTypeInfo {
+  int flags; /* eTFlag */
+
+  /**
+   * Allocate and initialize `t->data`.
+   */
+  void (*createTransData)(bContext *C, TransInfo *t);
+
+  /**
+   * Force recalculation of data during transformation.
+   */
+  void (*recalcData)(TransInfo *t);
+
+  /**
+   * Called when the operation is finished.
+   */
+  void (*special_aftertrans_update)(bContext *C, TransInfo *t);
+} TransConvertTypeInfo;
+
 /* transform_convert.c */
 
 /**
@@ -98,82 +117,53 @@ void animrecord_check_state(TransInfo *t, struct ID *id);
 
 /* transform_convert_action.c */
 
-void createTransActionData(bContext *C, TransInfo *t);
-/* helper for recalcData() - for Action Editor transforms */
-void recalcData_actedit(TransInfo *t);
-void special_aftertrans_update__actedit(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Action;
 
 /* transform_convert_armature.c */
 
+extern TransConvertTypeInfo TransConvertType_EditArmature;
+extern TransConvertTypeInfo TransConvertType_Pose;
+
 /**
  * Sets transform flags in the bones.
  * Returns total number of bones with #BONE_TRANSFORM.
  */
 void transform_convert_pose_transflags_update(Object *ob, int mode, short around);
 
-/**
- * When objects array is NULL, use 't->data_container' as is.
- */
-void createTransPose(TransInfo *t);
-void createTransArmatureVerts(TransInfo *t);
-void recalcData_edit_armature(TransInfo *t);
-void recalcData_pose(TransInfo *t);
-void special_aftertrans_update__pose(bContext *C, TransInfo *t);
-
 /* transform_convert_cursor.c */
 
-void createTransCursor_image(TransInfo *t);
-void createTransCursor_sequencer(TransInfo *t);
-void createTransCursor_view3d(TransInfo *t);
-void recalcData_cursor_image(TransInfo *t);
-void recalcData_cursor_sequencer(TransInfo *t);
-void recalcData_cursor_view3d(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_CursorImage;
+extern TransConvertTypeInfo TransConvertType_CursorSequencer;
+extern TransConvertTypeInfo TransConvertType_Cursor3D;
 
 /* transform_convert_curve.c */
 
-void createTransCurveVerts(TransInfo *t);
-void recalcData_curve(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Curve;
 
 /* transform_convert_graph.c */
 
-/**
- * It is important to note that this doesn't always act on the selection (like it's usually done),
- * it acts on a subset of it. E.g. the selection code may leave a hint that we just dragged on a
- * left or right handle (SIPO_RUNTIME_FLAG_TWEAK_HANDLES_LEFT/RIGHT) and then we only transform the
- * selected left or right handles accordingly.
- * The points to be transformed are tagged with BEZT_FLAG_TEMP_TAG; some lower level curve
- * functions may need to be made aware of this. It's ugly that these act based on selection state
- * anyway.
- */
-void createTransGraphEditData(bContext *C, TransInfo *t);
-/* helper for recalcData() - for Graph Editor transforms */
-void recalcData_graphedit(TransInfo *t);
-void special_aftertrans_update__graph(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Graph;
 
 /* transform_convert_gpencil.c */
 
-void createTransGPencil(bContext *C, TransInfo *t);
-/* force recalculation of triangles during transformation */
-void recalcData_gpencil_strokes(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_GPencil;
 
 /* transform_convert_lattice.c */
 
-void createTransLatticeVerts(TransInfo *t);
-void recalcData_lattice(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Lattice;
 
 /* transform_convert_mask.c */
 
-void createTransMaskingData(bContext *C, TransInfo *t);
-void recalcData_mask_common(TransInfo *t);
-void special_aftertrans_update__mask(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Mask;
 
 /* transform_convert_mball.c */
 
-void createTransMBallVerts(TransInfo *t);
-void recalcData_mball(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_MBall;
 
 /* transform_convert_mesh.c */
 
+extern TransConvertTypeInfo TransConvertType_Mesh;
+
 struct TransIslandData {
   float (*center)[3];
   float (*axismtx)[3][3];
@@ -232,89 +222,60 @@ void transform_convert_mesh_crazyspace_transdata_set(const float mtx[3][3],
                                                      struct TransData *r_td);
 void transform_convert_mesh_crazyspace_free(struct TransMeshDataCrazySpace *r_crazyspace_data);
 
-void createTransEditVerts(TransInfo *t);
-void recalcData_mesh(TransInfo *t);
 void special_aftertrans_update__mesh(bContext *C, TransInfo *t);
 
 /* transform_convert_mesh_edge.c */
 
-void createTransEdge(TransInfo *t);
-void recalcData_mesh_edge(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_MeshEdge;
 
 /* transform_convert_mesh_skin.c */
 
-void createTransMeshSkin(TransInfo *t);
-void recalcData_mesh_skin(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_MeshSkin;
 
 /* transform_convert_mesh_uv.c */
 
-void createTransUVs(bContext *C, TransInfo *t);
-/* helper for recalcData() - for Image Editor transforms */
-void recalcData_uv(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_MeshUV;
 
 /* transform_convert_mesh_vert_cdata.c */
 
-void createTransMeshVertCData(TransInfo *t);
-void recalcData_mesh_cdata(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_MeshVertCData;
 
 /* transform_convert_nla.c */
 
-void createTransNlaData(bContext *C, TransInfo *t);
-/* helper for recalcData() - for NLA Editor transforms */
-void recalcData_nla(TransInfo *t);
-void special_aftertrans_update__nla(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_NLA;
 
 /* transform_convert_node.c */
 
-void createTransNodeData(TransInfo *t);
-void flushTransNodes(TransInfo *t);
-void special_aftertrans_update__node(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Node;
 
 /* transform_convert_object.c */
 
-void createTransObject(bContext *C, TransInfo *t);
-/* helper for recalcData() - for object transforms, typically in the 3D view */
-void recalcData_objects(TransInfo *t);
-void special_aftertrans_update__object(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Object;
 
 /* transform_convert_object_texspace.c */
 
-void createTransTexspace(TransInfo *t);
-/* helper for recalcData() - for object transforms, typically in the 3D view */
-void recalcData_texspace(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_ObjectTexSpace;
 
 /* transform_convert_paintcurve.c */
 
-void createTransPaintCurveVerts(bContext *C, TransInfo *t);
-void flushTransPaintCurve(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_PaintCurve;
 
 /* transform_convert_particle.c */
 
-void createTransParticleVerts(TransInfo *t);
-void recalcData_particles(TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Particle;
 
 /* transform_convert_sculpt.c */
 
-void createTransSculpt(bContext *C, TransInfo *t);
-void recalcData_sculpt(TransInfo *t);
-void special_aftertrans_update__sculpt(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Sculpt;
 
 /* transform_convert_sequencer.c */
 
-void createTransSeqData(TransInfo *t);
-/* helper for recalcData() - for sequencer transforms */
-void recalcData_sequencer(TransInfo *t);
-void special_aftertrans_update__sequencer(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Sequencer;
 
 /* transform_convert_sequencer_image.c */
 
-void createTransSeqImageData(TransInfo *t);
-void recalcData_sequencer_image(TransInfo *t);
-void special_aftertrans_update__sequencer_image(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_SequencerImage;
 
 /* transform_convert_tracking.c */
 
-void createTransTrackingData(bContext *C, TransInfo *t);
-/* helper for recalcData() - for Movie Clip transforms */
-void recalcData_tracking(TransInfo *t);
-void special_aftertrans_update__movieclip(bContext *C, TransInfo *t);
+extern TransConvertTypeInfo TransConvertType_Tracking;
diff --git a/source/blender/editors/transform/transform_convert_action.c b/source/blender/editors/transform/transform_convert_action.c
index 71a78321e12..41635522d26 100644
--- a/source/blender/editors/transform/transform_convert_action.c
+++ b/source/blender/editors/transform/transform_convert_action.c
@@ -289,7 +289,7 @@ static int MaskLayerToTransData(TransData *td,
   return count;
 }
 
-void createTransActionData(bContext *C, TransInfo *t)
+static void createTransActionData(bContext *C, TransInfo *t)
 {
   Scene *scene = t->scene;
   TransData *td = NULL;
@@ -565,7 +565,7 @@ static void flushTransIntFrameActionData(TransInfo *t)
   }
 }
 
-void recalcData_actedit(TransInfo *t)
+static void recalcData_actedit(TransInfo *t)
 {
   ViewLayer *view_layer = t->view_layer;
   SpaceAction *saction = (SpaceAction *)t->area->spacedata.first;
@@ -759,7 +759,7 @@ static void posttrans_action_clean(bAnimContext *ac, bAction *act)
   ANIM_animdata_freelist(&anim_data);
 }
 
-void special_aftertrans_update__actedit(bContext *C, TransInfo *t)
+static void special_aftertrans_update__actedit(bContext *C, TransInfo *t)
 {
   SpaceAction *saction = (SpaceAction *)t->area->spacedata.first;
   bAnimContext ac;
@@ -926,3 +926,10 @@ void special_aftertrans_update__actedit(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Action = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransActionData,
+    /* recalcData */ recalcData_actedit,
+    /* special_aftertrans_update */ special_aftertrans_update__actedit,
+};
diff --git a/source/blender/editors/transform/transform_convert_armature.c b/source/blender/editors/transform/transform_convert_armature.c
index 1613218ca29..97d9ab2964a 100644
--- a/source/blender/editors/transform/transform_convert_armature.c
+++ b/source/blender/editors/transform/transform_convert_armature.c
@@ -701,7 +701,7 @@ static void add_pose_transdata(TransInfo *t, bPoseChannel *pchan, Object *ob, Tr
   td->con = pchan->constraints.first;
 }
 
-void createTransPose(TransInfo *t)
+static void createTransPose(bContext *UNUSED(C), TransInfo *t)
 {
   Main *bmain = CTX_data_main(t->context);
 
@@ -879,7 +879,7 @@ void createTransPose(TransInfo *t)
   }
 }
 
-void createTransArmatureVerts(TransInfo *t)
+static void createTransArmatureVerts(bContext *UNUSED(C), TransInfo *t)
 {
   t->data_len_all = 0;
 
@@ -1189,7 +1189,7 @@ static void restoreBones(TransDataContainer *tc)
   }
 }
 
-void recalcData_edit_armature(TransInfo *t)
+static void recalcData_edit_armature(TransInfo *t)
 {
   if (t->state != TRANS_CANCEL) {
     applySnappingIndividual(t);
@@ -1412,7 +1412,7 @@ static void restoreMirrorPoseBones(TransDataContainer *tc)
   }
 }
 
-void recalcData_pose(TransInfo *t)
+static void recalcData_pose(TransInfo *t)
 {
   if (t->mode == TFM_BONESIZE) {
     /* Handle the exception where for TFM_BONESIZE in edit mode we pretend to be
@@ -1684,7 +1684,7 @@ static void pose_grab_with_ik_clear(Main *bmain, Object *ob)
   }
 }
 
-void special_aftertrans_update__pose(bContext *C, TransInfo *t)
+static void special_aftertrans_update__pose(bContext *C, TransInfo *t)
 {
   Object *ob;
 
@@ -1768,3 +1768,17 @@ void special_aftertrans_update__pose(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_EditArmature = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransArmatureVerts,
+    /* recalcData */ recalcData_edit_armature,
+    /* special_aftertrans_update */ NULL,
+};
+
+TransConvertTypeInfo TransConvertType_Pose = {
+    /* flags */ 0,
+    /* createTransData */ createTransPose,
+    /* recalcData */ recalcData_pose,
+    /* special_aftertrans_update */ special_aftertrans_update__pose,
+};
diff --git a/source/blender/editors/transform/transform_convert_cursor.c b/source/blender/editors/transform/transform_convert_cursor.c
index 5e6eee192f2..0bf6f06a9f2 100644
--- a/source/blender/editors/transform/transform_convert_cursor.c
+++ b/source/blender/editors/transform/transform_convert_cursor.c
@@ -82,13 +82,13 @@ static void recalcData_cursor_2D_impl(TransInfo *t)
 /** \name Image Cursor
  * \{ */
 
-void createTransCursor_image(TransInfo *t)
+static void createTransCursor_image(bContext *UNUSED(C), TransInfo *t)
 {
   SpaceImage *sima = t->area->spacedata.first;
   createTransCursor_2D_impl(t, sima->cursor);
 }
 
-void recalcData_cursor_image(TransInfo *t)
+static void recalcData_cursor_image(TransInfo *t)
 {
   recalcData_cursor_2D_impl(t);
 }
@@ -99,7 +99,7 @@ void recalcData_cursor_image(TransInfo *t)
 /** \name Sequencer Cursor
  * \{ */
 
-void createTransCursor_sequencer(TransInfo *t)
+static void createTransCursor_sequencer(bContext *UNUSED(C), TransInfo *t)
 {
   SpaceSeq *sseq = t->area->spacedata.first;
   if (sseq->mainb != SEQ_DRAW_IMG_IMBUF) {
@@ -108,7 +108,7 @@ void createTransCursor_sequencer(TransInfo *t)
   createTransCursor_2D_impl(t, sseq->cursor);
 }
 
-void recalcData_cursor_sequencer(TransInfo *t)
+static void recalcData_cursor_sequencer(TransInfo *t)
 {
   recalcData_cursor_2D_impl(t);
 }
@@ -119,7 +119,7 @@ void recalcData_cursor_sequencer(TransInfo *t)
 /** \name View 3D Cursor
  * \{ */
 
-void createTransCursor_view3d(TransInfo *t)
+static void createTransCursor_view3d(bContext *UNUSED(C), TransInfo *t)
 {
   TransData *td;
 
@@ -178,9 +178,30 @@ void createTransCursor_view3d(TransInfo *t)
   td->ext->rotOrder = cursor->rotation_mode;
 }
 
-void recalcData_cursor_view3d(TransInfo *t)
+static void recalcData_cursor_view3d(TransInfo *t)
 {
   DEG_id_tag_update(&t->scene->id, ID_RECALC_COPY_ON_WRITE);
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_CursorImage = {
+    /* flags */ T_2D_EDIT,
+    /* createTransData */ createTransCursor_image,
+    /* recalcData */ recalcData_cursor_image,
+    /* special_aftertrans_update */ NULL,
+};
+
+TransConvertTypeInfo TransConvertType_CursorSequencer = {
+    /* flags */ T_2D_EDIT,
+    /* createTransData */ createTransCursor_sequencer,
+    /* recalcData */ recalcData_cursor_sequencer,
+    /* special_aftertrans_update */ NULL,
+};
+
+TransConvertTypeInfo TransConvertType_Cursor3D = {
+    /* flags */ 0,
+    /* createTransData */ createTransCursor_view3d,
+    /* recalcData */ recalcData_cursor_view3d,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_curve.c b/source/blender/editors/transform/transform_convert_curve.c
index b9581aa1e31..404b1293208 100644
--- a/source/blender/editors/transform/transform_convert_curve.c
+++ b/source/blender/editors/transform/transform_convert_curve.c
@@ -62,7 +62,7 @@ static int bezt_select_to_transform_triple_flag(const BezTriple *bezt, const boo
   return flag;
 }
 
-void createTransCurveVerts(TransInfo *t)
+static void createTransCurveVerts(bContext *UNUSED(C), TransInfo *t)
 {
 
 #define SEL_F1 (1 << 0)
@@ -415,7 +415,7 @@ void createTransCurveVerts(TransInfo *t)
 #undef SEL_F3
 }
 
-void recalcData_curve(TransInfo *t)
+static void recalcData_curve(TransInfo *t)
 {
   if (t->state != TRANS_CANCEL) {
     applySnappingIndividual(t);
@@ -446,3 +446,10 @@ void recalcData_curve(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Curve = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransCurveVerts,
+    /* recalcData */ recalcData_curve,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_gpencil.c b/source/blender/editors/transform/transform_convert_gpencil.c
index 4bd02b0a45b..0029eaefaba 100644
--- a/source/blender/editors/transform/transform_convert_gpencil.c
+++ b/source/blender/editors/transform/transform_convert_gpencil.c
@@ -672,7 +672,7 @@ static void createTransGPencil_strokes(bContext *C,
   }
 }
 
-void createTransGPencil(bContext *C, TransInfo *t)
+static void createTransGPencil(bContext *C, TransInfo *t)
 {
   if (t->data_container_len == 0) {
     return;
@@ -737,7 +737,7 @@ void createTransGPencil(bContext *C, TransInfo *t)
   }
 }
 
-void recalcData_gpencil_strokes(TransInfo *t)
+static void recalcData_gpencil_strokes(TransInfo *t)
 {
   TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
   GHash *strokes = BLI_ghash_ptr_new(__func__);
@@ -762,3 +762,10 @@ void recalcData_gpencil_strokes(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_GPencil = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransGPencil,
+    /* recalcData */ recalcData_gpencil_strokes,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_graph.c b/source/blender/editors/transform/transform_convert_graph.c
index b57f5b78939..aca2439d5fb 100644
--- a/source/blender/editors/transform/transform_convert_graph.c
+++ b/source/blender/editors/transform/transform_convert_graph.c
@@ -199,7 +199,16 @@ static void graph_key_shortest_dist(
   }
 }
 
-void createTransGraphEditData(bContext *C, TransInfo *t)
+/**
+ * It is important to note that this doesn't always act on the selection (like it's usually done),
+ * it acts on a subset of it. E.g. the selection code may leave a hint that we just dragged on a
+ * left or right handle (SIPO_RUNTIME_FLAG_TWEAK_HANDLES_LEFT/RIGHT) and then we only transform the
+ * selected left or right handles accordingly.
+ * The points to be transformed are tagged with BEZT_FLAG_TEMP_TAG; some lower level curve
+ * functions may need to be made aware of this. It's ugly that these act based on selection state
+ * anyway.
+ */
+static void createTransGraphEditData(bContext *C, TransInfo *t)
 {
   SpaceGraph *sipo = (SpaceGraph *)t->area->spacedata.first;
   Scene *scene = t->scene;
@@ -886,7 +895,7 @@ static void remake_graph_transdata(TransInfo *t, ListBase *anim_data)
   }
 }
 
-void recalcData_graphedit(TransInfo *t)
+static void recalcData_graphedit(TransInfo *t)
 {
   SpaceGraph *sipo = (SpaceGraph *)t->area->spacedata.first;
   ViewLayer *view_layer = t->view_layer;
@@ -960,7 +969,7 @@ void recalcData_graphedit(TransInfo *t)
 /** \name Special After Transform Graph
  * \{ */
 
-void special_aftertrans_update__graph(bContext *C, TransInfo *t)
+static void special_aftertrans_update__graph(bContext *C, TransInfo *t)
 {
   SpaceGraph *sipo = (SpaceGraph *)t->area->spacedata.first;
   bAnimContext ac;
@@ -1021,3 +1030,10 @@ void special_aftertrans_update__graph(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Graph = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransGraphEditData,
+    /* recalcData */ recalcData_graphedit,
+    /* special_aftertrans_update */ special_aftertrans_update__graph,
+};
diff --git a/source/blender/editors/transform/transform_convert_lattice.c b/source/blender/editors/transform/transform_convert_lattice.c
index d3c34697237..b77538dc249 100644
--- a/source/blender/editors/transform/transform_convert_lattice.c
+++ b/source/blender/editors/transform/transform_convert_lattice.c
@@ -25,7 +25,7 @@
 /** \name Curve/Surfaces Transform Creation
  * \{ */
 
-void createTransLatticeVerts(TransInfo *t)
+static void createTransLatticeVerts(bContext *UNUSED(C), TransInfo *t)
 {
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
 
@@ -98,7 +98,7 @@ void createTransLatticeVerts(TransInfo *t)
   }
 }
 
-void recalcData_lattice(TransInfo *t)
+static void recalcData_lattice(TransInfo *t)
 {
   if (t->state != TRANS_CANCEL) {
     applySnappingIndividual(t);
@@ -114,3 +114,10 @@ void recalcData_lattice(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Lattice = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransLatticeVerts,
+    /* recalcData */ recalcData_lattice,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_mask.c b/source/blender/editors/transform/transform_convert_mask.c
index f035cfc7aa9..2dca59a5da1 100644
--- a/source/blender/editors/transform/transform_convert_mask.c
+++ b/source/blender/editors/transform/transform_convert_mask.c
@@ -245,7 +245,7 @@ static void MaskPointToTransData(Scene *scene,
   }
 }
 
-void createTransMaskingData(bContext *C, TransInfo *t)
+static void createTransMaskingData(bContext *C, TransInfo *t)
 {
   Scene *scene = CTX_data_scene(C);
   Mask *mask = CTX_data_edit_mask(C);
@@ -416,7 +416,7 @@ static void flushTransMasking(TransInfo *t)
   }
 }
 
-void recalcData_mask_common(TransInfo *t)
+static void recalcData_mask_common(TransInfo *t)
 {
   Mask *mask = CTX_data_edit_mask(t->context);
 
@@ -431,7 +431,7 @@ void recalcData_mask_common(TransInfo *t)
 /** \name Special After Transform Mask
  * \{ */
 
-void special_aftertrans_update__mask(bContext *C, TransInfo *t)
+static void special_aftertrans_update__mask(bContext *C, TransInfo *t)
 {
   Mask *mask = NULL;
 
@@ -463,3 +463,10 @@ void special_aftertrans_update__mask(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Mask = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransMaskingData,
+    /* recalcData */ recalcData_mask_common,
+    /* special_aftertrans_update */ special_aftertrans_update__mask,
+};
diff --git a/source/blender/editors/transform/transform_convert_mball.c b/source/blender/editors/transform/transform_convert_mball.c
index 5b2a1f8336d..7ae93524d0b 100644
--- a/source/blender/editors/transform/transform_convert_mball.c
+++ b/source/blender/editors/transform/transform_convert_mball.c
@@ -22,7 +22,7 @@
 /** \name Meta Elements Transform Creation
  * \{ */
 
-void createTransMBallVerts(TransInfo *t)
+static void createTransMBallVerts(bContext *UNUSED(C), TransInfo *t)
 {
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
     MetaBall *mb = (MetaBall *)tc->obedit->data;
@@ -119,7 +119,7 @@ void createTransMBallVerts(TransInfo *t)
 /** \name Recalc Meta Ball
  * \{ */
 
-void recalcData_mball(TransInfo *t)
+static void recalcData_mball(TransInfo *t)
 {
   if (t->state != TRANS_CANCEL) {
     applySnappingIndividual(t);
@@ -132,3 +132,10 @@ void recalcData_mball(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_MBall = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransMBallVerts,
+    /* recalcData */ recalcData_mball,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_mesh.c b/source/blender/editors/transform/transform_convert_mesh.c
index de736fad94e..b5a85f57b84 100644
--- a/source/blender/editors/transform/transform_convert_mesh.c
+++ b/source/blender/editors/transform/transform_convert_mesh.c
@@ -1454,7 +1454,7 @@ static void VertsToTransData(TransInfo *t,
   }
 }
 
-void createTransEditVerts(TransInfo *t)
+static void createTransEditVerts(bContext *UNUSED(C), TransInfo *t)
 {
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
     TransDataExtension *tx = NULL;
@@ -2029,7 +2029,7 @@ static void tc_mesh_transdata_mirror_apply(TransDataContainer *tc)
   }
 }
 
-void recalcData_mesh(TransInfo *t)
+static void recalcData_mesh(TransInfo *t)
 {
   bool is_canceling = t->state == TRANS_CANCEL;
   /* Apply corrections. */
@@ -2129,3 +2129,10 @@ void special_aftertrans_update__mesh(bContext *UNUSED(C), TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Mesh = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransEditVerts,
+    /* recalcData */ recalcData_mesh,
+    /* special_aftertrans_update */ special_aftertrans_update__mesh,
+};
diff --git a/source/blender/editors/transform/transform_convert_mesh_edge.c b/source/blender/editors/transform/transform_convert_mesh_edge.c
index 4a8ddb78587..becf3c7ce5a 100644
--- a/source/blender/editors/transform/transform_convert_mesh_edge.c
+++ b/source/blender/editors/transform/transform_convert_mesh_edge.c
@@ -23,7 +23,7 @@
 /** \name Edge (for crease) Transform Creation
  * \{ */
 
-void createTransEdge(TransInfo *t)
+static void createTransEdge(bContext *UNUSED(C), TransInfo *t)
 {
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
 
@@ -108,7 +108,7 @@ void createTransEdge(TransInfo *t)
   }
 }
 
-void recalcData_mesh_edge(TransInfo *t)
+static void recalcData_mesh_edge(TransInfo *t)
 {
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
     DEG_id_tag_update(tc->obedit->data, ID_RECALC_GEOMETRY);
@@ -116,3 +116,10 @@ void recalcData_mesh_edge(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_MeshEdge = {
+    /* flags */ T_EDIT,
+    /* createTransData */ createTransEdge,
+    /* recalcData */ recalcData_mesh_edge,
+    /* special_aftertrans_update */ special_aftertrans_update__mesh,
+};
diff --git a/source/blender/editors/transform/transform_convert_mesh_skin.c b/source/blender/editors/transform/transform_convert_mesh_skin.c
index fdc2ba59035..376e559181e 100644
--- a/source/blender/editors/transform/transform_convert_mesh_skin.c
+++ b/source/blender/editors/transform/transform_convert_mesh_skin.c
@@ -66,7 +66,7 @@ static void tc_mesh_skin_transdata_create(TransDataBasic *td,
   td->extra = eve;
 }
 
-void createTransMeshSkin(TransInfo *t)
+static void createTransMeshSkin(bContext *UNUSED(C), TransInfo *t)
 {
   BLI_assert(t->mode == TFM_SKIN_RESIZE);
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
@@ -271,7 +271,7 @@ static void tc_mesh_skin_apply_to_mirror(TransInfo *t)
   }
 }
 
-void recalcData_mesh_skin(TransInfo *t)
+static void recalcData_mesh_skin(TransInfo *t)
 {
   bool is_canceling = t->state == TRANS_CANCEL;
   /* mirror modifier clipping? */
@@ -289,3 +289,10 @@ void recalcData_mesh_skin(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_MeshSkin = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransMeshSkin,
+    /* recalcData */ recalcData_mesh_skin,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_mesh_uv.c b/source/blender/editors/transform/transform_convert_mesh_uv.c
index bb550909407..d95bc7b976f 100644
--- a/source/blender/editors/transform/transform_convert_mesh_uv.c
+++ b/source/blender/editors/transform/transform_convert_mesh_uv.c
@@ -234,7 +234,7 @@ static void uv_set_connectivity_distance(BMesh *bm, float *dists, const float as
   MEM_freeN(dists_prev);
 }
 
-void createTransUVs(bContext *C, TransInfo *t)
+static void createTransUVs(bContext *C, TransInfo *t)
 {
   SpaceImage *sima = CTX_wm_space_image(C);
   Scene *scene = t->scene;
@@ -446,7 +446,7 @@ static void flushTransUVs(TransInfo *t)
   }
 }
 
-void recalcData_uv(TransInfo *t)
+static void recalcData_uv(TransInfo *t)
 {
   SpaceImage *sima = t->area->spacedata.first;
 
@@ -463,3 +463,10 @@ void recalcData_uv(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_MeshUV = {
+    /* flags */ (T_EDIT | T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransUVs,
+    /* recalcData */ recalcData_uv,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_mesh_vert_cdata.c b/source/blender/editors/transform/transform_convert_mesh_vert_cdata.c
index 104b45de138..f05688f3325 100644
--- a/source/blender/editors/transform/transform_convert_mesh_vert_cdata.c
+++ b/source/blender/editors/transform/transform_convert_mesh_vert_cdata.c
@@ -60,7 +60,7 @@ static void tc_mesh_cdata_transdata_create(TransDataBasic *td,
   td->extra = eve;
 }
 
-void createTransMeshVertCData(TransInfo *t)
+static void createTransMeshVertCData(bContext *UNUSED(C), TransInfo *t)
 {
   BLI_assert(ELEM(t->mode, TFM_BWEIGHT, TFM_VERT_CREASE));
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
@@ -269,7 +269,7 @@ static void tc_mesh_cdata_apply_to_mirror(TransInfo *t)
   }
 }
 
-void recalcData_mesh_cdata(TransInfo *t)
+static void recalcData_mesh_cdata(TransInfo *t)
 {
   bool is_canceling = t->state == TRANS_CANCEL;
   /* mirror modifier clipping? */
@@ -287,3 +287,10 @@ void recalcData_mesh_cdata(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_MeshVertCData = {
+    /* flags */ (T_EDIT | T_POINTS),
+    /* createTransData */ createTransMeshVertCData,
+    /* recalcData */ recalcData_mesh_cdata,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_nla.c b/source/blender/editors/transform/transform_convert_nla.c
index 32f70fc010b..cfa933d1600 100644
--- a/source/blender/editors/transform/transform_convert_nla.c
+++ b/source/blender/editors/transform/transform_convert_nla.c
@@ -59,7 +59,7 @@ typedef struct TransDataNla {
 /** \name NLA Transform Creation
  * \{ */
 
-void createTransNlaData(bContext *C, TransInfo *t)
+static void createTransNlaData(bContext *C, TransInfo *t)
 {
   Scene *scene = t->scene;
   SpaceNla *snla = NULL;
@@ -249,7 +249,7 @@ void createTransNlaData(bContext *C, TransInfo *t)
   ANIM_animdata_freelist(&anim_data);
 }
 
-void recalcData_nla(TransInfo *t)
+static void recalcData_nla(TransInfo *t)
 {
   SpaceNla *snla = (SpaceNla *)t->area->spacedata.first;
 
@@ -464,7 +464,7 @@ void recalcData_nla(TransInfo *t)
 /** \name Special After Transform NLA
  * \{ */
 
-void special_aftertrans_update__nla(bContext *C, TransInfo *UNUSED(t))
+static void special_aftertrans_update__nla(bContext *C, TransInfo *UNUSED(t))
 {
   bAnimContext ac;
 
@@ -506,3 +506,10 @@ void special_aftertrans_update__nla(bContext *C, TransInfo *UNUSED(t))
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_NLA = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransNlaData,
+    /* recalcData */ recalcData_nla,
+    /* special_aftertrans_update */ special_aftertrans_update__nla,
+};
diff --git a/source/blender/editors/transform/transform_convert_node.c b/source/blender/editors/transform/transform_convert_node.c
index 8281052c314..e18f75b71ae 100644
--- a/source/blender/editors/transform/transform_convert_node.c
+++ b/source/blender/editors/transform/transform_convert_node.c
@@ -89,7 +89,7 @@ static bool is_node_parent_select(bNode *node)
   return false;
 }
 
-void createTransNodeData(TransInfo *t)
+static void createTransNodeData(bContext *UNUSED(C), TransInfo *t)
 {
   const float dpi_fac = UI_DPI_FAC;
   SpaceNode *snode = t->area->spacedata.first;
@@ -150,7 +150,7 @@ void createTransNodeData(TransInfo *t)
 /** \name Node Transform Creation
  * \{ */
 
-void flushTransNodes(TransInfo *t)
+static void flushTransNodes(TransInfo *t)
 {
   const float dpi_fac = UI_DPI_FAC;
 
@@ -220,7 +220,7 @@ void flushTransNodes(TransInfo *t)
 /** \name Special After Transform Node
  * \{ */
 
-void special_aftertrans_update__node(bContext *C, TransInfo *t)
+static void special_aftertrans_update__node(bContext *C, TransInfo *t)
 {
   struct Main *bmain = CTX_data_main(C);
   const bool canceled = (t->state == TRANS_CANCEL);
@@ -249,3 +249,10 @@ void special_aftertrans_update__node(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Node = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransNodeData,
+    /* recalcData */ flushTransNodes,
+    /* special_aftertrans_update */ special_aftertrans_update__node,
+};
diff --git a/source/blender/editors/transform/transform_convert_object.c b/source/blender/editors/transform/transform_convert_object.c
index 26d57ae1e58..be5f59c61c0 100644
--- a/source/blender/editors/transform/transform_convert_object.c
+++ b/source/blender/editors/transform/transform_convert_object.c
@@ -480,7 +480,7 @@ static void clear_trans_object_base_flags(TransInfo *t)
   }
 }
 
-void createTransObject(bContext *C, TransInfo *t)
+static void createTransObject(bContext *C, TransInfo *t)
 {
   Main *bmain = CTX_data_main(C);
   TransData *td = NULL;
@@ -860,7 +860,7 @@ static bool motionpath_need_update_object(Scene *scene, Object *ob)
 /** \name Recalc Data object
  * \{ */
 
-void recalcData_objects(TransInfo *t)
+static void recalcData_objects(TransInfo *t)
 {
   bool motionpath_update = false;
 
@@ -918,7 +918,7 @@ void recalcData_objects(TransInfo *t)
 /** \name Special After Transform Object
  * \{ */
 
-void special_aftertrans_update__object(bContext *C, TransInfo *t)
+static void special_aftertrans_update__object(bContext *C, TransInfo *t)
 {
   BLI_assert(t->options & CTX_OBJECT);
 
@@ -991,3 +991,10 @@ void special_aftertrans_update__object(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Object = {
+    /* flags */ 0,
+    /* createTransData */ createTransObject,
+    /* recalcData */ recalcData_objects,
+    /* special_aftertrans_update */ special_aftertrans_update__object,
+};
diff --git a/source/blender/editors/transform/transform_convert_object_texspace.c b/source/blender/editors/transform/transform_convert_object_texspace.c
index e5a66f8a1d2..39bf22a9af9 100644
--- a/source/blender/editors/transform/transform_convert_object_texspace.c
+++ b/source/blender/editors/transform/transform_convert_object_texspace.c
@@ -29,7 +29,7 @@
  *
  * \{ */
 
-void createTransTexspace(TransInfo *t)
+static void createTransTexspace(bContext *UNUSED(C), TransInfo *t)
 {
   ViewLayer *view_layer = t->view_layer;
   TransData *td;
@@ -86,7 +86,7 @@ void createTransTexspace(TransInfo *t)
 /** \name Recalc Data object
  * \{ */
 
-void recalcData_texspace(TransInfo *t)
+static void recalcData_texspace(TransInfo *t)
 {
 
   if (t->state != TRANS_CANCEL) {
@@ -106,3 +106,10 @@ void recalcData_texspace(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_ObjectTexSpace = {
+    /* flags */ 0,
+    /* createTransData */ createTransTexspace,
+    /* recalcData */ recalcData_texspace,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_paintcurve.c b/source/blender/editors/transform/transform_convert_paintcurve.c
index b2566016496..61b1cb9493b 100644
--- a/source/blender/editors/transform/transform_convert_paintcurve.c
+++ b/source/blender/editors/transform/transform_convert_paintcurve.c
@@ -108,7 +108,7 @@ static void PaintCurvePointToTransData(PaintCurvePoint *pcp,
   }
 }
 
-void createTransPaintCurveVerts(bContext *C, TransInfo *t)
+static void createTransPaintCurveVerts(bContext *C, TransInfo *t)
 {
   Paint *paint = BKE_paint_get_active_from_context(C);
   PaintCurve *pc;
@@ -188,7 +188,7 @@ void createTransPaintCurveVerts(bContext *C, TransInfo *t)
 /** \name Paint Curve Transform Flush
  * \{ */
 
-void flushTransPaintCurve(TransInfo *t)
+static void flushTransPaintCurve(TransInfo *t)
 {
   int i;
 
@@ -204,3 +204,10 @@ void flushTransPaintCurve(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_PaintCurve = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransPaintCurveVerts,
+    /* recalcData */ flushTransPaintCurve,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_particle.c b/source/blender/editors/transform/transform_convert_particle.c
index 31e73288ad0..41f37b34af0 100644
--- a/source/blender/editors/transform/transform_convert_particle.c
+++ b/source/blender/editors/transform/transform_convert_particle.c
@@ -28,7 +28,7 @@
 /** \name Particle Edit Transform Creation
  * \{ */
 
-void createTransParticleVerts(TransInfo *t)
+static void createTransParticleVerts(bContext *UNUSED(C), TransInfo *t)
 {
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
 
@@ -235,7 +235,7 @@ static void flushTransParticles(TransInfo *t)
 /** \name Recalc Transform Particles Data
  * \{ */
 
-void recalcData_particles(TransInfo *t)
+static void recalcData_particles(TransInfo *t)
 {
   if (t->state != TRANS_CANCEL) {
     applySnappingIndividual(t);
@@ -244,3 +244,10 @@ void recalcData_particles(TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Particle = {
+    /* flags */ T_POINTS,
+    /* createTransData */ createTransParticleVerts,
+    /* recalcData */ recalcData_particles,
+    /* special_aftertrans_update */ NULL,
+};
diff --git a/source/blender/editors/transform/transform_convert_sculpt.c b/source/blender/editors/transform/transform_convert_sculpt.c
index 5bf6bfa8644..95958b816ab 100644
--- a/source/blender/editors/transform/transform_convert_sculpt.c
+++ b/source/blender/editors/transform/transform_convert_sculpt.c
@@ -23,7 +23,7 @@
 /** \name Sculpt Transform Creation
  * \{ */
 
-void createTransSculpt(bContext *C, TransInfo *t)
+static void createTransSculpt(bContext *C, TransInfo *t)
 {
   TransData *td;
 
@@ -94,13 +94,13 @@ void createTransSculpt(bContext *C, TransInfo *t)
 /** \name Recalc Data object
  * \{ */
 
-void recalcData_sculpt(TransInfo *t)
+static void recalcData_sculpt(TransInfo *t)
 {
   Object *ob = OBACT(t->view_layer);
   ED_sculpt_update_modal_transform(t->context, ob);
 }
 
-void special_aftertrans_update__sculpt(bContext *C, TransInfo *t)
+static void special_aftertrans_update__sculpt(bContext *C, TransInfo *t)
 {
   Scene *scene = t->scene;
   if (!BKE_id_is_editable(CTX_data_main(C), &scene->id)) {
@@ -114,3 +114,10 @@ void special_aftertrans_update__sculpt(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Sculpt = {
+    /* flags */ 0,
+    /* createTransData */ createTransSculpt,
+    /* recalcData */ recalcData_sculpt,
+    /* special_aftertrans_update */ special_aftertrans_update__sculpt,
+};
diff --git a/source/blender/editors/transform/transform_convert_sequencer.c b/source/blender/editors/transform/transform_convert_sequencer.c
index dcc1739606f..eefc9d0cc2a 100644
--- a/source/blender/editors/transform/transform_convert_sequencer.c
+++ b/source/blender/editors/transform/transform_convert_sequencer.c
@@ -465,7 +465,7 @@ static SeqCollection *query_time_dependent_strips_strips(TransInfo *t)
   return dependent;
 }
 
-void createTransSeqData(TransInfo *t)
+static void createTransSeqData(bContext *UNUSED(C), TransInfo *t)
 {
   Scene *scene = t->scene;
   Editing *ed = SEQ_editing_get(t->scene);
@@ -659,7 +659,7 @@ static void flushTransSeq(TransInfo *t)
   SEQ_collection_free(transformed_strips);
 }
 
-void recalcData_sequencer(TransInfo *t)
+static void recalcData_sequencer(TransInfo *t)
 {
   TransData *td;
   int a;
@@ -689,7 +689,7 @@ void recalcData_sequencer(TransInfo *t)
 /** \name Special After Transform Sequencer
  * \{ */
 
-void special_aftertrans_update__sequencer(bContext *UNUSED(C), TransInfo *t)
+static void special_aftertrans_update__sequencer(bContext *UNUSED(C), TransInfo *t)
 {
   if (t->state == TRANS_CANCEL) {
     return;
@@ -734,3 +734,10 @@ void transform_convert_sequencer_channel_clamp(TransInfo *t, float r_val[2])
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Sequencer = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransSeqData,
+    /* recalcData */ recalcData_sequencer,
+    /* special_aftertrans_update */ special_aftertrans_update__sequencer,
+};
diff --git a/source/blender/editors/transform/transform_convert_sequencer_image.c b/source/blender/editors/transform/transform_convert_sequencer_image.c
index 8be454b540c..3d0c3ddaa4c 100644
--- a/source/blender/editors/transform/transform_convert_sequencer_image.c
+++ b/source/blender/editors/transform/transform_convert_sequencer_image.c
@@ -105,7 +105,7 @@ static void freeSeqData(TransInfo *UNUSED(t),
   MEM_freeN(td->extra);
 }
 
-void createTransSeqImageData(TransInfo *t)
+static void createTransSeqImageData(bContext *UNUSED(C), TransInfo *t)
 {
   Editing *ed = SEQ_editing_get(t->scene);
   const SpaceSeq *sseq = t->area->spacedata.first;
@@ -191,7 +191,7 @@ static bool autokeyframe_sequencer_image(bContext *C,
   return changed;
 }
 
-void recalcData_sequencer_image(TransInfo *t)
+static void recalcData_sequencer_image(TransInfo *t)
 {
   TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
   TransData *td = NULL;
@@ -247,7 +247,7 @@ void recalcData_sequencer_image(TransInfo *t)
   }
 }
 
-void special_aftertrans_update__sequencer_image(bContext *UNUSED(C), TransInfo *t)
+static void special_aftertrans_update__sequencer_image(bContext *UNUSED(C), TransInfo *t)
 {
 
   TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
@@ -271,3 +271,10 @@ void special_aftertrans_update__sequencer_image(bContext *UNUSED(C), TransInfo *
     }
   }
 }
+
+TransConvertTypeInfo TransConvertType_SequencerImage = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransSeqImageData,
+    /* recalcData */ recalcData_sequencer_image,
+    /* special_aftertrans_update */ special_aftertrans_update__sequencer_image,
+};
diff --git a/source/blender/editors/transform/transform_convert_tracking.c b/source/blender/editors/transform/transform_convert_tracking.c
index d447cd71a40..c0c660289a5 100644
--- a/source/blender/editors/transform/transform_convert_tracking.c
+++ b/source/blender/editors/transform/transform_convert_tracking.c
@@ -518,7 +518,7 @@ static void createTransTrackingCurvesData(bContext *C, TransInfo *t)
   }
 }
 
-void createTransTrackingData(bContext *C, TransInfo *t)
+static void createTransTrackingData(bContext *C, TransInfo *t)
 {
   ARegion *region = CTX_wm_region(C);
   SpaceClip *sc = CTX_wm_space_clip(C);
@@ -694,7 +694,7 @@ static void flushTransTracking(TransInfo *t)
   }
 }
 
-void recalcData_tracking(TransInfo *t)
+static void recalcData_tracking(TransInfo *t)
 {
   SpaceClip *sc = t->area->spacedata.first;
 
@@ -747,7 +747,7 @@ void recalcData_tracking(TransInfo *t)
 /** \name Special After Transform Tracking
  * \{ */
 
-void special_aftertrans_update__movieclip(bContext *C, TransInfo *t)
+static void special_aftertrans_update__movieclip(bContext *C, TransInfo *t)
 {
   SpaceClip *sc = t->area->spacedata.first;
   MovieClip *clip = ED_space_clip_get_clip(sc);
@@ -790,3 +790,10 @@ void special_aftertrans_update__movieclip(bContext *C, TransInfo *t)
 }
 
 /** \} */
+
+TransConvertTypeInfo TransConvertType_Tracking = {
+    /* flags */ (T_POINTS | T_2D_EDIT),
+    /* createTransData */ createTransTrackingData,
+    /* recalcData */ recalcData_tracking,
+    /* special_aftertrans_update */ special_aftertrans_update__movieclip,
+};
diff --git a/source/blender/editors/transform/transform_mode.c b/source/blender/editors/transform/transform_mode.c
index 356828f513f..d8da7a11d28 100644
--- a/source/blender/editors/transform/transform_mode.c
+++ b/source/blender/editors/transform/transform_mode.c
@@ -944,7 +944,11 @@ void ElementResize(const TransInfo *t,
   if (td->ext && td->ext->size) {
     float fsize[3];
 
-    if (ELEM(t->data_type, TC_SCULPT, TC_OBJECT, TC_OBJECT_TEXSPACE, TC_POSE)) {
+    if (ELEM(t->data_type,
+             &TransConvertType_Sculpt,
+             &TransConvertType_Object,
+             &TransConvertType_ObjectTexSpace,
+             &TransConvertType_Pose)) {
       float obsizemat[3][3];
       /* Reorient the size mat to fit the oriented object. */
       mul_m3_m3m3(obsizemat, tmat, td->axismtx);
@@ -1204,7 +1208,7 @@ void transform_mode_init(TransInfo *t, wmOperator *op, const int mode)
       break;
   }
 
-  if (t->data_type == TC_MESH_VERTS) {
+  if (t->data_type == &TransConvertType_Mesh) {
     /* Init Custom Data correction.
      * Ideally this should be called when creating the TransData. */
     transform_convert_mesh_customdatacorrect_init(t);
diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index 22d062a71dc..9a563aaf473 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -813,7 +813,7 @@ static void initSnappingMode(TransInfo *t)
       t->tsnap.use_backface_culling = snap_use_backface_culling(t);
       t->tsnap.object_context = ED_transform_snap_object_context_create(t->scene, 0);
 
-      if (t->data_type == TC_MESH_VERTS) {
+      if (t->data_type == &TransConvertType_Mesh) {
         /* Ignore elements being transformed. */
         ED_transform_snap_object_context_set_editmesh_callbacks(
             t->tsnap.object_context,
@@ -1252,7 +1252,7 @@ static void snap_target_grid_ensure(TransInfo *t)
 {
   /* Only need to calculate once. */
   if ((t->tsnap.status & TARGET_GRID_INIT) == 0) {
-    if (t->data_type == TC_CURSOR_VIEW3D) {
+    if (t->data_type == &TransConvertType_Cursor3D) {
       /* Use a fallback when transforming the cursor.
        * In this case the center is _not_ derived from the cursor which is being transformed. */
       copy_v3_v3(t->tsnap.snapTargetGrid, TRANS_DATA_CONTAINER_FIRST_SINGLE(t)->data->iloc);
diff --git a/source/blender/editors/transform/transform_snap_sequencer.c b/source/blender/editors/transform/transform_snap_sequencer.c
index 5ac526b1e91..06d9bb05206 100644
--- a/source/blender/editors/transform/transform_snap_sequencer.c
+++ b/source/blender/editors/transform/transform_snap_sequencer.c
@@ -28,6 +28,7 @@
 #include "SEQ_time.h"
 
 #include "transform.h"
+#include "transform_convert.h"
 #include "transform_snap.h"
 
 typedef struct TransSeqSnapData {
@@ -244,7 +245,7 @@ static int seq_snap_threshold_get_frame_distance(const TransInfo *t)
 
 TransSeqSnapData *transform_snap_sequencer_data_alloc(const TransInfo *t)
 {
-  if (t->data_type == TC_SEQ_IMAGE_DATA) {
+  if (t->data_type == &TransConvertType_SequencerImage) {
     return NULL;
   }
 
@@ -375,7 +376,7 @@ bool ED_transform_snap_sequencer_to_closest_strip_calc(Scene *scene,
   t.scene = scene;
   t.region = region;
   t.values[0] = 0;
-  t.data_type = TC_SEQ_DATA;
+  t.data_type = &TransConvertType_Sequencer;
 
   t.tsnap.mode = SEQ_tool_settings_snap_mode_get(scene);
   *r_snap_distance = transform_snap_sequencer_to_closest_strip_ex(&t, frame_1, frame_2);