/* * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /** \file * \ingroup edinterface */ #include #include #include #include #include "MEM_guardedalloc.h" #include "DNA_armature_types.h" #include "DNA_screen_types.h" #include "DNA_userdef_types.h" #include "BLI_alloca.h" #include "BLI_dynstr.h" #include "BLI_listbase.h" #include "BLI_math.h" #include "BLI_rect.h" #include "BLI_string.h" #include "BLI_utildefines.h" #include "BLT_translation.h" #include "BKE_anim_data.h" #include "BKE_armature.h" #include "BKE_context.h" #include "BKE_global.h" #include "BKE_idprop.h" #include "BKE_screen.h" #include "RNA_access.h" #include "UI_interface.h" #include "WM_api.h" #include "WM_types.h" #include "interface_intern.h" /* Show an icon button after each RNA button to use to quickly set keyframes, * this is a way to display animation/driven/override status, see T54951. */ #define UI_PROP_DECORATE /* Alternate draw mode where some buttons can use single icon width, * giving more room for the text at the expense of nicely aligned text. */ #define UI_PROP_SEP_ICON_WIDTH_EXCEPTION /* -------------------------------------------------------------------- */ /** \name Structs and Defines * \{ */ #define UI_OPERATOR_ERROR_RET(_ot, _opname, return_statement) \ if (ot == NULL) { \ ui_item_disabled(layout, _opname); \ RNA_warning("'%s' unknown operator", _opname); \ return_statement; \ } \ (void)0 #define UI_ITEM_PROP_SEP_DIVIDE 0.4f /* uiLayoutRoot */ typedef struct uiLayoutRoot { struct uiLayoutRoot *next, *prev; int type; int opcontext; int emw, emh; int padding; uiMenuHandleFunc handlefunc; void *argv; const uiStyle *style; uiBlock *block; uiLayout *layout; } uiLayoutRoot; /* Item */ typedef enum uiItemType { ITEM_BUTTON, ITEM_LAYOUT_ROW, ITEM_LAYOUT_COLUMN, ITEM_LAYOUT_COLUMN_FLOW, ITEM_LAYOUT_ROW_FLOW, ITEM_LAYOUT_GRID_FLOW, ITEM_LAYOUT_BOX, ITEM_LAYOUT_ABSOLUTE, ITEM_LAYOUT_SPLIT, ITEM_LAYOUT_OVERLAP, ITEM_LAYOUT_RADIAL, ITEM_LAYOUT_ROOT #if 0 TEMPLATE_COLUMN_FLOW, TEMPLATE_SPLIT, TEMPLATE_BOX, TEMPLATE_HEADER, TEMPLATE_HEADER_ID, #endif } uiItemType; typedef struct uiItem { void *next, *prev; uiItemType type; int flag; } uiItem; enum { UI_ITEM_AUTO_FIXED_SIZE = 1 << 0, UI_ITEM_FIXED_SIZE = 1 << 1, UI_ITEM_BOX_ITEM = 1 << 2, /* The item is "inside" a box item */ UI_ITEM_PROP_SEP = 1 << 3, UI_ITEM_INSIDE_PROP_SEP = 1 << 4, /* Show an icon button next to each property (to set keyframes, show status). * Enabled by default, depends on 'UI_ITEM_PROP_SEP'. */ UI_ITEM_PROP_DECORATE = 1 << 5, UI_ITEM_PROP_DECORATE_NO_PAD = 1 << 6, }; typedef struct uiButtonItem { uiItem item; uiBut *but; } uiButtonItem; struct uiLayout { uiItem item; uiLayoutRoot *root; bContextStore *context; uiLayout *parent; ListBase items; char heading[UI_MAX_NAME_STR]; /** Sub layout to add child items, if not the layout itself. */ uiLayout *child_items_layout; int x, y, w, h; float scale[2]; short space; bool align; bool active; bool active_default; bool activate_init; bool enabled; bool redalert; bool keepaspect; /** For layouts inside grid-flow, they and their items shall never have a fixed maximal size. */ bool variable_size; char alignment; eUIEmbossType emboss; /** for fixed width or height to avoid UI size changes */ float units[2]; }; typedef struct uiLayoutItemFlow { uiLayout litem; int number; int totcol; } uiLayoutItemFlow; typedef struct uiLayoutItemGridFlow { uiLayout litem; /* Extra parameters */ bool row_major; /* Fill first row first, instead of filling first column first. */ bool even_columns; /* Same width for all columns. */ bool even_rows; /* Same height for all rows. */ /** * - If positive, absolute fixed number of columns. * - If 0, fully automatic (based on available width). * - If negative, automatic but only generates number of columns/rows * multiple of given (absolute) value. */ int columns_len; /* Pure internal runtime storage. */ int tot_items, tot_columns, tot_rows; } uiLayoutItemGridFlow; typedef struct uiLayoutItemBx { uiLayout litem; uiBut *roundbox; } uiLayoutItemBx; typedef struct uiLayoutItemSplit { uiLayout litem; float percentage; } uiLayoutItemSplit; typedef struct uiLayoutItemRoot { uiLayout litem; } uiLayoutItemRoot; /** \} */ /* -------------------------------------------------------------------- */ /** \name Item * \{ */ static const char *ui_item_name_add_colon(const char *name, char namestr[UI_MAX_NAME_STR]) { const int len = strlen(name); if (len != 0 && len + 1 < UI_MAX_NAME_STR) { memcpy(namestr, name, len); namestr[len] = ':'; namestr[len + 1] = '\0'; return namestr; } return name; } static int ui_item_fit( int item, int pos, int all, int available, bool is_last, int alignment, float *extra_pixel) { /* available == 0 is unlimited */ if (ELEM(0, available, all)) { return item; } if (all > available) { /* contents is bigger than available space */ if (is_last) { return available - pos; } const float width = *extra_pixel + (item * available) / (float)all; *extra_pixel = width - (int)width; return (int)width; } /* contents is smaller or equal to available space */ if (alignment == UI_LAYOUT_ALIGN_EXPAND) { if (is_last) { return available - pos; } const float width = *extra_pixel + (item * available) / (float)all; *extra_pixel = width - (int)width; return (int)width; } return item; } /* variable button size in which direction? */ #define UI_ITEM_VARY_X 1 #define UI_ITEM_VARY_Y 2 static int ui_layout_vary_direction(uiLayout *layout) { return ((ELEM(layout->root->type, UI_LAYOUT_HEADER, UI_LAYOUT_PIEMENU) || (layout->alignment != UI_LAYOUT_ALIGN_EXPAND)) ? UI_ITEM_VARY_X : UI_ITEM_VARY_Y); } static bool ui_layout_variable_size(uiLayout *layout) { /* Note that this code is probably a bit flaky, we'd probably want to know whether it's * variable in X and/or Y, etc. But for now it mimics previous one, * with addition of variable flag set for children of grid-flow layouts. */ return ui_layout_vary_direction(layout) == UI_ITEM_VARY_X || layout->variable_size; } /* estimated size of text + icon */ static int ui_text_icon_width(uiLayout *layout, const char *name, int icon, bool compact) { const int unit_x = UI_UNIT_X * (layout->scale[0] ? layout->scale[0] : 1.0f); if (icon && !name[0]) { return unit_x; /* icon only */ } if (ui_layout_variable_size(layout)) { if (!icon && !name[0]) { return unit_x; /* No icon or name. */ } if (layout->alignment != UI_LAYOUT_ALIGN_EXPAND) { layout->item.flag |= UI_ITEM_FIXED_SIZE; } const uiFontStyle *fstyle = UI_FSTYLE_WIDGET; float margin = compact ? 1.25 : 1.50; if (icon) { /* It may seem odd that the icon only adds (unit_x / 4) * but taking margins into account its fine, except * in compact mode a bit more margin is required. */ margin += compact ? 0.35 : 0.25; } return UI_fontstyle_string_width(fstyle, name) + (unit_x * margin); } return unit_x * 10; } static void ui_item_size(uiItem *item, int *r_w, int *r_h) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; if (r_w) { *r_w = BLI_rctf_size_x(&bitem->but->rect); } if (r_h) { *r_h = BLI_rctf_size_y(&bitem->but->rect); } } else { uiLayout *litem = (uiLayout *)item; if (r_w) { *r_w = litem->w; } if (r_h) { *r_h = litem->h; } } } static void ui_item_offset(uiItem *item, int *r_x, int *r_y) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; if (r_x) { *r_x = bitem->but->rect.xmin; } if (r_y) { *r_y = bitem->but->rect.ymin; } } else { if (r_x) { *r_x = 0; } if (r_y) { *r_y = 0; } } } static void ui_item_position(uiItem *item, int x, int y, int w, int h) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; bitem->but->rect.xmin = x; bitem->but->rect.ymin = y; bitem->but->rect.xmax = x + w; bitem->but->rect.ymax = y + h; ui_but_update(bitem->but); /* for strlen */ } else { uiLayout *litem = (uiLayout *)item; litem->x = x; litem->y = y + h; litem->w = w; litem->h = h; } } static void ui_item_move(uiItem *item, int delta_xmin, int delta_xmax) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; bitem->but->rect.xmin += delta_xmin; bitem->but->rect.xmax += delta_xmax; ui_but_update(bitem->but); /* for strlen */ } else { uiLayout *litem = (uiLayout *)item; if (delta_xmin > 0) { litem->x += delta_xmin; } else { litem->w += delta_xmax; } } } /** \} */ /* -------------------------------------------------------------------- */ /** \name Special RNA Items * \{ */ int uiLayoutGetLocalDir(const uiLayout *layout) { switch (layout->item.type) { case ITEM_LAYOUT_ROW: case ITEM_LAYOUT_ROOT: case ITEM_LAYOUT_OVERLAP: return UI_LAYOUT_HORIZONTAL; case ITEM_LAYOUT_COLUMN: case ITEM_LAYOUT_COLUMN_FLOW: case ITEM_LAYOUT_GRID_FLOW: case ITEM_LAYOUT_SPLIT: case ITEM_LAYOUT_ABSOLUTE: case ITEM_LAYOUT_BOX: default: return UI_LAYOUT_VERTICAL; } } static uiLayout *ui_item_local_sublayout(uiLayout *test, uiLayout *layout, bool align) { uiLayout *sub; if (uiLayoutGetLocalDir(test) == UI_LAYOUT_HORIZONTAL) { sub = uiLayoutRow(layout, align); } else { sub = uiLayoutColumn(layout, align); } sub->space = 0; return sub; } static void ui_layer_but_cb(bContext *C, void *arg_but, void *arg_index) { wmWindow *win = CTX_wm_window(C); uiBut *but = arg_but; PointerRNA *ptr = &but->rnapoin; PropertyRNA *prop = but->rnaprop; const int index = POINTER_AS_INT(arg_index); const int shift = win->eventstate->shift; const int len = RNA_property_array_length(ptr, prop); if (!shift) { RNA_property_boolean_set_index(ptr, prop, index, true); for (int i = 0; i < len; i++) { if (i != index) { RNA_property_boolean_set_index(ptr, prop, i, 0); } } RNA_property_update(C, ptr, prop); LISTBASE_FOREACH (uiBut *, cbut, &but->block->buttons) { ui_but_update(cbut); } } } /* 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), bool expand, bool slider, int toggle, bool icon_only, bool compact, bool show_text) { const uiStyle *style = layout->root->style; /* retrieve type and subtype */ const PropertyType type = RNA_property_type(prop); const PropertySubType subtype = RNA_property_subtype(prop); uiLayout *sub = ui_item_local_sublayout(layout, layout, 1); UI_block_layout_set_current(block, sub); /* create label */ if (name[0] && show_text) { uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); } /* create buttons */ if (type == PROP_BOOLEAN && ELEM(subtype, PROP_LAYER, PROP_LAYER_MEMBER)) { /* special check for layer layout */ const int cols = (len >= 20) ? 2 : 1; const int colbuts = len / (2 * cols); uint layer_used = 0; uint layer_active = 0; UI_block_layout_set_current(block, uiLayoutAbsolute(layout, false)); const int butw = UI_UNIT_X * 0.75; const int buth = UI_UNIT_X * 0.75; if (ptr->type == &RNA_Armature) { bArmature *arm = ptr->data; layer_used = arm->layer_used; if (arm->edbo) { if (arm->act_edbone) { layer_active |= arm->act_edbone->layer; } } else { if (arm->act_bone) { layer_active |= arm->act_bone->layer; } } } for (int b = 0; b < cols; b++) { UI_block_align_begin(block); for (int a = 0; a < colbuts; a++) { const int layer_num = a + b * colbuts; const uint layer_flag = (1u << layer_num); if (layer_used & layer_flag) { if (layer_active & layer_flag) { icon = ICON_LAYER_ACTIVE; } else { icon = ICON_LAYER_USED; } } else { icon = ICON_BLANK1; } uiBut *but = uiDefAutoButR( block, ptr, prop, layer_num, "", icon, x + butw * a, y + buth, butw, buth); if (subtype == PROP_LAYER_MEMBER) { UI_but_func_set(but, ui_layer_but_cb, but, POINTER_FROM_INT(layer_num)); } } for (int a = 0; a < colbuts; a++) { const int layer_num = a + len / 2 + b * colbuts; const uint layer_flag = (1u << layer_num); if (layer_used & layer_flag) { if (layer_active & layer_flag) { icon = ICON_LAYER_ACTIVE; } else { icon = ICON_LAYER_USED; } } else { icon = ICON_BLANK1; } uiBut *but = uiDefAutoButR( block, ptr, prop, layer_num, "", icon, x + butw * a, y, butw, buth); if (subtype == PROP_LAYER_MEMBER) { UI_but_func_set(but, ui_layer_but_cb, but, POINTER_FROM_INT(layer_num)); } } UI_block_align_end(block); x += colbuts * butw + style->buttonspacex; } } else if (subtype == PROP_MATRIX) { int totdim, dim_size[3]; /* 3 == RNA_MAX_ARRAY_DIMENSION */ int row, col; UI_block_layout_set_current(block, uiLayoutAbsolute(layout, true)); totdim = RNA_property_array_dimension(ptr, prop, dim_size); if (totdim != 2) { /* Only 2D matrices supported in UI so far. */ return; } w /= dim_size[0]; /* h /= dim_size[1]; */ /* UNUSED */ for (int a = 0; a < len; a++) { col = a % dim_size[0]; row = a / dim_size[0]; uiBut *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); if (slider && but->type == UI_BTYPE_NUM) { uiButNumber *number_but = (uiButNumber *)but; but->a1 = number_but->step_size; but = ui_but_change_type(but, UI_BTYPE_NUM_SLIDER); } } } else if (subtype == PROP_DIRECTION && !expand) { 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); } else { /* NOTE: this block of code is a bit arbitrary and has just been made * to work with common cases, but may need to be re-worked */ /* special case, boolean array in a menu, this could be used in a more generic way too */ if (ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA) && !expand && ELEM(len, 3, 4)) { uiDefAutoButR(block, ptr, prop, -1, "", ICON_NONE, 0, 0, w, UI_UNIT_Y); } else { /* Even if 'expand' is false, we expand anyway. */ /* layout for known array subtypes */ char str[3] = {'\0'}; if (!icon_only && show_text) { if (type != PROP_BOOLEAN) { str[1] = ':'; } } /* Show check-boxes for rna on a non-emboss block (menu for eg). */ bool *boolarr = NULL; if (type == PROP_BOOLEAN && ELEM(layout->root->block->emboss, UI_EMBOSS_NONE, UI_EMBOSS_PULLDOWN)) { boolarr = MEM_callocN(sizeof(bool) * len, __func__); RNA_property_boolean_get_array(ptr, prop, boolarr); } const char *str_buf = show_text ? str : ""; for (int a = 0; a < len; a++) { if (!icon_only && show_text) { str[0] = RNA_property_array_item_char(prop, a); } if (boolarr) { icon = boolarr[a] ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT; } const int width_item = ((compact && type == PROP_BOOLEAN) ? min_ii(w, ui_text_icon_width(layout, str_buf, icon, false)) : w); uiBut *but = uiDefAutoButR( block, ptr, prop, a, str_buf, icon, 0, 0, width_item, UI_UNIT_Y); if (slider && but->type == UI_BTYPE_NUM) { uiButNumber *number_but = (uiButNumber *)but; but->a1 = number_but->step_size; but = ui_but_change_type(but, UI_BTYPE_NUM_SLIDER); } if ((toggle == 1) && but->type == UI_BTYPE_CHECKBOX) { but->type = UI_BTYPE_TOGGLE; } if ((a == 0) && (subtype == PROP_AXISANGLE)) { UI_but_unit_type_set(but, PROP_UNIT_ROTATION); } } if (boolarr) { MEM_freeN(boolarr); } } } UI_block_layout_set_current(block, layout); } 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; const int enum_value = POINTER_AS_INT(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); } } /** * Draw a single enum button, a utility for #ui_item_enum_expand_exec */ static void ui_item_enum_expand_elem_exec(uiLayout *layout, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, const char *uiname, const int h, const eButType but_type, const bool icon_only, const EnumPropertyItem *item, const bool is_first) { const char *name = (!uiname || uiname[0]) ? item->name : ""; const int icon = item->icon; const int value = item->value; const int itemw = ui_text_icon_width(block->curlayout, icon_only ? "" : name, icon, 0); uiBut *but; if (icon && name[0] && !icon_only) { but = uiDefIconTextButR_prop( block, but_type, 0, icon, name, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL); } else if (icon) { const int w = (is_first) ? itemw : ceilf(itemw - U.pixelsize); but = uiDefIconButR_prop( block, but_type, 0, icon, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL); } else { but = uiDefButR_prop( block, but_type, 0, name, 0, 0, itemw, h, ptr, prop, -1, 0, value, -1, -1, NULL); } if (RNA_property_flag(prop) & PROP_ENUM_FLAG) { /* If this is set, assert since we're clobbering someone elses callback. */ /* Buttons get their block's func by default, so we cannot assert in that case either. */ BLI_assert(ELEM(but->func, NULL, block->func)); UI_but_func_set(but, ui_item_enum_expand_handle, but, POINTER_FROM_INT(value)); } if (uiLayoutGetLocalDir(layout) != UI_LAYOUT_HORIZONTAL) { but->drawflag |= UI_BUT_TEXT_LEFT; } /* Allow quick, inaccurate swipe motions to switch tabs * (no need to keep cursor over them). */ if (but_type == UI_BTYPE_TAB) { but->flag |= UI_BUT_DRAG_LOCK; } } static void ui_item_enum_expand_exec(uiLayout *layout, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, const char *uiname, const int h, const eButType but_type, const bool icon_only) { /* XXX: The way this function currently handles uiname parameter * is insane and inconsistent with general UI API: * * - uiname is the *enum property* label. * - when it is NULL or empty, we do not draw *enum items* labels, * this doubles the icon_only parameter. * - we *never* draw (i.e. really use) the enum label uiname, it is just used as a mere flag! * * Unfortunately, fixing this implies an API "soft break", so better to defer it for later... :/ * - mont29 */ BLI_assert(RNA_property_type(prop) == PROP_ENUM); const bool radial = (layout->root->type == UI_LAYOUT_PIEMENU); bool free; const EnumPropertyItem *item_array; if (radial) { RNA_property_enum_items_gettexted_all(block->evil_C, ptr, prop, &item_array, NULL, &free); } else { RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item_array, NULL, &free); } /* We don't want nested rows, cols in menus. */ uiLayout *layout_radial = NULL; if (radial) { if (layout->root->layout == layout) { layout_radial = uiLayoutRadial(layout); UI_block_layout_set_current(block, layout_radial); } else { if (layout->item.type == ITEM_LAYOUT_RADIAL) { layout_radial = layout; } UI_block_layout_set_current(block, layout); } } else if (ELEM(layout->item.type, ITEM_LAYOUT_GRID_FLOW, ITEM_LAYOUT_COLUMN_FLOW) || layout->root->type == UI_LAYOUT_MENU) { UI_block_layout_set_current(block, layout); } else { UI_block_layout_set_current(block, ui_item_local_sublayout(layout, layout, 1)); } for (const EnumPropertyItem *item = item_array; item->identifier; item++) { const bool is_first = item == item_array; if (!item->identifier[0]) { const EnumPropertyItem *next_item = item + 1; /* Separate items, potentially with a label. */ if (next_item->identifier) { /* Item without identifier but with name: * Add group label for the following items. */ if (item->name) { if (!is_first) { uiItemS(block->curlayout); } uiItemL(block->curlayout, item->name, item->icon); } else if (radial && layout_radial) { uiItemS(layout_radial); } else { uiItemS(block->curlayout); } } continue; } ui_item_enum_expand_elem_exec( layout, block, ptr, prop, uiname, h, but_type, icon_only, item, is_first); } UI_block_layout_set_current(block, layout); if (free) { MEM_freeN((void *)item_array); } } static void ui_item_enum_expand(uiLayout *layout, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, const char *uiname, const int h, const bool icon_only) { ui_item_enum_expand_exec(layout, block, ptr, prop, uiname, h, UI_BTYPE_ROW, icon_only); } static void ui_item_enum_expand_tabs(uiLayout *layout, bContext *C, uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *ptr_highlight, PropertyRNA *prop_highlight, const char *uiname, const int h, const bool icon_only) { uiBut *last = block->buttons.last; ui_item_enum_expand_exec(layout, block, ptr, prop, uiname, h, UI_BTYPE_TAB, icon_only); BLI_assert(last != block->buttons.last); for (uiBut *tab = last ? last->next : block->buttons.first; tab; tab = tab->next) { UI_but_drawflag_enable(tab, ui_but_align_opposite_to_area_align_get(CTX_wm_region(C))); } const bool use_custom_highlight = (prop_highlight != NULL); if (use_custom_highlight) { const int highlight_array_len = RNA_property_array_length(ptr_highlight, prop_highlight); bool *highlight_array = alloca(sizeof(bool) * highlight_array_len); RNA_property_boolean_get_array(ptr_highlight, prop_highlight, highlight_array); int i = 0; for (uiBut *tab_but = last ? last->next : block->buttons.first; (tab_but != NULL) && (i < highlight_array_len); tab_but = tab_but->next, i++) { SET_FLAG_FROM_TEST(tab_but->flag, !highlight_array[i], UI_BUT_INACTIVE); } } } /* callback for keymap item change button */ static void ui_keymap_but_cb(bContext *UNUSED(C), void *but_v, void *UNUSED(key_v)) { uiBut *but = but_v; RNA_boolean_set(&but->rnapoin, "shift", (but->modifier_key & KM_SHIFT) != 0); RNA_boolean_set(&but->rnapoin, "ctrl", (but->modifier_key & KM_CTRL) != 0); RNA_boolean_set(&but->rnapoin, "alt", (but->modifier_key & KM_ALT) != 0); RNA_boolean_set(&but->rnapoin, "oskey", (but->modifier_key & KM_OSKEY) != 0); } /** * Create label + button for RNA property * * \param w_hint: For varying width layout, this becomes the label width. * Otherwise it's used to fit both items into it. */ 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_hint, int h, int flag) { uiLayout *sub = layout; int prop_but_width = w_hint; #ifdef UI_PROP_DECORATE uiLayout *layout_prop_decorate = NULL; const bool use_prop_sep = ((layout->item.flag & UI_ITEM_PROP_SEP) != 0); const bool use_prop_decorate = use_prop_sep && (layout->item.flag & UI_ITEM_PROP_DECORATE) && (layout->item.flag & UI_ITEM_PROP_DECORATE_NO_PAD) == 0; #endif const bool is_keymapitem_ptr = RNA_struct_is_a(ptr->type, &RNA_KeyMapItem); if ((flag & UI_ITEM_R_FULL_EVENT) && !is_keymapitem_ptr) { RNA_warning("Data is not a keymap item struct: %s. Ignoring 'full_event' option.", RNA_struct_identifier(ptr->type)); } UI_block_layout_set_current(block, layout); /* Only add new row if more than 1 item will be added. */ if (name[0] #ifdef UI_PROP_DECORATE || use_prop_decorate #endif ) { /* Also avoid setting 'align' if possible. Set the space to zero instead as aligning a large * number of labels can end up aligning thousands of buttons when displaying key-map search (a * heavy operation), see: T78636. */ sub = uiLayoutRow(layout, layout->align); sub->space = 0; } if (name[0]) { #ifdef UI_PROP_DECORATE if (use_prop_sep) { layout_prop_decorate = uiItemL_respect_property_split(layout, name, 0); } else #endif { int w_label; if (ui_layout_variable_size(layout)) { /* w_hint is width for label in this case. * Use a default width for property button(s) */ prop_but_width = UI_UNIT_X * 5; w_label = w_hint; } else { w_label = w_hint / 3; } uiDefBut(block, UI_BTYPE_LABEL, 0, name, x, y, w_label, h, NULL, 0.0, 0.0, 0, 0, ""); } } const PropertyType type = RNA_property_type(prop); const PropertySubType subtype = RNA_property_subtype(prop); uiBut *but; if (ELEM(subtype, PROP_FILEPATH, PROP_DIRPATH)) { UI_block_layout_set_current(block, uiLayoutRow(sub, true)); but = uiDefAutoButR(block, ptr, prop, index, "", icon, x, y, prop_but_width - UI_UNIT_X, h); /* BUTTONS_OT_file_browse calls UI_context_active_but_prop_get_filebrowser */ uiDefIconButO(block, UI_BTYPE_BUT, subtype == PROP_DIRPATH ? "BUTTONS_OT_directory_browse" : "BUTTONS_OT_file_browse", WM_OP_INVOKE_DEFAULT, ICON_FILEBROWSER, x, y, UI_UNIT_X, h, NULL); } else if (flag & UI_ITEM_R_EVENT) { but = uiDefButR_prop(block, UI_BTYPE_KEY_EVENT, 0, name, x, y, prop_but_width, h, ptr, prop, index, 0, 0, -1, -1, NULL); } else if ((flag & UI_ITEM_R_FULL_EVENT) && is_keymapitem_ptr) { char buf[128]; WM_keymap_item_to_string(ptr->data, false, buf, sizeof(buf)); but = uiDefButR_prop(block, UI_BTYPE_HOTKEY_EVENT, 0, buf, x, y, prop_but_width, h, ptr, prop, 0, 0, 0, -1, -1, NULL); UI_but_func_set(but, ui_keymap_but_cb, but, NULL); if (flag & UI_ITEM_R_IMMEDIATE) { UI_but_flag_enable(but, UI_BUT_IMMEDIATE); } } else { const char *str = (type == PROP_ENUM && !(flag & UI_ITEM_R_ICON_ONLY)) ? NULL : ""; but = uiDefAutoButR(block, ptr, prop, index, str, icon, x, y, prop_but_width, h); } #ifdef UI_PROP_DECORATE /* Only for alignment. */ if (use_prop_decorate) { /* Note that sep flag may have been unset meanwhile. */ uiItemL(layout_prop_decorate ? layout_prop_decorate : sub, NULL, ICON_BLANK1); } #endif /* UI_PROP_DECORATE */ UI_block_layout_set_current(block, layout); return but; } void UI_context_active_but_prop_get_filebrowser(const bContext *C, PointerRNA *r_ptr, PropertyRNA **r_prop, bool *r_is_undo, bool *r_is_userdef) { ARegion *region = CTX_wm_menu(C) ? CTX_wm_menu(C) : CTX_wm_region(C); uiBut *prevbut = NULL; memset(r_ptr, 0, sizeof(*r_ptr)); *r_prop = NULL; *r_is_undo = false; *r_is_userdef = false; if (!region) { return; } LISTBASE_FOREACH (uiBlock *, block, ®ion->uiblocks) { LISTBASE_FOREACH (uiBut *, but, &block->buttons) { if (but && but->rnapoin.data) { if (RNA_property_type(but->rnaprop) == PROP_STRING) { prevbut = but; } } /* find the button before the active one */ if ((but->flag & UI_BUT_LAST_ACTIVE) && prevbut) { *r_ptr = prevbut->rnapoin; *r_prop = prevbut->rnaprop; *r_is_undo = (prevbut->flag & UI_BUT_UNDO) != 0; *r_is_userdef = UI_but_is_userdef(prevbut); return; } } } } /** \} */ /* -------------------------------------------------------------------- */ /** \name Button Items * \{ */ /** * Update a buttons tip with an enum's description if possible. */ static void ui_but_tip_from_enum_item(uiBut *but, const EnumPropertyItem *item) { if (but->tip == NULL || but->tip[0] == '\0') { if (item->description && item->description[0] && !(but->optype && but->optype->get_description)) { but->tip = item->description; } } } /* disabled item */ static void ui_item_disabled(uiLayout *layout, const char *name) { uiBlock *block = layout->root->block; UI_block_layout_set_current(block, layout); if (!name) { name = ""; } const int w = ui_text_icon_width(layout, name, 0, 0); uiBut *but = uiDefBut( block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); UI_but_disable(but, ""); } /** * Operator Item * \param r_opptr: Optional, initialize with operator properties when not NULL. * Will always be written to even in the case of errors. */ static uiBut *uiItemFullO_ptr_ex(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, IDProperty *properties, int context, int flag, PointerRNA *r_opptr) { /* Take care to fill 'r_opptr' whatever happens. */ uiBlock *block = layout->root->block; if (!name) { if (ot && ot->srna && (flag & UI_ITEM_R_ICON_ONLY) == 0) { name = WM_operatortype_name(ot, NULL); } else { name = ""; } } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } UI_block_layout_set_current(block, layout); ui_block_new_button_group(block, 0); const int w = ui_text_icon_width(layout, name, icon, 0); const eUIEmbossType prev_emboss = layout->emboss; if (flag & UI_ITEM_R_NO_BG) { layout->emboss = UI_EMBOSS_NONE_OR_STATUS; } /* create the button */ uiBut *but; if (icon) { if (name[0]) { but = uiDefIconTextButO_ptr( block, UI_BTYPE_BUT, ot, context, icon, name, 0, 0, w, UI_UNIT_Y, NULL); } else { but = uiDefIconButO_ptr(block, UI_BTYPE_BUT, ot, context, icon, 0, 0, w, UI_UNIT_Y, NULL); } } else { but = uiDefButO_ptr(block, UI_BTYPE_BUT, ot, context, name, 0, 0, w, UI_UNIT_Y, NULL); } BLI_assert(but->optype != NULL); if (flag & UI_ITEM_R_NO_BG) { layout->emboss = prev_emboss; } if (flag & UI_ITEM_O_DEPRESS) { but->flag |= UI_SELECT_DRAW; } if (flag & UI_ITEM_R_ICON_ONLY) { UI_but_drawflag_disable(but, UI_BUT_ICON_LEFT); } if (layout->redalert) { UI_but_flag_enable(but, UI_BUT_REDALERT); } if (layout->active_default) { UI_but_flag_enable(but, UI_BUT_ACTIVE_DEFAULT); } /* assign properties */ if (properties || r_opptr) { PointerRNA *opptr = UI_but_operator_ptr_get(but); if (properties) { opptr->data = properties; } else { const IDPropertyTemplate val = {0}; opptr->data = IDP_New(IDP_GROUP, &val, "wmOperatorProperties"); } if (r_opptr) { *r_opptr = *opptr; } } return but; } static void ui_item_menu_hold(struct bContext *C, ARegion *butregion, uiBut *but) { uiPopupMenu *pup = UI_popup_menu_begin(C, "", ICON_NONE); uiLayout *layout = UI_popup_menu_layout(pup); uiBlock *block = layout->root->block; UI_popup_menu_but_set(pup, butregion, but); block->flag |= UI_BLOCK_POPUP_HOLD; block->flag |= UI_BLOCK_IS_FLIP; char direction = UI_DIR_DOWN; if (!but->drawstr[0]) { switch (RGN_ALIGN_ENUM_FROM_MASK(butregion->alignment)) { case RGN_ALIGN_LEFT: direction = UI_DIR_RIGHT; break; case RGN_ALIGN_RIGHT: direction = UI_DIR_LEFT; break; case RGN_ALIGN_BOTTOM: direction = UI_DIR_UP; break; default: direction = UI_DIR_DOWN; break; } } UI_block_direction_set(block, direction); const char *menu_id = but->hold_argN; MenuType *mt = WM_menutype_find(menu_id, true); if (mt) { uiLayoutSetContextFromBut(layout, but); UI_menutype_draw(C, mt, layout); } else { uiItemL(layout, "Menu Missing:", ICON_NONE); uiItemL(layout, menu_id, ICON_NONE); } UI_popup_menu_end(C, pup); } void uiItemFullO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, IDProperty *properties, int context, int flag, PointerRNA *r_opptr) { uiItemFullO_ptr_ex(layout, ot, name, icon, properties, context, flag, r_opptr); } void uiItemFullOMenuHold_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, IDProperty *properties, int context, int flag, const char *menu_id, PointerRNA *r_opptr) { uiBut *but = uiItemFullO_ptr_ex(layout, ot, name, icon, properties, context, flag, r_opptr); UI_but_func_hold_set(but, ui_item_menu_hold, BLI_strdup(menu_id)); } void uiItemFullO(uiLayout *layout, const char *opname, const char *name, int icon, IDProperty *properties, int context, int flag, PointerRNA *r_opptr) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, { if (r_opptr) { *r_opptr = PointerRNA_NULL; } return; }); uiItemFullO_ptr(layout, ot, name, icon, properties, context, flag, r_opptr); } static const char *ui_menu_enumpropname(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int retval) { bool free; const EnumPropertyItem *item; RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free); const char *name; if (RNA_enum_name(item, retval, &name)) { name = CTX_IFACE_(RNA_property_translation_context(prop), name); } else { name = ""; } if (free) { MEM_freeN((void *)item); } return name; } void uiItemEnumO_ptr(uiLayout *layout, wmOperatorType *ot, const char *name, int icon, const char *propname, int value) { PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); PropertyRNA *prop = RNA_struct_find_property(&ptr, propname); if (prop == NULL) { RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname); return; } 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, NULL); } void uiItemEnumO(uiLayout *layout, const char *opname, const char *name, int icon, const char *propname, int value) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ if (ot) { uiItemEnumO_ptr(layout, ot, name, icon, propname, value); } else { ui_item_disabled(layout, opname); RNA_warning("unknown operator '%s'", opname); } } BLI_INLINE bool ui_layout_is_radial(const uiLayout *layout) { return (layout->item.type == ITEM_LAYOUT_RADIAL) || ((layout->item.type == ITEM_LAYOUT_ROOT) && (layout->root->type == UI_LAYOUT_PIEMENU)); } /** * Create UI items for enum items in \a item_array. * * A version of #uiItemsFullEnumO that takes pre-calculated item array. */ void uiItemsFullEnumO_items(uiLayout *layout, wmOperatorType *ot, PointerRNA ptr, PropertyRNA *prop, IDProperty *properties, int context, int flag, const EnumPropertyItem *item_array, int totitem) { const char *propname = RNA_property_identifier(prop); if (RNA_property_type(prop) != PROP_ENUM) { RNA_warning("%s.%s, not an enum type", RNA_struct_identifier(ptr.type), propname); return; } uiLayout *target, *split = NULL; uiBlock *block = layout->root->block; const bool radial = ui_layout_is_radial(layout); if (radial) { target = uiLayoutRadial(layout); } else if ((uiLayoutGetLocalDir(layout) == UI_LAYOUT_HORIZONTAL) && (flag & UI_ITEM_R_ICON_ONLY)) { target = layout; UI_block_layout_set_current(block, target); /* Add a blank button to the beginning of the row. */ uiDefIconBut(block, UI_BTYPE_LABEL, 0, ICON_BLANK1, 0, 0, 1.25f * UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL); } else { split = uiLayoutSplit(layout, 0.0f, false); target = uiLayoutColumn(split, layout->align); } bool last_iter = false; const EnumPropertyItem *item = item_array; for (int i = 1; item->identifier && !last_iter; i++, item++) { /* handle oversized pies */ if (radial && (totitem > PIE_MAX_ITEMS) && (i >= PIE_MAX_ITEMS)) { if (item->name) { /* only visible items */ const EnumPropertyItem *tmp; /* Check if there are more visible items for the next level. If not, we don't * add a new level and add the remaining item instead of the 'more' button. */ for (tmp = item + 1; tmp->identifier; tmp++) { if (tmp->name) { break; } } if (tmp->identifier) { /* only true if loop above found item and did early-exit */ ui_pie_menu_level_create( block, ot, propname, properties, item_array, totitem, context, flag); /* break since rest of items is handled in new pie level */ break; } last_iter = true; } else { continue; } } if (item->identifier[0]) { PointerRNA tptr; WM_operator_properties_create_ptr(&tptr, ot); if (properties) { if (tptr.data) { IDP_FreeProperty(tptr.data); } tptr.data = IDP_CopyProperty(properties); } RNA_property_enum_set(&tptr, prop, item->value); uiItemFullO_ptr(target, ot, (flag & UI_ITEM_R_ICON_ONLY) ? NULL : item->name, item->icon, tptr.data, context, flag, NULL); ui_but_tip_from_enum_item(block->buttons.last, item); } else { if (item->name) { if (item != item_array && !radial && split != NULL) { target = uiLayoutColumn(split, layout->align); /* inconsistent, but menus with labels do not look good flipped */ block->flag |= UI_BLOCK_NO_FLIP; } uiBut *but; if (item->icon || radial) { uiItemL(target, item->name, item->icon); but = block->buttons.last; } else { /* Do not use uiItemL here, as our root layout is a menu one, * it will add a fake blank icon! */ but = uiDefBut(block, UI_BTYPE_LABEL, 0, item->name, 0, 0, UI_UNIT_X * 5, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); uiItemS(target); } ui_but_tip_from_enum_item(but, item); } else { if (radial) { /* invisible dummy button to ensure all items are * always at the same position */ uiItemS(target); } else { /* XXX bug here, columns draw bottom item badly */ uiItemS(target); } } } } } 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 */ if (!ot || !ot->srna) { ui_item_disabled(layout, opname); RNA_warning("%s '%s'", ot ? "unknown operator" : "operator missing srna", opname); return; } PointerRNA 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); PropertyRNA *prop = RNA_struct_find_property(&ptr, propname); /* don't let bad properties slip through */ BLI_assert((prop == NULL) || (RNA_property_type(prop) == PROP_ENUM)); uiBlock *block = layout->root->block; if (prop && RNA_property_type(prop) == PROP_ENUM) { const EnumPropertyItem *item_array = NULL; int totitem; bool free; if (ui_layout_is_radial(layout)) { /* XXX: While "_all()" guarantees spatial stability, * it's bad when an enum has > 8 items total, * but only a small subset will ever be shown at once * (e.g. Mode Switch menu, after the introduction of GP editing modes). */ #if 0 RNA_property_enum_items_gettexted_all( block->evil_C, &ptr, prop, &item_array, &totitem, &free); #else RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item_array, &totitem, &free); #endif } else { RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item_array, &totitem, &free); } /* add items */ uiItemsFullEnumO_items(layout, ot, ptr, prop, properties, context, flag, item_array, totitem); if (free) { MEM_freeN((void *)item_array); } /* intentionally don't touch UI_BLOCK_IS_FLIP here, * we don't know the context this is called in */ } else if (prop && RNA_property_type(prop) != PROP_ENUM) { RNA_warning("%s.%s, not an enum type", RNA_struct_identifier(ptr.type), propname); return; } else { RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname); return; } } void uiItemsEnumO(uiLayout *layout, const char *opname, const char *propname) { uiItemsFullEnumO(layout, opname, propname, NULL, layout->root->opcontext, 0); } /* for use in cases where we have */ void uiItemEnumO_value(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); /* enum lookup */ PropertyRNA *prop = RNA_struct_find_property(&ptr, propname); if (prop == NULL) { 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); } uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0, NULL); } void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, const char *value_str) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); PropertyRNA *prop = RNA_struct_find_property(&ptr, propname); if (prop == NULL) { RNA_warning("%s.%s not found", RNA_struct_identifier(ptr.type), propname); return; } /* enum lookup */ /* no need for translations here */ const EnumPropertyItem *item; bool free; RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free); int value; if (item == NULL || RNA_enum_value_from_id(item, value_str, &value) == 0) { if (free) { MEM_freeN((void *)item); } RNA_warning("%s.%s, enum %s not found", RNA_struct_identifier(ptr.type), propname, value_str); return; } if (free) { MEM_freeN((void *)item); } RNA_property_enum_set(&ptr, prop, value); /* same as uiItemEnumO */ if (!name) { name = ui_menu_enumpropname(layout, &ptr, prop, value); } uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0, NULL); } void uiItemBooleanO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); RNA_boolean_set(&ptr, propname, value); uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0, NULL); } void uiItemIntO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, int value) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); RNA_int_set(&ptr, propname, value); uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0, NULL); } void uiItemFloatO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, float value) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); RNA_float_set(&ptr, propname, value); uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0, NULL); } void uiItemStringO(uiLayout *layout, const char *name, int icon, const char *opname, const char *propname, const char *value) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); PointerRNA ptr; WM_operator_properties_create_ptr(&ptr, ot); RNA_string_set(&ptr, propname, value); uiItemFullO_ptr(layout, ot, name, icon, ptr.data, layout->root->opcontext, 0, NULL); } void uiItemO(uiLayout *layout, const char *name, int icon, const char *opname) { uiItemFullO(layout, opname, name, icon, NULL, layout->root->opcontext, 0, NULL); } /* RNA property items */ static void ui_item_rna_size(uiLayout *layout, const char *name, int icon, PointerRNA *ptr, PropertyRNA *prop, int index, bool icon_only, bool compact, int *r_w, int *r_h) { int w = 0, h; /* arbitrary extended width by type */ const PropertyType type = RNA_property_type(prop); const PropertySubType subtype = RNA_property_subtype(prop); const int len = RNA_property_array_length(ptr, prop); bool is_checkbox_only = false; if (!name[0] && !icon_only) { if (ELEM(type, PROP_STRING, PROP_POINTER)) { name = "non-empty text"; } else if (type == PROP_BOOLEAN) { if (icon == ICON_NONE) { /* Exception for check-boxes, they need a little less space to align nicely. */ is_checkbox_only = true; } icon = ICON_DOT; } else if (type == PROP_ENUM) { /* Find the longest enum item name, instead of using a dummy text! */ const EnumPropertyItem *item_array; bool free; RNA_property_enum_items_gettexted( layout->root->block->evil_C, ptr, prop, &item_array, NULL, &free); for (const EnumPropertyItem *item = item_array; item->identifier; item++) { if (item->identifier[0]) { w = max_ii(w, ui_text_icon_width(layout, item->name, item->icon, compact)); } } if (free) { MEM_freeN((void *)item_array); } } } if (!w) { if (type == PROP_ENUM && icon_only) { w = ui_text_icon_width(layout, "", ICON_BLANK1, compact); if (index != RNA_ENUM_VALUE) { w += 0.6f * UI_UNIT_X; } } else { /* not compact for float/int buttons, looks too squashed */ w = ui_text_icon_width( layout, name, icon, ELEM(type, PROP_FLOAT, PROP_INT) ? false : compact); } } h = UI_UNIT_Y; /* increase height for arrays */ if (index == RNA_NO_INDEX && len > 0) { if (!name[0] && icon == ICON_NONE) { h = 0; } if (layout->item.flag & UI_ITEM_PROP_SEP) { h = 0; } if (ELEM(subtype, PROP_LAYER, PROP_LAYER_MEMBER)) { h += 2 * UI_UNIT_Y; } else if (subtype == PROP_MATRIX) { h += ceilf(sqrtf(len)) * UI_UNIT_Y; } else { h += len * UI_UNIT_Y; } } /* Increase width requirement if in a variable size layout. */ if (ui_layout_variable_size(layout)) { if (type == PROP_BOOLEAN && name[0]) { w += UI_UNIT_X / 5; } else if (is_checkbox_only) { w -= UI_UNIT_X / 4; } else if (type == PROP_ENUM && !icon_only) { w += UI_UNIT_X / 4; } else if (ELEM(type, PROP_FLOAT, PROP_INT)) { w += UI_UNIT_X * 3; } } *r_w = w; *r_h = h; } static bool ui_item_rna_is_expand(PropertyRNA *prop, int index, int item_flag) { const bool is_array = RNA_property_array_check(prop); const int subtype = RNA_property_subtype(prop); return is_array && (index == RNA_NO_INDEX) && ((item_flag & UI_ITEM_R_EXPAND) || !ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA, PROP_DIRECTION)); } /** * Find first layout ancestor (or self) with a heading set. * * \returns the layout to add the heading to as fallback (i.e. if it can't be placed in a split * layout). Its #uiLayout.heading member can be cleared to mark the heading as added (so * it's not added multiple times). Returns a pointer to the heading */ static uiLayout *ui_layout_heading_find(uiLayout *cur_layout) { for (uiLayout *parent = cur_layout; parent; parent = parent->parent) { if (parent->heading[0]) { return parent; } } return NULL; } static void ui_layout_heading_label_add(uiLayout *layout, uiLayout *heading_layout, bool right_align, bool respect_prop_split) { const int prev_alignment = layout->alignment; if (right_align) { uiLayoutSetAlignment(layout, UI_LAYOUT_ALIGN_RIGHT); } if (respect_prop_split) { uiItemL_respect_property_split(layout, heading_layout->heading, ICON_NONE); } else { uiItemL(layout, heading_layout->heading, ICON_NONE); } /* After adding the heading label, we have to mark it somehow as added, so it's not added again * for other items in this layout. For now just clear it. */ heading_layout->heading[0] = '\0'; layout->alignment = prev_alignment; } /** * Hack to add further items in a row into the second part of the split layout, so the label part * keeps a fixed size. * \return The layout to place further items in for the split layout. */ static uiLayout *ui_item_prop_split_layout_hack(uiLayout *layout_parent, uiLayout *layout_split) { /* Tag item as using property split layout, this is inherited to children so they can get special * treatment if needed. */ layout_parent->item.flag |= UI_ITEM_INSIDE_PROP_SEP; if (layout_parent->item.type == ITEM_LAYOUT_ROW) { /* Prevent further splits within the row. */ uiLayoutSetPropSep(layout_parent, false); layout_parent->child_items_layout = uiLayoutRow(layout_split, true); return layout_parent->child_items_layout; } return layout_split; } void uiItemFullR(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int index, int value, int flag, const char *name, int icon) { uiBlock *block = layout->root->block; char namestr[UI_MAX_NAME_STR]; const bool use_prop_sep = ((layout->item.flag & UI_ITEM_PROP_SEP) != 0); const bool inside_prop_sep = ((layout->item.flag & UI_ITEM_INSIDE_PROP_SEP) != 0); /* Columns can define a heading to insert. If the first item added to a split layout doesn't have * a label to display in the first column, the heading is inserted there. Otherwise it's inserted * as a new row before the first item. */ uiLayout *heading_layout = ui_layout_heading_find(layout); /* Although check-boxes use the split layout, they are an exception and should only place their * label in the second column, to not make that almost empty. * * Keep using 'use_prop_sep' instead of disabling it entirely because * we need the ability to have decorators still. */ bool use_prop_sep_split_label = use_prop_sep; bool use_split_empty_name = (flag & UI_ITEM_R_SPLIT_EMPTY_NAME); #ifdef UI_PROP_DECORATE struct { bool use_prop_decorate; int len; uiLayout *layout; uiBut *but; } ui_decorate = { .use_prop_decorate = (((layout->item.flag & UI_ITEM_PROP_DECORATE) != 0) && use_prop_sep), }; #endif /* UI_PROP_DECORATE */ UI_block_layout_set_current(block, layout); ui_block_new_button_group(block, 0); /* retrieve info */ const PropertyType type = RNA_property_type(prop); const bool is_array = RNA_property_array_check(prop); const int len = (is_array) ? RNA_property_array_length(ptr, prop) : 0; const bool icon_only = (flag & UI_ITEM_R_ICON_ONLY) != 0; /* Boolean with -1 to signify that the value depends on the presence of an icon. */ const int toggle = ((flag & UI_ITEM_R_TOGGLE) ? 1 : ((flag & UI_ITEM_R_ICON_NEVER) ? 0 : -1)); const bool no_icon = (toggle == 0); /* set name and icon */ if (!name) { if (!icon_only) { name = RNA_property_ui_name(prop); } else { name = ""; } } if (type != PROP_BOOLEAN) { flag &= ~UI_ITEM_R_CHECKBOX_INVERT; } if (flag & UI_ITEM_R_ICON_ONLY) { /* pass */ } else if (ELEM(type, PROP_INT, PROP_FLOAT, PROP_STRING, PROP_POINTER)) { if (use_prop_sep == false) { name = ui_item_name_add_colon(name, namestr); } } else if (type == PROP_BOOLEAN && is_array && index == RNA_NO_INDEX) { if (use_prop_sep == false) { name = ui_item_name_add_colon(name, namestr); } } else if (type == PROP_ENUM && index != RNA_ENUM_VALUE) { if (flag & UI_ITEM_R_COMPACT) { name = ""; } else { if (use_prop_sep == false) { name = ui_item_name_add_colon(name, namestr); } } } if (no_icon == false) { if (icon == ICON_NONE) { icon = RNA_property_ui_icon(prop); } /* Menus and pie-menus don't show checkbox without this. */ if ((layout->root->type == UI_LAYOUT_MENU) || /* Use check-boxes only as a fallback in pie-menu's, when no icon is defined. */ ((layout->root->type == UI_LAYOUT_PIEMENU) && (icon == ICON_NONE))) { const int prop_flag = RNA_property_flag(prop); if (type == PROP_BOOLEAN) { if ((is_array == false) || (index != RNA_NO_INDEX)) { if (prop_flag & PROP_ICONS_CONSECUTIVE) { icon = ICON_CHECKBOX_DEHLT; /* but->iconadd will set to correct icon */ } else if (is_array) { icon = (RNA_property_boolean_get_index(ptr, prop, index)) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT; } else { icon = (RNA_property_boolean_get(ptr, prop)) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT; } } } else if (type == PROP_ENUM) { if (index == RNA_ENUM_VALUE) { const int enum_value = RNA_property_enum_get(ptr, prop); if (prop_flag & PROP_ICONS_CONSECUTIVE) { icon = ICON_CHECKBOX_DEHLT; /* but->iconadd will set to correct icon */ } else if (prop_flag & PROP_ENUM_FLAG) { icon = (enum_value & value) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT; } else { icon = (enum_value == value) ? ICON_CHECKBOX_HLT : ICON_CHECKBOX_DEHLT; } } } } } #ifdef UI_PROP_SEP_ICON_WIDTH_EXCEPTION if (use_prop_sep) { if (type == PROP_BOOLEAN && (icon == ICON_NONE) && !icon_only) { use_prop_sep_split_label = false; /* For check-boxes we make an exception: We allow showing them in a split row even without * label. It typically relates to its neighbor items, so no need for an extra label. */ use_split_empty_name = true; } } #endif if ((type == PROP_ENUM) && (RNA_property_flag(prop) & PROP_ENUM_FLAG)) { flag |= UI_ITEM_R_EXPAND; } const bool slider = (flag & UI_ITEM_R_SLIDER) != 0; const bool expand = (flag & UI_ITEM_R_EXPAND) != 0; const bool no_bg = (flag & UI_ITEM_R_NO_BG) != 0; const bool compact = (flag & UI_ITEM_R_COMPACT) != 0; /* get size */ int w, h; ui_item_rna_size(layout, name, icon, ptr, prop, index, icon_only, compact, &w, &h); const eUIEmbossType prev_emboss = layout->emboss; if (no_bg) { layout->emboss = UI_EMBOSS_NONE_OR_STATUS; } uiBut *but = NULL; /* Split the label / property. */ uiLayout *layout_parent = layout; if (use_prop_sep) { uiLayout *layout_row = NULL; #ifdef UI_PROP_DECORATE if (ui_decorate.use_prop_decorate) { layout_row = uiLayoutRow(layout, true); layout_row->space = 0; ui_decorate.len = max_ii(1, len); } #endif /* UI_PROP_DECORATE */ if ((name[0] == '\0') && !use_split_empty_name) { /* Ensure we get a column when text is not set. */ layout = uiLayoutColumn(layout_row ? layout_row : layout, true); layout->space = 0; if (heading_layout) { ui_layout_heading_label_add(layout, heading_layout, false, false); } } else { uiLayout *layout_split = uiLayoutSplit( layout_row ? layout_row : layout, UI_ITEM_PROP_SEP_DIVIDE, true); bool label_added = false; uiLayout *layout_sub = uiLayoutColumn(layout_split, true); layout_sub->space = 0; if (!use_prop_sep_split_label) { /* Pass */ } else if (ui_item_rna_is_expand(prop, index, flag)) { char name_with_suffix[UI_MAX_DRAW_STR + 2]; char str[2] = {'\0'}; for (int a = 0; a < len; a++) { str[0] = RNA_property_array_item_char(prop, a); const bool use_prefix = (a == 0 && name && name[0]); if (use_prefix) { char *s = name_with_suffix; s += STRNCPY_RLEN(name_with_suffix, name); *s++ = ' '; *s++ = str[0]; *s++ = '\0'; } but = uiDefBut(block, UI_BTYPE_LABEL, 0, use_prefix ? name_with_suffix : str, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); but->drawflag |= UI_BUT_TEXT_RIGHT; but->drawflag &= ~UI_BUT_TEXT_LEFT; label_added = true; } } else { if (name) { but = uiDefBut( block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); but->drawflag |= UI_BUT_TEXT_RIGHT; but->drawflag &= ~UI_BUT_TEXT_LEFT; label_added = true; } } if (!label_added && heading_layout) { ui_layout_heading_label_add(layout_sub, heading_layout, true, false); } layout_split = ui_item_prop_split_layout_hack(layout_parent, layout_split); /* Watch out! We can only write into the new layout now. */ if ((type == PROP_ENUM) && (flag & UI_ITEM_R_EXPAND)) { /* Expanded enums each have their own name. */ /* Often expanded enum's are better arranged into a row, * so check the existing layout. */ if (uiLayoutGetLocalDir(layout) == UI_LAYOUT_HORIZONTAL) { layout = uiLayoutRow(layout_split, true); } else { layout = uiLayoutColumn(layout_split, true); } } else { if (use_prop_sep_split_label) { name = ""; } layout = uiLayoutColumn(layout_split, true); } layout->space = 0; } #ifdef UI_PROP_DECORATE if (ui_decorate.use_prop_decorate) { ui_decorate.layout = uiLayoutColumn(layout_row, true); ui_decorate.layout->space = 0; UI_block_layout_set_current(block, layout); ui_decorate.but = block->buttons.last; /* Clear after. */ layout->item.flag |= UI_ITEM_PROP_DECORATE_NO_PAD; } #endif /* UI_PROP_DECORATE */ } /* End split. */ else if (heading_layout) { /* Could not add heading to split layout, fallback to inserting it to the layout with the * heading itself. */ ui_layout_heading_label_add(heading_layout, heading_layout, false, false); } /* array property */ if (index == RNA_NO_INDEX && is_array) { if (inside_prop_sep) { /* Within a split row, add array items to a column so they match the column layout of * previous items (e.g. transform vector with lock icon for each item). */ layout = uiLayoutColumn(layout, true); } ui_item_array(layout, block, name, icon, ptr, prop, len, 0, 0, w, h, expand, slider, toggle, icon_only, compact, !use_prop_sep_split_label); } /* enum item */ else if (type == PROP_ENUM && index == RNA_ENUM_VALUE) { if (icon && name[0] && !icon_only) { uiDefIconTextButR_prop( block, UI_BTYPE_ROW, 0, icon, name, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL); } else if (icon) { uiDefIconButR_prop( block, UI_BTYPE_ROW, 0, icon, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL); } else { uiDefButR_prop( block, UI_BTYPE_ROW, 0, name, 0, 0, w, h, ptr, prop, -1, 0, value, -1, -1, NULL); } } /* expanded enum */ else if (type == PROP_ENUM && expand) { ui_item_enum_expand(layout, block, ptr, prop, name, h, icon_only); } /* property with separate label */ else if (ELEM(type, PROP_ENUM, PROP_STRING, PROP_POINTER)) { but = ui_item_with_label(layout, block, name, icon, ptr, prop, index, 0, 0, w, h, flag); but = ui_but_add_search(but, ptr, prop, NULL, NULL); if (layout->redalert) { UI_but_flag_enable(but, UI_BUT_REDALERT); } if (layout->activate_init) { UI_but_flag_enable(but, UI_BUT_ACTIVATE_ON_INIT); } } /* single button */ else { but = uiDefAutoButR(block, ptr, prop, index, name, icon, 0, 0, w, h); if (slider && but->type == UI_BTYPE_NUM) { uiButNumber *num_but = (uiButNumber *)but; but->a1 = num_but->step_size; but = ui_but_change_type(but, UI_BTYPE_NUM_SLIDER); } if (flag & UI_ITEM_R_CHECKBOX_INVERT) { if (ELEM(but->type, UI_BTYPE_CHECKBOX, UI_BTYPE_CHECKBOX_N, UI_BTYPE_ICON_TOGGLE, UI_BTYPE_ICON_TOGGLE_N)) { but->drawflag |= UI_BUT_CHECKBOX_INVERT; } } if ((toggle == 1) && but->type == UI_BTYPE_CHECKBOX) { but->type = UI_BTYPE_TOGGLE; } if (layout->redalert) { UI_but_flag_enable(but, UI_BUT_REDALERT); } if (layout->activate_init) { UI_but_flag_enable(but, UI_BUT_ACTIVATE_ON_INIT); } } /* The resulting button may have the icon set since boolean button drawing * is being 'helpful' and adding an icon for us. * In this case we want the ability not to have an icon. * * We could pass an argument not to set the icon to begin with however this is the one case * the functionality is needed. */ if (but && no_icon) { if ((icon == ICON_NONE) && (but->icon != ICON_NONE)) { ui_def_but_icon_clear(but); } } /* Mark non-embossed text-fields inside a list-box. */ if (but && (block->flag & UI_BLOCK_LIST_ITEM) && (but->type == UI_BTYPE_TEXT) && ELEM(but->emboss, UI_EMBOSS_NONE, UI_EMBOSS_NONE_OR_STATUS)) { UI_but_flag_enable(but, UI_BUT_LIST_ITEM); } #ifdef UI_PROP_DECORATE if (ui_decorate.use_prop_decorate) { uiBut *but_decorate = ui_decorate.but ? ui_decorate.but->next : block->buttons.first; const bool use_blank_decorator = (flag & UI_ITEM_R_FORCE_BLANK_DECORATE); uiLayout *layout_col = uiLayoutColumn(ui_decorate.layout, false); layout_col->space = 0; layout_col->emboss = UI_EMBOSS_NONE; int i; for (i = 0; i < ui_decorate.len && but_decorate; i++) { PointerRNA *ptr_dec = use_blank_decorator ? NULL : &but_decorate->rnapoin; PropertyRNA *prop_dec = use_blank_decorator ? NULL : but_decorate->rnaprop; /* The icons are set in 'ui_but_anim_flag' */ uiItemDecoratorR_prop(layout_col, ptr_dec, prop_dec, but_decorate->rnaindex); but = block->buttons.last; /* Order the decorator after the button we decorate, this is used so we can always * do a quick lookup. */ BLI_remlink(&block->buttons, but); BLI_insertlinkafter(&block->buttons, but_decorate, but); but_decorate = but->next; } BLI_assert(ELEM(i, 1, ui_decorate.len)); layout->item.flag &= ~UI_ITEM_PROP_DECORATE_NO_PAD; } #endif /* UI_PROP_DECORATE */ if (no_bg) { layout->emboss = prev_emboss; } /* ensure text isn't added to icon_only buttons */ if (but && icon_only) { BLI_assert(but->str[0] == '\0'); } } void uiItemR( uiLayout *layout, PointerRNA *ptr, const char *propname, int flag, const char *name, int icon) { PropertyRNA *prop = RNA_struct_find_property(ptr, propname); if (!prop) { ui_item_disabled(layout, propname); RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } uiItemFullR(layout, ptr, prop, RNA_NO_INDEX, 0, flag, name, icon); } /** * Use a wrapper function since re-implementing all the logic in this function would be messy. */ void uiItemFullR_with_popover(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int index, int value, int flag, const char *name, int icon, const char *panel_type) { uiBlock *block = layout->root->block; uiBut *but = block->buttons.last; uiItemFullR(layout, ptr, prop, index, value, flag, name, icon); but = but->next; while (but) { if (but->rnaprop == prop && ELEM(but->type, UI_BTYPE_MENU, UI_BTYPE_COLOR)) { ui_but_rna_menu_convert_to_panel_type(but, panel_type); break; } but = but->next; } if (but == NULL) { const char *propname = RNA_property_identifier(prop); ui_item_disabled(layout, panel_type); RNA_warning("property could not use a popover: %s.%s (%s)", RNA_struct_identifier(ptr->type), propname, panel_type); } } void uiItemFullR_with_menu(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int index, int value, int flag, const char *name, int icon, const char *menu_type) { uiBlock *block = layout->root->block; uiBut *but = block->buttons.last; uiItemFullR(layout, ptr, prop, index, value, flag, name, icon); but = but->next; while (but) { if (but->rnaprop == prop && but->type == UI_BTYPE_MENU) { ui_but_rna_menu_convert_to_menu_type(but, menu_type); break; } but = but->next; } if (but == NULL) { const char *propname = RNA_property_identifier(prop); ui_item_disabled(layout, menu_type); RNA_warning("property could not use a menu: %s.%s (%s)", RNA_struct_identifier(ptr->type), propname, menu_type); } } void uiItemEnumR_prop(uiLayout *layout, const char *name, int icon, struct PointerRNA *ptr, PropertyRNA *prop, int value) { if (RNA_property_type(prop) != PROP_ENUM) { const char *propname = RNA_property_identifier(prop); ui_item_disabled(layout, propname); RNA_warning("property not an enum: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, value, 0, name, icon); } void uiItemEnumR(uiLayout *layout, const char *name, int icon, struct PointerRNA *ptr, const char *propname, int value) { PropertyRNA *prop = RNA_struct_find_property(ptr, propname); if (prop == NULL) { ui_item_disabled(layout, propname); RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } uiItemFullR(layout, ptr, prop, RNA_ENUM_VALUE, value, 0, name, icon); } void uiItemEnumR_string_prop(uiLayout *layout, struct PointerRNA *ptr, PropertyRNA *prop, const char *value, const char *name, int icon) { if (UNLIKELY(RNA_property_type(prop) != PROP_ENUM)) { const char *propname = RNA_property_identifier(prop); ui_item_disabled(layout, propname); RNA_warning("not an enum property: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } const EnumPropertyItem *item; bool free; RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free); int ivalue; if (!RNA_enum_value_from_id(item, value, &ivalue)) { const char *propname = RNA_property_identifier(prop); if (free) { MEM_freeN((void *)item); } ui_item_disabled(layout, propname); RNA_warning("enum property value not found: %s", value); return; } for (int a = 0; item[a].identifier; a++) { if (item[a].identifier[0] == '\0') { /* Skip enum item separators. */ continue; } if (item[a].value == ivalue) { const char *item_name = name ? name : CTX_IFACE_(RNA_property_translation_context(prop), item[a].name); const int flag = item_name[0] ? 0 : UI_ITEM_R_ICON_ONLY; uiItemFullR( layout, ptr, prop, RNA_ENUM_VALUE, ivalue, flag, item_name, icon ? icon : item[a].icon); break; } } if (free) { MEM_freeN((void *)item); } } void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *value, const char *name, int icon) { PropertyRNA *prop = RNA_struct_find_property(ptr, propname); if (UNLIKELY(prop == NULL)) { ui_item_disabled(layout, propname); RNA_warning("enum property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } uiItemEnumR_string_prop(layout, ptr, prop, value, name, icon); } void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname) { uiBlock *block = layout->root->block; PropertyRNA *prop = RNA_struct_find_property(ptr, propname); if (!prop) { ui_item_disabled(layout, propname); RNA_warning("enum property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } if (RNA_property_type(prop) != PROP_ENUM) { RNA_warning("not an enum property: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } uiLayout *split = uiLayoutSplit(layout, 0.0f, false); uiLayout *column = uiLayoutColumn(split, false); int totitem; const EnumPropertyItem *item; bool free; RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free); for (int i = 0; i < totitem; i++) { if (item[i].identifier[0]) { uiItemEnumR_prop(column, item[i].name, item[i].icon, ptr, prop, item[i].value); ui_but_tip_from_enum_item(block->buttons.last, &item[i]); } else { if (item[i].name) { if (i != 0) { 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); uiBut *bt = block->buttons.last; bt->drawflag = UI_BUT_TEXT_LEFT; ui_but_tip_from_enum_item(bt, &item[i]); } else { uiItemS(column); } } } if (free) { MEM_freeN((void *)item); } /* intentionally don't touch UI_BLOCK_IS_FLIP here, * we don't know the context this is called in */ } /* Pointer RNA button with search */ static void search_id_collection(StructRNA *ptype, PointerRNA *r_ptr, PropertyRNA **r_prop) { /* look for collection property in Main */ /* NOTE: using global Main is OK-ish here, UI shall not access other Mains anyway. */ RNA_main_pointer_create(G_MAIN, r_ptr); *r_prop = NULL; RNA_STRUCT_BEGIN (r_ptr, iprop) { /* if it's a collection and has same pointer type, we've got it */ if (RNA_property_type(iprop) == PROP_COLLECTION) { StructRNA *srna = RNA_property_pointer_type(r_ptr, iprop); if (ptype == srna) { *r_prop = iprop; break; } } } RNA_STRUCT_END; } static void ui_rna_collection_search_arg_free_fn(void *ptr) { uiRNACollectionSearch *coll_search = ptr; UI_butstore_free(coll_search->butstore_block, coll_search->butstore); MEM_freeN(ptr); } /** * \note May reallocate \a but, so the possibly new address is returned. */ uiBut *ui_but_add_search( uiBut *but, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop) { /* for ID's we do automatic lookup */ PointerRNA sptr; if (!searchprop) { if (RNA_property_type(prop) == PROP_POINTER) { StructRNA *ptype = RNA_property_pointer_type(ptr, prop); search_id_collection(ptype, &sptr, &searchprop); searchptr = &sptr; } } /* turn button into search button */ if (searchprop) { uiRNACollectionSearch *coll_search = MEM_mallocN(sizeof(*coll_search), __func__); uiButSearch *search_but; but = ui_but_change_type(but, UI_BTYPE_SEARCH_MENU); search_but = (uiButSearch *)but; search_but->rnasearchpoin = *searchptr; search_but->rnasearchprop = searchprop; but->hardmax = MAX2(but->hardmax, 256.0f); but->drawflag |= UI_BUT_ICON_LEFT | UI_BUT_TEXT_LEFT; if (RNA_property_is_unlink(prop)) { but->flag |= UI_BUT_VALUE_CLEAR; } coll_search->target_ptr = *ptr; coll_search->target_prop = prop; coll_search->search_ptr = *searchptr; coll_search->search_prop = searchprop; coll_search->search_but = but; coll_search->butstore_block = but->block; coll_search->butstore = UI_butstore_create(coll_search->butstore_block); UI_butstore_register(coll_search->butstore, &coll_search->search_but); 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; } UI_but_func_search_set(but, ui_searchbox_create_generic, ui_rna_collection_search_update_fn, coll_search, false, ui_rna_collection_search_arg_free_fn, NULL, NULL); } else if (but->type == UI_BTYPE_SEARCH_MENU) { /* In case we fail to find proper searchprop, * so other code might have already set but->type to search menu... */ but->flag |= UI_BUT_DISABLED; } return but; } void uiItemPointerR_prop(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop, const char *name, int icon) { const bool use_prop_sep = ((layout->item.flag & UI_ITEM_PROP_SEP) != 0); ui_block_new_button_group(uiLayoutGetBlock(layout), 0); const PropertyType type = RNA_property_type(prop); if (!ELEM(type, PROP_POINTER, PROP_STRING, PROP_ENUM)) { RNA_warning("Property %s.%s must be a pointer, string or enum", RNA_struct_identifier(ptr->type), RNA_property_identifier(prop)); return; } if (RNA_property_type(searchprop) != PROP_COLLECTION) { RNA_warning("search collection property is not a collection type: %s.%s", RNA_struct_identifier(searchptr->type), RNA_property_identifier(searchprop)); return; } /* get icon & name */ if (icon == ICON_NONE) { StructRNA *icontype; if (type == PROP_POINTER) { icontype = RNA_property_pointer_type(ptr, prop); } else { icontype = RNA_property_pointer_type(searchptr, searchprop); } icon = RNA_struct_ui_icon(icontype); } if (!name) { name = RNA_property_ui_name(prop); } char namestr[UI_MAX_NAME_STR]; if (use_prop_sep == false) { name = ui_item_name_add_colon(name, namestr); } /* create button */ uiBlock *block = uiLayoutGetBlock(layout); int w, h; ui_item_rna_size(layout, name, icon, ptr, prop, 0, 0, false, &w, &h); w += UI_UNIT_X; /* X icon needs more space */ uiBut *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); } void uiItemPointerR(uiLayout *layout, PointerRNA *ptr, const char *propname, PointerRNA *searchptr, const char *searchpropname, const char *name, int icon) { /* validate arguments */ PropertyRNA *prop = RNA_struct_find_property(ptr, propname); if (!prop) { RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } PropertyRNA *searchprop = RNA_struct_find_property(searchptr, searchpropname); if (!searchprop) { RNA_warning("search collection property not found: %s.%s", RNA_struct_identifier(searchptr->type), searchpropname); return; } uiItemPointerR_prop(layout, ptr, prop, searchptr, searchprop, name, icon); } /* menu item */ void ui_item_menutype_func(bContext *C, uiLayout *layout, void *arg_mt) { MenuType *mt = (MenuType *)arg_mt; UI_menutype_draw(C, mt, layout); /* Menus are created flipped (from event handling point of view). */ layout->root->block->flag ^= UI_BLOCK_IS_FLIP; } void ui_item_paneltype_func(bContext *C, uiLayout *layout, void *arg_pt) { PanelType *pt = (PanelType *)arg_pt; UI_paneltype_draw(C, pt, layout); /* Panels are created flipped (from event handling POV). */ layout->root->block->flag ^= UI_BLOCK_IS_FLIP; } static uiBut *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; uiLayout *heading_layout = ui_layout_heading_find(layout); UI_block_layout_set_current(block, layout); ui_block_new_button_group(block, 0); if (!name) { name = ""; } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } int w = ui_text_icon_width(layout, name, icon, 1); const int h = UI_UNIT_Y; if (layout->root->type == UI_LAYOUT_HEADER) { /* Ugly! */ if (icon == ICON_NONE && force_menu) { /* pass */ } else if (force_menu) { w += 0.6f * UI_UNIT_X; } else { if (name[0]) { w -= UI_UNIT_X / 2; } } } if (heading_layout) { ui_layout_heading_label_add(layout, heading_layout, true, true); } uiBut *but; if (name[0] && icon) { but = uiDefIconTextMenuBut(block, func, arg, icon, name, 0, 0, w, h, tip); } else if (icon) { but = uiDefIconMenuBut(block, func, arg, icon, 0, 0, w, h, tip); if (force_menu && name[0]) { UI_but_drawflag_enable(but, UI_BUT_ICON_LEFT); } } else { but = uiDefMenuBut(block, func, arg, name, 0, 0, w, h, tip); } if (argN) { /* ugly! */ if (arg != argN) { but->poin = (char *)but; } but->func_argN = argN; } if (ELEM(layout->root->type, UI_LAYOUT_PANEL, UI_LAYOUT_TOOLBAR) || /* We never want a drop-down in menu! */ (force_menu && layout->root->type != UI_LAYOUT_MENU)) { UI_but_type_set_menu_from_pulldown(but); } return but; } void uiItemM_ptr(uiLayout *layout, MenuType *mt, const char *name, int icon) { uiBlock *block = layout->root->block; bContext *C = block->evil_C; if (WM_menutype_poll(C, mt) == false) { return; } if (!name) { 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, mt->description ? TIP_(mt->description) : "", false); } void uiItemM(uiLayout *layout, const char *menuname, const char *name, int icon) { MenuType *mt = WM_menutype_find(menuname, false); if (mt == NULL) { RNA_warning("not found %s", menuname); return; } uiItemM_ptr(layout, mt, name, icon); } void uiItemMContents(uiLayout *layout, const char *menuname) { MenuType *mt = WM_menutype_find(menuname, false); if (mt == NULL) { RNA_warning("not found %s", menuname); return; } uiBlock *block = layout->root->block; bContext *C = block->evil_C; if (WM_menutype_poll(C, mt) == false) { return; } UI_menutype_draw(C, mt, layout); } /** * Insert a decorator item for a button with the same property as \a prop. * To force inserting a blank dummy element, NULL can be passed for \a ptr and \a prop. */ void uiItemDecoratorR_prop(uiLayout *layout, PointerRNA *ptr, PropertyRNA *prop, int index) { uiBlock *block = layout->root->block; UI_block_layout_set_current(block, layout); uiLayout *col = uiLayoutColumn(layout, false); col->space = 0; col->emboss = UI_EMBOSS_NONE; if (ELEM(NULL, ptr, prop) || !RNA_property_animateable(ptr, prop)) { uiBut *but = uiDefIconBut(block, UI_BTYPE_DECORATOR, 0, ICON_BLANK1, 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0.0, 0.0, 0.0, 0.0, ""); but->flag |= UI_BUT_DISABLED; return; } const bool is_expand = ui_item_rna_is_expand(prop, index, 0); const bool is_array = RNA_property_array_check(prop); /* Loop for the array-case, but only do in case of an expanded array. */ for (int i = 0; i < (is_expand ? RNA_property_array_length(ptr, prop) : 1); i++) { uiButDecorator *decorator_but = (uiButDecorator *)uiDefIconBut(block, UI_BTYPE_DECORATOR, 0, ICON_DOT, 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Animate property")); UI_but_func_set(&decorator_but->but, ui_but_anim_decorate_cb, decorator_but, NULL); decorator_but->but.flag |= UI_BUT_UNDO | UI_BUT_DRAG_LOCK; /* Reusing RNA search members, setting actual RNA data has many side-effects. */ decorator_but->rnapoin = *ptr; decorator_but->rnaprop = prop; /* ui_def_but_rna() sets non-array buttons to have a RNA index of 0. */ decorator_but->rnaindex = (!is_array || is_expand) ? i : index; } } /** * Insert a decorator item for a button with the same property as \a prop. * To force inserting a blank dummy element, NULL can be passed for \a ptr and \a propname. */ void uiItemDecoratorR(uiLayout *layout, PointerRNA *ptr, const char *propname, int index) { PropertyRNA *prop = NULL; if (ptr && propname) { /* validate arguments */ prop = RNA_struct_find_property(ptr, propname); if (!prop) { ui_item_disabled(layout, propname); RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } } /* ptr and prop are allowed to be NULL here. */ uiItemDecoratorR_prop(layout, ptr, prop, index); } /* popover */ void uiItemPopoverPanel_ptr( uiLayout *layout, const bContext *C, PanelType *pt, const char *name, int icon) { if (!name) { name = CTX_IFACE_(pt->translation_context, pt->label); } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } const bool ok = (pt->poll == NULL) || pt->poll(C, pt); if (ok && (pt->draw_header != NULL)) { layout = uiLayoutRow(layout, true); Panel panel = { .type = pt, .layout = layout, .flag = PNL_POPOVER, }; pt->draw_header(C, &panel); } uiBut *but = ui_item_menu( layout, name, icon, ui_item_paneltype_func, pt, NULL, pt->description, true); but->type = UI_BTYPE_POPOVER; if (!ok) { but->flag |= UI_BUT_DISABLED; } } void uiItemPopoverPanel( uiLayout *layout, const bContext *C, const char *panel_type, const char *name, int icon) { PanelType *pt = WM_paneltype_find(panel_type, true); if (pt == NULL) { RNA_warning("Panel type not found '%s'", panel_type); return; } uiItemPopoverPanel_ptr(layout, C, pt, name, icon); } void uiItemPopoverPanelFromGroup(uiLayout *layout, bContext *C, int space_id, int region_id, const char *context, const char *category) { SpaceType *st = BKE_spacetype_from_id(space_id); if (st == NULL) { RNA_warning("space type not found %d", space_id); return; } ARegionType *art = BKE_regiontype_from_id(st, region_id); if (art == NULL) { RNA_warning("region type not found %d", region_id); return; } LISTBASE_FOREACH (PanelType *, pt, &art->paneltypes) { /* Causes too many panels, check context. */ if (pt->parent_id[0] == '\0') { if (/* (*context == '\0') || */ STREQ(pt->context, context)) { if ((*category == '\0') || STREQ(pt->category, category)) { if (pt->poll == NULL || pt->poll(C, pt)) { uiItemPopoverPanel_ptr(layout, C, pt, NULL, ICON_NONE); } } } } } } /* label item */ static uiBut *uiItemL_(uiLayout *layout, const char *name, int icon) { uiBlock *block = layout->root->block; UI_block_layout_set_current(block, layout); ui_block_new_button_group(block, 0); if (!name) { name = ""; } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } const int w = ui_text_icon_width(layout, name, icon, 0); uiBut *but; if (icon && name[0]) { but = uiDefIconTextBut( block, UI_BTYPE_LABEL, 0, icon, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, NULL); } else if (icon) { but = uiDefIconBut( block, UI_BTYPE_LABEL, 0, icon, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, NULL); } else { but = uiDefBut(block, UI_BTYPE_LABEL, 0, name, 0, 0, w, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, NULL); } /* 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->drawflag &= ~UI_BUT_TEXT_LEFT; /* default, needs to be unset */ but->drawflag |= UI_BUT_TEXT_RIGHT; } /* Mark as a label inside a list-box. */ if (block->flag & UI_BLOCK_LIST_ITEM) { but->flag |= UI_BUT_LIST_ITEM; } if (layout->redalert) { UI_but_flag_enable(but, UI_BUT_REDALERT); } return but; } void uiItemL_ex( uiLayout *layout, const char *name, int icon, const bool highlight, const bool redalert) { uiBut *but = uiItemL_(layout, name, icon); if (highlight) { /* TODO: add another flag for this. */ UI_but_flag_enable(but, UI_SELECT_DRAW); } if (redalert) { UI_but_flag_enable(but, UI_BUT_REDALERT); } } void uiItemL(uiLayout *layout, const char *name, int icon) { uiItemL_(layout, name, icon); } /** * Normally, we handle the split layout in #uiItemFullR(), but there are other cases where the * logic is needed. Ideally, #uiItemFullR() could just call this, but it currently has too many * special needs. */ uiPropertySplitWrapper uiItemPropertySplitWrapperCreate(uiLayout *parent_layout) { uiPropertySplitWrapper split_wrapper = {NULL}; uiLayout *layout_row = uiLayoutRow(parent_layout, true); uiLayout *layout_split = uiLayoutSplit(layout_row, UI_ITEM_PROP_SEP_DIVIDE, true); split_wrapper.label_column = uiLayoutColumn(layout_split, true); split_wrapper.label_column->alignment = UI_LAYOUT_ALIGN_RIGHT; split_wrapper.property_row = ui_item_prop_split_layout_hack(parent_layout, layout_split); split_wrapper.decorate_column = uiLayoutColumn(layout_row, true); return split_wrapper; } /* * Helper to add a label and creates a property split layout if needed. */ uiLayout *uiItemL_respect_property_split(uiLayout *layout, const char *text, int icon) { if (layout->item.flag & UI_ITEM_PROP_SEP) { uiBlock *block = uiLayoutGetBlock(layout); const uiPropertySplitWrapper split_wrapper = uiItemPropertySplitWrapperCreate(layout); /* Further items added to 'layout' will automatically be added to split_wrapper.property_row */ uiItemL_(split_wrapper.label_column, text, icon); UI_block_layout_set_current(block, split_wrapper.property_row); return split_wrapper.decorate_column; } char namestr[UI_MAX_NAME_STR]; if (text) { text = ui_item_name_add_colon(text, namestr); } uiItemL_(layout, text, icon); return layout; } void uiItemLDrag(uiLayout *layout, PointerRNA *ptr, const char *name, int icon) { uiBut *but = uiItemL_(layout, name, icon); if (ptr && ptr->type) { if (RNA_struct_is_ID(ptr->type)) { UI_but_drag_set_id(but, ptr->owner_id); } } } /* value item */ void uiItemV(uiLayout *layout, const char *name, int icon, int argval) { /* label */ uiBlock *block = layout->root->block; int *retvalue = (block->handle) ? &block->handle->retvalue : NULL; UI_block_layout_set_current(block, layout); if (!name) { name = ""; } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } const int w = ui_text_icon_width(layout, name, icon, 0); if (icon && name[0]) { uiDefIconTextButI(block, UI_BTYPE_BUT, argval, icon, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, ""); } else if (icon) { uiDefIconButI( block, UI_BTYPE_BUT, argval, icon, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, ""); } else { uiDefButI( block, UI_BTYPE_BUT, argval, name, 0, 0, w, UI_UNIT_Y, retvalue, 0.0, 0.0, 0, -1, ""); } } /* separator item */ void uiItemS_ex(uiLayout *layout, float factor) { uiBlock *block = layout->root->block; const bool is_menu = ui_block_is_menu(block); if (is_menu && !UI_block_can_add_separator(block)) { return; } int space = (is_menu) ? 0.45f * UI_UNIT_X : 0.3f * UI_UNIT_X; space *= factor; UI_block_layout_set_current(block, layout); uiDefBut(block, (is_menu) ? UI_BTYPE_SEPR_LINE : UI_BTYPE_SEPR, 0, "", 0, 0, space, space, NULL, 0.0, 0.0, 0, 0, ""); } /* separator item */ void uiItemS(uiLayout *layout) { uiItemS_ex(layout, 1.0f); } /* Flexible spacing. */ void uiItemSpacer(uiLayout *layout) { uiBlock *block = layout->root->block; const bool is_popup = ui_block_is_popup_any(block); if (is_popup) { printf("Error: separator_spacer() not supported in popups.\n"); return; } if (block->direction & UI_DIR_RIGHT) { printf("Error: separator_spacer() only supported in horizontal blocks.\n"); return; } UI_block_layout_set_current(block, layout); uiDefBut(block, UI_BTYPE_SEPR_SPACER, 0, "", 0, 0, 0.3f * UI_UNIT_X, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); } /* level items */ void uiItemMenuF(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *arg) { if (!func) { return; } ui_item_menu(layout, name, icon, func, arg, NULL, "", false); } /** * Version of #uiItemMenuF that free's `argN`. */ void uiItemMenuFN(uiLayout *layout, const char *name, int icon, uiMenuCreateFunc func, void *argN) { if (!func) { return; } /* Second 'argN' only ensures it gets freed. */ ui_item_menu(layout, name, icon, func, argN, argN, "", false); } typedef struct MenuItemLevel { int opcontext; /* don't use pointers to the strings because python can dynamically * allocate strings and free before the menu draws, see T27304. */ char opname[OP_MAX_TYPENAME]; char propname[MAX_IDPROP_NAME]; PointerRNA rnapoin; } MenuItemLevel; static void menu_item_enum_opname_menu(bContext *UNUSED(C), uiLayout *layout, void *arg) { uiBut *but = arg; MenuItemLevel *lvl = but->func_argN; /* Use the operator properties from the button owning the menu. */ IDProperty *op_props = but->opptr ? but->opptr->data : NULL; uiLayoutSetOperatorContext(layout, lvl->opcontext); uiItemsFullEnumO(layout, lvl->opname, lvl->propname, op_props, lvl->opcontext, 0); layout->root->block->flag |= UI_BLOCK_IS_FLIP; /* override default, needed since this was assumed pre 2.70 */ UI_block_direction_set(layout->root->block, UI_DIR_DOWN); } void uiItemMenuEnumFullO_ptr(uiLayout *layout, bContext *C, wmOperatorType *ot, const char *propname, const char *name, int icon, PointerRNA *r_opptr) { /* Caller must check */ BLI_assert(ot->srna != NULL); if (name == NULL) { name = WM_operatortype_name(ot, NULL); } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } MenuItemLevel *lvl = MEM_callocN(sizeof(MenuItemLevel), "MenuItemLevel"); BLI_strncpy(lvl->opname, ot->idname, sizeof(lvl->opname)); BLI_strncpy(lvl->propname, propname, sizeof(lvl->propname)); lvl->opcontext = layout->root->opcontext; uiBut *but = ui_item_menu(layout, name, icon, menu_item_enum_opname_menu, NULL, lvl, NULL, true); /* Use the menu button as owner for the operator properties, which will then be passed to the * individual menu items. */ if (r_opptr) { but->opptr = MEM_callocN(sizeof(PointerRNA), "uiButOpPtr"); WM_operator_properties_create_ptr(but->opptr, ot); BLI_assert(but->opptr->data == NULL); WM_operator_properties_alloc(&but->opptr, (IDProperty **)&but->opptr->data, ot->idname); *r_opptr = *but->opptr; } /* add hotkey here, lower UI code can't detect it */ if ((layout->root->block->flag & UI_BLOCK_LOOP) && (ot->prop && ot->invoke)) { char keybuf[128]; if (WM_key_event_operator_string( C, ot->idname, layout->root->opcontext, NULL, false, keybuf, sizeof(keybuf))) { ui_but_add_shortcut(but, keybuf, false); } } } void uiItemMenuEnumFullO(uiLayout *layout, bContext *C, const char *opname, const char *propname, const char *name, int icon, PointerRNA *r_opptr) { wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */ UI_OPERATOR_ERROR_RET(ot, opname, return ); if (!ot->srna) { ui_item_disabled(layout, opname); RNA_warning("operator missing srna '%s'", opname); return; } uiItemMenuEnumFullO_ptr(layout, C, ot, propname, name, icon, r_opptr); } void uiItemMenuEnumO(uiLayout *layout, bContext *C, const char *opname, const char *propname, const char *name, int icon) { uiItemMenuEnumFullO(layout, C, opname, propname, name, icon, NULL); } static void menu_item_enum_rna_menu(bContext *UNUSED(C), uiLayout *layout, void *arg) { MenuItemLevel *lvl = (MenuItemLevel *)(((uiBut *)arg)->func_argN); uiLayoutSetOperatorContext(layout, lvl->opcontext); uiItemsEnumR(layout, &lvl->rnapoin, lvl->propname); layout->root->block->flag |= UI_BLOCK_IS_FLIP; } void uiItemMenuEnumR_prop( uiLayout *layout, struct PointerRNA *ptr, PropertyRNA *prop, const char *name, int icon) { if (!name) { name = RNA_property_ui_name(prop); } if (layout->root->type == UI_LAYOUT_MENU && !icon) { icon = ICON_BLANK1; } MenuItemLevel *lvl = MEM_callocN(sizeof(MenuItemLevel), "MenuItemLevel"); lvl->rnapoin = *ptr; BLI_strncpy(lvl->propname, RNA_property_identifier(prop), 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), false); } void uiItemMenuEnumR( uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *name, int icon) { PropertyRNA *prop = RNA_struct_find_property(ptr, propname); if (!prop) { ui_item_disabled(layout, propname); RNA_warning("property not found: %s.%s", RNA_struct_identifier(ptr->type), propname); return; } uiItemMenuEnumR_prop(layout, ptr, prop, name, icon); } void uiItemTabsEnumR_prop(uiLayout *layout, bContext *C, PointerRNA *ptr, PropertyRNA *prop, PointerRNA *ptr_highlight, PropertyRNA *prop_highlight, bool icon_only) { uiBlock *block = layout->root->block; UI_block_layout_set_current(block, layout); ui_item_enum_expand_tabs( layout, C, block, ptr, prop, ptr_highlight, prop_highlight, NULL, UI_UNIT_Y, icon_only); } /** \} */ /* -------------------------------------------------------------------- */ /** \name Layout Items * \{ */ /* single-row layout */ static void ui_litem_estimate_row(uiLayout *litem) { int itemw, itemh; bool min_size_flag = true; litem->w = 0; litem->h = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); min_size_flag = min_size_flag && (item->flag & UI_ITEM_FIXED_SIZE); litem->w += itemw; litem->h = MAX2(itemh, litem->h); if (item->next) { litem->w += litem->space; } } if (min_size_flag) { litem->item.flag |= UI_ITEM_FIXED_SIZE; } } static int ui_litem_min_width(int itemw) { return MIN2(2 * UI_UNIT_X, itemw); } static void ui_litem_layout_row(uiLayout *litem) { uiItem *last_free_item = NULL; int x, neww, newtotw, itemw, minw, itemh, offset; int freew, fixedx, freex, flag = 0, lastw = 0; float extra_pixel; /* x = litem->x; */ /* UNUSED */ const int y = litem->y; int w = litem->w; int totw = 0; int tot = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); totw += itemw; tot++; } if (totw == 0) { return; } if (w != 0) { w -= (tot - 1) * litem->space; } int fixedw = 0; /* keep clamping items to fixed minimum size until all are done */ do { freew = 0; x = 0; flag = 0; newtotw = totw; extra_pixel = 0.0f; LISTBASE_FOREACH (uiItem *, item, &litem->items) { if (item->flag & UI_ITEM_AUTO_FIXED_SIZE) { continue; } ui_item_size(item, &itemw, &itemh); minw = ui_litem_min_width(itemw); if (w - lastw > 0) { neww = ui_item_fit(itemw, x, totw, w - lastw, !item->next, litem->alignment, &extra_pixel); } else { neww = 0; /* no space left, all will need clamping to minimum size */ } x += neww; bool min_flag = item->flag & UI_ITEM_FIXED_SIZE; /* ignore min flag for rows with right or center alignment */ if (item->type != ITEM_BUTTON && ELEM(((uiLayout *)item)->alignment, UI_LAYOUT_ALIGN_RIGHT, UI_LAYOUT_ALIGN_CENTER) && litem->alignment == UI_LAYOUT_ALIGN_EXPAND && ((uiItem *)litem)->flag & UI_ITEM_FIXED_SIZE) { min_flag = false; } if ((neww < minw || min_flag) && w != 0) { /* fixed size */ item->flag |= UI_ITEM_AUTO_FIXED_SIZE; if (item->type != ITEM_BUTTON && item->flag & UI_ITEM_FIXED_SIZE) { minw = itemw; } fixedw += minw; flag = 1; newtotw -= itemw; } else { /* keep free size */ item->flag &= ~UI_ITEM_AUTO_FIXED_SIZE; freew += itemw; } } totw = newtotw; lastw = fixedw; } while (flag); freex = 0; fixedx = 0; extra_pixel = 0.0f; x = litem->x; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); minw = ui_litem_min_width(itemw); if (item->flag & UI_ITEM_AUTO_FIXED_SIZE) { /* fixed minimum size items */ if (item->type != ITEM_BUTTON && item->flag & UI_ITEM_FIXED_SIZE) { minw = itemw; } itemw = ui_item_fit( minw, fixedx, fixedw, min_ii(w, fixedw), !item->next, litem->alignment, &extra_pixel); fixedx += itemw; } else { /* free size item */ itemw = ui_item_fit( itemw, freex, freew, w - fixedw, !item->next, litem->alignment, &extra_pixel); freex += itemw; last_free_item = item; } /* align right/center */ offset = 0; if (litem->alignment == UI_LAYOUT_ALIGN_RIGHT) { if (freew + fixedw > 0 && freew + fixedw < w) { offset = w - (fixedw + freew); } } else if (litem->alignment == UI_LAYOUT_ALIGN_CENTER) { if (freew + fixedw > 0 && freew + fixedw < w) { offset = (w - (fixedw + freew)) / 2; } } /* position item */ ui_item_position(item, x + offset, y - itemh, itemw, itemh); x += itemw; if (item->next) { x += litem->space; } } /* add extra pixel */ uiItem *last_item = litem->items.last; extra_pixel = litem->w - (x - litem->x); if (extra_pixel > 0 && litem->alignment == UI_LAYOUT_ALIGN_EXPAND && last_free_item && last_item && last_item->flag & UI_ITEM_AUTO_FIXED_SIZE) { ui_item_move(last_free_item, 0, extra_pixel); for (uiItem *item = last_free_item->next; item; item = item->next) { ui_item_move(item, extra_pixel, extra_pixel); } } litem->w = x - litem->x; litem->h = litem->y - y; litem->x = x; litem->y = y; } /* single-column layout */ static void ui_litem_estimate_column(uiLayout *litem, bool is_box) { int itemw, itemh; bool min_size_flag = true; litem->w = 0; litem->h = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); min_size_flag = min_size_flag && (item->flag & UI_ITEM_FIXED_SIZE); litem->w = MAX2(litem->w, itemw); litem->h += itemh; if (item->next && (!is_box || item != litem->items.first)) { litem->h += litem->space; } } if (min_size_flag) { litem->item.flag |= UI_ITEM_FIXED_SIZE; } } static void ui_litem_layout_column(uiLayout *litem, bool is_box, bool is_menu) { const int x = litem->x; int y = litem->y; LISTBASE_FOREACH (uiItem *, item, &litem->items) { int itemw, itemh; ui_item_size(item, &itemw, &itemh); y -= itemh; ui_item_position(item, x, y, is_menu ? itemw : litem->w, itemh); if (item->next && (!is_box || item != litem->items.first)) { y -= litem->space; } if (is_box) { item->flag |= UI_ITEM_BOX_ITEM; } } litem->h = litem->y - y; litem->x = x; litem->y = y; } /* calculates the angle of a specified button in a radial menu, * stores a float vector in unit circle */ static RadialDirection ui_get_radialbut_vec(float vec[2], short itemnum) { if (itemnum >= PIE_MAX_ITEMS) { itemnum %= PIE_MAX_ITEMS; printf("Warning: Pie menus with more than %i items are currently unsupported\n", PIE_MAX_ITEMS); } const RadialDirection dir = ui_radial_dir_order[itemnum]; ui_but_pie_dir(dir, vec); return dir; } static bool ui_item_is_radial_displayable(uiItem *item) { if ((item->type == ITEM_BUTTON) && (((uiButtonItem *)item)->but->type == UI_BTYPE_LABEL)) { return false; } return true; } static bool ui_item_is_radial_drawable(uiButtonItem *bitem) { if (ELEM(bitem->but->type, UI_BTYPE_SEPR, UI_BTYPE_SEPR_LINE, UI_BTYPE_SEPR_SPACER)) { return false; } return true; } static void ui_litem_layout_radial(uiLayout *litem) { int itemh, itemw; int itemnum = 0; int totitems = 0; /* For the radial layout we will use Matt Ebb's design * for radiation, see http://mattebb.com/weblog/radiation/ * also the old code at http://developer.blender.org/T5103 */ const int pie_radius = U.pie_menu_radius * UI_DPI_FAC; const int x = litem->x; const int y = litem->y; int minx = x, miny = y, maxx = x, maxy = y; /* first count total items */ LISTBASE_FOREACH (uiItem *, item, &litem->items) { totitems++; } if (totitems < 5) { litem->root->block->pie_data.flags |= UI_PIE_DEGREES_RANGE_LARGE; } LISTBASE_FOREACH (uiItem *, item, &litem->items) { /* not all button types are drawn in a radial menu, do filtering here */ if (ui_item_is_radial_displayable(item)) { RadialDirection dir; float vec[2]; float factor[2]; dir = ui_get_radialbut_vec(vec, itemnum); factor[0] = (vec[0] > 0.01f) ? 0.0f : ((vec[0] < -0.01f) ? -1.0f : -0.5f); factor[1] = (vec[1] > 0.99f) ? 0.0f : ((vec[1] < -0.99f) ? -1.0f : -0.5f); itemnum++; if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; bitem->but->pie_dir = dir; /* scale the buttons */ bitem->but->rect.ymax *= 1.5f; /* add a little bit more here to include number */ bitem->but->rect.xmax += 1.5f * UI_UNIT_X; /* enable drawing as pie item if supported by widget */ if (ui_item_is_radial_drawable(bitem)) { bitem->but->emboss = UI_EMBOSS_RADIAL; bitem->but->drawflag |= UI_BUT_ICON_LEFT; } } ui_item_size(item, &itemw, &itemh); ui_item_position(item, x + vec[0] * pie_radius + factor[0] * itemw, y + vec[1] * pie_radius + factor[1] * itemh, itemw, itemh); minx = min_ii(minx, x + vec[0] * pie_radius - itemw / 2); maxx = max_ii(maxx, x + vec[0] * pie_radius + itemw / 2); miny = min_ii(miny, y + vec[1] * pie_radius - itemh / 2); maxy = max_ii(maxy, y + vec[1] * pie_radius + itemh / 2); } } litem->x = minx; litem->y = miny; litem->w = maxx - minx; litem->h = maxy - miny; } /* root layout */ static void ui_litem_estimate_root(uiLayout *UNUSED(litem)) { /* nothing to do */ } static void ui_litem_layout_root_radial(uiLayout *litem) { /* first item is pie menu title, align on center of menu */ uiItem *item = litem->items.first; if (item->type == ITEM_BUTTON) { int itemh, itemw, x, y; x = litem->x; y = litem->y; ui_item_size(item, &itemw, &itemh); ui_item_position( item, x - itemw / 2, y + U.dpi_fac * (U.pie_menu_threshold + 9.0f), itemw, itemh); } } static void ui_litem_layout_root(uiLayout *litem) { if (litem->root->type == UI_LAYOUT_HEADER) { ui_litem_layout_row(litem); } else if (litem->root->type == UI_LAYOUT_PIEMENU) { ui_litem_layout_root_radial(litem); } else if (litem->root->type == UI_LAYOUT_MENU) { ui_litem_layout_column(litem, false, true); } else { ui_litem_layout_column(litem, false, false); } } /* box layout */ static void ui_litem_estimate_box(uiLayout *litem) { const uiStyle *style = litem->root->style; ui_litem_estimate_column(litem, true); int boxspace = style->boxspace; if (litem->root->type == UI_LAYOUT_HEADER) { boxspace = 0; } litem->w += 2 * boxspace; litem->h += 2 * boxspace; } static void ui_litem_layout_box(uiLayout *litem) { uiLayoutItemBx *box = (uiLayoutItemBx *)litem; const uiStyle *style = litem->root->style; int boxspace = style->boxspace; if (litem->root->type == UI_LAYOUT_HEADER) { boxspace = 0; } const int w = litem->w; const int h = litem->h; litem->x += boxspace; litem->y -= boxspace; if (w != 0) { litem->w -= 2 * boxspace; } if (h != 0) { litem->h -= 2 * boxspace; } ui_litem_layout_column(litem, true, false); litem->x -= boxspace; litem->y -= boxspace; if (w != 0) { litem->w += 2 * boxspace; } if (h != 0) { litem->h += 2 * boxspace; } /* roundbox around the sublayout */ uiBut *but = box->roundbox; but->rect.xmin = litem->x; but->rect.ymin = litem->y; but->rect.xmax = litem->x + litem->w; but->rect.ymax = litem->y + litem->h; } /* multi-column layout, automatically flowing to the next */ static void ui_litem_estimate_column_flow(uiLayout *litem) { const uiStyle *style = litem->root->style; uiLayoutItemFlow *flow = (uiLayoutItemFlow *)litem; int itemw, itemh, maxw = 0; /* compute max needed width and total height */ int toth = 0; int totitem = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); maxw = MAX2(maxw, itemw); toth += itemh; totitem++; } if (flow->number <= 0) { /* auto compute number of columns, not very good */ if (maxw == 0) { flow->totcol = 1; return; } flow->totcol = max_ii(litem->root->emw / maxw, 1); flow->totcol = min_ii(flow->totcol, totitem); } else { flow->totcol = flow->number; } /* compute sizes */ int x = 0; int y = 0; int emy = 0; int miny = 0; maxw = 0; const int emh = toth / flow->totcol; /* create column per column */ int col = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); y -= itemh + style->buttonspacey; miny = min_ii(miny, y); emy -= itemh; maxw = max_ii(itemw, maxw); /* decide to go to next one */ if (col < flow->totcol - 1 && emy <= -emh) { x += maxw + litem->space; maxw = 0; y = 0; emy = 0; /* need to reset height again for next column */ col++; } } litem->w = x; litem->h = litem->y - miny; } static void ui_litem_layout_column_flow(uiLayout *litem) { const uiStyle *style = litem->root->style; uiLayoutItemFlow *flow = (uiLayoutItemFlow *)litem; int col, emh, itemw, itemh; /* compute max needed width and total height */ int toth = 0; int totitem = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); toth += itemh; totitem++; } /* compute sizes */ int x = litem->x; int y = litem->y; int emy = 0; int miny = 0; emh = toth / flow->totcol; /* create column per column */ col = 0; int w = (litem->w - (flow->totcol - 1) * style->columnspace) / flow->totcol; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_size(item, &itemw, &itemh); itemw = (litem->alignment == UI_LAYOUT_ALIGN_EXPAND) ? w : min_ii(w, itemw); y -= itemh; emy -= itemh; ui_item_position(item, x, y, itemw, itemh); y -= style->buttonspacey; miny = min_ii(miny, y); /* decide to go to next one */ if (col < flow->totcol - 1 && emy <= -emh) { x += w + style->columnspace; y = litem->y; emy = 0; /* need to reset height again for next column */ col++; const int remaining_width = litem->w - (x - litem->x); const int remaining_width_between_columns = (flow->totcol - col - 1) * style->columnspace; const int remaining_columns = flow->totcol - col; w = (remaining_width - remaining_width_between_columns) / remaining_columns; } } litem->h = litem->y - miny; litem->x = x; litem->y = miny; } /* multi-column and multi-row layout. */ typedef struct UILayoutGridFlowInput { /* General layout control settings. */ const bool row_major : 1; /* Fill rows before columns */ const bool even_columns : 1; /* All columns will have same width. */ const bool even_rows : 1; /* All rows will have same height. */ const int space_x; /* Space between columns. */ const int space_y; /* Space between rows. */ /* Real data about current position and size of this layout item * (either estimated, or final values). */ const int litem_w; /* Layout item width. */ const int litem_x; /* Layout item X position. */ const int litem_y; /* Layout item Y position. */ /* Actual number of columns and rows to generate (computed from first pass usually). */ const int tot_columns; /* Number of columns. */ const int tot_rows; /* Number of rows. */ } UILayoutGridFlowInput; typedef struct UILayoutGridFlowOutput { int *tot_items; /* Total number of items in this grid layout. */ /* Width / X pos data. */ float *global_avg_w; /* Computed average width of the columns. */ int *cos_x_array; /* Computed X coordinate of each column. */ int *widths_array; /* Computed width of each column. */ int *tot_w; /* Computed total width. */ /* Height / Y pos data. */ int *global_max_h; /* Computed height of the tallest item in the grid. */ int *cos_y_array; /* Computed Y coordinate of each column. */ int *heights_array; /* Computed height of each column. */ int *tot_h; /* Computed total height. */ } UILayoutGridFlowOutput; static void ui_litem_grid_flow_compute(ListBase *items, UILayoutGridFlowInput *parameters, UILayoutGridFlowOutput *results) { float tot_w = 0.0f, tot_h = 0.0f; float global_avg_w = 0.0f, global_totweight_w = 0.0f; int global_max_h = 0; float *avg_w = NULL, *totweight_w = NULL; int *max_h = NULL; BLI_assert( parameters->tot_columns != 0 || (results->cos_x_array == NULL && results->widths_array == NULL && results->tot_w == NULL)); BLI_assert( parameters->tot_rows != 0 || (results->cos_y_array == NULL && results->heights_array == NULL && results->tot_h == NULL)); if (results->tot_items) { *results->tot_items = 0; } if (items->first == NULL) { if (results->global_avg_w) { *results->global_avg_w = 0.0f; } if (results->global_max_h) { *results->global_max_h = 0; } return; } if (parameters->tot_columns != 0) { avg_w = BLI_array_alloca(avg_w, parameters->tot_columns); totweight_w = BLI_array_alloca(totweight_w, parameters->tot_columns); memset(avg_w, 0, sizeof(*avg_w) * parameters->tot_columns); memset(totweight_w, 0, sizeof(*totweight_w) * parameters->tot_columns); } if (parameters->tot_rows != 0) { max_h = BLI_array_alloca(max_h, parameters->tot_rows); memset(max_h, 0, sizeof(*max_h) * parameters->tot_rows); } int i = 0; LISTBASE_FOREACH (uiItem *, item, items) { int item_w, item_h; ui_item_size(item, &item_w, &item_h); global_avg_w += (float)(item_w * item_w); global_totweight_w += (float)item_w; global_max_h = max_ii(global_max_h, item_h); if (parameters->tot_rows != 0 && parameters->tot_columns != 0) { const int index_col = parameters->row_major ? i % parameters->tot_columns : i / parameters->tot_rows; const int index_row = parameters->row_major ? i / parameters->tot_columns : i % parameters->tot_rows; avg_w[index_col] += (float)(item_w * item_w); totweight_w[index_col] += (float)item_w; max_h[index_row] = max_ii(max_h[index_row], item_h); } if (results->tot_items) { (*results->tot_items)++; } i++; } /* Finalize computing of column average sizes */ global_avg_w /= global_totweight_w; if (parameters->tot_columns != 0) { for (i = 0; i < parameters->tot_columns; i++) { avg_w[i] /= totweight_w[i]; tot_w += avg_w[i]; } if (parameters->even_columns) { tot_w = ceilf(global_avg_w) * parameters->tot_columns; } } /* Finalize computing of rows max sizes */ if (parameters->tot_rows != 0) { for (i = 0; i < parameters->tot_rows; i++) { tot_h += max_h[i]; } if (parameters->even_rows) { tot_h = global_max_h * parameters->tot_columns; } } /* Compute positions and sizes of all cells. */ if (results->cos_x_array != NULL && results->widths_array != NULL) { /* We enlarge/narrow columns evenly to match available width. */ const float wfac = (float)(parameters->litem_w - (parameters->tot_columns - 1) * parameters->space_x) / tot_w; for (int col = 0; col < parameters->tot_columns; col++) { results->cos_x_array[col] = (col ? results->cos_x_array[col - 1] + results->widths_array[col - 1] + parameters->space_x : parameters->litem_x); if (parameters->even_columns) { /* (< remaining width > - < space between remaining columns >) / < remaining columns > */ results->widths_array[col] = (((parameters->litem_w - (results->cos_x_array[col] - parameters->litem_x)) - (parameters->tot_columns - col - 1) * parameters->space_x) / (parameters->tot_columns - col)); } else if (col == parameters->tot_columns - 1) { /* Last column copes width rounding errors... */ results->widths_array[col] = parameters->litem_w - (results->cos_x_array[col] - parameters->litem_x); } else { results->widths_array[col] = (int)(avg_w[col] * wfac); } } } if (results->cos_y_array != NULL && results->heights_array != NULL) { for (int row = 0; row < parameters->tot_rows; row++) { if (parameters->even_rows) { results->heights_array[row] = global_max_h; } else { results->heights_array[row] = max_h[row]; } results->cos_y_array[row] = (row ? results->cos_y_array[row - 1] - parameters->space_y - results->heights_array[row] : parameters->litem_y - results->heights_array[row]); } } if (results->global_avg_w) { *results->global_avg_w = global_avg_w; } if (results->global_max_h) { *results->global_max_h = global_max_h; } if (results->tot_w) { *results->tot_w = (int)tot_w + parameters->space_x * (parameters->tot_columns - 1); } if (results->tot_h) { *results->tot_h = tot_h + parameters->space_y * (parameters->tot_rows - 1); } } static void ui_litem_estimate_grid_flow(uiLayout *litem) { const uiStyle *style = litem->root->style; uiLayoutItemGridFlow *gflow = (uiLayoutItemGridFlow *)litem; const int space_x = style->columnspace; const int space_y = style->buttonspacey; /* Estimate average needed width and height per item. */ { float avg_w; int max_h; ui_litem_grid_flow_compute(&litem->items, &((UILayoutGridFlowInput){ .row_major = gflow->row_major, .even_columns = gflow->even_columns, .even_rows = gflow->even_rows, .litem_w = litem->w, .litem_x = litem->x, .litem_y = litem->y, .space_x = space_x, .space_y = space_y, }), &((UILayoutGridFlowOutput){ .tot_items = &gflow->tot_items, .global_avg_w = &avg_w, .global_max_h = &max_h, })); if (gflow->tot_items == 0) { litem->w = litem->h = 0; gflow->tot_columns = gflow->tot_rows = 0; return; } /* Even in varying column width case, * we fix our columns number from weighted average width of items, * a proper solving of required width would be too costly, * and this should give reasonably good results in all reasonable cases. */ if (gflow->columns_len > 0) { gflow->tot_columns = gflow->columns_len; } else { if (avg_w == 0.0f) { gflow->tot_columns = 1; } else { gflow->tot_columns = min_ii(max_ii((int)(litem->w / avg_w), 1), gflow->tot_items); } } gflow->tot_rows = (int)ceilf((float)gflow->tot_items / gflow->tot_columns); /* Try to tweak number of columns and rows to get better filling of last column or row, * and apply 'modulo' value to number of columns or rows. * Note that modulo does not prevent ending with fewer columns/rows than modulo, if mandatory * to avoid empty column/row. */ { const int modulo = (gflow->columns_len < -1) ? -gflow->columns_len : 0; const int step = modulo ? modulo : 1; if (gflow->row_major) { /* Adjust number of columns to be multiple of given modulo. */ if (modulo && gflow->tot_columns % modulo != 0 && gflow->tot_columns > modulo) { gflow->tot_columns = gflow->tot_columns - (gflow->tot_columns % modulo); } /* Find smallest number of columns conserving computed optimal number of rows. */ for (gflow->tot_rows = (int)ceilf((float)gflow->tot_items / gflow->tot_columns); (gflow->tot_columns - step) > 0 && (int)ceilf((float)gflow->tot_items / (gflow->tot_columns - step)) <= gflow->tot_rows; gflow->tot_columns -= step) { /* pass */ } } else { /* Adjust number of rows to be multiple of given modulo. */ if (modulo && gflow->tot_rows % modulo != 0) { gflow->tot_rows = min_ii(gflow->tot_rows + modulo - (gflow->tot_rows % modulo), gflow->tot_items); } /* Find smallest number of rows conserving computed optimal number of columns. */ for (gflow->tot_columns = (int)ceilf((float)gflow->tot_items / gflow->tot_rows); (gflow->tot_rows - step) > 0 && (int)ceilf((float)gflow->tot_items / (gflow->tot_rows - step)) <= gflow->tot_columns; gflow->tot_rows -= step) { /* pass */ } } } /* Set evenly-spaced axes size * (quick optimization in case we have even columns and rows). */ if (gflow->even_columns && gflow->even_rows) { litem->w = (int)(gflow->tot_columns * avg_w) + space_x * (gflow->tot_columns - 1); litem->h = (int)(gflow->tot_rows * max_h) + space_y * (gflow->tot_rows - 1); return; } } /* Now that we have our final number of columns and rows, * we can compute actual needed space for non-evenly sized axes. */ { int tot_w, tot_h; ui_litem_grid_flow_compute(&litem->items, &((UILayoutGridFlowInput){ .row_major = gflow->row_major, .even_columns = gflow->even_columns, .even_rows = gflow->even_rows, .litem_w = litem->w, .litem_x = litem->x, .litem_y = litem->y, .space_x = space_x, .space_y = space_y, .tot_columns = gflow->tot_columns, .tot_rows = gflow->tot_rows, }), &((UILayoutGridFlowOutput){ .tot_w = &tot_w, .tot_h = &tot_h, })); litem->w = tot_w; litem->h = tot_h; } } static void ui_litem_layout_grid_flow(uiLayout *litem) { const uiStyle *style = litem->root->style; uiLayoutItemGridFlow *gflow = (uiLayoutItemGridFlow *)litem; if (gflow->tot_items == 0) { litem->w = litem->h = 0; return; } BLI_assert(gflow->tot_columns > 0); BLI_assert(gflow->tot_rows > 0); const int space_x = style->columnspace; const int space_y = style->buttonspacey; int *widths = BLI_array_alloca(widths, gflow->tot_columns); int *heights = BLI_array_alloca(heights, gflow->tot_rows); int *cos_x = BLI_array_alloca(cos_x, gflow->tot_columns); int *cos_y = BLI_array_alloca(cos_y, gflow->tot_rows); /* This time we directly compute coordinates and sizes of all cells. */ ui_litem_grid_flow_compute(&litem->items, &((UILayoutGridFlowInput){ .row_major = gflow->row_major, .even_columns = gflow->even_columns, .even_rows = gflow->even_rows, .litem_w = litem->w, .litem_x = litem->x, .litem_y = litem->y, .space_x = space_x, .space_y = space_y, .tot_columns = gflow->tot_columns, .tot_rows = gflow->tot_rows, }), &((UILayoutGridFlowOutput){ .cos_x_array = cos_x, .cos_y_array = cos_y, .widths_array = widths, .heights_array = heights, })); int i; LISTBASE_FOREACH_INDEX (uiItem *, item, &litem->items, i) { const int col = gflow->row_major ? i % gflow->tot_columns : i / gflow->tot_rows; const int row = gflow->row_major ? i / gflow->tot_columns : i % gflow->tot_rows; int item_w, item_h; ui_item_size(item, &item_w, &item_h); const int w = widths[col]; const int h = heights[row]; item_w = (litem->alignment == UI_LAYOUT_ALIGN_EXPAND) ? w : min_ii(w, item_w); item_h = (litem->alignment == UI_LAYOUT_ALIGN_EXPAND) ? h : min_ii(h, item_h); ui_item_position(item, cos_x[col], cos_y[row], item_w, item_h); } litem->h = litem->y - cos_y[gflow->tot_rows - 1]; litem->x = (cos_x[gflow->tot_columns - 1] - litem->x) + widths[gflow->tot_columns - 1]; litem->y = litem->y - litem->h; } /* free layout */ static void ui_litem_estimate_absolute(uiLayout *litem) { int minx = 1e6; int miny = 1e6; litem->w = 0; litem->h = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { int itemx, itemy, itemw, itemh; ui_item_offset(item, &itemx, &itemy); ui_item_size(item, &itemw, &itemh); minx = min_ii(minx, itemx); miny = min_ii(miny, itemy); litem->w = MAX2(litem->w, itemx + itemw); litem->h = MAX2(litem->h, itemy + itemh); } litem->w -= minx; litem->h -= miny; } static void ui_litem_layout_absolute(uiLayout *litem) { float scalex = 1.0f, scaley = 1.0f; int x, y, newx, newy, itemx, itemy, itemh, itemw; int minx = 1e6; int miny = 1e6; int totw = 0; int toth = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_offset(item, &itemx, &itemy); ui_item_size(item, &itemw, &itemh); minx = min_ii(minx, itemx); miny = min_ii(miny, itemy); totw = max_ii(totw, itemx + itemw); toth = max_ii(toth, itemy + itemh); } totw -= minx; toth -= miny; if (litem->w && totw > 0) { scalex = (float)litem->w / (float)totw; } if (litem->h && toth > 0) { scaley = (float)litem->h / (float)toth; } x = litem->x; y = litem->y - scaley * toth; LISTBASE_FOREACH (uiItem *, item, &litem->items) { ui_item_offset(item, &itemx, &itemy); ui_item_size(item, &itemw, &itemh); if (scalex != 1.0f) { newx = (itemx - minx) * scalex; itemw = (itemx - minx + itemw) * scalex - newx; itemx = minx + newx; } if (scaley != 1.0f) { newy = (itemy - miny) * scaley; itemh = (itemy - miny + itemh) * scaley - newy; itemy = miny + newy; } ui_item_position(item, x + itemx - minx, y + itemy - miny, itemw, itemh); } litem->w = scalex * totw; litem->h = litem->y - y; litem->x = x + litem->w; litem->y = y; } /* split layout */ static void ui_litem_estimate_split(uiLayout *litem) { ui_litem_estimate_row(litem); litem->item.flag &= ~UI_ITEM_FIXED_SIZE; } static void ui_litem_layout_split(uiLayout *litem) { uiLayoutItemSplit *split = (uiLayoutItemSplit *)litem; float extra_pixel = 0.0f; const int tot = BLI_listbase_count(&litem->items); if (tot == 0) { return; } int x = litem->x; const int y = litem->y; const float percentage = (split->percentage == 0.0f) ? 1.0f / (float)tot : split->percentage; const int w = (litem->w - (tot - 1) * litem->space); int colw = w * percentage; colw = MAX2(colw, 0); LISTBASE_FOREACH (uiItem *, item, &litem->items) { int itemh; ui_item_size(item, NULL, &itemh); ui_item_position(item, x, y - itemh, colw, itemh); x += colw; if (item->next) { const float width = extra_pixel + (w - (int)(w * percentage)) / ((float)tot - 1); extra_pixel = width - (int)width; colw = (int)width; colw = MAX2(colw, 0); x += litem->space; } } litem->w = x - litem->x; litem->h = litem->y - y; litem->x = x; litem->y = y; } /* overlap layout */ static void ui_litem_estimate_overlap(uiLayout *litem) { litem->w = 0; litem->h = 0; LISTBASE_FOREACH (uiItem *, item, &litem->items) { int itemw, itemh; ui_item_size(item, &itemw, &itemh); litem->w = MAX2(itemw, litem->w); litem->h = MAX2(itemh, litem->h); } } static void ui_litem_layout_overlap(uiLayout *litem) { const int x = litem->x; const int y = litem->y; LISTBASE_FOREACH (uiItem *, item, &litem->items) { int itemw, itemh; ui_item_size(item, &itemw, &itemh); ui_item_position(item, x, y - itemh, litem->w, itemh); litem->h = MAX2(litem->h, itemh); } litem->x = x; litem->y = y - litem->h; } static void ui_litem_init_from_parent(uiLayout *litem, uiLayout *layout, int align) { litem->root = layout->root; litem->align = align; /* Children of grid-flow layout shall never have "ideal big size" returned as estimated size. */ litem->variable_size = layout->variable_size || layout->item.type == ITEM_LAYOUT_GRID_FLOW; litem->active = true; litem->enabled = true; litem->context = layout->context; litem->redalert = layout->redalert; litem->w = layout->w; litem->emboss = layout->emboss; litem->item.flag = (layout->item.flag & (UI_ITEM_PROP_SEP | UI_ITEM_PROP_DECORATE | UI_ITEM_INSIDE_PROP_SEP)); if (layout->child_items_layout) { BLI_addtail(&layout->child_items_layout->items, litem); litem->parent = layout->child_items_layout; } else { BLI_addtail(&layout->items, litem); litem->parent = layout; } } static void ui_layout_heading_set(uiLayout *layout, const char *heading) { BLI_assert(layout->heading[0] == '\0'); if (heading) { STRNCPY(layout->heading, heading); } } /* layout create functions */ uiLayout *uiLayoutRow(uiLayout *layout, bool align) { uiLayout *litem = MEM_callocN(sizeof(uiLayout), "uiLayoutRow"); ui_litem_init_from_parent(litem, layout, align); litem->item.type = ITEM_LAYOUT_ROW; litem->space = (align) ? 0 : layout->root->style->buttonspacex; UI_block_layout_set_current(layout->root->block, litem); return litem; } /** * See #uiLayoutColumnWithHeading(). */ uiLayout *uiLayoutRowWithHeading(uiLayout *layout, bool align, const char *heading) { uiLayout *litem = uiLayoutRow(layout, align); ui_layout_heading_set(litem, heading); return litem; } uiLayout *uiLayoutColumn(uiLayout *layout, bool align) { uiLayout *litem = MEM_callocN(sizeof(uiLayout), "uiLayoutColumn"); ui_litem_init_from_parent(litem, layout, align); litem->item.type = ITEM_LAYOUT_COLUMN; litem->space = (align) ? 0 : layout->root->style->buttonspacey; UI_block_layout_set_current(layout->root->block, litem); return litem; } /** * Variant of #uiLayoutColumn() that sets a heading label for the layout if the first item is * added through #uiItemFullR(). If split layout is used and the item has no string to add to the * first split-column, the heading is added there instead. Otherwise the heading inserted with a * new row. */ uiLayout *uiLayoutColumnWithHeading(uiLayout *layout, bool align, const char *heading) { uiLayout *litem = uiLayoutColumn(layout, align); ui_layout_heading_set(litem, heading); return litem; } uiLayout *uiLayoutColumnFlow(uiLayout *layout, int number, bool align) { uiLayoutItemFlow *flow = MEM_callocN(sizeof(uiLayoutItemFlow), "uiLayoutItemFlow"); ui_litem_init_from_parent(&flow->litem, layout, align); flow->litem.item.type = ITEM_LAYOUT_COLUMN_FLOW; flow->litem.space = (flow->litem.align) ? 0 : layout->root->style->columnspace; flow->number = number; UI_block_layout_set_current(layout->root->block, &flow->litem); return &flow->litem; } uiLayout *uiLayoutGridFlow(uiLayout *layout, bool row_major, int columns_len, bool even_columns, bool even_rows, bool align) { uiLayoutItemGridFlow *flow = MEM_callocN(sizeof(uiLayoutItemGridFlow), __func__); flow->litem.item.type = ITEM_LAYOUT_GRID_FLOW; ui_litem_init_from_parent(&flow->litem, layout, align); flow->litem.space = (flow->litem.align) ? 0 : layout->root->style->columnspace; flow->row_major = row_major; flow->columns_len = columns_len; flow->even_columns = even_columns; flow->even_rows = even_rows; UI_block_layout_set_current(layout->root->block, &flow->litem); return &flow->litem; } static uiLayoutItemBx *ui_layout_box(uiLayout *layout, int type) { uiLayoutItemBx *box = MEM_callocN(sizeof(uiLayoutItemBx), "uiLayoutItemBx"); ui_litem_init_from_parent(&box->litem, layout, false); box->litem.item.type = ITEM_LAYOUT_BOX; box->litem.space = layout->root->style->columnspace; UI_block_layout_set_current(layout->root->block, &box->litem); box->roundbox = uiDefBut(layout->root->block, type, 0, "", 0, 0, 0, 0, NULL, 0.0, 0.0, 0, 0, ""); return box; } uiLayout *uiLayoutRadial(uiLayout *layout) { /* radial layouts are only valid for radial menus */ if (layout->root->type != UI_LAYOUT_PIEMENU) { return ui_item_local_sublayout(layout, layout, 0); } /* only one radial wheel per root layout is allowed, so check and return that, if it exists */ LISTBASE_FOREACH (uiItem *, item, &layout->root->layout->items) { uiLayout *litem = (uiLayout *)item; if (litem->item.type == ITEM_LAYOUT_RADIAL) { UI_block_layout_set_current(layout->root->block, litem); return litem; } } uiLayout *litem = MEM_callocN(sizeof(uiLayout), "uiLayoutRadial"); ui_litem_init_from_parent(litem, layout, false); litem->item.type = ITEM_LAYOUT_RADIAL; UI_block_layout_set_current(layout->root->block, litem); return litem; } uiLayout *uiLayoutBox(uiLayout *layout) { return (uiLayout *)ui_layout_box(layout, UI_BTYPE_ROUNDBOX); } /** * Check all buttons defined in this layout, * and set any button flagged as UI_BUT_LIST_ITEM as active/selected. * Needed to handle correctly text colors of active (selected) list item. */ void ui_layout_list_set_labels_active(uiLayout *layout) { LISTBASE_FOREACH (uiButtonItem *, bitem, &layout->items) { if (bitem->item.type != ITEM_BUTTON) { ui_layout_list_set_labels_active((uiLayout *)(&bitem->item)); } else if (bitem->but->flag & UI_BUT_LIST_ITEM) { UI_but_flag_enable(bitem->but, UI_SELECT); } } } uiLayout *uiLayoutListBox(uiLayout *layout, uiList *ui_list, PointerRNA *actptr, PropertyRNA *actprop) { uiLayoutItemBx *box = ui_layout_box(layout, UI_BTYPE_LISTBOX); uiBut *but = box->roundbox; but->custom_data = ui_list; but->rnapoin = *actptr; but->rnaprop = actprop; /* only for the undo string */ if (but->flag & UI_BUT_UNDO) { but->tip = RNA_property_description(actprop); } return (uiLayout *)box; } uiLayout *uiLayoutAbsolute(uiLayout *layout, bool align) { uiLayout *litem = MEM_callocN(sizeof(uiLayout), "uiLayoutAbsolute"); ui_litem_init_from_parent(litem, layout, align); litem->item.type = ITEM_LAYOUT_ABSOLUTE; UI_block_layout_set_current(layout->root->block, litem); return litem; } uiBlock *uiLayoutAbsoluteBlock(uiLayout *layout) { uiBlock *block = uiLayoutGetBlock(layout); uiLayoutAbsolute(layout, false); return block; } uiLayout *uiLayoutOverlap(uiLayout *layout) { uiLayout *litem = MEM_callocN(sizeof(uiLayout), "uiLayoutOverlap"); ui_litem_init_from_parent(litem, layout, false); litem->item.type = ITEM_LAYOUT_OVERLAP; UI_block_layout_set_current(layout->root->block, litem); return litem; } uiLayout *uiLayoutSplit(uiLayout *layout, float percentage, bool align) { uiLayoutItemSplit *split = MEM_callocN(sizeof(uiLayoutItemSplit), "uiLayoutItemSplit"); ui_litem_init_from_parent(&split->litem, layout, align); split->litem.item.type = ITEM_LAYOUT_SPLIT; split->litem.space = layout->root->style->columnspace; split->percentage = percentage; UI_block_layout_set_current(layout->root->block, &split->litem); return &split->litem; } void uiLayoutSetActive(uiLayout *layout, bool active) { layout->active = active; } void uiLayoutSetActiveDefault(uiLayout *layout, bool active_default) { layout->active_default = active_default; } void uiLayoutSetActivateInit(uiLayout *layout, bool activate_init) { layout->activate_init = activate_init; } void uiLayoutSetEnabled(uiLayout *layout, bool enabled) { layout->enabled = enabled; } void uiLayoutSetRedAlert(uiLayout *layout, bool redalert) { layout->redalert = redalert; } void uiLayoutSetKeepAspect(uiLayout *layout, bool keepaspect) { layout->keepaspect = keepaspect; } void uiLayoutSetAlignment(uiLayout *layout, char alignment) { layout->alignment = alignment; } void uiLayoutSetScaleX(uiLayout *layout, float scale) { layout->scale[0] = scale; } void uiLayoutSetScaleY(uiLayout *layout, float scale) { layout->scale[1] = scale; } void uiLayoutSetUnitsX(uiLayout *layout, float unit) { layout->units[0] = unit; } void uiLayoutSetUnitsY(uiLayout *layout, float unit) { layout->units[1] = unit; } void uiLayoutSetEmboss(uiLayout *layout, eUIEmbossType emboss) { layout->emboss = emboss; } bool uiLayoutGetPropSep(uiLayout *layout) { return (layout->item.flag & UI_ITEM_PROP_SEP) != 0; } void uiLayoutSetPropSep(uiLayout *layout, bool is_sep) { SET_FLAG_FROM_TEST(layout->item.flag, is_sep, UI_ITEM_PROP_SEP); } bool uiLayoutGetPropDecorate(uiLayout *layout) { return (layout->item.flag & UI_ITEM_PROP_DECORATE) != 0; } void uiLayoutSetPropDecorate(uiLayout *layout, bool is_sep) { SET_FLAG_FROM_TEST(layout->item.flag, is_sep, UI_ITEM_PROP_DECORATE); } bool uiLayoutGetActive(uiLayout *layout) { return layout->active; } bool uiLayoutGetActiveDefault(uiLayout *layout) { return layout->active_default; } bool uiLayoutGetActivateInit(uiLayout *layout) { return layout->activate_init; } bool uiLayoutGetEnabled(uiLayout *layout) { return layout->enabled; } bool uiLayoutGetRedAlert(uiLayout *layout) { return layout->redalert; } bool uiLayoutGetKeepAspect(uiLayout *layout) { return layout->keepaspect; } int uiLayoutGetAlignment(uiLayout *layout) { return layout->alignment; } int uiLayoutGetWidth(uiLayout *layout) { return layout->w; } float uiLayoutGetScaleX(uiLayout *layout) { return layout->scale[0]; } float uiLayoutGetScaleY(uiLayout *layout) { return layout->scale[1]; } float uiLayoutGetUnitsX(uiLayout *layout) { return layout->units[0]; } float uiLayoutGetUnitsY(uiLayout *layout) { return layout->units[1]; } eUIEmbossType uiLayoutGetEmboss(uiLayout *layout) { if (layout->emboss == UI_EMBOSS_UNDEFINED) { return layout->root->block->emboss; } return layout->emboss; } /** \} */ /* -------------------------------------------------------------------- */ /** \name Block Layout Search Filtering * \{ */ /* Disabled for performance reasons, but this could be turned on in the future. */ // #define PROPERTY_SEARCH_USE_TOOLTIPS static bool block_search_panel_label_matches(const uiBlock *block, const char *search_string) { if ((block->panel != NULL) && (block->panel->type != NULL)) { if (BLI_strcasestr(block->panel->type->label, search_string)) { return true; } } return false; } /** * Returns true if a button or the data / operator it represents matches the search filter. */ static bool button_matches_search_filter(uiBut *but, const char *search_filter) { /* Do the shorter checks first for better performance in case there is a match. */ if (BLI_strcasestr(but->str, search_filter)) { return true; } if (but->optype != NULL) { if (BLI_strcasestr(but->optype->name, search_filter)) { return true; } } if (but->rnaprop != NULL) { if (BLI_strcasestr(RNA_property_ui_name(but->rnaprop), search_filter)) { return true; } #ifdef PROPERTY_SEARCH_USE_TOOLTIPS if (BLI_strcasestr(RNA_property_description(but->rnaprop), search_filter)) { return true; } #endif /* Search through labels of enum property items if they are in a drop-down menu. * Unfortunately we have no #bContext here so we cannot search through RNA enums * with dynamic entries (or "itemf" functions) which require context. */ if (but->type == UI_BTYPE_MENU) { PointerRNA *ptr = &but->rnapoin; PropertyRNA *enum_prop = but->rnaprop; int items_len; const EnumPropertyItem *items_array = NULL; bool free; RNA_property_enum_items_gettexted(NULL, ptr, enum_prop, &items_array, &items_len, &free); if (items_array == NULL) { return false; } for (int i = 0; i < items_len; i++) { /* Check for NULL name field which enums use for separators. */ if (items_array[i].name == NULL) { continue; } if (BLI_strcasestr(items_array[i].name, search_filter)) { return true; } } if (free) { MEM_freeN((EnumPropertyItem *)items_array); } } } return false; } /** * Test for a search result within a specific button group. */ static bool button_group_has_search_match(uiButtonGroup *button_group, const char *search_filter) { LISTBASE_FOREACH (LinkData *, link, &button_group->buttons) { uiBut *but = link->data; if (button_matches_search_filter(but, search_filter)) { return true; } } return false; } /** * Apply the search filter, tagging all buttons with whether they match or not. * Tag every button in the group as a result if any button in the group matches. * * \note It would be great to return early here if we found a match, but because * the results may be visible we have to continue searching the entire block. * * \return True if the block has any search results. */ static bool block_search_filter_tag_buttons(uiBlock *block, const char *search_filter) { bool has_result = false; LISTBASE_FOREACH (uiButtonGroup *, button_group, &block->button_groups) { if (button_group_has_search_match(button_group, search_filter)) { has_result = true; } else { LISTBASE_FOREACH (LinkData *, link, &button_group->buttons) { uiBut *but = link->data; but->flag |= UI_SEARCH_FILTER_NO_MATCH; } } } return has_result; } /** * Apply property search behavior, setting panel flags and deactivating buttons that don't match. * * \note Must not be run after #UI_block_layout_resolve. */ bool UI_block_apply_search_filter(uiBlock *block, const char *search_filter) { if (search_filter == NULL || search_filter[0] == '\0') { return false; } Panel *panel = block->panel; if (panel != NULL && panel->type->flag & PANEL_TYPE_NO_SEARCH) { /* Panels for active blocks should always have a type, otherwise they wouldn't be created. */ BLI_assert(block->panel->type != NULL); if (panel->type->flag & PANEL_TYPE_NO_SEARCH) { return false; } } const bool panel_label_matches = block_search_panel_label_matches(block, search_filter); const bool has_result = (panel_label_matches) ? true : block_search_filter_tag_buttons(block, search_filter); if (panel != NULL) { if (has_result) { ui_panel_tag_search_filter_match(block->panel); } } return has_result; } /** \} */ /* -------------------------------------------------------------------- */ /** \name Layout * \{ */ static void ui_item_scale(uiLayout *litem, const float scale[2]) { int x, y, w, h; LISTBASE_FOREACH_BACKWARD (uiItem *, item, &litem->items) { if (item->type != ITEM_BUTTON) { uiLayout *subitem = (uiLayout *)item; ui_item_scale(subitem, scale); } ui_item_size(item, &w, &h); ui_item_offset(item, &x, &y); if (scale[0] != 0.0f) { x *= scale[0]; w *= scale[0]; } if (scale[1] != 0.0f) { y *= scale[1]; h *= scale[1]; } ui_item_position(item, x, y, w, h); } } static void ui_item_estimate(uiItem *item) { if (item->type != ITEM_BUTTON) { uiLayout *litem = (uiLayout *)item; LISTBASE_FOREACH (uiItem *, subitem, &litem->items) { ui_item_estimate(subitem); } if (BLI_listbase_is_empty(&litem->items)) { litem->w = 0; litem->h = 0; return; } if (litem->scale[0] != 0.0f || litem->scale[1] != 0.0f) { ui_item_scale(litem, litem->scale); } switch (litem->item.type) { case ITEM_LAYOUT_COLUMN: ui_litem_estimate_column(litem, false); break; case ITEM_LAYOUT_COLUMN_FLOW: ui_litem_estimate_column_flow(litem); break; case ITEM_LAYOUT_GRID_FLOW: ui_litem_estimate_grid_flow(litem); break; case ITEM_LAYOUT_ROW: ui_litem_estimate_row(litem); break; case ITEM_LAYOUT_BOX: ui_litem_estimate_box(litem); break; case ITEM_LAYOUT_ROOT: ui_litem_estimate_root(litem); break; case ITEM_LAYOUT_ABSOLUTE: ui_litem_estimate_absolute(litem); break; case ITEM_LAYOUT_SPLIT: ui_litem_estimate_split(litem); break; case ITEM_LAYOUT_OVERLAP: ui_litem_estimate_overlap(litem); break; default: break; } /* Force fixed size. */ if (litem->units[0] > 0) { litem->w = UI_UNIT_X * litem->units[0]; } if (litem->units[1] > 0) { litem->h = UI_UNIT_Y * litem->units[1]; } } } static void ui_item_align(uiLayout *litem, short nr) { LISTBASE_FOREACH_BACKWARD (uiItem *, item, &litem->items) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; #ifndef USE_UIBUT_SPATIAL_ALIGN if (ui_but_can_align(bitem->but)) #endif { if (!bitem->but->alignnr) { bitem->but->alignnr = nr; } } } else if (item->type == ITEM_LAYOUT_ABSOLUTE) { /* pass */ } else if (item->type == ITEM_LAYOUT_OVERLAP) { /* pass */ } else if (item->type == ITEM_LAYOUT_BOX) { uiLayoutItemBx *box = (uiLayoutItemBx *)item; if (!box->roundbox->alignnr) { box->roundbox->alignnr = nr; } } else if (((uiLayout *)item)->align) { ui_item_align((uiLayout *)item, nr); } } } static void ui_item_flag(uiLayout *litem, int flag) { LISTBASE_FOREACH_BACKWARD (uiItem *, item, &litem->items) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; bitem->but->flag |= flag; } else { ui_item_flag((uiLayout *)item, flag); } } } static void ui_item_layout(uiItem *item) { if (item->type != ITEM_BUTTON) { uiLayout *litem = (uiLayout *)item; if (BLI_listbase_is_empty(&litem->items)) { return; } if (litem->align) { ui_item_align(litem, ++litem->root->block->alignnr); } if (!litem->active) { ui_item_flag(litem, UI_BUT_INACTIVE); } if (!litem->enabled) { ui_item_flag(litem, UI_BUT_DISABLED); } switch (litem->item.type) { case ITEM_LAYOUT_COLUMN: ui_litem_layout_column(litem, false, false); break; case ITEM_LAYOUT_COLUMN_FLOW: ui_litem_layout_column_flow(litem); break; case ITEM_LAYOUT_GRID_FLOW: ui_litem_layout_grid_flow(litem); break; case ITEM_LAYOUT_ROW: ui_litem_layout_row(litem); break; case ITEM_LAYOUT_BOX: ui_litem_layout_box(litem); break; case ITEM_LAYOUT_ROOT: ui_litem_layout_root(litem); break; case ITEM_LAYOUT_ABSOLUTE: ui_litem_layout_absolute(litem); break; case ITEM_LAYOUT_SPLIT: ui_litem_layout_split(litem); break; case ITEM_LAYOUT_OVERLAP: ui_litem_layout_overlap(litem); break; case ITEM_LAYOUT_RADIAL: ui_litem_layout_radial(litem); break; default: break; } LISTBASE_FOREACH (uiItem *, subitem, &litem->items) { if (item->flag & UI_ITEM_BOX_ITEM) { subitem->flag |= UI_ITEM_BOX_ITEM; } ui_item_layout(subitem); } } else { if (item->flag & UI_ITEM_BOX_ITEM) { uiButtonItem *bitem = (uiButtonItem *)item; bitem->but->drawflag |= UI_BUT_BOX_ITEM; } } } static void ui_layout_end(uiBlock *block, uiLayout *layout, int *r_x, int *r_y) { if (layout->root->handlefunc) { UI_block_func_handle_set(block, layout->root->handlefunc, layout->root->argv); } ui_item_estimate(&layout->item); ui_item_layout(&layout->item); if (r_x) { *r_x = layout->x; } if (r_y) { *r_y = layout->y; } } static void ui_layout_free(uiLayout *layout) { LISTBASE_FOREACH_MUTABLE (uiItem *, item, &layout->items) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; bitem->but->layout = NULL; MEM_freeN(item); } else { ui_layout_free((uiLayout *)item); } } MEM_freeN(layout); } static void ui_layout_add_padding_button(uiLayoutRoot *root) { if (root->padding) { /* add an invisible button for padding */ uiBlock *block = root->block; uiLayout *prev_layout = block->curlayout; block->curlayout = root->layout; uiDefBut( block, UI_BTYPE_SEPR, 0, "", 0, 0, root->padding, root->padding, NULL, 0.0, 0.0, 0, 0, ""); block->curlayout = prev_layout; } } uiLayout *UI_block_layout(uiBlock *block, int dir, int type, int x, int y, int size, int em, int padding, const uiStyle *style) { uiLayoutRoot *root = MEM_callocN(sizeof(uiLayoutRoot), "uiLayoutRoot"); root->type = type; root->style = style; root->block = block; root->padding = padding; root->opcontext = WM_OP_INVOKE_REGION_WIN; uiLayout *layout = MEM_callocN(sizeof(uiLayout), "uiLayout"); layout->item.type = (type == UI_LAYOUT_VERT_BAR) ? ITEM_LAYOUT_COLUMN : ITEM_LAYOUT_ROOT; /* Only used when 'UI_ITEM_PROP_SEP' is set. */ layout->item.flag = UI_ITEM_PROP_DECORATE; layout->x = x; layout->y = y; layout->root = root; layout->space = style->templatespace; layout->active = true; layout->enabled = true; layout->context = NULL; layout->emboss = UI_EMBOSS_UNDEFINED; if (ELEM(type, UI_LAYOUT_MENU, UI_LAYOUT_PIEMENU)) { layout->space = 0; } if (dir == UI_LAYOUT_HORIZONTAL) { layout->h = size; layout->root->emh = em * UI_UNIT_Y; } else { layout->w = size; layout->root->emw = em * UI_UNIT_X; } block->curlayout = layout; root->layout = layout; BLI_addtail(&block->layouts, root); ui_layout_add_padding_button(root); return layout; } uiBlock *uiLayoutGetBlock(uiLayout *layout) { return layout->root->block; } int uiLayoutGetOperatorContext(uiLayout *layout) { return layout->root->opcontext; } void UI_block_layout_set_current(uiBlock *block, uiLayout *layout) { block->curlayout = layout; } void ui_layout_add_but(uiLayout *layout, uiBut *but) { uiButtonItem *bitem = MEM_callocN(sizeof(uiButtonItem), "uiButtonItem"); bitem->item.type = ITEM_BUTTON; bitem->but = but; int w, h; ui_item_size((uiItem *)bitem, &w, &h); /* XXX uiBut hasn't scaled yet * we can flag the button as not expandable, depending on its size */ if (w <= 2 * UI_UNIT_X && (!but->str || but->str[0] == '\0')) { bitem->item.flag |= UI_ITEM_FIXED_SIZE; } if (layout->child_items_layout) { BLI_addtail(&layout->child_items_layout->items, bitem); } else { BLI_addtail(&layout->items, bitem); } but->layout = layout; if (layout->context) { but->context = layout->context; but->context->used = true; } if (layout->emboss != UI_EMBOSS_UNDEFINED) { but->emboss = layout->emboss; } ui_button_group_add_but(uiLayoutGetBlock(layout), but); } bool ui_layout_replace_but_ptr(uiLayout *layout, const void *old_but_ptr, uiBut *new_but) { ListBase *child_list = layout->child_items_layout ? &layout->child_items_layout->items : &layout->items; LISTBASE_FOREACH (uiItem *, item, child_list) { if (item->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)item; if (bitem->but == old_but_ptr) { bitem->but = new_but; return true; } } else { if (ui_layout_replace_but_ptr((uiLayout *)item, old_but_ptr, new_but)) { return true; } } } return false; } void uiLayoutSetFixedSize(uiLayout *layout, bool fixed_size) { if (fixed_size) { layout->item.flag |= UI_ITEM_FIXED_SIZE; } else { layout->item.flag &= ~UI_ITEM_FIXED_SIZE; } } bool uiLayoutGetFixedSize(uiLayout *layout) { return (layout->item.flag & UI_ITEM_FIXED_SIZE) != 0; } void uiLayoutSetOperatorContext(uiLayout *layout, int opcontext) { layout->root->opcontext = opcontext; } void uiLayoutSetFunc(uiLayout *layout, uiMenuHandleFunc handlefunc, void *argv) { layout->root->handlefunc = handlefunc; layout->root->argv = argv; } /** * Used for property search when the layout process needs to be cancelled in order to avoid * computing the locations for buttons, but the layout items created while adding the buttons * must still be freed. */ void UI_block_layout_free(uiBlock *block) { LISTBASE_FOREACH_MUTABLE (uiLayoutRoot *, root, &block->layouts) { ui_layout_free(root->layout); MEM_freeN(root); } } void UI_block_layout_resolve(uiBlock *block, int *r_x, int *r_y) { BLI_assert(block->active); if (r_x) { *r_x = 0; } if (r_y) { *r_y = 0; } block->curlayout = NULL; LISTBASE_FOREACH_MUTABLE (uiLayoutRoot *, root, &block->layouts) { ui_layout_add_padding_button(root); /* NULL in advance so we don't interfere when adding button */ ui_layout_end(block, root->layout, r_x, r_y); ui_layout_free(root->layout); MEM_freeN(root); } BLI_listbase_clear(&block->layouts); /* XXX silly trick, interface_templates.c doesn't get linked * because it's not used by other files in this module? */ { UI_template_fix_linking(); } } void uiLayoutSetContextPointer(uiLayout *layout, const char *name, PointerRNA *ptr) { uiBlock *block = layout->root->block; layout->context = CTX_store_add(&block->contexts, name, ptr); } bContextStore *uiLayoutGetContextStore(uiLayout *layout) { return layout->context; } void uiLayoutContextCopy(uiLayout *layout, bContextStore *context) { uiBlock *block = layout->root->block; layout->context = CTX_store_add_all(&block->contexts, context); } void uiLayoutSetContextFromBut(uiLayout *layout, uiBut *but) { if (but->opptr) { uiLayoutSetContextPointer(layout, "button_operator", but->opptr); } if (but->rnapoin.data && but->rnaprop) { /* TODO: index could be supported as well */ PointerRNA ptr_prop; RNA_pointer_create(NULL, &RNA_Property, but->rnaprop, &ptr_prop); uiLayoutSetContextPointer(layout, "button_prop", &ptr_prop); uiLayoutSetContextPointer(layout, "button_pointer", &but->rnapoin); } } /* this is a bit of a hack but best keep it in one place at least */ wmOperatorType *UI_but_operatortype_get_from_enum_menu(uiBut *but, PropertyRNA **r_prop) { if (r_prop != NULL) { *r_prop = NULL; } if (but->menu_create_func == menu_item_enum_opname_menu) { MenuItemLevel *lvl = but->func_argN; wmOperatorType *ot = WM_operatortype_find(lvl->opname, false); if ((ot != NULL) && (r_prop != NULL)) { *r_prop = RNA_struct_type_find_property(ot->srna, lvl->propname); } return ot; } return NULL; } /* this is a bit of a hack but best keep it in one place at least */ MenuType *UI_but_menutype_get(uiBut *but) { if (but->menu_create_func == ui_item_menutype_func) { return (MenuType *)but->poin; } return NULL; } /* this is a bit of a hack but best keep it in one place at least */ PanelType *UI_but_paneltype_get(uiBut *but) { if (but->menu_create_func == ui_item_paneltype_func) { return (PanelType *)but->poin; } return NULL; } void UI_menutype_draw(bContext *C, MenuType *mt, struct uiLayout *layout) { Menu menu = { .layout = layout, .type = mt, }; 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 bool ui_layout_has_panel_label(const uiLayout *layout, const PanelType *pt) { LISTBASE_FOREACH (uiItem *, subitem, &layout->items) { if (subitem->type == ITEM_BUTTON) { uiButtonItem *bitem = (uiButtonItem *)subitem; if (!(bitem->but->flag & UI_HIDDEN) && STREQ(bitem->but->str, pt->label)) { return true; } } else { uiLayout *litem = (uiLayout *)subitem; if (ui_layout_has_panel_label(litem, pt)) { return true; } } } return false; } static void ui_paneltype_draw_impl(bContext *C, PanelType *pt, uiLayout *layout, bool show_header) { Panel *panel = MEM_callocN(sizeof(Panel), "popover panel"); panel->type = pt; panel->flag = PNL_POPOVER; uiLayout *last_item = layout->items.last; /* Draw main panel. */ if (show_header) { uiLayout *row = uiLayoutRow(layout, false); if (pt->draw_header) { panel->layout = row; pt->draw_header(C, panel); panel->layout = NULL; } /* draw_header() is often used to add a checkbox to the header. If we add the label like below * the label is disconnected from the checkbox, adding a weird looking gap. As workaround, let * the checkbox add the label instead. */ if (!ui_layout_has_panel_label(row, pt)) { uiItemL(row, CTX_IFACE_(pt->translation_context, pt->label), ICON_NONE); } } panel->layout = layout; pt->draw(C, panel); panel->layout = NULL; BLI_assert(panel->runtime.custom_data_ptr == NULL); MEM_freeN(panel); /* Draw child panels. */ LISTBASE_FOREACH (LinkData *, link, &pt->children) { PanelType *child_pt = link->data; if (child_pt->poll == NULL || child_pt->poll(C, child_pt)) { /* Add space if something was added to the layout. */ if (last_item != layout->items.last) { uiItemS(layout); last_item = layout->items.last; } uiLayout *col = uiLayoutColumn(layout, false); ui_paneltype_draw_impl(C, child_pt, col, true); } } } /** * Used for popup panels only. */ void UI_paneltype_draw(bContext *C, PanelType *pt, uiLayout *layout) { if (layout->context) { CTX_store_set(C, layout->context); } ui_paneltype_draw_impl(C, pt, layout, false); if (layout->context) { CTX_store_set(C, NULL); } } /** \} */ /* -------------------------------------------------------------------- */ /** \name Layout (Debugging/Introspection) * * Serialize the layout as a Python compatible dictionary, * * \note Proper string escaping isn't used, * triple quotes are used to prevent single quotes from interfering with Python syntax. * If we want this to be fool-proof, we would need full Python compatible string escape support. * As we don't use triple quotes in the UI it's good-enough in practice. * \{ */ static void ui_layout_introspect_button(DynStr *ds, uiButtonItem *bitem) { uiBut *but = bitem->but; BLI_dynstr_appendf(ds, "'type':%d, ", (int)but->type); BLI_dynstr_appendf(ds, "'draw_string':'''%s''', ", but->drawstr); /* Not exactly needed, rna has this. */ BLI_dynstr_appendf(ds, "'tip':'''%s''', ", but->tip ? but->tip : ""); if (but->optype) { char *opstr = WM_operator_pystring_ex( but->block->evil_C, NULL, false, true, but->optype, but->opptr); BLI_dynstr_appendf(ds, "'operator':'''%s''', ", opstr ? opstr : ""); MEM_freeN(opstr); } { PropertyRNA *prop = NULL; wmOperatorType *ot = UI_but_operatortype_get_from_enum_menu(but, &prop); if (ot) { char *opstr = WM_operator_pystring_ex(but->block->evil_C, NULL, false, true, ot, NULL); BLI_dynstr_appendf(ds, "'operator':'''%s''', ", opstr ? opstr : ""); BLI_dynstr_appendf(ds, "'property':'''%s''', ", prop ? RNA_property_identifier(prop) : ""); MEM_freeN(opstr); } } if (but->rnaprop) { BLI_dynstr_appendf(ds, "'rna':'%s.%s[%d]', ", RNA_struct_identifier(but->rnapoin.type), RNA_property_identifier(but->rnaprop), but->rnaindex); } } static void ui_layout_introspect_items(DynStr *ds, ListBase *lb) { uiItem *item; BLI_dynstr_append(ds, "["); for (item = lb->first; item; item = item->next) { BLI_dynstr_append(ds, "{"); #define CASE_ITEM(id) \ case id: { \ const char *id_str = STRINGIFY(id); \ BLI_dynstr_append(ds, "'type': '"); \ /* Skip 'ITEM_'. */ \ BLI_dynstr_append(ds, id_str + 5); \ BLI_dynstr_append(ds, "', "); \ break; \ } \ ((void)0) switch (item->type) { CASE_ITEM(ITEM_BUTTON); CASE_ITEM(ITEM_LAYOUT_ROW); CASE_ITEM(ITEM_LAYOUT_COLUMN); CASE_ITEM(ITEM_LAYOUT_COLUMN_FLOW); CASE_ITEM(ITEM_LAYOUT_ROW_FLOW); CASE_ITEM(ITEM_LAYOUT_BOX); CASE_ITEM(ITEM_LAYOUT_ABSOLUTE); CASE_ITEM(ITEM_LAYOUT_SPLIT); CASE_ITEM(ITEM_LAYOUT_OVERLAP); CASE_ITEM(ITEM_LAYOUT_ROOT); CASE_ITEM(ITEM_LAYOUT_GRID_FLOW); CASE_ITEM(ITEM_LAYOUT_RADIAL); } #undef CASE_ITEM switch (item->type) { case ITEM_BUTTON: ui_layout_introspect_button(ds, (uiButtonItem *)item); break; default: BLI_dynstr_append(ds, "'items':"); ui_layout_introspect_items(ds, &((uiLayout *)item)->items); break; } BLI_dynstr_append(ds, "}"); if (item != lb->last) { BLI_dynstr_append(ds, ", "); } } /* Don't use a comma here as it's not needed and * causes the result to evaluate to a tuple of 1. */ BLI_dynstr_append(ds, "]"); } /** * Evaluate layout items as a Python dictionary. */ const char *UI_layout_introspect(uiLayout *layout) { DynStr *ds = BLI_dynstr_new(); uiLayout layout_copy = *layout; layout_copy.item.next = NULL; layout_copy.item.prev = NULL; ListBase layout_dummy_list = {&layout_copy, &layout_copy}; ui_layout_introspect_items(ds, &layout_dummy_list); const char *result = BLI_dynstr_get_cstring(ds); BLI_dynstr_free(ds); return result; } /** \} */ /* -------------------------------------------------------------------- */ /** \name Alert Box with Big Icon * \{ */ /** * Helper to add a big icon and create a split layout for alert popups. * Returns the layout to place further items into the alert box. */ uiLayout *uiItemsAlertBox(uiBlock *block, const int size, const eAlertIcon icon) { const uiStyle *style = UI_style_get_dpi(); const short icon_size = 64 * U.dpi_fac; const int text_points_max = MAX2(style->widget.points, style->widgetlabel.points); const int dialog_width = icon_size + (text_points_max * size * U.dpi_fac); /* By default, the space between icon and text/buttons will be equal to the 'columnspace', * this extra padding will add some space by increasing the left column width, * making the icon placement more symmetrical, between the block edge and the text. */ const float icon_padding = 5.0f * U.dpi_fac; /* Calculate the factor of the fixed icon column depending on the block width. */ const float split_factor = ((float)icon_size + icon_padding) / (float)(dialog_width - style->columnspace); uiLayout *block_layout = UI_block_layout( block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, 0, 0, dialog_width, 0, 0, style); /* Split layout to put alert icon on left side. */ uiLayout *split_block = uiLayoutSplit(block_layout, split_factor, false); /* Alert icon on the left. */ uiLayout *layout = uiLayoutRow(split_block, false); /* Using 'align_left' with 'row' avoids stretching the icon along the width of column. */ uiLayoutSetAlignment(layout, UI_LAYOUT_ALIGN_LEFT); uiDefButAlert(block, icon, 0, 0, icon_size, icon_size); /* The rest of the content on the right. */ layout = uiLayoutColumn(split_block, false); return layout; } /** \} */