Bugfix: the sticky and use rot buttons for the floor constraint were
[blender.git] / source / blender / src / buttons_object.c
index 044af1f943168f45fb9cb00a6e715fcb9b41b201..e0190ab474f78fd12709d9cf8b830f5513ebe698 100644 (file)
@@ -52,6 +52,7 @@
 #include "BKE_library.h"
 #include "BKE_softbody.h"
 #include "BKE_utildefines.h"
+#include "BKE_particle.h"
 
 #include "BLI_blenlib.h"
 #include "BLI_arithb.h"
@@ -61,6 +62,7 @@
 
 #include "BIF_butspace.h"
 #include "BIF_editaction.h"
+#include "BIF_editparticle.h"
 #include "BIF_gl.h"
 #include "BIF_glutil.h"
 #include "BIF_graphics.h"
@@ -73,6 +75,7 @@
 #include "BIF_screen.h"
 #include "BIF_space.h"
 #include "BIF_toolbox.h"
+#include "BIF_outliner.h"
 
 #include "BDR_drawobject.h"
 #include "BDR_editcurve.h"
 #include "DNA_object_types.h"
 #include "DNA_object_force.h"
 #include "DNA_object_fluidsim.h"
+#include "DNA_particle_types.h"
 #include "DNA_radio_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_sound_types.h"
 #include "DNA_vfont_types.h"
 #include "DNA_view3d_types.h"
 #include "DNA_world_types.h"
+#include "DNA_text_types.h"
 
 #include "BKE_anim.h"
 #include "BKE_armature.h"
 #include "BKE_mesh.h"
 #include "BKE_modifier.h"
 #include "BKE_object.h"
+#include "BKE_particle.h"
 #include "BKE_sound.h"
 #include "BKE_texture.h"
 #include "BKE_utildefines.h"
 
 #include "BIF_editconstraint.h"
 #include "BIF_editdeform.h"
+#include "BIF_editparticle.h"
 
 #include "BSE_editipo.h"
 #include "BSE_edit.h"
 
 #include "BDR_editobject.h"
+#include "BPY_extern.h"
 
 #include "butspace.h" // own module
 
@@ -197,7 +205,7 @@ static void add_constraint_to_active(Object *ob, bConstraint *con)
 
 /* returns base ID for Ipo, sets actname to channel if appropriate */
 /* should not make action... */
-void get_constraint_ipo_context(void *ob_v, char *actname)
+static void get_constraint_ipo_context(void *ob_v, char *actname)
 {
        Object *ob= ob_v;
        
@@ -229,8 +237,11 @@ static void enable_constraint_ipo_func (void *ob_v, void *con_v)
        get_constraint_ipo_context(ob, actname);
        
        /* adds ipo & channels & curve if needed */
-       verify_ipo((ID *)ob, ID_CO, actname, con->name);
-       
+       if(con->flag & CONSTRAINT_OWN_IPO)
+               verify_ipo((ID *)ob, ID_CO, NULL, con->name, actname);
+       else
+               verify_ipo((ID *)ob, ID_CO, actname, con->name, NULL);
+               
        /* make sure ipowin shows it */
        ob->ipowin= ID_CO;
        allqueue(REDRAWIPO, ID_CO);
@@ -253,12 +264,20 @@ static void add_influence_key_to_constraint_func (void *ob_v, void *con_v)
        get_constraint_ipo_context(ob, actname);
 
        /* adds ipo & channels & curve if needed */
-       icu= verify_ipocurve((ID *)ob, ID_CO, actname, con->name, CO_ENFORCE);
-
+       if(con->flag & CONSTRAINT_OWN_IPO)
+               icu= verify_ipocurve((ID *)ob, ID_CO, NULL, con->name, actname, CO_ENFORCE);
+       else
+               icu= verify_ipocurve((ID *)ob, ID_CO, actname, con->name, NULL, CO_ENFORCE);
+               
+       if (!icu) {
+               error("Cannot get a curve from this IPO, may be dealing with linked data");
+               return;
+       }
+       
        if(ob->action)
-               insert_vert_ipo(icu, get_action_frame(ob, (float)CFRA), con->enforce);
+               insert_vert_icu(icu, get_action_frame(ob, (float)CFRA), con->enforce, 0);
        else
-               insert_vert_ipo(icu, CFRA, con->enforce);
+               insert_vert_icu(icu, CFRA, con->enforce, 0);
        
        /* make sure ipowin shows it */
        ob->ipowin= ID_CO;
@@ -300,110 +319,22 @@ static void del_constraint_func (void *ob_v, void *con_v)
        allqueue(REDRAWIPO, 0); 
 }
 
-static void verify_constraint_name_func (void *ob_v, void *con_v)
+static void verify_constraint_name_func (void *con_v, void *name_v)
 {
-       ListBase *conlist;
+       Object *ob= OBACT;
        bConstraint *con= con_v;
+       char oldname[32];       
        
        if (!con)
                return;
        
-       conlist = get_active_constraints(ob_v);
-       unique_constraint_name (con, conlist);
-       constraint_active_func(ob_v, con);
-
-}
-
-void get_constraint_typestring (char *str, void *con_v)
-{
-       bConstraint *con= con_v;
-
-       switch (con->type){
-       case CONSTRAINT_TYPE_CHILDOF:
-               strcpy (str, "Child Of");
-               return;
-       case CONSTRAINT_TYPE_NULL:
-               strcpy (str, "Null");
-               return;
-       case CONSTRAINT_TYPE_TRACKTO:
-               strcpy (str, "Track To");
-               return;
-       case CONSTRAINT_TYPE_MINMAX:
-               strcpy (str, "Floor");
-               return;
-       case CONSTRAINT_TYPE_KINEMATIC:
-               strcpy (str, "IK Solver");
-               return;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               strcpy (str, "Copy Rotation");
-               return;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               strcpy (str, "Copy Location");
-               return;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               strcpy (str, "Copy Scale");
-               return;
-       case CONSTRAINT_TYPE_ACTION:
-               strcpy (str, "Action");
-               return;
-       case CONSTRAINT_TYPE_LOCKTRACK:
-               strcpy (str, "Locked Track");
-               return;
-       case CONSTRAINT_TYPE_FOLLOWPATH:
-               strcpy (str, "Follow Path");
-               return;
-       case CONSTRAINT_TYPE_STRETCHTO:
-               strcpy (str, "Stretch To");
-               return;
-       case CONSTRAINT_TYPE_LOCLIMIT:
-               strcpy (str, "Limit Location");
-               return;
-       case CONSTRAINT_TYPE_ROTLIMIT:
-               strcpy (str, "Limit Rotation");
-               return;
-       case CONSTRAINT_TYPE_SIZELIMIT:
-               strcpy (str, "Limit Scale");
-               return;
-       default:
-               strcpy (str, "Unknown");
-               return;
-       }
-}
-
-static int get_constraint_col(bConstraint *con)
-{
-       switch (con->type) {
-       case CONSTRAINT_TYPE_NULL:
-               return TH_BUT_NEUTRAL;
-       case CONSTRAINT_TYPE_KINEMATIC:
-               return TH_BUT_SETTING2;
-       case CONSTRAINT_TYPE_TRACKTO:
-               return TH_BUT_SETTING;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               return TH_BUT_SETTING1;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               return TH_BUT_POPUP;
-       case CONSTRAINT_TYPE_MINMAX:
-               return TH_BUT_POPUP;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               return TH_BUT_POPUP;
-       case CONSTRAINT_TYPE_ACTION:
-               return TH_BUT_ACTION;
-       case CONSTRAINT_TYPE_LOCKTRACK:
-               return TH_BUT_SETTING;
-       case CONSTRAINT_TYPE_FOLLOWPATH:
-               return TH_BUT_SETTING2;
-       case CONSTRAINT_TYPE_STRETCHTO:
-               return TH_BUT_SETTING;
-       case CONSTRAINT_TYPE_LOCLIMIT:
-               return TH_BUT_POPUP;
-       case CONSTRAINT_TYPE_ROTLIMIT:
-               return TH_BUT_POPUP;
-       case CONSTRAINT_TYPE_SIZELIMIT:
-               return TH_BUT_POPUP;
-       default:
-               return TH_REDALERT;
-       }
+       /* put on the stack */
+       BLI_strncpy(oldname, (char *)name_v, 32);
+       
+       rename_constraint(ob, con, oldname);
+       
+       constraint_active_func(ob, con);
+       allqueue(REDRAWACTION, 0); 
 }
 
 void const_moveUp(void *ob_v, void *con_v)
@@ -456,37 +387,18 @@ static void constraint_moveDown(void *ob_v, void *con_v)
 void autocomplete_bone(char *str, void *arg_v)
 {
        Object *ob= (Object *)arg_v;
-       char truncate[40]= {0};
        
        if(ob==NULL || ob->pose==NULL) return;
        
        /* search if str matches the beginning of name */
        if(str[0]) {
+               AutoComplete *autocpl= autocomplete_begin(str, 32);
                bPoseChannel *pchan;
                
-               for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
-                       int a;
-                       
-                       for(a=0; a<31; a++) {
-                               if(str[a]==0 || str[a]!=pchan->name[a])
-                                       break;
-                       }
-                       /* found a match */
-                       if(str[a]==0) {
-                               /* first match */
-                               if(truncate[0]==0)
-                                       BLI_strncpy(truncate, pchan->name, 32);
-                               else {
-                                       /* remove from truncate what is not in bone->name */
-                                       for(a=0; a<31; a++) {
-                                               if(truncate[a]!=pchan->name[a])
-                                                       truncate[a]= 0;
-                                       }
-                               }
-                       }
-               }
-               if(truncate[0])
-                       BLI_strncpy(str, truncate, 32);
+               for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next)
+                       autocomplete_do_name(autocpl, pchan->name);
+
+               autocomplete_end(autocpl, str);
        }
 }
 
@@ -494,108 +406,160 @@ void autocomplete_bone(char *str, void *arg_v)
 void autocomplete_vgroup(char *str, void *arg_v)
 {
        Object *ob= (Object *)arg_v;
-       char truncate[40]= {0};
        
        if(ob==NULL) return;
        
        /* search if str matches the beginning of a name */
        if(str[0]) {
+               AutoComplete *autocpl= autocomplete_begin(str, 32);
                bDeformGroup *dg;
                
-               for(dg= ob->defbase.first; dg; dg= dg->next) {
-                       int a;
-                       if(dg->name==str) continue;
-                       
-                       for(a=0; a<31; a++) {
-                               if(str[a]==0 || str[a]!=dg->name[a])
-                                       break;
-                       }
-                       /* found a match */
-                       if(str[a]==0) {
-                               /* first match */
-                               if(truncate[0]==0)
-                                       BLI_strncpy(truncate, dg->name, 32);
-                               else {
-                                       /* remove from truncate what is not in bone->name */
-                                       for(a=0; a<31; a++) {
-                                               if(truncate[a]!=dg->name[a])
-                                                       truncate[a]= 0;
-                                       }
-                               }
-                       }
+               for(dg= ob->defbase.first; dg; dg= dg->next)
+                       if(dg->name!=str)
+                               autocomplete_do_name(autocpl, dg->name);
+
+               autocomplete_end(autocpl, str);
+       }
+}
+
+/* pole angle callback */
+void con_kinematic_set_pole_angle(void *ob_v, void *con_v)
+{
+       bConstraint *con= con_v;
+       bKinematicConstraint *data = con->data;
+
+       if(data->poletar) {
+               if(data->flag & CONSTRAINT_IK_SETANGLE) {
+                       data->flag |= CONSTRAINT_IK_GETANGLE;
+                       data->flag &= ~CONSTRAINT_IK_SETANGLE;
+               }
+               else {
+                       data->flag &= ~CONSTRAINT_IK_GETANGLE;
+                       data->flag |= CONSTRAINT_IK_SETANGLE;
                }
-               if(truncate[0])
-                       BLI_strncpy(str, truncate, 32);
        }
 }
 
+/* some commonly used macros in the constraints drawing code */
+#define is_armature_target(target) (target && target->type==OB_ARMATURE)
+#define is_armature_owner(ob) ((ob->type == OB_ARMATURE) && (ob->flag & OB_POSEMODE))
+#define is_geom_target(target) (target && (ELEM(target->type, OB_MESH, OB_LATTICE)) )
+
+/* Helper function for draw constraint - draws constraint space stuff 
+ * This function should not be called if no menus are required 
+ * owner/target: -1 = don't draw menu; 0= not posemode, 1 = posemode 
+ */
+static void draw_constraint_spaceselect (uiBlock *block, bConstraint *con, short xco, short yco, short owner, short target)
+{
+       short tarx, ownx;
+       short bwidth;
+       
+       /* calculate sizes and placement of menus */
+       if (owner == -1) {
+               bwidth = 125;
+               tarx = 120;
+               ownx = 0;
+       }
+       else if (target == -1) {
+               bwidth = 125;
+               tarx = 0;
+               ownx = 120;
+       }
+       else {
+               bwidth = 100;
+               tarx = 95;
+               ownx = tarx + bwidth;
+       }
+       
+       
+       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "CSpace:", xco, yco, 80,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+       
+       uiBlockBeginAlign(block);
+       
+       /* Target-Space */
+       if (target == 1) {
+               uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Target Space %t|World Space %x0|Pose Space %x3|Local with Parent %x4|Local Space %x1", 
+                                                                                               tarx, yco, bwidth, 18, &con->tarspace, 0, 0, 0, 0, "Choose space that target is evaluated in"); 
+       }
+       else if (target == 0) {
+               uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Target Space %t|World Space %x0|Local (Without Parent) Space %x1", 
+                                                                               tarx, yco, bwidth, 18, &con->tarspace, 0, 0, 0, 0, "Choose space that target is evaluated in"); 
+       }
+       
+       /* Owner-Space */
+       if (owner == 1) {
+               uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Owner Space %t|World Space %x0|Pose Space %x3|Local with Parent %x4|Local Space %x1", 
+                                                                                               ownx, yco, bwidth, 18, &con->ownspace, 0, 0, 0, 0, "Choose space that owner is evaluated in");  
+       }
+       else if (owner == 0) {
+               uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Owner Space %t|World Space %x0|Local (Without Parent) Space %x1", 
+                                                                               ownx, yco, bwidth, 18, &con->ownspace, 0, 0, 0, 0, "Choose space that owner is evaluated in");  
+       }
+       
+       uiBlockEndAlign(block);
+}
+
+/* draw panel showing settings for a constraint */
 static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, short *xco, short *yco)
 {
-       Object *ob= OBACT, *target;
+       Object *ob= OBACT;
+       bConstraintTypeInfo *cti;
        uiBut *but;
-       char typestr[64], *subtarget;
-       short height, width = 265, is_armature_target;
-       int curCol, rb_col;
-
-       target= get_constraint_target(con, &subtarget);
-       is_armature_target= (target && target->type==OB_ARMATURE);
-       
+       char typestr[32];
+       short height, width = 265;
+       int rb_col;
+
+       cti= constraint_get_typeinfo(con);
+       if (cti == NULL) {
+               /* exception for 'Null' constraint - it doesn't have constraint typeinfo! */
+               if (con->type == CONSTRAINT_TYPE_NULL)
+                       strcpy(typestr, "Null");
+               else
+                       strcpy(typestr, "Unknown");
+       }
+       else
+               strcpy(typestr, cti->name);
+               
        /* unless button has own callback, it adds this callback to button */
        uiBlockSetFunc(block, constraint_active_func, ob, con);
-       
-       get_constraint_typestring (typestr, con);
-
-       curCol = get_constraint_col(con);
 
        /* Draw constraint header */
        uiBlockSetEmboss(block, UI_EMBOSSN);
        
        /* rounded header */
-       rb_col= (con->flag & CONSTRAINT_ACTIVE)?40:20;
+       rb_col= (con->flag & CONSTRAINT_ACTIVE)?50:20;
        uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-1, width+40, 22, NULL, 5.0, 0.0, 
                         (con->flag & CONSTRAINT_EXPAND)?3:15 , rb_col-20, ""); 
        
        /* open/close */
        uiDefIconButBitS(block, ICONTOG, CONSTRAINT_EXPAND, B_CONSTRAINT_TEST, ICON_DISCLOSURE_TRI_RIGHT, *xco-10, *yco, 20, 20, &con->flag, 0.0, 0.0, 0.0, 0.0, "Collapse/Expand Constraint");
        
-       /* up down */
+       /* up/down */
+       uiBlockBeginAlign(block);
        uiBlockSetEmboss(block, UI_EMBOSS);
-       but = uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, VICON_MOVE_UP, *xco+width-50, *yco, 16, 18, NULL, 0.0, 0.0, 0.0, 0.0, "Move modifier up in stack");
+       but = uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, VICON_MOVE_UP, *xco+width-50, *yco, 16, 18, NULL, 0.0, 0.0, 0.0, 0.0, "Move constraint up in constraint stack");
        uiButSetFunc(but, constraint_moveUp, ob, con);
        
-       but = uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, VICON_MOVE_DOWN, *xco+width-50+20, *yco, 16, 18, NULL, 0.0, 0.0, 0.0, 0.0, "Move modifier down in stack");
+       but = uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, VICON_MOVE_DOWN, *xco+width-50+18, *yco, 16, 18, NULL, 0.0, 0.0, 0.0, 0.0, "Move constraint down in constraint stack");
        uiButSetFunc(but, constraint_moveDown, ob, con);
+       uiBlockEndAlign(block);
        
        if (con->flag & CONSTRAINT_EXPAND) {
-               
-               if (con->flag & CONSTRAINT_DISABLE) {
-                       BIF_ThemeColor(TH_REDALERT);
+               if (con->flag & CONSTRAINT_DISABLE)
                        uiBlockSetCol(block, TH_REDALERT);
-               }
-               else
-                       BIF_ThemeColor(curCol);
-
-               /*if (type==TARGET_BONE)
-                       but = uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Bone Constraint%t|Track To%x2|IK Solver%x3|Copy Rotation%x8|Copy Location%x9|Action%x12|Null%x0", *xco+20, *yco, 100, 20, &con->type, 0.0, 0.0, 0.0, 0.0, "Constraint type"); 
-               else
-                       but = uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Object Constraint%t|Track To%x2|Copy Rotation%x8|Copy Location%x9|Null%x0", *xco+20, *yco, 100, 20, &con->type, 0.0, 0.0, 0.0, 0.0, "Constraint type"); 
-               */
+               
                uiBlockSetEmboss(block, UI_EMBOSS);
                
                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, typestr, *xco+10, *yco, 100, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
                
                but = uiDefBut(block, TEX, B_CONSTRAINT_TEST, "", *xco+120, *yco, 85, 18, con->name, 0.0, 29.0, 0.0, 0.0, "Constraint name"); 
-               uiButSetFunc(but, verify_constraint_name_func, ob, con);
+               uiButSetFunc(but, verify_constraint_name_func, con, NULL);
        }       
-       else{
+       else {
                uiBlockSetEmboss(block, UI_EMBOSSN);
-
-               if (con->flag & CONSTRAINT_DISABLE) {
+               
+               if (con->flag & CONSTRAINT_DISABLE)
                        uiBlockSetCol(block, TH_REDALERT);
-                       BIF_ThemeColor(TH_REDALERT);
-               }
-               else
-                       BIF_ThemeColor(curCol);
                
                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, typestr, *xco+10, *yco, 100, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
                
@@ -612,46 +576,206 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
        uiBlockSetEmboss(block, UI_EMBOSS);
 
 
-       /* Draw constraint data*/
-       if (!(con->flag & CONSTRAINT_EXPAND)) {
-               (*yco)-=21;
+       /* Draw constraint data */
+       if ((con->flag & CONSTRAINT_EXPAND) == 0) {
+               (*yco) -= 21;
        }
        else {
-               switch (con->type){
+               switch (con->type) {
+               case CONSTRAINT_TYPE_PYTHON:
+                       {
+                               bPythonConstraint *data = con->data;
+                               bConstraintTarget *ct;
+                               uiBut *but2;
+                               int tarnum, theight;
+                               static int pyconindex=0;
+                               char *menustr;
+                               
+                               theight = (data->tarnum)? (data->tarnum * 38) : (38);
+                               height = theight + 78;
+                               uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40, height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
+                               
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Script:", *xco+60, *yco-24, 55, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               
+                               /* do the scripts menu */
+                               menustr = buildmenu_pyconstraints(data->text, &pyconindex);
+                               but2 = uiDefButI(block, MENU, B_CONSTRAINT_TEST, menustr,
+                                     *xco+120, *yco-24, 150, 20, &pyconindex,
+                                     0.0, 1.0, 0, 0, "Set the Script Constraint to use");
+                               uiButSetFunc(but2, validate_pyconstraint_cb, data, &pyconindex);
+                               MEM_freeN(menustr);     
+                               
+                               /* draw target(s) */
+                               if (data->flag & PYCON_USETARGETS) {
+                                       /* Draw target parameters */ 
+                                       for (ct=data->targets.first, tarnum=1; ct; ct=ct->next, tarnum++) {
+                                               char tarstr[32];
+                                               short yoffset= ((tarnum-1) * 38);
+                                               
+                                               /* target label */
+                                               sprintf(tarstr, "Target %02d:", tarnum);
+                                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, tarstr, *xco+45, *yco-(48+yoffset), 60, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                               
+                                               /* target space-selector - per target */
+                                               if (is_armature_target(ct->tar)) {
+                                                       uiDefButS(block, MENU, B_CONSTRAINT_TEST, "Target Space %t|World Space %x0|Pose Space %x3|Local with Parent %x4|Local Space %x1", 
+                                                                                                                       *xco+10, *yco-(66+yoffset), 100, 18, &ct->space, 0, 0, 0, 0, "Choose space that target is evaluated in");       
+                                               }
+                                               else {
+                                                       uiDefButS(block, MENU, B_CONSTRAINT_TEST, "Target Space %t|World Space %x0|Local (Without Parent) Space %x1", 
+                                                                                                                       *xco+10, *yco-(66+yoffset), 100, 18, &ct->space, 0, 0, 0, 0, "Choose space that target is evaluated in");       
+                                               }
+                                               
+                                               uiBlockBeginAlign(block);
+                                                       /* target object */
+                                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-(48+yoffset), 150, 18, &ct->tar, "Target Object"); 
+                                                       
+                                                       /* subtarget */
+                                                       if (is_armature_target(ct->tar)) {
+                                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-(66+yoffset),150,18, &ct->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)ct->tar);
+                                                       }
+                                                       else if (is_geom_target(ct->tar)) {
+                                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-(66+yoffset),150,18, &ct->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)ct->tar);
+                                                       }
+                                                       else {
+                                                               strcpy(ct->subtarget, "");
+                                                       }
+                                               uiBlockEndAlign(block);
+                                       }
+                               }
+                               else {
+                                       /* Draw indication that no target needed */
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+60, *yco-48, 55, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Not Applicable", *xco+120, *yco-48, 150, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               }
+                               
+                               /* settings */
+                               uiBlockBeginAlign(block);
+                                       but=uiDefBut(block, BUT, B_CONSTRAINT_TEST, "Options", *xco, *yco-(52+theight), (width/2),18, NULL, 0, 24, 0, 0, "Change some of the constraint's settings.");
+                                       uiButSetFunc(but, BPY_pyconstraint_settings, data, NULL);
+                                       
+                                       but=uiDefBut(block, BUT, B_CONSTRAINT_TEST, "Refresh", *xco+((width/2)+10), *yco-(52+theight), (width/2),18, NULL, 0, 24, 0, 0, "Force constraint to refresh it's settings");
+                               uiBlockEndAlign(block);
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-(73+theight), is_armature_owner(ob), -1);
+                       }
+                       break;
                case CONSTRAINT_TYPE_ACTION:
                        {
                                bActionConstraint *data = con->data;
-
-                               height = 88;
+                               float minval, maxval;
+                               
+                               height = 108;
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target){
-                                       but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
+                               
                                uiBlockEndAlign(block);
-
-                               /* Draw action button */
+                               
+                               /* Draw action/type buttons */
                                uiBlockBeginAlign(block);
-                               uiDefButS(block, TOG, B_CONSTRAINT_TEST, "Local",                                               *xco+((width/2)-117), *yco-46, 78, 18, &data->local, 0, 0, 0, 0, "Use true local rotation difference");
-                               uiDefIDPoinBut(block, test_actionpoin_but, ID_AC, B_CONSTRAINT_TEST, "AC:",     *xco+((width/2)-117), *yco-64, 78, 18, &data->act, "Action containing the keyed motion for this bone"); 
-                               uiDefButS(block, MENU, B_CONSTRAINT_TEST, "Key on%t|X Rot%x0|Y Rot%x1|Z Rot%x2", *xco+((width/2)-117), *yco-84, 78, 18, &data->type, 0, 24, 0, 0, "Specify which transformation channel from the target is used to key the action");
-
+                                       uiDefIDPoinBut(block, test_actionpoin_but, ID_AC, B_CONSTRAINT_TEST, "AC:",     *xco+((width/2)-117), *yco-64, 78, 18, &data->act, "Action containing the keyed motion for this bone"); 
+                                       uiDefButS(block, MENU, B_CONSTRAINT_TEST, "Key on%t|Loc X%x20|Loc Y%x21|Loc Z%x22|Rot X%x0|Rot Y%x1|Rot Z%x2|Size X%x10|Size Y%x11|Size Z%x12", *xco+((width/2)-117), *yco-84, 78, 18, &data->type, 0, 24, 0, 0, "Specify which transformation channel from the target is used to key the action");
+                               uiBlockEndAlign(block);
+                               
+                               /* Draw start/end frame buttons */
+                               uiBlockBeginAlign(block);
+                                       uiDefButI(block, NUM, B_CONSTRAINT_TEST, "Start:", *xco+((width/2)-36), *yco-64, 78, 18, &data->start, 1, MAXFRAME, 0.0, 0.0, "Starting frame of the keyed motion"); 
+                                       uiDefButI(block, NUM, B_CONSTRAINT_TEST, "End:", *xco+((width/2)-36), *yco-84, 78, 18, &data->end, 1, MAXFRAME, 0.0, 0.0, "Ending frame of the keyed motion"); 
+                               uiBlockEndAlign(block);
+                               
+                               /* Draw minimum/maximum transform range buttons */
+                               uiBlockBeginAlign(block);
+                                       if (data->type < 10) { /* rotation */
+                                               minval = -180.0f;
+                                               maxval = 180.0f;
+                                       }
+                                       else if (data->type < 20) { /* scaling */
+                                               minval = 0.0001f;
+                                               maxval = 1000.0f;
+                                       }
+                                       else { /* location */
+                                               minval = -1000.0f;
+                                               maxval = 1000.0f;
+                                       }
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Min:", *xco+((width/2)+45), *yco-64, 78, 18, &data->min, minval, maxval, 0, 0, "Minimum value for target channel range");
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Max:", *xco+((width/2)+45), *yco-84, 78, 18, &data->max, minval, maxval, 0, 0, "Maximum value for target channel range");
+                               uiBlockEndAlign(block);
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-104, -1, is_armature_target(data->tar));
+                       }
+                       break;
+               case CONSTRAINT_TYPE_CHILDOF:
+                       {
+                               bChildOfConstraint *data = con->data;
+                               short normButWidth = (width/3);
+                               
+                               height = 165;
+                               uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
+                               
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Parent:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               
+                               /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefButI(block, NUM, B_CONSTRAINT_TEST, "Start:", *xco+((width/2)-36), *yco-64, 78, 18, &data->start, 1, MAXFRAME, 0.0, 0.0, "Starting frame of the keyed motion"); 
-                               uiDefButI(block, NUM, B_CONSTRAINT_TEST, "End:", *xco+((width/2)-36), *yco-84, 78, 18, &data->end, 1, MAXFRAME, 0.0, 0.0, "Ending frame of the keyed motion"); 
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object to use as Parent"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone to use as Parent");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
+                               uiBlockEndAlign(block);
+                               
+                               /* Draw triples of channel toggles */
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Use Channel(s):", *xco+65, *yco-64, 150, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               uiBlockBeginAlign(block); 
+                                       uiDefButBitI(block, TOG, CHILDOF_LOCX, B_CONSTRAINT_TEST, "Loc X", *xco, *yco-84, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects x-location"); 
+                                       uiDefButBitI(block, TOG, CHILDOF_LOCY, B_CONSTRAINT_TEST, "Loc Y", *xco+normButWidth, *yco-84, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects y-location"); 
+                                       uiDefButBitI(block, TOG, CHILDOF_LOCZ, B_CONSTRAINT_TEST, "Loc Z", *xco+(normButWidth * 2), *yco-84, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects z-location"); 
+                               uiBlockEndAlign(block); 
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefButBitI(block, TOG, CHILDOF_ROTX, B_CONSTRAINT_TEST, "Rot X", *xco, *yco-105, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects x-rotation"); 
+                                       uiDefButBitI(block, TOG, CHILDOF_ROTY, B_CONSTRAINT_TEST, "Rot Y", *xco+normButWidth, *yco-105, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects y-rotation"); 
+                                       uiDefButBitI(block, TOG, CHILDOF_ROTZ, B_CONSTRAINT_TEST, "Rot Z", *xco+(normButWidth * 2), *yco-105, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects z-rotation"); 
+                               uiBlockEndAlign(block); 
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefButBitI(block, TOG, CHILDOF_SIZEX, B_CONSTRAINT_TEST, "Scale X", *xco, *yco-126, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects x-scaling"); 
+                                       uiDefButBitI(block, TOG, CHILDOF_SIZEY, B_CONSTRAINT_TEST, "Scale Y", *xco+normButWidth, *yco-126, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects y-scaling"); 
+                                       uiDefButBitI(block, TOG, CHILDOF_SIZEZ, B_CONSTRAINT_TEST, "Scale Z", *xco+(normButWidth * 2), *yco-126, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Parent affects z-scaling"); 
+                               uiBlockEndAlign(block);
+                               
                                
+                               /* Inverse options */
                                uiBlockBeginAlign(block);
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Min:", *xco+((width/2)+45), *yco-64, 78, 18, &data->min, -180, 180, 0, 0, "Minimum value for target channel range");
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Max:", *xco+((width/2)+45), *yco-84, 78, 18, &data->max, -180, 180, 0, 0, "Maximum value for target channel range");
+                                       but=uiDefBut(block, BUT, B_CONSTRAINT_TEST, "Set Offset", *xco, *yco-151, (width/2),18, NULL, 0, 24, 0, 0, "Calculate current Parent-Inverse Matrix (i.e. restore offset from parent)");
+                                       uiButSetFunc(but, childof_const_setinv, data, NULL);
+                                       
+                                       but=uiDefBut(block, BUT, B_CONSTRAINT_TEST, "Clear Offset", *xco+((width/2)+10), *yco-151, (width/2),18, NULL, 0, 24, 0, 0, "Clear Parent-Inverse Matrix (i.e. clear offset from parent)");
+                                       uiButSetFunc(but, childof_const_clearinv, data, NULL);
                                uiBlockEndAlign(block);
                        }
                        break;
@@ -659,207 +783,325 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
                        {
                                bLocateLikeConstraint *data = con->data;
                                
-                               height = 66;
+                               height = 111;
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
-
+                               
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target) {
-                                       but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
                                
                                /* Draw XYZ toggles */
                                uiBlockBeginAlign(block);
-                               if (is_armature_target)
-                                       uiDefButBitS(block, TOG, CONSTRAINT_LOCAL, B_CONSTRAINT_TEST, "Local", *xco+((width/2)-98), *yco-64, 50, 18, &con->flag, 0, 24, 0, 0, "Work on a Pose's local transform");
-                               but=uiDefButBitI(block, TOG, LOCLIKE_X, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
-                               but=uiDefButBitI(block, TOG, LOCLIKE_Y, B_CONSTRAINT_TEST, "Y", *xco+((width/2)-16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Y component");
-                               but=uiDefButBitI(block, TOG, LOCLIKE_Z, B_CONSTRAINT_TEST, "Z", *xco+((width/2)+16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Z component");
+                                       uiDefButBitI(block, TOG, LOCLIKE_X, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
+                                       uiDefButBitI(block, TOG, LOCLIKE_X_INVERT, B_CONSTRAINT_TEST, "-", *xco+((width/2)-16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Invert X component");
+                                       uiDefButBitI(block, TOG, LOCLIKE_Y, B_CONSTRAINT_TEST, "Y", *xco+((width/2)+16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Y component");
+                                       uiDefButBitI(block, TOG, LOCLIKE_Y_INVERT, B_CONSTRAINT_TEST, "-", *xco+((width/2)+48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Invert Y component");
+                                       uiDefButBitI(block, TOG, LOCLIKE_Z, B_CONSTRAINT_TEST, "Z", *xco+((width/2)+96), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Z component");
+                                       uiDefButBitI(block, TOG, LOCLIKE_Z_INVERT, B_CONSTRAINT_TEST, "-", *xco+((width/2)+128), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Invert Z component");
                                uiBlockEndAlign(block);
+                               
+                               /* Draw options */
+                               uiDefButBitI(block, TOG, LOCLIKE_OFFSET, B_CONSTRAINT_TEST, "Offset", *xco, *yco-89, (width/2), 18, &data->flag, 0, 24, 0, 0, "Add original location onto copied location");
+                               if (is_armature_target(data->tar)) {
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Head/Tail:", *xco+(width/2), *yco-89, (width/2), 18, &con->headtail, 0.0, 1, 0.1, 0.1, "Target along length of bone: Head=0, Tail=1");
+                               }
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-109, is_armature_owner(ob), is_armature_target(data->tar));
                        }
                        break;
                case CONSTRAINT_TYPE_ROTLIKE:
                        {
                                bRotateLikeConstraint *data = con->data;
                                
-                               /* also old files stuff... version patch is too much code! */
-                               if(data->flag==0) data->flag = ROTLIKE_X|ROTLIKE_Y|ROTLIKE_Z;
-                               
-                               height = 66;
+                               height = 101;
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target) {
-                                       but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) { 
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
                                
                                /* Draw XYZ toggles */
                                uiBlockBeginAlign(block);
-                               if (is_armature_target)
-                                       uiDefButBitS(block, TOG, CONSTRAINT_LOCAL, B_CONSTRAINT_TEST, "Local", *xco+((width/2)-98), *yco-64, 50, 18, &con->flag, 0, 24, 0, 0, "Work on a Pose's local transform");
-                               uiDefButBitI(block, TOG, ROTLIKE_X, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
-                               uiDefButBitI(block, TOG, ROTLIKE_Y, B_CONSTRAINT_TEST, "Y", *xco+((width/2)-16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Y component");
-                               uiDefButBitI(block, TOG, ROTLIKE_Z, B_CONSTRAINT_TEST, "Z", *xco+((width/2)+16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Z component");
+                                       uiDefButBitI(block, TOG, ROTLIKE_X, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
+                                       uiDefButBitI(block, TOG, ROTLIKE_X_INVERT, B_CONSTRAINT_TEST, "-", *xco+((width/2)-16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Invert X component");
+                                       uiDefButBitI(block, TOG, ROTLIKE_Y, B_CONSTRAINT_TEST, "Y", *xco+((width/2)+16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Y component");
+                                       uiDefButBitI(block, TOG, ROTLIKE_Y_INVERT, B_CONSTRAINT_TEST, "-", *xco+((width/2)+48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Invert Y component");
+                                       uiDefButBitI(block, TOG, ROTLIKE_Z, B_CONSTRAINT_TEST, "Z", *xco+((width/2)+96), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Z component");
+                                       uiDefButBitI(block, TOG, ROTLIKE_Z_INVERT, B_CONSTRAINT_TEST, "-", *xco+((width/2)+128), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Invert Z component");
                                uiBlockEndAlign(block);
+                               
+                               /* draw offset toggle */
+                               uiDefButBitI(block, TOG, ROTLIKE_OFFSET, B_CONSTRAINT_TEST, "Offset", *xco, *yco-64, 80, 18, &data->flag, 0, 24, 0, 0, "Add original rotation onto copied rotation");
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-94, is_armature_owner(ob), is_armature_target(data->tar));
                        }
                        break;
                case CONSTRAINT_TYPE_SIZELIKE:
                        {
                                bSizeLikeConstraint *data = con->data;
-                               height = 66;
-                       
+                               
+                               height = 101;
+                               
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
-
+                               
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-                               
-                               if (is_armature_target) {
-                                       but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
-
+                               
                                /* Draw XYZ toggles */
                                uiBlockBeginAlign(block);
-                               but=uiDefButI(block, TOG|BIT|0, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
-                               but=uiDefButI(block, TOG|BIT|1, B_CONSTRAINT_TEST, "Y", *xco+((width/2)-16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Y component");
-                               but=uiDefButI(block, TOG|BIT|2, B_CONSTRAINT_TEST, "Z", *xco+((width/2)+16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Z component");
+                                       uiDefButBitI(block, TOG, SIZELIKE_X, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
+                                       uiDefButBitI(block, TOG, SIZELIKE_Y, B_CONSTRAINT_TEST, "Y", *xco+((width/2)-16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Y component");
+                                       uiDefButBitI(block, TOG, SIZELIKE_Z, B_CONSTRAINT_TEST, "Z", *xco+((width/2)+16), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy Z component");
                                uiBlockEndAlign(block);
+                               
+                               /* draw offset toggle */
+                               uiDefButBitI(block, TOG, SIZELIKE_OFFSET, B_CONSTRAINT_TEST, "Offset", *xco, *yco-64, 80, 18, &data->flag, 0, 24, 0, 0, "Add original scaling onto copied scaling");
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-94, is_armature_owner(ob), is_armature_target(data->tar));
                        }
                        break;
                case CONSTRAINT_TYPE_KINEMATIC:
                        {
                                bKinematicConstraint *data = con->data;
                                
-                               height = 108;
+                               height = 146;
+                               if(data->poletar) 
+                                       height += 30;
+
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
-                               /* Draw target parameters */
-                               uiDefButBitS(block, TOG, CONSTRAINT_IK_ROT, B_CONSTRAINT_TEST, "Rot", *xco, *yco-24,60,19, &data->flag, 0, 0, 0, 0, "Chain follows rotation of target");
+                               /* IK Target */
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
                                
+                               /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 19, &data->tar, "Target Object"); 
+                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco, *yco-44, 137, 19, &data->tar, "Target Object"); 
 
-                               if (is_armature_target) {
-                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,19, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                               if (is_armature_target(data->tar)) {
+                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco, *yco-62,137,19, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
                                        uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
                                }
-                               else
+                               else if (is_geom_target(data->tar)) {
+                                       but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco, *yco-62,137,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                       uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                               }
+                               else {
                                        strcpy (data->subtarget, "");
-       
+                               }
+
+                               uiBlockEndAlign(block);
+
+                               /* Settings */
                                uiBlockBeginAlign(block);
-                               uiDefButBitS(block, TOG, CONSTRAINT_IK_TIP, B_CONSTRAINT_TEST, "Use Tip", *xco, *yco-64, 142, 19, &data->flag, 0, 0, 0, 0, "Include Bone's tip als last element in Chain");
-                               uiDefButI(block, NUM, B_CONSTRAINT_TEST, "ChainLen:", *xco+142, *yco-64,143,19, &data->rootbone, 0, 255, 0, 0, "If not zero, the amount of bones in this chain");
-                               
+                               uiDefButBitS(block, TOG, CONSTRAINT_IK_TIP, B_CONSTRAINT_TEST, "Use Tail", *xco, *yco-92, 137, 19, &data->flag, 0, 0, 0, 0, "Include Bone's tail als last element in Chain");
+                               uiDefButI(block, NUM, B_CONSTRAINT_TEST, "ChainLen:", *xco, *yco-112,137,19, &data->rootbone, 0, 255, 0, 0, "If not zero, the amount of bones in this chain");
+
                                uiBlockBeginAlign(block);
-                               uiDefButF(block, NUMSLI, B_CONSTRAINT_TEST, "PosW ", *xco, *yco-86, 142, 19, &data->weight, 0.01, 1.0, 2, 2, "For Tree-IK: weight of position control for this target");
-                               uiDefButF(block, NUMSLI, B_CONSTRAINT_TEST, "RotW ", *xco+142, *yco-86, 143, 19, &data->orientweight, 0.01, 1.0, 2, 2, "For Tree-IK: Weight of orientation control for this target");
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Tolerance:", *xco, *yco-106, 142, 19, &data->tolerance, 0.0001f, 1.0, 0, 0, "Maximum distance to target after solving"); 
-                               uiDefButS(block, NUM, B_CONSTRAINT_TEST, "Iterations:", *xco+142, *yco-106, 143, 19, &data->iterations, 1, 10000, 0, 0, "Maximum number of solving iterations"); 
-                               
+                               uiDefButF(block, NUMSLI, B_CONSTRAINT_TEST, "PosW ", *xco+147, *yco-92, 137, 19, &data->weight, 0.01, 1.0, 2, 2, "For Tree-IK: weight of position control for this target");
+                               uiDefButBitS(block, TOG, CONSTRAINT_IK_ROT, B_CONSTRAINT_TEST, "Rot", *xco+147, *yco-112, 40,19, &data->flag, 0, 0, 0, 0, "Chain follows rotation of target");
+                               uiDefButF(block, NUMSLI, B_CONSTRAINT_TEST, "W ", *xco+187, *yco-112, 97, 19, &data->orientweight, 0.01, 1.0, 2, 2, "For Tree-IK: Weight of orientation control for this target");
+
+                               uiBlockBeginAlign(block);
+
+                               uiDefButBitS(block, TOG, CONSTRAINT_IK_STRETCH, B_CONSTRAINT_TEST, "Stretch", *xco, *yco-137,137,19, &data->flag, 0, 0, 0, 0, "Enable IK stretching");
+                               uiBlockBeginAlign(block);
+                               uiDefButS(block, NUM, B_CONSTRAINT_TEST, "Iterations:", *xco+147, *yco-137, 137, 19, &data->iterations, 1, 10000, 0, 0, "Maximum number of solving iterations"); 
+                               uiBlockEndAlign(block);
+
+                               /* Pole Vector */
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Pole Target:", *xco+147, *yco-24, 100, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+
+                               uiBlockBeginAlign(block);
+                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+147, *yco-44, 137, 19, &data->poletar, "Pole Target Object"); 
+                               if (is_armature_target(data->poletar)) {
+                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+147, *yco-62,137,19, &data->polesubtarget, 0, 24, 0, 0, "Pole Subtarget Bone");
+                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->poletar);
+                               }
+                               else if (is_geom_target(data->poletar)) {
+                                       but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+147, *yco-62,137,18, &data->polesubtarget, 0, 24, 0, 0, "Name of Vertex Group defining pole 'target' points");
+                                       uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->poletar);
+                               }
+                               else {
+                                       strcpy (data->polesubtarget, "");
+                               }
+       
+                               if(data->poletar) {
+                                       uiBlockBeginAlign(block);
+#if 0
+                                       but = uiDefBut(block, BUT, B_CONSTRAINT_TEST, (data->flag & CONSTRAINT_IK_SETANGLE)? "Set Pole Offset": "Clear Pole Offset", *xco, *yco-167, 137, 19, 0, 0.0, 1.0, 0.0, 0.0, "Set the pole rotation offset from the current pose");
+                                       uiButSetFunc(but, con_kinematic_set_pole_angle, ob, con);
+                                       if(!(data->flag & CONSTRAINT_IK_SETANGLE))
+#endif
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Pole Offset ", *xco, *yco-167, 137, 19, &data->poleangle, -180.0, 180.0, 0, 0, "Pole rotation offset");
+                               }
                        }
                        break;
                case CONSTRAINT_TYPE_TRACKTO:
                        {
                                bTrackToConstraint *data = con->data;
-
-                               height = 66;
+                               
+                               if (is_armature_target(data->tar)) 
+                                       height = 118;
+                               else
+                                       height = 96;
+                                       
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target) {
-                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
-
+                               
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "To:", *xco+12, *yco-64, 25, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                               
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+39, *yco-64,17,18, &data->reserved1, 12.0, 0.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+56, *yco-64,17,18, &data->reserved1, 12.0, 1.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+73, *yco-64,17,18, &data->reserved1, 12.0, 2.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-X",    *xco+90, *yco-64,24,18, &data->reserved1, 12.0, 3.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Y",    *xco+114, *yco-64,24,18, &data->reserved1, 12.0, 4.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Z",    *xco+138, *yco-64,24,18, &data->reserved1, 12.0, 5.0, 0, 0, "The axis that points to the target object");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Align:", *xco+5, *yco-42, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
+                                       
+                                       uiDefButBitI(block, TOG, 1, B_CONSTRAINT_TEST, "TargetZ", *xco+60, *yco-42, 50, 18, &data->flags, 0, 1, 0, 0, "Target Z axis, not world Z axis, will constrain up direction");
                                uiBlockEndAlign(block);
                                
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Up:", *xco+174, *yco-64, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "To:", *xco+12, *yco-64, 25, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+39, *yco-64,17,18, &data->reserved1, 12.0, 0.0, 0, 0, "X axis points to the target object");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+56, *yco-64,17,18, &data->reserved1, 12.0, 1.0, 0, 0, "Y axis points to the target object");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+73, *yco-64,17,18, &data->reserved1, 12.0, 2.0, 0, 0, "Z axis points to the target object");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-X",    *xco+90, *yco-64,24,18, &data->reserved1, 12.0, 3.0, 0, 0, "-X axis points to the target object");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Y",    *xco+114, *yco-64,24,18, &data->reserved1, 12.0, 4.0, 0, 0, "-Y axis points to the target object");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Z",    *xco+138, *yco-64,24,18, &data->reserved1, 12.0, 5.0, 0, 0, "-Z axis points to the target object");
+                               uiBlockEndAlign(block);
                                
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+204, *yco-64,17,18, &data->reserved2, 13.0, 0.0, 0, 0, "The axis that points upward");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+221, *yco-64,17,18, &data->reserved2, 13.0, 1.0, 0, 0, "The axis that points upward");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+238, *yco-64,17,18, &data->reserved2, 13.0, 2.0, 0, 0, "The axis that points upward");
+                               uiBlockBeginAlign(block);
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Up:", *xco+174, *yco-64, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
+                                       
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+204, *yco-64,17,18, &data->reserved2, 13.0, 0.0, 0, 0, "X axis points upward");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+221, *yco-64,17,18, &data->reserved2, 13.0, 1.0, 0, 0, "Y axis points upward");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+238, *yco-64,17,18, &data->reserved2, 13.0, 2.0, 0, 0, "Z axis points upward");
                                uiBlockEndAlign(block);
+                               
+                               if (is_armature_target(data->tar)) {
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Head/Tail:", *xco, *yco-94, 241, 18, &con->headtail, 0.0, 1, 0.1, 0.1, "Target along length of bone: Head=0, Tail=1");
+                                       
+                                       /* constraint space settings */
+                                       draw_constraint_spaceselect(block, con, *xco, *yco-116, is_armature_owner(ob), is_armature_target(data->tar));
+                               }
+                               else {
+                                       /* constraint space settings */
+                                       draw_constraint_spaceselect(block, con, *xco, *yco-94, is_armature_owner(ob), is_armature_target(data->tar));
+                               }
                        }
                        break;
                case CONSTRAINT_TYPE_MINMAX:
                        {
                                bMinMaxConstraint *data = con->data;
-
-                               height = 66;
+                               
+                               if (is_armature_target(data->tar)) 
+                                       height = 88;
+                               else
+                                       height = 66;
+                                       
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Offset:", *xco, *yco-44, 100, 18, &data->offset, -100, 100, 100.0, 0.0, "Offset from the position of the object center"); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target) {
-                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
-
-                               but=uiDefButI(block, TOG|BIT|0, B_CONSTRAINT_TEST, "Sticky", *xco, *yco-24, 44, 18, &data->flag, 0, 24, 0, 0, "Immobilize object while constrained");
-                               but=uiDefButI(block, TOG|BIT|2, B_CONSTRAINT_TEST, "Use Rot", *xco+44, *yco-24, 64, 18, &data->flag, 0, 24, 0, 0, "Use target object rotation");
+                               
+                               uiDefButBitI(block, TOG, MINMAX_STICKY, B_CONSTRAINT_TEST, "Sticky", *xco, *yco-24, 44, 18, &data->flag, 0, 24, 0, 0, "Immobilize object while constrained");
+                               uiDefButBitI(block, TOG, MINMAX_USEROT, B_CONSTRAINT_TEST, "Use Rot", *xco+44, *yco-24, 64, 18, &data->flag, 0, 24, 0, 0, "Use target object rotation");
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Max/Min:", *xco-8, *yco-64, 54, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                uiBlockBeginAlign(block);                       
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+51, *yco-64,17,18, &data->minmaxflag, 12.0, 0.0, 0, 0, "Will not pass below X of target");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+67, *yco-64,17,18, &data->minmaxflag, 12.0, 1.0, 0, 0, "Will not pass below Y of target");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+85, *yco-64,17,18, &data->minmaxflag, 12.0, 2.0, 0, 0, "Will not pass below Z of target");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-X",    *xco+102, *yco-64,24,18, &data->minmaxflag, 12.0, 3.0, 0, 0, "Will not pass above X of target");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Y",    *xco+126, *yco-64,24,18, &data->minmaxflag, 12.0, 4.0, 0, 0, "Will not pass above Y of target");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Z",    *xco+150, *yco-64,24,18, &data->minmaxflag, 12.0, 5.0, 0, 0, "Will not pass above Z of target");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"X",    *xco+51, *yco-64,17,18, &data->minmaxflag, 12.0, 0.0, 0, 0, "Will not pass below X of target");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Y",    *xco+67, *yco-64,17,18, &data->minmaxflag, 12.0, 1.0, 0, 0, "Will not pass below Y of target");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Z",    *xco+85, *yco-64,17,18, &data->minmaxflag, 12.0, 2.0, 0, 0, "Will not pass below Z of target");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-X",   *xco+102, *yco-64,24,18, &data->minmaxflag, 12.0, 3.0, 0, 0, "Will not pass above X of target");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-Y",   *xco+126, *yco-64,24,18, &data->minmaxflag, 12.0, 4.0, 0, 0, "Will not pass above Y of target");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-Z",   *xco+150, *yco-64,24,18, &data->minmaxflag, 12.0, 5.0, 0, 0, "Will not pass above Z of target");
                                uiBlockEndAlign(block);
+                               
+                               if (is_armature_target(data->tar)) {
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Head/Tail:", *xco, *yco-86, 241, 18, &con->headtail, 0.0, 1, 0.1, 0.1, "Target along length of bone: Head=0, Tail=1");
+                               }
+                               
                        }
                        break;
                case CONSTRAINT_TYPE_LOCKTRACK:
@@ -867,76 +1109,81 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
                                bLockTrackConstraint *data = con->data;
                                height = 66;
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
-
+                               
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target) {
-                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
                                
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "To:", *xco+12, *yco-64, 25, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                               
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+39, *yco-64,17,18, &data->trackflag, 12.0, 0.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+56, *yco-64,17,18, &data->trackflag, 12.0, 1.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+73, *yco-64,17,18, &data->trackflag, 12.0, 2.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-X",    *xco+90, *yco-64,24,18, &data->trackflag, 12.0, 3.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Y",    *xco+114, *yco-64,24,18, &data->trackflag, 12.0, 4.0, 0, 0, "The axis that points to the target object");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Z",    *xco+138, *yco-64,24,18, &data->trackflag, 12.0, 5.0, 0, 0, "The axis that points to the target object");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "To:", *xco+12, *yco-64, 25, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"X",    *xco+39, *yco-64,17,18, &data->trackflag, 12.0, 0.0, 0, 0, "X axis points to the target object");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Y",    *xco+56, *yco-64,17,18, &data->trackflag, 12.0, 1.0, 0, 0, "Y axis points to the target object");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Z",    *xco+73, *yco-64,17,18, &data->trackflag, 12.0, 2.0, 0, 0, "Z axis points to the target object");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-X",   *xco+90, *yco-64,24,18, &data->trackflag, 12.0, 3.0, 0, 0, "-X axis points to the target object");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-Y",   *xco+114, *yco-64,24,18, &data->trackflag, 12.0, 4.0, 0, 0, "-Y axis points to the target object");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-Z",   *xco+138, *yco-64,24,18, &data->trackflag, 12.0, 5.0, 0, 0, "-Z axis points to the target object");
                                uiBlockEndAlign(block);
                                
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Lock:", *xco+166, *yco-64, 38, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
-                               
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+204, *yco-64,17,18, &data->lockflag, 13.0, 0.0, 0, 0, "The axis that is locked");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+221, *yco-64,17,18, &data->lockflag, 13.0, 1.0, 0, 0, "The axis that is locked");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+238, *yco-64,17,18, &data->lockflag, 13.0, 2.0, 0, 0, "The axis that is locked");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Lock:", *xco+166, *yco-64, 38, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
+                                       
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"X",    *xco+204, *yco-64,17,18, &data->lockflag, 13.0, 0.0, 0, 0, "X axis is locked");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Y",    *xco+221, *yco-64,17,18, &data->lockflag, 13.0, 1.0, 0, 0, "Y axis is locked");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Z",    *xco+238, *yco-64,17,18, &data->lockflag, 13.0, 2.0, 0, 0, "Z axis is locked");
                                uiBlockEndAlign(block);
                        }
                        break;
                case CONSTRAINT_TYPE_FOLLOWPATH:
                        {
                                bFollowPathConstraint *data = con->data;
-
+                               
                                height = 66;
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
                                
                                /* Draw Curve Follow toggle */
-                               but=uiDefButBitI(block, TOG, 1, B_CONSTRAINT_TEST, "CurveFollow", *xco+39, *yco-44, 100, 18, &data->followflag, 0, 24, 0, 0, "Object will follow the heading and banking of the curve");
-
+                               uiDefButBitI(block, TOG, 1, B_CONSTRAINT_TEST, "CurveFollow", *xco+39, *yco-44, 100, 18, &data->followflag, 0, 24, 0, 0, "Object will follow the heading and banking of the curve");
+                               
                                /* Draw Offset number button */
                                uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Offset:", *xco+155, *yco-44, 100, 18, &data->offset, -MAXFRAMEF, MAXFRAMEF, 100.0, 0.0, "Offset from the position corresponding to the time frame"); 
-
+                               
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Fw:", *xco+12, *yco-64, 27, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                               
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+39, *yco-64,17,18, &data->trackflag, 12.0, 0.0, 0, 0, "The axis that points forward along the path");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+56, *yco-64,17,18, &data->trackflag, 12.0, 1.0, 0, 0, "The axis that points forward along the path");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+73, *yco-64,17,18, &data->trackflag, 12.0, 2.0, 0, 0, "The axis that points forward along the path");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-X",    *xco+90, *yco-64,24,18, &data->trackflag, 12.0, 3.0, 0, 0, "The axis that points forward along the path");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Y",    *xco+114, *yco-64,24,18, &data->trackflag, 12.0, 4.0, 0, 0, "The axis that points forward along the path");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"-Z",    *xco+138, *yco-64,24,18, &data->trackflag, 12.0, 5.0, 0, 0, "The axis that points forward along the path");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Fw:", *xco+12, *yco-64, 27, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"X",    *xco+39, *yco-64,17,18, &data->trackflag, 12.0, 0.0, 0, 0, "The axis that points forward along the path");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Y",    *xco+56, *yco-64,17,18, &data->trackflag, 12.0, 1.0, 0, 0, "The axis that points forward along the path");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Z",    *xco+73, *yco-64,17,18, &data->trackflag, 12.0, 2.0, 0, 0, "The axis that points forward along the path");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-X",   *xco+90, *yco-64,24,18, &data->trackflag, 12.0, 3.0, 0, 0, "The axis that points forward along the path");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-Y",   *xco+114, *yco-64,24,18, &data->trackflag, 12.0, 4.0, 0, 0, "The axis that points forward along the path");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"-Z",   *xco+138, *yco-64,24,18, &data->trackflag, 12.0, 5.0, 0, 0, "The axis that points forward along the path");
                                uiBlockEndAlign(block);
                                
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Up:", *xco+174, *yco-64, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
-                               
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",     *xco+204, *yco-64,17,18, &data->upflag, 13.0, 0.0, 0, 0, "The axis that points upward");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Y",     *xco+221, *yco-64,17,18, &data->upflag, 13.0, 1.0, 0, 0, "The axis that points upward");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",     *xco+238, *yco-64,17,18, &data->upflag, 13.0, 2.0, 0, 0, "The axis that points upward");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Up:", *xco+174, *yco-64, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, "");
+                                       
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"X",    *xco+204, *yco-64,17,18, &data->upflag, 13.0, 0.0, 0, 0, "The axis that points upward");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Y",    *xco+221, *yco-64,17,18, &data->upflag, 13.0, 1.0, 0, 0, "The axis that points upward");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST,"Z",    *xco+238, *yco-64,17,18, &data->upflag, 13.0, 2.0, 0, 0, "The axis that points upward");
                                uiBlockEndAlign(block);
                        }
                        break;
@@ -948,40 +1195,50 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-
+                               
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
-                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
-
-                               if (is_armature_target) {
-                                       but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
-                                       uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
-                               }
-                               else
-                                       strcpy (data->subtarget, "");
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but=uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
                                uiBlockEndAlign(block);
-
                                
                                uiBlockBeginAlign(block);
-                               uiDefButF(block,BUTM,B_CONSTRAINT_TEST,"R",*xco, *yco-60,20,18,&(data->orglength),0.0,0,0,0,"Recalculate RLength");
-                               uiDefButF(block,NUM,B_CONSTRAINT_TEST,"Rest Length:",*xco+18, *yco-60,237,18,&(data->orglength),0.0,100,0.5,0.5,"Length at Rest Position");
+                                       if (is_armature_target(data->tar)) {
+                                               uiDefButF(block, BUTM, B_CONSTRAINT_TEST, "R", *xco, *yco-60, 20, 18, &data->orglength, 0.0, 0, 0, 0, "Recalculate RLength");
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Rest Length:", *xco+18, *yco-60,139,18, &data->orglength, 0.0, 100, 0.5, 0.5, "Length at Rest Position");
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Head/Tail:", *xco+155, *yco-60,97,18, &con->headtail, 0.0, 1, 0.1, 0.1, "Target along length of bone: Head=0, Tail=1");
+                                       }
+                                       else {
+                                               uiDefButF(block, BUTM, B_CONSTRAINT_TEST, "R", *xco, *yco-60, 20, 18, &data->orglength, 0.0, 0, 0, 0, "Recalculate RLength");
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Rest Length:", *xco+18, *yco-60, 237, 18, &data->orglength, 0.0, 100, 0.5, 0.5, "Length at Rest Position");
+                                       }
                                uiBlockEndAlign(block);
-
-                               uiDefButF(block,NUM,B_CONSTRAINT_TEST,"Volume Variation:",*xco+18, *yco-82,237,18,&(data->bulge),0.0,100,0.5,0.5,"Factor between volume variation and stretching");
-
+                               
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Volume Variation:", *xco+18, *yco-82, 237, 18, &data->bulge, 0.0, 100, 0.5, 0.5, "Factor between volume variation and stretching");
+                               
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Vol:",*xco+14, *yco-104,30,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"XZ",     *xco+44, *yco-104,30,18, &data->volmode, 12.0, 0.0, 0, 0, "Keep Volume: Scaling X & Z");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",      *xco+74, *yco-104,20,18, &data->volmode, 12.0, 1.0, 0, 0, "Keep Volume: Scaling X");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",      *xco+94, *yco-104,20,18, &data->volmode, 12.0, 2.0, 0, 0, "Keep Volume: Scaling Z");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"NONE", *xco+114, *yco-104,50,18, &data->volmode, 12.0, 3.0, 0, 0, "Ignore Volume");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Vol:",*xco+14, *yco-104,30,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"XZ",     *xco+44, *yco-104,30,18, &data->volmode, 12.0, 0.0, 0, 0, "Keep Volume: Scaling X & Z");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",      *xco+74, *yco-104,20,18, &data->volmode, 12.0, 1.0, 0, 0, "Keep Volume: Scaling X");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",      *xco+94, *yco-104,20,18, &data->volmode, 12.0, 2.0, 0, 0, "Keep Volume: Scaling Z");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"NONE", *xco+114, *yco-104,50,18, &data->volmode, 12.0, 3.0, 0, 0, "Ignore Volume");
                                uiBlockEndAlign(block);
-
                                
                                uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST,"Plane:",*xco+175, *yco-104,40,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",       *xco+215, *yco-104,20,18, &data->plane, 12.0, 0.0, 0, 0, "Keep X axis");
-                               uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",       *xco+235, *yco-104,20,18, &data->plane, 12.0, 2.0, 0, 0, "Keep Z axis");
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST,"Plane:",*xco+175, *yco-104,40,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"X",       *xco+215, *yco-104,20,18, &data->plane, 12.0, 0.0, 0, 0, "Keep X axis");
+                                       uiDefButI(block, ROW,B_CONSTRAINT_TEST,"Z",       *xco+235, *yco-104,20,18, &data->plane, 12.0, 2.0, 0, 0, "Keep Z axis");
                                uiBlockEndAlign(block);
                                }
                        break;
@@ -992,87 +1249,77 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
                                int togButWidth = 50;
                                int textButWidth = ((width/2)-togButWidth);
                                
-                               height = 118
+                               height = 136
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                /* Draw Pairs of LimitToggle+LimitValue */
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_XMIN, B_CONSTRAINT_TEST, "minX", *xco, *yco-28, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum x value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-28, (textButWidth-5), 18, &(data->xmin), -1000, 1000, 0.1,0.5,"Lowest x value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_XMIN, B_CONSTRAINT_TEST, "minX", *xco, *yco-28, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum x value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-28, (textButWidth-5), 18, &(data->xmin), -1000, 1000, 0.1,0.5,"Lowest x value to allow"); 
                                uiBlockEndAlign(block); 
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_XMAX, B_CONSTRAINT_TEST, "maxX", *xco+(width-(textButWidth-5)-togButWidth), *yco-28, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum x value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-28, (textButWidth-5), 18, &(data->xmax), -1000, 1000, 0.1,0.5,"Highest x value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_XMAX, B_CONSTRAINT_TEST, "maxX", *xco+(width-(textButWidth-5)-togButWidth), *yco-28, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum x value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-28, (textButWidth-5), 18, &(data->xmax), -1000, 1000, 0.1,0.5,"Highest x value to allow"); 
                                uiBlockEndAlign(block); 
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_YMIN, B_CONSTRAINT_TEST, "minY", *xco, *yco-50, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum y value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-50, (textButWidth-5), 18, &(data->ymin), -1000, 1000, 0.1,0.5,"Lowest y value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_YMIN, B_CONSTRAINT_TEST, "minY", *xco, *yco-50, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum y value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-50, (textButWidth-5), 18, &(data->ymin), -1000, 1000, 0.1,0.5,"Lowest y value to allow"); 
                                uiBlockEndAlign(block);
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_YMAX, B_CONSTRAINT_TEST, "maxY", *xco+(width-(textButWidth-5)-togButWidth), *yco-50, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum y value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-50, (textButWidth-5), 18, &(data->ymax), -1000, 1000, 0.1,0.5,"Highest y value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_YMAX, B_CONSTRAINT_TEST, "maxY", *xco+(width-(textButWidth-5)-togButWidth), *yco-50, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum y value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-50, (textButWidth-5), 18, &(data->ymax), -1000, 1000, 0.1,0.5,"Highest y value to allow"); 
                                uiBlockEndAlign(block); 
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_ZMIN, B_CONSTRAINT_TEST, "minZ", *xco, *yco-72, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum z value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-72, (textButWidth-5), 18, &(data->zmin), -1000, 1000, 0.1,0.5,"Lowest z value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_ZMIN, B_CONSTRAINT_TEST, "minZ", *xco, *yco-72, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum z value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-72, (textButWidth-5), 18, &(data->zmin), -1000, 1000, 0.1,0.5,"Lowest z value to allow"); 
                                uiBlockEndAlign(block);
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_ZMAX, B_CONSTRAINT_TEST, "maxZ", *xco+(width-(textButWidth-5)-togButWidth), *yco-72, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum z value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-72, (textButWidth-5), 18, &(data->zmax), -1000, 1000, 0.1,0.5,"Highest z value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_ZMAX, B_CONSTRAINT_TEST, "maxZ", *xco+(width-(textButWidth-5)-togButWidth), *yco-72, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum z value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-72, (textButWidth-5), 18, &(data->zmax), -1000, 1000, 0.1,0.5,"Highest z value to allow"); 
                                uiBlockEndAlign(block);
                                
-                               uiBlockBeginAlign(block);
-                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST,"Co-ordinate Space:",*xco, *yco-100,150,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                               
-                               if (ob->type == OB_ARMATURE && (ob->flag & OB_POSEMODE))
-                                       uiDefButBitS(block, TOG, CONSTRAINT_LOCAL, B_CONSTRAINT_TEST, "Local", *xco+160, *yco-100, 60, 18, &con->flag, 0, 24, 0, 0, "Limit locations relative to the bone's rest-position");
-                               else if (ob->parent != NULL)
-                                       uiDefButBitS(block, TOG, LIMIT_NOPARENT, B_CONSTRAINT_TEST, "Local", *xco+160, *yco-100, 60, 18, &data->flag2, 0, 24, 0, 0, "Limit locations relative to parent, not origin/world");
-                               else 
-                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST,"World",*xco+160, *yco-100,60,18, NULL, 0.0, 0.0, 0.0, 0.0, "Limit locations relative to origin/world"); 
+                               /* special option(s) */
+                               uiDefButBitS(block, TOG, LIMIT_TRANSFORM, B_CONSTRAINT_TEST, "For Transform", *xco+(width/4), *yco-100, (width/2), 18, &data->flag2, 0, 24, 0, 0, "Transforms are affected by this constraint as well"); 
                                
-                               uiBlockEndAlign(block);
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-130, is_armature_owner(ob), -1);
                        }
                        break;
                case CONSTRAINT_TYPE_ROTLIMIT:
                        {
                                bRotLimitConstraint *data = con->data;
-                               
                                int normButWidth = (width/3);
                                
-                               height = 118; 
+                               height = 106; 
+                               
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                /* Draw Pairs of LimitToggle+LimitValue */
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_XROT, B_CONSTRAINT_TEST, "LimitX", *xco, *yco-28, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Limit rotation on x-axis"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min:", *xco+normButWidth, *yco-28, normButWidth, 18, &(data->xmin), -360, 360, 0.1,0.5,"Lowest x value to allow"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max:", *xco+(normButWidth * 2), *yco-28, normButWidth, 18, &(data->xmax), -360, 360, 0.1,0.5,"Highest x value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_XROT, B_CONSTRAINT_TEST, "LimitX", *xco, *yco-28, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Limit rotation on x-axis"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min:", *xco+normButWidth, *yco-28, normButWidth, 18, &(data->xmin), -360, 360, 0.1,0.5,"Lowest x value to allow"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max:", *xco+(normButWidth * 2), *yco-28, normButWidth, 18, &(data->xmax), -360, 360, 0.1,0.5,"Highest x value to allow"); 
                                uiBlockEndAlign(block); 
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_YROT, B_CONSTRAINT_TEST, "LimitY", *xco, *yco-50, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Limit rotation on y-axis"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min:", *xco+normButWidth, *yco-50, normButWidth, 18, &(data->ymin), -360, 360, 0.1,0.5,"Lowest y value to allow"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max:", *xco+(normButWidth * 2), *yco-50, normButWidth, 18, &(data->ymax), -360, 360, 0.1,0.5,"Highest y value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_YROT, B_CONSTRAINT_TEST, "LimitY", *xco, *yco-50, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Limit rotation on y-axis"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min:", *xco+normButWidth, *yco-50, normButWidth, 18, &(data->ymin), -360, 360, 0.1,0.5,"Lowest y value to allow"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max:", *xco+(normButWidth * 2), *yco-50, normButWidth, 18, &(data->ymax), -360, 360, 0.1,0.5,"Highest y value to allow"); 
                                uiBlockEndAlign(block); 
                                
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_ZROT, B_CONSTRAINT_TEST, "LimitZ", *xco, *yco-72, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Limit rotation on z-axis"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min:", *xco+normButWidth, *yco-72, normButWidth, 18, &(data->zmin), -360, 360, 0.1,0.5,"Lowest z value to allow"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max:", *xco+(normButWidth * 2), *yco-72, normButWidth, 18, &(data->zmax), -360, 360, 0.1,0.5,"Highest z value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_ZROT, B_CONSTRAINT_TEST, "LimitZ", *xco, *yco-72, normButWidth, 18, &data->flag, 0, 24, 0, 0, "Limit rotation on z-axis"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min:", *xco+normButWidth, *yco-72, normButWidth, 18, &(data->zmin), -360, 360, 0.1,0.5,"Lowest z value to allow"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max:", *xco+(normButWidth * 2), *yco-72, normButWidth, 18, &(data->zmax), -360, 360, 0.1,0.5,"Highest z value to allow"); 
                                uiBlockEndAlign(block); 
                                
-                               if (ob->type == OB_ARMATURE && (ob->flag & OB_POSEMODE)) {
-                                       uiBlockBeginAlign(block);
-                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST,"Co-ordinate Space:",*xco, *yco-100,150,18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
-                                       uiDefButBitS(block, TOG, CONSTRAINT_LOCAL, B_CONSTRAINT_TEST, "Local", *xco+160, *yco-100, 60, 18, &con->flag, 0, 24, 0, 0, "Work on a Pose's local transform");
-                                       uiBlockEndAlign(block);
-                               }
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-100, is_armature_owner(ob), -1);
                        }
                        break;
                case CONSTRAINT_TYPE_SIZELIMIT:
@@ -1082,59 +1329,312 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
                                int togButWidth = 50;
                                int textButWidth = ((width/2)-togButWidth);
                                
-                               height = 90; 
+                               height = 106; 
+                                       
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                /* Draw Pairs of LimitToggle+LimitValue */
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_XMIN, B_CONSTRAINT_TEST, "minX", *xco, *yco-28, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum x value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-28, (textButWidth-5), 18, &(data->xmin), 0.0001, 1000, 0.1,0.5,"Lowest x value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_XMIN, B_CONSTRAINT_TEST, "minX", *xco, *yco-28, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum x value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-28, (textButWidth-5), 18, &(data->xmin), 0.0001, 1000, 0.1,0.5,"Lowest x value to allow"); 
                                uiBlockEndAlign(block); 
-
+                               
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_XMAX, B_CONSTRAINT_TEST, "maxX", *xco+(width-(textButWidth-5)-togButWidth), *yco-28, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum x value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-28, (textButWidth-5), 18, &(data->xmax), 0.0001, 1000, 0.1,0.5,"Highest x value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_XMAX, B_CONSTRAINT_TEST, "maxX", *xco+(width-(textButWidth-5)-togButWidth), *yco-28, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum x value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-28, (textButWidth-5), 18, &(data->xmax), 0.0001, 1000, 0.1,0.5,"Highest x value to allow"); 
                                uiBlockEndAlign(block); 
-
-
+                               
+                               
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_YMIN, B_CONSTRAINT_TEST, "minY", *xco, *yco-50, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum y value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-50, (textButWidth-5), 18, &(data->ymin), 0.0001, 1000, 0.1,0.5,"Lowest y value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_YMIN, B_CONSTRAINT_TEST, "minY", *xco, *yco-50, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum y value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-50, (textButWidth-5), 18, &(data->ymin), 0.0001, 1000, 0.1,0.5,"Lowest y value to allow"); 
                                uiBlockEndAlign(block); 
-
+                               
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_YMAX, B_CONSTRAINT_TEST, "maxY", *xco+(width-(textButWidth-5)-togButWidth), *yco-50, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum y value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-50, (textButWidth-5), 18, &(data->ymax), 0.0001, 1000, 0.1,0.5,"Highest y value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_YMAX, B_CONSTRAINT_TEST, "maxY", *xco+(width-(textButWidth-5)-togButWidth), *yco-50, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum y value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-50, (textButWidth-5), 18, &(data->ymax), 0.0001, 1000, 0.1,0.5,"Highest y value to allow"); 
                                uiBlockEndAlign(block); 
-
-
+                               
+                               
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_ZMIN, B_CONSTRAINT_TEST, "minZ", *xco, *yco-72, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum z value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-72, (textButWidth-5), 18, &(data->zmin), 0.0001, 1000, 0.1,0.5,"Lowest z value to allow"); 
+                                       uiDefButBitS(block, TOG, LIMIT_ZMIN, B_CONSTRAINT_TEST, "minZ", *xco, *yco-72, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum z value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-72, (textButWidth-5), 18, &(data->zmin), 0.0001, 1000, 0.1,0.5,"Lowest z value to allow"); 
                                uiBlockEndAlign(block); 
-
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefButBitS(block, TOG, LIMIT_ZMAX, B_CONSTRAINT_TEST, "maxZ", *xco+(width-(textButWidth-5)-togButWidth), *yco-72, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum z value"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-72, (textButWidth-5), 18, &(data->zmax), 0.0001, 1000, 0.1,0.5,"Highest z value to allow"); 
+                               uiBlockEndAlign(block);
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-100, is_armature_owner(ob), -1);
+                       }
+                       break;
+               case CONSTRAINT_TYPE_RIGIDBODYJOINT:
+                       {
+                               bRigidBodyJointConstraint *data = con->data;
+                               float extremeLin = 999.f;
+                               float extremeAngX = 180.f;
+                               float extremeAngY = 45.f;
+                               float extremeAngZ = 45.f;
+                               int togButWidth = 70;
+                               int offsetY = 150;
+                               int textButWidth = ((width/2)-togButWidth);
+                               
+                               uiDefButI(block, MENU, B_CONSTRAINT_TEST, "Joint Types%t|Ball%x1|Hinge%x2|Cone Twist%x4|Generic (experimental)%x12",//|Extra Force%x6",
+                                                                                               *xco, *yco-25, 150, 18, &data->type, 0, 0, 0, 0, "Choose the joint type");
+                height = 140;
+                               if (data->type==CONSTRAINT_RB_GENERIC6DOF)
+                                       height = 270;
+                               if (data->type==CONSTRAINT_RB_CONETWIST)
+                                       height = 200;
+                               
+                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, "");
+                               
+                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "toObject:", *xco, *yco-50, 130, 18, &data->tar, "Child Object");
+                               uiDefButBitS(block, TOG, CONSTRAINT_DRAW_PIVOT, B_CONSTRAINT_TEST, "ShowPivot", *xco+135, *yco-50, 130, 18, &data->flag, 0, 24, 0, 0, "Show pivot position and rotation");                              
+                               
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Pivot X:", *xco, *yco-75, 130, 18, &data->pivX, -1000, 1000, 100, 0.0, "Offset pivot on X");
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Pivot Y:", *xco, *yco-100, 130, 18, &data->pivY, -1000, 1000, 100, 0.0, "Offset pivot on Y");
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Pivot Z:", *xco, *yco-125, 130, 18, &data->pivZ, -1000, 1000, 100, 0.0, "Offset pivot on z");
+                               
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Ax X:", *xco+135, *yco-75, 130, 18, &data->axX, -360, 360, 1500, 0.0, "Rotate pivot on X Axis (in degrees)");
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Ax Y:", *xco+135, *yco-100, 130, 18, &data->axY, -360, 360, 1500, 0.0, "Rotate pivot on Y Axis (in degrees)");
+                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "Ax Z:", *xco+135, *yco-125, 130, 18, &data->axZ, -360, 360, 1500, 0.0, "Rotate pivot on Z Axis (in degrees)");
+                               
+                               if (data->type==CONSTRAINT_RB_GENERIC6DOF) {
+                                       /* Draw Pairs of LimitToggle+LimitValue */
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 1, B_CONSTRAINT_TEST, "LinMinX", *xco, *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum x limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-offsetY, (textButWidth-5), 18, &(data->minLimit[0]), -extremeLin, extremeLin, 0.1,0.5,"min x limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 1, B_CONSTRAINT_TEST, "LinMaxX", *xco+(width-(textButWidth-5)-togButWidth), *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use maximum x limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-offsetY, (textButWidth), 18, &(data->maxLimit[0]), -extremeLin, extremeLin, 0.1,0.5,"max x limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       offsetY += 20;
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 2, B_CONSTRAINT_TEST, "LinMinY", *xco, *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum y limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-offsetY, (textButWidth-5), 18, &(data->minLimit[1]), -extremeLin, extremeLin, 0.1,0.5,"min y limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 2, B_CONSTRAINT_TEST, "LinMaxY", *xco+(width-(textButWidth-5)-togButWidth), *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use maximum y limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-offsetY, (textButWidth), 18, &(data->maxLimit[1]), -extremeLin, extremeLin, 0.1,0.5,"max y limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       offsetY += 20;
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 4, B_CONSTRAINT_TEST, "LinMinZ", *xco, *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum z limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-offsetY, (textButWidth-5), 18, &(data->minLimit[2]), -extremeLin, extremeLin, 0.1,0.5,"min z limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 4, B_CONSTRAINT_TEST, "LinMaxZ", *xco+(width-(textButWidth-5)-togButWidth), *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use maximum z limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-offsetY, (textButWidth), 18, &(data->maxLimit[2]), -extremeLin, extremeLin, 0.1,0.5,"max z limit"); 
+                                       uiBlockEndAlign(block);
+                                       offsetY += 20;
+                               }
+                               if ((data->type==CONSTRAINT_RB_GENERIC6DOF) || (data->type==CONSTRAINT_RB_CONETWIST)) {
+                                       /* Draw Pairs of LimitToggle+LimitValue */
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 8, B_CONSTRAINT_TEST, "AngMinX", *xco, *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum x limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-offsetY, (textButWidth-5), 18, &(data->minLimit[3]), -extremeAngX, extremeAngX, 0.1,0.5,"min x limit"); 
+                                       uiBlockEndAlign(block);
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 8, B_CONSTRAINT_TEST, "AngMaxX", *xco+(width-(textButWidth-5)-togButWidth), *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use maximum x limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-offsetY, (textButWidth), 18, &(data->maxLimit[3]), -extremeAngX, extremeAngX, 0.1,0.5,"max x limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       offsetY += 20;
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 16, B_CONSTRAINT_TEST, "AngMinY", *xco, *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum y limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-offsetY, (textButWidth-5), 18, &(data->minLimit[4]), -extremeAngY, extremeAngY, 0.1,0.5,"min y limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 16, B_CONSTRAINT_TEST, "AngMaxY", *xco+(width-(textButWidth-5)-togButWidth), *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use maximum y limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-offsetY, (textButWidth), 18, &(data->maxLimit[4]), -extremeAngY, extremeAngY, 0.1,0.5,"max y limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       offsetY += 20;
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 32, B_CONSTRAINT_TEST, "AngMinZ", *xco, *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use minimum z limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+togButWidth, *yco-offsetY, (textButWidth-5), 18, &(data->minLimit[5]), -extremeAngZ, extremeAngZ, 0.1,0.5,"min z limit"); 
+                                       uiBlockEndAlign(block);
+                                       
+                                       uiBlockBeginAlign(block); 
+                                               uiDefButBitS(block, TOG, 32, B_CONSTRAINT_TEST, "AngMaxZ", *xco+(width-(textButWidth-5)-togButWidth), *yco-offsetY, togButWidth, 18, &data->flag, 0, 24, 0, 0, "Use maximum z limit"); 
+                                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-offsetY, (textButWidth), 18, &(data->maxLimit[5]), -extremeAngZ, extremeAngZ, 0.1,0.5,"max z limit"); 
+                                       uiBlockEndAlign(block);
+                               }
+                       }
+                       break;
+               case CONSTRAINT_TYPE_CLAMPTO:
+                       {
+                               bClampToConstraint *data = con->data;
+                               
+                               height = 90;
+                               uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
+                               
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               
+                               /* Draw target parameters */
+                               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
+                               
+                               /* Draw XYZ toggles */
+                               uiBlockBeginAlign(block);
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Main Axis:", *xco, *yco-64, 90, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST, "Auto", *xco+100, *yco-64, 50, 18, &data->flag, 12.0, CLAMPTO_AUTO, 0, 0, "Automatically determine main-axis of movement");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST, "X", *xco+150, *yco-64, 32, 18, &data->flag, 12.0, CLAMPTO_X, 0, 0, "Main axis of movement is x-axis");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST, "Y", *xco+182, *yco-64, 32, 18, &data->flag, 12.0, CLAMPTO_Y, 0, 0, "Main axis of movement is y-axis");
+                                       uiDefButI(block, ROW, B_CONSTRAINT_TEST, "Z", *xco+214, *yco-64, 32, 18, &data->flag, 12.0, CLAMPTO_Z, 0, 0, "Main axis of movement is z-axis");
+                               uiBlockEndAlign(block);
+                               
+                               /* Extra Options Controlling Behaviour */
+                               //uiBlockBeginAlign(block);
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Options:", *xco, *yco-88, 90, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButBitI(block, TOG, CLAMPTO_CYCLIC, B_CONSTRAINT_TEST, "Cyclic", *xco+((width/2)), *yco-88,60,19, &data->flag2, 0, 0, 0, 0, "Treat curve as cyclic curve (no clamping to curve bounding box)");
+                               //uiBlockEndAlign(block);
+                       }
+                       break;
+               case CONSTRAINT_TYPE_TRANSFORM:
+                       {
+                               bTransformConstraint *data = con->data;
+                               float fmin, fmax, tmin, tmax;
+                               
+                               height = 178;
+                               uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
+                               
+                               /* Draw target parameters */                    
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               
+                               /* Draw target parameters */
+                               uiBlockBeginAlign(block);
+                                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object to use as Parent"); 
+                                       
+                                       if (is_armature_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone to use as Parent");
+                                               uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
+                                       }
+                                       else if (is_geom_target(data->tar)) {
+                                               but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "VG:", *xco+120, *yco-66,150,18, &data->subtarget, 0, 24, 0, 0, "Name of Vertex Group defining 'target' points");
+                                               uiButSetCompleteFunc(but, autocomplete_vgroup, (void *)data->tar);
+                                       }
+                                       else {
+                                               strcpy(data->subtarget, "");
+                                       }
+                               uiBlockEndAlign(block);
+                               
+                               /* Extrapolate Ranges? */
+                               uiDefButBitC(block, TOG, 1, B_CONSTRAINT_TEST, "Extrapolate", *xco, *yco-42,80,19, &data->expo, 0, 0, 0, 0, "Extrapolate ranges");
+                               
+                               /* Draw options for source motion */
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Source:", *xco-10, *yco-62, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               
+                               /*      draw Loc/Rot/Size toggles       */
+                               uiBlockBeginAlign(block);
+                                       uiDefButS(block, ROW, B_CONSTRAINT_TEST, "Loc", *xco-5, *yco-82, 45, 18, &data->from, 12.0, 0, 0, 0, "Use Location transform channels from Target");
+                                       uiDefButS(block, ROW, B_CONSTRAINT_TEST, "Rot", *xco+40, *yco-82, 45, 18, &data->from, 12.0, 1, 0, 0, "Use Rotation transform channels from Target");
+                                       uiDefButS(block, ROW, B_CONSTRAINT_TEST, "Scale", *xco+85, *yco-82, 45, 18, &data->from, 12.0, 2, 0, 0, "Use Scale transform channels from Target");
+                               uiBlockEndAlign(block);
+                               
+                               /* Draw Pairs of Axis: Min/Max Value*/
+                               if (data->from == 2) {
+                                       fmin= 0.0001;
+                                       fmax= 1000.0;
+                               }
+                               else if (data->from == 1) {
+                                       fmin= -360.0;
+                                       fmax= 360.0;
+                               }
+                               else {
+                                       fmin = -1000.0;
+                                       fmax= 1000.0;
+                               }
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "X:", *xco-10, *yco-107, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min", *xco+20, *yco-107, 55, 18, &data->from_min[0], fmin, fmax, 0, 0, "Bottom of range of x-axis source motion for source->target mapping"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max", *xco+75, *yco-107, 55, 18, &data->from_max[0], fmin, fmax, 0, 0, "Top of range of x-axis source motion for source->target mapping"); 
+                               uiBlockEndAlign(block); 
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Y:", *xco-10, *yco-127, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min", *xco+20, *yco-127, 55, 18, &data->from_min[1], fmin, fmax, 0, 0, "Bottom of range of y-axis source motion for source->target mapping"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max", *xco+75, *yco-127, 55, 18, &data->from_max[1], fmin, fmax, 0, 0, "Top of range of y-axis source motion for source->target mapping"); 
+                               uiBlockEndAlign(block);
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Z:", *xco-10, *yco-147, 30, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min", *xco+20, *yco-147, 55, 18, &data->from_min[2], fmin, fmax, 0, 0, "Bottom of range of z-axis source motion for source->target mapping"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max", *xco+75, *yco-147, 55, 18, &data->from_max[2], fmin, fmax, 0, 0, "Top of range of z-axis source motion for source->target mapping"); 
+                               uiBlockEndAlign(block); 
+                               
+                               
+                               /* Draw options for target motion */
+                               uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Destination:", *xco+150, *yco-62, 150, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
+                               
+                               /*      draw Loc/Rot/Size toggles       */
+                               uiBlockBeginAlign(block);
+                                       uiDefButS(block, ROW, B_CONSTRAINT_TEST, "Loc", *xco+150, *yco-82, 45, 18, &data->to, 12.0, 0, 0, 0, "Use as Location transform");
+                                       uiDefButS(block, ROW, B_CONSTRAINT_TEST, "Rot", *xco+195, *yco-82, 45, 18, &data->to, 12.0, 1, 0, 0, "Use as Rotation transform");
+                                       uiDefButS(block, ROW, B_CONSTRAINT_TEST, "Scale", *xco+245, *yco-82, 45, 18, &data->to, 12.0, 2, 0, 0, "Use as Scale transform");
+                               uiBlockEndAlign(block);
+                               
+                               /* Draw Pairs of Source-Axis: Min/Max Value*/
+                               if (data->to == 2) {
+                                       tmin= 0.0001;
+                                       tmax= 1000.0;
+                               }
+                               else if (data->to == 1) {
+                                       tmin= -360.0;
+                                       tmax= 360.0;
+                               }
+                               else {
+                                       tmin = -1000.0;
+                                       tmax= 1000.0;
+                               }
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Axis Mapping%t|X->X%x0|Y->X%x1|Z->X%x2", *xco+150, *yco-107, 40, 18, &data->map[0], 0, 24, 0, 0, "Specify which source axis the x-axis destination uses");
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min", *xco+175, *yco-107, 50, 18, &data->to_min[0], tmin, tmax, 0, 0, "Bottom of range of x-axis destination motion for source->target mapping"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max", *xco+240, *yco-107, 50, 18, &data->to_max[0], tmin, tmax, 0, 0, "Top of range of x-axis destination motion for source->target mapping"); 
+                               uiBlockEndAlign(block); 
+                               
                                uiBlockBeginAlign(block); 
-                               uiDefButBitS(block, TOG, LIMIT_ZMAX, B_CONSTRAINT_TEST, "maxZ", *xco+(width-(textButWidth-5)-togButWidth), *yco-72, 50, 18, &data->flag, 0, 24, 0, 0, "Use maximum z value"); 
-                               uiDefButF(block, NUM, B_CONSTRAINT_TEST, "", *xco+(width-textButWidth-5), *yco-72, (textButWidth-5), 18, &(data->zmax), 0.0001, 1000, 0.1,0.5,"Highest z value to allow"); 
+                                       uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Axis Mapping%t|X->Y%x0|Y->Y%x1|Z->Y%x2", *xco+150, *yco-127, 40, 18, &data->map[1], 0, 24, 0, 0, "Specify which source axis the y-axis destination uses");
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min", *xco+175, *yco-127, 50, 18, &data->to_min[1], tmin, tmax, 0, 0, "Bottom of range of y-axis destination motion for source->target mapping"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max", *xco+240, *yco-127, 50, 18, &data->to_max[1], tmin, tmax, 0, 0, "Top of range of y-axis destination motion for source->target mapping"); 
                                uiBlockEndAlign(block);
+                               
+                               uiBlockBeginAlign(block); 
+                                       uiDefButC(block, MENU, B_CONSTRAINT_TEST, "Axis Mapping%t|X->Z%x0|Y->Z%x1|Z->Z%x2", *xco+150, *yco-147, 40, 18, &data->map[2], 0, 24, 0, 0, "Specify which source axis the z-axis destination uses");
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "min", *xco+175, *yco-147, 50, 18, &data->to_min[2], tmin, tmax, 0, 0, "Bottom of range of z-axis destination motion for source->target mapping"); 
+                                       uiDefButF(block, NUM, B_CONSTRAINT_TEST, "max", *xco+240, *yco-147, 50, 18, &data->to_max[2], tmin, tmax, 0, 0, "Top of range of z-axis destination motion for source->target mapping"); 
+                               uiBlockEndAlign(block); 
+                               
+                               /* constraint space settings */
+                               draw_constraint_spaceselect(block, con, *xco, *yco-170, is_armature_owner(ob), is_armature_target(data->tar));
                        }
                        break;
                case CONSTRAINT_TYPE_NULL:
                        {
                                height = 17;
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
-                               
                        }
                        break;
                default:
                        height = 0;
                        break;
                }
-
+               
                (*yco)-=(24+height);
        }
 
-       if (con->type!=CONSTRAINT_TYPE_NULL) {
+       if (ELEM(con->type, CONSTRAINT_TYPE_NULL, CONSTRAINT_TYPE_RIGIDBODYJOINT)==0) {
                uiBlockBeginAlign(block);
                uiDefButF(block, NUMSLI, B_CONSTRAINT_INF, "Influence ", *xco, *yco, 197, 20, &(con->enforce), 0.0, 1.0, 0.0, 0.0, "Amount of influence this constraint will have on the final solution");
                but = uiDefBut(block, BUT, B_CONSTRAINT_TEST, "Show", *xco+200, *yco, 45, 20, 0, 0.0, 1.0, 0.0, 0.0, "Show constraint's ipo in the Ipo window, adds a channel if not there");
@@ -1145,10 +1645,10 @@ static void draw_constraint (uiBlock *block, ListBase *list, bConstraint *con, s
                uiButSetFunc (but, add_influence_key_to_constraint_func, ob, con);
                uiBlockEndAlign(block);
                (*yco)-=24;
-       } else {
+       } 
+       else {
                (*yco)-=3;
        }
-       
 }
 
 static uiBlock *add_constraintmenu(void *arg_unused)
@@ -1162,37 +1662,50 @@ static uiBlock *add_constraintmenu(void *arg_unused)
        
        block= uiNewBlock(&curarea->uiblocks, "add_constraintmenu", UI_EMBOSSP, UI_HELV, curarea->win);
 
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_LOCLIKE,"Copy Location",         0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_ROTLIKE,"Copy Rotation",         0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_SIZELIKE,"Copy Scale",           0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_CHILDOF, "Child Of",                     0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_TRANSFORM, "Transformation", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
        
        uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
        
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_LOCLIMIT,"Limit Location",               0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_ROTLIMIT,"Limit Rotation",               0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_SIZELIMIT,"Limit Scale",                 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_LOCLIKE, "Copy Location", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_ROTLIKE, "Copy Rotation", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_SIZELIKE, "Copy Scale", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
        
        uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
        
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_TRACKTO,"Track To",              0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_MINMAX,"Floor",          0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_LOCKTRACK,"Locked Track",                0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_FOLLOWPATH,"Follow Path",                0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_LOCLIMIT, "Limit Location", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_ROTLIMIT, "Limit Rotation", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_SIZELIMIT, "Limit Scale", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
        
        uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
        
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_STRETCHTO,"Stretch To",          0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-
-       if (ob->flag & OB_POSEMODE) {
-               uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
-               
-               uiDefBut(block, BUTM, B_CONSTRAINT_ADD_KINEMATIC,"IK Solver",           0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
-               uiDefBut(block, BUTM, B_CONSTRAINT_ADD_ACTION,"Action",         0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_TRACKTO, "Track To",     0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_MINMAX, "Floor", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_LOCKTRACK, "Locked Track", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_FOLLOWPATH, "Follow Path", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
                
-       }
        uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
-
-       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_NULL,"Null",             0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_CLAMPTO, "Clamp To", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_STRETCHTO, "Stretch To", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_RIGIDBODYJOINT, "Rigid Body Joint", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");//rcruiz
+
+       uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
+       
+       if (ob->flag & OB_POSEMODE) {
+               uiDefBut(block, BUTM, B_CONSTRAINT_ADD_KINEMATIC, "IK Solver", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       }
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_ACTION, "Action", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       
+       uiDefBut(block, SEPR, 0, "",                                    0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
+
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_PYTHON, "Script", 0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       
+       uiDefBut(block, SEPR, 0, "", 0, yco-=6, 120, 6, NULL, 0.0, 0.0, 0, 0, "");
+       
+       uiDefBut(block, BUTM, B_CONSTRAINT_ADD_NULL, "Null",    0, yco-=20, 160, 19, NULL, 0.0, 0.0, 1, 0, "");
+       
        
        uiTextBoundsBlock(block, 50);
        uiBlockSetDirection(block, UI_DOWN);
@@ -1203,155 +1716,195 @@ static uiBlock *add_constraintmenu(void *arg_unused)
 void do_constraintbuts(unsigned short event)
 {
        Object *ob= OBACT;
+       bConstraint *con;
        
        switch(event) {
        case B_CONSTRAINT_TEST:
                break;  // no handling
        case B_CONSTRAINT_INF:
                /* influence; do not execute actions for 1 dag_flush */
-               if(ob->pose)
+               if (ob->pose)
                        ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
 
        case B_CONSTRAINT_CHANGETARGET:
-               if(ob->pose) ob->pose->flag |= POSE_RECALC;     // checks & sorts pose channels
+               if (ob->pose) ob->pose->flag |= POSE_RECALC;    // checks & sorts pose channels
                DAG_scene_sort(G.scene);
                break;
-               
+       
        case B_CONSTRAINT_ADD_NULL:
                {
-                       bConstraint *con;
-                       
                        con = add_new_constraint(CONSTRAINT_TYPE_NULL);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
-       case B_CONSTRAINT_ADD_KINEMATIC:
+       case B_CONSTRAINT_ADD_PYTHON:
                {
-                       bConstraint *con;
+                       con = add_new_constraint(CONSTRAINT_TYPE_PYTHON);
+                       add_constraint_to_active(ob, con);
                        
+                       BIF_undo_push("Add constraint");
+               }
+               break;  
+       case B_CONSTRAINT_ADD_KINEMATIC:
+               {
                        con = add_new_constraint(CONSTRAINT_TYPE_KINEMATIC);
                        add_constraint_to_active(ob, con);
-
+                       
+                       BIF_undo_push("Add constraint");
+               }
+               break;
+       case B_CONSTRAINT_ADD_CHILDOF:
+               {
+                       con= add_new_constraint(CONSTRAINT_TYPE_CHILDOF);
+                       add_constraint_to_active(ob, con);
+                       
+                       /* if this constraint is being added to a posechannel, make sure
+                        * the constraint gets evaluated in pose-space
+                        */
+                       if (ob->flag & OB_POSEMODE) {
+                               con->ownspace = CONSTRAINT_SPACE_POSE;
+                               con->flag |= CONSTRAINT_SPACEONCE;
+                       }
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_TRACKTO:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_TRACKTO);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_MINMAX:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_MINMAX);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_ROTLIKE:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_ROTLIKE);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_LOCLIKE:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_LOCLIKE);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_SIZELIKE:
                {
-                       bConstraint *con;
                        con = add_new_constraint(CONSTRAINT_TYPE_SIZELIKE);
                        add_constraint_to_active(ob, con);
-  
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_ACTION:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_ACTION);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_LOCKTRACK:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_LOCKTRACK);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_FOLLOWPATH:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_FOLLOWPATH);
                        add_constraint_to_active(ob, con);
-
+                       
+                       BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_STRETCHTO:
                {
-                       bConstraint *con;
                        con = add_new_constraint(CONSTRAINT_TYPE_STRETCHTO);
                        add_constraint_to_active(ob, con);
-                               
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_LOCLIMIT:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_LOCLIMIT);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_ROTLIMIT:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_ROTLIMIT);
                        add_constraint_to_active(ob, con);
-
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
        case B_CONSTRAINT_ADD_SIZELIMIT:
                {
-                       bConstraint *con;
-
                        con = add_new_constraint(CONSTRAINT_TYPE_SIZELIMIT);
                        add_constraint_to_active(ob, con);
-
+                       
+                       BIF_undo_push("Add constraint");
+               }
+               break;
+       case B_CONSTRAINT_ADD_RIGIDBODYJOINT:
+               {
+                       bRigidBodyJointConstraint *data;
+                       Base *base_iter;
+                       
+                       con = add_new_constraint(CONSTRAINT_TYPE_RIGIDBODYJOINT);
+                       add_constraint_to_active(ob, con);
+                       
+                       /* set selected first object as target - moved from new_constraint_data */
+                       data = (bRigidBodyJointConstraint*)con->data;
+                       base_iter = G.scene->base.first;
+            while ( base_iter && !data->tar ) {
+                if( ( ( base_iter->flag & SELECT ) &&
+//                     ( base_iter->lay & G.vd->lay ) ) &&
+                    ( base_iter != G.scene->basact ) ))
+                               {
+                        data->tar=base_iter->object;
+                                               break;
+                               }
+                base_iter = base_iter->next;
+            }
+                       
+                       BIF_undo_push("Add constraint");
+               }
+               break;
+       case B_CONSTRAINT_ADD_CLAMPTO:
+               {
+                       con = add_new_constraint(CONSTRAINT_TYPE_CLAMPTO);
+                       add_constraint_to_active(ob, con);
+                       
+                       BIF_undo_push("Add constraint");
+               }
+               break;
+       case B_CONSTRAINT_ADD_TRANSFORM:
+               {
+                       con = add_new_constraint(CONSTRAINT_TYPE_TRANSFORM);
+                       add_constraint_to_active(ob, con);
+                       
                        BIF_undo_push("Add constraint");
                }
                break;
@@ -1377,11 +1930,12 @@ void softbody_bake(Object *ob)
        SoftBody *sb;
        ScrArea *sa;
        float frameleno= G.scene->r.framelen;
-       int cfrao= CFRA, sfra=100000, efra=0;
-       unsigned short event=0;
-       short val;
+       int cfrao= CFRA, sfra=100000, efra=0, didbreak =0;
+       
        
        G.scene->r.framelen= 1.0;               // baking has to be in uncorrected time
+       sbSetInterruptCallBack(blender_test_break); // make softbody module ESC aware
+       G.afbreek=0; // init global break system
        
        if(ob) {
                sb= ob->soft;
@@ -1392,7 +1946,7 @@ void softbody_bake(Object *ob)
        }
        else {
                for(base=G.scene->base.first; base; base= base->next) {
-                       if(TESTBASE(base)) {
+                       if(TESTBASELIB(base)) {
                                if(base->object->soft) {
                                        sb= base->object->soft;
                                        sfra= MIN2(sfra, sb->sfra);
@@ -1420,21 +1974,19 @@ void softbody_bake(Object *ob)
                        }
                }
                screen_swapbuffers();
-               
-               while(qtest()) {
-                       
-                       event= extern_qread(&val);
-                       if(event==ESCKEY) break;
+               //blender_test_break() has a granularity of 10 ms, who cares .. baking the unit cube is kinda boring
+               if (blender_test_break()){ 
+                       didbreak = 1;
+                       break;
                }
-               if(event==ESCKEY) break;
+
        }
-       
-       if(event==ESCKEY) {
+       if((didbreak)&&(G.qual!=LR_SHIFTKEY)) {
                if(ob) 
                        sbObjectToSoftbody(ob); // free bake
                else {
                        for(base=G.scene->base.first; base; base= base->next) {
-                               if(TESTBASE(base)) {
+                               if(TESTBASELIB(base)) {
                                        if(base->object->soft) {
                                                sbObjectToSoftbody(base->object);       // free bake
                                        }
@@ -1445,12 +1997,14 @@ void softbody_bake(Object *ob)
        
        /* restore */
        waitcursor(0);
+       sbSetInterruptCallBack(NULL); // softbody module won't ESC
+       G.afbreek=0; // reset global break system
        
        if(ob) 
                ob->softflag &= ~OB_SB_BAKEDO;
        else {
                for(base=G.scene->base.first; base; base= base->next)
-                       if(TESTBASE(base))
+                       if(TESTBASELIB(base))
                                if(base->object->soft)
                                        base->object->softflag &= ~OB_SB_BAKEDO;
        }
@@ -1522,10 +2076,11 @@ void do_object_panels(unsigned short event)
        Effect *eff;
        
        ob= OBACT;
-
+       if(ob==NULL)
+               return;
+       
        switch(event) {
        case B_TRACKBUTS:
-               ob= OBACT;
                DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
                allqueue(REDRAWVIEW3D, 0);
                break;
@@ -1533,9 +2088,31 @@ void do_object_panels(unsigned short event)
                DAG_object_flush_update(G.scene, OBACT, OB_RECALC_DATA);
                allqueue(REDRAWVIEW3D, 0);
                break;
+       case B_DUPLI_FRAME:
+               ob->transflag &= ~(OB_DUPLIVERTS|OB_DUPLIFACES|OB_DUPLIGROUP);
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+       case B_DUPLI_VERTS:
+               ob->transflag &= ~(OB_DUPLIFRAMES|OB_DUPLIFACES|OB_DUPLIGROUP);
+               DAG_scene_sort(G.scene);
+               DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+       case B_DUPLI_FACES:
+               ob->transflag &= ~(OB_DUPLIVERTS|OB_DUPLIFRAMES|OB_DUPLIGROUP);
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+       case B_DUPLI_GROUP:
+               ob->transflag &= ~(OB_DUPLIVERTS|OB_DUPLIFRAMES|OB_DUPLIFACES);
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+               
        case B_PRINTSPEED:
-               ob= OBACT;
-               if(ob) {
+               {
                        float vec[3];
                        CFRA++;
                        do_ob_ipo(ob);
@@ -1545,13 +2122,12 @@ void do_object_panels(unsigned short event)
                        do_ob_ipo(ob);
                        where_is_object(ob);
                        VecSubf(vec, vec, ob->obmat[3]);
-                       prspeed= Normalise(vec);
+                       prspeed= Normalize(vec);
                        scrarea_queue_winredraw(curarea);
                }
                break;
        case B_PRINTLEN:
-               ob= OBACT;
-               if(ob && ob->type==OB_CURVE) {
+               if(ob->type==OB_CURVE) {
                        Curve *cu=ob->data;
                        
                        if(cu->path) prlen= cu->path->totdist; else prlen= -1.0;
@@ -1563,24 +2139,27 @@ void do_object_panels(unsigned short event)
                allqueue(REDRAWBUTSOBJECT, 0);
                allqueue(REDRAWBUTSEDIT, 0);
                allqueue(REDRAWIPO, 0);
-               DAG_object_flush_update(G.scene, OBACT, OB_RECALC_DATA);
+               DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
                break;
        case B_CURVECHECK:
-               DAG_object_flush_update(G.scene, OBACT, OB_RECALC_DATA);
+               DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
                allqueue(REDRAWVIEW3D, 0);
                break;
        
        case B_SOFTBODY_CHANGE:
                ob= OBACT;
                if(ob) {
-                       ob->softflag |= OB_SB_REDO;
+                       ParticleSystem *psys = PE_get_current(ob);
+                       if(psys)
+                               psys->softflag |= OB_SB_REDO;
+                       else
+                               ob->softflag |= OB_SB_REDO;
                        allqueue(REDRAWBUTSOBJECT, 0);
                        allqueue(REDRAWVIEW3D, 0);
                }
                break;
        case B_SOFTBODY_DEL_VG:
-               ob= OBACT;
-               if(ob && ob->soft) {
+               if(ob->soft) {
                        ob->soft->vertgroup= 0;
                        ob->softflag |= OB_SB_REDO;
                        allqueue(REDRAWBUTSOBJECT, 0);
@@ -1588,22 +2167,18 @@ void do_object_panels(unsigned short event)
                }
                break;
        case B_SOFTBODY_BAKE:
-               ob= OBACT;
-               if(ob && ob->soft) softbody_bake(ob);
+               if(ob->soft) softbody_bake(ob);
                break;
        case B_SOFTBODY_BAKE_FREE:
-               ob= OBACT;
-               if(ob && ob->soft) sbObjectToSoftbody(ob);
+               if(ob->soft) sbObjectToSoftbody(ob);
                allqueue(REDRAWBUTSOBJECT, 0);
                allqueue(REDRAWVIEW3D, 0);
                break;
        case B_FLUIDSIM_BAKE:
-               ob= OBACT;
                /* write config files (currently no simulation) */
                fluidsimBake(ob);
                break;
        case B_FLUIDSIM_MAKEPART:
-               ob= OBACT;
                {
                        PartEff *paf= NULL;
                        /* prepare fluidsim particle display */
@@ -1611,21 +2186,24 @@ void do_object_panels(unsigned short event)
                        if(ob==NULL || ob->type!=OB_MESH) break;
                        ob->fluidsimSettings->type = 0;
                        // reset type, and init particle system once normally
-                       eff= ob->effect.first;
-                       //if((eff) && (eff->flag & SELECT)) { BLI_remlink(&ob->effect, eff); free_effect(eff); }
-                       if(!eff){ copy_act_effect(ob); DAG_scene_sort(G.scene); }
+                       paf= give_parteff(ob); 
+                       if( (BLI_countlist(&ob->effect)<MAX_EFFECT) && 
+                           (!paf)) { 
+                               // create new entry
+                               copy_act_effect(ob); DAG_scene_sort(G.scene); }
                        paf = give_parteff(ob);
-                       paf->totpart = 1000; paf->sta = paf->end = 1.0; // generate some particles...
-                       build_particle_system(ob);
-                       
-                       ob->fluidsimSettings->type = OB_FLUIDSIM_PARTICLE;
+                       if(paf) {
+                               paf->totpart = 1000; paf->sta = paf->end = 1.0; // generate some particles...
+                               build_particle_system(ob);
+                               ob->fluidsimSettings->type = OB_FLUIDSIM_PARTICLE;
+                       }
                }
                allqueue(REDRAWVIEW3D, 0);
                allqueue(REDRAWBUTSOBJECT, 0);
                break;
-       case B_FLUIDSIM_SELDIR: {
+       case B_FLUIDSIM_SELDIR: 
+               {
                        ScrArea *sa = closest_bigger_area();
-                       ob= OBACT;
                        /* choose dir for surface files */
                        areawinset(sa->win);
                        activate_fileselect(FILE_SPECIAL, "Select Directory", ob->fluidsimSettings->surfdataPath, fluidsimFilesel);
@@ -1638,26 +2216,31 @@ void do_object_panels(unsigned short event)
                DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
                break;
        case B_GROUP_RELINK:
-               group_relink_nla_objects(OBACT);
+               group_relink_nla_objects(ob);
+               allqueue(REDRAWVIEW3D, 0);
+               break;
+       case B_BAKEABLE_CHANGE:
+               allqueue(REDRAWBUTSOBJECT, 0);
+               allqueue(REDRAWVIEW3D, 0);
+               break;
+       case B_OBJECT_IPOFLAG:
+               if(ob->ipo) ob->ipo->showkey= (ob->ipoflag & OB_DRAWKEY)?1:0;
                allqueue(REDRAWVIEW3D, 0);
                break;
                
        default:
                if(event>=B_SELEFFECT && event<B_SELEFFECT+MAX_EFFECT) {
-                       ob= OBACT;
-                       if(ob) {
-                               int a=B_SELEFFECT;
+                       int a=B_SELEFFECT;
+                       
+                       eff= ob->effect.first;
+                       while(eff) {
+                               if(event==a) eff->flag |= SELECT;
+                               else eff->flag &= ~SELECT;
                                
-                               eff= ob->effect.first;
-                               while(eff) {
-                                       if(event==a) eff->flag |= SELECT;
-                                       else eff->flag &= ~SELECT;
-                                       
-                                       a++;
-                                       eff= eff->next;
-                               }
-                               allqueue(REDRAWBUTSOBJECT, 0);
+                               a++;
+                               eff= eff->next;
                        }
+                       allqueue(REDRAWBUTSOBJECT, 0);
                }
        }
 
@@ -1670,7 +2253,7 @@ static void do_add_groupmenu(void *arg, int event)
        if(ob) {
                
                if(event== -1) {
-                       Group *group= add_group();
+                       Group *group= add_group( "Group" );
                        add_to_group(group, ob);
                }
                else
@@ -1737,12 +2320,13 @@ static void object_panel_object(Object *ob)
        uiBlock *block;
        uiBut *but;
        Group *group;
-       int a=0, xco;
-       
+       int a, xco, yco=0;
+       short dx= 33, dy= 30;
+
        block= uiNewBlock(&curarea->uiblocks, "object_panel_object", UI_EMBOSS, UI_HELV, curarea->win);
        if(uiNewPanel(curarea, block, "Object and Links", "Object", 0, 0, 318, 204)==0) return;
        
-       if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
+       uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
        
        /* object name */
        uiBlockSetCol(block, TH_BUT_SETTING2);
@@ -1751,29 +2335,54 @@ static void object_panel_object(Object *ob)
        
        /* parent */
        uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_OBJECTPANELPARENT, "Par:", xco+5, 180, 305-xco, 20, &ob->parent, "Parent Object"); 
+       
+       /* TODO, check for ob->id.lib */
+       but = uiDefButS(block, NUM, B_NOP, "PassIndex:",                xco+5, 150, 305-xco, 20, &ob->index, 0.0, 1000.0, 0, 0, "Index # for the IndexOB render pass.");
 
        uiDefBlockBut(block, add_groupmenu, NULL, "Add to Group", 10,150,150,20, "Add Object to a new Group");
 
        /* all groups */
-       uiBlockBeginAlign(block);
        for(group= G.main->group.first; group; group= group->id.next) {
                if(object_in_group(ob, group)) {
                        xco= 160;
                        
-                       but = uiDefBut(block, TEX, B_IDNAME, "GR:",     10, 120-a, 150, 20, group->id.name+2, 0.0, 19.0, 0, 0, "Displays Group name. Click to change.");
+                       uiBlockBeginAlign(block);
+                       but = uiDefBut(block, TEX, B_IDNAME, "GR:",     10, 120-yco, 150, 20, group->id.name+2, 0.0, 21.0, 0, 0, "Displays Group name. Click to change.");
                        uiButSetFunc(but, test_idbutton_cb, group->id.name, NULL);
                        
                        if(group->id.lib) {
-                               but= uiDefIconBut(block, BUT, B_NOP, ICON_PARLIB, 160, 120-a, 20, 20, NULL, 0.0, 0.0, 0.0, 0.0, "Make Group local");
+                               but= uiDefIconBut(block, BUT, B_NOP, ICON_PARLIB, 160, 120-yco, 20, 20, NULL, 0.0, 0.0, 0.0, 0.0, "Make Group local");
                                uiButSetFunc(but, group_local, group, NULL);
                                xco= 180;
                        }
-                       but = uiDefIconBut(block, BUT, B_NOP, VICON_X, xco, 120-a, 20, 20, NULL, 0.0, 0.0, 0.0, 0.0, "Remove Group membership");
+                       but = uiDefIconBut(block, BUT, B_NOP, VICON_X, xco, 120-yco, 20, 20, NULL, 0.0, 0.0, 0.0, 0.0, "Remove Group membership");
                        uiButSetFunc(but, group_ob_rem, group, ob);
                        
-                       a+= 20;
+                       yco+= 20;
+                       xco= 10;
+                       
+                       /* layers */
+                       uiBlockBeginAlign(block);
+                       for(a=0; a<5; a++)
+                               uiDefButBitI(block, TOG, 1<<a, REDRAWVIEW3D, "",        (short)(xco+a*(dx/2)), 120-yco, (short)(dx/2), (short)(dy/2), (int *)&(group->layer), 0, 0, 0, 0, "");
+                       for(a=0; a<5; a++)
+                               uiDefButBitI(block, TOG, 1<<(a+10), REDRAWVIEW3D, "",   (short)(xco+a*(dx/2)), 105-yco, (short)(dx/2), (short)(dy/2), (int *)&(group->layer), 0, 0, 0, 0, "");
+                       
+                       xco+= 7;
+                       uiBlockBeginAlign(block);
+                       for(a=5; a<10; a++)
+                               uiDefButBitI(block, TOG, 1<<a, REDRAWVIEW3D, "",        (short)(xco+a*(dx/2)), 120-yco, (short)(dx/2), (short)(dy/2), (int *)&(group->layer), 0, 0, 0, 0, "");
+                       for(a=5; a<10; a++)
+                               uiDefButBitI(block, TOG, 1<<(a+10), REDRAWVIEW3D, "",   (short)(xco+a*(dx/2)), 105-yco, (short)(dx/2), (short)(dy/2), (int *)&(group->layer), 0, 0, 0, 0, "");
+                       
+                       uiBlockEndAlign(block);
+                       
+                       yco+= 40;
                }
        }
+       
+       if(120-yco < -10)
+               uiNewPanelHeight(block, 204 - (120-yco));
 }
 
 static void object_panel_anim(Object *ob)
@@ -1784,7 +2393,7 @@ static void object_panel_anim(Object *ob)
        block= uiNewBlock(&curarea->uiblocks, "object_panel_anim", UI_EMBOSS, UI_HELV, curarea->win);
        if(uiNewPanel(curarea, block, "Anim settings", "Object", 320, 0, 318, 204)==0) return;
        
-       if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
+       uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
        
        uiBlockBeginAlign(block);
        uiDefButS(block, ROW,B_TRACKBUTS,"TrackX",      24,180,59,19, &ob->trackflag, 12.0, 0.0, 0, 0, "Specify the axis that points to another object");
@@ -1799,20 +2408,27 @@ static void object_panel_anim(Object *ob)
        uiDefButS(block, ROW,REDRAWVIEW3D,"Z",          298,180,19,19, &ob->upflag, 13.0, 2.0, 0, 0, "Specify the axis that points up");
        
        uiBlockBeginAlign(block);
-       uiDefButBitS(block, TOG, OB_DRAWKEY, REDRAWVIEW3D, "Draw Key",          24,155,71,19, &ob->ipoflag, 0, 0, 0, 0, "Draw object as key position");
+       uiDefButBitS(block, TOG, OB_DRAWKEY, B_OBJECT_IPOFLAG, "Draw Key",              24,155,71,19, &ob->ipoflag, 0, 0, 0, 0, "Draw object as key position");
        uiDefButBitS(block, TOG, OB_DRAWKEYSEL, REDRAWVIEW3D, "Draw Key Sel",   97,155,81,19, &ob->ipoflag, 0, 0, 0, 0, "Limit the drawing of object keys");
        uiDefButBitS(block, TOG, OB_POWERTRACK, REDRAWVIEW3D, "Powertrack",             180,155,78,19, &ob->transflag, 0, 0, 0, 0, "Switch objects rotation off");
        uiDefButBitS(block, TOG, PARSLOW, 0, "SlowPar",                                 260,155,56,19, &ob->partype, 0, 0, 0, 0, "Create a delay in the parent relationship");
        uiBlockBeginAlign(block);
        
-       uiDefButBitS(block, TOG, OB_DUPLIFRAMES, REDRAWVIEW3D, "DupliFrames",   24,130,89,20, &ob->transflag, 0, 0, 0, 0, "Make copy of object for every frame");
-       uiDefButBitS(block, TOG, OB_DUPLIVERTS, REDRAWVIEW3D, "DupliVerts",             114,130,82,20, &ob->transflag, 0, 0, 0, 0, "Duplicate child objects on all vertices");
-       uiDefButBitS(block, TOG, OB_DUPLIROT, REDRAWVIEW3D, "Rot",                              200,130,31,20, &ob->transflag, 0, 0, 0, 0, "Rotate dupli according to vertnormal");
-       uiDefButBitS(block, TOG, OB_DUPLINOSPEED, REDRAWVIEW3D, "No Speed",             234,130,82,20, &ob->transflag, 0, 0, 0, 0, "Set dupliframes to still, regardless of frame");
+       uiDefButBitS(block, TOG, OB_DUPLIFRAMES, B_DUPLI_FRAME, "DupliFrames",  24,130,95,20, &ob->transflag, 0, 0, 0, 0, "Make copy of object for every frame");
+       uiDefButBitS(block, TOG, OB_DUPLIVERTS, B_DUPLI_VERTS, "DupliVerts",            119,130,95,20, &ob->transflag, 0, 0, 0, 0, "Duplicate child objects on all vertices");
+       uiDefButBitS(block, TOG, OB_DUPLIFACES, B_DUPLI_FACES, "DupliFaces",            214,130,102,20, &ob->transflag, 0, 0, 0, 0, "Duplicate child objects on all faces");
+       uiDefButBitS(block, TOG, OB_DUPLIGROUP, B_DUPLI_GROUP, "DupliGroup",            24,110,150,20, &ob->transflag, 0, 0, 0, 0, "Enable group instancing");
+       if(ob->transflag & OB_DUPLIFRAMES) {
+               uiDefButBitS(block, TOG, OB_DUPLINOSPEED, REDRAWVIEW3D, "No Speed",             174,110,142,20, &ob->transflag, 0, 0, 0, 0, "Set dupliframes to still, regardless of frame");
+       } else if(ob->transflag & OB_DUPLIVERTS) {
+               uiDefButBitS(block, TOG, OB_DUPLIROT, REDRAWVIEW3D, "Rot",                              174,110,142,20, &ob->transflag, 0, 0, 0, 0, "Rotate dupli according to vertex normal");
+       } else if(ob->transflag & OB_DUPLIFACES) {
+               uiDefButBitS(block, TOG, OB_DUPLIFACES_SCALE, REDRAWVIEW3D, "Scale",                    174,110,80,20, &ob->transflag, 0, 0, 0, 0, "Scale dupli based on face size");
+               uiDefButF(block, NUM, REDRAWVIEW3D, "",         254,110,62,20, &ob->dupfacesca, 0.001, 10000.0, 0, 0, "Scale the DupliFace objects");
+       } else {
+               uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_GROUP_RELINK, "GR:", 174,110,142,20, &ob->dup_group, "Instance an existing group");
+       }
        
-       uiDefButBitS(block, TOG, OB_DUPLIGROUP, REDRAWVIEW3D, "DupliGroup",             24,110,150,20, &ob->transflag, 0, 0, 0, 0, "Enable group instancing");
-       uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_GROUP_RELINK, "GR:", 174,110,142,20, &ob->dup_group, "Instance an existing group");
-
        uiBlockBeginAlign(block);
        /* DupSta and DupEnd are both shorts, so the maxframe is greater then their range
        just limit the buttons to the max short */
@@ -1844,7 +2460,7 @@ static void object_panel_draw(Object *ob)
        block= uiNewBlock(&curarea->uiblocks, "object_panel_draw", UI_EMBOSS, UI_HELV, curarea->win);
        if(uiNewPanel(curarea, block, "Draw", "Object", 640, 0, 318, 204)==0) return;
        
-       if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
+       uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
        
        /* LAYERS */
        xco= 120;
@@ -1855,16 +2471,16 @@ static void object_panel_draw(Object *ob)
        
        uiBlockBeginAlign(block);
        for(a=0; a<5; a++)
-               uiDefButBitI(block, TOG, 1<<a, B_OBLAY+a, "",   (short)(xco+a*(dx/2)), 180, (short)(dx/2), (short)(dy/2), &(BASACT->lay), 0, 0, 0, 0, "");
+               uiDefButBitI(block, TOG, 1<<a, B_OBLAY+a, "",   (short)(xco+a*(dx/2)), 180, (short)(dx/2), (short)(dy/2), (int *)&(BASACT->lay), 0, 0, 0, 0, "");
        for(a=0; a<5; a++)
-               uiDefButBitI(block, TOG, 1<<(a+10), B_OBLAY+a+10, "",   (short)(xco+a*(dx/2)), 165, (short)(dx/2), (short)(dy/2), &(BASACT->lay), 0, 0, 0, 0, "");
+               uiDefButBitI(block, TOG, 1<<(a+10), B_OBLAY+a+10, "",   (short)(xco+a*(dx/2)), 165, (short)(dx/2), (short)(dy/2), (int *)&(BASACT->lay), 0, 0, 0, 0, "");
        
        xco+= 7;
        uiBlockBeginAlign(block);
        for(a=5; a<10; a++)
-               uiDefButBitI(block, TOG, 1<<a, B_OBLAY+a, "",   (short)(xco+a*(dx/2)), 180, (short)(dx/2), (short)(dy/2), &(BASACT->lay), 0, 0, 0, 0, "");
+               uiDefButBitI(block, TOG, 1<<a, B_OBLAY+a, "",   (short)(xco+a*(dx/2)), 180, (short)(dx/2), (short)(dy/2), (int *)&(BASACT->lay), 0, 0, 0, 0, "");
        for(a=5; a<10; a++)
-               uiDefButBitI(block, TOG, 1<<(a+10), B_OBLAY+a+10, "",   (short)(xco+a*(dx/2)), 165, (short)(dx/2), (short)(dy/2), &(BASACT->lay), 0, 0, 0, 0, "");
+               uiDefButBitI(block, TOG, 1<<(a+10), B_OBLAY+a+10, "",   (short)(xco+a*(dx/2)), 165, (short)(dx/2), (short)(dy/2), (int *)&(BASACT->lay), 0, 0, 0, 0, "");
        
        uiBlockEndAlign(block);
        
@@ -1885,14 +2501,13 @@ static void object_panel_draw(Object *ob)
        
        uiDefButS(block, MENU, REDRAWVIEW3D, "Boundary Display%t|Box%x0|Sphere%x1|Cylinder%x2|Cone%x3|Polyheder%x4",
                          120, 80, 90, 20, &ob->boundtype, 0, 0, 0, 0, "Selects the boundary display type");
-       uiDefButBitC(block, TOG, OB_AXIS, REDRAWVIEW3D, "Axis",                 210, 80, 90, 20, &ob->dtx, 0, 0, 0, 0, "Displays the active object's centre and axis");
+       uiDefButBitC(block, TOG, OB_AXIS, REDRAWVIEW3D, "Axis",                 210, 80, 90, 20, &ob->dtx, 0, 0, 0, 0, "Displays the active object's center and axis");
        
        uiDefButBitC(block, TOG, OB_TEXSPACE, REDRAWVIEW3D, "TexSpace", 120, 60, 90, 20, &ob->dtx, 0, 0, 0, 0, "Displays the active object's texture space");
        uiDefButBitC(block, TOG, OB_DRAWWIRE, REDRAWVIEW3D, "Wire",             210, 60, 90, 20, &ob->dtx, 0, 0, 0, 0, "Adds the active object's wireframe over solid drawing");
        
        uiDefButBitC(block, TOG, OB_DRAWTRANSP, REDRAWVIEW3D, "Transp", 120, 40, 90, 20, &ob->dtx, 0, 0, 0, 0, "Enables transparent materials for the active object (Mesh only)");
        uiDefButBitC(block, TOG, OB_DRAWXRAY, REDRAWVIEW3D, "X-ray",    210, 40, 90, 20, &ob->dtx, 0, 0, 0, 0, "Makes the active object draw in front of others");
-       
 }
 
 void object_panel_constraint(char *context)
@@ -1907,23 +2522,23 @@ void object_panel_constraint(char *context)
        block= uiNewBlock(&curarea->uiblocks, "object_panel_constraint", UI_EMBOSS, UI_HELV, curarea->win);
        if(uiNewPanel(curarea, block, "Constraints", context, 960, 0, 318, 204)==0) return;
        
-       if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
+       uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
        
        /* this is a variable height panel, newpanel doesnt force new size on existing panels */
        /* so first we make it default height */
        uiNewPanelHeight(block, 204);
        
+       /* do not allow this panel to draw in editmode - why?*/
        if(G.obedit==OBACT) return;     // ??
        
        conlist = get_active_constraints(OBACT);
        
        if (conlist) {
-               
                uiDefBlockBut(block, add_constraintmenu, NULL, "Add Constraint", 0, 190, 130, 20, "Add a new constraint");
                
                /* print active object or bone */
                str[0]= 0;
-               if (ob->flag & OB_POSEMODE){
+               if (ob->flag & OB_POSEMODE) {
                        bPoseChannel *pchan= get_active_posechannel(ob);
                        if(pchan) sprintf(str, "To Bone: %s", pchan->name);
                }
@@ -1958,9 +2573,17 @@ void do_effects_panels(unsigned short event)
        Base *base;
        Effect *eff, *effn;
        PartEff *paf;
+       ModifierData *md;
+       ParticleSystemModifierData *psmd;
+       ParticleSystem *psys;
+       ParticleSettings *part;
+       ID *id,*idtest;
+       int nr;
        
        ob= OBACT;
 
+       psys=psys_get_current(ob);
+
        switch(event) {
 
     case B_AUTOTIMEOFS:
@@ -1973,6 +2596,14 @@ void do_effects_panels(unsigned short event)
                break;
        case B_NEWEFFECT:
                if(ob) {
+                       if(ob->fluidsimFlag & OB_FLUIDSIM_ENABLE) { 
+                               // NT particles and fluid meshes currently dont work together -> switch off beforehand
+                               if(ob->fluidsimSettings->type == OB_FLUIDSIM_DOMAIN) {
+                                       pupmenu("Fluidsim Particle Error%t|Please disable the fluidsim domain before activating particles.%x0");
+                                       break;
+                                       //ob->fluidsimFlag = 0; ob->fluidsimSettings->type = 0; allqueue(REDRAWVIEW3D, 0); 
+                               }
+                       }
                        if (BLI_countlist(&ob->effect)==MAX_EFFECT)
                                error("Unable to add: effect limit reached");
                        else
@@ -2071,78 +2702,371 @@ void do_effects_panels(unsigned short event)
                        allqueue(REDRAWVIEW3D, 0);
                }
                break;
-       case B_FIELD_DEP:
-               /* do this before scene sort, that one checks for CU_PATH */
-               if(ob->type==OB_CURVE && ob->pd->forcefield==PFIELD_GUIDE) {
-                       Curve *cu= ob->data;
+       case B_PARTBROWSE:
+               if(G.buts->menunr== -2) {
+                       activate_databrowse((ID *)G.buts->lockpoin, ID_PA, 0, B_PARTBROWSE, &G.buts->menunr, do_effects_panels);
+                       return;
+               }
+               
+               if(G.buts->menunr < 0) return;
+               
+               if(G.buts->pin) {
                        
-                       cu->flag |= (CU_PATH|CU_3D);
-                       do_curvebuts(B_CU3D);   /* all curves too */
                }
-               DAG_scene_sort(G.scene);
-
-               if(ob->type==OB_CURVE && ob->pd->forcefield==PFIELD_GUIDE)
-                       DAG_object_flush_update(G.scene, ob, OB_RECALC);
-               else
-                       DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
+               else {
+                       psys= psys_get_current(ob);
+                       if(psys)
+                               part=psys->part;
+                       else
+                               part=NULL;
 
-               allqueue(REDRAWVIEW3D, 0);
-               allqueue(REDRAWBUTSOBJECT, 0);
-               break;
-       case B_FIELD_CHANGE:
-               DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
-               allqueue(REDRAWVIEW3D, 0);
-               break;
-       case B_RECALCAL:
-               if (G.vd==NULL)
-                       break;
-               
-               base= FIRSTBASE;
-               while(base) {
-                       if(base->lay & G.vd->lay) {
-                               ob= base->object;
-                               eff= ob->effect.first;
-                               while(eff) {
-                                       if(eff->flag & SELECT) {
-                                               if(eff->type==EFF_PARTICLE) build_particle_system(ob);
-                                       }
-                                       eff= eff->next;
+                       nr= 1;
+                       
+                       id= (ID *)part;
+                       
+                       idtest= G.main->particle.first;
+                       while(idtest) {
+                               if(nr==G.buts->menunr) {
+                                       break;
                                }
+                               nr++;
+                               idtest= idtest->next;
                        }
-                       base= base->next;
-               }
-               allqueue(REDRAWVIEW3D, 0);
-               break;
-       default:
-               if(event>=B_SELEFFECT && event<B_SELEFFECT+MAX_EFFECT) {
-                       ob= OBACT;
-                       if(ob) {
-                               int a=B_SELEFFECT;
-                               
-                               eff= ob->effect.first;
-                               while(eff) {
-                                       if(event==a) eff->flag |= SELECT;
-                                       else eff->flag &= ~SELECT;
-                                       
-                                       a++;
-                                       eff= eff->next;
+                       if(idtest==0) { /* new particle system */
+                               if(id){
+                                       idtest= (ID *)psys_copy_settings((ParticleSettings *)id);
+                               }
+                               else {
+                                       idtest= (ID *)psys_new_settings("PSys", G.main);
+                               }
+                               idtest->us--;
+                       }
+                       if(idtest!=id) {
+                               short nr=0;
+                               if(id==0){ /* no psys previously -> no modifier -> need to create that also */
+                                       psys = MEM_callocN(sizeof(ParticleSystem), "particle_system");
+                                       BLI_addtail(&ob->particlesystem,psys);
+
+                                       md= modifier_new(eModifierType_ParticleSystem);
+                                       sprintf(md->name, "ParticleSystem %i", BLI_countlist(&ob->particlesystem));
+                                       psmd= (ParticleSystemModifierData*) md;
+                                       psmd->psys=psys;
+                                       BLI_addtail(&ob->modifiers, md);
+                               }
+
+                               idtest->us++;
+                               psys->part=(ParticleSettings*)idtest;
+                               psys->totpart=0;
+                               psys->flag=PSYS_ENABLED|PSYS_CURRENT;
+                               psys->cfra=bsystem_time(ob,G.scene->r.cfra+1,0.0);
+
+                               /* check need for dupliobjects */
+                               nr=0;
+                               for(psys=ob->particlesystem.first; psys; psys=psys->next){
+                                       if(ELEM(psys->part->draw_as,PART_DRAW_OB,PART_DRAW_GR))
+                                               nr++;
                                }
+                               if(nr)
+                                       ob->transflag |= OB_DUPLIPARTS;
+                               else
+                                       ob->transflag &= ~OB_DUPLIPARTS;
+
+                               BIF_undo_push("Browse Particle System");
+
+                               DAG_scene_sort(G.scene);
+                               DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+
+                               allqueue(REDRAWVIEW3D, 0);
                                allqueue(REDRAWBUTSOBJECT, 0);
+                               allqueue(REDRAWOOPS, 0);
                        }
+                       
                }
-       }
+               break;
+       case B_PARTDELETE:
+               if(ob && ob->particlesystem.first){
+                       psys= psys_get_current(ob);
+                       if(psys) {
+                               /* clear modifier */
+                               psmd= psys_get_modifier(ob,psys);
+                               BLI_remlink(&ob->modifiers, psmd);
+                               modifier_free((ModifierData *)psmd);
 
-}
+                               /* clear particle system */
+                               BLI_remlink(&ob->particlesystem,psys);
+                               psys_free(ob,psys);
 
-/* Panel for particle interaction settings */
-static void object_panel_fields(Object *ob)
-{
-       uiBlock *block;
+                               BIF_undo_push("Delete particle system");
+
+                               DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+
+                               allqueue(REDRAWVIEW3D, 0);
+                               allqueue(REDRAWBUTSOBJECT, 0);
+                               allqueue(REDRAWOOPS, 0);
+                       }
+               }
+               break;
+       case B_PARTALONE: /* TODO: not too sure of how this works so someone check please, jahka */
+               if(ob && (psys=psys_get_current(ob))){
+                       if(psys->part) {
+                               if(psys->part->id.us>1){
+                                       if(okee("Make local")){
+                                               part=psys_copy_settings(psys->part);
+                                               part->id.us=1;
+                                               psys->part->id.us--;
+                                               psys->part=part;
+
+                                               allqueue(REDRAWVIEW3D, 0);
+                                               allqueue(REDRAWBUTSOBJECT, 0);
+                                               allqueue(REDRAWOOPS, 0);
+
+                                               BIF_undo_push("Make single user or local");
+                                       }
+                               }
+                       }
+               }
+               break;
+       case B_PART_ALLOC:
+       case B_PART_ALLOC_CHILD:
+               if(psys){
+                       psys_flush_settings(psys->part,PSYS_ALLOC,event==B_PART_ALLOC);
+                       allqueue(REDRAWVIEW3D, 0);
+                       allqueue(REDRAWBUTSOBJECT, 0);
+                       allqueue(REDRAWOOPS, 0);
+               }
+               break;
+       case B_PART_DISTR:
+       case B_PART_DISTR_CHILD:
+               if(psys){
+                       psys_flush_settings(psys->part,PSYS_DISTR,event==B_PART_DISTR);
+                       allqueue(REDRAWVIEW3D, 0);
+                       allqueue(REDRAWBUTSOBJECT, 0);
+                       allqueue(REDRAWOOPS, 0);
+               }
+               break;
+       case B_PART_INIT:
+       case B_PART_INIT_CHILD:
+               if(psys){
+                       psys_flush_settings(psys->part,PSYS_INIT,event==B_PART_INIT);
+                       allqueue(REDRAWVIEW3D, 0);
+                       allqueue(REDRAWBUTSOBJECT, 0);
+                       allqueue(REDRAWOOPS, 0);
+               }
+               break;
+       case B_PART_RECALC:
+       case B_PART_RECALC_CHILD:
+               if(psys){
+                       psys_flush_settings(psys->part,0,event==B_PART_RECALC);
+                       allqueue(REDRAWOOPS, 0);
+               }
+               /* no break! */
+       case B_PART_REDRAW:
+               nr=0;
+               for(psys=ob->particlesystem.first; psys; psys=psys->next){
+                       if(ELEM(psys->part->draw_as,PART_DRAW_OB,PART_DRAW_GR))
+                               nr++;
+               }
+               if(nr)
+                       ob->transflag |= OB_DUPLIPARTS;
+               else
+                       ob->transflag &= ~OB_DUPLIPARTS;
+
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+       case B_PARTTYPE:
+               if((psys=psys_get_current(ob))){
+                       DAG_scene_sort(G.scene);
+
+                       psys_flush_settings(psys->part,PSYS_TYPE,1);
+               }
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+       case B_PARTACT:
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               allqueue(REDRAWIPO, 0);
+               break;
+       case B_PARTTARGET:
+               if((psys=psys_get_current(ob))){
+                       if(psys->keyed_ob==ob || psys->target_ob==ob){
+                               if(psys->keyed_ob==ob)
+                                       psys->keyed_ob=NULL;
+                               else
+                                       psys->target_ob=NULL;
+                       }
+                       else{
+                               DAG_scene_sort(G.scene);
+                               DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+                       }
+                       allqueue(REDRAWVIEW3D, 0);
+                       allqueue(REDRAWBUTSOBJECT, 0);
+               }
+               break;
+       case B_PART_REKEY:
+               PE_rekey();
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSEDIT, 0);
+               break;
+       case B_PART_EDITABLE:
+               if((psys = psys_get_current(ob))) {
+                       if(psys->flag & PSYS_EDITED){
+                               if(okee("Lose changes done in particle mode?")){
+                                       if(psys->edit)
+                                               PE_free_particle_edit(psys);
+
+                                       psys->flag &= ~PSYS_EDITED;
+                                       psys->recalc |= PSYS_RECALC_HAIR;
+
+                                       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+                               }
+                       }
+                       else {
+                               psys->flag |= PSYS_EDITED;
+                               if(G.f & G_PARTICLEEDIT)
+                                       PE_create_particle_edit(ob, psys);
+                       }
+               }
+       case B_FIELD_DEP:
+               /* do this before scene sort, that one checks for CU_PATH */
+               if(ob->type==OB_CURVE && ob->pd->forcefield==PFIELD_GUIDE) {
+                       Curve *cu= ob->data;
+                       
+                       cu->flag |= (CU_PATH|CU_3D);
+                       do_curvebuts(B_CU3D);   /* all curves too */
+               }
+               DAG_scene_sort(G.scene);
+
+               if(ob->type==OB_CURVE && ob->pd->forcefield==PFIELD_GUIDE)
+                       DAG_object_flush_update(G.scene, ob, OB_RECALC);
+               else
+                       DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
+
+               allqueue(REDRAWVIEW3D, 0);
+               allqueue(REDRAWBUTSOBJECT, 0);
+               break;
+       case B_FIELD_CHANGE:
+               if(ob->pd->forcefield != PFIELD_TEXTURE && ob->pd->tex){
+                       ob->pd->tex->id.us--;
+                       ob->pd->tex=0;
+               }
+               DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
+               allqueue(REDRAWVIEW3D, 0);
+               break;
+       case B_RECALCAL:
+               if (G.vd==NULL)
+                       break;
+               
+               base= FIRSTBASE;
+               while(base) {
+                       if(base->lay & G.vd->lay) {
+                               ob= base->object;
+                               eff= ob->effect.first;
+                               while(eff) {
+                                       if(eff->flag & SELECT) {
+                                               if(eff->type==EFF_PARTICLE) build_particle_system(ob);
+                                       }
+                                       eff= eff->next;
+                               }
+                       }
+                       base= base->next;
+               }
+               allqueue(REDRAWVIEW3D, 0);
+               break;
+       default:
+               if(event>=B_SELEFFECT && event<B_SELEFFECT+MAX_EFFECT) {
+                       ob= OBACT;
+                       if(ob) {
+                               int a=B_SELEFFECT;
+                               
+                               eff= ob->effect.first;
+                               while(eff) {
+                                       if(event==a) eff->flag |= SELECT;
+                                       else eff->flag &= ~SELECT;
+                                       
+                                       a++;
+                                       eff= eff->next;
+                               }
+                               allqueue(REDRAWBUTSOBJECT, 0);
+                       }
+               }
+       }
+
+}
+
+/* copy from buttons_editing.c */
+static void field_testTexture(char *name, ID **idpp)
+{
+       ID *id;
+
+       for(id = G.main->tex.first; id; id = id->next) {
+               if(strcmp(name, id->name + 2) == 0) {
+                       *idpp = id;
+                       /* texture gets user, objects not: delete object = clear modifier */
+                       id_us_plus(id);
+                       return;
+               }
+       }
+       *idpp = 0;
+}
+/* Panels for particle interaction settings */
+static void object_panel_deflection(Object *ob)
+{
+       uiBlock *block;
+
+       block= uiNewBlock(&curarea->uiblocks, "object_panel_deflection", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Deflection", "Physics", 0, 0, 318, 204)==0) return;
+
+       uiSetButLock(object_data_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
+       
+       /* should become button, option? */
+       if(ob->pd==NULL) {
+               ob->pd= MEM_callocN(sizeof(PartDeflect), "PartDeflect");
+               /* and if needed, init here */
+               ob->pd->pdef_sbdamp = 0.1f;
+               ob->pd->pdef_sbift  = 0.2f;
+               ob->pd->pdef_sboft  = 0.02f;
+       }
+       
+       /* only meshes collide now */
+       if(ob->pd && ob->type==OB_MESH) {
+               PartDeflect *pd= ob->pd;
+               
+               uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",160,160,150,20, &pd->deflect, 0, 0, 0, 0, "Deflects particles based on collision");
+               if(pd->deflect) {
+                       uiDefBut(block, LABEL, 0, "Particles",                  160,140,75,20, NULL, 0.0, 0, 0, 0, "");
+                       uiDefButBitS(block, TOG, PDEFLE_KILL_PART, B_DIFF, "Kill",235,140,75,20, &pd->flag, 0, 0, 0, 0, "Kill collided particles");
+
+                       uiBlockBeginAlign(block);
+                       uiDefButF(block, NUM, B_DIFF, "Damping: ",              160,120,75,20, &pd->pdef_damp, 0.0, 1.0, 10, 0, "Amount of damping during particle collision");
+                       uiDefButF(block, NUM, B_DIFF, "Rnd Damping: ",  235,120,75,20, &pd->pdef_rdamp, 0.0, 1.0, 10, 0, "Random variation of damping");
+                       uiDefButF(block, NUM, B_DIFF, "Friction: ",             160,100,75,20, &pd->pdef_frict, 0.0, 1.0, 10, 0, "Amount of friction during particle collision");
+                       uiDefButF(block, NUM, B_DIFF, "Rnd Friction: ", 235,100,75,20, &pd->pdef_rfrict, 0.0, 1.0, 10, 0, "Random variation of friction");
+                       uiDefButF(block, NUM, B_DIFF, "Permeability: ", 160,80,150,20, &pd->pdef_perm, 0.0, 1.0, 10, 0, "Chance that the particle will pass through the mesh");
+                       uiBlockEndAlign(block);
+                       
+                       uiDefBut(block, LABEL, 0, "Soft Body",                  160,60,150,20, NULL, 0.0, 0, 0, 0, "");
+
+                       uiBlockBeginAlign(block);
+                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Damping:",       160,40,150,20, &pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
+                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Inner:", 160,20,150,20, &pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
+                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Outer:", 160, 0,150,20, &pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
+               }
+       }
+}
+static void object_panel_fields(Object *ob)
+{
+       uiBlock *block;
+       uiBut *but;
+       int particles=0;
+       static short actpsys=-1;
 
        block= uiNewBlock(&curarea->uiblocks, "object_panel_fields", UI_EMBOSS, UI_HELV, curarea->win);
-       if(uiNewPanel(curarea, block, "Fields and Deflection", "Physics", 0, 0, 318, 204)==0) return;
+       uiNewPanelTabbed("Deflection", "Physics");
+       if(uiNewPanel(curarea, block, "Fields", "Physics", 0, 0, 318, 204)==0) return;
 
-       if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
+       uiSetButLock(object_data_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
        
        /* should become button, option? */
        if(ob->pd==NULL) {
@@ -2158,390 +3082,1247 @@ static void object_panel_fields(Object *ob)
                char *menustr= MEM_mallocN(256, "temp string");
                char *tipstr="Choose field type";
                
-               uiDefBut(block, LABEL, 0, "Fields",             10,180,140,20, NULL, 0.0, 0, 0, 0, "");
-               
+               if(ob->particlesystem.first) {
+                       ParticleSystem *psys;
+                       char *menustr2= psys_menu_string(ob,1);
+                       
+                       psys= psys_get_current(ob);
+                       if(psys && actpsys >= 0) {
+                               actpsys= psys_get_current_num(ob)+1;
+
+                               if(psys->part->pd==NULL)
+                                       psys->part->pd= MEM_callocN(sizeof(PartDeflect), "PartDeflect");
+
+                               pd= psys->part->pd;
+                               particles=1;
+                       }
+                       else
+                               actpsys= -1; /* -1 = object */
+
+                       but=uiDefButS(block, MENU, B_BAKE_REDRAWEDIT, menustr2, 10,180,70,20, &actpsys, 14.0, 0.0, 0, 0, "Browse systems");
+                       uiButSetFunc(but, PE_change_act, ob, &actpsys);
+
+                       MEM_freeN(menustr2);
+               }
+
                /* setup menu button */
-               sprintf(menustr, "Field Type%%t|None %%x0|Spherical %%x%d|Wind %%x%d|Vortex %%x%d|Curve Guide %%x%d", 
-                               PFIELD_FORCE, PFIELD_WIND, PFIELD_VORTEX, PFIELD_GUIDE);
-               
-               if(pd->forcefield==PFIELD_FORCE) tipstr= "Object center attracts or repels particles";
-               else if(pd->forcefield==PFIELD_WIND) tipstr= "Constant force applied in direction of Object Z axis";
-               else if(pd->forcefield==PFIELD_VORTEX) tipstr= "Particles swirl around Z-axis of the Object";
-               else if(pd->forcefield==PFIELD_GUIDE) tipstr= "Use a Curve Path to guide particles";
+               if(particles){
+                       sprintf(menustr, "Field Type%%t|None%%x0|Spherical%%x%d|Wind%%x%d|Vortex%%x%d|Magnetic%%x%d|Harmonic%%x%d", 
+                                       PFIELD_FORCE, PFIELD_WIND, PFIELD_VORTEX, PFIELD_MAGNET, PFIELD_HARMONIC);
+
+                       if(pd->forcefield==PFIELD_FORCE) tipstr= "Particle attracts or repels particles";
+                       else if(pd->forcefield==PFIELD_WIND) tipstr= "Constant force applied in direction of particle Z axis";
+                       else if(pd->forcefield==PFIELD_VORTEX) tipstr= "Particles swirl around Z-axis of the particle";
+               }
+               else{
+                       if(ob->type==OB_CURVE)
+                               sprintf(menustr, "Field Type%%t|None%%x0|Spherical%%x%d|Wind%%x%d|Vortex%%x%d|Curve Guide%%x%d|Magnetic%%x%d|Harmonic%%x%d|Texture%%x%d", 
+                                               PFIELD_FORCE, PFIELD_WIND, PFIELD_VORTEX, PFIELD_GUIDE, PFIELD_MAGNET, PFIELD_HARMONIC, PFIELD_TEXTURE);
+                       else
+                               sprintf(menustr, "Field Type%%t|None%%x0|Spherical%%x%d|Wind%%x%d|Vortex%%x%d|Magnetic%%x%d|Harmonic%%x%d|Texture%%x%d", 
+                                               PFIELD_FORCE, PFIELD_WIND, PFIELD_VORTEX, PFIELD_MAGNET, PFIELD_HARMONIC, PFIELD_TEXTURE);
+
+                       if(pd->forcefield==PFIELD_FORCE) tipstr= "Object center attracts or repels particles";
+                       else if(pd->forcefield==PFIELD_WIND) tipstr= "Constant force applied in direction of Object Z axis";
+                       else if(pd->forcefield==PFIELD_VORTEX) tipstr= "Particles swirl around Z-axis of the Object";
+                       else if(pd->forcefield==PFIELD_GUIDE) tipstr= "Use a Curve Path to guide particles";
+               }
                
-               uiDefButS(block, MENU, B_FIELD_DEP, menustr,                    10,160,140,20, &pd->forcefield, 0.0, 0.0, 0, 0, tipstr);
+               if(ob->particlesystem.first)
+                       uiDefButS(block, MENU, B_FIELD_DEP, menustr,                    80,180,70,20, &pd->forcefield, 0.0, 0.0, 0, 0, tipstr);
+               else
+                       uiDefButS(block, MENU, B_FIELD_DEP, menustr,                    10,180,140,20, &pd->forcefield, 0.0, 0.0, 0, 0, tipstr);
+
                MEM_freeN(menustr);
                
                if(pd->forcefield) {
                        uiBlockBeginAlign(block);
                        if(pd->forcefield == PFIELD_GUIDE) {
-                               uiDefButF(block, NUM, B_FIELD_CHANGE, "MinDist: ",      10,120,140,20, &pd->f_strength, 0.0, 1000.0, 10, 0, "The distance from which particles are affected fully.");
-                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Fall-off: ",     10,100,140,20, &pd->f_power, 0.0, 10.0, 10, 0, "Falloff factor, between mindist and maxdist");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "MinDist: ",      10,140,140,20, &pd->f_strength, 0.0, 1000.0, 10, 0, "The distance from which particles are affected fully.");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Fall-off: ",     10,120,140,20, &pd->f_power, 0.0, 10.0, 10, 0, "Falloff factor, between mindist and maxdist");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Free: ", 10,100,140,20, &pd->free_end, 0.0, 0.99, 10, 0, "Guide-free time from particle life's end");
+                               uiBlockEndAlign(block);
+                               uiBlockBeginAlign(block);
+                               uiDefButBitS(block, TOG, PFIELD_USEMAX, B_FIELD_CHANGE, "Use",  10,80,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a maximum distance for the field to work");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "MaxDist: ",      50,80,100,20, &pd->maxdist, 0, 1000.0, 10, 0, "Maximum distance for the field to work");
                        }
-                       else {  
-                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Strength: ",     10,110,140,20, &pd->f_strength, -1000, 1000, 10, 0, "Strength of force field");
-                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Fall-off: ",     10,90,140,20, &pd->f_power, 0, 10, 10, 0, "Falloff power (real gravitational fallof = 2)");
+                       else {
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Strength: ",     10,140,140,20, &pd->f_strength, -1000, 1000, 10, 0, "Strength of force field");
+                               
+                               if(pd->forcefield == PFIELD_TEXTURE){
+                                       uiDefIDPoinBut(block, field_testTexture, ID_TE, B_FIELD_CHANGE, "Texture: ", 10, 120, 140, 20, &pd->tex, "Texture to use as force");
+                                       uiDefButBitS(block, TOG, PFIELD_TEX_OBJECT, B_FIELD_CHANGE, "Use Object Co",    10,100,140,20, &pd->flag, 0.0, 0, 0, 0, "Use object/global coordinates for texture");
+                                       uiDefButBitS(block, TOG, PFIELD_TEX_2D, B_FIELD_CHANGE, "2D",   10,80,140,20, &pd->flag, 0.0, 0, 0, 0, "Apply force only in 2d");
+                               }
+                               else if(pd->forcefield == PFIELD_HARMONIC) 
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Damp: ", 10,120,140,20, &pd->f_damp, 0, 10, 10, 0, "Damping of the harmonic force");     
                        }
+                       uiBlockEndAlign(block);
                        
                        uiBlockBeginAlign(block);
-                       uiDefButBitS(block, TOG, PFIELD_USEMAX, B_FIELD_CHANGE, "Use MaxDist",  10,60,140,20, &pd->flag, 0.0, 0, 0, 0, "Use a maximum distance for the field to work");
-                       uiDefButF(block, NUM, B_FIELD_CHANGE, "MaxDist: ",      10,40,140,20, &pd->maxdist, 0, 1000.0, 10, 0, "Maximum distance for the field to work");
+                       if(pd->forcefield == PFIELD_GUIDE){
+                               uiDefButBitS(block, TOG, PFIELD_GUIDE_PATH_ADD, B_FIELD_CHANGE, "Additive",     10,40,140,20, &pd->flag, 0.0, 0, 0, 0, "Based on distance/falloff it adds a portion of the entire path");
+                       }
+                       else if(pd->forcefield==PFIELD_TEXTURE){
+                               uiDefButS(block, MENU, B_FIELD_CHANGE, "Texture mode%t|RGB%x0|Gradient%x1|Curl%x2",     10,40,140,20, &pd->tex_mode, 0.0, 0.0, 0, 0, "How the texture effect is calculated (RGB & Curl need a RGB texture)");
+       
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Nabla:", 10,20,140,20, &pd->tex_nabla, 0.0001f, 1.0, 1, 0, "Specify the dimension of the area for gradient and curl calculation");
+                       }
+                       else if(particles==0 && ELEM(pd->forcefield,PFIELD_VORTEX,PFIELD_WIND)==0){
+                               //uiDefButF(block, NUM, B_FIELD_CHANGE, "Distance: ",   10,20,140,20, &pd->f_dist, 0, 1000.0, 10, 0, "Falloff power (real gravitational fallof = 2)");
+                               uiDefButBitS(block, TOG, PFIELD_PLANAR, B_FIELD_CHANGE, "Planar",       10,0,140,20, &pd->flag, 0.0, 0, 0, 0, "Create planar field");
+                       }
                        uiBlockEndAlign(block);
                        
-                       if(pd->forcefield == PFIELD_GUIDE)
-                               uiDefButBitS(block, TOG, PFIELD_GUIDE_PATH_ADD, B_FIELD_CHANGE, "Additive",     10,10,140,20, &pd->flag, 0.0, 0, 0, 0, "Based on distance/falloff it adds a portion of the entire path");
-                       
+                       if(pd->forcefield==PFIELD_GUIDE){
+                               uiBlockBeginAlign(block);
+                               uiDefButF(block, NUMSLI, B_FIELD_CHANGE, "Clump:",              160,180,140,20, &pd->clump_fac, -1.0, 1.0, 1, 3, "Amount of clumpimg");
+                               uiDefButF(block, NUMSLI, B_FIELD_CHANGE, "Shape:",              160,160,140,20, &pd->clump_pow, -0.999, 0.999, 1, 3, "Shape of clumpimg");
+                               uiBlockEndAlign(block);
+
+                               uiBlockBeginAlign(block);
+                               if(pd->kink){
+                                       uiDefButS(block, MENU, B_FIELD_CHANGE, "Kink:%t|Roll%x6|Rotation%x5|Braid%x4|Wave%x3|Radial%x2|Curl%x1|Nothing%x0", 160,120,70,20, &pd->kink, 14.0, 0.0, 0, 0, "Type of periodic offset on the curve");
+                                       uiDefButS(block, MENU, B_FIELD_CHANGE, "Axis %t|Z %x2|Y %x1|X %x0", 230,120,70,20, &pd->kink_axis, 14.0, 0.0, 0, 0, "Which axis to use for offset");
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Freq:",                  160,100,140,20, &pd->kink_freq, 0.0, 10.0, 1, 3, "The frequency of the offset (1/total length)");
+                                       uiDefButF(block, NUMSLI, B_FIELD_CHANGE, "Shape:",              160,80,140,20, &pd->kink_shape, -0.999, 0.999, 1, 3, "Adjust the offset to the beginning/end");
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Amplitude:",     160,60,140,20, &pd->kink_amp, 0.0, 10.0, 1, 3, "The amplitude of the offset");
+                               }
+                               else{
+                                       uiDefButS(block, MENU, B_FIELD_CHANGE, "Kink:%t|Roll%x6|Rotation%x5|Braid%x4|Wave%x3|Radial%x2|Curl%x1|Nothing%x0", 160,120,140,20, &pd->kink, 14.0, 0.0, 0, 0, "Type of periodic offset on the curve");
+                               }
+                               uiBlockEndAlign(block);
+                       }
+                       else{
+                               uiDefButS(block, MENU, B_FIELD_DEP, "Fall-off%t|Cone%x2|Tube%x1|Sphere%x0",     160,180,140,20, &pd->falloff, 0.0, 0.0, 0, 0, tipstr);
+                               if(pd->falloff==PFIELD_FALL_TUBE)
+                                       uiDefBut(block, LABEL, 0, "Lognitudinal",               160,160,70,20, NULL, 0.0, 0, 0, 0, "");
+                               uiBlockBeginAlign(block);
+                               uiDefButBitS(block, TOG, PFIELD_POSZ, B_FIELD_CHANGE, "Pos",    160,140,40,20, &pd->flag, 0.0, 0, 0, 0, "Effect only in direction of positive Z axis");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Fall-off: ",     200,140,100,20, &pd->f_power, 0, 10, 10, 0, "Falloff power (real gravitational falloff = 2)");
+                               uiDefButBitS(block, TOG, PFIELD_USEMAX, B_FIELD_CHANGE, "Use",  160,120,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a maximum distance for the field to work");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "MaxDist: ",      200,120,100,20, &pd->maxdist, 0, 1000.0, 10, 0, "Maximum distance for the field to work");
+                               uiDefButBitS(block, TOG, PFIELD_USEMIN, B_FIELD_CHANGE, "Use",  160,100,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a minimum distance for the field's fall-off");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "MinDist: ",      200,100,100,20, &pd->mindist, 0, 1000.0, 10, 0, "Minimum distance for the field's fall-off");
+                               uiBlockEndAlign(block);
+
+                               if(pd->falloff==PFIELD_FALL_TUBE){
+                                       uiDefBut(block, LABEL, 0, "Radial",             160,80,70,20, NULL, 0.0, 0, 0, 0, "");
+                                       uiBlockBeginAlign(block);
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Fall-off: ",     160,60,140,20, &pd->f_power_r, 0, 10, 10, 0, "Radial falloff power (real gravitational falloff = 2)");
+                                       uiDefButBitS(block, TOG, PFIELD_USEMAXR, B_FIELD_CHANGE, "Use", 160,40,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a maximum radial distance for the field to work");
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "MaxDist: ",      200,40,100,20, &pd->maxrad, 0, 1000.0, 10, 0, "Maximum radial distance for the field to work");
+                                       uiDefButBitS(block, TOG, PFIELD_USEMINR, B_FIELD_CHANGE, "Use", 160,20,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a minimum radial distance for the field's fall-off");
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "MinDist: ",      200,20,100,20, &pd->minrad, 0, 1000.0, 10, 0, "Minimum radial distance for the field's fall-off");
+                                       uiBlockEndAlign(block);
+                               }
+                               else if(pd->falloff==PFIELD_FALL_CONE){
+                                       uiDefBut(block, LABEL, 0, "Angular",            160,80,70,20, NULL, 0.0, 0, 0, 0, "");
+                                       uiBlockBeginAlign(block);
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "Fall-off: ",     160,60,140,20, &pd->f_power_r, 0, 10, 10, 0, "Radial falloff power (real gravitational falloff = 2)");
+                                       uiDefButBitS(block, TOG, PFIELD_USEMAXR, B_FIELD_CHANGE, "Use", 160,40,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a maximum angle for the field to work");
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "MaxAngle: ",     200,40,100,20, &pd->maxrad, 0, 89.0, 10, 0, "Maximum angle for the field to work (in radians)");
+                                       uiDefButBitS(block, TOG, PFIELD_USEMINR, B_FIELD_CHANGE, "Use", 160,20,40,20, &pd->flag, 0.0, 0, 0, 0, "Use a minimum angle for the field's fall-off");
+                                       uiDefButF(block, NUM, B_FIELD_CHANGE, "MinAngle: ",     200,20,100,20, &pd->minrad, 0, 89.0, 10, 0, "Minimum angle for the field's fall-off (in radians)");
+                                       uiBlockEndAlign(block);
+                               }
+                       }
+               }       
+       }
+}
+
+/* Panel for softbodies */
+static void object_softbodies__enable(void *ob_v, void *arg2)
+{
+       Object *ob = ob_v;
+       ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
+
+       if (modifiers_isSoftbodyEnabled(ob)) {
+               if (md) {
+                       md->mode &= ~(eModifierMode_Render|eModifierMode_Realtime);
                }
+       } else {
+               if (!md) {
+                       md = modifier_new(eModifierType_Softbody);
+                       BLI_addhead(&ob->modifiers, md);
+               }
+
+               md->mode |= eModifierMode_Render|eModifierMode_Realtime;
+
+               if (!ob->soft) {
+                       ob->soft= sbNew();
+                       ob->softflag |= OB_SB_GOAL|OB_SB_EDGES;
+                       softbody_clear_cache(ob, CFRA);
+               }
+       }
+       /* needed so that initial state is cached correctly */
+       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+
+       allqueue(REDRAWBUTSEDIT, 0);
+       allqueue(REDRAWVIEW3D, 0);
+}
+
+static int _can_softbodies_at_all(Object *ob)
+{
+       // list of Yes
+    if ((ob->type==OB_MESH)
+               || (ob->type==OB_CURVE)
+               || (ob->type==OB_LATTICE)
+               || (ob->type==OB_SURF)
+               ) return 1;
+       // else deny
+       return 0;
+}
+static void object_softbodies__enable_psys(void *ob_v, void *psys_v)
+{
+       ParticleSystem *psys = psys_v;
+       Object *ob = ob_v;
+
+       if(psys->softflag & OB_SB_ENABLE){
+               psys->softflag &= ~OB_SB_ENABLE;
+       }
+       else{
+               if (!psys->soft) {
+                       psys->soft= sbNew();
+                       psys->softflag |= OB_SB_GOAL|OB_SB_EDGES;
+                       psys->soft->particles=psys;
+                       clear_particles_from_cache(ob, psys, CFRA);
+               }
+               psys->softflag |= OB_SB_ENABLE;
+       }
+
+       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+
+       allqueue(REDRAWBUTSEDIT, 0);
+}
+
+static void object_softbodies_II(Object *ob)
+{
+       SoftBody *sb=ob->soft;
+       uiBlock *block;
+       static int val;
+       short *softflag=&ob->softflag, psys_cur=0;
+       int ob_has_hair=psys_ob_has_hair(ob);
+    if(!_can_softbodies_at_all(ob)) return;
+       /*bah that is ugly! creating missing data members in UI code*/
+       if(ob->pd == NULL){
+               ob->pd= MEM_callocN(sizeof(PartDeflect), "PartDeflect");
+               ob->pd->pdef_sbdamp = 0.1f;
+               ob->pd->pdef_sbift  = 0.2f;
+               ob->pd->pdef_sboft  = 0.02f;
+       }
+       block= uiNewBlock(&curarea->uiblocks, "object_softbodies_II", UI_EMBOSS, UI_HELV, curarea->win);
+       uiNewPanelTabbed("Soft Body", "Physics");
+       if(uiNewPanel(curarea, block, "Soft Body Collision", "Physics", 651, 0, 318, 204)==0) return;
+
+       uiSetButLock(object_data_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
+
+       if(ob_has_hair) {
+               if(PE_get_current_num(ob) >= 0) {
+                       ParticleSystem *psys = PE_get_current(ob);
+                       if(psys) {
+                               sb = psys->soft;
+                               softflag = &psys->softflag;
+                               psys_cur = 1;
+                       }
+               }
+       }
+
+       if(psys_cur) {
+               if(*softflag & OB_SB_ENABLE)
+                       val = 1;
+               else
+                       val = 0;
+       }
+       else
+               val = modifiers_isSoftbodyEnabled(ob);
+
+       if(!val) {
+               uiDefBut(block, LABEL, 0, "",10,10,1,2, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
+               uiBlockBeginAlign(block);
+               if(psys_cur){
+                       uiDefBut(block, LABEL, 0, "Hair is not a softbody",10,190,300,20, NULL, 0.0, 0, 0, 0, ""); 
+                       uiDefBut(block, LABEL, 0, "However the emitter can deflect a softbody",10,170,300,20, NULL, 0.0, 0, 0, 0, ""); 
+               }
+               else {
+                       uiDefBut(block, LABEL, 0, "Object is not a softbody",10,190,300,20, NULL, 0.0, 0, 0, 0, ""); 
+                       uiDefBut(block, LABEL, 0, "However it can deflect a softbody",10,170,300,20, NULL, 0.0, 0, 0, 0, ""); 
+               }
+               /* OTHER OBJECTS COLLISION STUFF */
+               if (ob->type==OB_MESH){
+                       uiBlockBeginAlign(block);
+                       uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",10,50,150,20, &ob->pd->deflect, 0, 0, 0, 0, "Makes this object visible to softbody objects");
+                       if(ob->pd->deflect) {
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Damping:",       160,50,150,20, &ob->pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
+                               uiDefButBitS(block, TOG,OB_SB_COLLFINAL , B_DIFF, "Ev.M.Stack",10,30,150,20, &ob->softflag, 0, 0, 0, 0, "Pick collision object from modifier stack");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Inner:", 160,30,150,20, &ob->pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
+                               uiDefButF(block, NUM, B_FIELD_CHANGE, "Outer:", 160,10,150,20, &ob->pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
+                       }
+               }
+               uiBlockEndAlign(block);
+       }
+       else{
+               /* SELF COLLISION STUFF */
+               if ((ob->type==OB_MESH)||(ob->type==OB_CURVE) ) {
+                       uiBlockBeginAlign(block);
+                       if (*softflag & OB_SB_EDGES){
+                               uiDefButBitS(block, TOG, OB_SB_SELF, B_SOFTBODY_CHANGE, "Self Collision",               10,170,150,20, softflag, 0, 0, 0, 0, "enable naive vertex ball self collision");
+                               if(*softflag & OB_SB_SELF){
+                                       uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Ball Size:", 160,170,150,20, &sb->colball, -10.0,  10.0, 10, 0, "Absolute ball size or factor if not manual adjusted");
+                                       uiDefButS(block, ROW, B_DIFF, "Man",10,150,60,20, &sb->sbc_mode, 4.0,SBC_MODE_MANUAL, 0, 0, "Manual adjust");
+                                       uiDefButS(block, ROW, B_DIFF, "Av",70,150,60,20, &sb->sbc_mode, 4.0,SBC_MODE_AVG, 0, 0, "Average Spring lenght * Ball Size");
+                                       uiDefButS(block, ROW, B_DIFF, "Min",130,150,60,20, &sb->sbc_mode, 4.0,SBC_MODE_MIN, 0, 0, "Minimal Spring lenght * Ball Size");
+                                       uiDefButS(block, ROW, B_DIFF, "Max",190,150,60,20, &sb->sbc_mode, 4.0,SBC_MODE_MAX, 0, 0, "Maximal Spring lenght * Ball Size");
+                                       uiDefButS(block, ROW, B_DIFF, "AvMiMa",250,150,60,20, &sb->sbc_mode, 4.0,SBC_MODE_AVGMINMAX, 0, 0, "(Min+Max)/2 * Ball Size");
+                                       uiDefButF(block, NUM, B_DIFF, "B Stiff:", 10,130,150,20, &sb->ballstiff, 0.001,  100.0, 10, 0, "Ball inflating presure");
+                                       uiDefButF(block, NUM, B_DIFF, "B Damp:", 160,130,150,20, &sb->balldamp,  0.001,  1.0, 10, 0, "Blending to inelastic collision");
+                               }
+                       }
+                       else{
+                               uiDefBut(block, LABEL, 0, "<Self Collision> not available because there",10,170,300,20, NULL, 0.0, 0, 0, 0, ""); 
+                               uiDefBut(block, LABEL, 0, "are no edges, enable <Use Edges>",10,150,300,20, NULL, 0.0, 0, 0, 0, ""); 
+                       }
+
+                       uiBlockEndAlign(block);
+                       /*SOLVER SETTINGS*/
+                       uiDefButF(block, NUM, B_DIFF, "Error Lim:",     10,100,130,20, &sb->rklimit , 0.001, 10.0, 10, 0, "The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed");
+                       uiDefButBitS(block, TOG, SBSO_OLDERR, B_DIFF,"O", 140,100,20,20, &sb->solverflags,  0,  0, 0, 0, "Old Error Calculation");
+                       uiDefButS(block, NUM, B_DIFF, "Fuzzy:", 160,100,130,20, &sb->fuzzyness,  1.00,  100.0, 10, 0, "Fuzzyness while on collision, high values make collsion handling faster but less stable");
+                       uiDefButBitS(block, TOG, SBSO_MONITOR, B_DIFF,"M", 290,100,20,20, &sb->solverflags,  0,  0, 0, 0, "Turn on SB diagnose console prints");
+                       uiDefButS(block, NUM, B_DIFF, "MinS:", 10,80,100,20, &sb->minloops,  0.00,  30000.0, 10, 0, "Minimal # solver steps/frame ");
+                       uiDefButS(block, NUM, B_DIFF, "MaxS:", 110,80,100,20, &sb->maxloops,  0.00,  30000.0, 10, 0, "Maximal # solver steps/frame ");
+                       uiDefButS(block, NUM, B_DIFF, "Choke:", 210,80,100,20, &sb->choke, 0.00,  100.0, 10, 0, "'Viscosity' inside collision target ");
+               }
+               /* OTHER OBJECTS COLLISION STUFF */
+               if (ob->type==OB_MESH){
+                       uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",10,50,150,20, &ob->pd->deflect, 0, 0, 0, 0, "Makes this object visible to other softbody objects");
+                       if(ob->pd->deflect) {
+                               uiDefButF(block, NUM, B_DIFF, "Damping:",       160,50,150,20, &ob->pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
+                           uiDefButBitS(block, TOG,OB_SB_COLLFINAL , B_DIFF, "Ev.M.Stack",10,30,150,20, softflag, 0, 0, 0, 0, "Pick collision object from modifier stack");
+                               uiDefButF(block, NUM, B_DIFF, "Inner:", 160,30,150,20, &ob->pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
+                               uiDefButF(block, NUM, B_DIFF, "Outer:", 160,10,150,20, &ob->pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
+                       }
+               }
+               uiDefBut(block, LABEL, 0, "",10,10,1,2, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
+       }
+       uiBlockEndAlign(block);
+}
+
+static void sb_clear_cache(void *ob_v, void *actsoft_v)
+{
+       Object *ob = ob_v;
+       short *actsoft = actsoft_v;
+
+       if(actsoft >= 0)
+               clear_particles_from_cache(ob, BLI_findlink(&ob->particlesystem, *actsoft), CFRA);
+       else
+               softbody_clear_cache(ob, CFRA);
+}
+static void object_softbodies(Object *ob)
+{
+       SoftBody *sb=ob->soft;
+       ParticleSystem *psys;
+       uiBlock *block;
+       uiBut *but;
+       static int val;
+       short *softflag=&ob->softflag, psys_cur=0;
+       int ob_has_hair = psys_ob_has_hair(ob);
+       static short actsoft= -1;
+
+    if(!_can_softbodies_at_all(ob)) return;
+       block= uiNewBlock(&curarea->uiblocks, "object_softbodies", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Soft Body", "Physics", 640, 0, 318, 204)==0) return;
+       uiSetButLock(object_data_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
+
+       if(ob_has_hair) {
+               char *menustr = psys_menu_string(ob,1);
+
+               psys= psys_get_current(ob);
+               if(psys && actsoft >= 0) {
+                       actsoft= psys_get_current_num(ob)+1;
+
+                       sb=psys->soft;
+                       softflag=&psys->softflag;
+                       psys_cur=1;
+               }
+               else
+                       actsoft= -1; /* -1 = object */
+
+               but=uiDefButS(block, MENU, B_BAKE_REDRAWEDIT, menustr, 10,200,100,20, &actsoft, 14.0, 0.0, 0, 0, "Browse systems");
+               uiButSetFunc(but, PE_change_act, ob, &actsoft);
                
-               uiDefBut(block, LABEL, 0, "Deflection", 160,180,140,20, NULL, 0.0, 0, 0, 0, "");
-                       
-               /* only meshes collide now */
-               if(ob->type==OB_MESH) {
-                       uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",160,160,150,20, &pd->deflect, 0, 0, 0, 0, "Deflects particles based on collision");
-                       if(pd->deflect) {
-                               uiDefBut(block, LABEL, 0, "Particles",                  160,140,150,20, NULL, 0.0, 0, 0, 0, "");
-                               
+               MEM_freeN(menustr);
+       }
+
+       if(psys_cur){
+               if(*softflag & OB_SB_ENABLE)
+                       val=1;
+               else
+                       val=0;
+
+               but = uiDefButI(block, TOG, REDRAWBUTSOBJECT, "Soft Body",      110,200,70,20, &val, 0, 0, 0, 0, "Sets hair to become soft body");
+               uiButSetFunc(but, object_softbodies__enable_psys, ob, psys);
+       }
+       else{
+               val = modifiers_isSoftbodyEnabled(ob);
+               if(ob_has_hair)
+                       but = uiDefButI(block, TOG, REDRAWBUTSOBJECT, "Soft Body",      110,200,70,20, &val, 0, 0, 0, 0, "Sets object to become soft body");
+               else
+                       but = uiDefButI(block, TOG, REDRAWBUTSOBJECT, "Soft Body",      10,200,130,20, &val, 0, 0, 0, 0, "Sets object to become soft body");
+
+               uiButSetFunc(but, object_softbodies__enable, ob, NULL);
+       }
+       
+       uiDefBut(block, LABEL, 0, "",10,10,300,0, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
+
+       if(val){
+               int defCount;
+               char *menustr;
+               static char str[128];
+
+               //uiDefButBitS(block, TOG, OB_SB_BAKESET, REDRAWBUTSOBJECT, "Bake settings",    180,200,130,20, &ob->softflag, 0, 0, 0, 0, "To convert simulation into baked (cached) result");
+
+               //if(sb->keys) uiSetButLock(1, "Soft Body is baked, free it first");
+               uiBlockBeginAlign(block);
+               uiDefButBitS(block, TOG, OB_SB_PROTECT_CACHE, REDRAWBUTSOBJECT, "Protect",      180,200,50,20, softflag, 0.0, 0.0, 10, 0, "Protect the cache");
+               but=uiDefBut(block, BUT, B_SOFTBODY_CHANGE, "Clear",                            230,200,50,20, NULL, 0.0, 0.0, 10, 0, "Clear the cache");
+               if((*softflag & PSYS_PROTECT_CACHE)==0)
+                       uiButSetFunc(but, sb_clear_cache, ob, &actsoft);
+
+               uiBlockEndAlign(block);
+
+               if(*softflag & OB_SB_PROTECT_CACHE) uiSetButLock(1, "Cache is protected");
+
+               //if(ob->softflag & OB_SB_BAKESET) {
+               //      uiBlockBeginAlign(block);
+               //      uiDefButI(block, NUM, B_DIFF, "Start:",                 10, 170,100,20, &sb->sfra, 1.0, 10000.0, 10, 0, "Start frame for baking");
+               //      uiDefButI(block, NUM, B_DIFF, "End:",                   110, 170,100,20, &sb->efra, 1.0, 10000.0, 10, 0, "End frame for baking");
+               //      uiDefButI(block, NUM, B_DIFF, "Interval:",              210, 170,100,20, &sb->interval, 1.0, 10.0, 10, 0, "Interval in frames between baked keys");
+               //      uiBlockEndAlign(block);
+
+               //      uiDefButS(block, TOG, B_DIFF, "Local",                  10, 145,100,20, &sb->local, 0.0, 0.0, 0, 0, "Use local coordinates for baking");
+
+
+               //      uiClearButLock();
+               //      uiBlockBeginAlign(block);
+
+               //      if(sb->keys) {
+               //              char str[128];
+               //              uiDefIconTextBut(block, BUT, B_SOFTBODY_BAKE_FREE, ICON_X, "FREE BAKE", 10, 120,300,20, NULL, 0.0, 0.0, 0, 0, "Free baked result");
+               //              sprintf(str, "Stored %d vertices %d keys %.3f MB", sb->totpoint, sb->totkey, ((float)16*sb->totpoint*sb->totkey)/(1024.0*1024.0));
+               //              uiDefBut(block, LABEL, 0, str, 10, 100,300,20, NULL, 0.0, 0.0, 00, 0, "");
+               //      }
+               //      else                            
+               //              uiDefBut(block, BUT, B_SOFTBODY_BAKE, "BAKE",   10, 120,300,20, NULL, 0.0, 0.0, 10, 0, "Start baking. Press ESC to exit without baking");
+               //}
+               //else {
+                       /* GENERAL STUFF */
+                       if (sb->totpoint){
+                       sprintf(str, "Vertex Mass; Object mass %f [k]",sb->nodemass*sb->totpoint/1000.0f);
+                       }
+                       else{
+                       sprintf(str, "Vertex Mass");
+                       }
+                       uiBlockBeginAlign(block);
+                       uiDefButF(block, NUM, B_DIFF, "Friction:", 10, 170,150,20, &sb->mediafrict, 0.0, 50.0, 10, 0, "General media friction for point movements");
+                       uiDefButF(block, NUM, B_DIFF, "Mass:",     160, 170,150,20, &sb->nodemass , 0.001, 50000.0, 10, 0, str);
+                       uiDefButF(block, NUM, B_DIFF, "Grav:",     10,150,150,20, &sb->grav , 0.0, 10.0, 10, 0, "Apply gravitation to point movement");
+                       uiDefButF(block, NUM, B_DIFF, "Speed:",    160,150,150,20, &sb->physics_speed , 0.01, 100.0, 10, 0, "Tweak timing for physics to control frequency and speed");
+                       uiBlockEndAlign(block);
+
+                       /* GOAL STUFF */
+                       uiBlockBeginAlign(block);
+                       uiDefButBitS(block, TOG, OB_SB_GOAL, B_SOFTBODY_CHANGE, "Use Goal",     10,120,130,20, softflag, 0, 0, 0, 0, "Define forces for vertices to stick to animated position");
+                       if (*softflag & OB_SB_GOAL){
+                               if(ob->type==OB_MESH) {
+                                       menustr= get_vertexgroup_menustr(ob);
+                                       defCount=BLI_countlist(&ob->defbase);
+                                       if(defCount==0) sb->vertgroup= 0;
+                                       uiDefButS(block, MENU, B_SOFTBODY_CHANGE, menustr,      140,120,20,20, &sb->vertgroup, 0, defCount, 0, 0, "Browses available vertex groups");
+                                       MEM_freeN (menustr);
+
+                                       if(sb->vertgroup) {
+                                               bDeformGroup *defGroup = BLI_findlink(&ob->defbase, sb->vertgroup-1);
+                                               if(defGroup)
+                                                       uiDefBut(block, BUT, B_DIFF, defGroup->name,    160,120,130,20, NULL, 0.0, 0.0, 0, 0, "Name of current vertex group");
+                                               else
+                                                       uiDefBut(block, BUT, B_DIFF, "(no group)",      160,120,130,20, NULL, 0.0, 0.0, 0, 0, "Vertex Group doesn't exist anymore");
+                                               uiDefIconBut(block, BUT, B_SOFTBODY_DEL_VG, ICON_X, 290,120,20,20, 0, 0, 0, 0, 0, "Disable use of vertex group");
+                                       }
+                                       else
+                                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Goal:",       160,120,150,20, &sb->defgoal, 0.0, 1.0, 10, 0, "Default Goal (vertex target position) value, when no Vertex Group used");
+                               }
+                               else {
+                                       uiDefButS(block, TOG, B_SOFTBODY_CHANGE, "W",                   140,120,20,20, &sb->vertgroup, 0, 1, 0, 0, "Use control point weight values");
+                                       uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Goal:",       160,120,150,20, &sb->defgoal, 0.0, 1.0, 10, 0, "Default Goal (vertex target position) value, when no Vertex Group used");
+                               }
+
+                               uiDefButF(block, NUM, B_DIFF, "G Stiff:",       10,100,150,20, &sb->goalspring, 0.0, 0.999, 10, 0, "Goal (vertex target position) spring stiffness");
+                               uiDefButF(block, NUM, B_DIFF, "G Damp:",        160,100,150,20, &sb->goalfrict  , 0.0, 50.0, 10, 0, "Goal (vertex target position) friction");
+                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "G Min:",              10,80,150,20, &sb->mingoal, 0.0, 1.0, 10, 0, "Goal minimum, vertex group weights are scaled to match this range");
+                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "G Max:",              160,80,150,20, &sb->maxgoal, 0.0, 1.0, 10, 0, "Goal maximum, vertex group weights are scaled to match this range");
+                       }
+                       uiBlockEndAlign(block);
+
+                       /* EDGE SPRING STUFF */
+                       if(ob->type!=OB_SURF) {
                                uiBlockBeginAlign(block);
-                               uiDefButF(block, NUM, B_DIFF, "Damping: ",              160,120,150,20, &pd->pdef_damp, 0.0, 1.0, 10, 0, "Amount of damping during particle collision");
-                               uiDefButF(block, NUM, B_DIFF, "Rnd Damping: ",  160,100,150,20, &pd->pdef_rdamp, 0.0, 1.0, 10, 0, "Random variation of damping");
-                               uiDefButF(block, NUM, B_DIFF, "Permeability: ", 160,80,150,20, &pd->pdef_perm, 0.0, 1.0, 10, 0, "Chance that the particle will pass through the mesh");
+                               uiDefButBitS(block, TOG, OB_SB_EDGES, B_SOFTBODY_CHANGE, "Use Edges",           10,50,90,20, softflag, 0, 0, 0, 0, "Use Edges as springs");
+                       if (*softflag & OB_SB_EDGES){
+                               uiDefButBitS(block, TOG, OB_SB_QUADS, B_SOFTBODY_CHANGE, "Stiff Quads",         110,50,90,20, softflag, 0, 0, 0, 0, "Adds diagonal springs on 4-gons");
+                               uiDefButBitS(block, TOG, OB_SB_EDGECOLL, B_DIFF, "CEdge",               220,50,45,20, softflag, 0, 0, 0, 0, "Edge collide too"); 
+                               uiDefButBitS(block, TOG, OB_SB_FACECOLL, B_DIFF, "CFace",               265,50,45,20, softflag, 0, 0, 0, 0, "Faces collide too SLOOOOOW warning "); 
+                               uiDefButF(block, NUM, B_DIFF, "E Stiff:",       10,30,150,20, &sb->inspring, 0.0,  0.999, 10, 0, "Edge spring stiffness");
+                               uiDefButF(block, NUM, B_DIFF, "E Damp:",        160,30,150,20, &sb->infrict, 0.0,  50.0, 10, 0, "Edge spring friction");
+                               uiDefButS(block, NUM, B_DIFF, "Aero:",     10,10,150,20, &sb->aeroedge,  0.00,  30000.0, 10, 0, "Make edges 'sail'");
+                               if(ob->type==OB_MESH) {
+                                       uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Rigidity:", 160,10,150,20, &sb->secondspring, 0.0,  10.0, 10, 0, "Strenght of Springs over 2 Edges");
+                               }
+                               else sb->secondspring = 0;
+                               uiDefBut(block, LABEL, 0, "",10,10,1,0, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
+                       }
+                               uiBlockEndAlign(block);
+                       }
+               //}
+       }
+       uiBlockEndAlign(block);
+}
+
+ /* Panels for new particles*/
+static void object_panel_particle_children(Object *ob)
+{
+       uiBlock *block;
+       ParticleSystem *psys = psys_get_current(ob);
+       ParticleSettings *part;
+       short butx=0, buty=160, butw=150, buth=20;
+       static short kink_ui=0;
+
+       if (psys==NULL) return;
+       part=psys->part;
+       if(part==NULL) return;
+               
+       block= uiNewBlock(&curarea->uiblocks, "object_panel_particle_child", UI_EMBOSS, UI_HELV, curarea->win);
+       uiNewPanelTabbed("Extras", "Particle");
+       if(uiNewPanel(curarea, block, "Children", "Particle", 1300, 0, 318, 204)==0) return;
+
+       uiDefButS(block, MENU, B_PART_ALLOC_CHILD, "Children from:%t|Faces%x2|Particles%x1|None%x0", butx,buty,butw,buth, &part->childtype, 14.0, 0.0, 0, 0, "Create child particles");
+
+       if(part->childtype==0) return;
+
+       if((psys->flag&(PSYS_HAIR_DONE|PSYS_KEYED))==0) {
+               uiDefBut(block, LABEL, 0, "Hair or keyed",      butx,(buty-=2*buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+               uiDefBut(block, LABEL, 0, "particles needed!",  butx,(buty-=2*buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+               return;
+       }
+
+       uiBlockBeginAlign(block);
+
+       buty -= buth/2;
+       
+       uiDefButI(block, NUM, B_PART_ALLOC_CHILD, "Amount:", butx,(buty-=buth),butw,buth, &part->child_nbr, 0.0, MAX_PART_CHILDREN, 0, 0, "Amount of children/parent");
+       uiDefButI(block, NUM, B_DIFF, "Render Amount:", butx,(buty-=buth),butw,buth, &part->ren_child_nbr, 0.0, MAX_PART_CHILDREN, 0, 0, "Amount of children/parent for rendering");
+       if(part->from!=PART_FROM_PARTICLE && part->childtype==PART_CHILD_FACES) {
+               uiDefButF(block, NUMSLI, B_PART_DISTR_CHILD, "VParents:",               butx,(buty-=buth),butw,buth, &part->parents, 0.0, 1.0, 1, 3, "Relative amount of virtual parents");
+               }
+       else {
+               uiDefButF(block, NUM, B_PART_RECALC_CHILD, "Rad:",              butx,(buty-=buth),butw,buth, &part->childrad, 0.0, 10.0, 1, 3, "Radius of children around parent");
+               uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Round:",         butx,(buty-=buth),butw,buth, &part->childflat, 0.0, 1.0, 1, 3, "Roundness of children around parent");
+       }
+       uiBlockEndAlign(block);
+
+       buty -= buth/2;
+
+       /* clump */
+       uiBlockBeginAlign(block);
+       uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Clump:",         butx,(buty-=buth),butw,buth, &part->clumpfac, -1.0, 1.0, 1, 3, "Amount of clumpimg");
+       uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Shape:",         butx,(buty-=buth),butw,buth, &part->clumppow, -0.999, 0.999, 1, 3, "Shape of clumpimg");
+       uiBlockEndAlign(block);
+
+       buty -= buth/2;
+
+       uiBlockBeginAlign(block);
+       uiDefButF(block, NUM, B_PART_REDRAW, "Size:",           butx,(buty-=buth),butw/2,buth, &part->childsize, 0.01, 100, 10, 1, "A multiplier for the child particle size");
+       uiDefButF(block, NUM, B_PART_REDRAW, "Rand:",           butx+butw/2,buty,butw/2,buth, &part->childrandsize, 0.0, 1.0, 10, 1, "Random variation to the size of the child particles");
+       if(part->childtype==PART_CHILD_FACES) {
+               uiDefButF(block, NUM, B_PART_REDRAW, "Spread:",butx,(buty-=buth),butw/2,buth, &part->childspread, -1.0, 1.0, 10, 1, "Spread children from the faces");
+               uiDefButBitI(block, TOG, PART_CHILD_SEAMS, B_PART_DISTR_CHILD, "Use Seams",      butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Use seams to determine parents");
+       }
+       uiBlockEndAlign(block);
+
+       butx=160;
+       buty=180;
+
+       uiDefButBitS(block, TOG, 1, B_PART_REDRAW, "Kink/Branch",        butx,(buty-=buth),butw,buth, &kink_ui, 0, 0, 0, 0, "Show kink and branch options");
+
+       if(kink_ui) {
+               buty -= buth/2;
+
+               /* kink */
+               uiBlockBeginAlign(block);
+               if(part->kink) {
+                       uiDefButS(block, MENU, B_PART_RECALC_CHILD, "Kink:%t|Roll%x6|Rotation%x5|Braid%x4|Wave%x3|Radial%x2|Curl%x1|Nothing%x0", butx,(buty-=buth),butw/2,buth, &part->kink, 14.0, 0.0, 0, 0, "Type of periodic offset on the path");
+                       uiDefButS(block, MENU, B_PART_RECALC_CHILD, "Axis %t|Z %x2|Y %x1|X %x0", butx+butw/2,buty,butw/2,buth, &part->kink_axis, 14.0, 0.0, 0, 0, "Which axis to use for offset");
+                       uiDefButF(block, NUM, B_PART_RECALC_CHILD, "Freq:",                     butx,(buty-=buth),butw,buth, &part->kink_freq, 0.0, 10.0, 1, 3, "The frequency of the offset (1/total length)");
+                       uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Shape:",         butx,(buty-=buth),butw,buth, &part->kink_shape, -0.999, 0.999, 1, 3, "Adjust the offset to the beginning/end");
+                       uiDefButF(block, NUM, B_PART_RECALC_CHILD, "Amplitude:",        butx,(buty-=buth),butw,buth, &part->kink_amp, 0.0, 10.0, 1, 3, "The amplitude of the offset");
+               }
+               else {
+                       uiDefButS(block, MENU, B_PART_RECALC_CHILD, "Kink:%t|Roll%x6|Rotation%x5|Braid%x4|Wave%x3|Radial%x2|Curl%x1|Nothing%x0", butx,(buty-=buth),butw,buth, &part->kink, 14.0, 0.0, 0, 0, "Type of periodic offset on the path");
+                       buty-=3*buth;
+               }
+               uiBlockEndAlign(block);
+
+               if(part->childtype==PART_CHILD_PARTICLES) {
+                       if(part->flag & PART_BRANCHING) {
+                               uiDefButBitI(block, TOG, PART_BRANCHING, B_PART_RECALC_CHILD, "Branching",      butx,(buty-=2*buth),butw,buth, &part->flag, 0, 0, 0, 0, "Branch child paths from eachother");
+                               uiDefButBitI(block, TOG, PART_ANIM_BRANCHING, B_PART_RECALC_CHILD, "Animated",  butx,(buty-=buth),butw/2,buth, &part->flag, 0, 0, 0, 0, "Animate branching");
+                               uiDefButBitI(block, TOG, PART_SYMM_BRANCHING, B_PART_RECALC_CHILD, "Symmetric", butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Start and end points are the same");
+                               uiDefButF(block, NUM, B_PART_RECALC_CHILD, "Threshold:",        butx,(buty-=buth),butw,buth, &part->branch_thres, 0.0, 1.0, 1, 3, "Threshold of branching");
+                       }
+                       else
+                               uiDefButBitI(block, TOG, PART_BRANCHING, B_PART_RECALC_CHILD, "Branching",      butx,(buty-=2*buth),butw,buth, &part->flag, 0, 0, 0, 0, "Branch child paths from eachother");
+               }
+       }
+       else {
+       /* rough */
+               buty -= buth/2;
+
+               uiBlockBeginAlign(block);
+               uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Rough1:",        butx,(buty-=buth),butw,buth, &part->rough1, 0.0, 10.0, 1, 3, "Amount of location dependant rough");
+               uiDefButF(block, NUM, B_PART_RECALC_CHILD, "Size1:",    butx,(buty-=buth),butw,buth, &part->rough1_size, 0.01, 10.0, 1, 3, "Size of location dependant rough");
+               uiBlockEndAlign(block);
+               buty -= buth/2;
+               uiBlockBeginAlign(block);
+               uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Rough2:",        butx,(buty-=buth),butw,buth, &part->rough2, 0.0, 10.0, 1, 3, "Amount of random rough");
+               uiDefButF(block, NUM, B_PART_RECALC_CHILD, "Size2:",    butx,(buty-=buth),butw,buth, &part->rough2_size, 0.01, 10.0, 1, 3, "Size of random rough");
+               uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Thresh:",        butx,(buty-=buth),butw,buth, &part->rough2_thres, 0.00, 1.0, 1, 3, "Amount of particles left untouched by random rough");
+               uiBlockEndAlign(block);
+               buty -= buth/2;
+               uiBlockBeginAlign(block);
+               uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "RoughE:",        butx,(buty-=buth),butw,buth, &part->rough_end, 0.0, 10.0, 1, 3, "Amount of end point rough");
+               uiDefButF(block, NUMSLI, B_PART_RECALC_CHILD, "Shape:", butx,(buty-=buth),butw,buth, &part->rough_end_shape, 0.0, 10.0, 1, 3, "Shape of end point rough");
+               uiBlockEndAlign(block);
+       }
+}
+static void particle_set_vg(void *ob_v, void *vgnum_v)
+{
+       Object *ob= ob_v;
+       ParticleSystem *psys=psys_get_current(ob);
+       short vgnum = *((short *)vgnum_v);
+
+       if(vgnum==PSYS_VG_DENSITY)
+               psys->recalc|=PSYS_DISTR;
+       else if(vgnum!=PSYS_VG_SIZE)
+               psys->recalc|=PSYS_INIT;
+
+       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+       allqueue(REDRAWVIEW3D, 0);
+}
+static void particle_del_vg(void *ob_v, void *vgnum_v)
+{
+       Object *ob= ob_v;
+       ParticleSystem *psys=psys_get_current(ob);
+       short vgnum = *((short *)vgnum_v);
+
+       if(vgnum==PSYS_VG_DENSITY) {
+               psys->recalc|=PSYS_DISTR;
+       }
+
+       psys->vgroup[vgnum]=0;
+
+       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+       allqueue(REDRAWVIEW3D, 0);
+}
+static void object_panel_particle_extra(Object *ob)
+{
+       uiBlock *block;
+       uiBut *but;
+       ParticleSystem *psys=psys_get_current(ob);
+       ParticleSettings *part;
+       short butx=0, buty=160, butw=150, buth=20;
+       static short vgnum=0;
+       int event;
+
+       if (psys==NULL) return;
+       part=psys->part;
+       if(part==NULL) return;
+               
+       block= uiNewBlock(&curarea->uiblocks, "object_panel_particle_extra", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Extras", "Particle", 980, 0, 318, 204)==0) return;
+
+       uiDefBut(block, LABEL, 0, "Effectors:", butx,buty,butw,buth, NULL, 0.0, 0, 0, 0, "");
+       uiBlockBeginAlign(block);
+       uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_PART_RECALC, "GR:", butx, (buty-=buth), butw/2, buth, &part->eff_group, "Limit effectors to this Group"); 
+       uiDefButBitI(block, TOG, PART_SIZE_DEFL, B_PART_RECALC, "Size Deflect", butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Use particle's size in deflection");
+       uiDefButBitI(block, TOG, PART_DIE_ON_COL, B_PART_RECALC, "Die on hit",butx,(buty-=buth),butw/2,buth, &part->flag, 0, 0, 0, 0, "Particles die when they collide with a deflector object");
+       uiDefButBitI(block, TOG, PART_STICKY, B_PART_RECALC, "Sticky",  butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Particles stick to collided objects if they die in the collision");
+       uiBlockEndAlign(block);
+
+       uiDefBut(block, LABEL, 0, "Time:",      butx,(buty-=buth),butw/3,buth, NULL, 0.0, 0, 0, 0, "");
+       uiBlockBeginAlign(block);
+       uiDefButBitI(block, TOG, PART_GLOB_TIME, B_PART_RECALC, "Global",        butx,(buty-=buth),butw/2,buth, &part->flag, 0, 0, 0, 0, "Set all ipos that work on particles to be calculated in global/object time");
+       uiDefButBitI(block, TOG, PART_ABS_TIME, B_PART_RECALC, "Absolute",       butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Set all ipos that work on particles to be calculated in absolute/relative time");
+
+       if(part->flag & PART_LOOP){
+               uiDefButBitI(block, TOG, PART_LOOP, B_PART_RECALC, "Loop",       butx,(buty-=buth),butw/2,buth, &part->flag, 0, 0, 0, 0, "Loop particle lives");
+               uiDefButBitI(block, TOG, PART_LOOP_INSTANT, B_PART_RECALC, "Instantly",  butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Loop particle life at time of death");
+       }
+       else
+               uiDefButBitI(block, TOG, PART_LOOP, B_PART_RECALC, "Loop",       butx,(buty-=buth),butw,buth, &part->flag, 0, 0, 0, 0, "Loop particle lives");
+
+       uiDefButF(block, NUM, B_PART_RECALC, "Tweak:",  butx,(buty-=buth),butw,buth, &part->timetweak, 0.0, 10.0, 1, 0, "A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)");
+       uiBlockEndAlign(block);
+
+       if(ob->type==OB_MESH) {
+               char *menustr= get_vertexgroup_menustr(ob);
+               int defCount=BLI_countlist(&ob->defbase);
+               if(defCount==0) psys->vgroup[vgnum]= 0;
+
+               uiDefBut(block, LABEL, 0, "Vertex group:",      butx,(buty-=2*buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+
+               uiBlockBeginAlign(block);
+               
+               uiDefButS(block, MENU, B_PART_REDRAW, "Attribute%t|TanRot%x10|TanVel%x9|Size%x8|RoughE%x7|Rough2%x6|Rough1%x5|Kink%x4|Clump%x3|Length%x2|Velocity%x1|Density%x0", butx,(buty-=buth),butw-40,buth, &vgnum, 14.0, 0.0, 0, 0, "Attribute effected by vertex group");
+               but=uiDefButBitS(block, TOG, (1<<vgnum), B_PART_REDRAW, "Neg",  butx+butw-40,buty,40,buth, &psys->vg_neg, 0, 0, 0, 0, "Negate the effect of the vertex group");
+               uiButSetFunc(but, particle_set_vg, (void *)ob, (void *)(&vgnum));
+               
+               butx+=butw;
+
+               but= uiDefButS(block, MENU, B_PART_REDRAW, menustr,     butx,buty,buth,buth, psys->vgroup+vgnum, 0, defCount, 0, 0, "Browses available vertex groups");
+               uiButSetFunc(but, particle_set_vg, (void *)ob, (void *)(&vgnum));
+               MEM_freeN (menustr);
+
+               if(psys->vgroup[vgnum]) {
+                       bDeformGroup *defGroup = BLI_findlink(&ob->defbase, psys->vgroup[vgnum]-1);
+                       if(defGroup)
+                               uiDefBut(block, BUT, B_PART_REDRAW, defGroup->name,     butx+buth,buty,butw-2*buth,buth, NULL, 0.0, 0.0, 0, 0, "Name of current vertex group");
+                       else{
+                               uiDefBut(block, BUT, B_PART_REDRAW, "(no group)",       butx+buth,buty,butw-2*buth,buth, NULL, 0.0, 0.0, 0, 0, "Vertex Group doesn't exist anymore");
+                       }
+                       but=uiDefIconBut(block, BUT, B_PART_REDRAW, ICON_X, butx+butw-buth,buty,buth,buth, 0, 0, 0, 0, 0, "Disable use of vertex group");
+                       uiButSetFunc(but, particle_del_vg, (void *)ob, (void *)(&vgnum));
+               }
+
+               uiBlockEndAlign(block);
+       }
+       
+       buty=butx=160;
+
+       uiDefButI(block, NUM, B_PART_DISTR, "Seed:",                            butx,(buty-=buth),butw,buth, &psys->seed, 0.0, 255.0, 1, 0, "Set an offset in the random table");
+
+       event=(part->flag&PART_SIZEMASS)?B_PART_RECALC:B_PART_REDRAW;
+       uiDefButF(block, NUM, event, "Size:",   butx,(buty-=2*buth),butw,buth, &part->size, 0.01, 100, 10, 1, "The size of the particles");
+       uiDefButF(block, NUM, event, "Rand:",   butx,(buty-=buth),butw,buth, &part->randsize, 0.0, 2.0, 10, 1, "Give the particle size a random variation");
+
+       uiDefButBitI(block, TOG, PART_SIZEMASS, B_PART_RECALC, "Mass from size",         butx,(buty-=buth),butw,buth, &part->flag, 0, 0, 0, 0, "Multiply mass with particle size");
+       uiDefButF(block, NUM, B_PART_RECALC, "Mass:",   butx,(buty-=buth),butw,buth, &part->mass, 0.01, 100, 10, 1, "Specify the mass of the particles");
+}
+/* copy from buttons_shading.c */
+static void autocomplete_uv(char *str, void *arg_v)
+{
+       Mesh *me;
+       CustomDataLayer *layer;
+       AutoComplete *autocpl;
+       int a;
+
+       if(str[0]==0)
+               return;
+
+       autocpl= autocomplete_begin(str, 32);
+               
+       /* search if str matches the beginning of name */
+       for(me= G.main->mesh.first; me; me=me->id.next)
+               for(a=0, layer= me->fdata.layers; a<me->fdata.totlayer; a++, layer++)
+                       if(layer->type == CD_MTFACE)
+                               autocomplete_do_name(autocpl, layer->name);
+       
+       autocomplete_end(autocpl, str);
+}
+static void object_panel_particle_visual(Object *ob)
+{
+       uiBlock *block;
+       uiBut *but;
+       ParticleSystem *psys=psys_get_current(ob);
+       ParticleSettings *part;
+       short butx=0, buty=160, butw=150, buth=20;
+       static short bbuvnum=0;
+
+       if (psys==NULL) return;
+       part=psys->part;
+       if(part==NULL) return;
+               
+       block= uiNewBlock(&curarea->uiblocks, "object_panel_particle_visual", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Visualization", "Particle", 640, 0, 318, 204)==0) return;
+
+       uiDefButS(block, MENU, B_PART_RECALC, "Billboard %x9|Group %x8|Object %x7|Path %x6|Line %x5|Axis %x4|Cross %x3|Circle %x2|Point %x1|None %x0", butx,buty,butw,buth, &part->draw_as, 14.0, 0.0, 0, 0, "How particles are visualized");
+
+       if(part->draw_as==PART_DRAW_NOT) {
+               uiDefButBitS(block, TOG, PART_DRAW_EMITTER, B_PART_REDRAW, "Render emitter",    butx,(buty-=2*buth),butw,buth, &part->draw, 0, 0, 0, 0, "Render emitter object");
+               return;
+       }
+
+       uiDefBut(block, LABEL, 0, "Draw:",      butx,(buty-=buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+       uiBlockBeginAlign(block);
+       uiDefButBitS(block, TOG, PART_DRAW_VEL, B_PART_REDRAW, "Vel",   butx,(buty-=buth),butw/3,buth, &part->draw, 0, 0, 0, 0, "Show particle velocity");
+       uiDefButBitS(block, TOG, PART_DRAW_SIZE, B_PART_REDRAW, "Size", butx+butw/3,buty,butw/3,buth, &part->draw, 0, 0, 0, 0, "Show particle size");
+       uiDefButBitS(block, TOG, PART_DRAW_NUM, B_PART_REDRAW, "Num",   butx+2*butw/3,buty,butw/3,buth, &part->draw, 0, 0, 0, 0, "Show particle number");
+       uiDefButS(block, NUM, B_PART_REDRAW, "Draw Size:", butx,(buty-=buth),butw,buth, &part->draw_size, 0.0, 10.0, 0, 0, "Size of particles on viewport in pixels (0=default)");
+       uiDefButS(block, NUM, B_PART_RECALC, "Disp:",           butx,(buty-=buth),butw,buth, &part->disp, 0.0, 100.0, 10, 0, "Percentage of particles to calculate for 3d view");
+       uiBlockEndAlign(block);
+
+       uiDefBut(block, LABEL, 0, "Render:",    butx,(buty-=buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+       uiBlockBeginAlign(block);
+       uiDefButS(block, NUM, B_PART_DISTR, "Material:",                                        butx,(buty-=buth),butw-30,buth, &part->omat, 1.0, 16.0, 0, 0, "Specify material used for the particles");
+       uiDefButBitS(block, TOG, PART_DRAW_MAT_COL, B_PART_RECALC, "Col",       butx+butw-30,buty,30,buth, &part->draw, 0, 0, 0, 0, "Draw particles using material's diffuse color");
+       uiDefButBitS(block, TOG, PART_DRAW_EMITTER, B_PART_REDRAW, "Emitter",   butx,(buty-=buth),butw/2,buth, &part->draw, 0, 0, 0, 0, "Render emitter Object also");
+       uiDefButBitS(block, TOG, PART_DRAW_PARENT, B_PART_REDRAW, "Parents",                            butx+butw/2,buty,butw/2,buth, &part->draw, 0, 0, 0, 0, "Render parent particles");
+       uiDefButBitI(block, TOG, PART_UNBORN, B_PART_REDRAW, "Unborn",                  butx,(buty-=buth),butw/2,buth, &part->flag, 0, 0, 0, 0, "Show particles before they are emitted");
+       uiDefButBitI(block, TOG, PART_DIED, B_PART_REDRAW, "Died",                              butx+butw/2,buty,butw/2,buth, &part->flag, 0, 0, 0, 0, "Show particles after they have died");
+
+       uiBlockEndAlign(block);
+
+       butx=160;
+       buty=160-buth;
+
+       uiBlockBeginAlign(block);
+
+       switch(part->draw_as) {
+               case PART_DRAW_OB:
+                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_PART_REDRAW, "OB:",     butx,(buty-=buth),butw,buth, &part->dup_ob, "Show this Object in place of particles"); 
+                       break;
+               case PART_DRAW_GR:
+                       uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_PART_REDRAW, "GR:",  butx,(buty-=buth),butw,buth, &part->dup_group, "Show Objects in this Group in place of particles"); 
+                       uiDefButBitS(block, TOG, PART_DRAW_WHOLE_GR, B_PART_REDRAW, "Dupli Group",      butx,(buty-=buth),butw,buth, &part->draw, 0, 0, 0, 0, "Use whole group at once");
+                       if((part->draw & PART_DRAW_WHOLE_GR)==0)
+                               uiDefButBitS(block, TOG, PART_DRAW_RAND_GR, B_PART_REDRAW, "Pick Random",       butx,(buty-=buth),butw,buth, &part->draw, 0, 0, 0, 0, "Pick objects from group randomly");
+                       break;
+               case PART_DRAW_BB:
+                       uiDefButBitS(block, TOG, PART_DRAW_BB_LOCK, B_PART_REDRAW, "Lock",      butx,(buty+=buth),butw/2,buth, &part->draw, 0, 0, 0, 0, "Lock the billboards align axis");
+                       uiDefButS(block, MENU, B_PART_REDRAW, "Align to%t|Velocity%x4|View%x3|Z%x2|Y%x1|X%x0", butx+butw/2,buty,butw/2,buth, &part->bb_align, 14.0, 0.0, 0, 0, "In respect to what the billboards are aligned");
+                       uiDefButF(block, NUM, B_PART_REDRAW, "Tilt:", butx,(buty-=buth),butw/2,buth, &part->bb_tilt, -1.0, 1.0, 0, 0, "Tilt of the billboards");
+                       uiDefButF(block, NUM, B_PART_REDRAW, "Rand:", butx+butw/2,buty,butw/2,buth, &part->bb_rand_tilt, 0.0, 1.0, 0, 0, "Random tilt of the billboards");
+                       uiDefButS(block, NUM, B_PART_REDRAW, "UV Split:", butx,(buty-=buth),butw,buth, &part->bb_uv_split, 1.0, 10.0, 0, 0, "Amount of rows/columns to split uv coordinates for billboards");
+                       uiDefButS(block, MENU, B_PART_REDRAW, "Animate%t|Angle%x2|Time%x1|None%x0", butx,(buty-=buth),butw/2,buth, &part->bb_anim, 14.0, 0.0, 0, 0, "How to animate billboard textures");
+                       uiDefButS(block, MENU, B_PART_REDRAW, "Offset%t|Random%x2|Linear%x1|None%x0", butx+butw/2,buty,butw/2,buth, &part->bb_split_offset, 14.0, 0.0, 0, 0, "How to offset billboard textures");
+                       uiDefButF(block, NUM, B_PART_REDRAW, "OffsetX:", butx,(buty-=buth),butw,buth, part->bb_offset, -1.0, 1.0, 0, 0, "Offset billboards horizontally");
+                       uiDefButF(block, NUM, B_PART_REDRAW, "OffsetY:", butx,(buty-=buth),butw,buth, part->bb_offset+1, -1.0, 1.0, 0, 0, "Offset billboards vertically");
+                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_PART_REDRAW, "OB:",     butx,(buty-=buth),butw,buth, &part->bb_ob, "Billboards face this object (default is active camera)"); 
+                       uiDefButS(block, MENU, B_PART_REDRAW, "UV channel%t|Split%x2|Time-Index (X-Y)%x1|Normal%x0", butx,(buty-=buth),butw,buth, &bbuvnum, 14.0, 0.0, 0, 0, "UV channel");
+                       but=uiDefBut(block, TEX, B_PART_REDRAW, "UV:", butx,(buty-=buth),butw,buth, psys->bb_uvname+bbuvnum, 0, 31, 0, 0, "Set name of UV layer to use with billboards, default is active UV layer");
+                       uiButSetCompleteFunc(but, autocomplete_uv, NULL);
+                       break;
+               case PART_DRAW_LINE:
+                       uiDefButBitS(block, TOG, PART_DRAW_VEL_LENGTH, B_PART_REDRAW, "Speed",  butx,(buty-=buth),butw,buth, &part->draw, 0, 0, 0, 0, "Multiply line length by particle speed");
+                       uiDefButF(block, NUM, B_PART_REDRAW, "Back:", butx,(buty-=buth),butw,buth, &part->draw_line[0], 0.0, 10.0, 0, 0, "Length of the line's tail");
+                       uiDefButF(block, NUM, B_PART_REDRAW, "Front:", butx,(buty-=buth),butw,buth, &part->draw_line[1], 0.0, 10.0, 0, 0, "Length of the line's head");
+                       break;
+               case PART_DRAW_PATH:
+                       if(psys->flag & (PSYS_HAIR_DONE|PSYS_KEYED)) {
+                               uiDefButS(block, NUM, B_PART_RECALC, "Steps:",  butx,(buty+=buth),butw,buth, &part->draw_step, 0.0, 7.0, 0, 0, "How many steps paths are drawn with (power of 2)");
+                               uiDefButS(block, NUM, B_PART_REDRAW, "Render:", butx,(buty-=buth),butw,buth, &part->ren_step, 0.0, 9.0, 0, 0, "How many steps paths are rendered with (power of 2)");
+
+                               uiDefButBitI(block, TOG, PART_ABS_LENGTH, B_PART_RECALC, "Abs Length",   butx,(buty-=buth),butw,buth, &part->flag, 0, 0, 0, 0, "Use maximum length in absolute blender units");
+                               uiDefButF(block, NUM, B_PART_RECALC, "Max Length:",             butx,(buty-=buth),butw,buth, &part->abslength, 0.0, 10000.0, 1, 3, "Absolute path length");
+                               uiDefButF(block, NUMSLI, B_PART_RECALC, "RLength:",             butx,(buty-=buth),butw,buth, &part->randlength, 0.0, 1.0, 1, 3, "Give path length a random variation");
                                uiBlockEndAlign(block);
-                               
-                               uiDefBut(block, LABEL, 0, "Soft Body",                  160,60,150,20, NULL, 0.0, 0, 0, 0, "");
+
+                               uiDefButBitI(block, TOG, PART_HAIR_BSPLINE, B_PART_RECALC, "B-Spline",   butx,(buty-=buth),butw,buth, &part->flag, 0, 0, 0, 0, "Interpolate hair using B-Splines");
 
                                uiBlockBeginAlign(block);
-                               uiDefButF(block, NUM, B_DIFF, "Damping:",       160,40,150,20, &pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
-                               uiDefButF(block, NUM, B_DIFF, "Inner:", 160,20,150,20, &pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
-                               uiDefButF(block, NUM, B_DIFF, "Outer:", 160, 0,150,20, &pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
+                               uiDefButBitS(block, TOG, PART_DRAW_REN_STRAND, B_PART_REDRAW, "Strand render",   butx,buty-=buth,butw,buth, &part->draw, 0, 0, 0, 0, "Use the strand primitive for rendering");
+                               if(part->draw & PART_DRAW_REN_STRAND) {
+                                       uiDefButS(block, NUM, B_PART_REDRAW, "Angle:",  butx,(buty-=buth),butw,buth, &part->adapt_angle, 0.0, 45.0, 0, 0, "How many degrees path has to curve to make another render segment");
+                               }
+                               else {
+                                       uiDefButBitS(block, TOG, PART_DRAW_REN_ADAPT, B_PART_REDRAW, "Adaptive render",  butx,buty-=buth,butw,buth, &part->draw, 0, 0, 0, 0, "Draw steps of the particle path");
+                                       if(part->draw & PART_DRAW_REN_ADAPT) {
+                                               uiDefButS(block, NUM, B_PART_REDRAW, "Angle:",  butx,(buty-=buth),butw/2,buth, &part->adapt_angle, 0.0, 45.0, 0, 0, "How many degrees path has to curve to make another render segment");
+                                               uiDefButS(block, NUM, B_PART_REDRAW, "Pixel:",  butx+butw/2,buty,(butw+1)/2,buth, &part->adapt_pix, 0.0, 50.0, 0, 0, "How many pixels path has to cover to make another render segment");
+                                       }
+                               }
+                       }
+                       else {
+                               uiDefBut(block, LABEL, 0, "Baked or keyed",     butx,(buty-=2*buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+                               uiDefBut(block, LABEL, 0, "particles needed!",  butx,(buty-=2*buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
                        }
-               }               
+                       break;
        }
+       uiBlockEndAlign(block);
 }
+static void boidrule_moveDown(void *part_v, void *rule_v)
+{
+       ParticleSettings *part = part_v;
+       char r, *rule = rule_v;
 
+       int n= rule - part->boidrule;
 
-/* Panel for softbodies */
-static void object_softbodies__enable(void *ob_v, void *arg2)
+       if(n+1 < BOID_TOT_RULES) {
+               r=part->boidrule[n];
+               part->boidrule[n]=part->boidrule[n+1];
+               part->boidrule[n+1]=r;
+       }
+}
+static void boidrule_moveUp(void *part_v, void *rule_v)
 {
-       Object *ob = ob_v;
-       ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
-
-       if (modifiers_isSoftbodyEnabled(ob)) {
-               if (md) {
-                       md->mode &= ~(eModifierMode_Render|eModifierMode_Realtime);
-               }
-       } else {
-               if (!md) {
-                       md = modifier_new(eModifierType_Softbody);
-                       BLI_addhead(&ob->modifiers, md);
-               }
+       ParticleSettings *part = part_v;
+       char r, *rule = rule_v;
 
-               md->mode |= eModifierMode_Render|eModifierMode_Realtime;
+       int n= rule - part->boidrule;
 
-               if (!ob->soft) {
-                       ob->soft= sbNew();
-                       ob->softflag |= OB_SB_GOAL|OB_SB_EDGES;
-               }
+       if(n-1 >= 0) {
+               r=part->boidrule[n];
+               part->boidrule[n]=part->boidrule[n-1];
+               part->boidrule[n-1]=r;
        }
-
-       allqueue(REDRAWBUTSEDIT, 0);
 }
-
-static void object_softbodies(Object *ob)
+static void object_panel_particle_physics(Object *ob)
 {
        uiBlock *block;
-       static int val;
        uiBut *but;
+       ParticleSystem *psys=psys_get_current(ob);
+       ParticleSettings *part;
+       short butx=0, buty=160, butw=150, buth=20;
 
-       block= uiNewBlock(&curarea->uiblocks, "object_softbodies", UI_EMBOSS, UI_HELV, curarea->win);
-       if(uiNewPanel(curarea, block, "Soft Body", "Physics", 640, 0, 318, 204)==0) return;
+       if (psys==NULL) return;
+       
+       part=psys->part;
 
+       if(part==NULL) return;
+               
+       block= uiNewBlock(&curarea->uiblocks, "object_panel_particle_physics", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Physics", "Particle", 320, 0, 318, 204)==0) return;
+       
        if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
+       
+       if(psys->flag & PSYS_EDITED || psys->flag & PSYS_PROTECT_CACHE) {
+               uiSetButLock(1, "Hair is edited or cache is protected!");
+       }
 
-       val = modifiers_isSoftbodyEnabled(ob);
-       but = uiDefButI(block, TOG, REDRAWBUTSOBJECT, "Soft Body",      10,200,70,20, &val, 0, 0, 0, 0, "Sets object to become soft body");
-       uiButSetFunc(but, object_softbodies__enable, ob, NULL);
-       uiDefBut(block, LABEL, 0, "",   160, 200,150,20, NULL, 0.0, 0.0, 0, 0, "");     // alignment reason
-
-       if(!modifiers_isSoftbodyEnabled(ob)) {
-               uiDefButBitS(block, TOG, OB_SB_COLLISIONSET, REDRAWBUTSOBJECT, "Collision",     90,200,70,20, &ob->softflag, 0, 0, 0, 0, "Collision Settings");
-               uiDefBut(block, LABEL, 0, "",10,10,1,2, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
-               if(ob->pd  && (ob->softflag & OB_SB_COLLISIONSET)){
-                       /* OTHER OBJECTS COLLISION STUFF */
-                       uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",10,50,150,20, &ob->pd->deflect, 0, 0, 0, 0, "Makes this object visible to softbody objects");
-                       if(ob->pd->deflect) {
-                               uiDefButF(block, NUM, B_DIFF, "Damping:",       160,50,150,20, &ob->pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
-                               uiDefButF(block, NUM, B_DIFF, "Inner:", 160,30,150,20, &ob->pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
-                               uiDefButF(block, NUM, B_DIFF, "Outer:", 160,10,150,20, &ob->pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
-                       }
-               }
+       if(part->phystype==PART_PHYS_KEYED){
+               uiBlockBeginAlign(block);
+               uiDefButBitI(block, TOG, PSYS_FIRST_KEYED, B_PART_RECALC, "First",       butx,buty,45,buth, &psys->flag, 0, 0, 0, 0, "Sets the system to be the starting point of keyed particles");
+               uiDefButS(block, MENU, B_PART_RECALC, "Physics %t|Boids%x3|Keyed %x2|Newtonian %x1|None %x0", butx+45,buty,butw-45,buth, &part->phystype, 14.0, 0.0, 0, 0, "Select particle physics type");
+               uiBlockEndAlign(block);
        }
-       else {
-               SoftBody *sb= ob->soft;
-               int defCount;
-               char *menustr;
+       else
+               uiDefButS(block, MENU, B_PART_RECALC, "Physics%t|Boids%x3|Keyed%x2|Newtonian%x1|None%x0", butx,buty,butw,buth, &part->phystype, 14.0, 0.0, 0, 0, "Select particle physics type");
+
+       if(part->phystype==PART_PHYS_BOIDS) {
+               int i;
+               char *rules[BOID_TOT_RULES] = {"Collision", "Avoid", "Crowd", "Center", "AvVel", "Velocity", "Goal", "Level"};
+               char *ruletext[BOID_TOT_RULES] = {
+                       "Avoid deflector objects",
+                       "Avoid predators",
+                       "Avoid other boids",
+                       "Get to flock center",
+                       "Maintain average velocity",
+                       "Match velocity of nearby boids",
+                       "Seek goal",
+                       "Keep the Z level"
+               };
+               /* left column */
+               uiDefBut(block, LABEL, 0, "Behaviour:",         butx,(buty-=buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+               uiBlockBeginAlign(block);
+               for(i=0; i<BOID_TOT_RULES; i++) {
+                       uiBlockSetCol(block, TH_BUT_ACTION);
 
-               if(sb==NULL) {
-                       sb= ob->soft= sbNew();
-                       ob->softflag |= OB_SB_GOAL|OB_SB_EDGES;
-               }
+                       but = uiDefIconBut(block, BUT, B_PART_RECALC, VICON_MOVE_UP, butx, (buty-=buth), 20, 20, NULL, 0.0, 0.0, 0.0, 0.0, "Move rule up");
+                       uiButSetFunc(but, boidrule_moveUp, part, part->boidrule+i);
 
-               if((ob->softflag & OB_SB_BAKESET)==0)  {
-               uiDefButBitS(block, TOG, OB_SB_COLLISIONSET, REDRAWBUTSOBJECT, "Collision",     90,200,70,20, &ob->softflag, 0, 0, 0, 0, "Collision Settings");
-               }
-               uiDefButBitS(block, TOG, OB_SB_BAKESET, REDRAWBUTSOBJECT, "Bake settings",      180,200,130,20, &ob->softflag, 0, 0, 0, 0, "To convert simulation into baked (cached) result");
+                       but = uiDefIconBut(block, BUT, B_PART_RECALC, VICON_MOVE_DOWN, butx+20, buty, 20, 20, NULL, 0.0, 0.0, 0.0, 0.0, "Move rule down");
+                       uiButSetFunc(but, boidrule_moveDown, part, part->boidrule+i);
 
-               if(sb->keys) uiSetButLock(1, "Soft Body is baked, free it first");
+                       uiBlockSetCol(block, TH_BUT_SETTING2);
 
-               if(ob->softflag & OB_SB_BAKESET) {
-                       uiBlockBeginAlign(block);
-                       uiDefButI(block, NUM, B_DIFF, "Start:",                 10, 170,100,20, &sb->sfra, 1.0, 10000.0, 10, 0, "Start frame for baking");
-                       uiDefButI(block, NUM, B_DIFF, "End:",                   110, 170,100,20, &sb->efra, 1.0, 10000.0, 10, 0, "End frame for baking");
-                       uiDefButI(block, NUM, B_DIFF, "Interval:",              210, 170,100,20, &sb->interval, 1.0, 10.0, 10, 0, "Interval in frames between baked keys");
-                       uiBlockEndAlign(block);
+                       uiDefButF(block, NUM, B_PART_RECALC, rules[part->boidrule[i]],          butx+40,buty,butw-40,buth, part->boidfac+part->boidrule[i], -1.0, 2.0, 1, 3, ruletext[part->boidrule[i]]);
+               }
+               uiBlockSetCol(block, TH_AUTO);
+               uiBlockEndAlign(block);
 
-                       uiDefButS(block, TOG, B_DIFF, "Local",                  10, 145,100,20, &sb->local, 0.0, 0.0, 0, 0, "Use local coordinates for baking");
+               buty=140;
+               butx=160;
+               
+               uiDefBut(block, LABEL, 0, "Physics:",           butx,buty,butw,buth, NULL, 0.0, 0, 0, 0, "");
+               uiBlockBeginAlign(block);
+               uiDefButBitI(block, TOG, PART_BOIDS_2D, B_PART_RECALC, "2D",     butx,(buty-=buth),butw,buth, &part->flag, 0, 0, 0, 0, "Constrain boids to a surface");
+               uiDefButF(block, NUM, B_PART_RECALC, "MaxVelocity:",            butx,(buty-=buth),butw,buth, &part->max_vel, 0.0, 200.0, 1, 3, "Maximum velocity");
+               uiDefButF(block, NUM, B_PART_RECALC, "AvVelocity:",             butx,(buty-=buth),butw,buth, &part->average_vel, 0.0, 1.0, 1, 3, "The usual speed % of max velocity");
+               uiDefButF(block, NUM, B_PART_RECALC, "LatAcc:",         butx,(buty-=buth),butw,buth, &part->max_lat_acc, 0.0, 1.0, 1, 3, "Lateral acceleration % of max velocity");
+               uiDefButF(block, NUM, B_PART_RECALC, "TanAcc:",         butx,(buty-=buth),butw,buth, &part->max_tan_acc, 0.0, 1.0, 1, 3, "Tangential acceleration % of max velocity");
+               if(part->flag & PART_BOIDS_2D) {
+                       uiDefButF(block, NUM, B_PART_RECALC, "GroundZ:",                butx,(buty-=buth),butw,buth, &part->groundz, -100.0, 100.0, 1, 3, "Default Z value");
+                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_PARTTARGET, "OB:",      butx,(buty-=buth),butw,buth, &psys->keyed_ob, "Constrain boids to object's surface"); 
+               }
+               else {
+                       uiDefButF(block, NUM, B_PART_RECALC, "Banking:",                butx,(buty-=buth),butw,buth, &part->banking, -10.0, 10.0, 1, 3, "Banking of boids on turns (1.0==natural banking)");
+                       uiDefButF(block, NUM, B_PART_RECALC, "MaxBank:",                butx,(buty-=buth),butw,buth, &part->max_bank, 0.0, 1.0, 1, 3, "How much a boid can bank at a single step");
+               }
+               uiBlockEndAlign(block);
+               uiDefButS(block, NUM, B_PART_RECALC, "N:",              butx,(buty-=buth),butw,buth, &part->boidneighbours, 1.0, 10.0, 1, 3, "How many neighbours to consider for each boid");
+       }
+       else {
+               /* left column */
+               uiDefBut(block, LABEL, 0, "Initial velocity:",          butx,(buty-=buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+               uiBlockBeginAlign(block);
+               uiBlockSetCol(block, TH_BUT_SETTING2);
+               uiDefButF(block, NUM, B_PART_RECALC, "Object:",         butx,(buty-=buth*4/5),butw,buth*4/5, &part->obfac, -1.0, 1.0, 1, 3, "Let the object give the particle a starting speed");
+               uiDefButF(block, NUM, B_PART_RECALC, "Normal:",         butx,(buty-=buth*4/5),butw,buth*4/5, &part->normfac, -200.0, 200.0, 1, 3, "Let the surface normal give the particle a starting speed");
+               uiDefButF(block, NUM, B_PART_RECALC, "Random:",         butx,(buty-=buth*4/5),butw,buth*4/5, &part->randfac, 0.0, 200.0, 1, 3, "Give the starting speed a random variation");
+               if(part->type==PART_REACTOR) {
+                       uiDefButF(block, NUM, B_PART_RECALC, "Particle:",               butx,(buty-=buth*4/5),butw,buth*4/5, &part->partfac, -10.0, 10.0, 1, 3, "Let the target particle give the particle a starting speed");
+                       uiDefButF(block, NUM, B_PART_RECALC, "Reactor:",                butx,(buty-=buth*4/5),butw,buth*4/5, &part->reactfac, -10.0, 10.0, 1, 3, "Let the vector from target particle give the particle a starting speed");
+               }
+               else {
+                       uiDefButF(block, NUM, B_PART_RECALC, "Tan:",            butx,(buty-=buth*4/5),butw,buth*4/5, &part->tanfac, -200.0, 200.0, 1, 3, "Let the surface tangent give the particle a starting speed");
+                       uiDefButF(block, NUM, B_PART_RECALC, "Rot:",            butx,(buty-=buth*4/5),butw,buth*4/5, &part->tanphase, -1.0, 1.0, 1, 3, "Rotate the surface tangent");
+               }
+               uiBlockSetCol(block, TH_AUTO);
+               uiBlockEndAlign(block);
 
+               buty=160;
+               butx=160;
+               
+               if(part->phystype==PART_PHYS_NEWTON)
+                       uiDefButS(block, MENU, B_PART_RECALC, "Integration%t|RK4%x2|Midpoint%x1|Euler%x0", butx,buty,butw,buth, &part->integrator, 14.0, 0.0, 0, 0, "Select physics integrator type");
+               
+               uiDefBut(block, LABEL, 0, "Rotation:",  butx, (buty-=buth),butw,buth, NULL, 0.0, 0, 0, 0, "");
+               uiBlockBeginAlign(block);
+               uiDefButBitI(block, TOG, PART_ROT_DYN, B_PART_RECALC, "Dynamic",         butx,(buty-=buth*4/5),butw/2,buth*4/5, &part->flag, 0, 0, 0, 0, "Sets rotation to dynamic/constant");
+               uiDefButS(block, MENU, B_PART_RECALC, "Rotation %t|Random %x3|Velocity %x2|Normal %x1|None %x0", butx+butw/2,buty,butw/2,buth*4/5, &part->rotmode, 14.0, 0.0, 0, 0, "Select particle rotation mode");
+               uiBlockSetCol(block, TH_BUT_SETTING2);
+               uiDefButF(block, NUM, B_PART_RECALC, "Amount:",         butx,(buty-=buth*4/5),butw,buth*4/5, &part->rotfac, -1.0, 1.0, 1, 3, "Rotation amount");
+               uiDefButF(block, NUM, B_PART_RECALC, "Phase:",                  butx,(buty-=buth*4/5),butw,buth*4/5, &part->phasefac, -1.0, 1.0, 1, 3, "Initial rotation phase");
+               uiBlockSetCol(block, TH_AUTO);
+
+               uiDefButS(block, MENU, B_PART_RECALC, "Angular v %t|Velocity%x3|Random%x2|Spin%x1|None%x0", butx,(buty-=buth*4/5),butw,buth*4/5, &part->avemode, 14.0, 0.0, 0, 0, "Select particle angular velocity mode");
+               uiBlockSetCol(block, TH_BUT_SETTING2);
+               uiDefButF(block, NUM, B_PART_RECALC, "Angular v:",              butx,(buty-=buth*4/5),butw,buth*4/5, &part->avefac, -200.0, 200.0, 1, 3, "Angular velocity amount");
+               uiBlockSetCol(block, TH_AUTO);
+               uiBlockEndAlign(block);
+               
+               if(part->phystype==PART_PHYS_NEWTON) {
+                       butx=0;
+                       buty=40;
+                       uiDefBut(block, LABEL, 0, "Global effects:",    butx,buty,butw,buth, NULL, 0.0, 0, 0, 0, "");
 
-                       uiClearButLock();
+                       butw=103;
                        uiBlockBeginAlign(block);
+                       uiDefButF(block, NUM, B_PART_RECALC, "AccX:",           butx,(buty-=buth),butw,buth, part->acc, -200.0, 200.0, 10, 0, "Specify a constant acceleration along the X-axis");
+                       uiDefButF(block, NUM, B_PART_RECALC, "AccY:",           butx+butw,buty,butw,buth, part->acc+1,-200.0, 200.0, 10, 0, "Specify a constant acceleration along the Y-axis");
+                       uiDefButF(block, NUM, B_PART_RECALC, "AccZ:",           butx+2*butw,buty,butw+1,buth, part->acc+2, -200.0, 200.0, 10, 0, "Specify a constant acceleration along the Z-axis");
 
-                       if(sb->keys) {
-                               char str[128];
-                               uiDefIconTextBut(block, BUT, B_SOFTBODY_BAKE_FREE, ICON_X, "FREE BAKE", 10, 120,300,20, NULL, 0.0, 0.0, 0, 0, "Free baked result");
-                               sprintf(str, "Stored %d vertices %d keys %.3f MB", sb->totpoint, sb->totkey, ((float)16*sb->totpoint*sb->totkey)/(1024.0*1024.0));
-                               uiDefBut(block, LABEL, 0, str, 10, 100,300,20, NULL, 0.0, 0.0, 00, 0, "");
-                       }
-                       else                            
-                               uiDefBut(block, BUT, B_SOFTBODY_BAKE, "BAKE",   10, 120,300,20, NULL, 0.0, 0.0, 10, 0, "Start baking. Press ESC to exit without baking");
-
+                       uiDefButF(block, NUM, B_PART_RECALC, "Drag:",           butx,(buty-=buth),butw,buth, &part->dragfac, 0.0, 1.0, 1, 0, "Specify the amount of air-drag");
+                       uiDefButF(block, NUM, B_PART_RECALC, "Brown:",          butx+butw,buty,butw,buth, &part->brownfac, 0.0, 200.0, 1, 0, "Specify the amount of brownian motion");
+                       uiDefButF(block, NUM, B_PART_RECALC, "Damp:",           butx+2*butw,buty,butw+1,buth, &part->dampfac, 0.0, 1.0, 1, 0, "Specify the amount of damping");
+                       uiBlockEndAlign(block);
                }
-               else {
-                       if(ob->softflag & OB_SB_COLLISIONSET) {
-                               /* COLLISION STUFF */
-                               uiDefButBitS(block, TOG, OB_SB_SELF, B_SOFTBODY_CHANGE, "Self Collision",               10,170,90,20, &ob->softflag, 0, 0, 0, 0, "enable naive vertex ball self collision");
-                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Ball Size:", 110,170,170,20, &sb->colball, -10.0,  10.0, 10, 0, "col. ball size ==0 auto, >0 set collision ball manual, -1 use longest attached spring for ball radius");
-                               /* OTHER OBJECTS COLLISION STUFF */
-                               uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",10,50,150,20, &ob->pd->deflect, 0, 0, 0, 0, "Makes this object visible to other softbody objects");
-                               if(ob->pd->deflect) {
-                                       uiDefButF(block, NUM, B_DIFF, "Damping:",       160,50,150,20, &ob->pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
-                                       uiDefButF(block, NUM, B_DIFF, "Inner:", 160,30,150,20, &ob->pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
-                                       uiDefButF(block, NUM, B_DIFF, "Outer:", 160,10,150,20, &ob->pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
-                               }
-                               uiDefBut(block, LABEL, 0, "",10,10,1,2, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
-
+               else if(part->phystype==PART_PHYS_KEYED) {
+                       short totkpsys=1;
+                       butx=0;
+                       buty=40;
+                       uiDefBut(block, LABEL, 0, "Keyed Target:",                                                      butx,buty,butw,buth, NULL, 0.0, 0, 0, 0, "");
+                       if(psys->keyed_ob){
+                               if(psys->keyed_ob==ob || BLI_findlink(&psys->keyed_ob->particlesystem,psys->keyed_psys-1)==0)
+                                       uiBlockSetCol(block, TH_REDALERT);
+                               else
+                                       totkpsys = BLI_countlist(&psys->keyed_ob->particlesystem);
                        }
-                       else {
-                               /* GENERAL STUFF */
-                               uiBlockBeginAlign(block);
-                               uiDefButF(block, NUM, B_DIFF, "Friction:",              10, 170,150,20, &sb->mediafrict, 0.0, 50.0, 10, 0, "General media friction for point movements");
-                               uiDefButF(block, NUM, B_DIFF, "Mass:",                  160, 170,150,20, &sb->nodemass , 0.001, 50.0, 10, 0, "Point Mass, the heavier the slower");
-                               uiDefButF(block, NUM, B_DIFF, "Grav:",                  10,150,150,20, &sb->grav , 0.0, 10.0, 10, 0, "Apply gravitation to point movement");
-                               uiDefButF(block, NUM, B_DIFF, "Speed:",                 160,150,150,20, &sb->physics_speed , 0.01, 100.0, 10, 0, "Tweak timing for physics to control frequency and speed");
-                               uiDefButF(block, NUM, B_DIFF, "Error Limit:",   10,130,150,20, &sb->rklimit , 0.01, 10.0, 10, 0, "The Runge-Kutta ODE solver error limit, low value gives more precision");
-                               if(ob->type==OB_MESH) {
-                                       uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Rigidity:", 160,130,150,20, &sb->secondspring, 0.0,  10.0, 10, 0, "Strenght of Springs over 2 Edges");
-                               }
-                               uiBlockEndAlign(block);
-
-                               /* GOAL STUFF */
-                               uiBlockBeginAlign(block);
-                               uiDefButBitS(block, TOG, OB_SB_GOAL, B_SOFTBODY_CHANGE, "Use Goal",     10,100,130,20, &ob->softflag, 0, 0, 0, 0, "Define forces for vertices to stick to animated position");
-
-                               if(ob->type==OB_MESH) {
-                                       menustr= get_vertexgroup_menustr(ob);
-                                       defCount=BLI_countlist(&ob->defbase);
-                                       if(defCount==0) sb->vertgroup= 0;
-                                       uiDefButS(block, MENU, B_SOFTBODY_CHANGE, menustr,      140,100,20,20, &sb->vertgroup, 0, defCount, 0, 0, "Browses available vertex groups");
-                                       MEM_freeN (menustr);
+                       else
+                               uiBlockSetCol(block, TH_REDALERT);
 
-                                       if(sb->vertgroup) {
-                                               bDeformGroup *defGroup = BLI_findlink(&ob->defbase, sb->vertgroup-1);
-                                               if(defGroup)
-                                                       uiDefBut(block, BUT, B_DIFF, defGroup->name,    160,100,130,20, NULL, 0.0, 0.0, 0, 0, "Name of current vertex group");
-                                               else
-                                                       uiDefBut(block, BUT, B_DIFF, "(no group)",      160,100,130,20, NULL, 0.0, 0.0, 0, 0, "Vertex Group doesn't exist anymore");
-                                               uiDefIconBut(block, BUT, B_SOFTBODY_DEL_VG, ICON_X, 290,100,20,20, 0, 0, 0, 0, 0, "Disable use of vertex group");
-                                       }
-                                       else
-                                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Goal:",       160,100,150,20, &sb->defgoal, 0.0, 1.0, 10, 0, "Default Goal (vertex target position) value, when no Vertex Group used");
-                               }
-                               else {
-                                       uiDefButS(block, TOG, B_SOFTBODY_CHANGE, "W",                   140,100,20,20, &sb->vertgroup, 0, 1, 0, 0, "Use control point weight values");
-                                       uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "Goal:",       160,100,150,20, &sb->defgoal, 0.0, 1.0, 10, 0, "Default Goal (vertex target position) value, when no Vertex Group used");
-                               }
+                       uiBlockBeginAlign(block);
+                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_PARTTARGET, "OB:",      butx,(buty-=buth),butw*2/3,buth, &psys->keyed_ob, "The object that has the target particle system"); 
+                       uiDefButS(block, NUM, B_PARTTARGET, "Psys:",            butx+butw*2/3,buty,butw/3,buth, &psys->keyed_psys, 1.0, totkpsys, 0, 0, "The target particle system number in the object");
+                       uiBlockEndAlign(block);
+                       
+                       uiBlockSetCol(block, TH_AUTO);
 
-                               uiDefButF(block, NUM, B_DIFF, "G Stiff:",       10,80,150,20, &sb->goalspring, 0.0, 0.999, 10, 0, "Goal (vertex target position) spring stiffness");
-                               uiDefButF(block, NUM, B_DIFF, "G Damp:",        160,80,150,20, &sb->goalfrict  , 0.0, 50.0, 10, 0, "Goal (vertex target position) friction");
-                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "G Min:",              10,60,150,20, &sb->mingoal, 0.0, 1.0, 10, 0, "Goal minimum, vertex group weights are scaled to match this range");
-                               uiDefButF(block, NUM, B_SOFTBODY_CHANGE, "G Max:",              160,60,150,20, &sb->maxgoal, 0.0, 1.0, 10, 0, "Goal maximum, vertex group weights are scaled to match this range");
-                               uiBlockEndAlign(block);
+                       butx=160;
 
-                               /* EDGE SPRING STUFF */
-                               if(ob->type!=OB_SURF) {
-                                       uiBlockBeginAlign(block);
-                                       uiDefButBitS(block, TOG, OB_SB_EDGES, B_SOFTBODY_CHANGE, "Use Edges",           10,30,90,20, &ob->softflag, 0, 0, 0, 0, "Use Edges as springs");
-                                       uiDefButBitS(block, TOG, OB_SB_QUADS, B_SOFTBODY_CHANGE, "Stiff Quads",         110,30,90,20, &ob->softflag, 0, 0, 0, 0, "Adds diagonal springs on 4-gons");
-                                       /* uiDefButBitS(block, TOG, OB_SB_SELF, B_DIFF, "Self Collision",               220,30,90,20, &ob->softflag, 0, 0, 0, 0, ""); */
-                                       uiDefButF(block, NUM, B_DIFF, "E Stiff:",       10,10,150,20, &sb->inspring, 0.0,  0.999, 10, 0, "Edge spring stiffness");
-                                       uiDefButF(block, NUM, B_DIFF, "E Damp:",        160,10,150,20, &sb->infrict, 0.0,  50.0, 10, 0, "Edge spring friction");
-                                       uiBlockEndAlign(block);
-                               }
-                       }
+                       if(psys->flag & PSYS_FIRST_KEYED)
+                               uiDefButBitI(block, TOG, PSYS_KEYED_TIME, B_PART_RECALC, "Timed",        butx,buty,butw,buth, &psys->flag, 0, 0, 0, 0, "Use intermediate key times");
+                       else
+                               uiDefButF(block, NUMSLI, B_PART_RECALC, "Time:",                butx,buty,butw,buth, &part->keyed_time, 0.0, 1.0, 1, 3, "Keyed key time relative to remaining particle life");
                }
        }
-       uiBlockEndAlign(block);
-
 }
 
-static void object_panel_particles_motion(Object *ob)
+static void psys_clear_cache(void *ob_v, void *psys_v)
+{
+       clear_particles_from_cache((Object *)ob_v, (ParticleSystem *)psys_v, CFRA);
+}
+static void object_panel_particle_system(Object *ob)
 {
        uiBlock *block;
        uiBut *but;
-       PartEff *paf= give_parteff(ob);
-
-       if (paf==NULL) return;
-               
-       block= uiNewBlock(&curarea->uiblocks, "object_panel_particles_motion", UI_EMBOSS, UI_HELV, curarea->win);
-       uiNewPanelTabbed("Particles ", "Physics");
-       if(uiNewPanel(curarea, block, "Particle Motion", "Physics", 320, 0, 318, 204)==0) return;
+       ParticleSystem *psys=NULL;
+       ParticleSettings *part;
+       ID *id, *idfrom;
+       short butx=0, buty=160, butw=150, buth=20;
+       char str[30];
+       static short partact;
+       short totpart;
+
+       block= uiNewBlock(&curarea->uiblocks, "object_panel_particle_system", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Particle System", "Particle", 0, 0, 318, 204)==0) return;
        
        if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
-       
-       /* top row */
-       uiBlockBeginAlign(block);
-       uiDefButI(block, NUM, B_CALCEFFECT, "Keys:",    0,180,75,20, &paf->totkey, 1.0, 100.0, 0, 0, "Specify the number of key positions");
-       uiDefButBitS(block, TOG, PAF_BSPLINE, B_CALCEFFECT, "Bspline",  75,180,75,20, &paf->flag, 0, 0, 0, 0, "Use B spline formula for particle interpolation");
-       uiDefButI(block, NUM, B_CALCEFFECT, "Seed:",    150,180,75,20, &paf->seed, 0.0, 255.0, 0, 0, "Set an offset in the random table");
-       uiDefButF(block, NUM, B_CALCEFFECT, "RLife:",   225,180,85,20, &paf->randlife, 0.0, 2.0, 10, 1, "Give the particlelife a random variation");
-       uiBlockEndAlign(block);
-       
-       /* left collumn */
-       uiDefBut(block, LABEL, 0, "Velocity:",                  0,160,150,20, NULL, 0.0, 0, 0, 0, "");
-       uiBlockBeginAlign(block);
+
+       if(ELEM4(ob->type,OB_MESH,OB_FONT,OB_CURVE,OB_SURF)==0) {
+               uiDefBut(block, LABEL, 0, "Only Mesh or Curve Objects can generate particles", 10,180,300,20, NULL, 0.0, 0, 0, 0, "");
+               return;
+       }
+       psys=psys_get_current(ob);
+
+       if(psys)
+               id=(ID*)(psys->part);
+       else
+               id=NULL;
+       idfrom=&ob->id;
+
+       /* browse buttons */
        uiBlockSetCol(block, TH_BUT_SETTING2);
-       uiDefButF(block, NUM, B_CALCEFFECT, "Normal:",          0,140,150,18, &paf->normfac, -2.0, 2.0, 1, 3, "Let the mesh give the particle a starting speed");
-       uiDefButF(block, NUM, B_CALCEFFECT, "Object:",          0,122,150,18, &paf->obfac, -1.0, 1.0, 1, 3, "Let the object give the particle a starting speed");
-       uiDefButF(block, NUM, B_CALCEFFECT, "Random:",          0,104,150,18, &paf->randfac, 0.0, 2.0, 1, 3, "Give the startingspeed a random variation");
-       uiDefButF(block, NUM, B_CALCEFFECT, "Texture:",         0,86,150,18, &paf->texfac, 0.0, 2.0, 1, 3, "Let the texture give