4d9c1b387a19557990fad55263aef7c9b08f2db2
[blender-staging.git] / source / blender / editors / interface / interface_layout.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation 2009.
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/editors/interface/interface_layout.c
24  *  \ingroup edinterface
25  */
26
27
28 #include <limits.h>
29 #include <math.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <assert.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_screen_types.h"
37 #include "DNA_armature_types.h"
38 #include "DNA_userdef_types.h"
39
40 #include "BLI_listbase.h"
41 #include "BLI_string.h"
42 #include "BLI_rect.h"
43 #include "BLI_utildefines.h"
44 #include "BLI_math.h"
45
46 #include "BLT_translation.h"
47
48 #include "BKE_context.h"
49 #include "BKE_global.h"
50 #include "BKE_idprop.h"
51 #include "BKE_screen.h"
52
53 #include "RNA_access.h"
54
55 #include "UI_interface.h"
56
57 #include "ED_armature.h"
58
59
60 #include "WM_api.h"
61 #include "WM_types.h"
62
63 #include "interface_intern.h"
64
65 /************************ Structs and Defines *************************/
66
67 // #define USE_OP_RESET_BUT  // we may want to make this optional, disable for now.
68
69 #define UI_OPERATOR_ERROR_RET(_ot, _opname, return_statement)                 \
70         if (ot == NULL) {                                                         \
71                 ui_item_disabled(layout, _opname);                                    \
72                 RNA_warning("'%s' unknown operator", _opname);                        \
73                 return_statement;                                                     \
74         } (void)0                                                                 \
75
76
77 /* uiLayoutRoot */
78
79 typedef struct uiLayoutRoot {
80         struct uiLayoutRoot *next, *prev;
81
82         int type;
83         int opcontext;
84
85         int emw, emh;
86         int padding;
87
88         uiMenuHandleFunc handlefunc;
89         void *argv;
90
91         uiStyle *style;
92         uiBlock *block;
93         uiLayout *layout;
94 } uiLayoutRoot;
95
96 /* Item */
97
98 typedef enum uiItemType {
99         ITEM_BUTTON,
100
101         ITEM_LAYOUT_ROW,
102         ITEM_LAYOUT_COLUMN,
103         ITEM_LAYOUT_COLUMN_FLOW,
104         ITEM_LAYOUT_ROW_FLOW,
105         ITEM_LAYOUT_BOX,
106         ITEM_LAYOUT_ABSOLUTE,
107         ITEM_LAYOUT_SPLIT,
108         ITEM_LAYOUT_OVERLAP,
109         ITEM_LAYOUT_RADIAL,
110
111         ITEM_LAYOUT_ROOT
112 #if 0
113         TEMPLATE_COLUMN_FLOW,
114         TEMPLATE_SPLIT,
115         TEMPLATE_BOX,
116
117         TEMPLATE_HEADER,
118         TEMPLATE_HEADER_ID
119 #endif
120 } uiItemType;
121
122 typedef struct uiItem {
123         void *next, *prev;
124         uiItemType type;
125         int flag;
126 } uiItem;
127
128 typedef struct uiButtonItem {
129         uiItem item;
130         uiBut *but;
131 } uiButtonItem;
132
133 struct uiLayout {
134         uiItem item;
135
136         uiLayoutRoot *root;
137         bContextStore *context;
138         ListBase items;
139
140         int x, y, w, h;
141         float scale[2];
142         short space;
143         bool align;
144         bool active;
145         bool enabled;
146         bool redalert;
147         bool keepaspect;
148         char alignment;
149 };
150
151 typedef struct uiLayoutItemFlow {
152         uiLayout litem;
153         int number;
154         int totcol;
155 } uiLayoutItemFlow;
156
157 typedef struct uiLayoutItemBx {
158         uiLayout litem;
159         uiBut *roundbox;
160 } uiLayoutItemBx;
161
162 typedef struct uiLayoutItemSplit {
163         uiLayout litem;
164         float percentage;
165 } uiLayoutItemSplit;
166
167 typedef struct uiLayoutItemRoot {
168         uiLayout litem;
169 } uiLayoutItemRoot;
170
171 /************************** Item ***************************/
172
173 static const char *ui_item_name_add_colon(const char *name, char namestr[UI_MAX_NAME_STR])
174 {
175         int len = strlen(name);
176
177         if (len != 0 && len + 1 < UI_MAX_NAME_STR) {
178                 BLI_strncpy(namestr, name, UI_MAX_NAME_STR);
179                 namestr[len] = ':';
180                 namestr[len + 1] = '\0';
181                 return namestr;
182         }
183
184         return name;
185 }
186
187 static int ui_item_fit(int item, int pos, int all, int available, bool is_last, int alignment, int *offset)
188 {
189         if (offset)
190                 *offset = 0;
191
192         /* available == 0 is unlimited */
193         if (available == 0)
194                 return item;
195
196         if (all > available) {
197                 /* contents is bigger than available space */
198                 if (is_last)
199                         return available - pos;
200                 else
201                         return (item * available) / all;
202         }
203         else {
204                 /* contents is smaller or equal to available space */
205                 if (alignment == UI_LAYOUT_ALIGN_EXPAND) {
206                         if (is_last)
207                                 return available - pos;
208                         else
209                                 return (item * available) / all;
210                 }
211                 else
212                         return item;
213         }
214 }
215
216 /* variable button size in which direction? */
217 #define UI_ITEM_VARY_X  1
218 #define UI_ITEM_VARY_Y  2
219
220 static int ui_layout_vary_direction(uiLayout *layout)
221 {
222         return ((ELEM(layout->root->type, UI_LAYOUT_HEADER, UI_LAYOUT_PIEMENU) ||
223                 (layout->alignment != UI_LAYOUT_ALIGN_EXPAND)) ?
224                 UI_ITEM_VARY_X : UI_ITEM_VARY_Y);
225 }
226
227 /* estimated size of text + icon */
228 static int ui_text_icon_width(uiLayout *layout, const char *name, int icon, bool compact)
229 {
230         bool variable;
231
232         if (icon && !name[0])
233                 return UI_UNIT_X;  /* icon only */
234
235         variable = (ui_layout_vary_direction(layout) == UI_ITEM_VARY_X);
236
237         if (variable) {
238                 const uiFontStyle *fstyle = UI_FSTYLE_WIDGET;
239                 /* it may seem odd that the icon only adds (UI_UNIT_X / 4)
240                  * but taking margins into account its fine */
241                 return (UI_fontstyle_string_width(fstyle, name) +
242                         (UI_UNIT_X * ((compact ? 1.25f : 1.50f) +
243                                       (icon    ? 0.25f : 0.0f))));
244         }
245         else {
246                 return UI_UNIT_X * 10;
247         }
248 }
249
250 static void ui_item_size(uiItem *item, int *r_w, int *r_h)
251 {
252         if (item->type == ITEM_BUTTON) {
253                 uiButtonItem *bitem = (uiButtonItem *)item;
254
255                 if (r_w) *r_w = BLI_rctf_size_x(&bitem->but->rect);
256                 if (r_h) *r_h = BLI_rctf_size_y(&bitem->but->rect);
257         }
258         else {
259                 uiLayout *litem = (uiLayout *)item;
260
261                 if (r_w) *r_w = litem->w;
262                 if (r_h) *r_h = litem->h;
263         }
264 }
265
266 static void ui_item_offset(uiItem *item, int *r_x, int *r_y)
267 {
268         if (item->type == ITEM_BUTTON) {
269                 uiButtonItem *bitem = (uiButtonItem *)item;
270
271                 if (r_x) *r_x = bitem->but->rect.xmin;
272                 if (r_y) *r_y = bitem->but->rect.ymin;
273         }
274         else {
275                 if (r_x) *r_x = 0;
276                 if (r_y) *r_y = 0;
277         }
278 }
279
280 static void ui_item_position(uiItem *item, int x, int y, int w, int h)
281 {
282         if (item->type == ITEM_BUTTON) {
283                 uiButtonItem *bitem = (uiButtonItem *)item;
284
285                 bitem->but->rect.xmin = x;
286                 bitem->but->rect.ymin = y;
287                 bitem->but->rect.xmax = x + w;
288                 bitem->but->rect.ymax = y + h;
289                 
290                 ui_but_update(bitem->but); /* for strlen */
291         }
292         else {
293                 uiLayout *litem = (uiLayout *)item;
294
295                 litem->x = x;
296                 litem->y = y + h;
297                 litem->w = w;
298                 litem->h = h;
299         }
300 }
301
302 /******************** Special RNA Items *********************/
303
304 static int ui_layout_local_dir(uiLayout *layout)
305 {
306         switch (layout->item.type) {
307                 case ITEM_LAYOUT_ROW:
308                 case ITEM_LAYOUT_ROOT:
309                 case ITEM_LAYOUT_OVERLAP:
310                         return UI_LAYOUT_HORIZONTAL;
311                 case ITEM_LAYOUT_COLUMN:
312                 case ITEM_LAYOUT_COLUMN_FLOW:
313                 case ITEM_LAYOUT_SPLIT:
314                 case ITEM_LAYOUT_ABSOLUTE:
315                 case ITEM_LAYOUT_BOX:
316                 default:
317                         return UI_LAYOUT_VERTICAL;
318         }
319 }
320
321 static uiLayout *ui_item_local_sublayout(uiLayout *test, uiLayout *layout, int align)
322 {
323         uiLayout *sub;
324
325         if (ui_layout_local_dir(test) == UI_LAYOUT_HORIZONTAL)
326                 sub = uiLayoutRow(layout, align);
327         else
328                 sub = uiLayoutColumn(layout, align);
329         
330         sub->space = 0;
331         return sub;
332 }
333
334 static void ui_layer_but_cb(bContext *C, void *arg_but, void *arg_index)
335 {
336         wmWindow *win = CTX_wm_window(C);
337         uiBut *but = arg_but, *cbut;
338         PointerRNA *ptr = &but->rnapoin;
339         PropertyRNA *prop = but->rnaprop;
340         int i, index = GET_INT_FROM_POINTER(arg_index);
341         int shift = win->eventstate->shift;
342         int len = RNA_property_array_length(ptr, prop);
343
344         if (!shift) {
345                 RNA_property_boolean_set_index(ptr, prop, index, true);
346
347                 for (i = 0; i < len; i++)
348                         if (i != index)
349                                 RNA_property_boolean_set_index(ptr, prop, i, 0);
350
351                 RNA_property_update(C, ptr, prop);
352
353                 for (cbut = but->block->buttons.first; cbut; cbut = cbut->next)
354                         ui_but_update(cbut);
355         }
356 }
357
358 /* create buttons for an item with an RNA array */
359 static void ui_item_array(
360         uiLayout *layout, uiBlock *block, const char *name, int icon,
361         PointerRNA *ptr, PropertyRNA *prop, int len, int x, int y, int w, int UNUSED(h),
362         bool expand, bool slider, bool toggle, bool icon_only)
363 {
364         uiStyle *style = layout->root->style;
365         uiBut *but;
366         PropertyType type;
367         PropertySubType subtype;
368         uiLayout *sub;
369         unsigned int a, b;
370
371         /* retrieve type and subtype */
372         type = RNA_property_type(prop);
373         subtype = RNA_property_subtype(prop);
374
375         sub = ui_item_local_sublayout(layout, layout, 1);
376         UI_block_layout_set_current(block, sub);
377
378         /* create label */
379         if (name[0])
380                 uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
381
382         /* create buttons */
383         if (type == PROP_BOOLEAN && ELEM(subtype, PROP_LAYER, PROP_LAYER_MEMBER)) {
384                 /* special check for layer layout */
385                 int butw, buth, unit;
386                 int cols = (len >= 20) ? 2 : 1;
387                 const unsigned int colbuts = len / (2 * cols);
388                 unsigned int layer_used = 0;
389                 unsigned int layer_active = 0;
390
391                 UI_block_layout_set_current(block, uiLayoutAbsolute(layout, false));
392
393                 unit = UI_UNIT_X * 0.75;
394                 butw = unit;
395                 buth = unit;
396
397                 if (ptr->type == &RNA_Armature) {
398                         bArmature *arm = (bArmature *)ptr->data;
399                         
400                         layer_used = arm->layer_used;
401                         
402                         if (arm->edbo) {
403                                 if (arm->act_edbone) {
404                                         layer_active |= arm->act_edbone->layer;
405                                 }
406                         }
407                         else {
408                                 if (arm->act_bone) {
409                                         layer_active |= arm->act_bone->layer;
410                                 }
411                         }
412                 }
413
414                 for (b = 0; b < cols; b++) {
415                         UI_block_align_begin(block);
416
417                         for (a = 0; a < colbuts; a++) {
418                                 const int layer_num  = a + b * colbuts;
419                                 const unsigned int layer_flag = (1u << layer_num);
420                                 
421                                 if (layer_used & layer_flag) {
422                                         if (layer_active & layer_flag)
423                                                 icon = ICON_LAYER_ACTIVE;
424                                         else
425                                                 icon = ICON_LAYER_USED;
426                                 }
427                                 else {
428                                         icon = ICON_BLANK1;
429                                 }
430
431                                 but = uiDefAutoButR(block, ptr, prop, layer_num, "", icon, x + butw * a, y + buth, butw, buth);
432                                 if (subtype == PROP_LAYER_MEMBER)
433                                         UI_but_func_set(but, ui_layer_but_cb, but, SET_INT_IN_POINTER(layer_num));
434                         }
435                         for (a = 0; a < colbuts; a++) {
436                                 const int layer_num  = a + len / 2 + b * colbuts;
437                                 const unsigned int layer_flag = (1u << layer_num);
438                                 
439                                 if (layer_used & layer_flag) {
440                                         if (layer_active & layer_flag)
441                                                 icon = ICON_LAYER_ACTIVE;
442                                         else
443                                                 icon = ICON_LAYER_USED;
444                                 }
445                                 else {
446                                         icon = ICON_BLANK1;
447                                 }
448
449                                 but = uiDefAutoButR(block, ptr, prop, layer_num, "", icon, x + butw * a, y, butw, buth);
450                                 if (subtype == PROP_LAYER_MEMBER)
451                                         UI_but_func_set(but, ui_layer_but_cb, but, SET_INT_IN_POINTER(layer_num));
452                         }
453                         UI_block_align_end(block);
454
455                         x += colbuts * butw + style->buttonspacex;
456                 }
457         }
458         else if (subtype == PROP_MATRIX) {
459                 int totdim, dim_size[3];    /* 3 == RNA_MAX_ARRAY_DIMENSION */
460                 int row, col;
461
462                 UI_block_layout_set_current(block, uiLayoutAbsolute(layout, true));
463
464                 totdim = RNA_property_array_dimension(ptr, prop, dim_size);
465                 if (totdim != 2) return;    /* only 2D matrices supported in UI so far */
466                 
467                 w /= dim_size[0];
468                 /* h /= dim_size[1]; */ /* UNUSED */
469
470                 for (a = 0; a < len; a++) {
471                         col = a % dim_size[0];
472                         row = a / dim_size[0];
473
474                         but = uiDefAutoButR(block, ptr, prop, a, "", ICON_NONE, x + w * col, y + (dim_size[1] * UI_UNIT_Y) - (row * UI_UNIT_Y), w, UI_UNIT_Y);
475                         if (slider && but->type == UI_BTYPE_NUM)
476                                 but->type = UI_BTYPE_NUM_SLIDER;
477                 }
478         }
479         else if (subtype == PROP_DIRECTION && !expand) {
480                 uiDefButR_prop(block, UI_BTYPE_UNITVEC, 0, name, x, y, UI_UNIT_X * 3, UI_UNIT_Y * 3, ptr, prop, -1, 0, 0, -1, -1, NULL);
481         }
482         else {
483                 /* note, this block of code is a bit arbitrary and has just been made
484                  * to work with common cases, but may need to be re-worked */
485
486                 /* special case, boolean array in a menu, this could be used in a more generic way too */
487                 if (ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA) && !expand) {
488                         uiDefAutoButR(block, ptr, prop, -1, "", ICON_NONE, 0, 0, w, UI_UNIT_Y);
489                 }
490                 else {
491                         int *boolarr = NULL;
492
493                         /* even if 'expand' is fale, expanding anyway */
494
495                         /* layout for known array subtypes */
496                         char str[3] = {'\0'};
497
498                         if (!icon_only) {
499                                 if (type != PROP_BOOLEAN) {
500                                         str[1] = ':';
501                                 }
502                         }
503
504                         /* show checkboxes for rna on a non-emboss block (menu for eg) */
505                         if (type == PROP_BOOLEAN && ELEM(layout->root->block->dt, UI_EMBOSS_NONE, UI_EMBOSS_PULLDOWN)) {
506                                 boolarr = MEM_callocN(sizeof(int) * len, __func__);
507                                 RNA_property_boolean_get_array(ptr, prop, boolarr);
508                         }
509
510                         for (a = 0; a < len; a++) {
511                                 if (!icon_only) str[0] = RNA_property_array_item_char(prop, a);
512                                 if (boolarr) icon = boolarr[a] ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
513                                 but = uiDefAutoButR(block, ptr, prop, a, str, icon, 0, 0, w, UI_UNIT_Y);
514                                 if (slider && but->type == UI_BTYPE_NUM)
515                                         but->type = UI_BTYPE_NUM_SLIDER;
516                                 if (toggle && but->type == UI_BTYPE_CHECKBOX)
517                                         but->type = UI_BTYPE_TOGGLE;
518                                 if ((a == 0) && (subtype == PROP_AXISANGLE))
519                                         UI_but_unit_type_set(but, PROP_UNIT_ROTATION);
520                         }
521
522                         if (boolarr) {
523                                 MEM_freeN(boolarr);
524                         }
525                 }
526         }
527
528         UI_block_layout_set_current(block, layout);
529 }
530
531 static void ui_item_enum_expand_handle(bContext *C, void *arg1, void *arg2)
532 {
533         wmWindow *win = CTX_wm_window(C);
534
535         if (!win->eventstate->shift) {
536                 uiBut *but = (uiBut *)arg1;
537                 int enum_value = GET_INT_FROM_POINTER(arg2);
538
539                 int current_value = RNA_property_enum_get(&but->rnapoin, but->rnaprop);
540                 if (!(current_value & enum_value)) {
541                         current_value = enum_value;
542                 }
543                 else {
544                         current_value &= enum_value;
545                 }
546                 RNA_property_enum_set(&but->rnapoin, but->rnaprop, current_value);
547         }
548 }
549 static void ui_item_enum_expand(
550         uiLayout *layout, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop,
551         const char *uiname, int h, bool icon_only)
552 {
553         /* XXX The way this function currently handles uiname parameter is insane and inconsistent with general UI API:
554          *     * uiname is the *enum property* label.
555          *     * when it is NULL or empty, we do not draw *enum items* labels, this doubles the icon_only parameter.
556          *     * we *never* draw (i.e. really use) the enum label uiname, it is just used as a mere flag!
557          *     Unfortunately, fixing this implies an API "soft break", so better to defer it for later... :/
558          *     --mont29
559          */
560
561         uiBut *but;
562         uiLayout *layout_radial = NULL;
563         EnumPropertyItem *item, *item_array;
564         const char *name;
565         int itemw, icon, value;
566         bool free;
567         bool radial = (layout->root->type == UI_LAYOUT_PIEMENU);
568
569         if (radial)
570                 RNA_property_enum_items_gettexted_all(block->evil_C, ptr, prop, &item_array, NULL, &free);
571         else
572                 RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item_array, NULL, &free);
573
574         /* we dont want nested rows, cols in menus */
575         if (radial) {
576                 layout_radial = uiLayoutRadial(layout);
577                 UI_block_layout_set_current(block, layout_radial);
578         }
579         else if (layout->root->type != UI_LAYOUT_MENU) {
580                 UI_block_layout_set_current(block, ui_item_local_sublayout(layout, layout, 1));
581         }
582         else {
583                 UI_block_layout_set_current(block, layout);
584         }
585
586         for (item = item_array; item->identifier; item++) {
587                 if (!item->identifier[0]) {
588                         if (radial)
589                                 uiItemS(layout_radial);
590                         continue;
591                 }
592
593                 name = (!uiname || uiname[0]) ? item->name : "";
594                 icon = item->icon;
595                 value = item->value;
596                 itemw = ui_text_icon_width(block->curlayout, icon_only ? "" : name, icon, 0);
597
598                 if (icon && name[0] && !icon_only)
599                         but = uiDefIconTextButR_prop(block, UI_BTYPE_ROW, 0, icon, name, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL);
600                 else if (icon)
601                         but = uiDefIconButR_prop(block, UI_BTYPE_ROW, 0, icon, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL);
602                 else
603                         but = uiDefButR_prop(block, UI_BTYPE_ROW, 0, name, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL);
604
605                 if (RNA_property_flag(prop) & PROP_ENUM_FLAG) {
606                         UI_but_func_set(but, ui_item_enum_expand_handle, but, SET_INT_IN_POINTER(value));
607                 }
608
609                 if (ui_layout_local_dir(layout) != UI_LAYOUT_HORIZONTAL)
610                         but->drawflag |= UI_BUT_TEXT_LEFT;
611         }
612         UI_block_layout_set_current(block, layout);
613
614         if (free) {
615                 MEM_freeN(item_array);
616         }
617 }
618
619 /* callback for keymap item change button */
620 static void ui_keymap_but_cb(bContext *UNUSED(C), void *but_v, void *UNUSED(key_v))
621 {
622         uiBut *but = but_v;
623
624         RNA_boolean_set(&but->rnapoin, "shift", (but->modifier_key & KM_SHIFT) != 0);
625         RNA_boolean_set(&but->rnapoin, "ctrl", (but->modifier_key & KM_CTRL) != 0);
626         RNA_boolean_set(&but->rnapoin, "alt", (but->modifier_key & KM_ALT) != 0);
627         RNA_boolean_set(&but->rnapoin, "oskey", (but->modifier_key & KM_OSKEY) != 0);
628 }
629
630 /* create label + button for RNA property */
631 static uiBut *ui_item_with_label(uiLayout *layout, uiBlock *block, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop, int index, int x, int y, int w, int h, int flag)
632 {
633         uiLayout *sub;
634         uiBut *but = NULL;
635         PropertyType type;
636         PropertySubType subtype;
637         int labelw;
638
639         sub = uiLayoutRow(layout, layout->align);
640         UI_block_layout_set_current(block, sub);
641
642         if (name[0]) {
643                 /* XXX UI_fontstyle_string_width is not accurate */
644 #if 0
645                 labelw = UI_fontstyle_string_width(fstyle, name);
646                 CLAMP(labelw, w / 4, 3 * w / 4);
647 #endif
648                 labelw = w / 3;
649                 uiDefBut(block, UI_BTYPE_LABEL, 0, name, x, y, labelw, h, NULL, 0.0, 0.0, 0, 0, "");
650                 w = w - labelw;
651         }
652
653         type = RNA_property_type(prop);
654         subtype = RNA_property_subtype(prop);
655
656         if (subtype == PROP_FILEPATH || subtype == PROP_DIRPATH) {
657                 UI_block_layout_set_current(block, uiLayoutRow(sub, true));
658                 but = uiDefAutoButR(block, ptr, prop, index, "", icon, x, y, w - UI_UNIT_X, h);
659
660                 /* BUTTONS_OT_file_browse calls UI_context_active_but_prop_get_filebrowser */
661                 uiDefIconButO(block, UI_BTYPE_BUT, subtype == PROP_DIRPATH ? "BUTTONS_OT_directory_browse" : "BUTTONS_OT_file_browse",
662                               WM_OP_INVOKE_DEFAULT, ICON_FILESEL, x, y, UI_UNIT_X, h, NULL);
663         }
664         else if (flag & UI_ITEM_R_EVENT) {
665                 uiDefButR_prop(block, UI_BTYPE_KEY_EVENT, 0, name, x, y, w, h, ptr, prop, index, 0, 0, -1, -1, NULL);
666         }
667         else if (flag & UI_ITEM_R_FULL_EVENT) {
668                 if (RNA_struct_is_a(ptr->type, &RNA_KeyMapItem)) {
669                         char buf[128];
670
671                         WM_keymap_item_to_string(ptr->data, false, sizeof(buf), buf);
672
673                         but = uiDefButR_prop(block, UI_BTYPE_HOTKEY_EVENT, 0, buf, x, y, w, h, ptr, prop, 0, 0, 0, -1, -1, NULL);
674                         UI_but_func_set(but, ui_keymap_but_cb, but, NULL);
675                         if (flag & UI_ITEM_R_IMMEDIATE)
676                                 UI_but_flag_enable(but, UI_BUT_IMMEDIATE);
677                 }
678         }
679         else
680                 but = uiDefAutoButR(block, ptr, prop, index, (type == PROP_ENUM && !(flag & UI_ITEM_R_ICON_ONLY)) ? NULL : "", icon, x, y, w, h);
681
682         UI_block_layout_set_current(block, layout);
683         return but;
684 }
685
686 void UI_context_active_but_prop_get_filebrowser(
687         const bContext *C,
688         PointerRNA *r_ptr, PropertyRNA **r_prop, bool *r_is_undo)
689 {
690         ARegion *ar = CTX_wm_region(C);
691         uiBlock *block;
692         uiBut *but, *prevbut;
693
694         memset(r_ptr, 0, sizeof(*r_ptr));
695         *r_prop = NULL;
696         *r_is_undo = false;
697
698         if (!ar)
699                 return;
700
701         for (block = ar->uiblocks.first; block; block = block->next) {
702                 for (but = block->buttons.first; but; but = but->next) {
703                         prevbut = but->prev;
704
705                         /* find the button before the active one */
706                         if ((but->flag & UI_BUT_LAST_ACTIVE) && prevbut && prevbut->rnapoin.data) {
707                                 if (RNA_property_type(prevbut->rnaprop) == PROP_STRING) {
708                                         *r_ptr = prevbut->rnapoin;
709                                         *r_prop = prevbut->rnaprop;
710                                         *r_is_undo = (prevbut->flag & UI_BUT_UNDO) != 0;
711                                         return;
712                                 }
713                         }
714                 }
715         }
716 }
717
718 /********************* Button Items *************************/
719
720 /**
721  * Update a buttons tip with an enum's description if possible.
722  */
723 static void ui_but_tip_from_enum_item(uiBut *but, const EnumPropertyItem *item)
724 {
725         if (but->tip == NULL || but->tip[0] == '\0') {
726                 if (item->description && item->description[0]) {
727                         but->tip = item->description;
728                 }
729         }
730 }
731
732 /* disabled item */
733 static void ui_item_disabled(uiLayout *layout, const char *name)
734 {
735         uiBlock *block = layout->root->block;
736         uiBut *but;
737         int w;
738
739         UI_block_layout_set_current(block, layout);
740
741         if (!name)
742                 name = "";
743
744         w = ui_text_icon_width(layout, name, 0, 0);
745
746         but = uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
747         but->flag |= UI_BUT_DISABLED;
748         but->lock = true;
749         but->lockstr = "";
750 }
751
752 /* operator items */
753 PointerRNA uiItemFullO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, IDProperty *properties, int context, int flag)
754 {
755         uiBlock *block = layout->root->block;
756         uiBut *but;
757         int w;
758
759         if (!name) {
760                 if (ot && ot->srna && (flag & UI_ITEM_R_ICON_ONLY) == 0)
761                         name = RNA_struct_ui_name(ot->srna);
762                 else
763                         name = "";
764         }
765
766         if (layout->root->type == UI_LAYOUT_MENU && !icon)
767                 icon = ICON_BLANK1;
768
769         /* create button */
770         UI_block_layout_set_current(block, layout);
771
772         w = ui_text_icon_width(layout, name, icon, 0);
773
774         if (flag & UI_ITEM_R_NO_BG)
775                 UI_block_emboss_set(block, UI_EMBOSS_NONE);
776
777         /* create the button */
778         if (icon) {
779                 if (name[0]) {
780                         but = uiDefIconTextButO_ptr(block, UI_BTYPE_BUT, ot, context, icon, name, 0, 0, w, UI_UNIT_Y, NULL);
781                 }
782                 else {
783                         but = uiDefIconButO_ptr(block, UI_BTYPE_BUT, ot, context, icon, 0, 0, w, UI_UNIT_Y, NULL);
784                 }
785         }
786         else {
787                 but = uiDefButO_ptr(block, UI_BTYPE_BUT, ot, context, name, 0, 0, w, UI_UNIT_Y, NULL);
788         }
789
790         assert(but->optype != NULL);
791
792         /* text alignment for toolbar buttons */
793         if ((layout->root->type == UI_LAYOUT_TOOLBAR) && !icon)
794                 but->drawflag |= UI_BUT_TEXT_LEFT;
795
796         if (flag & UI_ITEM_R_NO_BG)
797                 UI_block_emboss_set(block, UI_EMBOSS);
798
799         if (layout->redalert)
800                 UI_but_flag_enable(but, UI_BUT_REDALERT);
801
802         /* assign properties */
803         if (properties || (flag & UI_ITEM_O_RETURN_PROPS)) {
804                 PointerRNA *opptr = UI_but_operator_ptr_get(but);
805
806                 if (properties) {
807                         opptr->data = properties;
808                 }
809                 else {
810                         IDPropertyTemplate val = {0};
811                         opptr->data = IDP_New(IDP_GROUP, &val, "wmOperatorProperties");
812                 }
813
814                 return *opptr;
815         }
816
817         return PointerRNA_NULL;
818 }
819
820 PointerRNA uiItemFullO(uiLayout *layout, const char *opname, const char *name, int icon, IDProperty *properties, int context, int flag)
821 {
822         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
823
824         UI_OPERATOR_ERROR_RET(ot, opname, return PointerRNA_NULL);
825
826         return uiItemFullO_ptr(layout, ot, name, icon, properties, context, flag);
827 }
828
829 static const char *ui_menu_enumpropname(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int retval)
830 {
831         EnumPropertyItem *item;
832         bool free;
833         const char *name;
834
835         RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
836         if (RNA_enum_name(item, retval, &name)) {
837                 name = CTX_IFACE_(RNA_property_translation_context(prop), name);
838         }
839         else {
840                 name = "";
841         }
842
843         if (free) {
844                 MEM_freeN(item);
845         }
846
847         return name;
848 }
849
850 void uiItemEnumO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, const char *propname, int value)
851 {
852         PointerRNA ptr;
853         PropertyRNA *prop;
854
855         WM_operator_properties_create_ptr(&ptr, ot);
856
857         if ((prop = RNA_struct_find_property(&ptr, propname))) {
858                 /* pass */
859         }
860         else {
861                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
862                 return;
863         }
864
865         RNA_property_enum_set(&ptr, prop, value);
866
867         if (!name)
868                 name = ui_menu_enumpropname(layout, &ptr, prop, value);
869
870         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
871 }
872 void uiItemEnumO(uiLayout *layout, const char *opname, const char *name, int icon, const char *propname, int value)
873 {
874         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
875
876         if (ot) {
877                 uiItemEnumO_ptr(layout, ot, name, icon, propname, value);
878         }
879         else {
880                 ui_item_disabled(layout, opname);
881                 RNA_warning("unknown operator '%s'", opname);
882         }
883
884 }
885
886 BLI_INLINE bool ui_layout_is_radial(const uiLayout *layout)
887 {
888         return (layout->item.type == ITEM_LAYOUT_RADIAL) ||
889                ((layout->item.type == ITEM_LAYOUT_ROOT) && (layout->root->type == UI_LAYOUT_PIEMENU));
890 }
891
892 /**
893  * Create ui items for enum items in \a item_array.
894  *
895  * A version of #uiItemsFullEnumO that takes pre-calculated item array.
896  */
897 void uiItemsFullEnumO_items(
898         uiLayout *layout, wmOperatorType *ot, PointerRNA ptr, PropertyRNA *prop, IDProperty *properties,
899         int context, int flag,
900         const EnumPropertyItem *item_array, int totitem)
901 {
902         const char *propname = RNA_property_identifier(prop);
903         if (RNA_property_type(prop) != PROP_ENUM) {
904                 RNA_warning("%s.%s, not an enum type", RNA_struct_identifier(ptr.type), propname);
905                 return;
906         }
907
908         uiLayout *target, *split = NULL;
909         const EnumPropertyItem *item;
910         uiBlock *block = layout->root->block;
911         const bool radial = ui_layout_is_radial(layout);
912
913         if (radial) {
914                 target = uiLayoutRadial(layout);
915         }
916         else {
917                 split = uiLayoutSplit(layout, 0.0f, false);
918                 target = uiLayoutColumn(split, layout->align);
919         }
920
921
922         int i;
923         bool last_iter = false;
924
925         for (i = 1, item = item_array; item->identifier && !last_iter; i++, item++) {
926                 /* handle oversized pies */
927                 if (radial && (totitem > PIE_MAX_ITEMS) && (i >= PIE_MAX_ITEMS)) {
928                         if (item->name) { /* only visible items */
929                                 const EnumPropertyItem *tmp;
930
931                                 /* Check if there are more visible items for the next level. If not, we don't
932                                  * add a new level and add the remaining item instead of the 'more' button. */
933                                 for (tmp = item + 1; tmp->identifier; tmp++)
934                                         if (tmp->name)
935                                                 break;
936
937                                 if (tmp->identifier) { /* only true if loop above found item and did early-exit */
938                                         ui_pie_menu_level_create(block, ot, propname, properties, item_array, totitem, context, flag);
939                                         /* break since rest of items is handled in new pie level */
940                                         break;
941                                 }
942                                 else {
943                                         last_iter = true;
944                                 }
945                         }
946                         else {
947                                 continue;
948                         }
949                 }
950
951                 if (item->identifier[0]) {
952                         PointerRNA tptr;
953
954                         WM_operator_properties_create_ptr(&tptr, ot);
955                         if (properties) {
956                                 if (tptr.data) {
957                                         IDP_FreeProperty(tptr.data);
958                                         MEM_freeN(tptr.data);
959                                 }
960                                 tptr.data = IDP_CopyProperty(properties);
961                         }
962                         RNA_property_enum_set(&tptr, prop, item->value);
963
964                         uiItemFullO_ptr(target, ot, item->name, item->icon, tptr.data, context, flag);
965
966                         ui_but_tip_from_enum_item(block->buttons.last, item);
967                 }
968                 else {
969                         if (item->name) {
970                                 uiBut *but;
971
972                                 if (item != item_array && !radial) {
973                                         target = uiLayoutColumn(split, layout->align);
974
975                                         /* inconsistent, but menus with labels do not look good flipped */
976                                         block->flag |= UI_BLOCK_NO_FLIP;
977                                 }
978
979                                 if (item->icon || radial) {
980                                         uiItemL(target, item->name, item->icon);
981
982                                         but = block->buttons.last;
983                                 }
984                                 else {
985                                         /* Do not use uiItemL here, as our root layout is a menu one, it will add a fake blank icon! */
986                                         but = uiDefBut(block, UI_BTYPE_LABEL, 0, item->name, 0, 0, UI_UNIT_X * 5, UI_UNIT_Y, NULL,
987                                                        0.0, 0.0, 0, 0, "");
988                                 }
989                                 ui_but_tip_from_enum_item(but, item);
990                         }
991                         else {
992                                 if (radial) {
993                                         /* invisible dummy button to ensure all items are always at the same position */
994                                         uiItemS(target);
995                                 }
996                                 else {
997                                         /* XXX bug here, colums draw bottom item badly */
998                                         uiItemS(target);
999                                 }
1000                         }
1001                 }
1002         }
1003 }
1004
1005 void uiItemsFullEnumO(
1006         uiLayout *layout, const char *opname, const char *propname, IDProperty *properties,
1007         int context, int flag)
1008 {
1009         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1010
1011         PointerRNA ptr;
1012         PropertyRNA *prop;
1013         uiBlock *block = layout->root->block;
1014
1015         if (!ot || !ot->srna) {
1016                 ui_item_disabled(layout, opname);
1017                 RNA_warning("%s '%s'", ot ? "unknown operator" : "operator missing srna", opname);
1018                 return;
1019         }
1020
1021         WM_operator_properties_create_ptr(&ptr, ot);
1022         /* so the context is passed to itemf functions (some need it) */
1023         WM_operator_properties_sanitize(&ptr, false);
1024         prop = RNA_struct_find_property(&ptr, propname);
1025
1026         /* don't let bad properties slip through */
1027         BLI_assert((prop == NULL) || (RNA_property_type(prop) == PROP_ENUM));
1028
1029         if (prop && RNA_property_type(prop) == PROP_ENUM) {
1030                 EnumPropertyItem *item_array = NULL;
1031                 int totitem;
1032                 bool free;
1033
1034                 if (ui_layout_is_radial(layout)) {
1035                         RNA_property_enum_items_gettexted_all(block->evil_C, &ptr, prop, &item_array, &totitem, &free);
1036                 }
1037                 else {
1038                         RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item_array, &totitem, &free);
1039                 }
1040
1041                 /* add items */
1042                 uiItemsFullEnumO_items(
1043                         layout, ot, ptr, prop, properties, context, flag,
1044                         item_array, totitem);
1045
1046                 if (free) {
1047                         MEM_freeN(item_array);
1048                 }
1049
1050                 /* intentionally don't touch UI_BLOCK_IS_FLIP here,
1051                  * we don't know the context this is called in */
1052         }
1053         else if (prop && RNA_property_type(prop) != PROP_ENUM) {
1054                 RNA_warning("%s.%s, not an enum type", RNA_struct_identifier(ptr.type), propname);
1055                 return;
1056         }
1057         else {
1058                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
1059                 return;
1060         }
1061 }
1062
1063 void uiItemsEnumO(uiLayout *layout, const char *opname, const char *propname)
1064 {
1065         uiItemsFullEnumO(layout, opname, propname, NULL, layout->root->opcontext, 0);
1066 }
1067
1068 /* for use in cases where we have */
1069 void uiItemEnumO_value(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value)
1070 {
1071         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1072         PointerRNA ptr;
1073         PropertyRNA *prop;
1074
1075         UI_OPERATOR_ERROR_RET(ot, opname, return);
1076
1077         WM_operator_properties_create_ptr(&ptr, ot);
1078
1079         /* enum lookup */
1080         if ((prop = RNA_struct_find_property(&ptr, propname))) {
1081                 /* pass */
1082         }
1083         else {
1084                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
1085                 return;
1086         }
1087
1088         RNA_property_enum_set(&ptr, prop, value);
1089
1090         /* same as uiItemEnumO */
1091         if (!name)
1092                 name = ui_menu_enumpropname(layout, &ptr, prop, value);
1093
1094         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1095 }
1096
1097 void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, const char *value_str)
1098 {
1099         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1100         PointerRNA ptr;
1101         PropertyRNA *prop;
1102
1103         EnumPropertyItem *item;
1104         int value;
1105         bool free;
1106
1107         UI_OPERATOR_ERROR_RET(ot, opname, return);
1108
1109         WM_operator_properties_create_ptr(&ptr, ot);
1110
1111         /* enum lookup */
1112         if ((prop = RNA_struct_find_property(&ptr, propname))) {
1113                 /* no need for translations here */
1114                 RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free);
1115                 if (item == NULL || RNA_enum_value_from_id(item, value_str, &value) == 0) {
1116                         if (free) {
1117                                 MEM_freeN(item);
1118                         }
1119                         RNA_warning("%s.%s, enum %s not found", RNA_struct_identifier(ptr.type), propname, value_str);
1120                         return;
1121                 }
1122
1123                 if (free) {
1124                         MEM_freeN(item);
1125                 }
1126         }
1127         else {
1128                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
1129                 return;
1130         }
1131
1132         RNA_property_enum_set(&ptr, prop, value);
1133
1134         /* same as uiItemEnumO */
1135         if (!name)
1136                 name = ui_menu_enumpropname(layout, &ptr, prop, value);
1137
1138         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1139 }
1140
1141 void uiItemBooleanO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value)
1142 {
1143         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1144         PointerRNA ptr;
1145
1146         UI_OPERATOR_ERROR_RET(ot, opname, return);
1147
1148         WM_operator_properties_create_ptr(&ptr, ot);
1149         RNA_boolean_set(&ptr, propname, value);
1150
1151         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1152 }
1153
1154 void uiItemIntO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value)
1155 {
1156         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1157         PointerRNA ptr;
1158
1159         UI_OPERATOR_ERROR_RET(ot, opname, return);
1160
1161         WM_operator_properties_create_ptr(&ptr, ot);
1162         RNA_int_set(&ptr, propname, value);
1163
1164         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1165 }
1166
1167 void uiItemFloatO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, float value)
1168 {
1169         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1170         PointerRNA ptr;
1171
1172         UI_OPERATOR_ERROR_RET(ot, opname, return);
1173
1174         WM_operator_properties_create_ptr(&ptr, ot);
1175         RNA_float_set(&ptr, propname, value);
1176
1177         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1178 }
1179
1180 void uiItemStringO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, const char *value)
1181 {
1182         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1183         PointerRNA ptr;
1184
1185         UI_OPERATOR_ERROR_RET(ot, opname, return);
1186
1187         WM_operator_properties_create_ptr(&ptr, ot);
1188         RNA_string_set(&ptr, propname, value);
1189
1190         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1191 }
1192
1193 void uiItemO(uiLayout *layout, const char *name, int icon, const char *opname)
1194 {
1195         uiItemFullO(layout, opname, name, icon, NULL, layout->root->opcontext, 0);
1196 }
1197
1198 /* RNA property items */
1199
1200 static void ui_item_rna_size(
1201         uiLayout *layout, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop,
1202         int index, bool icon_only, int *r_w, int *r_h)
1203 {
1204         PropertyType type;
1205         PropertySubType subtype;
1206         int len, w = 0, h;
1207
1208         /* arbitrary extended width by type */
1209         type = RNA_property_type(prop);
1210         subtype = RNA_property_subtype(prop);
1211         len = RNA_property_array_length(ptr, prop);
1212
1213         if (!name[0] && !icon_only) {
1214                 if (ELEM(type, PROP_STRING, PROP_POINTER)) {
1215                         name = "non-empty text";
1216                 }
1217                 else if (type == PROP_BOOLEAN) {
1218                         icon = ICON_DOT;
1219                 }
1220                 else if (type == PROP_ENUM) {
1221                         /* Find the longest enum item name, instead of using a dummy text! */
1222                         EnumPropertyItem *item, *item_array;
1223                         bool free;
1224
1225                         RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item_array, NULL, &free);
1226                         for (item = item_array; item->identifier; item++) {
1227                                 if (item->identifier[0]) {
1228                                         w = max_ii(w, ui_text_icon_width(layout, item->name, item->icon, 0));
1229                                 }
1230                         }
1231                         if (free) {
1232                                 MEM_freeN(item_array);
1233                         }
1234                 }
1235         }
1236
1237         if (!w)
1238                 w = ui_text_icon_width(layout, name, icon, 0);
1239         h = UI_UNIT_Y;
1240
1241         /* increase height for arrays */
1242         if (index == RNA_NO_INDEX && len > 0) {
1243                 if (!name[0] && icon == ICON_NONE)
1244                         h = 0;
1245
1246                 if (ELEM(subtype, PROP_LAYER, PROP_LAYER_MEMBER))
1247                         h += 2 * UI_UNIT_Y;
1248                 else if (subtype == PROP_MATRIX)
1249                         h += ceilf(sqrtf(len)) * UI_UNIT_Y;
1250                 else
1251                         h += len * UI_UNIT_Y;
1252         }
1253         else if (ui_layout_vary_direction(layout) == UI_ITEM_VARY_X) {
1254                 if (type == PROP_BOOLEAN && name[0])
1255                         w += UI_UNIT_X / 5;
1256                 else if (type == PROP_ENUM)
1257                         w += UI_UNIT_X / 4;
1258                 else if (type == PROP_FLOAT || type == PROP_INT)
1259                         w += UI_UNIT_X * 3;
1260         }
1261
1262         *r_w = w;
1263         *r_h = h;
1264 }
1265
1266 void uiItemFullR(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int index, int value, int flag, const char *name, int icon)
1267 {
1268         uiBlock *block = layout->root->block;
1269         uiBut *but = NULL;
1270         PropertyType type;
1271         char namestr[UI_MAX_NAME_STR];
1272         int len, w, h;
1273         bool slider, toggle, expand, icon_only, no_bg;
1274         bool is_array;
1275
1276         UI_block_layout_set_current(block, layout);
1277
1278         /* retrieve info */
1279         type = RNA_property_type(prop);
1280         is_array = RNA_property_array_check(prop);
1281         len = (is_array) ? RNA_property_array_length(ptr, prop) : 0;
1282
1283         /* set name and icon */
1284         if (!name) {
1285                 if ((flag & UI_ITEM_R_ICON_ONLY) == 0) {
1286                         name = RNA_property_ui_name(prop);
1287                 }
1288                 else {
1289                         name = "";
1290                 }
1291         }
1292
1293         if (icon == ICON_NONE)
1294                 icon = RNA_property_ui_icon(prop);
1295         
1296         if (flag & UI_ITEM_R_ICON_ONLY) {
1297                 /* pass */
1298         }
1299         else if (ELEM(type, PROP_INT, PROP_FLOAT, PROP_STRING, PROP_POINTER)) {
1300                 name = ui_item_name_add_colon(name, namestr);
1301         }
1302         else if (type == PROP_BOOLEAN && is_array && index == RNA_NO_INDEX) {
1303                 name = ui_item_name_add_colon(name, namestr);
1304         }
1305         else if (type == PROP_ENUM && index != RNA_ENUM_VALUE) {
1306                 name = ui_item_name_add_colon(name, namestr);
1307         }
1308
1309         /* menus and pie-menus don't show checkbox without this */
1310         if ((layout->root->type == UI_LAYOUT_MENU) ||
1311             /* use checkboxes only as a fallback in pie-menu's, when no icon is defined */
1312             ((layout->root->type == UI_LAYOUT_PIEMENU) && (icon == ICON_NONE)))
1313         {
1314                 if (type == PROP_BOOLEAN && ((is_array == false) || (index != RNA_NO_INDEX))) {
1315                         if (is_array) icon = (RNA_property_boolean_get_index(ptr, prop, index)) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1316                         else icon = (RNA_property_boolean_get(ptr, prop)) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1317                 }
1318                 else if (type == PROP_ENUM && index == RNA_ENUM_VALUE) {
1319                         int enum_value = RNA_property_enum_get(ptr, prop);
1320                         if (RNA_property_flag(prop) & PROP_ENUM_FLAG) {
1321                                 icon = (enum_value & value) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1322                         }
1323                         else {
1324                                 icon = (enum_value == value) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1325                         }
1326                 }
1327         }
1328
1329         slider = (flag & UI_ITEM_R_SLIDER) != 0;
1330         toggle = (flag & UI_ITEM_R_TOGGLE) != 0;
1331         expand = (flag & UI_ITEM_R_EXPAND) != 0;
1332         icon_only = (flag & UI_ITEM_R_ICON_ONLY) != 0;
1333         no_bg = (flag & UI_ITEM_R_NO_BG) != 0;
1334
1335         /* get size */
1336         ui_item_rna_size(layout, name, icon, ptr, prop, index, icon_only, &w, &h);
1337
1338         if (no_bg)
1339                 UI_block_emboss_set(block, UI_EMBOSS_NONE);
1340         
1341         /* array property */
1342         if (index == RNA_NO_INDEX && is_array)
1343                 ui_item_array(layout, block, name, icon, ptr, prop, len, 0, 0, w, h, expand, slider, toggle, icon_only);
1344         /* enum item */
1345         else if (type == PROP_ENUM && index == RNA_ENUM_VALUE) {
1346                 if (icon && name[0] && !icon_only)
1347                         uiDefIconTextButR_prop(block, UI_BTYPE_ROW, 0, icon, name, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL);
1348                 else if (icon)
1349                         uiDefIconButR_prop(block, UI_BTYPE_ROW, 0, icon, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL);
1350                 else
1351                         uiDefButR_prop(block, UI_BTYPE_ROW, 0, name, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL);
1352         }
1353         /* expanded enum */
1354         else if (type == PROP_ENUM && (expand || RNA_property_flag(prop) & PROP_ENUM_FLAG))
1355                 ui_item_enum_expand(layout, block, ptr, prop, name, h, icon_only);
1356         /* property with separate label */
1357         else if (type == PROP_ENUM || type == PROP_STRING || type == PROP_POINTER) {
1358                 but = ui_item_with_label(layout, block, name, icon, ptr, prop, index, 0, 0, w, h, flag);
1359                 ui_but_add_search(but, ptr, prop, NULL, NULL);
1360                 
1361                 if (layout->redalert)
1362                         UI_but_flag_enable(but, UI_BUT_REDALERT);
1363         }
1364         /* single button */
1365         else {
1366                 but = uiDefAutoButR(block, ptr, prop, index, name, icon, 0, 0, w, h);
1367
1368                 if (slider && but->type == UI_BTYPE_NUM)
1369                         but->type = UI_BTYPE_NUM_SLIDER;
1370
1371                 if (toggle && but->type == UI_BTYPE_CHECKBOX)
1372                         but->type = UI_BTYPE_TOGGLE;
1373                 
1374                 if (layout->redalert)
1375                         UI_but_flag_enable(but, UI_BUT_REDALERT);
1376         }
1377
1378         /* Mark non-embossed textfields inside a listbox. */
1379         if (but && (block->flag & UI_BLOCK_LIST_ITEM) && (but->type == UI_BTYPE_TEXT) && (but->dt & UI_EMBOSS_NONE)) {
1380                 UI_but_flag_enable(but, UI_BUT_LIST_ITEM);
1381         }
1382
1383         if (no_bg)
1384                 UI_block_emboss_set(block, UI_EMBOSS);
1385
1386         /* ensure text isn't added to icon_only buttons */
1387         if (but && icon_only) {
1388                 BLI_assert(but->str[0] == '\0');
1389         }
1390
1391 }
1392
1393 void uiItemR(uiLayout *layout, PointerRNA *ptr, const char *propname, int flag, const char *name, int icon)
1394 {
1395         PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
1396
1397         if (!prop) {
1398                 ui_item_disabled(layout, propname);
1399                 RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1400                 return;
1401         }
1402
1403         uiItemFullR(layout, ptr, prop, RNA_NO_INDEX, 0, flag, name, icon);
1404 }
1405
1406 void uiItemEnumR_prop(uiLayout *layout, const char *name, int icon, struct PointerRNA *ptr, PropertyRNA *prop, int value)
1407 {
1408         if (RNA_property_type(prop) != PROP_ENUM) {
1409                 const char *propname = RNA_property_identifier(prop);
1410                 ui_item_disabled(layout, propname);
1411                 RNA_warning("property not an enum: %s.%s", RNA_struct_identifier(ptr->type), propname);
1412                 return;
1413         }
1414
1415         uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, value, 0, name, icon);
1416 }
1417
1418 void uiItemEnumR(uiLayout *layout, const char *name, int icon, struct PointerRNA *ptr, const char *propname, int value)
1419 {
1420         PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
1421
1422         if (prop == NULL) {
1423                 ui_item_disabled(layout, propname);
1424                 RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1425                 return;
1426         }
1427
1428         uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, value, 0, name, icon);
1429 }
1430
1431 void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *value, const char *name, int icon)
1432 {
1433         PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
1434         EnumPropertyItem *item;
1435         int ivalue, a;
1436         bool free;
1437
1438         if (!prop || RNA_property_type(prop) != PROP_ENUM) {
1439                 ui_item_disabled(layout, propname);
1440                 RNA_warning("enum property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1441                 return;
1442         }
1443
1444         RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
1445
1446         if (!RNA_enum_value_from_id(item, value, &ivalue)) {
1447                 if (free) {
1448                         MEM_freeN(item);
1449                 }
1450                 ui_item_disabled(layout, propname);
1451                 RNA_warning("enum property value not found: %s", value);
1452                 return;
1453         }
1454
1455         for (a = 0; item[a].identifier; a++) {
1456                 if (item[a].value == ivalue) {
1457                         const char *item_name = name ? name : CTX_IFACE_(RNA_property_translation_context(prop), item[a].name);
1458
1459                         uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, ivalue, 0, item_name, icon ? icon : item[a].icon);
1460                         break;
1461                 }
1462         }
1463
1464         if (free) {
1465                 MEM_freeN(item);
1466         }
1467 }
1468
1469 void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname)
1470 {
1471         PropertyRNA *prop;
1472         uiBlock *block = layout->root->block;
1473         uiBut *bt;
1474
1475         prop = RNA_struct_find_property(ptr, propname);
1476
1477         if (!prop) {
1478                 ui_item_disabled(layout, propname);
1479                 RNA_warning("enum property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1480                 return;
1481         }
1482
1483         if (RNA_property_type(prop) != PROP_ENUM) {
1484                 RNA_warning("not an enum property: %s.%s", RNA_struct_identifier(ptr->type), propname);
1485                 return;
1486         }
1487         else {
1488                 EnumPropertyItem *item;
1489                 int totitem, i;
1490                 bool free;
1491                 uiLayout *split = uiLayoutSplit(layout, 0.0f, false);
1492                 uiLayout *column = uiLayoutColumn(split, false);
1493
1494                 RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
1495
1496                 for (i = 0; i < totitem; i++) {
1497                         if (item[i].identifier[0]) {
1498                                 uiItemEnumR_prop(column, item[i].name, item[i].icon, ptr, prop, item[i].value);
1499                                 ui_but_tip_from_enum_item(block->buttons.last, &item[i]);
1500                         }
1501                         else {
1502                                 if (item[i].name) {
1503                                         if (i != 0) {
1504                                                 column = uiLayoutColumn(split, false);
1505                                                 /* inconsistent, but menus with labels do not look good flipped */
1506                                                 block->flag |= UI_BLOCK_NO_FLIP;
1507                                         }
1508
1509                                         uiItemL(column, item[i].name, ICON_NONE);
1510                                         bt = block->buttons.last;
1511                                         bt->drawflag = UI_BUT_TEXT_LEFT;
1512
1513                                         ui_but_tip_from_enum_item(bt, &item[i]);
1514                                 }
1515                                 else
1516                                         uiItemS(column);
1517                         }
1518                 }
1519
1520                 if (free) {
1521                         MEM_freeN(item);
1522                 }
1523         }
1524
1525         /* intentionally don't touch UI_BLOCK_IS_FLIP here,
1526          * we don't know the context this is called in */
1527 }
1528
1529 /* Pointer RNA button with search */
1530
1531 typedef struct CollItemSearch {
1532         struct CollItemSearch *next, *prev;
1533         char *name;
1534         int index;
1535         int iconid;
1536 } CollItemSearch;
1537
1538 static int sort_search_items_list(const void *a, const void *b)
1539 {
1540         const CollItemSearch *cis1 = a;
1541         const CollItemSearch *cis2 = b;
1542         
1543         if (BLI_strcasecmp(cis1->name, cis2->name) > 0)
1544                 return 1;
1545         else
1546                 return 0;
1547 }
1548
1549 static void rna_search_cb(const struct bContext *C, void *arg_but, const char *str, uiSearchItems *items)
1550 {
1551         uiBut *but = arg_but;
1552         char *name;
1553         int i = 0, iconid = 0, flag = RNA_property_flag(but->rnaprop);
1554         ListBase *items_list = MEM_callocN(sizeof(ListBase), "items_list");
1555         CollItemSearch *cis;
1556         const bool skip_filter = !but->changed;
1557
1558         /* build a temporary list of relevant items first */
1559         RNA_PROP_BEGIN (&but->rnasearchpoin, itemptr, but->rnasearchprop)
1560         {
1561                 if (flag & PROP_ID_SELF_CHECK)
1562                         if (itemptr.data == but->rnapoin.id.data)
1563                                 continue;
1564
1565                 /* use filter */
1566                 if (RNA_property_type(but->rnaprop) == PROP_POINTER) {
1567                         if (RNA_property_pointer_poll(&but->rnapoin, but->rnaprop, &itemptr) == 0)
1568                                 continue;
1569                 }
1570
1571                 if (itemptr.type && RNA_struct_is_ID(itemptr.type)) {
1572                         ID *id = itemptr.data;
1573                         char name_ui[MAX_ID_NAME];
1574
1575 #if 0       /* this name is used for a string comparison and can't be modified, TODO */
1576                         /* if ever enabled, make name_ui be MAX_ID_NAME+1 */
1577                         BKE_id_ui_prefix(name_ui, id);
1578 #else
1579                         BLI_strncpy(name_ui, id->name + 2, sizeof(name_ui));
1580 #endif
1581                         name = BLI_strdup(name_ui);
1582                         iconid = ui_id_icon_get(C, id, false);
1583                 }
1584                 else {
1585                         name = RNA_struct_name_get_alloc(&itemptr, NULL, 0, NULL); /* could use the string length here */
1586                         iconid = 0;
1587                 }
1588
1589                 if (name) {
1590                         if (skip_filter || BLI_strcasestr(name, str)) {
1591                                 cis = MEM_callocN(sizeof(CollItemSearch), "CollectionItemSearch");
1592                                 cis->name = MEM_dupallocN(name);
1593                                 cis->index = i;
1594                                 cis->iconid = iconid;
1595                                 BLI_addtail(items_list, cis);
1596                         }
1597                         MEM_freeN(name);
1598                 }
1599
1600                 i++;
1601         }
1602         RNA_PROP_END;
1603         
1604         BLI_listbase_sort(items_list, sort_search_items_list);
1605         
1606         /* add search items from temporary list */
1607         for (cis = items_list->first; cis; cis = cis->next) {
1608                 if (false == UI_search_item_add(items, cis->name, SET_INT_IN_POINTER(cis->index), cis->iconid)) {
1609                         break;
1610                 }
1611         }
1612
1613         for (cis = items_list->first; cis; cis = cis->next) {
1614                 MEM_freeN(cis->name);
1615         }
1616         BLI_freelistN(items_list);
1617         MEM_freeN(items_list);
1618 }
1619
1620 static void search_id_collection(StructRNA *ptype, PointerRNA *ptr, PropertyRNA **prop)
1621 {
1622         StructRNA *srna;
1623
1624         /* look for collection property in Main */
1625         RNA_main_pointer_create(G.main, ptr);
1626
1627         *prop = NULL;
1628
1629         RNA_STRUCT_BEGIN (ptr, iprop)
1630         {
1631                 /* if it's a collection and has same pointer type, we've got it */
1632                 if (RNA_property_type(iprop) == PROP_COLLECTION) {
1633                         srna = RNA_property_pointer_type(ptr, iprop);
1634
1635                         if (ptype == srna) {
1636                                 *prop = iprop;
1637                                 break;
1638                         }
1639                 }
1640         }
1641         RNA_STRUCT_END;
1642 }
1643
1644 void ui_but_add_search(uiBut *but, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop)
1645 {
1646         StructRNA *ptype;
1647         PointerRNA sptr;
1648
1649         /* for ID's we do automatic lookup */
1650         if (!searchprop) {
1651                 if (RNA_property_type(prop) == PROP_POINTER) {
1652                         ptype = RNA_property_pointer_type(ptr, prop);
1653                         search_id_collection(ptype, &sptr, &searchprop);
1654                         searchptr = &sptr;
1655                 }
1656         }
1657
1658         /* turn button into search button */
1659         if (searchprop) {
1660                 but->type = UI_BTYPE_SEARCH_MENU;
1661                 but->hardmax = MAX2(but->hardmax, 256.0f);
1662                 but->rnasearchpoin = *searchptr;
1663                 but->rnasearchprop = searchprop;
1664                 but->drawflag |= UI_BUT_ICON_LEFT | UI_BUT_TEXT_LEFT;
1665                 if (RNA_property_is_unlink(prop)) {
1666                         but->flag |= UI_BUT_SEARCH_UNLINK;
1667                 }
1668
1669                 if (RNA_property_type(prop) == PROP_ENUM) {
1670                         /* XXX, this will have a menu string,
1671                          * but in this case we just want the text */
1672                         but->str[0] = 0;
1673                 }
1674
1675                 UI_but_func_search_set(but, rna_search_cb, but, NULL, NULL);
1676         }
1677 }
1678
1679 void uiItemPointerR(uiLayout *layout, struct PointerRNA *ptr, const char *propname, struct PointerRNA *searchptr, const char *searchpropname, const char *name, int icon)
1680 {
1681         PropertyRNA *prop, *searchprop;
1682         PropertyType type;
1683         uiBut *but;
1684         uiBlock *block;
1685         StructRNA *icontype;
1686         int w, h;
1687         char namestr[UI_MAX_NAME_STR];
1688         
1689         /* validate arguments */
1690         prop = RNA_struct_find_property(ptr, propname);
1691
1692         if (!prop) {
1693                 RNA_warning("property not found: %s.%s",
1694                             RNA_struct_identifier(ptr->type), propname);
1695                 return;
1696         }
1697         
1698         type = RNA_property_type(prop);
1699         if (!ELEM(type, PROP_POINTER, PROP_STRING, PROP_ENUM)) {
1700                 RNA_warning("Property %s must be a pointer, string or enum", propname);
1701                 return;
1702         }
1703
1704         searchprop = RNA_struct_find_property(searchptr, searchpropname);
1705
1706
1707         if (!searchprop) {
1708                 RNA_warning("search collection property not found: %s.%s",
1709                             RNA_struct_identifier(searchptr->type), searchpropname);
1710                 return;
1711         }
1712         else if (RNA_property_type(searchprop) != PROP_COLLECTION) {
1713                 RNA_warning("search collection property is not a collection type: %s.%s",
1714                             RNA_struct_identifier(searchptr->type), searchpropname);
1715                 return;
1716         }
1717
1718         /* get icon & name */
1719         if (icon == ICON_NONE) {
1720                 if (type == PROP_POINTER)
1721                         icontype = RNA_property_pointer_type(ptr, prop);
1722                 else
1723                         icontype = RNA_property_pointer_type(searchptr, searchprop);
1724
1725                 icon = RNA_struct_ui_icon(icontype);
1726         }
1727         if (!name)
1728                 name = RNA_property_ui_name(prop);
1729
1730         name = ui_item_name_add_colon(name, namestr);
1731
1732         /* create button */
1733         block = uiLayoutGetBlock(layout);
1734
1735         ui_item_rna_size(layout, name, icon, ptr, prop, 0, 0, &w, &h);
1736         w += UI_UNIT_X; /* X icon needs more space */
1737         but = ui_item_with_label(layout, block, name, icon, ptr, prop, 0, 0, 0, w, h, 0);
1738
1739         ui_but_add_search(but, ptr, prop, searchptr, searchprop);
1740 }
1741
1742 /* menu item */
1743 static void ui_item_menutype_func(bContext *C, uiLayout *layout, void *arg_mt)
1744 {
1745         MenuType *mt = (MenuType *)arg_mt;
1746         Menu menu = {NULL};
1747
1748         menu.type = mt;
1749         menu.layout = layout;
1750
1751         if (G.debug & G_DEBUG_WM) {
1752                 printf("%s: opening menu \"%s\"\n", __func__, mt->idname);
1753         }
1754
1755         if (layout->context)
1756                 CTX_store_set(C, layout->context);
1757
1758         mt->draw(C, &menu);
1759
1760         if (layout->context)
1761                 CTX_store_set(C, NULL);
1762
1763         /* menus are created flipped (from event handling pov) */
1764         layout->root->block->flag ^= UI_BLOCK_IS_FLIP;
1765 }
1766
1767 static uiBut *ui_item_menu(
1768         uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg, void *argN,
1769         const char *tip, bool force_menu)
1770 {
1771         uiBlock *block = layout->root->block;
1772         uiBut *but;
1773         int w, h;
1774
1775         UI_block_layout_set_current(block, layout);
1776
1777         if (layout->root->type == UI_LAYOUT_HEADER)
1778                 UI_block_emboss_set(block, UI_EMBOSS);
1779
1780         if (!name)
1781                 name = "";
1782         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1783                 icon = ICON_BLANK1;
1784
1785         w = ui_text_icon_width(layout, name, icon, 1);
1786         h = UI_UNIT_Y;
1787
1788         if (layout->root->type == UI_LAYOUT_HEADER) { /* ugly .. */
1789                 if (force_menu) {
1790                         w += UI_UNIT_Y;
1791                 }
1792                 else {
1793                         if (name[0]) {
1794                                 w -= UI_UNIT_Y / 2;
1795                         }
1796                 }
1797         }
1798
1799         if (name[0] && icon)
1800                 but = uiDefIconTextMenuBut(block, func, arg, icon, name, 0, 0, w, h, tip);
1801         else if (icon)
1802                 but = uiDefIconMenuBut(block, func, arg, icon, 0, 0, w, h, tip);
1803         else
1804                 but = uiDefMenuBut(block, func, arg, name, 0, 0, w, h, tip);
1805
1806         if (argN) { /* ugly .. */
1807                 but->poin = (char *)but;
1808                 but->func_argN = argN;
1809         }
1810
1811         if (layout->root->type == UI_LAYOUT_HEADER) {
1812                 UI_block_emboss_set(block, UI_EMBOSS);
1813         }
1814         if (ELEM(layout->root->type, UI_LAYOUT_PANEL, UI_LAYOUT_TOOLBAR) ||
1815             (force_menu && layout->root->type != UI_LAYOUT_MENU))  /* We never want a dropdown in menu! */
1816         {
1817                 UI_but_type_set_menu_from_pulldown(but);
1818         }
1819
1820         return but;
1821 }
1822
1823 void uiItemM(uiLayout *layout, bContext *UNUSED(C), const char *menuname, const char *name, int icon)
1824 {
1825         MenuType *mt;
1826
1827         mt = WM_menutype_find(menuname, false);
1828
1829         if (mt == NULL) {
1830                 RNA_warning("not found %s", menuname);
1831                 return;
1832         }
1833
1834         if (!name) {
1835                 name = CTX_IFACE_(mt->translation_context, mt->label);
1836         }
1837
1838         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1839                 icon = ICON_BLANK1;
1840
1841         ui_item_menu(layout, name, icon, ui_item_menutype_func, mt, NULL, TIP_(mt->description), false);
1842 }
1843
1844 /* label item */
1845 static uiBut *uiItemL_(uiLayout *layout, const char *name, int icon)
1846 {
1847         uiBlock *block = layout->root->block;
1848         uiBut *but;
1849         int w;
1850
1851         UI_block_layout_set_current(block, layout);
1852
1853         if (!name)
1854                 name = "";
1855         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1856                 icon = ICON_BLANK1;
1857
1858         w = ui_text_icon_width(layout, name, icon, 0);
1859
1860         if (icon && name[0])
1861                 but = uiDefIconTextBut(block, UI_BTYPE_LABEL, 0, icon, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
1862         else if (icon)
1863                 but = uiDefIconBut(block, UI_BTYPE_LABEL, 0, icon, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
1864         else
1865                 but = uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
1866
1867         /* to compensate for string size padding in ui_text_icon_width,
1868          * make text aligned right if the layout is aligned right.
1869          */
1870         if (uiLayoutGetAlignment(layout) == UI_LAYOUT_ALIGN_RIGHT) {
1871                 but->drawflag &= ~UI_BUT_TEXT_LEFT;     /* default, needs to be unset */
1872                 but->drawflag |= UI_BUT_TEXT_RIGHT;
1873         }
1874
1875         /* Mark as a label inside a listbox. */
1876         if (block->flag & UI_BLOCK_LIST_ITEM) {
1877                 but->flag |= UI_BUT_LIST_ITEM;
1878         }
1879
1880         return but;
1881 }
1882
1883 void uiItemL(uiLayout *layout, const char *name, int icon)
1884 {
1885         uiItemL_(layout, name, icon);
1886 }
1887
1888 void uiItemLDrag(uiLayout *layout, PointerRNA *ptr, const char *name, int icon)
1889 {
1890         uiBut *but = uiItemL_(layout, name, icon);
1891
1892         if (ptr && ptr->type)
1893                 if (RNA_struct_is_ID(ptr->type))
1894                         UI_but_drag_set_id(but, ptr->id.data);
1895 }
1896
1897
1898 /* value item */
1899 void uiItemV(uiLayout *layout, const char *name, int icon, int argval)
1900 {
1901         /* label */
1902         uiBlock *block = layout->root->block;
1903         int *retvalue = (block->handle) ? &block->handle->retvalue : NULL;
1904         int w;
1905
1906         UI_block_layout_set_current(block, layout);
1907
1908         if (!name)
1909                 name = "";
1910         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1911                 icon = ICON_BLANK1;
1912
1913         w = ui_text_icon_width(layout, name, icon, 0);
1914
1915         if (icon && name[0])
1916                 uiDefIconTextButI(block, UI_BTYPE_BUT, argval, icon, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
1917         else if (icon)
1918                 uiDefIconButI(block, UI_BTYPE_BUT, argval, icon, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
1919         else
1920                 uiDefButI(block, UI_BTYPE_BUT, argval, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
1921 }
1922
1923 /* separator item */
1924 void uiItemS(uiLayout *layout)
1925 {
1926         uiBlock *block = layout->root->block;
1927         bool is_menu = ui_block_is_menu(block);
1928         int space = (is_menu) ? 0.45f * UI_UNIT_X : 0.3f * UI_UNIT_X;
1929
1930         UI_block_layout_set_current(block, layout);
1931         uiDefBut(block, (is_menu) ? UI_BTYPE_SEPR_LINE : UI_BTYPE_SEPR, 0, "", 0, 0, space, space, NULL, 0.0, 0.0, 0, 0, "");
1932 }
1933
1934 /* level items */
1935 void uiItemMenuF(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg)
1936 {
1937         if (!func)
1938                 return;
1939
1940         ui_item_menu(layout, name, icon, func, arg, NULL, "", false);
1941 }
1942
1943 typedef struct MenuItemLevel {
1944         int opcontext;
1945         /* don't use pointers to the strings because python can dynamically
1946          * allocate strings and free before the menu draws, see [#27304] */
1947         char opname[OP_MAX_TYPENAME];
1948         char propname[MAX_IDPROP_NAME];
1949         PointerRNA rnapoin;
1950 } MenuItemLevel;
1951
1952 static void menu_item_enum_opname_menu(bContext *UNUSED(C), uiLayout *layout, void *arg)
1953 {
1954         MenuItemLevel *lvl = (MenuItemLevel *)(((uiBut *)arg)->func_argN);
1955
1956         uiLayoutSetOperatorContext(layout, lvl->opcontext);
1957         uiItemsEnumO(layout, lvl->opname, lvl->propname);
1958
1959         layout->root->block->flag |= UI_BLOCK_IS_FLIP;
1960
1961         /* override default, needed since this was assumed pre 2.70 */
1962         UI_block_direction_set(layout->root->block, UI_DIR_DOWN);
1963 }
1964
1965 void uiItemMenuEnumO(uiLayout *layout, bContext *C, const char *opname, const char *propname, const char *name, int icon)
1966 {
1967         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1968         MenuItemLevel *lvl;
1969         uiBut *but;
1970
1971         UI_OPERATOR_ERROR_RET(ot, opname, return);
1972
1973         if (!ot->srna) {
1974                 ui_item_disabled(layout, opname);
1975                 RNA_warning("operator missing srna '%s'", opname);
1976                 return;
1977         }
1978
1979         if (name == NULL) {
1980                 name = RNA_struct_ui_name(ot->srna);
1981         }
1982
1983         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1984                 icon = ICON_BLANK1;
1985
1986         lvl = MEM_callocN(sizeof(MenuItemLevel), "MenuItemLevel");
1987         BLI_strncpy(lvl->opname, opname, sizeof(lvl->opname));
1988         BLI_strncpy(lvl->propname, propname, sizeof(lvl->propname));
1989         lvl->opcontext = layout->root->opcontext;
1990
1991         but = ui_item_menu(layout, name, icon, menu_item_enum_opname_menu, NULL, lvl,
1992                            RNA_struct_ui_description(ot->srna), true);
1993
1994         /* add hotkey here, lower UI code can't detect it */
1995         if ((layout->root->block->flag & UI_BLOCK_LOOP) &&
1996             (ot->prop && ot->invoke))
1997         {
1998                 char keybuf[128];
1999                 if (WM_key_event_operator_string(C, ot->idname, layout->root->opcontext, NULL, false,
2000                                                  sizeof(keybuf), keybuf))
2001                 {
2002                         ui_but_add_shortcut(but, keybuf, false);
2003                 }
2004         }
2005 }
2006
2007 static void menu_item_enum_rna_menu(bContext *UNUSED(C), uiLayout *layout, void *arg)
2008 {
2009         MenuItemLevel *lvl = (MenuItemLevel *)(((uiBut *)arg)->func_argN);
2010
2011         uiLayoutSetOperatorContext(layout, lvl->opcontext);
2012         uiItemsEnumR(layout, &lvl->rnapoin, lvl->propname);
2013         layout->root->block->flag |= UI_BLOCK_IS_FLIP;
2014 }
2015
2016 void uiItemMenuEnumR_prop(uiLayout *layout, struct PointerRNA *ptr, PropertyRNA *prop, const char *name, int icon)
2017 {
2018         MenuItemLevel *lvl;
2019
2020         if (!name)
2021                 name = RNA_property_ui_name(prop);
2022         if (layout->root->type == UI_LAYOUT_MENU && !icon)
2023                 icon = ICON_BLANK1;
2024
2025         lvl = MEM_callocN(sizeof(MenuItemLevel), "MenuItemLevel");
2026         lvl->rnapoin = *ptr;
2027         BLI_strncpy(lvl->propname, RNA_property_identifier(prop), sizeof(lvl->propname));
2028         lvl->opcontext = layout->root->opcontext;
2029
2030         ui_item_menu(layout, name, icon, menu_item_enum_rna_menu, NULL, lvl, RNA_property_description(prop), false);
2031 }
2032
2033 void uiItemMenuEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *name, int icon)
2034 {
2035         PropertyRNA *prop;
2036
2037         prop = RNA_struct_find_property(ptr, propname);
2038         if (!prop) {
2039                 ui_item_disabled(layout, propname);
2040                 RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
2041                 return;
2042         }
2043
2044         uiItemMenuEnumR_prop(layout, ptr, prop, name, icon);
2045 }
2046
2047 /**************************** Layout Items ***************************/
2048
2049 /* single-row layout */
2050 static void ui_litem_estimate_row(uiLayout *litem)
2051 {
2052         uiItem *item;
2053         int itemw, itemh;
2054
2055         litem->w = 0;
2056         litem->h = 0;
2057
2058         for (item = litem->items.first; item; item = item->next) {
2059                 ui_item_size(item, &itemw, &itemh);
2060
2061                 litem->w += itemw;
2062                 litem->h = MAX2(itemh, litem->h);
2063
2064                 if (item->next)
2065                         litem->w += litem->space;
2066         }
2067 }
2068
2069 static int ui_litem_min_width(int itemw)
2070 {
2071         return MIN2(2 * UI_UNIT_X, itemw);
2072 }
2073
2074 static void ui_litem_layout_row(uiLayout *litem)
2075 {
2076         uiItem *item;
2077         int x, y, w, tot, totw, neww, newtotw, itemw, minw, itemh, offset;
2078         int fixedw, freew, fixedx, freex, flag = 0, lastw = 0;
2079
2080         /* x = litem->x; */ /* UNUSED */
2081         y = litem->y;
2082         w = litem->w;
2083         totw = 0;
2084         tot = 0;
2085
2086         for (item = litem->items.first; item; item = item->next) {
2087                 ui_item_size(item, &itemw, &itemh);
2088                 totw += itemw;
2089                 tot++;
2090         }
2091
2092         if (totw == 0)
2093                 return;
2094         
2095         if (w != 0)
2096                 w -= (tot - 1) * litem->space;
2097         fixedw = 0;
2098
2099         /* keep clamping items to fixed minimum size until all are done */
2100         do {
2101                 freew = 0;
2102                 x = 0;
2103                 flag = 0;
2104                 newtotw = totw;
2105
2106                 for (item = litem->items.first; item; item = item->next) {
2107                         if (item->flag)
2108                                 continue;
2109
2110                         ui_item_size(item, &itemw, &itemh);
2111                         minw = ui_litem_min_width(itemw);
2112
2113                         if (w - lastw > 0)
2114                                 neww = ui_item_fit(itemw, x, totw, w - lastw, !item->next, litem->alignment, NULL);
2115                         else
2116                                 neww = 0;  /* no space left, all will need clamping to minimum size */
2117
2118                         x += neww;
2119
2120                         if ((neww < minw || itemw == minw) && w != 0) {
2121                                 /* fixed size */
2122                                 item->flag = 1;
2123                                 fixedw += minw;
2124                                 flag = 1;
2125                                 newtotw -= itemw;
2126                         }
2127                         else {
2128                                 /* keep free size */
2129                                 item->flag = 0;
2130                                 freew += itemw;
2131                         }
2132                 }
2133
2134                 totw = newtotw;
2135                 lastw = fixedw;
2136         } while (flag);
2137
2138         freex = 0;
2139         fixedx = 0;
2140         x = litem->x;
2141
2142         for (item = litem->items.first; item; item = item->next) {
2143                 ui_item_size(item, &itemw, &itemh);
2144                 minw = ui_litem_min_width(itemw);
2145
2146                 if (item->flag) {
2147                         /* fixed minimum size items */
2148                         itemw = ui_item_fit(minw, fixedx, fixedw, min_ii(w, fixedw), !item->next, litem->alignment, NULL);
2149                         fixedx += itemw;
2150                 }
2151                 else {
2152                         /* free size item */
2153                         itemw = ui_item_fit(itemw, freex, freew, w - fixedw, !item->next, litem->alignment, NULL);
2154                         freex += itemw;
2155                 }
2156
2157                 /* align right/center */
2158                 offset = 0;
2159                 if (litem->alignment == UI_LAYOUT_ALIGN_RIGHT) {
2160                         if (freew + fixedw > 0 && freew + fixedw < w)
2161                                 offset = w - (fixedw + freew);
2162                 }
2163                 else if (litem->alignment == UI_LAYOUT_ALIGN_CENTER) {
2164                         if (freew + fixedw > 0 && freew + fixedw < w)
2165                                 offset = (w - (fixedw + freew)) / 2;
2166                 }
2167
2168                 /* position item */
2169                 ui_item_position(item, x + offset, y - itemh, itemw, itemh);
2170
2171                 x += itemw;
2172                 if (item->next)
2173                         x += litem->space;
2174         }
2175
2176         litem->w = x - litem->x;
2177         litem->h = litem->y - y;
2178         litem->x = x;
2179         litem->y = y;
2180 }
2181
2182 /* single-column layout */
2183 static void ui_litem_estimate_column(uiLayout *litem)
2184 {
2185         uiItem *item;
2186         int itemw, itemh;
2187
2188         litem->w = 0;
2189         litem->h = 0;
2190
2191         for (item = litem->items.first; item; item = item->next) {
2192                 ui_item_size(item, &itemw, &itemh);
2193
2194                 litem->w = MAX2(litem->w, itemw);
2195                 litem->h += itemh;
2196
2197                 if (item->next)
2198                         litem->h += litem->space;
2199         }
2200 }
2201
2202 static void ui_litem_layout_column(uiLayout *litem)
2203 {
2204         uiItem *item;
2205         int itemh, x, y;
2206
2207         x = litem->x;
2208         y = litem->y;
2209
2210         for (item = litem->items.first; item; item = item->next) {
2211                 ui_item_size(item, NULL, &itemh);
2212
2213                 y -= itemh;
2214                 ui_item_position(item, x, y, litem->w, itemh);
2215
2216                 if (item->next)
2217                         y -= litem->space;
2218         }
2219
2220         litem->h = litem->y - y;
2221         litem->x = x;
2222         litem->y = y;
2223 }
2224
2225 /* calculates the angle of a specified button in a radial menu,
2226  * stores a float vector in unit circle */
2227 static RadialDirection ui_get_radialbut_vec(float vec[2], short itemnum)
2228 {
2229         RadialDirection dir;
2230
2231         if (itemnum >= PIE_MAX_ITEMS) {
2232                 itemnum %= PIE_MAX_ITEMS;
2233                 printf("Warning: Pie menus with more than %i items are currently unsupported\n", PIE_MAX_ITEMS);
2234         }
2235
2236         dir = ui_radial_dir_order[itemnum];
2237         ui_but_pie_dir(dir, vec);
2238
2239         return dir;
2240 }
2241
2242 static bool ui_item_is_radial_displayable(uiItem *item)
2243 {
2244
2245         if ((item->type == ITEM_BUTTON) && (((uiButtonItem *)item)->but->type == UI_BTYPE_LABEL))
2246                 return false;
2247
2248         return true;
2249 }
2250
2251 static bool ui_item_is_radial_drawable(uiButtonItem *bitem)
2252 {
2253
2254         if (ELEM(bitem->but->type, UI_BTYPE_SEPR, UI_BTYPE_SEPR_LINE))
2255                 return false;
2256
2257         return true;
2258 }
2259
2260 static void ui_litem_layout_radial(uiLayout *litem)
2261 {
2262         uiItem *item;
2263         int itemh, itemw, x, y;
2264         int itemnum = 0;
2265         int totitems = 0;
2266
2267         int minx, miny, maxx, maxy;
2268         /* For the radial layout we will use Matt Ebb's design
2269          * for radiation, see http://mattebb.com/weblog/radiation/
2270          * also the old code at http://developer.blender.org/T5103
2271          */
2272
2273         int pie_radius = U.pie_menu_radius * UI_DPI_FAC;
2274
2275         x = litem->x;
2276         y = litem->y;
2277
2278         minx = x, miny = y, maxx = x, maxy = y;
2279
2280         /* first count total items */
2281         for (item = litem->items.first; item; item = item->next)
2282                 totitems++;
2283
2284         if (totitems < 5)
2285                 litem->root->block->pie_data.flags |= UI_PIE_DEGREES_RANGE_LARGE;
2286
2287         for (item = litem->items.first; item; item = item->next) {
2288                 /* not all button types are drawn in a radial menu, do filtering here */
2289                 if (ui_item_is_radial_displayable(item)) {
2290                         RadialDirection dir;
2291                         float vec[2];
2292                         float factor[2];
2293
2294                         dir = ui_get_radialbut_vec(vec, itemnum);
2295                         factor[0] = (vec[0] > 0.01f) ? 0.0f : ((vec[0] < -0.01f) ? -1.0f : -0.5f);
2296                         factor[1] = (vec[1] > 0.99f) ? 0.0f : ((vec[1] < -0.99f) ? -1.0f : -0.5f);
2297
2298                         itemnum++;
2299
2300                         if (item->type == ITEM_BUTTON) {
2301                                 uiButtonItem *bitem = (uiButtonItem *) item;
2302
2303                                 bitem->but->pie_dir = dir;
2304                                 /* scale the buttons */
2305                                 bitem->but->rect.ymax *= 1.5f;
2306                                 /* add a little bit more here to include number */
2307                                 bitem->but->rect.xmax += 1.5f * UI_UNIT_X;
2308                                 /* enable drawing as pie item if supported by widget */
2309                                 if (ui_item_is_radial_drawable(bitem))
2310                                         bitem->but->dt = UI_EMBOSS_RADIAL;
2311                         }
2312
2313                         ui_item_size(item, &itemw, &itemh);
2314
2315                         ui_item_position(item, x + vec[0] * pie_radius + factor[0] * itemw, y + vec[1] * pie_radius + factor[1] * itemh, itemw, itemh);
2316
2317                         minx = min_ii(minx, x + vec[0] * pie_radius - itemw / 2);
2318                         maxx = max_ii(maxx, x + vec[0] * pie_radius + itemw / 2);
2319                         miny = min_ii(miny, y + vec[1] * pie_radius - itemh / 2);
2320                         maxy = max_ii(maxy, y + vec[1] * pie_radius + itemh / 2);
2321                 }
2322         }
2323
2324         litem->x = minx;
2325         litem->y = miny;
2326         litem->w = maxx - minx;
2327         litem->h = maxy - miny;
2328 }
2329
2330 /* root layout */
2331 static void ui_litem_estimate_root(uiLayout *UNUSED(litem))
2332 {
2333         /* nothing to do */
2334 }
2335
2336 static void ui_litem_layout_root_radial(uiLayout *litem)
2337 {
2338         /* first item is pie menu title, align on center of menu */
2339         uiItem *item = litem->items.first;
2340
2341         if (item->type == ITEM_BUTTON) {
2342                 int itemh, itemw, x, y;
2343                 x = litem->x;
2344                 y = litem->y;
2345
2346                 ui_item_size(item, &itemw, &itemh);
2347
2348                 ui_item_position(item, x - itemw / 2, y + U.pixelsize * (U.pie_menu_threshold + 9.0f), itemw, itemh);
2349         }
2350 }
2351
2352 static void ui_litem_layout_root(uiLayout *litem)
2353 {
2354         if (litem->root->type == UI_LAYOUT_HEADER)
2355                 ui_litem_layout_row(litem);
2356         else if (litem->root->type == UI_LAYOUT_PIEMENU)
2357                 ui_litem_layout_root_radial(litem);
2358         else
2359                 ui_litem_layout_column(litem);
2360 }
2361
2362 /* box layout */
2363 static void ui_litem_estimate_box(uiLayout *litem)
2364 {
2365         uiStyle *style = litem->root->style;
2366
2367         ui_litem_estimate_column(litem);
2368         litem->w += 2 * style->boxspace;
2369         litem->h += style->boxspace;
2370 }
2371
2372 static void ui_litem_layout_box(uiLayout *litem)
2373 {
2374         uiLayoutItemBx *box = (uiLayoutItemBx *)litem;
2375         uiStyle *style = litem->root->style;
2376         uiBut *but;
2377         int w, h;
2378
2379         w = litem->w;
2380         h = litem->h;
2381
2382         litem->x += style->boxspace;
2383
2384         if (w != 0) litem->w -= 2 * style->boxspace;
2385         if (h != 0) litem->h -= 2 * style->boxspace;
2386
2387         ui_litem_layout_column(litem);
2388
2389         litem->x -= style->boxspace;
2390         litem->y -= style->boxspace;
2391
2392         if (w != 0) litem->w += 2 * style->boxspace;
2393         if (h != 0) litem->h += style->boxspace;
2394
2395         /* roundbox around the sublayout */
2396         but = box->roundbox;
2397         but->rect.xmin = litem->x;
2398         but->rect.ymin = litem->y;
2399         but->rect.xmax = litem->x + litem->w;
2400         but->rect.ymax = litem->y + litem->h;
2401 }
2402
2403 /* multi-column layout, automatically flowing to the next */
2404 static void ui_litem_estimate_column_flow(uiLayout *litem)
2405 {
2406         uiStyle *style = litem->root->style;
2407         uiLayoutItemFlow *flow = (uiLayoutItemFlow *)litem;
2408         uiItem *item;
2409         int col, x, y, emh, emy, miny, itemw, itemh, maxw = 0;
2410         int toth, totitem;
2411
2412         /* compute max needed width and total height */
2413         toth = 0;
2414         totitem = 0;
2415         for (item = litem->items.first; item; item = item->next) {
2416                 ui_item_size(item, &itemw, &itemh);
2417                 maxw = MAX2(maxw, itemw);
2418                 toth += itemh;
2419                 totitem++;
2420         }
2421
2422         if (flow->number <= 0) {
2423                 /* auto compute number of columns, not very good */
2424                 if (maxw == 0) {
2425                         flow->totcol = 1;
2426                         return;
2427                 }
2428
2429                 flow->totcol = max_ii(litem->root->emw / maxw, 1);
2430                 flow->totcol = min_ii(flow->totcol, totitem);
2431         }
2432         else
2433                 flow->totcol = flow->number;
2434
2435         /* compute sizes */
2436         x = 0;
2437         y = 0;
2438         emy = 0;
2439         miny = 0;
2440
2441         maxw = 0;
2442         emh = toth / flow->totcol;
2443
2444         /* create column per column */
2445         col = 0;
2446         for (item = litem->items.first; item; item = item->next) {
2447                 ui_item_size(item, &itemw, &itemh);
2448
2449                 y -= itemh + style->buttonspacey;
2450                 miny = min_ii(miny, y);
2451                 emy -= itemh;
2452                 maxw = max_ii(itemw, maxw);
2453
2454                 /* decide to go to next one */
2455                 if (col < flow->totcol - 1 && emy <= -emh) {
2456                         x += maxw + litem->space;
2457                         maxw = 0;
2458                         y = 0;
2459                         emy = 0; /* need to reset height again for next column */
2460                         col++;
2461                 }
2462         }
2463
2464         litem->w = x;
2465         litem->h = litem->y - miny;
2466 }
2467
2468 static void ui_litem_layout_column_flow(uiLayout *litem)
2469 {
2470         uiStyle *style = litem->root->style;
2471         uiLayoutItemFlow *flow = (uiLayoutItemFlow *)litem;
2472         uiItem *item;
2473         int col, x, y, w, emh, emy, miny, itemw, itemh;
2474         int toth, totitem, offset;
2475
2476         /* compute max needed width and total height */
2477         toth = 0;
2478         totitem = 0;
2479         for (item = litem->items.first; item; item = item->next) {
2480                 ui_item_size(item, &itemw, &itemh);
2481                 toth += itemh;
2482                 totitem++;
2483         }
2484
2485         /* compute sizes */
2486         x = litem->x;
2487         y = litem->y;
2488         emy = 0;
2489         miny = 0;
2490
2491         w = litem->w - (flow->totcol - 1) * style->columnspace;
2492         emh = toth / flow->totcol;
2493
2494         /* create column per column */
2495         col = 0;
2496         for (item = litem->items.first; item; item = item->next) {
2497                 ui_item_size(item, NULL, &itemh);
2498                 itemw = ui_item_fit(1, x - litem->x, flow->totcol, w, col == flow->totcol - 1, litem->alignment, &offset);
2499         
2500                 y -= itemh;
2501                 emy -= itemh;
2502                 ui_item_position(item, x + offset, y, itemw, itemh);
2503                 y -= style->buttonspacey;
2504                 miny = min_ii(miny, y);
2505
2506                 /* decide to go to next one */
2507                 if (col < flow->totcol - 1 && emy <= -emh) {
2508                         x += itemw + style->columnspace;
2509                         y = litem->y;
2510                         emy = 0; /* need to reset height again for next column */
2511                         col++;
2512                 }
2513         }
2514
2515         litem->h = litem->y - miny;
2516         litem->x = x;
2517         litem->y = miny;
2518 }
2519
2520 /* free layout */
2521 static void ui_litem_estimate_absolute(uiLayout *litem)
2522 {
2523         uiItem *item;
2524         int itemx, itemy, itemw, itemh, minx, miny;
2525
2526         minx = 1e6;
2527         miny = 1e6;
2528         litem->w = 0;
2529         litem->h = 0;
2530
2531         for (item = litem->items.first; item; item = item->next) {
2532                 ui_item_offset(item, &itemx, &itemy);
2533                 ui_item_size(item, &itemw, &itemh);
2534
2535                 minx = min_ii(minx, itemx);
2536                 miny = min_ii(miny, itemy);
2537
2538                 litem->w = MAX2(litem->w, itemx + itemw);
2539                 litem->h = MAX2(litem->h, itemy + itemh);
2540         }
2541
2542         litem->w -= minx;
2543         litem->h -= miny;
2544 }
2545
2546 static void ui_litem_layout_absolute(uiLayout *litem)
2547 {
2548         uiItem *item;
2549         float scalex = 1.0f, scaley = 1.0f;
2550         int x, y, newx, newy, itemx, itemy, itemh, itemw, minx, miny, totw, toth;
2551
2552         minx = 1e6;
2553         miny = 1e6;
2554         totw = 0;
2555         toth = 0;
2556
2557         for (item = litem->items.first; item; item = item->next) {
2558                 ui_item_offset(item, &itemx, &itemy);
2559                 ui_item_size(item, &itemw, &itemh);
2560
2561                 minx = min_ii(minx, itemx);
2562                 miny = min_ii(miny, itemy);
2563
2564                 totw = max_ii(totw, itemx + itemw);
2565                 toth = max_ii(toth, itemy + itemh);
2566         }
2567
2568         totw -= minx;
2569         toth -= miny;
2570
2571         if (litem->w && totw > 0)
2572                 scalex = (float)litem->w / (float)totw;
2573         if (litem->h && toth > 0)
2574                 scaley = (float)litem->h / (float)toth;
2575         
2576         x = litem->x;
2577         y = litem->y - scaley * toth;
2578
2579         for (item = litem->items.first; item; item = item->next) {
2580                 ui_item_offset(item, &itemx, &itemy);
2581                 ui_item_size(item, &itemw, &itemh);
2582
2583                 if (scalex != 1.0f) {
2584                         newx = (itemx - minx) * scalex;
2585                         itemw = (itemx - minx + itemw) * scalex - newx;
2586                         itemx = minx + newx;
2587                 }
2588
2589                 if (scaley != 1.0f) {
2590                         newy = (itemy - miny) * scaley;
2591                         itemh = (itemy - miny + itemh) * scaley - newy;
2592                         itemy = miny + newy;
2593                 }
2594
2595                 ui_item_position(item, x + itemx - minx, y + itemy - miny, itemw, itemh);
2596         }
2597
2598         litem->w = scalex * totw;
2599         litem->h = litem->y - y;
2600         litem->x = x + litem->w;
2601         litem->y = y;
2602 }
2603
2604 /* split layout */
2605 static void ui_litem_estimate_split(uiLayout *litem)
2606 {
2607         ui_litem_estimate_row(litem);
2608 }
2609
2610 static void ui_litem_layout_split(uiLayout *litem)
2611 {
2612         uiLayoutItemSplit *split = (uiLayoutItemSplit *)litem;
2613         uiItem *item;
2614         float percentage;
2615         const int tot = BLI_listbase_count(&litem->items);
2616         int itemh, x, y, w, colw = 0;
2617
2618         if (tot == 0)
2619                 return;
2620
2621         x = litem->x;
2622         y = litem->y;
2623
2624         percentage = (split->percentage == 0.0f) ? 1.0f / (float)tot : split->percentage;
2625         
2626         w = (litem->w - (tot - 1) * litem->space);
2627         colw = w * percentage;
2628         colw = MAX2(colw, 0);
2629
2630         for (item = litem->items.first; item; item = item->next) {
2631                 ui_item_size(item, NULL, &itemh);
2632
2633                 ui_item_position(item, x, y - itemh, colw, itemh);
2634                 x += colw;
2635
2636                 if (item->next) {
2637                         colw = (w - (int)(w * percentage)) / (tot - 1);
2638                         colw = MAX2(colw, 0);
2639
2640                         x += litem->space;
2641                 }
2642         }
2643
2644         litem->w = x - litem->x;
2645         litem->h = litem->y - y;
2646         litem->x = x;
2647         litem->y = y;
2648 }
2649
2650 /* overlap layout */
2651 static void ui_litem_estimate_overlap(uiLayout *litem)
2652 {
2653         uiItem *item;
2654         int itemw, itemh;
2655
2656         litem->w = 0;
2657         litem->h = 0;
2658
2659         for (item = litem->items.first; item; item = item->next) {
2660                 ui_item_size(item, &itemw, &itemh);
2661
2662                 litem->w = MAX2(itemw, litem->w);
2663                 litem->h = MAX2(itemh, litem->h);
2664         }
2665 }
2666
2667 static void ui_litem_layout_overlap(uiLayout *litem)
2668 {
2669         uiItem *item;
2670         int itemw, itemh, x, y;
2671
2672         x = litem->x;
2673         y = litem->y;
2674
2675         for (item = litem->items.first; item; item = item->next) {
2676                 ui_item_size(item, &itemw, &itemh);
2677                 ui_item_position(item, x, y - itemh, litem->w, itemh);
2678
2679                 litem->h = MAX2(litem->h, itemh);
2680         }
2681
2682         litem->x = x;
2683         litem->y = y - litem->h;
2684 }
2685
2686 /* layout create functions */
2687 uiLayout *uiLayoutRow(uiLayout *layout, int align)
2688 {
2689         uiLayout *litem;
2690
2691         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutRow");
2692         litem->item.type = ITEM_LAYOUT_ROW;
2693         litem->root = layout->root;
2694         litem->align = align;
2695         litem->active = true;
2696         litem->enabled = true;
2697         litem->context = layout->context;
2698         litem->space = (align) ? 0 : layout->root->style->buttonspacex;
2699         litem->redalert = layout->redalert;
2700         litem->w = layout->w;
2701         BLI_addtail(&layout->items, litem);
2702
2703         UI_block_layout_set_current(layout->root->block, litem);
2704
2705         return litem;
2706 }
2707
2708 uiLayout *uiLayoutColumn(uiLayout *layout, int align)
2709 {
2710         uiLayout *litem;
2711
2712         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutColumn");
2713         litem->item.type = ITEM_LAYOUT_COLUMN;
2714         litem->root = layout->root;
2715         litem->align = align;
2716         litem->active = true;
2717         litem->enabled = true;
2718         litem->context = layout->context;
2719         litem->space = (litem->align) ? 0 : layout->root->style->buttonspacey;
2720         litem->redalert = layout->redalert;
2721         litem->w = layout->w;
2722         BLI_addtail(&layout->items, litem);
2723
2724         UI_block_layout_set_current(layout->root->block, litem);
2725
2726         return litem;
2727 }
2728
2729 uiLayout *uiLayoutColumnFlow(uiLayout *layout, int number, int align)
2730 {
2731         uiLayoutItemFlow *flow;
2732
2733         flow = MEM_callocN(sizeof(uiLayoutItemFlow), "uiLayoutItemFlow");
2734         flow->litem.item.type = ITEM_LAYOUT_COLUMN_FLOW;
2735         flow->litem.root = layout->root;
2736         flow->litem.align = align;
2737         flow->litem.active = true;
2738         flow->litem.enabled = true;
2739         flow->litem.context = layout->context;
2740         flow->litem.space = (flow->litem.align) ? 0 : layout->root->style->columnspace;
2741         flow->litem.redalert = layout->redalert;
2742         flow->litem.w = layout->w;
2743         flow->number = number;
2744         BLI_addtail(&layout->items, flow);
2745
2746         UI_block_layout_set_current(layout->root->block, &flow->litem);
2747
2748         return &flow->litem;
2749 }
2750
2751 static uiLayoutItemBx *ui_layout_box(uiLayout *layout, int type)
2752 {
2753         uiLayoutItemBx *box;
2754
2755         box = MEM_callocN(sizeof(uiLayoutItemBx), "uiLayoutItemBx");
2756         box->litem.item.type = ITEM_LAYOUT_BOX;
2757         box->litem.root = layout->root;
2758         box->litem.active = 1;
2759         box->litem.enabled = 1;
2760         box->litem.context = layout->context;
2761         box->litem.space = layout->root->style->columnspace;
2762         box->litem.redalert = layout->redalert;
2763         box->litem.w = layout->w;
2764         BLI_addtail(&layout->items, box);
2765
2766         UI_block_layout_set_current(layout->root->block, &box->litem);
2767
2768         box->roundbox = uiDefBut(layout->root->block, type, 0, "", 0, 0, 0, 0, NULL, 0.0, 0.0, 0, 0, "");
2769
2770         return box;
2771 }
2772
2773 uiLayout *uiLayoutRadial(uiLayout *layout)
2774 {
2775         uiLayout *litem;
2776         uiItem *item;
2777
2778         /* radial layouts are only valid for radial menus */
2779         if (layout->root->type != UI_LAYOUT_PIEMENU)
2780                 return ui_item_local_sublayout(layout, layout, 0);
2781
2782         /* only one radial wheel per root layout is allowed, so check and return that, if it exists */
2783         for (item = layout->root->layout->items.first; item; item = item->next) {
2784                 litem = (uiLayout *)item;
2785                 if (litem->item.type == ITEM_LAYOUT_RADIAL) {
2786                         UI_block_layout_set_current(layout->root->block, litem);
2787                         return litem;
2788                 }
2789         }
2790
2791         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutRadial");
2792         litem->item.type = ITEM_LAYOUT_RADIAL;
2793         litem->root = layout->root;
2794         litem->active = true;
2795         litem->enabled = true;
2796         litem->context = layout->context;
2797         litem->redalert = layout->redalert;
2798         litem->w = layout->w;
2799         BLI_addtail(&layout->root->layout->items, litem);
2800
2801         UI_block_layout_set_current(layout->root->block, litem);
2802
2803         return litem;
2804 }
2805
2806
2807 uiLayout *uiLayoutBox(uiLayout *layout)
2808 {
2809         return (uiLayout *)ui_layout_box(layout, UI_BTYPE_ROUNDBOX);
2810 }
2811
2812 /**
2813  * Check all buttons defined in this layout, and set any button flagged as UI_BUT_LIST_ITEM as active/selected.
2814  * Needed to handle correctly text colors of active (selected) list item.
2815  */
2816 void ui_layout_list_set_labels_active(uiLayout *layout)
2817 {
2818         uiButtonItem *bitem;
2819         for (bitem = layout->items.first; bitem; bitem = bitem->item.next) {
2820                 if (bitem->item.type != ITEM_BUTTON) {
2821                         ui_layout_list_set_labels_active((uiLayout *)(&bitem->item));
2822                 }
2823                 else if (bitem->but->flag & UI_BUT_LIST_ITEM) {
2824                         UI_but_flag_enable(bitem->but, UI_SELECT);
2825                 }
2826         }
2827 }
2828
2829 uiLayout *uiLayoutListBox(
2830         uiLayout *layout, uiList *ui_list, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *actptr,
2831         PropertyRNA *actprop)
2832 {
2833         uiLayoutItemBx *box = ui_layout_box(layout, UI_BTYPE_LISTBOX);
2834         uiBut *but = box->roundbox;
2835
2836         but->custom_data = ui_list;
2837
2838         but->rnasearchpoin = *ptr;
2839         but->rnasearchprop = prop;
2840         but->rnapoin = *actptr;
2841         but->rnaprop = actprop;
2842
2843         /* only for the undo string */
2844         if (but->flag & UI_BUT_UNDO) {
2845                 but->tip = RNA_property_description(actprop);
2846         }
2847
2848         return (uiLayout *)box;
2849 }
2850
2851 uiLayout *uiLayoutAbsolute(uiLayout *layout, int align)
2852 {
2853         uiLayout *litem;
2854
2855         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutAbsolute");
2856         litem->item.type = ITEM_LAYOUT_ABSOLUTE;
2857         litem->root = layout->root;
2858         litem->align = align;
2859         litem->active = 1;
2860         litem->enabled = 1;
2861         litem->context = layout->context;
2862         litem->redalert = layout->redalert;
2863         BLI_addtail(&layout->items, litem);
2864
2865         UI_block_layout_set_current(layout->root->block, litem);
2866
2867         return litem;
2868 }
2869
2870 uiBlock *uiLayoutAbsoluteBlock(uiLayout *layout)
2871 {
2872         uiBlock *block;
2873
2874         block = uiLayoutGetBlock(layout);
2875         uiLayoutAbsolute(layout, false);
2876
2877         return block;
2878 }
2879
2880 uiLayout *uiLayoutOverlap(uiLayout *layout)
2881 {
2882         uiLayout *litem;
2883
2884         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutOverlap");
2885         litem->item.type = ITEM_LAYOUT_OVERLAP;
2886         litem->root = layout->root;
2887         litem->active = true;
2888         litem->enabled = true;
2889         litem->context = layout->context;
2890         litem->redalert = layout->redalert;
2891         BLI_addtail(&layout->items, litem);
2892
2893         UI_block_layout_set_current(layout->root->block, litem);
2894
2895         return litem;
2896 }
2897
2898 uiLayout *uiLayoutSplit(uiLayout *layout, float percentage, int align)
2899 {
2900         uiLayoutItemSplit *split;
2901
2902         split = MEM_callocN(sizeof(uiLayoutItemSplit), "uiLayoutItemSplit");
2903         split->litem.item.type = ITEM_LAYOUT_SPLIT;
2904         split->litem.root = layout->root;
2905         split->litem.align = align;
2906         split->litem.active = true;
2907         split->litem.enabled = true;
2908         split->litem.context = layout->context;
2909         split->litem.space = layout->root->style->columnspace;
2910         split->litem.redalert = layout->redalert;
2911         split->litem.w = layout->w;
2912         split->percentage = percentage;
2913         BLI_addtail(&layout->items, split);
2914
2915         UI_block_layout_set_current(layout->root->block, &split->litem);
2916
2917         return &split->litem;
2918 }
2919
2920 void uiLayoutSetActive(uiLayout *layout, bool active)
2921 {
2922         layout->active = active;
2923 }
2924
2925 void uiLayoutSetEnabled(uiLayout *layout, bool enabled)
2926 {
2927         layout->enabled = enabled;
2928 }
2929
2930 void uiLayoutSetRedAlert(uiLayout *layout, bool redalert)
2931 {
2932         layout->redalert = redalert;
2933 }
2934
2935 void uiLayoutSetKeepAspect(uiLayout *layout, bool keepaspect)
2936 {
2937         layout->keepaspect = keepaspect;
2938 }
2939
2940 void uiLayoutSetAlignment(uiLayout *layout, char alignment)
2941 {
2942         layout->alignment = alignment;
2943 }
2944
2945 void uiLayoutSetScaleX(uiLayout *layout, float scale)
2946 {
2947         layout->scale[0] = scale;
2948 }
2949
2950 void uiLayoutSetScaleY(uiLayout *layout, float scale)
2951 {
2952         layout->scale[1] = scale;
2953 }
2954
2955 bool uiLayoutGetActive(uiLayout *layout)
2956 {
2957         return layout->active;
2958 }
2959
2960 bool uiLayoutGetEnabled(uiLayout *layout)
2961 {
2962         return layout->enabled;
2963 }
2964
2965 bool uiLayoutGetRedAlert(uiLayout *layout)
2966 {
2967         return layout->redalert;
2968 }
2969
2970 bool uiLayoutGetKeepAspect(uiLayout *layout)
2971 {
2972         return layout->keepaspect;
2973 }
2974
2975 int uiLayoutGetAlignment(uiLayout *layout)
2976 {
2977         return layout->alignment;
2978 }
2979
2980 int uiLayoutGetWidth(uiLayout *layout)
2981 {
2982         return layout->w;
2983 }
2984
2985 float uiLayoutGetScaleX(uiLayout *layout)
2986 {
2987         return layout->scale[0];
2988 }
2989
2990 float uiLayoutGetScaleY(uiLayout *layout)
2991 {
2992         return layout->scale[1];
2993 }
2994
2995 /********************** Layout *******************/
2996
2997 static void ui_item_scale(uiLayout *litem, const float scale[2])
2998 {
2999         uiItem *item;
3000         int x, y, w, h;
3001
3002         for (item = litem->items.last; item; item = item->prev) {
3003                 ui_item_size(item, &w, &h);
3004                 ui_item_offset(item, &x, &y);
3005
3006                 if (scale[0] != 0.0f) {
3007                         x *= scale[0];
3008                         w *= scale[0];
3009                 }
3010
3011                 if (scale[1] != 0.0f) {
3012                         y *= scale[1];
3013                         h *= scale[1];
3014                 }
3015
3016                 ui_item_position(item, x, y, w, h);
3017         }
3018 }
3019
3020 static void ui_item_estimate(uiItem *item)
3021 {
3022         uiItem *subitem;
3023
3024         if (item->type != ITEM_BUTTON) {
3025                 uiLayout *litem = (uiLayout *)item;
3026
3027                 for (subitem = litem->items.first; subitem; subitem = subitem->next)
3028                         ui_item_estimate(subitem);
3029
3030                 if (BLI_listbase_is_empty(&litem->items))
3031                         return;
3032
3033                 if (litem->scale[0] != 0.0f || litem->scale[1] != 0.0f)
3034                         ui_item_scale(litem, litem->scale);
3035
3036                 switch (litem->item.type) {
3037                         case ITEM_LAYOUT_COLUMN:
3038                                 ui_litem_estimate_column(litem);
3039                                 break;
3040                         case ITEM_LAYOUT_COLUMN_FLOW:
3041                                 ui_litem_estimate_column_flow(litem);
3042                                 break;
3043                         case ITEM_LAYOUT_ROW:
3044                                 ui_litem_estimate_row(litem);
3045                                 break;
3046                         case ITEM_LAYOUT_BOX:
3047                                 ui_litem_estimate_box(litem);
3048                                 break;
3049                         case ITEM_LAYOUT_ROOT:
3050                                 ui_litem_estimate_root(litem);
3051                                 break;
3052                         case ITEM_LAYOUT_ABSOLUTE:
3053                                 ui_litem_estimate_absolute(litem);
3054                                 break;
3055                         case ITEM_LAYOUT_SPLIT:
3056                                 ui_litem_estimate_split(litem);
3057                                 break;
3058                         case ITEM_LAYOUT_OVERLAP:
3059                                 ui_litem_estimate_overlap(litem);
3060                                 break;
3061                         default:
3062                                 break;
3063                 }
3064         }
3065 }
3066
3067 static void ui_item_align(uiLayout *litem, short nr)
3068 {
3069         uiItem *item;
3070         uiButtonItem *bitem;
3071         uiLayoutItemBx *box;
3072
3073         for (item = litem->items.last; item; item = item->prev) {
3074                 if (item->type == ITEM_BUTTON) {
3075                         bitem = (uiButtonItem *)item;
3076 #ifndef USE_UIBUT_SPATIAL_ALIGN
3077                         if (ui_but_can_align(bitem->but))
3078 #endif
3079                         {
3080                                 if (!bitem->but->alignnr) {
3081                                         bitem->but->alignnr = nr;
3082                                 }
3083                         }
3084                 }
3085                 else if (item->type == ITEM_LAYOUT_ABSOLUTE) {
3086                         /* pass */
3087                 }
3088                 else if (item->type == ITEM_LAYOUT_OVERLAP) {
3089                         /* pass */
3090                 }
3091                 else if (item->type == ITEM_LAYOUT_BOX) {
3092                         box = (uiLayoutItemBx *)item;
3093                         box->roundbox->alignnr = nr;
3094                         BLI_remlink(&litem->root->block->buttons, box->roundbox);
3095                         BLI_addhead(&litem->root->block->buttons, box->roundbox);
3096                 }
3097                 else if (((uiLayout *)item)->align) {
3098                         ui_item_align((uiLayout *)item, nr);
3099                 }
3100         }
3101 }
3102
3103 static void ui_item_flag(uiLayout *litem, int flag)
3104 {
3105         uiItem *item;
3106         uiButtonItem *bitem;
3107
3108         for (item = litem->items.last; item; item = item->prev) {
3109                 if (item->type == ITEM_BUTTON) {
3110                         bitem = (uiButtonItem *)item;
3111                         bitem->but->flag |= flag;
3112                 }
3113                 else
3114                         ui_item_flag((uiLayout *)item, flag);
3115         }
3116 }
3117
3118 static void ui_item_layout(uiItem *item)
3119 {
3120         uiItem *subitem;
3121
3122         if (item->type != ITEM_BUTTON) {
3123                 uiLayout *litem = (uiLayout *)item;
3124
3125                 if (BLI_listbase_is_empty(&litem->items))
3126                         return;
3127
3128                 if (litem->align)
3129                         ui_item_align(litem, ++litem->root->block->alignnr);
3130                 if (!litem->active)
3131                         ui_item_flag(litem, UI_BUT_INACTIVE);
3132                 if (!litem->enabled)
3133                         ui_item_flag(litem, UI_BUT_DISABLED);
3134
3135                 switch (litem->item.type) {
3136                         case ITEM_LAYOUT_COLUMN:
3137                                 ui_litem_layout_column(litem);
3138                                 break;
3139                         case ITEM_LAYOUT_COLUMN_FLOW:
3140                                 ui_litem_layout_column_flow(litem);
3141                                 break;
3142                         case ITEM_LAYOUT_ROW: