area.cc

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2008 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#include <algorithm>
#include <cstdio>
#include <cstring>
 
#include "MEM_guardedalloc.h"
 
#include "DNA_userdef_types.h"
 
#include "BLI_linklist.h"
#include "BLI_listbase.h"
#include "BLI_math_vector.h"
#include "BLI_rand.hh"
#include "BLI_string.h"
#include "BLI_string_utf8.h"
#include "BLI_string_utils.hh"
#include "BLI_utildefines.h"
 
#include "BKE_context.hh"
#include "BKE_global.hh"
#include "BKE_screen.hh"
#include "BKE_workspace.hh"
 
#include "RNA_access.hh"
 
#include "WM_api.hh"
#include "WM_message.hh"
#include "WM_toolsystem.hh"
#include "WM_types.hh"
 
#include "ED_asset_shelf.hh"
#include "ED_buttons.hh"
#include "ED_screen.hh"
#include "ED_screen_types.hh"
#include "ED_space_api.hh"
#include "ED_time_scrub_ui.hh"
 
#include "GPU_framebuffer.hh"
#include "GPU_immediate.hh"
#include "GPU_immediate_util.hh"
#include "GPU_matrix.hh"
#include "GPU_platform.hh"
#include "GPU_state.hh"
 
#include "BLF_api.hh"
 
#include "IMB_metadata.hh"
 
#include "UI_interface.hh"
#include "UI_interface_icons.hh"
#include "UI_interface_layout.hh"
#include "UI_resources.hh"
#include "UI_view2d.hh"
 
#include "screen_intern.hh"
 
/* general area and region code */
 
static void region_draw_gradient(const ARegion *region)
{
  if (region->v2d.cur.xmax >= region->v2d.tot.xmax) {
    /* No overflow. */
    return;
  }
 
  float opaque[4];
  UI_GetThemeColor4fv(TH_HEADER, opaque);
  float transparent[4];
  UI_GetThemeColor3fv(TH_HEADER, transparent);
  transparent[3] = 0.0f;
 
  rctf rect{};
  rect.xmax = BLI_rcti_size_x(&region->winrct) + 1;
  rect.xmin = rect.xmax - (25.0f * UI_SCALE_FAC);
  rect.ymin = 0.0f;
  rect.ymax = BLI_rcti_size_y(&region->winrct) + 1;
  UI_draw_roundbox_4fv_ex(&rect, opaque, transparent, 0.0f, nullptr, 0.0f, 0.0f);
}
 
void ED_region_pixelspace(const ARegion *region)
{
  wmOrtho2_region_pixelspace(region);
  GPU_matrix_identity_set();
}
 
void ED_region_do_listen(wmRegionListenerParams *params)
{
  ARegion *region = params->region;
  const wmNotifier *notifier = params->notifier;
 
  /* generic notes first */
  switch (notifier->category) {
    case NC_WM:
      if (notifier->data == ND_FILEREAD) {
        ED_region_tag_redraw(region);
      }
      break;
    case NC_WINDOW:
      ED_region_tag_redraw(region);
      break;
  }
 
  if (region->runtime->type && region->runtime->type->listener) {
    region->runtime->type->listener(params);
  }
 
  LISTBASE_FOREACH (uiBlock *, block, &region->runtime->uiblocks) {
    UI_block_listen(block, params);
  }
 
  LISTBASE_FOREACH (uiList *, list, &region->ui_lists) {
    if (list->type && list->type->listener) {
      list->type->listener(list, params);
    }
  }
}
 
void ED_area_do_listen(wmSpaceTypeListenerParams *params)
{
  /* no generic notes? */
  if (params->area->type && params->area->type->listener) {
    params->area->type->listener(params);
  }
}
 
void ED_area_do_refresh(bContext *C, ScrArea *area)
{
  /* no generic notes? */
  if (area->type && area->type->refresh) {
    area->type->refresh(C, area);
  }
  area->do_refresh = false;
}

static void area_draw_azone_fullscreen(short /*x1*/, short /*y1*/, short x2, short y2, float alpha)
{
  UI_icon_draw_ex(x2 - U.widget_unit,
                  y2 - U.widget_unit,
                  ICON_FULLSCREEN_EXIT,
                  UI_INV_SCALE_FAC,
                  min_ff(alpha, 0.75f),
                  0.0f,
                  nullptr,
                  false,
                  UI_NO_ICON_OVERLAY_TEXT);
}

static void area_draw_azone(ScrArea *area, ARegion *region, AZone *az)
{
  if (region->regiontype != RGN_TYPE_HEADER || !(U.uiflag & USER_AREA_CORNER_HANDLE)) {
    return;
  }
 
  if (az->x1 < area->totrct.xmin + 1) {
    if ((region->alignment == RGN_ALIGN_TOP && az->y2 > area->totrct.ymax - 1) ||
        (region->alignment == RGN_ALIGN_BOTTOM && az->y1 < area->totrct.ymin + 1))
    {
      UI_icon_draw_alpha(
          float(az->x1) + UI_SCALE_FAC, float(az->y1) + (6.0f * UI_SCALE_FAC), ICON_GRIP_V, 0.4f);
    }
  }
}

static void draw_azone_arrow(float x1, float y1, float x2, float y2, AZEdge edge)
{
  const float size = 0.2f * U.widget_unit;
  const float l = 1.0f;  /* arrow length */
  const float s = 0.25f; /* arrow thickness */
  const float hl = l / 2.0f;
  const float points[6][2] = {
      {0, -hl}, {l, hl}, {l - s, hl + s}, {0, s + s - hl}, {s - l, hl + s}, {-l, hl}};
  const float center[2] = {(x1 + x2) / 2, (y1 + y2) / 2};
 
  int axis;
  int sign;
  switch (edge) {
    case AE_BOTTOM_TO_TOPLEFT:
      axis = 0;
      sign = 1;
      break;
    case AE_TOP_TO_BOTTOMRIGHT:
      axis = 0;
      sign = -1;
      break;
    case AE_LEFT_TO_TOPRIGHT:
      axis = 1;
      sign = 1;
      break;
    case AE_RIGHT_TO_TOPLEFT:
      axis = 1;
      sign = -1;
      break;
    default:
      BLI_assert(0);
      return;
  }
 
  GPUVertFormat *format = immVertexFormat();
  uint pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
 
  GPU_blend(GPU_BLEND_ALPHA);
  immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
  immUniformColor4f(0.8f, 0.8f, 0.8f, 0.4f);
 
  immBegin(GPU_PRIM_TRI_FAN, 6);
  for (int i = 0; i < 6; i++) {
    if (axis == 0) {
      immVertex2f(pos, center[0] + points[i][0] * size, center[1] + points[i][1] * sign * size);
    }
    else {
      immVertex2f(pos, center[0] + points[i][1] * sign * size, center[1] + points[i][0] * size);
    }
  }
  immEnd();
 
  immUnbindProgram();
  GPU_blend(GPU_BLEND_NONE);
}
 
static void region_draw_azone_tab_arrow(ScrArea *area, ARegion *region, AZone *az)
{
  GPU_blend(GPU_BLEND_ALPHA);
 
  /* add code to draw region hidden as 'too small' */
  switch (az->edge) {
    case AE_TOP_TO_BOTTOMRIGHT:
      UI_draw_roundbox_corner_set(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
      break;
    case AE_BOTTOM_TO_TOPLEFT:
      UI_draw_roundbox_corner_set(UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT);
      break;
    case AE_LEFT_TO_TOPRIGHT:
      UI_draw_roundbox_corner_set(UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT);
      break;
    case AE_RIGHT_TO_TOPLEFT:
      UI_draw_roundbox_corner_set(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
      break;
  }
 
  /* Workaround for different color spaces between normal areas and the ones using GPUViewports. */
  float alpha = WM_region_use_viewport(area, region) ? 0.6f : 0.4f;
  const float color[4] = {0.05f, 0.05f, 0.05f, alpha};
  rctf rect{};
  /* Hit size is a bit larger than visible background. */
  rect.xmin = float(az->x1) + U.pixelsize;
  rect.xmax = float(az->x2) - U.pixelsize;
  rect.ymin = float(az->y1) + U.pixelsize;
  rect.ymax = float(az->y2) - U.pixelsize;
  UI_draw_roundbox_aa(&rect, true, 4.0f, color);
 
  draw_azone_arrow(float(az->x1), float(az->y1), float(az->x2), float(az->y2), az->edge);
}
 
static void area_azone_tag_update(ScrArea *area)
{
  area->flag |= AREA_FLAG_ACTIONZONES_UPDATE;
}
 
static void region_draw_azones(ScrArea *area, ARegion *region)
{
  if (!area) {
    return;
  }
 
  GPU_line_width(1.0f);
  GPU_blend(GPU_BLEND_ALPHA);
 
  GPU_matrix_push();
  GPU_matrix_translate_2f(-region->winrct.xmin, -region->winrct.ymin);
 
  LISTBASE_FOREACH (AZone *, az, &area->actionzones) {
    /* test if action zone is over this region */
    rcti azrct;
    BLI_rcti_init(&azrct, az->x1, az->x2, az->y1, az->y2);
 
    if (BLI_rcti_isect(&region->runtime->drawrct, &azrct, nullptr)) {
      if (az->type == AZONE_AREA) {
        area_draw_azone(area, region, az);
      }
      else if (az->type == AZONE_REGION) {
        if (az->region && !(az->region->flag & RGN_FLAG_POLL_FAILED)) {
          /* only display tab or icons when the region is hidden */
          if (az->region->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL)) {
            region_draw_azone_tab_arrow(area, region, az);
          }
        }
      }
      else if (az->type == AZONE_FULLSCREEN) {
        if (az->alpha > 0.0f) {
          area_draw_azone_fullscreen(az->x1, az->y1, az->x2, az->y2, az->alpha);
        }
      }
    }
    if (!IS_EQF(az->alpha, 0.0f) && ELEM(az->type, AZONE_FULLSCREEN, AZONE_REGION_SCROLL)) {
      area_azone_tag_update(area);
    }
  }
 
  GPU_matrix_pop();
 
  GPU_blend(GPU_BLEND_NONE);
}
 
static void region_draw_status_text(ScrArea * /*area*/, ARegion *region)
{
  float header_color[4];
  UI_GetThemeColor4fv(TH_HEADER, header_color);
 
  /* Clear the region from the buffer. */
  GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f);
 
  /* Fill with header color when the region is not overlapped. */
  if (!region->overlap) {
    const rctf rect = {0.0f, float(region->winx), 0.0f, float(region->winy)};
    UI_draw_roundbox_3fv_alpha(&rect, true, 0.0f, header_color, 1.0f);
  }
 
  const int fontid = BLF_set_default();
  float x = 12.0f * UI_SCALE_FAC;
  const float y = 0.4f * UI_UNIT_Y;
  const float width = BLF_width(fontid, region->runtime->headerstr, BLF_DRAW_STR_DUMMY_MAX);
  GPU_blend(GPU_BLEND_ALPHA);
 
  /* Draw a background behind the text for extra contrast. */
  if (region->overlap) {
    /* Center the text horizontally. */
    x = (region->winx - width) / 2.0f;
    const float pad = 5.0f * UI_SCALE_FAC;
    const float x1 = x - pad;
    const float x2 = x + width + pad;
    const float y1 = 3.0f * UI_SCALE_FAC;
    const float y2 = region->winy - (4.0f * UI_SCALE_FAC);
    /* Ensure header_color is not too transparent. */
    header_color[3] = std::max(header_color[3], 0.6f);
    UI_draw_roundbox_corner_set(UI_CNR_ALL);
    const rctf rect = {x1, x2, y1, y2};
    UI_draw_roundbox_4fv(&rect, true, 4.0f * UI_SCALE_FAC, header_color);
  }
 
  UI_FontThemeColor(fontid, TH_TEXT);
  BLF_position(fontid, x, y, 0.0f);
  BLF_draw(fontid, region->runtime->headerstr, BLF_DRAW_STR_DUMMY_MAX);
}
 
void ED_region_do_msg_notify_tag_redraw(
    /* Follow wmMsgNotifyFn spec */
    bContext * /*C*/,
    wmMsgSubscribeKey * /*msg_key*/,
    wmMsgSubscribeValue *msg_val)
{
  ARegion *region = static_cast<ARegion *>(msg_val->owner);
  ED_region_tag_redraw(region);
 
  /* This avoids _many_ situations where header/properties control display settings.
   * the common case is space properties in the header */
  if (ELEM(region->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER, RGN_TYPE_UI)) {
    while (region && region->prev) {
      region = region->prev;
    }
    for (; region; region = region->next) {
      if (ELEM(region->regiontype, RGN_TYPE_WINDOW, RGN_TYPE_CHANNELS)) {
        ED_region_tag_redraw(region);
      }
    }
  }
}
 
void ED_area_do_msg_notify_tag_refresh(
    /* Follow wmMsgNotifyFn spec */
    bContext * /*C*/,
    wmMsgSubscribeKey * /*msg_key*/,
    wmMsgSubscribeValue *msg_val)
{
  ScrArea *area = static_cast<ScrArea *>(msg_val->user_data);
  ED_area_tag_refresh(area);
}
 
void ED_area_do_mgs_subscribe_for_tool_header(const wmRegionMessageSubscribeParams *params)
{
  wmMsgBus *mbus = params->message_bus;
  WorkSpace *workspace = params->workspace;
  ARegion *region = params->region;
 
  BLI_assert(region->regiontype == RGN_TYPE_TOOL_HEADER);
  wmMsgSubscribeValue msg_sub_value_region_tag_redraw{};
  msg_sub_value_region_tag_redraw.owner = region;
  msg_sub_value_region_tag_redraw.user_data = region;
  msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw;
  WM_msg_subscribe_rna_prop(
      mbus, &workspace->id, workspace, WorkSpace, tools, &msg_sub_value_region_tag_redraw);
}
 
void ED_area_do_mgs_subscribe_for_tool_ui(const wmRegionMessageSubscribeParams *params)
{
  wmMsgBus *mbus = params->message_bus;
  WorkSpace *workspace = params->workspace;
  ARegion *region = params->region;
 
  BLI_assert(region->regiontype == RGN_TYPE_UI);
  const char *panel_category_tool = "Tool";
  const char *category = UI_panel_category_active_get(region, false);
 
  bool update_region = false;
  if (category && STREQ(category, panel_category_tool)) {
    update_region = true;
  }
  else {
    /* Check if a tool category panel is pinned and visible in another category. */
    LISTBASE_FOREACH (Panel *, panel, &region->panels) {
      if (UI_panel_is_active(panel) && panel->flag & PNL_PIN &&
          STREQ(panel->type->category, panel_category_tool))
      {
        update_region = true;
        break;
      }
    }
  }
 
  if (update_region) {
    wmMsgSubscribeValue msg_sub_value_region_tag_redraw{};
    msg_sub_value_region_tag_redraw.owner = region;
    msg_sub_value_region_tag_redraw.user_data = region;
    msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw;
    WM_msg_subscribe_rna_prop(
        mbus, &workspace->id, workspace, WorkSpace, tools, &msg_sub_value_region_tag_redraw);
  }
}

static bool area_is_pseudo_minimized(const ScrArea *area)
{
  return (area->winx < 3) || (area->winy < 3);
}
 
void ED_region_do_layout(bContext *C, ARegion *region)
{
  /* This is optional, only needed for dynamically sized regions. */
  ScrArea *area = CTX_wm_area(C);
  ARegionType *at = region->runtime->type;
 
  if (!at->layout) {
    return;
  }
 
  if (at->do_lock || (area && area_is_pseudo_minimized(area))) {
    return;
  }
 
  region->runtime->do_draw |= RGN_DRAWING;
 
  UI_SetTheme(area ? area->spacetype : 0, at->regionid);
  at->layout(C, region);
 
  /* Clear temporary update flag. */
  region->flag &= ~RGN_FLAG_SEARCH_FILTER_UPDATE;
}
 
void ED_region_do_draw(bContext *C, ARegion *region)
{
  using namespace blender;
  wmWindow *win = CTX_wm_window(C);
  ScrArea *area = CTX_wm_area(C);
  ARegionType *at = region->runtime->type;
 
  /* see BKE_spacedata_draw_locks() */
  if (at->do_lock) {
    return;
  }
 
  region->runtime->do_draw |= RGN_DRAWING;
 
  /* Set viewport, scissor, ortho and region->runtime->drawrct. */
  wmPartialViewport(&region->runtime->drawrct, &region->winrct, &region->runtime->drawrct);
 
  wmOrtho2_region_pixelspace(region);
 
  UI_SetTheme(area ? area->spacetype : 0, at->regionid);
 
  if (area && area_is_pseudo_minimized(area)) {
    UI_ThemeClearColor(TH_EDITOR_BORDER);
    return;
  }
  /* optional header info instead? */
  if (region->runtime->headerstr) {
    region_draw_status_text(area, region);
  }
  else if (at->draw) {
    at->draw(C, region);
  }
 
  /* XXX test: add convention to end regions always in pixel space,
   * for drawing of borders/gestures etc */
  ED_region_pixelspace(region);
 
  /* Remove sRGB override by rebinding the framebuffer. */
  blender::gpu::FrameBuffer *fb = GPU_framebuffer_active_get();
  GPU_framebuffer_bind(fb);
 
  ED_region_draw_cb_draw(C, region, REGION_DRAW_POST_PIXEL);
 
  region_draw_azones(area, region);
 
  /* for debugging unneeded area redraws and partial redraw */
  if (G.debug_value == 888) {
    GPU_blend(GPU_BLEND_ALPHA);
    GPUVertFormat *format = immVertexFormat();
    uint pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
    immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
    RandomNumberGenerator rng = RandomNumberGenerator::from_random_seed();
    immUniformColor4f(rng.get_float(), rng.get_float(), rng.get_float(), 0.1f);
    immRectf(pos,
             region->runtime->drawrct.xmin - region->winrct.xmin,
             region->runtime->drawrct.ymin - region->winrct.ymin,
             region->runtime->drawrct.xmax - region->winrct.xmin,
             region->runtime->drawrct.ymax - region->winrct.ymin);
    immUnbindProgram();
    GPU_blend(GPU_BLEND_NONE);
  }
 
  region->runtime->drawrct = rcti{};
 
  UI_blocklist_free_inactive(C, region);
 
  if (area) {
    const bScreen *screen = WM_window_get_active_screen(win);
 
    /* Only region gradient for Top Bar. */
    if ((screen->state != SCREENFULL) && area->spacetype == SPACE_TOPBAR &&
        region->regiontype == RGN_TYPE_HEADER)
    {
      region_draw_gradient(region);
    }
    else if ((region->regiontype == RGN_TYPE_WINDOW) && (region->alignment == RGN_ALIGN_QSPLIT)) {
 
      /* draw separating lines between the quad views */
 
      float color[4] = {0.0f, 0.0f, 0.0f, 0.8f};
      UI_GetThemeColor3fv(TH_EDITOR_BORDER, color);
      GPUVertFormat *format = immVertexFormat();
      uint pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
      immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
      immUniformColor4fv(color);
      GPU_line_width(1.0f);
      imm_draw_box_wire_2d(pos,
                           0,
                           0,
                           region->winrct.xmax - region->winrct.xmin + 1,
                           region->winrct.ymax - region->winrct.ymin + 1);
      immUnbindProgram();
    }
  }
 
  /* We may want to detach message-subscriptions from drawing. */
  {
    WorkSpace *workspace = CTX_wm_workspace(C);
    wmWindowManager *wm = CTX_wm_manager(C);
    bScreen *screen = WM_window_get_active_screen(win);
    Scene *scene = CTX_data_scene(C);
    wmMsgBus *mbus = wm->runtime->message_bus;
    WM_msgbus_clear_by_owner(mbus, region);
 
    /* Cheat, always subscribe to this space type properties.
     *
     * This covers most cases and avoids copy-paste similar code for each space type.
     */
    if (ELEM(region->regiontype, RGN_TYPE_WINDOW, RGN_TYPE_CHANNELS, RGN_TYPE_UI, RGN_TYPE_TOOLS))
    {
      SpaceLink *sl = static_cast<SpaceLink *>(area->spacedata.first);
 
      PointerRNA ptr = RNA_pointer_create_discrete(&screen->id, &RNA_Space, sl);
 
      /* All properties for this space type. */
      wmMsgSubscribeValue msg_sub_value_region_tag_redraw{};
      msg_sub_value_region_tag_redraw.owner = region;
      msg_sub_value_region_tag_redraw.user_data = region;
      msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw;
      WM_msg_subscribe_rna(mbus, &ptr, nullptr, &msg_sub_value_region_tag_redraw, __func__);
    }
 
    wmRegionMessageSubscribeParams message_subscribe_params{};
    message_subscribe_params.context = C;
    message_subscribe_params.message_bus = mbus;
    message_subscribe_params.workspace = workspace;
    message_subscribe_params.scene = scene;
    message_subscribe_params.screen = screen;
    message_subscribe_params.area = area;
    message_subscribe_params.region = region;
    ED_region_message_subscribe(&message_subscribe_params);
  }
}
 
/* **********************************
 * maybe silly, but let's try for now
 * to keep these tags protected
 * ********************************** */
 
void ED_region_tag_redraw(ARegion *region)
{
  /* don't tag redraw while drawing, it shouldn't happen normally
   * but python scripts can cause this to happen indirectly */
  if (region && !(region->runtime->do_draw & RGN_DRAWING)) {
    /* zero region means full region redraw */
    region->runtime->do_draw &= ~(RGN_DRAW_PARTIAL | RGN_DRAW_NO_REBUILD |
                                  RGN_DRAW_EDITOR_OVERLAYS);
    region->runtime->do_draw |= RGN_DRAW;
    region->runtime->drawrct = rcti{};
  }
}
 
void ED_region_tag_redraw_cursor(ARegion *region)
{
  if (region) {
    region->runtime->do_draw_paintcursor = RGN_DRAW;
  }
}
 
void ED_region_tag_redraw_no_rebuild(ARegion *region)
{
  if (region && !(region->runtime->do_draw & (RGN_DRAWING | RGN_DRAW))) {
    region->runtime->do_draw &= ~(RGN_DRAW_PARTIAL | RGN_DRAW_EDITOR_OVERLAYS);
    region->runtime->do_draw |= RGN_DRAW_NO_REBUILD;
    region->runtime->drawrct = rcti{};
  }
}
 
void ED_region_tag_refresh_ui(ARegion *region)
{
  if (region) {
    region->runtime->do_draw |= RGN_REFRESH_UI;
  }
}
 
void ED_region_tag_redraw_editor_overlays(ARegion *region)
{
  if (region && !(region->runtime->do_draw & (RGN_DRAWING | RGN_DRAW))) {
    if (region->runtime->do_draw & RGN_DRAW_PARTIAL) {
      ED_region_tag_redraw(region);
    }
    else {
      region->runtime->do_draw |= RGN_DRAW_EDITOR_OVERLAYS;
    }
  }
}
 
void ED_region_tag_redraw_partial(ARegion *region, const rcti *rct, bool rebuild)
{
  if (region && !(region->runtime->do_draw & RGN_DRAWING)) {
    if (region->runtime->do_draw & RGN_DRAW_PARTIAL) {
      /* Partial redraw already set, expand region. */
      BLI_rcti_union(&region->runtime->drawrct, rct);
      if (rebuild) {
        region->runtime->do_draw &= ~RGN_DRAW_NO_REBUILD;
      }
    }
    else if (region->runtime->do_draw & (RGN_DRAW | RGN_DRAW_NO_REBUILD)) {
      /* Full redraw already requested. */
      if (rebuild) {
        region->runtime->do_draw &= ~RGN_DRAW_NO_REBUILD;
      }
    }
    else {
      /* No redraw set yet, set partial region. */
      region->runtime->drawrct = *rct;
      region->runtime->do_draw |= RGN_DRAW_PARTIAL;
      if (!rebuild) {
        region->runtime->do_draw |= RGN_DRAW_NO_REBUILD;
      }
    }
  }
}
 
void ED_area_tag_redraw(ScrArea *area)
{
  if (area) {
    LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
      ED_region_tag_redraw(region);
    }
  }
}
 
void ED_area_tag_redraw_no_rebuild(ScrArea *area)
{
  if (area) {
    LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
      ED_region_tag_redraw_no_rebuild(region);
    }
  }
}
 
void ED_area_tag_redraw_regiontype(ScrArea *area, int regiontype)
{
  if (area) {
    LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
      if (region->regiontype == regiontype) {
        ED_region_tag_redraw(region);
      }
    }
  }
}
 
void ED_area_tag_refresh(ScrArea *area)
{
  if (area) {
    area->do_refresh = true;
  }
}
 
void ED_area_tag_region_size_update(ScrArea *area, ARegion *changed_region)
{
  if (!area || (area->flag & AREA_FLAG_REGION_SIZE_UPDATE)) {
    return;
  }
 
  area->flag |= AREA_FLAG_REGION_SIZE_UPDATE;
 
  /* Floating regions don't affect other regions, so the following can be skipped. */
  if (changed_region->alignment == RGN_ALIGN_FLOAT) {
    return;
  }
 
  /* Tag the following regions for redraw, since the size change of this region may affect the
   * available space for them. */
  for (ARegion *following_region = changed_region->next; following_region;
       following_region = following_region->next)
  {
    /* Overlapping and non-overlapping regions don't affect each others space. So layout changes
     * of one don't require redrawing the other. */
    if (changed_region->overlap != following_region->overlap) {
      continue;
    }
    /* Floating regions don't affect space of other regions. */
    if (following_region->alignment == RGN_ALIGN_FLOAT) {
      continue;
    }
    ED_region_tag_redraw(following_region);
  }
}
 
/* *************************************************************** */
 
int ED_area_max_regionsize(const ScrArea *area, const ARegion *scale_region, const AZEdge edge)
{
  int dist;
 
  /* regions in regions. */
  if (scale_region->alignment & RGN_SPLIT_PREV) {
    const int align = RGN_ALIGN_ENUM_FROM_MASK(scale_region->alignment);
 
    if (ELEM(align, RGN_ALIGN_TOP, RGN_ALIGN_BOTTOM)) {
      ARegion *region = scale_region->prev;
      dist = region->winy + scale_region->winy - U.pixelsize;
    }
    else /* if (ELEM(align, RGN_ALIGN_LEFT, RGN_ALIGN_RIGHT)) */ {
      ARegion *region = scale_region->prev;
      dist = region->winx + scale_region->winx - U.pixelsize;
    }
  }
  else {
    if (ELEM(edge, AE_RIGHT_TO_TOPLEFT, AE_LEFT_TO_TOPRIGHT)) {
      dist = BLI_rcti_size_x(&area->totrct);
    }
    else { /* AE_BOTTOM_TO_TOPLEFT, AE_TOP_TO_BOTTOMRIGHT */
      dist = BLI_rcti_size_y(&area->totrct);
    }
 
    /* Subtract the width of regions on opposite side
     * prevents dragging regions into other opposite regions. */
    LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
      if (region == scale_region) {
        continue;
      }
 
      if (scale_region->alignment == RGN_ALIGN_LEFT && region->alignment == RGN_ALIGN_RIGHT) {
        dist -= region->winx;
      }
      else if (scale_region->alignment == RGN_ALIGN_RIGHT && region->alignment == RGN_ALIGN_LEFT) {
        dist -= region->winx;
      }
      else if (scale_region->alignment == RGN_ALIGN_TOP &&
               (region->alignment == RGN_ALIGN_BOTTOM || ELEM(region->regiontype,
                                                              RGN_TYPE_HEADER,
                                                              RGN_TYPE_TOOL_HEADER,
                                                              RGN_TYPE_FOOTER,
                                                              RGN_TYPE_ASSET_SHELF_HEADER)))
      {
        dist -= region->winy;
      }
      else if (scale_region->alignment == RGN_ALIGN_BOTTOM &&
               (region->alignment == RGN_ALIGN_TOP || ELEM(region->regiontype,
                                                           RGN_TYPE_HEADER,
                                                           RGN_TYPE_TOOL_HEADER,
                                                           RGN_TYPE_FOOTER,
                                                           RGN_TYPE_ASSET_SHELF_HEADER)))
      {
        dist -= region->winy;
      }
    }
  }
 
  dist /= UI_SCALE_FAC;
  return dist;
}
 
const char *ED_area_region_search_filter_get(const ScrArea *area, const ARegion *region)
{
  /* Only the properties editor has a search string for now. */
  if (area->spacetype == SPACE_PROPERTIES) {
    SpaceProperties *sbuts = static_cast<SpaceProperties *>(area->spacedata.first);
    if (region->regiontype == RGN_TYPE_WINDOW) {
      return ED_buttons_search_string_get(sbuts);
    }
  }
 
  return nullptr;
}
 
void ED_region_search_filter_update(const ScrArea *area, ARegion *region)
{
  region->flag |= RGN_FLAG_SEARCH_FILTER_UPDATE;
 
  const char *search_filter = ED_area_region_search_filter_get(area, region);
  SET_FLAG_FROM_TEST(region->flag,
                     region->regiontype == RGN_TYPE_WINDOW && search_filter &&
                         search_filter[0] != '\0',
                     RGN_FLAG_SEARCH_FILTER_ACTIVE);
}
 
/* *************************************************************** */
 
void ED_area_status_text(ScrArea *area, const char *str)
{
  /* happens when running transform operators in background mode */
  if (area == nullptr) {
    return;
  }
 
  ARegion *ar = nullptr;
 
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    if (region->regiontype == RGN_TYPE_HEADER && region->runtime->visible) {
      ar = region;
    }
    else if (region->regiontype == RGN_TYPE_TOOL_HEADER && region->runtime->visible) {
      /* Prefer tool header when we also have a header. */
      ar = region;
      break;
    }
  }
 
  if (ar) {
    if (str) {
      if (ar->runtime->headerstr == nullptr) {
        ar->runtime->headerstr = MEM_malloc_arrayN<char>(UI_MAX_DRAW_STR, "headerprint");
      }
      BLI_strncpy_utf8(ar->runtime->headerstr, str, UI_MAX_DRAW_STR);
      BLI_str_rstrip(ar->runtime->headerstr);
    }
    else {
      MEM_SAFE_FREE(ar->runtime->headerstr);
    }
    ED_region_tag_redraw(ar);
  }
}
 
/* *************************************************************** */
 
static void ed_workspace_status_item(WorkSpace *workspace,
                                     std::string text,
                                     const int icon,
                                     const float space_factor = 0.0f,
                                     const bool inverted = false)
{
  /* Can be nullptr when running operators in background mode. */
  if (workspace == nullptr) {
    return;
  }
 
  blender::bke::WorkSpaceStatusItem item;
  item.text = std::move(text);
  item.icon = icon;
  item.space_factor = space_factor;
  item.inverted = inverted;
  workspace->runtime->status.append(std::move(item));
}
 
static void ed_workspace_status_space(WorkSpace *workspace, const float space_factor)
{
  ed_workspace_status_item(workspace, {}, ICON_NONE, space_factor);
}
 
WorkspaceStatus::WorkspaceStatus(bContext *C)
{
  workspace_ = CTX_wm_workspace(C);
  wm_ = CTX_wm_manager(C);
  if (workspace_) {
    BKE_workspace_status_clear(workspace_);
  }
  ED_area_tag_redraw(WM_window_status_area_find(CTX_wm_window(C), CTX_wm_screen(C)));
}
 
/* -------------------------------------------------------------------- */
 
static constexpr float STATUS_BEFORE_TEXT = 0.17f;
static constexpr float STATUS_AFTER_TEXT = 0.90f;
static constexpr float STATUS_MOUSE_ICON_PAD = -0.68f;
 
static void ed_workspace_status_text_item(WorkSpace *workspace, std::string text)
{
  if (!text.empty()) {
    ed_workspace_status_space(workspace, STATUS_BEFORE_TEXT);
    ed_workspace_status_item(workspace, std::move(text), ICON_NONE);
    ed_workspace_status_space(workspace, STATUS_AFTER_TEXT);
  }
}
 
static void ed_workspace_status_icon_item(WorkSpace *workspace,
                                          const int icon,
                                          const bool inverted = false)
{
  if (icon) {
    ed_workspace_status_item(workspace, {}, icon, 0.0f, inverted);
    if (icon >= ICON_MOUSE_LMB && icon <= ICON_MOUSE_MMB_SCROLL) {
      /* Negative space after narrow mice icons. */
      ed_workspace_status_space(workspace, STATUS_MOUSE_ICON_PAD);
    }
  }
}

 
/* -------------------------------------------------------------------- */
 
void WorkspaceStatus::item(std::string text, const int icon1, const int icon2)
{
  ed_workspace_status_icon_item(workspace_, icon1);
  ed_workspace_status_icon_item(workspace_, icon2);
  ed_workspace_status_text_item(workspace_, std::move(text));
}
 
void WorkspaceStatus::separator(float factor)
{
  ed_workspace_status_space(workspace_, factor);
}
 
void WorkspaceStatus::range(std::string text, const int icon1, const int icon2)
{
  ed_workspace_status_item(workspace_, {}, icon1);
  ed_workspace_status_item(workspace_, "-", ICON_NONE);
  ed_workspace_status_space(workspace_, -0.5f);
  ed_workspace_status_item(workspace_, {}, icon2);
  ed_workspace_status_text_item(workspace_, std::move(text));
}
 
void WorkspaceStatus::item_bool(std::string text,
                                const bool inverted,
                                const int icon1,
                                const int icon2)
{
  ed_workspace_status_icon_item(workspace_, icon1, inverted);
  ed_workspace_status_icon_item(workspace_, icon2, inverted);
  ed_workspace_status_text_item(workspace_, std::move(text));
}
 
void WorkspaceStatus::opmodal(std::string text,
                              const wmOperatorType *ot,
                              const int propvalue,
                              const bool inverted)
{
  wmKeyMap *keymap = WM_keymap_active(wm_, ot->modalkeymap);
  if (keymap) {
    const wmKeyMapItem *kmi = WM_modalkeymap_find_propvalue(keymap, propvalue);
    if (kmi) {
#ifdef WITH_HEADLESS
      int icon = 0;
#else
      int icon = UI_icon_from_event_type(kmi->type, kmi->val);
#endif
      if (kmi->shift == KM_MOD_HELD) {
        ed_workspace_status_item(workspace_, {}, ICON_EVENT_SHIFT, 0.0f, inverted);
      }
      if (kmi->ctrl == KM_MOD_HELD) {
        ed_workspace_status_item(workspace_, {}, ICON_EVENT_CTRL, 0.0f, inverted);
      }
      if (kmi->alt == KM_MOD_HELD) {
        ed_workspace_status_item(workspace_, {}, ICON_EVENT_ALT, 0.0f, inverted);
      }
      if (kmi->oskey == KM_MOD_HELD) {
        ed_workspace_status_item(workspace_, {}, ICON_EVENT_OS, 0.0f, inverted);
      }
      if (!ELEM(kmi->hyper, KM_NOTHING, KM_ANY)) {
        ed_workspace_status_item(workspace_, {}, ICON_EVENT_HYPER, 0.0f, inverted);
      }
      ed_workspace_status_icon_item(workspace_, icon, inverted);
      ed_workspace_status_text_item(workspace_, std::move(text));
    }
  }
}
 
void ED_workspace_status_text(bContext *C, const char *str)
{
  WorkspaceStatus status(C);
  status.item(str ? str : "", ICON_NONE);
}

 
/* ************************************************************ */
 
static void area_azone_init(const wmWindow *win, const bScreen *screen, ScrArea *area)
{
  /* reinitialize entirely, regions and full-screen add azones too */
  BLI_freelistN(&area->actionzones);
 
  if (screen->state != SCREENNORMAL) {
    return;
  }
 
  if (U.app_flag & USER_APP_LOCK_CORNER_SPLIT) {
    return;
  }
 
  if (ED_area_is_global(area)) {
    return;
  }
 
  if (screen->temp) {
    return;
  }
 
  /* Use a taller zone on the left side, the height of
   * the header, to make them easier to hit. The others
   * on the right are shorter to not interfere with
   * scroll bars. */
 
  const float coords[4][4] = {
      /* Bottom-left. */
      {area->totrct.xmin - U.pixelsize,
       area->totrct.ymin - U.pixelsize,
       area->totrct.xmin + UI_AZONESPOTW_LEFT,
       float(area->totrct.ymin + ED_area_headersize())},
      /* Bottom-right. */
      {area->totrct.xmax - UI_AZONESPOTW_RIGHT,
       area->totrct.ymin - U.pixelsize,
       area->totrct.xmax + U.pixelsize,
       area->totrct.ymin + UI_AZONESPOTH},
      /* Top-left. */
      {area->totrct.xmin - U.pixelsize,
       float(area->totrct.ymax - ED_area_headersize()),
       area->totrct.xmin + UI_AZONESPOTW_LEFT,
       area->totrct.ymax + U.pixelsize},
      /* Top-right. */
      {area->totrct.xmax - UI_AZONESPOTW_RIGHT,
       area->totrct.ymax - UI_AZONESPOTH,
       area->totrct.xmax + U.pixelsize,
       area->totrct.ymax + U.pixelsize},
  };
 
  for (int i = 0; i < 4; i++) {
    /* can't click on bottom corners on OS X, already used for resizing */
#ifdef __APPLE__
    if (!WM_window_is_fullscreen(win) &&
        ((coords[i][0] == 0 && coords[i][1] == 0) ||
         (coords[i][0] == WM_window_native_pixel_x(win) && coords[i][1] == 0)))
    {
      continue;
    }
#else
    (void)win;
#endif
 
    /* set area action zones */
    AZone *az = MEM_callocN<AZone>("actionzone");
    BLI_addtail(&(area->actionzones), az);
    az->type = AZONE_AREA;
    az->x1 = coords[i][0];
    az->y1 = coords[i][1];
    az->x2 = coords[i][2];
    az->y2 = coords[i][3];
    BLI_rcti_init(&az->rect, az->x1, az->x2, az->y1, az->y2);
  }
}
 
static void fullscreen_azone_init(ScrArea *area, ARegion *region)
{
  if (ED_area_is_global(area) || !ELEM(region->regiontype, RGN_TYPE_WINDOW, RGN_TYPE_PREVIEW)) {
    return;
  }
 
  AZone *az = MEM_callocN<AZone>("fullscreen action zone");
  BLI_addtail(&(area->actionzones), az);
  az->type = AZONE_FULLSCREEN;
  az->region = region;
  az->alpha = 0.0f;
 
  if (U.uiflag2 & USER_REGION_OVERLAP) {
    const rcti *rect_visible = ED_region_visible_rect(region);
    az->x2 = region->winrct.xmin + rect_visible->xmax;
    az->y2 = region->winrct.ymin + rect_visible->ymax;
  }
  else {
    az->x2 = region->winrct.xmax;
    az->y2 = region->winrct.ymax;
  }
  az->x1 = az->x2 - AZONEFADEOUT;
  az->y1 = az->y2 - AZONEFADEOUT;
 
  BLI_rcti_init(&az->rect, az->x1, az->x2, az->y1, az->y2);
}

static bool region_background_is_transparent(const ScrArea *area, const ARegion *region)
{
  /* Ensure the right theme is active, may not be the case on startup, for example. */
  bThemeState theme_state;
  UI_Theme_Store(&theme_state);
  UI_SetTheme(area->spacetype, region->regiontype);
 
  uchar back[4];
  UI_GetThemeColor4ubv(TH_BACK, back);
 
  UI_Theme_Restore(&theme_state);
 
  return back[3] < 50;
}
 
static void region_azone_edge(const ScrArea *area, AZone *az, const ARegion *region)
{
  /* Narrow regions like headers need a smaller hit-space that
   * does not interfere with content. */
  const bool is_narrow = RGN_TYPE_IS_HEADER_ANY(region->regiontype);
  const bool transparent = !is_narrow && region->overlap &&
                           region_background_is_transparent(area, region);
 
  /* Only scale the padding inside the region, not outside. */
  const float aspect = BLI_rctf_size_y(&region->v2d.cur) /
                       (BLI_rcti_size_y(&region->v2d.mask) + 1);
 
  /* Different padding inside and outside the region. */
  const int pad_out = (is_narrow ? 2.0f : 3.0f) * UI_SCALE_FAC;
  const int pad_in = (is_narrow ? 1.0f : (transparent ? 8.0f : 4.0f)) * UI_SCALE_FAC / aspect;
 
  switch (az->edge) {
    case AE_TOP_TO_BOTTOMRIGHT:
      az->x1 = region->winrct.xmin;
      az->y1 = region->winrct.ymax + pad_out;
      az->x2 = region->winrct.xmax;
      az->y2 = region->winrct.ymax - pad_in;
      break;
    case AE_BOTTOM_TO_TOPLEFT:
      az->x1 = region->winrct.xmin;
      az->y1 = region->winrct.ymin + pad_out;
      az->x2 = region->winrct.xmax;
      az->y2 = region->winrct.ymin - pad_in;
      break;
    case AE_LEFT_TO_TOPRIGHT:
      az->x1 = region->winrct.xmin - pad_out;
      az->y1 = region->winrct.ymin;
      az->x2 = region->winrct.xmin + pad_in;
      az->y2 = region->winrct.ymax;
      break;
    case AE_RIGHT_TO_TOPLEFT:
      az->x1 = region->winrct.xmax - pad_in;
      az->y1 = region->winrct.ymin;
      az->x2 = region->winrct.xmax + pad_out;
      az->y2 = region->winrct.ymax;
      break;
  }
  BLI_rcti_init(&az->rect, az->x1, az->x2, az->y1, az->y2);
}
 
/* region already made zero sized, in shape of edge */
static void region_azone_tab_plus(ScrArea *area, AZone *az, ARegion *region)
{
  float edge_offset = 1.0f;
  const float tab_size_x = 1.0f * U.widget_unit;
  const float tab_size_y = 0.5f * U.widget_unit;
 
  switch (az->edge) {
    case AE_TOP_TO_BOTTOMRIGHT: {
      int add = (region->winrct.ymax == area->totrct.ymin) ? 1 : 0;
      az->x1 = region->winrct.xmax - ((edge_offset + 1.0f) * tab_size_x);
      az->y1 = region->winrct.ymax - U.pixelsize;
      az->x2 = region->winrct.xmax - (edge_offset * tab_size_x);
      az->y2 = region->winrct.ymax - add + tab_size_y;
      break;
    }
    case AE_BOTTOM_TO_TOPLEFT:
      az->x1 = region->winrct.xmax - ((edge_offset + 1.0f) * tab_size_x);
      az->y1 = region->winrct.ymin - tab_size_y;
      az->x2 = region->winrct.xmax - (edge_offset * tab_size_x);
      az->y2 = region->winrct.ymin + U.pixelsize;
      break;
    case AE_LEFT_TO_TOPRIGHT:
      az->x1 = region->winrct.xmin - tab_size_y;
      az->y1 = region->winrct.ymax - ((edge_offset + 1.0f) * tab_size_x);
      az->x2 = region->winrct.xmin + U.pixelsize;
      az->y2 = region->winrct.ymax - (edge_offset * tab_size_x);
      break;
    case AE_RIGHT_TO_TOPLEFT:
      az->x1 = region->winrct.xmax - U.pixelsize;
      az->y1 = region->winrct.ymax - ((edge_offset + 1.0f) * tab_size_x);
      az->x2 = region->winrct.xmax + tab_size_y;
      az->y2 = region->winrct.ymax - (edge_offset * tab_size_x);
      break;
  }
  /* rect needed for mouse pointer test */
  BLI_rcti_init(&az->rect, az->x1, az->x2, az->y1, az->y2);
}
 
static bool region_azone_edge_poll(const ScrArea *area,
                                   const ARegion *region,
                                   const bool is_fullscreen)
{
  if (region->flag & RGN_FLAG_POLL_FAILED) {
    return false;
  }
 
  if (area->winy < int(float(ED_area_headersize()) * 1.5f)) {
    return false;
  }
 
  /* Don't use edge if the region hides with previous region which is now hidden. See #116196. */
  if ((region->alignment & (RGN_SPLIT_PREV | RGN_ALIGN_HIDE_WITH_PREV) && region->prev) &&
      region->prev->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL))
  {
    return false;
  }
 
  const bool is_hidden = (region->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL));
 
  if (is_hidden && is_fullscreen) {
    return false;
  }
  if (!is_hidden && ELEM(region->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER)) {
    return false;
  }
  if (!is_hidden && region->regiontype == RGN_TYPE_NAV_BAR && area->spacetype == SPACE_PROPERTIES)
  {
    return false;
  }
 
  if (is_hidden && (U.app_flag & USER_APP_HIDE_REGION_TOGGLE)) {
    return false;
  }
 
  if (!is_hidden && (U.app_flag & USER_APP_LOCK_EDGE_RESIZE)) {
    return false;
  }
 
  return true;
}
 
static void region_azone_edge_init(ScrArea *area,
                                   ARegion *region,
                                   AZEdge edge,
                                   const bool is_fullscreen)
{
  const bool is_hidden = (region->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL));
 
  if (!region_azone_edge_poll(area, region, is_fullscreen)) {
    return;
  }
 
  AZone *az = MEM_callocN<AZone>("actionzone");
  BLI_addtail(&(area->actionzones), az);
  az->type = AZONE_REGION;
  az->region = region;
  az->edge = edge;
 
  if (is_hidden) {
    region_azone_tab_plus(area, az, region);
  }
  else {
    region_azone_edge(area, az, region);
  }
}
 
static void region_azone_scrollbar_init(ScrArea *area,
                                        ARegion *region,
                                        AZScrollDirection direction)
{
  AZone *az = MEM_callocN<AZone>(__func__);
 
  BLI_addtail(&area->actionzones, az);
  az->type = AZONE_REGION_SCROLL;
  az->region = region;
  az->direction = direction;
 
  if (direction == AZ_SCROLL_VERT) {
    az->region->v2d.alpha_vert = 0;
  }
  else if (direction == AZ_SCROLL_HOR) {
    az->region->v2d.alpha_hor = 0;
  }
 
  /* No need to specify rect for scrollbar az. For intersection we'll test against the area around
   * the region's scroller instead, in `area_actionzone_get_rect`. */
}
 
static void region_azones_scrollbars_init(ScrArea *area, ARegion *region)
{
  const View2D *v2d = &region->v2d;
 
  if (v2d->scroll & V2D_SCROLL_VERTICAL) {
    region_azone_scrollbar_init(area, region, AZ_SCROLL_VERT);
  }
  if (v2d->scroll & V2D_SCROLL_HORIZONTAL) {
    region_azone_scrollbar_init(area, region, AZ_SCROLL_HOR);
  }
}
 
/* *************************************************************** */
static void region_azones_add_edge(ScrArea *area,
                                   ARegion *region,
                                   const int alignment,
                                   const bool is_fullscreen)
{
 
  /* edge code (t b l r) is along which area edge azone will be drawn */
  if (alignment == RGN_ALIGN_TOP) {
    region_azone_edge_init(area, region, AE_BOTTOM_TO_TOPLEFT, is_fullscreen);
  }
  else if (alignment == RGN_ALIGN_BOTTOM) {
    region_azone_edge_init(area, region, AE_TOP_TO_BOTTOMRIGHT, is_fullscreen);
  }
  else if (alignment == RGN_ALIGN_RIGHT) {
    region_azone_edge_init(area, region, AE_LEFT_TO_TOPRIGHT, is_fullscreen);
  }
  else if (alignment == RGN_ALIGN_LEFT) {
    region_azone_edge_init(area, region, AE_RIGHT_TO_TOPLEFT, is_fullscreen);
  }
}
 
static void region_azones_add(const bScreen *screen, ScrArea *area, ARegion *region)
{
  const bool is_fullscreen = screen->state == SCREENFULL;
 
  /* Only display tab or icons when the header region is hidden
   * (not the tool header - they overlap). */
  if (region->regiontype == RGN_TYPE_TOOL_HEADER) {
    return;
  }
 
  region_azones_add_edge(area, region, RGN_ALIGN_ENUM_FROM_MASK(region->alignment), is_fullscreen);
 
  /* For a split region also continue the azone edge from the next region if this region is aligned
   * with the next */
  if ((region->alignment & RGN_SPLIT_PREV) && region->prev) {
    region_azones_add_edge(
        area, region, RGN_ALIGN_ENUM_FROM_MASK(region->prev->alignment), is_fullscreen);
  }
 
  if (is_fullscreen) {
    fullscreen_azone_init(area, region);
  }
 
  region_azones_scrollbars_init(area, region);
}
 
/* dir is direction to check, not the splitting edge direction! */
static int rct_fits(const rcti *rect, const eScreenAxis dir_axis, int size)
{
  if (dir_axis == SCREEN_AXIS_H) {
    return BLI_rcti_size_x(rect) + 1 - size;
  }
  /* Vertical. */
  return BLI_rcti_size_y(rect) + 1 - size;
}
 
/* *************************************************************** */
 
/* region should be overlapping */
/* function checks if some overlapping region was defined before - on same place */
static void region_overlap_fix(ScrArea *area, ARegion *region)
{
  /* find overlapping previous region on same place */
  ARegion *region_iter;
  int align1 = 0;
  const int align = RGN_ALIGN_ENUM_FROM_MASK(region->alignment);
  for (region_iter = region->prev; region_iter; region_iter = region_iter->prev) {
    if (region_iter->flag & (RGN_FLAG_POLL_FAILED | RGN_FLAG_HIDDEN)) {
      continue;
    }
    if (!region_iter->overlap || (region_iter->alignment & RGN_SPLIT_PREV)) {
      continue;
    }
 
    const int align_iter = RGN_ALIGN_ENUM_FROM_MASK(region_iter->alignment);
    if (ELEM(align_iter, RGN_ALIGN_FLOAT)) {
      continue;
    }
 
    align1 = align_iter;
    if (BLI_rcti_isect(&region_iter->winrct, &region->winrct, nullptr)) {
      if (align1 != align) {
        /* Left overlapping right or vice-versa, forbid this! */
        region->flag |= RGN_FLAG_TOO_SMALL;
        return;
      }
      /* Else, we have our previous region on same side. */
      break;
    }
  }
 
  /* Guard against flags slipping through that would have to be masked out in usages below. */
  BLI_assert(align1 == RGN_ALIGN_ENUM_FROM_MASK(align1));
 
  /* translate or close */
  if (region_iter) {
    if (align1 == RGN_ALIGN_LEFT) {
      if (region->winrct.xmax + region_iter->winx > area->winx - U.widget_unit) {
        region->flag |= RGN_FLAG_TOO_SMALL;
        return;
      }
      BLI_rcti_translate(&region->winrct, region_iter->winx, 0);
    }
    else if (align1 == RGN_ALIGN_RIGHT) {
      if (region->winrct.xmin - region_iter->winx < U.widget_unit) {
        region->flag |= RGN_FLAG_TOO_SMALL;
        return;
      }
      BLI_rcti_translate(&region->winrct, -region_iter->winx, 0);
    }
  }
 
  /* At this point, 'region' is in its final position and still open.
   * Make a final check it does not overlap any previous 'other side' region. */
  for (region_iter = region->prev; region_iter; region_iter = region_iter->prev) {
    if (region_iter->flag & (RGN_FLAG_POLL_FAILED | RGN_FLAG_HIDDEN)) {
      continue;
    }
    if (!region_iter->overlap || (region_iter->alignment & RGN_SPLIT_PREV)) {
      continue;
    }
 
    const int align_iter = RGN_ALIGN_ENUM_FROM_MASK(region_iter->alignment);
    if (ELEM(align_iter, RGN_ALIGN_FLOAT)) {
      continue;
    }
 
    if ((align_iter != align) && BLI_rcti_isect(&region_iter->winrct, &region->winrct, nullptr)) {
      /* Left overlapping right or vice-versa, forbid this! */
      region->flag |= RGN_FLAG_TOO_SMALL;
      return;
    }
  }
}
 
bool ED_region_is_overlap(int spacetype, int regiontype)
{
  if (regiontype == RGN_TYPE_HUD) {
    return true;
  }
  if (U.uiflag2 & USER_REGION_OVERLAP) {
    if (spacetype == SPACE_NODE) {
      if (ELEM(regiontype,
               RGN_TYPE_TOOLS,
               RGN_TYPE_UI,
               RGN_TYPE_ASSET_SHELF,
               RGN_TYPE_ASSET_SHELF_HEADER))
      {
        return true;
      }
    }
    else if (spacetype == SPACE_VIEW3D) {
      if (regiontype == RGN_TYPE_HEADER) {
        /* Do not treat as overlapped if no transparency. */
        bTheme *theme = UI_GetTheme();
        return theme->space_view3d.header[3] != 255;
      }
      if (ELEM(regiontype,
               RGN_TYPE_TOOLS,
               RGN_TYPE_UI,
               RGN_TYPE_TOOL_PROPS,
               RGN_TYPE_FOOTER,
               RGN_TYPE_TOOL_HEADER,
               RGN_TYPE_ASSET_SHELF,
               RGN_TYPE_ASSET_SHELF_HEADER))
      {
        return true;
      }
    }
    else if (spacetype == SPACE_IMAGE) {
      if (ELEM(regiontype,
               RGN_TYPE_TOOLS,
               RGN_TYPE_UI,
               RGN_TYPE_TOOL_PROPS,
               RGN_TYPE_FOOTER,
               RGN_TYPE_TOOL_HEADER,
               RGN_TYPE_ASSET_SHELF,
               RGN_TYPE_ASSET_SHELF_HEADER))
      {
        return true;
      }
    }
  }
 
  return false;
}
 
static void region_rect_recursive(
    ScrArea *area, ARegion *region, rcti *remainder, rcti *overlap_remainder, int quad)
{
  using namespace blender::ed;
  rcti *remainder_prev = remainder;
 
  if (region == nullptr) {
    return;
  }
 
  int prev_winx = region->winx;
  int prev_winy = region->winy;
 
  /* no returns in function, winrct gets set in the end again */
  BLI_rcti_init(&region->winrct, 0, 0, 0, 0);
 
  /* for test; allow split of previously defined region */
  if (region->alignment & RGN_SPLIT_PREV) {
    if (region->prev) {
      remainder = &region->prev->winrct;
    }
  }
 
  int alignment = RGN_ALIGN_ENUM_FROM_MASK(region->alignment);
 
  /* set here, assuming userpref switching forces to call this again */
  region->overlap = ED_region_is_overlap(area->spacetype, region->regiontype);
 
  /* clear state flags first */
  region->flag &= ~(RGN_FLAG_TOO_SMALL | RGN_FLAG_SIZE_CLAMP_X | RGN_FLAG_SIZE_CLAMP_Y);
  /* user errors */
  if ((region->next == nullptr) && !ELEM(alignment, RGN_ALIGN_QSPLIT, RGN_ALIGN_FLOAT)) {
    alignment = RGN_ALIGN_NONE;
  }
 
  /* If both the #ARegion.sizex/y and the #ARegionType.prefsizex/y are 0, the region is tagged as
   * too small, even before the layout for dynamically sized regions is created.
   * #wm_draw_window_offscreen() allows the layout to be created despite the #RGN_FLAG_TOO_SMALL
   * flag being set. But there may still be regions that don't have a separate #ARegionType.layout
   * callback. For those, set a default #ARegionType.prefsizex/y so they can become visible. */
  if ((region->flag & RGN_FLAG_DYNAMIC_SIZE) && !(region->runtime->type->layout)) {
    if ((region->sizex == 0) && (region->runtime->type->prefsizex == 0)) {
      region->runtime->type->prefsizex = AREAMINX;
    }
    if ((region->sizey == 0) && (region->runtime->type->prefsizey == 0)) {
      region->runtime->type->prefsizey = HEADERY;
    }
  }
 
  /* `prefsizex/y`, taking into account DPI. */
  int prefsizex = UI_SCALE_FAC *
                  ((region->sizex > 1) ? region->sizex + 0.5f : region->runtime->type->prefsizex);
  int prefsizey;
 
  if (region->regiontype == RGN_TYPE_HEADER) {
    prefsizey = ED_area_headersize();
  }
  else if (region->regiontype == RGN_TYPE_TOOL_HEADER) {
    prefsizey = ED_area_headersize();
  }
  else if (region->regiontype == RGN_TYPE_FOOTER) {
    prefsizey = ED_area_footersize();
  }
  else if (region->regiontype == RGN_TYPE_ASSET_SHELF) {
    prefsizey = region->sizey > 1 ? (UI_SCALE_FAC * (region->sizey + 0.5f)) :
                                    asset::shelf::region_prefsizey();
  }
  else if (region->regiontype == RGN_TYPE_ASSET_SHELF_HEADER) {
    prefsizey = asset::shelf::header_region_size();
  }
  else if (ED_area_is_global(area)) {
    prefsizey = ED_region_global_size_y();
  }
  else {
    prefsizey = UI_SCALE_FAC *
                (region->sizey > 1 ? region->sizey + 0.5f : region->runtime->type->prefsizey);
  }
 
  if (region->flag & (RGN_FLAG_POLL_FAILED | RGN_FLAG_HIDDEN)) {
    /* hidden is user flag */
  }
  else if (alignment == RGN_ALIGN_FLOAT) {
    const int size_min[2] = {UI_UNIT_X, UI_UNIT_Y};
    rcti overlap_remainder_margin = *overlap_remainder;
 
    BLI_rcti_resize(&overlap_remainder_margin,
                    max_ii(0, BLI_rcti_size_x(overlap_remainder) - UI_UNIT_X / 2),
                    max_ii(0, BLI_rcti_size_y(overlap_remainder) - UI_UNIT_Y / 2));
    region->winrct.xmin = overlap_remainder_margin.xmin + region->runtime->offset_x;
    region->winrct.ymin = overlap_remainder_margin.ymin + region->runtime->offset_y;
    region->winrct.xmax = region->winrct.xmin + prefsizex - 1;
    region->winrct.ymax = region->winrct.ymin + prefsizey - 1;
 
    BLI_rcti_isect(&region->winrct, &overlap_remainder_margin, &region->winrct);
 
    if (BLI_rcti_size_x(&region->winrct) != prefsizex - 1) {
      region->flag |= RGN_FLAG_SIZE_CLAMP_X;
    }
    if (BLI_rcti_size_y(&region->winrct) != prefsizey - 1) {
      region->flag |= RGN_FLAG_SIZE_CLAMP_Y;
    }
 
    /* We need to use a test that won't have been previously clamped. */
    rcti winrct_test{};
    winrct_test.xmin = region->winrct.xmin;
    winrct_test.ymin = region->winrct.ymin;
    winrct_test.xmax = region->winrct.xmin + size_min[0];
    winrct_test.ymax = region->winrct.ymin + size_min[1];
 
    BLI_rcti_isect(&winrct_test, &overlap_remainder_margin, &winrct_test);
    if (BLI_rcti_size_x(&winrct_test) < size_min[0] || BLI_rcti_size_y(&winrct_test) < size_min[1])
    {
      region->flag |= RGN_FLAG_TOO_SMALL;
    }
  }
  else if (rct_fits(remainder, SCREEN_AXIS_V, 1) < 0 || rct_fits(remainder, SCREEN_AXIS_H, 1) < 0)
  {
    /* remainder is too small for any usage */
    region->flag |= RGN_FLAG_TOO_SMALL;
  }
  else if (alignment == RGN_ALIGN_NONE) {
    /* typically last region */
    region->winrct = *remainder;
    BLI_rcti_init(remainder, 0, 0, 0, 0);
  }
  else if (ELEM(alignment, RGN_ALIGN_TOP, RGN_ALIGN_BOTTOM)) {
    rcti *winrct = (region->overlap) ? overlap_remainder : remainder;
 
    if ((prefsizey == 0) || (rct_fits(winrct, SCREEN_AXIS_V, prefsizey) < (U.pixelsize * -2))) {
      region->flag |= RGN_FLAG_TOO_SMALL;
    }
    else {
      int fac = rct_fits(winrct, SCREEN_AXIS_V, prefsizey);
 
      if (fac < 0) {
        prefsizey += fac;
      }
 
      region->winrct = *winrct;
 
      if (alignment == RGN_ALIGN_TOP) {
        region->winrct.ymin = region->winrct.ymax - prefsizey + 1;
        winrct->ymax = region->winrct.ymin - 1;
      }
      else {
        region->winrct.ymax = region->winrct.ymin + prefsizey - 1;
        winrct->ymin = region->winrct.ymax + 1;
      }
      BLI_rcti_sanitize(winrct);
    }
  }
  else if (ELEM(alignment, RGN_ALIGN_LEFT, RGN_ALIGN_RIGHT)) {
    rcti *winrct = (region->overlap) ? overlap_remainder : remainder;
 
    if ((prefsizex == 0) || (rct_fits(winrct, SCREEN_AXIS_H, prefsizex) < 0)) {
      region->flag |= RGN_FLAG_TOO_SMALL;
    }
    else {
      int fac = rct_fits(winrct, SCREEN_AXIS_H, prefsizex);
 
      if (fac < 0) {
        prefsizex += fac;
      }
 
      region->winrct = *winrct;
 
      if (alignment == RGN_ALIGN_RIGHT) {
        region->winrct.xmin = region->winrct.xmax - prefsizex + 1;
        winrct->xmax = region->winrct.xmin - 1;
      }
      else {
        region->winrct.xmax = region->winrct.xmin + prefsizex - 1;
        winrct->xmin = region->winrct.xmax + 1;
      }
      BLI_rcti_sanitize(winrct);
    }
  }
  else if (ELEM(alignment, RGN_ALIGN_VSPLIT, RGN_ALIGN_HSPLIT)) {
    /* Percentage subdiv. */
    region->winrct = *remainder;
 
    if (alignment == RGN_ALIGN_HSPLIT) {
      if (rct_fits(remainder, SCREEN_AXIS_H, prefsizex) > 4) {
        region->winrct.xmax = BLI_rcti_cent_x(remainder);
        remainder->xmin = region->winrct.xmax + 1;
      }
      else {
        BLI_rcti_init(remainder, 0, 0, 0, 0);
      }
    }
    else {
      if (rct_fits(remainder, SCREEN_AXIS_V, prefsizey) > 4) {
        region->winrct.ymax = BLI_rcti_cent_y(remainder);
        remainder->ymin = region->winrct.ymax + 1;
      }
      else {
        BLI_rcti_init(remainder, 0, 0, 0, 0);
      }
    }
  }
  else if (alignment == RGN_ALIGN_QSPLIT) {
    region->winrct = *remainder;
 
    /* test if there's still 4 regions left */
    if (quad == 0) {
      ARegion *region_test = region->next;
      int count = 1;
 
      while (region_test) {
        region_test->alignment = RGN_ALIGN_QSPLIT;
        region_test = region_test->next;
        count++;
      }
 
      if (count != 4) {
        /* let's stop adding regions */
        BLI_rcti_init(remainder, 0, 0, 0, 0);
        if (G.debug & G_DEBUG) {
          printf("region quadsplit failed\n");
        }
      }
      else {
        quad = 1;
      }
    }
    if (quad) {
      if (quad == 1) { /* left bottom */
        region->winrct.xmax = BLI_rcti_cent_x(remainder);
        region->winrct.ymax = BLI_rcti_cent_y(remainder);
      }
      else if (quad == 2) { /* left top */
        region->winrct.xmax = BLI_rcti_cent_x(remainder);
        region->winrct.ymin = BLI_rcti_cent_y(remainder) + 1;
      }
      else if (quad == 3) { /* right bottom */
        region->winrct.xmin = BLI_rcti_cent_x(remainder) + 1;
        region->winrct.ymax = BLI_rcti_cent_y(remainder);
      }
      else { /* right top */
        region->winrct.xmin = BLI_rcti_cent_x(remainder) + 1;
        region->winrct.ymin = BLI_rcti_cent_y(remainder) + 1;
        BLI_rcti_init(remainder, 0, 0, 0, 0);
      }
 
      /* Fix any negative dimensions. This can happen when a quad split 3d view gets too small.
       * (see #72200). */
      BLI_rcti_sanitize(&region->winrct);
 
      quad++;
    }
  }
 
  /* for speedup */
  region->winx = BLI_rcti_size_x(&region->winrct) + 1;
  region->winy = BLI_rcti_size_y(&region->winrct) + 1;
 
  if (region->winy <= U.border_width && !(region->flag & RGN_FLAG_HIDDEN)) {
    /* Don't draw when just a couple pixels tall. #143617. */
    region->flag |= RGN_FLAG_TOO_SMALL;
  }
 
  /* If region opened normally, we store this for hide/reveal usage. */
  /* Prevent rounding errors for UI_SCALE_FAC multiply and divide. */
  if (region->winx > 1) {
    region->sizex = (region->winx + 0.5f) / UI_SCALE_FAC;
  }
  if (region->winy > 1) {
    region->sizey = (region->winy + 0.5f) / UI_SCALE_FAC;
  }
 
  /* exception for multiple overlapping regions on same spot */
  if (region->overlap && (alignment != RGN_ALIGN_FLOAT)) {
    region_overlap_fix(area, region);
  }
 
  /* Set `region->winrct` for action-zones. */
  if (region->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL)) {
    region->winrct = (region->overlap) ? *overlap_remainder : *remainder;
 
    switch (alignment) {
      case RGN_ALIGN_TOP:
        region->winrct.ymin = region->winrct.ymax;
        break;
      case RGN_ALIGN_BOTTOM:
        region->winrct.ymax = region->winrct.ymin;
        break;
      case RGN_ALIGN_RIGHT:
        region->winrct.xmin = region->winrct.xmax;
        break;
      case RGN_ALIGN_LEFT:
        region->winrct.xmax = region->winrct.xmin;
        break;
      default:
        /* prevent winrct to be valid */
        region->winrct.xmax = region->winrct.xmin;
        break;
    }
 
    /* Size on one axis is now 0, the other axis may still be invalid (negative) though. */
    BLI_rcti_sanitize(&region->winrct);
  }
 
  /* restore prev-split exception */
  if (region->alignment & RGN_SPLIT_PREV) {
    if (region->prev) {
      remainder = remainder_prev;
      region->prev->winx = BLI_rcti_size_x(&region->prev->winrct) + 1;
      region->prev->winy = BLI_rcti_size_y(&region->prev->winrct) + 1;
    }
  }
 
  /* After non-overlapping region, all following overlapping regions
   * fit within the remaining space again. */
  if (!region->overlap) {
    *overlap_remainder = *remainder;
  }
 
  BLI_assert(BLI_rcti_is_valid(&region->winrct));
 
  region_rect_recursive(area, region->next, remainder, overlap_remainder, quad);
 
  /* Tag for redraw if size changes. */
  if (region->winx != prev_winx || region->winy != prev_winy) {
    /* 3D View needs a full rebuild in case a progressive render runs. Rest can live with
     * no-rebuild (e.g. Outliner) */
    if (area->spacetype == SPACE_VIEW3D) {
      ED_region_tag_redraw(region);
    }
    else {
      ED_region_tag_redraw_no_rebuild(region);
    }
  }
 
  /* Clear, initialize on demand. */
  region->runtime->visible_rect = rcti{};
}
 
static void area_calc_totrct(const bScreen *screen, ScrArea *area, const rcti *window_rect)
{
  /* Padding around each area, except at window edges. */
  const short px = short(std::max(float(U.border_width) * UI_SCALE_FAC, UI_SCALE_FAC));
 
  /* Padding at window edges. Cannot be less than border width. */
  const short px_edge = short(std::min(UI_SCALE_FAC * 2.0f, float(U.border_width) * UI_SCALE_FAC));
 
  area->totrct.xmin = area->v1->vec.x;
  area->totrct.xmax = area->v4->vec.x;
  area->totrct.ymin = area->v1->vec.y;
  area->totrct.ymax = area->v2->vec.y;
 
  /* Scale down totrct by the border size on all sides not at window edges. */
  if (!ED_area_is_global(area) && screen->state != SCREENFULL && !(screen->temp) &&
      !BLI_listbase_is_single(&screen->areabase))
  {
    area->totrct.xmin += (area->totrct.xmin > window_rect->xmin) ? px : px_edge;
    area->totrct.xmax -= (area->totrct.xmax < (window_rect->xmax - 1)) ? px : px_edge;
    area->totrct.ymin += (area->totrct.ymin > window_rect->ymin) ? px : px_edge;
 
    if (area->totrct.ymax < (window_rect->ymax - 1)) {
      area->totrct.ymax -= px;
    }
    else if (!BLI_listbase_is_single(&screen->areabase) || screen->state == SCREENMAXIMIZED) {
      /* Small gap below Top Bar. */
      area->totrct.ymax -= U.pixelsize;
    }
    else {
      area->totrct.ymax -= px_edge;
    }
  }
  /* Although the following asserts are correct they lead to a very unstable Blender.
   * And the asserts would fail even in 2.7x
   * (they were added in 2.8x as part of the top-bar commit).
   * For more details see #54864. */
#if 0
  BLI_assert(area->totrct.xmin >= 0);
  BLI_assert(area->totrct.xmax >= 0);
  BLI_assert(area->totrct.ymin >= 0);
  BLI_assert(area->totrct.ymax >= 0);
#endif
 
  /* for speedup */
  area->winx = BLI_rcti_size_x(&area->totrct) + 1;
  area->winy = BLI_rcti_size_y(&area->totrct) + 1;
}

static void region_evaulate_visibility(ARegion *region)
{
  bool hidden = (region->flag & (RGN_FLAG_POLL_FAILED | RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL)) !=
                0;
 
  if ((region->alignment & (RGN_SPLIT_PREV | RGN_ALIGN_HIDE_WITH_PREV)) && region->prev) {
    hidden = hidden || (region->prev->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_TOO_SMALL));
  }
 
  region->runtime->visible = !hidden;
}

static void ed_default_handlers(
    wmWindowManager *wm, ScrArea *area, ARegion *region, ListBase *handlers, int flag)
{
  BLI_assert(region ? (&region->runtime->handlers == handlers) : (&area->handlers == handlers));
 
  /* NOTE: add-handler checks if it already exists. */
 
  /* XXX: it would be good to have bound-box checks for some of these. */
  if (flag & ED_KEYMAP_UI) {
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "User Interface", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(handlers, keymap);
 
    ListBase *dropboxes = WM_dropboxmap_find("User Interface", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_dropbox_handler(handlers, dropboxes);
 
    /* user interface widgets */
    UI_region_handlers_add(handlers);
  }
  if (flag & ED_KEYMAP_GIZMO) {
    BLI_assert(region && ELEM(region->runtime->type->regionid, RGN_TYPE_WINDOW, RGN_TYPE_PREVIEW));
    if (region) {
      /* Anything else is confusing, only allow this. */
      BLI_assert(&region->runtime->handlers == handlers);
      if (region->runtime->gizmo_map == nullptr) {
        wmGizmoMapType_Params params{};
        params.spaceid = area->spacetype;
        params.regionid = region->runtime->type->regionid;
        region->runtime->gizmo_map = WM_gizmomap_new_from_type(&params);
      }
      WM_gizmomap_add_handlers(region, region->runtime->gizmo_map);
    }
  }
  if (flag & ED_KEYMAP_VIEW2D) {
    /* 2d-viewport handling+manipulation */
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "View2D", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(handlers, keymap);
  }
  if (flag & ED_KEYMAP_ANIMATION) {
    wmKeyMap *keymap;
 
    /* time-markers */
    keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Markers", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler_poll(handlers, keymap, WM_event_handler_region_marker_poll);
 
    /* time-scrub */
    keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "Time Scrub", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler_poll(handlers, keymap, ED_time_scrub_event_in_region_poll);
 
    /* frame changing and timeline operators (for time spaces) */
    keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Animation", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(handlers, keymap);
  }
  if (flag & ED_KEYMAP_TOOL) {
    if (flag & ED_KEYMAP_GIZMO) {
      WM_event_add_keymap_handler_dynamic(
          &region->runtime->handlers, WM_event_get_keymap_from_toolsystem_with_gizmos, area);
    }
    else {
      WM_event_add_keymap_handler_dynamic(
          &region->runtime->handlers, WM_event_get_keymap_from_toolsystem, area);
    }
  }
  if (flag & ED_KEYMAP_FRAMES) {
    /* frame changing/jumping (for all spaces) */
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "Frames", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(handlers, keymap);
  }
  if (flag & ED_KEYMAP_HEADER) {
    /* standard keymap for headers regions */
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "Region Context Menu", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(handlers, keymap);
  }
  if (flag & ED_KEYMAP_FOOTER) {
    /* standard keymap for footer regions */
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "Region Context Menu", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(handlers, keymap);
  }
  if (flag & ED_KEYMAP_NAVBAR) {
    /* standard keymap for Navigation bar regions */
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "Region Context Menu", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
  }
  if (flag & ED_KEYMAP_ASSET_SHELF) {
    /* standard keymap for asset shelf regions */
    wmKeyMap *keymap = WM_keymap_ensure(
        wm->runtime->defaultconf, "Asset Shelf", SPACE_EMPTY, RGN_TYPE_WINDOW);
    WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
  }
 
  /* Keep last because of LMB/RMB handling, see: #57527. */
  if (flag & ED_KEYMAP_GPENCIL) {
    /* grease pencil */
    {
      wmKeyMap *keymap = WM_keymap_ensure(
          wm->runtime->defaultconf, "Grease Pencil", SPACE_EMPTY, RGN_TYPE_WINDOW);
      WM_event_add_keymap_handler(handlers, keymap);
    }
  }
}
 
void ED_area_update_region_sizes(wmWindowManager *wm, wmWindow *win, ScrArea *area)
{
  if (!(area->flag & AREA_FLAG_REGION_SIZE_UPDATE)) {
    return;
  }
  const bScreen *screen = WM_window_get_active_screen(win);
 
  rcti window_rect;
  WM_window_screen_rect_calc(win, &window_rect);
  area_calc_totrct(screen, area, &window_rect);
 
  /* region rect sizes */
  rcti rect = area->totrct;
  rcti overlap_rect = rect;
  region_rect_recursive(
      area, static_cast<ARegion *>(area->regionbase.first), &rect, &overlap_rect, 0);
 
  /* Dynamically sized regions may have changed region sizes, so we have to force azone update. */
  area_azone_init(win, screen, area);
 
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    if (region->flag & RGN_FLAG_POLL_FAILED) {
      continue;
    }
    region_evaulate_visibility(region);
 
    /* region size may have changed, init does necessary adjustments */
    if (region->runtime->type->init) {
      region->runtime->type->init(wm, region);
    }
 
    /* Some AZones use View2D data which is only updated in region init, so call that first! */
    region_azones_add(screen, area, region);
  }
  ED_area_azones_update(area, win->eventstate->xy);
 
  area->flag &= ~AREA_FLAG_REGION_SIZE_UPDATE;
}
 
bool ED_area_has_shared_border(ScrArea *a, ScrArea *b)
{
  return area_getorientation(a, b) != -1;
}

static void area_init_type_fallback(ScrArea *area, eSpace_Type space_type)
{
  BLI_assert(area->type == nullptr);
  area->spacetype = space_type;
  area->type = BKE_spacetype_from_id(area->spacetype);
 
  SpaceLink *sl = nullptr;
  LISTBASE_FOREACH (SpaceLink *, sl_iter, &area->spacedata) {
    if (sl_iter->spacetype == space_type) {
      sl = sl_iter;
      break;
    }
  }
  if (sl) {
    SpaceLink *sl_old = static_cast<SpaceLink *>(area->spacedata.first);
    if (LIKELY(sl != sl_old)) {
      BLI_remlink(&area->spacedata, sl);
      BLI_addhead(&area->spacedata, sl);
 
      /* swap regions */
      sl_old->regionbase = area->regionbase;
      area->regionbase = sl->regionbase;
      BLI_listbase_clear(&sl->regionbase);
    }
  }
  else {
    screen_area_spacelink_add(nullptr, area, space_type);
  }
}
 
void ED_area_and_region_types_init(ScrArea *area)
{
  area->type = BKE_spacetype_from_id(area->spacetype);
 
  if (area->type == nullptr) {
    area_init_type_fallback(area, SPACE_VIEW3D);
    BLI_assert(area->type != nullptr);
  }
 
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    region->runtime->type = BKE_regiontype_from_id(area->type, region->regiontype);
    /* Invalid region types may be stored in files (e.g. for new files), but they should be handled
     * on file read already, see #BKE_screen_area_blend_read_lib(). */
    BLI_assert_msg(region->runtime->type != nullptr, "Region type not valid for this space type");
  }
}
 
void ED_area_init(bContext *C, const wmWindow *win, ScrArea *area)
{
  wmWindowManager *wm = CTX_wm_manager(C);
  WorkSpace *workspace = WM_window_get_active_workspace(win);
  const bScreen *screen = BKE_workspace_active_screen_get(win->workspace_hook);
  const Scene *scene = WM_window_get_active_scene(win);
  ViewLayer *view_layer = WM_window_get_active_view_layer(win);
 
  if (ED_area_is_global(area) && (area->global->flag & GLOBAL_AREA_IS_HIDDEN)) {
    return;
  }
 
  rcti window_rect;
  WM_window_screen_rect_calc(win, &window_rect);
 
  ED_area_and_region_types_init(area);
 
  /* area sizes */
  area_calc_totrct(screen, area, &window_rect);
 
  area_regions_poll(C, screen, area);
 
  /* region rect sizes */
  rcti rect = area->totrct;
  rcti overlap_rect = rect;
  region_rect_recursive(
      area, static_cast<ARegion *>(area->regionbase.first), &rect, &overlap_rect, 0);
  area->flag &= ~AREA_FLAG_REGION_SIZE_UPDATE;
 
  /* default area handlers */
  ed_default_handlers(wm, area, nullptr, &area->handlers, area->type->keymapflag);
  /* checks spacedata, adds own handlers */
  if (area->type->init) {
    area->type->init(wm, area);
  }
 
  /* clear all azones, add the area triangle widgets */
  area_azone_init(win, screen, area);
 
  /* region windows, default and own handlers */
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    region_evaulate_visibility(region);
 
    if (region->runtime->visible) {
      /* default region handlers */
      ed_default_handlers(
          wm, area, region, &region->runtime->handlers, region->runtime->type->keymapflag);
      /* own handlers */
      if (region->runtime->type->init) {
        region->runtime->type->init(wm, region);
      }
    }
    else {
      /* prevent uiblocks to run */
      UI_blocklist_free(nullptr, region);
    }
 
    /* Some AZones use View2D data which is only updated in region init, so call that first! */
    region_azones_add(screen, area, region);
  }
 
  /* Avoid re-initializing tools while resizing areas & regions. */
  if ((G.moving & G_TRANSFORM_WM) == 0) {
    if ((1 << area->spacetype) & WM_TOOLSYSTEM_SPACE_MASK) {
      if (WM_toolsystem_refresh_screen_area(workspace, scene, view_layer, area) ||
          /* When the tool is null it may not be initialized.
           * This happens when switching to a new area, see: #126990.
           *
           * NOTE(@ideasman42): There is a possible down-side here: when refreshing
           * tools results in a null value, refreshing won't be skipped here as intended.
           * As it happens, spaces that use tools will practically always have a default tool. */
          (area->runtime.tool == nullptr))
      {
        /* Only re-initialize as needed to prevent redundant updates as they
         * can cause gizmos to flicker when the flag is set continuously, see: #126525. */
        area->flag |= AREA_FLAG_ACTIVE_TOOL_UPDATE;
      }
    }
    else {
      area->runtime.tool = nullptr;
      area->runtime.is_tool_set = true;
    }
  }
}
 
static void area_offscreen_init(ScrArea *area)
{
  area->flag |= AREA_FLAG_OFFSCREEN;
  area->type = BKE_spacetype_from_id(area->spacetype);
  /* Off screen areas are only ever created at run-time,
   * so there is no reason for the type to be unknown. */
  BLI_assert(area->type != nullptr);
 
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    region->runtime->type = BKE_regiontype_from_id(area->type, region->regiontype);
  }
}
 
ScrArea *ED_area_offscreen_create(wmWindow *win, eSpace_Type space_type)
{
  ScrArea *area = MEM_callocN<ScrArea>(__func__);
  area->spacetype = space_type;
 
  screen_area_spacelink_add(WM_window_get_active_scene(win), area, space_type);
  area_offscreen_init(area);
 
  return area;
}
 
static void area_offscreen_exit(wmWindowManager *wm, wmWindow *win, ScrArea *area)
{
  if (area->type && area->type->exit) {
    area->type->exit(wm, area);
  }
 
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    if (region->runtime->type && region->runtime->type->exit) {
      region->runtime->type->exit(wm, region);
    }
 
    WM_event_modal_handler_region_replace(win, region, nullptr);
    WM_draw_region_free(region);
    region->runtime->visible = false;
 
    MEM_SAFE_FREE(region->runtime->headerstr);
 
    if (region->runtime->regiontimer) {
      WM_event_timer_remove(wm, win, region->runtime->regiontimer);
      region->runtime->regiontimer = nullptr;
    }
 
    if (wm->runtime->message_bus) {
      WM_msgbus_clear_by_owner(wm->runtime->message_bus, region);
    }
  }
 
  WM_event_modal_handler_area_replace(win, area, nullptr);
}
 
void ED_area_offscreen_free(wmWindowManager *wm, wmWindow *win, ScrArea *area)
{
  area_offscreen_exit(wm, win, area);
 
  BKE_screen_area_free(area);
  MEM_freeN(area);
}
 
static void region_update_rect(ARegion *region)
{
  region->winx = BLI_rcti_size_x(&region->winrct) + 1;
  region->winy = BLI_rcti_size_y(&region->winrct) + 1;
 
  /* v2d mask is used to subtract scrollbars from a 2d view. Needs initialize here. */
  BLI_rcti_init(&region->v2d.mask, 0, region->winx - 1, 0, region->winy - 1);
}
 
void ED_region_update_rect(ARegion *region)
{
  region_update_rect(region);
}
 
void ED_region_floating_init(ARegion *region)
{
  BLI_assert(region->alignment == RGN_ALIGN_FLOAT);
 
  /* refresh can be called before window opened */
  region_evaulate_visibility(region);
 
  region_update_rect(region);
}
 
void ED_region_cursor_set(wmWindow *win, ScrArea *area, ARegion *region)
{
  if (region != nullptr) {
    if ((region->runtime->gizmo_map != nullptr) &&
        WM_gizmomap_cursor_set(region->runtime->gizmo_map, win))
    {
      return;
    }
    if (area && region->runtime->type && region->runtime->type->cursor) {
      region->runtime->type->cursor(win, area, region);
      return;
    }
  }
 
  if (WM_cursor_set_from_tool(win, area, region)) {
    return;
  }
 
  WM_cursor_set(win, WM_CURSOR_DEFAULT);
}
 
void ED_region_visibility_change_update_ex(
    bContext *C, ScrArea *area, ARegion *region, bool is_hidden, bool do_init)
{
  if (is_hidden) {
    WM_event_remove_handlers(C, &region->runtime->handlers);
    /* Needed to close any open pop-overs which would otherwise remain open,
     * crashing on attempting to refresh. See: #93410.
     *
     * When #ED_area_init frees buttons via #UI_blocklist_free a nullptr context
     * is passed, causing the free not to remove menus or their handlers. */
    UI_region_free_active_but_all(C, region);
  }
 
  if (do_init) {
    ED_area_init(C, CTX_wm_window(C), area);
    ED_area_tag_redraw(area);
  }
}
 
void ED_region_visibility_change_update(bContext *C, ScrArea *area, ARegion *region)
{
  const bool is_hidden = region->flag & (RGN_FLAG_HIDDEN | RGN_FLAG_POLL_FAILED);
  const bool do_init = true;
  ED_region_visibility_change_update_ex(C, area, region, is_hidden, do_init);
}
 
void region_toggle_hidden(bContext *C, ARegion *region, const bool do_fade)
{
  ScrArea *area = CTX_wm_area(C);
 
  region->flag ^= RGN_FLAG_HIDDEN;
 
  if (do_fade && region->overlap && !(U.uiflag & USER_REDUCE_MOTION)) {
    /* starts a timer, and in end calls the stuff below itself (region_sblend_invoke()) */
    ED_region_visibility_change_update_animated(C, area, region);
  }
  else {
    ED_region_visibility_change_update(C, area, region);
  }
}
 
void ED_region_toggle_hidden(bContext *C, ARegion *region)
{
  region_toggle_hidden(C, region, true);
}
 
void ED_area_data_copy(ScrArea *area_dst, ScrArea *area_src, const bool do_free)
{
  const char spacetype = area_dst->spacetype;
  const short flag_copy = HEADER_NO_PULLDOWN;
 
  area_dst->spacetype = area_src->spacetype;
  area_dst->type = area_src->type;
 
  area_dst->flag = (area_dst->flag & ~flag_copy) | (area_src->flag & flag_copy);
 
  /* area */
  if (do_free) {
    BKE_spacedata_freelist(&area_dst->spacedata);
  }
  BKE_spacedata_copylist(&area_dst->spacedata, &area_src->spacedata);
 
  /* NOTE: SPACE_EMPTY is possible on new screens. */
 
  /* regions */
  if (do_free) {
    SpaceType *st = BKE_spacetype_from_id(spacetype);
    LISTBASE_FOREACH (ARegion *, region, &area_dst->regionbase) {
      BKE_area_region_free(st, region);
    }
    BLI_freelistN(&area_dst->regionbase);
  }
  SpaceType *st = BKE_spacetype_from_id(area_src->spacetype);
  LISTBASE_FOREACH (ARegion *, region, &area_src->regionbase) {
    ARegion *newar = BKE_area_region_copy(st, region);
    BLI_addtail(&area_dst->regionbase, newar);
  }
}
 
void ED_area_data_swap(ScrArea *area_dst, ScrArea *area_src)
{
  std::swap(area_dst->spacetype, area_src->spacetype);
  std::swap(area_dst->type, area_src->type);
 
  std::swap(area_dst->spacedata, area_src->spacedata);
  std::swap(area_dst->regionbase, area_src->regionbase);
}
 
/* -------------------------------------------------------------------- */

struct RegionTypeAlignInfo {
  struct {
    short alignment;
    bool hidden;
  } by_type[RGN_TYPE_NUM];
};
 
static void region_align_info_from_area(ScrArea *area, RegionTypeAlignInfo *r_align_info)
{
  for (int index = 0; index < RGN_TYPE_NUM; index++) {
    r_align_info->by_type[index].alignment = -1;
    /* Default to true, when it doesn't exist - it's effectively hidden. */
    r_align_info->by_type[index].hidden = true;
  }
 
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    if (region->flag & RGN_FLAG_POLL_FAILED) {
      continue;
    }
 
    const int index = region->regiontype;
    if (uint(index) < RGN_TYPE_NUM) {
      r_align_info->by_type[index].alignment = RGN_ALIGN_ENUM_FROM_MASK(region->alignment);
      r_align_info->by_type[index].hidden = (region->flag & RGN_FLAG_HIDDEN) != 0;
    }
  }
}

static short region_alignment_from_header_and_tool_header_state(
    const RegionTypeAlignInfo *region_align_info, const short fallback)
{
  const short header_alignment = region_align_info->by_type[RGN_TYPE_HEADER].alignment;
  const short tool_header_alignment = region_align_info->by_type[RGN_TYPE_TOOL_HEADER].alignment;
 
  const bool header_hidden = region_align_info->by_type[RGN_TYPE_HEADER].hidden;
  const bool tool_header_hidden = region_align_info->by_type[RGN_TYPE_TOOL_HEADER].hidden;
 
  if ((tool_header_alignment != -1) &&
      /* If tool-header is hidden, use header alignment. */
      ((tool_header_hidden == false) ||
       /* Don't prioritize the tool-header if both are hidden (behave as if both are visible).
        * Without this, switching to a space with headers hidden will flip the alignment
        * upon switching to a space with visible headers. */
       (header_hidden && tool_header_hidden)))
  {
    return tool_header_alignment;
  }
  if (header_alignment != -1) {
    return header_alignment;
  }
  return fallback;
}

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])
{
  /* Abbreviate access. */
  const short header_alignment_src = region_align_info_src->by_type[RGN_TYPE_HEADER].alignment;
  const short tool_header_alignment_src =
      region_align_info_src->by_type[RGN_TYPE_TOOL_HEADER].alignment;
 
  const bool tool_header_hidden_src = region_align_info_src->by_type[RGN_TYPE_TOOL_HEADER].hidden;
 
  const short primary_header_alignment_src = region_alignment_from_header_and_tool_header_state(
      region_align_info_src, -1);
 
  /* Neither alignments are usable, don't sync. */
  if (primary_header_alignment_src == -1) {
    return;
  }
 
  const short header_alignment_dst = region_align_info_dst->by_type[RGN_TYPE_HEADER].alignment;
  const short tool_header_alignment_dst =
      region_align_info_dst->by_type[RGN_TYPE_TOOL_HEADER].alignment;
  const short footer_alignment_dst = region_align_info_dst->by_type[RGN_TYPE_FOOTER].alignment;
 
  const bool tool_header_hidden_dst = region_align_info_dst->by_type[RGN_TYPE_TOOL_HEADER].hidden;
 
  /* New synchronized alignments to set (or ignore when left as -1). */
  short header_alignment_sync = -1;
  short tool_header_alignment_sync = -1;
  short footer_alignment_sync = -1;
 
  /* Both source/destination areas have same region configurations regarding headers.
   * Simply copy the values. */
  if (((header_alignment_src != -1) == (header_alignment_dst != -1)) &&
      ((tool_header_alignment_src != -1) == (tool_header_alignment_dst != -1)) &&
      (tool_header_hidden_src == tool_header_hidden_dst))
  {
    if (header_alignment_dst != -1) {
      header_alignment_sync = header_alignment_src;
    }
    if (tool_header_alignment_dst != -1) {
      tool_header_alignment_sync = tool_header_alignment_src;
    }
  }
  else {
    /* Not an exact match, check the space selector isn't moving. */
    const short primary_header_alignment_dst = region_alignment_from_header_and_tool_header_state(
        region_align_info_dst, -1);
 
    if (primary_header_alignment_src != primary_header_alignment_dst) {
      if ((header_alignment_dst != -1) && (tool_header_alignment_dst != -1)) {
        if (header_alignment_dst == tool_header_alignment_dst) {
          /* Apply to both. */
          tool_header_alignment_sync = primary_header_alignment_src;
          header_alignment_sync = primary_header_alignment_src;
        }
        else {
          /* Keep on opposite sides. */
          tool_header_alignment_sync = primary_header_alignment_src;
          header_alignment_sync = (tool_header_alignment_sync == RGN_ALIGN_BOTTOM) ?
                                      RGN_ALIGN_TOP :
                                      RGN_ALIGN_BOTTOM;
        }
      }
      else {
        /* Apply what we can to regions that exist. */
        if (header_alignment_dst != -1) {
          header_alignment_sync = primary_header_alignment_src;
        }
        if (tool_header_alignment_dst != -1) {
          tool_header_alignment_sync = primary_header_alignment_src;
        }
      }
    }
  }
 
  if (footer_alignment_dst != -1) {
    if ((header_alignment_dst != -1) && (header_alignment_dst == footer_alignment_dst)) {
      /* Apply to both. */
      footer_alignment_sync = primary_header_alignment_src;
    }
    else {
      /* Keep on opposite sides. */
      footer_alignment_sync = (primary_header_alignment_src == RGN_ALIGN_BOTTOM) ?
                                  RGN_ALIGN_TOP :
                                  RGN_ALIGN_BOTTOM;
    }
  }
 
  /* Finally apply synchronized flags. */
  if (header_alignment_sync != -1) {
    ARegion *region = region_by_type[RGN_TYPE_HEADER];
    if (region != nullptr) {
      region->alignment = RGN_ALIGN_ENUM_FROM_MASK(header_alignment_sync) |
                          RGN_ALIGN_FLAG_FROM_MASK(region->alignment);
    }
  }
 
  if (tool_header_alignment_sync != -1) {
    ARegion *region = region_by_type[RGN_TYPE_TOOL_HEADER];
    if (region != nullptr) {
      region->alignment = RGN_ALIGN_ENUM_FROM_MASK(tool_header_alignment_sync) |
                          RGN_ALIGN_FLAG_FROM_MASK(region->alignment);
    }
  }
 
  if (footer_alignment_sync != -1) {
    ARegion *region = region_by_type[RGN_TYPE_FOOTER];
    if (region != nullptr) {
      region->alignment = RGN_ALIGN_ENUM_FROM_MASK(footer_alignment_sync) |
                          RGN_ALIGN_FLAG_FROM_MASK(region->alignment);
    }
  }
}
 
static void region_align_info_to_area(
    ScrArea *area, const RegionTypeAlignInfo region_align_info_src[RGN_TYPE_NUM])
{
  ARegion *region_by_type[RGN_TYPE_NUM] = {nullptr};
  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
    const int index = region->regiontype;
    if (uint(index) < RGN_TYPE_NUM) {
      region_by_type[index] = region;
    }
  }
 
  RegionTypeAlignInfo region_align_info_dst;
  region_align_info_from_area(area, &region_align_info_dst);
 
  if ((region_by_type[RGN_TYPE_HEADER] != nullptr) ||
      (region_by_type[RGN_TYPE_TOOL_HEADER] != nullptr))
  {
    region_align_info_to_area_for_headers(
        region_align_info_src, &region_align_info_dst, region_by_type);
  }
 
  /* Note that we could support other region types. */
}

 
/* *********** Space switching code *********** */
 
void ED_area_swapspace(bContext *C, ScrArea *sa1, ScrArea *sa2)
{
  ScrArea *tmp = MEM_callocN<ScrArea>(__func__);
  wmWindow *win = CTX_wm_window(C);
 
  ED_area_exit(C, sa1);
  ED_area_exit(C, sa2);
 
  ED_area_data_copy(tmp, sa1, false);
  ED_area_data_copy(sa1, sa2, true);
  ED_area_data_copy(sa2, tmp, true);
  ED_area_init(C, win, sa1);
  ED_area_init(C, win, sa2);
 
  BKE_screen_area_free(tmp);
  MEM_delete(tmp);
 
  /* The areas being swapped could be between different windows,
   * so clear screen active region pointers. This is set later
   * through regular operations. #141313. */
  wmWindowManager *wm = CTX_wm_manager(C);
  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
    if (bScreen *screen = WM_window_get_active_screen(win)) {
      screen->active_region = nullptr;
    }
  }
 
  /* tell WM to refresh, cursor types etc */
  WM_event_add_mousemove(win);
 
  ED_area_tag_redraw(sa1);
  ED_area_tag_refresh(sa1);
  ED_area_tag_redraw(sa2);
  ED_area_tag_refresh(sa2);
}
 
void ED_area_newspace(bContext *C, ScrArea *area, int type, const bool skip_region_exit)
{
  wmWindow *win = CTX_wm_window(C);
  SpaceType *st = BKE_spacetype_from_id(type);
 
  if (area->spacetype != type) {
    SpaceLink *slold = static_cast<SpaceLink *>(area->spacedata.first);
    /* store area->type->exit callback */
    void (*area_exit)(wmWindowManager *, ScrArea *) = area->type ? area->type->exit : nullptr;
    /* When the user switches between space-types from the type-selector,
     * changing the header-type is jarring (especially when using Ctrl-MouseWheel).
     *
     * However, add-on install for example, forces the header to the top which shouldn't
     * be applied back to the previous space type when closing - see: #57724
     *
     * Newly-created windows won't have any space data, use the alignment
     * the space type defaults to in this case instead
     * (needed for preferences to have space-type on bottom).
     */
 
    bool sync_header_alignment = false;
    RegionTypeAlignInfo region_align_info[RGN_TYPE_NUM];
    if ((slold != nullptr) && (slold->link_flag & SPACE_FLAG_TYPE_TEMPORARY) == 0) {
      region_align_info_from_area(area, region_align_info);
      sync_header_alignment = true;
    }
 
    /* in some cases (opening temp space) we don't want to
     * call area exit callback, so we temporarily unset it */
    if (skip_region_exit && area->type) {
      area->type->exit = nullptr;
    }
 
    ED_area_exit(C, area);
 
    /* restore old area exit callback */
    if (skip_region_exit && area->type) {
      area->type->exit = area_exit;
    }
 
    area->spacetype = type;
    area->type = st;
 
    /* If st->create may be called, don't use context until then. The
     * area->type->context() callback has changed but data may be invalid
     * (e.g. with properties editor) until space-data is properly created */
 
    /* check previously stored space */
    SpaceLink *sl = nullptr;
    LISTBASE_FOREACH (SpaceLink *, sl_iter, &area->spacedata) {
      if (sl_iter->spacetype == type) {
        sl = sl_iter;
        break;
      }
    }
 
    /* old spacedata... happened during work on 2.50, remove */
    if (sl && BLI_listbase_is_empty(&sl->regionbase)) {
      st->free(sl);
      BLI_freelinkN(&area->spacedata, sl);
      if (slold == sl) {
        slold = nullptr;
      }
      sl = nullptr;
    }
 
    if (sl) {
      /* swap regions */
      slold->regionbase = area->regionbase;
      area->regionbase = sl->regionbase;
      BLI_listbase_clear(&sl->regionbase);
      /* SPACE_FLAG_TYPE_WAS_ACTIVE is only used to go back to a previously active space that is
       * overlapped by temporary ones. It's now properly activated, so the flag should be cleared
       * at this point. */
      sl->link_flag &= ~SPACE_FLAG_TYPE_WAS_ACTIVE;
 
      /* put in front of list */
      BLI_remlink(&area->spacedata, sl);
      BLI_addhead(&area->spacedata, sl);
    }
    else {
      /* new space */
      if (st) {
        /* Don't get scene from context here which may depend on space-data. */
        Scene *scene = WM_window_get_active_scene(win);
        sl = st->create(area, scene);
        BLI_addhead(&area->spacedata, sl);
 
        /* swap regions */
        if (slold) {
          slold->regionbase = area->regionbase;
        }
        area->regionbase = sl->regionbase;
        BLI_listbase_clear(&sl->regionbase);
      }
    }
 
    /* Sync header alignment. */
    if (sync_header_alignment) {
      region_align_info_to_area(area, region_align_info);
    }
 
    ED_area_init(C, win, area);
 
    /* tell WM to refresh, cursor types etc */
    WM_event_add_mousemove(win);
 
    /* send space change notifier */
    WM_event_add_notifier(C, NC_SPACE | ND_SPACE_CHANGED, area);
 
    ED_area_tag_refresh(area);
  }
 
  /* Set area space subtype if applicable. */
  if (st && st->space_subtype_item_extend != nullptr) {
    if (area->butspacetype_subtype == -1) {
      /* Indication (probably from space_type_set_or_cycle) to ignore the
       * area's current subtype and use last-used, as saved in the space. */
      area->butspacetype_subtype = st->space_subtype_get(area);
    }
    st->space_subtype_set(area, area->butspacetype_subtype);
  }
 
  /* Whether setting a subtype or not we need to clear this value. Not just unneeded
   * but can interfere with the next change. Operations can change the type without
   * specifying a subtype (assumed zero) and we don't want to use the old subtype. */
  area->butspacetype_subtype = 0;
 
  if (BLI_listbase_is_single(&CTX_wm_screen(C)->areabase)) {
    /* If there is only one area update the window title. */
    WM_window_title(CTX_wm_manager(C), CTX_wm_window(C));
  }
 
  /* See #WM_capabilities_flag code-comments for details on the background check. */
  if (!G.background) {
    /* If window decoration styles are supported, send a notification to re-apply them. */
    if (WM_capabilities_flag() & WM_CAPABILITY_WINDOW_DECORATION_STYLES) {
      WM_event_add_notifier(C, NC_WINDOW, nullptr);
    }
  }
 
  /* also redraw when re-used */
  ED_area_tag_redraw(area);
}
 
static SpaceLink *area_get_prevspace(ScrArea *area)
{
  SpaceLink *sl = static_cast<SpaceLink *>(area->spacedata.first);
 
  /* First toggle to the next temporary space in the list. */
  for (SpaceLink *sl_iter = sl->next; sl_iter; sl_iter = sl_iter->next) {
    if (sl_iter->link_flag & SPACE_FLAG_TYPE_TEMPORARY) {
      return sl_iter;
    }
  }
 
  /* No temporary space, find the item marked as last active. */
  for (SpaceLink *sl_iter = sl->next; sl_iter; sl_iter = sl_iter->next) {
    if (sl_iter->link_flag & SPACE_FLAG_TYPE_WAS_ACTIVE) {
      return sl_iter;
    }
  }
 
  /* If neither is found, we can just return to the regular previous one. */
  return sl->next;
}
 
void ED_area_prevspace(bContext *C, ScrArea *area)
{
  SpaceLink *sl = static_cast<SpaceLink *>(area->spacedata.first);
  SpaceLink *prevspace = sl ? area_get_prevspace(area) : nullptr;
 
  if (prevspace) {
    /* Specify that we want last-used if there are subtypes. */
    area->butspacetype_subtype = -1;
    ED_area_newspace(C, area, prevspace->spacetype, false);
    /* We've exited the space, so it can't be considered temporary anymore. */
    sl->link_flag &= ~SPACE_FLAG_TYPE_TEMPORARY;
  }
  else {
    /* no change */
    return;
  }
  /* If this is a stacked full-screen, changing to previous area exits it (meaning we're still in a
   * full-screen, but not in a stacked one). */
  area->flag &= ~AREA_FLAG_STACKED_FULLSCREEN;
 
  ED_area_tag_redraw(area);
 
  /* send space change notifier */
  WM_event_add_notifier(C, NC_SPACE | ND_SPACE_CHANGED, area);
}
 
int ED_area_header_switchbutton(const bContext *C, uiBlock *block, int yco)
{
  ScrArea *area = CTX_wm_area(C);
  bScreen *screen = CTX_wm_screen(C);
  int xco = 0.4 * U.widget_unit;
 
  PointerRNA areaptr = RNA_pointer_create_discrete(&(screen->id), &RNA_Area, area);
 
  uiDefButR(block,
            ButType::Menu,
            0,
            "",
            xco,
            yco,
            1.6 * U.widget_unit,
            U.widget_unit,
            &areaptr,
            "ui_type",
            0,
            0.0f,
            0.0f,
            "");
 
  return xco + 1.7 * U.widget_unit;
}
 
/************************ standard UI regions ************************/
 
static ThemeColorID region_background_color_id(const bContext * /*C*/, const ARegion *region)
{
  switch (region->regiontype) {
    case RGN_TYPE_HEADER:
    case RGN_TYPE_TOOL_HEADER:
      return TH_HEADER;
    case RGN_TYPE_PREVIEW:
      return TH_PREVIEW_BACK;
    default:
      return TH_BACK;
  }
}
 
void ED_region_clear(const bContext *C, const ARegion *region, const int /*ThemeColorID*/ colorid)
{
  if (region->overlap) {
    /* view should be in pixelspace */
    UI_view2d_view_restore(C);
 
    float back[4];
    UI_GetThemeColor4fv(colorid, back);
    GPU_clear_color(back[3] * back[0], back[3] * back[1], back[3] * back[2], back[3]);
  }
  else {
    UI_ThemeClearColor(colorid);
  }
}
 
static void region_clear_fully_transparent(const bContext *C)
{
  /* view should be in pixelspace */
  UI_view2d_view_restore(C);
 
  GPU_clear_color(0, 0, 0, 0);
}
 
BLI_INLINE bool streq_array_any(const char *s, const char *arr[])
{
  for (uint i = 0; arr[i]; i++) {
    if (STREQ(arr[i], s)) {
      return true;
    }
  }
  return false;
}

static void ed_panel_draw(const bContext *C,
                          ARegion *region,
                          ListBase *lb,
                          PanelType *pt,
                          Panel *panel,
                          int w,
                          int em,
                          char *unique_panel_str,
                          const char *search_filter,
                          blender::wm::OpCallContext op_context)
{
  const uiStyle *style = UI_style_get_dpi();
 
  /* Draw panel. */
  char block_name[BKE_ST_MAXNAME + INSTANCED_PANEL_UNIQUE_STR_SIZE];
  if (unique_panel_str) {
    /* Instanced panels should have already been added at this point. */
    BLI_string_join(block_name, sizeof(block_name), pt->idname, unique_panel_str);
  }
  else {
    STRNCPY_UTF8(block_name, pt->idname);
  }
  uiBlock *block = UI_block_begin(C, region, block_name, blender::ui::EmbossType::Emboss);
 
  bool open;
  panel = UI_panel_begin(region, lb, block, pt, panel, &open);
  panel->runtime->layout_panels.clear();
 
  const bool search_filter_active = search_filter != nullptr && search_filter[0] != '\0';
 
  /* bad fixed values */
  blender::int2 co = {0, 0};
  int h = 0;
  int headerend = w - UI_UNIT_X;
 
  UI_panel_header_buttons_begin(panel);
  if (pt->draw_header_preset && !(pt->flag & PANEL_TYPE_NO_HEADER)) {
    /* for preset menu */
    panel->layout = &blender::ui::block_layout(block,
                                               blender::ui::LayoutDirection::Horizontal,
                                               blender::ui::LayoutType::Header,
                                               0,
                                               (UI_UNIT_Y * 1.1f) + style->panelspace,
                                               UI_UNIT_Y,
                                               1,
                                               0,
                                               style);
 
    panel->layout->operator_context_set(op_context);
 
    pt->draw_header_preset(C, panel);
 
    UI_block_apply_search_filter(block, search_filter);
    co = blender::ui::block_layout_resolve(block);
    UI_block_translate(block, headerend - co.x, 0);
    panel->layout = nullptr;
  }
 
  if (pt->draw_header && !(pt->flag & PANEL_TYPE_NO_HEADER)) {
    int labelx, labely;
    UI_panel_label_offset(block, &labelx, &labely);
 
    /* Unusual case: Use expanding layout (buttons stretch to available width). */
    if (pt->flag & PANEL_TYPE_HEADER_EXPAND) {
      uiLayout &layout = blender::ui::block_layout(block,
                                                   blender::ui::LayoutDirection::Vertical,
                                                   blender::ui::LayoutType::Panel,
                                                   labelx,
                                                   labely,
                                                   headerend - 2 * style->panelspace,
                                                   1,
                                                   0,
                                                   style);
      panel->layout = &layout.row(false);
    }
    /* Regular case: Normal panel with fixed size buttons. */
    else {
      panel->layout = &blender::ui::block_layout(block,
                                                 blender::ui::LayoutDirection::Horizontal,
                                                 blender::ui::LayoutType::Header,
                                                 labelx,
                                                 labely,
                                                 UI_UNIT_Y,
                                                 1,
                                                 0,
                                                 style);
    }
 
    panel->layout->operator_context_set(op_context);
 
    pt->draw_header(C, panel);
 
    UI_block_apply_search_filter(block, search_filter);
    co = blender::ui::block_layout_resolve(block);
    panel->labelofs = co.x - labelx;
    panel->layout = nullptr;
  }
  else {
    panel->labelofs = 0;
  }
  UI_panel_header_buttons_end(panel);
 
  if (open || search_filter_active) {
    blender::ui::LayoutType panelContext;
 
    /* panel context can either be toolbar region or normal panels region */
    if (pt->flag & PANEL_TYPE_LAYOUT_VERT_BAR) {
      panelContext = blender::ui::LayoutType::VerticalBar;
    }
    else if (region->regiontype == RGN_TYPE_TOOLS) {
      panelContext = blender::ui::LayoutType::Toolbar;
    }
    else {
      panelContext = blender::ui::LayoutType::Panel;
    }
 
    panel->layout = &blender::ui::block_layout(
        block,
        blender::ui::LayoutDirection::Vertical,
        panelContext,
        (pt->flag & PANEL_TYPE_LAYOUT_VERT_BAR) ? 0 : style->panelspace,
        0,
        (pt->flag & PANEL_TYPE_LAYOUT_VERT_BAR) ? 0 : w - 2 * style->panelspace,
        em,
        0,
        style);
 
    panel->layout->operator_context_set(op_context);
 
    pt->draw(C, panel);
 
    const bool ends_with_layout_panel_header = uiLayoutEndsWithPanelHeader(*panel->layout);
 
    UI_block_apply_search_filter(block, search_filter);
    co = blender::ui::block_layout_resolve(block);
    panel->layout = nullptr;
 
    if (co.y != 0) {
      h = -co.y;
      h += style->panelspace;
      if (!ends_with_layout_panel_header) {
        /* Last layout panel header ends together with the panel. */
        h += style->panelspace;
      }
    }
  }
 
  UI_block_end(C, block);
 
  /* Draw child panels. */
  if (open || search_filter_active) {
    LISTBASE_FOREACH (LinkData *, link, &pt->children) {
      PanelType *child_pt = static_cast<PanelType *>(link->data);
      Panel *child_panel = UI_panel_find_by_type(&panel->children, child_pt);
 
      if (child_pt->draw && (!child_pt->poll || child_pt->poll(C, child_pt))) {
        ed_panel_draw(C,
                      region,
                      &panel->children,
                      child_pt,
                      child_panel,
                      w,
                      em,
                      unique_panel_str,
                      search_filter,
                      op_context);
      }
    }
  }
 
  UI_panel_end(panel, w, h);
}

static bool panel_add_check(const bContext *C,
                            const WorkSpace *workspace,
                            const char *contexts[],
                            const char *category_override,
                            PanelType *panel_type)
{
  /* Only add top level panels. */
  if (panel_type->parent) {
    return false;
  }
  /* Check the category override first. */
  if (category_override) {
    if (!STREQ(panel_type->category, category_override)) {
      return false;
    }
  }
 
  /* Verify context. */
  if (contexts != nullptr && panel_type->context[0]) {
    if (!streq_array_any(panel_type->context, contexts)) {
      return false;
    }
  }
 
  /* If we're tagged, only use compatible. */
  if (panel_type->owner_id[0]) {
    if (!BKE_workspace_owner_id_check(workspace, panel_type->owner_id)) {
      return false;
    }
  }
 
  if (LIKELY(panel_type->draw)) {
    if (panel_type->poll && !panel_type->poll(C, panel_type)) {
      return false;
    }
  }
 
  return true;
}
 
static bool region_uses_category_tabs(const ScrArea *area, const ARegion *region)
{
  /* XXX, should use some better check? */
  /* For now also has hardcoded check for clip editor until it supports actual toolbar. */
  return ((1 << region->regiontype) & RGN_TYPE_HAS_CATEGORY_MASK) ||
         (region->regiontype == RGN_TYPE_TOOLS && area->spacetype == SPACE_CLIP);
}
 
static const char *region_panels_collect_categories(ARegion *region,
                                                    LinkNode *panel_types_stack,
                                                    bool *use_category_tabs)
{
  UI_panel_category_clear_all(region);
 
  /* gather unique categories */
  for (LinkNode *pt_link = panel_types_stack; pt_link; pt_link = pt_link->next) {
    PanelType *pt = static_cast<PanelType *>(pt_link->link);
    if (pt->category[0]) {
      if (!UI_panel_category_find(region, pt->category)) {
        UI_panel_category_add(region, pt->category);
      }
    }
  }
 
  if (UI_panel_category_is_visible(region)) {
    return UI_panel_category_active_get(region, true);
  }
 
  *use_category_tabs = false;
  return nullptr;
}
 
static int panel_draw_width_from_max_width_get(const ARegion *region,
                                               const PanelType *panel_type,
                                               const int max_width)
{
  /* With a background, we want some extra padding. */
  return UI_panel_should_show_background(region, panel_type) ?
             max_width - UI_PANEL_MARGIN_X * 2.0f :
             max_width;
}
 
void ED_region_panels_layout_ex(const bContext *C,
                                ARegion *region,
                                ListBase *paneltypes,
                                blender::wm::OpCallContext op_context,
                                const char *contexts[],
                                const char *category_override)
{
  /* collect panels to draw */
  WorkSpace *workspace = CTX_wm_workspace(C);
  LinkNode *panel_types_stack = nullptr;
  LISTBASE_FOREACH_BACKWARD (PanelType *, pt, paneltypes) {
    if (panel_add_check(C, workspace, contexts, category_override, pt)) {
      BLI_linklist_prepend_alloca(&panel_types_stack, pt);
    }
  }
 
  region->runtime->category = nullptr;
 
  ScrArea *area = CTX_wm_area(C);
  View2D *v2d = &region->v2d;
 
  bool use_category_tabs = (category_override == nullptr) &&
                           region_uses_category_tabs(area, region);
  /* offset panels for small vertical tab area */
  const char *category = nullptr;
  const int category_tabs_width = UI_PANEL_CATEGORY_MARGIN_WIDTH;
  int margin_x = 0;
  const bool region_layout_based = region->flag & RGN_FLAG_DYNAMIC_SIZE;
  bool update_tot_size = true;
 
  /* only allow scrolling in vertical direction */
  v2d->keepofs |= V2D_LOCKOFS_X | V2D_KEEPOFS_Y;
  v2d->keepofs &= ~(V2D_LOCKOFS_Y | V2D_KEEPOFS_X);
  v2d->scroll &= ~V2D_SCROLL_BOTTOM;
 
  if (region->alignment & RGN_ALIGN_LEFT) {
    region->v2d.scroll &= ~V2D_SCROLL_RIGHT;
    region->v2d.scroll |= V2D_SCROLL_LEFT;
  }
  else {
    region->v2d.scroll &= ~V2D_SCROLL_LEFT;
    region->v2d.scroll |= V2D_SCROLL_RIGHT;
  }
 
  /* collect categories */
  if (use_category_tabs) {
    category = region_panels_collect_categories(region, panel_types_stack, &use_category_tabs);
  }
  if (use_category_tabs) {
    margin_x = category_tabs_width;
  }
 
  const int max_panel_width = BLI_rctf_size_x(&v2d->cur) - margin_x;
  /* Works out to 10 * UI_UNIT_X or 20 * UI_UNIT_X. */
  const int em = (region->runtime->type->prefsizex) ? 10 : 20;
 
  /* create panels */
  UI_panels_begin(C, region);
 
  /* Get search string for property search. */
  const char *search_filter = ED_area_region_search_filter_get(area, region);
 
  /* set view2d view matrix  - UI_block_begin() stores it */
  UI_view2d_view_ortho(v2d);
 
  bool has_instanced_panel = false;
  for (LinkNode *pt_link = panel_types_stack; pt_link; pt_link = pt_link->next) {
    PanelType *pt = static_cast<PanelType *>(pt_link->link);
 
    if (pt->flag & PANEL_TYPE_INSTANCED) {
      has_instanced_panel = true;
      continue;
    }
    Panel *panel = UI_panel_find_by_type(&region->panels, pt);
 
    if (use_category_tabs && pt->category[0] && !STREQ(category, pt->category)) {
      if ((panel == nullptr) || ((panel->flag & PNL_PIN) == 0)) {
        continue;
      }
    }
    const int width = panel_draw_width_from_max_width_get(region, pt, max_panel_width);
 
    if (panel && UI_panel_is_dragging(panel)) {
      /* Prevent View2d.tot rectangle size changes while dragging panels. */
      update_tot_size = false;
    }
 
    ed_panel_draw(
        C, region, &region->panels, pt, panel, width, em, nullptr, search_filter, op_context);
  }
 
  /* Draw "poly-instantiated" panels that don't have a 1 to 1 correspondence with their types. */
  if (has_instanced_panel) {
    LISTBASE_FOREACH (Panel *, panel, &region->panels) {
      if (panel->type == nullptr) {
        continue; /* Some panels don't have a type. */
      }
      if (!(panel->type->flag & PANEL_TYPE_INSTANCED)) {
        continue;
      }
      if (use_category_tabs && panel->type->category[0] && !STREQ(category, panel->type->category))
      {
        continue;
      }
      if (!panel_add_check(C, workspace, contexts, category_override, panel->type)) {
        continue;
      }
 
      const int width = panel_draw_width_from_max_width_get(region, panel->type, max_panel_width);
 
      if (UI_panel_is_dragging(panel)) {
        /* Prevent View2d.tot rectangle size changes while dragging panels. */
        update_tot_size = false;
      }
 
      /* Use a unique identifier for instanced panels, otherwise an old block for a different
       * panel of the same type might be found. */
      char unique_panel_str[INSTANCED_PANEL_UNIQUE_STR_SIZE];
      UI_list_panel_unique_str(panel, unique_panel_str);
      ed_panel_draw(C,
                    region,
                    &region->panels,
                    panel->type,
                    panel,
                    width,
                    em,
                    unique_panel_str,
                    search_filter,
                    op_context);
    }
  }
 
  /* align panels and return size */
  int x, y;
  UI_panels_end(C, region, &x, &y);
 
  /* before setting the view */
  if (region_layout_based) {
    /* XXX, only single panel support at the moment.
     * Can't use x/y values calculated above because they're not using the real height of panels,
     * instead they calculate offsets for the next panel to start drawing. */
    Panel *panel = static_cast<Panel *>(region->panels.last);
    if (panel != nullptr) {
      const int size_dyn[2] = {
          int(UI_UNIT_X * (UI_panel_is_closed(panel) ? 8 : 14) / UI_SCALE_FAC),
          int(UI_panel_size_y(panel) / UI_SCALE_FAC),
      };
      /* region size is layout based and needs to be updated */
      if ((region->sizex != size_dyn[0]) || (region->sizey != size_dyn[1])) {
        region->sizex = size_dyn[0];
        region->sizey = size_dyn[1];
        ED_area_tag_region_size_update(area, region);
      }
      y = fabsf(region->sizey * UI_SCALE_FAC - 1);
    }
  }
  else {
    /* We always keep the scroll offset -
     * so the total view gets increased with the scrolled away part. */
    if (v2d->cur.ymax < -FLT_EPSILON) {
      /* Clamp to lower view boundary */
      if (v2d->tot.ymin < -v2d->winy) {
        y = min_ii(y, 0);
      }
      else {
        y = min_ii(y, v2d->cur.ymin);
      }
    }
 
    y = -y;
  }
 
  UI_blocklist_update_view_for_buttons(C, &region->runtime->uiblocks);
 
  if (update_tot_size) {
    /* this also changes the 'cur' */
    UI_view2d_totRect_set(v2d, x, y);
  }
 
  if (use_category_tabs) {
    region->runtime->category = category;
  }
}
 
void ED_region_draw_overflow_indication(const ScrArea *area, ARegion *region, rcti *mask)
{
  if (!(region->flag & RGN_FLAG_INDICATE_OVERFLOW)) {
    return;
  }
 
  const bool is_overlap = ED_region_is_overlap(area->spacetype, region->regiontype);
  const bool is_header = ELEM(region->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER);
  const bool narrow = region->v2d.scroll & (V2D_SCROLL_VERTICAL | V2D_SCROLL_HORIZONTAL);
  const float gradient_width = (narrow ? 4.0f : 16.0f) * UI_SCALE_FAC;
  const float transition = 20.0f * UI_SCALE_FAC;
 
  float opaque[4];
  if (narrow) {
    UI_GetThemeColor3fv(TH_BLACK, opaque);
    opaque[3] = 0.2f;
  }
  else {
    UI_GetThemeColor3fv(TH_BACK, opaque);
    opaque[3] = 1.0f;
    if (!is_header) {
      mul_v3_fl(opaque, 0.85f);
    }
  }
 
  if (!mask) {
    mask = &region->v2d.mask;
  }
 
  int width = BLI_rcti_size_x(mask) + 1;
  int height = BLI_rcti_size_y(mask) + 1;
  float offset_x = mask->xmin;
  float offset_y = mask->ymin;
 
  if (is_overlap) {
    if (is_header) {
      offset_y += 3.0f * UI_SCALE_FAC;
    }
    else if (region->panels.first) {
      offset_x = UI_PANEL_MARGIN_X;
      width -= (2 * UI_PANEL_MARGIN_X);
    }
  }
 
  rctf rect{};
  float transparent[4];
  copy_v3_v3(transparent, opaque);
  transparent[3] = 0.0f;
  float grad_color[4];
 
  if (region->v2d.cur.xmax < region->v2d.tot.xmax &&
      !(area->spacetype == SPACE_OUTLINER && region->regiontype == RGN_TYPE_WINDOW))
  {
    /* Right Edge. */
    rect.xmax = offset_x + width;
    rect.xmin = offset_x + rect.xmax - gradient_width;
    rect.ymin = offset_y;
    rect.ymax = height;
    copy_v4_v4(grad_color, opaque);
    grad_color[3] *= std::min((region->v2d.tot.xmax - region->v2d.cur.xmax) / transition, 1.0f);
    UI_draw_roundbox_4fv_ex(&rect, grad_color, transparent, 0.0f, nullptr, 0.0f, 0.0f);
  }
  if (region->v2d.cur.xmin > region->v2d.tot.xmin) {
    /* Left Edge. */
    rect.xmin = offset_x;
    if (is_header && (U.uiflag & USER_AREA_CORNER_HANDLE)) {
      rect.xmin += 12.0f * UI_SCALE_FAC;
    }
    rect.xmax = rect.xmin + gradient_width;
    rect.ymin = offset_y;
    rect.ymax = height;
    copy_v4_v4(grad_color, opaque);
    grad_color[3] *= std::min((region->v2d.cur.xmin - region->v2d.tot.xmin) / transition, 1.0f);
    UI_draw_roundbox_4fv_ex(&rect, transparent, grad_color, 0.0f, nullptr, 0.0f, 0.0f);
    if (is_header && (U.uiflag & USER_AREA_CORNER_HANDLE)) {
      rect.xmin = 0.0f;
      rect.xmax = 12.0f * UI_SCALE_FAC;
      UI_draw_roundbox_4fv_ex(&rect, grad_color, nullptr, 0.0f, nullptr, 0.0f, 0.0f);
    }
  }
  if (region->v2d.cur.ymax < region->v2d.tot.ymax) {
    /* Top Edge. */
    rect.xmin = offset_x;
    rect.xmax = offset_x + width;
    rect.ymax = offset_y + height;
    rect.ymin = rect.ymax - gradient_width;
    copy_v4_v4(grad_color, opaque);
    grad_color[3] *= std::min((region->v2d.tot.ymax - region->v2d.cur.ymax) / transition, 1.0f);
    UI_draw_roundbox_4fv_ex(&rect, grad_color, transparent, 1.0f, nullptr, 0.0f, 0.0f);
  }
  if (region->v2d.cur.ymin > region->v2d.tot.ymin) {
    /* Bottom Edge. */
    rect.xmin = offset_x;
    rect.xmax = offset_x + width;
    rect.ymin = offset_y;
    rect.ymax = rect.ymin + gradient_width;
    copy_v4_v4(grad_color, opaque);
    grad_color[3] *= std::min((region->v2d.cur.ymin - region->v2d.tot.ymin) / transition, 1.0f);
    UI_draw_roundbox_4fv_ex(&rect, transparent, grad_color, 1.0f, nullptr, 0.0f, 0.0f);
  }
}
 
void ED_region_panels_layout(const bContext *C, ARegion *region)
{
  ED_region_panels_layout_ex(C,
                             region,
                             &region->runtime->type->paneltypes,
                             blender::wm::OpCallContext::InvokeRegionWin,
                             nullptr,
                             nullptr);
}
 
void ED_region_panels_draw(const bContext *C, ARegion *region)
{
  View2D *v2d = &region->v2d;
  const float aspect = BLI_rctf_size_y(&region->v2d.cur) /
                       (BLI_rcti_size_y(&region->v2d.mask) + 1);
 
  if (region->alignment != RGN_ALIGN_FLOAT) {
    ED_region_clear(C,
                    region,
                    (region->runtime->type->regionid == RGN_TYPE_PREVIEW) ? TH_PREVIEW_BACK :
                                                                            TH_BACK);
  }
 
  /* reset line width for drawing tabs */
  GPU_line_width(1.0f);
 
  /* set the view */
  UI_view2d_view_ortho(v2d);
 
  /* View2D matrix might have changed due to dynamic sized regions. */
  UI_blocklist_update_window_matrix(C, &region->runtime->uiblocks);
 
  /* draw panels if they are large enough. */
  const bool has_catgories = (region->panels_category_active.first != nullptr);
  const short min_draw_size = has_catgories ? short(UI_PANEL_CATEGORY_MIN_WIDTH) + 20 :
                                              std::min(region->runtime->type->prefsizex, 20);
  if (region->winx >= (min_draw_size * UI_SCALE_FAC / aspect)) {
    UI_panels_draw(C, region);
  }
 
  /* restore view matrix */
  UI_view2d_view_restore(C);
 
  /* Set in layout. */
  if (region->runtime->category) {
    UI_panel_category_draw_all(region, region->runtime->category);
  }
 
  /* scrollers */
  bool use_mask = false;
  rcti mask;
  const short alignment = RGN_ALIGN_ENUM_FROM_MASK(region->alignment);
  if (region->runtime->category && ELEM(alignment, RGN_ALIGN_RIGHT, RGN_ALIGN_LEFT) &&
      UI_panel_category_is_visible(region))
  {
    use_mask = true;
    UI_view2d_mask_from_win(v2d, &mask);
    const int category_width = round_fl_to_int(UI_view2d_scale_get_x(&region->v2d) *
                                               UI_PANEL_CATEGORY_MARGIN_WIDTH);
    if (alignment == RGN_ALIGN_RIGHT) {
      mask.xmax -= category_width;
    }
    else if (alignment == RGN_ALIGN_LEFT) {
      mask.xmin += category_width;
    }
  }
 
  ED_region_draw_overflow_indication(CTX_wm_area(C), region, use_mask ? &mask : nullptr);
 
  /* Hide scrollbars below a threshold. */
  int min_width = UI_panel_category_is_visible(region) ? 60.0f * UI_SCALE_FAC / aspect :
                                                         40.0f * UI_SCALE_FAC / aspect;
  if (BLI_rcti_size_x(&region->winrct) <= min_width) {
    v2d->scroll &= ~(V2D_SCROLL_HORIZONTAL | V2D_SCROLL_VERTICAL);
  }
 
  UI_view2d_scrollers_draw(v2d, use_mask ? &mask : nullptr);
}
 
void ED_region_panels_ex(const bContext *C,
                         ARegion *region,
                         blender::wm::OpCallContext op_context,
                         const char *contexts[])
{
  /* TODO: remove? */
  ED_region_panels_layout_ex(
      C, region, &region->runtime->type->paneltypes, op_context, contexts, nullptr);
  ED_region_panels_draw(C, region);
}
 
void ED_region_panels(const bContext *C, ARegion *region)
{
  /* TODO: remove? */
  ED_region_panels_layout(C, region);
  ED_region_panels_draw(C, region);
}
 
void ED_region_panels_init(wmWindowManager *wm, ARegion *region)
{
  UI_view2d_region_reinit(&region->v2d, V2D_COMMONVIEW_PANELS_UI, region->winx, region->winy);
 
  /* Place scroll bars to the left if left-aligned, right if right-aligned. */
  if (region->alignment & RGN_ALIGN_LEFT) {
    region->v2d.scroll &= ~V2D_SCROLL_RIGHT;
    region->v2d.scroll |= V2D_SCROLL_LEFT;
  }
  else if (region->alignment & RGN_ALIGN_RIGHT) {
    region->v2d.scroll &= ~V2D_SCROLL_LEFT;
    region->v2d.scroll |= V2D_SCROLL_RIGHT;
  }
 
  wmKeyMap *keymap = WM_keymap_ensure(
      wm->runtime->defaultconf, "View2D Buttons List", SPACE_EMPTY, RGN_TYPE_WINDOW);
  WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
}

static bool panel_property_search(const bContext *C,
                                  ARegion *region,
                                  const uiStyle *style,
                                  Panel *panel,
                                  PanelType *panel_type,
                                  const char *search_filter)
{
  uiBlock *block = UI_block_begin(C, region, panel_type->idname, blender::ui::EmbossType::Emboss);
  UI_block_set_search_only(block, true);
 
  /* Skip panels that give meaningless search results. */
  if (panel_type->flag & PANEL_TYPE_NO_SEARCH) {
    return false;
  }
 
  if (panel == nullptr) {
    bool open; /* Dummy variable. */
    panel = UI_panel_begin(region, &region->panels, block, panel_type, panel, &open);
  }
 
  /* Build the layouts. Because they are only used for search,
   * they don't need any of the proper style or layout information. */
  if (panel->type->draw_header_preset != nullptr) {
    panel->layout = &blender::ui::block_layout(block,
                                               blender::ui::LayoutDirection::Horizontal,
                                               blender::ui::LayoutType::Header,
                                               0,
                                               0,
                                               0,
                                               0,
                                               0,
                                               style);
    panel_type->draw_header_preset(C, panel);
  }
  if (panel->type->draw_header != nullptr) {
    panel->layout = &blender::ui::block_layout(block,
                                               blender::ui::LayoutDirection::Horizontal,
                                               blender::ui::LayoutType::Header,
                                               0,
                                               0,
                                               0,
                                               0,
                                               0,
                                               style);
    panel_type->draw_header(C, panel);
  }
  if (LIKELY(panel->type->draw != nullptr)) {
    panel->layout = &blender::ui::block_layout(block,
                                               blender::ui::LayoutDirection::Vertical,
                                               blender::ui::LayoutType::Panel,
                                               0,
                                               0,
                                               0,
                                               0,
                                               0,
                                               style);
    panel_type->draw(C, panel);
  }
 
  blender::ui::block_layout_free(block);
 
  /* We could check after each layout to increase the likelihood of returning early,
   * but that probably wouldn't make much of a difference anyway. */
  if (UI_block_apply_search_filter(block, search_filter)) {
    return true;
  }
 
  LISTBASE_FOREACH (LinkData *, link, &panel_type->children) {
    PanelType *panel_type_child = static_cast<PanelType *>(link->data);
    if (!panel_type_child->poll || panel_type_child->poll(C, panel_type_child)) {
      /* Search for the existing child panel here because it might be an instanced
       * child panel with a custom data field that will be needed to build the layout. */
      Panel *child_panel = UI_panel_find_by_type(&panel->children, panel_type_child);
      if (panel_property_search(C, region, style, child_panel, panel_type_child, search_filter)) {
        return true;
      }
    }
  }
 
  return false;
}
 
bool ED_region_property_search(const bContext *C,
                               ARegion *region,
                               ListBase *paneltypes,
                               const char *contexts[],
                               const char *category_override)
{
  ScrArea *area = CTX_wm_area(C);
  WorkSpace *workspace = CTX_wm_workspace(C);
  const uiStyle *style = UI_style_get_dpi();
  const char *search_filter = ED_area_region_search_filter_get(area, region);
 
  LinkNode *panel_types_stack = nullptr;
  LISTBASE_FOREACH_BACKWARD (PanelType *, pt, paneltypes) {
    if (panel_add_check(C, workspace, contexts, category_override, pt)) {
      BLI_linklist_prepend_alloca(&panel_types_stack, pt);
    }
  }
 
  const char *category = nullptr;
  bool use_category_tabs = (category_override == nullptr) &&
                           region_uses_category_tabs(area, region);
  if (use_category_tabs) {
    category = region_panels_collect_categories(region, panel_types_stack, &use_category_tabs);
  }
 
  /* Run property search for each panel, stopping if a result is found. */
  bool has_result = true;
  bool has_instanced_panel = false;
  for (LinkNode *pt_link = panel_types_stack; pt_link; pt_link = pt_link->next) {
    PanelType *panel_type = static_cast<PanelType *>(pt_link->link);
    /* Note that these checks are duplicated from #ED_region_panels_layout_ex. */
    if (panel_type->flag & PANEL_TYPE_INSTANCED) {
      has_instanced_panel = true;
      continue;
    }
 
    if (use_category_tabs) {
      if (panel_type->category[0] && !STREQ(category, panel_type->category)) {
        continue;
      }
    }
 
    /* We start property search with an empty panel list, so there's
     * no point in trying to find an existing panel with this type. */
    has_result = panel_property_search(C, region, style, nullptr, panel_type, search_filter);
    if (has_result) {
      break;
    }
  }
 
  /* Run property search for instanced panels (created in the layout calls of previous panels). */
  if (!has_result && has_instanced_panel) {
    LISTBASE_FOREACH (Panel *, panel, &region->panels) {
      /* Note that these checks are duplicated from #ED_region_panels_layout_ex. */
      if (panel->type == nullptr || !(panel->type->flag & PANEL_TYPE_INSTANCED)) {
        continue;
      }
      if (use_category_tabs) {
        if (panel->type->category[0] && !STREQ(category, panel->type->category)) {
          continue;
        }
      }
 
      has_result = panel_property_search(C, region, style, panel, panel->type, search_filter);
      if (has_result) {
        break;
      }
    }
  }
 
  /* Free the panels and blocks, as they are only used for search. */
  UI_blocklist_free(C, region);
  UI_panels_free_instanced(C, region);
  BKE_area_region_panels_free(&region->panels);
 
  return has_result;
}
 
void ED_region_header_layout(const bContext *C, ARegion *region)
{
  const uiStyle *style = UI_style_get_dpi();
  bool region_layout_based = region->flag & RGN_FLAG_DYNAMIC_SIZE;
  const ScrArea *area = CTX_wm_area(C);
  const bool is_global = area && ELEM(area->spacetype, SPACE_TOPBAR, SPACE_STATUSBAR);
  const int offset = is_global ? 4.0f * UI_SCALE_FAC : int(UI_HEADER_OFFSET);
 
  /* Height of buttons and scaling needed to achieve it. */
  const int buttony = min_ii(UI_UNIT_Y, region->winy - 2 * UI_SCALE_FAC);
  const float buttony_scale = buttony / float(UI_UNIT_Y);
 
  /* Vertically center buttons. */
  blender::int2 co = {offset, buttony + (region->winy - buttony) / 2};
  int maxco = co.x;
 
  /* set view2d view matrix for scrolling (without scrollers) */
  UI_view2d_view_ortho(&region->v2d);
 
  /* draw all headers types */
  LISTBASE_FOREACH (HeaderType *, ht, &region->runtime->type->headertypes) {
    if (ht->poll && !ht->poll(C, ht)) {
      continue;
    }
 
    uiBlock *block = UI_block_begin(C, region, ht->idname, blender::ui::EmbossType::Emboss);
    uiLayout &layout = blender::ui::block_layout(block,
                                                 blender::ui::LayoutDirection::Horizontal,
                                                 blender::ui::LayoutType::Header,
                                                 co.x,
                                                 co.y,
                                                 buttony,
                                                 1,
                                                 0,
                                                 style);
 
    if (buttony_scale != 1.0f) {
      layout.scale_y_set(buttony_scale);
    }
 
    Header header = {nullptr};
    if (ht->draw) {
      header.type = ht;
      header.layout = &layout;
      ht->draw(C, &header);
      if (ht->next) {
        layout.separator();
      }
 
      /* for view2d */
      co.x = layout.width();
      maxco = std::max(co.x, maxco);
    }
 
    co = blender::ui::block_layout_resolve(block);
 
    /* for view2d */
    maxco = std::max(co.x, maxco);
 
    int new_sizex = (maxco + offset) / UI_SCALE_FAC;
 
    if (region_layout_based && (region->sizex != new_sizex)) {
      /* region size is layout based and needs to be updated */
      ScrArea *area = CTX_wm_area(C);
 
      region->sizex = new_sizex;
      ED_area_tag_region_size_update(area, region);
    }
 
    UI_block_end(C, block);
 
    /* In most cases there is only ever one header, it never makes sense to draw more than one
     * header in the same region, this results in overlapping buttons, see: #60195. */
    break;
  }
 
  if (!region_layout_based) {
    maxco += offset;
  }
 
  /* Always as last. */
  UI_view2d_totRect_set(&region->v2d, maxco, region->winy);
 
  /* Restore view matrix. */
  UI_view2d_view_restore(C);
}
 
static void region_draw_blocks_in_view2d(const bContext *C, const ARegion *region)
{
  UI_view2d_view_ortho(&region->v2d);
 
  /* View2D matrix might have changed due to dynamic sized regions. */
  UI_blocklist_update_window_matrix(C, &region->runtime->uiblocks);
 
  /* draw blocks */
  UI_blocklist_draw(C, &region->runtime->uiblocks);
 
  /* restore view matrix */
  UI_view2d_view_restore(C);
}
 
void ED_region_header_draw(const bContext *C, ARegion *region)
{
  /* clear */
  ED_region_clear(C, region, region_background_color_id(C, region));
 
  if (GPU_type_matches_ex(GPU_DEVICE_ATI, GPU_OS_UNIX, GPU_DRIVER_OPENSOURCE, GPU_BACKEND_OPENGL))
  {
    /* WORKAROUND: Driver bug. Fixes invalid glyph being rendered (see #147168). */
    BLF_batch_discard();
  }
 
  region_draw_blocks_in_view2d(C, region);
  ED_region_draw_overflow_indication(CTX_wm_area(C), region);
}
 
void ED_region_header_draw_with_button_sections(const bContext *C,
                                                const ARegion *region,
                                                const uiButtonSectionsAlign align)
{
  const ThemeColorID bgcolorid = region_background_color_id(C, region);
 
  /* Clear and draw button sections background when using region overlap. Otherwise clear using the
   * background color like normal. */
  if (region->overlap) {
    region_clear_fully_transparent(C);
    UI_region_button_sections_draw(region, bgcolorid, align);
  }
  else {
    ED_region_clear(C, region, bgcolorid);
  }
  region_draw_blocks_in_view2d(C, region);
}
 
void ED_region_header(const bContext *C, ARegion *region)
{
  /* TODO: remove? */
  ED_region_header_layout(C, region);
  ED_region_header_draw(C, region);
}
 
void ED_region_header_with_button_sections(const bContext *C,
                                           ARegion *region,
                                           const uiButtonSectionsAlign align)
{
  ED_region_header_layout(C, region);
  ED_region_header_draw_with_button_sections(C, region, align);
}
 
void ED_region_header_init(ARegion *region)
{
  UI_view2d_region_reinit(&region->v2d, V2D_COMMONVIEW_HEADER, region->winx, region->winy);
  region->flag |= RGN_FLAG_INDICATE_OVERFLOW;
}
 
int ED_area_headersize()
{
  /* Accommodate widget and padding. */
  return U.widget_unit + int(UI_SCALE_FAC * HEADER_PADDING_Y);
}
 
int ED_area_footersize()
{
  return ED_area_headersize();
}
 
int ED_area_global_size_y(const ScrArea *area)
{
  BLI_assert(ED_area_is_global(area));
  return round_fl_to_int(area->global->cur_fixed_height * UI_SCALE_FAC);
}
int ED_area_global_min_size_y(const ScrArea *area)
{
  BLI_assert(ED_area_is_global(area));
  return round_fl_to_int(area->global->size_min * UI_SCALE_FAC);
}
int ED_area_global_max_size_y(const ScrArea *area)
{
  BLI_assert(ED_area_is_global(area));
  return round_fl_to_int(area->global->size_max * UI_SCALE_FAC);
}
 
bool ED_area_is_global(const ScrArea *area)
{
  return area->global != nullptr;
}
 
ScrArea *ED_area_find_under_cursor(const bContext *C, int spacetype, const int event_xy[2])
{
  bScreen *screen = CTX_wm_screen(C);
  wmWindow *win = CTX_wm_window(C);
 
  ScrArea *area = nullptr;
 
  if (win->parent) {
    /* If active window is a child, check itself first. */
    area = BKE_screen_find_area_xy(screen, spacetype, event_xy);
  }
 
  if (!area) {
    /* Check all windows except the active one. */
    int event_xy_other[2];
    wmWindow *win_other = WM_window_find_under_cursor(win, event_xy, event_xy_other);
    if (win_other && win_other != win) {
      win = win_other;
      screen = WM_window_get_active_screen(win);
      area = BKE_screen_find_area_xy(screen, spacetype, event_xy_other);
    }
  }
 
  if (!area && !win->parent) {
    /* If active window is a parent window, check itself last. */
    area = BKE_screen_find_area_xy(screen, spacetype, event_xy);
  }
 
  return area;
}
 
ScrArea *ED_screen_areas_iter_first(const wmWindow *win, const bScreen *screen)
{
  ScrArea *global_area = static_cast<ScrArea *>(win->global_areas.areabase.first);
 
  if (!global_area) {
    return static_cast<ScrArea *>(screen->areabase.first);
  }
  if ((global_area->global->flag & GLOBAL_AREA_IS_HIDDEN) == 0) {
    return global_area;
  }
  /* Find next visible area. */
  return ED_screen_areas_iter_next(screen, global_area);
}
ScrArea *ED_screen_areas_iter_next(const bScreen *screen, const ScrArea *area)
{
  if (area->global == nullptr) {
    return area->next;
  }
 
  for (ScrArea *area_iter = area->next; area_iter; area_iter = area_iter->next) {
    if ((area_iter->global->flag & GLOBAL_AREA_IS_HIDDEN) == 0) {
      return area_iter;
    }
  }
  /* No visible next global area found, start iterating over layout areas. */
  return static_cast<ScrArea *>(screen->areabase.first);
}
 
int ED_region_global_size_y()
{
  return ED_area_headersize(); /* same size as header */
}
 
void ED_region_info_draw_multiline(ARegion *region,
                                   const char *text_array[],
                                   const float fill_color[4],
                                   const bool full_redraw)
{
  const int header_height = UI_UNIT_Y;
  const uiStyle *style = UI_style_get_dpi();
  int fontid = style->widget.uifont_id;
  int scissor[4];
  int num_lines = 0;
 
  /* background box */
  rcti rect = *ED_region_visible_rect(region);
 
  /* Needed in case scripts leave the font size at an unexpected value, see: #102213. */
  BLF_size(fontid, style->widget.points * UI_SCALE_FAC);
 
  /* Box fill entire width or just around text. */
  if (!full_redraw) {
    const char **text = &text_array[0];
    while (*text) {
      rect.xmax = min_ii(rect.xmax,
                         rect.xmin + BLF_width(fontid, *text, BLF_DRAW_STR_DUMMY_MAX) +
                             1.2f * U.widget_unit);
      text++;
      num_lines++;
    }
  }
  /* Just count the line number. */
  else {
    const char **text = &text_array[0];
    while (*text) {
      text++;
      num_lines++;
    }
  }
 
  rect.ymin = rect.ymax - header_height * num_lines;
 
  /* setup scissor */
  GPU_scissor_get(scissor);
  GPU_scissor(rect.xmin, rect.ymin, BLI_rcti_size_x(&rect) + 1, BLI_rcti_size_y(&rect) + 1);
 
  GPU_blend(GPU_BLEND_ALPHA);
  GPUVertFormat *format = immVertexFormat();
  uint pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
  immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
  immUniformColor4fv(fill_color);
  immRectf(pos, rect.xmin, rect.ymin, rect.xmax + 1, rect.ymax + 1);
  immUnbindProgram();
  GPU_blend(GPU_BLEND_NONE);
 
  /* text */
  UI_FontThemeColor(fontid, TH_TEXT_HI);
  BLF_clipping(fontid, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
  BLF_enable(fontid, BLF_CLIPPING);
  int offset = num_lines - 1;
  {
    const char **text = &text_array[0];
    while (*text) {
      BLF_position(fontid,
                   rect.xmin + 0.6f * U.widget_unit,
                   rect.ymin + 0.3f * U.widget_unit + offset * header_height,
                   0.0f);
      BLF_draw(fontid, *text, BLF_DRAW_STR_DUMMY_MAX);
      text++;
      offset--;
    }
  }
 
  BLF_disable(fontid, BLF_CLIPPING);
 
  /* restore scissor as it was before */
  GPU_scissor(scissor[0], scissor[1], scissor[2], scissor[3]);
}
 
void ED_region_info_draw(ARegion *region,
                         const char *text,
                         const float fill_color[4],
                         const bool full_redraw)
{
  const char *text_array[2] = {text, nullptr};
  ED_region_info_draw_multiline(region, text_array, fill_color, full_redraw);
}
 
struct MetadataPanelDrawContext {
  uiLayout *layout;
};
 
static void metadata_panel_draw_field(const char *field, const char *value, void *ctx_v)
{
  MetadataPanelDrawContext *ctx = (MetadataPanelDrawContext *)ctx_v;
  uiLayout *row = &ctx->layout->row(false);
  row->label(field, ICON_NONE);
  row->label(value, ICON_NONE);
}
 
void ED_region_image_metadata_panel_draw(ImBuf *ibuf, uiLayout *layout)
{
  MetadataPanelDrawContext ctx;
  ctx.layout = layout;
  IMB_metadata_foreach(ibuf, metadata_panel_draw_field, &ctx);
}
 
void ED_region_grid_draw(ARegion *region, float zoomx, float zoomy, float x0, float y0)
{
  /* the image is located inside (x0, y0), (x0+1, y0+1) as set by view2d */
  int x1, y1, x2, y2;
  UI_view2d_view_to_region(&region->v2d, x0, y0, &x1, &y1);
  UI_view2d_view_to_region(&region->v2d, x0 + 1.0f, y0 + 1.0f, &x2, &y2);
 
  GPUVertFormat *format = immVertexFormat();
  uint pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
 
  float gridcolor[4];
  UI_GetThemeColor4fv(TH_GRID, gridcolor);
 
  immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
  /* To fake alpha-blending, color shading is reduced when alpha is nearing 0. */
  immUniformThemeColorBlendShade(TH_BACK, TH_GRID, gridcolor[3], 20 * gridcolor[3]);
  immRectf(pos, x1, y1, x2, y2);
  immUnbindProgram();
 
  /* gridsize adapted to zoom level */
  float gridsize = 0.5f * (zoomx + zoomy);
  float gridstep = 1.0f / 32.0f;
  if (gridsize <= 0.0f) {
    return;
  }
 
  if (gridsize < 1.0f) {
    while (gridsize < 1.0f) {
      gridsize *= 4.0f;
      gridstep *= 4.0f;
    }
  }
  else {
    while (gridsize >= 4.0f) {
      gridsize /= 4.0f;
      gridstep /= 4.0f;
    }
  }
 
  float blendfac = 0.25f * gridsize - floorf(0.25f * gridsize);
  CLAMP(blendfac, 0.0f, 1.0f);
 
  int count_fine = 1.0f / gridstep;
  int count_large = 1.0f / (4.0f * gridstep);
 
  if (count_fine > 0) {
    GPU_vertformat_clear(format);
    pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
    uint color = GPU_vertformat_attr_add(
        format, "color", blender::gpu::VertAttrType::SFLOAT_32_32_32);
 
    immBindBuiltinProgram(GPU_SHADER_3D_FLAT_COLOR);
    immBegin(GPU_PRIM_LINES, 4 * count_fine + 4 * count_large);
 
    float theme_color[3];
    UI_GetThemeColorShade3fv(TH_GRID, int(20.0f * (1.0f - blendfac)), theme_color);
    float fac = 0.0f;
 
    /* the fine resolution level */
    for (int i = 0; i < count_fine; i++) {
      immAttr3fv(color, theme_color);
      immVertex2f(pos, x1, y1 * (1.0f - fac) + y2 * fac);
      immAttr3fv(color, theme_color);
      immVertex2f(pos, x2, y1 * (1.0f - fac) + y2 * fac);
      immAttr3fv(color, theme_color);
      immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y1);
      immAttr3fv(color, theme_color);
      immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y2);
      fac += gridstep;
    }
 
    if (count_large > 0) {
      UI_GetThemeColor3fv(TH_GRID, theme_color);
      fac = 0.0f;
 
      /* the large resolution level */
      for (int i = 0; i < count_large; i++) {
        immAttr3fv(color, theme_color);
        immVertex2f(pos, x1, y1 * (1.0f - fac) + y2 * fac);
        immAttr3fv(color, theme_color);
        immVertex2f(pos, x2, y1 * (1.0f - fac) + y2 * fac);
        immAttr3fv(color, theme_color);
        immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y1);
        immAttr3fv(color, theme_color);
        immVertex2f(pos, x1 * (1.0f - fac) + x2 * fac, y2);
        fac += 4.0f * gridstep;
      }
    }
 
    immEnd();
    immUnbindProgram();
  }
}
 
/* If the area has overlapping regions, it returns visible rect for Region *region */
/* rect gets returned in local region coordinates */
static void region_visible_rect_calc(ARegion *region, rcti *rect)
{
  ARegion *region_iter = region;
 
  /* allow function to be called without area */
  while (region_iter->prev) {
    region_iter = region_iter->prev;
  }
 
  *rect = region->winrct;
 
  /* check if a region overlaps with the current one */
  for (; region_iter; region_iter = region_iter->next) {
    if (region != region_iter && region_iter->overlap) {
      if (BLI_rcti_isect(rect, &region_iter->winrct, nullptr)) {
        int alignment = RGN_ALIGN_ENUM_FROM_MASK(region_iter->alignment);
 
        if (ELEM(alignment, RGN_ALIGN_LEFT, RGN_ALIGN_RIGHT)) {
          /* Overlap left, also check 1 pixel offset (2 regions on one side). */
          if (abs(rect->xmin - region_iter->winrct.xmin) < 2) {
            rect->xmin = region_iter->winrct.xmax;
          }
 
          /* Overlap right. */
          if (abs(rect->xmax - region_iter->winrct.xmax) < 2) {
            rect->xmax = region_iter->winrct.xmin;
          }
        }
        else if (ELEM(alignment, RGN_ALIGN_TOP, RGN_ALIGN_BOTTOM)) {
          /* Same logic as above for vertical regions. */
          if (abs(rect->ymin - region_iter->winrct.ymin) < 2) {
            rect->ymin = region_iter->winrct.ymax;
          }
          if (abs(rect->ymax - region_iter->winrct.ymax) < 2) {
            rect->ymax = region_iter->winrct.ymin;
          }
        }
        else if (alignment == RGN_ALIGN_FLOAT) {
          /* Skip floating. */
        }
        else {
          BLI_assert_msg(0, "Region overlap with unknown alignment");
        }
      }
    }
  }
  BLI_rcti_translate(rect, -region->winrct.xmin, -region->winrct.ymin);
}
 
const rcti *ED_region_visible_rect(ARegion *region)
{
  rcti *rect = &region->runtime->visible_rect;
  if (rect->xmin == 0 && rect->ymin == 0 && rect->xmax == 0 && rect->ymax == 0) {
    region_visible_rect_calc(region, rect);
  }
  return rect;
}
 
/* Cache display helpers */
 
void ED_region_cache_draw_background(ARegion *region)
{
  /* Local coordinate visible rect inside region, to accommodate overlapping ui. */
  const rcti *rect_visible = ED_region_visible_rect(region);
  const int region_bottom = rect_visible->ymin;
 
  uint pos = GPU_vertformat_attr_add(
      immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
  immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
  immUniformColor4ub(128, 128, 255, 64);
  immRectf(pos, 0, region_bottom, region->winx, region_bottom + 8 * UI_SCALE_FAC);
  immUnbindProgram();
}
 
void ED_region_cache_draw_curfra_label(const int framenr, const float x, const float y)
{
  using namespace blender;
  const uiStyle *style = UI_style_get();
  int fontid = style->widget.uifont_id;
 
  /* Format frame number. */
  char numstr[32];
  BLF_size(fontid, 11.0f * UI_SCALE_FAC);
  SNPRINTF_UTF8(numstr, "%d", framenr);
 
  float2 text_dims = {0.0f, 0.0f};
  BLF_width_and_height(fontid, numstr, sizeof(numstr), &text_dims.x, &text_dims.y);
  float padding = 3.0f * UI_SCALE_FAC;
 
  /* Rounded corner background box. */
  float4 bg_color;
  UI_GetThemeColorShade4fv(TH_CFRAME, -5, bg_color);
  float4 outline_color;
  UI_GetThemeColorShade4fv(TH_CFRAME, 5, outline_color);
 
  rctf rect{};
  rect.xmin = x - text_dims.x / 2 - padding;
  rect.xmax = x + text_dims.x / 2 + padding;
  rect.ymin = y;
  rect.ymax = y + text_dims.y + padding * 2;
  UI_draw_roundbox_corner_set(UI_CNR_ALL);
  UI_draw_roundbox_4fv_ex(
      &rect, bg_color, nullptr, 1.0f, outline_color, U.pixelsize, 3 * UI_SCALE_FAC);
 
  /* Text label. */
  UI_FontThemeColor(fontid, TH_HEADER_TEXT_HI);
  BLF_position(fontid, x - text_dims.x * 0.5f, y + padding, 0.0f);
  BLF_draw(fontid, numstr, sizeof(numstr));
}
 
void ED_region_cache_draw_cached_segments(
    ARegion *region, const int num_segments, const int *points, const int sfra, const int efra)
{
  if (num_segments) {
    /* Local coordinate visible rect inside region, to accommodate overlapping ui. */
    const rcti *rect_visible = ED_region_visible_rect(region);
    const int region_bottom = rect_visible->ymin;
 
    uint pos = GPU_vertformat_attr_add(
        immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
    immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
    immUniformColor4ub(128, 128, 255, 128);
 
    for (int a = 0; a < num_segments; a++) {
      float x1 = float(points[a * 2] - sfra) / (efra - sfra + 1) * region->winx;
      float x2 = float(points[a * 2 + 1] - sfra + 1) / (efra - sfra + 1) * region->winx;
 
      immRectf(pos, x1, region_bottom, x2, region_bottom + 8 * UI_SCALE_FAC);
      /* TODO(merwin): use primitive restart to draw multiple rects more efficiently */
    }
 
    immUnbindProgram();
  }
}
 
void ED_region_message_subscribe(wmRegionMessageSubscribeParams *params)
{
  ARegion *region = params->region;
  const bContext *C = params->context;
  wmMsgBus *mbus = params->message_bus;
 
  if (region->runtime->gizmo_map != nullptr) {
    WM_gizmomap_message_subscribe(C, region->runtime->gizmo_map, region, mbus);
  }
 
  if (!BLI_listbase_is_empty(&region->runtime->uiblocks)) {
    UI_region_message_subscribe(region, mbus);
  }
 
  if (region->runtime->type->message_subscribe != nullptr) {
    region->runtime->type->message_subscribe(params);
  }
}
 
int ED_region_snap_size_test(const ARegion *region)
{
  /* Use a larger value because toggling scrollbars can jump in size. */
  const int snap_match_threshold = 16;
  if (region->runtime->type->snap_size != nullptr) {
    const int snap_size_x = region->runtime->type->snap_size(region, region->sizex, 0);
    const int snap_size_y = region->runtime->type->snap_size(region, region->sizey, 1);
    return (((abs(region->sizex - snap_size_x) <= snap_match_threshold) << 0) |
            ((abs(region->sizey - snap_size_y) <= snap_match_threshold) << 1));
  }
  return 0;
}
 
bool ED_region_snap_size_apply(ARegion *region, int snap_flag)
{
  bool changed = false;
  if (region->runtime->type->snap_size != nullptr) {
    if (snap_flag & (1 << 0)) {
      short snap_size = region->runtime->type->snap_size(region, region->sizex, 0);
      if (snap_size != region->sizex) {
        region->sizex = snap_size;
        changed = true;
      }
    }
    if (snap_flag & (1 << 1)) {
      short snap_size = region->runtime->type->snap_size(region, region->sizey, 1);
      if (snap_size != region->sizey) {
        region->sizey = snap_size;
        changed = true;
      }
    }
  }
  return changed;
}