2.5
authorMartin Poirier <theeth@yahoo.com>
Sun, 18 Jan 2009 21:36:38 +0000 (21:36 +0000)
committerMartin Poirier <theeth@yahoo.com>
Sun, 18 Jan 2009 21:36:38 +0000 (21:36 +0000)
Transform orientations (Alt-Space and in header)

enum for transform operator parameter.

source/blender/editors/include/BIF_transform.h
source/blender/editors/space_view3d/view3d_header.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform.h
source/blender/editors/transform/transform_constraints.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_manipulator.c
source/blender/editors/transform/transform_ops.c
source/blender/editors/transform/transform_orientations.c

index 652df0948217c3f03faec313e67eab20b476356c..5039d5e0f7e2b5543369cb49e9d12a6b20033bc4 100644 (file)
@@ -96,7 +96,6 @@ struct ScrArea;
 struct Base;
 struct Scene;
 
-struct TransInfo * BIF_GetTransInfo(void);
 void BIF_setSingleAxisConstraint(float vec[3], char *text);
 void BIF_setDualAxisConstraint(float vec1[3], float vec2[3], char *text);
 void BIF_setLocalAxisConstraint(char axis, char *text);
@@ -105,16 +104,17 @@ void BIF_setLocalLockConstraint(char axis, char *text);
 int BIF_snappingSupported(struct Object *obedit);
 
 struct TransformOrientation;
+struct bContext;
 
-void BIF_clearTransformOrientation(void);
-void BIF_removeTransformOrientation(struct TransformOrientation *ts);
-void BIF_manageTransformOrientation(int confirm, int set);
+void BIF_clearTransformOrientation(struct bContext *C);
+void BIF_removeTransformOrientation(struct bContext *C, struct TransformOrientation *ts);
+void BIF_manageTransformOrientation(struct bContext *C, int confirm, int set);
 int BIF_menuselectTransformOrientation(void);
-void BIF_selectTransformOrientation(struct TransformOrientation *ts);
-void BIF_selectTransformOrientationFromIndex(int index);
+void BIF_selectTransformOrientation(struct bContext *C, struct TransformOrientation *ts);
+void BIF_selectTransformOrientationValue(struct bContext *C, int orientation);
 
-char * BIF_menustringTransformOrientation(char *title); /* the returned value was allocated and needs to be freed after use */
-int BIF_countTransformOrientation();
+char * BIF_menustringTransformOrientation(const struct bContext *C, char *title); /* the returned value was allocated and needs to be freed after use */
+int BIF_countTransformOrientation(const struct bContext *C);
 
 void BIF_getPropCenter(float *center);
 
index 7d3ae203cd206b0e8947e5117eefc7284a1b3a0a..fd37b5bcddd2a8da8e99412362714563b1780a16 100644 (file)
@@ -5821,7 +5821,7 @@ void view3d_header_buttons(const bContext *C, ARegion *ar)
                        xco+= XIC+10;
                } else {
                        /* Manipulators arnt used in weight paint mode */
-// XXX                         char *str_menu;
+                       char *str_menu;
                        uiDefIconTextButS(block, ICONTEXTROW,B_AROUND, ICON_ROTATE, around_pup(C), xco,yco,XIC+10,YIC, &(v3d->around), 0, 3.0, 0, 0, "Rotation/Scaling Pivot (Hotkeys: Comma, Shift Comma, Period, Ctrl Period, Alt Period)");
 
                        xco+= XIC+10;
@@ -5865,13 +5865,13 @@ void view3d_header_buttons(const bContext *C, ARegion *ar)
                                xco+= XIC;
                        }
                        
-// XXX                 if (v3d->twmode > (BIF_countTransformOrientation() - 1) + V3D_MANIP_CUSTOM) {
-//                             v3d->twmode = 0;
-//                     }
+                       if (v3d->twmode > (BIF_countTransformOrientation(C) - 1) + V3D_MANIP_CUSTOM) {
+                               v3d->twmode = 0;
+                       }
                        
-// XXX                 str_menu = BIF_menustringTransformOrientation("Orientation");
-//                     uiDefButS(block, MENU, B_MAN_MODE, str_menu,xco,yco,70,YIC, &v3d->twmode, 0, 0, 0, 0, "Transform Orientation (ALT+Space)");
-//                     MEM_freeN(str_menu);
+                       str_menu = BIF_menustringTransformOrientation(C, "Orientation");
+                       uiDefButS(block, MENU, B_MAN_MODE, str_menu,xco,yco,70,YIC, &v3d->twmode, 0, 0, 0, 0, "Transform Orientation (ALT+Space)");
+                       MEM_freeN(str_menu);
                        
                        xco+= 70;
                        uiBlockEndAlign(block);
index 22ecc33c85162f6e79f8319202223dbe5512bb52..95878a35b620cd34b67b783f1f8ec23087ce39f8 100644 (file)
@@ -990,6 +990,8 @@ void initTransform(bContext *C, TransInfo *t, wmOperator *op, wmEvent *event)
        t->mode = mode;
 
        initTransInfo(C, t, event);                                     // internal data, mouse, vectors
+       
+       initTransformOrientation(C, t);
 
        if(t->spacetype == SPACE_VIEW3D)
        {
index fb1a82d232c93b7ad8eedb056930ede5e7f62bd4..6198a8ec145917223eaba37dae83ba1577bf85ea 100644 (file)
@@ -307,8 +307,7 @@ typedef struct TransInfo {
 #define CON_AXIS2              8
 #define CON_SELECT             16
 #define CON_NOFLIP             32      /* does not reorient vector to face viewport when on */
-#define CON_LOCAL              64
-#define CON_USER               128
+#define CON_USER               64
 
 /* transdata->flag */
 #define TD_SELECTED                    1
@@ -577,19 +576,21 @@ int handleNDofInput(NDofInput *n, struct wmEvent *event);
 #define NDOF_CANCEL            4
 
 
-/*********************** TransSpace ******************************/
+/*********************** Transform Orientations ******************************/
 
-int manageObjectSpace(int confirm, int set);
-int manageMeshSpace(int confirm, int set);
-int manageBoneSpace(int confirm, int set);
+void initTransformOrientation(struct bContext *C, TransInfo *t);
+
+int manageObjectSpace(struct bContext *C, int confirm, int set);
+int manageMeshSpace(struct bContext *C, int confirm, int set);
+int manageBoneSpace(struct bContext *C, int confirm, int set);
 
 /* Those two fill in mat and return non-zero on success */
 int createSpaceNormal(float mat[3][3], float normal[3]);
 int createSpaceNormalTangent(float mat[3][3], float normal[3], float tangent[3]);
 
-int addMatrixSpace(float mat[3][3], char name[]);
-int addObjectSpace(struct Object *ob);
-void applyTransformOrientation(void);
+int addMatrixSpace(struct bContext *C, float mat[3][3], char name[]);
+int addObjectSpace(struct bContext *C, struct Object *ob);
+void applyTransformOrientation(struct bContext *C, TransInfo *t);
 
 
 #define ORIENTATION_NONE       0
index bebf8ccc0e6424acbfe1552b65c8b68777a23652..0c0c78c969df37b648bcbc39c0312d97dc0e7ede 100644 (file)
@@ -490,16 +490,16 @@ void setLocalConstraint(TransInfo *t, int mode, const char text[]) {
        if (t->flag & T_EDIT) {
                float obmat[3][3];
                Mat3CpyMat4(obmat, t->scene->obedit->obmat);
-               setConstraint(t, obmat, mode|CON_LOCAL, text);
+               setConstraint(t, obmat, mode, text);
        }
        else {
                if (t->total == 1) {
-                       setConstraint(t, t->data->axismtx, mode|CON_LOCAL, text);
+                       setConstraint(t, t->data->axismtx, mode, text);
                }
                else {
                        strncpy(t->con.text + 1, text, 48);
                        Mat3CpyMat3(t->con.mtx, t->data->axismtx);
-                       t->con.mode = mode|CON_LOCAL;
+                       t->con.mode = mode;
                        getConstraintMatrix(t);
 
                        startConstraint(t);
@@ -869,7 +869,6 @@ void initSelectConstraint(TransInfo *t, float mtx[3][3])
        Mat3CpyMat3(t->con.mtx, mtx);
        t->con.mode |= CON_APPLY;
        t->con.mode |= CON_SELECT;
-       t->con.mode &= ~CON_LOCAL;
 
        setNearestAxis(t);
        t->con.drawExtra = NULL;
index d8421bb7a60124bf6210ea58fc45de94f282a0d6..2f7a3821022910c64e88e1cc1680761c36ee0610 100644 (file)
@@ -1553,8 +1553,7 @@ static void createTransCurveVerts(bContext *C, TransInfo *t)
 
 static void createTransLatticeVerts(bContext *C, TransInfo *t)
 {
-       // TRANSFORM_FIX_ME
-#if 0
+       Lattice *latt = ((Lattice*)t->obedit->data)->editlatt;
        TransData *td = NULL;
        BPoint *bp;
        float mtx[3][3], smtx[3][3];
@@ -1562,8 +1561,8 @@ static void createTransLatticeVerts(bContext *C, TransInfo *t)
        int count=0, countsel=0;
        int propmode = t->flag & T_PROP_EDIT;
 
-       bp= editLatt->def;
-       a= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
+       bp = latt->def;
+       a  = latt->pntsu * latt->pntsv * latt->pntsw;
        while(a--) {
                if(bp->hide==0) {
                        if(bp->f1 & SELECT) countsel++;
@@ -1583,8 +1582,8 @@ static void createTransLatticeVerts(bContext *C, TransInfo *t)
        Mat3Inv(smtx, mtx);
 
        td = t->data;
-       bp= editLatt->def;
-       a= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
+       bp = latt->def;
+       a  = latt->pntsu * latt->pntsv * latt->pntsw;
        while(a--) {
                if(propmode || (bp->f1 & SELECT)) {
                        if(bp->hide==0) {
@@ -1606,7 +1605,6 @@ static void createTransLatticeVerts(bContext *C, TransInfo *t)
                }
                bp++;
        }
-#endif
 }
 
 /* ******************* particle edit **************** */
@@ -2342,8 +2340,8 @@ static void UVsToTransData(TransData *td, TransData2D *td2d, float *uv, int sele
 
 static void createTransUVs(bContext *C, TransInfo *t)
 {
-       // TRANSFORM_FIX_ME
-#if 0
+#if 0 // TRANSFORM_FIX_ME
+       SpaceImage *sima = (SpaceImage*)CTX_wm_space_data(C);
        TransData *td = NULL;
        TransData2D *td2d = NULL;
        MTFace *tf;
@@ -2357,7 +2355,7 @@ static void createTransUVs(bContext *C, TransInfo *t)
        if(is_uv_tface_editing_allowed()==0) return;
 
        /* count */
-       if (G.sima->flag & SI_BE_SQUARE && !propmode) {
+       if (sima->flag & SI_BE_SQUARE && !propmode) {
                for (efa= em->faces.first; efa; efa= efa->next) {
                        /* store face pointer for second loop, prevent second lookup */
                        tf= CustomData_em_get(&em->fdata, efa->data, CD_MTFACE);
@@ -2409,13 +2407,13 @@ static void createTransUVs(bContext *C, TransInfo *t)
           treated just as if they were 3d verts */
        t->data2d= MEM_callocN(t->total*sizeof(TransData2D), "TransObData2D(UV Editing)");
 
-       if(G.sima->flag & SI_CLIP_UV)
+       if(sima->flag & SI_CLIP_UV)
                t->flag |= T_CLIP_UV;
 
        td= t->data;
        td2d= t->data2d;
        
-       if (G.sima->flag & SI_BE_SQUARE && !propmode) {
+       if (sima->flag & SI_BE_SQUARE && !propmode) {
                for (efa= em->faces.first; efa; efa= efa->next) {
                        tf=(MTFace *)efa->tmp.p;
                        if (tf) {
@@ -2474,7 +2472,7 @@ static void createTransUVs(bContext *C, TransInfo *t)
                }
        }
        
-       if (G.sima->flag & SI_LIVE_UNWRAP)
+       if (sima->flag & SI_LIVE_UNWRAP)
                unwrap_lscm_live_begin();
 #endif
 }
index 8dbd5f5c7742fbab82ef613e04372fbf9b2fc99e..5312050b2d98120f5d37d6150939ab6a2a6d993e 100644 (file)
@@ -219,7 +219,7 @@ int calc_manipulator_stats(ScrArea *sa)
        float plane[3]={0.0, 0.0, 0.0};
        int a, totsel=0;
 
-       t = BIF_GetTransInfo();
+//XXX  t = BIF_GetTransInfo();
        
        /* transform widget matrix */
        Mat4One(v3d->twmat);
index 2eec6252c18e9fab3dbb2d63f63ac21ac987762c..c89ab10c2a96438dd6e3d60c1b0faf0818c7b0ab 100644 (file)
 #include "WM_api.h"
 #include "WM_types.h"
 
+#include "UI_interface.h"
+
 #include "ED_screen.h"
 
 #include "transform.h"
 
+
+static int select_orientation_exec(bContext *C, wmOperator *op)
+{
+       int orientation = RNA_int_get(op->ptr, "orientation");
+       
+       if (orientation > -1)
+       {
+               BIF_selectTransformOrientationValue(C, orientation);
+               return OPERATOR_FINISHED;
+       }
+       else
+       {
+               return OPERATOR_CANCELLED;
+       }
+}
+
+static int select_orientation_invoke(bContext *C, wmOperator *op, wmEvent *event)
+{
+       char *string = BIF_menustringTransformOrientation(C, "Orientation");
+       
+       op->customdata = string;
+       
+       uiPupmenuOperator(C, 0, op, "orientation", string);
+       
+       return OPERATOR_RUNNING_MODAL;
+}
+       
+void TFM_OT_select_orientation(struct wmOperatorType *ot)
+{
+       PropertyRNA *prop;
+       
+       /* identifiers */
+       ot->name   = "Select Orientation";
+       ot->idname = "TFM_OT_select_orientation";
+
+       /* api callbacks */
+       ot->invoke = select_orientation_invoke;
+       ot->exec   = select_orientation_exec;
+       ot->poll   = ED_operator_areaactive;
+
+       prop = RNA_def_property(ot->srna, "orientation", PROP_INT, PROP_NONE);
+       RNA_def_property_array(prop, -1);
+}
+
 static void transformops_exit(bContext *C, wmOperator *op)
 {
        saveTransform(C, op->customdata, op);
@@ -91,7 +137,7 @@ static int transform_cancel(bContext *C, wmOperator *op)
        transformEnd(C, t);
        transformops_exit(C, op);
        
-       return OPERATOR_FINISHED;
+       return OPERATOR_CANCELLED;
 }
 
 static int transform_exec(bContext *C, wmOperator *op)
@@ -136,6 +182,36 @@ void TFM_OT_transform(struct wmOperatorType *ot)
 {
        static const float value[4] = {0, 0, 0};
        static const float mtx[3][3] = {{1, 0, 0},{0, 1, 0},{0, 0, 1}};
+       static EnumPropertyItem transform_mode_types[] = {
+                       {TFM_INIT, "INIT", "Init", ""},
+                       {TFM_DUMMY, "DUMMY", "Dummy", ""},
+                       {TFM_TRANSLATION, "TRANSLATION", "Translation", ""},
+                       {TFM_ROTATION, "ROTATION", "Rotation", ""},
+                       {TFM_RESIZE, "RESIZE", "Resize", ""},
+                       {TFM_TOSPHERE, "TOSPHERE", "Tosphere", ""},
+                       {TFM_SHEAR, "SHEAR", "Shear", ""},
+                       {TFM_WARP, "WARP", "Warp", ""},
+                       {TFM_SHRINKFATTEN, "SHRINKFATTEN", "Shrinkfatten", ""},
+                       {TFM_TILT, "TILT", "Tilt", ""},
+                       {TFM_LAMP_ENERGY, "LAMP_ENERGY", "Lamp_Energy", ""},
+                       {TFM_TRACKBALL, "TRACKBALL", "Trackball", ""},
+                       {TFM_PUSHPULL, "PUSHPULL", "Pushpull", ""},
+                       {TFM_CREASE, "CREASE", "Crease", ""},
+                       {TFM_MIRROR, "MIRROR", "Mirror", ""},
+                       {TFM_BONESIZE, "BONESIZE", "Bonesize", ""},
+                       {TFM_BONE_ENVELOPE, "BONE_ENVELOPE", "Bone_Envelope", ""},
+                       {TFM_CURVE_SHRINKFATTEN, "CURVE_SHRINKFATTEN", "Curve_Shrinkfatten", ""},
+                       {TFM_BONE_ROLL, "BONE_ROLL", "Bone_Roll", ""},
+                       {TFM_TIME_TRANSLATE, "TIME_TRANSLATE", "Time_Translate", ""},
+                       {TFM_TIME_SLIDE, "TIME_SLIDE", "Time_Slide", ""},
+                       {TFM_TIME_SCALE, "TIME_SCALE", "Time_Scale", ""},
+                       {TFM_TIME_EXTEND, "TIME_EXTEND", "Time_Extend", ""},
+                       {TFM_BAKE_TIME, "BAKE_TIME", "Bake_Time", ""},
+                       {TFM_BEVEL, "BEVEL", "Bevel", ""},
+                       {TFM_BWEIGHT, "BWEIGHT", "Bweight", ""},
+                       {TFM_ALIGN, "ALIGN", "Align", ""},
+                       {0, NULL, NULL, NULL}
+       };
        
        /* identifiers */
        ot->name   = "Transform";
@@ -149,7 +225,7 @@ void TFM_OT_transform(struct wmOperatorType *ot)
        ot->cancel  = transform_cancel;
        ot->poll   = ED_operator_areaactive;
 
-       RNA_def_int(ot->srna, "mode", 0, INT_MIN, INT_MAX, "Mode", "", INT_MIN, INT_MAX);
+       RNA_def_enum(ot->srna, "mode", transform_mode_types, 0, "Mode", "");
        RNA_def_int(ot->srna, "options", 0, INT_MIN, INT_MAX, "Options", "", INT_MIN, INT_MAX);
        
        RNA_def_float_vector(ot->srna, "values", 4, value, -FLT_MAX, FLT_MAX, "Values", "", -FLT_MAX, FLT_MAX);
@@ -157,12 +233,16 @@ void TFM_OT_transform(struct wmOperatorType *ot)
        RNA_def_int(ot->srna, "constraint_orientation", 0, INT_MIN, INT_MAX, "Constraint Orientation", "", INT_MIN, INT_MAX);
        RNA_def_int(ot->srna, "constraint_mode", 0, INT_MIN, INT_MAX, "Constraint Mode", "", INT_MIN, INT_MAX);
 
+//     prop = RNA_def_property(ot->srna, "constraint_matrix", PROP_FLOAT, PROP_MATRIX);
+//     RNA_def_property_array(prop, 9);
+//     RNA_def_property_float_array_default(prop, (float*)mtx);
        RNA_def_float_matrix(ot->srna, "constraint_matrix", 9, mtx[0], -FLT_MAX, FLT_MAX, "Constraint Matrix", "", -FLT_MAX, FLT_MAX);
 }
 
 void transform_operatortypes(void)
 {
        WM_operatortype_append(TFM_OT_transform);
+       WM_operatortype_append(TFM_OT_select_orientation);
 }
  
 void transform_keymap_for_space(struct wmWindowManager *wm, struct ListBase *keymap, int spaceid)
@@ -189,6 +269,8 @@ void transform_keymap_for_space(struct wmWindowManager *wm, struct ListBase *key
                        km = WM_keymap_add_item(keymap, "TFM_OT_transform", SKEY, KM_PRESS, KM_ALT|KM_CTRL|KM_SHIFT, 0);
                        RNA_int_set(km->ptr, "mode", TFM_SHEAR);
                        
+                       km = WM_keymap_add_item(keymap, "TFM_OT_select_orientation", SPACEKEY, KM_PRESS, KM_ALT, 0);
+
                        break;
                case SPACE_ACTION:
                        km= WM_keymap_add_item(keymap, "TFM_OT_transform", GKEY, KM_PRESS, 0, 0);
index 4605baa18f699e67bd4d884954ed3b04fc1104d1..5fe45f2e94a028793afba696112cb2693b5e6269 100644 (file)
 
 #include "ED_armature.h"
 #include "ED_mesh.h"
+#include "ED_util.h"
 
 #include "transform.h"
 
-#if 0 // TRANSFORM_FIX_ME
-
 /* *********************** TransSpace ************************** */
 
-void BIF_clearTransformOrientation(void)
+void BIF_clearTransformOrientation(bContext *C)
 {
-       ListBase *transform_spaces = &G.scene->transform_spaces;
+       ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
        BLI_freelistN(transform_spaces);
        
        // TRANSFORM_FIX_ME
@@ -73,45 +72,46 @@ void BIF_clearTransformOrientation(void)
 //             G.vd->twmode = V3D_MANIP_GLOBAL;        /* fallback to global   */
 }
  
-void BIF_manageTransformOrientation(int confirm, int set) {
-       Object *ob = OBACT;
+void BIF_manageTransformOrientation(bContext *C, int confirm, int set) {
+       Object *obedit = CTX_data_edit_object(C);
+       Object *ob = CTX_data_active_object(C);
        int index = -1; 
        
-       if (t->obedit) {
-               if (t->obedit->type == OB_MESH)
-                       index = manageMeshSpace(confirm, set);
-               else if (t->obedit->type == OB_ARMATURE)
-                       index = manageBoneSpace(confirm, set);
+       if (obedit) {
+               if (obedit->type == OB_MESH)
+                       index = manageMeshSpace(C, confirm, set);
+               else if (obedit->type == OB_ARMATURE)
+                       index = manageBoneSpace(C, confirm, set);
        }
        else if (ob && (ob->flag & OB_POSEMODE)) {
-                       index = manageBoneSpace(confirm, set);
+                       index = manageBoneSpace(C, confirm, set);
        }
        else {
-               index = manageObjectSpace(confirm, set);
+               index = manageObjectSpace(C, confirm, set);
        }
        
        if (set && index != -1)
        {
-               BIF_selectTransformOrientationFromIndex(index);
+               BIF_selectTransformOrientationValue(C, V3D_MANIP_CUSTOM + index);
        }
 }
 
-int manageObjectSpace(int confirm, int set) {
-       Base *base = BASACT;
+int manageObjectSpace(bContext *C, int confirm, int set) {
+       Base *base = CTX_data_active_base(C);
 
        if (base == NULL)
                return -1;
 
-       if (confirm == 0) {
-               if (set && pupmenu("Custom Orientation %t|Add and Use Active Object%x1") != 1) {
-                       return -1;
-               }
-               else if (set == 0 && pupmenu("Custom Orientation %t|Add Active Object%x1") != 1) {
-                       return -1;
-               }
-       }
+//XXX  if (confirm == 0) {
+//             if (set && pupmenu("Custom Orientation %t|Add and Use Active Object%x1") != 1) {
+//                     return -1;
+//             }
+//             else if (set == 0 && pupmenu("Custom Orientation %t|Add Active Object%x1") != 1) {
+//                     return -1;
+//             }
+//     }
 
-       return addObjectSpace(base->object);
+       return addObjectSpace(C, base->object);
 }
 
 /* return 1 on confirm */
@@ -126,48 +126,48 @@ int confirmSpace(int set, char text[])
                sprintf(menu, "Custom Orientation %%t|Add %s%%x1", text);
        }
        
-       if (pupmenu(menu) == 1) {
+//XXX  if (pupmenu(menu) == 1) {
                return 1;
-       }
-       else {
-               return 0;
-       }
+//     }
+//     else {
+//             return 0;
+//     }
 }
 
-int manageBoneSpace(int confirm, int set) {
+int manageBoneSpace(bContext *C, int confirm, int set) {
        float mat[3][3];
        float normal[3], plane[3];
        char name[36] = "";
        int index;
 
-       getTransformOrientation(normal, plane, 0);
+       getTransformOrientation(C, normal, plane, 0);
        
        if (confirm == 0 && confirmSpace(set, "Bone") == 0) {
                return -1;
        }
 
        if (createSpaceNormalTangent(mat, normal, plane) == 0) {
-               error("Cannot use zero-length bone");
+//XXX          error("Cannot use zero-length bone");
                return -1;
        }
 
        strcpy(name, "Bone");
 
        /* Input name */
-       sbutton(name, 1, 35, "name: ");
+//XXX  sbutton(name, 1, 35, "name: ");
 
-       index = addMatrixSpace(mat, name);
+       index = addMatrixSpace(C, mat, name);
        return index;
 }
 
-int manageMeshSpace(int confirm, int set) {
+int manageMeshSpace(bContext *C, int confirm, int set) {
        float mat[3][3];
        float normal[3], plane[3];
        char name[36] = "";
        int index;
        int type;
 
-       type = getTransformOrientation(normal, plane, 0);
+       type = getTransformOrientation(C, normal, plane, 0);
        
        switch (type)
        {
@@ -213,9 +213,9 @@ int manageMeshSpace(int confirm, int set) {
        }
 
        /* Input name */
-       sbutton(name, 1, 35, "name: ");
+//XXX  sbutton(name, 1, 35, "name: ");
 
-       index = addMatrixSpace(mat, name);
+       index = addMatrixSpace(C, mat, name);
        return index;
 }
 
@@ -268,7 +268,7 @@ int createSpaceNormalTangent(float mat[3][3], float normal[3], float tangent[3])
 }
 
 
-int addObjectSpace(Object *ob) {
+int addObjectSpace(bContext *C, Object *ob) {
        float mat[3][3];
        char name[36] = "";
 
@@ -278,13 +278,13 @@ int addObjectSpace(Object *ob) {
        strncpy(name, ob->id.name+2, 35);
 
        /* Input name */
-       sbutton(name, 1, 35, "name: ");
+//XXX  sbutton(name, 1, 35, "name: ");
 
-       return addMatrixSpace(mat, name);
+       return addMatrixSpace(C, mat, name);
 }
 
-int addMatrixSpace(float mat[3][3], char name[]) {
-       ListBase *transform_spaces = &G.scene->transform_spaces;
+int addMatrixSpace(bContext *C, float mat[3][3], char name[]) {
+       ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
        TransformOrientation *ts;
        int index = 0;
 
@@ -306,58 +306,61 @@ int addMatrixSpace(float mat[3][3], char name[]) {
        /* copy matrix into transform space */
        Mat3CpyMat3(ts->mat, mat);
 
-       BIF_undo_push("Add/Update Transform Orientation");
+       ED_undo_push(C, "Add/Update Transform Orientation");
        
        return index;
 }
 
-void BIF_removeTransformOrientation(TransformOrientation *target) {
-       ListBase *transform_spaces = &G.scene->transform_spaces;
+void BIF_removeTransformOrientation(bContext *C, TransformOrientation *target) {
+       ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
        TransformOrientation *ts = transform_spaces->first;
-       int selected_index = (G.vd->twmode - V3D_MANIP_CUSTOM);
+       //int selected_index = (G.vd->twmode - V3D_MANIP_CUSTOM);
        int i;
        
        for (i = 0, ts = transform_spaces->first; ts; ts = ts->next, i++) {
                if (ts == target) {
-                       if (selected_index == i) {
-                               G.vd->twmode = V3D_MANIP_GLOBAL;        /* fallback to global   */
-                       }
-                       else if (selected_index > i)
-                               G.vd->twmode--;
+                       // Transform_fix_me NEED TO DO THIS FOR ALL VIEW3D
+//                     if (selected_index == i) {
+//                             G.vd->twmode = V3D_MANIP_GLOBAL;        /* fallback to global   */
+//                     }
+//                     else if (selected_index > i)
+//                             G.vd->twmode--;
 
                        BLI_freelinkN(transform_spaces, ts);
                        break;
                }
        }
-       BIF_undo_push("Remove Transform Orientation");
+       ED_undo_push(C, "Remove Transform Orientation");
 }
 
-void BIF_selectTransformOrientation(TransformOrientation *target) {
-       ListBase *transform_spaces = &G.scene->transform_spaces;
+void BIF_selectTransformOrientation(bContext *C, TransformOrientation *target) {
+       ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
+       View3D *v3d = CTX_wm_area(C)->spacedata.first;
        TransformOrientation *ts = transform_spaces->first;
        int i;
        
        for (i = 0, ts = transform_spaces->first; ts; ts = ts->next, i++) {
                if (ts == target) {
-                       G.vd->twmode = V3D_MANIP_CUSTOM + i;
+                       v3d->twmode = V3D_MANIP_CUSTOM + i;
                        break;
                }
        }
 }
 
-void BIF_selectTransformOrientationFromIndex(int index) {
-       G.vd->twmode = V3D_MANIP_CUSTOM + index;
+void BIF_selectTransformOrientationValue(bContext *C, int orientation) {
+       View3D *v3d = CTX_wm_area(C)->spacedata.first;
+       v3d->twmode = orientation;
 }
 
-char * BIF_menustringTransformOrientation(char *title) {
+char * BIF_menustringTransformOrientation(const bContext *C, char *title) {
        char menu[] = "%t|Global%x0|Local%x1|Normal%x2|View%x3";
-       ListBase *transform_spaces = &G.scene->transform_spaces;
+       ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
        TransformOrientation *ts;
        int i = V3D_MANIP_CUSTOM;
        char *str_menu, *p;
        
        
-       str_menu = MEM_callocN(strlen(menu) + strlen(title) + 1 + 40 * BIF_countTransformOrientation(), "UserTransSpace from matrix");
+       str_menu = MEM_callocN(strlen(menu) + strlen(title) + 1 + 40 * BIF_countTransformOrientation(C), "UserTransSpace from matrix");
        p = str_menu;
        
        p += sprintf(str_menu, "%s", title);
@@ -370,8 +373,8 @@ char * BIF_menustringTransformOrientation(char *title) {
        return str_menu;
 }
 
-int BIF_countTransformOrientation() {
-       ListBase *transform_spaces = &G.scene->transform_spaces;
+int BIF_countTransformOrientation(const bContext *C) {
+       ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
        TransformOrientation *ts;
        int count = 0;
 
@@ -382,26 +385,24 @@ int BIF_countTransformOrientation() {
        return count;
 }
 
-void applyTransformOrientation() {
-       TransInfo *t = BIF_GetTransInfo();
+void applyTransformOrientation(bContext *C, TransInfo *t) {
        TransformOrientation *ts;
-       int selected_index = (G.vd->twmode - V3D_MANIP_CUSTOM);
+       View3D *v3d = CTX_wm_area(C)->spacedata.first;
+       int selected_index = (v3d->twmode - V3D_MANIP_CUSTOM);
        int i;
        
        if (selected_index >= 0) {
-               for (i = 0, ts = G.scene->transform_spaces.first; ts; ts = ts->next, i++) {
+               for (i = 0, ts = CTX_data_scene(C)->transform_spaces.first; ts; ts = ts->next, i++) {
                        if (selected_index == i) {
                                strcpy(t->spacename, ts->name);
                                Mat3CpyMat3(t->spacemtx, ts->mat);
-                               Mat4CpyMat3(G.vd->twmat, ts->mat);
+                               Mat4CpyMat3(v3d->twmat, ts->mat);
                                break;
                        }
                }
        }
 }
 
-#endif // TRANSFORM_FIX_ME
-
 static int count_bone_select(bArmature *arm, ListBase *lb, int do_it) 
 {
        Bone *bone;
@@ -426,6 +427,88 @@ static int count_bone_select(bArmature *arm, ListBase *lb, int do_it)
        return total;
 }
 
+void initTransformOrientation(bContext *C, TransInfo *t)
+{
+       View3D *v3d = CTX_wm_area(C)->spacedata.first;
+       Object *ob = CTX_data_active_object(C);
+       Object *obedit = CTX_data_active_object(C);
+       float normal[3]={0.0, 0.0, 0.0};
+       float plane[3]={0.0, 0.0, 0.0};
+
+       switch(v3d->twmode) {
+       case V3D_MANIP_GLOBAL:
+               strcpy(t->spacename, "global");
+               break;
+               
+       case V3D_MANIP_NORMAL:
+               if(obedit || ob->flag & OB_POSEMODE) {
+                       float mat[3][3];
+                       int type;
+                       
+                       strcpy(t->spacename, "normal");
+                       
+                       type = getTransformOrientation(C, normal, plane, (v3d->around == V3D_ACTIVE));
+                       
+                       switch (type)
+                       {
+                               case ORIENTATION_NORMAL:
+                                       if (createSpaceNormalTangent(mat, normal, plane) == 0)
+                                       {
+                                               type = ORIENTATION_NONE;
+                                       }
+                                       break;
+                               case ORIENTATION_VERT:
+                                       if (createSpaceNormal(mat, normal) == 0)
+                                       {
+                                               type = ORIENTATION_NONE;
+                                       }
+                                       break;
+                               case ORIENTATION_EDGE:
+                                       if (createSpaceNormalTangent(mat, normal, plane) == 0)
+                                       {
+                                               type = ORIENTATION_NONE;
+                                       }
+                                       break;
+                               case ORIENTATION_FACE:
+                                       if (createSpaceNormalTangent(mat, normal, plane) == 0)
+                                       {
+                                               type = ORIENTATION_NONE;
+                                       }
+                                       break;
+                       }
+                       
+                       if (type == ORIENTATION_NONE)
+                       {
+                               Mat4One(v3d->twmat);
+                       }
+                       else
+                       {
+                               Mat4CpyMat3(v3d->twmat, mat);
+                       }
+                       break;
+               }
+               /* no break we define 'normal' as 'local' in Object mode */
+       case V3D_MANIP_LOCAL:
+               strcpy(t->spacename, "local");
+               Mat4CpyMat4(v3d->twmat, ob->obmat);
+               Mat4Ortho(v3d->twmat);
+               break;
+               
+       case V3D_MANIP_VIEW:
+               {
+                       float mat[3][3];
+                       strcpy(t->spacename, "view");
+                       Mat3CpyMat4(mat, v3d->viewinv);
+                       Mat3Ortho(mat);
+                       Mat4CpyMat3(v3d->twmat, mat);
+               }
+               break;
+       default: /* V3D_MANIP_CUSTOM */
+               applyTransformOrientation(C, t);
+               break;
+       }
+}
+
 int getTransformOrientation(bContext *C, float normal[3], float plane[3], int activeOnly)
 {
        Scene *scene = CTX_data_scene(C);
@@ -651,6 +734,7 @@ int getTransformOrientation(bContext *C, float normal[3], float plane[3], int ac
                        extern ListBase editelems;  /* go away ! */
                        MetaElem *ml, *ml_sel = NULL;
        
+#if 0 // XXX
                        /* loop and check that only one element is selected */  
                        for (ml = editelems.first; ml; ml = ml->next)
                        {
@@ -666,6 +750,7 @@ int getTransformOrientation(bContext *C, float normal[3], float plane[3], int ac
                                        }
                                }
                        }
+#endif
                        
                        if (ml_sel)
                        {