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