source/blender/editors/space_view3d/view3d_buttons.c

   1 /**
   2  * $Id:
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2009 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  *
  24  * Contributor(s): Blender Foundation
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <math.h>
  32 #include <float.h>
  33
  34 #include "DNA_ID.h"
  35 #include "DNA_action_types.h"
  36 #include "DNA_armature_types.h"
  37 #include "DNA_curve_types.h"
  38 #include "DNA_camera_types.h"
  39 #include "DNA_lamp_types.h"
  40 #include "DNA_lattice_types.h"
  41 #include "DNA_meta_types.h"
  42 #include "DNA_mesh_types.h"
  43 #include "DNA_meshdata_types.h"
  44 #include "DNA_object_types.h"
  45 #include "DNA_space_types.h"
  46 #include "DNA_scene_types.h"
  47 #include "DNA_screen_types.h"
  48 #include "DNA_userdef_types.h"
  49 #include "DNA_view3d_types.h"
  50 #include "DNA_world_types.h"
  51
  52 #include "MEM_guardedalloc.h"
  53
  54 #include "BLI_arithb.h"
  55 #include "BLI_blenlib.h"
  56 #include "BLI_editVert.h"
  57 #include "BLI_rand.h"
  58
  59 #include "BKE_action.h"
  60 #include "BKE_brush.h"
  61 #include "BKE_context.h"
  62 #include "BKE_curve.h"
  63 #include "BKE_customdata.h"
  64 #include "BKE_depsgraph.h"
  65 #include "BKE_idprop.h"
  66 #include "BKE_mesh.h"
  67 #include "BKE_object.h"
  68 #include "BKE_global.h"
  69 #include "BKE_scene.h"
  70 #include "BKE_screen.h"
  71 #include "BKE_utildefines.h"
  72
  73 #include "BIF_gl.h"
  74
  75 #include "WM_api.h"
  76 #include "WM_types.h"
  77
  78 #include "RNA_access.h"
  79 #include "RNA_define.h"
  80
  81 #include "ED_armature.h"
  82 #include "ED_curve.h"
  83 #include "ED_image.h"
  84 #include "ED_keyframing.h"
  85 #include "ED_mesh.h"
  86 #include "ED_object.h"
  87 #include "ED_particle.h"
  88 #include "ED_screen.h"
  89 #include "ED_transform.h"
  90 #include "ED_types.h"
  91 #include "ED_util.h"
  92
  93 #include "UI_interface.h"
  94 #include "UI_resources.h"
  95 #include "UI_view2d.h"
  96
  97 #include "view3d_intern.h"      // own include
  98
  99
 100 /* ******************* view3d space & buttons ************** */
 101 #define B_NOP           1
 102 #define B_REDR          2
 103 #define B_OBJECTPANELROT        1007
 104 #define B_OBJECTPANELMEDIAN 1008
 105 #define B_ARMATUREPANEL1        1009
 106 #define B_ARMATUREPANEL2        1010
 107 #define B_OBJECTPANELPARENT 1011
 108 #define B_OBJECTPANEL           1012
 109 #define B_ARMATUREPANEL3        1013
 110 #define B_OBJECTPANELSCALE      1014
 111 #define B_OBJECTPANELDIMS       1015
 112 #define B_TRANSFORMSPACEADD     1016
 113 #define B_TRANSFORMSPACECLEAR   1017
 114 #define B_SETPT_AUTO    2125
 115 #define B_SETPT_VECTOR  2126
 116 #define B_SETPT_ALIGN   2127
 117 #define B_SETPT_FREE    2128
 118 #define B_RECALCMBALL   2501
 119
 120 #define B_WEIGHT0_0             2840
 121 #define B_WEIGHT1_4             2841
 122 #define B_WEIGHT1_2             2842
 123 #define B_WEIGHT3_4             2843
 124 #define B_WEIGHT1_0             2844
 125
 126 #define B_OPA1_8                2845
 127 #define B_OPA1_4                2846
 128 #define B_OPA1_2                2847
 129 #define B_OPA3_4                2848
 130 #define B_OPA1_0                2849
 131
 132 #define B_CLR_WPAINT    2850
 133
 134 #define B_RV3D_LOCKED   2900
 135 #define B_RV3D_BOXVIEW  2901
 136 #define B_RV3D_BOXCLIP  2902
 137
 138 #define B_IDNAME                3000
 139
 140 /* temporary struct for storing transform properties */
 141 typedef struct {
 142         float ob_eul[4];        // used for quat too....
 143         float ob_scale[3]; // need temp space due to linked values
 144         float ob_dims[3];
 145         short link_scale;
 146         float ve_median[5];
 147         int curdef;
 148         float *defweightp;
 149 } TransformProperties;
 150
 151
 152 /* is used for both read and write... */
 153 static void v3d_editvertex_buts(const bContext *C, uiBlock *block, View3D *v3d, Object *ob, float lim)
 154 {
 155         MDeformVert *dvert=NULL;
 156         TransformProperties *tfp= v3d->properties_storage;
 157         float median[5], ve_median[5];
 158         int tot, totw, totweight, totedge;
 159         char defstr[320];
 160
 161         median[0]= median[1]= median[2]= median[3]= median[4]= 0.0;
 162         tot= totw= totweight= totedge= 0;
 163         defstr[0]= 0;
 164
 165         if(ob->type==OB_MESH) {
 166                 Mesh *me= ob->data;
 167                 EditMesh *em = BKE_mesh_get_editmesh(me);
 168                 EditVert *eve, *evedef=NULL;
 169                 EditEdge *eed;
 170
 171                 eve= em->verts.first;
 172                 while(eve) {
 173                         if(eve->f & SELECT) {
 174                                 evedef= eve;
 175                                 tot++;
 176                                 VecAddf(median, median, eve->co);
 177                         }
 178                         eve= eve->next;
 179                 }
 180                 eed= em->edges.first;
 181                 while(eed) {
 182                         if((eed->f & SELECT)) {
 183                                 totedge++;
 184                                 median[3]+= eed->crease;
 185                         }
 186                         eed= eed->next;
 187                 }
 188
 189                 /* check for defgroups */
 190                 if(evedef)
 191                         dvert= CustomData_em_get(&em->vdata, evedef->data, CD_MDEFORMVERT);
 192                 if(tot==1 && dvert && dvert->totweight) {
 193                         bDeformGroup *dg;
 194                         int i, max=1, init=1;
 195                         char str[320];
 196
 197                         for (i=0; i<dvert->totweight; i++){
 198                                 dg = BLI_findlink (&ob->defbase, dvert->dw[i].def_nr);
 199                                 if(dg) {
 200                                         max+= BLI_snprintf(str, sizeof(str), "%s %%x%d|", dg->name, dvert->dw[i].def_nr);
 201                                         if(max<320) strcat(defstr, str);
 202                                 }
 203                                 else printf("oh no!\n");
 204                                 if(tfp->curdef==dvert->dw[i].def_nr) {
 205                                         init= 0;
 206                                         tfp->defweightp= &dvert->dw[i].weight;
 207                                 }
 208                         }
 209
 210                         if(init) {      // needs new initialized
 211                                 tfp->curdef= dvert->dw[0].def_nr;
 212                                 tfp->defweightp= &dvert->dw[0].weight;
 213                         }
 214                 }
 215
 216                 BKE_mesh_end_editmesh(me, em);
 217         }
 218         else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
 219                 Curve *cu= ob->data;
 220                 Nurb *nu;
 221                 BPoint *bp;
 222                 BezTriple *bezt;
 223                 int a;
 224
 225                 nu= cu->editnurb->first;
 226                 while(nu) {
 227                         if((nu->type & 7)==CU_BEZIER) {
 228                                 bezt= nu->bezt;
 229                                 a= nu->pntsu;
 230                                 while(a--) {
 231                                         if(bezt->f2 & SELECT) {
 232                                                 VecAddf(median, median, bezt->vec[1]);
 233                                                 tot++;
 234                                                 median[4]+= bezt->weight;
 235                                                 totweight++;
 236                                         }
 237                                         else {
 238                                                 if(bezt->f1 & SELECT) {
 239                                                         VecAddf(median, median, bezt->vec[0]);
 240                                                         tot++;
 241                                                 }
 242                                                 if(bezt->f3 & SELECT) {
 243                                                         VecAddf(median, median, bezt->vec[2]);
 244                                                         tot++;
 245                                                 }
 246                                         }
 247                                         bezt++;
 248                                 }
 249                         }
 250                         else {
 251                                 bp= nu->bp;
 252                                 a= nu->pntsu*nu->pntsv;
 253                                 while(a--) {
 254                                         if(bp->f1 & SELECT) {
 255                                                 VecAddf(median, median, bp->vec);
 256                                                 median[3]+= bp->vec[3];
 257                                                 totw++;
 258                                                 tot++;
 259                                                 median[4]+= bp->weight;
 260                                                 totweight++;
 261                                         }
 262                                         bp++;
 263                                 }
 264                         }
 265                         nu= nu->next;
 266                 }
 267         }
 268         else if(ob->type==OB_LATTICE) {
 269                 Lattice *lt= ob->data;
 270                 BPoint *bp;
 271                 int a;
 272
 273                 a= lt->editlatt->pntsu*lt->editlatt->pntsv*lt->editlatt->pntsw;
 274                 bp= lt->editlatt->def;
 275                 while(a--) {
 276                         if(bp->f1 & SELECT) {
 277                                 VecAddf(median, median, bp->vec);
 278                                 tot++;
 279                                 median[4]+= bp->weight;
 280                                 totweight++;
 281                         }
 282                         bp++;
 283                 }
 284         }
 285
 286         if(tot==0) return;
 287
 288         median[0] /= (float)tot;
 289         median[1] /= (float)tot;
 290         median[2] /= (float)tot;
 291         if(totedge) median[3] /= (float)totedge;
 292         else if(totw) median[3] /= (float)totw;
 293         if(totweight) median[4] /= (float)totweight;
 294
 295         if(v3d->flag & V3D_GLOBAL_STATS)
 296                 Mat4MulVecfl(ob->obmat, median);
 297
 298         if(block) {     // buttons
 299                 int but_y;
 300                 if((ob->parent) && (ob->partype == PARBONE))    but_y = 135;
 301                 else                                                                                    but_y = 150;
 302
 303                 uiBlockBeginAlign(block);
 304                 uiDefButBitS(block, TOG, V3D_GLOBAL_STATS, B_REDR, "Global",            0, 20, 100, 20, &v3d->flag, 0, 0, 0, 0, "Displays global values");
 305                 uiDefButBitS(block, TOGN, V3D_GLOBAL_STATS, B_REDR, "Local",            100, 20, 100, 20, &v3d->flag, 0, 0, 0, 0, "Displays local values");
 306                 uiBlockEndAlign(block);
 307
 308                 memcpy(tfp->ve_median, median, sizeof(tfp->ve_median));
 309
 310                 uiBlockBeginAlign(block);
 311                 if(tot==1) {
 312                         uiDefBut(block, LABEL, 0, "Vertex:",                                    0, 130, 200, 20, 0, 0, 0, 0, 0, "");
 313                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "X:",                0, 110, 200, 20, &(tfp->ve_median[0]), -lim, lim, 10, 3, "");
 314                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Y:",                0, 90, 200, 20, &(tfp->ve_median[1]), -lim, lim, 10, 3, "");
 315                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Z:",                0, 70, 200, 20, &(tfp->ve_median[2]), -lim, lim, 10, 3, "");
 316                         if(totw==1)
 317                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex W:", 0, 50, 200, 19, &(tfp->ve_median[3]), 0.01, 100.0, 10, 3, "");
 318                         uiBlockEndAlign(block);
 319
 320                         if(defstr[0]) {
 321                                 uiDefBut(block, LABEL, 1, "Vertex Deform Groups",               0, 40, 200, 20, NULL, 0.0, 0.0, 0, 0, "");
 322
 323                                 uiBlockBeginAlign(block);
 324                                 uiDefButF(block, NUM, B_NOP, "Weight:",                                 10, 20, 150, 20, tfp->defweightp, 0.0f, 1.0f, 10, 3, "Weight value");
 325                                 uiDefButI(block, MENU, B_REDR, defstr,                                  160, 20, 140, 20, &tfp->curdef, 0.0, 0.0, 0, 0, "Current Vertex Group");
 326                                 uiBlockEndAlign(block);
 327                         }
 328                         else if(totweight)
 329                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   0, 20, 200, 20, &(tfp->ve_median[4]), 0.0, 1.0, 10, 3, "");
 330
 331                 }
 332                 else {
 333                         uiDefBut(block, LABEL, 0, "Median:",                                            0, 130, 200, 20, 0, 0, 0, 0, 0, "");
 334                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "X:",                0, 110, 200, 20, &(tfp->ve_median[0]), -lim, lim, 10, 3, "");
 335                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Y:",                0, 90, 200, 20, &(tfp->ve_median[1]), -lim, lim, 10, 3, "");
 336                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Z:",                0, 70, 200, 20, &(tfp->ve_median[2]), -lim, lim, 10, 3, "");
 337                         if(totw==tot)
 338                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "W:",        0, 50, 200, 20, &(tfp->ve_median[3]), 0.01, 100.0, 10, 3, "");
 339                         uiBlockEndAlign(block);
 340                         if(totweight)
 341                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   0, 20, 200, 20, &(tfp->ve_median[4]), 0.0, 1.0, 10, 3, "Weight is used for SoftBody Goal");
 342                 }
 343
 344                 if(ob->type==OB_CURVE && (totw==0)) { /* bez curves have no w */
 345                         uiBlockBeginAlign(block);
 346                         uiDefBut(block, BUT,B_SETPT_AUTO,"Auto",        10, 44, 72, 19, 0, 0, 0, 0, 0, "Auto handles (Shift H)");
 347                         uiDefBut(block, BUT,B_SETPT_VECTOR,"Vector",82, 44, 73, 19, 0, 0, 0, 0, 0, "Vector handles (V)");
 348                         uiDefBut(block, BUT,B_SETPT_ALIGN,"Align",155, 44, 73, 19, 0, 0, 0, 0, 0, "Align handles (H Toggles)");
 349                         uiDefBut(block, BUT,B_SETPT_FREE,"Free",        227, 44, 72, 19, 0, 0, 0, 0, 0, "Align handles (H Toggles)");
 350                         uiBlockEndAlign(block);
 351                 }
 352
 353                 if(totedge==1)
 354                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Crease W:", 0, 45, 200, 20, &(tfp->ve_median[3]), 0.0, 1.0, 10, 3, "");
 355                 else if(totedge>1)
 356                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Crease W:",  0, 45, 200, 20, &(tfp->ve_median[3]), 0.0, 1.0, 10, 3, "");
 357
 358         }
 359         else {  // apply
 360                 memcpy(ve_median, tfp->ve_median, sizeof(tfp->ve_median));
 361
 362                 if(v3d->flag & V3D_GLOBAL_STATS) {
 363                         Mat4Invert(ob->imat, ob->obmat);
 364                         Mat4MulVecfl(ob->imat, median);
 365                         Mat4MulVecfl(ob->imat, ve_median);
 366                 }
 367                 VecSubf(median, ve_median, median);
 368                 median[3]= ve_median[3]-median[3];
 369                 median[4]= ve_median[4]-median[4];
 370
 371                 if(ob->type==OB_MESH) {
 372                         Mesh *me= ob->data;
 373                         EditMesh *em = BKE_mesh_get_editmesh(me);
 374                         EditVert *eve;
 375                         EditEdge *eed;
 376
 377                         eve= em->verts.first;
 378                         while(eve) {
 379                                 if(eve->f & SELECT) {
 380                                         VecAddf(eve->co, eve->co, median);
 381                                 }
 382                                 eve= eve->next;
 383                         }
 384
 385                         for(eed= em->edges.first; eed; eed= eed->next) {
 386                                 if(eed->f & SELECT) {
 387                                         /* ensure the median can be set to zero or one */
 388                                         if(ve_median[3]==0.0f) eed->crease= 0.0f;
 389                                         else if(ve_median[3]==1.0f) eed->crease= 1.0f;
 390                                         else {
 391                                                 eed->crease+= median[3];
 392                                                 CLAMP(eed->crease, 0.0, 1.0);
 393                                         }
 394                                 }
 395                         }
 396
 397                         recalc_editnormals(em);
 398
 399                         BKE_mesh_end_editmesh(me, em);
 400                 }
 401                 else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
 402                         Curve *cu= ob->data;
 403                         Nurb *nu;
 404                         BPoint *bp;
 405                         BezTriple *bezt;
 406                         int a;
 407
 408                         nu= cu->editnurb->first;
 409                         while(nu) {
 410                                 if((nu->type & 7)==CU_BEZIER) {
 411                                         bezt= nu->bezt;
 412                                         a= nu->pntsu;
 413                                         while(a--) {
 414                                                 if(bezt->f2 & SELECT) {
 415                                                         VecAddf(bezt->vec[0], bezt->vec[0], median);
 416                                                         VecAddf(bezt->vec[1], bezt->vec[1], median);
 417                                                         VecAddf(bezt->vec[2], bezt->vec[2], median);
 418                                                         bezt->weight+= median[4];
 419                                                 }
 420                                                 else {
 421                                                         if(bezt->f1 & SELECT) {
 422                                                                 VecAddf(bezt->vec[0], bezt->vec[0], median);
 423                                                         }
 424                                                         if(bezt->f3 & SELECT) {
 425                                                                 VecAddf(bezt->vec[2], bezt->vec[2], median);
 426                                                         }
 427                                                 }
 428                                                 bezt++;
 429                                         }
 430                                 }
 431                                 else {
 432                                         bp= nu->bp;
 433                                         a= nu->pntsu*nu->pntsv;
 434                                         while(a--) {
 435                                                 if(bp->f1 & SELECT) {
 436                                                         VecAddf(bp->vec, bp->vec, median);
 437                                                         bp->vec[3]+= median[3];
 438                                                         bp->weight+= median[4];
 439                                                 }
 440                                                 bp++;
 441                                         }
 442                                 }
 443                                 test2DNurb(nu);
 444                                 testhandlesNurb(nu); /* test for bezier too */
 445
 446                                 nu= nu->next;
 447                         }
 448                 }
 449                 else if(ob->type==OB_LATTICE) {
 450                         Lattice *lt= ob->data;
 451                         BPoint *bp;
 452                         int a;
 453
 454                         a= lt->editlatt->pntsu*lt->editlatt->pntsv*lt->editlatt->pntsw;
 455                         bp= lt->editlatt->def;
 456                         while(a--) {
 457                                 if(bp->f1 & SELECT) {
 458                                         VecAddf(bp->vec, bp->vec, median);
 459                                         bp->weight+= median[4];
 460                                 }
 461                                 bp++;
 462                         }
 463                 }
 464
 465 //              ED_undo_push(C, "Transform properties");
 466         }
 467 }
 468
 469 /* assumes armature active */
 470 static void validate_bonebutton_cb(bContext *C, void *bonev, void *namev)
 471 {
 472         Object *ob= CTX_data_active_object(C);
 473
 474         if(ob && ob->type==OB_ARMATURE) {
 475                 Bone *bone= bonev;
 476                 char oldname[32], newname[32];
 477
 478                 /* need to be on the stack */
 479                 BLI_strncpy(newname, bone->name, 32);
 480                 BLI_strncpy(oldname, (char *)namev, 32);
 481                 /* restore */
 482                 BLI_strncpy(bone->name, oldname, 32);
 483
 484                 ED_armature_bone_rename(ob->data, oldname, newname); // editarmature.c
 485         }
 486 }
 487
 488 static void v3d_posearmature_buts(uiBlock *block, View3D *v3d, Object *ob, float lim)
 489 {
 490         uiBut *but;
 491         bArmature *arm;
 492         bPoseChannel *pchan;
 493         Bone *bone= NULL;
 494         TransformProperties *tfp= v3d->properties_storage;
 495
 496         arm = ob->data;
 497         if (!arm || !ob->pose) return;
 498
 499         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
 500                 bone = pchan->bone;
 501                 if(bone && (bone->flag & BONE_ACTIVE) && (bone->layer & arm->layer))
 502                         break;
 503         }
 504         if (!pchan || !bone) return;
 505
 506         if((ob->parent) && (ob->partype == PARBONE))
 507                 but= uiDefBut (block, TEX, B_NOP, "Bone:",                              160, 130, 140, 19, bone->name, 1, 31, 0, 0, "");
 508         else
 509                 but= uiDefBut(block, TEX, B_NOP, "Bone:",                               160, 140, 140, 19, bone->name, 1, 31, 0, 0, "");
 510         uiButSetFunc(but, validate_bonebutton_cb, bone, NULL);
 511         uiButSetCompleteFunc(but, autocomplete_bone, (void *)ob);
 512
 513         QuatToEul(pchan->quat, tfp->ob_eul);
 514         tfp->ob_eul[0]*= 180.0/M_PI;
 515         tfp->ob_eul[1]*= 180.0/M_PI;
 516         tfp->ob_eul[2]*= 180.0/M_PI;
 517
 518         uiBlockBeginAlign(block);
 519         uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCX, B_REDR, ICON_UNLOCKED,   10,140,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 520         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocX:",        30, 140, 120, 19, pchan->loc, -lim, lim, 100, 3, "");
 521         uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCY, B_REDR, ICON_UNLOCKED,   10,120,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 522         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocY:",        30, 120, 120, 19, pchan->loc+1, -lim, lim, 100, 3, "");
 523         uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCZ, B_REDR, ICON_UNLOCKED,   10,100,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 524         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocZ:",        30, 100, 120, 19, pchan->loc+2, -lim, lim, 100, 3, "");
 525
 526         uiBlockBeginAlign(block);
 527         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTX, B_REDR, ICON_UNLOCKED,   10,70,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 528         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotX:",        30, 70, 120, 19, tfp->ob_eul, -1000.0, 1000.0, 100, 3, "");
 529         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTY, B_REDR, ICON_UNLOCKED,   10,50,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 530         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotY:",        30, 50, 120, 19, tfp->ob_eul+1, -1000.0, 1000.0, 100, 3, "");
 531         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTZ, B_REDR, ICON_UNLOCKED,   10,30,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 532         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotZ:",        30, 30, 120, 19, tfp->ob_eul+2, -1000.0, 1000.0, 100, 3, "");
 533
 534         uiBlockBeginAlign(block);
 535         uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEX, B_REDR, ICON_UNLOCKED, 160,70,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 536         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleX:",      180, 70, 120, 19, pchan->size, -lim, lim, 10, 3, "");
 537         uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEY, B_REDR, ICON_UNLOCKED, 160,50,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 538         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleY:",      180, 50, 120, 19, pchan->size+1, -lim, lim, 10, 3, "");
 539         uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEZ, B_REDR, ICON_UNLOCKED, 160,30,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
 540         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleZ:",      180, 30, 120, 19, pchan->size+2, -lim, lim, 10, 3, "");
 541         uiBlockEndAlign(block);
 542 }
 543
 544 /* assumes armature editmode */
 545 void validate_editbonebutton_cb(bContext *C, void *bonev, void *namev)
 546 {
 547         EditBone *eBone= bonev;
 548         char oldname[32], newname[32];
 549
 550         /* need to be on the stack */
 551         BLI_strncpy(newname, eBone->name, 32);
 552         BLI_strncpy(oldname, (char *)namev, 32);
 553         /* restore */
 554         BLI_strncpy(eBone->name, oldname, 32);
 555
 556         ED_armature_bone_rename(CTX_data_edit_object(C)->data, oldname, newname); // editarmature.c
 557         WM_event_add_notifier(C, NC_OBJECT|ND_BONE_SELECT, CTX_data_edit_object(C)); // XXX fix
 558 }
 559
 560 static void v3d_editarmature_buts(uiBlock *block, View3D *v3d, Object *ob, float lim)
 561 {
 562         bArmature *arm= ob->data;
 563         EditBone *ebone;
 564         uiBut *but;
 565         TransformProperties *tfp= v3d->properties_storage;
 566
 567         ebone= arm->edbo->first;
 568
 569         for (ebone = arm->edbo->first; ebone; ebone=ebone->next){
 570                 if ((ebone->flag & BONE_ACTIVE) && (ebone->layer & arm->layer))
 571                         break;
 572         }
 573
 574         if (!ebone)
 575                 return;
 576
 577         if((ob->parent) && (ob->partype == PARBONE))
 578                 but= uiDefBut(block, TEX, B_NOP, "Bone:", 160, 130, 140, 19, ebone->name, 1, 31, 0, 0, "");
 579         else
 580                 but= uiDefBut(block, TEX, B_NOP, "Bone:",                       160, 150, 140, 19, ebone->name, 1, 31, 0, 0, "");
 581         uiButSetFunc(but, validate_editbonebutton_cb, ebone, NULL);
 582
 583         uiBlockBeginAlign(block);
 584         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadX:",       10, 70, 140, 19, ebone->head, -lim, lim, 10, 3, "");
 585         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadY:",       10, 50, 140, 19, ebone->head+1, -lim, lim, 10, 3, "");
 586         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadZ:",       10, 30, 140, 19, ebone->head+2, -lim, lim, 10, 3, "");
 587         uiBlockBeginAlign(block);
 588         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailX:",       160, 70, 140, 19, ebone->tail, -lim, lim, 10, 3, "");
 589         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailY:",       160, 50, 140, 19, ebone->tail+1, -lim, lim, 10, 3, "");
 590         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailZ:",       160, 30, 140, 19, ebone->tail+2, -lim, lim, 10, 3, "");
 591         uiBlockEndAlign(block);
 592
 593         tfp->ob_eul[0]= 180.0*ebone->roll/M_PI;
 594         uiDefButF(block, NUM, B_ARMATUREPANEL1, "Roll:",        10, 100, 140, 19, tfp->ob_eul, -lim, lim, 1000, 3, "");
 595
 596         uiDefButBitI(block, TOG, BONE_EDITMODE_LOCKED, B_REDR, "Lock", 160, 100, 140, 19, &(ebone->flag), 0, 0, 0, 0, "Prevents bone from being transformed in edit mode");
 597
 598         uiBlockBeginAlign(block);
 599         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailRadius:",  10, 150, 140, 19, &ebone->rad_tail, 0, lim, 10, 3, "");
 600         if (ebone->parent && ebone->flag & BONE_CONNECTED )
 601                 uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadRadius:",  10, 130, 140, 19, &ebone->parent->rad_tail, 0, lim, 10, 3, "");
 602         else
 603                 uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadRadius:",  10, 130, 140, 19, &ebone->rad_head, 0, lim, 10, 3, "");
 604         uiBlockEndAlign(block);
 605 }
 606
 607 static void v3d_editmetaball_buts(uiBlock *block, Object *ob, float lim)
 608 {
 609         MetaElem *lastelem= NULL; // XXX
 610
 611         if(lastelem) {
 612                 uiBlockBeginAlign(block);
 613                 uiDefButF(block, NUM, B_RECALCMBALL, "LocX:", 10, 70, 140, 19, &lastelem->x, -lim, lim, 100, 3, "");
 614                 uiDefButF(block, NUM, B_RECALCMBALL, "LocY:", 10, 50, 140, 19, &lastelem->y, -lim, lim, 100, 3, "");
 615                 uiDefButF(block, NUM, B_RECALCMBALL, "LocZ:", 10, 30, 140, 19, &lastelem->z, -lim, lim, 100, 3, "");
 616
 617                 uiBlockBeginAlign(block);
 618                 if(lastelem->type!=MB_BALL)
 619                         uiDefButF(block, NUM, B_RECALCMBALL, "dx:", 160, 70, 140, 19, &lastelem->expx, 0, lim, 100, 3, "");
 620                 if((lastelem->type!=MB_BALL) && (lastelem->type!=MB_TUBE))
 621                         uiDefButF(block, NUM, B_RECALCMBALL, "dy:", 160, 50, 140, 19, &lastelem->expy, 0, lim, 100, 3, "");
 622                 if((lastelem->type==MB_ELIPSOID) || (lastelem->type==MB_CUBE))
 623                         uiDefButF(block, NUM, B_RECALCMBALL, "dz:", 160, 30, 140, 19, &lastelem->expz, 0, lim, 100, 3, "");
 624
 625                 uiBlockEndAlign(block);
 626
 627                 uiBlockBeginAlign(block);
 628                 uiDefButF(block, NUM, B_RECALCMBALL, "Radius:", 10, 120, 140, 19, &lastelem->rad, 0, lim, 100, 3, "Size of the active metaball");
 629                 uiDefButF(block, NUM, B_RECALCMBALL, "Stiffness:", 10, 100, 140, 19, &lastelem->s, 0, 10, 100, 3, "Stiffness of the active metaball");
 630                 uiBlockEndAlign(block);
 631
 632                 uiDefButS(block, MENU, B_RECALCMBALL, "Type%t|Ball%x0|Tube%x4|Plane%x5|Elipsoid%x6|Cube%x7", 160, 120, 140, 19, &lastelem->type, 0.0, 0.0, 0, 0, "Set active element type");
 633
 634         }
 635 }
 636
 637 /* test if 'ob' is a parent somewhere in par's parents */
 638 static int test_parent_loop(Object *par, Object *ob)
 639 {
 640         if(par == NULL) return 0;
 641         if(ob == par) return 1;
 642         return test_parent_loop(par->parent, ob);
 643 }
 644
 645 static void do_view3d_region_buttons(bContext *C, void *arg, int event)
 646 {
 647         Scene *scene= CTX_data_scene(C);
 648         Object *obedit= CTX_data_edit_object(C);
 649         View3D *v3d= CTX_wm_view3d(C);
 650         BoundBox *bb;
 651         Object *ob= OBACT;
 652         TransformProperties *tfp= v3d->properties_storage;
 653
 654         switch(event) {
 655
 656         case B_REDR:
 657                 ED_area_tag_redraw(CTX_wm_area(C));
 658                 return; /* no notifier! */
 659
 660         case B_OBJECTPANEL:
 661                 DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 662                 break;
 663
 664         case B_OBJECTPANELROT:
 665                 if(ob) {
 666                         ob->rot[0]= M_PI*tfp->ob_eul[0]/180.0;
 667                         ob->rot[1]= M_PI*tfp->ob_eul[1]/180.0;
 668                         ob->rot[2]= M_PI*tfp->ob_eul[2]/180.0;
 669                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 670                 }
 671                 break;
 672
 673         case B_OBJECTPANELSCALE:
 674                 if(ob) {
 675
 676                         /* link scale; figure out which axis changed */
 677                         if (tfp->link_scale) {
 678                                 float ratio, tmp, max = 0.0;
 679                                 int axis;
 680
 681                                 axis = 0;
 682                                 max = fabs(tfp->ob_scale[0] - ob->size[0]);
 683                                 tmp = fabs(tfp->ob_scale[1] - ob->size[1]);
 684                                 if (tmp > max) {
 685                                         axis = 1;
 686                                         max = tmp;
 687                                 }
 688                                 tmp = fabs(tfp->ob_scale[2] - ob->size[2]);
 689                                 if (tmp > max) {
 690                                         axis = 2;
 691                                         max = tmp;
 692                                 }
 693
 694                                 if (ob->size[axis] != tfp->ob_scale[axis]) {
 695                                         if (fabs(ob->size[axis]) > FLT_EPSILON) {
 696                                                 ratio = tfp->ob_scale[axis] / ob->size[axis];
 697                                                 ob->size[0] *= ratio;
 698                                                 ob->size[1] *= ratio;
 699                                                 ob->size[2] *= ratio;
 700                                         }
 701                                 }
 702                         }
 703                         else {
 704                                 VECCOPY(ob->size, tfp->ob_scale);
 705
 706                         }
 707                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 708                 }
 709                 break;
 710
 711         case B_OBJECTPANELDIMS:
 712                 bb= object_get_boundbox(ob);
 713                 if(bb) {
 714                         float old_dims[3], scale[3], ratio, len[3];
 715                         int axis;
 716
 717                         Mat4ToSize(ob->obmat, scale);
 718
 719                         len[0] = bb->vec[4][0] - bb->vec[0][0];
 720                         len[1] = bb->vec[2][1] - bb->vec[0][1];
 721                         len[2] = bb->vec[1][2] - bb->vec[0][2];
 722
 723                         old_dims[0] = fabs(scale[0]) * len[0];
 724                         old_dims[1] = fabs(scale[1]) * len[1];
 725                         old_dims[2] = fabs(scale[2]) * len[2];
 726
 727                         /* for each axis changed */
 728                         for (axis = 0; axis<3; axis++) {
 729                                 if (fabs(old_dims[axis] - tfp->ob_dims[axis]) > 0.0001) {
 730                                         if (old_dims[axis] > 0.0) {
 731                                                 ratio = tfp->ob_dims[axis] / old_dims[axis];
 732                                                 if (tfp->link_scale) {
 733                                                         ob->size[0] *= ratio;
 734                                                         ob->size[1] *= ratio;
 735                                                         ob->size[2] *= ratio;
 736                                                         break;
 737                                                 }
 738                                                 else {
 739                                                         ob->size[axis] *= ratio;
 740                                                 }
 741                                         }
 742                                         else {
 743                                                 if (len[axis] > 0) {
 744                                                         ob->size[axis] = tfp->ob_dims[axis] / len[axis];
 745                                                 }
 746                                         }
 747                                 }
 748                         }
 749
 750                         /* prevent multiple B_OBJECTPANELDIMS events to keep scaling, cycling with TAB on buttons can cause that */
 751                         VECCOPY(tfp->ob_dims, old_dims);
 752
 753                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 754                 }
 755                 break;
 756
 757         case B_OBJECTPANELMEDIAN:
 758                 if(ob) {
 759                         v3d_editvertex_buts(C, NULL, v3d, ob, 1.0);
 760                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
 761                 }
 762                 break;
 763
 764                 /* note; this case also used for parbone */
 765         case B_OBJECTPANELPARENT:
 766                 if(ob) {
 767                         if(ob->id.lib || test_parent_loop(ob->parent, ob) )
 768                                 ob->parent= NULL;
 769                         else {
 770                                 DAG_scene_sort(scene);
 771                                 DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 772                         }
 773                 }
 774                 break;
 775
 776         case B_ARMATUREPANEL1:
 777                 {
 778                         bArmature *arm= obedit->data;
 779                         EditBone *ebone, *child;
 780
 781                         for (ebone = arm->edbo->first; ebone; ebone=ebone->next){
 782                                 if ((ebone->flag & BONE_ACTIVE) && (ebone->layer & arm->layer))
 783                                         break;
 784                         }
 785                         if (ebone) {
 786                                 ebone->roll= M_PI*tfp->ob_eul[0]/180.0;
 787                                 //      Update our parent
 788                                 if (ebone->parent && ebone->flag & BONE_CONNECTED){
 789                                         VECCOPY (ebone->parent->tail, ebone->head);
 790                                 }
 791
 792                                 //      Update our children if necessary
 793                                 for (child = arm->edbo->first; child; child=child->next){
 794                                         if (child->parent == ebone && (child->flag & BONE_CONNECTED)){
 795                                                 VECCOPY (child->head, ebone->tail);
 796                                         }
 797                                 }
 798                                 if(arm->flag & ARM_MIRROR_EDIT) {
 799                                         EditBone *eboflip= ED_armature_bone_get_mirrored(arm->edbo, ebone);
 800                                         if(eboflip) {
 801                                                 eboflip->roll= -ebone->roll;
 802                                                 eboflip->head[0]= -ebone->head[0];
 803                                                 eboflip->tail[0]= -ebone->tail[0];
 804
 805                                                 //      Update our parent
 806                                                 if (eboflip->parent && eboflip->flag & BONE_CONNECTED){
 807                                                         VECCOPY (eboflip->parent->tail, eboflip->head);
 808                                                 }
 809
 810                                                 //      Update our children if necessary
 811                                                 for (child = arm->edbo->first; child; child=child->next){
 812                                                         if (child->parent == eboflip && (child->flag & BONE_CONNECTED)){
 813                                                                 VECCOPY (child->head, eboflip->tail);
 814                                                         }
 815                                                 }
 816                                         }
 817                                 }
 818                         }
 819                 }
 820                 break;
 821         case B_ARMATUREPANEL3:  // rotate button on channel
 822                 {
 823                         bArmature *arm;
 824                         bPoseChannel *pchan;
 825                         Bone *bone;
 826                         float eul[3];
 827
 828                         arm = ob->data;
 829                         if (!arm || !ob->pose) return;
 830
 831                         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
 832                                 bone = pchan->bone;
 833                                 if(bone && (bone->flag & BONE_ACTIVE) && (bone->layer & arm->layer))
 834                                         break;
 835                         }
 836                         if (!pchan) return;
 837
 838                         /* make a copy to eul[3], to allow TAB on buttons to work */
 839                         eul[0]= M_PI*tfp->ob_eul[0]/180.0;
 840                         eul[1]= M_PI*tfp->ob_eul[1]/180.0;
 841                         eul[2]= M_PI*tfp->ob_eul[2]/180.0;
 842                         EulToQuat(eul, pchan->quat);
 843                 }
 844                 /* no break, pass on */
 845         case B_ARMATUREPANEL2:
 846                 {
 847                         ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
 848                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
 849                 }
 850                 break;
 851         case B_TRANSFORMSPACEADD:
 852                 BIF_manageTransformOrientation(C, 1, 0);
 853                 break;
 854         case B_TRANSFORMSPACECLEAR:
 855                 BIF_clearTransformOrientation(C);
 856                 break;
 857
 858 #if 0 // XXX
 859         case B_WEIGHT0_0:
 860                 wpaint->weight = 0.0f;
 861                 break;
 862
 863         case B_WEIGHT1_4:
 864                 wpaint->weight = 0.25f;
 865                 break;
 866         case B_WEIGHT1_2:
 867                 wpaint->weight = 0.5f;
 868                 break;
 869         case B_WEIGHT3_4:
 870                 wpaint->weight = 0.75f;
 871                 break;
 872         case B_WEIGHT1_0:
 873                 wpaint->weight = 1.0f;
 874                 break;
 875
 876         case B_OPA1_8:
 877                 wpaint->a = 0.125f;
 878                 break;
 879         case B_OPA1_4:
 880                 wpaint->a = 0.25f;
 881                 break;
 882         case B_OPA1_2:
 883                 wpaint->a = 0.5f;
 884                 break;
 885         case B_OPA3_4:
 886                 wpaint->a = 0.75f;
 887                 break;
 888         case B_OPA1_0:
 889                 wpaint->a = 1.0f;
 890                 break;
 891 #endif
 892         case B_CLR_WPAINT:
 893 //              if(!multires_level1_test()) {
 894                 {
 895                         bDeformGroup *defGroup = BLI_findlink(&ob->defbase, ob->actdef-1);
 896                         if(defGroup) {
 897                                 Mesh *me= ob->data;
 898                                 int a;
 899                                 for(a=0; a<me->totvert; a++)
 900                                         remove_vert_defgroup (ob, defGroup, a);
 901                                 DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
 902                         }
 903                 }
 904                 break;
 905         case B_RV3D_LOCKED:
 906         case B_RV3D_BOXVIEW:
 907         case B_RV3D_BOXCLIP:
 908                 {
 909                         ScrArea *sa= CTX_wm_area(C);
 910                         ARegion *ar= sa->regionbase.last;
 911                         RegionView3D *rv3d;
 912                         short viewlock;
 913
 914                         ar= ar->prev;
 915                         rv3d= ar->regiondata;
 916                         viewlock= rv3d->viewlock;
 917
 918                         if((viewlock & RV3D_LOCKED)==0)
 919                                 viewlock= 0;
 920                         else if((viewlock & RV3D_BOXVIEW)==0)
 921                                 viewlock &= ~RV3D_BOXCLIP;
 922
 923                         for(; ar; ar= ar->prev) {
 924                                 if(ar->alignment==RGN_ALIGN_QSPLIT) {
 925                                         rv3d= ar->regiondata;
 926                                         rv3d->viewlock= viewlock;
 927                                 }
 928                         }
 929
 930                         if(rv3d->viewlock & RV3D_BOXVIEW)
 931                                 view3d_boxview_copy(sa, sa->regionbase.last);
 932
 933                         ED_area_tag_redraw(sa);
 934                 }
 935                 break;
 936         }
 937
 938         /* default for now */
 939         WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, ob);
 940 }
 941
 942 void removeTransformOrientation_func(bContext *C, void *target, void *unused)
 943 {
 944         BIF_removeTransformOrientation(C, (TransformOrientation *) target);
 945 }
 946
 947 void selectTransformOrientation_func(bContext *C, void *target, void *unused)
 948 {
 949         BIF_selectTransformOrientation(C, (TransformOrientation *) target);
 950 }
 951
 952 #if 0 // XXX not used
 953 static void view3d_panel_transform_spaces(const bContext *C, Panel *pa)
 954 {
 955         Scene *scene= CTX_data_scene(C);
 956         Object *obedit= CTX_data_edit_object(C);
 957         View3D *v3d= CTX_wm_view3d(C);
 958         ListBase *transform_spaces = &scene->transform_spaces;
 959         TransformOrientation *ts = transform_spaces->first;
 960         uiBlock *block;
 961         uiBut *but;
 962         int xco = 20, yco = 70;
 963         int index;
 964
 965         block= uiLayoutFreeBlock(pa->layout);
 966
 967         uiBlockBeginAlign(block);
 968
 969         if (obedit)
 970                 uiDefBut(block, BUT, B_TRANSFORMSPACEADD, "Add", xco,120,80,20, 0, 0, 0, 0, 0, "Add the selected element as a Transform Orientation");
 971         else
 972                 uiDefBut(block, BUT, B_TRANSFORMSPACEADD, "Add", xco,120,80,20, 0, 0, 0, 0, 0, "Add the active object as a Transform Orientation");
 973
 974         uiDefBut(block, BUT, B_TRANSFORMSPACECLEAR, "Clear", xco + 80,120,80,20, 0, 0, 0, 0, 0, "Removal all Transform Orientations");
 975
 976         uiBlockEndAlign(block);
 977
 978         uiBlockBeginAlign(block);
 979
 980         uiDefButS(block, ROW, B_REDR, "Global", xco,            90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_GLOBAL,0, 0, "Global Transform Orientation");
 981         uiDefButS(block, ROW, B_REDR, "Local",  xco + 40,       90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_LOCAL, 0, 0, "Local Transform Orientation");
 982         uiDefButS(block, ROW, B_REDR, "Normal", xco + 80,       90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_NORMAL,0, 0, "Normal Transform Orientation");
 983         uiDefButS(block, ROW, B_REDR, "View",           xco + 120,      90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_VIEW,    0, 0, "View Transform Orientation");
 984
 985         for (index = V3D_MANIP_CUSTOM, ts = transform_spaces->first ; ts ; ts = ts->next, index++) {
 986
 987                 if (v3d->twmode == index) {
 988                         but = uiDefIconButS(block,ROW, B_REDR, ICON_CHECKBOX_HLT, xco,yco,XIC,YIC, &v3d->twmode, 5.0, (float)index, 0, 0, "Use this Custom Transform Orientation");
 989                 }
 990                 else {
 991                         but = uiDefIconButS(block,ROW, B_REDR, ICON_CHECKBOX_DEHLT, xco,yco,XIC,YIC, &v3d->twmode, 5.0, (float)index, 0, 0, "Use this Custom Transform Orientation");
 992                 }
 993                 uiButSetFunc(but, selectTransformOrientation_func, ts, NULL);
 994                 uiDefBut(block, TEX, 0, "", xco+=XIC, yco,100+XIC,20, &ts->name, 0, 30, 0, 0, "Edits the name of this Transform Orientation");
 995                 but = uiDefIconBut(block, BUT, B_REDR, ICON_X, xco+=100+XIC,yco,XIC,YIC, 0, 0, 0, 0, 0, "Deletes this Transform Orientation");
 996                 uiButSetFunc(but, removeTransformOrientation_func, ts, NULL);
 997
 998                 xco = 20;
 999                 yco -= 25;
1000         }
1001         uiBlockEndAlign(block);
1002 }
1003 #endif // XXX not used
1004
1005 static void weight_paint_buttons(Scene *scene, uiBlock *block)
1006 {
1007         VPaint *wpaint= scene->toolsettings->wpaint;
1008         Object *ob;
1009         ob= OBACT;
1010
1011         if(ob==NULL || ob->type!=OB_MESH) return;
1012
1013         /* XXX
1014         uiBlockBeginAlign(block);
1015         uiDefButF(block, NUMSLI, B_REDR, "Weight:",10,170,225,19, &wpaint->weight, 0, 1, 10, 0, "Sets the current vertex group's bone deformation strength");
1016
1017         uiDefBut(block, BUT, B_WEIGHT0_0 , "0",                  10,150,45,19, 0, 0, 0, 0, 0, "");
1018         uiDefBut(block, BUT, B_WEIGHT1_4 , "1/4",                55,150,45,19, 0, 0, 0, 0, 0, "");
1019         uiDefBut(block, BUT, B_WEIGHT1_2 , "1/2",                100,150,45,19, 0, 0, 0, 0, 0, "");
1020         uiDefBut(block, BUT, B_WEIGHT3_4 , "3/4",                145,150,45,19, 0, 0, 0, 0, 0, "");
1021         uiDefBut(block, BUT, B_WEIGHT1_0 , "1",                  190,150,45,19, 0, 0, 0, 0, 0, "");
1022
1023         uiDefButF(block, NUMSLI, B_NOP, "Opacity ",             10,130,225,19, &wpaint->a, 0.0, 1.0, 0, 0, "The amount of pressure on the brush");
1024
1025         uiDefBut(block, BUT, B_OPA1_8 , "1/8",          10,110,45,19, 0, 0, 0, 0, 0, "");
1026         uiDefBut(block, BUT, B_OPA1_4 , "1/4",          55,110,45,19, 0, 0, 0, 0, 0, "");
1027         uiDefBut(block, BUT, B_OPA1_2 , "1/2",          100,110,45,19, 0, 0, 0, 0, 0, "");
1028         uiDefBut(block, BUT, B_OPA3_4 , "3/4",          145,110,45,19, 0, 0, 0, 0, 0, "");
1029         uiDefBut(block, BUT, B_OPA1_0 , "1",            190,110,45,19, 0, 0, 0, 0, 0, "");
1030
1031         uiDefButF(block, NUMSLI, B_NOP, "Size ",        10,90,225,19, &wpaint->size, 2.0, 64.0, 0, 0, "The size of the brush");
1032
1033         uiBlockBeginAlign(block);
1034         uiDefButS(block, ROW, B_NOP, "Mix",             250,170,60,17, &wpaint->mode, 1.0, 0.0, 0, 0, "Mix the vertex colors");
1035         uiDefButS(block, ROW, B_NOP, "Add",             250,152,60,17, &wpaint->mode, 1.0, 1.0, 0, 0, "Add the vertex colors");
1036         uiDefButS(block, ROW, B_NOP, "Sub",             250,134,60,17, &wpaint->mode, 1.0, 2.0, 0, 0, "Subtract from the vertex color");
1037         uiDefButS(block, ROW, B_NOP, "Mul",             250,116,60,17, &wpaint->mode, 1.0, 3.0, 0, 0, "Multiply the vertex color");
1038         uiDefButS(block, ROW, B_NOP, "Blur",            250, 98,60,17, &wpaint->mode, 1.0, 4.0, 0, 0, "Blur the weight with surrounding values");
1039         uiDefButS(block, ROW, B_NOP, "Lighter", 250, 80,60,17, &wpaint->mode, 1.0, 5.0, 0, 0, "Paint over darker areas only");
1040         uiDefButS(block, ROW, B_NOP, "Darker",          250, 62,60,17, &wpaint->mode, 1.0, 6.0, 0, 0, "Paint over lighter areas only");
1041         uiBlockEndAlign(block);
1042         */
1043
1044         /* draw options same as below */
1045         uiBlockBeginAlign(block);
1046         if (FACESEL_PAINT_TEST) {
1047                 Mesh *me= ob->data;
1048                 uiDefButBitI(block, TOG, ME_DRAWFACES, B_REDR, "Faces", 10,45,60,19, &me->drawflag, 0, 0, 0, 0, "Displays all faces as shades");
1049                 uiDefButBitI(block,TOG, ME_DRAWEDGES, B_REDR,"Edges",70,45,60,19, &me->drawflag, 2.0, 0, 0, 0,  "Displays edges of visible faces");
1050                 uiDefButBitI(block,TOG, ME_HIDDENEDGES, B_REDR,"Hidden Edges",130,45,100,19, &me->drawflag, 2.0, 1.0, 0, 0,  "Displays edges of hidden faces");
1051         } else{
1052                 uiDefButBitC(block, TOG, OB_DRAWWIRE, B_REDR, "Wire",   10,45,75,19, &ob->dtx, 0, 0, 0, 0, "Displays the active object's wireframe in shaded drawing modes");
1053         }
1054         uiBlockEndAlign(block);
1055
1056         uiBlockBeginAlign(block);
1057         uiDefButBitS(block, TOG, VP_AREA, 0, "All Faces",       10,20,60,19, &wpaint->flag, 0, 0, 0, 0, "Paint on all faces inside brush (otherwise only on face under mouse cursor)");
1058         uiDefButBitS(block, TOG, VP_SOFT, 0, "Vert Dist", 70,20,60,19, &wpaint->flag, 0, 0, 0, 0, "Use distances to vertices (instead of all vertices of face)");
1059         uiDefButBitS(block, TOGN, VP_HARD, 0, "Soft",           130,20,60,19, &wpaint->flag, 0, 0, 0, 0, "Use a soft brush");
1060         uiDefButBitS(block, TOG, VP_NORMALS, 0, "Normals",      190,20,60,19, &wpaint->flag, 0, 0, 0, 0, "Applies the vertex normal before painting");
1061         uiDefButBitS(block, TOG, VP_SPRAY, 0, "Spray",          250,20,55,19, &wpaint->flag, 0, 0, 0, 0, "Keep applying paint effect while holding mouse");
1062         uiBlockEndAlign(block);
1063
1064         if(ob) {
1065                 uiBlockBeginAlign(block);
1066                 uiDefButBitS(block, TOG, VP_ONLYVGROUP, B_REDR, "Vgroup",               10,0,100,19, &wpaint->flag, 0, 0, 0, 0, "Only paint on vertices in the selected vertex group.");
1067                 uiDefButBitS(block, TOG, VP_MIRROR_X, B_REDR, "X-Mirror",       110,0,100,19, &wpaint->flag, 0, 0, 0, 0, "Mirrored Paint, applying on mirrored Weight Group name");
1068                 uiDefBut(block, BUT, B_CLR_WPAINT, "Clear",                                     210,0,100,19, NULL, 0, 0, 0, 0, "Removes reference to this deform group from all vertices");
1069                 uiBlockEndAlign(block);
1070         }
1071 }
1072
1073 static void brush_idpoin_handle(bContext *C, ID *id, int event)
1074 {
1075         Brush **br = current_brush_source(CTX_data_scene(C));
1076
1077         if(!br)
1078                 return;
1079
1080         switch(event) {
1081         case UI_ID_BROWSE:
1082                 (*br) = (Brush*)id;
1083                 break;
1084         case UI_ID_DELETE:
1085                 brush_delete(br);
1086                 break;
1087         case UI_ID_RENAME:
1088                 /* XXX ? */
1089                 break;
1090         case UI_ID_ADD_NEW:
1091                 if(id) {
1092                         (*br) = copy_brush((Brush*)id);
1093                         id->us--;
1094                 }
1095                 else
1096                         (*br) = add_brush("Brush");
1097                 break;
1098         case UI_ID_OPEN:
1099                 /* XXX not implemented */
1100                 break;
1101         }
1102 }
1103
1104 static int view3d_panel_brush_poll(const bContext *C, PanelType *pt)
1105 {
1106         Brush **brp = current_brush_source(CTX_data_scene(C));
1107
1108         return ((G.f & (G_SCULPTMODE|G_TEXTUREPAINT|G_VERTEXPAINT|G_WEIGHTPAINT)) && brp);
1109 }
1110
1111 static void view3d_panel_brush(const bContext *C, Panel *pa)
1112 {
1113         uiBlock *block;
1114         ToolSettings *ts= CTX_data_tool_settings(C);
1115         Brush **brp = current_brush_source(CTX_data_scene(C)), *br;
1116         short w = 268, h = 400, cx = 10, cy = h;
1117         rctf rect;
1118
1119         br = *brp;
1120
1121         block= uiLayoutFreeBlock(pa->layout);
1122         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1123
1124         uiBlockBeginAlign(block);
1125         uiDefIDPoinButs(block, CTX_data_main(C), NULL, &br->id, ID_BR, NULL, cx, cy,
1126                         brush_idpoin_handle, UI_ID_BROWSE|UI_ID_RENAME|UI_ID_ADD_NEW|UI_ID_OPEN|UI_ID_DELETE|UI_ID_ALONE);
1127         cy-= 25;
1128         uiBlockEndAlign(block);
1129
1130         if(!br)
1131                 return;
1132
1133         if(G.f & G_SCULPTMODE) {
1134                 uiBlockBeginAlign(block);
1135                 uiDefButC(block,ROW,B_REDR,"Draw",cx,cy,67,19,&br->sculpt_tool,14.0,SCULPT_TOOL_DRAW,0,0,"Draw lines on the model");
1136                 uiDefButC(block,ROW,B_REDR,"Smooth",cx+67,cy,67,19,&br->sculpt_tool,14.0,SCULPT_TOOL_SMOOTH,0,0,"Interactively smooth areas of the model");
1137                 uiDefButC(block,ROW,B_REDR,"Pinch",cx+134,cy,67,19,&br->sculpt_tool,14.0,SCULPT_TOOL_PINCH,0,0,"Interactively pinch areas of the model");
1138                 uiDefButC(block,ROW,B_REDR,"Inflate",cx+201,cy,67,19,&br->sculpt_tool,14,SCULPT_TOOL_INFLATE,0,0,"Push vertices along the direction of their normals");
1139                 cy-= 20;
1140                 uiDefButC(block,ROW,B_REDR,"Grab", cx,cy,67,19,&br->sculpt_tool,14,SCULPT_TOOL_GRAB,0,0,"Grabs a group of vertices and moves them with the mouse");
1141                 uiDefButC(block,ROW,B_REDR,"Layer", cx+67,cy,67,19,&br->sculpt_tool,14, SCULPT_TOOL_LAYER,0,0,"Adds a layer of depth");
1142                 uiDefButC(block,ROW,B_REDR,"Flatten", cx+134,cy,67,19,&br->sculpt_tool,14, SCULPT_TOOL_FLATTEN,0,0,"Interactively flatten areas of the model");
1143                 uiDefButC(block,ROW,B_REDR,"Clay", cx+201,cy,67,19,&br->sculpt_tool,14, SCULPT_TOOL_CLAY,0,0,"Build up depth quickly");
1144                 cy-= 25;
1145                 uiBlockEndAlign(block);
1146         }
1147
1148         uiBlockBeginAlign(block);
1149         uiDefButI(block,NUMSLI,B_NOP,"Size: ",cx,cy,w,19,&br->size,1.0,200.0,0,0,"Set brush radius in pixels");
1150         cy-= 20;
1151         if(G.f & G_WEIGHTPAINT) {
1152                 uiDefButF(block,NUMSLI,B_NOP,"Weight: ",cx,cy,w,19,&ts->vgroup_weight,0,1.0,0,0,"Set vertex weight");
1153                 cy-= 20;
1154         }
1155         uiDefButF(block,NUMSLI,B_NOP,"Strength: ",cx,cy,w,19,&br->alpha,0,1.0,0,0,"Set brush strength");
1156         cy-= 25;
1157         uiBlockEndAlign(block);
1158
1159         uiBlockBeginAlign(block);
1160
1161         uiDefButBitS(block, TOG, BRUSH_AIRBRUSH, B_NOP, "Airbrush", cx,cy,w/3,19, &br->flag,0,0,0,0, "Brush makes changes without waiting for the mouse to move");
1162         uiDefButBitS(block, TOG, BRUSH_RAKE, B_NOP, "Rake", cx+w/3,cy,w/3,19, &br->flag,0,0,0,0, "");
1163         uiDefButBitS(block, TOG, BRUSH_ANCHORED, B_NOP, "Anchored", cx+w*2.0/3,cy,w/3,19, &br->flag,0,0,0,0, "");
1164         cy-= 20;
1165         uiDefButBitS(block, TOG, BRUSH_SPACE, B_NOP, "Space", cx,cy,w/3,19, &br->flag,0,0,0,0, "");
1166         uiDefButF(block,NUMSLI,B_NOP,"Spacing: ",cx+w/3,cy,w*2.0/3,19,&br->spacing,1.0,500,0,0,"");
1167         cy-= 20;
1168         uiBlockEndAlign(block);
1169
1170         if(br->curve) {
1171                 rect.xmin= cx; rect.xmax= cx + w;
1172                 rect.ymin= cy - 200; rect.ymax= cy;
1173                 uiBlockBeginAlign(block);
1174                 curvemap_buttons(block, br->curve, (char)0, B_NOP, 0, &rect);
1175                 uiBlockEndAlign(block);
1176         }
1177 }
1178
1179 static void sculptmode_draw_interface_tools(Scene *scene, uiBlock *block, unsigned short cx, unsigned short cy)
1180 {
1181         Sculpt *s = scene->toolsettings->sculpt;
1182
1183         //XXX if(sd->brush_type != SMOOTH_BRUSH && sd->brush_type != GRAB_BRUSH && sd->brush_type != FLATTEN_BRUSH) {
1184         {
1185                 /*uiDefButBitS(block,ROW,B_NOP,"Add",cx,cy,89,19,&br->dir,15.0,1.0,0, 0,"Add depth to model [Shift]");
1186                 uiDefButBitS(block,ROW,B_NOP,"Sub",cx+89,cy,89,19,&br->dir,15.0,2.0,0, 0,"Subtract depth from model [Shift]");
1187                 */}
1188         //XXX if(sd->brush_type!=GRAB_BRUSH)
1189
1190         uiBlockBeginAlign(block);
1191         uiDefBut( block,LABEL,B_NOP,"Symmetry",cx,cy,90,19,NULL,0,0,0,0,"");
1192         cy-= 20;
1193         uiBlockBeginAlign(block);
1194         uiDefButBitI(block, TOG, SCULPT_SYMM_X, B_NOP, "X", cx,cy,40,19, &s->flags, 0,0,0,0, "Mirror brush across X axis");
1195         uiDefButBitI(block, TOG, SCULPT_SYMM_Y, B_NOP, "Y", cx+40,cy,40,19, &s->flags, 0,0,0,0, "Mirror brush across Y axis");
1196         uiDefButBitI(block, TOG, SCULPT_SYMM_Z, B_NOP, "Z", cx+80,cy,40,19, &s->flags, 0,0,0,0, "Mirror brush across Z axis");
1197         uiBlockEndAlign(block);
1198
1199
1200         cy+= 20;
1201         uiBlockBeginAlign(block);
1202         uiDefBut( block,LABEL,B_NOP,"LockAxis",cx+140,cy,90,19,NULL,0,0,0,0,"");
1203         cy-= 20;
1204         uiBlockBeginAlign(block);
1205         uiDefButBitI(block, TOG, SCULPT_LOCK_X, B_NOP, "X", cx+140,cy,40,19, &s->flags, 0,0,0,0, "Constrain X axis");
1206         uiDefButBitI(block, TOG, SCULPT_LOCK_Y, B_NOP, "Y", cx+180,cy,40,19, &s->flags, 0,0,0,0, "Constrain Y axis");
1207         uiDefButBitI(block, TOG, SCULPT_LOCK_Z, B_NOP, "Z", cx+220,cy,40,19, &s->flags, 0,0,0,0, "Constrain Z axis");
1208         uiBlockEndAlign(block);
1209
1210         cx+= 210;
1211 }
1212
1213
1214 static void view3d_panel_object(const bContext *C, Panel *pa)
1215 {
1216         uiBlock *block;
1217         Scene *scene= CTX_data_scene(C);
1218         Object *obedit= CTX_data_edit_object(C);
1219         View3D *v3d= CTX_wm_view3d(C);
1220         //uiBut *bt;
1221         Object *ob= OBACT;
1222         TransformProperties *tfp;
1223         float lim;
1224         static char hexcol[128];
1225
1226         if(ob==NULL) return;
1227
1228         /* make sure we got storage */
1229         if(v3d->properties_storage==NULL)
1230                 v3d->properties_storage= MEM_callocN(sizeof(TransformProperties), "TransformProperties");
1231         tfp= v3d->properties_storage;
1232
1233         block= uiLayoutFreeBlock(pa->layout);
1234         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1235
1236 // XXX  uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
1237
1238         if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
1239         }
1240         else {
1241                 //bt= uiDefBut(block, TEX, B_IDNAME, "OB: ",    10,180,140,20, ob->id.name+2, 0.0, 21.0, 0, 0, "");
1242                 //uiButSetFunc(bt, test_idbutton_cb, ob->id.name, NULL);
1243
1244                 if((G.f & G_PARTICLEEDIT)==0) {
1245                 //      uiBlockBeginAlign(block);
1246                 //      uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_OBJECTPANELPARENT, "Par:", 160, 180, 140, 20, &ob->parent, "Parent Object");
1247                         if((ob->parent) && (ob->partype == PARBONE)) {
1248                 //              bt= uiDefBut(block, TEX, B_OBJECTPANELPARENT, "ParBone:", 160, 160, 140, 20, ob->parsubstr, 0, 30, 0, 0, "");
1249                 //              uiButSetCompleteFunc(bt, autocomplete_bone, (void *)ob->parent);
1250                         }
1251                         else {
1252                                 strcpy(ob->parsubstr, "");
1253                         }
1254                         uiBlockEndAlign(block);
1255                 }
1256         }
1257
1258         lim= 10000.0f*MAX2(1.0, v3d->grid);
1259
1260         if(ob==obedit) {
1261                 if(ob->type==OB_ARMATURE) v3d_editarmature_buts(block, v3d, ob, lim);
1262                 if(ob->type==OB_MBALL) v3d_editmetaball_buts(block, ob, lim);
1263                 else v3d_editvertex_buts(C, block, v3d, ob, lim);
1264         }
1265         else if(ob->flag & OB_POSEMODE) {
1266                 v3d_posearmature_buts(block, v3d, ob, lim);
1267         }
1268         else if(G.f & G_WEIGHTPAINT) {
1269                 BLI_strncpy(pa->drawname, "Weight Paint Properties", sizeof(pa->drawname));
1270                 weight_paint_buttons(scene, block);
1271         }
1272         else if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT)) {
1273                 static float hsv[3], old[3];    // used as temp mem for picker
1274                 Brush **br = current_brush_source(scene);
1275
1276                 BLI_strncpy(pa->drawname, "Paint Properties", sizeof(pa->drawname));
1277                 if(br && *br)
1278                         /* 'f' is for floating panel */
1279                         uiBlockPickerButtons(block, (*br)->rgb, hsv, old, hexcol, 'f', B_REDR);
1280         }
1281         else if(G.f & G_SCULPTMODE) {
1282                 BLI_strncpy(pa->drawname, "Sculpt Properties", sizeof(pa->drawname));
1283                 sculptmode_draw_interface_tools(scene, block, 10, 150);
1284         }
1285         else if(G.f & G_PARTICLEEDIT){
1286                 BLI_strncpy(pa->drawname, "Particle Edit Properties", sizeof(pa->drawname));
1287 // XXX          particle_edit_buttons(block);
1288         }
1289         else {
1290                 BoundBox *bb = NULL;
1291
1292                 uiDefBut(block, LABEL, 0, "Location:",                                  10, 170, 100, 20, 0, 0, 0, 0, 0, "");
1293                 uiBlockBeginAlign(block);
1294                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCX, B_REDR, ICON_UNLOCKED,   10,150,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1295                 uiDefButF(block, NUM, B_OBJECTPANEL, "X:",              30, 150, 120, 19, &(ob->loc[0]), -lim, lim, 100, 3, "");
1296                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCY, B_REDR, ICON_UNLOCKED,   10,130,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1297                 uiDefButF(block, NUM, B_OBJECTPANEL, "Y:",              30, 130, 120, 19, &(ob->loc[1]), -lim, lim, 100, 3, "");
1298                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCZ, B_REDR, ICON_UNLOCKED,   10,110,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1299                 uiDefButF(block, NUM, B_OBJECTPANEL, "Z:",              30, 110, 120, 19, &(ob->loc[2]), -lim, lim, 100, 3, "");
1300
1301                 tfp->ob_eul[0]= 180.0*ob->rot[0]/M_PI;
1302                 tfp->ob_eul[1]= 180.0*ob->rot[1]/M_PI;
1303                 tfp->ob_eul[2]= 180.0*ob->rot[2]/M_PI;
1304
1305                 uiBlockBeginAlign(block);
1306                 if ((ob->parent) && (ob->partype == PARBONE)) {
1307                         uiDefBut(block, LABEL, 0, "Rotation:",                                  160, 170, 100, 20, 0, 0, 0, 0, 0, "");
1308                         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTX, B_REDR, ICON_UNLOCKED,   160,130,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1309                         uiDefButF(block, NUM, B_OBJECTPANELROT, "X:",   180, 130, 120, 19, &(tfp->ob_eul[0]), -lim, lim, 1000, 3, "");
1310                         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTY, B_REDR, ICON_UNLOCKED,   160,110,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1311                         uiDefButF(block, NUM, B_OBJECTPANELROT, "Y:",   180, 110, 120, 19, &(tfp->ob_eul[1]), -lim, lim, 1000, 3, "");
1312                         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTZ, B_REDR, ICON_UNLOCKED,   160,90,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1313                         uiDefButF(block, NUM, B_OBJECTPANELROT, "Z:",   180, 90, 120, 19, &(tfp->ob_eul[2]), -lim, lim, 1000, 3, "");
1314
1315                 }
1316                 else {
1317                         uiDefBut(block, LABEL, 0, "Rotation:",                                  160, 170, 100, 20, 0, 0, 0, 0, 0, "");
1318                         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTX, B_REDR, ICON_UNLOCKED,   160,150,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1319                         uiDefButF(block, NUM, B_OBJECTPANELROT, "X:",   180, 150, 120, 19, &(tfp->ob_eul[0]), -lim, lim, 1000, 3, "");
1320                         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTY, B_REDR, ICON_UNLOCKED,   160,130,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1321                         uiDefButF(block, NUM, B_OBJECTPANELROT, "Y:",   180, 130, 120, 19, &(tfp->ob_eul[1]), -lim, lim, 1000, 3, "");
1322                         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTZ, B_REDR, ICON_UNLOCKED,   160,110,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1323                         uiDefButF(block, NUM, B_OBJECTPANELROT, "Z:",   180, 110, 120, 19, &(tfp->ob_eul[2]), -lim, lim, 1000, 3, "");
1324                 }
1325
1326                 tfp->ob_scale[0]= ob->size[0];
1327                 tfp->ob_scale[1]= ob->size[1];
1328                 tfp->ob_scale[2]= ob->size[2];
1329
1330                 uiDefBut(block, LABEL, 0, "Scale:",                                     10, 90, 100, 20, 0, 0, 0, 0, 0, "");
1331                 uiBlockBeginAlign(block);
1332                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEX, B_REDR, ICON_UNLOCKED, 10, 70, 20, 19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1333                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "X:",                                                 30, 70, 120, 19, &(tfp->ob_scale[0]), -lim, lim, 10, 3, "");
1334                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEY, B_REDR, ICON_UNLOCKED, 10, 50, 20, 19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1335                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "Y:",                                                 30, 50, 120, 19, &(tfp->ob_scale[1]), -lim, lim, 10, 3, "");
1336                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEZ, B_REDR, ICON_UNLOCKED, 10, 30, 20, 19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1337                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "Z:",                                                 30, 30, 120, 19, &(tfp->ob_scale[2]), -lim, lim, 10, 3, "");
1338                 uiBlockEndAlign(block);
1339
1340                 uiDefButS(block, TOG, B_REDR, "Link Scale",             10, 0, 140, 19, &(tfp->link_scale), 0, 1, 0, 0, "Scale values vary proportionally in all directions");
1341
1342                 bb= object_get_boundbox(ob);
1343                 if (bb) {
1344                         float scale[3];
1345
1346                         Mat4ToSize(ob->obmat, scale);
1347
1348                         tfp->ob_dims[0] = fabs(scale[0]) * (bb->vec[4][0] - bb->vec[0][0]);
1349                         tfp->ob_dims[1] = fabs(scale[1]) * (bb->vec[2][1] - bb->vec[0][1]);
1350                         tfp->ob_dims[2] = fabs(scale[2]) * (bb->vec[1][2] - bb->vec[0][2]);
1351
1352
1353                         if ((ob->parent) && (ob->partype == PARBONE)) {
1354                                 uiDefBut(block, LABEL, 0, "Dimensions:",                        160, 90, 100, 20, 0, 0, 0, 0, 0, "");
1355                                 uiBlockBeginAlign(block);
1356                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "X:",          160, 70, 140, 19, &(tfp->ob_dims[0]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1357                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "Y:",          160, 50, 140, 19, &(tfp->ob_dims[1]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1358                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "Z:",          160, 30, 140, 19, &(tfp->ob_dims[2]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1359
1360                         }
1361                         else {
1362                                 uiDefBut(block, LABEL, 0, "Dimensions:",                        160, 90, 100, 20, 0, 0, 0, 0, 0, "");
1363                                 uiBlockBeginAlign(block);
1364                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "X:",          160, 70, 140, 19, &(tfp->ob_dims[0]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1365                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "Y:",          160, 50, 140, 19, &(tfp->ob_dims[1]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1366                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "Z:",          160, 30, 140, 19, &(tfp->ob_dims[2]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1367                         }
1368
1369                         uiBlockEndAlign(block);
1370                 }
1371         }
1372 }
1373
1374 #if 0 // XXX not used anymore
1375 static void view3d_panel_background(const bContext *C, Panel *pa)
1376 {
1377         View3D *v3d= CTX_wm_view3d(C);
1378         uiBlock *block;
1379
1380         block= uiLayoutFreeBlock(pa->layout);
1381         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1382
1383         if(v3d->flag & V3D_DISPBGPIC) {
1384                 if(v3d->bgpic==NULL) {
1385                         v3d->bgpic= MEM_callocN(sizeof(BGpic), "bgpic");
1386                         v3d->bgpic->size= 5.0;
1387                         v3d->bgpic->blend= 0.5;
1388                         v3d->bgpic->iuser.fie_ima= 2;
1389                         v3d->bgpic->iuser.ok= 1;
1390                 }
1391         }
1392
1393         if(!(v3d->flag & V3D_DISPBGPIC)) {
1394                 uiDefButBitS(block, TOG, V3D_DISPBGPIC, B_REDR, "Use Background Image", 10, 180, 150, 20, &v3d->flag, 0, 0, 0, 0, "Display an image in the background of this 3D View");
1395                 uiDefBut(block, LABEL, 1, " ",  160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
1396         }
1397         else {
1398                 uiBlockBeginAlign(block);
1399                 uiDefButBitS(block, TOG, V3D_DISPBGPIC, B_REDR, "Use", 10, 225, 50, 20, &v3d->flag, 0, 0, 0, 0, "Display an image in the background of this 3D View");
1400                 uiDefButF(block, NUMSLI, B_REDR, "Blend:",      60, 225, 150, 20, &v3d->bgpic->blend, 0.0,1.0, 0, 0, "Set the transparency of the background image");
1401                 uiDefButF(block, NUM, B_REDR, "Size:",          210, 225, 100, 20, &v3d->bgpic->size, 0.1, 250.0*v3d->grid, 100, 0, "Set the size (width) of the background image");
1402
1403                 uiDefButF(block, NUM, B_REDR, "X Offset:",      10, 205, 150, 20, &v3d->bgpic->xof, -250.0*v3d->grid,250.0*v3d->grid, 10, 2, "Set the horizontal offset of the background image");
1404                 uiDefButF(block, NUM, B_REDR, "Y Offset:",      160, 205, 150, 20, &v3d->bgpic->yof, -250.0*v3d->grid,250.0*v3d->grid, 10, 2, "Set the vertical offset of the background image");
1405
1406                 ED_image_uiblock_panel(C, block, &v3d->bgpic->ima, &v3d->bgpic->iuser, B_REDR, B_REDR);
1407                 uiBlockEndAlign(block);
1408         }
1409 }
1410
1411
1412 static void view3d_panel_properties(const bContext *C, Panel *pa)
1413 {
1414         ScrArea *sa= CTX_wm_area(C);
1415         ARegion *arlast;
1416         Scene *scene= CTX_data_scene(C);
1417         View3D *v3d= CTX_wm_view3d(C);
1418         RegionView3D *rv3d;
1419         uiBlock *block;
1420         float *curs;
1421
1422         block= uiLayoutFreeBlock(pa->layout);
1423         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1424
1425         uiDefBut(block, LABEL, 1, "Grid:",                                      10, 220, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1426         uiBlockBeginAlign(block);
1427         uiDefButF(block, NUM, B_REDR, "Spacing:",               10, 200, 140, 19, &v3d->grid, 0.001, 100.0, 10, 0, "Set the distance between grid lines");
1428         uiDefButS(block, NUM, B_REDR, "Lines:",         10, 180, 140, 19, &v3d->gridlines, 0.0, 100.0, 100, 0, "Set the number of grid lines in perspective view");
1429         uiDefButS(block, NUM, B_REDR, "Divisions:",             10, 160, 140, 19, &v3d->gridsubdiv, 1.0, 100.0, 100, 0, "Set the number of grid lines");
1430         uiBlockEndAlign(block);
1431
1432         uiDefBut(block, LABEL, 1, "3D Display:",                                                        160, 220, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1433         uiDefButBitS(block, TOG, V3D_SHOW_FLOOR, B_REDR, "Grid Floor",160, 200, 150, 19, &v3d->gridflag, 0, 0, 0, 0, "Show the grid floor in free camera mode");
1434         uiDefButBitS(block, TOG, V3D_SHOW_X, B_REDR, "X Axis",          160, 176, 48, 19, &v3d->gridflag, 0, 0, 0, 0, "Show the X Axis line");
1435         uiDefButBitS(block, TOG, V3D_SHOW_Y, B_REDR, "Y Axis",          212, 176, 48, 19, &v3d->gridflag, 0, 0, 0, 0, "Show the Y Axis line");
1436         uiDefButBitS(block, TOG, V3D_SHOW_Z, B_REDR, "Z Axis",          262, 176, 48, 19, &v3d->gridflag, 0, 0, 0, 0, "Show the Z Axis line");
1437
1438         uiDefBut(block, LABEL, 1, "View Camera:",                       10, 140, 140, 19, NULL, 0.0, 0.0, 0, 0, "");
1439
1440         uiDefButF(block, NUM, B_REDR, "Lens:",          10, 120, 140, 19, &v3d->lens, 10.0, 120.0, 100, 0, "The lens angle in perspective view");
1441         uiBlockBeginAlign(block);
1442         uiDefButF(block, NUM, B_REDR, "Clip Start:",    10, 96, 140, 19, &v3d->near, v3d->grid/100.0, 100.0, 10, 0, "Set the beginning of the range in which 3D objects are displayed (perspective view)");
1443         uiDefButF(block, NUM, B_REDR, "Clip End:",      10, 76, 140, 19, &v3d->far, 1.0, 10000.0*v3d->grid, 100, 0, "Set the end of the range in which 3D objects are displayed (perspective view)");
1444         uiBlockEndAlign(block);
1445
1446         uiDefBut(block, LABEL, 1, "3D Cursor:",                         160, 150, 140, 19, NULL, 0.0, 0.0, 0, 0, "");
1447
1448         uiBlockBeginAlign(block);
1449         curs= give_cursor(scene, v3d);
1450         uiDefButF(block, NUM, B_REDR, "X:",                     160, 130, 150, 22, curs, -10000.0*v3d->grid, 10000.0*v3d->grid, 10, 0, "X co-ordinate of the 3D cursor");
1451         uiDefButF(block, NUM, B_REDR, "Y:",                     160, 108, 150, 22, curs+1, -10000.0*v3d->grid, 10000.0*v3d->grid, 10, 0, "Y co-ordinate of the 3D cursor");
1452         uiDefButF(block, NUM, B_REDR, "Z:",                     160, 86, 150, 22, curs+2, -10000.0*v3d->grid, 10000.0*v3d->grid, 10, 0, "Z co-ordinate of the 3D cursor");
1453         uiBlockEndAlign(block);
1454
1455         uiDefBut(block, LABEL, 1, "Display:",                           10, 50, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1456         uiBlockBeginAlign(block);
1457         uiDefButBitS(block, TOG, V3D_SELECT_OUTLINE, B_REDR, "Outline Selected", 10, 30, 140, 19, &v3d->flag, 0, 0, 0, 0, "Highlight selected objects with an outline, in Solid, Shaded or Textured viewport shading modes");
1458         uiDefButBitS(block, TOG, V3D_DRAW_CENTERS, B_REDR, "All Object Centers", 10, 10, 140, 19, &v3d->flag, 0, 0, 0, 0, "Draw the center points on all objects");
1459         uiDefButBitS(block, TOGN, V3D_HIDE_HELPLINES, B_REDR, "Relationship Lines", 10, -10, 140, 19, &v3d->flag, 0, 0, 0, 0, "Draw dashed lines indicating Parent, Constraint, or Hook relationships");
1460         uiDefButBitS(block, TOG, V3D_SOLID_TEX, B_REDR, "Solid Tex", 10, -30, 140, 19, &v3d->flag2, 0, 0, 0, 0, "Display textures in Solid draw type (Shift T)");
1461         uiBlockEndAlign(block);
1462
1463         uiDefBut(block, LABEL, 1, "View Locking:",                              160, 60, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1464         uiBlockBeginAlign(block);
1465         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_REDR, "Object:", 160, 40, 150, 19, &v3d->ob_centre, "Lock view to center to this Object");
1466         uiDefBut(block, TEX, B_REDR, "Bone:",                                           160, 20, 150, 19, v3d->ob_centre_bone, 1, 31, 0, 0, "If view locked to Object, use this Bone to lock to view to");
1467         uiBlockEndAlign(block);
1468
1469         /* last region is always 3d... a bit weak */
1470         arlast= sa->regionbase.last;
1471         uiBlockBeginAlign(block);
1472         if(arlast->alignment==RGN_ALIGN_QSPLIT) {
1473                 arlast= arlast->prev;
1474                 rv3d= arlast->regiondata;
1475
1476                 uiDefButO(block, BUT, "SCREEN_OT_region_foursplit", WM_OP_EXEC_REGION_WIN, "End 4-Split View", 160, -10, 150, 19, "Join the 3D View");
1477                 uiDefButBitS(block, TOG, RV3D_LOCKED, B_RV3D_LOCKED, "Lock", 160, -30, 50, 19, &rv3d->viewlock, 0, 0, 0, 0, "");
1478                 uiDefButBitS(block, TOG, RV3D_BOXVIEW, B_RV3D_BOXVIEW, "Box", 210, -30, 50, 19, &rv3d->viewlock, 0, 0, 0, 0, "");
1479                 uiDefButBitS(block, TOG, RV3D_BOXCLIP, B_RV3D_BOXCLIP, "Clip", 260, -30, 50, 19, &rv3d->viewlock, 0, 0, 0, 0, "");
1480         }
1481         else
1482                 uiDefButO(block, BUT, "SCREEN_OT_region_foursplit", WM_OP_EXEC_REGION_WIN, "4-Split View", 160, -10, 150, 19, "Split 3D View in 4 parts");
1483
1484         uiBlockEndAlign(block);
1485
1486
1487 // XXX
1488 //      uiDefBut(block, LABEL, 1, "Keyframe Display:",                          160, -2, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1489 //      uiBlockBeginAlign(block);
1490 //      uiDefButBitS(block, TOG, ANIMFILTER_ACTIVE, B_REDR, "Active",160, -22, 50, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes for active element only (i.e. active bone or active material)");
1491 //      uiDefButBitS(block, TOG, ANIMFILTER_MUTED, B_REDR, "Muted",210, -22, 50, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes in muted channels");
1492 //      uiDefButBitS(block, TOG, ANIMFILTER_LOCAL, B_REDR, "Local",260, -22, 50, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes directly connected to datablock");
1493 //      if ((v3d->keyflags & ANIMFILTER_LOCAL)==0) {
1494 //              uiDefButBitS(block, TOGN, ANIMFILTER_NOMAT, B_REDR, "Material",160, -42, 75, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes for any available Materials");
1495 //              uiDefButBitS(block, TOGN, ANIMFILTER_NOSKEY, B_REDR, "ShapeKey",235, -42, 75, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes for any available Shape Keys");
1496 //      }
1497         uiBlockEndAlign(block);
1498 }
1499 #endif // XXX not used anymore
1500
1501 #if 0
1502 static void view3d_panel_preview(bContext *C, ARegion *ar, short cntrl) // VIEW3D_HANDLER_PREVIEW
1503 {
1504         uiBlock *block;
1505         View3D *v3d= sa->spacedata.first;
1506         int ofsx, ofsy;
1507
1508         block= uiBeginBlock(C, ar, "view3d_panel_preview", UI_EMBOSS);
1509         uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | UI_PNL_SCALE | cntrl);
1510         uiSetPanelHandler(VIEW3D_HANDLER_PREVIEW);  // for close and esc
1511
1512         ofsx= -150+(sa->winx/2)/v3d->blockscale;
1513         ofsy= -100+(sa->winy/2)/v3d->blockscale;
1514         if(uiNewPanel(C, ar, block, "Preview", "View3d", ofsx, ofsy, 300, 200)==0) return;
1515
1516         uiBlockSetDrawExtraFunc(block, BIF_view3d_previewdraw);
1517
1518         if(scene->recalc & SCE_PRV_CHANGED) {
1519                 scene->recalc &= ~SCE_PRV_CHANGED;
1520                 //printf("found recalc\n");
1521                 BIF_view3d_previewrender_free(sa->spacedata.first);
1522                 BIF_preview_changed(0);
1523         }
1524 }
1525 #endif
1526
1527 #if 0
1528 static void view3d_panel_gpencil(const bContext *C, Panel *pa)
1529 {
1530         View3D *v3d= CTX_wm_view3d(C);
1531         uiBlock *block;
1532
1533         block= uiLayoutFreeBlock(pa->layout);
1534
1535         /* allocate memory for gpd if drawing enabled (this must be done first or else we crash) */
1536         if (v3d->flag2 & V3D_DISPGP) {
1537 //              if (v3d->gpd == NULL)
1538 // XXX                  gpencil_data_setactive(ar, gpencil_data_addnew());
1539         }
1540
1541         if (v3d->flag2 & V3D_DISPGP) {
1542 // XXX          bGPdata *gpd= v3d->gpd;
1543
1544                 /* draw button for showing gpencil settings and drawings */
1545                 uiDefButBitS(block, TOG, V3D_DISPGP, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &v3d->flag2, 0, 0, 0, 0, "Display freehand annotations overlay over this 3D View (draw using Shift-LMB)");
1546         }
1547         else {
1548                 uiDefButBitS(block, TOG, V3D_DISPGP, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &v3d->flag2, 0, 0, 0, 0, "Display freehand annotations overlay over this 3D View");
1549                 uiDefBut(block, LABEL, 1, " ",  160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
1550         }
1551 }
1552 #endif
1553
1554 #if 0 // XXX not used
1555 static void delete_sketch_armature(bContext *C, void *arg1, void *arg2)
1556 {
1557         BIF_deleteSketch(C);
1558 }
1559
1560 static void convert_sketch_armature(bContext *C, void *arg1, void *arg2)
1561 {
1562         BIF_convertSketch(C);
1563 }
1564
1565 static void assign_template_sketch_armature(bContext *C, void *arg1, void *arg2)
1566 {
1567         int index = *(int*)arg1;
1568         BIF_setTemplate(C, index);
1569 }
1570
1571 static int view3d_panel_bonesketch_spaces_poll(const bContext *C, PanelType *pt)
1572 {
1573         Object *obedit = CTX_data_edit_object(C);
1574
1575         /* replace with check call to sketching lib */
1576         return (obedit && obedit->type == OB_ARMATURE);
1577 }
1578 static void view3d_panel_bonesketch_spaces(const bContext *C, Panel *pa)
1579 {
1580         Scene *scene = CTX_data_scene(C);
1581         static int template_index;
1582         static char joint_label[128];
1583         uiBlock *block;
1584         uiBut *but;
1585         char *bone_name;
1586         int yco = 130;
1587         int nb_joints;
1588         static char subdiv_tooltip[4][64] = {
1589                 "Subdivide arcs based on a fixed number of bones",
1590                 "Subdivide arcs in bones of equal length",
1591                 "Subdivide arcs based on correlation",
1592                 "Retarget template to stroke"
1593                 };
1594
1595
1596         block= uiLayoutFreeBlock(pa->layout);
1597         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1598
1599         uiBlockBeginAlign(block);
1600
1601         /* use real flag instead of 1 */
1602         uiDefButBitC(block, TOG, BONE_SKETCHING, B_REDR, "Use Bone Sketching", 10, yco, 160, 20, &scene->toolsettings->bone_sketching, 0, 0, 0, 0, "Use sketching to create and edit bones, (Ctrl snaps to mesh volume)");
1603         uiDefButBitC(block, TOG, BONE_SKETCHING_ADJUST, B_REDR, "A", 170, yco, 20, 20, &scene->toolsettings->bone_sketching, 0, 0, 0, 0, "Adjust strokes by drawing near them");
1604         uiDefButBitC(block, TOG, BONE_SKETCHING_QUICK, B_REDR, "Q", 190, yco, 20, 20, &scene->toolsettings->bone_sketching, 0, 0, 0, 0, "Automatically convert and delete on stroke end");
1605         yco -= 20;
1606
1607         but = uiDefBut(block, BUT, B_REDR, "Convert", 10,yco,100,20, 0, 0, 0, 0, 0, "Convert sketch to armature");
1608         uiButSetFunc(but, convert_sketch_armature, NULL, NULL);
1609
1610         but = uiDefBut(block, BUT, B_REDR, "Delete", 110,yco,100,20, 0, 0, 0, 0, 0, "Delete sketch");
1611         uiButSetFunc(but, delete_sketch_armature, NULL, NULL);
1612         yco -= 20;
1613
1614         uiBlockEndAlign(block);
1615
1616         uiBlockBeginAlign(block);
1617
1618         uiDefButC(block, MENU, B_REDR, "Subdivision Method%t|Length%x1|Adaptative%x2|Fixed%x0|Template%x3", 10,yco,60,19, &scene->toolsettings->bone_sketching_convert, 0, 0, 0, 0, subdiv_tooltip[(unsigned char)scene->toolsettings->bone_sketching_convert]);
1619
1620         switch(scene->toolsettings->bone_sketching_convert)
1621         {
1622         case SK_CONVERT_CUT_LENGTH:
1623                 uiDefButF(block, NUM, B_REDR,                                   "Lim:",         70, yco, 140, 19, &scene->toolsettings->skgen_length_limit,0.1,50.0, 10, 0,             "Maximum length of the subdivided bones");
1624                 yco -= 20;
1625                 break;
1626         case SK_CONVERT_CUT_ADAPTATIVE:
1627                 uiDefButF(block, NUM, B_REDR,                                   "Thres:",                       70, yco, 140, 19, &scene->toolsettings->skgen_correlation_limit,0.0, 1.0, 0.01, 0,      "Correlation threshold for subdivision");
1628                 yco -= 20;
1629                 break;
1630         default:
1631         case SK_CONVERT_CUT_FIXED:
1632                 uiDefButC(block, NUM, B_REDR,                                   "Num:",         70, yco, 140, 19, &scene->toolsettings->skgen_subdivision_number,1, 100, 1, 5,  "Number of subdivided bones");
1633                 yco -= 20;
1634                 break;
1635         case SK_CONVERT_RETARGET:
1636                 uiDefButC(block, ROW, B_NOP, "No",                      70,  yco, 40,19, &scene->toolsettings->skgen_retarget_roll, 0, 0, 0, 0,                                                                 "No special roll treatment");
1637                 uiDefButC(block, ROW, B_NOP, "View",            110,  yco, 50,19, &scene->toolsettings->skgen_retarget_roll, 0, SK_RETARGET_ROLL_VIEW, 0, 0,                            "Roll bones perpendicular to view");
1638                 uiDefButC(block, ROW, B_NOP, "Joint",           160, yco, 50,19, &scene->toolsettings->skgen_retarget_roll, 0, SK_RETARGET_ROLL_JOINT, 0, 0,                            "Roll bones relative to joint bend");
1639                 yco -= 30;
1640
1641                 uiBlockEndAlign(block);
1642
1643                 uiBlockBeginAlign(block);
1644                 /* button here to select what to do (copy or not), template, ...*/
1645
1646                 BIF_makeListTemplates(C);
1647                 template_index = BIF_currentTemplate(C);
1648
1649                 but = uiDefButI(block, MENU, B_REDR, BIF_listTemplates(C), 10,yco,200,19, &template_index, 0, 0, 0, 0, "Template");
1650                 uiButSetFunc(but, assign_template_sketch_armature, &template_index, NULL);
1651
1652                 yco -= 20;
1653
1654                 uiDefButF(block, NUM, B_NOP,                                                    "A:",                   10, yco, 66,19, &scene->toolsettings->skgen_retarget_angle_weight, 0, 10, 1, 0,         "Angle Weight");
1655                 uiDefButF(block, NUM, B_NOP,                                                    "L:",                   76, yco, 67,19, &scene->toolsettings->skgen_retarget_length_weight, 0, 10, 1, 0,                "Length Weight");
1656                 uiDefButF(block, NUM, B_NOP,                                                    "D:",           143,yco, 67,19, &scene->toolsettings->skgen_retarget_distance_weight, 0, 10, 1, 0,              "Distance Weight");
1657                 yco -= 20;
1658
1659                 uiDefBut(block, TEX,B_REDR,"S:",                                                        10,  yco, 90, 20, scene->toolsettings->skgen_side_string, 0.0, 8.0, 0, 0, "Text to replace &S with");
1660                 uiDefBut(block, TEX,B_REDR,"N:",                                                        100, yco, 90, 20, scene->toolsettings->skgen_num_string, 0.0, 8.0, 0, 0, "Text to replace &N with");
1661                 uiDefIconButBitC(block, TOG, SK_RETARGET_AUTONAME, B_NOP, ICON_AUTO,190,yco,20,20, &scene->toolsettings->skgen_retarget_options, 0, 0, 0, 0, "Use Auto Naming");
1662                 yco -= 20;
1663
1664                 /* auto renaming magic */
1665                 uiBlockEndAlign(block);
1666
1667                 nb_joints = BIF_nbJointsTemplate(C);
1668
1669                 if (nb_joints == -1)
1670                 {
1671                         //XXX
1672                         //nb_joints = G.totvertsel;
1673                 }
1674
1675                 bone_name = BIF_nameBoneTemplate(C);
1676
1677                 BLI_snprintf(joint_label, 32, "%i joints: %s", nb_joints, bone_name);
1678
1679                 uiDefBut(block, LABEL, 1, joint_label,                                  10, yco, 200, 20, NULL, 0.0, 0.0, 0, 0, "");
1680                 yco -= 20;
1681                 break;
1682         }
1683
1684         uiBlockEndAlign(block);
1685
1686         uiDefButBitS(block, TOG, SCE_SNAP_PEEL_OBJECT, B_NOP, "Peel Objects", 10, yco, 200, 20, &scene->toolsettings->snap_flag, 0, 0, 0, 0, "Peel whole objects as one");
1687 }
1688
1689
1690 /* op->invoke */
1691 static void redo_cb(bContext *C, void *arg_op, void *arg2)
1692 {
1693         wmOperator *lastop= arg_op;
1694
1695         if(lastop) {
1696                 int retval;
1697
1698                 printf("operator redo %s\n", lastop->type->name);
1699                 ED_undo_pop(C);
1700                 retval= WM_operator_repeat(C, lastop);
1701                 if((retval & OPERATOR_FINISHED)==0) {
1702                         printf("operator redo failed %s\n", lastop->type->name);
1703                         ED_undo_redo(C);
1704                 }
1705         }
1706 }
1707
1708 static void view3d_panel_operator_redo(const bContext *C, Panel *pa)
1709 {
1710         wmWindowManager *wm= CTX_wm_manager(C);
1711         wmOperator *op;
1712         PointerRNA ptr;
1713         uiBlock *block;
1714
1715         block= uiLayoutGetBlock(pa->layout);
1716
1717         /* only for operators that are registered and did an undo push */
1718         for(op= wm->operators.last; op; op= op->prev)
1719                 if((op->type->flag & OPTYPE_REGISTER) && (op->type->flag & OPTYPE_UNDO))
1720                         break;
1721
1722         if(op==NULL)
1723                 return;
1724
1725         uiBlockSetFunc(block, redo_cb, op, NULL);
1726
1727         if(!op->properties) {
1728                 IDPropertyTemplate val = {0};
1729                 op->properties= IDP_New(IDP_GROUP, val, "wmOperatorProperties");
1730         }
1731
1732         RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
1733         uiDefAutoButsRNA(C, pa->layout, &ptr, 2);
1734 }
1735 #endif // XXX not used
1736
1737 void view3d_buttons_register(ARegionType *art)
1738 {
1739         PanelType *pt;
1740
1741         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel object");
1742         strcpy(pt->idname, "VIEW3D_PT_object");
1743         strcpy(pt->label, "Transform");
1744         pt->draw= view3d_panel_object;
1745         BLI_addtail(&art->paneltypes, pt);
1746 /*
1747         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel properties");
1748         strcpy(pt->idname, "VIEW3D_PT_properties");
1749         strcpy(pt->label, "View Properties");
1750         pt->draw= view3d_panel_properties;
1751         BLI_addtail(&art->paneltypes, pt);
1752
1753
1754         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel background");
1755         strcpy(pt->idname, "VIEW3D_PT_background");
1756         strcpy(pt->label, "Background Image");
1757         pt->draw= view3d_panel_background;
1758         BLI_addtail(&art->paneltypes, pt);
1759 */
1760         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel brush");
1761         strcpy(pt->idname, "VIEW3D_PT_brush");
1762         strcpy(pt->label, "Brush");
1763         pt->draw= view3d_panel_brush;
1764         pt->poll= view3d_panel_brush_poll;
1765         BLI_addtail(&art->paneltypes, pt);
1766 /*
1767         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel transform spaces");
1768         strcpy(pt->idname, "VIEW3D_PT_transform spaces");
1769         strcpy(pt->label, "Transform Orientations");
1770         pt->draw= view3d_panel_transform_spaces;
1771         BLI_addtail(&art->paneltypes, pt);
1772
1773         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel gpencil");
1774         strcpy(pt->idname, "VIEW3D_PT_gpencil");
1775         strcpy(pt->label, "Greas Pencil");
1776         pt->draw= view3d_panel_gpencil;
1777         BLI_addtail(&art->paneltypes, pt);*/
1778 /*
1779         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel bonesketch spaces");
1780         strcpy(pt->idname, "VIEW3D_PT_bonesketch_spaces");
1781         strcpy(pt->label, "Bone Sketching");
1782         pt->draw= view3d_panel_bonesketch_spaces;
1783         pt->poll= view3d_panel_bonesketch_spaces_poll;
1784         BLI_addtail(&art->paneltypes, pt);
1785
1786         pt= MEM_callocN(sizeof(PanelType), "spacetype view3d panel redo");
1787         strcpy(pt->idname, "VIEW3D_PT_redo");
1788         strcpy(pt->label, "Last Operator");
1789         pt->draw= view3d_panel_operator_redo;
1790         BLI_addtail(&art->paneltypes, pt);
1791 */
1792         // XXX view3d_panel_preview(C, ar, 0);
1793 }
1794
1795 static int view3d_properties(bContext *C, wmOperator *op)
1796 {
1797         ScrArea *sa= CTX_wm_area(C);
1798         ARegion *ar= view3d_has_buttons_region(sa);
1799
1800         if(ar) {
1801                 ar->flag ^= RGN_FLAG_HIDDEN;
1802                 ar->v2d.flag &= ~V2D_IS_INITIALISED; /* XXX should become hide/unhide api? */
1803
1804                 ED_area_initialize(CTX_wm_manager(C), CTX_wm_window(C), sa);
1805                 ED_area_tag_redraw(sa);
1806         }
1807         return OPERATOR_FINISHED;
1808 }
1809
1810 void VIEW3D_OT_properties(wmOperatorType *ot)
1811 {
1812         ot->name= "Properties";
1813         ot->idname= "VIEW3D_OT_properties";
1814
1815         ot->exec= view3d_properties;
1816         ot->poll= ED_operator_view3d_active;
1817
1818         /* flags */
1819         ot->flag= 0;
1820 }