Cleanup: wrapped function indentation
[blender.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 "BLF_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, buf, sizeof(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(const bContext *C, PointerRNA *ptr, PropertyRNA **prop)
687 {
688         ARegion *ar = CTX_wm_region(C);
689         uiBlock *block;
690         uiBut *but, *prevbut;
691
692         memset(ptr, 0, sizeof(*ptr));
693         *prop = NULL;
694
695         if (!ar)
696                 return;
697
698         for (block = ar->uiblocks.first; block; block = block->next) {
699                 for (but = block->buttons.first; but; but = but->next) {
700                         prevbut = but->prev;
701
702                         /* find the button before the active one */
703                         if ((but->flag & UI_BUT_LAST_ACTIVE) && prevbut && prevbut->rnapoin.data) {
704                                 if (RNA_property_type(prevbut->rnaprop) == PROP_STRING) {
705                                         *ptr = prevbut->rnapoin;
706                                         *prop = prevbut->rnaprop;
707                                         return;
708                                 }
709                         }
710                 }
711         }
712 }
713
714 /********************* Button Items *************************/
715
716 /**
717  * Update a buttons tip with an enum's description if possible.
718  */
719 static void ui_but_tip_from_enum_item(uiBut *but, EnumPropertyItem *item)
720 {
721         if (but->tip == NULL || but->tip[0] == '\0') {
722                 if (item->description && item->description[0]) {
723                         but->tip = item->description;
724                 }
725         }
726 }
727
728 /* disabled item */
729 static void ui_item_disabled(uiLayout *layout, const char *name)
730 {
731         uiBlock *block = layout->root->block;
732         uiBut *but;
733         int w;
734
735         UI_block_layout_set_current(block, layout);
736
737         if (!name)
738                 name = "";
739
740         w = ui_text_icon_width(layout, name, 0, 0);
741
742         but = uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
743         but->flag |= UI_BUT_DISABLED;
744         but->lock = true;
745         but->lockstr = "";
746 }
747
748 /* operator items */
749 PointerRNA uiItemFullO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, IDProperty *properties, int context, int flag)
750 {
751         uiBlock *block = layout->root->block;
752         uiBut *but;
753         int w;
754
755         if (!name) {
756                 if (ot && ot->srna && (flag & UI_ITEM_R_ICON_ONLY) == 0)
757                         name = RNA_struct_ui_name(ot->srna);
758                 else
759                         name = "";
760         }
761
762         if (layout->root->type == UI_LAYOUT_MENU && !icon)
763                 icon = ICON_BLANK1;
764
765         /* create button */
766         UI_block_layout_set_current(block, layout);
767
768         w = ui_text_icon_width(layout, name, icon, 0);
769
770         if (flag & UI_ITEM_R_NO_BG)
771                 UI_block_emboss_set(block, UI_EMBOSS_NONE);
772
773         /* create the button */
774         if (icon) {
775                 if (name[0]) {
776                         but = uiDefIconTextButO_ptr(block, UI_BTYPE_BUT, ot, context, icon, name, 0, 0, w, UI_UNIT_Y, NULL);
777                 }
778                 else {
779                         but = uiDefIconButO_ptr(block, UI_BTYPE_BUT, ot, context, icon, 0, 0, w, UI_UNIT_Y, NULL);
780                 }
781         }
782         else {
783                 but = uiDefButO_ptr(block, UI_BTYPE_BUT, ot, context, name, 0, 0, w, UI_UNIT_Y, NULL);
784         }
785
786         assert(but->optype != NULL);
787
788         /* text alignment for toolbar buttons */
789         if ((layout->root->type == UI_LAYOUT_TOOLBAR) && !icon)
790                 but->drawflag |= UI_BUT_TEXT_LEFT;
791
792         if (flag & UI_ITEM_R_NO_BG)
793                 UI_block_emboss_set(block, UI_EMBOSS);
794
795         if (layout->redalert)
796                 UI_but_flag_enable(but, UI_BUT_REDALERT);
797
798         /* assign properties */
799         if (properties || (flag & UI_ITEM_O_RETURN_PROPS)) {
800                 PointerRNA *opptr = UI_but_operator_ptr_get(but);
801
802                 if (properties) {
803                         opptr->data = properties;
804                 }
805                 else {
806                         IDPropertyTemplate val = {0};
807                         opptr->data = IDP_New(IDP_GROUP, &val, "wmOperatorProperties");
808                 }
809
810                 return *opptr;
811         }
812
813         return PointerRNA_NULL;
814 }
815
816 PointerRNA uiItemFullO(uiLayout *layout, const char *opname, const char *name, int icon, IDProperty *properties, int context, int flag)
817 {
818         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
819
820         UI_OPERATOR_ERROR_RET(ot, opname, return PointerRNA_NULL);
821
822         return uiItemFullO_ptr(layout, ot, name, icon, properties, context, flag);
823 }
824
825 static const char *ui_menu_enumpropname(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int retval)
826 {
827         EnumPropertyItem *item;
828         bool free;
829         const char *name;
830
831         RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
832         if (RNA_enum_name(item, retval, &name)) {
833                 name = CTX_IFACE_(RNA_property_translation_context(prop), name);
834         }
835         else {
836                 name = "";
837         }
838
839         if (free) {
840                 MEM_freeN(item);
841         }
842
843         return name;
844 }
845
846 void uiItemEnumO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, const char *propname, int value)
847 {
848         PointerRNA ptr;
849         PropertyRNA *prop;
850
851         WM_operator_properties_create_ptr(&ptr, ot);
852
853         if ((prop = RNA_struct_find_property(&ptr, propname))) {
854                 /* pass */
855         }
856         else {
857                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
858                 return;
859         }
860
861         RNA_property_enum_set(&ptr, prop, value);
862
863         if (!name)
864                 name = ui_menu_enumpropname(layout, &ptr, prop, value);
865
866         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
867 }
868 void uiItemEnumO(uiLayout *layout, const char *opname, const char *name, int icon, const char *propname, int value)
869 {
870         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
871
872         if (ot) {
873                 uiItemEnumO_ptr(layout, ot, name, icon, propname, value);
874         }
875         else {
876                 ui_item_disabled(layout, opname);
877                 RNA_warning("unknown operator '%s'", opname);
878         }
879
880 }
881
882 void uiItemsFullEnumO(
883         uiLayout *layout, const char *opname, const char *propname, IDProperty *properties,
884         int context, int flag)
885 {
886         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
887
888         PointerRNA ptr;
889         PropertyRNA *prop;
890         uiBlock *block = layout->root->block;
891         const bool radial = (layout->item.type == ITEM_LAYOUT_RADIAL) ||
892                              ((layout->item.type == ITEM_LAYOUT_ROOT) && (layout->root->type == UI_LAYOUT_PIEMENU));
893
894         if (!ot || !ot->srna) {
895                 ui_item_disabled(layout, opname);
896                 RNA_warning("%s '%s'", ot ? "unknown operator" : "operator missing srna", opname);
897                 return;
898         }
899
900         WM_operator_properties_create_ptr(&ptr, ot);
901         /* so the context is passed to itemf functions (some need it) */
902         WM_operator_properties_sanitize(&ptr, false);
903         prop = RNA_struct_find_property(&ptr, propname);
904
905         /* don't let bad properties slip through */
906         BLI_assert((prop == NULL) || (RNA_property_type(prop) == PROP_ENUM));
907
908         if (prop && RNA_property_type(prop) == PROP_ENUM) {
909                 EnumPropertyItem *item, *item_array = NULL;
910                 bool free;
911                 uiLayout *split = NULL;
912                 uiLayout *target;
913
914                 if (radial) {
915                         target = uiLayoutRadial(layout);
916                 }
917                 else {
918                         split = uiLayoutSplit(layout, 0.0f, false);
919                         target = uiLayoutColumn(split, layout->align);
920                 }
921
922                 if (radial) {
923                         RNA_property_enum_items_gettexted_all(block->evil_C, &ptr, prop, &item_array, NULL, &free);
924                 }
925                 else {
926                         RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item_array, NULL, &free);
927                 }
928
929                 for (item = item_array; item->identifier; item++) {
930                         if (item->identifier[0]) {
931                                 PointerRNA tptr;
932
933                                 WM_operator_properties_create_ptr(&tptr, ot);
934                                 if (properties) {
935                                         if (tptr.data) {
936                                                 IDP_FreeProperty(tptr.data);
937                                                 MEM_freeN(tptr.data);
938                                         }
939                                         tptr.data = IDP_CopyProperty(properties);
940                                 }
941                                 RNA_property_enum_set(&tptr, prop, item->value);
942
943                                 uiItemFullO_ptr(target, ot, item->name, item->icon, tptr.data, context, flag);
944
945                                 ui_but_tip_from_enum_item(block->buttons.last, item);
946                         }
947                         else {
948                                 if (item->name) {
949                                         uiBut *but;
950
951                                         if (item != item_array && !radial) {
952                                                 target = uiLayoutColumn(split, layout->align);
953
954                                                 /* inconsistent, but menus with labels do not look good flipped */
955                                                 block->flag |= UI_BLOCK_NO_FLIP;
956                                         }
957
958                                         if (item->icon || radial) {
959                                                 uiItemL(target, item->name, item->icon);
960
961                                                 but = block->buttons.last;
962                                         }
963                                         else {
964                                                 /* Do not use uiItemL here, as our root layout is a menu one, it will add a fake blank icon! */
965                                                 but = uiDefBut(block, UI_BTYPE_LABEL, 0, item->name, 0, 0, UI_UNIT_X * 5, UI_UNIT_Y, NULL,
966                                                                0.0, 0.0, 0, 0, "");
967                                         }
968                                         ui_but_tip_from_enum_item(but, item);
969                                 }
970                                 else {
971                                         if (radial) {
972                                                 uiItemS(target);
973                                         }
974                                         else {
975                                                 /* XXX bug here, colums draw bottom item badly */
976                                                 uiItemS(target);
977                                         }
978                                 }
979                         }
980                 }
981                 if (free) {
982                         MEM_freeN(item_array);
983                 }
984
985                 /* intentionally don't touch UI_BLOCK_IS_FLIP here,
986                  * we don't know the context this is called in */
987         }
988         else if (prop && RNA_property_type(prop) != PROP_ENUM) {
989                 RNA_warning("%s.%s, not an enum type", RNA_struct_identifier(ptr.type), propname);
990                 return;
991         }
992         else {
993                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
994                 return;
995         }
996 }
997
998 void uiItemsEnumO(uiLayout *layout, const char *opname, const char *propname)
999 {
1000         uiItemsFullEnumO(layout, opname, propname, NULL, layout->root->opcontext, 0);
1001 }
1002
1003 /* for use in cases where we have */
1004 void uiItemEnumO_value(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value)
1005 {
1006         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1007         PointerRNA ptr;
1008         PropertyRNA *prop;
1009
1010         UI_OPERATOR_ERROR_RET(ot, opname, return);
1011
1012         WM_operator_properties_create_ptr(&ptr, ot);
1013
1014         /* enum lookup */
1015         if ((prop = RNA_struct_find_property(&ptr, propname))) {
1016                 /* pass */
1017         }
1018         else {
1019                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
1020                 return;
1021         }
1022
1023         RNA_property_enum_set(&ptr, prop, value);
1024
1025         /* same as uiItemEnumO */
1026         if (!name)
1027                 name = ui_menu_enumpropname(layout, &ptr, prop, value);
1028
1029         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1030 }
1031
1032 void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, const char *value_str)
1033 {
1034         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1035         PointerRNA ptr;
1036         PropertyRNA *prop;
1037
1038         EnumPropertyItem *item;
1039         int value;
1040         bool free;
1041
1042         UI_OPERATOR_ERROR_RET(ot, opname, return);
1043
1044         WM_operator_properties_create_ptr(&ptr, ot);
1045
1046         /* enum lookup */
1047         if ((prop = RNA_struct_find_property(&ptr, propname))) {
1048                 /* no need for translations here */
1049                 RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free);
1050                 if (item == NULL || RNA_enum_value_from_id(item, value_str, &value) == 0) {
1051                         if (free) {
1052                                 MEM_freeN(item);
1053                         }
1054                         RNA_warning("%s.%s, enum %s not found", RNA_struct_identifier(ptr.type), propname, value_str);
1055                         return;
1056                 }
1057
1058                 if (free) {
1059                         MEM_freeN(item);
1060                 }
1061         }
1062         else {
1063                 RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
1064                 return;
1065         }
1066
1067         RNA_property_enum_set(&ptr, prop, value);
1068
1069         /* same as uiItemEnumO */
1070         if (!name)
1071                 name = ui_menu_enumpropname(layout, &ptr, prop, value);
1072
1073         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1074 }
1075
1076 void uiItemBooleanO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value)
1077 {
1078         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1079         PointerRNA ptr;
1080
1081         UI_OPERATOR_ERROR_RET(ot, opname, return);
1082
1083         WM_operator_properties_create_ptr(&ptr, ot);
1084         RNA_boolean_set(&ptr, propname, value);
1085
1086         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1087 }
1088
1089 void uiItemIntO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value)
1090 {
1091         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1092         PointerRNA ptr;
1093
1094         UI_OPERATOR_ERROR_RET(ot, opname, return);
1095
1096         WM_operator_properties_create_ptr(&ptr, ot);
1097         RNA_int_set(&ptr, propname, value);
1098
1099         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1100 }
1101
1102 void uiItemFloatO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, float value)
1103 {
1104         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1105         PointerRNA ptr;
1106
1107         UI_OPERATOR_ERROR_RET(ot, opname, return);
1108
1109         WM_operator_properties_create_ptr(&ptr, ot);
1110         RNA_float_set(&ptr, propname, value);
1111
1112         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1113 }
1114
1115 void uiItemStringO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, const char *value)
1116 {
1117         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1118         PointerRNA ptr;
1119
1120         UI_OPERATOR_ERROR_RET(ot, opname, return);
1121
1122         WM_operator_properties_create_ptr(&ptr, ot);
1123         RNA_string_set(&ptr, propname, value);
1124
1125         uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
1126 }
1127
1128 void uiItemO(uiLayout *layout, const char *name, int icon, const char *opname)
1129 {
1130         uiItemFullO(layout, opname, name, icon, NULL, layout->root->opcontext, 0);
1131 }
1132
1133 /* RNA property items */
1134
1135 static void ui_item_rna_size(
1136         uiLayout *layout, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop,
1137         int index, bool icon_only, int *r_w, int *r_h)
1138 {
1139         PropertyType type;
1140         PropertySubType subtype;
1141         int len, w = 0, h;
1142
1143         /* arbitrary extended width by type */
1144         type = RNA_property_type(prop);
1145         subtype = RNA_property_subtype(prop);
1146         len = RNA_property_array_length(ptr, prop);
1147
1148         if (!name[0] && !icon_only) {
1149                 if (ELEM(type, PROP_STRING, PROP_POINTER)) {
1150                         name = "non-empty text";
1151                 }
1152                 else if (type == PROP_BOOLEAN) {
1153                         icon = ICON_DOT;
1154                 }
1155                 else if (type == PROP_ENUM) {
1156                         /* Find the longest enum item name, instead of using a dummy text! */
1157                         EnumPropertyItem *item, *item_array;
1158                         bool free;
1159
1160                         RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item_array, NULL, &free);
1161                         for (item = item_array; item->identifier; item++) {
1162                                 if (item->identifier[0]) {
1163                                         w = max_ii(w, ui_text_icon_width(layout, item->name, item->icon, 0));
1164                                 }
1165                         }
1166                         if (free) {
1167                                 MEM_freeN(item_array);
1168                         }
1169                 }
1170         }
1171
1172         if (!w)
1173                 w = ui_text_icon_width(layout, name, icon, 0);
1174         h = UI_UNIT_Y;
1175
1176         /* increase height for arrays */
1177         if (index == RNA_NO_INDEX && len > 0) {
1178                 if (!name[0] && icon == ICON_NONE)
1179                         h = 0;
1180
1181                 if (ELEM(subtype, PROP_LAYER, PROP_LAYER_MEMBER))
1182                         h += 2 * UI_UNIT_Y;
1183                 else if (subtype == PROP_MATRIX)
1184                         h += ceilf(sqrtf(len)) * UI_UNIT_Y;
1185                 else
1186                         h += len * UI_UNIT_Y;
1187         }
1188         else if (ui_layout_vary_direction(layout) == UI_ITEM_VARY_X) {
1189                 if (type == PROP_BOOLEAN && name[0])
1190                         w += UI_UNIT_X / 5;
1191                 else if (type == PROP_ENUM)
1192                         w += UI_UNIT_X / 4;
1193                 else if (type == PROP_FLOAT || type == PROP_INT)
1194                         w += UI_UNIT_X * 3;
1195         }
1196
1197         *r_w = w;
1198         *r_h = h;
1199 }
1200
1201 void uiItemFullR(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int index, int value, int flag, const char *name, int icon)
1202 {
1203         uiBlock *block = layout->root->block;
1204         uiBut *but = NULL;
1205         PropertyType type;
1206         char namestr[UI_MAX_NAME_STR];
1207         int len, w, h;
1208         bool slider, toggle, expand, icon_only, no_bg;
1209         bool is_array;
1210
1211         UI_block_layout_set_current(block, layout);
1212
1213         /* retrieve info */
1214         type = RNA_property_type(prop);
1215         is_array = RNA_property_array_check(prop);
1216         len = (is_array) ? RNA_property_array_length(ptr, prop) : 0;
1217
1218         /* set name and icon */
1219         if (!name) {
1220                 if ((flag & UI_ITEM_R_ICON_ONLY) == 0) {
1221                         name = RNA_property_ui_name(prop);
1222                 }
1223                 else {
1224                         name = "";
1225                 }
1226         }
1227
1228         if (icon == ICON_NONE)
1229                 icon = RNA_property_ui_icon(prop);
1230         
1231         if (flag & UI_ITEM_R_ICON_ONLY) {
1232                 /* pass */
1233         }
1234         else if (ELEM(type, PROP_INT, PROP_FLOAT, PROP_STRING, PROP_POINTER)) {
1235                 name = ui_item_name_add_colon(name, namestr);
1236         }
1237         else if (type == PROP_BOOLEAN && is_array && index == RNA_NO_INDEX) {
1238                 name = ui_item_name_add_colon(name, namestr);
1239         }
1240         else if (type == PROP_ENUM && index != RNA_ENUM_VALUE) {
1241                 name = ui_item_name_add_colon(name, namestr);
1242         }
1243
1244         /* menus and pie-menus don't show checkbox without this */
1245         if (ELEM(layout->root->type, UI_LAYOUT_MENU, UI_LAYOUT_PIEMENU)) {
1246                 if (type == PROP_BOOLEAN && ((is_array == false) || (index != RNA_NO_INDEX))) {
1247                         if (is_array) icon = (RNA_property_boolean_get_index(ptr, prop, index)) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1248                         else icon = (RNA_property_boolean_get(ptr, prop)) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1249                 }
1250                 else if (type == PROP_ENUM && index == RNA_ENUM_VALUE) {
1251                         int enum_value = RNA_property_enum_get(ptr, prop);
1252                         if (RNA_property_flag(prop) & PROP_ENUM_FLAG) {
1253                                 icon = (enum_value & value) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1254                         }
1255                         else {
1256                                 icon = (enum_value == value) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT;
1257                         }
1258                 }
1259         }
1260
1261         slider = (flag & UI_ITEM_R_SLIDER) != 0;
1262         toggle = (flag & UI_ITEM_R_TOGGLE) != 0;
1263         expand = (flag & UI_ITEM_R_EXPAND) != 0;
1264         icon_only = (flag & UI_ITEM_R_ICON_ONLY) != 0;
1265         no_bg = (flag & UI_ITEM_R_NO_BG);
1266
1267         /* get size */
1268         ui_item_rna_size(layout, name, icon, ptr, prop, index, icon_only, &w, &h);
1269
1270         if (no_bg)
1271                 UI_block_emboss_set(block, UI_EMBOSS_NONE);
1272         
1273         /* array property */
1274         if (index == RNA_NO_INDEX && is_array)
1275                 ui_item_array(layout, block, name, icon, ptr, prop, len, 0, 0, w, h, expand, slider, toggle, icon_only);
1276         /* enum item */
1277         else if (type == PROP_ENUM && index == RNA_ENUM_VALUE) {
1278                 if (icon && name[0] && !icon_only)
1279                         uiDefIconTextButR_prop(block, UI_BTYPE_ROW, 0, icon, name, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL);
1280                 else if (icon)
1281                         uiDefIconButR_prop(block, UI_BTYPE_ROW, 0, icon, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL);
1282                 else
1283                         uiDefButR_prop(block, UI_BTYPE_ROW, 0, name, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL);
1284         }
1285         /* expanded enum */
1286         else if (type == PROP_ENUM && (expand || RNA_property_flag(prop) & PROP_ENUM_FLAG))
1287                 ui_item_enum_expand(layout, block, ptr, prop, name, h, icon_only);
1288         /* property with separate label */
1289         else if (type == PROP_ENUM || type == PROP_STRING || type == PROP_POINTER) {
1290                 but = ui_item_with_label(layout, block, name, icon, ptr, prop, index, 0, 0, w, h, flag);
1291                 ui_but_add_search(but, ptr, prop, NULL, NULL);
1292                 
1293                 if (layout->redalert)
1294                         UI_but_flag_enable(but, UI_BUT_REDALERT);
1295         }
1296         /* single button */
1297         else {
1298                 but = uiDefAutoButR(block, ptr, prop, index, name, icon, 0, 0, w, h);
1299
1300                 if (slider && but->type == UI_BTYPE_NUM)
1301                         but->type = UI_BTYPE_NUM_SLIDER;
1302
1303                 if (toggle && but->type == UI_BTYPE_CHECKBOX)
1304                         but->type = UI_BTYPE_TOGGLE;
1305                 
1306                 if (layout->redalert)
1307                         UI_but_flag_enable(but, UI_BUT_REDALERT);
1308         }
1309
1310         /* Mark non-embossed textfields inside a listbox. */
1311         if (but && (block->flag & UI_BLOCK_LIST_ITEM) && (but->type == UI_BTYPE_TEXT) && (but->dt & UI_EMBOSS_NONE)) {
1312                 UI_but_flag_enable(but, UI_BUT_LIST_ITEM);
1313         }
1314
1315         if (no_bg)
1316                 UI_block_emboss_set(block, UI_EMBOSS);
1317
1318         /* ensure text isn't added to icon_only buttons */
1319         if (but && icon_only) {
1320                 BLI_assert(but->str[0] == '\0');
1321         }
1322
1323 }
1324
1325 void uiItemR(uiLayout *layout, PointerRNA *ptr, const char *propname, int flag, const char *name, int icon)
1326 {
1327         PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
1328
1329         if (!prop) {
1330                 ui_item_disabled(layout, propname);
1331                 RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1332                 return;
1333         }
1334
1335         uiItemFullR(layout, ptr, prop, RNA_NO_INDEX, 0, flag, name, icon);
1336 }
1337
1338 void uiItemEnumR(uiLayout *layout, const char *name, int icon, struct PointerRNA *ptr, const char *propname, int value)
1339 {
1340         PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
1341
1342         if (!prop || RNA_property_type(prop) != PROP_ENUM) {
1343                 ui_item_disabled(layout, propname);
1344                 RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1345                 return;
1346         }
1347
1348         uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, value, 0, name, icon);
1349 }
1350
1351 void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *value, const char *name, int icon)
1352 {
1353         PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
1354         EnumPropertyItem *item;
1355         int ivalue, a;
1356         bool free;
1357
1358         if (!prop || RNA_property_type(prop) != PROP_ENUM) {
1359                 ui_item_disabled(layout, propname);
1360                 RNA_warning("enum property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1361                 return;
1362         }
1363
1364         RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
1365
1366         if (!RNA_enum_value_from_id(item, value, &ivalue)) {
1367                 if (free) {
1368                         MEM_freeN(item);
1369                 }
1370                 ui_item_disabled(layout, propname);
1371                 RNA_warning("enum property value not found: %s", value);
1372                 return;
1373         }
1374
1375         for (a = 0; item[a].identifier; a++) {
1376                 if (item[a].value == ivalue) {
1377                         const char *item_name = name ? name : CTX_IFACE_(RNA_property_translation_context(prop), item[a].name);
1378
1379                         uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, ivalue, 0, item_name, icon ? icon : item[a].icon);
1380                         break;
1381                 }
1382         }
1383
1384         if (free) {
1385                 MEM_freeN(item);
1386         }
1387 }
1388
1389 void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname)
1390 {
1391         PropertyRNA *prop;
1392         uiBlock *block = layout->root->block;
1393         uiBut *bt;
1394
1395         prop = RNA_struct_find_property(ptr, propname);
1396
1397         if (!prop) {
1398                 ui_item_disabled(layout, propname);
1399                 RNA_warning("enum property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1400                 return;
1401         }
1402
1403         if (RNA_property_type(prop) != PROP_ENUM) {
1404                 RNA_warning("not an enum property: %s.%s", RNA_struct_identifier(ptr->type), propname);
1405                 return;
1406         }
1407         else {
1408                 EnumPropertyItem *item;
1409                 int totitem, i;
1410                 bool free;
1411                 uiLayout *split = uiLayoutSplit(layout, 0.0f, false);
1412                 uiLayout *column = uiLayoutColumn(split, false);
1413
1414                 RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
1415
1416                 for (i = 0; i < totitem; i++) {
1417                         if (item[i].identifier[0]) {
1418                                 uiItemEnumR(column, item[i].name, ICON_NONE, ptr, propname, item[i].value);
1419                                 ui_but_tip_from_enum_item(block->buttons.last, &item[i]);
1420                         }
1421                         else {
1422                                 if (item[i].name) {
1423                                         if (i != 0) {
1424                                                 column = uiLayoutColumn(split, false);
1425                                                 /* inconsistent, but menus with labels do not look good flipped */
1426                                                 block->flag |= UI_BLOCK_NO_FLIP;
1427                                         }
1428
1429                                         uiItemL(column, item[i].name, ICON_NONE);
1430                                         bt = block->buttons.last;
1431                                         bt->drawflag = UI_BUT_TEXT_LEFT;
1432
1433                                         ui_but_tip_from_enum_item(bt, &item[i]);
1434                                 }
1435                                 else
1436                                         uiItemS(column);
1437                         }
1438                 }
1439
1440                 if (free) {
1441                         MEM_freeN(item);
1442                 }
1443         }
1444
1445         /* intentionally don't touch UI_BLOCK_IS_FLIP here,
1446          * we don't know the context this is called in */
1447 }
1448
1449 /* Pointer RNA button with search */
1450
1451 typedef struct CollItemSearch {
1452         struct CollItemSearch *next, *prev;
1453         char *name;
1454         int index;
1455         int iconid;
1456 } CollItemSearch;
1457
1458 static int sort_search_items_list(const void *a, const void *b)
1459 {
1460         const CollItemSearch *cis1 = a;
1461         const CollItemSearch *cis2 = b;
1462         
1463         if (BLI_strcasecmp(cis1->name, cis2->name) > 0)
1464                 return 1;
1465         else
1466                 return 0;
1467 }
1468
1469 static void rna_search_cb(const struct bContext *C, void *arg_but, const char *str, uiSearchItems *items)
1470 {
1471         uiBut *but = arg_but;
1472         char *name;
1473         int i = 0, iconid = 0, flag = RNA_property_flag(but->rnaprop);
1474         ListBase *items_list = MEM_callocN(sizeof(ListBase), "items_list");
1475         CollItemSearch *cis;
1476         const bool skip_filter = !but->changed;
1477
1478         /* build a temporary list of relevant items first */
1479         RNA_PROP_BEGIN (&but->rnasearchpoin, itemptr, but->rnasearchprop)
1480         {
1481                 if (flag & PROP_ID_SELF_CHECK)
1482                         if (itemptr.data == but->rnapoin.id.data)
1483                                 continue;
1484
1485                 /* use filter */
1486                 if (RNA_property_type(but->rnaprop) == PROP_POINTER) {
1487                         if (RNA_property_pointer_poll(&but->rnapoin, but->rnaprop, &itemptr) == 0)
1488                                 continue;
1489                 }
1490
1491                 if (itemptr.type && RNA_struct_is_ID(itemptr.type)) {
1492                         ID *id = itemptr.data;
1493                         char name_ui[MAX_ID_NAME];
1494
1495 #if 0       /* this name is used for a string comparison and can't be modified, TODO */
1496                         /* if ever enabled, make name_ui be MAX_ID_NAME+1 */
1497                         name_uiprefix_id(name_ui, id);
1498 #else
1499                         BLI_strncpy(name_ui, id->name + 2, sizeof(name_ui));
1500 #endif
1501                         name = BLI_strdup(name_ui);
1502                         iconid = ui_id_icon_get(C, id, false);
1503                 }
1504                 else {
1505                         name = RNA_struct_name_get_alloc(&itemptr, NULL, 0, NULL); /* could use the string length here */
1506                         iconid = 0;
1507                 }
1508
1509                 if (name) {
1510                         if (skip_filter || BLI_strcasestr(name, str)) {
1511                                 cis = MEM_callocN(sizeof(CollItemSearch), "CollectionItemSearch");
1512                                 cis->name = MEM_dupallocN(name);
1513                                 cis->index = i;
1514                                 cis->iconid = iconid;
1515                                 BLI_addtail(items_list, cis);
1516                         }
1517                         MEM_freeN(name);
1518                 }
1519
1520                 i++;
1521         }
1522         RNA_PROP_END;
1523         
1524         BLI_listbase_sort(items_list, sort_search_items_list);
1525         
1526         /* add search items from temporary list */
1527         for (cis = items_list->first; cis; cis = cis->next) {
1528                 if (false == UI_search_item_add(items, cis->name, SET_INT_IN_POINTER(cis->index), cis->iconid)) {
1529                         break;
1530                 }
1531         }
1532
1533         for (cis = items_list->first; cis; cis = cis->next) {
1534                 MEM_freeN(cis->name);
1535         }
1536         BLI_freelistN(items_list);
1537         MEM_freeN(items_list);
1538 }
1539
1540 static void search_id_collection(StructRNA *ptype, PointerRNA *ptr, PropertyRNA **prop)
1541 {
1542         StructRNA *srna;
1543
1544         /* look for collection property in Main */
1545         RNA_main_pointer_create(G.main, ptr);
1546
1547         *prop = NULL;
1548
1549         RNA_STRUCT_BEGIN (ptr, iprop)
1550         {
1551                 /* if it's a collection and has same pointer type, we've got it */
1552                 if (RNA_property_type(iprop) == PROP_COLLECTION) {
1553                         srna = RNA_property_pointer_type(ptr, iprop);
1554
1555                         if (ptype == srna) {
1556                                 *prop = iprop;
1557                                 break;
1558                         }
1559                 }
1560         }
1561         RNA_STRUCT_END;
1562 }
1563
1564 void ui_but_add_search(uiBut *but, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop)
1565 {
1566         StructRNA *ptype;
1567         PointerRNA sptr;
1568
1569         /* for ID's we do automatic lookup */
1570         if (!searchprop) {
1571                 if (RNA_property_type(prop) == PROP_POINTER) {
1572                         ptype = RNA_property_pointer_type(ptr, prop);
1573                         search_id_collection(ptype, &sptr, &searchprop);
1574                         searchptr = &sptr;
1575                 }
1576         }
1577
1578         /* turn button into search button */
1579         if (searchprop) {
1580                 but->type = UI_BTYPE_SEARCH_MENU;
1581                 but->hardmax = MAX2(but->hardmax, 256.0f);
1582                 but->rnasearchpoin = *searchptr;
1583                 but->rnasearchprop = searchprop;
1584                 but->drawflag |= UI_BUT_ICON_LEFT | UI_BUT_TEXT_LEFT;
1585                 if (RNA_property_is_unlink(prop)) {
1586                         but->flag |= UI_BUT_SEARCH_UNLINK;
1587                 }
1588
1589                 if (RNA_property_type(prop) == PROP_ENUM) {
1590                         /* XXX, this will have a menu string,
1591                          * but in this case we just want the text */
1592                         but->str[0] = 0;
1593                 }
1594
1595                 UI_but_func_search_set(but, rna_search_cb, but, NULL, NULL);
1596         }
1597 }
1598
1599 void uiItemPointerR(uiLayout *layout, struct PointerRNA *ptr, const char *propname, struct PointerRNA *searchptr, const char *searchpropname, const char *name, int icon)
1600 {
1601         PropertyRNA *prop, *searchprop;
1602         PropertyType type;
1603         uiBut *but;
1604         uiBlock *block;
1605         StructRNA *icontype;
1606         int w, h;
1607         char namestr[UI_MAX_NAME_STR];
1608         
1609         /* validate arguments */
1610         prop = RNA_struct_find_property(ptr, propname);
1611
1612         if (!prop) {
1613                 RNA_warning("property not found: %s.%s",
1614                             RNA_struct_identifier(ptr->type), propname);
1615                 return;
1616         }
1617         
1618         type = RNA_property_type(prop);
1619         if (!ELEM(type, PROP_POINTER, PROP_STRING, PROP_ENUM)) {
1620                 RNA_warning("Property %s must be a pointer, string or enum", propname);
1621                 return;
1622         }
1623
1624         searchprop = RNA_struct_find_property(searchptr, searchpropname);
1625
1626
1627         if (!searchprop) {
1628                 RNA_warning("search collection property not found: %s.%s",
1629                             RNA_struct_identifier(searchptr->type), searchpropname);
1630                 return;
1631         }
1632         else if (RNA_property_type(searchprop) != PROP_COLLECTION) {
1633                 RNA_warning("search collection property is not a collection type: %s.%s",
1634                             RNA_struct_identifier(searchptr->type), searchpropname);
1635                 return;
1636         }
1637
1638         /* get icon & name */
1639         if (icon == ICON_NONE) {
1640                 if (type == PROP_POINTER)
1641                         icontype = RNA_property_pointer_type(ptr, prop);
1642                 else
1643                         icontype = RNA_property_pointer_type(searchptr, searchprop);
1644
1645                 icon = RNA_struct_ui_icon(icontype);
1646         }
1647         if (!name)
1648                 name = RNA_property_ui_name(prop);
1649
1650         name = ui_item_name_add_colon(name, namestr);
1651
1652         /* create button */
1653         block = uiLayoutGetBlock(layout);
1654
1655         ui_item_rna_size(layout, name, icon, ptr, prop, 0, 0, &w, &h);
1656         w += UI_UNIT_X; /* X icon needs more space */
1657         but = ui_item_with_label(layout, block, name, icon, ptr, prop, 0, 0, 0, w, h, 0);
1658
1659         ui_but_add_search(but, ptr, prop, searchptr, searchprop);
1660 }
1661
1662 /* menu item */
1663 static void ui_item_menutype_func(bContext *C, uiLayout *layout, void *arg_mt)
1664 {
1665         MenuType *mt = (MenuType *)arg_mt;
1666         Menu menu = {NULL};
1667
1668         menu.type = mt;
1669         menu.layout = layout;
1670
1671         if (G.debug & G_DEBUG_WM) {
1672                 printf("%s: opening menu \"%s\"\n", __func__, mt->idname);
1673         }
1674
1675         if (layout->context)
1676                 CTX_store_set(C, layout->context);
1677
1678         mt->draw(C, &menu);
1679
1680         if (layout->context)
1681                 CTX_store_set(C, NULL);
1682
1683         /* menus are created flipped (from event handling pov) */
1684         layout->root->block->flag ^= UI_BLOCK_IS_FLIP;
1685 }
1686
1687 static uiBut *ui_item_menu(
1688         uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg, void *argN,
1689         const char *tip, bool force_menu)
1690 {
1691         uiBlock *block = layout->root->block;
1692         uiBut *but;
1693         int w, h;
1694
1695         UI_block_layout_set_current(block, layout);
1696
1697         if (layout->root->type == UI_LAYOUT_HEADER)
1698                 UI_block_emboss_set(block, UI_EMBOSS);
1699
1700         if (!name)
1701                 name = "";
1702         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1703                 icon = ICON_BLANK1;
1704
1705         w = ui_text_icon_width(layout, name, icon, 1);
1706         h = UI_UNIT_Y;
1707
1708         if (layout->root->type == UI_LAYOUT_HEADER) { /* ugly .. */
1709                 if (force_menu) {
1710                         w += UI_UNIT_Y;
1711                 }
1712                 else {
1713                         if (name[0]) {
1714                                 w -= UI_UNIT_Y / 2;
1715                         }
1716                 }
1717         }
1718
1719         if (name[0] && icon)
1720                 but = uiDefIconTextMenuBut(block, func, arg, icon, name, 0, 0, w, h, tip);
1721         else if (icon)
1722                 but = uiDefIconMenuBut(block, func, arg, icon, 0, 0, w, h, tip);
1723         else
1724                 but = uiDefMenuBut(block, func, arg, name, 0, 0, w, h, tip);
1725
1726         if (argN) { /* ugly .. */
1727                 but->poin = (char *)but;
1728                 but->func_argN = argN;
1729         }
1730
1731         if (layout->root->type == UI_LAYOUT_HEADER) {
1732                 UI_block_emboss_set(block, UI_EMBOSS);
1733         }
1734         if (ELEM(layout->root->type, UI_LAYOUT_PANEL, UI_LAYOUT_TOOLBAR) ||
1735             (force_menu && layout->root->type != UI_LAYOUT_MENU))  /* We never want a dropdown in menu! */
1736         {
1737                 UI_but_type_set_menu_from_pulldown(but);
1738         }
1739
1740         return but;
1741 }
1742
1743 void uiItemM(uiLayout *layout, bContext *UNUSED(C), const char *menuname, const char *name, int icon)
1744 {
1745         MenuType *mt;
1746
1747         mt = WM_menutype_find(menuname, false);
1748
1749         if (mt == NULL) {
1750                 RNA_warning("not found %s", menuname);
1751                 return;
1752         }
1753
1754         if (!name) {
1755                 name = CTX_IFACE_(mt->translation_context, mt->label);
1756         }
1757
1758         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1759                 icon = ICON_BLANK1;
1760
1761         ui_item_menu(layout, name, icon, ui_item_menutype_func, mt, NULL, TIP_(mt->description), false);
1762 }
1763
1764 /* label item */
1765 static uiBut *uiItemL_(uiLayout *layout, const char *name, int icon)
1766 {
1767         uiBlock *block = layout->root->block;
1768         uiBut *but;
1769         int w;
1770
1771         UI_block_layout_set_current(block, layout);
1772
1773         if (!name)
1774                 name = "";
1775         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1776                 icon = ICON_BLANK1;
1777
1778         w = ui_text_icon_width(layout, name, icon, 0);
1779
1780         if (icon && name[0])
1781                 but = uiDefIconTextBut(block, UI_BTYPE_LABEL, 0, icon, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
1782         else if (icon)
1783                 but = uiDefIconBut(block, UI_BTYPE_LABEL, 0, icon, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
1784         else
1785                 but = uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
1786
1787         /* to compensate for string size padding in ui_text_icon_width,
1788          * make text aligned right if the layout is aligned right.
1789          */
1790         if (uiLayoutGetAlignment(layout) == UI_LAYOUT_ALIGN_RIGHT) {
1791                 but->drawflag &= ~UI_BUT_TEXT_LEFT;     /* default, needs to be unset */
1792                 but->drawflag |= UI_BUT_TEXT_RIGHT;
1793         }
1794
1795         /* Mark as a label inside a listbox. */
1796         if (block->flag & UI_BLOCK_LIST_ITEM) {
1797                 but->flag |= UI_BUT_LIST_ITEM;
1798         }
1799
1800         return but;
1801 }
1802
1803 void uiItemL(uiLayout *layout, const char *name, int icon)
1804 {
1805         uiItemL_(layout, name, icon);
1806 }
1807
1808 void uiItemLDrag(uiLayout *layout, PointerRNA *ptr, const char *name, int icon)
1809 {
1810         uiBut *but = uiItemL_(layout, name, icon);
1811
1812         if (ptr && ptr->type)
1813                 if (RNA_struct_is_ID(ptr->type))
1814                         UI_but_drag_set_id(but, ptr->id.data);
1815 }
1816
1817
1818 /* value item */
1819 void uiItemV(uiLayout *layout, const char *name, int icon, int argval)
1820 {
1821         /* label */
1822         uiBlock *block = layout->root->block;
1823         int *retvalue = (block->handle) ? &block->handle->retvalue : NULL;
1824         int w;
1825
1826         UI_block_layout_set_current(block, layout);
1827
1828         if (!name)
1829                 name = "";
1830         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1831                 icon = ICON_BLANK1;
1832
1833         w = ui_text_icon_width(layout, name, icon, 0);
1834
1835         if (icon && name[0])
1836                 uiDefIconTextButI(block, UI_BTYPE_BUT, argval, icon, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
1837         else if (icon)
1838                 uiDefIconButI(block, UI_BTYPE_BUT, argval, icon, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
1839         else
1840                 uiDefButI(block, UI_BTYPE_BUT, argval, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
1841 }
1842
1843 /* separator item */
1844 void uiItemS(uiLayout *layout)
1845 {
1846         uiBlock *block = layout->root->block;
1847         bool is_menu = ui_block_is_menu(block);
1848         int space = (is_menu) ? 0.45f * UI_UNIT_X : 0.3f * UI_UNIT_X;
1849
1850         UI_block_layout_set_current(block, layout);
1851         uiDefBut(block, (is_menu) ? UI_BTYPE_SEPR_LINE : UI_BTYPE_SEPR, 0, "", 0, 0, space, space, NULL, 0.0, 0.0, 0, 0, "");
1852 }
1853
1854 /* level items */
1855 void uiItemMenuF(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg)
1856 {
1857         if (!func)
1858                 return;
1859
1860         ui_item_menu(layout, name, icon, func, arg, NULL, "", false);
1861 }
1862
1863 typedef struct MenuItemLevel {
1864         int opcontext;
1865         /* don't use pointers to the strings because python can dynamically
1866          * allocate strings and free before the menu draws, see [#27304] */
1867         char opname[OP_MAX_TYPENAME];
1868         char propname[MAX_IDPROP_NAME];
1869         PointerRNA rnapoin;
1870 } MenuItemLevel;
1871
1872 static void menu_item_enum_opname_menu(bContext *UNUSED(C), uiLayout *layout, void *arg)
1873 {
1874         MenuItemLevel *lvl = (MenuItemLevel *)(((uiBut *)arg)->func_argN);
1875
1876         uiLayoutSetOperatorContext(layout, lvl->opcontext);
1877         uiItemsEnumO(layout, lvl->opname, lvl->propname);
1878
1879         layout->root->block->flag |= UI_BLOCK_IS_FLIP;
1880
1881         /* override default, needed since this was assumed pre 2.70 */
1882         UI_block_direction_set(layout->root->block, UI_DIR_DOWN);
1883 }
1884
1885 void uiItemMenuEnumO(uiLayout *layout, bContext *C, const char *opname, const char *propname, const char *name, int icon)
1886 {
1887         wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
1888         MenuItemLevel *lvl;
1889         uiBut *but;
1890
1891         UI_OPERATOR_ERROR_RET(ot, opname, return);
1892
1893         if (!ot->srna) {
1894                 ui_item_disabled(layout, opname);
1895                 RNA_warning("operator missing srna '%s'", opname);
1896                 return;
1897         }
1898
1899         if (name == NULL) {
1900                 name = RNA_struct_ui_name(ot->srna);
1901         }
1902
1903         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1904                 icon = ICON_BLANK1;
1905
1906         lvl = MEM_callocN(sizeof(MenuItemLevel), "MenuItemLevel");
1907         BLI_strncpy(lvl->opname, opname, sizeof(lvl->opname));
1908         BLI_strncpy(lvl->propname, propname, sizeof(lvl->propname));
1909         lvl->opcontext = layout->root->opcontext;
1910
1911         but = ui_item_menu(layout, name, icon, menu_item_enum_opname_menu, NULL, lvl,
1912                            RNA_struct_ui_description(ot->srna), true);
1913
1914         /* add hotkey here, lower UI code can't detect it */
1915         if ((layout->root->block->flag & UI_BLOCK_LOOP) &&
1916             (ot->prop && ot->invoke))
1917         {
1918                 char keybuf[128];
1919                 if (WM_key_event_operator_string(C, ot->idname, layout->root->opcontext, NULL, false,
1920                                                  keybuf, sizeof(keybuf)))
1921                 {
1922                         ui_but_add_shortcut(but, keybuf, false);
1923                 }
1924         }
1925 }
1926
1927 static void menu_item_enum_rna_menu(bContext *UNUSED(C), uiLayout *layout, void *arg)
1928 {
1929         MenuItemLevel *lvl = (MenuItemLevel *)(((uiBut *)arg)->func_argN);
1930
1931         uiLayoutSetOperatorContext(layout, lvl->opcontext);
1932         uiItemsEnumR(layout, &lvl->rnapoin, lvl->propname);
1933         layout->root->block->flag |= UI_BLOCK_IS_FLIP;
1934 }
1935
1936 void uiItemMenuEnumR_prop(uiLayout *layout, struct PointerRNA *ptr, PropertyRNA *prop, const char *name, int icon)
1937 {
1938         MenuItemLevel *lvl;
1939
1940         if (!name)
1941                 name = RNA_property_ui_name(prop);
1942         if (layout->root->type == UI_LAYOUT_MENU && !icon)
1943                 icon = ICON_BLANK1;
1944
1945         lvl = MEM_callocN(sizeof(MenuItemLevel), "MenuItemLevel");
1946         lvl->rnapoin = *ptr;
1947         BLI_strncpy(lvl->propname, RNA_property_identifier(prop), sizeof(lvl->propname));
1948         lvl->opcontext = layout->root->opcontext;
1949
1950         ui_item_menu(layout, name, icon, menu_item_enum_rna_menu, NULL, lvl, RNA_property_description(prop), false);
1951 }
1952
1953 void uiItemMenuEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *name, int icon)
1954 {
1955         PropertyRNA *prop;
1956
1957         prop = RNA_struct_find_property(ptr, propname);
1958         if (!prop) {
1959                 ui_item_disabled(layout, propname);
1960                 RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
1961                 return;
1962         }
1963
1964         uiItemMenuEnumR_prop(layout, ptr, prop, name, icon);
1965 }
1966
1967 /**************************** Layout Items ***************************/
1968
1969 /* single-row layout */
1970 static void ui_litem_estimate_row(uiLayout *litem)
1971 {
1972         uiItem *item;
1973         int itemw, itemh;
1974
1975         litem->w = 0;
1976         litem->h = 0;
1977
1978         for (item = litem->items.first; item; item = item->next) {
1979                 ui_item_size(item, &itemw, &itemh);
1980
1981                 litem->w += itemw;
1982                 litem->h = MAX2(itemh, litem->h);
1983
1984                 if (item->next)
1985                         litem->w += litem->space;
1986         }
1987 }
1988
1989 static int ui_litem_min_width(int itemw)
1990 {
1991         return MIN2(2 * UI_UNIT_X, itemw);
1992 }
1993
1994 static void ui_litem_layout_row(uiLayout *litem)
1995 {
1996         uiItem *item;
1997         int x, y, w, tot, totw, neww, newtotw, itemw, minw, itemh, offset;
1998         int fixedw, freew, fixedx, freex, flag = 0, lastw = 0;
1999
2000         /* x = litem->x; */ /* UNUSED */
2001         y = litem->y;
2002         w = litem->w;
2003         totw = 0;
2004         tot = 0;
2005
2006         for (item = litem->items.first; item; item = item->next) {
2007                 ui_item_size(item, &itemw, &itemh);
2008                 totw += itemw;
2009                 tot++;
2010         }
2011
2012         if (totw == 0)
2013                 return;
2014         
2015         if (w != 0)
2016                 w -= (tot - 1) * litem->space;
2017         fixedw = 0;
2018
2019         /* keep clamping items to fixed minimum size until all are done */
2020         do {
2021                 freew = 0;
2022                 x = 0;
2023                 flag = 0;
2024                 newtotw = totw;
2025
2026                 for (item = litem->items.first; item; item = item->next) {
2027                         if (item->flag)
2028                                 continue;
2029
2030                         ui_item_size(item, &itemw, &itemh);
2031                         minw = ui_litem_min_width(itemw);
2032
2033                         if (w - lastw > 0)
2034                                 neww = ui_item_fit(itemw, x, totw, w - lastw, !item->next, litem->alignment, NULL);
2035                         else
2036                                 neww = 0;  /* no space left, all will need clamping to minimum size */
2037
2038                         x += neww;
2039
2040                         if ((neww < minw || itemw == minw) && w != 0) {
2041                                 /* fixed size */
2042                                 item->flag = 1;
2043                                 fixedw += minw;
2044                                 flag = 1;
2045                                 newtotw -= itemw;
2046                         }
2047                         else {
2048                                 /* keep free size */
2049                                 item->flag = 0;
2050                                 freew += itemw;
2051                         }
2052                 }
2053
2054                 totw = newtotw;
2055                 lastw = fixedw;
2056         } while (flag);
2057
2058         freex = 0;
2059         fixedx = 0;
2060         x = litem->x;
2061
2062         for (item = litem->items.first; item; item = item->next) {
2063                 ui_item_size(item, &itemw, &itemh);
2064                 minw = ui_litem_min_width(itemw);
2065
2066                 if (item->flag) {
2067                         /* fixed minimum size items */
2068                         itemw = ui_item_fit(minw, fixedx, fixedw, min_ii(w, fixedw), !item->next, litem->alignment, NULL);
2069                         fixedx += itemw;
2070                 }
2071                 else {
2072                         /* free size item */
2073                         itemw = ui_item_fit(itemw, freex, freew, w - fixedw, !item->next, litem->alignment, NULL);
2074                         freex += itemw;
2075                 }
2076
2077                 /* align right/center */
2078                 offset = 0;
2079                 if (litem->alignment == UI_LAYOUT_ALIGN_RIGHT) {
2080                         if (freew + fixedw > 0 && freew + fixedw < w)
2081                                 offset = w - (fixedw + freew);
2082                 }
2083                 else if (litem->alignment == UI_LAYOUT_ALIGN_CENTER) {
2084                         if (freew + fixedw > 0 && freew + fixedw < w)
2085                                 offset = (w - (fixedw + freew)) / 2;
2086                 }
2087
2088                 /* position item */
2089                 ui_item_position(item, x + offset, y - itemh, itemw, itemh);
2090
2091                 x += itemw;
2092                 if (item->next)
2093                         x += litem->space;
2094         }
2095
2096         litem->w = x - litem->x;
2097         litem->h = litem->y - y;
2098         litem->x = x;
2099         litem->y = y;
2100 }
2101
2102 /* single-column layout */
2103 static void ui_litem_estimate_column(uiLayout *litem)
2104 {
2105         uiItem *item;
2106         int itemw, itemh;
2107
2108         litem->w = 0;
2109         litem->h = 0;
2110
2111         for (item = litem->items.first; item; item = item->next) {
2112                 ui_item_size(item, &itemw, &itemh);
2113
2114                 litem->w = MAX2(litem->w, itemw);
2115                 litem->h += itemh;
2116
2117                 if (item->next)
2118                         litem->h += litem->space;
2119         }
2120 }
2121
2122 static void ui_litem_layout_column(uiLayout *litem)
2123 {
2124         uiItem *item;
2125         int itemh, x, y;
2126
2127         x = litem->x;
2128         y = litem->y;
2129
2130         for (item = litem->items.first; item; item = item->next) {
2131                 ui_item_size(item, NULL, &itemh);
2132
2133                 y -= itemh;
2134                 ui_item_position(item, x, y, litem->w, itemh);
2135
2136                 if (item->next)
2137                         y -= litem->space;
2138         }
2139
2140         litem->h = litem->y - y;
2141         litem->x = x;
2142         litem->y = y;
2143 }
2144
2145 /* calculates the angle of a specified button in a radial menu,
2146  * stores a float vector in unit circle */
2147 static RadialDirection ui_get_radialbut_vec(float vec[2], short itemnum)
2148 {
2149         RadialDirection dir;
2150         BLI_assert(itemnum < 8);
2151
2152         dir = ui_radial_dir_order[itemnum];
2153         ui_but_pie_dir(dir, vec);
2154
2155         return dir;
2156 }
2157
2158 static bool ui_item_is_radial_displayable(uiItem *item)
2159 {
2160
2161         if ((item->type == ITEM_BUTTON) && (((uiButtonItem *)item)->but->type == UI_BTYPE_LABEL))
2162                 return false;
2163
2164         return true;
2165 }
2166
2167 static bool ui_item_is_radial_drawable(uiButtonItem *bitem)
2168 {
2169
2170         if (ELEM(bitem->but->type, UI_BTYPE_SEPR, UI_BTYPE_SEPR_LINE))
2171                 return false;
2172
2173         return true;
2174 }
2175
2176 static void ui_litem_layout_radial(uiLayout *litem)
2177 {
2178         uiItem *item;
2179         int itemh, itemw, x, y;
2180         int itemnum = 0;
2181         int totitems = 0;
2182
2183         int minx, miny, maxx, maxy;
2184         /* For the radial layout we will use Matt Ebb's design
2185          * for radiation, see http://mattebb.com/weblog/radiation/
2186          * also the old code at http://developer.blender.org/T5103
2187          */
2188
2189         int pie_radius = U.pie_menu_radius * UI_DPI_FAC;
2190
2191         x = litem->x;
2192         y = litem->y;
2193
2194         minx = x, miny = y, maxx = x, maxy = y;
2195
2196         /* first count total items */
2197         for (item = litem->items.first; item; item = item->next)
2198                 totitems++;
2199
2200         if (totitems < 5)
2201                 litem->root->block->pie_data.flags |= UI_PIE_DEGREES_RANGE_LARGE;
2202
2203         for (item = litem->items.first; item; item = item->next) {
2204                 /* not all button types are drawn in a radial menu, do filtering here */
2205                 if (ui_item_is_radial_displayable(item)) {
2206                         RadialDirection dir;
2207                         float vec[2];
2208                         float factor[2];
2209
2210                         dir = ui_get_radialbut_vec(vec, itemnum);
2211                         factor[0] = (vec[0] > 0.01f) ? 0.0f : ((vec[0] < -0.01f) ? -1.0f : -0.5f);
2212                         factor[1] = (vec[1] > 0.99f) ? 0.0f : ((vec[1] < -0.99f) ? -1.0f : -0.5f);
2213
2214                         itemnum++;
2215
2216                         if (item->type == ITEM_BUTTON) {
2217                                 uiButtonItem *bitem = (uiButtonItem *) item;
2218
2219                                 bitem->but->pie_dir = dir;
2220                                 /* scale the buttons */
2221                                 bitem->but->rect.ymax *= 1.5f;
2222                                 /* add a little bit more here to include number */
2223                                 bitem->but->rect.xmax += 1.5f * UI_UNIT_X;
2224                                 /* enable drawing as pie item if supported by widget */
2225                                 if (ui_item_is_radial_drawable(bitem))
2226                                         bitem->but->dt = UI_EMBOSS_RADIAL;
2227                         }
2228
2229                         ui_item_size(item, &itemw, &itemh);
2230
2231                         ui_item_position(item, x + vec[0] * pie_radius + factor[0] * itemw, y + vec[1] * pie_radius + factor[1] * itemh, itemw, itemh);
2232
2233                         minx = min_ii(minx, x + vec[0] * pie_radius - itemw / 2);
2234                         maxx = max_ii(maxx, x + vec[0] * pie_radius + itemw / 2);
2235                         miny = min_ii(miny, y + vec[1] * pie_radius - itemh / 2);
2236                         maxy = max_ii(maxy, y + vec[1] * pie_radius + itemh / 2);
2237                 }
2238         }
2239
2240         litem->x = minx;
2241         litem->y = miny;
2242         litem->w = maxx - minx;
2243         litem->h = maxy - miny;
2244 }
2245
2246 /* root layout */
2247 static void ui_litem_estimate_root(uiLayout *UNUSED(litem))
2248 {
2249         /* nothing to do */
2250 }
2251
2252 static void ui_litem_layout_root_radial(uiLayout *litem)
2253 {
2254         /* first item is pie menu title, align on center of menu */
2255         uiItem *item = litem->items.first;
2256
2257         if (item->type == ITEM_BUTTON) {
2258                 int itemh, itemw, x, y;
2259                 x = litem->x;
2260                 y = litem->y;
2261
2262                 ui_item_size(item, &itemw, &itemh);
2263
2264                 ui_item_position(item, x - itemw / 2, y + U.pixelsize * (U.pie_menu_threshold + 9.0f), itemw, itemh);
2265         }
2266 }
2267
2268 static void ui_litem_layout_root(uiLayout *litem)
2269 {
2270         if (litem->root->type == UI_LAYOUT_HEADER)
2271                 ui_litem_layout_row(litem);
2272         else if (litem->root->type == UI_LAYOUT_PIEMENU)
2273                 ui_litem_layout_root_radial(litem);
2274         else
2275                 ui_litem_layout_column(litem);
2276 }
2277
2278 /* box layout */
2279 static void ui_litem_estimate_box(uiLayout *litem)
2280 {
2281         uiStyle *style = litem->root->style;
2282
2283         ui_litem_estimate_column(litem);
2284         litem->w += 2 * style->boxspace;
2285         litem->h += style->boxspace;
2286 }
2287
2288 static void ui_litem_layout_box(uiLayout *litem)
2289 {
2290         uiLayoutItemBx *box = (uiLayoutItemBx *)litem;
2291         uiStyle *style = litem->root->style;
2292         uiBut *but;
2293         int w, h;
2294
2295         w = litem->w;
2296         h = litem->h;
2297
2298         litem->x += style->boxspace;
2299
2300         if (w != 0) litem->w -= 2 * style->boxspace;
2301         if (h != 0) litem->h -= 2 * style->boxspace;
2302
2303         ui_litem_layout_column(litem);
2304
2305         litem->x -= style->boxspace;
2306         litem->y -= style->boxspace;
2307
2308         if (w != 0) litem->w += 2 * style->boxspace;
2309         if (h != 0) litem->h += style->boxspace;
2310
2311         /* roundbox around the sublayout */
2312         but = box->roundbox;
2313         but->rect.xmin = litem->x;
2314         but->rect.ymin = litem->y;
2315         but->rect.xmax = litem->x + litem->w;
2316         but->rect.ymax = litem->y + litem->h;
2317 }
2318
2319 /* multi-column layout, automatically flowing to the next */
2320 static void ui_litem_estimate_column_flow(uiLayout *litem)
2321 {
2322         uiStyle *style = litem->root->style;
2323         uiLayoutItemFlow *flow = (uiLayoutItemFlow *)litem;
2324         uiItem *item;
2325         int col, x, y, emh, emy, miny, itemw, itemh, maxw = 0;
2326         int toth, totitem;
2327
2328         /* compute max needed width and total height */
2329         toth = 0;
2330         totitem = 0;
2331         for (item = litem->items.first; item; item = item->next) {
2332                 ui_item_size(item, &itemw, &itemh);
2333                 maxw = MAX2(maxw, itemw);
2334                 toth += itemh;
2335                 totitem++;
2336         }
2337
2338         if (flow->number <= 0) {
2339                 /* auto compute number of columns, not very good */
2340                 if (maxw == 0) {
2341                         flow->totcol = 1;
2342                         return;
2343                 }
2344
2345                 flow->totcol = max_ii(litem->root->emw / maxw, 1);
2346                 flow->totcol = min_ii(flow->totcol, totitem);
2347         }
2348         else
2349                 flow->totcol = flow->number;
2350
2351         /* compute sizes */
2352         x = 0;
2353         y = 0;
2354         emy = 0;
2355         miny = 0;
2356
2357         maxw = 0;
2358         emh = toth / flow->totcol;
2359
2360         /* create column per column */
2361         col = 0;
2362         for (item = litem->items.first; item; item = item->next) {
2363                 ui_item_size(item, &itemw, &itemh);
2364
2365                 y -= itemh + style->buttonspacey;
2366                 miny = min_ii(miny, y);
2367                 emy -= itemh;
2368                 maxw = max_ii(itemw, maxw);
2369
2370                 /* decide to go to next one */
2371                 if (col < flow->totcol - 1 && emy <= -emh) {
2372                         x += maxw + litem->space;
2373                         maxw = 0;
2374                         y = 0;
2375                         emy = 0; /* need to reset height again for next column */
2376                         col++;
2377                 }
2378         }
2379
2380         litem->w = x;
2381         litem->h = litem->y - miny;
2382 }
2383
2384 static void ui_litem_layout_column_flow(uiLayout *litem)
2385 {
2386         uiStyle *style = litem->root->style;
2387         uiLayoutItemFlow *flow = (uiLayoutItemFlow *)litem;
2388         uiItem *item;
2389         int col, x, y, w, emh, emy, miny, itemw, itemh;
2390         int toth, totitem, offset;
2391
2392         /* compute max needed width and total height */
2393         toth = 0;
2394         totitem = 0;
2395         for (item = litem->items.first; item; item = item->next) {
2396                 ui_item_size(item, &itemw, &itemh);
2397                 toth += itemh;
2398                 totitem++;
2399         }
2400
2401         /* compute sizes */
2402         x = litem->x;
2403         y = litem->y;
2404         emy = 0;
2405         miny = 0;
2406
2407         w = litem->w - (flow->totcol - 1) * style->columnspace;
2408         emh = toth / flow->totcol;
2409
2410         /* create column per column */
2411         col = 0;
2412         for (item = litem->items.first; item; item = item->next) {
2413                 ui_item_size(item, NULL, &itemh);
2414                 itemw = ui_item_fit(1, x - litem->x, flow->totcol, w, col == flow->totcol - 1, litem->alignment, &offset);
2415         
2416                 y -= itemh;
2417                 emy -= itemh;
2418                 ui_item_position(item, x + offset, y, itemw, itemh);
2419                 y -= style->buttonspacey;
2420                 miny = min_ii(miny, y);
2421
2422                 /* decide to go to next one */
2423                 if (col < flow->totcol - 1 && emy <= -emh) {
2424                         x += itemw + style->columnspace;
2425                         y = litem->y;
2426                         emy = 0; /* need to reset height again for next column */
2427                         col++;
2428                 }
2429         }
2430
2431         litem->h = litem->y - miny;
2432         litem->x = x;
2433         litem->y = miny;
2434 }
2435
2436 /* free layout */
2437 static void ui_litem_estimate_absolute(uiLayout *litem)
2438 {
2439         uiItem *item;
2440         int itemx, itemy, itemw, itemh, minx, miny;
2441
2442         minx = 1e6;
2443         miny = 1e6;
2444         litem->w = 0;
2445         litem->h = 0;
2446
2447         for (item = litem->items.first; item; item = item->next) {
2448                 ui_item_offset(item, &itemx, &itemy);
2449                 ui_item_size(item, &itemw, &itemh);
2450
2451                 minx = min_ii(minx, itemx);
2452                 miny = min_ii(miny, itemy);
2453
2454                 litem->w = MAX2(litem->w, itemx + itemw);
2455                 litem->h = MAX2(litem->h, itemy + itemh);
2456         }
2457
2458         litem->w -= minx;
2459         litem->h -= miny;
2460 }
2461
2462 static void ui_litem_layout_absolute(uiLayout *litem)
2463 {
2464         uiItem *item;
2465         float scalex = 1.0f, scaley = 1.0f;
2466         int x, y, newx, newy, itemx, itemy, itemh, itemw, minx, miny, totw, toth;
2467
2468         minx = 1e6;
2469         miny = 1e6;
2470         totw = 0;
2471         toth = 0;
2472
2473         for (item = litem->items.first; item; item = item->next) {
2474                 ui_item_offset(item, &itemx, &itemy);
2475                 ui_item_size(item, &itemw, &itemh);
2476
2477                 minx = min_ii(minx, itemx);
2478                 miny = min_ii(miny, itemy);
2479
2480                 totw = max_ii(totw, itemx + itemw);
2481                 toth = max_ii(toth, itemy + itemh);
2482         }
2483
2484         totw -= minx;
2485         toth -= miny;
2486
2487         if (litem->w && totw > 0)
2488                 scalex = (float)litem->w / (float)totw;
2489         if (litem->h && toth > 0)
2490                 scaley = (float)litem->h / (float)toth;
2491         
2492         x = litem->x;
2493         y = litem->y - scaley * toth;
2494
2495         for (item = litem->items.first; item; item = item->next) {
2496                 ui_item_offset(item, &itemx, &itemy);
2497                 ui_item_size(item, &itemw, &itemh);
2498
2499                 if (scalex != 1.0f) {
2500                         newx = (itemx - minx) * scalex;
2501                         itemw = (itemx - minx + itemw) * scalex - newx;
2502                         itemx = minx + newx;
2503                 }
2504
2505                 if (scaley != 1.0f) {
2506                         newy = (itemy - miny) * scaley;
2507                         itemh = (itemy - miny + itemh) * scaley - newy;
2508                         itemy = miny + newy;
2509                 }
2510
2511                 ui_item_position(item, x + itemx - minx, y + itemy - miny, itemw, itemh);
2512         }
2513
2514         litem->w = scalex * totw;
2515         litem->h = litem->y - y;
2516         litem->x = x + litem->w;
2517         litem->y = y;
2518 }
2519
2520 /* split layout */
2521 static void ui_litem_estimate_split(uiLayout *litem)
2522 {
2523         ui_litem_estimate_row(litem);
2524 }
2525
2526 static void ui_litem_layout_split(uiLayout *litem)
2527 {
2528         uiLayoutItemSplit *split = (uiLayoutItemSplit *)litem;
2529         uiItem *item;
2530         float percentage;
2531         const int tot = BLI_listbase_count(&litem->items);
2532         int itemh, x, y, w, colw = 0;
2533
2534         if (tot == 0)
2535                 return;
2536
2537         x = litem->x;
2538         y = litem->y;
2539
2540         percentage = (split->percentage == 0.0f) ? 1.0f / (float)tot : split->percentage;
2541         
2542         w = (litem->w - (tot - 1) * litem->space);
2543         colw = w * percentage;
2544         colw = MAX2(colw, 0);
2545
2546         for (item = litem->items.first; item; item = item->next) {
2547                 ui_item_size(item, NULL, &itemh);
2548
2549                 ui_item_position(item, x, y - itemh, colw, itemh);
2550                 x += colw;
2551
2552                 if (item->next) {
2553                         colw = (w - (int)(w * percentage)) / (tot - 1);
2554                         colw = MAX2(colw, 0);
2555
2556                         x += litem->space;
2557                 }
2558         }
2559
2560         litem->w = x - litem->x;
2561         litem->h = litem->y - y;
2562         litem->x = x;
2563         litem->y = y;
2564 }
2565
2566 /* overlap layout */
2567 static void ui_litem_estimate_overlap(uiLayout *litem)
2568 {
2569         uiItem *item;
2570         int itemw, itemh;
2571
2572         litem->w = 0;
2573         litem->h = 0;
2574
2575         for (item = litem->items.first; item; item = item->next) {
2576                 ui_item_size(item, &itemw, &itemh);
2577
2578                 litem->w = MAX2(itemw, litem->w);
2579                 litem->h = MAX2(itemh, litem->h);
2580         }
2581 }
2582
2583 static void ui_litem_layout_overlap(uiLayout *litem)
2584 {
2585         uiItem *item;
2586         int itemw, itemh, x, y;
2587
2588         x = litem->x;
2589         y = litem->y;
2590
2591         for (item = litem->items.first; item; item = item->next) {
2592                 ui_item_size(item, &itemw, &itemh);
2593                 ui_item_position(item, x, y - itemh, litem->w, itemh);
2594
2595                 litem->h = MAX2(litem->h, itemh);
2596         }
2597
2598         litem->x = x;
2599         litem->y = y - litem->h;
2600 }
2601
2602 /* layout create functions */
2603 uiLayout *uiLayoutRow(uiLayout *layout, int align)
2604 {
2605         uiLayout *litem;
2606
2607         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutRow");
2608         litem->item.type = ITEM_LAYOUT_ROW;
2609         litem->root = layout->root;
2610         litem->align = align;
2611         litem->active = true;
2612         litem->enabled = true;
2613         litem->context = layout->context;
2614         litem->space = (align) ? 0 : layout->root->style->buttonspacex;
2615         litem->redalert = layout->redalert;
2616         litem->w = layout->w;
2617         BLI_addtail(&layout->items, litem);
2618
2619         UI_block_layout_set_current(layout->root->block, litem);
2620
2621         return litem;
2622 }
2623
2624 uiLayout *uiLayoutColumn(uiLayout *layout, int align)
2625 {
2626         uiLayout *litem;
2627
2628         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutColumn");
2629         litem->item.type = ITEM_LAYOUT_COLUMN;
2630         litem->root = layout->root;
2631         litem->align = align;
2632         litem->active = true;
2633         litem->enabled = true;
2634         litem->context = layout->context;
2635         litem->space = (litem->align) ? 0 : layout->root->style->buttonspacey;
2636         litem->redalert = layout->redalert;
2637         litem->w = layout->w;
2638         BLI_addtail(&layout->items, litem);
2639
2640         UI_block_layout_set_current(layout->root->block, litem);
2641
2642         return litem;
2643 }
2644
2645 uiLayout *uiLayoutColumnFlow(uiLayout *layout, int number, int align)
2646 {
2647         uiLayoutItemFlow *flow;
2648
2649         flow = MEM_callocN(sizeof(uiLayoutItemFlow), "uiLayoutItemFlow");
2650         flow->litem.item.type = ITEM_LAYOUT_COLUMN_FLOW;
2651         flow->litem.root = layout->root;
2652         flow->litem.align = align;
2653         flow->litem.active = true;
2654         flow->litem.enabled = true;
2655         flow->litem.context = layout->context;
2656         flow->litem.space = (flow->litem.align) ? 0 : layout->root->style->columnspace;
2657         flow->litem.redalert = layout->redalert;
2658         flow->litem.w = layout->w;
2659         flow->number = number;
2660         BLI_addtail(&layout->items, flow);
2661
2662         UI_block_layout_set_current(layout->root->block, &flow->litem);
2663
2664         return &flow->litem;
2665 }
2666
2667 static uiLayoutItemBx *ui_layout_box(uiLayout *layout, int type)
2668 {
2669         uiLayoutItemBx *box;
2670
2671         box = MEM_callocN(sizeof(uiLayoutItemBx), "uiLayoutItemBx");
2672         box->litem.item.type = ITEM_LAYOUT_BOX;
2673         box->litem.root = layout->root;
2674         box->litem.active = 1;
2675         box->litem.enabled = 1;
2676         box->litem.context = layout->context;
2677         box->litem.space = layout->root->style->columnspace;
2678         box->litem.redalert = layout->redalert;
2679         box->litem.w = layout->w;
2680         BLI_addtail(&layout->items, box);
2681
2682         UI_block_layout_set_current(layout->root->block, &box->litem);
2683
2684         box->roundbox = uiDefBut(layout->root->block, type, 0, "", 0, 0, 0, 0, NULL, 0.0, 0.0, 0, 0, "");
2685
2686         return box;
2687 }
2688
2689 uiLayout *uiLayoutRadial(uiLayout *layout)
2690 {
2691         uiLayout *litem;
2692         uiItem *item;
2693
2694         /* radial layouts are only valid for radial menus */
2695         if (layout->root->type != UI_LAYOUT_PIEMENU)
2696                 return ui_item_local_sublayout(layout, layout, 0);
2697
2698         /* only one radial wheel per root layout is allowed, so check and return that, if it exists */
2699         for (item = layout->root->layout->items.first; item; item = item->next) {
2700                 litem = (uiLayout *)item;
2701                 if (litem->item.type == ITEM_LAYOUT_RADIAL) {
2702                         UI_block_layout_set_current(layout->root->block, litem);
2703                         return litem;
2704                 }
2705         }
2706
2707         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutRadial");
2708         litem->item.type = ITEM_LAYOUT_RADIAL;
2709         litem->root = layout->root;
2710         litem->active = true;
2711         litem->enabled = true;
2712         litem->context = layout->context;
2713         litem->redalert = layout->redalert;
2714         litem->w = layout->w;
2715         BLI_addtail(&layout->root->layout->items, litem);
2716
2717         UI_block_layout_set_current(layout->root->block, litem);
2718
2719         return litem;
2720 }
2721
2722
2723 uiLayout *uiLayoutBox(uiLayout *layout)
2724 {
2725         return (uiLayout *)ui_layout_box(layout, UI_BTYPE_ROUNDBOX);
2726 }
2727
2728 /* Check all buttons defined in this layout, and set any button flagged as UI_BUT_LIST_ITEM as active/selected.
2729  * Needed to handle correctly text colors of active (selected) list item.
2730  */
2731 void ui_layout_list_set_labels_active(uiLayout *layout)
2732 {
2733         uiButtonItem *bitem;
2734         for (bitem = layout->items.first; bitem; bitem = bitem->item.next) {
2735                 if (bitem->item.type != ITEM_BUTTON) {
2736                         ui_layout_list_set_labels_active((uiLayout *)(&bitem->item));
2737                 }
2738                 else if (bitem->but->flag & UI_BUT_LIST_ITEM) {
2739                         UI_but_flag_enable(bitem->but, UI_SELECT);
2740                 }
2741         }
2742 }
2743
2744 uiLayout *uiLayoutListBox(
2745         uiLayout *layout, uiList *ui_list, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *actptr,
2746         PropertyRNA *actprop)
2747 {
2748         uiLayoutItemBx *box = ui_layout_box(layout, UI_BTYPE_LISTBOX);
2749         uiBut *but = box->roundbox;
2750
2751         but->custom_data = ui_list;
2752
2753         but->rnasearchpoin = *ptr;
2754         but->rnasearchprop = prop;
2755         but->rnapoin = *actptr;
2756         but->rnaprop = actprop;
2757
2758         /* only for the undo string */
2759         if (but->flag & UI_BUT_UNDO) {
2760                 but->tip = RNA_property_description(actprop);
2761         }
2762
2763         return (uiLayout *)box;
2764 }
2765
2766 uiLayout *uiLayoutAbsolute(uiLayout *layout, int align)
2767 {
2768         uiLayout *litem;
2769
2770         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutAbsolute");
2771         litem->item.type = ITEM_LAYOUT_ABSOLUTE;
2772         litem->root = layout->root;
2773         litem->align = align;
2774         litem->active = 1;
2775         litem->enabled = 1;
2776         litem->context = layout->context;
2777         litem->redalert = layout->redalert;
2778         BLI_addtail(&layout->items, litem);
2779
2780         UI_block_layout_set_current(layout->root->block, litem);
2781
2782         return litem;
2783 }
2784
2785 uiBlock *uiLayoutAbsoluteBlock(uiLayout *layout)
2786 {
2787         uiBlock *block;
2788
2789         block = uiLayoutGetBlock(layout);
2790         uiLayoutAbsolute(layout, false);
2791
2792         return block;
2793 }
2794
2795 uiLayout *uiLayoutOverlap(uiLayout *layout)
2796 {
2797         uiLayout *litem;
2798
2799         litem = MEM_callocN(sizeof(uiLayout), "uiLayoutOverlap");
2800         litem->item.type = ITEM_LAYOUT_OVERLAP;
2801         litem->root = layout->root;
2802         litem->active = true;
2803         litem->enabled = true;
2804         litem->context = layout->context;
2805         litem->redalert = layout->redalert;
2806         BLI_addtail(&layout->items, litem);
2807
2808         UI_block_layout_set_current(layout->root->block, litem);
2809
2810         return litem;
2811 }
2812
2813 uiLayout *uiLayoutSplit(uiLayout *layout, float percentage, int align)
2814 {
2815         uiLayoutItemSplit *split;
2816
2817         split = MEM_callocN(sizeof(uiLayoutItemSplit), "uiLayoutItemSplit");
2818         split->litem.item.type = ITEM_LAYOUT_SPLIT;
2819         split->litem.root = layout->root;
2820         split->litem.align = align;
2821         split->litem.active = true;
2822         split->litem.enabled = true;
2823         split->litem.context = layout->context;
2824         split->litem.space = layout->root->style->columnspace;
2825         split->litem.redalert = layout->redalert;
2826         split->litem.w = layout->w;
2827         split->percentage = percentage;
2828         BLI_addtail(&layout->items, split);
2829
2830         UI_block_layout_set_current(layout->root->block, &split->litem);
2831
2832         return &split->litem;
2833 }
2834
2835 void uiLayoutSetActive(uiLayout *layout, bool active)
2836 {
2837         layout->active = active;
2838 }
2839
2840 void uiLayoutSetEnabled(uiLayout *layout, bool enabled)
2841 {
2842         layout->enabled = enabled;
2843 }
2844
2845 void uiLayoutSetRedAlert(uiLayout *layout, bool redalert)
2846 {
2847         layout->redalert = redalert;
2848 }
2849
2850 void uiLayoutSetKeepAspect(uiLayout *layout, bool keepaspect)
2851 {
2852         layout->keepaspect = keepaspect;
2853 }
2854
2855 void uiLayoutSetAlignment(uiLayout *layout, char alignment)
2856 {
2857         layout->alignment = alignment;
2858 }
2859
2860 void uiLayoutSetScaleX(uiLayout *layout, float scale)
2861 {
2862         layout->scale[0] = scale;
2863 }
2864
2865 void uiLayoutSetScaleY(uiLayout *layout, float scale)
2866 {
2867         layout->scale[1] = scale;
2868 }
2869
2870 bool uiLayoutGetActive(uiLayout *layout)
2871 {
2872         return layout->active;
2873 }
2874
2875 bool uiLayoutGetEnabled(uiLayout *layout)
2876 {
2877         return layout->enabled;
2878 }
2879
2880 bool uiLayoutGetRedAlert(uiLayout *layout)
2881 {
2882         return layout->redalert;
2883 }
2884
2885 bool uiLayoutGetKeepAspect(uiLayout *layout)
2886 {
2887         return layout->keepaspect;
2888 }
2889
2890 int uiLayoutGetAlignment(uiLayout *layout)
2891 {
2892         return layout->alignment;
2893 }
2894
2895 int uiLayoutGetWidth(uiLayout *layout)
2896 {
2897         return layout->w;
2898 }
2899
2900 float uiLayoutGetScaleX(uiLayout *layout)
2901 {
2902         return layout->scale[0];
2903 }
2904
2905 float uiLayoutGetScaleY(uiLayout *layout)
2906 {
2907         return layout->scale[1];
2908 }
2909
2910 /********************** Layout *******************/
2911
2912 static void ui_item_scale(uiLayout *litem, const float scale[2])
2913 {
2914         uiItem *item;
2915         int x, y, w, h;
2916
2917         for (item = litem->items.last; item; item = item->prev) {
2918                 ui_item_size(item, &w, &h);
2919                 ui_item_offset(item, &x, &y);
2920
2921                 if (scale[0] != 0.0f) {
2922                         x *= scale[0];
2923                         w *= scale[0];
2924                 }
2925
2926                 if (scale[1] != 0.0f) {
2927                         y *= scale[1];
2928                         h *= scale[1];
2929                 }
2930
2931                 ui_item_position(item, x, y, w, h);
2932         }
2933 }
2934
2935 static void ui_item_estimate(uiItem *item)
2936 {
2937         uiItem *subitem;
2938
2939         if (item->type != ITEM_BUTTON) {
2940                 uiLayout *litem = (uiLayout *)item;
2941
2942                 for (subitem = litem->items.first; subitem; subitem = subitem->next)
2943                         ui_item_estimate(subitem);
2944
2945                 if (BLI_listbase_is_empty(&litem->items))
2946                         return;
2947
2948                 if (litem->scale[0] != 0.0f || litem->scale[1] != 0.0f)
2949                         ui_item_scale(litem, litem->scale);
2950
2951                 switch (litem->item.type) {
2952                         case ITEM_LAYOUT_COLUMN:
2953                                 ui_litem_estimate_column(litem);
2954                                 break;
2955                         case ITEM_LAYOUT_COLUMN_FLOW:
2956                                 ui_litem_estimate_column_flow(litem);
2957                                 break;
2958                         case ITEM_LAYOUT_ROW:
2959                                 ui_litem_estimate_row(litem);
2960                                 break;
2961                         case ITEM_LAYOUT_BOX:
2962                                 ui_litem_estimate_box(litem);
2963                                 break;
2964                         case ITEM_LAYOUT_ROOT:
2965                                 ui_litem_estimate_root(litem);
2966                                 break;
2967                         case ITEM_LAYOUT_ABSOLUTE:
2968                                 ui_litem_estimate_absolute(litem);
2969                                 break;
2970                         case ITEM_LAYOUT_SPLIT:
2971                                 ui_litem_estimate_split(litem);
2972                                 break;
2973                         case ITEM_LAYOUT_OVERLAP:
2974                                 ui_litem_estimate_overlap(litem);
2975                                 break;
2976                         default:
2977                                 break;
2978                 }
2979         }
2980 }
2981
2982 static void ui_item_align(uiLayout *litem, short nr)
2983 {
2984         uiItem *item;
2985         uiButtonItem *bitem;
2986         uiLayoutItemBx *box;
2987
2988         for (item = litem->items.last; item; item = item->prev) {
2989                 if (item->type == ITEM_BUTTON) {
2990                         bitem = (uiButtonItem *)item;
2991                         if (ui_but_can_align(bitem->but))
2992                                 if (!bitem->but->alignnr)
2993                                         bitem->but->alignnr = nr;
2994                 }
2995                 else if (item->type == ITEM_LAYOUT_ABSOLUTE) {
2996                         /* pass */
2997                 }
2998                 else if (item->type == ITEM_LAYOUT_OVERLAP) {
2999                         /* pass */
3000                 }
3001                 else if (item->type == ITEM_LAYOUT_BOX) {
3002                         box = (uiLayoutItemBx *)item;
3003                         box->roundbox->alignnr = nr;
3004                         BLI_remlink(&litem->root->block->buttons, box->roundbox);
3005                         BLI_addhead(&litem->root->block->buttons, box->roundbox);
3006                 }
3007                 else if (((uiLayout *)item)->align) {
3008                         ui_item_align((uiLayout *)item, nr);
3009                 }
3010         }
3011 }
3012
3013 static void ui_item_flag(uiLayout *litem, int flag)
3014 {
3015         uiItem *item;
3016         uiButtonItem *bitem;
3017
3018         for (item = litem->items.last; item; item = item->prev) {
3019                 if (item->type == ITEM_BUTTON) {
3020                         bitem = (uiButtonItem *)item;
3021                         bitem->but->flag |= flag;
3022                 }
3023                 else
3024                         ui_item_flag((uiLayout *)item, flag);
3025         }
3026 }
3027
3028 static void ui_item_layout(uiItem *item)
3029 {
3030         uiItem *subitem;
3031
3032         if (item->type != ITEM_BUTTON) {
3033                 uiLayout *litem = (uiLayout *)item;
3034
3035                 if (BLI_listbase_is_empty(&litem->items))
3036                         return;
3037
3038                 if (litem->align)
3039                         ui_item_align(litem, ++litem->root->block->alignnr);
3040                 if (!litem->active)
3041                         ui_item_flag(litem, UI_BUT_INACTIVE);
3042                 if (!litem->enabled)
3043                         ui_item_flag(litem, UI_BUT_DISABLED);
3044
3045                 switch (litem->item.type) {
3046                         case ITEM_LAYOUT_COLUMN:
3047                                 ui_litem_layout_column(litem);
3048                                 break;
3049                         case ITEM_LAYOUT_COLUMN_FLOW:
3050                                 ui_litem_layout_column_flow(litem);
3051                                 break;
3052                         case ITEM_LAYOUT_ROW:
3053                                 ui_litem_layout_row(litem);
3054                                 break;
3055                         case ITEM_LAYOUT_BOX:
3056                                 ui_litem_layout_box(litem);
3057                                 break;
3058                         case ITEM_LAYOUT_ROOT:
3059                                 ui_litem_layout_root(litem);
3060                                 break;
3061                         case ITEM_LAYOUT_ABSOLUTE:
3062                                 ui_litem_layout_absolute(litem);
3063                                 break;
3064                         case ITEM_LAYOUT_SPLIT:
3065                                 ui_litem_layout_split(litem);
3066                                 break;
3067                         case ITEM_LAYOUT_OVERLAP:
3068                                 ui_litem_layout_overlap(litem);
3069                                 break;
3070                         case ITEM_LAYOUT_RADIAL:
3071                                 ui_litem_layout_radial(litem);
3072                                 break;
3073                         default:
3074                                 break;
3075                 }
3076
3077                 for (subitem = litem->items.first; subitem; subitem = subitem->next)
3078                         ui_item_layout(subitem);
3079         }
3080 }
3081
3082 static void ui_layout_end(uiBlock *block, uiLayout *layout, int *x, int *y)
3083 {
3084         if (layout->root->handlefunc)
3085                 UI_block_func_handle_set(block, layout->root->handlefunc, layout->root->argv);
3086
3087         ui_item_estimate(&layout->item);
3088         ui_item_layout(&layout->item);
3089
3090         if (x) *x = layout->x;
3091         if (y) *y = layout->y;
3092 }
3093
3094 static void ui_layout_free(uiLayout *layout)
3095 {
3096         uiItem *item, *next;
3097
3098         for (item = layout->items.first; item; item = next) {
3099                 next = item->next;
3100
3101                 if (item->type == ITEM_BUTTON)
3102                         MEM_freeN(item);
3103                 else
3104                         ui_layout_free((uiLayout *)item);
3105         }
3106
3107         MEM_freeN(layout);
3108 }
3109
3110 static void ui_layout_add_padding_button(uiLayoutRoot *root)
3111 {
3112         if (root->padding) {
3113                 /* add an invisible button for padding */
3114                 uiBlock *block = root->block;
3115                 uiLayout *prev_layout = block->curlayout;
3116
3117                 block->curlayout = root->layout;
3118                 uiDefBut(block, UI_BTYPE_SEPR, 0, "", 0, 0, root->padding, root->padding, NULL, 0.0, 0.0, 0, 0, "");
3119                 block->curlayout = prev_layout;
3120         }
3121 }
3122
3123 uiLayout *UI_block_layout(uiBlock *block, int dir, int type, int x, int y, int size, int em, int padding, uiStyle *style)
3124 {
3125         uiLayout *layout;
3126         uiLayoutRoot *root;
3127
3128         root = MEM_callocN(sizeof(uiLayoutRoot), "uiLayoutRoot");
3129         root->type = type;
3130         root->style = style;
3131         root->block = block;
3132         root->padding = padding;
3133         root->opcontext = WM_OP_INVOKE_REGION_WIN;
3134
3135         layout = MEM_callocN(sizeof(uiLayout), "uiLayout");
3136         layout->item.type = ITEM_LAYOUT_ROOT;
3137
3138         layout->x = x;
3139         layout->y = y;
3140         layout->root = root;
3141         layout->space = style->templatespace;
3142         layout->active = 1;
3143         layout->enabled = 1;
3144         layout->context = NULL;
3145
3146         if (type == UI_LAYOUT_MENU || type == UI_LAYOUT_PIEMENU)
3147                 layout->space = 0;
3148
3149         if (dir == UI_LAYOUT_HORIZONTAL) {
3150                 layout->h = size;
3151                 layout->root->emh = em * UI_UNIT_Y;
3152         }
3153         else {
3154                 layout->w = size;
3155                 layout->root->emw = em * UI_UNIT_X;
3156         }
3157
3158         block->curlayout = layout;
3159         root->layout = layout;
3160         BLI_addtail(&block->layouts, root);
3161
3162         ui_layout_add_padding_button(root);
3163         
3164         return layout;
3165 }
3166
3167 uiBlock *uiLayoutGetBlock(uiLayout *layout)
3168 {
3169         return layout->root->block;
3170 }
3171
3172 int uiLayoutGetOperatorContext(uiLayout *layout)
3173 {
3174         return layout->root->opcontext;
3175 }
3176
3177
3178 void UI_block_layout_set_current(uiBlock *block, uiLayout *layout)
3179 {
3180         block->curlayout = layout;
3181 }
3182
3183 void ui_layout_add_but(uiLayout *layout, uiBut *but)
3184 {
3185         uiButtonItem *bitem;
3186         
3187         bitem = MEM_callocN(sizeof(uiButtonItem), "uiButtonItem");
3188         bitem->item.type = ITEM_BUTTON;
3189         bitem->but = but;
3190         BLI_addtail(&layout->items, bitem);
3191
3192         if (layout->context) {
3193                 but->context = layout->context;
3194                 but->context->used = true;
3195         }
3196 }
3197
3198 void uiLayoutSetOperatorContext(uiLayout *layout, int opcontext)
3199 {
3200         layout->root->opcontext = opcontext;
3201 }
3202
3203 void uiLayoutSetFunc(uiLayout *layout, uiMenuHandleFunc handlefunc, void *argv)
3204 {
3205         layout->root->handlefunc = handlefunc;
3206         layout->root->argv = argv;
3207 }
3208
3209 void UI_block_layout_resolve(uiBlock *block, int *x, int *y)
3210 {
3211         uiLayoutRoot *root;
3212
3213         BLI_assert(block->active);
3214
3215         if (x) *x = 0;
3216         if (y) *y = 0;
3217
3218         block->curlayout = NULL;
3219
3220         for (root = block->layouts.first; root; root = root->next) {
3221                 ui_layout_add_padding_button(root);
3222
3223                 /* NULL in advance so we don't interfere when adding button */
3224                 ui_layout_end(block, root->layout, x, y);
3225                 ui_layout_free(root->layout);
3226         }
3227
3228         BLI_freelistN(&block->layouts);
3229
3230         /* XXX silly trick, interface_templates.c doesn't get linked
3231          * because it's not used by other files in this module? */
3232         {