UI: various panels fixes.
[blender.git] / 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 = EM_GetEditMesh(me);
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                 EM_EndEditMesh(me, em);
214         }
215         else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
216                 Curve *cu= ob->data;
217                 Nurb *nu;
218                 BPoint *bp;
219                 BezTriple *bezt;
220                 int a;
221                 
222                 nu= cu->editnurb->first;
223                 while(nu) {
224                         if((nu->type & 7)==CU_BEZIER) {
225                                 bezt= nu->bezt;
226                                 a= nu->pntsu;
227                                 while(a--) {
228                                         if(bezt->f2 & SELECT) {
229                                                 VecAddf(median, median, bezt->vec[1]);
230                                                 tot++;
231                                                 median[4]+= bezt->weight;
232                                                 totweight++;
233                                         }
234                                         else {
235                                                 if(bezt->f1 & SELECT) {
236                                                         VecAddf(median, median, bezt->vec[0]);
237                                                         tot++;
238                                                 }
239                                                 if(bezt->f3 & SELECT) {
240                                                         VecAddf(median, median, bezt->vec[2]);
241                                                         tot++;
242                                                 }
243                                         }
244                                         bezt++;
245                                 }
246                         }
247                         else {
248                                 bp= nu->bp;
249                                 a= nu->pntsu*nu->pntsv;
250                                 while(a--) {
251                                         if(bp->f1 & SELECT) {
252                                                 VecAddf(median, median, bp->vec);
253                                                 median[3]+= bp->vec[3];
254                                                 totw++;
255                                                 tot++;
256                                                 median[4]+= bp->weight;
257                                                 totweight++;
258                                         }
259                                         bp++;
260                                 }
261                         }
262                         nu= nu->next;
263                 }
264         }
265         else if(ob->type==OB_LATTICE) {
266                 Lattice *lt= ob->data;
267                 BPoint *bp;
268                 int a;
269                 
270                 a= lt->editlatt->pntsu*lt->editlatt->pntsv*lt->editlatt->pntsw;
271                 bp= lt->editlatt->def;
272                 while(a--) {
273                         if(bp->f1 & SELECT) {
274                                 VecAddf(median, median, bp->vec);
275                                 tot++;
276                                 median[4]+= bp->weight;
277                                 totweight++;
278                         }
279                         bp++;
280                 }
281         }
282         
283         if(tot==0) return;
284
285         median[0] /= (float)tot;
286         median[1] /= (float)tot;
287         median[2] /= (float)tot;
288         if(totedge) median[3] /= (float)totedge;
289         else if(totw) median[3] /= (float)totw;
290         if(totweight) median[4] /= (float)totweight;
291         
292         if(v3d->flag & V3D_GLOBAL_STATS)
293                 Mat4MulVecfl(ob->obmat, median);
294         
295         if(block) {     // buttons
296                 int but_y;
297                 if((ob->parent) && (ob->partype == PARBONE))    but_y = 135;
298                 else                                                                                    but_y = 150;
299                 
300                 uiBlockBeginAlign(block);
301                 uiDefButBitS(block, TOG, V3D_GLOBAL_STATS, B_REDR, "Global",            160, but_y, 70, 19, &v3d->flag, 0, 0, 0, 0, "Displays global values");
302                 uiDefButBitS(block, TOGN, V3D_GLOBAL_STATS, B_REDR, "Local",            230, but_y, 70, 19, &v3d->flag, 0, 0, 0, 0, "Displays local values");
303                 uiBlockEndAlign(block);
304                 
305                 memcpy(tfp->ve_median, median, sizeof(tfp->ve_median));
306                 
307                 uiBlockBeginAlign(block);
308                 if(tot==1) {
309                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex X:", 10, 110, 290, 19, &(tfp->ve_median[0]), -lim, lim, 10, 3, "");
310                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex Y:", 10, 90, 290, 19, &(tfp->ve_median[1]), -lim, lim, 10, 3, "");
311                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex Z:", 10, 70, 290, 19, &(tfp->ve_median[2]), -lim, lim, 10, 3, "");
312                         if(totw==1)
313                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex W:", 10, 50, 290, 19, &(tfp->ve_median[3]), 0.01, 100.0, 10, 3, "");
314                         uiBlockEndAlign(block);
315         
316                         if(defstr[0]) {
317                                 uiDefBut(block, LABEL, 1, "Vertex Deform Groups",               10, 40, 290, 20, NULL, 0.0, 0.0, 0, 0, "");
318
319                                 uiBlockBeginAlign(block);
320                                 uiDefButF(block, NUM, B_NOP, "Weight:",                 10, 20, 150, 19, tfp->defweightp, 0.0f, 1.0f, 10, 3, "Weight value");
321                                 uiDefButI(block, MENU, B_REDR, defstr,  160, 20, 140, 19, &tfp->curdef, 0.0, 0.0, 0, 0, "Current Vertex Group");
322                                 uiBlockEndAlign(block);
323                         }
324                         else if(totweight)
325                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   10, 20, 290, 19, &(tfp->ve_median[4]), 0.0, 1.0, 10, 3, "");
326
327                 }
328                 else {
329                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median X:", 10, 110, 290, 19, &(tfp->ve_median[0]), -lim, lim, 10, 3, "");
330                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Y:", 10, 90, 290, 19, &(tfp->ve_median[1]), -lim, lim, 10, 3, "");
331                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Z:", 10, 70, 290, 19, &(tfp->ve_median[2]), -lim, lim, 10, 3, "");
332                         if(totw==tot)
333                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median W:", 10, 50, 290, 19, &(tfp->ve_median[3]), 0.01, 100.0, 10, 3, "");
334                         uiBlockEndAlign(block);
335                         if(totweight)
336                                 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");
337                 }
338                 
339                 if(ob->type==OB_CURVE && (totw==0)) { /* bez curves have no w */
340                         uiBlockBeginAlign(block);
341                         uiDefBut(block, BUT,B_SETPT_AUTO,"Auto",        10, 44, 72, 19, 0, 0, 0, 0, 0, "Auto handles (Shift H)");
342                         uiDefBut(block, BUT,B_SETPT_VECTOR,"Vector",82, 44, 73, 19, 0, 0, 0, 0, 0, "Vector handles (V)");
343                         uiDefBut(block, BUT,B_SETPT_ALIGN,"Align",155, 44, 73, 19, 0, 0, 0, 0, 0, "Align handles (H Toggles)");
344                         uiDefBut(block, BUT,B_SETPT_FREE,"Free",        227, 44, 72, 19, 0, 0, 0, 0, 0, "Align handles (H Toggles)");
345                         uiBlockEndAlign(block);
346                 }
347                 
348                 if(totedge==1)
349                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Crease W:", 10, 30, 290, 19, &(tfp->ve_median[3]), 0.0, 1.0, 10, 3, "");
350                 else if(totedge>1)
351                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Crease W:",  10, 30, 290, 19, &(tfp->ve_median[3]), 0.0, 1.0, 10, 3, "");
352                 
353         }
354         else {  // apply
355                 memcpy(ve_median, tfp->ve_median, sizeof(tfp->ve_median));
356                 
357                 if(v3d->flag & V3D_GLOBAL_STATS) {
358                         Mat4Invert(ob->imat, ob->obmat);
359                         Mat4MulVecfl(ob->imat, median);
360                         Mat4MulVecfl(ob->imat, ve_median);
361                 }
362                 VecSubf(median, ve_median, median);
363                 median[3]= ve_median[3]-median[3];
364                 median[4]= ve_median[4]-median[4];
365                 
366                 if(ob->type==OB_MESH) {
367                         Mesh *me= ob->data;
368                         EditMesh *em = EM_GetEditMesh(me);
369                         EditVert *eve;
370                         EditEdge *eed;
371                         
372                         eve= em->verts.first;
373                         while(eve) {
374                                 if(eve->f & SELECT) {
375                                         VecAddf(eve->co, eve->co, median);
376                                 }
377                                 eve= eve->next;
378                         }
379                         
380                         for(eed= em->edges.first; eed; eed= eed->next) {
381                                 if(eed->f & SELECT) {
382                                         /* ensure the median can be set to zero or one */
383                                         if(ve_median[3]==0.0f) eed->crease= 0.0f;
384                                         else if(ve_median[3]==1.0f) eed->crease= 1.0f;
385                                         else {
386                                                 eed->crease+= median[3];
387                                                 CLAMP(eed->crease, 0.0, 1.0);
388                                         }
389                                 }
390                         }
391                         
392                         recalc_editnormals(em);
393
394                         EM_EndEditMesh(me, em);
395                 }
396                 else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
397                         Curve *cu= ob->data;
398                         Nurb *nu;
399                         BPoint *bp;
400                         BezTriple *bezt;
401                         int a;
402                         
403                         nu= cu->editnurb->first;
404                         while(nu) {
405                                 if((nu->type & 7)==1) {
406                                         bezt= nu->bezt;
407                                         a= nu->pntsu;
408                                         while(a--) {
409                                                 if(bezt->f2 & SELECT) {
410                                                         VecAddf(bezt->vec[0], bezt->vec[0], median);
411                                                         VecAddf(bezt->vec[1], bezt->vec[1], median);
412                                                         VecAddf(bezt->vec[2], bezt->vec[2], median);
413                                                         bezt->weight+= median[4];
414                                                 }
415                                                 else {
416                                                         if(bezt->f1 & SELECT) {
417                                                                 VecAddf(bezt->vec[0], bezt->vec[0], median);
418                                                         }
419                                                         if(bezt->f3 & SELECT) {
420                                                                 VecAddf(bezt->vec[2], bezt->vec[2], median);
421                                                         }
422                                                 }
423                                                 bezt++;
424                                         }
425                                 }
426                                 else {
427                                         bp= nu->bp;
428                                         a= nu->pntsu*nu->pntsv;
429                                         while(a--) {
430                                                 if(bp->f1 & SELECT) {
431                                                         VecAddf(bp->vec, bp->vec, median);
432                                                         bp->vec[3]+= median[3];
433                                                         bp->weight+= median[4];
434                                                 }
435                                                 bp++;
436                                         }
437                                 }
438                                 test2DNurb(nu);
439                                 testhandlesNurb(nu); /* test for bezier too */
440
441                                 nu= nu->next;
442                         }
443                 }
444                 else if(ob->type==OB_LATTICE) {
445                         Lattice *lt= ob->data;
446                         BPoint *bp;
447                         int a;
448                         
449                         a= lt->editlatt->pntsu*lt->editlatt->pntsv*lt->editlatt->pntsw;
450                         bp= lt->editlatt->def;
451                         while(a--) {
452                                 if(bp->f1 & SELECT) {
453                                         VecAddf(bp->vec, bp->vec, median);
454                                         bp->weight+= median[4];
455                                 }
456                                 bp++;
457                         }
458                 }
459                 
460 //              ED_undo_push(C, "Transform properties");
461         }
462 }
463
464 /* assumes armature active */
465 static void validate_bonebutton_cb(bContext *C, void *bonev, void *namev)
466 {
467         Object *ob= CTX_data_active_object(C);
468         
469         if(ob && ob->type==OB_ARMATURE) {
470                 Bone *bone= bonev;
471                 char oldname[32], newname[32];
472                 
473                 /* need to be on the stack */
474                 BLI_strncpy(newname, bone->name, 32);
475                 BLI_strncpy(oldname, (char *)namev, 32);
476                 /* restore */
477                 BLI_strncpy(bone->name, oldname, 32);
478                 
479                 armature_bone_rename(ob, oldname, newname); // editarmature.c
480         }
481 }
482
483 static void v3d_posearmature_buts(uiBlock *block, View3D *v3d, Object *ob, float lim)
484 {
485         uiBut *but;
486         bArmature *arm;
487         bPoseChannel *pchan;
488         Bone *bone= NULL;
489         TransformProperties *tfp= v3d->properties_storage;
490
491         arm = ob->data;
492         if (!arm || !ob->pose) return;
493
494         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
495                 bone = pchan->bone;
496                 if(bone && (bone->flag & BONE_ACTIVE) && (bone->layer & arm->layer))
497                         break;
498         }
499         if (!pchan || !bone) return;
500
501         if((ob->parent) && (ob->partype == PARBONE))
502                 but= uiDefBut (block, TEX, B_NOP, "Bone:",                              160, 130, 140, 19, bone->name, 1, 31, 0, 0, "");
503         else
504                 but= uiDefBut(block, TEX, B_NOP, "Bone:",                               160, 140, 140, 19, bone->name, 1, 31, 0, 0, "");
505         uiButSetFunc(but, validate_bonebutton_cb, bone, NULL);
506         uiButSetCompleteFunc(but, autocomplete_bone, (void *)ob);
507
508         QuatToEul(pchan->quat, tfp->ob_eul);
509         tfp->ob_eul[0]*= 180.0/M_PI;
510         tfp->ob_eul[1]*= 180.0/M_PI;
511         tfp->ob_eul[2]*= 180.0/M_PI;
512         
513         uiBlockBeginAlign(block);
514         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");
515         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocX:",        30, 140, 120, 19, pchan->loc, -lim, lim, 100, 3, "");
516         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");
517         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocY:",        30, 120, 120, 19, pchan->loc+1, -lim, lim, 100, 3, "");
518         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");
519         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocZ:",        30, 100, 120, 19, pchan->loc+2, -lim, lim, 100, 3, "");
520
521         uiBlockBeginAlign(block);
522         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");
523         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotX:",        30, 70, 120, 19, tfp->ob_eul, -1000.0, 1000.0, 100, 3, "");
524         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");
525         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotY:",        30, 50, 120, 19, tfp->ob_eul+1, -1000.0, 1000.0, 100, 3, "");
526         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");
527         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotZ:",        30, 30, 120, 19, tfp->ob_eul+2, -1000.0, 1000.0, 100, 3, "");
528         
529         uiBlockBeginAlign(block);
530         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");
531         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleX:",      180, 70, 120, 19, pchan->size, -lim, lim, 10, 3, "");
532         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");
533         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleY:",      180, 50, 120, 19, pchan->size+1, -lim, lim, 10, 3, "");
534         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");
535         uiDefButF(block, NUM, B_ARMATUREPANEL2, "ScaleZ:",      180, 30, 120, 19, pchan->size+2, -lim, lim, 10, 3, "");
536         uiBlockEndAlign(block);
537 }
538
539 /* assumes armature editmode */
540 void validate_editbonebutton_cb(bContext *C, void *bonev, void *namev)
541 {
542         EditBone *eBone= bonev;
543         char oldname[32], newname[32];
544         
545         /* need to be on the stack */
546         BLI_strncpy(newname, eBone->name, 32);
547         BLI_strncpy(oldname, (char *)namev, 32);
548         /* restore */
549         BLI_strncpy(eBone->name, oldname, 32);
550         
551         armature_bone_rename(CTX_data_edit_object(C), oldname, newname); // editarmature.c
552         WM_event_add_notifier(C, NC_OBJECT|ND_BONE_SELECT, CTX_data_edit_object(C)); // XXX fix
553 }
554
555 static void v3d_editarmature_buts(uiBlock *block, View3D *v3d, Object *ob, float lim)
556 {
557         bArmature *arm= ob->data;
558         EditBone *ebone;
559         uiBut *but;
560         TransformProperties *tfp= v3d->properties_storage;
561         
562         ebone= arm->edbo->first;
563
564         for (ebone = arm->edbo->first; ebone; ebone=ebone->next){
565                 if ((ebone->flag & BONE_ACTIVE) && (ebone->layer & arm->layer))
566                         break;
567         }
568
569         if (!ebone)
570                 return;
571         
572         if((ob->parent) && (ob->partype == PARBONE))
573                 but= uiDefBut(block, TEX, B_NOP, "Bone:", 160, 130, 140, 19, ebone->name, 1, 31, 0, 0, "");
574         else
575                 but= uiDefBut(block, TEX, B_NOP, "Bone:",                       160, 150, 140, 19, ebone->name, 1, 31, 0, 0, "");
576         uiButSetFunc(but, validate_editbonebutton_cb, ebone, NULL);
577
578         uiBlockBeginAlign(block);
579         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadX:",       10, 70, 140, 19, ebone->head, -lim, lim, 10, 3, "");
580         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadY:",       10, 50, 140, 19, ebone->head+1, -lim, lim, 10, 3, "");
581         uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadZ:",       10, 30, 140, 19, ebone->head+2, -lim, lim, 10, 3, "");
582         uiBlockBeginAlign(block);
583         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailX:",       160, 70, 140, 19, ebone->tail, -lim, lim, 10, 3, "");
584         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailY:",       160, 50, 140, 19, ebone->tail+1, -lim, lim, 10, 3, "");
585         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailZ:",       160, 30, 140, 19, ebone->tail+2, -lim, lim, 10, 3, "");
586         uiBlockEndAlign(block);
587         
588         tfp->ob_eul[0]= 180.0*ebone->roll/M_PI;
589         uiDefButF(block, NUM, B_ARMATUREPANEL1, "Roll:",        10, 100, 140, 19, tfp->ob_eul, -lim, lim, 1000, 3, "");
590
591         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");
592         
593         uiBlockBeginAlign(block);
594         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TailRadius:",  10, 150, 140, 19, &ebone->rad_tail, 0, lim, 10, 3, "");
595         if (ebone->parent && ebone->flag & BONE_CONNECTED )
596                 uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadRadius:",  10, 130, 140, 19, &ebone->parent->rad_tail, 0, lim, 10, 3, "");
597         else
598                 uiDefButF(block, NUM, B_ARMATUREPANEL1, "HeadRadius:",  10, 130, 140, 19, &ebone->rad_head, 0, lim, 10, 3, "");
599         uiBlockEndAlign(block);
600 }
601
602 static void v3d_editmetaball_buts(uiBlock *block, Object *ob, float lim)
603 {
604         MetaElem *lastelem= NULL; // XXX
605
606         if(lastelem) {
607                 uiBlockBeginAlign(block);
608                 uiDefButF(block, NUM, B_RECALCMBALL, "LocX:", 10, 70, 140, 19, &lastelem->x, -lim, lim, 100, 3, "");
609                 uiDefButF(block, NUM, B_RECALCMBALL, "LocY:", 10, 50, 140, 19, &lastelem->y, -lim, lim, 100, 3, "");
610                 uiDefButF(block, NUM, B_RECALCMBALL, "LocZ:", 10, 30, 140, 19, &lastelem->z, -lim, lim, 100, 3, "");
611
612                 uiBlockBeginAlign(block);
613                 if(lastelem->type!=MB_BALL)
614                         uiDefButF(block, NUM, B_RECALCMBALL, "dx:", 160, 70, 140, 19, &lastelem->expx, 0, lim, 100, 3, "");
615                 if((lastelem->type!=MB_BALL) && (lastelem->type!=MB_TUBE))
616                         uiDefButF(block, NUM, B_RECALCMBALL, "dy:", 160, 50, 140, 19, &lastelem->expy, 0, lim, 100, 3, "");
617                 if((lastelem->type==MB_ELIPSOID) || (lastelem->type==MB_CUBE))
618                         uiDefButF(block, NUM, B_RECALCMBALL, "dz:", 160, 30, 140, 19, &lastelem->expz, 0, lim, 100, 3, "");
619
620                 uiBlockEndAlign(block); 
621
622                 uiBlockBeginAlign(block);
623                 uiDefButF(block, NUM, B_RECALCMBALL, "Radius:", 10, 120, 140, 19, &lastelem->rad, 0, lim, 100, 3, "Size of the active metaball");
624                 uiDefButF(block, NUM, B_RECALCMBALL, "Stiffness:", 10, 100, 140, 19, &lastelem->s, 0, 10, 100, 3, "Stiffness of the active metaball");
625                 uiBlockEndAlign(block);
626                 
627                 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");
628                 
629         }
630 }
631
632 /* test if 'ob' is a parent somewhere in par's parents */
633 static int test_parent_loop(Object *par, Object *ob)
634 {
635         if(par == NULL) return 0;
636         if(ob == par) return 1;
637         return test_parent_loop(par->parent, ob);
638 }
639
640 static void do_view3d_region_buttons(bContext *C, void *arg, int event)
641 {
642         Scene *scene= CTX_data_scene(C);
643         Object *obedit= CTX_data_edit_object(C);
644         View3D *v3d= CTX_wm_view3d(C);
645         BoundBox *bb;
646         Object *ob= OBACT;
647         TransformProperties *tfp= v3d->properties_storage;
648         
649         switch(event) {
650         
651         case B_REDR:
652                 ED_area_tag_redraw(CTX_wm_area(C));
653                 return; /* no notifier! */
654                 
655         case B_OBJECTPANEL:
656                 DAG_object_flush_update(scene, ob, OB_RECALC_OB);
657                 break;
658                 
659         case B_OBJECTPANELROT:
660                 if(ob) {
661                         ob->rot[0]= M_PI*tfp->ob_eul[0]/180.0;
662                         ob->rot[1]= M_PI*tfp->ob_eul[1]/180.0;
663                         ob->rot[2]= M_PI*tfp->ob_eul[2]/180.0;
664                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
665                 }
666                 break;
667
668         case B_OBJECTPANELSCALE:
669                 if(ob) {
670
671                         /* link scale; figure out which axis changed */
672                         if (tfp->link_scale) {
673                                 float ratio, tmp, max = 0.0;
674                                 int axis;
675                                 
676                                 axis = 0;
677                                 max = fabs(tfp->ob_scale[0] - ob->size[0]);
678                                 tmp = fabs(tfp->ob_scale[1] - ob->size[1]);
679                                 if (tmp > max) {
680                                         axis = 1;
681                                         max = tmp;
682                                 }
683                                 tmp = fabs(tfp->ob_scale[2] - ob->size[2]);
684                                 if (tmp > max) {
685                                         axis = 2;
686                                         max = tmp;
687                                 }
688                         
689                                 if (ob->size[axis] != tfp->ob_scale[axis]) {
690                                         if (fabs(ob->size[axis]) > FLT_EPSILON) {
691                                                 ratio = tfp->ob_scale[axis] / ob->size[axis];
692                                                 ob->size[0] *= ratio;
693                                                 ob->size[1] *= ratio;
694                                                 ob->size[2] *= ratio;
695                                         }
696                                 }
697                         }
698                         else {
699                                 VECCOPY(ob->size, tfp->ob_scale);
700                                 
701                         }
702                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
703                 }
704                 break;
705
706         case B_OBJECTPANELDIMS:
707                 bb= object_get_boundbox(ob);
708                 if(bb) {
709                         float old_dims[3], scale[3], ratio, len[3];
710                         int axis;
711
712                         Mat4ToSize(ob->obmat, scale);
713
714                         len[0] = bb->vec[4][0] - bb->vec[0][0];
715                         len[1] = bb->vec[2][1] - bb->vec[0][1];
716                         len[2] = bb->vec[1][2] - bb->vec[0][2];
717
718                         old_dims[0] = fabs(scale[0]) * len[0];
719                         old_dims[1] = fabs(scale[1]) * len[1];
720                         old_dims[2] = fabs(scale[2]) * len[2];
721
722                         /* for each axis changed */
723                         for (axis = 0; axis<3; axis++) {
724                                 if (fabs(old_dims[axis] - tfp->ob_dims[axis]) > 0.0001) {
725                                         if (old_dims[axis] > 0.0) {
726                                                 ratio = tfp->ob_dims[axis] / old_dims[axis]; 
727                                                 if (tfp->link_scale) {
728                                                         ob->size[0] *= ratio;
729                                                         ob->size[1] *= ratio;
730                                                         ob->size[2] *= ratio;
731                                                         break;
732                                                 }
733                                                 else {
734                                                         ob->size[axis] *= ratio;
735                                                 }
736                                         }
737                                         else {
738                                                 if (len[axis] > 0) {
739                                                         ob->size[axis] = tfp->ob_dims[axis] / len[axis];
740                                                 }
741                                         }
742                                 }
743                         }
744                         
745                         /* prevent multiple B_OBJECTPANELDIMS events to keep scaling, cycling with TAB on buttons can cause that */
746                         VECCOPY(tfp->ob_dims, old_dims);
747                         
748                         DAG_object_flush_update(scene, ob, OB_RECALC_OB);
749                 }
750                 break;
751         
752         case B_OBJECTPANELMEDIAN:
753                 if(ob) {
754                         v3d_editvertex_buts(C, NULL, v3d, ob, 1.0);
755                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
756                 }
757                 break;
758                 
759                 /* note; this case also used for parbone */
760         case B_OBJECTPANELPARENT:
761                 if(ob) {
762                         if(ob->id.lib || test_parent_loop(ob->parent, ob) ) 
763                                 ob->parent= NULL;
764                         else {
765                                 DAG_scene_sort(scene);
766                                 DAG_object_flush_update(scene, ob, OB_RECALC_OB);
767                         }
768                 }
769                 break;
770                 
771         case B_ARMATUREPANEL1:
772                 {
773                         bArmature *arm= obedit->data;
774                         EditBone *ebone, *child;
775                         
776                         for (ebone = arm->edbo->first; ebone; ebone=ebone->next){
777                                 if ((ebone->flag & BONE_ACTIVE) && (ebone->layer & arm->layer))
778                                         break;
779                         }
780                         if (ebone) {
781                                 ebone->roll= M_PI*tfp->ob_eul[0]/180.0;
782                                 //      Update our parent
783                                 if (ebone->parent && ebone->flag & BONE_CONNECTED){
784                                         VECCOPY (ebone->parent->tail, ebone->head);
785                                 }
786                         
787                                 //      Update our children if necessary
788                                 for (child = arm->edbo->first; child; child=child->next){
789                                         if (child->parent == ebone && (child->flag & BONE_CONNECTED)){
790                                                 VECCOPY (child->head, ebone->tail);
791                                         }
792                                 }
793                                 if(arm->flag & ARM_MIRROR_EDIT) {
794                                         EditBone *eboflip= ED_armature_bone_get_mirrored(arm->edbo, ebone);
795                                         if(eboflip) {
796                                                 eboflip->roll= -ebone->roll;
797                                                 eboflip->head[0]= -ebone->head[0];
798                                                 eboflip->tail[0]= -ebone->tail[0];
799                                                 
800                                                 //      Update our parent
801                                                 if (eboflip->parent && eboflip->flag & BONE_CONNECTED){
802                                                         VECCOPY (eboflip->parent->tail, eboflip->head);
803                                                 }
804                                                 
805                                                 //      Update our children if necessary
806                                                 for (child = arm->edbo->first; child; child=child->next){
807                                                         if (child->parent == eboflip && (child->flag & BONE_CONNECTED)){
808                                                                 VECCOPY (child->head, eboflip->tail);
809                                                         }
810                                                 }
811                                         }
812                                 }
813                         }
814                 }
815                 break;
816         case B_ARMATUREPANEL3:  // rotate button on channel
817                 {
818                         bArmature *arm;
819                         bPoseChannel *pchan;
820                         Bone *bone;
821                         float eul[3];
822                         
823                         arm = ob->data;
824                         if (!arm || !ob->pose) return;
825                                 
826                         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
827                                 bone = pchan->bone;
828                                 if(bone && (bone->flag & BONE_ACTIVE) && (bone->layer & arm->layer))
829                                         break;
830                         }
831                         if (!pchan) return;
832                         
833                         /* make a copy to eul[3], to allow TAB on buttons to work */
834                         eul[0]= M_PI*tfp->ob_eul[0]/180.0;
835                         eul[1]= M_PI*tfp->ob_eul[1]/180.0;
836                         eul[2]= M_PI*tfp->ob_eul[2]/180.0;
837                         EulToQuat(eul, pchan->quat);
838                 }
839                 /* no break, pass on */
840         case B_ARMATUREPANEL2:
841                 {
842                         ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
843                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
844                 }
845                 break;
846         case B_TRANSFORMSPACEADD:
847                 BIF_manageTransformOrientation(C, 1, 0);
848                 break;
849         case B_TRANSFORMSPACECLEAR:
850                 BIF_clearTransformOrientation(C);
851                 break;
852                 
853 #if 0 // XXX
854         case B_WEIGHT0_0:
855                 wpaint->weight = 0.0f;
856                 break;
857                 
858         case B_WEIGHT1_4:
859                 wpaint->weight = 0.25f;
860                 break;
861         case B_WEIGHT1_2:
862                 wpaint->weight = 0.5f;
863                 break;
864         case B_WEIGHT3_4:
865                 wpaint->weight = 0.75f;
866                 break;
867         case B_WEIGHT1_0:
868                 wpaint->weight = 1.0f;
869                 break;
870                 
871         case B_OPA1_8:
872                 wpaint->a = 0.125f;
873                 break;
874         case B_OPA1_4:
875                 wpaint->a = 0.25f;
876                 break;
877         case B_OPA1_2:
878                 wpaint->a = 0.5f;
879                 break;
880         case B_OPA3_4:
881                 wpaint->a = 0.75f;
882                 break;
883         case B_OPA1_0:
884                 wpaint->a = 1.0f;
885                 break;
886 #endif
887         case B_CLR_WPAINT:
888 //              if(!multires_level1_test()) {
889                 {
890                         bDeformGroup *defGroup = BLI_findlink(&ob->defbase, ob->actdef-1);
891                         if(defGroup) {
892                                 Mesh *me= ob->data;
893                                 int a;
894                                 for(a=0; a<me->totvert; a++)
895                                         remove_vert_defgroup (ob, defGroup, a);
896                                 DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
897                         }
898                 }
899                 break;
900         case B_RV3D_LOCKED:
901         case B_RV3D_BOXVIEW:
902         case B_RV3D_BOXCLIP:
903                 {
904                         ScrArea *sa= CTX_wm_area(C);
905                         ARegion *ar= sa->regionbase.last;
906                         RegionView3D *rv3d;
907                         short viewlock;
908                         
909                         ar= ar->prev;
910                         rv3d= ar->regiondata;
911                         viewlock= rv3d->viewlock;
912                         
913                         if((viewlock & RV3D_LOCKED)==0)
914                                 viewlock= 0;
915                         else if((viewlock & RV3D_BOXVIEW)==0)
916                                 viewlock &= ~RV3D_BOXCLIP;
917                         
918                         for(; ar; ar= ar->prev) {
919                                 if(ar->alignment==RGN_ALIGN_QSPLIT) {
920                                         rv3d= ar->regiondata;
921                                         rv3d->viewlock= viewlock;
922                                 }
923                         }
924                         
925                         if(rv3d->viewlock & RV3D_BOXVIEW)
926                                 view3d_boxview_copy(sa, sa->regionbase.last);
927                         
928                         ED_area_tag_redraw(sa);
929                 }
930                 break;
931         }
932
933         /* default for now */
934         WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, ob);
935 }
936
937 void removeTransformOrientation_func(bContext *C, void *target, void *unused)
938 {
939         BIF_removeTransformOrientation(C, (TransformOrientation *) target);
940 }
941
942 void selectTransformOrientation_func(bContext *C, void *target, void *unused)
943 {
944         BIF_selectTransformOrientation(C, (TransformOrientation *) target);
945 }
946
947 static void view3d_panel_transform_spaces(const bContext *C, ARegion *ar, short cntrl)
948 {
949         Scene *scene= CTX_data_scene(C);
950         Object *obedit= CTX_data_edit_object(C);
951         View3D *v3d= CTX_wm_view3d(C);
952         ListBase *transform_spaces = &scene->transform_spaces;
953         TransformOrientation *ts = transform_spaces->first;
954         uiBlock *block;
955         uiBut *but;
956         int xco = 20, yco = 70, height = 140;
957         int index;
958
959         block= uiBeginBlock(C, ar, "view3d_panel_transform", UI_EMBOSS, UI_HELV);
960         if(uiNewPanel(C, ar, block, "Transform Orientations", "View3d", 1000, 0, 318, height)==0) return;
961
962         uiNewPanelHeight(block, height);
963
964         uiBlockBeginAlign(block);
965         
966         if (obedit)
967                 uiDefBut(block, BUT, B_TRANSFORMSPACEADD, "Add", xco,120,80,20, 0, 0, 0, 0, 0, "Add the selected element as a Transform Orientation");
968         else
969                 uiDefBut(block, BUT, B_TRANSFORMSPACEADD, "Add", xco,120,80,20, 0, 0, 0, 0, 0, "Add the active object as a Transform Orientation");
970
971         uiDefBut(block, BUT, B_TRANSFORMSPACECLEAR, "Clear", xco + 80,120,80,20, 0, 0, 0, 0, 0, "Removal all Transform Orientations");
972         
973         uiBlockEndAlign(block);
974         
975         uiBlockBeginAlign(block);
976         
977         uiDefButS(block, ROW, B_REDR, "Global", xco,            90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_GLOBAL,0, 0, "Global Transform Orientation");
978         uiDefButS(block, ROW, B_REDR, "Local",  xco + 40,       90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_LOCAL, 0, 0, "Local Transform Orientation");
979         uiDefButS(block, ROW, B_REDR, "Normal", xco + 80,       90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_NORMAL,0, 0, "Normal Transform Orientation");
980         uiDefButS(block, ROW, B_REDR, "View",           xco + 120,      90, 40,20, &v3d->twmode, 5.0, (float)V3D_MANIP_VIEW,    0, 0, "View Transform Orientation");
981         
982         for (index = V3D_MANIP_CUSTOM, ts = transform_spaces->first ; ts ; ts = ts->next, index++) {
983
984                 UI_ThemeColor(TH_BUT_ACTION);
985                 if (v3d->twmode == index) {
986                         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");
987                 }
988                 else {
989                         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");
990                 }
991                 uiButSetFunc(but, selectTransformOrientation_func, ts, NULL);
992                 uiDefBut(block, TEX, 0, "", xco+=XIC, yco,100+XIC,20, &ts->name, 0, 30, 0, 0, "Edits the name of this Transform Orientation");
993                 but = uiDefIconBut(block, BUT, B_REDR, ICON_X, xco+=100+XIC,yco,XIC,YIC, 0, 0, 0, 0, 0, "Deletes this Transform Orientation");
994                 uiButSetFunc(but, removeTransformOrientation_func, ts, NULL);
995
996                 xco = 20;
997                 yco -= 25;
998         }
999         uiBlockEndAlign(block);
1000         
1001         if(yco < 0) uiNewPanelHeight(block, height-yco);
1002         uiEndBlock(C, block);
1003 }
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 void view3d_panel_brush(const bContext *C, ARegion *ar, short cntrl)
1105 {
1106         uiBlock *block;
1107         Brush **brp = current_brush_source(CTX_data_scene(C)), *br;
1108         short w = 268, h = 400, cx = 10, cy = h;
1109         rctf rect;
1110
1111         if(!brp)
1112                 return;
1113         br = *brp;
1114
1115         block= uiBeginBlock(C, ar, "view3d_panel_brush", UI_EMBOSS, UI_HELV);
1116         if(uiNewPanel(C, ar, block, "Brush", "View3d", 340, 10, 318, h)==0) return;
1117         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1118
1119         uiBlockBeginAlign(block);
1120         uiDefIDPoinButs(block, CTX_data_main(C), NULL, &br->id, ID_BR, NULL, cx, cy,
1121                         brush_idpoin_handle, UI_ID_BROWSE|UI_ID_RENAME|UI_ID_ADD_NEW|UI_ID_OPEN|UI_ID_DELETE|UI_ID_ALONE);
1122         cy-= 25;
1123         uiBlockEndAlign(block);
1124
1125         if(!br)
1126                 return;
1127
1128         if(G.f & G_SCULPTMODE) {
1129                 uiBlockBeginAlign(block);       
1130                 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");
1131                 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");
1132                 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");
1133                 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");
1134                 cy-= 20;
1135                 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");
1136                 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");
1137                 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");
1138                 cy-= 25;
1139                 uiBlockEndAlign(block);
1140         }
1141
1142         uiBlockBeginAlign(block);
1143         uiDefButI(block,NUMSLI,B_NOP,"Size: ",cx,cy,w,19,&br->size,1.0,200.0,0,0,"Set brush radius in pixels");
1144         cy-= 20;
1145         uiDefButF(block,NUMSLI,B_NOP,"Strength: ",cx,cy,w,19,&br->alpha,0,1.0,0,0,"Set brush strength");
1146         cy-= 25;
1147         uiBlockEndAlign(block);
1148
1149         uiBlockBeginAlign(block);
1150
1151         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");
1152         uiDefButBitS(block, TOG, BRUSH_ANCHORED, B_NOP, "Rake", cx+w/3,cy,w/3,19, &br->flag,0,0,0,0, "");
1153         uiDefButBitS(block, TOG, BRUSH_RAKE, B_NOP, "Anchored", cx+w*2.0/3,cy,w/3,19, &br->flag,0,0,0,0, "");
1154         cy-= 20;
1155         uiDefButBitS(block, TOG, BRUSH_SPACE, B_NOP, "Space", cx,cy,w/3,19, &br->flag,0,0,0,0, "");
1156         uiDefButF(block,NUMSLI,B_NOP,"Spacing: ",cx+w/3,cy,w*2.0/3,19,&br->spacing,1.0,500,0,0,"");
1157         cy-= 20;
1158         uiBlockEndAlign(block);
1159
1160         rect.xmin= cx; rect.xmax= cx + w;
1161         rect.ymin= cy - 200; rect.ymax= cy;
1162         uiBlockBeginAlign(block);
1163         curvemap_buttons(block, br->curve, (char)0, B_NOP, 0, &rect);
1164         uiBlockEndAlign(block);
1165         
1166         uiEndBlock(C, block);
1167 }
1168
1169 static void sculptmode_draw_interface_tools(Scene *scene, uiBlock *block, unsigned short cx, unsigned short cy)
1170 {
1171         Sculpt *s = scene->toolsettings->sculpt;
1172         
1173         //XXX if(sd->brush_type != SMOOTH_BRUSH && sd->brush_type != GRAB_BRUSH && sd->brush_type != FLATTEN_BRUSH) {
1174         {
1175                 /*uiDefButBitS(block,ROW,B_NOP,"Add",cx,cy,89,19,&br->dir,15.0,1.0,0, 0,"Add depth to model [Shift]");
1176                 uiDefButBitS(block,ROW,B_NOP,"Sub",cx+89,cy,89,19,&br->dir,15.0,2.0,0, 0,"Subtract depth from model [Shift]");
1177                 */}
1178         //XXX if(sd->brush_type!=GRAB_BRUSH)
1179         
1180         uiBlockBeginAlign(block);
1181         uiDefBut( block,LABEL,B_NOP,"Symmetry",cx,cy,90,19,NULL,0,0,0,0,"");
1182         cy-= 20;
1183         uiBlockBeginAlign(block);
1184         uiDefButBitI(block, TOG, SCULPT_SYMM_X, B_NOP, "X", cx,cy,40,19, &s->flags, 0,0,0,0, "Mirror brush across X axis");
1185         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");
1186         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");
1187         uiBlockEndAlign(block);
1188         
1189         
1190         cy+= 20;
1191         uiBlockBeginAlign(block);
1192         uiDefBut( block,LABEL,B_NOP,"LockAxis",cx+140,cy,90,19,NULL,0,0,0,0,"");
1193         cy-= 20;
1194         uiBlockBeginAlign(block);
1195         uiDefButBitI(block, TOG, SCULPT_LOCK_X, B_NOP, "X", cx+140,cy,40,19, &s->flags, 0,0,0,0, "Constrain X axis");
1196         uiDefButBitI(block, TOG, SCULPT_LOCK_Y, B_NOP, "Y", cx+180,cy,40,19, &s->flags, 0,0,0,0, "Constrain Y axis");
1197         uiDefButBitI(block, TOG, SCULPT_LOCK_Z, B_NOP, "Z", cx+220,cy,40,19, &s->flags, 0,0,0,0, "Constrain Z axis");
1198         uiBlockEndAlign(block);
1199                 
1200         cx+= 210;
1201 }
1202
1203
1204 static void view3d_panel_object(const bContext *C, ARegion *ar, short cntrl)    // VIEW3D_HANDLER_OBJECT
1205 {
1206         Scene *scene= CTX_data_scene(C);
1207         Object *obedit= CTX_data_edit_object(C);
1208         View3D *v3d= CTX_wm_view3d(C);
1209         uiBlock *block;
1210         uiBut *bt;
1211         Object *ob= OBACT;
1212         TransformProperties *tfp;
1213         float lim;
1214         static char hexcol[128];
1215         
1216         if(ob==NULL) return;
1217
1218         /* make sure we got storage */
1219         if(v3d->properties_storage==NULL)
1220                 v3d->properties_storage= MEM_callocN(sizeof(TransformProperties), "TransformProperties");
1221         tfp= v3d->properties_storage;
1222         
1223         block= uiBeginBlock(C, ar, "view3d_panel_object", UI_EMBOSS, UI_HELV);
1224         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1225         
1226         if((G.f & G_SCULPTMODE) && !obedit) {
1227                 if(!uiNewPanel(C, ar, block, "Transform Properties", "View3d", 10, 230, 318, 234))
1228                         return;
1229         } else if(G.f & G_PARTICLEEDIT && !obedit){
1230                 if(!uiNewPanel(C, ar, block, "Transform Properties", "View3d", 10, 230, 318, 234))
1231                         return;
1232         } else {
1233                 if(!uiNewPanel(C, ar, block, "Transform Properties", "View3d", 10, 230, 318, 204))
1234                         return;
1235         }
1236
1237 // XXX  uiSetButLock(object_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
1238         
1239         if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
1240         }
1241         else {
1242                 bt= uiDefBut(block, TEX, B_IDNAME, "OB: ",      10,180,140,20, ob->id.name+2, 0.0, 21.0, 0, 0, "");
1243                 uiButSetFunc(bt, test_idbutton_cb, ob->id.name, NULL);
1244
1245                 if((G.f & G_PARTICLEEDIT)==0) {
1246                         uiBlockBeginAlign(block);
1247                         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_OBJECTPANELPARENT, "Par:", 160, 180, 140, 20, &ob->parent, "Parent Object"); 
1248                         if((ob->parent) && (ob->partype == PARBONE)) {
1249                                 bt= uiDefBut(block, TEX, B_OBJECTPANELPARENT, "ParBone:", 160, 160, 140, 20, ob->parsubstr, 0, 30, 0, 0, "");
1250                                 uiButSetCompleteFunc(bt, autocomplete_bone, (void *)ob->parent);
1251                         }
1252                         else {
1253                                 strcpy(ob->parsubstr, "");
1254                         }
1255                         uiBlockEndAlign(block);
1256                 }
1257         }
1258
1259         lim= 10000.0f*MAX2(1.0, v3d->grid);
1260
1261         if(ob==obedit) {
1262                 if(ob->type==OB_ARMATURE) v3d_editarmature_buts(block, v3d, ob, lim);
1263                 if(ob->type==OB_MBALL) v3d_editmetaball_buts(block, ob, lim);
1264                 else v3d_editvertex_buts(C, block, v3d, ob, lim);
1265         }
1266         else if(ob->flag & OB_POSEMODE) {
1267                 v3d_posearmature_buts(block, v3d, ob, lim);
1268         }
1269         else if(G.f & G_WEIGHTPAINT) {
1270                 uiNewPanelTitle(block, "Weight Paint Properties");
1271                 weight_paint_buttons(scene, block);
1272         }
1273         else if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT)) {
1274                 static float hsv[3], old[3];    // used as temp mem for picker
1275                 Brush **br = current_brush_source(scene);
1276
1277                 uiNewPanelTitle(block, "Paint Properties");
1278                 if(br && *br)
1279                         /* 'f' is for floating panel */
1280                         uiBlockPickerButtons(block, (*br)->rgb, hsv, old, hexcol, 'f', B_REDR);
1281         }
1282         else if(G.f & G_SCULPTMODE) {
1283                 uiNewPanelTitle(block, "Sculpt Properties");
1284                 sculptmode_draw_interface_tools(scene, block, 10, 150);
1285         } 
1286         else if(G.f & G_PARTICLEEDIT){
1287                 uiNewPanelTitle(block, "Particle Edit Properties");
1288 // XXX          particle_edit_buttons(block);
1289         } 
1290         else {
1291                 BoundBox *bb = NULL;
1292
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, "LocX:",           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, "LocY:",           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, "LocZ:",           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                         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");
1308                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotX:",        180, 130, 120, 19, &(tfp->ob_eul[0]), -lim, lim, 1000, 3, "");
1309                         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");
1310                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotY:",        180, 110, 120, 19, &(tfp->ob_eul[1]), -lim, lim, 1000, 3, "");
1311                         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");
1312                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotZ:",        180, 90, 120, 19, &(tfp->ob_eul[2]), -lim, lim, 1000, 3, "");
1313
1314                 }
1315                 else {
1316                         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");
1317                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotX:",        180, 150, 120, 19, &(tfp->ob_eul[0]), -lim, lim, 1000, 3, "");
1318                         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");
1319                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotY:",        180, 130, 120, 19, &(tfp->ob_eul[1]), -lim, lim, 1000, 3, "");
1320                         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");
1321                         uiDefButF(block, NUM, B_OBJECTPANELROT, "RotZ:",        180, 110, 120, 19, &(tfp->ob_eul[2]), -lim, lim, 1000, 3, "");
1322                 }
1323
1324                 tfp->ob_scale[0]= ob->size[0];
1325                 tfp->ob_scale[1]= ob->size[1];
1326                 tfp->ob_scale[2]= ob->size[2];
1327
1328                 uiBlockBeginAlign(block);
1329                 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");
1330                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "ScaleX:",            30, 80, 120, 19, &(tfp->ob_scale[0]), -lim, lim, 10, 3, "");
1331                 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");
1332                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "ScaleY:",            30, 60, 120, 19, &(tfp->ob_scale[1]), -lim, lim, 10, 3, "");
1333                 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");
1334                 uiDefButF(block, NUM, B_OBJECTPANELSCALE, "ScaleZ:",            30, 40, 120, 19, &(tfp->ob_scale[2]), -lim, lim, 10, 3, "");
1335                 uiBlockEndAlign(block);
1336                 
1337                 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");
1338
1339                 bb= object_get_boundbox(ob);
1340                 if (bb) {
1341                         float scale[3];
1342
1343                         Mat4ToSize(ob->obmat, scale);
1344
1345                         tfp->ob_dims[0] = fabs(scale[0]) * (bb->vec[4][0] - bb->vec[0][0]);
1346                         tfp->ob_dims[1] = fabs(scale[1]) * (bb->vec[2][1] - bb->vec[0][1]);
1347                         tfp->ob_dims[2] = fabs(scale[2]) * (bb->vec[1][2] - bb->vec[0][2]);
1348
1349                         uiBlockBeginAlign(block);
1350                         if ((ob->parent) && (ob->partype == PARBONE)) {
1351                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimX:",               160, 60, 140, 19, &(tfp->ob_dims[0]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1352                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimY:",               160, 40, 140, 19, &(tfp->ob_dims[1]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1353                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimZ:",               160, 20, 140, 19, &(tfp->ob_dims[2]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1354
1355                         }
1356                         else {
1357                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimX:",               160, 80, 140, 19, &(tfp->ob_dims[0]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1358                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimY:",               160, 60, 140, 19, &(tfp->ob_dims[1]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1359                                 uiDefButF(block, NUM, B_OBJECTPANELDIMS, "DimZ:",               160, 40, 140, 19, &(tfp->ob_dims[2]), 0.0, lim, 10, 3, "Manipulate bounding box size");
1360                         }
1361
1362                         uiBlockEndAlign(block);
1363                 }
1364         }
1365 // XXX  uiClearButLock();
1366         uiEndBlock(C, block);
1367 }
1368
1369 static void view3d_panel_background(const bContext *C, ARegion *ar, short cntrl)        // VIEW3D_HANDLER_BACKGROUND
1370 {
1371         View3D *v3d= CTX_wm_view3d(C);
1372         uiBlock *block;
1373
1374         block= uiBeginBlock(C, ar, "view3d_panel_background", UI_EMBOSS, UI_HELV);
1375         if(uiNewPanel(C, ar, block, "Background Image", "View3d", 340, 10, 318, 204)==0) return;
1376         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1377
1378         if(v3d->flag & V3D_DISPBGPIC) {
1379                 if(v3d->bgpic==NULL) {
1380                         v3d->bgpic= MEM_callocN(sizeof(BGpic), "bgpic");
1381                         v3d->bgpic->size= 5.0;
1382                         v3d->bgpic->blend= 0.5;
1383                         v3d->bgpic->iuser.fie_ima= 2;
1384                         v3d->bgpic->iuser.ok= 1;
1385                 }
1386         }
1387         
1388         if(!(v3d->flag & V3D_DISPBGPIC)) {
1389                 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");
1390                 uiDefBut(block, LABEL, 1, " ",  160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
1391         }
1392         else {
1393                 uiBlockBeginAlign(block);
1394                 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");
1395                 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");
1396                 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");
1397
1398                 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");
1399                 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");
1400                 
1401                 ED_image_uiblock_panel(C, block, &v3d->bgpic->ima, &v3d->bgpic->iuser, B_REDR, B_REDR);
1402                 uiBlockEndAlign(block);
1403         }
1404         uiEndBlock(C, block);
1405 }
1406
1407
1408 static void view3d_panel_properties(const bContext *C, ARegion *ar, short cntrl)        // VIEW3D_HANDLER_SETTINGS
1409 {
1410         ScrArea *sa= CTX_wm_area(C);
1411         ARegion *arlast;
1412         Scene *scene= CTX_data_scene(C);
1413         View3D *v3d= CTX_wm_view3d(C);
1414         RegionView3D *rv3d;
1415         uiBlock *block;
1416         float *curs;
1417
1418         block= uiBeginBlock(C, ar, "view3d_panel_properties", UI_EMBOSS, UI_HELV);
1419         if(uiNewPanel(C, ar, block, "View Properties", "View3d", 340, 30, 318, 254)==0) return;
1420         uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1421
1422         /* to force height */
1423         uiNewPanelHeight(block, 264);
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         uiEndBlock(C, block);
1500 }
1501
1502 #if 0
1503 static void view3d_panel_preview(bContext *C, ARegion *ar, short cntrl) // VIEW3D_HANDLER_PREVIEW
1504 {
1505         uiBlock *block;
1506         View3D *v3d= sa->spacedata.first;
1507         int ofsx, ofsy;
1508         
1509         block= uiBeginBlock(C, ar, "view3d_panel_preview", UI_EMBOSS, UI_HELV);
1510         uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | UI_PNL_SCALE | cntrl);
1511         uiSetPanelHandler(VIEW3D_HANDLER_PREVIEW);  // for close and esc
1512         
1513         ofsx= -150+(sa->winx/2)/v3d->blockscale;
1514         ofsy= -100+(sa->winy/2)/v3d->blockscale;
1515         if(uiNewPanel(C, ar, block, "Preview", "View3d", ofsx, ofsy, 300, 200)==0) return;
1516
1517         uiBlockSetDrawExtraFunc(block, BIF_view3d_previewdraw);
1518         
1519         if(scene->recalc & SCE_PRV_CHANGED) {
1520                 scene->recalc &= ~SCE_PRV_CHANGED;
1521                 //printf("found recalc\n");
1522                 BIF_view3d_previewrender_free(sa->spacedata.first);
1523                 BIF_preview_changed(0);
1524         }
1525 }
1526 #endif
1527
1528 static void view3d_panel_gpencil(const bContext *C, ARegion *ar, short cntrl)   // VIEW3D_HANDLER_GREASEPENCIL
1529 {
1530         View3D *v3d= CTX_wm_view3d(C);
1531         uiBlock *block;
1532
1533         block= uiBeginBlock(C, ar, "view3d_panel_gpencil", UI_EMBOSS, UI_HELV);
1534         if (uiNewPanel(C, ar, block, "Grease Pencil", "View3d", 100, 30, 318, 204)==0) return;
1535
1536         /* allocate memory for gpd if drawing enabled (this must be done first or else we crash) */
1537         if (v3d->flag2 & V3D_DISPGP) {
1538 //              if (v3d->gpd == NULL)
1539 // XXX                  gpencil_data_setactive(ar, gpencil_data_addnew());
1540         }
1541         
1542         if (v3d->flag2 & V3D_DISPGP) {
1543 // XXX          bGPdata *gpd= v3d->gpd;
1544                 short newheight;
1545                 
1546                 /* this is a variable height panel, newpanel doesnt force new size on existing panels */
1547                 /* so first we make it default height */
1548                 uiNewPanelHeight(block, 204);
1549                 
1550                 /* draw button for showing gpencil settings and drawings */
1551                 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)");
1552                 
1553                 /* extend the panel if the contents won't fit */
1554 //              newheight= draw_gpencil_panel(block, gpd, ar); 
1555                 uiNewPanelHeight(block, newheight);
1556         }
1557         else {
1558                 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");
1559                 uiDefBut(block, LABEL, 1, " ",  160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
1560         }
1561         uiEndBlock(C, block);
1562 }
1563
1564 static void delete_sketch_armature(bContext *C, void *arg1, void *arg2)
1565 {
1566         BIF_deleteSketch(C);
1567 }
1568
1569 static void convert_sketch_armature(bContext *C, void *arg1, void *arg2)
1570 {
1571         BIF_convertSketch(C);
1572 }
1573
1574 static void assign_template_sketch_armature(bContext *C, void *arg1, void *arg2)
1575 {
1576         int index = *(int*)arg1;
1577         BIF_setTemplate(C, index);
1578 }
1579 static void view3d_panel_bonesketch_spaces(const bContext *C, ARegion *ar, short cntrl)
1580 {
1581         Object *obedit = CTX_data_edit_object(C);
1582         Scene *scene = CTX_data_scene(C);
1583         static int template_index;
1584         static char joint_label[128];
1585         uiBlock *block;
1586         uiBut *but;
1587         char *bone_name;
1588         int yco = 130, height = 140;
1589         int nb_joints;
1590
1591         /* replace with check call to sketching lib */
1592         if (obedit && obedit->type == OB_ARMATURE)
1593         {
1594                 static char subdiv_tooltip[4][64] = {
1595                         "Subdivide arcs based on a fixed number of bones",
1596                         "Subdivide arcs in bones of equal length",
1597                         "Subdivide arcs based on correlation",
1598                         "Retarget template to stroke"
1599                         };
1600
1601                 
1602                 block= uiBeginBlock(C, ar, "view3d_panel_bonesketch_spaces", UI_EMBOSS, UI_HELV);
1603                 if(uiNewPanel(C, ar, block, "Bone Sketching", "View3d", 340, 10, 318, height)==0) return;
1604                 uiBlockSetHandleFunc(block, do_view3d_region_buttons, NULL);
1605         
1606                 uiNewPanelHeight(block, height);
1607         
1608                 uiBlockBeginAlign(block);
1609                 
1610                 /* use real flag instead of 1 */
1611                 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");
1612                 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");
1613                 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");
1614                 yco -= 20;
1615                 
1616                 but = uiDefBut(block, BUT, B_REDR, "Convert", 10,yco,100,20, 0, 0, 0, 0, 0, "Convert sketch to armature");
1617                 uiButSetFunc(but, convert_sketch_armature, NULL, NULL);
1618
1619                 but = uiDefBut(block, BUT, B_REDR, "Delete", 110,yco,100,20, 0, 0, 0, 0, 0, "Delete sketch");
1620                 uiButSetFunc(but, delete_sketch_armature, NULL, NULL);
1621                 yco -= 20;
1622                 
1623                 uiBlockEndAlign(block);
1624
1625                 uiBlockBeginAlign(block);
1626                 
1627                 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]);
1628
1629                 switch(scene->toolsettings->bone_sketching_convert)
1630                 {
1631                 case SK_CONVERT_CUT_LENGTH:
1632                         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");
1633                         yco -= 20;
1634                         break;
1635                 case SK_CONVERT_CUT_ADAPTATIVE:
1636                         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");
1637                         yco -= 20;
1638                         break;
1639                 default:
1640                 case SK_CONVERT_CUT_FIXED:
1641                         uiDefButC(block, NUM, B_REDR,                                   "Num:",         70, yco, 140, 19, &scene->toolsettings->skgen_subdivision_number,1, 100, 1, 5,  "Number of subdivided bones");
1642                         yco -= 20;
1643                         break;
1644                 case SK_CONVERT_RETARGET:
1645                         uiDefButC(block, ROW, B_NOP, "No",                      70,  yco, 40,19, &scene->toolsettings->skgen_retarget_roll, 0, 0, 0, 0,                                                                 "No special roll treatment");
1646                         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");
1647                         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");
1648                         yco -= 30;
1649
1650                         uiBlockEndAlign(block);
1651
1652                         uiBlockBeginAlign(block);
1653                         /* button here to select what to do (copy or not), template, ...*/
1654
1655                         BIF_makeListTemplates(C);
1656                         template_index = BIF_currentTemplate(C);
1657                         
1658                         but = uiDefButI(block, MENU, B_REDR, BIF_listTemplates(C), 10,yco,200,19, &template_index, 0, 0, 0, 0, "Template");
1659                         uiButSetFunc(but, assign_template_sketch_armature, &template_index, NULL);
1660                         
1661                         yco -= 20;
1662                         
1663                         uiDefButF(block, NUM, B_NOP,                                                    "A:",                   10, yco, 66,19, &scene->toolsettings->skgen_retarget_angle_weight, 0, 10, 1, 0,         "Angle Weight");
1664                         uiDefButF(block, NUM, B_NOP,                                                    "L:",                   76, yco, 67,19, &scene->toolsettings->skgen_retarget_length_weight, 0, 10, 1, 0,                "Length Weight");
1665                         uiDefButF(block, NUM, B_NOP,                                                    "D:",           143,yco, 67,19, &scene->toolsettings->skgen_retarget_distance_weight, 0, 10, 1, 0,              "Distance Weight");
1666                         yco -= 20;
1667                         
1668                         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");
1669                         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");
1670                         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");        
1671                         yco -= 20;
1672         
1673                         /* auto renaming magic */
1674                         uiBlockEndAlign(block);
1675                         
1676                         nb_joints = BIF_nbJointsTemplate(C);
1677         
1678                         if (nb_joints == -1)
1679                         {
1680                                 //XXX
1681                                 //nb_joints = G.totvertsel;
1682                         }
1683                         
1684                         bone_name = BIF_nameBoneTemplate(C);
1685                         
1686                         BLI_snprintf(joint_label, 32, "%i joints: %s", nb_joints, bone_name);
1687                         
1688                         uiDefBut(block, LABEL, 1, joint_label,                                  10, yco, 200, 20, NULL, 0.0, 0.0, 0, 0, "");
1689                         yco -= 20;
1690                         break;
1691                 }
1692
1693                 uiBlockEndAlign(block);
1694                 
1695                 uiDefButBitS(block, TOG, SCE_SNAP_PEEL_OBJECT, B_NOP, "Peel Objects", 10, yco, 200, 20, &scene->snap_flag, 0, 0, 0, 0, "Peel whole objects as one");
1696
1697                 if(yco < 0) uiNewPanelHeight(block, height-yco);
1698         }
1699 }
1700
1701 void view3d_buttons_area_defbuts(const bContext *C, ARegion *ar)
1702 {
1703         uiBeginPanels(C, ar);
1704         
1705         view3d_panel_object(C, ar, 0);
1706         view3d_panel_properties(C, ar, 0);
1707         view3d_panel_background(C, ar, 0);
1708         if(G.f & (G_SCULPTMODE|G_TEXTUREPAINT|G_VERTEXPAINT|G_WEIGHTPAINT))
1709                 view3d_panel_brush(C, ar, 0);
1710         // XXX view3d_panel_preview(C, ar, 0);
1711         view3d_panel_transform_spaces(C, ar, 0);
1712         if(0)
1713                 view3d_panel_gpencil(C, ar, 0);
1714         
1715         view3d_panel_bonesketch_spaces(C, ar, 0);
1716         
1717         uiEndPanels(C, ar);
1718 }
1719
1720
1721 static int view3d_properties(bContext *C, wmOperator *op)
1722 {
1723         ScrArea *sa= CTX_wm_area(C);
1724         ARegion *ar= view3d_has_buttons_region(sa);
1725         
1726         if(ar) {
1727                 ar->flag ^= RGN_FLAG_HIDDEN;
1728                 ar->v2d.flag &= ~V2D_IS_INITIALISED; /* XXX should become hide/unhide api? */
1729                 
1730                 ED_area_initialize(CTX_wm_manager(C), CTX_wm_window(C), sa);
1731                 ED_area_tag_redraw(sa);
1732         }
1733         return OPERATOR_FINISHED;
1734 }
1735
1736 void VIEW3D_OT_properties(wmOperatorType *ot)
1737 {
1738         ot->name= "Properties";
1739         ot->idname= "VIEW3D_OT_properties";
1740         
1741         ot->exec= view3d_properties;
1742         ot->poll= ED_operator_view3d_active;
1743         
1744         /* flags */
1745         ot->flag= 0;
1746 }