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_action_types.h"
  35 #include "DNA_armature_types.h"
  36 #include "DNA_curve_types.h"
  37 #include "DNA_camera_types.h"
  38 #include "DNA_lamp_types.h"
  39 #include "DNA_lattice_types.h"
  40 #include "DNA_meta_types.h"
  41 #include "DNA_mesh_types.h"
  42 #include "DNA_meshdata_types.h"
  43 #include "DNA_object_types.h"
  44 #include "DNA_space_types.h"
  45 #include "DNA_scene_types.h"
  46 #include "DNA_screen_types.h"
  47 #include "DNA_userdef_types.h"
  48 #include "DNA_view3d_types.h"
  49 #include "DNA_world_types.h"
  50
  51 #include "MEM_guardedalloc.h"
  52
  53 #include "BLI_arithb.h"
  54 #include "BLI_blenlib.h"
  55 #include "BLI_editVert.h"
  56 #include "BLI_rand.h"
  57
  58 #include "BKE_action.h"
  59 #include "BKE_brush.h"
  60 #include "BKE_context.h"
  61 #include "BKE_curve.h"
  62 #include "BKE_customdata.h"
  63 #include "BKE_depsgraph.h"
  64 #include "BKE_object.h"
  65 #include "BKE_global.h"
  66 #include "BKE_scene.h"
  67 #include "BKE_screen.h"
  68 #include "BKE_utildefines.h"
  69
  70 #include "BIF_gl.h"
  71 #include "BIF_transform.h"
  72
  73 #include "WM_api.h"
  74 #include "WM_types.h"
  75
  76 #include "RNA_access.h"
  77 #include "RNA_define.h"
  78
  79 #include "ED_armature.h"
  80 #include "ED_curve.h"
  81 #include "ED_image.h"
  82 #include "ED_keyframing.h"
  83 #include "ED_mesh.h"
  84 #include "ED_object.h"
  85 #include "ED_particle.h"
  86 #include "ED_screen.h"
  87 #include "ED_types.h"
  88 #include "ED_util.h"
  89
  90 #include "UI_interface.h"
  91 #include "UI_resources.h"
  92 #include "UI_view2d.h"
  93
  94 #include "view3d_intern.h"      // own include
  95
  96
  97 /* ******************* view3d space & buttons ************** */
  98 #define B_NOP           1
  99 #define B_REDR          2
 100 #define B_OBJECTPANELROT        1007
 101 #define B_OBJECTPANELMEDIAN 1008
 102 #define B_ARMATUREPANEL1        1009
 103 #define B_ARMATUREPANEL2        1010
 104 #define B_OBJECTPANELPARENT 1011
 105 #define B_OBJECTPANEL           1012
 106 #define B_ARMATUREPANEL3        1013
 107 #define B_OBJECTPANELSCALE      1014
 108 #define B_OBJECTPANELDIMS       1015
 109 #define B_TRANSFORMSPACEADD     1016
 110 #define B_TRANSFORMSPACECLEAR   1017
 111 #define B_SETPT_AUTO    2125
 112 #define B_SETPT_VECTOR  2126
 113 #define B_SETPT_ALIGN   2127
 114 #define B_SETPT_FREE    2128
 115 #define B_RECALCMBALL   2501
 116
 117 #define B_WEIGHT0_0             2840
 118 #define B_WEIGHT1_4             2841
 119 #define B_WEIGHT1_2             2842
 120 #define B_WEIGHT3_4             2843
 121 #define B_WEIGHT1_0             2844
 122
 123 #define B_OPA1_8                2845
 124 #define B_OPA1_4                2846
 125 #define B_OPA1_2                2847
 126 #define B_OPA3_4                2848
 127 #define B_OPA1_0                2849
 128
 129 #define B_CLR_WPAINT    2850
 130
 131 #define B_RV3D_LOCKED   2900
 132 #define B_RV3D_BOXVIEW  2901
 133 #define B_RV3D_BOXCLIP  2902
 134
 135 #define B_IDNAME                3000
 136
 137 /* temporary struct for storing transform properties */
 138 typedef struct {
 139         float ob_eul[4];        // used for quat too....
 140         float ob_scale[3]; // need temp space due to linked values
 141         float ob_dims[3];
 142         short link_scale;
 143         float ve_median[5];
 144         int curdef;
 145         float *defweightp;
 146 } TransformProperties;
 147
 148
 149 /* is used for both read and write... */
 150 static void v3d_editvertex_buts(const bContext *C, uiBlock *block, View3D *v3d, Object *ob, float lim)
 151 {
 152         MDeformVert *dvert=NULL;
 153         TransformProperties *tfp= v3d->properties_storage;
 154         float median[5], ve_median[5];
 155         int tot, totw, totweight, totedge;
 156         char defstr[320];
 157
 158         median[0]= median[1]= median[2]= median[3]= median[4]= 0.0;
 159         tot= totw= totweight= totedge= 0;
 160         defstr[0]= 0;
 161
 162         if(ob->type==OB_MESH) {
 163                 Mesh *me= ob->data;
 164                 EditMesh *em = me->edit_mesh;
 165                 EditVert *eve, *evedef=NULL;
 166                 EditEdge *eed;
 167
 168                 eve= em->verts.first;
 169                 while(eve) {
 170                         if(eve->f & SELECT) {
 171                                 evedef= eve;
 172                                 tot++;
 173                                 VecAddf(median, median, eve->co);
 174                         }
 175                         eve= eve->next;
 176                 }
 177                 eed= em->edges.first;
 178                 while(eed) {
 179                         if((eed->f & SELECT)) {
 180                                 totedge++;
 181                                 median[3]+= eed->crease;
 182                         }
 183                         eed= eed->next;
 184                 }
 185
 186                 /* check for defgroups */
 187                 if(evedef)
 188                         dvert= CustomData_em_get(&em->vdata, evedef->data, CD_MDEFORMVERT);
 189                 if(tot==1 && dvert && dvert->totweight) {
 190                         bDeformGroup *dg;
 191                         int i, max=1, init=1;
 192                         char str[320];
 193
 194                         for (i=0; i<dvert->totweight; i++){
 195                                 dg = BLI_findlink (&ob->defbase, dvert->dw[i].def_nr);
 196                                 if(dg) {
 197                                         max+= BLI_snprintf(str, sizeof(str), "%s %%x%d|", dg->name, dvert->dw[i].def_nr);
 198                                         if(max<320) strcat(defstr, str);
 199                                 }
 200                                 else printf("oh no!\n");
 201                                 if(tfp->curdef==dvert->dw[i].def_nr) {
 202                                         init= 0;
 203                                         tfp->defweightp= &dvert->dw[i].weight;
 204                                 }
 205                         }
 206
 207                         if(init) {      // needs new initialized
 208                                 tfp->curdef= dvert->dw[0].def_nr;
 209                                 tfp->defweightp= &dvert->dw[0].weight;
 210                         }
 211                 }
 212         }
 213         else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
 214                 Curve *cu= ob->data;
 215                 Nurb *nu;
 216                 BPoint *bp;
 217                 BezTriple *bezt;
 218                 int a;
 219
 220                 nu= cu->editnurb->first;
 221                 while(nu) {
 222                         if((nu->type & 7)==CU_BEZIER) {
 223                                 bezt= nu->bezt;
 224                                 a= nu->pntsu;
 225                                 while(a--) {
 226                                         if(bezt->f2 & SELECT) {
 227                                                 VecAddf(median, median, bezt->vec[1]);
 228                                                 tot++;
 229                                                 median[4]+= bezt->weight;
 230                                                 totweight++;
 231                                         }
 232                                         else {
 233                                                 if(bezt->f1 & SELECT) {
 234                                                         VecAddf(median, median, bezt->vec[0]);
 235                                                         tot++;
 236                                                 }
 237                                                 if(bezt->f3 & SELECT) {
 238                                                         VecAddf(median, median, bezt->vec[2]);
 239                                                         tot++;
 240                                                 }
 241                                         }
 242                                         bezt++;
 243                                 }
 244                         }
 245                         else {
 246                                 bp= nu->bp;
 247                                 a= nu->pntsu*nu->pntsv;
 248                                 while(a--) {
 249                                         if(bp->f1 & SELECT) {
 250                                                 VecAddf(median, median, bp->vec);
 251                                                 median[3]+= bp->vec[3];
 252                                                 totw++;
 253                                                 tot++;
 254                                                 median[4]+= bp->weight;
 255                                                 totweight++;
 256                                         }
 257                                         bp++;
 258                                 }
 259                         }
 260                         nu= nu->next;
 261                 }
 262         }
 263         else if(ob->type==OB_LATTICE) {
 264                 Lattice *lt= ob->data;
 265                 BPoint *bp;
 266                 int a;
 267
 268                 a= lt->editlatt->pntsu*lt->editlatt->pntsv*lt->editlatt->pntsw;
 269                 bp= lt->editlatt->def;
 270                 while(a--) {
 271                         if(bp->f1 & SELECT) {
 272                                 VecAddf(median, median, bp->vec);
 273                                 tot++;
 274                                 median[4]+= bp->weight;
 275                                 totweight++;
 276                         }
 277                         bp++;
 278                 }
 279         }
 280
 281         if(tot==0) return;
 282
 283         median[0] /= (float)tot;
 284         median[1] /= (float)tot;
 285         median[2] /= (float)tot;
 286         if(totedge) median[3] /= (float)totedge;
 287         else if(totw) median[3] /= (float)totw;
 288         if(totweight) median[4] /= (float)totweight;
 289
 290         if(v3d->flag & V3D_GLOBAL_STATS)
 291                 Mat4MulVecfl(ob->obmat, median);
 292
 293         if(block) {     // buttons
 294                 int but_y;
 295                 if((ob->parent) && (ob->partype == PARBONE))    but_y = 135;
 296                 else                                                                                    but_y = 150;
 297
 298                 uiBlockBeginAlign(block);
 299                 uiDefButBitS(block, TOG, V3D_GLOBAL_STATS, B_REDR, "Global",            160, but_y, 70, 19, &v3d->flag, 0, 0, 0, 0, "Displays global values");
 300                 uiDefButBitS(block, TOGN, V3D_GLOBAL_STATS, B_REDR, "Local",            230, but_y, 70, 19, &v3d->flag, 0, 0, 0, 0, "Displays local values");
 301                 uiBlockEndAlign(block);
 302
 303                 memcpy(tfp->ve_median, median, sizeof(tfp->ve_median));
 304
 305                 uiBlockBeginAlign(block);
 306                 if(tot==1) {
 307                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex X:", 10, 110, 290, 19, &(tfp->ve_median[0]), -lim, lim, 10, 3, "");
 308                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex Y:", 10, 90, 290, 19, &(tfp->ve_median[1]), -lim, lim, 10, 3, "");
 309                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex Z:", 10, 70, 290, 19, &(tfp->ve_median[2]), -lim, lim, 10, 3, "");
 310                         if(totw==1)
 311                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex W:", 10, 50, 290, 19, &(tfp->ve_median[3]), 0.01, 100.0, 10, 3, "");
 312                         uiBlockEndAlign(block);
 313
 314                         if(defstr[0]) {
 315                                 uiDefBut(block, LABEL, 1, "Vertex Deform Groups",               10, 40, 290, 20, NULL, 0.0, 0.0, 0, 0, "");
 316
 317                                 uiBlockBeginAlign(block);
 318                                 uiDefButF(block, NUM, B_NOP, "Weight:",                 10, 20, 150, 19, tfp->defweightp, 0.0f, 1.0f, 10, 3, "Weight value");
 319                                 uiDefButI(block, MENU, B_REDR, defstr,  160, 20, 140, 19, &tfp->curdef, 0.0, 0.0, 0, 0, "Current Vertex Group");
 320                                 uiBlockEndAlign(block);
 321                         }
 322                         else if(totweight)
 323                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   10, 20, 290, 19, &(tfp->ve_median[4]), 0.0, 1.0, 10, 3, "");
 324
 325                 }
 326                 else {
 327                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median X:", 10, 110, 290, 19, &(tfp->ve_median[0]), -lim, lim, 10, 3, "");
 328                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Y:", 10, 90, 290, 19, &(tfp->ve_median[1]), -lim, lim, 10, 3, "");
 329                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Z:", 10, 70, 290, 19, &(tfp->ve_median[2]), -lim, lim, 10, 3, "");
 330                         if(totw==tot)
 331                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median W:", 10, 50, 290, 19, &(tfp->ve_median[3]), 0.01, 100.0, 10, 3, "");
 332                         uiBlockEndAlign(block);
 333                         if(totweight)
 334                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   10, 20, 290, 19, &(tfp->ve_median[4]), 0.0, 1.0, 10, 3, "Weight is used for SoftBody Goal");
 335                 }
 336
 337                 if(ob->type==OB_CURVE && (totw==0)) { /* bez curves have no w */
 338                         uiBlockBeginAlign(block);
 339                         uiDefBut(block, BUT,B_SETPT_AUTO,"Auto",        10, 44, 72, 19, 0, 0, 0, 0, 0, "Auto handles (Shift H)");
 340                         uiDefBut(block, BUT,B_SETPT_VECTOR,"Vector",82, 44, 73, 19, 0, 0, 0, 0, 0, "Vector handles (V)");
 341                         uiDefBut(block, BUT,B_SETPT_ALIGN,"Align",155, 44, 73, 19, 0, 0, 0, 0, 0, "Align handles (H Toggles)");
 342                         uiDefBut(block, BUT,B_SETPT_FREE,"Free",        227, 44, 72, 19, 0, 0, 0, 0, 0, "Align handles (H Toggles)");
 343                         uiBlockEndAlign(block);
 344                 }
 345
 346                 if(totedge==1)
 347                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Crease W:", 10, 30, 290, 19, &(tfp->ve_median[3]), 0.0, 1.0, 10, 3, "");
 348                 else if(totedge>1)
 349                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Crease W:",  10, 30, 290, 19, &(tfp->ve_median[3]), 0.0, 1.0, 10, 3, "");
 350
 351         }
 352         else {  // apply
 353                 memcpy(ve_median, tfp->ve_median, sizeof(tfp->ve_median));
 354
 355                 if(v3d->flag & V3D_GLOBAL_STATS) {
 356                         Mat4Invert(ob->imat, ob->obmat);
 357                         Mat4MulVecfl(ob->imat, median);
 358                         Mat4MulVecfl(ob->imat, ve_median);
 359                 }
 360                 VecSubf(median, ve_median, median);
 361                 median[3]= ve_median[3]-median[3];
 362                 median[4]= ve_median[4]-median[4];
 363
 364                 if(ob->type==OB_MESH) {
 365                         Mesh *me= ob->data;
 366                         EditMesh *em = me->edit_mesh;
 367                         EditVert *eve;
 368                         EditEdge *eed;
 369
 370                         eve= em->verts.first;
 371                         while(eve) {
 372                                 if(eve->f & SELECT) {
 373                                         VecAddf(eve->co, eve->co, median);
 374                                 }
 375                                 eve= eve->next;
 376                         }
 377
 378                         for(eed= em->edges.first; eed; eed= eed->next) {
 379                                 if(eed->f & SELECT) {
 380                                         /* ensure the median can be set to zero or one */
 381                                         if(ve_median[3]==0.0f) eed->crease= 0.0f;
 382                                         else if(ve_median[3]==1.0f) eed->crease= 1.0f;
 383                                         else {
 384                                                 eed->crease+= median[3];
 385                                                 CLAMP(eed->crease, 0.0, 1.0);
 386                                         }
 387                                 }
 388                         }
 389
 390                         recalc_editnormals(em);
 391                 }
 392                 else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
 393                         Curve *cu= ob->data;
 394                         Nurb *nu;
 395                         BPoint *bp;
 396                         BezTriple *bezt;
 397                         int a;
 398
 399                         nu= cu->editnurb->first;
 400                         while(nu) {
 401                                 if((nu->type & 7)==1) {
 402                                         bezt= nu->bezt;
 403                                         a= nu->pntsu;
 404                                         while(a--) {
 405                                                 if(bezt->f2 & SELECT) {
 406                                                         VecAddf(bezt->vec[0], bezt->vec[0], median);
 407                                                         VecAddf(bezt->vec[1], bezt->vec[1], median);
 408                                                         VecAddf(bezt->vec[2], bezt->vec[2], median);
 409                                                         bezt->weight+= median[4];
 410                                                 }
 411                                                 else {
 412                                                         if(bezt->f1 & SELECT) {
 413                                                                 VecAddf(bezt->vec[0], bezt->vec[0], median);
 414                                                         }
 415                                                         if(bezt->f3 & SELECT) {
 416                                                                 VecAddf(bezt->vec[2], bezt->vec[2], median);
 417                                                         }
 418                                                 }
 419                                                 bezt++;
 420                                         }
 421                                 }
 422                                 else {
 423                                         bp= nu->bp;
 424                                         a= nu->pntsu*nu->pntsv;
 425                                         while(a--) {
 426                                                 if(bp->f1 & SELECT) {
 427                                                         VecAddf(bp->vec, bp->vec, median);
 428                                                         bp->vec[3]+= median[3];
 429                                                         bp->weight+= median[4];
 430                                                 }
 431                                                 bp++;
 432                                         }
 433                                 }
 434                                 test2DNurb(nu);
 435                                 testhandlesNurb(nu); /* test for bezier too */
 436
 437                                 nu= nu->next;
 438                         }
 439                 }
 440                 else if(ob->type==OB_LATTICE) {
 441                         Lattice *lt= ob->data;
 442                         BPoint *bp;
 443                         int a;
 444
 445                         a= lt->editlatt->pntsu*lt->editlatt->pntsv*lt->editlatt->pntsw;
 446                         bp= lt->editlatt->def;
 447                         while(a--) {
 448                                 if(bp->f1 & SELECT) {
 449                                         VecAddf(bp->vec, bp->vec, median);
 450                                         bp->weight+= median[4];
 451                                 }
 452                                 bp++;
 453                         }
 454                 }
 455
 456 //              ED_undo_push(C, "Transform properties");
 457         }
 458 }
 459
 460 /* assumes armature active */
 461 static void validate_bonebutton_cb(bContext *C, void *bonev, void *namev)
 462 {
 463         Object *ob= CTX_data_active_object(C);
 464
 465         if(ob && ob->type==OB_ARMATURE) {
 466                 Bone *bone= bonev;
 467                 char oldname[32], newname[32];
 468
 469                 /* need to be on the stack */
 470                 BLI_strncpy(newname, bone->name, 32);
 471                 BLI_strncpy(oldname, (char *)namev, 32);
 472                 /* restore */
 473                 BLI_strncpy(bone->name, oldname, 32);
 474
 475                 armature_bone_rename(ob, oldname, newname); // editarmature.c
 476         }
 477 }
 478
 479 static void v3d_posearmature_buts(uiBlock *block, View3D *v3d, Object *ob, float lim)
 480 {
 481         uiBut *but;
 482         bArmature *arm;
 483         bPoseChannel *pchan;
 484         Bone *bone= NULL;
 485         TransformProperties *tfp= v3d->properties_storage;
 486
 487         arm = ob->data;
 488         if (!arm || !ob->pose) return;
 489
 490         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
 491                 bone = pchan->bone;
 492                 if(bone && (bone->flag & BONE_ACTIVE) && (bone->layer & arm->layer))
 493                         break;
 494         }
 495         if (!pchan || !bone) return;
 496
 497         if((ob->parent) && (ob->partype == PARBONE))
 498                 but= uiDefBut (block, TEX, B_NOP, "Bone:",                              160, 130, 140, 19, bone->name, 1, 31, 0, 0, "");
 499         else
 500                 but= uiDefBut(block, TEX, B_NOP, "Bone:",                               160, 140, 140, 19, bone->name, 1, 31, 0, 0, "");
 501         uiButSetFunc(but, validate_bonebutton_cb, bone, NULL);
 502         uiButSetCompleteFunc(but, autocomplete_bone, (void *)ob);
 503
 504         QuatToEul(pchan->quat, tfp->ob_eul);
 505         tfp->ob_eul[0]*= 180.0/M_PI;
 506         tfp->ob_eul[1]*= 180.0/M_PI;
 507         tfp->ob_eul[2]*= 180.0/M_PI;
 508
 509         uiBlockBeginAlign(block);
 510         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");
 511         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocX:",        30, 140, 120, 19, pchan->loc, -lim, lim, 100, 3, "");
 512         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");
 513         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocY:",        30, 120, 120, 19, pchan->loc+1, -lim, lim, 100, 3, "");
 514         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");
 515         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocZ:",        30, 100, 120, 19, pchan->loc+2, -lim, lim, 100, 3, "");
 516
 517         uiBlockBeginAlign(block);
 518         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");
 519         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotX:",        30, 70, 120, 19, tfp->ob_eul, -1000.0, 1000.0, 100, 3, "");
 520         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");
 521         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotY:",        30, 50, 120, 19, tfp->ob_eul+1, -1000.0, 1000.0, 100, 3, "");
 522         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");
 523         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotZ:",        30, 30, 120, 19, tfp->ob_eul+2, -1000.0, 1000.0, 100, 3, "");
 524
 525         uiBlockBeginAlign(block);
 526         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");
 527         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleX:",      180, 70, 120, 19, pchan->size, -lim, lim, 10, 3, "");
 528         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");
 529         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleY:",      180, 50, 120, 19, pchan->size+1, -lim, lim, 10, 3, "");
 530         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");
 531         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleZ:",      180, 30, 120, 19, pchan->size+2, -lim, lim, 10, 3, "");
 532         uiBlockEndAlign(block);
 533 }
 534
 535 /* assumes armature editmode */
 536 void validate_editbonebutton_cb(bContext *C, void *bonev, void *namev)
 537 {
 538         EditBone *eBone= bonev;
 539         char oldname[32], newname[32];
 540
 541         /* need to be on the stack */
 542         BLI_strncpy(newname, eBone->name, 32);
 543         BLI_strncpy(oldname, (char *)namev, 32);
 544         /* restore */
 545         BLI_strncpy(eBone->name, oldname, 32);
 546
 547         armature_bone_rename(CTX_data_edit_object(C), oldname, newname); // editarmature.c
 548         WM_event_add_notifier(C, NC_OBJECT|ND_BONE_SELECT, CTX_data_edit_object(C)); // XXX fix
 549 }
 550
 551 static void v3d_editarmature_buts(uiBlock *block, View3D *v3d, Object *ob, float lim)
 552 {
 553         bArmature *arm= ob->data;
 554         EditBone *ebone;
 555         uiBut *but;
 556         TransformProperties *tfp= v3d->properties_storage;
 557
 558         ebone= arm->edbo->first;
 559
 560         for (ebone = arm->edbo->first; ebone; ebone=ebone->next){
 561                 if ((ebone->flag & BONE_ACTIVE) && (ebone->layer & arm->layer))
 562                         break;
 563         }
 564
 565         if (!ebone)
 566                 return;
 567
 568         if((ob->parent) && (ob->partype == PARBONE))
 569                 but= uiDefBut(block, TEX, B_NOP, "Bone:", 160, 130, 140, 19, ebone->name, 1, 31, 0, 0, "");
 570         else
 571                 but= uiDefBut(block, TEX, B_NOP, "Bone:",                       160, 150, 140, 19, ebone->name, 1, 31, 0, 0, "");
 572         uiButSetFunc(but, validate_editbonebutton_cb, ebone, NULL);
 573
 574         uiBlockBeginAlign(block);
 575         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadX:",       10, 70, 140, 19, ebone->head, -lim, lim, 10, 3, "");
 576         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadY:",       10, 50, 140, 19, ebone->head+1, -lim, lim, 10, 3, "");
 577         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadZ:",       10, 30, 140, 19, ebone->head+2, -lim, lim, 10, 3, "");
 578         uiBlockBeginAlign(block);
 579         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailX:",       160, 70, 140, 19, ebone->tail, -lim, lim, 10, 3, "");
 580         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailY:",       160, 50, 140, 19, ebone->tail+1, -lim, lim, 10, 3, "");
 581         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailZ:",       160, 30, 140, 19, ebone->tail+2, -lim, lim, 10, 3, "");
 582         uiBlockEndAlign(block);
 583
 584         tfp->ob_eul[0]= 180.0*ebone->roll/M_PI;
 585         uiDefButF(block, NUM, B_ARMATUREPANEL1, "Roll:",        10, 100, 140, 19, tfp->ob_eul, -lim, lim, 1000, 3, "");
 586
 587         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");
 588
 589         uiBlockBeginAlign(block);
 590         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailRadius:",  10, 150, 140, 19, &ebone->rad_tail, 0, lim, 10, 3, "");
 591         if (ebone->parent && ebone->flag & BONE_CONNECTED )
 592                 uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadRadius:",  10, 130, 140, 19, &ebone->parent->rad_tail, 0, lim, 10, 3, "");
 593         else
 594                 uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadRadius:",  10, 130, 140, 19, &ebone->rad_head, 0, lim, 10, 3, "");
 595         uiBlockEndAlign(block);
 596 }
 597
 598 static void v3d_editmetaball_buts(uiBlock *block, Object *ob, float lim)
 599 {
 600         MetaElem *lastelem= NULL; // XXX
 601
 602         if(lastelem) {
 603                 uiBlockBeginAlign(block);
 604                 uiDefButF(block, NUM, B_RECALCMBALL, "LocX:", 10, 70, 140, 19, &lastelem->x, -lim, lim, 100, 3, "");
 605                 uiDefButF(block, NUM, B_RECALCMBALL, "LocY:", 10, 50, 140, 19, &lastelem->y, -lim, lim, 100, 3, "");
 606                 uiDefButF(block, NUM, B_RECALCMBALL, "LocZ:", 10, 30, 140, 19, &lastelem->z, -lim, lim, 100, 3, "");
 607
 608                 uiBlockBeginAlign(block);
 609                 if(lastelem->type!=MB_BALL)
 610                         uiDefButF(block, NUM, B_RECALCMBALL, "dx:", 160, 70, 140, 19, &lastelem->expx, 0, lim, 100, 3, "");
 611                 if((lastelem->type!=MB_BALL) && (lastelem->type!=MB_TUBE))
 612                         uiDefButF(block, NUM, B_RECALCMBALL, "dy:", 160, 50, 140, 19, &lastelem->expy, 0, lim, 100, 3, "");
 613                 if((lastelem->type==MB_ELIPSOID) || (lastelem->type==MB_CUBE))
 614                         uiDefButF(block, NUM, B_RECALCMBALL, "dz:", 160, 30, 140, 19, &lastelem->expz, 0, lim, 100, 3, "");
 615
 616                 uiBlockEndAlign(block);
 617
 618                 uiBlockBeginAlign(block);
 619                 uiDefButF(block, NUM, B_RECALCMBALL, "Radius:", 10, 120, 140, 19, &lastelem->rad, 0, lim, 100, 3, "Size of the active metaball");
 620                 uiDefButF(block, NUM, B_RECALCMBALL, "Stiffness:", 10, 100, 140, 19, &lastelem->s, 0, 10, 100, 3, "Stiffness of the active metaball");
 621                 uiBlockEndAlign(block);
 622
 623                 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");
 624
 625         }
 626 }
 627
 628 /* test if 'ob' is a parent somewhere in par's parents */
 629 static int test_parent_loop(Object *par, Object *ob)
 630 {
 631         if(par == NULL) return 0;
 632         if(ob == par) return 1;
 633         return test_parent_loop(par->parent, ob);
 634 }
 635
 636 static void do_view3d_region_buttons(bContext *C, void *arg, int event)
 637 {
 638         Scene *scene= CTX_data_scene(C);
 639         Object *obedit= CTX_data_edit_object(C);
 640         View3D *v3d= CTX_wm_view3d(C);
 641         BoundBox *bb;
 642         Object *ob= OBACT;
 643         TransformProperties *tfp= v3d->properties_storage;
 644
 645         switch(event) {
 646
 647         case B_REDR:
 648                 ED_area_tag_redraw(CTX_wm_area(C));
 649                 return; /* no notifier! */
 650
 651         case B_OBJECTPANEL:
 652                 DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 653                 break;
 654
 655         case B_OBJECTPANELROT:
 656                 if(ob) {
 657                         ob->rot[0]= M_PI*tfp->ob_eul[0]/180.0;
 658                         ob->rot[1]= M_PI*tfp->ob_eul[1]/180.0;
 659                         ob->rot[2]= M_PI*tfp->ob_eul[2]/180.0;
 660                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 661                 }
 662                 break;
 663
 664         case B_OBJECTPANELSCALE:
 665                 if(ob) {
 666
 667                         /* link scale; figure out which axis changed */
 668                         if (tfp->link_scale) {
 669                                 float ratio, tmp, max = 0.0;
 670                                 int axis;
 671
 672                                 axis = 0;
 673                                 max = fabs(tfp->ob_scale[0] - ob->size[0]);
 674                                 tmp = fabs(tfp->ob_scale[1] - ob->size[1]);
 675                                 if (tmp > max) {
 676                                         axis = 1;
 677                                         max = tmp;
 678                                 }
 679                                 tmp = fabs(tfp->ob_scale[2] - ob->size[2]);
 680                                 if (tmp > max) {
 681                                         axis = 2;
 682                                         max = tmp;
 683                                 }
 684
 685                                 if (ob->size[axis] != tfp->ob_scale[axis]) {
 686                                         if (fabs(ob->size[axis]) > FLT_EPSILON) {
 687                                                 ratio = tfp->ob_scale[axis] / ob->size[axis];
 688                                                 ob->size[0] *= ratio;
 689                                                 ob->size[1] *= ratio;
 690                                                 ob->size[2] *= ratio;
 691                                         }
 692                                 }
 693                         }
 694                         else {
 695                                 VECCOPY(ob->size, tfp->ob_scale);
 696
 697                         }
 698                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 699                 }
 700                 break;
 701
 702         case B_OBJECTPANELDIMS:
 703                 bb= object_get_boundbox(ob);
 704                 if(bb) {
 705                         float old_dims[3], scale[3], ratio, len[3];
 706                         int axis;
 707
 708                         Mat4ToSize(ob->obmat, scale);
 709
 710                         len[0] = bb->vec[4][0] - bb->vec[0][0];
 711                         len[1] = bb->vec[2][1] - bb->vec[0][1];
 712                         len[2] = bb->vec[1][2] - bb->vec[0][2];
 713
 714                         old_dims[0] = fabs(scale[0]) * len[0];
 715                         old_dims[1] = fabs(scale[1]) * len[1];
 716                         old_dims[2] = fabs(scale[2]) * len[2];
 717
 718                         /* for each axis changed */
 719                         for (axis = 0; axis<3; axis++) {
 720                                 if (fabs(old_dims[axis] - tfp->ob_dims[axis]) > 0.0001) {
 721                                         if (old_dims[axis] > 0.0) {
 722                                                 ratio = tfp->ob_dims[axis] / old_dims[axis];
 723                                                 if (tfp->link_scale) {
 724                                                         ob->size[0] *= ratio;
 725                                                         ob->size[1] *= ratio;
 726                                                         ob->size[2] *= ratio;
 727                                                         break;
 728                                                 }
 729                                                 else {
 730                                                         ob->size[axis] *= ratio;
 731                                                 }
 732                                         }
 733                                         else {
 734                                                 if (len[axis] > 0) {
 735                                                         ob->size[axis] = tfp->ob_dims[axis] / len[axis];
 736                                                 }
 737                                         }
 738                                 }
 739                         }
 740
 741                         /* prevent multiple B_OBJECTPANELDIMS events to keep scaling, cycling with TAB on buttons can cause that */
 742                         VECCOPY(tfp->ob_dims, old_dims);
 743
 744                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 745                 }
 746                 break;
 747
 748         case B_OBJECTPANELMEDIAN:
 749                 if(ob) {
 750                         v3d_editvertex_buts(C, NULL, v3d, ob, 1.0);
 751                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
 752                 }
 753                 break;
 754
 755                 /* note; this case also used for parbone */
 756         case B_OBJECTPANELPARENT:
 757                 if(ob) {
 758                         if(ob->id.lib || test_parent_loop(ob->parent, ob) )
 759                                 ob->parent= NULL;
 760                         else {
 761                                 DAG_scene_sort(scene);
 762                                 DAG_object_flush_update(scene, ob, OB_RECALC_OB);
 763                         }
 764                 }
 765                 break;
 766
 767         case B_ARMATUREPANEL1:
 768                 {
 769                         bArmature *arm= obedit->data;
 770                         EditBone *ebone, *child;
 771
 772                         for (ebone = arm->edbo->first; ebone; ebone=ebone->next){
 773                                 if ((ebone->flag & BONE_ACTIVE) && (ebone->layer & arm->layer))
 774                                         break;
 775                         }
 776                         if (ebone) {
 777                                 ebone->roll= M_PI*tfp->ob_eul[0]/180.0;
 778                                 //      Update our parent
 779                                 if (ebone->parent && ebone->flag & BONE_CONNECTED){
 780                                         VECCOPY (ebone->parent->tail, ebone->head);
 781                                 }
 782
 783                                 //      Update our children if necessary
 784                                 for (child = arm->edbo->first; child; child=child->next){
 785                                         if (child->parent == ebone && (child->flag & BONE_CONNECTED)){
 786                                                 VECCOPY (child->head, ebone->tail);
 787                                         }
 788                                 }
 789                                 if(arm->flag & ARM_MIRROR_EDIT) {
 790                                         EditBone *eboflip= ED_armature_bone_get_mirrored(arm->edbo, ebone);
 791                                         if(eboflip) {
 792                                                 eboflip->roll= -ebone->roll;
 793                                                 eboflip->head[0]= -ebone->head[0];
 794                                                 eboflip->tail[0]= -ebone->tail[0];
 795
 796                                                 //      Update our parent
 797                                                 if (eboflip->parent && eboflip->flag & BONE_CONNECTED){
 798                                                         VECCOPY (eboflip->parent->tail, eboflip->head);
 799                                                 }
 800
 801                                                 //      Update our children if necessary
 802                                                 for (child = arm->edbo->first; child; child=child->next){
 803                                                         if (child->parent == eboflip && (child->flag & BONE_CONNECTED)){
 804                                                                 VECCOPY (child->head, eboflip->tail);
 805                                                         }
 806                                                 }
 807                                         }
 808                                 }
 809                         }
 810                 }
 811                 break;
 812         case B_ARMATUREPANEL3:  // rotate button on channel
 813                 {
 814                         bArmature *arm;
 815                         bPoseChannel *pchan;
 816                         Bone *bone;
 817                         float eul[3];
 818
 819                         arm = ob->data;
 820                         if (!arm || !ob->pose) return;
 821
 822                         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
 823                                 bone = pchan->bone;
 824                                 if(bone && (bone->flag & BONE_ACTIVE) && (bone->layer & arm->layer))
 825                                         break;
 826                         }
 827                         if (!pchan) return;
 828
 829                         /* make a copy to eul[3], to allow TAB on buttons to work */
 830                         eul[0]= M_PI*tfp->ob_eul[0]/180.0;
 831                         eul[1]= M_PI*tfp->ob_eul[1]/180.0;
 832                         eul[2]= M_PI*tfp->ob_eul[2]/180.0;
 833                         EulToQuat(eul, pchan->quat);
 834                 }
 835                 /* no break, pass on */
 836         case B_ARMATUREPANEL2:
 837                 {
 838                         ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
 839                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
 840                 }
 841                 break;
 842         case B_TRANSFORMSPACEADD:
 843                 BIF_manageTransformOrientation(C, 1, 0);
 844                 break;
 845         case B_TRANSFORMSPACECLEAR:
 846                 BIF_clearTransformOrientation(C);
 847                 break;
 848
 849 #if 0 // XXX
 850         case B_WEIGHT0_0:
 851                 wpaint->weight = 0.0f;
 852                 break;
 853
 854         case B_WEIGHT1_4:
 855                 wpaint->weight = 0.25f;
 856                 break;
 857         case B_WEIGHT1_2:
 858                 wpaint->weight = 0.5f;
 859                 break;
 860         case B_WEIGHT3_4:
 861                 wpaint->weight = 0.75f;
 862                 break;
 863         case B_WEIGHT1_0:
 864                 wpaint->weight = 1.0f;
 865                 break;
 866
 867         case B_OPA1_8:
 868                 wpaint->a = 0.125f;
 869                 break;
 870         case B_OPA1_4:
 871                 wpaint->a = 0.25f;
 872                 break;
 873         case B_OPA1_2:
 874                 wpaint->a = 0.5f;
 875                 break;
 876         case B_OPA3_4:
 877                 wpaint->a = 0.75f;
 878                 break;
 879         case B_OPA1_0:
 880                 wpaint->a = 1.0f;
 881                 break;
 882 #endif
 883         case B_CLR_WPAINT:
 884 //              if(!multires_level1_test()) {
 885                 {
 886                         bDeformGroup *defGroup = BLI_findlink(&ob->defbase, ob->actdef-1);
 887                         if(defGroup) {
 888                                 Mesh *me= ob->data;
 889                                 int a;
 890                                 for(a=0; a<me->totvert; a++)
 891                                         remove_vert_defgroup (ob, defGroup, a);
 892                                 DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
 893                         }
 894                 }
 895                 break;
 896         case B_RV3D_LOCKED:
 897         case B_RV3D_BOXVIEW:
 898         case B_RV3D_BOXCLIP:
 899                 {
 900                         ScrArea *sa= CTX_wm_area(C);
 901                         ARegion *ar= sa->regionbase.last;
 902                         RegionView3D *rv3d;
 903                         short viewlock;
 904
 905                         ar= ar->prev;
 906                         rv3d= ar->regiondata;
 907                         viewlock= rv3d->viewlock;
 908
 909                         if((viewlock & RV3D_LOCKED)==0)
 910                                 viewlock= 0;
 911                         else if((viewlock & RV3D_BOXVIEW)==0)
 912                                 viewlock &= ~RV3D_BOXCLIP;
 913
 914                         for(; ar; ar= ar->prev) {
 915                                 if(ar->alignment==RGN_ALIGN_QSPLIT) {
 916                                         rv3d= ar->regiondata;
 917                                         rv3d->viewlock= viewlock;
 918                                 }
 919                         }
 920
 921                         if(rv3d->viewlock & RV3D_BOXVIEW)
 922                                 view3d_boxview_copy(sa, sa->regionbase.last);
 923
 924                         ED_area_tag_redraw(sa);
 925                 }
 926                 break;
 927         }
 928
 929         /* default for now */
 930         WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, ob);
 931 }
 932
 933 void removeTransformOrientation_func(bContext *C, void *target, void *unused)
 934 {
 935         BIF_removeTransformOrientation(C, (TransformOrientation *) target);
 936 }
 937
 938 void selectTransformOrientation_func(bContext *C, void *target, void *unused)
 939 {
 940         BIF_selectTransformOrientation(C, (TransformOrientation *) target);
 941 }
 942
 943 static void view3d_panel_transform_spaces(const bContext *C, ARegion *ar, short cntrl)
 944 {
 945         Scene *scene= CTX_data_scene(C);
 946         Object *obedit= CTX_data_edit_object(C);
 947         View3D *v3d= CTX_wm_view3d(C);
 948         ListBase *transform_spaces = &scene->transform_spaces;
 949         TransformOrientation *ts = transform_spaces->first;
 950         uiBlock *block;
 951         uiBut *but;
 952         int xco = 20, yco = 70, height = 140;
 953         int index;
 954
 955         block= uiBeginBlock(C, ar, "view3d_panel_transform", UI_EMBOSS, UI_HELV);
 956         if(uiNewPanel(C, ar, block, "Transform Orientations", "View3d", 1000, 0, 318, height)==0) return;
 957
 958         uiNewPanelHeight(block, height);
 959
 960         uiBlockBeginAlign(block);
 961
 962         if (obedit)
 963                 uiDefBut(block, BUT, B_TRANSFORMSPACEADD, "Add", xco,120,80,20, 0, 0, 0, 0, 0, "Add the selected element as a Transform Orientation");
 964         else
 965                 uiDefBut(block, BUT, B_TRANSFORMSPACEADD, "Add", xco,120,80,20, 0, 0, 0, 0, 0, "Add the active object as a Transform Orientation");
 966
 967         uiDefBut(block, BUT, B_TRANSFORMSPACECLEAR, "Clear", xco + 80,120,80,20, 0, 0, 0, 0, 0, "Removal all Transform Orientations");
 968
 969         uiBlockEndAlign(block);
 970
 971         uiBlockBeginAlign(block);
 972
 973         uiDefButS(block, ROW, B_REDR, "Global", xco,            90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_GLOBAL,0, 0, "Global Transform Orientation");
 974         uiDefButS(block, ROW, B_REDR, "Local",  xco + 40,       90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_LOCAL, 0, 0, "Local Transform Orientation");
 975         uiDefButS(block, ROW, B_REDR, "Normal", xco + 80,       90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_NORMAL,0, 0, "Normal Transform Orientation");
 976         uiDefButS(block, ROW, B_REDR, "View",           xco + 120,      90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_VIEW,    0, 0, "View Transform Orientation");
 977
 978         for (index = V3D_MANIP_CUSTOM, ts = transform_spaces->first ; ts ; ts = ts->next, index++) {
 979
 980                 UI_ThemeColor(TH_BUT_ACTION);
 981                 if (v3d->twmode == index) {
 982                         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");
 983                 }
 984                 else {
 985                         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");
 986                 }
 987                 uiButSetFunc(but, selectTransformOrientation_func, ts, NULL);
 988                 uiDefBut(block, TEX, 0, "", xco+=XIC, yco,100+XIC,20, &ts->name, 0, 30, 0, 0, "Edits the name of this Transform Orientation");
 989                 but = uiDefIconBut(block, BUT, B_REDR, ICON_X, xco+=100+XIC,yco,XIC,YIC, 0, 0, 0, 0, 0, "Deletes this Transform Orientation");
 990                 uiButSetFunc(but, removeTransformOrientation_func, ts, NULL);
 991
 992                 xco = 20;
 993                 yco -= 25;
 994         }
 995         uiBlockEndAlign(block);
 996
 997         if(yco < 0) uiNewPanelHeight(block, height-yco);
 998         uiEndBlock(C, block);
 999 }
1000
1001 static void weight_paint_buttons(Scene *scene, uiBlock *block)
1002 {
1003         VPaint *wpaint= scene->toolsettings->wpaint;
1004         Object *ob;
1005         ob= OBACT;
1006
1007         if(ob==NULL || ob->type!=OB_MESH) return;
1008
1009         /* XXX
1010         uiBlockBeginAlign(block);
1011         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");
1012
1013         uiDefBut(block, BUT, B_WEIGHT0_0 , "0",                  10,150,45,19, 0, 0, 0, 0, 0, "");
1014         uiDefBut(block, BUT, B_WEIGHT1_4 , "1/4",                55,150,45,19, 0, 0, 0, 0, 0, "");
1015         uiDefBut(block, BUT, B_WEIGHT1_2 , "1/2",                100,150,45,19, 0, 0, 0, 0, 0, "");
1016         uiDefBut(block, BUT, B_WEIGHT3_4 , "3/4",                145,150,45,19, 0, 0, 0, 0, 0, "");
1017         uiDefBut(block, BUT, B_WEIGHT1_0 , "1",                  190,150,45,19, 0, 0, 0, 0, 0, "");
1018
1019         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");
1020
1021         uiDefBut(block, BUT, B_OPA1_8 , "1/8",          10,110,45,19, 0, 0, 0, 0, 0, "");
1022         uiDefBut(block, BUT, B_OPA1_4 , "1/4",          55,110,45,19, 0, 0, 0, 0, 0, "");
1023         uiDefBut(block, BUT, B_OPA1_2 , "1/2",          100,110,45,19, 0, 0, 0, 0, 0, "");
1024         uiDefBut(block, BUT, B_OPA3_4 , "3/4",          145,110,45,19, 0, 0, 0, 0, 0, "");
1025         uiDefBut(block, BUT, B_OPA1_0 , "1",            190,110,45,19, 0, 0, 0, 0, 0, "");
1026
1027         uiDefButF(block, NUMSLI, B_NOP, "Size ",        10,90,225,19, &wpaint->size, 2.0, 64.0, 0, 0, "The size of the brush");
1028
1029         uiBlockBeginAlign(block);
1030         uiDefButS(block, ROW, B_NOP, "Mix",             250,170,60,17, &wpaint->mode, 1.0, 0.0, 0, 0, "Mix the vertex colors");
1031         uiDefButS(block, ROW, B_NOP, "Add",             250,152,60,17, &wpaint->mode, 1.0, 1.0, 0, 0, "Add the vertex colors");
1032         uiDefButS(block, ROW, B_NOP, "Sub",             250,134,60,17, &wpaint->mode, 1.0, 2.0, 0, 0, "Subtract from the vertex color");
1033         uiDefButS(block, ROW, B_NOP, "Mul",             250,116,60,17, &wpaint->mode, 1.0, 3.0, 0, 0, "Multiply the vertex color");
1034         uiDefButS(block, ROW, B_NOP, "Blur",            250, 98,60,17, &wpaint->mode, 1.0, 4.0, 0, 0, "Blur the weight with surrounding values");
1035         uiDefButS(block, ROW, B_NOP, "Lighter", 250, 80,60,17, &wpaint->mode, 1.0, 5.0, 0, 0, "Paint over darker areas only");
1036         uiDefButS(block, ROW, B_NOP, "Darker",          250, 62,60,17, &wpaint->mode, 1.0, 6.0, 0, 0, "Paint over lighter areas only");
1037         uiBlockEndAlign(block);
1038         */
1039
1040         /* draw options same as below */
1041         uiBlockBeginAlign(block);
1042         if (FACESEL_PAINT_TEST) {
1043                 Mesh *me= ob->data;
1044                 uiDefButBitI(block, TOG, ME_DRAWFACES, B_REDR, "Faces", 10,45,60,19, &me->drawflag, 0, 0, 0, 0, "Displays all faces as shades");
1045                 uiDefButBitI(block,TOG, ME_DRAWEDGES, B_REDR,"Edges",70,45,60,19, &me->drawflag, 2.0, 0, 0, 0,  "Displays edges of visible faces");
1046                 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");
1047         } else{
1048                 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");
1049         }
1050         uiBlockEndAlign(block);
1051
1052         uiBlockBeginAlign(block);
1053         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)");
1054         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)");
1055         uiDefButBitS(block, TOGN, VP_HARD, 0, "Soft",           130,20,60,19, &wpaint->flag, 0, 0, 0, 0, "Use a soft brush");
1056         uiDefButBitS(block, TOG, VP_NORMALS, 0, "Normals",      190,20,60,19, &wpaint->flag, 0, 0, 0, 0, "Applies the vertex normal before painting");
1057         uiDefButBitS(block, TOG, VP_SPRAY, 0, "Spray",          250,20,55,19, &wpaint->flag, 0, 0, 0, 0, "Keep applying paint effect while holding mouse");
1058         uiBlockEndAlign(block);
1059
1060         if(ob) {
1061                 uiBlockBeginAlign(block);
1062                 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.");
1063                 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");
1064                 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");
1065                 uiBlockEndAlign(block);
1066         }
1067 }
1068
1069 static void brush_idpoin_handle(bContext *C, ID *id, int event)
1070 {
1071         Brush **br = current_brush_source(CTX_data_scene(C));
1072
1073         if(!br)
1074                 return;
1075
1076         switch(event) {
1077         case UI_ID_BROWSE:
1078                 (*br) = (Brush*)id;
1079                 break;
1080         case UI_ID_DELETE:
1081                 brush_delete(br);
1082                 break;
1083         case UI_ID_RENAME:
1084                 /* XXX ? */
1085                 break;
1086         case UI_ID_ADD_NEW:
1087                 if(id) {
1088                         (*br) = copy_brush((Brush*)id);
1089                         id->us--;
1090                 }
1091                 else
1092                         (*br) = add_brush("Brush");
1093                 break;
1094         case UI_ID_OPEN:
1095                 /* XXX not implemented */
1096                 break;
1097         }
1098 }
1099
1100 static void view3d_panel_brush(const bContext *C, ARegion *ar, short cntrl)
1101 {
1102         uiBlock *block;
1103         Brush **brp = current_brush_source(CTX_data_scene(C)), *br;
1104         short w = 268, h = 400, cx = 10, cy = h;
1105         rctf rect;
1106
1107         if(!brp)
1108                 return;
1109         br = *brp;
1110
1111         block= uiBeginBlock(C, ar, "view3d_panel_brush", UI_EMBOSS, UI_HELV);
1112         if(uiNewPanel(C, ar, block, "Brush", "View3d", 340, 10, 318, h)==0) return;
1113         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1114
1115         uiBlockBeginAlign(block);
1116         uiDefIDPoinButs(block, CTX_data_main(C), NULL, &br->id, ID_BR, NULL, cx, cy,
1117                         brush_idpoin_handle, UI_ID_BROWSE|UI_ID_RENAME|UI_ID_ADD_NEW|UI_ID_OPEN|UI_ID_DELETE|UI_ID_ALONE);
1118         cy-= 25;
1119         uiBlockEndAlign(block);
1120
1121         if(!br)
1122                 return;
1123
1124         if(G.f & G_SCULPTMODE) {
1125                 uiBlockBeginAlign(block);
1126                 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");
1127                 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");
1128                 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");
1129                 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");
1130                 cy-= 20;
1131                 uiDefButC(block,ROW,B_REDR,"Grab", cx,cy,89,19,&br->sculpt_tool,14,SCULPT_TOOL_GRAB,0,0,"Grabs a group of vertices and moves them with the mouse");
1132                 uiDefButC(block,ROW,B_REDR,"Layer", cx+89,cy,89,19,&br->sculpt_tool,14, SCULPT_TOOL_LAYER,0,0,"Adds a layer of depth");
1133                 uiDefButC(block,ROW,B_REDR,"Flatten", cx+178,cy,90,19,&br->sculpt_tool,14, SCULPT_TOOL_FLATTEN,0,0,"Interactively flatten areas of the model");
1134                 cy-= 25;
1135                 uiBlockEndAlign(block);
1136         }
1137
1138         uiBlockBeginAlign(block);
1139         uiDefButI(block,NUMSLI,B_NOP,"Size: ",cx,cy,w,19,&br->size,1.0,200.0,0,0,"Set brush radius in pixels");
1140         cy-= 20;
1141         uiDefButF(block,NUMSLI,B_NOP,"Strength: ",cx,cy,w,19,&br->alpha,0,1.0,0,0,"Set brush strength");
1142         cy-= 25;
1143         uiBlockEndAlign(block);
1144
1145         uiBlockBeginAlign(block);
1146
1147         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");
1148         uiDefButBitS(block, TOG, BRUSH_ANCHORED, B_NOP, "Rake", cx+w/3,cy,w/3,19, &br->flag,0,0,0,0, "");
1149         uiDefButBitS(block, TOG, BRUSH_RAKE, B_NOP, "Anchored", cx+w*2.0/3,cy,w/3,19, &br->flag,0,0,0,0, "");
1150         cy-= 20;
1151         uiDefButBitS(block, TOG, BRUSH_SPACE, B_NOP, "Space", cx,cy,w/3,19, &br->flag,0,0,0,0, "");
1152         uiDefButF(block,NUMSLI,B_NOP,"Spacing: ",cx+w/3,cy,w*2.0/3,19,&br->spacing,1.0,500,0,0,"");
1153         cy-= 20;
1154         uiBlockEndAlign(block);
1155
1156         rect.xmin= cx; rect.xmax= cx + w;
1157         rect.ymin= cy - 200; rect.ymax= cy;
1158         uiBlockBeginAlign(block);
1159         curvemap_buttons(block, br->curve, (char)0, B_NOP, 0, &rect);
1160         uiBlockEndAlign(block);
1161
1162         uiEndBlock(C, block);
1163 }
1164
1165 static void sculptmode_draw_interface_tools(Scene *scene, uiBlock *block, unsigned short cx, unsigned short cy)
1166 {
1167         Sculpt *s = scene->toolsettings->sculpt;
1168
1169         //XXX if(sd->brush_type != SMOOTH_BRUSH && sd->brush_type != GRAB_BRUSH && sd->brush_type != FLATTEN_BRUSH) {
1170         {
1171                 /*uiDefButBitS(block,ROW,B_NOP,"Add",cx,cy,89,19,&br->dir,15.0,1.0,0, 0,"Add depth to model [Shift]");
1172                 uiDefButBitS(block,ROW,B_NOP,"Sub",cx+89,cy,89,19,&br->dir,15.0,2.0,0, 0,"Subtract depth from model [Shift]");
1173                 */}
1174         //XXX if(sd->brush_type!=GRAB_BRUSH)
1175
1176         uiBlockBeginAlign(block);
1177         uiDefBut( block,LABEL,B_NOP,"Symmetry",cx,cy,90,19,NULL,0,0,0,0,"");
1178         cy-= 20;
1179         uiBlockBeginAlign(block);
1180         uiDefButBitI(block, TOG, SCULPT_SYMM_X, B_NOP, "X", cx,cy,40,19, &s->flags, 0,0,0,0, "Mirror brush across X axis");
1181         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");
1182         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");
1183         uiBlockEndAlign(block);
1184
1185
1186         cy+= 20;
1187         uiBlockBeginAlign(block);
1188         uiDefBut( block,LABEL,B_NOP,"LockAxis",cx+140,cy,90,19,NULL,0,0,0,0,"");
1189         cy-= 20;
1190         uiBlockBeginAlign(block);
1191         uiDefButBitI(block, TOG, SCULPT_LOCK_X, B_NOP, "X", cx+140,cy,40,19, &s->flags, 0,0,0,0, "Constrain X axis");
1192         uiDefButBitI(block, TOG, SCULPT_LOCK_Y, B_NOP, "Y", cx+180,cy,40,19, &s->flags, 0,0,0,0, "Constrain Y axis");
1193         uiDefButBitI(block, TOG, SCULPT_LOCK_Z, B_NOP, "Z", cx+220,cy,40,19, &s->flags, 0,0,0,0, "Constrain Z axis");
1194         uiBlockEndAlign(block);
1195
1196         cx+= 210;
1197 }
1198
1199
1200 static void view3d_panel_object(const bContext *C, ARegion *ar, short cntrl)    // VIEW3D_HANDLER_OBJECT
1201 {
1202         Scene *scene= CTX_data_scene(C);
1203         Object *obedit= CTX_data_edit_object(C);
1204         View3D *v3d= CTX_wm_view3d(C);
1205         uiBlock *block;
1206         uiBut *bt;
1207         Object *ob= OBACT;
1208         TransformProperties *tfp;
1209         float lim;
1210         static char hexcol[128];
1211
1212         if(ob==NULL) return;
1213
1214         /* make sure we got storage */
1215         if(v3d->properties_storage==NULL)
1216                 v3d->properties_storage= MEM_callocN(sizeof(TransformProperties), "TransformProperties");
1217         tfp= v3d->properties_storage;
1218
1219         block= uiBeginBlock(C, ar, "view3d_panel_object", UI_EMBOSS, UI_HELV);
1220         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1221
1222         if((G.f & G_SCULPTMODE) && !obedit) {
1223                 if(!uiNewPanel(C, ar, block, "Transform Properties", "View3d", 10, 230, 318, 234))
1224                         return;
1225         } else if(G.f & G_PARTICLEEDIT && !obedit){
1226                 if(!uiNewPanel(C, ar, block, "Transform Properties", "View3d", 10, 230, 318, 234))
1227                         return;
1228         } else {
1229                 if(!uiNewPanel(C, ar, block, "Transform Properties", "View3d", 10, 230, 318, 204))
1230                         return;
1231         }
1232
1233 // XXX  uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
1234
1235         if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
1236         }
1237         else {
1238                 bt= uiDefBut(block, TEX, B_IDNAME, "OB: ",      10,180,140,20, ob->id.name+2, 0.0, 21.0, 0, 0, "");
1239                 uiButSetFunc(bt, test_idbutton_cb, ob->id.name, NULL);
1240
1241                 if((G.f & G_PARTICLEEDIT)==0) {
1242                         uiBlockBeginAlign(block);
1243                         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_OBJECTPANELPARENT, "Par:", 160, 180, 140, 20, &ob->parent, "Parent Object");
1244                         if((ob->parent) && (ob->partype == PARBONE)) {
1245                                 bt= uiDefBut(block, TEX, B_OBJECTPANELPARENT, "ParBone:", 160, 160, 140, 20, ob->parsubstr, 0, 30, 0, 0, "");
1246                                 uiButSetCompleteFunc(bt, autocomplete_bone, (void *)ob->parent);
1247                         }
1248                         else {
1249                                 strcpy(ob->parsubstr, "");
1250                         }
1251                         uiBlockEndAlign(block);
1252                 }
1253         }
1254
1255         lim= 10000.0f*MAX2(1.0, v3d->grid);
1256
1257         if(ob==obedit) {
1258                 if(ob->type==OB_ARMATURE) v3d_editarmature_buts(block, v3d, ob, lim);
1259                 if(ob->type==OB_MBALL) v3d_editmetaball_buts(block, ob, lim);
1260                 else v3d_editvertex_buts(C, block, v3d, ob, lim);
1261         }
1262         else if(ob->flag & OB_POSEMODE) {
1263                 v3d_posearmature_buts(block, v3d, ob, lim);
1264         }
1265         else if(G.f & G_WEIGHTPAINT) {
1266                 uiNewPanelTitle(block, "Weight Paint Properties");
1267                 weight_paint_buttons(scene, block);
1268         }
1269         else if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT)) {
1270                 static float hsv[3], old[3];    // used as temp mem for picker
1271                 Brush **br = current_brush_source(scene);
1272
1273                 uiNewPanelTitle(block, "Paint Properties");
1274                 if(br && *br)
1275                         /* 'f' is for floating panel */
1276                         uiBlockPickerButtons(block, (*br)->rgb, hsv, old, hexcol, 'f', B_REDR);
1277         }
1278         else if(G.f & G_SCULPTMODE) {
1279                 uiNewPanelTitle(block, "Sculpt Properties");
1280                 sculptmode_draw_interface_tools(scene, block, 10, 150);
1281         }
1282         else if(G.f & G_PARTICLEEDIT){
1283                 uiNewPanelTitle(block, "Particle Edit Properties");
1284 // XXX          particle_edit_buttons(block);
1285         }
1286         else {
1287                 BoundBox *bb = NULL;
1288
1289                 uiBlockBeginAlign(block);
1290                 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");
1291                 uiDefButF(block, NUM, B_OBJECTPANEL, "LocX:",           30, 150, 120, 19, &(ob->loc[0]), -lim, lim, 100, 3, "");
1292                 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");
1293                 uiDefButF(block, NUM, B_OBJECTPANEL, "LocY:",           30, 130, 120, 19, &(ob->loc[1]), -lim, lim, 100, 3, "");
1294                 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");
1295                 uiDefButF(block, NUM, B_OBJECTPANEL, "LocZ:",           30, 110, 120, 19, &(ob->loc[2]), -lim, lim, 100, 3, "");
1296
1297                 tfp->ob_eul[0]= 180.0*ob->rot[0]/M_PI;
1298                 tfp->ob_eul[1]= 180.0*ob->rot[1]/M_PI;
1299                 tfp->ob_eul[2]= 180.0*ob->rot[2]/M_PI;
1300
1301                 uiBlockBeginAlign(block);
1302                 if ((ob->parent) && (ob->partype == PARBONE)) {
1303                         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");
1304                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotX:",        180, 130, 120, 19, &(tfp->ob_eul[0]), -lim, lim, 1000, 3, "");
1305                         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");
1306                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotY:",        180, 110, 120, 19, &(tfp->ob_eul[1]), -lim, lim, 1000, 3, "");
1307                         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");
1308                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotZ:",        180, 90, 120, 19, &(tfp->ob_eul[2]), -lim, lim, 1000, 3, "");
1309
1310                 }
1311                 else {
1312                         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");
1313                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotX:",        180, 150, 120, 19, &(tfp->ob_eul[0]), -lim, lim, 1000, 3, "");
1314                         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");
1315                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotY:",        180, 130, 120, 19, &(tfp->ob_eul[1]), -lim, lim, 1000, 3, "");
1316                         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");
1317                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotZ:",        180, 110, 120, 19, &(tfp->ob_eul[2]), -lim, lim, 1000, 3, "");
1318                 }
1319
1320                 tfp->ob_scale[0]= ob->size[0];
1321                 tfp->ob_scale[1]= ob->size[1];
1322                 tfp->ob_scale[2]= ob->size[2];
1323
1324                 uiBlockBeginAlign(block);
1325                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEX, B_REDR, ICON_UNLOCKED, 10,80,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1326                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "ScaleX:",            30, 80, 120, 19, &(tfp->ob_scale[0]), -lim, lim, 10, 3, "");
1327                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEY, B_REDR, ICON_UNLOCKED, 10,60,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1328                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "ScaleY:",            30, 60, 120, 19, &(tfp->ob_scale[1]), -lim, lim, 10, 3, "");
1329                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SCALEZ, B_REDR, ICON_UNLOCKED, 10,40,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1330                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "ScaleZ:",            30, 40, 120, 19, &(tfp->ob_scale[2]), -lim, lim, 10, 3, "");
1331                 uiBlockEndAlign(block);
1332
1333                 uiDefButS(block, TOG, B_REDR, "Link Scale",             10, 10, 140, 19, &(tfp->link_scale), 0, 1, 0, 0, "Scale values vary proportionally in all directions");
1334
1335                 bb= object_get_boundbox(ob);
1336                 if (bb) {
1337                         float scale[3];
1338
1339                         Mat4ToSize(ob->obmat, scale);
1340
1341                         tfp->ob_dims[0] = fabs(scale[0]) * (bb->vec[4][0] - bb->vec[0][0]);
1342                         tfp->ob_dims[1] = fabs(scale[1]) * (bb->vec[2][1] - bb->vec[0][1]);
1343                         tfp->ob_dims[2] = fabs(scale[2]) * (bb->vec[1][2] - bb->vec[0][2]);
1344
1345                         uiBlockBeginAlign(block);
1346                         if ((ob->parent) && (ob->partype == PARBONE)) {
1347                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimX:",               160, 60, 140, 19, &(tfp->ob_dims[0]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1348                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimY:",               160, 40, 140, 19, &(tfp->ob_dims[1]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1349                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimZ:",               160, 20, 140, 19, &(tfp->ob_dims[2]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1350
1351                         }
1352                         else {
1353                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimX:",               160, 80, 140, 19, &(tfp->ob_dims[0]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1354                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimY:",               160, 60, 140, 19, &(tfp->ob_dims[1]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1355                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimZ:",               160, 40, 140, 19, &(tfp->ob_dims[2]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1356                         }
1357
1358                         uiBlockEndAlign(block);
1359                 }
1360         }
1361 // XXX  uiClearButLock();
1362         uiEndBlock(C, block);
1363 }
1364
1365 static void view3d_panel_background(const bContext *C, ARegion *ar, short cntrl)        // VIEW3D_HANDLER_BACKGROUND
1366 {
1367         View3D *v3d= CTX_wm_view3d(C);
1368         uiBlock *block;
1369
1370         block= uiBeginBlock(C, ar, "view3d_panel_background", UI_EMBOSS, UI_HELV);
1371         if(uiNewPanel(C, ar, block, "Background Image", "View3d", 340, 10, 318, 204)==0) return;
1372         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1373
1374         if(v3d->flag & V3D_DISPBGPIC) {
1375                 if(v3d->bgpic==NULL) {
1376                         v3d->bgpic= MEM_callocN(sizeof(BGpic), "bgpic");
1377                         v3d->bgpic->size= 5.0;
1378                         v3d->bgpic->blend= 0.5;
1379                         v3d->bgpic->iuser.fie_ima= 2;
1380                         v3d->bgpic->iuser.ok= 1;
1381                 }
1382         }
1383
1384         if(!(v3d->flag & V3D_DISPBGPIC)) {
1385                 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");
1386                 uiDefBut(block, LABEL, 1, " ",  160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
1387         }
1388         else {
1389                 uiBlockBeginAlign(block);
1390                 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");
1391                 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");
1392                 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");
1393
1394                 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");
1395                 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");
1396
1397                 ED_image_uiblock_panel(C, block, &v3d->bgpic->ima, &v3d->bgpic->iuser, B_REDR, B_REDR);
1398                 uiBlockEndAlign(block);
1399         }
1400         uiEndBlock(C, block);
1401 }
1402
1403
1404 static void view3d_panel_properties(const bContext *C, ARegion *ar, short cntrl)        // VIEW3D_HANDLER_SETTINGS
1405 {
1406         ScrArea *sa= CTX_wm_area(C);
1407         ARegion *arlast;
1408         Scene *scene= CTX_data_scene(C);
1409         View3D *v3d= CTX_wm_view3d(C);
1410         RegionView3D *rv3d;
1411         uiBlock *block;
1412         float *curs;
1413
1414         block= uiBeginBlock(C, ar, "view3d_panel_properties", UI_EMBOSS, UI_HELV);
1415         if(uiNewPanel(C, ar, block, "View Properties", "View3d", 340, 30, 318, 254)==0) return;
1416         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1417
1418         /* to force height */
1419         uiNewPanelHeight(block, 264);
1420
1421         uiDefBut(block, LABEL, 1, "Grid:",                                      10, 220, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1422         uiBlockBeginAlign(block);
1423         uiDefButF(block, NUM, B_REDR, "Spacing:",               10, 200, 140, 19, &v3d->grid, 0.001, 100.0, 10, 0, "Set the distance between grid lines");
1424         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");
1425         uiDefButS(block, NUM, B_REDR, "Divisions:",             10, 160, 140, 19, &v3d->gridsubdiv, 1.0, 100.0, 100, 0, "Set the number of grid lines");
1426         uiBlockEndAlign(block);
1427
1428         uiDefBut(block, LABEL, 1, "3D Display:",                                                        160, 220, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1429         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");
1430         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");
1431         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");
1432         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");
1433
1434         uiDefBut(block, LABEL, 1, "View Camera:",                       10, 140, 140, 19, NULL, 0.0, 0.0, 0, 0, "");
1435
1436         uiDefButF(block, NUM, B_REDR, "Lens:",          10, 120, 140, 19, &v3d->lens, 10.0, 120.0, 100, 0, "The lens angle in perspective view");
1437         uiBlockBeginAlign(block);
1438         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)");
1439         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)");
1440         uiBlockEndAlign(block);
1441
1442         uiDefBut(block, LABEL, 1, "3D Cursor:",                         160, 150, 140, 19, NULL, 0.0, 0.0, 0, 0, "");
1443
1444         uiBlockBeginAlign(block);
1445         curs= give_cursor(scene, v3d);
1446         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");
1447         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");
1448         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");
1449         uiBlockEndAlign(block);
1450
1451         uiDefBut(block, LABEL, 1, "Display:",                           10, 50, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1452         uiBlockBeginAlign(block);
1453         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");
1454         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");
1455         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");
1456         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)");
1457         uiBlockEndAlign(block);
1458
1459         uiDefBut(block, LABEL, 1, "View Locking:",                              160, 60, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1460         uiBlockBeginAlign(block);
1461         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_REDR, "Object:", 160, 40, 150, 19, &v3d->ob_centre, "Lock view to center to this Object");
1462         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");
1463         uiBlockEndAlign(block);
1464
1465         /* last region is always 3d... a bit weak */
1466         arlast= sa->regionbase.last;
1467         uiBlockBeginAlign(block);
1468         if(arlast->alignment==RGN_ALIGN_QSPLIT) {
1469                 arlast= arlast->prev;
1470                 rv3d= arlast->regiondata;
1471
1472                 uiDefButO(block, BUT, "SCREEN_OT_region_foursplit", WM_OP_EXEC_REGION_WIN, "End 4-Split View", 160, -10, 150, 19, "Join the 3D View");
1473                 uiDefButBitS(block, TOG, RV3D_LOCKED, B_RV3D_LOCKED, "Lock", 160, -30, 50, 19, &rv3d->viewlock, 0, 0, 0, 0, "");
1474                 uiDefButBitS(block, TOG, RV3D_BOXVIEW, B_RV3D_BOXVIEW, "Box", 210, -30, 50, 19, &rv3d->viewlock, 0, 0, 0, 0, "");
1475                 uiDefButBitS(block, TOG, RV3D_BOXCLIP, B_RV3D_BOXCLIP, "Clip", 260, -30, 50, 19, &rv3d->viewlock, 0, 0, 0, 0, "");
1476         }
1477         else
1478                 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");
1479
1480         uiBlockEndAlign(block);
1481
1482
1483 // XXX
1484 //      uiDefBut(block, LABEL, 1, "Keyframe Display:",                          160, -2, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1485 //      uiBlockBeginAlign(block);
1486 //      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)");
1487 //      uiDefButBitS(block, TOG, ANIMFILTER_MUTED, B_REDR, "Muted",210, -22, 50, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes in muted channels");
1488 //      uiDefButBitS(block, TOG, ANIMFILTER_LOCAL, B_REDR, "Local",260, -22, 50, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes directly connected to datablock");
1489 //      if ((v3d->keyflags & ANIMFILTER_LOCAL)==0) {
1490 //              uiDefButBitS(block, TOGN, ANIMFILTER_NOMAT, B_REDR, "Material",160, -42, 75, 19, &v3d->keyflags, 0, 0, 0, 0, "Show keyframes for any available Materials");
1491 //              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");
1492 //      }
1493         uiBlockEndAlign(block);
1494
1495         uiEndBlock(C, block);
1496 }
1497
1498 #if 0
1499 static void view3d_panel_preview(bContext *C, ARegion *ar, short cntrl) // VIEW3D_HANDLER_PREVIEW
1500 {
1501         uiBlock *block;
1502         View3D *v3d= sa->spacedata.first;
1503         int ofsx, ofsy;
1504
1505         block= uiBeginBlock(C, ar, "view3d_panel_preview", UI_EMBOSS, UI_HELV);
1506         uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | UI_PNL_SCALE | cntrl);
1507         uiSetPanelHandler(VIEW3D_HANDLER_PREVIEW);  // for close and esc
1508
1509         ofsx= -150+(sa->winx/2)/v3d->blockscale;
1510         ofsy= -100+(sa->winy/2)/v3d->blockscale;
1511         if(uiNewPanel(C, ar, block, "Preview", "View3d", ofsx, ofsy, 300, 200)==0) return;
1512
1513         uiBlockSetDrawExtraFunc(block, BIF_view3d_previewdraw);
1514
1515         if(scene->recalc & SCE_PRV_CHANGED) {
1516                 scene->recalc &= ~SCE_PRV_CHANGED;
1517                 //printf("found recalc\n");
1518                 BIF_view3d_previewrender_free(sa->spacedata.first);
1519                 BIF_preview_changed(0);
1520         }
1521 }
1522 #endif
1523
1524 static void view3d_panel_gpencil(const bContext *C, ARegion *ar, short cntrl)   // VIEW3D_HANDLER_GREASEPENCIL
1525 {
1526         View3D *v3d= CTX_wm_view3d(C);
1527         uiBlock *block;
1528
1529         block= uiBeginBlock(C, ar, "view3d_panel_gpencil", UI_EMBOSS, UI_HELV);
1530         if (uiNewPanel(C, ar, block, "Grease Pencil", "View3d", 100, 30, 318, 204)==0) return;
1531
1532         /* allocate memory for gpd if drawing enabled (this must be done first or else we crash) */
1533         if (v3d->flag2 & V3D_DISPGP) {
1534 //              if (v3d->gpd == NULL)
1535 // XXX                  gpencil_data_setactive(ar, gpencil_data_addnew());
1536         }
1537
1538         if (v3d->flag2 & V3D_DISPGP) {
1539 // XXX          bGPdata *gpd= v3d->gpd;
1540                 short newheight;
1541
1542                 /* this is a variable height panel, newpanel doesnt force new size on existing panels */
1543                 /* so first we make it default height */
1544                 uiNewPanelHeight(block, 204);
1545
1546                 /* draw button for showing gpencil settings and drawings */
1547                 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)");
1548
1549                 /* extend the panel if the contents won't fit */
1550 //              newheight= draw_gpencil_panel(block, gpd, ar);
1551                 uiNewPanelHeight(block, newheight);
1552         }
1553         else {
1554                 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");
1555                 uiDefBut(block, LABEL, 1, " ",  160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
1556         }
1557         uiEndBlock(C, block);
1558 }
1559
1560
1561 void view3d_buttons_area_defbuts(const bContext *C, ARegion *ar)
1562 {
1563
1564         view3d_panel_object(C, ar, 0);
1565         view3d_panel_properties(C, ar, 0);
1566         view3d_panel_background(C, ar, 0);
1567         if(G.f & (G_SCULPTMODE|G_TEXTUREPAINT|G_VERTEXPAINT|G_WEIGHTPAINT))
1568                 view3d_panel_brush(C, ar, 0);
1569         // XXX view3d_panel_preview(C, ar, 0);
1570         view3d_panel_transform_spaces(C, ar, 0);
1571         if(0)
1572                 view3d_panel_gpencil(C, ar, 0);
1573
1574         uiDrawPanels(C, 1);             /* 1 = align */
1575         uiMatchPanelsView2d(ar); /* sets v2d->totrct */
1576
1577 }
1578
1579
1580 static int view3d_properties(bContext *C, wmOperator *op)
1581 {
1582         ScrArea *sa= CTX_wm_area(C);
1583         ARegion *ar= view3d_has_buttons_region(sa);
1584
1585         if(ar) {
1586                 ar->flag ^= RGN_FLAG_HIDDEN;
1587                 ar->v2d.flag &= ~V2D_IS_INITIALISED; /* XXX should become hide/unhide api? */
1588
1589                 ED_area_initialize(CTX_wm_manager(C), CTX_wm_window(C), sa);
1590                 ED_area_tag_redraw(sa);
1591         }
1592         return OPERATOR_FINISHED;
1593 }
1594
1595 void VIEW3D_OT_properties(wmOperatorType *ot)
1596 {
1597         ot->name= "Properties";
1598         ot->idname= "VIEW3D_OT_properties";
1599
1600         ot->exec= view3d_properties;
1601         ot->poll= ED_operator_view3d_active;
1602
1603         /* flags */
1604         ot->flag= 0;
1605 }