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

1 files changed, 166 insertions, 447 deletions

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);
 }
 
 /** \} */