371 lines
13 KiB
C
371 lines
13 KiB
C
/*
|
||
* meow_ui_draw.c — 绘制物注册表 / z 序 / 区域重画（§6.2 / SDK_Z_ORDER_DESIGN §2）。
|
||
*
|
||
* 非保留模型下，把「清底 + 按 z 重画重叠区完整 z 栈」下沉到 SDK：
|
||
* - 控件（meow_widget）创建即自动注册（create 末尾调 meow_draw_widget_register），
|
||
* meow_widget_free 自动注销；rect 实时读 w->x/y/w/h；
|
||
* - App 直绘的非控件内容显式 meow_draw_custom_register（声明 bbox + 绘制回调）；
|
||
* - z 自动推导（子>父、同层注册先序）；显式 set_z 粘滞、置顶。
|
||
* 显式 z 存于本注册表（按 w 反查 entry），**不改 struct meow_widget**（零 ABI 破坏）。
|
||
*/
|
||
#include "meow_ui.h"
|
||
#include "meow_ui_internal.h"
|
||
#include "meow_ui_view.h"
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#define MEOW_DRAW_MAX 256
|
||
#define MEOW_ITEM_VIEW 2 /* 内部 kinds（不进公共枚举）：meow_view 绘制物 */
|
||
|
||
typedef struct draw_entry {
|
||
int kind; /* MEOW_ITEM_WIDGET / MEOW_ITEM_CUSTOM / MEOW_ITEM_VIEW */
|
||
meow_widget *w; /* WIDGET：绘制其 meow_widget_draw(w) */
|
||
meow_draw_fn draw_cb; /* CUSTOM：绘制回调 */
|
||
void *ctx; /* CUSTOM: 传给 draw_cb; VIEW: (meow_view*)v */
|
||
int rx, ry, rw, rh; /* CUSTOM bbox（WIDGET 读 w->x/y/w/h，VIEW 读 v->x/y/w/h） */
|
||
int z; /* 生效 z（显式=其值，否则=自动推导） */
|
||
int z_explicit; /* 1=显式（粘滞） */
|
||
int id; /* CUSTOM id（0=无效） */
|
||
int seq; /* 全局注册序（z 同值时稳定先序） */
|
||
struct meow_view *view; /* WIDGET：所属 view（z 深度源）+1 */
|
||
} draw_entry;
|
||
|
||
static draw_entry g_e[MEOW_DRAW_MAX];
|
||
static int g_n = 0;
|
||
static int g_seq = 0; /* 全局注册序（单调递增） */
|
||
static int g_next_id = 1; /* CUSTOM id 起点（0=无效） */
|
||
|
||
static uint32_t g_page_bg = 0;
|
||
static int g_page_bg_set = 0;
|
||
|
||
/* ---- 内部访问器（widget.c 提供；跨 TU 用 meow_ui_internal.h 声明）---- */
|
||
static int w_is_layout(const meow_widget *w) { return meow_widget_is_layout(w); }
|
||
|
||
/* ---- 查找 ---- */
|
||
static draw_entry *e_find_widget(const meow_widget *w)
|
||
{
|
||
for (int i = 0; i < g_n; i++)
|
||
if (g_e[i].kind == MEOW_ITEM_WIDGET && g_e[i].w == w) return &g_e[i];
|
||
return NULL;
|
||
}
|
||
static draw_entry *e_find_view(const meow_view *v)
|
||
{
|
||
for (int i = 0; i < g_n; i++)
|
||
if (g_e[i].kind == MEOW_ITEM_VIEW && g_e[i].ctx == (void *)v) return &g_e[i];
|
||
return NULL;
|
||
}
|
||
static draw_entry *e_find_id(int id)
|
||
{
|
||
for (int i = 0; i < g_n; i++)
|
||
if (g_e[i].kind == MEOW_ITEM_CUSTOM && g_e[i].id == id) return &g_e[i];
|
||
return NULL;
|
||
}
|
||
|
||
/* ---- 深度：view 树深度 ---- */
|
||
static int view_depth(const meow_view *v)
|
||
{
|
||
int d = 0;
|
||
const meow_view *p = v ? v->parent : NULL;
|
||
while (p) {
|
||
d++;
|
||
if (d > MEOW_Z_DEPTH_MAX) break;
|
||
p = p->parent;
|
||
}
|
||
return d;
|
||
}
|
||
|
||
/* ---- 深度：widget 所属嵌套深度（view 树为主；否则 W_LAYOUT children 反推；否则 0）---- */
|
||
static int widget_nest_depth(meow_widget *w, int depth)
|
||
{
|
||
if (depth > MEOW_Z_DEPTH_MAX) return MEOW_Z_DEPTH_MAX;
|
||
draw_entry *e = e_find_widget(w);
|
||
if (e && e->view) return view_depth(e->view) + 1; /* 视图树深度源（更确定） */
|
||
/* 注册表反推：w 是否经 meow_layout_add 挂在某布局下（此时布局自身已注册为 WIDGET）。 */
|
||
for (int i = 0; i < g_n; i++) {
|
||
if (g_e[i].kind != MEOW_ITEM_WIDGET) continue;
|
||
meow_widget *lw = g_e[i].w;
|
||
if (!lw || !w_is_layout(lw)) continue;
|
||
int nc = meow_widget_nchild(lw);
|
||
for (int j = 0; j < nc; j++)
|
||
if (meow_widget_child_at(lw, j) == w)
|
||
return widget_nest_depth(lw, depth + 1) + 1; /* 子层 >= 父层+1 */
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* 计算 auto z（显式不重算——粘滞）：depth*STRIDE + 层内 seq（注册先序，折叠 MEOW_Z_PER_LEVEL_MAX）。 */
|
||
static void e_compute_auto(draw_entry *e)
|
||
{
|
||
if (e->z_explicit) return;
|
||
int depth = 0;
|
||
if (e->kind == MEOW_ITEM_WIDGET && e->w) depth = widget_nest_depth(e->w, 0);
|
||
else if (e->kind == MEOW_ITEM_VIEW && e->ctx) depth = view_depth((const meow_view *)e->ctx);
|
||
/* CUSTOM：z 恒显式（register 传入），不进 auto 分支 */
|
||
int cnt = 0;
|
||
for (int i = 0; i < g_n; i++) {
|
||
draw_entry *o = &g_e[i];
|
||
if (o == e || o->z_explicit) continue;
|
||
if (o->seq >= e->seq) continue;
|
||
if (o->z / MEOW_Z_STRIDE == depth) cnt++;
|
||
}
|
||
if (cnt > MEOW_Z_PER_LEVEL_MAX) cnt = MEOW_Z_PER_LEVEL_MAX;
|
||
e->z = depth * MEOW_Z_STRIDE + cnt;
|
||
}
|
||
|
||
/* ============================================================ */
|
||
/* 控件自动注册 / 注销（create 末尾 / meow_widget_free 调用） */
|
||
/* ============================================================ */
|
||
void meow_draw_widget_register(meow_widget *w)
|
||
{
|
||
if (!w || e_find_widget(w)) return; /* 幂等 */
|
||
if (g_n >= MEOW_DRAW_MAX) return; /* 满：静默（骨架级） */
|
||
draw_entry *e = &g_e[g_n++];
|
||
memset(e, 0, sizeof *e);
|
||
e->kind = MEOW_ITEM_WIDGET;
|
||
e->w = w;
|
||
e->seq = g_seq++;
|
||
e_compute_auto(e);
|
||
}
|
||
|
||
void meow_draw_widget_unregister(meow_widget *w)
|
||
{
|
||
if (!w) return;
|
||
int idx = -1;
|
||
for (int i = 0; i < g_n; i++)
|
||
if (g_e[i].kind == MEOW_ITEM_WIDGET && g_e[i].w == w) { idx = i; break; }
|
||
if (idx < 0) return;
|
||
g_e[idx] = g_e[--g_n]; /* 交换移除（seq 保留，排序稳定） */
|
||
}
|
||
|
||
int meow_draw_widget_registered(const meow_widget *w)
|
||
{
|
||
return w ? e_find_widget(w) != NULL : 0;
|
||
}
|
||
|
||
void meow_draw_widget_set_view(meow_widget *w, struct meow_view *v)
|
||
{
|
||
draw_entry *e = e_find_widget(w);
|
||
if (!e) return;
|
||
e->view = v;
|
||
e_compute_auto(e);
|
||
}
|
||
|
||
/* ============================================================ */
|
||
/* 显式 z（widget） */
|
||
/* ============================================================ */
|
||
void meow_widget_set_z(meow_widget *w, int z)
|
||
{
|
||
if (!w || z < 0) return;
|
||
draw_entry *e = e_find_widget(w);
|
||
if (!e) return;
|
||
e->z_explicit = 1;
|
||
e->z = z;
|
||
}
|
||
int meow_widget_z(const meow_widget *w)
|
||
{
|
||
if (!w) return 0;
|
||
draw_entry *e = e_find_widget((meow_widget *)w);
|
||
if (!e) return 0;
|
||
if (e->z_explicit) return e->z;
|
||
e_compute_auto(e);
|
||
return e->z;
|
||
}
|
||
void meow_widget_clear_z(meow_widget *w)
|
||
{
|
||
if (!w) return;
|
||
draw_entry *e = e_find_widget(w);
|
||
if (!e) return;
|
||
e->z_explicit = 0;
|
||
e_compute_auto(e);
|
||
}
|
||
|
||
/* ============================================================ */
|
||
/* CUSTOM（App 直绘）注册 / 注销 / 改 z */
|
||
/* ============================================================ */
|
||
int meow_draw_custom_register(int z, int x, int y, int w, int h,
|
||
meow_draw_fn cb, void *ctx)
|
||
{
|
||
if (!cb || w <= 0 || h <= 0) return 0;
|
||
if (g_n >= MEOW_DRAW_MAX) return 0;
|
||
draw_entry *e = &g_e[g_n++];
|
||
memset(e, 0, sizeof *e);
|
||
e->kind = MEOW_ITEM_CUSTOM;
|
||
e->draw_cb = cb;
|
||
e->ctx = ctx;
|
||
e->rx = x; e->ry = y; e->rw = w; e->rh = h;
|
||
e->z = z < 0 ? 0 : z;
|
||
e->z_explicit = 1;
|
||
e->id = g_next_id++;
|
||
e->seq = g_seq++;
|
||
return e->id;
|
||
}
|
||
void meow_draw_unregister(int id)
|
||
{
|
||
if (id <= 0) return;
|
||
int idx = -1;
|
||
for (int i = 0; i < g_n; i++)
|
||
if (g_e[i].kind == MEOW_ITEM_CUSTOM && g_e[i].id == id) { idx = i; break; }
|
||
if (idx < 0) return;
|
||
g_e[idx] = g_e[--g_n];
|
||
}
|
||
int meow_draw_set_z(int id, int z)
|
||
{
|
||
if (id <= 0 || z < 0) return -1;
|
||
draw_entry *e = e_find_id(id);
|
||
if (!e) return -1;
|
||
e->z = z;
|
||
e->z_explicit = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* ============================================================ */
|
||
/* view 绘制物注册 / 注销 */
|
||
/* ============================================================ */
|
||
void meow_draw_view_register(struct meow_view *v)
|
||
{
|
||
if (!v || e_find_view(v)) return;
|
||
if (g_n >= MEOW_DRAW_MAX) return;
|
||
draw_entry *e = &g_e[g_n++];
|
||
memset(e, 0, sizeof *e);
|
||
e->kind = MEOW_ITEM_VIEW;
|
||
e->ctx = (void *)v;
|
||
e->seq = g_seq++;
|
||
e_compute_auto(e);
|
||
}
|
||
void meow_draw_view_unregister(struct meow_view *v)
|
||
{
|
||
if (!v) return;
|
||
int idx = -1;
|
||
for (int i = 0; i < g_n; i++)
|
||
if (g_e[i].kind == MEOW_ITEM_VIEW && g_e[i].ctx == (void *)v) { idx = i; break; }
|
||
if (idx < 0) return;
|
||
g_e[idx] = g_e[--g_n];
|
||
}
|
||
int meow_draw_view_entered(const struct meow_view *v)
|
||
{
|
||
/* 子>父：view 或其任意祖先已进入即视为「可绘制」——配合 view_enter/leave 递归
|
||
* （meow_ui_view.c §A.4），父 on_enter 重绘时子视图（尚未单独进入）也要经 on_draw 画出；
|
||
* 且子随父进出（"子视图随父进出"），祖先已进入 ⇒ 子树已进入，可绘制。 */
|
||
const struct meow_view *cur = v;
|
||
while (cur) {
|
||
if (meow_view_get_state(cur) & MEOW_VIEW_STATE_ENTERED) return 1;
|
||
cur = meow_view_parent(cur);
|
||
}
|
||
return 0;
|
||
}
|
||
void meow_draw_view_set_z(struct meow_view *v, int z)
|
||
{
|
||
draw_entry *e = e_find_view(v);
|
||
if (!e) return;
|
||
if (z <= 0) {
|
||
e->z_explicit = 0;
|
||
e_compute_auto(e);
|
||
} else {
|
||
e->z_explicit = 1;
|
||
e->z = z;
|
||
}
|
||
}
|
||
|
||
/* ============================================================ */
|
||
/* page bg / 区域重画 / 整帧 */
|
||
/* ============================================================ */
|
||
void meow_ui_set_page_bg(uint32_t color) { g_page_bg = color; g_page_bg_set = 1; }
|
||
uint32_t meow_ui_page_bg(void) { return g_page_bg_set ? g_page_bg : meow_theme_get()->bg; }
|
||
|
||
static int rect_hit(int ax, int ay, int aw, int ah, int bx, int by, int bw, int bh)
|
||
{
|
||
return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
|
||
}
|
||
|
||
static int entry_rect(draw_entry *e, int out[4])
|
||
{
|
||
if (e->kind == MEOW_ITEM_WIDGET && e->w) {
|
||
meow_widget_rect(e->w, out);
|
||
} else if (e->kind == MEOW_ITEM_VIEW && e->ctx) {
|
||
meow_view *v = (meow_view *)e->ctx;
|
||
out[0] = v->x; out[1] = v->y; out[2] = v->w; out[3] = v->h;
|
||
} else {
|
||
out[0] = e->rx; out[1] = e->ry; out[2] = e->rw; out[3] = e->rh;
|
||
}
|
||
return out[2] > 0 && out[3] > 0;
|
||
}
|
||
|
||
static void draw_one(draw_entry *e)
|
||
{
|
||
switch (e->kind) {
|
||
case MEOW_ITEM_WIDGET:
|
||
meow_widget_draw(e->w);
|
||
break;
|
||
case MEOW_ITEM_CUSTOM:
|
||
e->draw_cb(e->ctx);
|
||
break;
|
||
case MEOW_ITEM_VIEW: {
|
||
meow_view *v = (meow_view *)e->ctx;
|
||
if (v->hooks.on_draw) v->hooks.on_draw(v, meow_theme_get(), v->ctx);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void paint(int full, int x, int y, int w, int h)
|
||
{
|
||
uint32_t bg = meow_ui_page_bg();
|
||
if (full) {
|
||
meow_ui_clear(bg);
|
||
} else {
|
||
if (w <= 0 || h <= 0) return;
|
||
meow_ui_fill_rect(x, y, w, h, bg);
|
||
}
|
||
/* 刷新 auto z + 组装按 (z,seq) 升序的绘制序（owner==active 过滤 WIDGET；view 须已进入）。 */
|
||
draw_entry *order[MEOW_DRAW_MAX];
|
||
int nn = 0;
|
||
int active = meow_ui_activity_active();
|
||
for (int i = 0; i < g_n; i++) {
|
||
draw_entry *e = &g_e[i];
|
||
e_compute_auto(e);
|
||
if (e->kind == MEOW_ITEM_WIDGET && e->w && meow_widget_owner(e->w) != active) continue;
|
||
if (e->kind == MEOW_ITEM_VIEW && !meow_draw_view_entered((meow_view *)e->ctx)) continue;
|
||
order[nn++] = e;
|
||
}
|
||
/* 稳定插入排序：（z 升序，同 z 按 seq 升序＝注册先序）。 */
|
||
for (int i = 1; i < nn; i++) {
|
||
draw_entry *key = order[i];
|
||
int j = i - 1;
|
||
while (j >= 0 && (order[j]->z > key->z ||
|
||
(order[j]->z == key->z && order[j]->seq > key->seq))) {
|
||
order[j + 1] = order[j];
|
||
j--;
|
||
}
|
||
order[j + 1] = key;
|
||
}
|
||
if (full) {
|
||
for (int i = 0; i < nn; i++) draw_one(order[i]);
|
||
meow_ui_flush();
|
||
} else {
|
||
int r[4];
|
||
/* 区域重画（meow_ui_invalidate）：把绘制 clip 收敛到本次失效矩形，只画「真正相交且可见」的
|
||
* 部分——大绘制物（整页 card/布局）仅擦边相交时不再整块重画，而是裁到矩形内，避免 overdraw。
|
||
* 控件内部还会再 push 自身矩形（嵌套求交 = 矩形∩控件，语义不变：越界仍被裁）。 */
|
||
meow_gfx_clip_push(x, y, w, h);
|
||
for (int i = 0; i < nn; i++) {
|
||
if (!entry_rect(order[i], r)) continue;
|
||
if (rect_hit(r[0], r[1], r[2], r[3], x, y, w, h)) draw_one(order[i]);
|
||
}
|
||
meow_gfx_clip_pop();
|
||
meow_ui_flush_region(x, y, w, h);
|
||
}
|
||
}
|
||
|
||
void meow_ui_invalidate(int x, int y, int w, int h)
|
||
{
|
||
if (w <= 0 || h <= 0) return;
|
||
paint(0, x, y, w, h);
|
||
}
|
||
|
||
void meow_ui_paint_full(void)
|
||
{
|
||
paint(1, 0, 0, 0, 0);
|
||
}
|