wm_cursors.cc

Go to the documentation of this file.

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

 
#include <cstring>
 
#include "GHOST_C-api.h"
 
#include "BLI_string_utf8.h"
#include "BLI_utildefines.h"
 
#include "DNA_listBase.h"
#include "DNA_userdef_types.h"
#include "DNA_workspace_types.h"
 
#include "BKE_global.hh"
#include "BKE_main.hh"
 
#include "BLF_api.hh"
 
#ifndef WITH_HEADLESS
#  include "nanosvgrast.h"
#  include "svg_cursors.h"
#endif
 
#include "WM_api.hh"
#include "WM_types.hh"
#include "wm_cursors.hh"
#include "wm_window.hh"

constexpr int CURSOR_HARDWARE_SIZE_MAX = 255;

#define CURSOR_TEXT_BUFFER_SIZE 24

struct BCursor {
  const char *svg_source;
  blender::float2 hotspot;
  bool can_invert;
};

static BCursor g_cursors[WM_CURSOR_NUM] = {{nullptr}};

static GHOST_TStandardCursor convert_to_ghost_standard_cursor(WMCursorType curs)
{
  switch (curs) {
    case WM_CURSOR_DEFAULT:
      return GHOST_kStandardCursorDefault;
    case WM_CURSOR_WAIT:
      return GHOST_kStandardCursorWait;
    case WM_CURSOR_EDIT:
    case WM_CURSOR_CROSS:
      return GHOST_kStandardCursorCrosshair;
    case WM_CURSOR_MOVE:
      return GHOST_kStandardCursorMove;
    case WM_CURSOR_X_MOVE:
      return GHOST_kStandardCursorLeftRight;
    case WM_CURSOR_Y_MOVE:
      return GHOST_kStandardCursorUpDown;
    case WM_CURSOR_COPY:
      return GHOST_kStandardCursorCopy;
    case WM_CURSOR_HAND:
      return GHOST_kStandardCursorHandOpen;
    case WM_CURSOR_HAND_CLOSED:
      return GHOST_kStandardCursorHandClosed;
    case WM_CURSOR_HAND_POINT:
      return GHOST_kStandardCursorHandPoint;
    case WM_CURSOR_H_SPLIT:
      return GHOST_kStandardCursorHorizontalSplit;
    case WM_CURSOR_V_SPLIT:
      return GHOST_kStandardCursorVerticalSplit;
    case WM_CURSOR_STOP:
      return GHOST_kStandardCursorStop;
    case WM_CURSOR_KNIFE:
      return GHOST_kStandardCursorKnife;
    case WM_CURSOR_NSEW_SCROLL:
      return GHOST_kStandardCursorNSEWScroll;
    case WM_CURSOR_NS_SCROLL:
      return GHOST_kStandardCursorNSScroll;
    case WM_CURSOR_EW_SCROLL:
      return GHOST_kStandardCursorEWScroll;
    case WM_CURSOR_EYEDROPPER:
      return GHOST_kStandardCursorEyedropper;
    case WM_CURSOR_N_ARROW:
      return GHOST_kStandardCursorUpArrow;
    case WM_CURSOR_S_ARROW:
      return GHOST_kStandardCursorDownArrow;
    case WM_CURSOR_PAINT:
      return GHOST_kStandardCursorCrosshairA;
    case WM_CURSOR_DOT:
      return GHOST_kStandardCursorCrosshairB;
    case WM_CURSOR_CROSSC:
      return GHOST_kStandardCursorCrosshairC;
    case WM_CURSOR_ERASER:
      return GHOST_kStandardCursorEraser;
    case WM_CURSOR_ZOOM_IN:
      return GHOST_kStandardCursorZoomIn;
    case WM_CURSOR_ZOOM_OUT:
      return GHOST_kStandardCursorZoomOut;
    case WM_CURSOR_TEXT_EDIT:
      return GHOST_kStandardCursorText;
    case WM_CURSOR_PAINT_BRUSH:
      return GHOST_kStandardCursorPencil;
    case WM_CURSOR_E_ARROW:
      return GHOST_kStandardCursorRightArrow;
    case WM_CURSOR_W_ARROW:
      return GHOST_kStandardCursorLeftArrow;
    case WM_CURSOR_LEFT_HANDLE:
      return GHOST_kStandardCursorLeftHandle;
    case WM_CURSOR_RIGHT_HANDLE:
      return GHOST_kStandardCursorRightHandle;
    case WM_CURSOR_BOTH_HANDLES:
      return GHOST_kStandardCursorBothHandles;
    case WM_CURSOR_BLADE:
      return GHOST_kStandardCursorBlade;
    case WM_CURSOR_SLIP:
      return GHOST_kStandardCursorSlip;
    default:
      return GHOST_kStandardCursorCustom;
  }
}

static int wm_cursor_size(const wmWindow *win)
{
  /* Keep for testing. */
  if (false) {
    /* Scaling with UI scale can be useful for magnified captures. */
    return std::lround(21.0f * UI_SCALE_FAC);
  }
 
  if (OS_MAC) {
    /* MacOS always scales up this type of cursor for high-dpi displays. */
    return 21;
  }
 
  /* The DPI as a scale without the UI scale preference. */
  const float system_scale = WM_window_dpi_get_scale(win);
 
  return std::lround(WM_cursor_preferred_logical_size() * system_scale);
}

static void cursor_bitmap_rgba_flip_y(uint8_t *buffer, const size_t size[2])
{
  uint *top, *bottom, *line;
  const size_t x_size = size[0];
  size_t y_size = size[1];
  const size_t stride = x_size * sizeof(int);
 
  top = reinterpret_cast<uint *>(buffer);
  bottom = top + ((y_size - 1) * x_size);
  line = MEM_malloc_arrayN<uint>(x_size, "linebuf");
 
  y_size >>= 1;
  for (; y_size > 0; y_size--) {
    memcpy(line, top, stride);
    memcpy(top, bottom, stride);
    memcpy(bottom, line, stride);
    bottom -= x_size;
    top += x_size;
  }
 
  MEM_freeN(line);
}

static uint8_t *cursor_bitmap_from_svg(const char *svg,
                                       const int cursor_size,
                                       uint8_t *(*alloc_fn)(size_t size),
                                       int r_bitmap_size[2])
{
#ifdef WITH_HEADLESS
  UNUSED_VARS(svg, cursor_size, alloc_fn, r_bitmap_size);
  return nullptr;
#else
  /* #nsvgParse alters the source string. */
  std::string svg_source = svg;
 
  NSVGimage *image = nsvgParse(svg_source.data(), "px", 96.0f);
  if (image == nullptr) {
    return nullptr;
  }
  if (image->width == 0 || image->height == 0) {
    nsvgDelete(image);
    return nullptr;
  }
  NSVGrasterizer *rast = nsvgCreateRasterizer();
  if (rast == nullptr) {
    nsvgDelete(image);
    return nullptr;
  }
 
  const float scale = float(cursor_size) / 1600.0f;
  const size_t dest_size[2] = {
      std::min(size_t(ceil(image->width * scale)), size_t(cursor_size)),
      std::min(size_t(ceil(image->height * scale)), size_t(cursor_size)),
  };
 
  uint8_t *bitmap_rgba = alloc_fn(sizeof(uint8_t[4]) * dest_size[0] * dest_size[1]);
  if (bitmap_rgba == nullptr) {
    return nullptr;
  }
 
  nsvgRasterize(
      rast, image, 0.0f, 0.0f, scale, bitmap_rgba, dest_size[0], dest_size[1], dest_size[0] * 4);
 
  nsvgDeleteRasterizer(rast);
  nsvgDelete(image);
 
  r_bitmap_size[0] = dest_size[0];
  r_bitmap_size[1] = dest_size[1];
 
  return bitmap_rgba;
#endif /* !WITH_HEADLESS */
}

static void cursor_rgba_to_xbm_32(const uint8_t *rgba,
                                  const int bitmap_size[2],
                                  uint8_t *bitmap,
                                  uint8_t *mask)
{
  for (int y = 0; y < bitmap_size[1]; y++) {
    for (int x = 0; x < bitmap_size[0]; x++) {
      int i = (y * bitmap_size[0] * 4) + (x * 4);
      int j = (y * 4) + (x >> 3);
      int k = (x % 8);
      if (rgba[i + 3] > 128) {
        if (rgba[i] > 128) {
          bitmap[j] |= (1 << k);
        }
        mask[j] |= (1 << k);
      }
    }
  }
}
 
static bool window_set_custom_cursor_generator(wmWindow *win, const BCursor &cursor)
{
  GHOST_CursorGenerator *cursor_generator = MEM_callocN<GHOST_CursorGenerator>(__func__);
  cursor_generator->generate_fn = [](const GHOST_CursorGenerator *cursor_generator,
                                     const int cursor_size,
                                     const int cursor_size_max,
                                     uint8_t *(*alloc_fn)(size_t size),
                                     int r_bitmap_size[2],
                                     int r_hot_spot[2],
                                     bool *r_can_invert_color) -> uint8_t * {
    const BCursor &cursor = *(const BCursor *)(cursor_generator->user_data);
    /* Currently SVG uses the `cursor_size` as the maximum. */
    UNUSED_VARS(cursor_size_max);
 
    int bitmap_size[2];
    uint8_t *bitmap_rgba = cursor_bitmap_from_svg(
        cursor.svg_source, cursor_size, alloc_fn, bitmap_size);
 
    if (UNLIKELY(bitmap_rgba == nullptr)) {
      return nullptr;
    }
 
    r_bitmap_size[0] = bitmap_size[0];
    r_bitmap_size[1] = bitmap_size[1];
 
    r_hot_spot[0] = int(cursor.hotspot[0] * (bitmap_size[0] - 1));
    r_hot_spot[1] = int(cursor.hotspot[1] * (bitmap_size[1] - 1));
 
    *r_can_invert_color = cursor.can_invert;
 
    return bitmap_rgba;
  };
 
  cursor_generator->user_data = (void *)&cursor;
  cursor_generator->free_fn = [](GHOST_CursorGenerator *cursor_generator) {
    MEM_freeN(cursor_generator);
  };
 
  GHOST_TSuccess success = GHOST_SetCustomCursorGenerator(
      static_cast<GHOST_WindowHandle>(win->ghostwin), cursor_generator);
 
  return (success == GHOST_kSuccess) ? true : false;
}
 
static bool window_set_custom_cursor_pixmap(wmWindow *win, const BCursor &cursor)
{
  /* Option to force use of 1bpp XBitMap cursors is needed for testing. */
  const bool use_only_1bpp_cursors = false;
 
  const bool use_rgba = !use_only_1bpp_cursors &&
                        (WM_capabilities_flag() & WM_CAPABILITY_CURSOR_RGBA);
 
  const int max_size = use_rgba ? CURSOR_HARDWARE_SIZE_MAX : 32;
  const int size = std::min(wm_cursor_size(win), max_size);
 
  int bitmap_size[2] = {0, 0};
  uint8_t *bitmap_rgba = cursor_bitmap_from_svg(
      cursor.svg_source,
      size,
      [](size_t size) -> uint8_t * { return MEM_malloc_arrayN<uint8_t>(size, "wm.cursor"); },
      bitmap_size);
  if (UNLIKELY(bitmap_rgba == nullptr)) {
    return false;
  }
 
  const int hot_spot[2] = {
      int(cursor.hotspot[0] * (bitmap_size[0] - 1)),
      int(cursor.hotspot[1] * (bitmap_size[1] - 1)),
  };
 
  GHOST_TSuccess success;
  if (use_rgba) {
    success = GHOST_SetCustomCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin),
                                         bitmap_rgba,
                                         nullptr,
                                         bitmap_size,
                                         hot_spot,
                                         cursor.can_invert);
  }
  else {
    int bitmap_size_fixed[2] = {32, 32};
 
    uint8_t bitmap[4 * 32] = {0};
    uint8_t mask[4 * 32] = {0};
    cursor_rgba_to_xbm_32(bitmap_rgba, bitmap_size, bitmap, mask);
    success = GHOST_SetCustomCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin),
                                         bitmap,
                                         mask,
                                         bitmap_size_fixed,
                                         hot_spot,
                                         cursor.can_invert);
  }
 
  MEM_freeN(bitmap_rgba);
  return (success == GHOST_kSuccess) ? true : false;
}
 
static bool window_set_custom_cursor(wmWindow *win, const BCursor &cursor)
{
  if (WM_capabilities_flag() & WM_CAPABILITY_CURSOR_GENERATOR) {
    return window_set_custom_cursor_generator(win, cursor);
  }
  return window_set_custom_cursor_pixmap(win, cursor);
}
 
void WM_cursor_set(wmWindow *win, int curs)
{
  /* Option to not use any OS-supplied cursors is needed for testing. */
  const bool use_only_custom_cursors = false;
 
  if (G.background) {
    return;
  }
 
  if (win == nullptr) {
    /* Can't set custom cursor before window initialization. */
    return;
  }
 
  if (curs == WM_CURSOR_DEFAULT && win->modalcursor) {
    curs = win->modalcursor;
  }
 
  if (curs == WM_CURSOR_NONE) {
    GHOST_SetCursorVisibility(static_cast<GHOST_WindowHandle>(win->ghostwin), false);
    return;
  }
 
  GHOST_SetCursorVisibility(static_cast<GHOST_WindowHandle>(win->ghostwin), true);
 
  if (win->cursor == curs) {
    return; /* Cursor is already set. */
  }
 
  win->cursor = curs;
 
  if (curs < 0 || curs >= WM_CURSOR_NUM) {
    BLI_assert_msg(0, "Invalid cursor number");
    return;
  }
 
  GHOST_TStandardCursor ghost_cursor = convert_to_ghost_standard_cursor(WMCursorType(curs));
 
  if (!use_only_custom_cursors && ghost_cursor != GHOST_kStandardCursorCustom &&
      GHOST_HasCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin), ghost_cursor))
  {
    /* Use native GHOST cursor when available. */
    GHOST_SetCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin), ghost_cursor);
  }
  else {
    const BCursor &bcursor = g_cursors[curs];
    if (!bcursor.svg_source || !window_set_custom_cursor(win, bcursor)) {
      /* Fall back to default cursor if no bitmap found. */
      GHOST_SetCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin),
                           GHOST_kStandardCursorDefault);
    }
  }
}
 
bool WM_cursor_set_from_tool(wmWindow *win, const ScrArea *area, const ARegion *region)
{
  if (region && !ELEM(region->regiontype, RGN_TYPE_WINDOW, RGN_TYPE_PREVIEW)) {
    return false;
  }
 
  bToolRef_Runtime *tref_rt = (area && area->runtime.tool) ? area->runtime.tool->runtime : nullptr;
  if (tref_rt && tref_rt->cursor != WM_CURSOR_DEFAULT) {
    if (win->modalcursor == 0) {
      WM_cursor_set(win, tref_rt->cursor);
      win->cursor = tref_rt->cursor;
      return true;
    }
  }
  return false;
}
 
bool WM_cursor_modal_is_set_ok(const wmWindow *win)
{
  return (win->grabcursor == 0 && win->modalcursor == 0);
}
 
void WM_cursor_modal_set(wmWindow *win, int val)
{
  if (win->lastcursor == 0) {
    win->lastcursor = win->cursor;
  }
  win->modalcursor = val;
  WM_cursor_set(win, val);
}
 
void WM_cursor_modal_restore(wmWindow *win)
{
  win->modalcursor = 0;
  if (win->lastcursor) {
    WM_cursor_set(win, win->lastcursor);
  }
  win->lastcursor = 0;
}
 
void WM_cursor_wait(bool val)
{
  if (!G.background) {
    wmWindowManager *wm = static_cast<wmWindowManager *>(G_MAIN->wm.first);
    wmWindow *win = static_cast<wmWindow *>(wm ? wm->windows.first : nullptr);
 
    for (; win; win = win->next) {
      if (val) {
        WM_cursor_modal_set(win, WM_CURSOR_WAIT);
      }
      else {
        WM_cursor_modal_restore(win);
      }
    }
  }
}
 
void WM_cursor_grab_enable(wmWindow *win,
                           const eWM_CursorWrapAxis wrap,
                           const rcti *wrap_region,
                           const bool hide)
{
  int _wrap_region_buf[4];
  int *wrap_region_screen = nullptr;
 
  /* Only grab cursor when not running debug.
   * It helps not to get a stuck WM when hitting a break-point. */
  GHOST_TGrabCursorMode mode = GHOST_kGrabNormal;
  GHOST_TAxisFlag mode_axis = GHOST_TAxisFlag(GHOST_kAxisX | GHOST_kAxisY);
 
  if (wrap_region) {
    wrap_region_screen = _wrap_region_buf;
    wrap_region_screen[0] = wrap_region->xmin;
    wrap_region_screen[1] = wrap_region->ymax;
    wrap_region_screen[2] = wrap_region->xmax;
    wrap_region_screen[3] = wrap_region->ymin;
    wm_cursor_position_to_ghost_screen_coords(win, &wrap_region_screen[0], &wrap_region_screen[1]);
    wm_cursor_position_to_ghost_screen_coords(win, &wrap_region_screen[2], &wrap_region_screen[3]);
  }
 
  if (hide) {
    mode = GHOST_kGrabHide;
  }
  else if (wrap != WM_CURSOR_WRAP_NONE) {
    mode = GHOST_kGrabWrap;
 
    if (wrap == WM_CURSOR_WRAP_X) {
      mode_axis = GHOST_kAxisX;
    }
    else if (wrap == WM_CURSOR_WRAP_Y) {
      mode_axis = GHOST_kAxisY;
    }
  }
 
  if ((G.debug & G_DEBUG) == 0) {
    if (win->ghostwin) {
      if (win->eventstate->tablet.is_motion_absolute == false) {
        GHOST_SetCursorGrab(static_cast<GHOST_WindowHandle>(win->ghostwin),
                            mode,
                            mode_axis,
                            wrap_region_screen,
                            nullptr);
      }
 
      win->grabcursor = mode;
    }
  }
}
 
void WM_cursor_grab_disable(wmWindow *win, const int mouse_ungrab_xy[2])
{
  if ((G.debug & G_DEBUG) == 0) {
    if (win && win->ghostwin) {
      if (mouse_ungrab_xy) {
        int mouse_xy[2] = {mouse_ungrab_xy[0], mouse_ungrab_xy[1]};
        wm_cursor_position_to_ghost_screen_coords(win, &mouse_xy[0], &mouse_xy[1]);
        GHOST_SetCursorGrab(static_cast<GHOST_WindowHandle>(win->ghostwin),
                            GHOST_kGrabDisable,
                            GHOST_kAxisNone,
                            nullptr,
                            mouse_xy);
      }
      else {
        GHOST_SetCursorGrab(static_cast<GHOST_WindowHandle>(win->ghostwin),
                            GHOST_kGrabDisable,
                            GHOST_kAxisNone,
                            nullptr,
                            nullptr);
      }
 
      win->grabcursor = GHOST_kGrabDisable;
    }
  }
}
 
static void wm_cursor_warp_relative(wmWindow *win, int x, int y)
{
  /* NOTE: don't use #wmEvent coords because of continuous grab, see: #36409. */
  int cx, cy;
  if (wm_cursor_position_get(win, &cx, &cy)) {
    WM_cursor_warp(win, cx + x, cy + y);
  }
}
 
bool wm_cursor_arrow_move(wmWindow *win, const wmEvent *event)
{
  /* TODO: give it a modal keymap? Hard coded for now. */
 
  if (win && event->val == KM_PRESS) {
    /* Must move at least this much to avoid rounding in #WM_cursor_warp. */
    float fac = GHOST_GetNativePixelSize(static_cast<GHOST_WindowHandle>(win->ghostwin));
 
    if (event->type == EVT_UPARROWKEY) {
      wm_cursor_warp_relative(win, 0, fac);
      return true;
    }
    if (event->type == EVT_DOWNARROWKEY) {
      wm_cursor_warp_relative(win, 0, -fac);
      return true;
    }
    if (event->type == EVT_LEFTARROWKEY) {
      wm_cursor_warp_relative(win, -fac, 0);
      return true;
    }
    if (event->type == EVT_RIGHTARROWKEY) {
      wm_cursor_warp_relative(win, fac, 0);
      return true;
    }
  }
  return false;
}
 
static bool wm_cursor_time_large(wmWindow *win, uint32_t nr)
{
  /* 10 16x16 digits. */
  const uchar number_bitmaps[][32] = {
      {0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x1f, 0x1c, 0x38, 0x0c, 0x30, 0x0c,
       0x30, 0x0c, 0x30, 0x0c, 0x30, 0x0c, 0x30, 0x0c, 0x30, 0x0c, 0x30,
       0x0c, 0x30, 0x1c, 0x38, 0xf8, 0x1f, 0xf0, 0x0f, 0x00, 0x00},
      {0x00, 0x00, 0x80, 0x01, 0xc0, 0x01, 0xf0, 0x01, 0xbc, 0x01, 0x8c,
       0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
       0x80, 0x01, 0x80, 0x01, 0xfc, 0x3f, 0xfc, 0x3f, 0x00, 0x00},
      {0x00, 0x00, 0xf0, 0x1f, 0xf8, 0x3f, 0x1c, 0x30, 0x0c, 0x30, 0x00,
       0x30, 0x00, 0x30, 0xe0, 0x3f, 0xf0, 0x1f, 0x38, 0x00, 0x1c, 0x00,
       0x0c, 0x00, 0x0c, 0x00, 0xfc, 0x3f, 0xfc, 0x3f, 0x00, 0x00},
      {0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x1f, 0x1c, 0x38, 0x00, 0x30, 0x00,
       0x30, 0x00, 0x38, 0xf0, 0x1f, 0xf0, 0x1f, 0x00, 0x38, 0x00, 0x30,
       0x00, 0x30, 0x1c, 0x38, 0xf8, 0x1f, 0xf0, 0x0f, 0x00, 0x00},
      {0x00, 0x00, 0x00, 0x0f, 0x80, 0x0f, 0xc0, 0x0d, 0xe0, 0x0c, 0x70,
       0x0c, 0x38, 0x0c, 0x1c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
       0xfc, 0x3f, 0xfc, 0x3f, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x00},
      {0x00, 0x00, 0xfc, 0x3f, 0xfc, 0x3f, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
       0x00, 0xfc, 0x0f, 0xfc, 0x1f, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30,
       0x00, 0x30, 0x0c, 0x38, 0xfc, 0x1f, 0xf8, 0x0f, 0x00, 0x00},
      {0x00, 0x00, 0xc0, 0x3f, 0xe0, 0x3f, 0x70, 0x00, 0x38, 0x00, 0x1c,
       0x00, 0xfc, 0x0f, 0xfc, 0x1f, 0x0c, 0x38, 0x0c, 0x30, 0x0c, 0x30,
       0x0c, 0x30, 0x1c, 0x38, 0xf8, 0x1f, 0xf0, 0x0f, 0x00, 0x00},
      {0x00, 0x00, 0xfc, 0x3f, 0xfc, 0x3f, 0x0c, 0x30, 0x0c, 0x38, 0x00,
       0x18, 0x00, 0x1c, 0x00, 0x0c, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x07,
       0x00, 0x03, 0x80, 0x03, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00},
      {0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x1f, 0x1c, 0x38, 0x0c, 0x30, 0x0c,
       0x30, 0x1c, 0x38, 0xf8, 0x1f, 0xf8, 0x1f, 0x1c, 0x38, 0x0c, 0x30,
       0x0c, 0x30, 0x1c, 0x38, 0xf8, 0x1f, 0xf0, 0x0f, 0x00, 0x00},
      {0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x1f, 0x1c, 0x38, 0x0c, 0x30, 0x0c,
       0x30, 0x0c, 0x30, 0x1c, 0x30, 0xf8, 0x3f, 0xf0, 0x3f, 0x00, 0x38,
       0x00, 0x1c, 0x00, 0x0e, 0xfc, 0x07, 0xfc, 0x03, 0x00, 0x00},
  };
  uint8_t mask[32][4] = {{0}};
  uint8_t bitmap[32][4] = {{0}};
 
  /* Print number bottom right justified. */
  for (int idx = 3; nr && idx >= 0; idx--) {
    const uchar *digit = number_bitmaps[nr % 10];
    int x = idx % 2;
    int y = idx / 2;
 
    for (int i = 0; i < 16; i++) {
      bitmap[i + y * 16][x * 2] = digit[i * 2];
      bitmap[i + y * 16][(x * 2) + 1] = digit[(i * 2) + 1];
    }
    for (int i = 0; i < 16; i++) {
      mask[i + y * 16][x * 2] = 0xFF;
      mask[i + y * 16][(x * 2) + 1] = 0xFF;
    }
 
    nr /= 10;
  }
 
  const int size[2] = {32, 32};
  const int hot_spot[2] = {15, 15};
  return GHOST_SetCustomCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin),
                                    bitmap[0],
                                    mask[0],
                                    size,
                                    hot_spot,
                                    false) == GHOST_kSuccess;
}
 
static void wm_cursor_time_small(wmWindow *win, uint32_t nr)
{
  /* 10 8x8 digits. */
  const char number_bitmaps[10][8] = {
      {0, 56, 68, 68, 68, 68, 68, 56},
      {0, 24, 16, 16, 16, 16, 16, 56},
      {0, 60, 66, 32, 16, 8, 4, 126},
      {0, 124, 32, 16, 56, 64, 66, 60},
      {0, 32, 48, 40, 36, 126, 32, 32},
      {0, 124, 4, 60, 64, 64, 68, 56},
      {0, 56, 4, 4, 60, 68, 68, 56},
      {0, 124, 64, 32, 16, 8, 8, 8},
      {0, 60, 66, 66, 60, 66, 66, 60},
      {0, 56, 68, 68, 120, 64, 68, 56},
  };
  uint8_t mask[16][2] = {{0}};
  uint8_t bitmap[16][2] = {{0}};
 
  /* Print number bottom right justified. */
  for (int idx = 3; nr && idx >= 0; idx--) {
    const char *digit = number_bitmaps[nr % 10];
    int x = idx % 2;
    int y = idx / 2;
 
    for (int i = 0; i < 8; i++) {
      bitmap[i + y * 8][x] = digit[i];
    }
    for (int i = 0; i < 8; i++) {
      mask[i + y * 8][x] = 0xFF;
    }
    nr /= 10;
  }
 
  const int size[2] = {16, 16};
  const int hot_spot[2] = {7, 7};
  GHOST_SetCustomCursorShape(static_cast<GHOST_WindowHandle>(win->ghostwin),
                             (uint8_t *)bitmap,
                             (uint8_t *)mask,
                             size,
                             hot_spot,
                             false);
}

static uint8_t *cursor_bitmap_from_text(const char *text,
                                        const int cursor_size,
                                        const int cursor_size_max,
                                        int font_id,
                                        uint8_t *(*alloc_fn)(size_t size),
                                        int r_bitmap_size[2])
{
  /* Smaller than a full cursor size since this is typically wider.
   * Also, use a small scale to avoid scaling single numbers up
   * which are then shrunk when more digits are added since this seems strange. */
  int font_size = (cursor_size * 3) / 4;
  int font_dims[2];
  int font_padding;
 
  int font_descender;
 
  /* At least 1 even on an empty string else the cursor is blank. */
  const size_t text_len = strlen(text);
  const int text_units = std::max(1, BLI_str_utf8_column_count(text, text_len));
  const bool text_to_draw = text_len != 0;
 
  for (int pass = 0; pass < 2; pass++) {
    BLF_size(font_id, font_size);
 
    /* Use fixed sizes instead of calculating the bounds of the text
     * because the text can jitter based on differences in the glyphs. */
    font_dims[0] = BLF_fixed_width(font_id) * text_units;
    font_dims[1] = BLF_height_max(font_id);
    font_descender = -BLF_descender(font_id);
 
    font_padding = font_size / 6;
    font_dims[0] += font_padding * 2;
    font_dims[1] += (font_padding * 2) + font_descender;
 
    if (pass == 0) {
      const int font_dims_max = std::max(font_dims[0], font_dims[1]);
      if (font_dims_max <= cursor_size_max) {
        break;
      }
      /* +1 to scale down more than a small fraction. */
      constexpr int fixed_pt = 1024;
      font_size = ((font_size * fixed_pt) * cursor_size_max) / (font_dims_max * fixed_pt);
    }
  }
 
  /* Camping by `cursor_size` is a safeguard to ensure the size *never* exceeds the bounds.
   * In practice this should happen rarely - if at all. */
  const size_t dest_size[2] = {
      size_t(std::min(font_dims[0], cursor_size_max)),
      size_t(std::min(font_dims[1], cursor_size_max)),
  };
 
  uint8_t *bitmap_rgba = alloc_fn(sizeof(uint8_t[4]) * dest_size[0] * dest_size[1]);
  if (bitmap_rgba == nullptr) {
    return nullptr;
  }
  std::fill_n(reinterpret_cast<uint32_t *>(bitmap_rgba), dest_size[0] * dest_size[1], 0xA0000000);
 
  if (text_to_draw) {
    const float color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
    BLF_buffer_col(font_id, color);
    BLF_buffer(font_id, nullptr, bitmap_rgba, dest_size[0], dest_size[1], nullptr);
    BLF_position(font_id, font_padding, font_padding + font_descender, 0.0f);
    BLF_draw_buffer(font_id, text, text_len);
    BLF_buffer(font_id, nullptr, nullptr, 0, 0, nullptr);
 
    cursor_bitmap_rgba_flip_y(bitmap_rgba, dest_size);
  }
 
  r_bitmap_size[0] = dest_size[0];
  r_bitmap_size[1] = dest_size[1];
 
  return bitmap_rgba;
}
 
static bool wm_cursor_text_generator(wmWindow *win, const char *text, int font_id)
{
  struct WMCursorText {
    char text[CURSOR_TEXT_BUFFER_SIZE];
    int font_id;
  };
 
  GHOST_CursorGenerator *cursor_generator = MEM_callocN<GHOST_CursorGenerator>(__func__);
  cursor_generator->generate_fn = [](const GHOST_CursorGenerator *cursor_generator,
                                     const int cursor_size,
                                     const int cursor_size_max,
                                     uint8_t *(*alloc_fn)(size_t size),
                                     int r_bitmap_size[2],
                                     int r_hot_spot[2],
                                     bool *r_can_invert_color) -> uint8_t * {
    const WMCursorText &cursor_text = *(const WMCursorText *)(cursor_generator->user_data);
 
    int bitmap_size[2];
    uint8_t *bitmap_rgba = cursor_bitmap_from_text(cursor_text.text,
                                                   cursor_size,
                                                   cursor_size_max,
                                                   cursor_text.font_id,
                                                   alloc_fn,
                                                   bitmap_size);
 
    if (UNLIKELY(bitmap_rgba == nullptr)) {
      return nullptr;
    }
 
    r_bitmap_size[0] = bitmap_size[0];
    r_bitmap_size[1] = bitmap_size[1];
 
    r_hot_spot[0] = bitmap_size[0] / 2;
    r_hot_spot[1] = bitmap_size[1] / 2;
 
    /* Always use a dark background, not optional. */
    *r_can_invert_color = false;
 
    return bitmap_rgba;
  };
 
  WMCursorText *cursor_text = MEM_new<WMCursorText>(__func__);
  STRNCPY_UTF8(cursor_text->text, text);
  cursor_text->font_id = font_id;
 
  cursor_generator->user_data = (void *)cursor_text;
  cursor_generator->free_fn = [](GHOST_CursorGenerator *cursor_generator) {
    const WMCursorText *cursor_text = (WMCursorText *)(cursor_generator->user_data);
    MEM_delete(cursor_text);
    MEM_freeN(cursor_generator);
  };
 
  GHOST_TSuccess success = GHOST_SetCustomCursorGenerator(
      static_cast<GHOST_WindowHandle>(win->ghostwin), cursor_generator);
 
  return (success == GHOST_kSuccess) ? true : false;
}
 
static bool wm_cursor_text_pixmap(wmWindow *win, const char *text, int font_id)
{
  const int cursor_size = wm_cursor_size(win);
  /* This is arbitrary. Use a larger value than the cursor size since the text is often wider than
   * it is tall. In that case constraining to the cursor size tends to make the text too small.
   * On the other hand allowing of the text to be much wider than other curses also seems strange,
   * so constrain to twice the cursor size. */
  const int cursor_size_max = std::min(cursor_size * 2, CURSOR_HARDWARE_SIZE_MAX);
 
  int bitmap_size[2];
  uint8_t *bitmap_rgba = cursor_bitmap_from_text(
      text,
      cursor_size,
      cursor_size_max,
      font_id,
      [](size_t size) -> uint8_t * { return MEM_malloc_arrayN<uint8_t>(size, "wm.cursor"); },
      bitmap_size);
  if (bitmap_rgba == nullptr) {
    return false;
  }
 
  const int hot_spot[2] = {
      bitmap_size[0] / 2,
      bitmap_size[1] / 2,
  };
  GHOST_TSuccess success = GHOST_SetCustomCursorShape(
      static_cast<GHOST_WindowHandle>(win->ghostwin),
      bitmap_rgba,
      nullptr,
      bitmap_size,
      hot_spot,
      /* Always use a black background. */
      false);
  MEM_freeN(bitmap_rgba);
 
  return (success == GHOST_kSuccess) ? true : false;
}
 
static bool wm_cursor_text(wmWindow *win, const char *text, int font_id)
{
  if (WM_capabilities_flag() & WM_CAPABILITY_CURSOR_GENERATOR) {
    return wm_cursor_text_generator(win, text, font_id);
  }
  return wm_cursor_text_pixmap(win, text, font_id);
}

static void wm_cursor_number_impl(wmWindow *win, int nr, bool is_percentage)
{
  if (win->lastcursor == 0) {
    win->lastcursor = win->cursor;
  }
  /* Negative numbers not supported by #wm_cursor_time_large & #wm_cursor_time_small.
   * Make absolute to show *something* although in typical usage this shouldn't be negative.
   * NOTE: Use of unsigned here to allow negation when `nr` is `std::numeric_limits<int>::min()`
   * which *can't* be negated. */
  const uint32_t nr_abs = nr >= 0 ? uint32_t(nr) : -uint32_t(nr);
 
  if (WM_capabilities_flag() & WM_CAPABILITY_CURSOR_RGBA) {
    char text[CURSOR_TEXT_BUFFER_SIZE];
    if (is_percentage) {
      /* Left pad to avoid resizing text between 9% & 10%. */
      SNPRINTF_UTF8(text, "%2u.%02u", nr_abs / 100, nr_abs % 100);
    }
    else {
      SNPRINTF_UTF8(text, "%u", nr_abs);
    }
    wm_cursor_text(win, text, blf_mono_font);
  }
  else if (wm_cursor_size(win) < 24 || !wm_cursor_time_large(win, nr_abs)) {
    wm_cursor_time_small(win, nr_abs);
  }
 
  /* Unset current cursor value so it's properly reset to #wmWindow::lastcursor. */
  win->cursor = 0;
}
 
void WM_cursor_time(wmWindow *win, int nr)
{
  wm_cursor_number_impl(win, nr, false);
}
 
void WM_cursor_progress(wmWindow *win, float progress_factor)
{
  constexpr int nr_max = 10000;
  const int nr = std::clamp(int(std::round(double(progress_factor) * nr_max)), 0, nr_max);
  wm_cursor_number_impl(win, nr, true);
}
 
#ifndef WITH_HEADLESS
static void wm_add_cursor(WMCursorType cursor,
                          const char *svg_source,
                          const blender::float2 &hotspot,
                          bool can_invert = true)
{
  g_cursors[cursor].svg_source = svg_source;
  g_cursors[cursor].hotspot = hotspot;
  g_cursors[cursor].can_invert = can_invert;
}
#endif /* !WITH_HEADLESS */
 
void wm_init_cursor_data()
{
#ifndef WITH_HEADLESS
  wm_add_cursor(WM_CURSOR_DEFAULT, datatoc_cursor_pointer_svg, {0.0f, 0.0f});
  wm_add_cursor(WM_CURSOR_NW_ARROW, datatoc_cursor_pointer_svg, {0.0f, 0.0f});
  wm_add_cursor(WM_CURSOR_COPY, datatoc_cursor_pointer_svg, {0.0f, 0.0f});
  wm_add_cursor(WM_CURSOR_MOVE, datatoc_cursor_pointer_svg, {0.0f, 0.0f});
  wm_add_cursor(WM_CURSOR_TEXT_EDIT, datatoc_cursor_text_edit_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_WAIT, datatoc_cursor_wait_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_STOP, datatoc_cursor_stop_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_EDIT, datatoc_cursor_crosshair_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_HAND, datatoc_cursor_hand_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_HAND_CLOSED, datatoc_cursor_hand_closed_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_HAND_POINT, datatoc_cursor_hand_point_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_CROSS, datatoc_cursor_crosshair_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_PAINT, datatoc_cursor_paint_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_DOT, datatoc_cursor_dot_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_CROSSC, datatoc_cursor_crossc_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_KNIFE, datatoc_cursor_knife_svg, {0.0f, 1.0f});
  wm_add_cursor(WM_CURSOR_BLADE, datatoc_cursor_blade_svg, {0.0f, 0.375f});
  wm_add_cursor(WM_CURSOR_VERTEX_LOOP, datatoc_cursor_vertex_loop_svg, {0.0f, 0.0f});
  wm_add_cursor(WM_CURSOR_PAINT_BRUSH, datatoc_cursor_pencil_svg, {0.0f, 1.0f});
  wm_add_cursor(WM_CURSOR_ERASER, datatoc_cursor_eraser_svg, {0.0f, 1.0f});
  wm_add_cursor(WM_CURSOR_EYEDROPPER, datatoc_cursor_eyedropper_svg, {0.0f, 1.0f});
  wm_add_cursor(WM_CURSOR_SWAP_AREA, datatoc_cursor_swap_area_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_X_MOVE, datatoc_cursor_x_move_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_EW_ARROW, datatoc_cursor_x_move_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_Y_MOVE, datatoc_cursor_y_move_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_NS_ARROW, datatoc_cursor_y_move_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_H_SPLIT, datatoc_cursor_h_split_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_V_SPLIT, datatoc_cursor_v_split_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_N_ARROW, datatoc_cursor_n_arrow_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_S_ARROW, datatoc_cursor_s_arrow_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_E_ARROW, datatoc_cursor_e_arrow_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_W_ARROW, datatoc_cursor_w_arrow_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_NSEW_SCROLL, datatoc_cursor_nsew_scroll_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_EW_SCROLL, datatoc_cursor_ew_scroll_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_NS_SCROLL, datatoc_cursor_ns_scroll_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_ZOOM_IN, datatoc_cursor_zoom_in_svg, {0.32f, 0.32f});
  wm_add_cursor(WM_CURSOR_ZOOM_OUT, datatoc_cursor_zoom_out_svg, {0.32f, 0.32f});
  wm_add_cursor(WM_CURSOR_MUTE, datatoc_cursor_mute_svg, {0.59f, 0.59f});
  wm_add_cursor(WM_CURSOR_PICK_AREA, datatoc_cursor_pick_area_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_BOTH_HANDLES, datatoc_cursor_both_handles_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_RIGHT_HANDLE, datatoc_cursor_right_handle_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_LEFT_HANDLE, datatoc_cursor_left_handle_svg, {0.5f, 0.5f});
  wm_add_cursor(WM_CURSOR_SLIP, datatoc_cursor_slip_svg, {0.5f, 0.5f});
#endif /* !WITH_HEADLESS */
}