86 transparent[3] = 0.0f;
130 block_listen(&block, params);
134 if (
list.type &&
list.type->listener) {
170 ICON_FULLSCREEN_EXIT,
203 const float size = 0.2f *
U.widget_unit;
204 const float l = 1.0f;
205 const float s = 0.25f;
206 const float hl =
l / 2.0f;
207 const float points[6][2] = {
208 {0, -hl}, {
l, hl}, {
l - s, hl + s}, {0, s + s - hl}, {s -
l, hl + s}, {-
l, hl}};
209 const float center[2] = {(x1 + x2) / 2, (y1 + y2) / 2};
246 for (
int i = 0; i < 6; i++) {
248 immVertex2f(pos, center[0] + points[i][0] * size, center[1] + points[i][1] *
sign * size);
251 immVertex2f(pos, center[0] + points[i][1] *
sign * size, center[1] + points[i][0] * size);
332 if (az.
alpha > 0.0f) {
349 float header_color[4];
368 x = (region->
winx - width) / 2.0f;
370 const float x1 =
x -
pad;
371 const float x2 =
x + width +
pad;
375 header_color[3] = std::max(header_color[3], 0.6f);
379 const rctf rect = {x1, x2, y1, y2};
406 while (region && region->
prev) {
407 region = region->
prev;
409 for (; region; region = region->
next) {
435 msg_sub_value_region_tag_redraw.
owner = region;
436 msg_sub_value_region_tag_redraw.
user_data = region;
439 mbus, &workspace->
id, workspace,
WorkSpace, tools, &msg_sub_value_region_tag_redraw);
449 const char *panel_category_tool =
"Tool";
452 bool update_region =
false;
453 if (category &&
STREQ(category, panel_category_tool)) {
454 update_region =
true;
462 update_region =
true;
470 msg_sub_value_region_tag_redraw.
owner = region;
471 msg_sub_value_region_tag_redraw.
user_data = region;
474 mbus, &workspace->
id, workspace,
WorkSpace, tools, &msg_sub_value_region_tag_redraw);
492 return (area->
winx < 3) || (area->
winy < 3);
550 bool ime_cursor_is_set =
false;
558 ime_cursor_is_set = WM_window_IME_region_refresh(win, area, region,
true, &ime_cursor);
575 if (ime_cursor_is_set) {
576 ed::ime::region_overlay_draw(win, region,
U.pixelsize, ime_cursor);
585 if (
G.debug_value == 888) {
618 float color[4] = {0.0f, 0.0f, 0.0f, 0.8f};
655 msg_sub_value_region_tag_redraw.
owner = region;
656 msg_sub_value_region_tag_redraw.
user_data = region;
662 message_subscribe_params.
context =
C;
664 message_subscribe_params.
workspace = workspace;
665 message_subscribe_params.
scene = scene;
666 message_subscribe_params.
screen = screen;
667 message_subscribe_params.
area = area;
668 message_subscribe_params.
region = region;
708 [
data, prop_name = std::string(prop_name), found =
false](
const bContext &
C,
835 for (
ARegion *following_region = changed_region->
next; following_region;
836 following_region = following_region->
next)
840 if (changed_region->
overlap != following_region->overlap) {
853 const bool set_padding)
856 if (hud_region ==
nullptr) {
883 dist = region->
winy + scale_region->
winy -
U.pixelsize;
887 dist = region->
winx + scale_region->
winx -
U.pixelsize;
901 if (®ion == scale_region) {
965 search_filter && search_filter[0] !=
'\0',
978 if (area ==
nullptr) {
1013 const float space_factor = 0.0f,
1017 if (workspace ==
nullptr) {
1022 item.
text = std::move(text);
1050 if (!text.empty()) {
1063 if (icon >= ICON_MOUSE_LMB && icon <= ICON_MOUSE_MMB_SCROLL) {
1109 const int propvalue,
1113 if (keymap ==
nullptr) {
1121 const int propvalue,
1125 if (kmi ==
nullptr) {
1191 const float coords[4][4] = {
1214 for (
int i = 0; i < 4; i++) {
1218 ((coords[i][0] == 0 && coords[i][1] == 0) ||
1228 AZone *az = MEM_new<AZone>(
"actionzone");
1231 az->
x1 = coords[i][0];
1232 az->
y1 = coords[i][1];
1233 az->
x2 = coords[i][2];
1234 az->
y2 = coords[i][3];
1245 AZone *az = MEM_new<AZone>(
"fullscreen action zone");
1272 const int half_line = int(
floor(
U.pixelsize / 2.0f));
1298 return back[3] < 50;
1306 const bool transparent = !is_narrow && region->
overlap &&
1314 const int pad_out = (is_narrow ? 2.0f : 3.0f) *
UI_SCALE_FAC;
1315 const int pad_in = (is_narrow ? 1.0f : (transparent ? 8.0f : 4.0f)) *
UI_SCALE_FAC / aspect;
1349 float edge_offset = 1.0f;
1350 const float tab_size_x = 1.0f *
U.widget_unit;
1351 const float tab_size_y = 0.5f *
U.widget_unit;
1356 az->
x1 = region->
winrct.
xmax - ((edge_offset + 1.0f) * tab_size_x);
1358 az->
x2 = region->
winrct.
xmax - (edge_offset * tab_size_x);
1363 az->
x1 = region->
winrct.
xmax - ((edge_offset + 1.0f) * tab_size_x);
1365 az->
x2 = region->
winrct.
xmax - (edge_offset * tab_size_x);
1370 az->
y1 = region->
winrct.
ymax - ((edge_offset + 1.0f) * tab_size_x);
1372 az->
y2 = region->
winrct.
ymax - (edge_offset * tab_size_x);
1376 az->
y1 = region->
winrct.
ymax - ((edge_offset + 1.0f) * tab_size_x);
1378 az->
y2 = region->
winrct.
ymax - (edge_offset * tab_size_x);
1387 const bool is_fullscreen)
1406 if (is_hidden && is_fullscreen) {
1431 const bool is_fullscreen)
1439 AZone *az = MEM_new<AZone>(
"actionzone");
1457 AZone *az = MEM_new<AZone>(__func__);
1462 az->direction = direction;
1489 const int alignment,
1490 const bool is_fullscreen)
1534 if (is_fullscreen) {
1578 for (region_iter = region->
prev; region_iter; region_iter = region_iter->
prev) {
1594 align1 = align_iter;
1596 if (align1 != align) {
1629 for (region_iter = region->
prev; region_iter; region_iter = region_iter->
prev) {
1662 switch (spacetype) {
1664 return ELEM(regiontype,
1676 return ELEM(regiontype,
1686 return ELEM(regiontype,
1707 rcti *remainder_prev = remainder;
1709 if (region ==
nullptr) {
1713 int prev_winx = region->
winx;
1714 int prev_winy = region->
winy;
1796 rcti overlap_remainder_margin = *overlap_remainder;
1825 BLI_rcti_isect(&winrct_test, &overlap_remainder_margin, &winrct_test);
1838 region->
winrct = *remainder;
1842 rcti *winrct = (region->
overlap) ? overlap_remainder : remainder;
1854 region->
winrct = *winrct;
1868 rcti *winrct = (region->
overlap) ? overlap_remainder : remainder;
1870 if (prefsizex == 0) {
1873 else if (width < prefsizex) {
1885 region->
winrct = *winrct;
1888 else if (has_tabs) {
1891 region->
winrct = *winrct;
1913 if (prefsizex < tab_auto_snap_width) {
1923 region->
winrct = *winrct;
1938 region->
winrct = *remainder;
1960 region->
winrct = *remainder;
1967 while (region_test) {
1969 region_test = region_test->
next;
1977 printf(
"region quadsplit failed\n");
1987 const int x = remainder->
xmin + int(
float(remainder->
xmax - remainder->
xmin) * ratio_x);
1988 const int y = remainder->
ymin + int(
float(remainder->
ymax - remainder->
ymin) * ratio_y);
2026 if (region->
winy <=
U.border_width && !is_hidden) {
2033 if (region->
winx > 1) {
2036 if (region->
winy > 1) {
2047 region->
winrct = (region->
overlap) ? *overlap_remainder : *remainder;
2049 switch (alignment) {
2075 remainder = remainder_prev;
2084 *overlap_remainder = *remainder;
2092 if (region->
winx != prev_winx || region->
winy != prev_winy) {
2182 ListBaseT<wmEventHandler> *handlers,
2303 rcti overlap_rect = rect;
2351 if (sl != sl_old) [[likely]] {
2370 if (area->
type ==
nullptr) {
2408 rcti overlap_rect = rect;
2483 ScrArea *area = MEM_new<ScrArea>(__func__);
2514 if (
wm->runtime->message_bus) {
2561 if (region !=
nullptr) {
2602 const bool do_init =
true;
2640 std::swap(area_dst->
type, area_src->
type);
2710 if ((tool_header_alignment != -1) &&
2712 ((tool_header_hidden ==
false) ||
2716 (header_hidden && tool_header_hidden)))
2718 return tool_header_alignment;
2720 if (header_alignment != -1) {
2721 return header_alignment;
2754 const short tool_header_alignment_src =
2760 region_align_info_src, -1);
2763 if (primary_header_alignment_src == -1) {
2768 const short tool_header_alignment_dst =
2775 short header_alignment_sync = -1;
2776 short tool_header_alignment_sync = -1;
2777 short footer_alignment_sync = -1;
2781 if (((header_alignment_src != -1) == (header_alignment_dst != -1)) &&
2782 ((tool_header_alignment_src != -1) == (tool_header_alignment_dst != -1)) &&
2783 (tool_header_hidden_src == tool_header_hidden_dst))
2785 if (header_alignment_dst != -1) {
2786 header_alignment_sync = header_alignment_src;
2788 if (tool_header_alignment_dst != -1) {
2789 tool_header_alignment_sync = tool_header_alignment_src;
2795 region_align_info_dst, -1);
2797 if (primary_header_alignment_src != primary_header_alignment_dst) {
2798 if ((header_alignment_dst != -1) && (tool_header_alignment_dst != -1)) {
2799 if (header_alignment_dst == tool_header_alignment_dst) {
2801 tool_header_alignment_sync = primary_header_alignment_src;
2802 header_alignment_sync = primary_header_alignment_src;
2806 tool_header_alignment_sync = primary_header_alignment_src;
2814 if (header_alignment_dst != -1) {
2815 header_alignment_sync = primary_header_alignment_src;
2817 if (tool_header_alignment_dst != -1) {
2818 tool_header_alignment_sync = primary_header_alignment_src;
2824 if (footer_alignment_dst != -1) {
2825 if ((header_alignment_dst != -1) && (header_alignment_dst == footer_alignment_dst)) {
2827 footer_alignment_sync = primary_header_alignment_src;
2831 footer_alignment_sync = (primary_header_alignment_src ==
RGN_ALIGN_BOTTOM) ?
2838 if (header_alignment_sync != -1) {
2840 if (region !=
nullptr) {
2846 if (tool_header_alignment_sync != -1) {
2848 if (region !=
nullptr) {
2854 if (footer_alignment_sync != -1) {
2856 if (region !=
nullptr) {
2870 region_by_type[
index] = ®ion;
2881 region_align_info_src, ®ion_align_info_dst, region_by_type);
2895 ScrArea *tmp = MEM_new<ScrArea>(__func__);
2916 screen->active_region =
nullptr;
2949 bool sync_header_alignment =
false;
2953 sync_header_alignment =
true;
2958 if (skip_region_exit && area->
type) {
2964#ifdef WITH_INPUT_IME
2968 WM_window_IME_end(win);
2973 if (skip_region_exit && area->
type) {
3022 sl = st->
create(area, scene);
3035 if (sync_header_alignment) {
3078 if (!
G.background) {
3141 int xco = 0.4 *
U.widget_unit;
3150 1.6 *
U.widget_unit,
3159 return xco + 1.7 *
U.widget_unit;
3189 GPU_clear_color(back[3] * back[0], back[3] * back[1], back[3] * back[2], back[3]);
3212 for (
uint i = 0; arr[i]; i++) {
3213 if (
STREQ(arr[i], s)) {
3231 ListBaseT<Panel> *lb,
3236 char *unique_panel_str,
3237 const char *search_filter,
3244 if (unique_panel_str) {
3254 panel = panel_begin(region, lb, block, pt, panel, &open);
3257 const bool search_filter_active = search_filter !=
nullptr && search_filter[0] !=
'\0';
3281 block_apply_search_filter(block, search_filter);
3283 block_translate(block, headerend - co.x, 0);
3289 panel_label_offset(block, &labelx, &labely);
3321 block_apply_search_filter(block, search_filter);
3331 if (open || search_filter_active) {
3360 const bool ends_with_layout_panel_header = uiLayoutEndsWithPanelHeader(*panel->
layout);
3362 block_apply_search_filter(block, search_filter);
3369 if (!ends_with_layout_panel_header) {
3376 block_end(
C, block,
true);
3379 if (open || search_filter_active) {
3384 if (child_pt->
draw && (!child_pt->
poll || child_pt->
poll(
C, child_pt))) {
3407 const char *contexts[],
3408 const char *category_override,
3412 if (panel_type->
parent) {
3416 if (category_override) {
3423 if (contexts !=
nullptr && panel_type->
context[0]) {
3436 if (panel_type->
draw) [[likely]] {
3437 if (panel_type->
poll && !panel_type->
poll(
C, panel_type)) {
3447 bool *use_categories)
3452 for (
LinkNode *pt_link = panel_types_stack; pt_link; pt_link = pt_link->
next) {
3465 *use_categories =
false;
3471 const int max_width)
3499 const char *next_active =
nullptr;
3500 const char *first_active =
nullptr;
3501 bool found_active =
false;
3505 if (has_match && !first_active) {
3506 first_active = pc_dyn.
idname;
3508 if (has_match && found_active) {
3509 next_active = pc_dyn.
idname;
3518 else if (first_active) {
3526 ListBaseT<PanelType> *paneltypes,
3528 const char *contexts[],
3529 const char *category_override)
3536 LinkNode *panel_types_stack =
nullptr;
3537 for (
PanelType &pt : paneltypes->items_reversed()) {
3548 bool use_categories = (category_override ==
nullptr) &&
3550 bool use_category_tabs = (category_override ==
nullptr) &&
3553 const char *category =
nullptr;
3557 bool update_tot_size =
true;
3574 if (use_categories) {
3576 if (!use_categories) {
3577 use_category_tabs =
false;
3580 if (use_category_tabs) {
3581 margin_x = category_tabs_width;
3597 bool has_instanced_panel =
false;
3598 for (
LinkNode *pt_link = panel_types_stack; pt_link; pt_link = pt_link->
next) {
3602 has_instanced_panel =
true;
3608 if ((panel ==
nullptr) || ((panel->
flag &
PNL_PIN) == 0)) {
3616 update_tot_size =
false;
3620 C, region, ®ion->
panels, pt, panel, width, em,
nullptr, search_filter, op_context);
3624 if (has_instanced_panel) {
3626 if (panel.
type ==
nullptr) {
3643 update_tot_size =
false;
3677 if (region_layout_based) {
3682 if (panel !=
nullptr) {
3683 const int size_dyn[2] = {
3688 if ((region->
sizex != size_dyn[0]) || (region->
sizey != size_dyn[1])) {
3689 region->
sizex = size_dyn[0];
3690 region->
sizey = size_dyn[1];
3714 if (update_tot_size) {
3719 if (use_categories) {
3737 const float gradient_width = (narrow ? 4.0f : 16.0f) *
UI_SCALE_FAC;
3759 float offset_x =
mask->xmin;
3760 float offset_y =
mask->ymin;
3766 else if (region->
panels.first_) {
3778 float transparent[4];
3780 transparent[3] = 0.0f;
3781 float grad_color[4];
3787 rect.
xmax = offset_x + width;
3788 rect.
xmin = offset_x + rect.
xmax - gradient_width;
3789 rect.
ymin = offset_y;
3797 rect.
xmin = offset_x;
3801 rect.
xmax = rect.
xmin + gradient_width;
3802 rect.
ymin = offset_y;
3815 rect.
xmin = offset_x;
3816 rect.
xmax = offset_x + width;
3817 rect.
ymax = offset_y + height;
3818 rect.
ymin = rect.
ymax - gradient_width;
3825 rect.
xmin = offset_x;
3826 rect.
xmax = offset_x + width;
3827 rect.
ymin = offset_y;
3828 rect.
ymax = rect.
ymin + gradient_width;
3853 float color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
3893 std::max<int>(
w, 0),
3910 block_bounds_set_normal(block, 0);
3911 block_end(
C, block);
3913 block_draw(
C, block);
3940 const short min_draw_size = has_category_tabs ?
3943 ui::PANEL_MIN_DRAW_WIDTH);
3958 bool use_mask =
false;
3969 mask.xmax -= category_width;
3972 mask.xmin += category_width;
3979 int min_width = has_category_tabs ? 60.0f *
UI_SCALE_FAC / aspect :
3991 const char *contexts[])
4042 const char *search_filter)
4045 block_set_search_only(block,
true);
4052 if (panel ==
nullptr) {
4054 panel = panel_begin(region, ®ion->
panels, block, panel_type, panel, &open);
4069 if (panel->
type->
draw !=
nullptr) [[likely]] {
4072 panel_type->
draw(
C, panel);
4079 if (block_apply_search_filter(block, search_filter)) {
4085 if (!panel_type_child->
poll || panel_type_child->
poll(
C, panel_type_child)) {
4100 std::array<const char *, 4> contexts = {
nullptr};
4135 LinkNode *panel_types_stack =
nullptr;
4141 bool use_categories =
true;
4143 region_original, panel_types_stack, &use_categories);
4148 if (category == pc_dyn.
idname) {
4158 MEM_delete(region_copy);
4175 ListBaseT<PanelType> *paneltypes,
4176 const char *contexts[],
4177 const char *category_override)
4184 LinkNode *panel_types_stack =
nullptr;
4185 for (
PanelType &pt : paneltypes->items_reversed()) {
4191 const char *category = category_override;
4192 bool use_categories = (category !=
nullptr) &&
4194 if (use_categories) {
4199 bool has_result =
true;
4200 bool has_instanced_panel =
false;
4201 for (
LinkNode *pt_link = panel_types_stack; pt_link; pt_link = pt_link->
next) {
4205 has_instanced_panel =
true;
4209 if (use_categories) {
4224 if (!has_result && has_instanced_panel) {
4230 if (use_categories) {
4270 int2 co = {offset, buttony + (region->
winy - buttony) / 2};
4293 if (buttony_scale != 1.0f) {
4297 Header header = {
nullptr};
4301 ht.
draw(
C, &header);
4307 co.x = layout.
width();
4308 maxco = std::max(co.x, maxco);
4314 maxco = std::max(co.x, maxco);
4318 if (region_layout_based && (region->
sizex != new_sizex)) {
4322 region->
sizex = new_sizex;
4326 block_end(
C, block);
4333 if (!region_layout_based) {
4453 return area->
global !=
nullptr;
4470 int event_xy_other[2];
4472 if (win_other && win_other != win) {
4479 if (!area && !win->
parent) {
4502 if (area->
global ==
nullptr) {
4506 for (
ScrArea *area_iter = area->
next; area_iter; area_iter = area_iter->
next) {
4527 const char *text_array[],
4528 const float fill_color[4],
4529 const bool full_redraw)
4545 const char **
text = &text_array[0];
4549 1.2f *
U.widget_unit);
4556 const char **
text = &text_array[0];
4563 rect.
ymin = rect.
ymax - header_height * num_lines;
4582 int offset = num_lines - 1;
4584 const char **
text = &text_array[0];
4587 rect.
xmin + 0.6f *
U.widget_unit,
4588 rect.
ymin + 0.3f *
U.widget_unit + offset * header_height,
4599 GPU_scissor(scissor[0], scissor[1], scissor[2], scissor[3]);
4604 const float fill_color[4],
4605 const bool full_redraw)
4607 const char *text_array[2] = {
text,
nullptr};
4619 row.
label(field, ICON_NONE);
4620 row.
label(value, ICON_NONE);
4656 float gridsize = 0.5f * (zoomx + zoomy);
4657 float gridstep = 1.0f / 32.0f;
4658 if (gridsize <= 0.0f) {
4662 if (gridsize < 1.0f) {
4663 while (gridsize < 1.0f) {
4669 while (gridsize >= 4.0f) {
4675 float blendfac = 0.25f * gridsize -
floorf(0.25f * gridsize);
4676 CLAMP(blendfac, 0.0f, 1.0f);
4678 int count_fine = 1.0f / gridstep;
4679 int count_large = 1.0f / (4.0f * gridstep);
4681 if (count_fine > 0) {
4689 float theme_color[3];
4694 for (
int i = 0; i < count_fine; i++) {
4696 immVertex2f(pos, x1, y1 * (1.0f - fac) + y2 * fac);
4698 immVertex2f(pos, x2, y1 * (1.0f - fac) + y2 * fac);
4700 immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y1);
4702 immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y2);
4706 if (count_large > 0) {
4711 for (
int i = 0; i < count_large; i++) {
4713 immVertex2f(pos, x1, y1 * (1.0f - fac) + y2 * fac);
4715 immVertex2f(pos, x2, y1 * (1.0f - fac) + y2 * fac);
4717 immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y1);
4719 immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y2);
4720 fac += 4.0f * gridstep;
4739 ARegion *region_iter = region;
4742 while (region_iter->
prev) {
4743 region_iter = region_iter->
prev;
4749 for (; region_iter; region_iter = region_iter->
next) {
4750 if (region != region_iter && region_iter->
overlap) {
4794 if (rect->
xmin == 0 && rect->
ymin == 0 && rect->
xmax == 0 && rect->
ymax == 0) {
4810 const int region_bottom = rect_visible->
ymin;
4829 float2 text_dims = {0.0f, 0.0f};
4846 &rect, bg_color,
nullptr, 1.0f, outline_color,
U.pixelsize, 3 *
UI_SCALE_FAC);
4851 BLF_draw(fontid, numstr,
sizeof(numstr));
4855 ARegion *region,
const int num_segments,
const int *points,
const int sfra,
const int efra)
4860 const int region_bottom = rect_visible->
ymin;
4866 for (
int a = 0; a < num_segments; a++) {
4867 float x1 =
float(points[a * 2] - sfra) / (efra - sfra + 1) * region->
winx;
4868 float x2 =
float(points[a * 2 + 1] - sfra + 1) / (efra - sfra + 1) * region->
winx;
4912 const int snap_match_threshold = 16;
4916 return (((
abs(region->
sizex - snap_size_x) <= snap_match_threshold) << 0) |
4917 ((
abs(region->
sizey - snap_size_y) <= snap_match_threshold) << 1));
4924 bool changed =
false;
4926 if (snap_flag & (1 << 0)) {
4928 if (snap_size != region->
sizex) {
4929 region->
sizex = snap_size;
4933 if (snap_flag & (1 << 1)) {
4935 if (snap_size != region->
sizey) {
4936 region->
sizey = snap_size;
#define BLF_DRAW_STR_DUMMY_MAX
#define BLI_linklist_prepend_alloca(listp, ptr)
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define BLI_string_join(...)
#define RGN_ALIGN_ENUM_FROM_MASK(align)
#define RGN_TYPE_IS_HEADER_ANY(regiontype)
#define RGN_ALIGN_FLAG_FROM_MASK(align)
#define REGION_DRAW_POST_PIXEL
Read Blender memory allocation and freeing.
#define UI_PANEL_CATEGORY_MIN_SNAP_WIDTH
#define INSTANCED_PANEL_UNIQUE_STR_SIZE
#define UI_PANEL_CATEGORY_MIN_WIDTH
#define UI_PANEL_MARGIN_X
#define UI_PANEL_SEARCH_BLOCK_MARGIN_HEIGHT
#define UI_AZONESPOTW_RIGHT
#define UI_PANEL_CATEGORY_MARGIN_WIDTH
#define UI_AZONESPOTW_LEFT
#define UI_NO_ICON_OVERLAY_TEXT
int pad[32 - sizeof(int)]
#define BLI_assert_unreachable()
#define SET_FLAG_FROM_TEST(value, test, flag)
#define BLI_assert_msg(a, msg)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
static RandomNumberGenerator from_random_seed()
bool contains(const Key &key) const
constexpr const char * c_str() const
void separator(float factor=1.0f)
void item(std::string text, int icon1, int icon2=0)
void modal_keymap(std::string text, const wmKeyMap &keymap, int propvalue, bool inverted=false)
void opmodal(std::string text, const wmOperatorType *ot, int propvalue, bool inverted=false)
void range(std::string text, int icon1, int icon2)
WorkspaceStatus(bContext *C)
void item_bool(std::string text, bool inverted, int icon1, int icon2=0)
constexpr const char * data() const
ccl_device_inline float3x3 inverted(const float3x3 m)
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
void font_theme_color_set(int fontid, int colorid)
void get_color_4ubv(int colorid, unsigned char col[4])
void get_color_3fv(int colorid, float col[3])
void theme_store(bThemeState *theme_state)
void theme_set(int spacetype, int regionid)
void get_color_4fv(int colorid, float col[4])
void get_color_shade_3fv(int colorid, int offset, float col[3])
void frame_buffer_clear(int colorid)
void get_color_shade_4fv(int colorid, int offset, float col[4])
const bTheme * theme_get()
void theme_restore(const bThemeState *theme_state)
int icon_from_event_type(short event_type, short event_value)
int panel_size_y(const Panel *panel)
void panel_category_add(ARegion *region, const char *name, int icon=0)
void blocklist_free(const bContext *C, ARegion *region)
void panels_begin(const bContext *C, ARegion *region)
bool region_panels_fits_only_categories(const ARegion *region)
void view2d_view_ortho(const View2D *v2d)
void panel_category_clear_all(ARegion *region)
void view2d_totRect_set(View2D *v2d, int width, int height)
bool panel_should_show_background(const ARegion *region, const PanelType *panel_type)
void blocklist_update_window_matrix(const bContext *C, const ListBaseT< ui::Block > *lb)
const uiStyle * style_get()
void panels_draw(const bContext *C, ARegion *region)
bool textbutton_activate_rna(const bContext *C, ARegion *region, const void *rna_poin_data, const char *rna_prop_id)
PanelCategoryDyn * panel_category_find(const ARegion *region, const char *idname)
void UI_region_free_active_but_all(bContext *C, ARegion *region)
void panels_do_after_block_layout_fns(const bContext *C, ARegion *region)
void view2d_view_restore(const bContext *C)
void icon_draw_ex(float x, float y, int icon_id, float aspect, float alpha, float desaturate, const uchar mono_color[4], bool mono_border, const IconTextOverlay *text_overlay, const bool inverted=false, float scale=1.0f)
void view2d_mask_from_win(const View2D *v2d, rcti *r_mask)
void invalidate_text_wrap_cache(const ARegion ®ion)
void view2d_view_to_region(const View2D *v2d, float x, float y, int *r_region_x, int *r_region_y) ATTR_NONNULL()
void blocklist_draw(const bContext *C, const ListBaseT< ui::Block > *lb)
void panel_category_active_set(ARegion *region, const char *idname)
bool panel_is_closed(const Panel *panel)
void panels_end(const bContext *C, ARegion *region, int *r_x, int *r_y)
void panel_end(Panel *panel, int width, int height)
bool panel_matches_search_filter(const Panel *panel)
const uiStyle * style_get_dpi()
Button * uiDefIconButR_prop(Block *block, ButtonType type, int icon, int x, int y, short width, short height, PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, std::optional< StringRef > tip)
void panel_header_buttons_end(Panel *panel)
void view2d_scrollers_draw(View2D *v2d, const rcti *mask_custom)
void panel_category_show_tab(const bContext &C, ARegion *region, StringRef category)
void button_flag_enable(Button *but, int64_t flag)
void draw_roundbox_corner_set(int type)
bool panel_category_tabs_is_visible(const ARegion *region)
void blocklist_free_inactive(const bContext *C, ARegion *region)
void panels_free_instanced(const bContext *C, ARegion *region)
void region_button_sections_draw(const ARegion *region, int colorid, ButtonSectionsAlign align)
bool panel_is_active(const Panel *panel)
float view2d_scale_get_x(const View2D *v2d)
void draw_roundbox_aa(const rctf *rect, bool filled, float rad, const float color[4])
void draw_roundbox_4fv_ex(const rctf *rect, const float inner1[4], const float inner2[4], float shade_dir, const float outline[4], float outline_width, float rad)
void list_panel_unique_str(Panel *panel, char *r_name)
void block_layout_free(Block *block)
int2 block_layout_resolve(Block *block)
void draw_roundbox_3fv_alpha(const rctf *rect, bool filled, float rad, const float col[3], float alpha)
void panel_header_buttons_begin(Panel *panel)
@ V2D_COMMONVIEW_PANELS_UI
void icon_draw_alpha(float x, float y, int icon_id, float alpha)
PointerRNA * button_extra_operator_icon_add(Button *but, StringRefNull opname, wm::OpCallContext opcontext, int icon)
void region_message_subscribe(ARegion *region, wmMsgBus *mbus)
void panel_category_tabs_draw_all(const bContext *C, ARegion *region, const char *category_id_active)
Layout & block_layout(Block *block, LayoutDirection direction, LayoutType type, int x, int y, int size, int em, int padding, const uiStyle *style)
bool panel_category_is_visible(const ARegion *region)
void region_handlers_add(ListBaseT< wmEventHandler > *handlers)
void blocklist_update_view_for_buttons(const bContext *C, const ListBaseT< ui::Block > *lb)
const char * panel_category_active_get(ARegion *region, bool set_fallback)
void draw_roundbox_4fv(const rctf *rect, bool filled, float rad, const float col[4])
bool panel_is_dragging(const Panel *panel)
Panel * panel_find_by_type(ListBaseT< Panel > *lb, const PanelType *pt)
MINLINE float min_ff(float a, float b)
static void region_visible_rect_calc(ARegion *region, rcti *rect)
ScrArea * ED_screen_areas_iter_next(const bScreen *screen, const ScrArea *area)
void GPU_framebuffer_bind(gpu::FrameBuffer *fb)
static constexpr float STATUS_AFTER_TEXT
wmKeyMap * WM_keymap_active(const wmWindowManager *wm, wmKeyMap *keymap)
bool BLI_rcti_is_valid(const struct rcti *rect)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void region_draw_gradient(const ARegion *region)
void immUniformThemeColorBlendShade(int color_id1, int color_id2, float fac, int offset)
eScreenDir area_getorientation(ScrArea *sa_a, ScrArea *sa_b)
gpu::FrameBuffer * GPU_framebuffer_active_get()
const wmKeyMapItem * WM_modalkeymap_find_propvalue(const wmKeyMap *km, const int propvalue)
ScrArea * CTX_wm_area(const bContext *C)
void wmOrtho2_region_pixelspace(const ARegion *region)
bool BKE_regiontype_uses_panel_categories_search(const ARegionType *region_type)
void ED_region_blend_rect(ARegion *region, rcti *r_rect)
void ED_region_draw_cb_draw(const bContext *C, ARegion *region, int type)
void ED_area_data_copy(ScrArea *area_dst, ScrArea *area_src, const bool do_free)
void ED_area_tag_redraw_no_rebuild(ScrArea *area)
uint padding(uint offset, uint alignment)
static void ed_workspace_status_text_item(WorkSpace *workspace, std::string text)
bool GPU_type_matches_ex(GPUDeviceType device, GPUOSType os, GPUDriverType driver, GPUBackendType backend)
void ED_region_update_rect(ARegion *region)
void BLF_position(int fontid, float x, float y, float z)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
float BLF_width(int fontid, const char *str, size_t str_len, ResultBLF *r_info=nullptr) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2)
static void ed_workspace_status_item(WorkSpace *workspace, std::string text, const int icon, const float space_factor=0.0f, const bool inverted=false)
void BKE_screen_area_free(ScrArea *area)
void ED_area_update_region_sizes(wmWindowManager *wm, wmWindow *win, ScrArea *area)
static bool area_is_pseudo_minimized(const ScrArea *area)
MINLINE void copy_v3_v3(float r[3], const float a[3])
static const char * region_panels_collect_categories(ARegion *region, LinkNode *panel_types_stack, bool *use_categories)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void ED_region_do_listen(wmRegionListenerParams *params)
static bool region_azone_edge_poll(const ScrArea *area, const ARegion *region, const bool is_fullscreen)
static void region_azone_edge(const ScrArea *area, AZone *az, const ARegion *region)
int ED_area_max_regionsize(const ScrArea *area, const ARegion *scale_region, const AZEdge edge)
void GPU_clear_color(float red, float green, float blue, float alpha)
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
WorkSpace * CTX_wm_workspace(const bContext *C)
const char * ED_buttons_search_string_get(SpaceProperties *sbuts)
bool WM_cursor_set_from_tool(wmWindow *win, const ScrArea *area, const ARegion *region)
void ED_region_visibility_change_update_ex(bContext *C, ScrArea *area, ARegion *region, bool is_hidden, bool do_init)
@ RGN_TYPE_ASSET_SHELF_HEADER
ATTR_WARN_UNUSED_RESULT const BMLoop * l
static void area_azone_init(const wmWindow *win, const bScreen *screen, ScrArea *area)
const char * ED_area_region_search_filter_get(const ScrArea *area, const ARegion *region)
MINLINE int round_fl_to_int(float a)
static bool panel_add_check(const bContext *C, const WorkSpace *workspace, const char *contexts[], const char *category_override, PanelType *panel_type)
static void region_azones_scrollbars_init(ScrArea *area, ARegion *region)
ScrArea * WM_window_status_area_find(wmWindow *win, bScreen *screen)
void ED_region_do_layout(bContext *C, ARegion *region)
void immUniformColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
bool BLI_rcti_isect(const struct rcti *src1, const struct rcti *src2, struct rcti *dest)
void ED_area_do_msg_notify_tag_refresh(bContext *C, wmMsgSubscribeKey *msg_key, wmMsgSubscribeValue *msg_val)
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
BLI_INLINE float fb(float length, float L)
bool BKE_workspace_owner_id_check(const WorkSpace *workspace, const char *owner_id) ATTR_NONNULL()
void GPU_matrix_identity_set()
static void region_clear_fully_transparent(const bContext *C)
BLI_INLINE bool streq_array_any(const char *s, const char *arr[])
GPUVertFormat * immVertexFormat()
bool WM_region_use_viewport(ScrArea *area, ARegion *region)
static void area_azone_tag_update(ScrArea *area)
wmEventHandler_Keymap * WM_event_add_keymap_handler_dynamic(ListBaseT< wmEventHandler > *handlers, wmEventHandler_KeymapDynamicFn keymap_fn, void *user_data)
static void region_draw_blocks_in_view2d(const bContext *C, const ARegion *region)
static ThemeColorID region_background_color_id(const bContext *, const ARegion *region)
wmWindow * WM_window_find_under_cursor(wmWindow *win, const int event_xy[2], int r_event_xy_other[2])
void BKE_area_region_free(SpaceType *st, ARegion *region)
void ED_area_prevspace(bContext *C, ScrArea *area)
bool BKE_regiontype_uses_category_tabs(const ARegionType *region_type)
void ED_region_cache_draw_background(ARegion *region)
AZone * ED_area_azones_update(ScrArea *area, const int mouse_xy[2])
static void area_offscreen_init(ScrArea *area)
void ED_region_panels_ex(const bContext *C, ARegion *region, wm::OpCallContext op_context, const char *contexts[])
void immBegin(GPUPrimType, uint vertex_len)
bool ED_region_property_search(const bContext *C, ARegion *region, ListBaseT< PanelType > *paneltypes, const char *contexts[], const char *category_override)
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
static bool region_background_is_transparent(const ScrArea *area, const ARegion *region)
bool ED_region_is_overlap(int spacetype, int regiontype)
@ RGN_DRAW_EDITOR_OVERLAYS
void WM_draw_region_free(ARegion *region)
static void area_draw_azone(ScrArea *area, ARegion *region, AZone *az)
Corner widgets use for dragging and splitting the view.
void WM_gizmomap_message_subscribe(const bContext *C, wmGizmoMap *gzmap, ARegion *region, wmMsgBus *mbus)
void ED_area_newspace(bContext *C, ScrArea *area, int type, bool skip_region_exit)
wmWindow * CTX_wm_window(const bContext *C)
void BKE_area_region_panels_free(ListBaseT< Panel > *panels)
static void region_azone_edge_init(ScrArea *area, ARegion *region, AZEdge edge, const bool is_fullscreen)
void ED_area_data_swap(ScrArea *area_dst, ScrArea *area_src)
MINLINE int max_ii(int a, int b)
void ED_region_search_filter_update(const ScrArea *area, ARegion *region)
int WM_window_native_pixel_x(const wmWindow *win)
void immUniformColor4fv(const float rgba[4])
const rcti * ED_region_visible_rect(ARegion *region)
void WM_gizmomap_add_handlers(ARegion *region, wmGizmoMap *gzmap)
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
static int rct_fits(const rcti *rect, const eScreenAxis dir_axis, int size)
void ED_region_header_draw(const bContext *C, ARegion *region)
static void region_rect_recursive(ScrArea *area, ARegion *region, rcti *remainder, rcti *overlap_remainder, int quad)
static void region_align_info_from_area(ScrArea *area, RegionTypeAlignInfo *r_align_info)
bool ED_area_has_shared_border(ScrArea *a, ScrArea *b)
void ED_region_tag_redraw_cursor(ARegion *region)
void ED_region_tag_redraw_editor_overlays(ARegion *region)
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
void ED_region_tag_redraw(ARegion *region)
void ED_region_do_draw(bContext *C, ARegion *region)
void ED_region_cache_draw_cached_segments(ARegion *region, int num_segments, const int *points, int sfra, int efra)
void ED_area_swapspace(bContext *C, ScrArea *sa1, ScrArea *sa2)
void BLF_disable(int fontid, FontFlags flag)
void ED_region_clear(const bContext *C, const ARegion *region, int colorid)
bool ED_region_snap_size_apply(ARegion *region, int snap_flag)
static void area_calc_totrct(const bScreen *screen, ScrArea *area, const rcti *window_rect)
static void region_update_rect(ARegion *region)
void BLI_rcti_sanitize(struct rcti *rect)
ARegion * BKE_area_region_copy(const SpaceType *st, const ARegion *region)
void ED_area_tag_redraw_regiontype(ScrArea *area, int regiontype)
MINLINE void mul_v3_fl(float r[3], float f)
void GPU_line_width(float width)
static bool side_region_search_for_context(const bContext *C, ARegion *region, StringRef category)
@ RGN_ALIGN_HIDE_WITH_PREV
VecBase< float, 4 > float4
static void region_align_info_to_area_for_headers(const RegionTypeAlignInfo *region_align_info_src, const RegionTypeAlignInfo *region_align_info_dst, ARegion *region_by_type[RGN_TYPE_NUM])
void immAttr3fv(uint attr_id, const float data[3])
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
static void region_azones_add_edge(ScrArea *area, ARegion *region, const int alignment, const bool is_fullscreen)
int ED_region_global_size_y()
static void region_draw_azone_tab_arrow(ScrArea *area, ARegion *region, AZone *az)
void WM_event_modal_handler_area_replace(wmWindow *win, const ScrArea *old_area, ScrArea *new_area)
bool BKE_regiontype_uses_categories(const ARegionType *region_type)
int ED_area_global_min_size_y(const ScrArea *area)
void immUniformThemeColor(int color_id)
void BLF_size(int fontid, float size)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
void WM_event_remove_handlers(bContext *C, ListBaseT< wmEventHandler > *handlers)
void ED_region_draw_overflow_indication(const ScrArea *area, const ARegion *region, const rcti *mask=nullptr)
void ED_region_visibility_change_update_animated(bContext *C, ScrArea *area, ARegion *region)
wmEventHandler_Dropbox * WM_event_add_dropbox_handler(ListBaseT< wmEventHandler > *handlers, ListBaseT< wmDropBox > *dropboxes)
VecBase< int32_t, 2 > int2
Scene * WM_window_get_active_scene(const wmWindow *win)
VecBase< float, 2 > float2
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void immVertex2f(uint attr_id, float x, float y)
void ED_region_tag_refresh_ui(ARegion *region)
static void region_evaluate_visibility(ARegion *region)
BLI_INLINE int BLI_rcti_cent_y(const struct rcti *rct)
static void ed_workspace_status_icon_item(WorkSpace *workspace, const int icon, const bool inverted=false)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
static void region_overlap_fix(ScrArea *area, ARegion *region)
BMesh const char void * data
void ED_region_header_with_button_sections(const bContext *C, ARegion *region, ui::ButtonSectionsAlign align)
@ GPU_SHADER_3D_UNIFORM_COLOR
@ GPU_SHADER_3D_FLAT_COLOR
void GPU_scissor_get(int coords[4])
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
wmWindowManager * CTX_wm_manager(const bContext *C)
static bool panel_property_search(const bContext *C, ARegion *region, const uiStyle *style, Panel *panel, PanelType *panel_type, const char *search_filter)
void ED_area_offscreen_free(wmWindowManager *wm, wmWindow *win, ScrArea *area)
void BLI_rcti_union(struct rcti *rct_a, const struct rcti *rct_b)
static bool region_is_hidden(const ARegion *region)
static constexpr float STATUS_MOUSE_ICON_PAD
void ED_region_panels(const bContext *C, ARegion *region)
void ED_area_exit(bContext *C, ScrArea *area)
void BLI_rcti_translate(struct rcti *rect, int x, int y)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
static void ed_default_handlers(wmWindowManager *wm, ScrArea *area, ARegion *region, ListBaseT< wmEventHandler > *handlers, int flag)
bool ED_time_scrub_event_in_region_poll(const wmWindow *, const ScrArea *, const ARegion *region, const wmEvent *event)
static void area_init_type_fallback(ScrArea *area, eSpace_Type space_type)
void immUniformColor4f(float r, float g, float b, float a)
WorkSpace * WM_window_get_active_workspace(const wmWindow *win)
static void fullscreen_azone_init(ScrArea *area, ARegion *region)
wmKeyMap * WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void BLF_clipping(int fontid, int xmin, int ymin, int xmax, int ymax)
ARegionType * BKE_regiontype_from_id(const SpaceType *st, int regionid)
static void region_azone_scrollbar_init(ScrArea *area, ARegion *region, AZScrollDirection direction)
void ED_area_status_text(ScrArea *area, const char *str)
SpaceType * BKE_spacetype_from_id(int spaceid)
void ED_area_do_refresh(bContext *C, ScrArea *area)
void ED_area_tag_region_size_update(ScrArea *area, ARegion *changed_region)
void WM_event_get_keymap_from_toolsystem_with_gizmos(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result)
int ED_area_global_size_y(const ScrArea *area)
static void region_align_info_to_area(ScrArea *area, const RegionTypeAlignInfo region_align_info_src[RGN_TYPE_NUM])
static void region_draw_status_text(ScrArea *, ARegion *region)
void BKE_area_copy(ScrArea *area_dst, ScrArea *area_src)
static void draw_azone_arrow(float x1, float y1, float x2, float y2, AZEdge edge)
Edge widgets to show hidden panels such as the toolbar and headers.
void ED_area_do_mgs_subscribe_for_tool_ui(const wmRegionMessageSubscribeParams *params)
void ED_region_floating_init(ARegion *region)
wmEventHandler_Keymap * WM_event_add_keymap_handler(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap)
ScrArea * ED_screen_areas_iter_first(const wmWindow *win, const bScreen *screen)
void ED_region_image_metadata_panel_draw(ImBuf *ibuf, ui::Layout *layout)
void WM_msgbus_clear_by_owner(wmMsgBus *mbus, void *owner)
static void side_region_search_all_categories(const bContext *C, ARegion *region_original)
void ED_region_toggle_hidden(bContext *C, ARegion *region)
bool WM_gizmomap_cursor_set(const wmGizmoMap *gzmap, wmWindow *win)
const char * ED_userpref_search_string_get(SpaceUserPref *sprefs)
void GPU_matrix_translate_2f(float x, float y)
ScrArea ScrArea * BKE_screen_find_area_xy(const bScreen *screen, int spacetype, const int xy[2]) ATTR_NONNULL(1
void BLF_draw(int fontid, const char *str, size_t str_len, ResultBLF *r_info=nullptr) ATTR_NONNULL(2)
void ED_region_panels_layout_ex(const bContext *C, ARegion *region, ListBaseT< PanelType > *paneltypes, wm::OpCallContext op_context, const char *contexts[], const char *category_override)
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
static int panel_draw_width_from_max_width_get(const ARegion *region, const PanelType *panel_type, const int max_width)
static void side_region_search_move_next_category_with_result(const bContext *C, ARegion *region)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool WM_event_handler_region_marker_poll(const wmWindow *win, const ScrArea *area, const ARegion *region, const wmEvent *event)
void ED_region_message_subscribe(wmRegionMessageSubscribeParams *params)
static void area_offscreen_exit(wmWindowManager *wm, wmWindow *win, ScrArea *area)
bool area_regions_poll(bContext *C, const bScreen *screen, ScrArea *area)
wmEventHandler_Keymap * WM_event_add_keymap_handler_poll(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap, EventHandlerPoll poll)
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax)
void WM_msg_subscribe_rna(wmMsgBus *mbus, PointerRNA *ptr, const PropertyRNA *prop, const wmMsgSubscribeValue *msg_val_params, const char *id_repr)
@ WM_CAPABILITY_WINDOW_DECORATION_STYLES
ScrArea * ED_area_find_under_cursor(const bContext *C, int spacetype, const int event_xy[2])
void ED_region_visibility_change_update(bContext *C, ScrArea *area, ARegion *region)
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
SpaceImage * CTX_wm_space_image(const bContext *C)
void GPU_scissor(int x, int y, int width, int height)
void ED_region_header_draw_with_button_sections(const bContext *C, const ARegion *region, ui::ButtonSectionsAlign align)
void ED_area_and_region_types_init(ScrArea *area)
static void quadview_azone_init(ScrArea *area, ARegion *region)
void ED_region_pixelspace(const ARegion *region)
static short region_alignment_from_header_and_tool_header_state(const RegionTypeAlignInfo *region_align_info, const short fallback)
static void region_draw_azones(ScrArea *area, ARegion *region)
void ED_area_init(bContext *C, const wmWindow *win, ScrArea *area)
ScrArea * ED_area_offscreen_create(wmWindow *win, eSpace_Type space_type)
void wmPartialViewport(rcti *drawrct, const rcti *winrct, const rcti *partialrct)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_workspace_status_clear(WorkSpace *workspace)
Main * CTX_data_main(const bContext *C)
void ED_region_cursor_set(wmWindow *win, ScrArea *area, ARegion *region)
@ PANEL_TYPE_HEADER_EXPAND
@ PANEL_TYPE_LAYOUT_VERT_BAR
void ED_region_grid_draw(ARegion *region, float zoomx, float zoomy, float x0, float y0)
void imm_draw_box_wire_2d(uint pos, float x1, float y1, float x2, float y2)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
eWM_CapabilitiesFlag WM_capabilities_flag()
std::array< const char *, 4 > ED_view3d_buttons_contexts(const bContext *C)
@ USER_AREA_CORNER_HANDLE
wmGizmoMap * WM_gizmomap_new_from_type(const wmGizmoMapType_Params *gzmap_params)
int ED_area_global_max_size_y(const ScrArea *area)
void WM_window_title_refresh(wmWindowManager *wm, wmWindow *win)
void IMB_metadata_foreach(const ImBuf *ibuf, IMBMetadataForeachCb callback, void *userdata)
bool WM_toolsystem_refresh_screen_area(const Main &bmain, WorkSpace *workspace, const Scene *scene, ViewLayer *view_layer, ScrArea *area)
void ED_area_hud_region_set_padding_flag(ScrArea *area, ARegion *changed_region, const bool set_padding=false)
void ED_region_header_init(ARegion *region)
void BLI_str_rstrip(char *str) ATTR_NONNULL(1)
int ED_area_header_switchbutton(const bContext *C, ui::Block *block, int yco)
static SpaceLink * area_get_prevspace(ScrArea *area)
void GPU_vertformat_clear(GPUVertFormat *)
Scene * CTX_data_scene(const bContext *C)
bool BKE_region_panel_categories_search_filter_visible(const ARegion *region)
bScreen * CTX_wm_screen(const bContext *C)
void CTX_wm_region_set(bContext *C, ARegion *region)
void WM_cursor_set(wmWindow *win, int curs)
void WM_event_modal_handler_region_replace(wmWindow *win, const ARegion *old_region, ARegion *new_region)
void WM_event_timer_remove(wmWindowManager *wm, wmWindow *, wmTimer *timer)
MINLINE void copy_v4_v4(float r[4], const float a[4])
void ED_area_do_mgs_subscribe_for_tool_header(const wmRegionMessageSubscribeParams *params)
void ED_region_panels_layout(const bContext *C, ARegion *region)
void GPU_blend(GPUBlend blend)
@ RGN_FLAG_INDICATE_OVERFLOW
@ RGN_FLAG_SEARCH_FILTER_ACTIVE
@ RGN_FLAG_SEARCH_FILTER_UPDATE
void ED_area_tag_refresh(ScrArea *area)
void ED_region_header_layout(const bContext *C, ARegion *region)
void BLI_rcti_resize(struct rcti *rect, int x, int y)
void ED_region_do_msg_notify_tag_redraw(bContext *C, wmMsgSubscribeKey *msg_key, wmMsgSubscribeValue *msg_val)
void ED_region_info_draw_multiline(ARegion *region, const char *text_array[], const float fill_color[4], bool full_redraw)
BLI_INLINE int BLI_rcti_cent_x(const struct rcti *rct)
static constexpr float STATUS_BEFORE_TEXT
ListBaseT< wmDropBox > * WM_dropboxmap_find(const char *idname, int spaceid, int regionid)
static void region_azones_add(const bScreen *screen, ScrArea *area, ARegion *region)
void region_toggle_hidden(bContext *C, ARegion *region, const bool do_fade)
void ED_region_activate_rna_prop(bContext *C, ARegion *region, const void *data, StringRefNull prop_name)
void WM_event_add_mousemove(wmWindow *win)
void BLF_width_and_height(int fontid, const char *str, size_t str_len, float *r_width, float *r_height) ATTR_NONNULL()
void ED_region_tag_redraw_partial(ARegion *region, const rcti *rct, bool rebuild)
void WM_window_screen_rect_calc(const wmWindow *win, rcti *r_rect)
void ED_region_header(const bContext *C, ARegion *region)
bScreen * WM_window_get_active_screen(const wmWindow *win)
static void region_azone_tab_plus(ScrArea *area, AZone *az, ARegion *region)
static void ed_workspace_status_space(WorkSpace *workspace, const float space_factor)
MINLINE int min_ii(int a, int b)
void immRectf(uint pos, float x1, float y1, float x2, float y2)
void ED_region_panels_draw(const bContext *C, ARegion *region)
void side_region_property_search(const bContext *C, ARegion *region)
ARegion * CTX_wm_region(const bContext *C)
void WM_event_get_keymap_from_toolsystem(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result)
void ED_workspace_status_text(bContext *C, const char *str)
void ED_region_panels_init(wmWindowManager *wm, ARegion *region)
void ED_region_tag_redraw_no_rebuild(ARegion *region)
void ED_region_cache_draw_curfra_label(int framenr, float x, float y)
int ED_region_snap_size_test(const ARegion *region)
@ USER_APP_LOCK_CORNER_SPLIT
@ USER_APP_HIDE_REGION_TOGGLE
@ USER_APP_LOCK_EDGE_RESIZE
void ED_region_info_draw(ARegion *region, const char *text, const float fill_color[4], bool full_redraw)
static void side_panel_draw_search_block(const bContext *C, ARegion *region)
void BLF_enable(int fontid, FontFlags flag)
View3D * CTX_wm_view3d(const bContext *C)
bool WM_window_is_fullscreen(const wmWindow *win)
@ AREA_FLAG_REGION_SIZE_UPDATE
@ AREA_FLAG_ACTIONZONES_UPDATE
@ AREA_FLAG_ACTIVE_TOOL_UPDATE
@ AREA_FLAG_STACKED_FULLSCREEN
bool ED_area_is_global(const ScrArea *area)
static void metadata_panel_draw_field(const char *field, const char *value, void *ctx_v)
void ED_area_tag_redraw(ScrArea *area)
std::array< const char *, 4 > ED_image_buttons_contexts(const bContext *C)
static void area_draw_azone_fullscreen(short, short, short x2, short y2, float alpha)
Corner widget use for quitting full-screen.
void ED_area_do_listen(wmSpaceTypeListenerParams *params)
void void BLI_INLINE bool BLI_listbase_is_single(const ListBase *lb)
void CTX_wm_area_set(bContext *C, ScrArea *area)
@ SPACE_FLAG_TYPE_WAS_ACTIVE
@ SPACE_FLAG_TYPE_TEMPORARY
static void ed_panel_draw(const bContext *C, ARegion *region, ListBaseT< Panel > *lb, PanelType *pt, Panel *panel, int w, int em, char *unique_panel_str, const char *search_filter, wm::OpCallContext op_context)
void screen_area_spacelink_add(const Scene *scene, ScrArea *area, eSpace_Type space_type)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void(*) exit(wmWindowManager *wm, ARegion *region)
void(*) cursor(wmWindow *win, ScrArea *area, ARegion *region)
int(*) snap_size(const ARegion *region, int size, int axis)
void(*) message_subscribe(const wmRegionMessageSubscribeParams *params)
void(*) draw(const bContext *C, ARegion *region)
ListBaseT< HeaderType > headertypes
void(*) listener(const wmRegionListenerParams *params)
void(*) layout(const bContext *C, ARegion *region)
std::optional< ARegionIMECursorState >(*) cursor_ime(wmWindow *win, const ScrArea *area, const ARegion *region, ARegionIMECursor *r_cursor)
ListBaseT< PanelType > paneltypes
void(*) init(wmWindowManager *wm, ARegion *region)
ListBaseT< uiList > ui_lists
ListBaseT< Panel > panels
bke::ARegionRuntime * runtime
eRegion_Alignment alignment
ListBaseT< PanelCategoryStack > panels_category_active
ListBaseT< LinkData > children
void(*) draw_header_preset(const bContext *C, Panel *panel)
char context[BKE_ST_MAXNAME]
void(*) draw(const bContext *C, Panel *panel)
char category[BKE_ST_MAXNAME]
bool(*) poll(const bContext *C, PanelType *pt)
void(*) draw_header(const bContext *C, Panel *panel)
char idname[BKE_ST_MAXNAME]
LayoutPanels layout_panels
ListBaseT< Panel > children
struct Panel_Runtime * runtime
struct blender::RegionTypeAlignInfo::@330321312102166170135030316252357105161245251177 by_type[RGN_TYPE_NUM]
ListBaseT< ScrArea > areabase
ListBaseT< struct wmEventHandler > handlers
ListBaseT< struct AZone > actionzones
ListBaseT< ARegion > regionbase
short butspacetype_subtype
ListBaseT< SpaceLink > spacedata
ScrGlobalAreaData * global
eSpace_Link_Flag link_flag
ListBaseT< ARegion > regionbase
int(*) space_subtype_get(ScrArea *area)
void(*) init(wmWindowManager *wm, ScrArea *area)
SpaceLink *(*) create(const ScrArea *area, const Scene *scene)
void(*) refresh(const bContext *C, ScrArea *area)
void(*) free(SpaceLink *sl)
void(*) exit(wmWindowManager *wm, ScrArea *area)
void(*) space_subtype_item_extend(bContext *C, EnumPropertyItem **item, int *totitem)
void(*) space_subtype_set(ScrArea *area, int value)
void(*) listener(const wmSpaceTypeListenerParams *params)
bke::WorkSpaceRuntime * runtime
struct wmTimer * animtimer
struct ARegion * active_region
ListBaseT< struct ScrArea > areabase
ListBaseT< wmEventHandler > handlers
Vector< std::function< void(const bContext &C, ui::Block &Block)> > post_block_layout_fns
ListBaseT< ui::Block > uiblocks
ListBaseT< PanelCategoryDyn > panels_category
ARegionQuadviewIndex quadview_index
short do_draw_paintcursor
struct ARegionType * type
std::string search_filter
Set< std::string > categories_search_match
Vector< WorkSpaceStatusItem > status
void operator_context_set(wm::OpCallContext opcontext)
void label(StringRef name, int icon)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
void scale_y_set(float scale)
const wmNotifier * notifier
bke::WindowRuntime * runtime
struct WorkSpaceInstanceHook * workspace_hook
#define WM_msg_subscribe_rna_prop(mbus, id_, data_, type_, prop_, value)