9a3f80b8f2
This PR adds an optional block alert level, defaulting to none. Then for error-level alerts only it adds a red line and a color icon. Dialogs with other alert types do not change at all. This also adds a UI_alert function to create such dialogs. Pull Request: https://projects.blender.org/blender/blender/pulls/134084
5931 lines
185 KiB
C++
5931 lines
185 KiB
C++
/* SPDX-FileCopyrightText: 2009 Blender Authors
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup edinterface
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <climits>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <list>
|
|
|
|
#include "DNA_brush_types.h"
|
|
#include "DNA_node_types.h"
|
|
#include "DNA_screen_types.h"
|
|
#include "DNA_space_types.h"
|
|
#include "DNA_userdef_types.h"
|
|
|
|
#include "BLI_color.hh"
|
|
#include "BLI_listbase.h"
|
|
#include "BLI_math_color.h"
|
|
#include "BLI_math_vector.h"
|
|
#include "BLI_rect.h"
|
|
#include "BLI_string.h"
|
|
#include "BLI_string_utf8.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BKE_context.hh"
|
|
|
|
#include "RNA_access.hh"
|
|
|
|
#include "BLF_api.hh"
|
|
|
|
#include "ED_node.hh"
|
|
|
|
#include "UI_interface_icons.hh"
|
|
#include "UI_view2d.hh"
|
|
|
|
#include "interface_intern.hh"
|
|
|
|
#include "GPU_batch.hh"
|
|
#include "GPU_batch_presets.hh"
|
|
#include "GPU_immediate.hh"
|
|
#include "GPU_immediate_util.hh"
|
|
#include "GPU_matrix.hh"
|
|
#include "GPU_state.hh"
|
|
|
|
#include "UI_abstract_view.hh"
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
# include "WM_types.hh"
|
|
#endif
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Local Enums/Defines
|
|
* \{ */
|
|
|
|
/* icons are 80% of height of button (16 pixels inside 20 height) */
|
|
#define ICON_SIZE_FROM_BUTRECT(rect) (0.8f * BLI_rcti_size_y(rect))
|
|
|
|
/* visual types for drawing */
|
|
/* for time being separated from functional types */
|
|
enum uiWidgetTypeEnum {
|
|
/* default */
|
|
UI_WTYPE_REGULAR,
|
|
|
|
/* standard set */
|
|
UI_WTYPE_LABEL,
|
|
UI_WTYPE_TOGGLE,
|
|
UI_WTYPE_CHECKBOX,
|
|
UI_WTYPE_RADIO,
|
|
UI_WTYPE_NUMBER,
|
|
UI_WTYPE_SLIDER,
|
|
UI_WTYPE_EXEC,
|
|
UI_WTYPE_TOOLBAR_ITEM,
|
|
UI_WTYPE_TAB,
|
|
UI_WTYPE_TOOLTIP,
|
|
|
|
/* strings */
|
|
UI_WTYPE_NAME,
|
|
UI_WTYPE_NAME_LINK,
|
|
UI_WTYPE_POINTER_LINK,
|
|
UI_WTYPE_FILENAME,
|
|
|
|
/* menus */
|
|
UI_WTYPE_MENU_RADIO,
|
|
UI_WTYPE_MENU_ICON_RADIO,
|
|
UI_WTYPE_MENU_POINTER_LINK,
|
|
UI_WTYPE_MENU_NODE_LINK,
|
|
|
|
UI_WTYPE_PULLDOWN,
|
|
UI_WTYPE_MENU_ITEM,
|
|
/* Same as #UI_WTYPE_MENU_ITEM, but doesn't add padding to sides for text & icon inside the
|
|
* widget. To be used when multiple menu items should be displayed close to each other
|
|
* horizontally. */
|
|
UI_WTYPE_MENU_ITEM_UNPADDED,
|
|
UI_WTYPE_MENU_ITEM_PIE,
|
|
UI_WTYPE_MENU_BACK,
|
|
|
|
/* specials */
|
|
UI_WTYPE_ICON,
|
|
UI_WTYPE_ICON_LABEL,
|
|
UI_WTYPE_PREVIEW_TILE,
|
|
UI_WTYPE_SWATCH,
|
|
UI_WTYPE_RGB_PICKER,
|
|
UI_WTYPE_UNITVEC,
|
|
UI_WTYPE_BOX,
|
|
UI_WTYPE_SCROLL,
|
|
UI_WTYPE_LISTITEM,
|
|
UI_WTYPE_PROGRESS,
|
|
UI_WTYPE_NODESOCKET,
|
|
UI_WTYPE_VIEW_ITEM,
|
|
};
|
|
|
|
/**
|
|
* The button's state information adapted for drawing. Use #STATE_INFO_NULL for empty state.
|
|
*/
|
|
struct uiWidgetStateInfo {
|
|
/** Copy of #uiBut.flag (possibly with overrides for drawing). */
|
|
int but_flag;
|
|
/** Copy of #uiBut.drawflag (possibly with overrides for drawing). */
|
|
int but_drawflag;
|
|
|
|
/** Show that holding the button opens a menu. */
|
|
bool has_hold_action : 1;
|
|
/** The button is in text input mode. */
|
|
bool is_text_input : 1;
|
|
};
|
|
|
|
static const uiWidgetStateInfo STATE_INFO_NULL = {0};
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Internal Color Utilities
|
|
* \{ */
|
|
|
|
static void color_blend_v3_v3(uchar cp[3], const uchar cpstate[3], const float fac)
|
|
{
|
|
if (fac != 0.0f) {
|
|
cp[0] = int((1.0f - fac) * cp[0] + fac * cpstate[0]);
|
|
cp[1] = int((1.0f - fac) * cp[1] + fac * cpstate[1]);
|
|
cp[2] = int((1.0f - fac) * cp[2] + fac * cpstate[2]);
|
|
}
|
|
}
|
|
|
|
static void color_blend_v4_v4v4(uchar r_col[4],
|
|
const uchar col1[4],
|
|
const uchar col2[4],
|
|
const float fac)
|
|
{
|
|
const int faci = unit_float_to_uchar_clamp(fac);
|
|
const int facm = 255 - faci;
|
|
|
|
r_col[0] = (faci * col1[0] + facm * col2[0]) / 256;
|
|
r_col[1] = (faci * col1[1] + facm * col2[1]) / 256;
|
|
r_col[2] = (faci * col1[2] + facm * col2[2]) / 256;
|
|
r_col[3] = (faci * col1[3] + facm * col2[3]) / 256;
|
|
}
|
|
|
|
static void color_ensure_contrast_v3(uchar cp[3], const uchar cp_other[3], int contrast)
|
|
{
|
|
BLI_assert(contrast > 0);
|
|
const int item_value = srgb_to_grayscale_byte(cp);
|
|
const int inner_value = srgb_to_grayscale_byte(cp_other);
|
|
const int delta = item_value - inner_value;
|
|
if (delta >= 0) {
|
|
if (contrast > delta) {
|
|
add_v3_uchar_clamped(cp, contrast - delta);
|
|
}
|
|
}
|
|
else {
|
|
if (contrast > -delta) {
|
|
add_v3_uchar_clamped(cp, -contrast - delta);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void color_mul_hsl_v3(uchar ch[3], float h_factor, float s_factor, float l_factor)
|
|
{
|
|
float rgb[3], hsl[3];
|
|
rgb_uchar_to_float(rgb, ch);
|
|
rgb_to_hsl_v(rgb, hsl);
|
|
hsl[0] *= h_factor;
|
|
hsl[1] *= s_factor;
|
|
hsl[2] *= l_factor;
|
|
hsl_to_rgb_v(hsl, rgb);
|
|
rgb_float_to_uchar(ch, rgb);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget Base Type
|
|
* \{ */
|
|
|
|
/**
|
|
* - in: `roundbox` codes for corner types and radius
|
|
* - return: array of `[size][2][x, y]` points, the edges of the `roundbox`, + UV coords
|
|
*
|
|
* - Draw black box with alpha 0 on exact button bounding-box.
|
|
* - For every AA step:
|
|
* - draw the inner part for a round filled box, with color blend codes or texture coords
|
|
* - draw outline in outline color
|
|
* - draw outer part, bottom half, extruded 1 pixel to bottom, for emboss shadow
|
|
* - draw extra decorations
|
|
* - Draw background color box with alpha 1 on exact button bounding-box.
|
|
*/
|
|
|
|
/* fill this struct with polygon info to draw AA'ed */
|
|
/* it has outline, back, and two optional tria meshes */
|
|
|
|
struct uiWidgetTrias {
|
|
uint tot;
|
|
int type;
|
|
float size, center[2];
|
|
|
|
float vec[16][2];
|
|
const uint (*index)[3];
|
|
};
|
|
|
|
/* max as used by round_box__edges */
|
|
/* Make sure to change widget_base_vert.glsl accordingly. */
|
|
#define WIDGET_CURVE_RESOLU 9
|
|
#define WIDGET_SIZE_MAX (WIDGET_CURVE_RESOLU * 4)
|
|
|
|
struct uiWidgetBase {
|
|
/* TODO: remove these completely. */
|
|
int totvert, halfwayvert;
|
|
float outer_v[WIDGET_SIZE_MAX][2];
|
|
float inner_v[WIDGET_SIZE_MAX][2];
|
|
float inner_uv[WIDGET_SIZE_MAX][2];
|
|
|
|
bool draw_inner, draw_outline, draw_emboss;
|
|
|
|
uiWidgetTrias tria1;
|
|
uiWidgetTrias tria2;
|
|
|
|
/* Widget shader parameters, must match the shader layout. */
|
|
uiWidgetBaseParameters uniform_params;
|
|
};
|
|
|
|
/**
|
|
* For time being only for visual appearance,
|
|
* later, a handling callback can be added too.
|
|
*/
|
|
struct uiWidgetType {
|
|
|
|
/* pointer to theme color definition */
|
|
const uiWidgetColors *wcol_theme;
|
|
uiWidgetStateColors *wcol_state;
|
|
|
|
/* converted colors for state */
|
|
uiWidgetColors wcol;
|
|
|
|
void (*state)(uiWidgetType *, const uiWidgetStateInfo *state, blender::ui::EmbossType emboss)
|
|
ATTR_NONNULL();
|
|
void (*draw)(uiWidgetColors *,
|
|
rcti *,
|
|
const uiWidgetStateInfo *,
|
|
int roundboxalign,
|
|
const float zoom) ATTR_NONNULL();
|
|
void (*custom)(uiBut *,
|
|
uiWidgetColors *,
|
|
rcti *,
|
|
const uiWidgetStateInfo *,
|
|
int roundboxalign,
|
|
const float zoom) ATTR_NONNULL();
|
|
void (*draw_block)(
|
|
uiWidgetColors *, const rcti *, int block_flag, int roundboxalign, const float zoom);
|
|
void (*text)(const uiFontStyle *, const uiWidgetColors *, uiBut *, rcti *);
|
|
};
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Shape Preset Data
|
|
* \{ */
|
|
|
|
static const float cornervec[WIDGET_CURVE_RESOLU][2] = {
|
|
{0.0, 0.0},
|
|
{0.195, 0.02},
|
|
{0.383, 0.067},
|
|
{0.55, 0.169},
|
|
{0.707, 0.293},
|
|
{0.831, 0.45},
|
|
{0.924, 0.617},
|
|
{0.98, 0.805},
|
|
{1.0, 1.0},
|
|
};
|
|
|
|
const float ui_pixel_jitter[UI_PIXEL_AA_JITTER][2] = {
|
|
{0.468813, -0.481430},
|
|
{-0.155755, -0.352820},
|
|
{0.219306, -0.238501},
|
|
{-0.393286, -0.110949},
|
|
{-0.024699, 0.013908},
|
|
{0.343805, 0.147431},
|
|
{-0.272855, 0.269918},
|
|
{0.095909, 0.388710},
|
|
};
|
|
#define WIDGET_AA_JITTER UI_PIXEL_AA_JITTER
|
|
#define jit ui_pixel_jitter
|
|
|
|
static const float g_shape_preset_number_arrow_vert[3][2] = {
|
|
{-0.352077, 0.532607},
|
|
{-0.352077, -0.549313},
|
|
{0.330000, -0.008353},
|
|
};
|
|
static const uint g_shape_preset_number_arrow_face[1][3] = {
|
|
{0, 1, 2},
|
|
};
|
|
|
|
static const float g_shape_preset_scroll_circle_vert[16][2] = {
|
|
{0.382684, 0.923879},
|
|
{0.000001, 1.000000},
|
|
{-0.382683, 0.923880},
|
|
{-0.707107, 0.707107},
|
|
{-0.923879, 0.382684},
|
|
{-1.000000, 0.000000},
|
|
{-0.923880, -0.382684},
|
|
{-0.707107, -0.707107},
|
|
{-0.382683, -0.923880},
|
|
{0.000000, -1.000000},
|
|
{0.382684, -0.923880},
|
|
{0.707107, -0.707107},
|
|
{0.923880, -0.382684},
|
|
{1.000000, -0.000000},
|
|
{0.923880, 0.382683},
|
|
{0.707107, 0.707107},
|
|
};
|
|
static const uint g_shape_preset_scroll_circle_face[14][3] = {
|
|
{0, 1, 2},
|
|
{2, 0, 3},
|
|
{3, 0, 15},
|
|
{3, 15, 4},
|
|
{4, 15, 14},
|
|
{4, 14, 5},
|
|
{5, 14, 13},
|
|
{5, 13, 6},
|
|
{6, 13, 12},
|
|
{6, 12, 7},
|
|
{7, 12, 11},
|
|
{7, 11, 8},
|
|
{8, 11, 10},
|
|
{8, 10, 9},
|
|
};
|
|
|
|
static const float g_shape_preset_menu_arrow_vert[6][2] = {
|
|
{-0.33, 0.16},
|
|
{0.33, 0.16},
|
|
{0, 0.82},
|
|
{0, -0.82},
|
|
{-0.33, -0.16},
|
|
{0.33, -0.16},
|
|
};
|
|
static const uint g_shape_preset_menu_arrow_face[2][3] = {{2, 0, 1}, {3, 5, 4}};
|
|
|
|
static const float g_shape_preset_checkmark_vert[6][2] = {
|
|
{-0.578579, 0.253369},
|
|
{-0.392773, 0.412794},
|
|
{-0.004241, -0.328551},
|
|
{-0.003001, 0.034320},
|
|
{1.055313, 0.864744},
|
|
{0.866408, 1.026895},
|
|
};
|
|
|
|
static const uint g_shape_preset_checkmark_face[4][3] = {
|
|
{3, 2, 4},
|
|
{3, 4, 5},
|
|
{1, 0, 3},
|
|
{0, 2, 3},
|
|
};
|
|
|
|
#define OY (-0.2 / 2)
|
|
#define SC (0.35 * 2)
|
|
static const float g_shape_preset_hold_action_vert[6][2] = {
|
|
{-0.5 + SC, 1.0 + OY},
|
|
{0.5, 1.0 + OY},
|
|
{0.5, 0.0 + OY + SC},
|
|
};
|
|
static const uint g_shape_preset_hold_action_face[2][3] = {{2, 0, 1}, {3, 5, 4}};
|
|
#undef OY
|
|
#undef SC
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name #gpu::Batch Creation
|
|
*
|
|
* In order to speed up UI drawing we create some batches that are then
|
|
* modified by specialized shaders to draw certain elements really fast.
|
|
* TODO: find a better place. Maybe its own file?
|
|
*
|
|
* \{ */
|
|
|
|
static struct {
|
|
blender::gpu::Batch *roundbox_widget;
|
|
blender::gpu::Batch *roundbox_shadow;
|
|
|
|
/* TODO: remove. */
|
|
GPUVertFormat format;
|
|
uint vflag_id;
|
|
} g_ui_batch_cache = {nullptr};
|
|
|
|
static const GPUVertFormat &vflag_format()
|
|
{
|
|
if (g_ui_batch_cache.format.attr_len == 0) {
|
|
GPUVertFormat *format = &g_ui_batch_cache.format;
|
|
g_ui_batch_cache.vflag_id = GPU_vertformat_attr_add(
|
|
format, "vflag", blender::gpu::VertAttrType::UINT_32);
|
|
}
|
|
return g_ui_batch_cache.format;
|
|
}
|
|
|
|
#define INNER 0
|
|
#define OUTLINE 1
|
|
#define EMBOSS 2
|
|
#define NO_AA 0
|
|
|
|
static void set_roundbox_vertex_data(GPUVertBufRaw *vflag_step, uint32_t d)
|
|
{
|
|
uint32_t *data = static_cast<uint32_t *>(GPU_vertbuf_raw_step(vflag_step));
|
|
*data = d;
|
|
}
|
|
|
|
static uint32_t set_roundbox_vertex(GPUVertBufRaw *vflag_step,
|
|
int corner_id,
|
|
int corner_v,
|
|
int jit_v,
|
|
bool inner,
|
|
bool emboss,
|
|
int color)
|
|
{
|
|
uint32_t *data = static_cast<uint32_t *>(GPU_vertbuf_raw_step(vflag_step));
|
|
*data = corner_id;
|
|
*data |= corner_v << 2;
|
|
*data |= jit_v << 6;
|
|
*data |= color << 12;
|
|
*data |= (inner) ? (1 << 10) : 0; /* is inner vert */
|
|
*data |= (emboss) ? (1 << 11) : 0; /* is emboss vert */
|
|
return *data;
|
|
}
|
|
|
|
blender::gpu::Batch *ui_batch_roundbox_widget_get()
|
|
{
|
|
if (g_ui_batch_cache.roundbox_widget == nullptr) {
|
|
blender::gpu::VertBuf *vbo = GPU_vertbuf_create_with_format(vflag_format());
|
|
|
|
GPU_vertbuf_data_alloc(*vbo, 12);
|
|
|
|
GPUIndexBufBuilder ibuf;
|
|
GPU_indexbuf_init(&ibuf, GPU_PRIM_TRIS, 6, 12);
|
|
/* Widget */
|
|
GPU_indexbuf_add_tri_verts(&ibuf, 0, 1, 2);
|
|
GPU_indexbuf_add_tri_verts(&ibuf, 2, 1, 3);
|
|
/* Trias */
|
|
GPU_indexbuf_add_tri_verts(&ibuf, 4, 5, 6);
|
|
GPU_indexbuf_add_tri_verts(&ibuf, 6, 5, 7);
|
|
|
|
GPU_indexbuf_add_tri_verts(&ibuf, 8, 9, 10);
|
|
GPU_indexbuf_add_tri_verts(&ibuf, 10, 9, 11);
|
|
|
|
g_ui_batch_cache.roundbox_widget = GPU_batch_create_ex(
|
|
GPU_PRIM_TRIS, vbo, GPU_indexbuf_build(&ibuf), GPU_BATCH_OWNS_INDEX | GPU_BATCH_OWNS_VBO);
|
|
gpu_batch_presets_register(g_ui_batch_cache.roundbox_widget);
|
|
}
|
|
return g_ui_batch_cache.roundbox_widget;
|
|
}
|
|
|
|
blender::gpu::Batch *ui_batch_roundbox_shadow_get()
|
|
{
|
|
if (g_ui_batch_cache.roundbox_shadow == nullptr) {
|
|
uint32_t last_data;
|
|
GPUVertBufRaw vflag_step;
|
|
blender::gpu::VertBuf *vbo = GPU_vertbuf_create_with_format(vflag_format());
|
|
const int vcount = (WIDGET_SIZE_MAX + 1) * 2 + 2 + WIDGET_SIZE_MAX;
|
|
GPU_vertbuf_data_alloc(*vbo, vcount);
|
|
GPU_vertbuf_attr_get_raw_data(vbo, g_ui_batch_cache.vflag_id, &vflag_step);
|
|
|
|
for (int c = 0; c < 4; c++) {
|
|
for (int a = 0; a < WIDGET_CURVE_RESOLU; a++) {
|
|
set_roundbox_vertex(&vflag_step, c, a, NO_AA, true, false, INNER);
|
|
set_roundbox_vertex(&vflag_step, c, a, NO_AA, false, false, INNER);
|
|
}
|
|
}
|
|
/* close loop */
|
|
last_data = set_roundbox_vertex(&vflag_step, 0, 0, NO_AA, true, false, INNER);
|
|
last_data = set_roundbox_vertex(&vflag_step, 0, 0, NO_AA, false, false, INNER);
|
|
/* restart */
|
|
set_roundbox_vertex_data(&vflag_step, last_data);
|
|
set_roundbox_vertex(&vflag_step, 0, 0, NO_AA, true, false, INNER);
|
|
/* filled */
|
|
for (int c1 = 0, c2 = 3; c1 < 2; c1++, c2--) {
|
|
for (int a1 = 0, a2 = WIDGET_CURVE_RESOLU - 1; a2 >= 0; a1++, a2--) {
|
|
set_roundbox_vertex(&vflag_step, c1, a1, NO_AA, true, false, INNER);
|
|
set_roundbox_vertex(&vflag_step, c2, a2, NO_AA, true, false, INNER);
|
|
}
|
|
}
|
|
g_ui_batch_cache.roundbox_shadow = GPU_batch_create_ex(
|
|
GPU_PRIM_TRI_STRIP, vbo, nullptr, GPU_BATCH_OWNS_VBO);
|
|
gpu_batch_presets_register(g_ui_batch_cache.roundbox_shadow);
|
|
}
|
|
return g_ui_batch_cache.roundbox_shadow;
|
|
}
|
|
|
|
#undef INNER
|
|
#undef OUTLINE
|
|
#undef EMBOSS
|
|
#undef NO_AA
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Draw Triangle Arrow
|
|
* \{ */
|
|
|
|
static void draw_anti_tria(
|
|
float x1, float y1, float x2, float y2, float x3, float y3, const float color[4])
|
|
{
|
|
const float tri_arr[3][2] = {{x1, y1}, {x2, y2}, {x3, y3}};
|
|
|
|
float draw_color[4];
|
|
copy_v4_v4(draw_color, color);
|
|
/* NOTE: This won't give back the original color. */
|
|
draw_color[3] *= 1.0f / WIDGET_AA_JITTER;
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
immUniformColor4fv(draw_color);
|
|
immBegin(GPU_PRIM_TRIS, 3 * WIDGET_AA_JITTER);
|
|
|
|
/* for each AA step */
|
|
for (int j = 0; j < WIDGET_AA_JITTER; j++) {
|
|
immVertex2f(pos, tri_arr[0][0] + jit[j][0], tri_arr[0][1] + jit[j][1]);
|
|
immVertex2f(pos, tri_arr[1][0] + jit[j][0], tri_arr[1][1] + jit[j][1]);
|
|
immVertex2f(pos, tri_arr[2][0] + jit[j][0], tri_arr[2][1] + jit[j][1]);
|
|
}
|
|
|
|
immEnd();
|
|
|
|
immUnbindProgram();
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
void UI_draw_icon_tri(float x, float y, char dir, const float color[4])
|
|
{
|
|
const float f3 = 0.05 * U.widget_unit;
|
|
const float f5 = 0.15 * U.widget_unit;
|
|
const float f7 = 0.25 * U.widget_unit;
|
|
|
|
if (dir == 'h') {
|
|
draw_anti_tria(x - f3, y - f5, x - f3, y + f5, x + f7, y, color);
|
|
}
|
|
else if (dir == 't') {
|
|
draw_anti_tria(x - f5, y - f7, x + f5, y - f7, x, y + f3, color);
|
|
}
|
|
else { /* 'v' = vertical, down. */
|
|
draw_anti_tria(x - f5, y + f3, x + f5, y + f3, x, y - f7, color);
|
|
}
|
|
}
|
|
|
|
/* triangle 'icon' inside rect */
|
|
static void draw_anti_tria_rect(const rctf *rect, char dir, const float color[4])
|
|
{
|
|
if (dir == 'h') {
|
|
const float half = 0.5f * BLI_rctf_size_y(rect);
|
|
draw_anti_tria(
|
|
rect->xmin, rect->ymin, rect->xmin, rect->ymax, rect->xmax, rect->ymin + half, color);
|
|
}
|
|
else {
|
|
const float half = 0.5f * BLI_rctf_size_x(rect);
|
|
draw_anti_tria(
|
|
rect->xmin, rect->ymax, rect->xmax, rect->ymax, rect->xmin + half, rect->ymin, color);
|
|
}
|
|
}
|
|
|
|
static void widget_init(uiWidgetBase *wtb)
|
|
{
|
|
wtb->totvert = wtb->halfwayvert = 0;
|
|
wtb->tria1.tot = 0;
|
|
wtb->tria2.tot = 0;
|
|
wtb->tria1.type = ROUNDBOX_TRIA_NONE;
|
|
wtb->tria1.size = 0;
|
|
wtb->tria2.size = 0;
|
|
|
|
wtb->draw_inner = true;
|
|
wtb->draw_outline = true;
|
|
wtb->draw_emboss = true;
|
|
|
|
wtb->uniform_params.shade_dir = 1.0f;
|
|
wtb->uniform_params.alpha_discard = 1.0f;
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Draw Round Box
|
|
* \{ */
|
|
|
|
/* this call has 1 extra arg to allow mask outline */
|
|
static void round_box__edges(
|
|
uiWidgetBase *wt, int roundboxalign, const rcti *rect, float rad, float radi)
|
|
{
|
|
float vec[WIDGET_CURVE_RESOLU][2], veci[WIDGET_CURVE_RESOLU][2];
|
|
const float minx = rect->xmin, miny = rect->ymin, maxx = rect->xmax, maxy = rect->ymax;
|
|
const float minxi = minx + U.pixelsize; /* Bounding-box inner. */
|
|
const float maxxi = maxx - U.pixelsize;
|
|
const float minyi = miny + U.pixelsize;
|
|
const float maxyi = maxy - U.pixelsize;
|
|
/* for uv, can divide by zero */
|
|
const float facxi = (maxxi != minxi) ? 1.0f / (maxxi - minxi) : 0.0f;
|
|
const float facyi = (maxyi != minyi) ? 1.0f / (maxyi - minyi) : 0.0f;
|
|
int tot = 0;
|
|
const int hnum = ((roundboxalign & (UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT)) ==
|
|
(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT) ||
|
|
(roundboxalign & (UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT)) ==
|
|
(UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT)) ?
|
|
1 :
|
|
2;
|
|
const int vnum = ((roundboxalign & (UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT)) ==
|
|
(UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT) ||
|
|
(roundboxalign & (UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT)) ==
|
|
(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT)) ?
|
|
1 :
|
|
2;
|
|
|
|
const int minsize = min_ii(BLI_rcti_size_x(rect) * hnum, BLI_rcti_size_y(rect) * vnum);
|
|
|
|
if (2.0f * rad > minsize) {
|
|
rad = 0.5f * minsize;
|
|
}
|
|
|
|
if (2.0f * (radi + 1.0f) > minsize) {
|
|
radi = 0.5f * minsize - U.pixelsize;
|
|
}
|
|
|
|
wt->uniform_params.rad = rad;
|
|
wt->uniform_params.radi = radi;
|
|
wt->uniform_params.facxi = facxi;
|
|
wt->uniform_params.facyi = facyi;
|
|
wt->uniform_params.round_corners[0] = (roundboxalign & UI_CNR_BOTTOM_LEFT) ? 1.0f : 0.0f;
|
|
wt->uniform_params.round_corners[1] = (roundboxalign & UI_CNR_BOTTOM_RIGHT) ? 1.0f : 0.0f;
|
|
wt->uniform_params.round_corners[2] = (roundboxalign & UI_CNR_TOP_RIGHT) ? 1.0f : 0.0f;
|
|
wt->uniform_params.round_corners[3] = (roundboxalign & UI_CNR_TOP_LEFT) ? 1.0f : 0.0f;
|
|
BLI_rctf_rcti_copy(&wt->uniform_params.rect, rect);
|
|
BLI_rctf_init(&wt->uniform_params.recti, minxi, maxxi, minyi, maxyi);
|
|
|
|
/* Multiply by radius. */
|
|
for (int a = 0; a < WIDGET_CURVE_RESOLU; a++) {
|
|
veci[a][0] = radi * cornervec[a][0];
|
|
veci[a][1] = radi * cornervec[a][1];
|
|
vec[a][0] = rad * cornervec[a][0];
|
|
vec[a][1] = rad * cornervec[a][1];
|
|
}
|
|
|
|
/* corner left-bottom */
|
|
if (roundboxalign & UI_CNR_BOTTOM_LEFT) {
|
|
for (int a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
|
|
wt->inner_v[tot][0] = minxi + veci[a][1];
|
|
wt->inner_v[tot][1] = minyi + radi - veci[a][0];
|
|
|
|
wt->outer_v[tot][0] = minx + vec[a][1];
|
|
wt->outer_v[tot][1] = miny + rad - vec[a][0];
|
|
|
|
wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0] = minxi;
|
|
wt->inner_v[tot][1] = minyi;
|
|
|
|
wt->outer_v[tot][0] = minx;
|
|
wt->outer_v[tot][1] = miny;
|
|
|
|
wt->inner_uv[tot][0] = 0.0f;
|
|
wt->inner_uv[tot][1] = 0.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
/* corner right-bottom */
|
|
if (roundboxalign & UI_CNR_BOTTOM_RIGHT) {
|
|
for (int a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
|
|
wt->inner_v[tot][0] = maxxi - radi + veci[a][0];
|
|
wt->inner_v[tot][1] = minyi + veci[a][1];
|
|
|
|
wt->outer_v[tot][0] = maxx - rad + vec[a][0];
|
|
wt->outer_v[tot][1] = miny + vec[a][1];
|
|
|
|
wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0] = maxxi;
|
|
wt->inner_v[tot][1] = minyi;
|
|
|
|
wt->outer_v[tot][0] = maxx;
|
|
wt->outer_v[tot][1] = miny;
|
|
|
|
wt->inner_uv[tot][0] = 1.0f;
|
|
wt->inner_uv[tot][1] = 0.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
wt->halfwayvert = tot;
|
|
|
|
/* corner right-top */
|
|
if (roundboxalign & UI_CNR_TOP_RIGHT) {
|
|
for (int a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
|
|
wt->inner_v[tot][0] = maxxi - veci[a][1];
|
|
wt->inner_v[tot][1] = maxyi - radi + veci[a][0];
|
|
|
|
wt->outer_v[tot][0] = maxx - vec[a][1];
|
|
wt->outer_v[tot][1] = maxy - rad + vec[a][0];
|
|
|
|
wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0] = maxxi;
|
|
wt->inner_v[tot][1] = maxyi;
|
|
|
|
wt->outer_v[tot][0] = maxx;
|
|
wt->outer_v[tot][1] = maxy;
|
|
|
|
wt->inner_uv[tot][0] = 1.0f;
|
|
wt->inner_uv[tot][1] = 1.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
/* corner left-top */
|
|
if (roundboxalign & UI_CNR_TOP_LEFT) {
|
|
for (int a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
|
|
wt->inner_v[tot][0] = minxi + radi - veci[a][0];
|
|
wt->inner_v[tot][1] = maxyi - veci[a][1];
|
|
|
|
wt->outer_v[tot][0] = minx + rad - vec[a][0];
|
|
wt->outer_v[tot][1] = maxy - vec[a][1];
|
|
|
|
wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0] = minxi;
|
|
wt->inner_v[tot][1] = maxyi;
|
|
|
|
wt->outer_v[tot][0] = minx;
|
|
wt->outer_v[tot][1] = maxy;
|
|
|
|
wt->inner_uv[tot][0] = 0.0f;
|
|
wt->inner_uv[tot][1] = 1.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
BLI_assert(tot <= WIDGET_SIZE_MAX);
|
|
|
|
wt->totvert = tot;
|
|
}
|
|
|
|
static void round_box_edges(uiWidgetBase *wt, int roundboxalign, const rcti *rect, float rad)
|
|
{
|
|
round_box__edges(wt, roundboxalign, rect, rad, rad - U.pixelsize);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Shape Preset Mini API
|
|
* \{ */
|
|
|
|
/* based on button rect, return scaled array of triangles */
|
|
static void shape_preset_init_trias_ex(uiWidgetTrias *tria,
|
|
const rcti *rect,
|
|
float triasize,
|
|
char where,
|
|
/* input data */
|
|
const float verts[][2],
|
|
const int verts_tot,
|
|
const uint tris[][3],
|
|
const int tris_tot)
|
|
{
|
|
float sizex, sizey;
|
|
int i1 = 0, i2 = 1;
|
|
|
|
const float minsize = ELEM(where, 'r', 'l') ? BLI_rcti_size_y(rect) : BLI_rcti_size_x(rect);
|
|
|
|
/* center position and size */
|
|
float centx = float(rect->xmin) + 0.4f * minsize;
|
|
float centy = float(rect->ymin) + 0.5f * minsize;
|
|
tria->size = sizex = sizey = -0.5f * triasize * minsize;
|
|
|
|
if (where == 'r') {
|
|
centx = float(rect->xmax) - 0.4f * minsize;
|
|
sizex = -sizex;
|
|
}
|
|
else if (where == 't') {
|
|
centx = float(rect->xmin) + 0.5f * minsize;
|
|
centy = float(rect->ymax) - 0.5f * minsize;
|
|
sizey = -sizey;
|
|
i2 = 0;
|
|
i1 = 1;
|
|
}
|
|
else if (where == 'b') {
|
|
centx = float(rect->xmin) + 0.5f * minsize;
|
|
sizex = -sizex;
|
|
i2 = 0;
|
|
i1 = 1;
|
|
}
|
|
|
|
for (int a = 0; a < verts_tot; a++) {
|
|
tria->vec[a][0] = sizex * verts[a][i1] + centx;
|
|
tria->vec[a][1] = sizey * verts[a][i2] + centy;
|
|
}
|
|
|
|
tria->center[0] = centx;
|
|
tria->center[1] = centy;
|
|
|
|
tria->tot = tris_tot;
|
|
tria->index = tris;
|
|
}
|
|
|
|
static void shape_preset_init_number_arrows(uiWidgetTrias *tria,
|
|
const rcti *rect,
|
|
float triasize,
|
|
char where)
|
|
{
|
|
tria->type = ROUNDBOX_TRIA_ARROWS;
|
|
shape_preset_init_trias_ex(tria,
|
|
rect,
|
|
triasize,
|
|
where,
|
|
g_shape_preset_number_arrow_vert,
|
|
ARRAY_SIZE(g_shape_preset_number_arrow_vert),
|
|
g_shape_preset_number_arrow_face,
|
|
ARRAY_SIZE(g_shape_preset_number_arrow_face));
|
|
}
|
|
|
|
static void shape_preset_init_hold_action(uiWidgetTrias *tria,
|
|
const rcti *rect,
|
|
float triasize,
|
|
char where)
|
|
{
|
|
tria->type = ROUNDBOX_TRIA_HOLD_ACTION_ARROW;
|
|
/* With the current changes to use batches for widget drawing, the code
|
|
* below is doing almost nothing effectively. 'where' doesn't work either,
|
|
* shader is currently hardcoded to work for the button triangle pointing
|
|
* at the lower right. The same limitation applies to other trias as well.
|
|
* XXX Should be addressed. */
|
|
shape_preset_init_trias_ex(tria,
|
|
rect,
|
|
triasize,
|
|
where,
|
|
g_shape_preset_hold_action_vert,
|
|
ARRAY_SIZE(g_shape_preset_hold_action_vert),
|
|
g_shape_preset_hold_action_face,
|
|
ARRAY_SIZE(g_shape_preset_hold_action_face));
|
|
}
|
|
|
|
static void shape_preset_init_scroll_circle(uiWidgetTrias *tria,
|
|
const rcti *rect,
|
|
float triasize,
|
|
char where)
|
|
{
|
|
tria->type = ROUNDBOX_TRIA_SCROLL;
|
|
shape_preset_init_trias_ex(tria,
|
|
rect,
|
|
triasize,
|
|
where,
|
|
g_shape_preset_scroll_circle_vert,
|
|
ARRAY_SIZE(g_shape_preset_scroll_circle_vert),
|
|
g_shape_preset_scroll_circle_face,
|
|
ARRAY_SIZE(g_shape_preset_scroll_circle_face));
|
|
}
|
|
|
|
static void widget_draw_vertex_buffer(uint pos,
|
|
uint col,
|
|
GPUPrimType mode,
|
|
const float quads_pos[WIDGET_SIZE_MAX][2],
|
|
const uchar quads_col[WIDGET_SIZE_MAX][4],
|
|
uint totvert)
|
|
{
|
|
immBegin(mode, totvert);
|
|
for (int i = 0; i < totvert; i++) {
|
|
if (quads_col) {
|
|
immAttr4ubv(col, quads_col[i]);
|
|
}
|
|
immVertex2fv(pos, quads_pos[i]);
|
|
}
|
|
immEnd();
|
|
}
|
|
|
|
static void shape_preset_trias_from_rect_menu(uiWidgetTrias *tria, const rcti *rect)
|
|
{
|
|
const float width = BLI_rcti_size_x(rect);
|
|
const float height = BLI_rcti_size_y(rect);
|
|
if ((width / height) < 0.5f) {
|
|
/* Too narrow to fit. */
|
|
return;
|
|
}
|
|
float centx, centy, size;
|
|
|
|
tria->type = ROUNDBOX_TRIA_MENU;
|
|
|
|
/* Center position and size. */
|
|
tria->center[0] = centx = rect->xmin + 0.52f * BLI_rcti_size_y(rect);
|
|
tria->center[1] = centy = rect->ymin + 0.52f * BLI_rcti_size_y(rect);
|
|
tria->size = size = 0.4f * height;
|
|
|
|
if (width > height * 1.1f) {
|
|
/* For wider buttons align tighter to the right. */
|
|
tria->center[0] = centx = rect->xmax - 0.32f * height;
|
|
}
|
|
|
|
for (int a = 0; a < 6; a++) {
|
|
tria->vec[a][0] = size * g_shape_preset_menu_arrow_vert[a][0] + centx;
|
|
tria->vec[a][1] = size * g_shape_preset_menu_arrow_vert[a][1] + centy;
|
|
}
|
|
|
|
tria->tot = 2;
|
|
tria->index = g_shape_preset_menu_arrow_face;
|
|
}
|
|
|
|
static void shape_preset_trias_from_rect_checkmark(uiWidgetTrias *tria, const rcti *rect)
|
|
{
|
|
float centx, centy, size;
|
|
|
|
tria->type = ROUNDBOX_TRIA_CHECK;
|
|
|
|
/* Center position and size. */
|
|
tria->center[0] = centx = rect->xmin + 0.5f * BLI_rcti_size_y(rect);
|
|
tria->center[1] = centy = rect->ymin + 0.5f * BLI_rcti_size_y(rect);
|
|
tria->size = size = 0.5f * BLI_rcti_size_y(rect);
|
|
|
|
for (int a = 0; a < 6; a++) {
|
|
tria->vec[a][0] = size * g_shape_preset_checkmark_vert[a][0] + centx;
|
|
tria->vec[a][1] = size * g_shape_preset_checkmark_vert[a][1] + centy;
|
|
}
|
|
|
|
tria->tot = 4;
|
|
tria->index = g_shape_preset_checkmark_face;
|
|
}
|
|
|
|
static void shape_preset_trias_from_rect_dash(uiWidgetTrias *tria, const rcti *rect)
|
|
{
|
|
tria->type = ROUNDBOX_TRIA_DASH;
|
|
|
|
/* Center position and size. */
|
|
tria->center[0] = rect->xmin + 0.5f * BLI_rcti_size_y(rect);
|
|
tria->center[1] = rect->ymin + 0.5f * BLI_rcti_size_y(rect);
|
|
tria->size = 0.5f * BLI_rcti_size_y(rect);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget Base Drawing
|
|
* \{ */
|
|
|
|
/* prepares shade colors */
|
|
static void shadecolors4(
|
|
const uchar *color, short shadetop, short shadedown, uchar r_coltop[4], uchar r_coldown[4])
|
|
{
|
|
r_coltop[0] = std::clamp(color[0] + shadetop, 0, 255);
|
|
r_coltop[1] = std::clamp(color[1] + shadetop, 0, 255);
|
|
r_coltop[2] = std::clamp(color[2] + shadetop, 0, 255);
|
|
r_coltop[3] = color[3];
|
|
|
|
r_coldown[0] = std::clamp(color[0] + shadedown, 0, 255);
|
|
r_coldown[1] = std::clamp(color[1] + shadedown, 0, 255);
|
|
r_coldown[2] = std::clamp(color[2] + shadedown, 0, 255);
|
|
r_coldown[3] = color[3];
|
|
}
|
|
|
|
static void widget_verts_to_triangle_strip(uiWidgetBase *wtb,
|
|
const int totvert,
|
|
float triangle_strip[WIDGET_SIZE_MAX * 2 + 2][2])
|
|
{
|
|
int a;
|
|
for (a = 0; a < totvert; a++) {
|
|
copy_v2_v2(triangle_strip[a * 2], wtb->outer_v[a]);
|
|
copy_v2_v2(triangle_strip[a * 2 + 1], wtb->inner_v[a]);
|
|
}
|
|
copy_v2_v2(triangle_strip[a * 2], wtb->outer_v[0]);
|
|
copy_v2_v2(triangle_strip[a * 2 + 1], wtb->inner_v[0]);
|
|
}
|
|
|
|
static void widgetbase_outline(uiWidgetBase *wtb, uint pos)
|
|
{
|
|
float triangle_strip[WIDGET_SIZE_MAX * 2 + 2][2]; /* + 2 because the last pair is wrapped */
|
|
widget_verts_to_triangle_strip(wtb, wtb->totvert, triangle_strip);
|
|
|
|
widget_draw_vertex_buffer(
|
|
pos, 0, GPU_PRIM_TRI_STRIP, triangle_strip, nullptr, wtb->totvert * 2 + 2);
|
|
}
|
|
|
|
static void widgetbase_set_uniform_alpha_discard(uiWidgetBase *wtb,
|
|
const bool alpha_check,
|
|
const float discard_factor)
|
|
{
|
|
if (alpha_check) {
|
|
wtb->uniform_params.alpha_discard = -discard_factor;
|
|
}
|
|
else {
|
|
wtb->uniform_params.alpha_discard = discard_factor;
|
|
}
|
|
}
|
|
|
|
static void widgetbase_set_uniform_alpha_check(uiWidgetBase *wtb, const bool alpha_check)
|
|
{
|
|
const float discard_factor = fabs(wtb->uniform_params.alpha_discard);
|
|
widgetbase_set_uniform_alpha_discard(wtb, alpha_check, discard_factor);
|
|
}
|
|
|
|
static void widgetbase_set_uniform_discard_factor(uiWidgetBase *wtb, const float discard_factor)
|
|
{
|
|
const bool alpha_check = wtb->uniform_params.alpha_discard < 0.0f;
|
|
widgetbase_set_uniform_alpha_discard(wtb, alpha_check, discard_factor);
|
|
}
|
|
|
|
static void widgetbase_set_uniform_colors_ubv(uiWidgetBase *wtb,
|
|
const uchar *col1,
|
|
const uchar *col2,
|
|
const uchar *outline,
|
|
const uchar *emboss,
|
|
const uchar *tria,
|
|
const bool alpha_check)
|
|
{
|
|
widgetbase_set_uniform_alpha_check(wtb, alpha_check);
|
|
rgba_float_args_set_ch(wtb->uniform_params.color_inner1, col1[0], col1[1], col1[2], col1[3]);
|
|
rgba_float_args_set_ch(wtb->uniform_params.color_inner2, col2[0], col2[1], col2[2], col2[3]);
|
|
rgba_float_args_set_ch(
|
|
wtb->uniform_params.color_outline, outline[0], outline[1], outline[2], outline[3]);
|
|
rgba_float_args_set_ch(
|
|
wtb->uniform_params.color_emboss, emboss[0], emboss[1], emboss[2], emboss[3]);
|
|
rgba_float_args_set_ch(wtb->uniform_params.color_tria, tria[0], tria[1], tria[2], tria[3]);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget Base Drawing #gpu::Batch Cache
|
|
* \{ */
|
|
|
|
/* keep in sync with shader */
|
|
#define MAX_WIDGET_BASE_BATCH 6
|
|
#define MAX_WIDGET_PARAMETERS 12
|
|
|
|
static struct {
|
|
uiWidgetBaseParameters params[MAX_WIDGET_BASE_BATCH];
|
|
int count;
|
|
bool enabled;
|
|
} g_widget_base_batch = {{{{0}}}};
|
|
|
|
void UI_widgetbase_draw_cache_flush()
|
|
{
|
|
const float checker_params[3] = {
|
|
UI_ALPHA_CHECKER_DARK / 255.0f, UI_ALPHA_CHECKER_LIGHT / 255.0f, 8.0f};
|
|
|
|
if (g_widget_base_batch.count == 0) {
|
|
return;
|
|
}
|
|
|
|
blender::gpu::Batch *batch = ui_batch_roundbox_widget_get();
|
|
if (g_widget_base_batch.count == 1) {
|
|
/* draw single */
|
|
GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_WIDGET_BASE);
|
|
GPU_batch_uniform_4fv_array(
|
|
batch, "parameters", MAX_WIDGET_PARAMETERS, (const float(*)[4])g_widget_base_batch.params);
|
|
GPU_batch_uniform_3fv(batch, "checkerColorAndSize", checker_params);
|
|
GPU_batch_draw(batch);
|
|
}
|
|
else {
|
|
GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_WIDGET_BASE_INST);
|
|
GPU_batch_uniform_4fv_array(batch,
|
|
"parameters",
|
|
MAX_WIDGET_PARAMETERS * MAX_WIDGET_BASE_BATCH,
|
|
(float(*)[4])g_widget_base_batch.params);
|
|
GPU_batch_uniform_3fv(batch, "checkerColorAndSize", checker_params);
|
|
GPU_batch_draw_instance_range(batch, 0, g_widget_base_batch.count);
|
|
}
|
|
g_widget_base_batch.count = 0;
|
|
}
|
|
|
|
void UI_widgetbase_draw_cache_begin()
|
|
{
|
|
BLI_assert(g_widget_base_batch.enabled == false);
|
|
g_widget_base_batch.enabled = true;
|
|
}
|
|
|
|
void UI_widgetbase_draw_cache_end()
|
|
{
|
|
BLI_assert(g_widget_base_batch.enabled == true);
|
|
g_widget_base_batch.enabled = false;
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
|
|
UI_widgetbase_draw_cache_flush();
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
static void draw_widgetbase_batch(uiWidgetBase *wtb)
|
|
{
|
|
wtb->uniform_params.tria_type = wtb->tria1.type;
|
|
wtb->uniform_params.tria1_size = wtb->tria1.size;
|
|
wtb->uniform_params.tria2_size = wtb->tria2.size;
|
|
copy_v2_v2(wtb->uniform_params.tria1_center, wtb->tria1.center);
|
|
copy_v2_v2(wtb->uniform_params.tria2_center, wtb->tria2.center);
|
|
|
|
if (g_widget_base_batch.enabled) {
|
|
g_widget_base_batch.params[g_widget_base_batch.count] = wtb->uniform_params;
|
|
g_widget_base_batch.count++;
|
|
|
|
if (g_widget_base_batch.count == MAX_WIDGET_BASE_BATCH) {
|
|
UI_widgetbase_draw_cache_flush();
|
|
}
|
|
}
|
|
else {
|
|
const float checker_params[3] = {
|
|
UI_ALPHA_CHECKER_DARK / 255.0f, UI_ALPHA_CHECKER_LIGHT / 255.0f, 8.0f};
|
|
/* draw single */
|
|
blender::gpu::Batch *batch = ui_batch_roundbox_widget_get();
|
|
GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_WIDGET_BASE);
|
|
GPU_batch_uniform_4fv_array(
|
|
batch, "parameters", MAX_WIDGET_PARAMETERS, (float(*)[4]) & wtb->uniform_params);
|
|
GPU_batch_uniform_3fv(batch, "checkerColorAndSize", checker_params);
|
|
GPU_batch_draw(batch);
|
|
}
|
|
}
|
|
|
|
static void widgetbase_draw_ex(uiWidgetBase *wtb,
|
|
const uiWidgetColors *wcol,
|
|
bool show_alpha_checkers)
|
|
{
|
|
uchar inner_col1[4] = {0};
|
|
uchar inner_col2[4] = {0};
|
|
uchar emboss_col[4] = {0};
|
|
uchar outline_col[4] = {0};
|
|
uchar tria_col[4] = {0};
|
|
/* For color widget. */
|
|
if (wcol->shaded != 0) {
|
|
show_alpha_checkers = false;
|
|
}
|
|
|
|
/* backdrop non AA */
|
|
if (wtb->draw_inner) {
|
|
if (wcol->shaded == 0) {
|
|
/* simple fill */
|
|
inner_col1[0] = inner_col2[0] = wcol->inner[0];
|
|
inner_col1[1] = inner_col2[1] = wcol->inner[1];
|
|
inner_col1[2] = inner_col2[2] = wcol->inner[2];
|
|
inner_col1[3] = inner_col2[3] = wcol->inner[3];
|
|
}
|
|
else {
|
|
/* gradient fill */
|
|
shadecolors4(wcol->inner, wcol->shadetop, wcol->shadedown, inner_col1, inner_col2);
|
|
}
|
|
}
|
|
|
|
if (wtb->draw_outline) {
|
|
outline_col[0] = wcol->outline[0];
|
|
outline_col[1] = wcol->outline[1];
|
|
outline_col[2] = wcol->outline[2];
|
|
outline_col[3] = wcol->outline[3];
|
|
|
|
/* Emboss shadow if enabled, and inner and outline colors are not fully transparent. */
|
|
if ((wtb->draw_emboss) && (wcol->inner[3] != 0.0f || wcol->outline[3] != 0.0f)) {
|
|
UI_GetThemeColor4ubv(TH_WIDGET_EMBOSS, emboss_col);
|
|
}
|
|
}
|
|
|
|
if (wtb->tria1.type != ROUNDBOX_TRIA_NONE) {
|
|
tria_col[0] = wcol->item[0];
|
|
tria_col[1] = wcol->item[1];
|
|
tria_col[2] = wcol->item[2];
|
|
tria_col[3] = wcol->item[3];
|
|
}
|
|
|
|
/* Draw everything in one draw-call. */
|
|
if (inner_col1[3] || inner_col2[3] || outline_col[3] || emboss_col[3] || tria_col[3] ||
|
|
show_alpha_checkers)
|
|
{
|
|
widgetbase_set_uniform_colors_ubv(
|
|
wtb, inner_col1, inner_col2, outline_col, emboss_col, tria_col, show_alpha_checkers);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
draw_widgetbase_batch(wtb);
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
}
|
|
|
|
static void widgetbase_draw(uiWidgetBase *wtb, const uiWidgetColors *wcol)
|
|
{
|
|
widgetbase_draw_ex(wtb, wcol, false);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Text/Icon Drawing
|
|
* \{ */
|
|
|
|
#define UI_TEXT_CLIP_MARGIN (0.25f * U.widget_unit / but->block->aspect)
|
|
|
|
#define PREVIEW_PAD (0.15f * UI_UNIT_X)
|
|
|
|
static float widget_alpha_factor(const uiWidgetStateInfo *state)
|
|
{
|
|
if (state->but_flag & (UI_BUT_INACTIVE | UI_BUT_DISABLED)) {
|
|
if (state->but_flag & UI_SEARCH_FILTER_NO_MATCH) {
|
|
return 0.25f;
|
|
}
|
|
return 0.5f;
|
|
}
|
|
|
|
if (state->but_flag & UI_SEARCH_FILTER_NO_MATCH) {
|
|
return 0.5f;
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
static void widget_draw_icon_centered(const BIFIconID icon,
|
|
const float aspect,
|
|
const float alpha,
|
|
const rcti *rect,
|
|
const uchar mono_color[4])
|
|
{
|
|
if (icon == ICON_NONE) {
|
|
return;
|
|
}
|
|
|
|
const float size = ICON_DEFAULT_HEIGHT / (aspect * UI_INV_SCALE_FAC);
|
|
|
|
if (size > 0) {
|
|
const int x = BLI_rcti_cent_x(rect) - size / 2;
|
|
const int y = BLI_rcti_cent_y(rect) - size / 2;
|
|
|
|
const bTheme *btheme = UI_GetTheme();
|
|
const float desaturate = 1.0 - btheme->tui.icon_saturation;
|
|
uchar color[4] = {mono_color[0], mono_color[1], mono_color[2], mono_color[3]};
|
|
const bool has_theme = UI_icon_get_theme_color(int(icon), color);
|
|
const bool outline = btheme->tui.icon_border_intensity > 0.0f && has_theme;
|
|
|
|
UI_icon_draw_ex(
|
|
x, y, icon, aspect * UI_INV_SCALE_FAC, alpha, desaturate, color, outline, nullptr);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \param aspect: The inverse zoom factor (typically #uiBlock.aspect), with DPI applied (i.e. not
|
|
* multiplied by #UI_INV_SCALE_FAC).
|
|
* \param mono_color: Only for drawing monochrome icons.
|
|
*/
|
|
static void widget_draw_preview_icon(BIFIconID icon,
|
|
float alpha,
|
|
float aspect,
|
|
const bool add_padding,
|
|
const rcti *rect,
|
|
const uchar mono_color[4])
|
|
{
|
|
if (icon == ICON_NONE) {
|
|
return;
|
|
}
|
|
|
|
if (icon < BIFICONID_LAST_STATIC) {
|
|
widget_draw_icon_centered(icon, aspect, alpha, rect, mono_color);
|
|
return;
|
|
}
|
|
|
|
const int w = BLI_rcti_size_x(rect);
|
|
const int h = BLI_rcti_size_y(rect);
|
|
const int size = std::min(w, h) - (add_padding ? (PREVIEW_PAD * 2) : 0);
|
|
|
|
if (size > 0) {
|
|
const int x = rect->xmin + w / 2 - size / 2;
|
|
const int y = rect->ymin + h / 2 - size / 2;
|
|
|
|
UI_icon_draw_preview(x, y, icon, 1.0f, alpha, size);
|
|
}
|
|
}
|
|
|
|
static int ui_but_draw_menu_icon(const uiBut *but)
|
|
{
|
|
return (but->flag & UI_BUT_ICON_SUBMENU) && (but->emboss == blender::ui::EmbossType::Pulldown);
|
|
}
|
|
|
|
/* icons have been standardized... and this call draws in untransformed coordinates */
|
|
|
|
static void widget_draw_icon(
|
|
const uiBut *but, BIFIconID icon, float alpha, const rcti *rect, const uchar mono_color[4])
|
|
{
|
|
if (but->flag & UI_BUT_ICON_PREVIEW) {
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
widget_draw_preview_icon(icon,
|
|
alpha,
|
|
but->block->aspect,
|
|
!(but->drawflag & UI_BUT_NO_PREVIEW_PADDING),
|
|
rect,
|
|
mono_color);
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
return;
|
|
}
|
|
|
|
/* this icon doesn't need draw... */
|
|
if (icon == ICON_BLANK1 && (but->flag & UI_BUT_ICON_SUBMENU) == 0) {
|
|
return;
|
|
}
|
|
|
|
const float aspect = but->block->aspect * UI_INV_SCALE_FAC;
|
|
const float height = ICON_DEFAULT_HEIGHT / aspect;
|
|
|
|
/* calculate blend color */
|
|
if (ELEM(but->type, ButType::Toggle, ButType::Row, ButType::ToggleN, ButType::ListRow)) {
|
|
if (but->flag & UI_SELECT) {
|
|
/* pass */
|
|
}
|
|
else if (but->flag & UI_HOVER) {
|
|
/* pass */
|
|
}
|
|
else {
|
|
alpha = 0.75f;
|
|
}
|
|
}
|
|
else if (but->type == ButType::Label) {
|
|
/* extra feature allows more alpha blending */
|
|
const uiButLabel *but_label = reinterpret_cast<const uiButLabel *>(but);
|
|
alpha *= but_label->alpha_factor;
|
|
}
|
|
else if (ELEM(but->type, ButType::But, ButType::Decorator)) {
|
|
uiWidgetStateInfo state = {0};
|
|
state.but_flag = but->flag;
|
|
state.but_drawflag = but->drawflag;
|
|
alpha *= widget_alpha_factor(&state);
|
|
}
|
|
|
|
/* Dim the icon as its space is reduced to zero. */
|
|
if (height > (rect->xmax - rect->xmin)) {
|
|
alpha *= std::max(float(rect->xmax - rect->xmin) / height, 0.0f);
|
|
}
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
|
|
if (icon && icon != ICON_BLANK1) {
|
|
const float ofs = 1.0f / aspect;
|
|
float xs, ys;
|
|
|
|
if (but->drawflag & UI_BUT_ICON_LEFT) {
|
|
/* special case - icon_only pie buttons */
|
|
if (ui_block_is_pie_menu(but->block) && !ELEM(but->type, ButType::Menu, ButType::Popover) &&
|
|
but->str.empty())
|
|
{
|
|
xs = rect->xmin + 2.0f * ofs;
|
|
}
|
|
else if (but->emboss == blender::ui::EmbossType::None || but->type == ButType::Label) {
|
|
xs = rect->xmin + 2.0f * ofs;
|
|
}
|
|
else {
|
|
xs = rect->xmin + 4.0f * ofs;
|
|
}
|
|
}
|
|
else {
|
|
xs = (rect->xmin + rect->xmax - height) / 2.0f;
|
|
}
|
|
ys = (rect->ymin + rect->ymax - height) / 2.0f;
|
|
|
|
/* force positions to integers, for zoom levels near 1. draws icons crisp. */
|
|
if (aspect > 0.95f && aspect < 1.05f) {
|
|
xs = roundf(xs);
|
|
ys = roundf(ys);
|
|
}
|
|
|
|
/* Get theme color. */
|
|
uchar color[4] = {mono_color[0], mono_color[1], mono_color[2], mono_color[3]};
|
|
const bTheme *btheme = UI_GetTheme();
|
|
/* Only use theme colors if the button doesn't override the color. */
|
|
const bool has_theme = !but->col[3] && UI_icon_get_theme_color(int(icon), color);
|
|
const bool outline = btheme->tui.icon_border_intensity > 0.0f && has_theme;
|
|
|
|
/* to indicate draggable */
|
|
if (ui_but_drag_is_draggable(but) && (but->flag & UI_HOVER)) {
|
|
UI_icon_draw_ex(xs, ys, icon, aspect, 1.25f, 0.0f, color, outline, &but->icon_overlay_text);
|
|
}
|
|
else if (but->flag & (UI_HOVER | UI_SELECT | UI_SELECT_DRAW)) {
|
|
UI_icon_draw_ex(xs, ys, icon, aspect, alpha, 0.0f, color, outline, &but->icon_overlay_text);
|
|
}
|
|
else if (!((but->icon != ICON_NONE) && UI_but_is_tool(but))) {
|
|
if (has_theme) {
|
|
alpha *= 0.8f;
|
|
}
|
|
UI_icon_draw_ex(xs,
|
|
ys,
|
|
icon,
|
|
aspect,
|
|
alpha,
|
|
0.0f,
|
|
color,
|
|
outline,
|
|
&but->icon_overlay_text,
|
|
but->drawflag & UI_BUT_ICON_INVERT);
|
|
}
|
|
else {
|
|
const float desaturate = 1.0 - btheme->tui.icon_saturation;
|
|
UI_icon_draw_ex(
|
|
xs, ys, icon, aspect, alpha, desaturate, color, outline, &but->icon_overlay_text);
|
|
}
|
|
}
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
static void widget_draw_submenu_tria(const uiBut *but,
|
|
const rcti *rect,
|
|
const uiWidgetColors *wcol)
|
|
{
|
|
const float aspect = but->block->aspect * UI_INV_SCALE_FAC;
|
|
const int tria_height = int(ICON_DEFAULT_HEIGHT / aspect);
|
|
const int tria_width = int(ICON_DEFAULT_WIDTH / aspect) - 2 * U.pixelsize;
|
|
const int xs = rect->xmax - tria_width;
|
|
const int ys = (rect->ymin + rect->ymax - tria_height) / 2.0f;
|
|
|
|
float col[4];
|
|
rgba_uchar_to_float(col, wcol->text);
|
|
col[3] *= 0.8f;
|
|
|
|
rctf tria_rect;
|
|
BLI_rctf_init(&tria_rect, xs, xs + tria_width, ys, ys + tria_height);
|
|
BLI_rctf_scale(&tria_rect, 0.4f);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
draw_anti_tria_rect(&tria_rect, 'h', col);
|
|
}
|
|
|
|
static void ui_text_clip_give_prev_off(uiBut *but, const char *str)
|
|
{
|
|
const char *prev_utf8 = BLI_str_find_prev_char_utf8(str + but->ofs, str);
|
|
const int bytes = str + but->ofs - prev_utf8;
|
|
|
|
but->ofs -= bytes;
|
|
}
|
|
|
|
static void ui_text_clip_give_next_off(uiBut *but, const char *str, const char *str_end)
|
|
{
|
|
const char *next_utf8 = BLI_str_find_next_char_utf8(str + but->ofs, str_end);
|
|
const int bytes = next_utf8 - (str + but->ofs);
|
|
|
|
but->ofs += bytes;
|
|
}
|
|
|
|
/**
|
|
* Helper.
|
|
* This func assumes things like kerning handling have already been handled!
|
|
* Return the length of modified (right-clipped + ellipsis) string.
|
|
*/
|
|
static void ui_text_clip_right_ex(const uiFontStyle *fstyle,
|
|
char *str,
|
|
const size_t max_len,
|
|
const float okwidth,
|
|
const char *sep,
|
|
const int sep_len,
|
|
const float sep_strwidth,
|
|
size_t *r_final_len)
|
|
{
|
|
BLI_assert(str[0]);
|
|
|
|
/* How many BYTES (not characters) of this UTF8 string can fit, along with appended ellipsis. */
|
|
int l_end = BLF_width_to_strlen(
|
|
fstyle->uifont_id, str, max_len, okwidth - sep_strwidth, nullptr);
|
|
|
|
if (l_end > 0) {
|
|
/* At least one character, so clip and add the ellipsis. */
|
|
memcpy(str + l_end, sep, sep_len + 1); /* +1 for trailing '\0'. */
|
|
if (r_final_len) {
|
|
*r_final_len = size_t(l_end) + sep_len;
|
|
}
|
|
}
|
|
else {
|
|
/* Otherwise fit as much as we can without adding an ellipsis. */
|
|
l_end = BLF_width_to_strlen(fstyle->uifont_id, str, max_len, okwidth, nullptr);
|
|
str[l_end] = '\0';
|
|
if (r_final_len) {
|
|
*r_final_len = size_t(l_end);
|
|
}
|
|
}
|
|
}
|
|
|
|
float UI_text_clip_middle_ex(const uiFontStyle *fstyle,
|
|
char *str,
|
|
float okwidth,
|
|
const float minwidth,
|
|
const size_t max_len,
|
|
const char rpart_sep,
|
|
const bool clip_right_if_tight)
|
|
{
|
|
BLI_assert(str[0]);
|
|
|
|
/* need to set this first */
|
|
UI_fontstyle_set(fstyle);
|
|
|
|
float strwidth = BLF_width(fstyle->uifont_id, str, max_len);
|
|
|
|
if ((okwidth > 0.0f) && (strwidth > okwidth)) {
|
|
const char sep[] = BLI_STR_UTF8_HORIZONTAL_ELLIPSIS;
|
|
const int sep_len = sizeof(sep) - 1;
|
|
const float sep_strwidth = BLF_width(fstyle->uifont_id, sep, sep_len + 1);
|
|
|
|
char *rpart = nullptr, rpart_buf[UI_MAX_DRAW_STR];
|
|
float rpart_width = 0.0f;
|
|
size_t rpart_len = 0;
|
|
size_t final_lpart_len;
|
|
|
|
if (rpart_sep) {
|
|
rpart = strrchr(str, rpart_sep);
|
|
|
|
if (rpart) {
|
|
rpart_len = strlen(rpart);
|
|
rpart_width = BLF_width(fstyle->uifont_id, rpart, rpart_len);
|
|
okwidth -= rpart_width;
|
|
strwidth -= rpart_width;
|
|
|
|
if (okwidth < 0.0f) {
|
|
/* Not enough place for actual label, just display protected right part.
|
|
* Here just for safety, should never happen in real life! */
|
|
memmove(str, rpart, rpart_len + 1);
|
|
rpart = nullptr;
|
|
okwidth += rpart_width;
|
|
strwidth = rpart_width;
|
|
}
|
|
}
|
|
}
|
|
|
|
const float parts_strwidth = (okwidth - sep_strwidth) / 2.0f;
|
|
|
|
if (rpart) {
|
|
STRNCPY(rpart_buf, rpart);
|
|
*rpart = '\0';
|
|
rpart = rpart_buf;
|
|
}
|
|
|
|
const size_t l_end = BLF_width_to_strlen(
|
|
fstyle->uifont_id, str, max_len, parts_strwidth, nullptr);
|
|
if (clip_right_if_tight &&
|
|
(l_end < 10 || min_ff(parts_strwidth, strwidth - okwidth) < minwidth))
|
|
{
|
|
/* If we really have no place, or we would clip a very small piece of string in the middle,
|
|
* only show start of string.
|
|
*/
|
|
ui_text_clip_right_ex(
|
|
fstyle, str, max_len, okwidth, sep, sep_len, sep_strwidth, &final_lpart_len);
|
|
}
|
|
else {
|
|
size_t r_offset, r_len;
|
|
|
|
r_offset = BLF_width_to_rstrlen(fstyle->uifont_id, str, max_len, parts_strwidth, nullptr);
|
|
r_len = strlen(str + r_offset) + 1; /* +1 for the trailing '\0'. */
|
|
|
|
if (l_end + sep_len + r_len + rpart_len > max_len) {
|
|
/* Corner case, the str already takes all available mem,
|
|
* and the ellipsis chars would actually add more chars.
|
|
* Better to just trim one or two letters to the right in this case...
|
|
* NOTE: with a single-char ellipsis, this should never happen! But better be safe
|
|
* here...
|
|
*/
|
|
ui_text_clip_right_ex(
|
|
fstyle, str, max_len, okwidth, sep, sep_len, sep_strwidth, &final_lpart_len);
|
|
}
|
|
else {
|
|
memmove(str + l_end + sep_len, str + r_offset, r_len);
|
|
memcpy(str + l_end, sep, sep_len);
|
|
/* -1 to remove trailing '\0'! */
|
|
final_lpart_len = size_t(l_end + sep_len + r_len - 1);
|
|
|
|
/* Seems like this was only needed because of an error in #BLF_width_to_rstrlen(), not because of
|
|
* integer imprecision. See PR #135239. */
|
|
#if 0
|
|
while (BLF_width(fstyle->uifont_id, str, max_len) > okwidth) {
|
|
/* This will happen because a lot of string width processing is done in integer pixels,
|
|
* which can introduce a rather high error in the end (about 2 pixels or so).
|
|
* Only one char removal shall ever be needed in real-life situation... */
|
|
r_len--;
|
|
final_lpart_len--;
|
|
char *c = str + l_end + sep_len;
|
|
memmove(c, c + 1, r_len);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (rpart) {
|
|
/* Add back preserved right part to our shorten str. */
|
|
memcpy(str + final_lpart_len, rpart, rpart_len + 1); /* +1 for trailing '\0'. */
|
|
okwidth += rpart_width;
|
|
}
|
|
|
|
strwidth = BLF_width(fstyle->uifont_id, str, max_len);
|
|
}
|
|
|
|
/* The following assert is meant to catch code changes that break this function's result, but
|
|
* some wriggle room is fine and needed. Just a couple pixels for large sizes and with some
|
|
* settings like "Full" hinting which can move features both left and right a pixel. We could
|
|
* probably reduce this to one pixel if we consolidate text output with length measuring. But
|
|
* our text string lengths include the last character's right-side bearing anyway, so a string
|
|
* can be longer by that amount and still fit visibly in the required space. */
|
|
BLI_assert((strwidth <= (okwidth + 2)) || (okwidth <= 0.0f) ||
|
|
/* TODO: proper handling of non UTF8 strings. */
|
|
(BLI_str_utf8_invalid_byte(str, max_len) != -1));
|
|
UNUSED_VARS_NDEBUG(okwidth);
|
|
|
|
return strwidth;
|
|
}
|
|
|
|
/**
|
|
* Wrapper around UI_text_clip_middle_ex.
|
|
*/
|
|
static void ui_text_clip_middle(const uiFontStyle *fstyle, uiBut *but, const rcti *rect)
|
|
{
|
|
/* No margin for labels! */
|
|
const int border = ELEM(but->type, ButType::Label, ButType::Menu, ButType::Popover) ?
|
|
0 :
|
|
int(UI_TEXT_CLIP_MARGIN + 0.5f);
|
|
const float okwidth = float(max_ii(BLI_rcti_size_x(rect) - border, 0));
|
|
const float minwidth = UI_ICON_SIZE / but->block->aspect * 2.0f;
|
|
|
|
but->ofs = 0;
|
|
char new_drawstr[UI_MAX_DRAW_STR];
|
|
STRNCPY(new_drawstr, but->drawstr.c_str());
|
|
const size_t max_len = sizeof(new_drawstr);
|
|
but->strwidth = UI_text_clip_middle_ex(fstyle, new_drawstr, okwidth, minwidth, max_len, '\0');
|
|
but->drawstr = new_drawstr;
|
|
}
|
|
|
|
/**
|
|
* Like #ui_text_clip_middle(), but protect/preserve at all cost
|
|
* the right part of the string after sep.
|
|
* Useful for strings with shortcuts
|
|
* (like 'AVeryLongFooBarLabelForMenuEntry|Ctrl O' -> 'AVeryLong...MenuEntry|Ctrl O').
|
|
*/
|
|
static void ui_text_clip_middle_protect_right(const uiFontStyle *fstyle,
|
|
uiBut *but,
|
|
const rcti *rect,
|
|
const char rsep)
|
|
{
|
|
/* No margin for labels! */
|
|
const int border = ELEM(but->type, ButType::Label, ButType::Menu, ButType::Popover) ?
|
|
0 :
|
|
int(UI_TEXT_CLIP_MARGIN + 0.5f);
|
|
const float okwidth = float(max_ii(BLI_rcti_size_x(rect) - border, 0));
|
|
const float minwidth = UI_ICON_SIZE / but->block->aspect * 2.0f;
|
|
|
|
but->ofs = 0;
|
|
char new_drawstr[UI_MAX_DRAW_STR];
|
|
STRNCPY(new_drawstr, but->drawstr.c_str());
|
|
const size_t max_len = sizeof(new_drawstr);
|
|
but->strwidth = UI_text_clip_middle_ex(fstyle, new_drawstr, okwidth, minwidth, max_len, rsep);
|
|
but->drawstr = new_drawstr;
|
|
}
|
|
|
|
blender::Vector<blender::StringRef> UI_text_clip_multiline_middle(
|
|
const uiFontStyle *fstyle,
|
|
const char *str,
|
|
char *clipped_str_buf,
|
|
const size_t clipped_str_buf_maxncpy,
|
|
const float max_line_width,
|
|
const int max_lines)
|
|
{
|
|
using namespace blender;
|
|
BLI_assert(max_lines > 0);
|
|
|
|
const Vector<StringRef> lines = BLF_string_wrap(
|
|
fstyle->uifont_id,
|
|
str,
|
|
max_line_width,
|
|
BLFWrapMode(int(BLFWrapMode::Typographical) | int(BLFWrapMode::HardLimit)));
|
|
|
|
if (lines.size() <= max_lines) {
|
|
return lines;
|
|
}
|
|
|
|
Vector<StringRef> clipped_lines;
|
|
clipped_lines.reserve(max_lines);
|
|
|
|
if (max_lines == 1) {
|
|
BLI_strncpy(clipped_str_buf, str, clipped_str_buf_maxncpy);
|
|
|
|
UI_text_clip_middle_ex(
|
|
fstyle, clipped_str_buf, max_line_width, UI_ICON_SIZE, clipped_str_buf_maxncpy, '\0');
|
|
clipped_lines.append(clipped_str_buf);
|
|
return clipped_lines;
|
|
}
|
|
if (max_lines == 2) {
|
|
clipped_lines.append(lines[0]);
|
|
BLI_strncpy(clipped_str_buf, str + lines[0].size(), clipped_str_buf_maxncpy);
|
|
UI_text_clip_middle_ex(fstyle,
|
|
clipped_str_buf,
|
|
max_line_width,
|
|
UI_ICON_SIZE,
|
|
clipped_str_buf_maxncpy,
|
|
'\0',
|
|
false);
|
|
clipped_lines.append(clipped_str_buf);
|
|
return clipped_lines;
|
|
}
|
|
|
|
/* The line in the middle that will get the "..." (rounded upwards, so will use the first line of
|
|
* the second half if the number of lines is even) */
|
|
const int middle_index = max_lines / 2;
|
|
|
|
/* Take the lines until the middle line with the "..." as is. */
|
|
for (int i = 0; i < middle_index; i++) {
|
|
clipped_lines.append(lines[i]);
|
|
}
|
|
|
|
/* Clip the middle of the middle line. */
|
|
{
|
|
BLI_strncpy(clipped_str_buf, lines[middle_index].data(), clipped_str_buf_maxncpy);
|
|
UI_text_clip_middle_ex(fstyle,
|
|
clipped_str_buf,
|
|
max_line_width,
|
|
UI_ICON_SIZE,
|
|
clipped_str_buf_maxncpy,
|
|
'\0',
|
|
false);
|
|
clipped_lines.append(clipped_str_buf);
|
|
}
|
|
|
|
/* All remaining lines should be completely filled, including the last one. So fill lines
|
|
* backwards, and append them to #clipped_lines in the correct order afterwards. */
|
|
if ((middle_index + 1) < max_lines) {
|
|
const char *remaining = lines[middle_index + 1].data();
|
|
size_t remaining_len = strlen(remaining);
|
|
std::list<StringRef> last_lines;
|
|
for (int i = 0; i < max_lines - (middle_index + 1) && remaining_len; i++) {
|
|
size_t offset = BLF_width_to_rstrlen(
|
|
fstyle->uifont_id, remaining, remaining_len, max_line_width, nullptr);
|
|
size_t line_len = remaining_len - offset;
|
|
last_lines.emplace_front(remaining + offset, int64_t(line_len));
|
|
remaining_len = offset;
|
|
}
|
|
|
|
for (StringRef line : last_lines) {
|
|
clipped_lines.append(line);
|
|
}
|
|
}
|
|
|
|
return clipped_lines;
|
|
}
|
|
|
|
/**
|
|
* Cut off the text, taking into account the cursor location (text display while editing).
|
|
*/
|
|
static void ui_text_clip_cursor(const uiFontStyle *fstyle, uiBut *but, const rcti *rect)
|
|
{
|
|
const int border = int(UI_TEXT_CLIP_MARGIN + 0.5f);
|
|
const int okwidth = max_ii(BLI_rcti_size_x(rect) - border, 0);
|
|
|
|
BLI_assert(but->editstr && but->pos >= 0);
|
|
|
|
/* need to set this first */
|
|
UI_fontstyle_set(fstyle);
|
|
|
|
/* define ofs dynamically */
|
|
but->ofs = std::min(but->ofs, but->pos);
|
|
|
|
if (BLF_width(fstyle->uifont_id, but->editstr, INT_MAX) <= okwidth) {
|
|
but->ofs = 0;
|
|
}
|
|
|
|
but->strwidth = BLF_width(fstyle->uifont_id, but->editstr + but->ofs, INT_MAX);
|
|
|
|
if (but->strwidth > okwidth) {
|
|
const int editstr_len = strlen(but->editstr);
|
|
int len = editstr_len;
|
|
|
|
while (but->strwidth > okwidth) {
|
|
float width;
|
|
|
|
/* string position of cursor */
|
|
width = BLF_width(fstyle->uifont_id, but->editstr + but->ofs, (but->pos - but->ofs));
|
|
|
|
/* if cursor is at 20 pixels of right side button we clip left */
|
|
if (width > okwidth - 20) {
|
|
ui_text_clip_give_next_off(but, but->editstr, but->editstr + editstr_len);
|
|
}
|
|
else {
|
|
/* shift string to the left */
|
|
if (width < 20 && but->ofs > 0) {
|
|
ui_text_clip_give_prev_off(but, but->editstr);
|
|
}
|
|
len -= BLI_str_utf8_size_safe(
|
|
BLI_str_find_prev_char_utf8(but->editstr + len, but->editstr));
|
|
}
|
|
|
|
but->strwidth = BLF_width(fstyle->uifont_id, but->editstr + but->ofs, len - but->ofs);
|
|
|
|
if (but->strwidth < 10) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cut off the end of text to fit into the width of \a rect.
|
|
*
|
|
* \note deals with ': ' especially for number buttons
|
|
*/
|
|
static void ui_text_clip_right_label(const uiFontStyle *fstyle, uiBut *but, const rcti *rect)
|
|
{
|
|
const int border = UI_TEXT_CLIP_MARGIN + 1;
|
|
const int okwidth = max_ii(BLI_rcti_size_x(rect) - border, 0);
|
|
|
|
int drawstr_len = but->drawstr.size();
|
|
char new_drawstr[UI_MAX_DRAW_STR];
|
|
STRNCPY(new_drawstr, but->drawstr.c_str());
|
|
|
|
const char *cpend = new_drawstr + drawstr_len;
|
|
|
|
/* need to set this first */
|
|
UI_fontstyle_set(fstyle);
|
|
|
|
but->strwidth = BLF_width(fstyle->uifont_id, new_drawstr, drawstr_len);
|
|
|
|
/* The string already fits, so do nothing. */
|
|
if (but->strwidth <= okwidth) {
|
|
return;
|
|
}
|
|
|
|
const char sep[] = BLI_STR_UTF8_HORIZONTAL_ELLIPSIS;
|
|
const int sep_len = sizeof(sep) - 1;
|
|
const float sep_strwidth = BLF_width(fstyle->uifont_id, sep, sep_len + 1);
|
|
|
|
/* Assume the string will have an ellipsis for initial tests. */
|
|
but->strwidth += sep_strwidth;
|
|
|
|
but->ofs = 0;
|
|
|
|
/* First shorten number-buttons eg,
|
|
* Translucency: 0.000
|
|
* becomes
|
|
* Trans: 0.000
|
|
*/
|
|
|
|
/* find the space after ':' separator */
|
|
char *cpoin = strrchr(new_drawstr, ':');
|
|
|
|
if (cpoin && (cpoin < cpend - 2)) {
|
|
char *cp2 = cpoin;
|
|
|
|
/* chop off the leading text, starting from the right */
|
|
while (but->strwidth > okwidth && cp2 > new_drawstr) {
|
|
const char *prev_utf8 = BLI_str_find_prev_char_utf8(cp2, new_drawstr);
|
|
const int bytes = cp2 - prev_utf8;
|
|
|
|
/* shift the text after and including cp2 back by 1 char,
|
|
* +1 to include null terminator */
|
|
memmove(cp2 - bytes, cp2, drawstr_len + 1);
|
|
cp2 -= bytes;
|
|
|
|
drawstr_len -= bytes;
|
|
|
|
but->strwidth = BLF_width(fstyle->uifont_id,
|
|
new_drawstr + but->ofs,
|
|
sizeof(new_drawstr) - but->ofs) +
|
|
sep_strwidth;
|
|
if (but->strwidth < sep_strwidth) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* after the leading text is gone, chop off the : and following space, with ofs */
|
|
while ((but->strwidth > okwidth) && (but->ofs < 2)) {
|
|
ui_text_clip_give_next_off(but, new_drawstr, new_drawstr + drawstr_len);
|
|
but->strwidth = BLF_width(
|
|
fstyle->uifont_id, new_drawstr + but->ofs, sizeof(new_drawstr) - but->ofs);
|
|
if (but->strwidth < 10) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now just remove trailing chars */
|
|
/* once the label's gone, chop off the least significant digits */
|
|
if (but->strwidth > okwidth) {
|
|
float strwidth;
|
|
drawstr_len = BLF_width_to_strlen(fstyle->uifont_id,
|
|
new_drawstr + but->ofs,
|
|
drawstr_len - but->ofs,
|
|
okwidth,
|
|
&strwidth) +
|
|
but->ofs;
|
|
but->strwidth = strwidth;
|
|
new_drawstr[drawstr_len] = 0;
|
|
}
|
|
|
|
cpoin = strrchr(new_drawstr, ':');
|
|
if (cpoin && (cpoin - new_drawstr > 0) && (drawstr_len < (sizeof(new_drawstr) - sep_len))) {
|
|
/* We shortened the string and still have a colon, so insert ellipsis. */
|
|
memmove(cpoin + sep_len, cpoin, cpend - cpoin);
|
|
memcpy(cpoin, sep, sep_len);
|
|
but->strwidth = BLF_width(
|
|
fstyle->uifont_id, new_drawstr + but->ofs, sizeof(new_drawstr) - but->ofs);
|
|
}
|
|
|
|
but->drawstr = new_drawstr;
|
|
}
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
static void widget_draw_text_ime_underline(const uiFontStyle *fstyle,
|
|
const uiWidgetColors *wcol,
|
|
const uiBut *but,
|
|
const rcti *rect,
|
|
const wmIMEData *ime_data,
|
|
const char *drawstr)
|
|
{
|
|
int ofs_x, width;
|
|
int rect_x = BLI_rcti_size_x(rect);
|
|
int sel_start = ime_data->sel_start, sel_end = ime_data->sel_end;
|
|
float fcol[4];
|
|
|
|
if (drawstr[0] != 0) {
|
|
if (but->pos >= but->ofs) {
|
|
ofs_x = BLF_width(fstyle->uifont_id, drawstr + but->ofs, but->pos - but->ofs);
|
|
}
|
|
else {
|
|
ofs_x = 0;
|
|
}
|
|
|
|
width = BLF_width(
|
|
fstyle->uifont_id, drawstr + but->ofs, ime_data->composite.size() + but->pos - but->ofs);
|
|
|
|
rgba_uchar_to_float(fcol, wcol->text);
|
|
UI_draw_text_underline(rect->xmin + ofs_x,
|
|
rect->ymin + 6 * U.pixelsize,
|
|
min_ii(width, rect_x - 2) - ofs_x,
|
|
1,
|
|
fcol);
|
|
|
|
/* draw the thick line */
|
|
if (sel_start != -1 && sel_end != -1) {
|
|
sel_end -= sel_start;
|
|
sel_start += but->pos;
|
|
|
|
if (sel_start >= but->ofs) {
|
|
ofs_x = BLF_width(fstyle->uifont_id, drawstr + but->ofs, sel_start - but->ofs);
|
|
}
|
|
else {
|
|
ofs_x = 0;
|
|
}
|
|
|
|
width = BLF_width(fstyle->uifont_id, drawstr + but->ofs, sel_end + sel_start - but->ofs);
|
|
|
|
UI_draw_text_underline(rect->xmin + ofs_x,
|
|
rect->ymin + 6 * U.pixelsize,
|
|
min_ii(width, rect_x - 2) - ofs_x,
|
|
2,
|
|
fcol);
|
|
}
|
|
}
|
|
}
|
|
#endif /* WITH_INPUT_IME */
|
|
|
|
static void widget_draw_text(const uiFontStyle *fstyle,
|
|
const uiWidgetColors *wcol,
|
|
uiBut *but,
|
|
rcti *rect)
|
|
{
|
|
int drawstr_left_len = UI_MAX_DRAW_STR;
|
|
const char *drawstr = but->drawstr.c_str();
|
|
const char *drawstr_right = nullptr;
|
|
bool use_right_only = false;
|
|
const char *indeterminate_str = UI_VALUE_INDETERMINATE_CHAR;
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
const wmIMEData *ime_data;
|
|
#endif
|
|
|
|
UI_fontstyle_set(fstyle);
|
|
|
|
eFontStyle_Align align;
|
|
if (but->editstr || (but->drawflag & UI_BUT_TEXT_LEFT)) {
|
|
align = UI_STYLE_TEXT_LEFT;
|
|
}
|
|
else if (but->drawflag & UI_BUT_TEXT_RIGHT) {
|
|
align = UI_STYLE_TEXT_RIGHT;
|
|
}
|
|
else {
|
|
align = UI_STYLE_TEXT_CENTER;
|
|
}
|
|
|
|
/* Special case: when we're entering text for multiple buttons,
|
|
* don't draw the text for any of the multi-editing buttons */
|
|
if (UNLIKELY(but->flag & UI_BUT_DRAG_MULTI)) {
|
|
uiBut *but_edit = ui_but_drag_multi_edit_get(but);
|
|
if (but_edit) {
|
|
drawstr = but_edit->editstr;
|
|
align = UI_STYLE_TEXT_LEFT;
|
|
}
|
|
}
|
|
else {
|
|
if (but->editstr) {
|
|
/* The maximum length isn't used in this case,
|
|
* we rely on string being null terminated. */
|
|
drawstr_left_len = INT_MAX;
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
/* FIXME: IME is modifying `const char *drawstr`! */
|
|
ime_data = ui_but_ime_data_get(but);
|
|
|
|
if (ime_data && ime_data->composite.size()) {
|
|
/* insert composite string into cursor pos */
|
|
char tmp_drawstr[UI_MAX_DRAW_STR];
|
|
STRNCPY(tmp_drawstr, drawstr);
|
|
BLI_snprintf(tmp_drawstr,
|
|
sizeof(tmp_drawstr),
|
|
"%.*s%s%s",
|
|
but->pos,
|
|
but->editstr,
|
|
ime_data->composite.c_str(),
|
|
but->editstr + but->pos);
|
|
but->drawstr = tmp_drawstr;
|
|
drawstr = but->drawstr.c_str();
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
drawstr = but->editstr;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If not editing and indeterminate, show dash. */
|
|
if (but->drawflag & UI_BUT_INDETERMINATE && !but->editstr &&
|
|
ELEM(but->type,
|
|
ButType::Menu,
|
|
ButType::Num,
|
|
ButType::NumSlider,
|
|
ButType::Text,
|
|
ButType::SearchMenu))
|
|
{
|
|
drawstr = indeterminate_str;
|
|
drawstr_left_len = strlen(drawstr);
|
|
align = UI_STYLE_TEXT_CENTER;
|
|
}
|
|
|
|
/* text button selection, cursor, composite underline */
|
|
if (but->editstr && but->pos != -1) {
|
|
int but_pos_ofs;
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
bool ime_reposition_window = false;
|
|
int ime_win_x, ime_win_y;
|
|
#endif
|
|
|
|
/* text button selection */
|
|
if ((but->selend - but->selsta) != 0 && drawstr[0] != 0) {
|
|
/* We are drawing on top of widget bases. Flush cache. */
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
immUniformColor4ubv(wcol->item);
|
|
const auto boxes = BLF_str_selection_boxes(
|
|
fstyle->uifont_id,
|
|
drawstr + but->ofs,
|
|
strlen(drawstr + but->ofs),
|
|
(but->selsta >= but->ofs) ? but->selsta - but->ofs : 0,
|
|
but->selend - std::max(but->ofs, but->selsta));
|
|
for (auto bounds : boxes) {
|
|
immRectf(pos,
|
|
rect->xmin + bounds.min,
|
|
rect->ymin + U.pixelsize,
|
|
std::min(rect->xmin + bounds.max, rect->xmax - 2),
|
|
rect->ymax - U.pixelsize);
|
|
}
|
|
immUnbindProgram();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
/* IME candidate window uses selection position. */
|
|
if (!ime_reposition_window && boxes.size() > 0) {
|
|
ime_reposition_window = true;
|
|
ime_win_x = rect->xmin + boxes[0].min;
|
|
ime_win_y = rect->ymin + U.pixelsize;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* Text cursor position. */
|
|
but_pos_ofs = but->pos;
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
/* If is IME compositing, move the cursor. */
|
|
if (ime_data && ime_data->composite.size() && ime_data->cursor_pos != -1) {
|
|
but_pos_ofs += ime_data->cursor_pos;
|
|
}
|
|
#endif
|
|
|
|
/* Draw text cursor (caret). */
|
|
if (but->pos >= but->ofs) {
|
|
|
|
int t = BLF_str_offset_to_cursor(fstyle->uifont_id,
|
|
drawstr + but->ofs,
|
|
UI_MAX_DRAW_STR,
|
|
but_pos_ofs - but->ofs,
|
|
max_ii(1, int(U.pixelsize * 2)));
|
|
|
|
/* We are drawing on top of widget bases. Flush cache. */
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
immUniformThemeColor(TH_WIDGET_TEXT_CURSOR);
|
|
|
|
/* draw cursor */
|
|
immRectf(pos,
|
|
rect->xmin + t,
|
|
rect->ymin + U.pixelsize,
|
|
rect->xmin + t + int(2.0f * U.pixelsize),
|
|
rect->ymax - U.pixelsize);
|
|
|
|
immUnbindProgram();
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
/* IME candidate window uses cursor position. */
|
|
if (!ime_reposition_window) {
|
|
ime_reposition_window = true;
|
|
ime_win_x = rect->xmin + t + 5;
|
|
ime_win_y = rect->ymin + 3;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef WITH_INPUT_IME
|
|
/* IME cursor following. */
|
|
if (ime_reposition_window) {
|
|
ui_but_ime_reposition(but, ime_win_x, ime_win_y, false);
|
|
}
|
|
if (ime_data && ime_data->composite.size()) {
|
|
/* Composite underline. */
|
|
widget_draw_text_ime_underline(fstyle, wcol, but, rect, ime_data, drawstr);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if 0
|
|
ui_rasterpos_safe(x, y, but->aspect);
|
|
transopts = ui_translate_buttons();
|
|
#endif
|
|
|
|
bool use_drawstr_right_as_hint = false;
|
|
|
|
/* cut string in 2 parts - only for menu entries */
|
|
if (but->flag & UI_BUT_HAS_SEP_CHAR && (but->editstr == nullptr)) {
|
|
drawstr_right = strrchr(drawstr, UI_SEP_CHAR);
|
|
if (drawstr_right) {
|
|
use_drawstr_right_as_hint = true;
|
|
drawstr_left_len = (drawstr_right - drawstr);
|
|
drawstr_right++;
|
|
}
|
|
}
|
|
|
|
#ifdef USE_NUMBUTS_LR_ALIGN
|
|
if (!drawstr_right && (but->drawflag & UI_BUT_TEXT_LEFT) &&
|
|
ELEM(but->type, ButType::Num, ButType::NumSlider) &&
|
|
/* if we're editing or multi-drag (fake editing), then use left alignment */
|
|
(but->editstr == nullptr) && (drawstr == but->drawstr))
|
|
{
|
|
drawstr_right = strrchr(drawstr + but->ofs, ':');
|
|
if (drawstr_right) {
|
|
drawstr_right++;
|
|
drawstr_left_len = (drawstr_right - drawstr - 1);
|
|
|
|
while (*drawstr_right == ' ') {
|
|
drawstr_right++;
|
|
}
|
|
}
|
|
else {
|
|
/* no prefix, even so use only cpoin */
|
|
drawstr_right = drawstr + but->ofs;
|
|
use_right_only = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!use_right_only) {
|
|
/* for underline drawing */
|
|
int font_xofs, font_yofs;
|
|
|
|
int drawlen = (drawstr_left_len == INT_MAX) ? strlen(drawstr + but->ofs) :
|
|
(drawstr_left_len - but->ofs);
|
|
|
|
if (drawlen > 0) {
|
|
uiFontStyleDraw_Params params{};
|
|
params.align = align;
|
|
UI_fontstyle_draw_ex(fstyle,
|
|
rect,
|
|
drawstr + but->ofs,
|
|
drawlen,
|
|
wcol->text,
|
|
¶ms,
|
|
&font_xofs,
|
|
&font_yofs,
|
|
nullptr);
|
|
|
|
if (but->menu_key != '\0') {
|
|
const char *drawstr_ofs = drawstr + but->ofs;
|
|
int ul_index = -1;
|
|
|
|
{
|
|
/* Find upper case, fall back to lower case. */
|
|
const char *drawstr_end = drawstr_ofs + drawlen;
|
|
const char keys[] = {char(but->menu_key - 32), but->menu_key};
|
|
for (int i = 0; i < ARRAY_SIZE(keys); i++) {
|
|
const char *drawstr_menu = strchr(drawstr_ofs, keys[i]);
|
|
if (drawstr_menu != nullptr && drawstr_menu < drawstr_end) {
|
|
ul_index = int(drawstr_menu - drawstr_ofs);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ul_index != -1) {
|
|
rcti bounds;
|
|
if (BLF_str_offset_to_glyph_bounds(fstyle->uifont_id, drawstr_ofs, ul_index, &bounds) &&
|
|
!BLI_rcti_is_empty(&bounds))
|
|
{
|
|
int ul_width = round_fl_to_int(BLF_width(fstyle->uifont_id, "_", 2));
|
|
int pos_x = rect->xmin + font_xofs + bounds.xmin +
|
|
(bounds.xmax - bounds.xmin - ul_width) / 2;
|
|
int pos_y = rect->ymin + font_yofs + bounds.ymin - U.pixelsize;
|
|
/* Use text output because direct drawing doesn't always work. See #89246. */
|
|
BLF_position(fstyle->uifont_id, float(pos_x), pos_y, 0.0f);
|
|
BLF_color4ubv(fstyle->uifont_id, wcol->text);
|
|
BLF_draw(fstyle->uifont_id, "_", 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Show placeholder text if the input is empty and not being edited. */
|
|
if (!drawstr[0] && !but->editstr && ELEM(but->type, ButType::Text, ButType::SearchMenu)) {
|
|
const char *placeholder = ui_but_placeholder_get(but);
|
|
if (placeholder && placeholder[0]) {
|
|
uiFontStyleDraw_Params params{};
|
|
params.align = align;
|
|
uiFontStyle style = *fstyle;
|
|
style.shadow = 0;
|
|
uchar col[4];
|
|
copy_v4_v4_uchar(col, wcol->text);
|
|
col[3] *= 0.33f;
|
|
UI_fontstyle_draw_ex(
|
|
&style, rect, placeholder, strlen(placeholder), col, ¶ms, nullptr, nullptr, nullptr);
|
|
}
|
|
}
|
|
|
|
/* part text right aligned */
|
|
if (drawstr_right) {
|
|
uchar col[4];
|
|
copy_v4_v4_uchar(col, wcol->text);
|
|
if (use_drawstr_right_as_hint) {
|
|
col[3] *= 0.5f;
|
|
}
|
|
|
|
rect->xmax -= UI_TEXT_CLIP_MARGIN;
|
|
uiFontStyleDraw_Params params{};
|
|
params.align = UI_STYLE_TEXT_RIGHT;
|
|
UI_fontstyle_draw(fstyle, rect, drawstr_right, UI_MAX_DRAW_STR, col, ¶ms);
|
|
}
|
|
}
|
|
|
|
static void widget_draw_extra_icons(const uiWidgetColors *wcol,
|
|
uiBut *but,
|
|
rcti *rect,
|
|
float alpha)
|
|
{
|
|
const float icon_size = ICON_SIZE_FROM_BUTRECT(rect);
|
|
|
|
/* Offset of icons from the right edge. Keep in sync
|
|
* with 'ui_but_extra_operator_icon_mouse_over_get'. */
|
|
if (!BLI_listbase_is_empty(&but->extra_op_icons)) {
|
|
/* Eyeballed. */
|
|
rect->xmax -= 0.2 * icon_size;
|
|
}
|
|
|
|
/* Inverse order, from right to left. */
|
|
LISTBASE_FOREACH_BACKWARD (uiButExtraOpIcon *, op_icon, &but->extra_op_icons) {
|
|
rcti temp = *rect;
|
|
float alpha_this = alpha;
|
|
|
|
temp.xmin = temp.xmax - icon_size;
|
|
|
|
if (op_icon->disabled) {
|
|
alpha_this *= 0.4f;
|
|
}
|
|
else if (!op_icon->highlighted) {
|
|
alpha_this *= 0.75f;
|
|
}
|
|
|
|
/* Draw the icon at the center, and restore the flags after. */
|
|
const int old_drawflags = but->drawflag;
|
|
UI_but_drawflag_disable(but, UI_BUT_ICON_LEFT);
|
|
widget_draw_icon(but, op_icon->icon, alpha_this, &temp, wcol->text);
|
|
but->drawflag = old_drawflags;
|
|
|
|
rect->xmax -= icon_size;
|
|
}
|
|
}
|
|
|
|
static void widget_draw_node_link_socket(const uiWidgetColors *wcol,
|
|
const rcti *rect,
|
|
uiBut *but,
|
|
float alpha)
|
|
{
|
|
/* Node socket pointer can be passed as custom_data, see UI_but_node_link_set(). */
|
|
if (but->custom_data) {
|
|
const float scale = 0.9f / but->block->aspect;
|
|
|
|
float col[4];
|
|
rgba_uchar_to_float(col, but->col);
|
|
col[3] *= alpha;
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
blender::ed::space_node::node_socket_draw(
|
|
static_cast<bNodeSocket *>(but->custom_data), rect, col, scale);
|
|
}
|
|
else {
|
|
widget_draw_icon(but, ICON_LAYER_USED, alpha, rect, wcol->text);
|
|
}
|
|
}
|
|
|
|
/* draws text and icons for buttons */
|
|
static void widget_draw_text_icon(const uiFontStyle *fstyle,
|
|
const uiWidgetColors *wcol,
|
|
uiBut *but,
|
|
rcti *rect)
|
|
{
|
|
const bool show_menu_icon = ui_but_draw_menu_icon(but);
|
|
const float alpha = float(wcol->text[3]) / 255.0f;
|
|
char password_str[UI_MAX_DRAW_STR];
|
|
bool no_text_padding = but->drawflag & UI_BUT_NO_TEXT_PADDING;
|
|
|
|
ui_but_text_password_hide(password_str, but, false);
|
|
|
|
/* check for button text label */
|
|
if (ELEM(but->type, ButType::Menu, ButType::Popover) && (but->flag & UI_BUT_NODE_LINK)) {
|
|
rcti temp = *rect;
|
|
const int size = BLI_rcti_size_y(rect) + 1; /* Not the icon size! */
|
|
|
|
if (but->drawflag & UI_BUT_ICON_LEFT) {
|
|
temp.xmax = rect->xmin + size;
|
|
rect->xmin = temp.xmax;
|
|
/* Further padding looks off. */
|
|
no_text_padding = true;
|
|
}
|
|
else {
|
|
temp.xmin = rect->xmax - size;
|
|
rect->xmax = temp.xmin;
|
|
}
|
|
|
|
widget_draw_node_link_socket(wcol, &temp, but, alpha);
|
|
}
|
|
|
|
const uchar *icon_color = (but->col[3] != 0) ? but->col : wcol->text;
|
|
|
|
/* If there's an icon too (made with uiDefIconTextBut) then draw the icon
|
|
* and offset the text label to accommodate it */
|
|
|
|
/* Big previews with optional text label below */
|
|
if (but->flag & UI_BUT_ICON_PREVIEW && ui_block_is_menu(but->block)) {
|
|
const BIFIconID icon = ui_but_icon(but);
|
|
int icon_size = BLI_rcti_size_y(rect);
|
|
int text_size = 0;
|
|
|
|
/* This is a bit brittle, but avoids adding an 'UI_BUT_HAS_LABEL' flag to but... */
|
|
if (icon_size > BLI_rcti_size_x(rect)) {
|
|
/* button is not square, it has extra height for label */
|
|
text_size = UI_UNIT_Y;
|
|
icon_size -= text_size;
|
|
}
|
|
|
|
/* draw icon in rect above the space reserved for the label */
|
|
rect->ymin += text_size;
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
widget_draw_preview_icon(icon,
|
|
alpha,
|
|
but->block->aspect,
|
|
!(but->drawflag & UI_BUT_NO_PREVIEW_PADDING),
|
|
rect,
|
|
icon_color);
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
/* offset rect to draw label in */
|
|
rect->ymin -= text_size;
|
|
rect->ymax -= icon_size;
|
|
|
|
/* vertically centering text */
|
|
rect->ymin += UI_UNIT_Y / 2;
|
|
}
|
|
/* Icons on the left with optional text label on the right */
|
|
else if (but->flag & UI_HAS_ICON || show_menu_icon) {
|
|
const bool is_tool = ((but->icon != ICON_NONE) & UI_but_is_tool(but));
|
|
|
|
/* XXX add way to draw icons at a different size!
|
|
* Use small icons for popup. */
|
|
#ifdef USE_UI_TOOLBAR_HACK
|
|
const float aspect_orig = but->block->aspect;
|
|
if (is_tool && (but->block->flag & UI_BLOCK_POPOVER)) {
|
|
but->block->aspect *= 2.0f;
|
|
}
|
|
#endif
|
|
|
|
const BIFIconID icon = ui_but_icon(but);
|
|
const int icon_size_init = is_tool ? ICON_DEFAULT_HEIGHT_TOOLBAR : ICON_DEFAULT_HEIGHT;
|
|
const float icon_size = icon_size_init / (but->block->aspect * UI_INV_SCALE_FAC);
|
|
const float icon_padding = 2 * UI_SCALE_FAC;
|
|
|
|
#ifdef USE_UI_TOOLBAR_HACK
|
|
if (is_tool) {
|
|
/* pass (even if its a menu toolbar) */
|
|
but->drawflag |= UI_BUT_TEXT_LEFT;
|
|
but->drawflag |= UI_BUT_ICON_LEFT;
|
|
}
|
|
#endif
|
|
|
|
/* menu item - add some more padding so menus don't feel cramped. it must
|
|
* be part of the button so that this area is still clickable */
|
|
if (is_tool) {
|
|
/* pass (even if its a menu toolbar) */
|
|
}
|
|
else if (ui_block_is_pie_menu(but->block)) {
|
|
if (but->emboss == blender::ui::EmbossType::PieMenu) {
|
|
rect->xmin += 0.3f * U.widget_unit;
|
|
}
|
|
}
|
|
/* Menu items, but only if they are not icon-only (rare). */
|
|
else if (ui_block_is_menu(but->block) && but->drawstr[0]) {
|
|
rect->xmin += 0.2f * U.widget_unit;
|
|
}
|
|
|
|
/* By default icon is the color of text, but can optionally override with but->col. */
|
|
widget_draw_icon(but, icon, alpha, rect, icon_color);
|
|
|
|
if (show_menu_icon) {
|
|
BLI_assert(but->block->content_hints & UI_BLOCK_CONTAINS_SUBMENU_BUT);
|
|
widget_draw_submenu_tria(but, rect, wcol);
|
|
}
|
|
|
|
#ifdef USE_UI_TOOLBAR_HACK
|
|
but->block->aspect = aspect_orig;
|
|
#endif
|
|
|
|
rect->xmin += round_fl_to_int(icon_size + icon_padding);
|
|
}
|
|
|
|
if (!no_text_padding) {
|
|
const int text_padding = round_fl_to_int((UI_TEXT_MARGIN_X * U.widget_unit) /
|
|
but->block->aspect);
|
|
if (but->editstr) {
|
|
rect->xmin += text_padding;
|
|
}
|
|
else if (but->flag & UI_BUT_DRAG_MULTI) {
|
|
const bool text_is_edited = ui_but_drag_multi_edit_get(but) != nullptr;
|
|
if (text_is_edited || (but->drawflag & UI_BUT_TEXT_LEFT)) {
|
|
rect->xmin += text_padding;
|
|
}
|
|
}
|
|
else if (but->drawflag & UI_BUT_TEXT_LEFT) {
|
|
rect->xmin += text_padding;
|
|
}
|
|
else if (but->drawflag & UI_BUT_TEXT_RIGHT) {
|
|
rect->xmax -= text_padding;
|
|
}
|
|
}
|
|
else {
|
|
/* In case a separate text label and some other button are placed under each other,
|
|
* and the outline of the button does not contrast with the background.
|
|
* Add an offset (thickness of the outline) so that the text does not stick out visually. */
|
|
if (but->drawflag & UI_BUT_TEXT_LEFT) {
|
|
rect->xmin += U.pixelsize;
|
|
}
|
|
else if (but->drawflag & UI_BUT_TEXT_RIGHT) {
|
|
rect->xmax -= U.pixelsize;
|
|
}
|
|
}
|
|
|
|
/* Menu contains sub-menu items with triangle icon on their right. Shortcut
|
|
* strings should be drawn with some padding to the right then. */
|
|
if (ui_block_is_menu(but->block) && (but->block->content_hints & UI_BLOCK_CONTAINS_SUBMENU_BUT))
|
|
{
|
|
rect->xmax -= UI_MENU_SUBMENU_PADDING;
|
|
}
|
|
|
|
/* extra icons, e.g. 'x' icon to clear text or icon for eyedropper */
|
|
widget_draw_extra_icons(wcol, but, rect, alpha);
|
|
|
|
/* clip but->drawstr to fit in available space */
|
|
if (but->editstr && but->pos >= 0) {
|
|
ui_text_clip_cursor(fstyle, but, rect);
|
|
}
|
|
else if (but->drawstr[0] == '\0') {
|
|
/* bypass text clipping on icon buttons */
|
|
but->ofs = 0;
|
|
but->strwidth = 0;
|
|
}
|
|
else if (ELEM(but->type, ButType::Num, ButType::NumSlider)) {
|
|
ui_text_clip_right_label(fstyle, but, rect);
|
|
}
|
|
else if (but->flag & UI_BUT_HAS_SEP_CHAR) {
|
|
/* Clip middle, but protect in all case right part containing the shortcut, if any. */
|
|
ui_text_clip_middle_protect_right(fstyle, but, rect, UI_SEP_CHAR);
|
|
}
|
|
else {
|
|
ui_text_clip_middle(fstyle, but, rect);
|
|
}
|
|
|
|
/* Always draw text for text-button cursor. */
|
|
widget_draw_text(fstyle, wcol, but, rect);
|
|
|
|
ui_but_text_password_hide(password_str, but, true);
|
|
|
|
/* if a widget uses font shadow it has to be deactivated now */
|
|
BLF_disable(fstyle->uifont_id, BLF_SHADOW);
|
|
}
|
|
|
|
#undef UI_TEXT_CLIP_MARGIN
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget State Management
|
|
*
|
|
* Adjust widget display based on animated, driven, overridden ... etc.
|
|
* \{ */
|
|
|
|
/* put all widget colors on half alpha, use local storage */
|
|
static void ui_widget_color_disabled(uiWidgetType *wt, const uiWidgetStateInfo *state)
|
|
{
|
|
static uiWidgetColors wcol_theme_s;
|
|
|
|
wcol_theme_s = *wt->wcol_theme;
|
|
|
|
const float factor = widget_alpha_factor(state);
|
|
|
|
wcol_theme_s.outline[3] *= factor;
|
|
wcol_theme_s.outline_sel[3] *= factor;
|
|
wcol_theme_s.inner[3] *= factor;
|
|
wcol_theme_s.inner_sel[3] *= factor;
|
|
wcol_theme_s.item[3] *= factor;
|
|
wcol_theme_s.text[3] *= factor;
|
|
wcol_theme_s.text_sel[3] *= factor;
|
|
|
|
wt->wcol_theme = &wcol_theme_s;
|
|
}
|
|
|
|
static void widget_active_color(uiWidgetColors *wcol)
|
|
{
|
|
const bool dark = (srgb_to_grayscale_byte(wcol->text) > srgb_to_grayscale_byte(wcol->inner));
|
|
color_mul_hsl_v3(wcol->inner, 1.0f, 1.15f, dark ? 1.2f : 1.1f);
|
|
color_blend_v4_v4v4(wcol->outline, wcol->outline, wcol->outline_sel, 0.5f);
|
|
color_mul_hsl_v3(wcol->outline_sel, 1.0f, 1.15f, 1.15f);
|
|
color_mul_hsl_v3(wcol->text, 1.0f, 1.15f, dark ? 1.25f : 0.8f);
|
|
}
|
|
|
|
static const uchar *widget_color_blend_from_flags(const uiWidgetStateColors *wcol_state,
|
|
const uiWidgetStateInfo *state,
|
|
const blender::ui::EmbossType emboss)
|
|
{
|
|
/* Explicitly require #blender::ui::EmbossType::NoneOrStatus for color blending with no emboss.
|
|
*/
|
|
if (emboss == blender::ui::EmbossType::None) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (state->but_drawflag & UI_BUT_ANIMATED_CHANGED) {
|
|
return wcol_state->inner_changed_sel;
|
|
}
|
|
if (state->but_flag & UI_BUT_ANIMATED_KEY) {
|
|
return wcol_state->inner_key_sel;
|
|
}
|
|
if (state->but_flag & UI_BUT_ANIMATED) {
|
|
return wcol_state->inner_anim_sel;
|
|
}
|
|
if (state->but_flag & UI_BUT_DRIVEN) {
|
|
return wcol_state->inner_driven_sel;
|
|
}
|
|
if (state->but_flag & UI_BUT_OVERRIDDEN) {
|
|
return wcol_state->inner_overridden_sel;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/* copy colors from theme, and set changes in it based on state */
|
|
static void widget_state(uiWidgetType *wt,
|
|
const uiWidgetStateInfo *state,
|
|
blender::ui::EmbossType emboss)
|
|
{
|
|
uiWidgetStateColors *wcol_state = wt->wcol_state;
|
|
|
|
if (state->but_flag & UI_BUT_LIST_ITEM) {
|
|
/* Override default widget's colors. */
|
|
bTheme *btheme = UI_GetTheme();
|
|
wt->wcol_theme = &btheme->tui.wcol_list_item;
|
|
|
|
if (state->but_flag & (UI_BUT_DISABLED | UI_BUT_INACTIVE | UI_SEARCH_FILTER_NO_MATCH)) {
|
|
ui_widget_color_disabled(wt, state);
|
|
}
|
|
}
|
|
|
|
wt->wcol = *(wt->wcol_theme);
|
|
|
|
const uchar *color_blend = widget_color_blend_from_flags(wcol_state, state, emboss);
|
|
|
|
if (state->but_flag & UI_SELECT) {
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.inner_sel);
|
|
copy_v4_v4_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
if (color_blend != nullptr) {
|
|
color_blend_v3_v3(wt->wcol.inner, color_blend, wcol_state->blend);
|
|
}
|
|
|
|
copy_v3_v3_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
|
|
std::swap(wt->wcol.shadetop, wt->wcol.shadedown);
|
|
}
|
|
else {
|
|
if (state->but_flag & UI_BUT_ACTIVE_DEFAULT) {
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.inner_sel);
|
|
copy_v4_v4_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
copy_v4_v4_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
}
|
|
if (color_blend != nullptr) {
|
|
color_blend_v3_v3(wt->wcol.inner, color_blend, wcol_state->blend);
|
|
}
|
|
|
|
/* Add "hover" highlight. Ideally this could apply in all cases,
|
|
* even if UI_SELECT. But currently this causes some flickering
|
|
* as buttons can be created and updated without respect to mouse
|
|
* position and so can draw without UI_HOVER set. See D6503. */
|
|
if (state->but_flag & UI_HOVER) {
|
|
widget_active_color(&wt->wcol);
|
|
}
|
|
}
|
|
|
|
if (state->but_flag & UI_BUT_REDALERT) {
|
|
if (wt->draw && emboss != blender::ui::EmbossType::None) {
|
|
UI_GetThemeColor3ubv(TH_REDALERT, wt->wcol.inner);
|
|
}
|
|
else {
|
|
uchar red[4];
|
|
UI_GetThemeColor3ubv(TH_REDALERT, red);
|
|
color_mul_hsl_v3(red, 1.0f, 1.5f, 1.5f);
|
|
color_blend_v3_v3(wt->wcol.text, red, 0.5f);
|
|
}
|
|
}
|
|
|
|
if (state->but_flag & UI_BUT_DRAG_MULTI) {
|
|
/* the button isn't SELECT but we're editing this so draw with sel color */
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.inner_sel);
|
|
copy_v4_v4_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
std::swap(wt->wcol.shadetop, wt->wcol.shadedown);
|
|
color_blend_v3_v3(wt->wcol.text, wt->wcol.text_sel, 0.85f);
|
|
}
|
|
|
|
if (state->but_flag & UI_BUT_NODE_ACTIVE) {
|
|
const uchar blue[4] = {86, 128, 194};
|
|
color_blend_v3_v3(wt->wcol.inner, blue, 0.3f);
|
|
}
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget Corner Radius Calculation
|
|
*
|
|
* A lot of places of the UI like the Node Editor or panels are zoomable. In most cases we can
|
|
* get the zoom factor from the aspect, but in some cases like popups we need to fall back to
|
|
* using the size of the element. The latter method relies on the element always being the same
|
|
* size.
|
|
* \{ */
|
|
|
|
static float widget_radius_from_zoom(const float zoom, const uiWidgetColors *wcol)
|
|
{
|
|
return wcol->roundness * U.widget_unit * zoom;
|
|
}
|
|
|
|
static float widget_radius_from_rcti(const rcti *rect, const uiWidgetColors *wcol)
|
|
{
|
|
return wcol->roundness * BLI_rcti_size_y(rect);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget Emboss Helper
|
|
*
|
|
* Emboss is an (optional) shadow shown under the bottom edge of buttons. For
|
|
* vertically-aligned stacks of buttons it should only be shown under the bottom one.
|
|
* \{ */
|
|
|
|
static bool draw_emboss(const uiBut *but)
|
|
{
|
|
if (but->drawflag & UI_BUT_ALIGN_DOWN) {
|
|
return false;
|
|
}
|
|
uiBut *but_next = but->block->next_but(but);
|
|
if (but->type == ButType::Tab &&
|
|
(BLI_rctf_size_y(&but->block->rect) > BLI_rctf_size_x(&but->block->rect)) &&
|
|
!(but_next == nullptr || but_next->type == ButType::Sepr))
|
|
{
|
|
/* Vertical tabs, emboss at end and before separators. */
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Widget Types
|
|
* \{ */
|
|
|
|
/* sliders use special hack which sets 'item' as inner when drawing filling */
|
|
static void widget_state_numslider(uiWidgetType *wt,
|
|
const uiWidgetStateInfo *state,
|
|
blender::ui::EmbossType emboss)
|
|
{
|
|
uiWidgetStateColors *wcol_state = wt->wcol_state;
|
|
|
|
/* call this for option button */
|
|
widget_state(wt, state, emboss);
|
|
|
|
const uchar *color_blend = widget_color_blend_from_flags(wcol_state, state, emboss);
|
|
if (color_blend != nullptr) {
|
|
/* Set the slider 'item' so that it reflects state settings too.
|
|
* De-saturate so the color of the slider doesn't conflict with the blend color,
|
|
* which can make the color hard to see when the slider is set to full (see #66102). */
|
|
wt->wcol.item[0] = wt->wcol.item[1] = wt->wcol.item[2] = srgb_to_grayscale_byte(wt->wcol.item);
|
|
color_blend_v3_v3(wt->wcol.item, color_blend, wcol_state->blend);
|
|
color_ensure_contrast_v3(wt->wcol.item, wt->wcol.inner, 30);
|
|
}
|
|
|
|
if (state->but_flag & UI_SELECT) {
|
|
std::swap(wt->wcol.shadetop, wt->wcol.shadedown);
|
|
}
|
|
}
|
|
|
|
/* labels use theme colors for text */
|
|
static void widget_state_option_menu(uiWidgetType *wt,
|
|
const uiWidgetStateInfo *state,
|
|
blender::ui::EmbossType emboss)
|
|
{
|
|
const bTheme *btheme = UI_GetTheme();
|
|
|
|
const uiWidgetColors *old_wcol = wt->wcol_theme;
|
|
uiWidgetColors wcol_menu_option = *wt->wcol_theme;
|
|
|
|
/* Override the checkbox theme colors to use the menu-back text colors. */
|
|
copy_v3_v3_uchar(wcol_menu_option.text, btheme->tui.wcol_menu_back.text);
|
|
copy_v3_v3_uchar(wcol_menu_option.text_sel, btheme->tui.wcol_menu_back.text_sel);
|
|
wt->wcol_theme = &wcol_menu_option;
|
|
|
|
widget_state(wt, state, emboss);
|
|
|
|
wt->wcol_theme = old_wcol;
|
|
}
|
|
|
|
static void widget_state_nothing(uiWidgetType *wt,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
blender::ui::EmbossType /*emboss*/)
|
|
{
|
|
wt->wcol = *(wt->wcol_theme);
|
|
}
|
|
|
|
/* special case, button that calls pulldown */
|
|
static void widget_state_pulldown(uiWidgetType *wt,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
blender::ui::EmbossType /*emboss*/)
|
|
{
|
|
wt->wcol = *(wt->wcol_theme);
|
|
}
|
|
|
|
/* special case, pie menu items */
|
|
static void widget_state_pie_menu_item(uiWidgetType *wt,
|
|
const uiWidgetStateInfo *state,
|
|
blender::ui::EmbossType /*emboss*/)
|
|
{
|
|
wt->wcol = *(wt->wcol_theme);
|
|
|
|
if ((state->but_flag & UI_BUT_DISABLED) && (state->but_flag & UI_HOVER)) {
|
|
color_blend_v3_v3(wt->wcol.text, wt->wcol.text_sel, 0.5f);
|
|
color_blend_v3_v3(wt->wcol.outline, wt->wcol.outline_sel, 0.5f);
|
|
/* draw the backdrop at low alpha, helps navigating with keys
|
|
* when disabled items are active */
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.item);
|
|
wt->wcol.inner[3] = 64;
|
|
}
|
|
else {
|
|
/* regular active */
|
|
if (state->but_flag & (UI_SELECT | UI_HOVER)) {
|
|
copy_v3_v3_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
copy_v3_v3_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
}
|
|
else if (state->but_flag & (UI_BUT_DISABLED | UI_BUT_INACTIVE)) {
|
|
/* regular disabled */
|
|
color_blend_v3_v3(wt->wcol.text, wt->wcol.inner, 0.5f);
|
|
}
|
|
|
|
if (state->but_flag & UI_SELECT) {
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.inner_sel);
|
|
copy_v4_v4_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
}
|
|
else if (state->but_flag & UI_HOVER) {
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.item);
|
|
color_blend_v3_v3(wt->wcol.outline, wt->wcol.outline_sel, 0.5f);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* special case, menu items */
|
|
static void widget_state_menu_item(uiWidgetType *wt,
|
|
const uiWidgetStateInfo *state,
|
|
blender::ui::EmbossType /*emboss*/)
|
|
{
|
|
wt->wcol = *(wt->wcol_theme);
|
|
|
|
if ((state->but_flag & UI_BUT_DISABLED) && (state->but_flag & UI_HOVER)) {
|
|
/* Hovering over disabled item. */
|
|
wt->wcol.text[3] = 128;
|
|
color_blend_v3_v3(wt->wcol.inner, wt->wcol.text, 0.5f);
|
|
wt->wcol.inner[3] = 64;
|
|
}
|
|
else if (state->but_flag & UI_BUT_DISABLED) {
|
|
/* Regular disabled. */
|
|
wt->wcol.text[3] = 128;
|
|
}
|
|
else if (state->but_flag & UI_BUT_INACTIVE) {
|
|
/* Inactive. */
|
|
if (state->but_flag & UI_HOVER) {
|
|
color_blend_v3_v3(wt->wcol.inner, wt->wcol.text, 0.2f);
|
|
copy_v3_v3_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
wt->wcol.inner[3] = 255;
|
|
}
|
|
color_blend_v3_v3(wt->wcol.text, wt->wcol.inner, 0.5f);
|
|
}
|
|
else if (state->but_flag & (UI_BUT_ACTIVE_DEFAULT | UI_SELECT_DRAW)) {
|
|
/* Currently-selected item. */
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.inner_sel);
|
|
copy_v4_v4_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
copy_v4_v4_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
}
|
|
else if ((state->but_flag & (UI_SELECT | UI_BUT_ICON_PREVIEW)) ==
|
|
(UI_SELECT | UI_BUT_ICON_PREVIEW))
|
|
{
|
|
/* Currently-selected list or menu item that is large icon preview. */
|
|
copy_v4_v4_uchar(wt->wcol.inner, wt->wcol.inner_sel);
|
|
copy_v4_v4_uchar(wt->wcol.outline, wt->wcol.outline_sel);
|
|
copy_v4_v4_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
}
|
|
else if (state->but_flag & UI_HOVER) {
|
|
/* Regular hover. */
|
|
color_blend_v3_v3(wt->wcol.inner, wt->wcol.text, 0.2f);
|
|
color_blend_v3_v3(wt->wcol.outline, wt->wcol.outline_sel, 0.5f);
|
|
copy_v3_v3_uchar(wt->wcol.text, wt->wcol.text_sel);
|
|
wt->wcol.inner[3] = 255;
|
|
wt->wcol.text[3] = 255;
|
|
}
|
|
/* Subtle background for larger preview buttons, so text and icons feel connected (esp. for while
|
|
* previews are loading still and a loading icon is displayed). */
|
|
else if (state->but_flag & UI_BUT_ICON_PREVIEW) {
|
|
copy_v3_v3_uchar(wt->wcol.inner, wt->wcol.text);
|
|
wt->wcol.inner[3] = 11;
|
|
}
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Draw Menu Backdrop
|
|
* \{ */
|
|
|
|
/* outside of rect, rad to left/bottom/right */
|
|
static void widget_softshadow(const rcti *rect, int roundboxalign, const float radin)
|
|
{
|
|
const float outline = U.pixelsize;
|
|
|
|
rctf shadow_rect;
|
|
BLI_rctf_rcti_copy(&shadow_rect, rect);
|
|
BLI_rctf_pad(&shadow_rect, -outline, -outline);
|
|
|
|
UI_draw_roundbox_corner_set(roundboxalign);
|
|
|
|
const float shadow_alpha = UI_GetTheme()->tui.menu_shadow_fac;
|
|
const float shadow_width = UI_ThemeMenuShadowWidth();
|
|
|
|
ui_draw_dropshadow(&shadow_rect, radin, shadow_width, 1.0f, shadow_alpha);
|
|
}
|
|
|
|
static void widget_menu_back(uiWidgetColors *wcol,
|
|
const rcti *rect,
|
|
const int block_flag,
|
|
const int direction,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
int roundboxalign = UI_CNR_ALL;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* menu is 2nd level or deeper */
|
|
if (block_flag & UI_BLOCK_POPUP) {
|
|
// rect->ymin -= 4.0;
|
|
// rect->ymax += 4.0;
|
|
}
|
|
else if (direction & (UI_DIR_DOWN | UI_DIR_UP)) {
|
|
if (direction & UI_DIR_DOWN) {
|
|
roundboxalign = (UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT);
|
|
}
|
|
else {
|
|
roundboxalign = (UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
|
|
}
|
|
/* Corner rounding based on secondary direction. */
|
|
if (direction & UI_DIR_LEFT) {
|
|
roundboxalign |= (UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
|
|
}
|
|
if (direction & UI_DIR_RIGHT) {
|
|
roundboxalign |= (UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT);
|
|
}
|
|
}
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
const float radius = widget_radius_from_zoom(zoom, wcol);
|
|
widget_softshadow(rect, roundboxalign, radius);
|
|
|
|
round_box_edges(&wtb, roundboxalign, rect, radius);
|
|
wtb.draw_emboss = false;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
static void ui_hsv_cursor(const float x,
|
|
const float y,
|
|
const float zoom,
|
|
const float rgb[3],
|
|
const float hsv[3],
|
|
const bool is_active)
|
|
{
|
|
/* Draw the circle larger while the mouse button is pressed down. */
|
|
const float radius = zoom * (((is_active ? 20.0f : 12.0f) * UI_SCALE_FAC) + U.pixelsize);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
GPU_program_point_size(true);
|
|
immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA);
|
|
immUniformColor3fv(rgb);
|
|
immUniform1f("outlineWidth", U.pixelsize);
|
|
|
|
/* Alpha of outline colors just strong enough to give good contrast. */
|
|
const float fg = std::min(1.0f - hsv[2] + 0.2f, 0.8f);
|
|
const float bg = hsv[2] / 2.0f;
|
|
|
|
immUniform4f("outlineColor", 0.0f, 0.0f, 0.0f, bg);
|
|
immUniform1f("size", radius);
|
|
immBegin(GPU_PRIM_POINTS, 1);
|
|
immVertex2f(pos, x, y);
|
|
immEnd();
|
|
|
|
immUniform4f("outlineColor", 1.0f, 1.0f, 1.0f, fg);
|
|
immUniform1f("size", radius - 1.0f);
|
|
immBegin(GPU_PRIM_POINTS, 1);
|
|
immVertex2f(pos, x, y);
|
|
immEnd();
|
|
|
|
immUnbindProgram();
|
|
GPU_program_point_size(false);
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
void ui_hsvcircle_vals_from_pos(
|
|
const rcti *rect, const float mx, const float my, float *r_val_rad, float *r_val_dist)
|
|
{
|
|
/* duplication of code... well, simple is better now */
|
|
const float centx = BLI_rcti_cent_x_fl(rect);
|
|
const float centy = BLI_rcti_cent_y_fl(rect);
|
|
const float radius = float(min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect))) / 2.0f;
|
|
const float m_delta[2] = {mx - centx, my - centy};
|
|
const float dist_sq = len_squared_v2(m_delta);
|
|
|
|
*r_val_dist = (dist_sq < (radius * radius)) ? sqrtf(dist_sq) / radius : 1.0f;
|
|
*r_val_rad = atan2f(m_delta[0], m_delta[1]) / (2.0f * float(M_PI)) + 0.5f;
|
|
}
|
|
|
|
void ui_hsvcircle_pos_from_vals(
|
|
const ColorPicker *cpicker, const rcti *rect, const float *hsv, float *r_xpos, float *r_ypos)
|
|
{
|
|
/* duplication of code... well, simple is better now */
|
|
const float centx = BLI_rcti_cent_x_fl(rect);
|
|
const float centy = BLI_rcti_cent_y_fl(rect);
|
|
const float radius = float(min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect))) / 2.0f;
|
|
|
|
const float ang = 2.0f * float(M_PI) * hsv[0] + float(M_PI_2);
|
|
|
|
float radius_t;
|
|
if (cpicker->use_color_cubic && (U.color_picker_type == USER_CP_CIRCLE_HSV)) {
|
|
radius_t = (1.0f - pow3f(1.0f - hsv[1]));
|
|
}
|
|
else {
|
|
radius_t = hsv[1];
|
|
}
|
|
|
|
const float rad = clamp_f(radius_t, 0.0f, 1.0f) * radius;
|
|
*r_xpos = centx + cosf(-ang) * rad;
|
|
*r_ypos = centy + sinf(-ang) * rad;
|
|
}
|
|
|
|
static void ui_draw_but_HSVCIRCLE(uiBut *but, const uiWidgetColors *wcol, const rcti *rect)
|
|
{
|
|
/* TODO(merwin): reimplement as shader for pixel-perfect colors */
|
|
|
|
const int tot = 64;
|
|
const float radstep = 2.0f * float(M_PI) / float(tot);
|
|
const float centx = BLI_rcti_cent_x_fl(rect);
|
|
const float centy = BLI_rcti_cent_y_fl(rect);
|
|
const float radius = float(min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect))) / 2.0f;
|
|
|
|
ColorPicker *cpicker = static_cast<ColorPicker *>(but->custom_data);
|
|
float rgb[3], hsv[3], rgb_center[3];
|
|
const bool is_color_gamma = ui_but_is_color_gamma(but);
|
|
|
|
/* Initialize for compatibility. */
|
|
copy_v3_v3(hsv, cpicker->hsv_perceptual);
|
|
|
|
/* Compute current hue. */
|
|
ui_but_v3_get(but, rgb);
|
|
ui_scene_linear_to_perceptual_space(but, rgb);
|
|
ui_color_picker_rgb_to_hsv_compat(rgb, hsv);
|
|
|
|
CLAMP(hsv[2], 0.0f, 1.0f); /* for display only */
|
|
|
|
/* exception: if 'lock' is set
|
|
* lock the value of the color wheel to 1.
|
|
* Useful for color correction tools where you're only interested in hue. */
|
|
if (cpicker->use_color_lock) {
|
|
if (U.color_picker_type == USER_CP_CIRCLE_HSV) {
|
|
hsv[2] = 1.0f;
|
|
}
|
|
else {
|
|
hsv[2] = 0.5f;
|
|
}
|
|
}
|
|
|
|
const float hsv_center[3] = {0.0f, 0.0f, hsv[2]};
|
|
ui_color_picker_hsv_to_rgb(hsv_center, rgb_center);
|
|
ui_perceptual_to_scene_linear_space(but, rgb_center);
|
|
|
|
if (!is_color_gamma) {
|
|
ui_block_cm_to_display_space_v3(but->block, rgb_center);
|
|
}
|
|
|
|
GPUVertFormat *format = immVertexFormat();
|
|
uint pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
const uint color = GPU_vertformat_attr_add(
|
|
format, "color", blender::gpu::VertAttrType::SFLOAT_32_32_32);
|
|
|
|
immBindBuiltinProgram(GPU_SHADER_3D_SMOOTH_COLOR);
|
|
|
|
immBegin(GPU_PRIM_TRI_FAN, tot + 2);
|
|
immAttr3fv(color, rgb_center);
|
|
immVertex2f(pos, centx, centy);
|
|
|
|
float ang = 0.0f;
|
|
for (int a = 0; a <= tot; a++, ang += radstep) {
|
|
const float si = sinf(ang);
|
|
const float co = cosf(ang);
|
|
float hsv_ang[3];
|
|
float rgb_ang[3];
|
|
|
|
ui_hsvcircle_vals_from_pos(
|
|
rect, centx + co * radius, centy + si * radius, hsv_ang, hsv_ang + 1);
|
|
hsv_ang[2] = hsv[2];
|
|
|
|
ui_color_picker_hsv_to_rgb(hsv_ang, rgb_ang);
|
|
ui_perceptual_to_scene_linear_space(but, rgb_ang);
|
|
|
|
if (!is_color_gamma) {
|
|
ui_block_cm_to_display_space_v3(but->block, rgb_ang);
|
|
}
|
|
|
|
immAttr3fv(color, rgb_ang);
|
|
immVertex2f(pos, centx + co * radius, centy + si * radius);
|
|
}
|
|
immEnd();
|
|
immUnbindProgram();
|
|
|
|
/* fully rounded outline */
|
|
format = immVertexFormat();
|
|
pos = GPU_vertformat_attr_add(format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
GPU_line_smooth(true);
|
|
|
|
immUniformColor3ubv(wcol->outline);
|
|
imm_draw_circle_wire_2d(pos, centx, centy, radius, tot);
|
|
|
|
immUnbindProgram();
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
GPU_line_smooth(false);
|
|
|
|
/* cursor */
|
|
copy_v3_v3(hsv, cpicker->hsv_perceptual);
|
|
ui_but_v3_get(but, rgb);
|
|
ui_scene_linear_to_perceptual_space(but, rgb);
|
|
ui_color_picker_rgb_to_hsv_compat(rgb, hsv);
|
|
|
|
float xpos, ypos;
|
|
ui_hsvcircle_pos_from_vals(cpicker, rect, hsv, &xpos, &ypos);
|
|
const float zoom = 1.0f / but->block->aspect;
|
|
ui_hsv_cursor(xpos, ypos, zoom, rgb, hsv, but->flag & UI_SELECT);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Draw Custom Buttons
|
|
* \{ */
|
|
|
|
void ui_draw_gradient(const rcti *rect,
|
|
const float hsv[3],
|
|
const eButGradientType type,
|
|
const float alpha)
|
|
{
|
|
/* allows for 4 steps (red->yellow) */
|
|
const int steps = 48;
|
|
const float color_step = 1.0f / steps;
|
|
int a;
|
|
const float h = hsv[0], s = hsv[1], v = hsv[2];
|
|
float dx, dy, sx1, sx2, sy;
|
|
float col0[4][3]; /* left half, rect bottom to top */
|
|
float col1[4][3]; /* right half, rect bottom to top */
|
|
|
|
/* draw series of gouraud rects */
|
|
|
|
switch (type) {
|
|
case UI_GRAD_SV:
|
|
hsv_to_rgb(h, 0.0, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(h, 0.0, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(h, 0.0, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(h, 0.0, 1.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
break;
|
|
case UI_GRAD_HV:
|
|
hsv_to_rgb(0.0, s, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(0.0, s, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(0.0, s, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(0.0, s, 1.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
break;
|
|
case UI_GRAD_HS:
|
|
hsv_to_rgb(0.0, 0.0, v, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(0.0, 0.333, v, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(0.0, 0.666, v, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(0.0, 1.0, v, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
break;
|
|
case UI_GRAD_H:
|
|
hsv_to_rgb(0.0, 1.0, 1.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
copy_v3_v3(col1[1], col1[0]);
|
|
copy_v3_v3(col1[2], col1[0]);
|
|
copy_v3_v3(col1[3], col1[0]);
|
|
break;
|
|
case UI_GRAD_S:
|
|
hsv_to_rgb(1.0, 0.0, 1.0, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
copy_v3_v3(col1[0], col1[1]);
|
|
copy_v3_v3(col1[2], col1[1]);
|
|
copy_v3_v3(col1[3], col1[1]);
|
|
break;
|
|
case UI_GRAD_V:
|
|
hsv_to_rgb(1.0, 1.0, 0.0, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
copy_v3_v3(col1[0], col1[2]);
|
|
copy_v3_v3(col1[1], col1[2]);
|
|
copy_v3_v3(col1[3], col1[2]);
|
|
break;
|
|
default:
|
|
BLI_assert_msg(0, "invalid 'type' argument");
|
|
hsv_to_rgb(1.0, 1.0, 1.0, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
copy_v3_v3(col1[0], col1[2]);
|
|
copy_v3_v3(col1[1], col1[2]);
|
|
copy_v3_v3(col1[3], col1[2]);
|
|
break;
|
|
}
|
|
|
|
/* old below */
|
|
GPUVertFormat *format = immVertexFormat();
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
const uint col = GPU_vertformat_attr_add(
|
|
format, "color", blender::gpu::VertAttrType::SFLOAT_32_32_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_SMOOTH_COLOR);
|
|
|
|
immBegin(GPU_PRIM_TRIS, steps * 3 * 6);
|
|
|
|
/* 0.999 = prevent float inaccuracy for steps */
|
|
for (dx = 0.0f; dx < 0.999f; dx += color_step) {
|
|
const float dx_next = dx + color_step;
|
|
|
|
/* previous color */
|
|
copy_v3_v3(col0[0], col1[0]);
|
|
copy_v3_v3(col0[1], col1[1]);
|
|
copy_v3_v3(col0[2], col1[2]);
|
|
copy_v3_v3(col0[3], col1[3]);
|
|
|
|
/* new color */
|
|
switch (type) {
|
|
case UI_GRAD_SV:
|
|
hsv_to_rgb(h, dx, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(h, dx, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(h, dx, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(h, dx, 1.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
break;
|
|
case UI_GRAD_HV:
|
|
hsv_to_rgb(dx_next, s, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(dx_next, s, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(dx_next, s, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(dx_next, s, 1.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
break;
|
|
case UI_GRAD_HS:
|
|
hsv_to_rgb(dx_next, 0.0, v, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(dx_next, 0.333, v, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(dx_next, 0.666, v, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(dx_next, 1.0, v, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
break;
|
|
case UI_GRAD_H:
|
|
/* annoying but without this the color shifts - could be solved some other way
|
|
* - campbell */
|
|
hsv_to_rgb(dx_next, 1.0, 1.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
copy_v3_v3(col1[1], col1[0]);
|
|
copy_v3_v3(col1[2], col1[0]);
|
|
copy_v3_v3(col1[3], col1[0]);
|
|
break;
|
|
case UI_GRAD_S:
|
|
hsv_to_rgb(h, dx, 1.0, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
copy_v3_v3(col1[0], col1[1]);
|
|
copy_v3_v3(col1[2], col1[1]);
|
|
copy_v3_v3(col1[3], col1[1]);
|
|
break;
|
|
case UI_GRAD_V:
|
|
hsv_to_rgb(h, 1.0, dx, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
copy_v3_v3(col1[0], col1[2]);
|
|
copy_v3_v3(col1[1], col1[2]);
|
|
copy_v3_v3(col1[3], col1[2]);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* rect */
|
|
sx1 = rect->xmin + dx * BLI_rcti_size_x(rect);
|
|
sx2 = rect->xmin + dx_next * BLI_rcti_size_x(rect);
|
|
sy = rect->ymin;
|
|
dy = float(BLI_rcti_size_y(rect)) / 3.0f;
|
|
|
|
for (a = 0; a < 3; a++, sy += dy) {
|
|
immAttr4f(col, col0[a][0], col0[a][1], col0[a][2], alpha);
|
|
immVertex2f(pos, sx1, sy);
|
|
|
|
immAttr4f(col, col1[a][0], col1[a][1], col1[a][2], alpha);
|
|
immVertex2f(pos, sx2, sy);
|
|
|
|
immAttr4f(col, col1[a + 1][0], col1[a + 1][1], col1[a + 1][2], alpha);
|
|
immVertex2f(pos, sx2, sy + dy);
|
|
|
|
immAttr4f(col, col0[a][0], col0[a][1], col0[a][2], alpha);
|
|
immVertex2f(pos, sx1, sy);
|
|
|
|
immAttr4f(col, col1[a + 1][0], col1[a + 1][1], col1[a + 1][2], alpha);
|
|
immVertex2f(pos, sx2, sy + dy);
|
|
|
|
immAttr4f(col, col0[a + 1][0], col0[a + 1][1], col0[a + 1][2], alpha);
|
|
immVertex2f(pos, sx1, sy + dy);
|
|
}
|
|
}
|
|
immEnd();
|
|
|
|
immUnbindProgram();
|
|
}
|
|
|
|
void ui_hsvcube_pos_from_vals(
|
|
const uiButHSVCube *hsv_but, const rcti *rect, const float *hsv, float *r_xp, float *r_yp)
|
|
{
|
|
float x = 0.0f, y = 0.0f;
|
|
|
|
switch (hsv_but->gradient_type) {
|
|
case UI_GRAD_SV:
|
|
x = hsv[1];
|
|
y = hsv[2];
|
|
break;
|
|
case UI_GRAD_HV:
|
|
x = hsv[0];
|
|
y = hsv[2];
|
|
break;
|
|
case UI_GRAD_HS:
|
|
x = hsv[0];
|
|
y = hsv[1];
|
|
break;
|
|
case UI_GRAD_H:
|
|
x = hsv[0];
|
|
y = 0.5;
|
|
break;
|
|
case UI_GRAD_S:
|
|
x = hsv[1];
|
|
y = 0.5;
|
|
break;
|
|
case UI_GRAD_V:
|
|
x = hsv[2];
|
|
y = 0.5;
|
|
break;
|
|
case UI_GRAD_L_ALT:
|
|
x = 0.5f;
|
|
/* exception only for value strip - use the range set in but->min/max */
|
|
y = hsv[2];
|
|
break;
|
|
case UI_GRAD_V_ALT:
|
|
x = 0.5f;
|
|
/* exception only for value strip - use the range set in but->min/max */
|
|
y = (hsv[2] - hsv_but->softmin) / (hsv_but->softmax - hsv_but->softmin);
|
|
break;
|
|
case UI_GRAD_NONE:
|
|
BLI_assert_unreachable();
|
|
}
|
|
|
|
/* cursor */
|
|
*r_xp = rect->xmin + x * BLI_rcti_size_x(rect);
|
|
*r_yp = rect->ymin + y * BLI_rcti_size_y(rect);
|
|
}
|
|
|
|
static void ui_draw_but_HSVCUBE(uiBut *but, const rcti *rect)
|
|
{
|
|
const uiButHSVCube *hsv_but = (uiButHSVCube *)but;
|
|
float rgb[3];
|
|
float x = 0.0f, y = 0.0f;
|
|
ColorPicker *cpicker = static_cast<ColorPicker *>(but->custom_data);
|
|
float *hsv = cpicker->hsv_perceptual;
|
|
float hsv_n[3];
|
|
|
|
/* Is this the larger color canvas or narrow color slider? */
|
|
bool is_canvas = ELEM(hsv_but->gradient_type, UI_GRAD_SV, UI_GRAD_HV, UI_GRAD_HS);
|
|
|
|
/* Initialize for compatibility. */
|
|
copy_v3_v3(hsv_n, hsv);
|
|
|
|
ui_but_v3_get(but, rgb);
|
|
ui_scene_linear_to_perceptual_space(but, rgb);
|
|
rgb_to_hsv_compat_v(rgb, hsv_n);
|
|
|
|
ui_draw_gradient(rect, hsv_n, hsv_but->gradient_type, 1.0f);
|
|
|
|
ui_hsvcube_pos_from_vals(hsv_but, rect, hsv_n, &x, &y);
|
|
|
|
const float zoom = 1.0f / but->block->aspect;
|
|
|
|
/* outline */
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
immUniformColor3ub(0, 0, 0);
|
|
imm_draw_box_wire_2d(pos, (rect->xmin), (rect->ymin), (rect->xmax), (rect->ymax));
|
|
immUnbindProgram();
|
|
|
|
if (is_canvas) {
|
|
/* Round cursor in the large square area. */
|
|
float margin = (4.0f * UI_SCALE_FAC);
|
|
CLAMP(x, rect->xmin + margin, rect->xmax - margin);
|
|
CLAMP(y, rect->ymin + margin, rect->ymax - margin);
|
|
ui_hsv_cursor(x, y, zoom, rgb, hsv, but->flag & UI_SELECT);
|
|
}
|
|
else {
|
|
/* Square indicator in the narrow area. */
|
|
rctf rectf;
|
|
BLI_rctf_rcti_copy(&rectf, rect);
|
|
const float margin = (2.0f * UI_SCALE_FAC);
|
|
CLAMP(x, rect->xmin + margin, rect->xmax - margin);
|
|
CLAMP(y, rect->ymin + margin, rect->ymax - margin);
|
|
rectf.ymax += 1;
|
|
const float cursor_width = std::max(BLI_rctf_size_y(&rectf) * 0.35f, 1.0f);
|
|
rectf.xmin = x - cursor_width;
|
|
rectf.xmax = x + cursor_width;
|
|
|
|
if (but->flag & UI_SELECT) {
|
|
/* Make the indicator larger while the mouse button is pressed. */
|
|
rectf.xmin -= U.pixelsize;
|
|
rectf.xmax += U.pixelsize;
|
|
rectf.ymin -= U.pixelsize;
|
|
rectf.ymax += U.pixelsize;
|
|
}
|
|
|
|
const float col[4] = {0.0f, 0.0f, 0.0f, 1.0f};
|
|
UI_draw_roundbox_4fv(&rectf, false, 0, col);
|
|
|
|
rectf.xmin += 1.0f;
|
|
rectf.xmax -= 1.0f;
|
|
const float inner[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
|
const float col2[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
|
UI_draw_roundbox_4fv_ex(&rectf, col2, nullptr, 0.0f, inner, U.pixelsize, 0.0f);
|
|
}
|
|
}
|
|
|
|
/* vertical 'value' slider, using new widget code */
|
|
static void ui_draw_but_HSV_v(uiBut *but, const rcti *rect)
|
|
{
|
|
const uiButHSVCube *hsv_but = (uiButHSVCube *)but;
|
|
float rgb[3], hsv[3], v;
|
|
|
|
ui_but_v3_get(but, rgb);
|
|
ui_scene_linear_to_perceptual_space(but, rgb);
|
|
|
|
if (hsv_but->gradient_type == UI_GRAD_L_ALT) {
|
|
rgb_to_hsl_v(rgb, hsv);
|
|
}
|
|
else {
|
|
rgb_to_hsv_v(rgb, hsv);
|
|
}
|
|
v = hsv[2];
|
|
|
|
/* map v from property range to [0,1] */
|
|
if (hsv_but->gradient_type == UI_GRAD_V_ALT) {
|
|
const float min = but->softmin, max = but->softmax;
|
|
v = (v - min) / (max - min);
|
|
}
|
|
|
|
rctf rectf;
|
|
BLI_rctf_rcti_copy(&rectf, rect);
|
|
|
|
const float inner1[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
|
const float inner2[4] = {0.0f, 0.0f, 0.0f, 1.0f};
|
|
const float outline[4] = {0.0f, 0.0f, 0.0f, 1.0f};
|
|
|
|
const float outline_width = (BLI_rctf_size_x(&rectf) < 4.0f) ? 0.0f : 1.0f;
|
|
UI_draw_roundbox_4fv_ex(&rectf, inner1, inner2, U.pixelsize, outline, outline_width, 0.0f);
|
|
|
|
/* cursor */
|
|
float y = rect->ymin + v * BLI_rcti_size_y(rect);
|
|
CLAMP(y, float(rect->ymin) + (2.0f * UI_SCALE_FAC), float(rect->ymax) - (2.0f * UI_SCALE_FAC));
|
|
const float cursor_height = std::max(BLI_rctf_size_x(&rectf) * 0.35f, 1.0f);
|
|
rectf.ymin = y - cursor_height;
|
|
rectf.ymax = y + cursor_height;
|
|
float col[4] = {0.0f, 0.0f, 0.0f, 1.0f};
|
|
|
|
if (but->flag & UI_SELECT) {
|
|
/* Enlarge the indicator while the mouse button is pressed down. */
|
|
rectf.xmin -= U.pixelsize;
|
|
rectf.xmax += U.pixelsize;
|
|
rectf.ymin -= U.pixelsize;
|
|
rectf.ymax += U.pixelsize;
|
|
}
|
|
|
|
UI_draw_roundbox_4fv(&rectf, false, 0.0f, col);
|
|
|
|
rectf.ymin += 1.0f;
|
|
rectf.ymax -= 1.0f;
|
|
const float col2[4] = {v, v, v, 1.0f};
|
|
UI_draw_roundbox_4fv_ex(&rectf, col2, nullptr, 0.0f, inner1, U.pixelsize, 0.0f);
|
|
}
|
|
|
|
/** Separator line. */
|
|
static void ui_draw_separator(const uiWidgetColors *wcol, uiBut *but, const rcti *rect)
|
|
{
|
|
const uiButSeparatorLine *but_line = static_cast<uiButSeparatorLine *>(but);
|
|
const bool vertical = but_line->is_vertical;
|
|
const int mid = vertical ? BLI_rcti_cent_x(rect) : BLI_rcti_cent_y(rect);
|
|
const uchar col[4] = {
|
|
wcol->text[0],
|
|
wcol->text[1],
|
|
wcol->text[2],
|
|
30,
|
|
};
|
|
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
immUniformColor4ubv(col);
|
|
GPU_line_width(1.0f);
|
|
|
|
immBegin(GPU_PRIM_LINES, 2);
|
|
|
|
if (vertical) {
|
|
immVertex2f(pos, mid, rect->ymin);
|
|
immVertex2f(pos, mid, rect->ymax);
|
|
}
|
|
else {
|
|
immVertex2f(pos, rect->xmin, mid);
|
|
immVertex2f(pos, rect->xmax, mid);
|
|
}
|
|
|
|
immEnd();
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
immUnbindProgram();
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Button Draw Callbacks
|
|
* \{ */
|
|
|
|
#define NUM_BUT_PADDING_FACTOR 0.425f
|
|
|
|
static void widget_numbut_draw(const uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const float zoom,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
bool emboss)
|
|
{
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
const int handle_width = min_ii(BLI_rcti_size_x(rect) / 3, BLI_rcti_size_y(rect) * 0.7f);
|
|
|
|
if (state->but_flag & UI_SELECT) {
|
|
std::swap(wcol->shadetop, wcol->shadedown);
|
|
}
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
if (!emboss) {
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
}
|
|
else {
|
|
wtb.draw_inner = false;
|
|
wtb.draw_outline = false;
|
|
}
|
|
|
|
/* decoration */
|
|
if ((state->but_flag & UI_HOVER) && !state->is_text_input) {
|
|
uiWidgetColors wcol_zone;
|
|
uiWidgetBase wtb_zone;
|
|
rcti rect_zone;
|
|
int roundboxalign_zone;
|
|
|
|
/* left arrow zone */
|
|
widget_init(&wtb_zone);
|
|
wtb_zone.draw_outline = false;
|
|
wtb_zone.draw_emboss = false;
|
|
|
|
wcol_zone = *wcol;
|
|
copy_v3_v3_uchar(wcol_zone.item, wcol->text);
|
|
if (state->but_drawflag & UI_BUT_HOVER_LEFT) {
|
|
widget_active_color(&wcol_zone);
|
|
}
|
|
|
|
rect_zone = *rect;
|
|
rect_zone.xmax = rect->xmin + handle_width + U.pixelsize;
|
|
roundboxalign_zone = roundboxalign & ~(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
|
|
round_box_edges(&wtb_zone, roundboxalign_zone, &rect_zone, rad);
|
|
|
|
shape_preset_init_number_arrows(&wtb_zone.tria1, &rect_zone, 0.6f, 'l');
|
|
widgetbase_draw(&wtb_zone, &wcol_zone);
|
|
|
|
/* right arrow zone */
|
|
widget_init(&wtb_zone);
|
|
wtb_zone.draw_outline = false;
|
|
wtb_zone.draw_emboss = false;
|
|
wtb_zone.tria1.type = ROUNDBOX_TRIA_ARROWS;
|
|
|
|
wcol_zone = *wcol;
|
|
copy_v3_v3_uchar(wcol_zone.item, wcol->text);
|
|
if (state->but_drawflag & UI_BUT_HOVER_RIGHT) {
|
|
widget_active_color(&wcol_zone);
|
|
}
|
|
|
|
rect_zone = *rect;
|
|
rect_zone.xmin = rect->xmax - handle_width - U.pixelsize;
|
|
roundboxalign_zone = roundboxalign & ~(UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT);
|
|
round_box_edges(&wtb_zone, roundboxalign_zone, &rect_zone, rad);
|
|
|
|
shape_preset_init_number_arrows(&wtb_zone.tria2, &rect_zone, 0.6f, 'r');
|
|
widgetbase_draw(&wtb_zone, &wcol_zone);
|
|
|
|
/* middle highlight zone */
|
|
widget_init(&wtb_zone);
|
|
wtb_zone.draw_outline = false;
|
|
wtb_zone.draw_emboss = false;
|
|
|
|
wcol_zone = *wcol;
|
|
copy_v3_v3_uchar(wcol_zone.item, wcol->text);
|
|
if (!(state->but_drawflag & (UI_BUT_HOVER_LEFT | UI_BUT_HOVER_RIGHT))) {
|
|
widget_active_color(&wcol_zone);
|
|
}
|
|
|
|
rect_zone = *rect;
|
|
rect_zone.xmin = rect->xmin + handle_width - U.pixelsize;
|
|
rect_zone.xmax = rect->xmax - handle_width + U.pixelsize;
|
|
round_box_edges(&wtb_zone, 0, &rect_zone, 0);
|
|
widgetbase_draw(&wtb_zone, &wcol_zone);
|
|
|
|
/* outline */
|
|
wtb.draw_inner = false;
|
|
wtb.draw_emboss = draw_emboss(but);
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
else {
|
|
/* inner and outline */
|
|
wtb.draw_emboss = draw_emboss(but);
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
if (!state->is_text_input) {
|
|
const float text_padding = NUM_BUT_PADDING_FACTOR * BLI_rcti_size_y(rect);
|
|
|
|
rect->xmin += text_padding;
|
|
rect->xmax -= text_padding;
|
|
}
|
|
}
|
|
|
|
static void widget_numbut(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
widget_numbut_draw(but, wcol, rect, zoom, state, roundboxalign, false);
|
|
}
|
|
|
|
static void widget_menubut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
/* decoration */
|
|
shape_preset_trias_from_rect_menu(&wtb.tria1, rect);
|
|
/* copy size and center to 2nd tria */
|
|
wtb.tria2 = wtb.tria1;
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* text space, arrows are about 0.6 height of button */
|
|
rect->xmax -= (6 * BLI_rcti_size_y(rect)) / 10;
|
|
}
|
|
|
|
/**
|
|
* Draw menu buttons still with triangles when field is not embossed
|
|
*/
|
|
static void widget_menubut_embossn(const uiBut * /*but*/,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int /*roundboxalign*/)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
wtb.draw_inner = false;
|
|
wtb.draw_outline = false;
|
|
|
|
/* decoration */
|
|
shape_preset_trias_from_rect_menu(&wtb.tria1, rect);
|
|
/* copy size and center to 2nd tria */
|
|
wtb.tria2 = wtb.tria1;
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
/**
|
|
* Draw number buttons still with triangles when field is not embossed
|
|
*/
|
|
static void widget_numbut_embossn(const uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
widget_numbut_draw(but, wcol, rect, zoom, state, roundboxalign, true);
|
|
}
|
|
|
|
void UI_draw_widget_scroll(uiWidgetColors *wcol, const rcti *rect, const rcti *slider, int state)
|
|
{
|
|
uiWidgetBase wtb;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* determine horizontal/vertical */
|
|
const bool horizontal = (BLI_rcti_size_x(rect) > BLI_rcti_size_y(rect));
|
|
|
|
const float rad = (horizontal) ? wcol->roundness * BLI_rcti_size_y(rect) :
|
|
wcol->roundness * BLI_rcti_size_x(rect);
|
|
|
|
wtb.uniform_params.shade_dir = (horizontal) ? 1.0f : 0.0;
|
|
|
|
/* draw back part, colors swapped and shading inverted */
|
|
if (horizontal) {
|
|
std::swap(wcol->shadetop, wcol->shadedown);
|
|
}
|
|
|
|
round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* slider */
|
|
if ((BLI_rcti_size_x(slider) < 2) || (BLI_rcti_size_y(slider) < 2)) {
|
|
/* pass */
|
|
}
|
|
else {
|
|
std::swap(wcol->shadetop, wcol->shadedown);
|
|
|
|
copy_v4_v4_uchar(wcol->inner, wcol->item);
|
|
|
|
if (wcol->shadetop > wcol->shadedown) {
|
|
wcol->shadetop += 20; /* XXX violates themes... */
|
|
}
|
|
else {
|
|
wcol->shadedown += 20;
|
|
}
|
|
|
|
if (state & UI_SCROLL_PRESSED) {
|
|
wcol->inner[0] = wcol->inner[0] >= 250 ? 255 : wcol->inner[0] + 5;
|
|
wcol->inner[1] = wcol->inner[1] >= 250 ? 255 : wcol->inner[1] + 5;
|
|
wcol->inner[2] = wcol->inner[2] >= 250 ? 255 : wcol->inner[2] + 5;
|
|
}
|
|
|
|
/* draw */
|
|
wtb.draw_emboss = false; /* only emboss once */
|
|
|
|
round_box_edges(&wtb, UI_CNR_ALL, slider, rad);
|
|
|
|
if (state & UI_SCROLL_ARROWS) {
|
|
const uchar lightness = srgb_to_grayscale_byte(wcol->item);
|
|
if (lightness > 70) {
|
|
wcol->item[0] = 0;
|
|
wcol->item[1] = 0;
|
|
wcol->item[2] = 0;
|
|
wcol->item[3] = 128;
|
|
}
|
|
else {
|
|
wcol->item[0] = 255;
|
|
wcol->item[1] = 255;
|
|
wcol->item[2] = 255;
|
|
wcol->item[3] = 128;
|
|
}
|
|
|
|
if (horizontal) {
|
|
rcti slider_inset = *slider;
|
|
slider_inset.xmin += 0.05 * U.widget_unit;
|
|
slider_inset.xmax -= 0.05 * U.widget_unit;
|
|
shape_preset_init_scroll_circle(&wtb.tria1, &slider_inset, 0.6f, 'l');
|
|
shape_preset_init_scroll_circle(&wtb.tria2, &slider_inset, 0.6f, 'r');
|
|
}
|
|
else {
|
|
shape_preset_init_scroll_circle(&wtb.tria1, slider, 0.6f, 'b');
|
|
shape_preset_init_scroll_circle(&wtb.tria2, slider, 0.6f, 't');
|
|
}
|
|
}
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
}
|
|
|
|
static void widget_scroll(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int /*roundboxalign*/,
|
|
const float /*zoom*/)
|
|
{
|
|
const uiButScrollBar *but_scroll = reinterpret_cast<const uiButScrollBar *>(but);
|
|
const float height = but_scroll->visual_height;
|
|
|
|
/* calculate slider part */
|
|
const float value = float(ui_but_value_get(but));
|
|
|
|
const float size = max_ff((but->softmax + height - but->softmin), 2.0f);
|
|
|
|
/* position */
|
|
rcti rect1 = *rect;
|
|
|
|
/* determine horizontal/vertical */
|
|
const bool horizontal = (BLI_rcti_size_x(rect) > BLI_rcti_size_y(rect));
|
|
|
|
if (horizontal) {
|
|
const float fac = BLI_rcti_size_x(rect) / size;
|
|
rect1.xmin = rect1.xmin + ceilf(fac * (value - but->softmin));
|
|
rect1.xmax = rect1.xmin + ceilf(fac * (height - but->softmin));
|
|
|
|
/* Ensure minimum size. */
|
|
const float min = BLI_rcti_size_y(rect);
|
|
|
|
if (BLI_rcti_size_x(&rect1) < min) {
|
|
rect1.xmax = rect1.xmin + min;
|
|
|
|
if (rect1.xmax > rect->xmax) {
|
|
rect1.xmax = rect->xmax;
|
|
rect1.xmin = max_ii(rect1.xmax - min, rect->xmin);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
const float fac = BLI_rcti_size_y(rect) / size;
|
|
rect1.ymax = rect1.ymax - ceilf(fac * (value - but->softmin));
|
|
rect1.ymin = rect1.ymax - ceilf(fac * (height - but->softmin));
|
|
|
|
/* Ensure minimum size. */
|
|
const float min = BLI_rcti_size_x(rect);
|
|
|
|
if (BLI_rcti_size_y(&rect1) < min) {
|
|
rect1.ymax = rect1.ymin + min;
|
|
|
|
if (rect1.ymax > rect->ymax) {
|
|
rect1.ymax = rect->ymax;
|
|
rect1.ymin = max_ii(rect1.ymax - min, rect->ymin);
|
|
}
|
|
}
|
|
}
|
|
|
|
UI_draw_widget_scroll(wcol, rect, &rect1, (state->but_flag & UI_SELECT) ? UI_SCROLL_PRESSED : 0);
|
|
}
|
|
|
|
static void widget_progress_type_bar(uiButProgress *but_progress,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
rcti rect_prog = *rect, rect_bar = *rect;
|
|
|
|
uiWidgetBase wtb, wtb_bar;
|
|
widget_init(&wtb);
|
|
widget_init(&wtb_bar);
|
|
|
|
/* round corners */
|
|
const float factor = but_progress->progress_factor;
|
|
const float ofs = widget_radius_from_zoom(zoom, wcol);
|
|
float w = factor * BLI_rcti_size_x(&rect_prog);
|
|
|
|
/* Ensure minimum size. */
|
|
w = std::max(w, ofs);
|
|
|
|
rect_bar.xmax = rect_bar.xmin + w;
|
|
|
|
round_box_edges(&wtb, roundboxalign, &rect_prog, ofs);
|
|
round_box_edges(&wtb_bar, roundboxalign, &rect_bar, ofs);
|
|
|
|
wtb.draw_outline = true;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* "slider" bar color */
|
|
copy_v3_v3_uchar(wcol->inner, wcol->item);
|
|
widgetbase_draw(&wtb_bar, wcol);
|
|
}
|
|
|
|
/**
|
|
* Used for both ring & pie types.
|
|
*/
|
|
static void widget_progress_type_ring(uiButProgress *but_progress,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect)
|
|
{
|
|
const float ring_width = 0.6; /* 0.0 would be a pie. */
|
|
const float outer_rad = (rect->ymax - rect->ymin) / 2.0f;
|
|
const float inner_rad = outer_rad * ring_width;
|
|
const float x = rect->xmin + outer_rad;
|
|
const float y = rect->ymin + outer_rad;
|
|
const float start = 0.0f;
|
|
const float end = but_progress->progress_factor * 360.0f;
|
|
GPUVertFormat *format = immVertexFormat();
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
immUniformColor3ubvAlpha(wcol->item, 255 / UI_PIXEL_AA_JITTER * 2);
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
|
|
for (int i = 0; i < UI_PIXEL_AA_JITTER; i++) {
|
|
imm_draw_disk_partial_fill_2d(pos,
|
|
x + ui_pixel_jitter[i][0],
|
|
y + ui_pixel_jitter[i][1],
|
|
inner_rad,
|
|
outer_rad,
|
|
48,
|
|
start,
|
|
end);
|
|
}
|
|
immUnbindProgram();
|
|
|
|
if (but_progress->drawstr[0]) {
|
|
rect->xmin += UI_UNIT_X;
|
|
}
|
|
}
|
|
|
|
static void widget_progress_indicator(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiButProgress *but_progress = static_cast<uiButProgress *>(but);
|
|
switch (but_progress->progress_type) {
|
|
case blender::ui::ButProgressType::Bar: {
|
|
widget_progress_type_bar(but_progress, wcol, rect, roundboxalign, zoom);
|
|
break;
|
|
}
|
|
case blender::ui::ButProgressType::Ring: {
|
|
widget_progress_type_ring(but_progress, wcol, rect);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void widget_nodesocket(uiBut *but,
|
|
uiWidgetColors * /*wcol*/,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int /*roundboxalign*/,
|
|
const float zoom)
|
|
{
|
|
blender::ColorTheme4f socket_color;
|
|
rgba_uchar_to_float(socket_color, but->col);
|
|
|
|
blender::ColorTheme4f outline_color;
|
|
UI_GetThemeColorType4fv(TH_WIRE, SPACE_NODE, outline_color);
|
|
outline_color.a = 1.0f;
|
|
|
|
const int cent_x = BLI_rcti_cent_x(rect);
|
|
const int cent_y = BLI_rcti_cent_y(rect);
|
|
const int socket_radius = 0.25f * BLI_rcti_size_y(rect);
|
|
|
|
rctf socket_rect;
|
|
socket_rect.xmin = cent_x - socket_radius;
|
|
socket_rect.xmax = cent_x + socket_radius;
|
|
socket_rect.ymin = cent_y - socket_radius;
|
|
socket_rect.ymax = cent_y + socket_radius;
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
blender::ed::space_node::node_draw_nodesocket(&socket_rect,
|
|
socket_color,
|
|
outline_color,
|
|
U.pixelsize,
|
|
SOCK_DISPLAY_SHAPE_CIRCLE,
|
|
1.0f / zoom);
|
|
}
|
|
|
|
static void widget_numslider(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb, wtb1;
|
|
widget_init(&wtb);
|
|
widget_init(&wtb1);
|
|
|
|
/* Backdrop first. */
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
wtb.draw_outline = false;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* Draw slider part only when not in text editing. */
|
|
if (!state->is_text_input && !(but->drawflag & UI_BUT_INDETERMINATE)) {
|
|
int roundboxalign_slider = roundboxalign;
|
|
|
|
uchar outline[3];
|
|
copy_v3_v3_uchar(outline, wcol->outline);
|
|
copy_v3_v3_uchar(wcol->outline, wcol->item);
|
|
copy_v3_v3_uchar(wcol->inner, wcol->item);
|
|
|
|
if (!(state->but_flag & UI_SELECT)) {
|
|
std::swap(wcol->shadetop, wcol->shadedown);
|
|
}
|
|
|
|
rcti rect1 = *rect;
|
|
float factor, factor_ui;
|
|
float factor_discard = 1.0f; /* No discard. */
|
|
const float value = float(ui_but_value_get(but));
|
|
const float softmin = but->softmin;
|
|
const float softmax = but->softmax;
|
|
const float softrange = softmax - softmin;
|
|
const PropertyScaleType scale_type = ui_but_scale_type(but);
|
|
|
|
switch (scale_type) {
|
|
case PROP_SCALE_LINEAR: {
|
|
if (but->rnaprop && (RNA_property_subtype(but->rnaprop) == PROP_PERCENTAGE)) {
|
|
factor = value / softmax;
|
|
}
|
|
else {
|
|
factor = (value - softmin) / softrange;
|
|
}
|
|
break;
|
|
}
|
|
case PROP_SCALE_LOG: {
|
|
const float logmin = fmaxf(softmin, 0.5e-8f);
|
|
const float base = softmax / logmin;
|
|
factor = logf(value / logmin) / logf(base);
|
|
break;
|
|
}
|
|
case PROP_SCALE_CUBIC: {
|
|
const float cubicmin = cube_f(softmin);
|
|
const float cubicmax = cube_f(softmax);
|
|
const float cubicrange = cubicmax - cubicmin;
|
|
const float f = (value - softmin) * cubicrange / softrange + cubicmin;
|
|
factor = (cbrtf(f) - softmin) / softrange;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const float width = float(BLI_rcti_size_x(rect));
|
|
factor_ui = factor * width;
|
|
/* The rectangle width needs to be at least twice the corner radius for the round corners
|
|
* to be drawn properly. */
|
|
const float min_width = 2.0f * rad;
|
|
|
|
if (factor_ui > width - rad) {
|
|
/* Left part + middle part + right part. */
|
|
factor_discard = factor;
|
|
}
|
|
else if (factor_ui > min_width) {
|
|
/* Left part + middle part. */
|
|
roundboxalign_slider &= ~(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
|
|
rect1.xmax = rect1.xmin + factor_ui;
|
|
}
|
|
else {
|
|
/* Left part */
|
|
roundboxalign_slider &= ~(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
|
|
rect1.xmax = rect1.xmin + min_width;
|
|
factor_discard = factor_ui / min_width;
|
|
}
|
|
|
|
round_box_edges(&wtb1, roundboxalign_slider, &rect1, rad);
|
|
wtb1.draw_outline = false;
|
|
widgetbase_set_uniform_discard_factor(&wtb1, factor_discard);
|
|
widgetbase_draw(&wtb1, wcol);
|
|
|
|
copy_v3_v3_uchar(wcol->outline, outline);
|
|
|
|
if (!(state->but_flag & UI_SELECT)) {
|
|
std::swap(wcol->shadetop, wcol->shadedown);
|
|
}
|
|
}
|
|
|
|
/* Outline. */
|
|
wtb.draw_outline = true;
|
|
wtb.draw_inner = false;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* Add space at either side of the button so text aligns with number-buttons
|
|
* (which have arrow icons). */
|
|
if (!state->is_text_input) {
|
|
const float text_padding = NUM_BUT_PADDING_FACTOR * BLI_rcti_size_y(rect);
|
|
rect->xmax -= text_padding;
|
|
rect->xmin += text_padding;
|
|
}
|
|
}
|
|
|
|
/* I think 3 is sufficient border to indicate keyed status */
|
|
#define SWATCH_KEYED_BORDER 3
|
|
|
|
static void widget_swatch(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
BLI_assert(but->type == ButType::Color);
|
|
uiButColor *color_but = (uiButColor *)but;
|
|
float col[4];
|
|
|
|
col[3] = 1.0f;
|
|
|
|
if (but->rnaprop) {
|
|
BLI_assert(but->rnaindex == -1);
|
|
|
|
if (RNA_property_array_length(&but->rnapoin, but->rnaprop) >= 4) {
|
|
col[3] = RNA_property_float_get_index(&but->rnapoin, but->rnaprop, 3);
|
|
}
|
|
}
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
ui_but_v3_get(but, col);
|
|
|
|
if (but->drawflag & UI_BUT_INDETERMINATE) {
|
|
col[0] = col[1] = col[2] = col[3] = 0.5f;
|
|
}
|
|
|
|
if ((state->but_flag & (UI_BUT_ANIMATED | UI_BUT_ANIMATED_KEY | UI_BUT_DRIVEN |
|
|
UI_BUT_OVERRIDDEN | UI_BUT_REDALERT)) ||
|
|
(state->but_drawflag & UI_BUT_ANIMATED_CHANGED))
|
|
{
|
|
/* draw based on state - color for keyed etc */
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* inset to draw swatch color */
|
|
rect->xmin += SWATCH_KEYED_BORDER;
|
|
rect->xmax -= SWATCH_KEYED_BORDER;
|
|
rect->ymin += SWATCH_KEYED_BORDER;
|
|
rect->ymax -= SWATCH_KEYED_BORDER;
|
|
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
}
|
|
|
|
if (!ui_but_is_color_gamma(but)) {
|
|
ui_block_cm_to_display_space_v3(but->block, col);
|
|
}
|
|
|
|
rgba_float_to_uchar(wcol->inner, col);
|
|
const bool show_alpha_checkers = (wcol->inner[3] < 255);
|
|
|
|
wcol->shaded = 0;
|
|
|
|
/* Now we reduce alpha of the inner color (i.e. the color shown)
|
|
* so that this setting can look grayed out, while retaining
|
|
* the checkerboard (for transparent values). This is needed
|
|
* here as the effects of ui_widget_color_disabled() are overwritten. */
|
|
wcol->inner[3] *= widget_alpha_factor(state);
|
|
|
|
widgetbase_draw_ex(&wtb, wcol, show_alpha_checkers);
|
|
if (color_but->is_pallete_color &&
|
|
((Palette *)but->rnapoin.owner_id)->active_color == color_but->palette_color_index)
|
|
{
|
|
const float width = rect->xmax - rect->xmin;
|
|
const float height = rect->ymax - rect->ymin;
|
|
/* find color luminance and change it slightly */
|
|
float bw = srgb_to_grayscale(col);
|
|
|
|
bw += (bw < 0.5f) ? 0.5f : -0.5f;
|
|
|
|
/* We are drawing on top of widget bases. Flush cache. */
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
immUniformColor3f(bw, bw, bw);
|
|
immBegin(GPU_PRIM_TRIS, 3);
|
|
immVertex2f(pos, rect->xmin + 0.1f * width, rect->ymin + 0.9f * height);
|
|
immVertex2f(pos, rect->xmin + 0.1f * width, rect->ymin + 0.5f * height);
|
|
immVertex2f(pos, rect->xmin + 0.5f * width, rect->ymin + 0.9f * height);
|
|
immEnd();
|
|
|
|
immUnbindProgram();
|
|
}
|
|
}
|
|
|
|
static void widget_unitvec(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int /*roundboxalign*/,
|
|
const float zoom)
|
|
{
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
ui_draw_but_UNITVEC(but, wcol, rect, rad);
|
|
}
|
|
|
|
static void widget_icon_has_anim(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
if (state->but_flag & (UI_BUT_ANIMATED | UI_BUT_ANIMATED_KEY | UI_BUT_DRIVEN |
|
|
UI_BUT_OVERRIDDEN | UI_BUT_REDALERT) &&
|
|
but->emboss != blender::ui::EmbossType::None)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
wtb.draw_outline = false;
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
else if (but->type == ButType::Num) {
|
|
/* Draw number buttons still with left/right
|
|
* triangles when field is not embossed */
|
|
widget_numbut_embossn(but, wcol, rect, state, roundboxalign, zoom);
|
|
}
|
|
else if (but->type == ButType::Menu) {
|
|
/* Draw menu buttons still with down arrow. */
|
|
widget_menubut_embossn(but, wcol, rect, state, roundboxalign);
|
|
}
|
|
}
|
|
|
|
static void widget_textbut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
if (state->but_flag & UI_SELECT) {
|
|
std::swap(wcol->shadetop, wcol->shadedown);
|
|
}
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_menuiconbut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
/* decoration */
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_pulldownbut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
float back[4];
|
|
UI_GetThemeColor4fv(TH_BACK, back);
|
|
|
|
if ((state->but_flag & UI_HOVER) || (back[3] < 1.0f)) {
|
|
uiWidgetBase wtb;
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
|
|
if (state->but_flag & UI_HOVER) {
|
|
copy_v4_v4_uchar(wcol->inner, wcol->inner_sel);
|
|
copy_v3_v3_uchar(wcol->text, wcol->text_sel);
|
|
}
|
|
else {
|
|
wcol->inner[3] *= 1.0f - back[3];
|
|
wcol->outline[3] = 0.0f;
|
|
}
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
}
|
|
|
|
static void widget_menu_itembut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int /*roundboxalign*/,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
/* Padding on the sides. */
|
|
const float padding = zoom * 0.125f * U.widget_unit;
|
|
rect->xmin += padding;
|
|
rect->xmax -= padding;
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
|
|
round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_menu_itembut_unpadded(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int /*roundboxalign*/,
|
|
const float zoom)
|
|
{
|
|
/* This function is used for menu items placed close to each other horizontally, e.g. the matcap
|
|
* preview popup or the row of collection color icons in the Outliner context menu. Don't use
|
|
* padding on the sides like the normal menu item. */
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
/* No outline. */
|
|
wtb.draw_outline = false;
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_menu_pie_itembut(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int /*roundboxalign*/,
|
|
const float zoom)
|
|
{
|
|
const float fac = but->block->pie_data.alphafac;
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
wtb.draw_emboss = false;
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
|
|
|
|
wcol->inner[3] *= fac;
|
|
wcol->inner_sel[3] *= fac;
|
|
wcol->item[3] *= fac;
|
|
wcol->text[3] *= fac;
|
|
wcol->text_sel[3] *= fac;
|
|
wcol->outline[3] *= fac;
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_list_itembut(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int /*roundboxalign*/,
|
|
const float zoom)
|
|
{
|
|
rcti draw_rect = *rect;
|
|
bool is_selected = state->but_flag & UI_SELECT;
|
|
|
|
if (but->type == ButType::ViewItem) {
|
|
uiButViewItem *item_but = static_cast<uiButViewItem *>(but);
|
|
blender::ui::AbstractViewItem &view_item = *item_but->view_item;
|
|
|
|
if (!view_item.is_active() && view_item.is_selected()) {
|
|
copy_v4_v4_uchar(wcol->inner, wcol->inner_sel);
|
|
color_blend_v3_v3(wcol->inner, wcol->outline, 0.5);
|
|
is_selected = true;
|
|
}
|
|
if (item_but->draw_width > 0) {
|
|
BLI_rcti_resize_x(&draw_rect, zoom * item_but->draw_width);
|
|
}
|
|
if (item_but->draw_height > 0) {
|
|
BLI_rcti_resize_y(&draw_rect, zoom * item_but->draw_height);
|
|
}
|
|
}
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, UI_CNR_ALL, &draw_rect, rad);
|
|
|
|
if (state->but_flag & UI_HOVER) {
|
|
color_blend_v3_v3(wcol->inner, wcol->text, 0.2);
|
|
wcol->inner[3] = is_selected ? 255 : 20;
|
|
}
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_preview_tile(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
if (!ELEM(but->emboss, blender::ui::EmbossType::None, blender::ui::EmbossType::NoneOrStatus)) {
|
|
widget_list_itembut(but, wcol, rect, state, roundboxalign, zoom);
|
|
}
|
|
|
|
const BIFIconID icon = ui_but_icon(but);
|
|
ui_draw_preview_item_stateless(&UI_style_get()->widget,
|
|
rect,
|
|
but->drawstr,
|
|
icon,
|
|
wcol->text,
|
|
UI_STYLE_TEXT_CENTER,
|
|
!(but->drawflag & UI_BUT_NO_PREVIEW_PADDING));
|
|
}
|
|
|
|
static void widget_optionbut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int /*roundboxalign*/,
|
|
const float /*zoom*/)
|
|
{
|
|
/* For a right aligned layout (signified by #UI_BUT_TEXT_RIGHT), draw the text on the left of the
|
|
* checkbox. */
|
|
const bool text_before_widget = (state->but_drawflag & UI_BUT_TEXT_RIGHT);
|
|
rcti recttemp = *rect;
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
/* square */
|
|
if (text_before_widget) {
|
|
recttemp.xmin = recttemp.xmax - BLI_rcti_size_y(&recttemp);
|
|
}
|
|
else {
|
|
recttemp.xmax = recttemp.xmin + BLI_rcti_size_y(&recttemp);
|
|
}
|
|
|
|
/* smaller */
|
|
const int delta = (BLI_rcti_size_y(&recttemp) - 2 * U.pixelsize) / 6;
|
|
BLI_rcti_resize(
|
|
&recttemp, BLI_rcti_size_x(&recttemp) - delta * 2, BLI_rcti_size_y(&recttemp) - delta * 2);
|
|
/* Keep one edge in place. */
|
|
BLI_rcti_translate(&recttemp, text_before_widget ? delta : -delta, 0);
|
|
|
|
if (state->but_drawflag & UI_BUT_INDETERMINATE) {
|
|
/* The same muted background color regardless of state. */
|
|
color_blend_v4_v4v4(wcol->inner, wcol->inner, wcol->inner_sel, 0.75f);
|
|
}
|
|
|
|
const float rad = widget_radius_from_rcti(&recttemp, wcol);
|
|
round_box_edges(&wtb, UI_CNR_ALL, &recttemp, rad);
|
|
|
|
/* decoration */
|
|
if (state->but_drawflag & UI_BUT_INDETERMINATE) {
|
|
shape_preset_trias_from_rect_dash(&wtb.tria1, &recttemp);
|
|
}
|
|
else if (state->but_flag & UI_SELECT) {
|
|
shape_preset_trias_from_rect_checkmark(&wtb.tria1, &recttemp);
|
|
}
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* Text space - factor is really just eyeballed. */
|
|
const float offset = delta * 0.9;
|
|
if (text_before_widget) {
|
|
rect->xmax = recttemp.xmin - offset;
|
|
}
|
|
else {
|
|
rect->xmin = recttemp.xmax + offset;
|
|
}
|
|
}
|
|
|
|
/* labels use Editor theme colors for text */
|
|
static void widget_state_label(uiWidgetType *wt,
|
|
const uiWidgetStateInfo *state,
|
|
blender::ui::EmbossType emboss)
|
|
{
|
|
if (state->but_flag & UI_BUT_LIST_ITEM) {
|
|
/* Override default label theme's colors. */
|
|
bTheme *btheme = UI_GetTheme();
|
|
wt->wcol_theme = &btheme->tui.wcol_list_item;
|
|
/* call this for option button */
|
|
widget_state(wt, state, emboss);
|
|
}
|
|
else {
|
|
/* call this for option button */
|
|
widget_state(wt, state, emboss);
|
|
if (state->but_flag & UI_SELECT) {
|
|
UI_GetThemeColor3ubv(TH_TEXT_HI, wt->wcol.text);
|
|
}
|
|
else {
|
|
UI_GetThemeColor3ubv(TH_TEXT, wt->wcol.text);
|
|
}
|
|
}
|
|
|
|
if (state->but_flag & UI_BUT_REDALERT) {
|
|
uchar red[4];
|
|
UI_GetThemeColor3ubv(TH_REDALERT, red);
|
|
color_mul_hsl_v3(red, 1.0f, 1.5f, 1.5f);
|
|
color_blend_v3_v3(wt->wcol.text, red, 0.5f);
|
|
}
|
|
}
|
|
|
|
static void widget_radiobut(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_box(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
uchar old_col[3];
|
|
copy_v3_v3_uchar(old_col, wcol->inner);
|
|
|
|
/* abuse but->hsv - if it's non-zero, use this color as the box's background */
|
|
if (but != nullptr && but->col[3]) {
|
|
wcol->inner[0] = but->col[0];
|
|
wcol->inner[1] = but->col[1];
|
|
wcol->inner[2] = but->col[2];
|
|
wcol->inner[3] = but->col[3];
|
|
}
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
wtb.draw_emboss = draw_emboss(but);
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
copy_v3_v3_uchar(wcol->inner, old_col);
|
|
|
|
/* Flush the cache so that we don't draw over contents. #125035 */
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
static void widget_but(uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo * /*state*/,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
#if 0
|
|
static void widget_roundbut(uiWidgetColors *wcol, rcti *rect, int /*state*/ int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
const float rad = wcol->roundness * U.widget_unit;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
#endif
|
|
|
|
static void widget_roundbut_exec(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
if (state->has_hold_action) {
|
|
/* Show that keeping pressed performs another action (typically a menu). */
|
|
shape_preset_init_hold_action(&wtb.tria1, rect, 0.75f, 'r');
|
|
}
|
|
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
wtb.draw_emboss = draw_emboss(but);
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_tab(uiBut *but,
|
|
uiWidgetColors *wcol,
|
|
rcti *rect,
|
|
const uiWidgetStateInfo *state,
|
|
int roundboxalign,
|
|
const float zoom)
|
|
{
|
|
const float rad = widget_radius_from_zoom(zoom, wcol);
|
|
const bool is_active = (state->but_flag & UI_SELECT);
|
|
|
|
/* Draw shaded outline - Disabled for now,
|
|
* seems incorrect and also looks nicer without it IMHO ;). */
|
|
// #define USE_TAB_SHADED_HIGHLIGHT
|
|
|
|
uchar theme_col_tab_highlight[3];
|
|
|
|
#ifdef USE_TAB_SHADED_HIGHLIGHT
|
|
/* create outline highlight colors */
|
|
if (is_active) {
|
|
interp_v3_v3v3_uchar(theme_col_tab_highlight, wcol->inner_sel, wcol->outline, 0.2f);
|
|
}
|
|
else {
|
|
interp_v3_v3v3_uchar(theme_col_tab_highlight, wcol->inner, wcol->outline, 0.12f);
|
|
}
|
|
#endif
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
/* draw inner */
|
|
#ifdef USE_TAB_SHADED_HIGHLIGHT
|
|
wtb.draw_outline = 0;
|
|
#endif
|
|
wtb.draw_emboss = draw_emboss(but);
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* We are drawing on top of widget bases. Flush cache. */
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_widgetbase_draw_cache_flush();
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
#ifdef USE_TAB_SHADED_HIGHLIGHT
|
|
/* draw outline (3d look) */
|
|
ui_draw_but_TAB_outline(rect, rad, theme_col_tab_highlight, wcol->inner);
|
|
#endif
|
|
|
|
#ifndef USE_TAB_SHADED_HIGHLIGHT
|
|
UNUSED_VARS(is_active, theme_col_tab_highlight);
|
|
#endif
|
|
}
|
|
|
|
static void widget_draw_extra_mask(const bContext *C, uiBut *but, uiWidgetType *wt, rcti *rect)
|
|
{
|
|
bTheme *btheme = UI_GetTheme();
|
|
uiWidgetColors *wcol = &btheme->tui.wcol_radio;
|
|
const float rad = wcol->roundness * U.widget_unit;
|
|
|
|
/* state copy! */
|
|
wt->wcol = *(wt->wcol_theme);
|
|
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
if (but->block->drawextra) {
|
|
/* NOTE: drawextra can change rect +1 or -1, to match round errors of existing previews. */
|
|
but->block->drawextra(C, rect);
|
|
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
/* make mask to draw over image */
|
|
uchar col[4];
|
|
UI_GetThemeColor3ubv(TH_BACK, col);
|
|
immUniformColor3ubv(col);
|
|
|
|
round_box__edges(&wtb, UI_CNR_ALL, rect, 0.0f, rad);
|
|
widgetbase_outline(&wtb, pos);
|
|
|
|
immUnbindProgram();
|
|
}
|
|
|
|
/* outline */
|
|
round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
|
|
wtb.draw_outline = true;
|
|
wtb.draw_inner = false;
|
|
widgetbase_draw(&wtb, &wt->wcol);
|
|
}
|
|
|
|
static uiWidgetType *widget_type(uiWidgetTypeEnum type)
|
|
{
|
|
bTheme *btheme = UI_GetTheme();
|
|
|
|
/* defaults */
|
|
static uiWidgetType wt;
|
|
wt.wcol_theme = &btheme->tui.wcol_regular;
|
|
wt.wcol_state = &btheme->tui.wcol_state;
|
|
wt.state = widget_state;
|
|
wt.draw = widget_but;
|
|
wt.custom = nullptr;
|
|
wt.text = widget_draw_text_icon;
|
|
|
|
switch (type) {
|
|
case UI_WTYPE_REGULAR:
|
|
break;
|
|
|
|
case UI_WTYPE_LABEL:
|
|
wt.draw = nullptr;
|
|
wt.state = widget_state_label;
|
|
break;
|
|
|
|
case UI_WTYPE_TOGGLE:
|
|
wt.wcol_theme = &btheme->tui.wcol_toggle;
|
|
break;
|
|
|
|
case UI_WTYPE_CHECKBOX:
|
|
wt.wcol_theme = &btheme->tui.wcol_option;
|
|
wt.draw = widget_optionbut;
|
|
break;
|
|
|
|
case UI_WTYPE_RADIO:
|
|
wt.wcol_theme = &btheme->tui.wcol_radio;
|
|
wt.draw = widget_radiobut;
|
|
break;
|
|
|
|
case UI_WTYPE_NUMBER:
|
|
wt.wcol_theme = &btheme->tui.wcol_num;
|
|
wt.custom = widget_numbut;
|
|
break;
|
|
|
|
case UI_WTYPE_SLIDER:
|
|
wt.wcol_theme = &btheme->tui.wcol_numslider;
|
|
wt.custom = widget_numslider;
|
|
wt.state = widget_state_numslider;
|
|
break;
|
|
|
|
case UI_WTYPE_EXEC:
|
|
wt.wcol_theme = &btheme->tui.wcol_tool;
|
|
wt.custom = widget_roundbut_exec;
|
|
break;
|
|
|
|
case UI_WTYPE_TOOLBAR_ITEM:
|
|
wt.wcol_theme = &btheme->tui.wcol_toolbar_item;
|
|
wt.custom = widget_roundbut_exec;
|
|
break;
|
|
|
|
case UI_WTYPE_TAB:
|
|
wt.wcol_theme = &btheme->tui.wcol_tab;
|
|
wt.custom = widget_tab;
|
|
break;
|
|
|
|
case UI_WTYPE_TOOLTIP:
|
|
wt.wcol_theme = &btheme->tui.wcol_tooltip;
|
|
wt.draw_block = widget_menu_back;
|
|
break;
|
|
|
|
/* strings */
|
|
case UI_WTYPE_NAME:
|
|
wt.wcol_theme = &btheme->tui.wcol_text;
|
|
wt.draw = widget_textbut;
|
|
break;
|
|
|
|
case UI_WTYPE_NAME_LINK:
|
|
break;
|
|
|
|
case UI_WTYPE_POINTER_LINK:
|
|
break;
|
|
|
|
case UI_WTYPE_FILENAME:
|
|
break;
|
|
|
|
/* start menus */
|
|
case UI_WTYPE_MENU_RADIO:
|
|
wt.wcol_theme = &btheme->tui.wcol_menu;
|
|
wt.draw = widget_menubut;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_ICON_RADIO:
|
|
case UI_WTYPE_MENU_NODE_LINK:
|
|
wt.wcol_theme = &btheme->tui.wcol_menu;
|
|
wt.draw = widget_menuiconbut;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_POINTER_LINK:
|
|
wt.wcol_theme = &btheme->tui.wcol_menu;
|
|
wt.draw = widget_menubut;
|
|
break;
|
|
|
|
case UI_WTYPE_PULLDOWN:
|
|
wt.wcol_theme = &btheme->tui.wcol_pulldown;
|
|
wt.draw = widget_pulldownbut;
|
|
wt.state = widget_state_pulldown;
|
|
break;
|
|
|
|
/* in menus */
|
|
case UI_WTYPE_MENU_ITEM:
|
|
wt.wcol_theme = &btheme->tui.wcol_menu_item;
|
|
wt.draw = widget_menu_itembut;
|
|
wt.state = widget_state_menu_item;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_ITEM_UNPADDED:
|
|
wt.wcol_theme = &btheme->tui.wcol_menu_item;
|
|
wt.draw = widget_menu_itembut_unpadded;
|
|
wt.state = widget_state_menu_item;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_BACK:
|
|
wt.wcol_theme = &btheme->tui.wcol_menu_back;
|
|
wt.draw_block = widget_menu_back;
|
|
break;
|
|
|
|
/* specials */
|
|
case UI_WTYPE_ICON:
|
|
wt.custom = widget_icon_has_anim;
|
|
break;
|
|
|
|
case UI_WTYPE_ICON_LABEL:
|
|
/* behave like regular labels (this is simply a label with an icon) */
|
|
wt.state = widget_state_label;
|
|
wt.custom = widget_icon_has_anim;
|
|
break;
|
|
|
|
case UI_WTYPE_PREVIEW_TILE:
|
|
wt.draw = nullptr;
|
|
/* Drawn via the `custom` callback. */
|
|
wt.text = nullptr;
|
|
/* Drawing indicates state well enough. No need to change colors further. */
|
|
wt.state = widget_state_nothing;
|
|
wt.custom = widget_preview_tile;
|
|
wt.wcol_theme = &btheme->tui.wcol_list_item;
|
|
break;
|
|
|
|
case UI_WTYPE_SWATCH:
|
|
wt.custom = widget_swatch;
|
|
break;
|
|
|
|
case UI_WTYPE_BOX:
|
|
wt.custom = widget_box;
|
|
wt.wcol_theme = &btheme->tui.wcol_box;
|
|
break;
|
|
|
|
case UI_WTYPE_RGB_PICKER:
|
|
break;
|
|
|
|
case UI_WTYPE_UNITVEC:
|
|
wt.custom = widget_unitvec;
|
|
break;
|
|
|
|
case UI_WTYPE_SCROLL:
|
|
wt.wcol_theme = &btheme->tui.wcol_scroll;
|
|
wt.state = widget_state_nothing;
|
|
wt.custom = widget_scroll;
|
|
break;
|
|
|
|
case UI_WTYPE_LISTITEM:
|
|
case UI_WTYPE_VIEW_ITEM:
|
|
wt.wcol_theme = &btheme->tui.wcol_list_item;
|
|
wt.custom = widget_list_itembut;
|
|
break;
|
|
|
|
case UI_WTYPE_PROGRESS:
|
|
wt.wcol_theme = &btheme->tui.wcol_progress;
|
|
wt.custom = widget_progress_indicator;
|
|
break;
|
|
|
|
case UI_WTYPE_NODESOCKET:
|
|
wt.custom = widget_nodesocket;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_ITEM_PIE:
|
|
wt.wcol_theme = &btheme->tui.wcol_pie_menu;
|
|
wt.custom = widget_menu_pie_itembut;
|
|
wt.state = widget_state_pie_menu_item;
|
|
break;
|
|
}
|
|
|
|
return &wt;
|
|
}
|
|
|
|
static int widget_roundbox_set(uiBut *but, rcti *rect)
|
|
{
|
|
int roundbox = UI_CNR_ALL;
|
|
|
|
/* alignment */
|
|
if ((but->drawflag & UI_BUT_ALIGN) && but->type != ButType::Pulldown) {
|
|
|
|
/* ui_popup_block_position has this correction too, keep in sync */
|
|
if (but->drawflag & (UI_BUT_ALIGN_TOP | UI_BUT_ALIGN_STITCH_TOP)) {
|
|
rect->ymax += U.pixelsize;
|
|
}
|
|
if (but->drawflag & (UI_BUT_ALIGN_LEFT | UI_BUT_ALIGN_STITCH_LEFT)) {
|
|
rect->xmin -= U.pixelsize;
|
|
}
|
|
|
|
switch (but->drawflag & UI_BUT_ALIGN) {
|
|
case UI_BUT_ALIGN_TOP:
|
|
roundbox = UI_CNR_BOTTOM_LEFT | UI_CNR_BOTTOM_RIGHT;
|
|
break;
|
|
case UI_BUT_ALIGN_DOWN:
|
|
roundbox = UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT;
|
|
break;
|
|
case UI_BUT_ALIGN_LEFT:
|
|
roundbox = UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT;
|
|
break;
|
|
case UI_BUT_ALIGN_RIGHT:
|
|
roundbox = UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT;
|
|
break;
|
|
case UI_BUT_ALIGN_DOWN | UI_BUT_ALIGN_RIGHT:
|
|
roundbox = UI_CNR_TOP_LEFT;
|
|
break;
|
|
case UI_BUT_ALIGN_DOWN | UI_BUT_ALIGN_LEFT:
|
|
roundbox = UI_CNR_TOP_RIGHT;
|
|
break;
|
|
case UI_BUT_ALIGN_TOP | UI_BUT_ALIGN_RIGHT:
|
|
roundbox = UI_CNR_BOTTOM_LEFT;
|
|
break;
|
|
case UI_BUT_ALIGN_TOP | UI_BUT_ALIGN_LEFT:
|
|
roundbox = UI_CNR_BOTTOM_RIGHT;
|
|
break;
|
|
default:
|
|
roundbox = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* align with open menu */
|
|
if (but->active && (but->type != ButType::Popover) && !ui_but_menu_draw_as_popover(but)) {
|
|
const int direction = ui_but_menu_direction(but);
|
|
|
|
/* Pull-down menus that open above or below a button can have more than one direction. */
|
|
if (direction & UI_DIR_UP) {
|
|
roundbox &= ~(UI_CNR_TOP_RIGHT | UI_CNR_TOP_LEFT);
|
|
}
|
|
else if (direction & UI_DIR_DOWN) {
|
|
roundbox &= ~(UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT);
|
|
}
|
|
else if (direction == UI_DIR_LEFT) {
|
|
roundbox &= ~(UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT);
|
|
}
|
|
else if (direction == UI_DIR_RIGHT) {
|
|
roundbox &= ~(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
|
|
}
|
|
}
|
|
|
|
return roundbox;
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Public API
|
|
* \{ */
|
|
|
|
void ui_draw_but(const bContext *C, ARegion *region, uiStyle *style, uiBut *but, rcti *rect)
|
|
{
|
|
bTheme *btheme = UI_GetTheme();
|
|
const ThemeUI *tui = &btheme->tui;
|
|
const uiFontStyle *fstyle = &style->widget;
|
|
uiWidgetType *wt = nullptr;
|
|
|
|
/* handle menus separately */
|
|
if (but->emboss == blender::ui::EmbossType::Pulldown) {
|
|
switch (but->type) {
|
|
case ButType::Label:
|
|
widget_draw_text_icon(&style->widget, &tui->wcol_menu_back, but, rect);
|
|
break;
|
|
case ButType::Sepr:
|
|
break;
|
|
case ButType::SeprLine:
|
|
/* Add horizontal padding between the line and menu sides. */
|
|
BLI_rcti_pad(rect, int(-7.0f * UI_SCALE_FAC), 0);
|
|
ui_draw_separator(&tui->wcol_menu_item, but, rect);
|
|
break;
|
|
default: {
|
|
const bool use_unpadded = (but->flag & UI_BUT_ICON_PREVIEW) ||
|
|
((but->flag & UI_HAS_ICON) && !but->drawstr[0]);
|
|
wt = widget_type(use_unpadded ? UI_WTYPE_MENU_ITEM_UNPADDED : UI_WTYPE_MENU_ITEM);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (ELEM(but->emboss, blender::ui::EmbossType::None, blender::ui::EmbossType::NoneOrStatus))
|
|
{
|
|
/* Use the same widget types for both no emboss types. Later on,
|
|
* #blender::ui::EmbossType::NoneOrStatus will blend state colors if they apply. */
|
|
switch (but->type) {
|
|
case ButType::Label:
|
|
case ButType::Text:
|
|
wt = widget_type(UI_WTYPE_ICON_LABEL);
|
|
if (!(but->flag & UI_HAS_ICON)) {
|
|
but->drawflag |= UI_BUT_NO_TEXT_PADDING;
|
|
}
|
|
break;
|
|
case ButType::PreviewTile:
|
|
wt = widget_type(UI_WTYPE_PREVIEW_TILE);
|
|
break;
|
|
case ButType::NodeSocket:
|
|
wt = widget_type(UI_WTYPE_NODESOCKET);
|
|
break;
|
|
default:
|
|
wt = widget_type(UI_WTYPE_ICON);
|
|
break;
|
|
}
|
|
}
|
|
else if (but->emboss == blender::ui::EmbossType::PieMenu) {
|
|
wt = widget_type(UI_WTYPE_MENU_ITEM_PIE);
|
|
}
|
|
else {
|
|
BLI_assert(but->emboss == blender::ui::EmbossType::Emboss);
|
|
|
|
switch (but->type) {
|
|
case ButType::Label:
|
|
wt = widget_type(UI_WTYPE_LABEL);
|
|
if (but->drawflag & UI_BUT_BOX_ITEM) {
|
|
wt->wcol_theme = &tui->wcol_box;
|
|
wt->state = widget_state;
|
|
}
|
|
else if (but->block->theme_style == UI_BLOCK_THEME_STYLE_POPUP) {
|
|
wt->wcol_theme = &tui->wcol_menu_back;
|
|
wt->state = widget_state;
|
|
}
|
|
if (!(but->flag & UI_HAS_ICON)) {
|
|
but->drawflag |= UI_BUT_NO_TEXT_PADDING;
|
|
}
|
|
break;
|
|
|
|
case ButType::Sepr:
|
|
case ButType::SeprSpacer:
|
|
break;
|
|
case ButType::SeprLine:
|
|
ui_draw_separator(&tui->wcol_menu_item, but, rect);
|
|
break;
|
|
|
|
case ButType::But:
|
|
case ButType::Decorator:
|
|
#ifdef USE_UI_TOOLBAR_HACK
|
|
if ((but->icon != ICON_NONE) && UI_but_is_tool(but)) {
|
|
wt = widget_type(UI_WTYPE_TOOLBAR_ITEM);
|
|
}
|
|
else {
|
|
wt = widget_type(UI_WTYPE_EXEC);
|
|
}
|
|
#else
|
|
wt = widget_type(UI_WTYPE_EXEC);
|
|
#endif
|
|
break;
|
|
|
|
case ButType::Num:
|
|
wt = widget_type(UI_WTYPE_NUMBER);
|
|
break;
|
|
|
|
case ButType::NumSlider:
|
|
wt = widget_type(UI_WTYPE_SLIDER);
|
|
break;
|
|
|
|
case ButType::Row:
|
|
wt = widget_type(UI_WTYPE_RADIO);
|
|
break;
|
|
|
|
case ButType::ListRow:
|
|
wt = widget_type(UI_WTYPE_LISTITEM);
|
|
break;
|
|
|
|
case ButType::Text:
|
|
wt = widget_type(UI_WTYPE_NAME);
|
|
break;
|
|
|
|
case ButType::SearchMenu:
|
|
wt = widget_type(UI_WTYPE_NAME);
|
|
break;
|
|
|
|
case ButType::Tab:
|
|
wt = widget_type(UI_WTYPE_TAB);
|
|
break;
|
|
|
|
case ButType::ButToggle:
|
|
case ButType::Toggle:
|
|
case ButType::ToggleN:
|
|
wt = widget_type(UI_WTYPE_TOGGLE);
|
|
break;
|
|
|
|
case ButType::Checkbox:
|
|
case ButType::CheckboxN:
|
|
if (!(but->flag & UI_HAS_ICON)) {
|
|
wt = widget_type(UI_WTYPE_CHECKBOX);
|
|
|
|
if ((but->drawflag & (UI_BUT_TEXT_LEFT | UI_BUT_TEXT_RIGHT)) == 0) {
|
|
but->drawflag |= UI_BUT_TEXT_LEFT;
|
|
}
|
|
/* #widget_optionbut() carefully sets the text rectangle for fine tuned paddings. If the
|
|
* text drawing were to add its own padding, DPI and zoom factor would be applied twice
|
|
* in the final padding, so it's difficult to control it. */
|
|
but->drawflag |= UI_BUT_NO_TEXT_PADDING;
|
|
}
|
|
else {
|
|
wt = widget_type(UI_WTYPE_TOGGLE);
|
|
}
|
|
|
|
/* option buttons have strings outside, on menus use different colors */
|
|
if (but->block->theme_style == UI_BLOCK_THEME_STYLE_POPUP) {
|
|
wt->state = widget_state_option_menu;
|
|
}
|
|
break;
|
|
|
|
case ButType::Menu:
|
|
case ButType::Block:
|
|
case ButType::Popover:
|
|
if (but->flag & UI_BUT_NODE_LINK) {
|
|
/* new node-link button, not active yet XXX */
|
|
wt = widget_type(UI_WTYPE_MENU_NODE_LINK);
|
|
}
|
|
else {
|
|
/* with menu arrows */
|
|
|
|
/* We could use a flag for this, but for now just check size,
|
|
* add up/down arrows if there is room. */
|
|
if ((but->str.empty() && but->icon &&
|
|
(BLI_rcti_size_x(rect) < BLI_rcti_size_y(rect) + 2)) ||
|
|
/* disable for brushes also */
|
|
(but->flag & UI_BUT_ICON_PREVIEW))
|
|
{
|
|
/* no arrows */
|
|
wt = widget_type(UI_WTYPE_MENU_ICON_RADIO);
|
|
}
|
|
else {
|
|
wt = widget_type(UI_WTYPE_MENU_RADIO);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ButType::Pulldown:
|
|
wt = widget_type(UI_WTYPE_PULLDOWN);
|
|
break;
|
|
|
|
case ButType::ButMenu:
|
|
wt = widget_type(UI_WTYPE_MENU_ITEM);
|
|
break;
|
|
|
|
case ButType::Color:
|
|
wt = widget_type(UI_WTYPE_SWATCH);
|
|
break;
|
|
|
|
case ButType::Roundbox:
|
|
case ButType::ListBox:
|
|
wt = widget_type(UI_WTYPE_BOX);
|
|
break;
|
|
|
|
case ButType::PreviewTile:
|
|
wt = widget_type(UI_WTYPE_PREVIEW_TILE);
|
|
break;
|
|
|
|
case ButType::Extra:
|
|
widget_draw_extra_mask(C, but, widget_type(UI_WTYPE_BOX), rect);
|
|
break;
|
|
|
|
case ButType::HsvCube: {
|
|
const uiButHSVCube *hsv_but = (uiButHSVCube *)but;
|
|
|
|
if (ELEM(hsv_but->gradient_type, UI_GRAD_V_ALT, UI_GRAD_L_ALT)) {
|
|
/* vertical V slider, uses new widget draw now */
|
|
ui_draw_but_HSV_v(but, rect);
|
|
}
|
|
else { /* other HSV pickers... */
|
|
ui_draw_but_HSVCUBE(but, rect);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ButType::HsvCircle:
|
|
ui_draw_but_HSVCIRCLE(but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::ColorBand: {
|
|
/* Horizontal padding to make room for handles at edges. */
|
|
const int padding = BLI_rcti_size_y(rect) / 6;
|
|
rect->xmin += padding;
|
|
rect->xmax -= padding;
|
|
ui_draw_but_COLORBAND(but, &tui->wcol_regular, rect);
|
|
break;
|
|
}
|
|
|
|
case ButType::Unitvec:
|
|
wt = widget_type(UI_WTYPE_UNITVEC);
|
|
break;
|
|
|
|
case ButType::Image:
|
|
ui_draw_but_IMAGE(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::Histogram:
|
|
ui_draw_but_HISTOGRAM(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::Waveform:
|
|
ui_draw_but_WAVEFORM(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::Vectorscope:
|
|
ui_draw_but_VECTORSCOPE(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::Curve:
|
|
ui_draw_but_CURVE(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::CurveProfile:
|
|
ui_draw_but_CURVEPROFILE(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::Progress:
|
|
wt = widget_type(UI_WTYPE_PROGRESS);
|
|
break;
|
|
|
|
case ButType::ViewItem:
|
|
wt = widget_type(UI_WTYPE_VIEW_ITEM);
|
|
break;
|
|
|
|
case ButType::Scroll:
|
|
wt = widget_type(UI_WTYPE_SCROLL);
|
|
break;
|
|
|
|
case ButType::Grip:
|
|
wt = widget_type(UI_WTYPE_ICON);
|
|
break;
|
|
|
|
case ButType::TrackPreview:
|
|
ui_draw_but_TRACKPREVIEW(region, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case ButType::NodeSocket:
|
|
wt = widget_type(UI_WTYPE_NODESOCKET);
|
|
break;
|
|
|
|
default:
|
|
wt = widget_type(UI_WTYPE_REGULAR);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (wt == nullptr) {
|
|
return;
|
|
}
|
|
|
|
// rcti disablerect = *rect; /* rect gets clipped smaller for text */
|
|
|
|
const int roundboxalign = widget_roundbox_set(but, rect);
|
|
|
|
uiWidgetStateInfo state = {0};
|
|
state.but_flag = but->flag;
|
|
state.but_drawflag = but->drawflag;
|
|
|
|
/* Override selected flag for drawing. */
|
|
if (but->flag & UI_SELECT_DRAW) {
|
|
state.but_flag |= UI_SELECT;
|
|
}
|
|
|
|
if ((but->editstr) ||
|
|
(UNLIKELY(but->flag & UI_BUT_DRAG_MULTI) && ui_but_drag_multi_edit_get(but)))
|
|
{
|
|
state.is_text_input = true;
|
|
}
|
|
|
|
if (but->hold_func) {
|
|
state.has_hold_action = true;
|
|
}
|
|
|
|
bool use_alpha_blend = false;
|
|
if (but->emboss != blender::ui::EmbossType::Pulldown) {
|
|
if (but->flag & (UI_BUT_DISABLED | UI_BUT_INACTIVE | UI_SEARCH_FILTER_NO_MATCH)) {
|
|
use_alpha_blend = true;
|
|
ui_widget_color_disabled(wt, &state);
|
|
}
|
|
}
|
|
|
|
#ifdef USE_UI_POPOVER_ONCE
|
|
if (but->block->flag & UI_BLOCK_POPOVER_ONCE) {
|
|
if ((but->flag & UI_HOVER) && ui_but_is_popover_once_compat(but)) {
|
|
state.but_flag |= UI_BUT_ACTIVE_DEFAULT;
|
|
}
|
|
}
|
|
#endif
|
|
if (but->block->flag & UI_BLOCK_NO_DRAW_OVERRIDDEN_STATE) {
|
|
state.but_flag &= ~UI_BUT_OVERRIDDEN;
|
|
}
|
|
|
|
if (state.but_drawflag & UI_BUT_INDETERMINATE) {
|
|
state.but_flag &= ~UI_SELECT;
|
|
}
|
|
|
|
const float zoom = 1.0f / but->block->aspect;
|
|
wt->state(wt, &state, but->emboss);
|
|
if (wt->custom) {
|
|
wt->custom(but, &wt->wcol, rect, &state, roundboxalign, zoom);
|
|
}
|
|
else if (wt->draw) {
|
|
wt->draw(&wt->wcol, rect, &state, roundboxalign, zoom);
|
|
}
|
|
|
|
if (wt->text) {
|
|
if (use_alpha_blend) {
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
}
|
|
|
|
if (but->type == ButType::Label && !(but->flag & UI_HAS_ICON) && but->col[3] != 0) {
|
|
/* Optionally use button color for text color if label without icon.
|
|
* For example, ensuring that the Splash version text is always white. */
|
|
copy_v4_v4_uchar(wt->wcol.text, but->col);
|
|
}
|
|
|
|
wt->text(fstyle, &wt->wcol, but, rect);
|
|
if (use_alpha_blend) {
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ui_draw_clip_tri(uiBlock *block, const rcti *rect, uiWidgetType *wt)
|
|
{
|
|
if (block) {
|
|
float draw_color[4];
|
|
const uchar *color = wt->wcol.text;
|
|
|
|
draw_color[0] = float(color[0]) / 255.0f;
|
|
draw_color[1] = float(color[1]) / 255.0f;
|
|
draw_color[2] = float(color[2]) / 255.0f;
|
|
draw_color[3] = 1.0f;
|
|
|
|
if (block->flag & UI_BLOCK_CLIPTOP) {
|
|
/* XXX no scaling for UI here yet */
|
|
UI_draw_icon_tri(BLI_rcti_cent_x(rect), rect->ymax - 6 * UI_SCALE_FAC, 't', draw_color);
|
|
}
|
|
if (block->flag & UI_BLOCK_CLIPBOTTOM) {
|
|
/* XXX no scaling for UI here yet */
|
|
UI_draw_icon_tri(BLI_rcti_cent_x(rect), rect->ymin + 10 * UI_SCALE_FAC, 'v', draw_color);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ui_draw_dialog_alert(uiBlock *block, const rcti *rect)
|
|
{
|
|
if (block->alert_level != uiBlockAlertLevel::Error) {
|
|
return;
|
|
}
|
|
|
|
float color[4];
|
|
switch (block->alert_level) {
|
|
case uiBlockAlertLevel::Error:
|
|
UI_GetThemeColor4fv(TH_ERROR, color);
|
|
break;
|
|
case uiBlockAlertLevel::Warning:
|
|
UI_GetThemeColor4fv(TH_WARNING, color);
|
|
break;
|
|
case uiBlockAlertLevel::Success:
|
|
UI_GetThemeColor4fv(TH_SUCCESS, color);
|
|
break;
|
|
default:
|
|
UI_GetThemeColor4fv(TH_INFO, color);
|
|
}
|
|
|
|
bTheme *btheme = UI_GetTheme();
|
|
const float bg_radius = btheme->tui.wcol_menu_back.roundness * U.widget_unit;
|
|
const float line_width = 3.0f * UI_SCALE_FAC;
|
|
const float radius = (bg_radius > (line_width * 2.0f)) ? 0.0f : bg_radius;
|
|
const float padding = (bg_radius > (line_width * 2.0f)) ? bg_radius : 0.0f;
|
|
rctf line_rect;
|
|
BLI_rctf_rcti_copy(&line_rect, rect);
|
|
line_rect.ymin = line_rect.ymax - line_width;
|
|
BLI_rctf_pad(&line_rect, -padding, 0.0f);
|
|
UI_draw_roundbox_corner_set(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
|
|
UI_draw_roundbox_4fv(&line_rect, true, radius, color);
|
|
}
|
|
|
|
void ui_draw_menu_back(uiStyle * /*style*/, uiBlock *block, const rcti *rect)
|
|
{
|
|
uiWidgetType *wt = widget_type(UI_WTYPE_MENU_BACK);
|
|
|
|
wt->state(wt, &STATE_INFO_NULL, blender::ui::EmbossType::Undefined);
|
|
if (block) {
|
|
const float zoom = 1.0f / block->aspect;
|
|
wt->draw_block(&wt->wcol,
|
|
rect,
|
|
block->flag,
|
|
block->alert_level == uiBlockAlertLevel::None ? block->direction : UI_DIR_DOWN,
|
|
zoom);
|
|
if (block->alert_level != uiBlockAlertLevel::None) {
|
|
ui_draw_dialog_alert(block, rect);
|
|
}
|
|
}
|
|
else {
|
|
wt->draw_block(&wt->wcol, rect, 0, 0, 1.0f);
|
|
}
|
|
|
|
ui_draw_clip_tri(block, rect, wt);
|
|
}
|
|
|
|
/**
|
|
* Similar to 'widget_menu_back', however we can't use the widget preset system
|
|
* because we need to pass in the original location so we know where to show the arrow.
|
|
*/
|
|
static void ui_draw_popover_back_impl(const uiWidgetColors *wcol,
|
|
const rcti *rect,
|
|
int direction,
|
|
const float unit_size,
|
|
const float mval_origin[2])
|
|
{
|
|
/* Alas, this isn't nice. */
|
|
const float unit_half = unit_size / 2;
|
|
const float cent_x = mval_origin ? std::clamp(mval_origin[0],
|
|
rect->xmin + unit_size,
|
|
rect->xmax - unit_size) :
|
|
BLI_rcti_cent_x(rect);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
|
|
/* Extracted from 'widget_menu_back', keep separate to avoid menu changes breaking popovers */
|
|
{
|
|
uiWidgetBase wtb;
|
|
widget_init(&wtb);
|
|
|
|
const int roundboxalign = UI_CNR_ALL;
|
|
widget_softshadow(rect, roundboxalign, wcol->roundness * U.widget_unit);
|
|
|
|
round_box_edges(&wtb, roundboxalign, rect, wcol->roundness * U.widget_unit);
|
|
wtb.draw_emboss = false;
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
/* Draw popover arrow (top/bottom) */
|
|
if (ELEM(direction, UI_DIR_UP, UI_DIR_DOWN)) {
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
immVertexFormat(), "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
|
|
const bool is_down = (direction == UI_DIR_DOWN);
|
|
const int sign = is_down ? 1 : -1;
|
|
float y = is_down ? rect->ymax : rect->ymin;
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
immBegin(GPU_PRIM_TRIS, 3);
|
|
immUniformColor4ubv(wcol->outline);
|
|
immVertex2f(pos, cent_x - unit_half, y);
|
|
immVertex2f(pos, cent_x + unit_half, y);
|
|
immVertex2f(pos, cent_x, y + sign * unit_half);
|
|
immEnd();
|
|
|
|
y = y - sign * round(U.pixelsize * 1.41);
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
immBegin(GPU_PRIM_TRIS, 3);
|
|
immUniformColor4ub(0, 0, 0, 0);
|
|
immVertex2f(pos, cent_x - unit_half, y);
|
|
immVertex2f(pos, cent_x + unit_half, y);
|
|
immVertex2f(pos, cent_x, y + sign * unit_half);
|
|
immEnd();
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
immBegin(GPU_PRIM_TRIS, 3);
|
|
immUniformColor4ubv(wcol->inner);
|
|
immVertex2f(pos, cent_x - unit_half, y);
|
|
immVertex2f(pos, cent_x + unit_half, y);
|
|
immVertex2f(pos, cent_x, y + sign * unit_half);
|
|
immEnd();
|
|
|
|
immUnbindProgram();
|
|
}
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
void ui_draw_popover_back(ARegion *region, uiStyle * /*style*/, uiBlock *block, const rcti *rect)
|
|
{
|
|
uiWidgetType *wt = widget_type(UI_WTYPE_MENU_BACK);
|
|
|
|
float mval_origin[2] = {float(block->bounds_offset[0]), float(block->bounds_offset[1])};
|
|
ui_window_to_block_fl(region, block, &mval_origin[0], &mval_origin[1]);
|
|
ui_draw_popover_back_impl(
|
|
wt->wcol_theme, rect, block->direction, U.widget_unit / block->aspect, mval_origin);
|
|
|
|
ui_draw_clip_tri(block, rect, wt);
|
|
}
|
|
|
|
static void draw_disk_shaded(float start,
|
|
float angle,
|
|
float radius_int,
|
|
float radius_ext,
|
|
int subd,
|
|
const uchar col1[4],
|
|
const uchar col2[4],
|
|
bool shaded)
|
|
{
|
|
const float radius_ext_scale = (0.5f / radius_ext); /* 1 / (2 * radius_ext) */
|
|
|
|
uint col;
|
|
GPUVertFormat *format = immVertexFormat();
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
if (shaded) {
|
|
col = GPU_vertformat_attr_add(format, "color", blender::gpu::VertAttrType::SFLOAT_32_32_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_SMOOTH_COLOR);
|
|
}
|
|
else {
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
immUniformColor4ubv(col1);
|
|
}
|
|
|
|
immBegin(GPU_PRIM_TRI_STRIP, subd * 2);
|
|
for (int i = 0; i < subd; i++) {
|
|
const float a = start + ((i) / float(subd - 1)) * angle;
|
|
const float s = sinf(a);
|
|
const float c = cosf(a);
|
|
const float y1 = s * radius_int;
|
|
const float y2 = s * radius_ext;
|
|
|
|
if (shaded) {
|
|
uchar r_col[4];
|
|
const float fac = (y1 + radius_ext) * radius_ext_scale;
|
|
color_blend_v4_v4v4(r_col, col1, col2, fac);
|
|
float f_col[4];
|
|
rgba_uchar_to_float(f_col, r_col);
|
|
immAttr4fv(col, f_col);
|
|
}
|
|
immVertex2f(pos, c * radius_int, s * radius_int);
|
|
|
|
if (shaded) {
|
|
uchar r_col[4];
|
|
const float fac = (y2 + radius_ext) * radius_ext_scale;
|
|
color_blend_v4_v4v4(r_col, col1, col2, fac);
|
|
float f_col[4];
|
|
rgba_uchar_to_float(f_col, r_col);
|
|
immAttr4fv(col, f_col);
|
|
}
|
|
immVertex2f(pos, c * radius_ext, s * radius_ext);
|
|
}
|
|
immEnd();
|
|
|
|
immUnbindProgram();
|
|
}
|
|
|
|
void ui_draw_pie_center(uiBlock *block)
|
|
{
|
|
bTheme *btheme = UI_GetTheme();
|
|
const float cx = block->pie_data.pie_center_spawned[0];
|
|
const float cy = block->pie_data.pie_center_spawned[1];
|
|
|
|
const float *pie_dir = block->pie_data.pie_dir;
|
|
|
|
const float pie_radius_internal = UI_SCALE_FAC * U.pie_menu_threshold;
|
|
const float pie_radius_external = UI_SCALE_FAC * (U.pie_menu_threshold + 7.0f);
|
|
|
|
const int subd = 40;
|
|
|
|
const float angle = atan2f(pie_dir[1], pie_dir[0]);
|
|
/* Use a smaller range if there are both axis aligned & diagonal buttons. */
|
|
const bool has_aligned = (block->pie_data.pie_dir_mask & UI_RADIAL_MASK_ALL_AXIS_ALIGNED) != 0;
|
|
const bool has_diagonal = (block->pie_data.pie_dir_mask & UI_RADIAL_MASK_ALL_DIAGONAL) != 0;
|
|
const float range = (has_aligned && has_diagonal) ? M_PI_4 : M_PI_2;
|
|
|
|
GPU_matrix_push();
|
|
GPU_matrix_translate_2f(cx, cy);
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
if (btheme->tui.wcol_pie_menu.shaded) {
|
|
uchar col1[4], col2[4];
|
|
shadecolors4(btheme->tui.wcol_pie_menu.inner,
|
|
btheme->tui.wcol_pie_menu.shadetop,
|
|
btheme->tui.wcol_pie_menu.shadedown,
|
|
col1,
|
|
col2);
|
|
draw_disk_shaded(
|
|
0.0f, float(M_PI * 2.0), pie_radius_internal, pie_radius_external, subd, col1, col2, true);
|
|
}
|
|
else {
|
|
draw_disk_shaded(0.0f,
|
|
float(M_PI * 2.0),
|
|
pie_radius_internal,
|
|
pie_radius_external,
|
|
subd,
|
|
btheme->tui.wcol_pie_menu.inner,
|
|
nullptr,
|
|
false);
|
|
}
|
|
|
|
if (!(block->pie_data.flags & UI_PIE_INVALID_DIR)) {
|
|
if (btheme->tui.wcol_pie_menu.shaded) {
|
|
uchar col1[4], col2[4];
|
|
shadecolors4(btheme->tui.wcol_pie_menu.inner_sel,
|
|
btheme->tui.wcol_pie_menu.shadetop,
|
|
btheme->tui.wcol_pie_menu.shadedown,
|
|
col1,
|
|
col2);
|
|
draw_disk_shaded(angle - range / 2.0f,
|
|
range,
|
|
pie_radius_internal,
|
|
pie_radius_external,
|
|
subd,
|
|
col1,
|
|
col2,
|
|
true);
|
|
}
|
|
else {
|
|
draw_disk_shaded(angle - range / 2.0f,
|
|
range,
|
|
pie_radius_internal,
|
|
pie_radius_external,
|
|
subd,
|
|
btheme->tui.wcol_pie_menu.inner_sel,
|
|
nullptr,
|
|
false);
|
|
}
|
|
}
|
|
|
|
GPUVertFormat *format = immVertexFormat();
|
|
const uint pos = GPU_vertformat_attr_add(
|
|
format, "pos", blender::gpu::VertAttrType::SFLOAT_32_32);
|
|
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
|
|
immUniformColor4ubv(btheme->tui.wcol_pie_menu.outline);
|
|
|
|
imm_draw_circle_wire_2d(pos, 0.0f, 0.0f, pie_radius_internal, subd);
|
|
imm_draw_circle_wire_2d(pos, 0.0f, 0.0f, pie_radius_external, subd);
|
|
|
|
immUnbindProgram();
|
|
|
|
if (U.pie_menu_confirm > 0 &&
|
|
!(block->pie_data.flags & (UI_PIE_INVALID_DIR | UI_PIE_CLICK_STYLE)))
|
|
{
|
|
const float pie_confirm_radius = UI_SCALE_FAC * (pie_radius_internal + U.pie_menu_confirm);
|
|
const float pie_confirm_external = UI_SCALE_FAC *
|
|
(pie_radius_internal + U.pie_menu_confirm + 7.0f);
|
|
|
|
const uchar col[4] = {UNPACK3(btheme->tui.wcol_pie_menu.text_sel), 64};
|
|
draw_disk_shaded(angle - range / 2.0f,
|
|
range,
|
|
pie_confirm_radius,
|
|
pie_confirm_external,
|
|
subd,
|
|
col,
|
|
nullptr,
|
|
false);
|
|
}
|
|
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
GPU_matrix_pop();
|
|
}
|
|
|
|
const uiWidgetColors *ui_tooltip_get_theme()
|
|
{
|
|
uiWidgetType *wt = widget_type(UI_WTYPE_TOOLTIP);
|
|
return wt->wcol_theme;
|
|
}
|
|
|
|
/**
|
|
* Generic drawing for background.
|
|
*/
|
|
static void ui_draw_widget_back_color(uiWidgetTypeEnum type,
|
|
bool use_shadow,
|
|
const rcti *rect,
|
|
const float color[4])
|
|
{
|
|
uiWidgetType *wt = widget_type(type);
|
|
|
|
if (use_shadow) {
|
|
widget_softshadow(rect, UI_CNR_ALL, 0.25f * U.widget_unit);
|
|
}
|
|
|
|
wt->state(wt, &STATE_INFO_NULL, blender::ui::EmbossType::Undefined);
|
|
if (color) {
|
|
rgba_float_to_uchar(wt->wcol.inner, color);
|
|
}
|
|
|
|
if (wt->draw_block) {
|
|
wt->draw_block(&wt->wcol, rect, 0, UI_CNR_ALL, 1.0f);
|
|
}
|
|
else if (wt->draw) {
|
|
rcti rect_copy = *rect;
|
|
wt->draw(&wt->wcol, &rect_copy, &STATE_INFO_NULL, UI_CNR_ALL, 1.0f);
|
|
}
|
|
else {
|
|
BLI_assert_unreachable();
|
|
}
|
|
}
|
|
void ui_draw_widget_menu_back_color(const rcti *rect, bool use_shadow, const float color[4])
|
|
{
|
|
ui_draw_widget_back_color(UI_WTYPE_MENU_BACK, use_shadow, rect, color);
|
|
}
|
|
|
|
void ui_draw_widget_menu_back(const rcti *rect, bool use_shadow)
|
|
{
|
|
ui_draw_widget_back_color(UI_WTYPE_MENU_BACK, use_shadow, rect, nullptr);
|
|
}
|
|
|
|
void ui_draw_tooltip_background(const uiStyle * /*style*/, uiBlock * /*block*/, const rcti *rect)
|
|
{
|
|
uiWidgetType *wt = widget_type(UI_WTYPE_TOOLTIP);
|
|
wt->state(wt, &STATE_INFO_NULL, blender::ui::EmbossType::Undefined);
|
|
/* wt->draw_block ends up using same function to draw the tooltip as menu_back */
|
|
wt->draw_block(&wt->wcol, rect, 0, 0, 1.0f);
|
|
}
|
|
|
|
void ui_draw_menu_item(const uiFontStyle *fstyle,
|
|
rcti *rect,
|
|
rcti *back_rect,
|
|
const float zoom,
|
|
const bool use_unpadded,
|
|
const char *name,
|
|
int iconid,
|
|
int but_flag,
|
|
uiMenuItemSeparatorType separator_type,
|
|
int *r_xmax)
|
|
{
|
|
uiWidgetType *wt = widget_type(use_unpadded ? UI_WTYPE_MENU_ITEM_UNPADDED : UI_WTYPE_MENU_ITEM);
|
|
const rcti _rect = *rect;
|
|
const int row_height = BLI_rcti_size_y(rect);
|
|
int max_hint_width = INT_MAX;
|
|
int padding = 0.25f * row_height;
|
|
char *cpoin = nullptr;
|
|
|
|
uiWidgetStateInfo state = {0};
|
|
state.but_flag = but_flag;
|
|
|
|
wt->state(wt, &state, blender::ui::EmbossType::Undefined);
|
|
|
|
if (back_rect) {
|
|
wt->draw(&wt->wcol, back_rect, &STATE_INFO_NULL, 0, zoom);
|
|
}
|
|
|
|
UI_fontstyle_set(fstyle);
|
|
|
|
/* text location offset */
|
|
rect->xmin += padding;
|
|
if (iconid) {
|
|
rect->xmin += row_height; /* Use square area for icon. */
|
|
}
|
|
|
|
/* cut string in 2 parts? */
|
|
if (separator_type != UI_MENU_ITEM_SEPARATOR_NONE) {
|
|
cpoin = const_cast<char *>(strrchr(name, UI_SEP_CHAR));
|
|
if (cpoin) {
|
|
*cpoin = 0;
|
|
|
|
/* need to set this first */
|
|
UI_fontstyle_set(fstyle);
|
|
|
|
if (separator_type == UI_MENU_ITEM_SEPARATOR_SHORTCUT) {
|
|
/* Shrink rect to exclude the shortcut string. */
|
|
rect->xmax -= BLF_width(fstyle->uifont_id, cpoin + 1, INT_MAX) + UI_ICON_SIZE;
|
|
}
|
|
else if (separator_type == UI_MENU_ITEM_SEPARATOR_HINT) {
|
|
/* Determine max-width for the hint string to leave the name string un-clipped (if there's
|
|
* enough space to display it). */
|
|
|
|
const int available_width = BLI_rcti_size_x(rect) - padding;
|
|
const int name_width = BLF_width(fstyle->uifont_id, name, INT_MAX);
|
|
const int hint_width = BLF_width(fstyle->uifont_id, cpoin + 1, INT_MAX) + padding;
|
|
|
|
if ((name_width + hint_width) > available_width) {
|
|
/* Clipping width for hint string. */
|
|
max_hint_width = available_width * 0.40f;
|
|
/* Clipping xmax for clipping of item name. */
|
|
rect->xmax = (hint_width < max_hint_width) ?
|
|
(rect->xmax - hint_width) :
|
|
(rect->xmin + (available_width - max_hint_width));
|
|
}
|
|
}
|
|
else {
|
|
BLI_assert_msg(0, "Unknown menu item separator type");
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
char drawstr[UI_MAX_DRAW_STR];
|
|
const float okwidth = float(BLI_rcti_size_x(rect));
|
|
const size_t max_len = sizeof(drawstr);
|
|
const float minwidth = UI_ICON_SIZE;
|
|
|
|
STRNCPY_UTF8(drawstr, name);
|
|
if (drawstr[0]) {
|
|
UI_text_clip_middle_ex(fstyle, drawstr, okwidth, minwidth, max_len, '\0');
|
|
}
|
|
|
|
int xofs = 0, yofs = 0;
|
|
ResultBLF info;
|
|
uiFontStyleDraw_Params params{};
|
|
params.align = UI_STYLE_TEXT_LEFT;
|
|
UI_fontstyle_draw_ex(
|
|
fstyle, rect, drawstr, sizeof(drawstr), wt->wcol.text, ¶ms, &xofs, &yofs, &info);
|
|
if (r_xmax != nullptr) {
|
|
*r_xmax = xofs + info.width;
|
|
}
|
|
}
|
|
|
|
/* restore rect, was messed with */
|
|
*rect = _rect;
|
|
|
|
if (iconid) {
|
|
const int xs = rect->xmin + 0.2f * UI_UNIT_X * zoom;
|
|
const int ys = rect->ymin + 0.5f * (BLI_rcti_size_y(rect) - UI_ICON_SIZE * zoom);
|
|
|
|
const float aspect = U.inv_scale_factor / zoom;
|
|
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
UI_icon_draw_ex(
|
|
xs, ys, iconid, aspect, 1.0f, 0.0f, wt->wcol.text, false, UI_NO_ICON_OVERLAY_TEXT);
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
}
|
|
|
|
/* part text right aligned */
|
|
if (separator_type != UI_MENU_ITEM_SEPARATOR_NONE) {
|
|
if (cpoin) {
|
|
/* State info for the hint drawing. */
|
|
uiWidgetStateInfo hint_state = state;
|
|
/* Set inactive state for grayed out text. */
|
|
hint_state.but_flag |= UI_BUT_INACTIVE;
|
|
|
|
wt->state(wt, &hint_state, blender::ui::EmbossType::Undefined);
|
|
|
|
char hint_drawstr[UI_MAX_DRAW_STR];
|
|
{
|
|
const size_t max_len = sizeof(hint_drawstr);
|
|
const float minwidth = UI_ICON_SIZE;
|
|
|
|
STRNCPY_UTF8(hint_drawstr, cpoin + 1);
|
|
if (hint_drawstr[0] && (max_hint_width < INT_MAX)) {
|
|
UI_text_clip_middle_ex(fstyle, hint_drawstr, max_hint_width, minwidth, max_len, '\0');
|
|
}
|
|
}
|
|
|
|
rect->xmax = _rect.xmax - padding;
|
|
uiFontStyleDraw_Params params{};
|
|
params.align = UI_STYLE_TEXT_RIGHT;
|
|
UI_fontstyle_draw(fstyle, rect, hint_drawstr, sizeof(hint_drawstr), wt->wcol.text, ¶ms);
|
|
*cpoin = UI_SEP_CHAR;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ui_draw_preview_item_stateless(const uiFontStyle *fstyle,
|
|
rcti *rect,
|
|
const blender::StringRef name,
|
|
int iconid,
|
|
const uchar text_col[4],
|
|
eFontStyle_Align text_align,
|
|
const bool add_padding)
|
|
{
|
|
rcti trect = *rect;
|
|
const float text_size = UI_UNIT_Y;
|
|
const bool has_text = !name.is_empty();
|
|
|
|
float alpha = 1.0f;
|
|
|
|
if (has_text) {
|
|
/* draw icon in rect above the space reserved for the label */
|
|
rect->ymin += text_size;
|
|
}
|
|
GPU_blend(GPU_BLEND_ALPHA);
|
|
widget_draw_preview_icon(iconid, alpha, 1.0f, add_padding, rect, text_col);
|
|
GPU_blend(GPU_BLEND_NONE);
|
|
|
|
if (!has_text) {
|
|
return;
|
|
}
|
|
|
|
/* text rect */
|
|
trect.ymax = trect.ymin + text_size;
|
|
if (add_padding) {
|
|
trect.ymin += PREVIEW_PAD;
|
|
trect.xmin += PREVIEW_PAD;
|
|
trect.xmax -= PREVIEW_PAD;
|
|
}
|
|
|
|
{
|
|
char drawstr[UI_MAX_DRAW_STR];
|
|
const float okwidth = float(BLI_rcti_size_x(&trect));
|
|
const size_t max_len = sizeof(drawstr);
|
|
const float minwidth = UI_ICON_SIZE;
|
|
|
|
memcpy(drawstr, name.data(), name.size());
|
|
drawstr[name.size()] = '\0';
|
|
UI_text_clip_middle_ex(fstyle, drawstr, okwidth, minwidth, max_len, '\0');
|
|
|
|
uiFontStyleDraw_Params params{};
|
|
params.align = text_align;
|
|
UI_fontstyle_draw(fstyle, &trect, drawstr, sizeof(drawstr), text_col, ¶ms);
|
|
}
|
|
}
|
|
|
|
void ui_draw_preview_item(const uiFontStyle *fstyle,
|
|
rcti *rect,
|
|
const float zoom,
|
|
const char *name,
|
|
int iconid,
|
|
int but_flag,
|
|
eFontStyle_Align text_align)
|
|
{
|
|
uiWidgetType *wt = widget_type(UI_WTYPE_MENU_ITEM_UNPADDED);
|
|
|
|
uiWidgetStateInfo state = {0};
|
|
state.but_flag = but_flag;
|
|
|
|
/* drawing button background */
|
|
wt->state(wt, &state, blender::ui::EmbossType::Undefined);
|
|
wt->draw(&wt->wcol, rect, &STATE_INFO_NULL, 0, zoom);
|
|
|
|
ui_draw_preview_item_stateless(fstyle, rect, name, iconid, wt->wcol.text, text_align, true);
|
|
}
|
|
|
|
/** \} */
|