Cycles / Sky Texture:
[blender-staging.git] / source / blender / editors / interface / interface_layout.c
index 7a369019ac46615e0301a526eeaef729f1e0e385..ce9b0db6b14c891bf32190626a430d31eccd4abd 100644 (file)
@@ -41,6 +41,7 @@
 #include "BLI_string.h"
 #include "BLI_rect.h"
 #include "BLI_utildefines.h"
+#include "BLI_math.h"
 
 #include "BLF_translation.h"
 
@@ -64,8 +65,8 @@
 #define RNA_NO_INDEX    -1
 #define RNA_ENUM_VALUE  -2
 
-#define EM_SEPR_X       6
-#define EM_SEPR_Y       6
+
+// #define USE_OP_RESET_BUT  // we may want to make this optional, disable for now.
 
 #define UI_OPERATOR_ERROR_RET(_ot, _opname, return_statement)                 \
        if (ot == NULL) {                                                         \
@@ -139,11 +140,11 @@ struct uiLayout {
        int x, y, w, h;
        float scale[2];
        short space;
-       char align;
-       char active;
-       char enabled;
-       char redalert;
-       char keepaspect;
+       bool align;
+       bool active;
+       bool enabled;
+       bool redalert;
+       bool keepaspect;
        char alignment;
 };
 
@@ -185,13 +186,13 @@ static const char *ui_item_name_add_colon(const char *name, char namestr[UI_MAX_
 
 static int ui_item_fit(int item, int pos, int all, int available, int last, int alignment, int *offset)
 {
+       if (offset)
+               *offset = 0;
+
        /* available == 0 is unlimited */
        if (available == 0)
                return item;
-       
-       if (offset)
-               *offset = 0;
-       
+
        if (all > available) {
                /* contents is bigger than available space */
                if (last)
@@ -224,14 +225,16 @@ static int ui_layout_vary_direction(uiLayout *layout)
 /* estimated size of text + icon */
 static int ui_text_icon_width(uiLayout *layout, const char *name, int icon, int compact)
 {
+       float f5 = 0.25f * UI_UNIT_X;
+       float f10 = 0.5f * UI_UNIT_X;
        int variable = ui_layout_vary_direction(layout) == UI_ITEM_VARY_X;
 
        if (icon && !name[0])
                return UI_UNIT_X;  /* icon only */
        else if (icon)
-               return (variable) ? UI_GetStringWidth(name) + (compact ? 5 : 10) + UI_UNIT_X : 10 * UI_UNIT_X;  /* icon + text */
+               return (variable) ? UI_GetStringWidth(name) + (compact ? f5 : f10) + UI_UNIT_X : 10 * UI_UNIT_X;  /* icon + text */
        else
-               return (variable) ? UI_GetStringWidth(name) + (compact ? 5 : 10) + UI_UNIT_X : 10 * UI_UNIT_X;  /* text only */
+               return (variable) ? UI_GetStringWidth(name) + (compact ? f5 : f10) + UI_UNIT_X : 10 * UI_UNIT_X;  /* text only */
 }
 
 static void ui_item_size(uiItem *item, int *r_w, int *r_h)
@@ -343,14 +346,16 @@ static void ui_layer_but_cb(bContext *C, void *arg_but, void *arg_index)
 }
 
 /* create buttons for an item with an RNA array */
-static void ui_item_array(uiLayout *layout, uiBlock *block, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop, int len, int x, int y, int w, int UNUSED(h), int expand, int slider, int toggle, int icon_only)
+static void ui_item_array(uiLayout *layout, uiBlock *block, const char *name, int icon,
+                          PointerRNA *ptr, PropertyRNA *prop, int len, int x, int y, int w, int UNUSED(h),
+                          int expand, int slider, int toggle, int icon_only)
 {
        uiStyle *style = layout->root->style;
        uiBut *but;
        PropertyType type;
        PropertySubType subtype;
        uiLayout *sub;
-       int a, b;
+       unsigned int a, b;
 
        /* retrieve type and subtype */
        type = RNA_property_type(prop);
@@ -368,8 +373,8 @@ static void ui_item_array(uiLayout *layout, uiBlock *block, const char *name, in
                /* special check for layer layout */
                int butw, buth, unit;
                int cols = (len >= 20) ? 2 : 1;
-               int colbuts = len / (2 * cols);
-               int layer_used = 0;
+               const unsigned int colbuts = len / (2 * cols);
+               unsigned int layer_used = 0;
 
                uiBlockSetCurLayout(block, uiLayoutAbsolute(layout, FALSE));
 
@@ -427,7 +432,7 @@ static void ui_item_array(uiLayout *layout, uiBlock *block, const char *name, in
                                but->type = NUMSLI;
                }
        }
-       else if (subtype == PROP_DIRECTION) {
+       else if (subtype == PROP_DIRECTION && !expand) {
                uiDefButR_prop(block, BUT_NORMAL, 0, name, x, y, UI_UNIT_X * 3, UI_UNIT_Y * 3, ptr, prop, 0, 0, 0, -1, -1, NULL);
        }
        else {
@@ -477,24 +482,50 @@ static void ui_item_array(uiLayout *layout, uiBlock *block, const char *name, in
        uiBlockSetCurLayout(block, layout);
 }
 
-static void ui_item_enum_expand(uiLayout *layout, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, const char *uiname, int h, int icon_only)
+static void ui_item_enum_expand_handle(bContext *C, void *arg1, void *arg2)
+{
+       wmWindow *win = CTX_wm_window(C);
+
+       if (!win->eventstate->shift) {
+               uiBut *but = (uiBut *)arg1;
+               int enum_value = GET_INT_FROM_POINTER(arg2);
+
+               int current_value = RNA_property_enum_get(&but->rnapoin, but->rnaprop);
+               if (!(current_value & enum_value)) {
+                       current_value = enum_value;
+               }
+               else {
+                       current_value &= enum_value;
+               }
+               RNA_property_enum_set(&but->rnapoin, but->rnaprop, current_value);
+       }
+}
+static void ui_item_enum_expand(uiLayout *layout, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop,
+                                const char *uiname, int h, int icon_only)
 {
        uiBut *but;
-       EnumPropertyItem *item;
+       EnumPropertyItem *item, *item_array;
        const char *name;
-       int a, totitem, itemw, icon, value, free;
+       int itemw, icon, value, free;
 
-       RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
+       RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item_array, NULL, &free);
+
+       /* we dont want nested rows, cols in menus */
+       if (layout->root->type != UI_LAYOUT_MENU) {
+               uiBlockSetCurLayout(block, ui_item_local_sublayout(layout, layout, 1));
+       }
+       else {
+               uiBlockSetCurLayout(block, layout);
+       }
 
-       uiBlockSetCurLayout(block, ui_item_local_sublayout(layout, layout, 1));
-       for (a = 0; a < totitem; a++) {
-               if (!item[a].identifier[0])
+       for (item = item_array; item->identifier; item++) {
+               if (!item->identifier[0])
                        continue;
 
-               name = (!uiname || uiname[0]) ? item[a].name : "";
-               icon = item[a].icon;
-               value = item[a].value;
-               itemw = ui_text_icon_width(block->curlayout, name, icon, 0);
+               name = (!uiname || uiname[0]) ? item->name : "";
+               icon = item->icon;
+               value = item->value;
+               itemw = ui_text_icon_width(block->curlayout, icon_only ? "" : name, icon, 0);
 
                if (icon && name[0] && !icon_only)
                        but = uiDefIconTextButR_prop(block, ROW, 0, icon, name, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL);
@@ -503,13 +534,17 @@ static void ui_item_enum_expand(uiLayout *layout, uiBlock *block, PointerRNA *pt
                else
                        but = uiDefButR_prop(block, ROW, 0, name, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL);
 
+               if (RNA_property_flag(prop) & PROP_ENUM_FLAG) {
+                       uiButSetFunc(but, ui_item_enum_expand_handle, but, SET_INT_IN_POINTER(value));
+               }
+
                if (ui_layout_local_dir(layout) != UI_LAYOUT_HORIZONTAL)
                        but->flag |= UI_TEXT_LEFT;
        }
        uiBlockSetCurLayout(block, layout);
 
        if (free) {
-               MEM_freeN(item);
+               MEM_freeN(item_array);
        }
 }
 
@@ -533,7 +568,7 @@ static uiBut *ui_item_with_label(uiLayout *layout, uiBlock *block, const char *n
        PropertySubType subtype;
        int labelw;
 
-       sub = uiLayoutRow(layout, FALSE);
+       sub = uiLayoutRow(layout, layout->align);
        uiBlockSetCurLayout(block, sub);
 
        if (name[0]) {
@@ -612,6 +647,18 @@ void uiFileBrowseContextProperty(const bContext *C, PointerRNA *ptr, PropertyRNA
 
 /********************* Button Items *************************/
 
+/**
+ * Update a buttons tip with an enum's description if possible.
+ */
+static void ui_but_tip_from_enum_item(uiBut *but, EnumPropertyItem *item)
+{
+       if (but->tip == NULL || but->tip[0] == '\0') {
+               if (item->description && item->description[0]) {
+                       but->tip = item->description;
+               }
+       }
+}
+
 /* disabled item */
 static void ui_item_disabled(uiLayout *layout, const char *name)
 {
@@ -712,11 +759,14 @@ PointerRNA uiItemFullO(uiLayout *layout, const char *opname, const char *name, i
 static const char *ui_menu_enumpropname(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int retval)
 {
        EnumPropertyItem *item;
-       int totitem, free;
+       int free;
        const char *name;
 
-       RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item, &totitem, &free);
-       if (RNA_enum_name(item, retval, &name) == 0) {
+       RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
+       if (RNA_enum_name(item, retval, &name)) {
+               name = CTX_IFACE_(RNA_property_translation_context(prop), name);
+       }
+       else {
                name = "";
        }
 
@@ -727,18 +777,6 @@ static const char *ui_menu_enumpropname(uiLayout *layout, PointerRNA *ptr, Prope
        return name;
 }
 
-/* same as below but 'prop' is already known */
-static void uiItemEnumO_ptr__internal(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, PropertyRNA *prop, int value)
-{
-       PointerRNA ptr;
-       WM_operator_properties_create_ptr(&ptr, ot);
-       RNA_property_enum_set(&ptr, prop, value);
-
-       if (!name)
-               name = ui_menu_enumpropname(layout, &ptr, prop, value);
-
-       uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0);
-}
 void uiItemEnumO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, const char *propname, int value)
 {
        PointerRNA ptr;
@@ -775,13 +813,13 @@ void uiItemEnumO(uiLayout *layout, const char *opname, const char *name, int ico
 
 }
 
-void uiItemsFullEnumO(uiLayout *layout, const char *opname, const char *propname, IDProperty *properties, int context, int flag)
+void uiItemsFullEnumO(uiLayout *layout, const char *opname, const char *propname, IDProperty *properties,
+                      int context, int flag)
 {
        wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
 
        PointerRNA ptr;
        PropertyRNA *prop;
-       uiBut *bt;
        uiBlock *block = layout->root->block;
 
        if (!ot || !ot->srna) {
@@ -790,58 +828,59 @@ void uiItemsFullEnumO(uiLayout *layout, const char *opname, const char *propname
                return;
        }
 
-       RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
+       WM_operator_properties_create_ptr(&ptr, ot);
+       /* so the context is passed to itemf functions (some need it) */
+       WM_operator_properties_sanitize(&ptr, false);
        prop = RNA_struct_find_property(&ptr, propname);
 
        /* don't let bad properties slip through */
        BLI_assert((prop == NULL) || (RNA_property_type(prop) == PROP_ENUM));
 
        if (prop && RNA_property_type(prop) == PROP_ENUM) {
-               EnumPropertyItem *item;
-               int totitem, i, free;
+               EnumPropertyItem *item, *item_array = NULL;
+               int free;
                uiLayout *split = uiLayoutSplit(layout, 0.0f, FALSE);
                uiLayout *column = uiLayoutColumn(split, FALSE);
 
-               RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item, &totitem, &free);
+               RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item_array, NULL, &free);
+               for (item = item_array; item->identifier; item++) {
+                       if (item->identifier[0]) {
+                               PointerRNA tptr;
 
-               for (i = 0; i < totitem; i++) {
-                       if (item[i].identifier[0]) {
+                               WM_operator_properties_create_ptr(&tptr, ot);
                                if (properties) {
-                                       PointerRNA tptr;
-
-                                       WM_operator_properties_create_ptr(&tptr, ot);
                                        if (tptr.data) {
                                                IDP_FreeProperty(tptr.data);
                                                MEM_freeN(tptr.data);
                                        }
                                        tptr.data = IDP_CopyProperty(properties);
-                                       RNA_property_enum_set(&tptr, prop, item[i].value);
-
-                                       uiItemFullO_ptr(column, ot, item[i].name, item[i].icon, tptr.data, context, flag);
-                               }
-                               else {
-                                       uiItemEnumO_ptr__internal(column, ot, item[i].name, item[i].icon, prop, item[i].value);
                                }
+                               RNA_property_enum_set(&tptr, prop, item->value);
+
+                               uiItemFullO_ptr(column, ot, item->name, item->icon, tptr.data, context, flag);
+                               ui_but_tip_from_enum_item(block->buttons.last, item);
                        }
                        else {
-                               if (item[i].name) {
-                                       if (i != 0) {
+                               if (item->name) {
+                                       uiBut *but;
+                                       if (item != item_array) {
                                                column = uiLayoutColumn(split, FALSE);
                                                /* inconsistent, but menus with labels do not look good flipped */
                                                block->flag |= UI_BLOCK_NO_FLIP;
                                        }
 
-                                       uiItemL(column, item[i].name, ICON_NONE);
-                                       bt = block->buttons.last;
-                                       bt->flag = UI_TEXT_LEFT;
+                                       uiItemL(column, item->name, ICON_NONE);
+                                       but = block->buttons.last;
+                                       but->flag = UI_TEXT_LEFT;
+                                       ui_but_tip_from_enum_item(but, item);
                                }
-                               else /* XXX bug here, collums draw bottom item badly */
+                               else {  /* XXX bug here, colums draw bottom item badly */
                                        uiItemS(column);
+                               }
                        }
                }
-
                if (free) {
-                       MEM_freeN(item);
+                       MEM_freeN(item_array);
                }
        }
        else if (prop && RNA_property_type(prop) != PROP_ENUM) {
@@ -900,10 +939,11 @@ void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char
        UI_OPERATOR_ERROR_RET(ot, opname, return );
 
        WM_operator_properties_create_ptr(&ptr, ot);
-       
+
        /* enum lookup */
        if ((prop = RNA_struct_find_property(&ptr, propname))) {
-               RNA_property_enum_items_gettexted(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free);
+               /* no need for translations here */
+               RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free);
                if (item == NULL || RNA_enum_value_from_id(item, value_str, &value) == 0) {
                        if (free) {
                                MEM_freeN(item);
@@ -920,9 +960,9 @@ void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char
                RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname);
                return;
        }
-       
+
        RNA_property_enum_set(&ptr, prop, value);
-       
+
        /* same as uiItemEnumO */
        if (!name)
                name = ui_menu_enumpropname(layout, &ptr, prop, value);
@@ -989,23 +1029,44 @@ void uiItemO(uiLayout *layout, const char *name, int icon, const char *opname)
 
 /* RNA property items */
 
-static void ui_item_rna_size(uiLayout *layout, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop, int index, int icon_only, int *r_w, int *r_h)
+static void ui_item_rna_size(uiLayout *layout, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop,
+                             int index, int icon_only, int *r_w, int *r_h)
 {
        PropertyType type;
        PropertySubType subtype;
-       int len, w, h;
+       int len, w = 0, h;
 
        /* arbitrary extended width by type */
        type = RNA_property_type(prop);
        subtype = RNA_property_subtype(prop);
        len = RNA_property_array_length(ptr, prop);
 
-       if (ELEM3(type, PROP_STRING, PROP_POINTER, PROP_ENUM) && !name[0] && !icon_only)
-               name = "non-empty text";
-       else if (type == PROP_BOOLEAN && !name[0] && !icon_only)
-               icon = ICON_DOT;
+       if (!name[0] && !icon_only) {
+               if (ELEM(type, PROP_STRING, PROP_POINTER)) {
+                       name = "non-empty text";
+               }
+               else if (type == PROP_BOOLEAN) {
+                       icon = ICON_DOT;
+               }
+               else if (type == PROP_ENUM) {
+                       /* Find the longest enum item name, instead of using a dummy text! */
+                       EnumPropertyItem *item, *item_array;
+                       int free;
+
+                       RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item_array, NULL, &free);
+                       for (item = item_array; item->identifier; item++) {
+                               if (item->identifier[0]) {
+                                       w = max_ii(w, ui_text_icon_width(layout, item->name, icon, 0));
+                               }
+                       }
+                       if (free) {
+                               MEM_freeN(item_array);
+                       }
+               }
+       }
 
-       w = ui_text_icon_width(layout, name, icon, 0);
+       if (!w)
+               w = ui_text_icon_width(layout, name, icon, 0);
        h = UI_UNIT_Y;
 
        /* increase height for arrays */
@@ -1168,7 +1229,7 @@ void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *pr
                return;
        }
 
-       RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
+       RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
 
        if (!RNA_enum_value_from_id(item, value, &ivalue)) {
                if (free) {
@@ -1181,7 +1242,9 @@ void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *pr
 
        for (a = 0; item[a].identifier; a++) {
                if (item[a].value == ivalue) {
-                       uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, ivalue, 0, name ? name : item[a].name, icon ? icon : item[a].icon);
+                       const char *item_name = CTX_IFACE_(RNA_property_translation_context(prop), item[a].name);
+
+                       uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, ivalue, 0, item_name ? item_name : name, icon ? icon : item[a].icon);
                        break;
                }
        }
@@ -1220,6 +1283,7 @@ void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname
                for (i = 0; i < totitem; i++) {
                        if (item[i].identifier[0]) {
                                uiItemEnumR(column, item[i].name, ICON_NONE, ptr, propname, item[i].value);
+                               ui_but_tip_from_enum_item(block->buttons.last, &item[i]);
                        }
                        else {
                                if (item[i].name) {
@@ -1232,6 +1296,8 @@ void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname
                                        uiItemL(column, item[i].name, ICON_NONE);
                                        bt = block->buttons.last;
                                        bt->flag = UI_TEXT_LEFT;
+
+                                       ui_but_tip_from_enum_item(bt, &item[i]);
                                }
                                else
                                        uiItemS(column);
@@ -1291,12 +1357,13 @@ static void rna_search_cb(const struct bContext *C, void *arg_but, const char *s
                        char name_ui[MAX_ID_NAME];
 
 #if 0       /* this name is used for a string comparison and can't be modified, TODO */
+                       /* if ever enabled, make name_ui be MAX_ID_NAME+1 */
                        name_uiprefix_id(name_ui, id);
 #else
                        BLI_strncpy(name_ui, id->name + 2, sizeof(name_ui));
 #endif
                        name = BLI_strdup(name_ui);
-                       iconid = ui_id_icon_get((bContext *)C, id, 0);
+                       iconid = ui_id_icon_get((bContext *)C, id, false);
                }
                else {
                        name = RNA_struct_name_get_alloc(&itemptr, NULL, 0, NULL); /* could use the string length here */
@@ -1312,7 +1379,7 @@ static void rna_search_cb(const struct bContext *C, void *arg_but, const char *s
                                BLI_addtail(items_list, cis);
                        }
                        MEM_freeN(name);
-               }                       
+               }
 
                i++;
        }
@@ -1322,7 +1389,7 @@ static void rna_search_cb(const struct bContext *C, void *arg_but, const char *s
        
        /* add search items from temporary list */
        for (cis = items_list->first; cis; cis = cis->next) {
-               if (!uiSearchItemAdd(items, cis->name, SET_INT_IN_POINTER(cis->index), cis->iconid)) {
+               if (false == uiSearchItemAdd(items, cis->name, SET_INT_IN_POINTER(cis->index), cis->iconid)) {
                        break;
                }
        }
@@ -1374,12 +1441,18 @@ void ui_but_add_search(uiBut *but, PointerRNA *ptr, PropertyRNA *prop, PointerRN
 
        /* turn button into search button */
        if (searchprop) {
-               but->type = SEARCH_MENU;
-               but->hardmax = MAX2(but->hardmax, 256);
+               but->type = RNA_property_is_unlink(prop) ? SEARCH_MENU_UNLINK : SEARCH_MENU;
+               but->hardmax = MAX2(but->hardmax, 256.0f);
                but->rnasearchpoin = *searchptr;
                but->rnasearchprop = searchprop;
                but->flag |= UI_ICON_LEFT | UI_TEXT_LEFT;
 
+               if (RNA_property_type(prop) == PROP_ENUM) {
+                       /* XXX, this will have a menu string,
+                        * but in this case we just want the text */
+                       but->str[0] = 0;
+               }
+
                uiButSetSearchFunc(but, rna_search_cb, but, NULL, NULL);
        }
 }
@@ -1392,18 +1465,20 @@ void uiItemPointerR(uiLayout *layout, struct PointerRNA *ptr, const char *propna
        uiBlock *block;
        StructRNA *icontype;
        int w, h;
+       char namestr[UI_MAX_NAME_STR];
        
        /* validate arguments */
        prop = RNA_struct_find_property(ptr, propname);
 
        if (!prop) {
-               RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname);
+               RNA_warning("property not found: %s.%s",
+                           RNA_struct_identifier(ptr->type), propname);
                return;
        }
        
        type = RNA_property_type(prop);
-       if (!ELEM(type, PROP_POINTER, PROP_STRING)) {
-               RNA_warning("Property %s must be a pointer or string", propname);
+       if (!ELEM3(type, PROP_POINTER, PROP_STRING, PROP_ENUM)) {
+               RNA_warning("Property %s must be a pointer, string or enum", propname);
                return;
        }
 
@@ -1411,11 +1486,13 @@ void uiItemPointerR(uiLayout *layout, struct PointerRNA *ptr, const char *propna
 
 
        if (!searchprop) {
-               RNA_warning("search collection property not found: %s.%s", RNA_struct_identifier(ptr->type), searchpropname);
+               RNA_warning("search collection property not found: %s.%s",
+                           RNA_struct_identifier(searchptr->type), searchpropname);
                return;
        }
        else if (RNA_property_type(searchprop) != PROP_COLLECTION) {
-               RNA_warning("search collection property is not a collection type: %s.%s", RNA_struct_identifier(ptr->type), searchpropname);
+               RNA_warning("search collection property is not a collection type: %s.%s",
+                           RNA_struct_identifier(searchptr->type), searchpropname);
                return;
        }
 
@@ -1431,10 +1508,13 @@ void uiItemPointerR(uiLayout *layout, struct PointerRNA *ptr, const char *propna
        if (!name)
                name = RNA_property_ui_name(prop);
 
+       name = ui_item_name_add_colon(name, namestr);
+
        /* create button */
        block = uiLayoutGetBlock(layout);
 
        ui_item_rna_size(layout, name, icon, ptr, prop, 0, 0, &w, &h);
+       w += UI_UNIT_X; /* X icon needs more space */
        but = ui_item_with_label(layout, block, name, icon, ptr, prop, 0, 0, 0, w, h, 0);
 
        ui_but_add_search(but, ptr, prop, searchptr, searchprop);
@@ -1448,10 +1528,22 @@ static void ui_item_menutype_func(bContext *C, uiLayout *layout, void *arg_mt)
 
        menu.type = mt;
        menu.layout = layout;
+
+       if (G.debug & G_DEBUG_WM) {
+               printf("%s: opening menu \"%s\"\n", __func__, mt->idname);
+       }
+
+       if (layout->context)
+               CTX_store_set(C, layout->context);
+
        mt->draw(C, &menu);
+
+       if (layout->context)
+               CTX_store_set(C, NULL);
 }
 
-static void ui_item_menu(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg, void *argN, const char *tip)
+static void ui_item_menu(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg, void *argN,
+                         const char *tip, bool force_menu)
 {
        uiBlock *block = layout->root->block;
        uiBut *but;
@@ -1470,8 +1562,12 @@ static void ui_item_menu(uiLayout *layout, const char *name, int icon, uiMenuCre
        w = ui_text_icon_width(layout, name, icon, 1);
        h = UI_UNIT_Y;
 
-       if (layout->root->type == UI_LAYOUT_HEADER) /* ugly .. */
-               w -= 10;
+       if (layout->root->type == UI_LAYOUT_HEADER) { /* ugly .. */
+               if (force_menu)
+                       w += UI_UNIT_Y;
+               else
+                       w -= UI_UNIT_Y / 2;
+       }
 
        if (name[0] && icon)
                but = uiDefIconTextMenuBut(block, func, arg, icon, name, 0, 0, w, h, tip);
@@ -1485,9 +1581,12 @@ static void ui_item_menu(uiLayout *layout, const char *name, int icon, uiMenuCre
                but->func_argN = argN;
        }
 
-       if (layout->root->type == UI_LAYOUT_HEADER)
+       if (layout->root->type == UI_LAYOUT_HEADER) {
                uiBlockSetEmboss(block, UI_EMBOSS);
-       else if (ELEM(layout->root->type, UI_LAYOUT_PANEL, UI_LAYOUT_TOOLBAR)) {
+       }
+       if (ELEM(layout->root->type, UI_LAYOUT_PANEL, UI_LAYOUT_TOOLBAR) ||
+           (force_menu && layout->root->type != UI_LAYOUT_MENU))  /* We never want a dropdown in menu! */
+       {
                but->type = MENU;
                but->flag |= UI_TEXT_LEFT;
        }
@@ -1505,13 +1604,13 @@ void uiItemM(uiLayout *layout, bContext *UNUSED(C), const char *menuname, const
        }
 
        if (!name) {
-               name = IFACE_(mt->label);
+               name = CTX_IFACE_(mt->translation_context, mt->label);
        }
 
        if (layout->root->type == UI_LAYOUT_MENU && !icon)
                icon = ICON_BLANK1;
 
-       ui_item_menu(layout, name, icon, ui_item_menutype_func, mt, NULL, TIP_(mt->description));
+       ui_item_menu(layout, name, icon, ui_item_menutype_func, mt, NULL, TIP_(mt->description), false);
 }
 
 /* label item */
@@ -1536,7 +1635,20 @@ static uiBut *uiItemL_(uiLayout *layout, const char *name, int icon)
                but = uiDefIconBut(block, LABEL, 0, icon, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
        else
                but = uiDefBut(block, LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
-       
+
+       /* to compensate for string size padding in ui_text_icon_width,
+        * make text aligned right if the layout is aligned right.
+        */
+       if (uiLayoutGetAlignment(layout) == UI_LAYOUT_ALIGN_RIGHT) {
+               but->flag &= ~UI_TEXT_LEFT;     /* default, needs to be unset */
+               but->flag |= UI_TEXT_RIGHT;
+       }
+
+       /* Mark as a label inside a listbox. */
+       if (block->flag & UI_BLOCK_LIST_ITEM) {
+               but->type = LISTLABEL;
+       }
+
        return but;
 }
 
@@ -1573,11 +1685,11 @@ void uiItemV(uiLayout *layout, const char *name, int icon, int argval)
        w = ui_text_icon_width(layout, name, icon, 0);
 
        if (icon && name[0])
-               uiDefIconTextButF(block, BUT, argval, icon, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, 0, "");
+               uiDefIconTextButF(block, BUT, argval, icon, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
        else if (icon)
-               uiDefIconButF(block, BUT, argval, icon, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, 0, "");
+               uiDefIconButF(block, BUT, argval, icon, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
        else
-               uiDefButF(block, BUT, argval, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, 0, "");
+               uiDefButF(block, BUT, argval, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, "");
 }
 
 /* separator item */
@@ -1586,7 +1698,7 @@ void uiItemS(uiLayout *layout)
        uiBlock *block = layout->root->block;
 
        uiBlockSetCurLayout(block, layout);
-       uiDefBut(block, SEPR, 0, "", 0, 0, EM_SEPR_X, EM_SEPR_Y, NULL, 0.0, 0.0, 0, 0, "");
+       uiDefBut(block, SEPR, 0, "", 0, 0, 0.3f * UI_UNIT_X, 0.3f * UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
 }
 
 /* level items */
@@ -1595,7 +1707,7 @@ void uiItemMenuF(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc
        if (!func)
                return;
 
-       ui_item_menu(layout, name, icon, func, arg, NULL, "");
+       ui_item_menu(layout, name, icon, func, arg, NULL, "", false);
 }
 
 typedef struct MenuItemLevel {
@@ -1615,10 +1727,12 @@ static void menu_item_enum_opname_menu(bContext *UNUSED(C), uiLayout *layout, vo
        uiItemsEnumO(layout, lvl->opname, lvl->propname);
 }
 
-void uiItemMenuEnumO(uiLayout *layout, const char *opname, const char *propname, const char *name, int icon)
+void uiItemMenuEnumO(uiLayout *layout, bContext *C, const char *opname, const char *propname, const char *name, int icon)
 {
        wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
        MenuItemLevel *lvl;
+       char namestr_buf[UI_MAX_NAME_STR], keybuf[128];
+       char *namestr = namestr_buf;
 
        UI_OPERATOR_ERROR_RET(ot, opname, return );
 
@@ -1628,8 +1742,11 @@ void uiItemMenuEnumO(uiLayout *layout, const char *opname, const char *propname,
                return;
        }
 
-       if (!name)
-               name = RNA_struct_ui_name(ot->srna);
+       if (name)
+               namestr += BLI_strncpy_rlen(namestr, name, sizeof(namestr_buf));
+       else
+               namestr += BLI_strncpy_rlen(namestr, RNA_struct_ui_name(ot->srna), sizeof(namestr_buf));
+
        if (layout->root->type == UI_LAYOUT_MENU && !icon)
                icon = ICON_BLANK1;
 
@@ -1638,7 +1755,17 @@ void uiItemMenuEnumO(uiLayout *layout, const char *opname, const char *propname,
        BLI_strncpy(lvl->propname, propname, sizeof(lvl->propname));
        lvl->opcontext = layout->root->opcontext;
 
-       ui_item_menu(layout, name, icon, menu_item_enum_opname_menu, NULL, lvl, RNA_struct_ui_description(ot->srna));
+       /* add hotkey here, lower UI code can't detect it */
+       if (layout->root->block->flag & UI_BLOCK_LOOP) {
+               if (ot->prop && ot->invoke &&
+                   WM_key_event_operator_string(C, ot->idname, layout->root->opcontext, NULL, false, keybuf, sizeof(keybuf)))
+               {
+                       namestr += BLI_snprintf(namestr, sizeof(namestr_buf) - (namestr - namestr_buf), "|%s", keybuf);
+               }
+       }
+
+       ui_item_menu(layout, namestr_buf, icon, menu_item_enum_opname_menu, NULL, lvl, RNA_struct_ui_description(ot->srna),
+                    true);
 }
 
 static void menu_item_enum_rna_menu(bContext *UNUSED(C), uiLayout *layout, void *arg)
@@ -1671,7 +1798,7 @@ void uiItemMenuEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propn
        BLI_strncpy(lvl->propname, propname, sizeof(lvl->propname));
        lvl->opcontext = layout->root->opcontext;
 
-       ui_item_menu(layout, name, icon, menu_item_enum_rna_menu, NULL, lvl, RNA_property_description(prop));
+       ui_item_menu(layout, name, icon, menu_item_enum_rna_menu, NULL, lvl, RNA_property_description(prop), false);
 }
 
 /**************************** Layout Items ***************************/
@@ -1707,7 +1834,7 @@ static void ui_litem_layout_row(uiLayout *litem)
        int x, y, w, tot, totw, neww, itemw, minw, itemh, offset;
        int fixedw, freew, fixedx, freex, flag = 0, lastw = 0;
 
-       /* x= litem->x; */ /* UNUSED */
+       /* x = litem->x; */ /* UNUSED */
        y = litem->y;
        w = litem->w;
        totw = 0;
@@ -1773,7 +1900,7 @@ static void ui_litem_layout_row(uiLayout *litem)
 
                if (item->flag) {
                        /* fixed minimum size items */
-                       itemw = ui_item_fit(minw, fixedx, fixedw, MIN2(w, fixedw), !item->next, litem->alignment, NULL);
+                       itemw = ui_item_fit(minw, fixedx, fixedw, min_ii(w, fixedw), !item->next, litem->alignment, NULL);
                        fixedx += itemw;
                }
                else {
@@ -1931,8 +2058,8 @@ static void ui_litem_estimate_column_flow(uiLayout *litem)
                        return;
                }
 
-               flow->totcol = MAX2(litem->root->emw / maxw, 1);
-               flow->totcol = MIN2(flow->totcol, totitem);
+               flow->totcol = max_ii(litem->root->emw / maxw, 1);
+               flow->totcol = min_ii(flow->totcol, totitem);
        }
        else
                flow->totcol = flow->number;
@@ -1952,9 +2079,9 @@ static void ui_litem_estimate_column_flow(uiLayout *litem)
                ui_item_size(item, &itemw, &itemh);
 
                y -= itemh + style->buttonspacey;
-               miny = MIN2(miny, y);
+               miny = min_ii(miny, y);
                emy -= itemh;
-               maxw = MAX2(itemw, maxw);
+               maxw = max_ii(itemw, maxw);
 
                /* decide to go to next one */
                if (col < flow->totcol - 1 && emy <= -emh) {
@@ -2006,7 +2133,7 @@ static void ui_litem_layout_column_flow(uiLayout *litem)
                emy -= itemh;
                ui_item_position(item, x + offset, y, itemw, itemh);
                y -= style->buttonspacey;
-               miny = MIN2(miny, y);
+               miny = min_ii(miny, y);
 
                /* decide to go to next one */
                if (col < flow->totcol - 1 && emy <= -emh) {
@@ -2037,8 +2164,8 @@ static void ui_litem_estimate_absolute(uiLayout *litem)
                ui_item_offset(item, &itemx, &itemy);
                ui_item_size(item, &itemw, &itemh);
 
-               minx = MIN2(minx, itemx);
-               miny = MIN2(miny, itemy);
+               minx = min_ii(minx, itemx);
+               miny = min_ii(miny, itemy);
 
                litem->w = MAX2(litem->w, itemx + itemw);
                litem->h = MAX2(litem->h, itemy + itemh);
@@ -2063,11 +2190,11 @@ static void ui_litem_layout_absolute(uiLayout *litem)
                ui_item_offset(item, &itemx, &itemy);
                ui_item_size(item, &itemw, &itemh);
 
-               minx = MIN2(minx, itemx);
-               miny = MIN2(miny, itemy);
+               minx = min_ii(minx, itemx);
+               miny = min_ii(miny, itemy);
 
-               totw = MAX2(totw, itemx + itemw);
-               toth = MAX2(toth, itemy + itemh);
+               totw = max_ii(totw, itemx + itemw);
+               toth = max_ii(toth, itemy + itemh);
        }
 
        totw -= minx;
@@ -2197,10 +2324,11 @@ uiLayout *uiLayoutRow(uiLayout *layout, int align)
        litem->item.type = ITEM_LAYOUT_ROW;
        litem->root = layout->root;
        litem->align = align;
-       litem->active = 1;
-       litem->enabled = 1;
+       litem->active = true;
+       litem->enabled = true;
        litem->context = layout->context;
        litem->space = (align) ? 0 : layout->root->style->buttonspacex;
+       litem->redalert = layout->redalert;
        litem->w = layout->w;
        BLI_addtail(&layout->items, litem);
 
@@ -2217,10 +2345,11 @@ uiLayout *uiLayoutColumn(uiLayout *layout, int align)
        litem->item.type = ITEM_LAYOUT_COLUMN;
        litem->root = layout->root;
        litem->align = align;
-       litem->active = 1;
-       litem->enabled = 1;
+       litem->active = true;
+       litem->enabled = true;
        litem->context = layout->context;
        litem->space = (litem->align) ? 0 : layout->root->style->buttonspacey;
+       litem->redalert = layout->redalert;
        litem->w = layout->w;
        BLI_addtail(&layout->items, litem);
 
@@ -2237,10 +2366,11 @@ uiLayout *uiLayoutColumnFlow(uiLayout *layout, int number, int align)
        flow->litem.item.type = ITEM_LAYOUT_COLUMN_FLOW;
        flow->litem.root = layout->root;
        flow->litem.align = align;
-       flow->litem.active = 1;
-       flow->litem.enabled = 1;
+       flow->litem.active = true;
+       flow->litem.enabled = true;
        flow->litem.context = layout->context;
        flow->litem.space = (flow->litem.align) ? 0 : layout->root->style->columnspace;
+       flow->litem.redalert = layout->redalert;
        flow->litem.w = layout->w;
        flow->number = number;
        BLI_addtail(&layout->items, flow);
@@ -2261,6 +2391,7 @@ static uiLayoutItemBx *ui_layout_box(uiLayout *layout, int type)
        box->litem.enabled = 1;
        box->litem.context = layout->context;
        box->litem.space = layout->root->style->columnspace;
+       box->litem.redalert = layout->redalert;
        box->litem.w = layout->w;
        BLI_addtail(&layout->items, box);
 
@@ -2276,16 +2407,45 @@ uiLayout *uiLayoutBox(uiLayout *layout)
        return (uiLayout *)ui_layout_box(layout, ROUNDBOX);
 }
 
-uiLayout *uiLayoutListBox(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *actptr, PropertyRNA *actprop)
+/* Check all buttons defined in this layout, and set labels as active/selected.
+ * Needed to handle correctly text colors of list items. */
+void ui_layout_list_set_labels_active(uiLayout *layout)
+{
+       uiButtonItem *bitem;
+       for (bitem = layout->items.first; bitem; bitem = bitem->item.next) {
+               if (bitem->item.type == ITEM_BUTTON && bitem->but->type == LISTLABEL) {
+                       uiButSetFlag(bitem->but, UI_SELECT);
+               }
+       }
+}
+
+uiLayout *uiLayoutListBox(uiLayout *layout, uiList *ui_list, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *actptr,
+                          PropertyRNA *actprop)
 {
        uiLayoutItemBx *box = ui_layout_box(layout, LISTBOX);
        uiBut *but = box->roundbox;
 
+       but->custom_data = ui_list;
+
        but->rnasearchpoin = *ptr;
        but->rnasearchprop = prop;
        but->rnapoin = *actptr;
        but->rnaprop = actprop;
 
+       /* Resizing data. */
+       /* Note: we can't use usual "num button" value handling, as it only tries rnapoin when it is non-NULL... :/
+        *       So just setting but->poin, not but->pointype.
+        */
+       but->poin = (void *)&ui_list->list_grip;
+       but->hardmin = but->softmin = 0.0f;
+       but->hardmax = but->softmax = 1000.0f; /* Should be more than enough! */
+       but->a1 = 0.0f;
+
+       /* only for the undo string */
+       if (but->flag & UI_BUT_UNDO) {
+               but->tip = RNA_property_description(actprop);
+       }
+
        return (uiLayout *)box;
 }
 
@@ -2300,6 +2460,7 @@ uiLayout *uiLayoutAbsolute(uiLayout *layout, int align)
        litem->active = 1;
        litem->enabled = 1;
        litem->context = layout->context;
+       litem->redalert = layout->redalert;
        BLI_addtail(&layout->items, litem);
 
        uiBlockSetCurLayout(layout->root->block, litem);
@@ -2324,9 +2485,10 @@ uiLayout *uiLayoutOverlap(uiLayout *layout)
        litem = MEM_callocN(sizeof(uiLayout), "uiLayoutOverlap");
        litem->item.type = ITEM_LAYOUT_OVERLAP;
        litem->root = layout->root;
-       litem->active = 1;
-       litem->enabled = 1;
+       litem->active = true;
+       litem->enabled = true;
        litem->context = layout->context;
+       litem->redalert = layout->redalert;
        BLI_addtail(&layout->items, litem);
 
        uiBlockSetCurLayout(layout->root->block, litem);
@@ -2342,10 +2504,11 @@ uiLayout *uiLayoutSplit(uiLayout *layout, float percentage, int align)
        split->litem.item.type = ITEM_LAYOUT_SPLIT;
        split->litem.root = layout->root;
        split->litem.align = align;
-       split->litem.active = 1;
-       split->litem.enabled = 1;
+       split->litem.active = true;
+       split->litem.enabled = true;
        split->litem.context = layout->context;
        split->litem.space = layout->root->style->columnspace;
+       split->litem.redalert = layout->redalert;
        split->litem.w = layout->w;
        split->percentage = percentage;
        BLI_addtail(&layout->items, split);
@@ -2355,27 +2518,27 @@ uiLayout *uiLayoutSplit(uiLayout *layout, float percentage, int align)
        return &split->litem;
 }
 
-void uiLayoutSetActive(uiLayout *layout, int active)
+void uiLayoutSetActive(uiLayout *layout, bool active)
 {
        layout->active = active;
 }
 
-void uiLayoutSetEnabled(uiLayout *layout, int enabled)
+void uiLayoutSetEnabled(uiLayout *layout, bool enabled)
 {
        layout->enabled = enabled;
 }
 
-void uiLayoutSetRedAlert(uiLayout *layout, int redalert)
+void uiLayoutSetRedAlert(uiLayout *layout, bool redalert)
 {
        layout->redalert = redalert;
 }
 
-void uiLayoutSetKeepAspect(uiLayout *layout, int keepaspect)
+void uiLayoutSetKeepAspect(uiLayout *layout, bool keepaspect)
 {
        layout->keepaspect = keepaspect;
 }
 
-void uiLayoutSetAlignment(uiLayout *layout, int alignment)
+void uiLayoutSetAlignment(uiLayout *layout, char alignment)
 {
        layout->alignment = alignment;
 }
@@ -2390,22 +2553,22 @@ void uiLayoutSetScaleY(uiLayout *layout, float scale)
        layout->scale[1] = scale;
 }
 
-int uiLayoutGetActive(uiLayout *layout)
+bool uiLayoutGetActive(uiLayout *layout)
 {
        return layout->active;
 }
 
-int uiLayoutGetEnabled(uiLayout *layout)
+bool uiLayoutGetEnabled(uiLayout *layout)
 {
        return layout->enabled;
 }
 
-int uiLayoutGetRedAlert(uiLayout *layout)
+bool uiLayoutGetRedAlert(uiLayout *layout)
 {
        return layout->redalert;
 }
 
-int uiLayoutGetKeepAspect(uiLayout *layout)
+bool uiLayoutGetKeepAspect(uiLayout *layout)
 {
        return layout->keepaspect;
 }
@@ -2432,7 +2595,7 @@ float uiLayoutGetScaleY(uiLayout *layout)
 
 /********************** Layout *******************/
 
-static void ui_item_scale(uiLayout *litem, float scale[2])
+static void ui_item_scale(uiLayout *litem, const float scale[2])
 {
        uiItem *item;
        int x, y, w, h;
@@ -2515,16 +2678,21 @@ static void ui_item_align(uiLayout *litem, short nr)
                                if (!bitem->but->alignnr)
                                        bitem->but->alignnr = nr;
                }
-               else if (item->type == ITEM_LAYOUT_ABSOLUTE) ;
-               else if (item->type == ITEM_LAYOUT_OVERLAP) ;
+               else if (item->type == ITEM_LAYOUT_ABSOLUTE) {
+                       /* pass */
+               }
+               else if (item->type == ITEM_LAYOUT_OVERLAP) {
+                       /* pass */
+               }
                else if (item->type == ITEM_LAYOUT_BOX) {
                        box = (uiLayoutItemBx *)item;
                        box->roundbox->alignnr = nr;
                        BLI_remlink(&litem->root->block->buttons, box->roundbox);
                        BLI_addhead(&litem->root->block->buttons, box->roundbox);
                }
-               else
+               else if (((uiLayout *)item)->align) {
                        ui_item_align((uiLayout *)item, nr);
+               }
        }
 }
 
@@ -2829,14 +2997,16 @@ const char *uiLayoutIntrospect(uiLayout *layout)
        return str;
 }
 
+#ifdef USE_OP_RESET_BUT
 static void ui_layout_operator_buts__reset_cb(bContext *UNUSED(C), void *op_pt, void *UNUSED(arg_dummy2))
 {
        WM_operator_properties_reset((wmOperator *)op_pt);
 }
+#endif
 
 /* this function does not initialize the layout, functions can be called on the layout before and after */
 void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,
-                          int (*check_prop)(struct PointerRNA *, struct PropertyRNA *),
+                          bool (*check_prop)(struct PointerRNA *, struct PropertyRNA *),
                           const char label_align, const short flag)
 {
        if (!op->properties) {
@@ -2851,7 +3021,7 @@ void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,
        /* poll() on this operator may still fail, at the moment there is no nice feedback when this happens
         * just fails silently */
        if (!WM_operator_repeat_check(C, op)) {
-               uiBlockSetButLock(uiLayoutGetBlock(layout), TRUE, "Operator can't' redo");
+               uiBlockSetButLock(uiLayoutGetBlock(layout), true, "Operator can't' redo");
 
                /* XXX, could give some nicer feedback or not show redo panel at all? */
                uiItemL(layout, IFACE_("* Redo Unsupported *"), ICON_NONE);
@@ -2900,6 +3070,7 @@ void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,
                }
        }
 
+#ifdef USE_OP_RESET_BUT
        /* its possible that reset can do nothing if all have PROP_SKIP_SAVE enabled
         * but this is not so important if this button is drawn in those cases
         * (which isn't all that likely anyway) - campbell */
@@ -2910,10 +3081,11 @@ void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,
 
                col = uiLayoutColumn(layout, FALSE);
                block = uiLayoutGetBlock(col);
-               but = uiDefIconTextBut(block, BUT, 0, ICON_FILE_REFRESH, IFACE_("Reset"), 0, 0, 18, 20,
+               but = uiDefIconTextBut(block, BUT, 0, ICON_FILE_REFRESH, IFACE_("Reset"), 0, 0, UI_UNIT_X, UI_UNIT_Y,
                                       NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Reset operator defaults"));
                uiButSetFunc(but, ui_layout_operator_buts__reset_cb, op, NULL);
        }
+#endif
 
        /* set various special settings for buttons */
        {
@@ -2923,12 +3095,14 @@ void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,
                        /* no undo for buttons for operator redo panels */
                        uiButClearFlag(but, UI_BUT_UNDO);
                        
+#if 0          /* broken, causes freedback loop, see [#36109] */
                        /* if button is operator's default property, and a text-field, enable focus for it
                         *      - this is used for allowing operators with popups to rename stuff with fewer clicks
                         */
                        if ((but->rnaprop == op->type->prop) && (but->type == TEX)) {
                                uiButSetFocusOnEnter(CTX_wm_window(C), but);
                        }
+#endif
                }
        }
 }