/* Kit core: nodes, properties, layout cache, input context, damage-driven * rendering, text editing and number evaluation. * * The interaction rules follow Blender's interface_handlers.cc: drag * threshold, double-click, drag-toggle, continuous grab while scrubbing * (pointer hidden and warped at the window edge, restored on release), * value shortcuts while hovering, tooltips after a delay. * * SPDX-License-Identifier: GPL-2.0-or-later */ #include #include #include #include #include #include #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN # include #endif #include "BUI_anim.h" #include "BUI_blender_c.h" #include "blender/bk_blender.h" #include "kit_intern.h" #include int bk_theme_gen = 0; static BKContext *g_contexts = NULL; /* every live context (themes redraw them) */ /* Blender's UTF-8 cursor stepping (blenlib, linked from bui_core). */ typedef enum { STRCUR_JUMP_NONE, STRCUR_JUMP_DELIM, STRCUR_JUMP_ALL } eStrCursorJumpType; typedef enum { STRCUR_DIR_PREV, STRCUR_DIR_NEXT } eStrCursorJumpDirection; void BLI_str_cursor_step_utf8(const char *str, int str_maxlen, int *pos, eStrCursorJumpDirection direction, eStrCursorJumpType jump, bool use_init_step); void BLI_str_cursor_step_bounds_utf8(const char *str, int str_maxlen, int pos, int *r_start, int *r_end); /* -------------------------------------------------------------------- */ /** \name Utilities * \{ */ static void (*g_retain)(void *) = NULL; static void (*g_release)(void *) = NULL; void BK_set_ref_hooks(void (*retain)(void *ref), void (*release)(void *ref)) { g_retain = retain; g_release = release; } void bk_retain(void *ref) { if (ref && g_retain) { g_retain(ref); } } void bk_release(void *ref) { if (ref && g_release) { g_release(ref); } } char *bk_strdup(const char *s) { if (!s) { return NULL; } const size_t n = strlen(s) + 1; char *d = (char *)malloc(n); if (d) { memcpy(d, s, n); } return d; } void bk_set_text(char **dst, const char *s) { char *d = bk_strdup(s ? s : ""); free(*dst); *dst = d; } void bk_strs_free(BKStrs *s) { for (int i = 0; i < s->n; i++) { free(s->v[i]); } free(s->v); s->v = NULL; s->n = 0; } void bk_strs_set(BKStrs *s, const char *const *v, int n) { bk_strs_free(s); if (n <= 0) { return; } s->v = (char **)calloc((size_t)n, sizeof(char *)); for (int i = 0; i < n; i++) { s->v[i] = bk_strdup(v[i] ? v[i] : ""); } s->n = n; } bool bk_streq(const char *a, const char *b) { return a && b && strcmp(a, b) == 0; } bool bk_keysym_is(const char *keysym, const char *name) { if (!keysym) { return false; } for (; *keysym && *name; keysym++, name++) { if (tolower((uchar)*keysym) != tolower((uchar)*name)) { return false; } } return *keysym == 0 && *name == 0; } double bk_time(void) { #ifdef _WIN32 static LARGE_INTEGER freq; LARGE_INTEGER now; if (!freq.QuadPart) { QueryPerformanceFrequency(&freq); } QueryPerformanceCounter(&now); return (double)now.QuadPart / (double)freq.QuadPart; #else struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_sec + ts.tv_nsec * 1e-9; #endif } /** \} */ /* -------------------------------------------------------------------- */ /** \name Nodes * \{ */ static int g_gen = 1; /* layout generation for the natural-size cache */ static const BKClass *const g_classes[] = { &bk_cls_column, &bk_cls_row, &bk_cls_split, &bk_cls_grid, &bk_cls_box, &bk_cls_panel, &bk_cls_tabs, &bk_cls_sidetabs, &bk_cls_sidebar, &bk_cls_nodeeditor, &bk_cls_graphnode, &bk_cls_areaheader, &bk_cls_scroll, &bk_cls_scrollbar, &bk_cls_label, &bk_cls_separator, &bk_cls_progress, &bk_cls_button, &bk_cls_toggle, &bk_cls_checkbox, &bk_cls_decorator, &bk_cls_text, &bk_cls_search, &bk_cls_hotkey, &bk_cls_number, &bk_cls_slider, &bk_cls_dropdown, &bk_cls_enum, &bk_cls_swatch, &bk_cls_popover, &bk_cls_menubutton, &bk_cls_menubar, &bk_cls_list, &bk_cls_tree, &bk_cls_gridview, &bk_cls_ramp, &bk_cls_curve, &bk_cls_normal, &bk_cls_histogram, &bk_cls_frame, &bk_cls_radio, &bk_cls_canvas, &bk_cls_textarea, &bk_cls_image, &bk_cls_meter, &bk_cls_custom, &bk_cls_video, &bk_cls_screen, &bk_cls_area, #ifdef BUI_FILEBROWSER &bk_cls_filebrowser, #endif }; const BKClass *bk_class_find(const char *name) { for (size_t i = 0; i < sizeof(g_classes) / sizeof(g_classes[0]); i++) { if (strcmp(g_classes[i]->name, name) == 0) { return g_classes[i]; } } return NULL; } BKNode *bk_node_new_cls(const BKClass *cls) { BKNode *n = (BKNode *)calloc(1, sizeof(BKNode)); n->cls = cls; n->flags = NF_VISIBLE | NF_ENABLED | NF_EMBOSS; n->weight = 1.0f; n->corners = CNR_ALL; n->precision = 3; n->step = 0.1; n->vmin = 0.0; n->vmax = 1.0; n->hot = -1; n->rename_row = -1; n->spacing = -1; n->rows = 5; n->split = 0.4f; n->color[3] = 1.0f; n->nat_gen = 0; if (cls->init) { cls->init(n); } return n; } BKNode *BK_node_new(const char *type) { const BKClass *cls = bk_class_find(type); return cls ? bk_node_new_cls(cls) : NULL; } const char *BK_node_type(const BKNode *n) { return n->cls->name; } static void node_detach(BKNode *child) { BKNode *p = child->parent; if (!p) { return; } if (p->cls->detach) { p->cls->detach(p, child); } BKContext *ctx = bk_ctx(child); if (ctx) { bk_forget(ctx, child); bk_relayout(p); } for (int i = 0; i < p->nkids; i++) { if (p->kids[i] == child) { memmove(p->kids + i, p->kids + i + 1, sizeof(BKNode *) * (size_t)(p->nkids - i - 1)); p->nkids--; break; } } child->parent = NULL; } void BK_node_free(BKNode *n) { if (!n) { return; } BK_anim_kill_target(n, -1); /* its motions stop: nothing writes to it any more */ if (n->parent) { node_detach(n); } if (n->ctx_root) { n->ctx_root->root = NULL; } for (int i = 0; i < n->nkids; i++) { BKNode *c = n->kids[i]; c->parent = NULL; if (c->ref) { bk_release(c->ref); /* host owns it */ } else { BK_node_free(c); /* C-owned (built by a composite) */ } } free(n->kids); if (n->cls->free_ext) { n->cls->free_ext(n); } bk_release(n->bref); free(n->text); free(n->label); free(n->desc); free(n->placeholder); free(n->suffix); free(n->category); bk_strs_free(&n->items); free(n->marks); bk_strs_free(&n->item_icons_s); bk_strs_free(&n->shortcuts); free(n->item_icons); free(n->linked); free(n->linked_start); bk_te_free(n->edit); free(n->geom); free(n->rgn); bk_image_ref_clear(&n->image); free(n); } void BK_node_set_ref(BKNode *n, void *ref) { n->ref = ref; } void *BK_node_ref(const BKNode *n) { return n->ref; } void BK_node_set_borrowed_ref(BKNode *n, void *ref) { if (n->bref == ref) { return; } bk_retain(ref); bk_release(n->bref); n->bref = ref; } void *BK_node_borrowed_ref(const BKNode *n) { return n->bref; } void bk_node_add(BKNode *parent, BKNode *child) { BK_node_add(parent, child, -1); } int BK_node_add(BKNode *parent, BKNode *child, int index) { if (!parent || !child || child == parent) { return 0; } if (parent->cls->accept && child->parent != parent && !parent->cls->accept(parent, child)) { return 0; } if (child->parent) { void *ref = child->ref; bk_retain(ref); /* keep alive across the move */ BK_node_remove(child->parent, child); BK_node_add(parent, child, index); bk_release(ref); return 1; } if (parent->nkids == parent->capkids) { parent->capkids = parent->capkids ? parent->capkids * 2 : 4; parent->kids = (BKNode **)realloc(parent->kids, sizeof(BKNode *) * (size_t)parent->capkids); } if (index < 0 || index > parent->nkids) { index = parent->nkids; } memmove(parent->kids + index + 1, parent->kids + index, sizeof(BKNode *) * (size_t)(parent->nkids - index)); parent->kids[index] = child; parent->nkids++; child->parent = parent; bk_retain(child->ref); bk_relayout(parent); return 1; } void BK_node_remove(BKNode *parent, BKNode *child) { if (!child || child->parent != parent) { return; } node_detach(child); bk_release(child->ref); } int BK_node_child_count(const BKNode *n) { return n->nkids; } BKNode *BK_node_child(const BKNode *n, int i) { return (i >= 0 && i < n->nkids) ? n->kids[i] : NULL; } BKNode *BK_node_parent(const BKNode *n) { return n->parent; } void BK_node_rect(const BKNode *n, int r[4]) { r[0] = n->x; r[1] = n->y; r[2] = n->w; r[3] = n->h; } void BK_node_natural(BKNode *n, int r[2]) { bk_natural(n, &r[0], &r[1]); } void BK_node_invalidate(BKNode *n) { bk_invalidate(n); } void BK_node_relayout(BKNode *n) { bk_relayout(n); } BKContext *bk_ctx(const BKNode *n) { while (n) { if (n->ctx_root) { return n->ctx_root; } n = n->parent; } return NULL; } BKRect bk_node_rect(const BKNode *n) { return bk_rect(n->x, n->y, n->w, n->h); } void bk_invalidate(BKNode *n) { BKContext *ctx = bk_ctx(n); if (!ctx) { return; } int m = 3; for (const BKNode *p = n; p; p = p->parent) { if (p->cls->flags & CLS_POPUP) { m = (int)(bk_theme.menu_shadow_width * bk_scale_fac) + 6; break; } } bk_ctx_dirty_rect(ctx, bk_rect(n->x - m, n->y - m, n->w + 2 * m, n->h + 2 * m)); } void bk_relayout(BKNode *n) { g_gen++; BKContext *ctx = bk_ctx(n); if (ctx) { ctx->layout_dirty = true; bk_ctx_request(ctx); } } void bk_natural(BKNode *n, int *r_w, int *r_h) { if (n->nat_gen != g_gen) { int w = 4 * bk_unit(), h = bk_unit(); if (n->cls->measure || BK_HTML(n)) { const float saved = bk_text_scale; bk_text_scale = n->font_scale > 0.0f ? n->font_scale : 1.0f; if (!(BK_HTML(n) && bk_html_measure(n, &w, &h)) && n->cls->measure) { n->cls->measure(n, &w, &h); } if (bk_text_scale > 1.0f) { /* taller text needs a taller widget */ h = BK_MAX(h, (int)(h * bk_text_scale + 0.5f)); } bk_text_scale = saved; } if (n->geom) { /* explicit requested size (Tk width=/height=, Qt fixed size) */ if (n->geom->reqw > 0) { w = n->geom->reqw; } if (n->geom->reqh > 0) { h = n->geom->reqh; } } n->nat_w = w; n->nat_h = h; n->nat_gen = g_gen; } *r_w = n->nat_w; *r_h = n->nat_h; } int bk_configure_pending; void bk_arrange(BKNode *n, int x, int y, int w, int h) { if ((n->flags & NF_EVENTS) && (n->x != x || n->y != y || n->w != w || n->h != h)) { n->flags |= NF_CONFIGURED; /* reported after layout (Tk's ) */ bk_configure_pending = 1; } n->x = x; n->y = y; n->w = w; n->h = h; if (n->cls->arrange) { n->cls->arrange(n); } } static void draw_tree_in(BKNode *n); void bk_draw_tree(BKNode *n) { if (!NODE_VISIBLE(n)) { return; } const BKGeom *g = n->geom; if (g && g->has_clip) { /* a host that clips what it places (a widget under `overflow: hidden`) */ bk_clip_push(g->clip[0], g->clip[1], g->clip[2], g->clip[3]); draw_tree_in(n); bk_clip_pop(); return; } draw_tree_in(n); } static void draw_tree_in(BKNode *n) { if (n->cls->draw_tree) { n->cls->draw_tree(n); return; } /* Skip whole subtrees outside the redrawn region (children stay inside * their parent's rect; emboss/outlines spill by a pixel or two). */ BKRect r = bk_rect(n->x - 3, n->y - 3, n->w + 6, n->h + 6); if (!bk_clip_visible(&r)) { return; } if (n->cls->draw) { const float saved = bk_text_scale; bk_text_scale = n->font_scale > 0.0f ? n->font_scale : 1.0f; bool done = false; if (BK_HTML(n)) { /* a browser draws no text shadow */ const int shadow = bk_text_shadow; bk_text_shadow = 0; done = bk_html_draw(n); bk_text_shadow = shadow; } if (!done) { n->cls->draw(n); } bk_text_scale = saved; } for (int i = 0; i < n->nkids; i++) { bk_draw_tree(n->kids[i]); } } bool bk_contains(const BKNode *n, int x, int y) { return x >= n->x && x < n->x + n->w && y >= n->y && y < n->y + n->h; } BKNode *bk_hit(BKNode *n, int x, int y) { if (!NODE_VISIBLE(n) || !bk_contains(n, x, y)) { return NULL; } const BKGeom *g = n->geom; if (g && g->has_clip && (x < g->clip[0] || y < g->clip[1] || x >= g->clip[0] + g->clip[2] || y >= g->clip[1] + g->clip[3])) { return NULL; } if (n->cls->hit) { return n->cls->hit(n, x, y); } for (int i = n->nkids - 1; i >= 0; i--) { BKNode *f = bk_hit(n->kids[i], x, y); if (f) { return f; } } return ((n->cls->flags & CLS_INTERACTIVE) || (n->flags & NF_EVENTS)) ? n : NULL; } bool bk_hovered(const BKNode *n) { const BKContext *ctx = bk_ctx(n); return ctx && ctx->hover == n && NODE_ENABLED(n); } bool bk_pressed(const BKNode *n) { const BKContext *ctx = bk_ctx(n); return ctx && ctx->grab == n && ctx->hover == n; } void bk_emit(BKNode *n, int kind, void *ref, double a, double b) { BKContext *ctx = bk_ctx(n); if (ctx && ctx->host.emit) { ctx->host.emit(ctx->host.data, n, kind, ref, a, b); } } void bk_changed(BKNode *n) { bk_invalidate(n); if (n->on_change) { n->on_change(n, n->on_change_data); } bk_emit(n, BK_EV_CHANGE, NULL, n->value, 0); } /** \} */ /* -------------------------------------------------------------------- */ /** \name Values & shortcuts * \{ */ double bk_clamp_value(const BKNode *n, double v) { if (n->flags & NF_HAS_MIN && v < n->vmin) { v = n->vmin; } if (n->flags & NF_HAS_MAX && v > n->vmax) { v = n->vmax; } if (n->flags & NF_INTEGER) { v = floor(v + 0.5); } return v; } void bk_set_value_silent(BKNode *n, double v) { v = bk_clamp_value(n, v); if (v != n->value) { n->value = v; bk_invalidate(n); } } void bk_set_value(BKNode *n, double v) { v = bk_clamp_value(n, v); if (v != n->value) { bk_undo_record(n, 0); n->value = v; bk_changed(n); } } char *bk_clipboard_get(BKContext *ctx); void bk_clipboard_set(BKContext *ctx, const char *s); static void vc_copy(void *data) { BKNode *n = (BKNode *)data; char buf[256]; if (n->cls->to_text && n->cls->to_text(n, buf, sizeof(buf))) { bk_clipboard_set(bk_ctx(n), buf); } } static void vc_paste(void *data) { BKNode *n = (BKNode *)data; char *s = bk_clipboard_get(bk_ctx(n)); if (s) { /* trim */ char *b = s; while (*b && isspace((uchar)*b)) { b++; } size_t l = strlen(b); while (l && isspace((uchar)b[l - 1])) { b[--l] = 0; } if (n->cls->from_text) { n->cls->from_text(n, b); } free(s); } } static void vc_reset(void *data) { BKNode *n = (BKNode *)data; if (n->cls->reset) { n->cls->reset(n); } } int bk_value_context_items(BKNode *n, BKMenuSpec *items, int max) { if (max < 4) { return 0; } memset(items, 0, sizeof(BKMenuSpec) * 4); items[0] = (BKMenuSpec){"Copy Value", bk_icons_lookup("COPYDOWN"), "Ctrl C", -1, 1}; items[0].fn = vc_copy; items[0].data = n; items[1] = (BKMenuSpec){"Paste Value", bk_icons_lookup("PASTEDOWN"), "Ctrl V", -1, 1}; items[1].fn = vc_paste; items[1].data = n; items[2] = (BKMenuSpec){"-", 0, NULL, -1, 1}; items[3] = (BKMenuSpec){"Reset to Default Value", bk_icons_lookup("LOOP_BACK"), "Backspace", -1, 1}; items[3].fn = vc_reset; items[3].data = n; return 4; } int bk_value_key(BKNode *n, BKEvent *e) { const BKClass *c = n->cls; if (EV_CTRL(e) && EV_ALT(e)) { return 0; /* Ctrl+Alt+C/V: whole vector, handled by the parent */ } if (EV_CTRL(e) && bk_keysym_is(e->keysym, "c")) { vc_copy(n); return 1; } if (EV_CTRL(e) && bk_keysym_is(e->keysym, "v")) { vc_paste(n); return 1; } if (bk_keysym_is(e->keysym, "BackSpace")) { if (c->reset) { c->reset(n); } return 1; } if (bk_keysym_is(e->keysym, "minus") || bk_keysym_is(e->keysym, "KP_Subtract")) { if (c->negate) { c->negate(n); return 1; } return 0; } if (bk_keysym_is(e->keysym, "Return") || bk_keysym_is(e->keysym, "KP_Enter")) { if (c->activate) { c->activate(n); } return 1; } return 0; } int bk_value_wheel(BKNode *n, BKEvent *e) { if (EV_CTRL(e) && n->cls->step) { n->cls->step(n, e->delta > 0 ? 1 : -1); return 1; } return 0; } void bk_begin_edit(BKNode *n, const char *text, bool select_all) { BKContext *ctx = bk_ctx(n); if (ctx && ctx->focus && ctx->focus != n) { bk_ime_commit(ctx); /* another field takes over: the composition stays in this one */ BKNode *f = ctx->focus; ctx->focus = NULL; if (f->cls->finish_edit) { f->cls->finish_edit(f, true); } } bk_te_free(n->edit); n->edit = bk_te_new(text, select_all); memcpy(n->edit->mask, n->mask, sizeof(n->mask)); if (ctx) { ctx->focus = n; ctx->cursor = -1; /* re-evaluate (text cursor) */ } bk_invalidate(n); } static void end_edit(BKContext *ctx, bool confirm) { if (confirm) { bk_ime_commit(ctx); /* Blender: a click outside inserts the text being composed */ } BKNode *f = ctx->focus; ctx->focus = NULL; if (f) { if (f->cls->finish_edit) { f->cls->finish_edit(f, confirm); } bk_te_free(f->edit); f->edit = NULL; bk_invalidate(f); } } int bk_edit_key(BKNode *n, BKEvent *e) { BKContext *ctx = bk_ctx(n); const int res = bk_te_key(n->edit, ctx, e->text, e->keysym, e->mods); if ((res == TE_CONFIRM || res == TE_CANCEL) && ctx) { end_edit(ctx, res == TE_CONFIRM); } else if ((res == TE_NEXT || res == TE_PREV) && ctx) { end_edit(ctx, true); bk_edit_next(n, res == TE_NEXT ? 1 : -1); } bk_invalidate(n); return 1; } void BK_link_fields(BKNode *const *fields, int n) { for (int i = 0; i < n; i++) { BKNode *f = fields[i]; free(f->linked); free(f->linked_start); f->linked = (BKNode **)calloc((size_t)BK_MAX(1, n - 1), sizeof(BKNode *)); f->linked_start = (double *)calloc((size_t)BK_MAX(1, n - 1), sizeof(double)); f->nlinked = 0; for (int j = 0; j < n; j++) { if (j != i) { f->linked[f->nlinked++] = fields[j]; } } } if (n > 0 && fields[0]->parent) { fields[0]->parent->flags |= NF_VECTOR; } } /** \} */ /* -------------------------------------------------------------------- */ /** \name Properties * \{ */ static int str_align(const char *s) { if (bk_streq(s, "right")) { return BK_ALIGN_RIGHT; } if (bk_streq(s, "center")) { return BK_ALIGN_CENTER; } return BK_ALIGN_LEFT; } static const struct { const char *key; unsigned flag; bool relayout; } g_flag_props[] = { {"visible", NF_VISIBLE, true}, {"enabled", NF_ENABLED, false}, {"align", NF_ALIGN, true}, {"emboss", NF_EMBOSS, false}, {"vertical", NF_VERTICAL, true}, {"icon_only", NF_ICON_ONLY, true}, {"collapsed", NF_COLLAPSED, true}, {"integer", NF_INTEGER, false}, {"pinned", NF_PINNED, true}, {"live", NF_LIVE, false}, {"alpha", NF_ALPHA, false}, {"square", NF_SQUARE, false}, {"directory", NF_DIRECTORY, false}, {"line", NF_LINE, false}, {"bold", NF_BOLD, true}, {"events", NF_EVENTS, false}, {"nopropagate", NF_NOPROPAGATE, true}, {"viewevents", NF_VIEWEVENTS, false}, {"noscrollbar", NF_NOSCROLLBAR, true}, {"opaque", NF_OPAQUE, false}, {"html", NF_HTML, true}, /* Chrome's form-control look (kit_widgets.c) */ {"bare", NF_BARE, false}, {"active_default", NF_ACTIVE_DEFAULT, false}, {"select", NF_SELECT, false}, }; static int g_view_watchers; /* > 0 once any node asked for view events */ /* Scrolled views (Tk's xview/yview): the class reports first/visible/total * in its own units; fractions, moveto, scrolling by units and change * notification are shared here. */ static void view_of(BKNode *n, int axis, int *first, int *vis, int *total) { *first = 0; *vis = *total = 1; if (n->cls->view) { n->cls->view(n, axis, first, vis, total); } *total = BK_MAX(1, *total); *vis = BK_CLAMP(*vis, 1, *total); } void bk_view_fractions(BKNode *n, int axis, float *r_first, float *r_last) { int first, vis, total; view_of(n, axis, &first, &vis, &total); *r_first = BK_CLAMP((float)first / total, 0.0f, 1.0f); *r_last = BK_CLAMP((float)(first + vis) / total, 0.0f, 1.0f); } static void view_set_first(BKNode *n, int axis, int first) { int cur, vis, total; view_of(n, axis, &cur, &vis, &total); first = BK_CLAMP(first, 0, total - vis); if (n->cls->set_view && first != cur) { n->cls->set_view(n, axis, first); bk_invalidate(n); } } static int view_set_num(BKNode *n, const char *key, double v) { const int axis = key[0] == 'x'; int first, vis, total; if (strcmp(key + 1, "view") == 0) { /* moveto fraction */ view_of(n, axis, &first, &vis, &total); view_set_first(n, axis, (int)floor(v * total + 0.5)); return 1; } if (strcmp(key + 1, "scroll") == 0) { /* by units */ view_of(n, axis, &first, &vis, &total); view_set_first(n, axis, first + (int)v); return 1; } return 0; } static int view_get_num(BKNode *n, const char *key, double *r_v) { const int axis = key[0] == 'x'; if (strcmp(key + 1, "first") == 0 || strcmp(key + 1, "last") == 0) { float a, b; bk_view_fractions(n, axis, &a, &b); *r_v = key[1] == 'f' ? a : b; return 1; } if (strcmp(key + 1, "total") == 0 || strcmp(key + 1, "visible") == 0) { int first, vis, total; view_of(n, axis, &first, &vis, &total); *r_v = key[1] == 't' ? total : vis; return 1; } return 0; } typedef struct Notify { BKNode *node; int kind; } Notify; static void notify_collect(BKNode *n, Notify *out, int *count, int max) { if (*count >= max) { return; } if (n->flags & NF_CONFIGURED) { n->flags &= ~NF_CONFIGURED; out[(*count)++] = (Notify){n, BK_EV_CONFIGURE}; } if ((n->flags & NF_VIEWEVENTS) && *count < max) { float f[4]; bk_view_fractions(n, 0, &f[0], &f[1]); bk_view_fractions(n, 1, &f[2], &f[3]); if (memcmp(f, n->view_seen, sizeof(f)) != 0) { memcpy(n->view_seen, f, sizeof(f)); out[(*count)++] = (Notify){n, BK_EV_VIEW}; } } for (int i = 0; i < n->nkids; i++) { notify_collect(n->kids[i], out, count, max); } } /* Tell the host what layout and input changed: a widget's geometry (Tk's * ) and scrolled views (Tk's x/yscrollcommand). One shared pass * after input and after layout. */ void bk_views_check(BKContext *ctx) { if ((!g_view_watchers && !bk_configure_pending) || !ctx->root) { return; } bk_configure_pending = 0; Notify changed[128]; int count = 0; notify_collect(ctx->root, changed, &count, 128); for (int i = 0; i < count; i++) { /* after the walk: callbacks may edit the tree */ BKNode *n = changed[i].node; bk_emit(n, changed[i].kind, NULL, changed[i].kind == BK_EV_CONFIGURE ? n->w : 0, changed[i].kind == BK_EV_CONFIGURE ? n->h : 0); } } int BK_set_num(BKNode *n, const char *key, double v) { if (n->cls->set_num && n->cls->set_num(n, key, v)) { return 1; } const int region = bk_region_set_num(n, key, v); /* an area's region: size, hidden ... */ if (region != 0) { return region > 0; } if ((key[0] == 'x' || key[0] == 'y') && view_set_num(n, key, v)) { return 1; } if (strcmp(key, "viewevents") == 0 && v != 0) { g_view_watchers++; } for (size_t i = 0; i < sizeof(g_flag_props) / sizeof(g_flag_props[0]); i++) { if (strcmp(key, g_flag_props[i].key) == 0) { if (((n->flags & g_flag_props[i].flag) != 0) == (v != 0)) { return 1; /* unchanged: no relayout, no redraw */ } if (v != 0) { n->flags |= g_flag_props[i].flag; } else { n->flags &= ~g_flag_props[i].flag; } if (g_flag_props[i].relayout) { bk_relayout(n); } bk_invalidate(n); if (strcmp(key, "enabled") == 0 || strcmp(key, "visible") == 0) { BKContext *ctx = bk_ctx(n); if (ctx && !(n->flags & g_flag_props[i].flag)) { bk_forget(ctx, n); } } return 1; } } if (strcmp(key, "value") == 0) { if (n->cls == &bk_cls_tabs || n->cls == &bk_cls_sidetabs || n->cls == &bk_cls_sidebar) { n->current = (int)v; bk_relayout(n); } else { if (!(n->flags & NF_DEFAULT_SET)) { /* the value a widget is made with is its default */ n->defval = v; n->flags |= NF_DEFAULT_SET; } bk_set_value_silent(n, v); } return 1; } if (strcmp(key, "set_value") == 0) { /* notifying setter */ bk_set_value(n, v); return 1; } if (strcmp(key, "default") == 0) { n->defval = v; n->flags |= NF_DEFAULT_SET; return 1; } if (strcmp(key, "min") == 0) { n->vmin = v; n->flags |= NF_HAS_MIN; return 1; } if (strcmp(key, "max") == 0) { n->vmax = v; n->flags |= NF_HAS_MAX; return 1; } if (strcmp(key, "step") == 0) { n->step = v; return 1; } if (strcmp(key, "precision") == 0) { n->precision = (int)v; bk_invalidate(n); return 1; } if (strcmp(key, "radius") == 0) { /* HTML look border-radius (CSS px); negative: the default */ n->has_radius = v >= 0; n->radius = (float)v; bk_invalidate(n); return 1; } if (strcmp(key, "weight") == 0) { n->weight = (float)v; bk_relayout(n); return 1; } if (strcmp(key, "fill") == 0) { n->fill = v != 0.0; bk_relayout(n); return 1; } if (strcmp(key, "factor") == 0) { n->factor = v; bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "spacing") == 0) { n->spacing = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "padding") == 0) { n->padding = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "columns") == 0) { n->columns = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "rows") == 0) { n->rows = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "tile") == 0) { n->tile = (float)v; bk_relayout(n); return 1; } if (strcmp(key, "height") == 0) { n->height_units = (float)v; bk_relayout(n); return 1; } if (strcmp(key, "split") == 0) { n->split = (float)v; bk_relayout(n); return 1; } if (strcmp(key, "scroll") == 0) { n->scroll = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "scroll_x") == 0) { n->scroll_x = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "selmode") == 0) { n->selmode = (int)v; bk_invalidate(n); return 1; } if (strcmp(key, "field_bg") == 0) { /* 0xAARRGGBB */ const uint32_t argb = (uint32_t)v; n->field_bg[0] = (uchar)(argb >> 16); n->field_bg[1] = (uchar)(argb >> 8); n->field_bg[2] = (uchar)argb; n->field_bg[3] = (uchar)(argb >> 24); bk_invalidate(n); return 1; } if (strcmp(key, "text_color") == 0) { /* 0xAARRGGBB */ const uint32_t argb = (uint32_t)v; n->text_color[0] = (uchar)(argb >> 16); n->text_color[1] = (uchar)(argb >> 8); n->text_color[2] = (uchar)argb; n->text_color[3] = (uchar)(argb >> 24); bk_invalidate(n); return 1; } if (strcmp(key, "font_scale") == 0) { n->font_scale = (float)v; bk_relayout(n); return 1; } if (strcmp(key, "cursor") == 0) { /* < 0: back to the class cursor */ n->cursor_override = v < 0 ? 0 : (int)v + 1; return 1; } if (strcmp(key, "current") == 0) { n->current = (int)v; bk_relayout(n); return 1; } if (strcmp(key, "icon") == 0) { n->icon = (int)v; bk_relayout(n); return 1; } return 0; } double BK_get_num(BKNode *n, const char *key) { double cv; if (n->cls->get_num && n->cls->get_num(n, key, &cv)) { return cv; } if (bk_region_get_num(n, key, &cv)) { return cv; } for (size_t i = 0; i < sizeof(g_flag_props) / sizeof(g_flag_props[0]); i++) { if (strcmp(key, g_flag_props[i].key) == 0) { return (n->flags & g_flag_props[i].flag) ? 1.0 : 0.0; } } if (strcmp(key, "value") == 0) { if (n->cls == &bk_cls_tabs || n->cls == &bk_cls_sidetabs || n->cls == &bk_cls_sidebar) { return n->current; } return n->value; } if (strcmp(key, "default") == 0) { return n->defval; } if (strcmp(key, "min") == 0) { return n->vmin; } if (strcmp(key, "max") == 0) { return n->vmax; } if (strcmp(key, "step") == 0) { return n->step; } if (strcmp(key, "factor") == 0) { return n->factor; } if (strcmp(key, "weight") == 0) { return n->weight; } if (strcmp(key, "fill") == 0) { return n->fill; } if (strcmp(key, "scroll") == 0) { return n->scroll; } if (strcmp(key, "scroll_x") == 0) { return n->scroll_x; } if ((key[0] == 'x' || key[0] == 'y') && view_get_num(n, key, &cv)) { return cv; } if (strcmp(key, "current") == 0) { return n->current; } if (strcmp(key, "tile") == 0) { return n->tile; } if (strcmp(key, "height") == 0) { return n->height_units; } if (strcmp(key, "hot") == 0) { return n->hot; } if (strcmp(key, "editing") == 0) { return n->edit != NULL || n->dragmode == 99; } if (strcmp(key, "corners") == 0) { return n->corners; } if (strcmp(key, "radius") == 0) { return n->has_radius ? n->radius : -1; } if (strcmp(key, "rename_row") == 0) { return n->rename_row; } return 0.0; } /* A field being edited shows a programmatic text change (Tk's entry.delete / * insert, validatecommand rejecting a keystroke). */ static void edit_follow_text(BKNode *n) { BKTextEdit *te = n->edit; const char *s = n->text ? n->text : ""; if (!te || strcmp(te->text, s) == 0) { return; } const int caret = te->caret; BKTextEdit *fresh = bk_te_new(s, false); memcpy(fresh->mask, te->mask, sizeof(te->mask)); fresh->caret = BK_MIN(caret, fresh->len); fresh->anchor = -1; bk_te_free(te); n->edit = fresh; } int BK_set_str(BKNode *n, const char *key, const char *v) { if (n->cls->set_str && n->cls->set_str(n, key, v)) { return 1; } const int region = bk_region_set_str(n, key, v); /* region, side, hotkey */ if (region != 0) { return region > 0; } if (strcmp(key, "text") == 0 || strcmp(key, "title") == 0) { bk_set_text(&n->text, v); bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "value") == 0 && n->cls == &bk_cls_textarea) { return bk_textarea_set_text(n, v); } if (strcmp(key, "value") == 0) { /* string-valued nodes */ bk_set_text(&n->text, v); edit_follow_text(n); bk_invalidate(n); return 1; } if (strcmp(key, "set_value") == 0) { if (!bk_streq(n->text, v)) { bk_undo_record(n, 1); bk_set_text(&n->text, v); edit_follow_text(n); bk_changed(n); } return 1; } if (strcmp(key, "label") == 0) { bk_set_text(&n->label, v); bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "description") == 0) { bk_set_text(&n->desc, v); return 1; } if (strcmp(key, "placeholder") == 0) { bk_set_text(&n->placeholder, v); bk_invalidate(n); return 1; } if (strcmp(key, "mask") == 0) { /* one UTF-8 character, "" = plain */ memset(n->mask, 0, sizeof(n->mask)); strncpy(n->mask, v ? v : "", sizeof(n->mask) - 1); if (n->edit) { memcpy(n->edit->mask, n->mask, sizeof(n->mask)); } bk_invalidate(n); return 1; } if (strcmp(key, "suffix") == 0) { bk_set_text(&n->suffix, v); bk_invalidate(n); return 1; } if (strcmp(key, "category") == 0) { bk_set_text(&n->category, v); bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "icon") == 0) { n->icon = bk_icons_lookup(v); bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "icon_on") == 0) { n->icon_on = bk_icons_lookup(v); bk_invalidate(n); return 1; } if (strcmp(key, "text_align") == 0) { n->align = str_align(v); bk_invalidate(n); return 1; } return 0; } const char *BK_get_str(BKNode *n, const char *key) { if (n->cls->get_str) { const char *s = n->cls->get_str(n, key); if (s) { return s; } } const char *region = bk_region_get_str(n, key); if (region) { return region; } if (strcmp(key, "value") == 0 && n->cls == &bk_cls_textarea) { return bk_textarea_text(n); } if (strcmp(key, "text") == 0 || strcmp(key, "value") == 0 || strcmp(key, "title") == 0) { return n->text ? n->text : ""; } if (strcmp(key, "label") == 0) { return n->label ? n->label : ""; } if (strcmp(key, "description") == 0) { return n->desc ? n->desc : ""; } if (strcmp(key, "edit") == 0) { return n->edit ? n->edit->text : ""; } if (strcmp(key, "display") == 0) { /* number fields: the value text as drawn */ const char *s = bk_number_display(n); return s ? s : ""; } if (strcmp(key, "type") == 0) { return n->cls->name; } return ""; } int BK_set_color(BKNode *n, const char *key, const float c[4]) { if (strcmp(key, "color") == 0 || strcmp(key, "value") == 0) { for (int k = 0; k < 4; k++) { /* normals keep their sign */ n->color[k] = n->cls == &bk_cls_normal ? c[k] : BK_CLAMP(c[k], 0.0f, 1.0f); } bk_invalidate(n); return 1; } if (strcmp(key, "bg") == 0) { /* frames / canvases */ memcpy(n->color, c, sizeof(float[4])); n->flags = c[3] > 0 ? (n->flags | NF_HAS_BG) : (n->flags & ~NF_HAS_BG); bk_invalidate(n); return 1; } if (strcmp(key, "set_value") == 0) { float v[4]; for (int k = 0; k < 4; k++) { v[k] = BK_CLAMP(c[k], 0.0f, 1.0f); } if (memcmp(v, n->color, sizeof(v)) != 0) { bk_undo_record(n, 2); memcpy(n->color, v, sizeof(v)); bk_changed(n); } return 1; } if (strcmp(key, "text_color") == 0) { for (int k = 0; k < 4; k++) { n->color_text[k] = (uchar)(BK_CLAMP(c[k], 0.0f, 1.0f) * 255.0f + 0.5f); } n->has_color_text = true; bk_invalidate(n); return 1; } return 0; } int BK_get_color(BKNode *n, const char *key, float r[4]) { if (strcmp(key, "color") == 0 || strcmp(key, "value") == 0 || strcmp(key, "bg") == 0) { memcpy(r, n->color, sizeof(float[4])); return 1; } return 0; } int BK_set_strs(BKNode *n, const char *key, const char *const *v, int count) { if (n->cls->set_strs && n->cls->set_strs(n, key, v, count)) { return 1; } if (strcmp(key, "headers") == 0) { /* tree/table column headers */ bk_strs_set(&n->shortcuts, v, count); bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "items") == 0) { bk_strs_set(&n->items, v, count); if (n->value >= count) { n->value = count > 0 ? count - 1 : 0; } bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "groups") == 0) { /* side tabs: "1" where a tab group starts */ bk_strs_set(&n->shortcuts, v, count); bk_relayout(n); bk_invalidate(n); return 1; } if (strcmp(key, "icons") == 0) { bk_strs_set(&n->item_icons_s, v, count); free(n->item_icons); n->item_icons = (int *)calloc((size_t)BK_MAX(1, count), sizeof(int)); for (int i = 0; i < count; i++) { n->item_icons[i] = bk_icons_lookup(v[i]); } if (n->cls == &bk_cls_tree) { bk_tree_columns_from_icons(n); /* (off, on) icon pairs per toggle column */ } bk_relayout(n); bk_invalidate(n); return 1; } return 0; } int BK_strs_count(BKNode *n, const char *key) { const BKStrs *own = n->cls->get_strs ? n->cls->get_strs(n, key) : NULL; if (own) { return own->n; } return strcmp(key, "items") == 0 ? n->items.n : 0; } const char *BK_strs_get(BKNode *n, const char *key, int i) { const BKStrs *own = n->cls->get_strs ? n->cls->get_strs(n, key) : NULL; if (own) { return (i >= 0 && i < own->n) ? own->v[i] : ""; } if (strcmp(key, "items") == 0 && i >= 0 && i < n->items.n) { return n->items.v[i]; } return ""; } /** \} */ /* -------------------------------------------------------------------- */ /** \name Context: damage, popups, services * \{ */ /* a motion started: every context draws frames until the motions end (BK_animating) */ static void anim_wake(void *data) { (void)data; for (BKContext *c = g_contexts; c; c = c->next_ctx) { bk_ctx_request(c); } } BKContext *BK_context_new(BKNode *root) { BKContext *ctx = (BKContext *)calloc(1, sizeof(BKContext)); ctx->root = root; ctx->cursor = BK_CURSOR_DEFAULT; ctx->layout_dirty = true; ctx->full_dirty = true; if (root) { root->ctx_root = ctx; } bk_theme_env_init(); ctx->next_ctx = g_contexts; g_contexts = ctx; BK_anim_set_wake(anim_wake, NULL); BK_anim_set_clock(bk_time); /* frames stop when idle: motions start on the kit's clock */ return ctx; } static void undo_entry_free(BKUndo *u); void BK_context_free(BKContext *ctx) { if (!ctx) { return; } BK_close_popups(ctx); for (int i = 0; i < ctx->nundo; i++) { undo_entry_free(&ctx->undo[i]); /* the text steps own their strings */ } ctx->nundo = ctx->undo_pos = 0; bk_image_forget_context(ctx); for (int i = 0; i < ctx->nkeys; i++) { bk_release(ctx->keys[i].ref); } if (ctx->root) { ctx->root->ctx_root = NULL; } if (ctx->header) { ctx->header->ctx_root = NULL; } for (BKContext **p = &g_contexts; *p; p = &(*p)->next_ctx) { if (*p == ctx) { *p = ctx->next_ctx; break; } } free(ctx); } /* -------------------------------------------------------------------- */ /* Themes: Blender's Dark (default) and Light presets (kit_theme_presets.c) */ static int g_theme_light = 0, g_theme_set = 0; int bk_theme_from_name(const char *name) { /* "dark" / "light", any case; Blender's preset names work too */ char buf[32]; int n = 0; for (; name && name[n] && n < (int)sizeof(buf) - 1; n++) { buf[n] = (char)tolower((unsigned char)name[n]); } buf[n] = 0; const char *s = buf; if (strncmp(s, "blender", 7) == 0) { s += 7; while (*s == ' ' || *s == '_' || *s == '-') { s++; } } if (strcmp(s, "dark") == 0 || strcmp(s, "default") == 0) { return 0; } if (strcmp(s, "light") == 0) { return 1; } return -1; } /* The preset itself, nothing redrawn yet: bk_theme_changed does that once the theme is complete. */ void bk_theme_load_preset(int light) { g_theme_light = light; bk_theme = light ? bk_theme_light : bk_theme_dark; } bool bk_theme_is_light(void) { return g_theme_light != 0; } void bk_theme_mark_set(void) { g_theme_set = 1; } /* bk_theme changed (a preset, a custom theme, one color): every context relayouts and redraws. */ void bk_theme_changed(void) { bk_theme_gen++; for (BKContext *c = g_contexts; c; c = c->next_ctx) { c->layout_dirty = true; /* shadow widths size popups */ c->full_dirty = true; if (c->host.request) { c->host.request(c->host.data); } } } static void theme_apply(int light) { bk_theme_load_preset(light); bk_theme_changed(); } void bk_theme_env_init(void) { if (g_theme_set) { return; } g_theme_set = 1; const char *env = getenv("BUI_THEME"); const int t = env && *env ? bk_theme_from_name(env) : -1; if (t > 0) { theme_apply(t); } } int BK_version(void) { return BUI_KIT_VERSION; } const char *BK_version_string(void) { return BUI_KIT_VERSION_STRING; } #define TH_FIELD(f) {#f, offsetof(BKTheme, f)} static const struct { const char *name; size_t off; } k_theme_colors[] = { TH_FIELD(region_bg), TH_FIELD(header_bg), TH_FIELD(tabs_bg), TH_FIELD(panel_header), TH_FIELD(panel_back), TH_FIELD(panel_sub_back), TH_FIELD(panel_outline), TH_FIELD(text), TH_FIELD(text_hi), TH_FIELD(emboss), TH_FIELD(cursor), TH_FIELD(selection), TH_FIELD(file_back), TH_FIELD(file_text), TH_FIELD(file_header), TH_FIELD(file_row_alternate), TH_FIELD(node_back), TH_FIELD(node_grid), TH_FIELD(node_wire), TH_FIELD(node_body), TH_FIELD(node_outline), TH_FIELD(node_selected), TH_FIELD(node_active), TH_FIELD(area_header), }, k_theme_wcols[] = { TH_FIELD(regular), TH_FIELD(tool), TH_FIELD(toggle), TH_FIELD(radio), TH_FIELD(option), TH_FIELD(textfield), TH_FIELD(num), TH_FIELD(numslider), TH_FIELD(menu), TH_FIELD(pulldown), TH_FIELD(menu_back), TH_FIELD(menu_item), TH_FIELD(list_item), TH_FIELD(box), TH_FIELD(scroll), TH_FIELD(progress), TH_FIELD(tooltip), TH_FIELD(tab), TH_FIELD(pie_menu), TH_FIELD(curve), }, k_wcol_fields[] = { {"outline", offsetof(BKWCol, outline)}, {"outline_sel", offsetof(BKWCol, outline_sel)}, {"inner", offsetof(BKWCol, inner)}, {"inner_sel", offsetof(BKWCol, inner_sel)}, {"item", offsetof(BKWCol, item)}, {"text", offsetof(BKWCol, text)}, {"text_sel", offsetof(BKWCol, text_sel)}, }; #undef TH_FIELD int BK_theme_color(const char *key, float r_rgba[4]) { bk_theme_env_init(); if (!key) { return 0; } const uchar *c = NULL; const char *dot = strchr(key, '.'); if (!dot) { for (size_t i = 0; i < sizeof(k_theme_colors) / sizeof(k_theme_colors[0]); i++) { if (strcmp(key, k_theme_colors[i].name) == 0) { c = (const uchar *)&bk_theme + k_theme_colors[i].off; } } } else { const size_t n = (size_t)(dot - key); for (size_t i = 0; i < sizeof(k_theme_wcols) / sizeof(k_theme_wcols[0]); i++) { if (strlen(k_theme_wcols[i].name) == n && strncmp(key, k_theme_wcols[i].name, n) == 0) { for (size_t j = 0; j < sizeof(k_wcol_fields) / sizeof(k_wcol_fields[0]); j++) { if (strcmp(dot + 1, k_wcol_fields[j].name) == 0) { c = (const uchar *)&bk_theme + k_theme_wcols[i].off + k_wcol_fields[j].off; } } } } } if (!c) { /* "button.background", "user_interface.wcol_regular.inner", then the theme's own keys */ return bk_theme_key_color(key, r_rgba) || bk_theme_custom_color(key, r_rgba); } if (r_rgba) { bk_rgba(c, r_rgba); } return 1; } void BK_context_set_host(BKContext *ctx, const BKHost *host) { ctx->host = *host; } void BK_context_set_header(BKContext *ctx, BKNode *header) { if (ctx->header) { ctx->header->ctx_root = NULL; } ctx->header = header; if (header) { header->ctx_root = ctx; } ctx->layout_dirty = true; } BKNode *BK_context_root(BKContext *ctx) { return ctx->root; } void bk_ctx_request(BKContext *ctx) { if (ctx->in_custom_frame) { return; /* BK_render draws what the frame callbacks dirtied right after */ } if (ctx->host.request) { ctx->host.request(ctx->host.data); } } static bool rect_overlap(const BKRect *a, const BKRect *b) { return a->xmin < b->xmax && b->xmin < a->xmax && a->ymin < b->ymax && b->ymin < a->ymax; } static void rect_union(BKRect *a, const BKRect *b) { a->xmin = BK_MIN(a->xmin, b->xmin); a->ymin = BK_MIN(a->ymin, b->ymin); a->xmax = BK_MAX(a->xmax, b->xmax); a->ymax = BK_MAX(a->ymax, b->ymax); } void bk_ctx_dirty_rect(BKContext *ctx, BKRect r) { if (r.xmax <= r.xmin || r.ymax <= r.ymin) { return; } bk_ctx_request(ctx); if (ctx->full_dirty) { return; } for (int i = 0; i < ctx->ndirty; i++) { if (rect_overlap(&ctx->dirty[i], &r)) { rect_union(&ctx->dirty[i], &r); return; } } if (ctx->ndirty == BK_MAX_DIRTY) { for (int i = 1; i < ctx->ndirty; i++) { rect_union(&ctx->dirty[0], &ctx->dirty[i]); } rect_union(&ctx->dirty[0], &r); ctx->ndirty = 1; return; } ctx->dirty[ctx->ndirty++] = r; } static bool is_within(const BKNode *n, const BKNode *subtree) { for (; n; n = n->parent) { if (n == subtree) { return true; } } return false; } static void undo_forget(BKContext *ctx, BKNode *subtree); void bk_forget(BKContext *ctx, BKNode *subtree) { undo_forget(ctx, subtree); for (int i = ctx->nanim - 1; i >= 0; i--) { if (is_within(ctx->anim[i], subtree)) { const int last = --ctx->nanim; ctx->anim[i] = ctx->anim[last]; ctx->anim_start[i] = ctx->anim_start[last]; ctx->anim_from[i] = ctx->anim_from[last]; } } for (int i = 0; i < ctx->nmulti; i++) { if (is_within(ctx->multi[i], subtree)) { ctx->nmulti = 0; break; } } if (ctx->hover && is_within(ctx->hover, subtree)) { ctx->hover = NULL; } if (ctx->grab && is_within(ctx->grab, subtree)) { ctx->grab = NULL; } if (ctx->focus && is_within(ctx->focus, subtree)) { BKNode *f = ctx->focus; ctx->focus = NULL; bk_te_free(f->edit); f->edit = NULL; } if (ctx->modal && is_within(ctx->modal, subtree)) { ctx->modal = NULL; } if (ctx->tip_node && is_within(ctx->tip_node, subtree)) { ctx->tip_node = NULL; ctx->tip_shown = 0; } if (ctx->last_click_node && is_within(ctx->last_click_node, subtree)) { ctx->last_click_node = NULL; } /* popups owned by the subtree */ for (int i = 0; i < ctx->npopups; i++) { if (ctx->popups[i]->parent && is_within(ctx->popups[i]->parent, subtree)) { bk_close_popups_after(ctx, i > 0 ? ctx->popups[i - 1] : NULL); break; } } } int bk_popup_index(BKContext *ctx, const BKNode *popup) { for (int i = 0; i < ctx->npopups; i++) { if (ctx->popups[i] == popup) { return i; } } return -1; } bool bk_owns_popup(BKContext *ctx, const BKNode *owner) { if (!ctx) { return false; } for (int i = 0; i < ctx->npopups; i++) { if (ctx->popups[i]->parent == owner) { return true; } } return false; } static void free_popup(BKNode *p) { if (p->cls == &bk_cls_menu || p->cls == &bk_cls_pie) { bk_menu_on_close(p); } p->parent = NULL; BK_node_free(p); } void bk_close_popups_after(BKContext *ctx, BKNode *after) { const int keep = after ? bk_popup_index(ctx, after) + 1 : 0; while (ctx->npopups > keep) { BKNode *p = ctx->popups[--ctx->npopups]; bk_invalidate(p); bk_forget(ctx, p); /* references into the popup, its animations, its undo steps */ /* The popover panel's body belongs to its owner, not the popup. */ if (p->cls == &bk_cls_popover_panel && p->nkids) { BKNode *body = p->kids[0]; p->nkids = 0; body->parent = p->parent; } BKNode *owner = p->parent; free_popup(p); if (owner) { bk_invalidate(owner); } } ctx->layout_dirty = ctx->layout_dirty; /* no relayout needed */ bk_ctx_request(ctx); } void BK_close_popups(BKContext *ctx) { bk_close_popups_after(ctx, NULL); } void bk_open_popup(BKContext *ctx, BKNode *popup, BKNode *owner, BKNode *parent_popup) { if (!parent_popup) { /* opened from inside a popup: nest under it */ for (const BKNode *nd = owner; nd && !parent_popup; nd = nd->parent) { if (bk_popup_index(ctx, nd) >= 0) { parent_popup = (BKNode *)nd; } } } if (parent_popup && bk_popup_index(ctx, parent_popup) >= 0) { bk_close_popups_after(ctx, parent_popup); } else { BK_close_popups(ctx); } if (ctx->npopups == BK_MAX_POPUPS) { BK_node_free(popup); return; } popup->parent = owner ? owner : ctx->root; ctx->popups[ctx->npopups++] = popup; ctx->tip_serial++; if (ctx->tip_shown) { ctx->tip_shown = 0; bk_ctx_dirty_rect(ctx, ctx->tip_rect); } if (ctx->win_w > 0) { bk_popup_place(popup, ctx->win_w, ctx->win_h); } bk_invalidate(popup); if (owner) { bk_invalidate(owner); } } int BK_popup_count(BKContext *ctx) { return ctx->npopups; } BKNode *BK_popup(BKContext *ctx, int i) { return (i >= 0 && i < ctx->npopups) ? ctx->popups[i] : NULL; } BKNode *BK_popup_owner(BKContext *ctx, int i) { return (i >= 0 && i < ctx->npopups) ? ctx->popups[i]->parent : NULL; } void bk_start_drag_toggle(BKContext *ctx, int group, int value) { ctx->dt_group = group; ctx->dt_value = value; ctx->dt_active = 1; ctx->dt_init_x = ctx->dt_last_x = ctx->pointer_x; ctx->dt_init_y = ctx->dt_last_y = ctx->pointer_y; } /* Sets one drag-toggle target to the dragged state (button_execute / panel open-close). */ static int drag_toggle_apply(BKContext *ctx, BKNode *under) { if (!under || under->cls->drag_group != ctx->dt_group || !NODE_ENABLED(under) || under == ctx->grab || (int)(under->value != 0) == ctx->dt_value) { return 0; } if (under->cls->drag_group == DRAG_GROUP_PANEL) { if (!bk_anim_running(under)) { under->anim = (under->flags & NF_COLLAPSED) ? 0.0f : 1.0f; } under->flags = ctx->dt_value ? (under->flags & ~NF_COLLAPSED) : (under->flags | NF_COLLAPSED); under->value = ctx->dt_value; bk_anim_start(under); bk_relayout(under); } else { bk_set_value(under, ctx->dt_value); } return 1; } static BKNode *hit_all(BKContext *ctx, int x, int y); /* drag_toggle_set_xy_xy (interface_handlers.cc): touch every toggle whose rect the segment from * the last pointer position to this one crosses (BLI_rctf_isect_segment), so fast drags don't * skip buttons; the segment is sampled every 2 px through the regular hit test. Panel headers * follow panel_drag_collapse: the segment runs from the drag start with x locked to it. No * xy axis lock for toggles: BL only locks for BUT_DRAG_LOCK buttons (tabs, decorators). */ static int drag_toggle_segment(BKContext *ctx, int x, int y) { int x0 = ctx->dt_last_x, y0 = ctx->dt_last_y; if (ctx->dt_group == DRAG_GROUP_PANEL) { x0 = x = ctx->dt_init_x; y0 = ctx->dt_init_y; } const int steps = BK_MAX(1, (int)(hypotf((float)(x - x0), (float)(y - y0)) / 2.0f)); int changed = 0; for (int i = 0; i <= steps; i++) { const int sx = x0 + (int)lroundf((x - x0) * (float)i / steps); const int sy = y0 + (int)lroundf((y - y0) * (float)i / steps); changed |= drag_toggle_apply(ctx, hit_all(ctx, sx, sy)); } ctx->dt_last_x = x; ctx->dt_last_y = y; return changed; } static void update_cursor(BKContext *ctx); void bk_begin_modal(BKContext *ctx, BKNode *tool) { if (!tool->parent) { tool->parent = ctx->root; } ctx->modal = tool; update_cursor(ctx); bk_ctx_request(ctx); } void bk_end_modal(BKContext *ctx) { BKNode *m = ctx->modal; ctx->modal = NULL; if (m) { m->parent = NULL; BK_node_free(m); } update_cursor(ctx); bk_ctx_request(ctx); } static char *g_clipboard = NULL; /* fallback when the host has none */ char *bk_clipboard_get(BKContext *ctx) { if (ctx && ctx->host.clipboard_get) { char *s = ctx->host.clipboard_get(ctx->host.data); if (s) { return s; } } return bk_strdup(g_clipboard ? g_clipboard : ""); } void bk_clipboard_set(BKContext *ctx, const char *s) { bk_set_text(&g_clipboard, s); if (ctx && ctx->host.clipboard_set) { ctx->host.clipboard_set(ctx->host.data, s); } } /** \} */ /* -------------------------------------------------------------------- */ /** \name Rendering * \{ */ static void layout(BKContext *ctx) { g_gen++; const int w = ctx->win_w, h = ctx->win_h; int hw = 0, hh = 0; if (ctx->header) { bk_natural(ctx->header, &hw, &hh); } ctx->header_h = hh; int cw = 0, ch = 0; if (ctx->root) { bk_natural(ctx->root, &cw, &ch); } ctx->content_h = ch; const int view_h = h - hh; ctx->scroll = BK_CLAMP(ctx->scroll, 0, BK_MAX(0, ch - view_h)); if (ctx->root) { bk_arrange(ctx->root, 0, hh - ctx->scroll, w, BK_MAX(ch, view_h)); } if (ctx->header) { bk_arrange(ctx->header, 0, 0, w, hh); } for (int i = 0; i < ctx->npopups; i++) { bk_popup_place(ctx->popups[i], w, h); } ctx->layout_dirty = false; } /* interface_region_tooltip.cc: portions of the line height, and the wrap width. */ #define TIP_SPACER 0.3f #define TIP_PADDING_X 1.95f #define TIP_PADDING_Y 1.28f #define TIP_MAXWIDTH 600 /* Bytes of the next wrapped line (BLFWrapMode Typographical | HardLimit): break at the last * space that fits, else inside the word at a UTF-8 boundary. */ static int tip_wrap_len(const char *s, int len, float maxw) { if (bk_text_width(s, len, false) <= maxw) { return len; } int brk = -1; for (int i = 1; i < len; i++) { if (s[i] == ' ') { if (bk_text_width(s, i, false) > maxw) { break; } brk = i; } } if (brk > 0) { return brk; } int i = 1; while (i < len && ((uchar)s[i] & 0xC0) == 0x80) { i++; } for (int j = i; j < len;) { int k = j + 1; while (k < len && ((uchar)s[k] & 0xC0) == 0x80) { k++; } if (bk_text_width(s, k, false) > maxw) { break; } i = j = k; } return i; } /* Lays out (and with `r`, draws) the tooltip text like tooltip_create_with_data / * tooltip_region_draw_cb: the first line is the TIP_STYLE_HEADER label in the theme text color, * followed by a TIP_SPACER gap; later lines use TIP_LC_VALUE, the text color blended 20% toward * the background (color_blend_f3_f3). Returns the text height, width in r_w. */ static float tooltip_text(BKContext *ctx, const BKRect *r, float *r_w) { const char *s = ctx->tip_node && ctx->tip_node->desc ? ctx->tip_node->desc : ""; const float h = bk_line_height(), pad_x = h * TIP_PADDING_X, pad_y = h * TIP_PADDING_Y; const float wrap = BK_MAX(h, BK_MIN(TIP_MAXWIDTH * bk_scale_fac, ctx->win_w - pad_x)); uchar value[4]; for (int i = 0; i < 3; i++) { value[i] = (uchar)(0.8f * bk_theme.tooltip.text[i] + 0.2f * bk_theme.tooltip.inner[i] + 0.5f); } value[3] = 255; float y = 0.0f, w = 0.0f; for (int para = 0;; para++) { const char *nl = strchr(s, '\n'); int len = nl ? (int)(nl - s) : (int)strlen(s); const char *p = s; do { const int n = tip_wrap_len(p, len, wrap); w = BK_MAX(w, bk_text_width(p, n, false)); if (r) { const BKRect lr = bk_rect(r->xmin, (int)(r->ymin + 0.5f * pad_y + y), bk_rw(r), (int)h); bk_text(r->xmin + 0.5f * pad_x, bk_text_baseline(&lr), p, n, para == 0 ? bk_theme.tooltip.text : value, false); } y += h; p += n; len -= n; while (len > 0 && *p == ' ') { p++; len--; } } while (len > 0); if (!nl) { break; } if (para == 0) { y += h * TIP_SPACER; } s = nl + 1; } if (r_w) { *r_w = w; } return y; } /* tooltip_create_from_button_or_extra_icon + tooltip_create_with_data: anchored under the * hovered button (rect.ymin - UI_POPUP_MARGIN / 2) at the pointer's x, offset by 0.2 line * heights, padded by TIP_PADDING, clamped 5/7 px (scaled) inside the window. */ static void tooltip_rect(BKContext *ctx, BKRect *r_rect) { float fontw; const float fonth = tooltip_text(ctx, NULL, &fontw); const float h = bk_line_height(), pad_x = h * TIP_PADDING_X, pad_y = h * TIP_PADDING_Y; const BKRect br = bk_node_rect(ctx->tip_node); const float init_x = (float)ctx->tip_x, init_y = br.ymax + 6.0f * bk_scale_fac; const int tw = (int)(fontw + pad_x + 0.5f), th = (int)(fonth + pad_y + 0.5f); int tx = (int)(init_x - 0.2f * h - pad_x); int ty = (int)(init_y + 0.2f * h); const int cx = (int)(5.0f * bk_scale_fac), cy = (int)(7.0f * bk_scale_fac); tx = BK_MAX(cx, BK_MIN(tx, ctx->win_w - cx - tw)); ty = BK_MAX(cy, BK_MIN(ty, ctx->win_h - cy - th)); /* near the bottom and overlapping the pointer: move up by 3 lines */ if (ctx->tip_x >= tx && ctx->tip_x < tx + tw && ctx->tip_y >= ty && ctx->tip_y < ty + th && ty + th > ctx->win_h * 3 / 4) { ty -= (int)(3.0f * h); } *r_rect = bk_rect(tx, ty, tw, th); } static void draw_tooltip(BKContext *ctx) { if (!ctx->tip_shown || !ctx->tip_node || !ctx->tip_node->desc) { return; } const BKRect r = ctx->tip_rect; bk_widget_tooltip_back(&r); tooltip_text(ctx, &r, NULL); } /* Region (View2D) vertical scroller, view2d_scroller_size_get + view2d_scrollers_calc: width * lerps from V2D_SCROLL_MIN_WIDTH (5 px * scale + 2 * pixelsize) to V2D_SCROLL_WIDTH * (0.45 * widget_unit + 2 * pixelsize) by alpha_vert, padded 0.1 units from the region edge; the * thumb is at least V2D_SCROLL_THUMB_SIZE_MIN (30 px * scale). */ void bk_scroller_rects(const BKRect *area, int scroll, int content_h, int alpha, BKRect *r_track, BKRect *r_thumb) { const int top = area->ymin, view_h = bk_rh(area); const float min_w = 5.0f * bk_scale_fac + 2.0f * bk_px(); const float max_w = 0.45f * bk_unit() + 2.0f * bk_px(); const int sw = (int)((max_w - min_w) * (alpha / 255.0f) + min_w); const int xmax = area->xmax - (int)(0.1f * bk_unit()); *r_track = bk_rect(xmax - sw, top, sw, view_h); const float thumb_min = 30.0f * bk_scale_fac; float t0 = top + (float)view_h * scroll / content_h; float t1 = top + (float)view_h * (scroll + view_h) / content_h; if (t1 - t0 < thumb_min) { t1 = BK_CLAMP(t0 + thumb_min, top + thumb_min, (float)(top + view_h)); t0 = BK_CLAMP(t0, (float)top, top + view_h - thumb_min); } *r_thumb = bk_rect(r_track->xmin, (int)t0, sw, (int)(t1 - t0)); } /* view2d_scrollers_draw_ex: alpha_fac maps alpha_vert 0..255 to V2D_SCROLL_MIN_ALPHA..1 */ void bk_scroller_draw(const BKRect *track, const BKRect *thumb, int alpha, bool pressed) { const float alpha_fac = (alpha / 255.0f) * (1.0f - 0.4f) + 0.4f; BKWCol wc = bk_theme.scroll; wc.inner[3] = wc.inner[3] == 0 ? (uchar)(0.25f * alpha) : (uchar)(wc.inner[3] * alpha_fac); wc.item[3] = (uchar)(wc.item[3] * alpha_fac); wc.outline[3] = 0; /* also disables the emboss, as widget_emboss[3] = 0 does */ bk_widget_scroll(&wc, track, thumb, pressed); } static void region_scroll_rects(BKContext *ctx, BKRect *r_track, BKRect *r_thumb) { const BKRect area = bk_rect(0, ctx->header_h, ctx->win_w, ctx->win_h - ctx->header_h); bk_scroller_rects(&area, ctx->scroll, ctx->content_h, ctx->scroll_alpha, r_track, r_thumb); } /* screen_ops.cc area_azone (AZ_SCROLL_VERT): alpha_vert = 1 - distance in x from the scroller / * V2D_SCROLL_HIDE_HEIGHT (HEADERY * scale); 255 while over it. Dirties it when it changes. */ static int region_scroll_update_alpha(BKContext *ctx, int x, int y) { const int top = ctx->header_h; if (ctx->content_h <= ctx->win_h - top) { return 0; } BKRect track, thumb; region_scroll_rects(ctx, &track, &thumb); const int dx = x < track.xmin ? track.xmin - x : (x > track.xmax ? x - track.xmax : 0); float alpha = 1.0f - BK_CLAMP(dx / (26.0f * bk_scale_fac), 0.0f, 1.0f); if (y < top) { alpha = 0.0f; } const int a = (int)(alpha * 255); if (a == ctx->scroll_alpha) { return 0; } const int full = (int)(0.45f * bk_unit() + 2.0f * bk_px()) + bk_unit(); ctx->scroll_alpha = a; bk_ctx_dirty_rect(ctx, bk_rect(ctx->win_w - full, top, full, ctx->win_h - top)); return 1; } static void draw_region(BKContext *ctx, const BKRect *rect) { bk_image_pass_begin(ctx, rect->xmin, rect->ymin, rect->xmax, rect->ymax); const int w = ctx->win_w, h = ctx->win_h; bk_clip_reset(w, h); bk_clip_push(rect->xmin, rect->ymin, bk_rw(rect), bk_rh(rect)); if (BUI_raster_alpha(bk_draw.r)) { /* a transparent window: no region background */ BUI_raster_clear(bk_draw.r, rect->xmin, rect->ymin, bk_rw(rect), bk_rh(rect)); } else if (!(ctx->root && (ctx->root->flags & NF_OPAQUE))) { bk_fill(rect->xmin, rect->ymin, bk_rw(rect), bk_rh(rect), bk_theme.region_bg); } const int top = ctx->header_h, view_h = h - top; bk_clip_push(0, top, w, view_h); if (ctx->root) { bk_draw_tree(ctx->root); } bk_clip_pop(); if (ctx->header) { bk_draw_tree(ctx->header); } if (ctx->content_h > view_h) { /* region scrollbar */ BKRect track, thumb; region_scroll_rects(ctx, &track, &thumb); bk_scroller_draw(&track, &thumb, ctx->scroll_alpha, false); } for (int i = 0; i < ctx->npopups; i++) { bk_draw_tree(ctx->popups[i]); } draw_tooltip(ctx); bk_clip_reset(w, h); bk_image_pass_end(); } int BK_needs_render(BKContext *ctx) { return ctx->layout_dirty || ctx->full_dirty || ctx->ndirty > 0; } static void anim_step(BKContext *ctx); /* The window's size is `w` x `h`: lays out and reports the new geometry (BK_EV_CONFIGURE), whose * handlers can rebuild the tree before anything is drawn. True when the size changed. */ int BK_configure(BKContext *ctx, int w, int h) { const bool changed = w != ctx->win_w || h != ctx->win_h; if (changed) { ctx->win_w = w; ctx->win_h = h; ctx->layout_dirty = true; layout(ctx); bk_views_check(ctx); } return changed; } int BK_render(BKContext *ctx, BuiRaster *r, int w, int h, int full) { BK_image_poll(); /* decoded images arrive (and damage where they show) */ bk_image_tick(); /* animated images whose next frame is due */ bk_draw.r = r; ctx->raster = r; if (!BK_anim_host_clock()) { BK_anim_tick(bk_time()); /* motions write their values (nodes damage themselves) */ } anim_step(ctx); BK_configure(ctx, w, h); if (BUI_raster_width(r) != w || BUI_raster_height(r) != h) { ctx->layout_dirty = true; } if (full || ctx->layout_dirty) { ctx->full_dirty = true; } if (ctx->layout_dirty) { layout(ctx); } bk_views_check(ctx); if (ctx->layout_dirty) { /* a scroll command changed the layout */ layout(ctx); } bk_custom_frames(ctx); /* immediate-mode nodes build this frame (they dirty themselves) */ if (ctx->layout_dirty) { ctx->full_dirty = true; layout(ctx); } if (!ctx->full_dirty && ctx->ndirty == 0) { return 0; } bk_image_frame_begin(); /* a drawn frame: the image cache ages one generation */ BUI_raster_begin_frame(r, w, h); int regions; if (ctx->full_dirty) { const BKRect all = bk_rect(0, 0, w, h); draw_region(ctx, &all); BUI_raster_end_frame(r); regions = 1; } else { BKRect bbox = ctx->dirty[0]; for (int i = 0; i < ctx->ndirty; i++) { BKRect d = ctx->dirty[i]; d.xmin = BK_MAX(d.xmin, 0); d.ymin = BK_MAX(d.ymin, 0); d.xmax = BK_MIN(d.xmax, w); d.ymax = BK_MIN(d.ymax, h); if (d.xmax > d.xmin && d.ymax > d.ymin) { draw_region(ctx, &d); } rect_union(&bbox, &ctx->dirty[i]); } BUI_raster_end_frame_region(r, bbox.xmin, bbox.ymin, bk_rw(&bbox), bk_rh(&bbox)); regions = ctx->ndirty; } ctx->full_dirty = false; ctx->ndirty = 0; return regions; } /** \} */ /* -------------------------------------------------------------------- */ /** \name Input * \{ */ #define DOUBLE_CLICK_S 0.35 #define DOUBLE_CLICK_PX 4 #define TOOLTIP_DELAY_MS 500 /* UI_TOOLTIP_DELAY 0.5 */ static BKNode *hit_all(BKContext *ctx, int x, int y) { for (int i = ctx->npopups - 1; i >= 0; i--) { if (bk_contains(ctx->popups[i], x, y)) { return bk_hit(ctx->popups[i], x, y); } } if (ctx->header && bk_contains(ctx->header, x, y)) { return bk_hit(ctx->header, x, y); } if (y < ctx->header_h) { return NULL; } return ctx->root ? bk_hit(ctx->root, x, y) : NULL; } static BKEvent make_event(BKContext *ctx, BKNode *target, int x, int y, int mods) { BKEvent e; memset(&e, 0, sizeof(e)); e.x = x; e.y = y; e.mods = mods; if (target) { e.lx = x - target->x; e.ly = y - target->y; e.inside = bk_contains(target, x, y); } e.dx = x - ctx->press_x; e.dy = y - ctx->press_y; e.dragged = ctx->dragging; e.text = ""; e.keysym = ""; return e; } static int hide_tooltip(BKContext *ctx) { ctx->tip_serial++; if (ctx->tip_shown) { ctx->tip_shown = 0; bk_ctx_dirty_rect(ctx, bk_rect(ctx->tip_rect.xmin - 12, ctx->tip_rect.ymin - 12, bk_rw(&ctx->tip_rect) + 24, bk_rh(&ctx->tip_rect) + 24)); return 1; } return 0; } static void arm_tooltip(BKContext *ctx, BKNode *target, int x, int y) { ctx->tip_serial++; if (!target || !target->desc || !target->desc[0] || !ctx->host.schedule) { return; } ctx->tip_node = target; ctx->tip_x = x; ctx->tip_y = y; ctx->host.schedule(ctx->host.data, TOOLTIP_DELAY_MS, ctx->tip_serial); } void BK_timer(BKContext *ctx, int timer) { if (timer == BK_TIMER_CUSTOM) { bk_custom_timer(ctx); return; } if (timer == ctx->tip_serial && ctx->tip_node && ctx->hover == ctx->tip_node && !ctx->grab && !ctx->tip_shown) { ctx->tip_shown = 1; tooltip_rect(ctx, &ctx->tip_rect); bk_ctx_dirty_rect(ctx, bk_rect(ctx->tip_rect.xmin - 12, ctx->tip_rect.ymin - 12, bk_rw(&ctx->tip_rect) + 24, bk_rh(&ctx->tip_rect) + 24)); } } static void set_hover(BKContext *ctx, BKNode *n) { if (n == ctx->hover) { return; } BKNode *old = ctx->hover; ctx->hover = n; if (old) { if (old->cls->leave) { old->cls->leave(old); } bk_invalidate(old); bk_event(old, BK_EV_LEAVE, 0, NULL); } if (n) { bk_invalidate(n); bk_event(n, BK_EV_ENTER, 0, NULL); } } static void update_cursor(BKContext *ctx) { int name; if (ctx->modal) { name = ctx->modal->cls->cursor ? ctx->modal->cls->cursor : BK_CURSOR_CROSSHAIR; } else if (ctx->grab && ctx->dragging && ctx->grab->cls->drag_cursor && !BK_HTML(ctx->grab)) { name = ctx->grab->cls->drag_cursor; } else { BKNode *n = ctx->grab ? ctx->grab : ctx->hover; name = BK_CURSOR_DEFAULT; if (n && n->cursor_override) { name = n->cursor_override - 1; } else if (n && NODE_ENABLED(n)) { name = n->cls->cursor_at ? n->cls->cursor_at(n, ctx->pointer_x, ctx->pointer_y) : n->cls->cursor; } } if (name != ctx->cursor) { ctx->cursor = name; if (ctx->host.set_cursor) { ctx->host.set_cursor(ctx->host.data, name); } } } void bk_update_cursor(BKContext *ctx) { update_cursor(ctx); } static bool continuous(BKContext *ctx) { return ctx->host.warp && ctx->grab && ctx->dragging && !BK_HTML(ctx->grab) && ctx->grab->cls->drag_cursor == BK_CURSOR_NONE; } static void wrap_pointer(BKContext *ctx, int x, int y) { const int e = 12, w = ctx->win_w, h = ctx->win_h; if (w <= 2 * e || h <= 2 * e) { return; } if (x > e && x < w - e && y > e && y < h - e) { return; } int px = ctx->press_x - ctx->off_x, py = ctx->press_y - ctx->off_y; px = BK_CLAMP(px, e + 1, w - e - 1); py = BK_CLAMP(py, e + 1, h - e - 1); ctx->off_x += x - px; ctx->off_y += y - py; ctx->skip_x = px; ctx->skip_y = py; ctx->has_skip = true; ctx->host.warp(ctx->host.data, px, py); } void BK_set_pointer(BKContext *ctx, int x, int y) { ctx->pointer_x = x; ctx->pointer_y = y; } static int in_BK_motion(BKContext *ctx, int x, int y, int mods) { if (ctx->has_skip) { ctx->has_skip = false; if (x == ctx->skip_x && y == ctx->skip_y) { return 0; /* the warp we caused */ } } ctx->pointer_x = x; ctx->pointer_y = y; int changed = hide_tooltip(ctx); changed |= region_scroll_update_alpha(ctx, x, y); if (ctx->modal) { BKEvent e = make_event(ctx, ctx->modal, x, y, mods); if (ctx->modal->cls->move) { changed |= ctx->modal->cls->move(ctx->modal, &e); } update_cursor(ctx); return changed; } if (BK_IS_CUSTOM(ctx->grab)) { /* every motion, no drag threshold of ours */ BKNode *g = ctx->grab; if (x <= -50000 || y <= -50000) { return 0; /* a host's "pointer left the window" while grabbed: keep the last position */ } BKEvent e = make_event(ctx, g, x, y, mods); g->cls->move(g, &e); BKNode *under = hit_all(ctx, x, y); if (under != ctx->hover) { set_hover(ctx, under); } update_cursor(ctx); return 1; } if (ctx->grab) { const int vx = x + ctx->off_x, vy = y + ctx->off_y; const int threshold = BK_MAX(3, (int)(0.15f * bk_unit())); if (!ctx->dragging && (abs(vx - ctx->press_x) > threshold || abs(vy - ctx->press_y) > threshold)) { ctx->dragging = true; update_cursor(ctx); } if (ctx->dragging) { BKEvent e = make_event(ctx, ctx->grab, vx, vy, mods); if (ctx->grab->cls->drag) { changed |= ctx->grab->cls->drag(ctx->grab, &e); } if (ctx->grab) { bk_event(ctx->grab, BK_EV_MOTION, mods, &e); } } if (!ctx->grab) { /* the drag handler may have closed things */ return 1; } if (ctx->dt_active) { /* Blender: drag across toggles */ changed |= drag_toggle_segment(ctx, x, y); } BKNode *under = hit_all(ctx, x, y); if (under != ctx->hover) { set_hover(ctx, under); changed = 1; } if (continuous(ctx)) { wrap_pointer(ctx, x, y); } return changed; } BKNode *under = hit_all(ctx, x, y); if (under != ctx->hover) { set_hover(ctx, under); changed = 1; } if (under) { BKEvent e = make_event(ctx, under, x, y, mods); if (under->cls->move) { changed |= under->cls->move(under, &e); } bk_event(under, BK_EV_MOTION, mods, &e); } arm_tooltip(ctx, under, x, y); update_cursor(ctx); return changed; } /* A custom node grabbed by one button gets presses and releases of the others * directly (ImGui holds several buttons at once). */ static int custom_extra_button(BKContext *ctx, int x, int y, int button, int release, int mods) { BKNode *g = ctx->grab; if (!BK_IS_CUSTOM(g) || button == ctx->press_button) { return 0; } BKCustomEvent ce; memset(&ce, 0, sizeof(ce)); ce.type = release ? BK_CUSTOM_RELEASE : BK_CUSTOM_PRESS; ce.button = button; ce.mods = mods; ce.clicks = release ? 0 : 1; bk_custom_event(g, &ce, x, y); return 1; } static int in_BK_press(BKContext *ctx, int x, int y, int mods) { const int button = ctx->next_button > 0 ? ctx->next_button : 1; ctx->next_button = 0; if (custom_extra_button(ctx, x, y, button, 0, mods)) { return 1; } hide_tooltip(ctx); ctx->pointer_x = x; ctx->pointer_y = y; ctx->press_x = x; ctx->press_y = y; ctx->dragging = false; ctx->has_ungrab = false; ctx->press_button = button; ctx->off_x = ctx->off_y = 0; if (ctx->modal) { BKEvent e = make_event(ctx, ctx->modal, x, y, mods); if (ctx->modal->cls->press) { ctx->modal->cls->press(ctx->modal, &e); } update_cursor(ctx); return 1; } if (ctx->npopups) { bool inside = false; for (int i = 0; i < ctx->npopups; i++) { inside |= bk_contains(ctx->popups[i], x, y); } if (!inside) { BK_close_popups(ctx); /* Blender: an outside click only closes menus */ ctx->hover = NULL; update_cursor(ctx); return 1; } } BKNode *target = hit_all(ctx, x, y); if (ctx->focus && target != ctx->focus) { end_edit(ctx, true); } set_hover(ctx, target); if (!target || !NODE_ENABLED(target)) { ctx->grab = NULL; /* disabled components get no drags either */ return 1; } ctx->grab = target; ctx->interaction++; bk_invalidate(target); BKEvent e = make_event(ctx, target, x, y, mods); const double now = bk_time(); if (ctx->last_click_node == target && now - ctx->last_click_t < DOUBLE_CLICK_S && abs(x - ctx->last_click_x) <= DOUBLE_CLICK_PX && abs(y - ctx->last_click_y) <= DOUBLE_CLICK_PX) { ctx->last_click_node = NULL; bk_event(target, BK_EV_DOUBLE, mods, &e); if (target->cls->dbl) { target->cls->dbl(target, &e); } else if (target->cls->press) { target->cls->press(target, &e); } } else { ctx->last_click_t = now; ctx->last_click_node = target; ctx->last_click_x = x; ctx->last_click_y = y; bk_event(target, BK_EV_PRESS, mods, &e); if (target->cls->press) { target->cls->press(target, &e); } } update_cursor(ctx); return 1; } static int in_BK_release(BKContext *ctx, int x, int y, int mods) { const int button = ctx->next_button > 0 ? ctx->next_button : 1; ctx->next_button = 0; if (custom_extra_button(ctx, x, y, button, 1, mods)) { return 1; } if (ctx->modal) { BKEvent e = make_event(ctx, ctx->modal, x, y, mods); if (ctx->modal->cls->release) { ctx->modal->cls->release(ctx->modal, &e); } return 1; } const bool was_continuous = continuous(ctx); const int vx = x + ctx->off_x, vy = y + ctx->off_y; BKNode *grab = ctx->grab; ctx->dt_active = 0; if (grab && NODE_ENABLED(grab)) { BKEvent e = make_event(ctx, grab, vx, vy, mods); if (grab->cls->release) { grab->cls->release(grab, &e); } if (ctx->grab == grab) { bk_event(grab, BK_EV_RELEASE, mods, &e); } } /* The handler may have closed (freed) popups; that clears ctx->grab when * it pointed into them, so re-read it. */ grab = ctx->grab; ctx->grab = NULL; if (grab) { bk_invalidate(grab); } if (ctx->dragging && bk_popup_index(ctx, grab) < 0) { /* Blender: press a menu button, drag onto an item, release to pick. */ for (int i = ctx->npopups - 1; i >= 0; i--) { BKNode *p = ctx->popups[i]; if (bk_contains(p, x, y) && p != grab) { BKEvent e = make_event(ctx, p, x, y, mods); if (p->cls->release) { p->cls->release(p, &e); } break; } } } ctx->dragging = false; if (was_continuous) { /* Blender puts the pointer back where the drag began, or where the * widget asks (USE_CONT_MOUSE_CORRECT: a slider's value). */ const int ux = ctx->has_ungrab ? ctx->ungrab_x : ctx->press_x; const int uy = ctx->has_ungrab ? ctx->ungrab_y : ctx->press_y; ctx->has_ungrab = false; ctx->skip_x = ux; ctx->skip_y = uy; ctx->has_skip = true; ctx->host.warp(ctx->host.data, ux, uy); x = ux; y = uy; } ctx->off_x = ctx->off_y = 0; ctx->pointer_x = x; ctx->pointer_y = y; set_hover(ctx, hit_all(ctx, x, y)); update_cursor(ctx); return 1; } static void raw_event(BKNode *n, int kind, int mods, const BKEvent *e, int button); static BKNode *buttons_target(BKContext *ctx, int x, int y) { if (ctx->modal || ctx->npopups) { return NULL; } BKNode *n = hit_all(ctx, x, y); return n && (n->cls->flags & CLS_BUTTONS) && NODE_ENABLED(n) ? n : NULL; } static int in_BK_context_menu(BKContext *ctx, int x, int y, int mods) { if (custom_extra_button(ctx, x, y, 3, 0, mods | BK_BUTTON3)) { return 1; } if (ctx->grab && ctx->dragging && ctx->grab->cls->cancel) { ctx->grab->cls->cancel(ctx->grab); /* Blender: the right button cancels a drag, as Escape */ ctx->has_ungrab = false; return 1; } if (buttons_target(ctx, x, y) && !ctx->grab) { /* an editor takes the right button */ ctx->next_button = 3; const int r = in_BK_press(ctx, x, y, mods | BK_BUTTON3); ctx->press_button = 3; return r; } hide_tooltip(ctx); if (ctx->modal) { bk_end_modal(ctx); return 1; } if (ctx->focus) { end_edit(ctx, true); } BKNode *under = hit_all(ctx, x, y); if (under && (under->flags & NF_EVENTS)) { /* bindings see it first */ BKEvent e = make_event(ctx, under, x, y, mods); raw_event(under, BK_EV_PRESS, mods, &e, 3); } bool in_popup = false; for (int i = 0; i < ctx->npopups; i++) { in_popup |= bk_contains(ctx->popups[i], x, y); } BKNode *target = hit_all(ctx, x, y); if (!in_popup) { BK_close_popups(ctx); } for (BKNode *n = target; n; n = n->parent) { if (!NODE_ENABLED(n) || bk_popup_index(ctx, n) >= 0) { continue; } BKMenuSpec items[16]; int count = 0; if (n->cls->context_items) { count = n->cls->context_items(n, items, 16); } else if (n->cls->flags & CLS_VALUE) { count = bk_value_context_items(n, items, 16); } if (count > 0) { if (in_popup) { BK_close_popups(ctx); } BK_open_menu(ctx, n, items, count, n->label && n->label[0] ? n->label : NULL, x, y); return 1; } } return 1; } static int key_mods_match(int mods, const BKKeyBinding *k) { return (mods & (BK_SHIFT | BK_CTRL | BK_ALT)) == k->mods; } /* Blender: Ctrl+Z / Ctrl+Shift+Z (and Ctrl+Y) undo/redo UI edits */ static int undo_key(BKContext *ctx, const char *keysym, int mods) { if ((mods & BK_CTRL) && bk_keysym_is(keysym, "z")) { return (mods & BK_SHIFT) ? BK_redo(ctx) : BK_undo(ctx); } if ((mods & BK_CTRL) && bk_keysym_is(keysym, "y")) { return BK_redo(ctx); } return 0; } static BKNode *deepest(BKNode *n, int x, int y); static int in_BK_key(BKContext *ctx, const char *text, const char *keysym, int mods) { hide_tooltip(ctx); if (bk_ime_swallow_key(ctx, text, keysym)) { return 1; /* typed text and Escape belong to the IME while it composes */ } BKEvent e = make_event(ctx, NULL, ctx->pointer_x, ctx->pointer_y, mods); e.text = text ? text : ""; e.keysym = keysym ? keysym : ""; snprintf(ctx->key_held, sizeof(ctx->key_held), "%s", e.keysym); ctx->interaction++; for (BKNode *n = ctx->focus ? ctx->focus : ctx->hover; n; n = n->parent) { if (n->flags & NF_EVENTS) { /* Tk/Qt key bindings see the key first */ bk_event(n, BK_EV_KEY, mods, &e); break; } } if (ctx->modal) { if (bk_keysym_is(e.keysym, "Escape")) { bk_end_modal(ctx); } return 1; } if (ctx->grab && ctx->dragging && ctx->grab->cls->cancel && bk_keysym_is(e.keysym, "Escape")) { ctx->grab->cls->cancel(ctx->grab); /* Blender: Escape cancels a drag */ ctx->has_ungrab = false; return 1; } if (ctx->focus) { BKNode *f = ctx->focus; if (f->cls->key && f->cls->key(f, &e)) { return 1; } return undo_key(ctx, e.keysym, mods); } if (ctx->npopups) { BKNode *top = ctx->popups[ctx->npopups - 1]; if (top->cls->key && top->cls->key(top, &e)) { return 1; } if (bk_keysym_is(e.keysym, "Escape")) { bk_close_popups_after(ctx, ctx->npopups > 1 ? ctx->popups[ctx->npopups - 2] : NULL); return 1; } return 0; } /* bubble up to a handler: from the hovered widget, or over none from what is under the pointer * (Blender's region and area keymaps: Ctrl+Space anywhere in an editor) */ BKNode *start = ctx->hover; if (!start && ctx->root && ctx->pointer_y >= ctx->header_h) { start = deepest(ctx->root, ctx->pointer_x, ctx->pointer_y); } for (BKNode *n = start; n; n = n->parent) { if (!NODE_ENABLED(n)) { continue; } if (n->cls->key) { e.lx = e.x - n->x; e.ly = e.y - n->y; if (n->cls->key(n, &e)) { return 1; } } else if ((n->cls->flags & CLS_VALUE) && bk_value_key(n, &e)) { return 1; } } for (int i = 0; i < ctx->nkeys; i++) { if (key_mods_match(mods, &ctx->keys[i]) && bk_keysym_is(e.keysym, ctx->keys[i].keysym)) { if (ctx->host.emit) { ctx->host.emit(ctx->host.data, NULL, BK_EV_CALL, ctx->keys[i].ref, 0, 0); } return 1; } } return undo_key(ctx, e.keysym, mods); } static BKNode *deepest(BKNode *n, int x, int y) { if (!NODE_VISIBLE(n) || !bk_contains(n, x, y)) { return NULL; } for (int i = n->nkids - 1; i >= 0; i--) { BKNode *f = deepest(n->kids[i], x, y); if (f) { return f; } } return n; } /* `px`: the exact distance in pixels (BK_scroll_px; same sign as `delta`), 0 for a plain wheel step. * Scroll containers and raw events use it, other widgets keep the step. */ static int in_BK_wheel(BKContext *ctx, int x, int y, int delta, float px, int mods) { hide_tooltip(ctx); BKNode *target = hit_all(ctx, x, y); if (!target && ctx->root && y >= ctx->header_h) { target = deepest(ctx->root, x, y); /* non-interactive area: let containers scroll */ } for (BKNode *n = target; n; n = n->parent) { if (!NODE_ENABLED(n)) { continue; } BKEvent e = make_event(ctx, n, x, y, mods); e.delta = delta; e.wheel_y = px; if (n == target) { bk_event(n, BK_EV_WHEEL, mods, &e); } if (n->cls->wheel ? n->cls->wheel(n, &e) : ((n->cls->flags & CLS_VALUE) && bk_value_wheel(n, &e))) { return 1; } } /* scroll the region */ const int view_h = ctx->win_h - ctx->header_h; if (ctx->content_h > view_h && !ctx->npopups) { const int step = px != 0.0f ? (int)(px + (px > 0.0f ? 0.5f : -0.5f)) : delta * 2 * bk_unit(); const int ns = BK_CLAMP(ctx->scroll - step, 0, ctx->content_h - view_h); if (ns != ctx->scroll) { ctx->scroll = ns; ctx->layout_dirty = true; bk_ctx_request(ctx); return 1; } } return 0; } void BK_bind(BKContext *ctx, const char *combo, void *ref) { if (ctx->nkeys == BK_MAX_KEYS) { return; } BKKeyBinding *k = &ctx->keys[ctx->nkeys++]; memset(k, 0, sizeof(*k)); k->mods = bk_combo_parse(combo, k->keysym, sizeof(k->keysym)); k->ref = ref; bk_retain(ref); } int bk_combo_parse(const char *combo, char *r_keysym, int size) { int mods = 0; const char *s = combo; while (1) { const char *plus = strchr(s, '+'); if (!plus || plus[1] == '\0') { /* "ctrl++": the key is '+' */ break; } const int len = (int)(plus - s); if (len == 4 && strncmp(s, "ctrl", 4) == 0) { mods |= BK_CTRL; } else if (len == 5 && strncmp(s, "shift", 5) == 0) { mods |= BK_SHIFT; } else if (len == 3 && strncmp(s, "alt", 3) == 0) { mods |= BK_ALT; } s = plus + 1; } snprintf(r_keysym, (size_t)size, "%s", s); return mods; } bool bk_combo_matches(const char *combo, int mods, const char *keysym) { char key[32]; const int want = bk_combo_parse(combo, key, sizeof(key)); return key[0] && (mods & (BK_SHIFT | BK_CTRL | BK_ALT)) == want && bk_keysym_is(keysym, key); } int BK_cursor(BKContext *ctx) { return ctx->cursor; } BKNode *BK_hover(BKContext *ctx) { return ctx->hover; } BKNode *BK_focus(BKContext *ctx) { return ctx->focus; } void BK_focus_node(BKContext *ctx, BKNode *n) { if (!n) { if (ctx->focus) { end_edit(ctx, true); } return; } if (n == ctx->focus || !NODE_ENABLED(n)) { return; } if (n->cls == &bk_cls_textarea) { if (ctx->focus) { end_edit(ctx, true); } ctx->focus = n; bk_invalidate(n); } else if ((n->cls == &bk_cls_text || n->cls == &bk_cls_search || n->cls == &bk_cls_number) && n->cls->activate) { n->cls->activate(n); } } char *BK_clipboard_get(BKContext *ctx) { return bk_clipboard_get(ctx); } void BK_clipboard_set(BKContext *ctx, const char *text) { bk_clipboard_set(ctx, text); } int BK_modal_active(BKContext *ctx) { return ctx->modal != NULL; } int BK_tooltip_visible(BKContext *ctx) { return ctx->tip_shown; } /** \} */ /* -------------------------------------------------------------------- */ /** \name Text editing (Blender's text button: ui_textedit_*) * \{ */ BKTextEdit *bk_te_new(const char *text, bool select_all) { BKTextEdit *te = (BKTextEdit *)calloc(1, sizeof(BKTextEdit)); te->len = text ? (int)strlen(text) : 0; te->cap = te->len + 64; te->text = (char *)malloc((size_t)te->cap); memcpy(te->text, text ? text : "", (size_t)te->len + 1); te->caret = te->len; te->anchor = select_all ? 0 : -1; /* ui_textedit_begin: textedit_undo_stack_create + push of the initial string */ te->undo = bk_textedit_undo_stack_create(); bk_textedit_undo_push(te->undo, te->text, te->caret); return te; } void bk_te_free(BKTextEdit *te) { if (te) { bk_textedit_undo_stack_destroy(te->undo); bk_ime_comp_free(&te->ime); free(te->text); free(te); } } static bool te_selection(const BKTextEdit *te, int *a, int *b) { if (te->anchor < 0 || te->anchor == te->caret) { return false; } *a = BK_MIN(te->anchor, te->caret); *b = BK_MAX(te->anchor, te->caret); return true; } static void te_delete(BKTextEdit *te, int a, int b) { memmove(te->text + a, te->text + b, (size_t)(te->len - b + 1)); te->len -= b - a; te->caret = a; te->anchor = -1; } bool bk_te_delete_selection(BKTextEdit *te) { int a, b; if (!te_selection(te, &a, &b)) { return false; } te_delete(te, a, b); return true; } #define te_delete_selection bk_te_delete_selection static void te_insert(BKTextEdit *te, const char *s) { te_delete_selection(te); int n = (int)strlen(s); if (te->len + n + 1 > te->cap) { te->cap = te->len + n + 64; te->text = (char *)realloc(te->text, (size_t)te->cap); } memmove(te->text + te->caret + n, te->text + te->caret, (size_t)(te->len - te->caret + 1)); memcpy(te->text + te->caret, s, (size_t)n); /* no line breaks in single-line fields */ for (int i = 0; i < n; i++) { if (te->text[te->caret + i] == '\n' || te->text[te->caret + i] == '\r') { te->text[te->caret + i] = ' '; } } te->len += n; te->caret += n; te->anchor = -1; } static void te_move(BKTextEdit *te, int to, bool extend) { if (extend) { if (te->anchor < 0) { te->anchor = te->caret; } } else { te->anchor = -1; } te->caret = BK_CLAMP(to, 0, te->len); } static int te_step(BKTextEdit *te, int pos, bool next, bool word) { BLI_str_cursor_step_utf8(te->text, te->len, &pos, next ? STRCUR_DIR_NEXT : STRCUR_DIR_PREV, word ? STRCUR_JUMP_DELIM : STRCUR_JUMP_NONE, true); return pos; } static int te_key(BKTextEdit *te, BKContext *ctx, const char *text, const char *ks, int mods); /* Blender's ui_do_but_textedit undo: Ctrl+Z / Ctrl+Shift+Z (and Ctrl+Y) step * the edit's own stack (interface_undo.cc); every other change is pushed. */ int bk_te_key(BKTextEdit *te, BKContext *ctx, const char *text, const char *ks, int mods) { if ((mods & BK_CTRL) && !(mods & BK_ALT) && (bk_keysym_is(ks, "z") || bk_keysym_is(ks, "y"))) { const bool is_redo = (mods & BK_SHIFT) || bk_keysym_is(ks, "y"); int undo_pos; const char *undo_str = bk_textedit_undo(te->undo, is_redo ? 1 : -1, &undo_pos); if (undo_str != NULL) { te->len = (int)strlen(undo_str); if (te->len + 1 > te->cap) { te->cap = te->len + 64; te->text = (char *)realloc(te->text, (size_t)te->cap); } memcpy(te->text, undo_str, (size_t)te->len + 1); /* Set the cursor & clear selection. */ te->caret = BK_CLAMP(undo_pos, 0, te->len); te->anchor = -1; } return TE_CHANGED; } char stack_buf[256]; char *before = te->len < (int)sizeof(stack_buf) ? stack_buf : (char *)malloc((size_t)te->len + 1); memcpy(before, te->text, (size_t)te->len + 1); const int res = te_key(te, ctx, text, ks, mods); if (res == TE_CHANGED && strcmp(before, te->text) != 0) { bk_textedit_undo_push(te->undo, te->text, te->caret); } if (before != stack_buf) { free(before); } return res; } static int te_key(BKTextEdit *te, BKContext *ctx, const char *text, const char *ks, int mods) { const bool ctrl = mods & BK_CTRL, shift = mods & BK_SHIFT; if (bk_keysym_is(ks, "ISO_Left_Tab")) { /* X11's Shift+Tab */ return TE_PREV; } if (bk_keysym_is(ks, "Tab")) { return (mods & BK_SHIFT) ? TE_PREV : TE_NEXT; /* Blender: Tab edits the next field */ } if (bk_keysym_is(ks, "Return") || bk_keysym_is(ks, "KP_Enter")) { return TE_CONFIRM; } if (bk_keysym_is(ks, "Escape")) { return TE_CANCEL; } int a, b; const bool has_sel = te_selection(te, &a, &b); if (ctrl && (bk_keysym_is(ks, "a") || bk_keysym_is(ks, "c") || bk_keysym_is(ks, "x") || bk_keysym_is(ks, "v"))) { if (bk_keysym_is(ks, "a")) { te->anchor = 0; te->caret = te->len; } else if ((bk_keysym_is(ks, "c") || bk_keysym_is(ks, "x")) && has_sel) { char *sel = (char *)malloc((size_t)(b - a + 1)); memcpy(sel, te->text + a, (size_t)(b - a)); sel[b - a] = 0; bk_clipboard_set(ctx, sel); free(sel); if (bk_keysym_is(ks, "x")) { te_delete_selection(te); } } else if (bk_keysym_is(ks, "v")) { char *clip = bk_clipboard_get(ctx); if (clip) { te_insert(te, clip); free(clip); } } return TE_CHANGED; } if (bk_keysym_is(ks, "Left")) { if (has_sel && !shift) { te_move(te, a, false); } else { te_move(te, te_step(te, te->caret, false, ctrl), shift); } return TE_CHANGED; } if (bk_keysym_is(ks, "Right")) { if (has_sel && !shift) { te_move(te, b, false); } else { te_move(te, te_step(te, te->caret, true, ctrl), shift); } return TE_CHANGED; } if (bk_keysym_is(ks, "Home") || bk_keysym_is(ks, "Up")) { te_move(te, 0, shift); return TE_CHANGED; } if (bk_keysym_is(ks, "End") || bk_keysym_is(ks, "Down")) { te_move(te, te->len, shift); return TE_CHANGED; } if (bk_keysym_is(ks, "BackSpace")) { if (!te_delete_selection(te) && te->caret > 0) { te_delete(te, te_step(te, te->caret, false, ctrl), te->caret); } return TE_CHANGED; } if (bk_keysym_is(ks, "Delete")) { if (!te_delete_selection(te) && te->caret < te->len) { const int c = te->caret; te_delete(te, c, te_step(te, c, true, ctrl)); } return TE_CHANGED; } if (text && (uchar)text[0] >= 0x20 && text[0] != 0x7f && !ctrl) { te_insert(te, text); return TE_CHANGED; } return TE_NONE; } int bk_te_index_at(BKTextEdit *te, float px) { px += te->scroll; float prev = 0.0f; int i = 0; while (i < te->len) { int nx = i; BLI_str_cursor_step_utf8(te->text, te->len, &nx, STRCUR_DIR_NEXT, STRCUR_JUMP_NONE, true); const float w = bk_masked_width(te->text, nx, te->mask, false); if (px < (prev + w) * 0.5f) { return i; } prev = w; i = nx; } return te->len; } void bk_te_click(BKTextEdit *te, float px, bool extend) { te_move(te, bk_te_index_at(te, px), extend); } void bk_te_drag(BKTextEdit *te, float px) { if (te->anchor < 0) { te->anchor = te->caret; } te->caret = bk_te_index_at(te, px); } void bk_te_select_word(BKTextEdit *te, int index) { int a, b; BLI_str_cursor_step_bounds_utf8(te->text, te->len, BK_CLAMP(index, 0, te->len), &a, &b); if (a == b) { te->anchor = 0; te->caret = te->len; } else { te->anchor = a; te->caret = b; } } #define CARET_BLINK_S 0.53 bool bk_te_caret_visible(BKTextEdit *te) { const double now = bk_time(); if (te->blink_t0 <= 0.0 || te->caret != te->blink_caret || te->len != te->blink_len) { te->blink_t0 = now; te->blink_caret = te->caret; te->blink_len = te->len; } return (((long)((now - te->blink_t0) / CARET_BLINK_S)) & 1) == 0; } double bk_te_next_toggle(BKTextEdit *te) { return te->blink_t0 + (floor((bk_time() - te->blink_t0) / CARET_BLINK_S) + 1.0) * CARET_BLINK_S; } void bk_te_draw(BKTextEdit *te, const BKRect *rect, const uchar color[4]) { const int p = bk_pad(); const float inner = BK_MAX(1.0f, (float)(bk_rw(rect) - 2 * p)); const BKImeComp *ime = &te->ime; /* an IME composition sits at the caret and the caret moves into it (widget_draw_text) */ const float comp_w = ime->len ? bk_text_width(ime->text, ime->len, false) : 0.0f; const float text_px = bk_masked_width(te->text, te->caret, te->mask, false); const float caret_px = text_px + bk_ime_caret_offset(ime, false); if (caret_px - te->scroll > inner) { te->scroll = caret_px - inner; } else if (caret_px - te->scroll < 0) { te->scroll = caret_px; } const float tx = rect->xmin + p - te->scroll; const int h = bk_rh(rect); bk_clip_push(rect->xmin + 1, rect->ymin, bk_rw(rect) - 2, h); int a, b; if (te_selection(te, &a, &b)) { const float sx = tx + bk_masked_width(te->text, a, te->mask, false); const float sw = bk_masked_width(te->text, b, te->mask, false) - bk_masked_width(te->text, a, te->mask, false); const float m = 0.15f * h; bk_fill(sx, rect->ymin + m, sw, h - 2 * m, bk_theme.selection); } if (ime->len) { /* text before the caret, the composite, the text after it */ const float cx = tx + text_px; bk_text(tx, bk_text_baseline(rect), te->text, te->caret, color, false); bk_text(cx, bk_text_baseline(rect), ime->text, ime->len, color, false); bk_text(cx + comp_w, bk_text_baseline(rect), te->text + te->caret, te->len - te->caret, color, false); bk_ime_draw_underline(ime, cx, (float)rect->ymax, (float)bk_rw(rect), color, false); } else if (te->mask[0]) { char buf[1024]; bk_text(tx, bk_text_baseline(rect), buf, bk_mask_text(te->text, te->len, te->mask, buf, sizeof(buf)), color, false); } else { bk_text(tx, bk_text_baseline(rect), te->text, te->len, color, false); } const float m = 0.2f * h; /* Blender's caret is solid (interface_widgets.cc, ui_draw_but_TEX); only the HTML look blinks. */ bk_fill(floorf(tx + caret_px), rect->ymin + m, BK_MAX(1.0f, floorf(0.1f * bk_unit() + 0.5f)), h - 2 * m, bk_theme.cursor); bk_clip_pop(); bk_ime_set_candidate(&te->ime, (int)floorf(tx + caret_px) + 5, rect->ymax + 1); } /** \} */ /* -------------------------------------------------------------------- */ /** \name Number expressions ("2*pi", "1/3+2^2") * \{ */ /* Blender's BLI_expr_pylike_eval (core/intern/expr_pylike_eval.cc, through * BUI_blender_c.h): what Blender uses for number fields when Python is off, * with BUI's `**`/`^`, `//`, `%`, `e` and `tau`. */ int BK_eval_number(const char *expr, double *r_value) { return BUI_expr_eval(expr, NULL, NULL, 0, r_value); } /** \} */ /* Public input entry points: mark the input scope (undo grouping) and report * the view changes the event caused (scrollbars follow). */ #define INPUT_ENTRY(call) \ ctx->in_input++; \ const int r = call; \ ctx->in_input--; \ bk_views_check(ctx); \ return r int BK_press(BKContext *ctx, int x, int y, int mods) { INPUT_ENTRY(in_BK_press(ctx, x, y, mods)); } int BK_release(BKContext *ctx, int x, int y, int mods) { INPUT_ENTRY(in_BK_release(ctx, x, y, mods)); } int BK_motion(BKContext *ctx, int x, int y, int mods) { INPUT_ENTRY(in_BK_motion(ctx, x, y, mods)); } int BK_wheel(BKContext *ctx, int x, int y, int delta, int mods) { INPUT_ENTRY(in_BK_wheel(ctx, x, y, delta, 0.0f, mods)); } static int wheel_px(BKContext *ctx, int x, int y, int delta, float px, int mods) { INPUT_ENTRY(in_BK_wheel(ctx, x, y, delta, px, mods)); } int BK_key(BKContext *ctx, const char *text, const char *keysym, int mods) { INPUT_ENTRY(in_BK_key(ctx, text, keysym, mods)); } int BK_scroll(BKContext *ctx, int x, int y, float dx, float dy, int mods) { BKNode *t = BK_IS_CUSTOM(ctx->grab) ? ctx->grab : (ctx->modal ? NULL : hit_all(ctx, x, y)); if (BK_IS_CUSTOM(t) && NODE_ENABLED(t)) { if (dx == 0.0f && dy == 0.0f) { return 0; } hide_tooltip(ctx); BKEvent e = make_event(ctx, t, x, y, mods); e.wheel_x = dx; e.wheel_y = dy; e.delta = dy > 0.0f ? 1 : (dy < 0.0f ? -1 : 0); ctx->in_input++; t->cls->wheel(t, &e); ctx->in_input--; return 1; } int r = 0; if (dy != 0.0f) { r |= BK_wheel(ctx, x, y, dy > 0.0f ? 1 : -1, mods); } if (dx != 0.0f) { /* X11's buttons 6 / 7: Shift + wheel, left = up */ r |= BK_wheel(ctx, x, y, dx > 0.0f ? -1 : 1, mods | BK_SHIFT); } return r; } int BK_scroll_px(BKContext *ctx, int x, int y, float dx, float dy, int mods) { const float notch = 2.0f * (float)bk_unit(); BKNode *t = BK_IS_CUSTOM(ctx->grab) ? ctx->grab : (ctx->modal ? NULL : hit_all(ctx, x, y)); if (BK_IS_CUSTOM(t) && NODE_ENABLED(t)) { return BK_scroll(ctx, x, y, dx / notch, dy / notch, mods); /* custom nodes take notches */ } int r = 0; if (dy != 0.0f) { r |= wheel_px(ctx, x, y, dy > 0.0f ? 1 : -1, dy, mods); } if (dx != 0.0f) { /* Shift + wheel, left = up, as BK_scroll */ r |= wheel_px(ctx, x, y, dx > 0.0f ? -1 : 1, -dx, mods | BK_SHIFT); } return r; } int BK_context_menu(BKContext *ctx, int x, int y, int mods) { INPUT_ENTRY(in_BK_context_menu(ctx, x, y, mods)); } int BK_key_release(BKContext *ctx, const char *keysym, int mods) { BKEvent e = make_event(ctx, NULL, ctx->pointer_x, ctx->pointer_y, mods); e.text = ""; e.keysym = keysym ? keysym : ""; if (bk_keysym_is(e.keysym, ctx->key_held)) { ctx->key_held[0] = '\0'; } BKNode *top = ctx->npopups ? ctx->popups[ctx->npopups - 1] : NULL; if (top && top->cls->key_up && top->cls->key_up(top, &e)) { return 1; } for (BKNode *n = ctx->focus ? ctx->focus : ctx->hover; n; n = n->parent) { if (BK_IS_CUSTOM(n) && NODE_ENABLED(n)) { BKCustomEvent ce; memset(&ce, 0, sizeof(ce)); ce.type = BK_CUSTOM_KEYUP; ce.mods = mods; ce.keysym = e.keysym; return bk_custom_event(n, &ce, ctx->pointer_x, ctx->pointer_y); } if (n->flags & NF_EVENTS) { char buf[96]; snprintf(buf, sizeof(buf), "\t%s", e.keysym); bk_emit(n, BK_EV_KEYRELEASE, buf, mods, 0); return 1; } } return 0; } int BK_button(BKContext *ctx, int x, int y, int button, int release, int mods) { if (button == 2 || button == 3) { /* editors: middle drags, right drags */ const int bit = button == 2 ? BK_BUTTON2 : BK_BUTTON3; if (custom_extra_button(ctx, x, y, button, release, mods | bit)) { return 1; } if (!release && button == 2 && !ctx->grab && buttons_target(ctx, x, y)) { ctx->in_input++; ctx->next_button = button; in_BK_press(ctx, x, y, mods | bit); ctx->press_button = button; ctx->in_input--; bk_views_check(ctx); return 1; } if (release && ctx->grab && ctx->press_button == button) { ctx->in_input++; ctx->next_button = button; in_BK_release(ctx, x, y, mods | bit); ctx->press_button = 0; ctx->in_input--; bk_views_check(ctx); return 1; } } BKNode *under = hit_all(ctx, x, y); if (!under || !(under->flags & NF_EVENTS)) { return 0; } BKEvent e = make_event(ctx, under, x, y, mods); raw_event(under, release ? BK_EV_RELEASE : BK_EV_PRESS, mods, &e, button); return 1; } /* -------------------------------------------------------------------- */ /** \name Raw events, undo, animation, Tab order * \{ */ /* Raw events for host bindings (Tk's bind). Pointer events carry * "state button" in `ref` so hosts can match etc. */ static void raw_event(BKNode *n, int kind, int mods, const BKEvent *e, int button) { if (!(n->flags & NF_EVENTS)) { return; } char buf[128]; if (kind == BK_EV_KEY && e) { snprintf(buf, sizeof(buf), "%s\t%s", e->text ? e->text : "", e->keysym ? e->keysym : ""); bk_emit(n, kind, buf, mods, 0); return; } snprintf(buf, sizeof(buf), "%d %d", mods, button); if (kind == BK_EV_WHEEL && e) { bk_emit(n, kind, buf, e->delta, e->wheel_y); /* b: the exact pixels of BK_scroll_px, else 0 */ return; } bk_emit(n, kind, buf, e ? e->x - n->x : 0, e ? e->y - n->y : 0); } void bk_event(BKNode *n, int kind, int mods, const BKEvent *e) { raw_event(n, kind, mods, e, 1); } static const char *node_text(BKNode *n) { return n->cls == &bk_cls_textarea ? bk_textarea_text(n) : (n->text ? n->text : ""); } static void undo_entry_free(BKUndo *u) { free(u->t[0]); free(u->t[1]); memset(u, 0, sizeof(*u)); } void bk_undo_record(BKNode *n, int kind) { BKContext *ctx = bk_ctx(n); if (!ctx || !ctx->in_input || ctx->in_undo) { return; } for (const BKNode *p = n; p; p = p->parent) { if (p->cls->flags & CLS_POPUP) { return; /* popup internals (picker sliders): the owner records */ } } if (ctx->undo_pos > 0) { const BKUndo *top = &ctx->undo[ctx->undo_pos - 1]; const int span = kind == 1 ? 24 : 0; /* a typing burst is one step */ if (top->node == n && ctx->interaction - top->interaction <= span) { return; /* same interaction: keep the first "before" */ } } for (int i = ctx->undo_pos; i < ctx->nundo; i++) { undo_entry_free(&ctx->undo[i]); /* drop the redo tail */ } ctx->nundo = ctx->undo_pos; if (ctx->nundo == BK_MAX_UNDO) { undo_entry_free(&ctx->undo[0]); memmove(ctx->undo, ctx->undo + 1, sizeof(BKUndo) * (BK_MAX_UNDO - 1)); memset(&ctx->undo[BK_MAX_UNDO - 1], 0, sizeof(BKUndo)); ctx->nundo--; } BKUndo *u = &ctx->undo[ctx->nundo++]; memset(u, 0, sizeof(*u)); u->node = n; u->kind = kind; u->interaction = ctx->interaction; if (kind == 0) { u->v[0] = n->value; } else if (kind == 1) { u->t[0] = bk_strdup(node_text(n)); } else { memcpy(u->c[0], n->color, sizeof(float[4])); } ctx->undo_pos = ctx->nundo; } static void undo_capture(BKUndo *u, int slot) { BKNode *n = u->node; if (u->kind == 0) { u->v[slot] = n->value; } else if (u->kind == 1) { free(u->t[slot]); u->t[slot] = bk_strdup(node_text(n)); } else { memcpy(u->c[slot], n->color, sizeof(float[4])); } } static void undo_apply(BKContext *ctx, BKUndo *u, int slot) { BKNode *n = u->node; ctx->in_undo = 1; if (u->kind == 0) { bk_set_value(n, u->v[slot]); } else if (u->kind == 1) { if (n->cls == &bk_cls_textarea) { bk_textarea_set_text(n, u->t[slot]); bk_emit(n, BK_EV_CHANGE, NULL, 0, 0); } else { BK_set_str(n, "set_value", u->t[slot] ? u->t[slot] : ""); } } else { BK_set_color(n, "set_value", u->c[slot]); } ctx->in_undo = 0; } int BK_undo(BKContext *ctx) { if (ctx->undo_pos == 0) { return 0; } const int group = ctx->undo[ctx->undo_pos - 1].interaction; while (ctx->undo_pos > 0 && ctx->undo[ctx->undo_pos - 1].interaction == group) { BKUndo *u = &ctx->undo[--ctx->undo_pos]; undo_capture(u, 1); undo_apply(ctx, u, 0); } return 1; } int BK_redo(BKContext *ctx) { if (ctx->undo_pos >= ctx->nundo) { return 0; } const int group = ctx->undo[ctx->undo_pos].interaction; while (ctx->undo_pos < ctx->nundo && ctx->undo[ctx->undo_pos].interaction == group) { undo_apply(ctx, &ctx->undo[ctx->undo_pos++], 1); } return 1; } int BK_undo_depth(BKContext *ctx, int *r_redo) { if (r_redo) { *r_redo = ctx->nundo - ctx->undo_pos; } return ctx->undo_pos; } static void undo_forget(BKContext *ctx, BKNode *subtree) { int w = 0; const int pos = ctx->undo_pos; int new_pos = pos; for (int i = 0; i < ctx->nundo; i++) { if (is_within(ctx->undo[i].node, subtree)) { undo_entry_free(&ctx->undo[i]); if (i < pos) { new_pos--; } continue; } if (w != i) { ctx->undo[w] = ctx->undo[i]; memset(&ctx->undo[i], 0, sizeof(BKUndo)); } w++; } ctx->nundo = w; ctx->undo_pos = BK_MIN(new_pos, w); } static int g_animations = 1; /* Blender's panel animation (interface_panel.cc): ANIMATION_TIME 0.30 s, eased * by do_animate's `fac = min_ff(sqrtf(fac), 1.0f)` (fast start, slow end). */ #define ANIMATION_TIME 0.30 void BK_set_animations(int enabled) { g_animations = enabled != 0; BK_anim_set_reduced_motion(!g_animations); } bool bk_animations_enabled(void) { return g_animations; } int BK_animating(BKContext *ctx) { /* motions need frames from the kit only when it runs their clock (else the host draws them) */ return ctx->nanim > 0 || bk_custom_animating(ctx) || (!BK_anim_host_clock() && BK_anim_active()); } static float anim_target(const BKNode *n) { if (n->cls->anim_target) { return n->cls->anim_target(n); } return (n->flags & NF_COLLAPSED) ? 0.0f : 1.0f; } void bk_anim_start(BKNode *n) { BKContext *ctx = bk_ctx(n); if (!ctx || !g_animations) { n->anim = anim_target(n); return; } const double now = bk_time(); for (int i = 0; i < ctx->nanim; i++) { if (ctx->anim[i] == n) { /* already running: reverse from where it is (Blender restarts its * animation from the panels' current offsets) */ ctx->anim_start[i] = now; ctx->anim_from[i] = n->anim; return; } } if (ctx->nanim < BK_MAX_ANIM) { if (!ctx->nanim) { ctx->anim_t = now; } ctx->anim_start[ctx->nanim] = now; ctx->anim_from[ctx->nanim] = n->anim; ctx->anim[ctx->nanim++] = n; bk_ctx_request(ctx); } } static void anim_step(BKContext *ctx) { if (!ctx->nanim) { return; } const double now = bk_time(); ctx->anim_t = now; for (int i = ctx->nanim - 1; i >= 0; i--) { BKNode *n = ctx->anim[i]; const float target = anim_target(n); const double time = n->cls->anim_time; /* do_animate: fac = (now - starttime) / ANIMATION_TIME; fac = min(sqrt(fac), 1) */ float fac = (float)((now - ctx->anim_start[i]) / (time > 0.0 ? time : ANIMATION_TIME)); fac = BK_MIN(time > 0.0 ? BK_MAX(fac, 0.0f) : sqrtf(BK_MAX(fac, 0.0f)), 1.0f); n->anim = fac >= 1.0f ? target : ctx->anim_from[i] + (target - ctx->anim_from[i]) * fac; if (n->anim == target) { const int last = --ctx->nanim; ctx->anim[i] = ctx->anim[last]; ctx->anim_start[i] = ctx->anim_start[last]; ctx->anim_from[i] = ctx->anim_from[last]; } } g_gen++; ctx->layout_dirty = true; } /* Tab / Shift+Tab: the next editable field in tree order (Blender's * ui_textedit_next_but), wrapping around. */ static bool is_editable(const BKNode *n) { return n->cls == &bk_cls_number || n->cls == &bk_cls_slider || n->cls == &bk_cls_text || n->cls == &bk_cls_search; } static void collect_editable(BKNode *n, BKNode **out, int *count, int max) { if (!NODE_VISIBLE(n) || *count >= max) { return; } if (n->cls == &bk_cls_panel && (n->flags & NF_COLLAPSED)) { return; } if (is_editable(n) && NODE_ENABLED(n)) { out[(*count)++] = n; } for (int i = 0; i < n->nkids; i++) { collect_editable(n->kids[i], out, count, max); } } BKNode *bk_next_editable(BKNode *from, int dir) { BKNode *top = from; while (top->parent) { top = top->parent; } BKNode *list[512]; int count = 0, at = -1; collect_editable(top, list, &count, 512); for (int i = 0; i < count; i++) { if (list[i] == from) { at = i; } } if (at < 0 || count < 2) { return NULL; } return list[(at + dir + count) % count]; } void bk_window_focus(BKContext *ctx, BKWindow *win, const BKWindowCallbacks *cb, int active) { if (!active) { /* pie_handler WINDEACTIVATE: the pie key may be released outside, so cancel the pie */ ctx->key_held[0] = '\0'; if (ctx->npopups && ctx->popups[ctx->npopups - 1]->cls == &bk_cls_pie) { BK_close_popups(ctx); } } if (cb->on_focus) { cb->on_focus(cb->data, win, active); } } BKNode *BK_hit_at(BKContext *ctx, int x, int y) { return hit_all(ctx, x, y); } /** \} */ bool bk_anim_running(const BKNode *n) { const BKContext *ctx = bk_ctx(n); if (!ctx) { return false; } for (int i = 0; i < ctx->nanim; i++) { if (ctx->anim[i] == n) { return true; } } return false; } void bk_edit_next(BKNode *from, int dir) { BKNode *next = bk_next_editable(from, dir); if (next && next->cls->activate) { next->cls->activate(next); } }