@typecad/ui 0.1.0-alpha.1

package/src/ui-engine/runtime-header/paint-rects-repair.ts

@@ -0,0 +1,553 @@
+// Slice of the C++ runtime header (original source lines 1895-2441).
+// Paint rects, overlapping layers dirty, buffer decisions, seed/repair, scroll-clip tests, clipped primitives, clear/repair, set_visible.
+// See docs/superpowers/specs/2026-07-12-split-runtime-header-design.md.
+export function emitPaintRectsRepair(): string {
+  return `
+static inline void ui_node_paint_rect(uint16_t nodeIdx, int16_t baseX, int16_t baseY, int16_t drawX, int16_t drawY, uint16_t textW, uint16_t textH, UIRect* out) {
+  int16_t shadowL, shadowT, shadowR, shadowB;
+  ui_shadow_extents(nodeIdx, &shadowL, &shadowT, &shadowR, &shadowB);
+
+  int16_t faceW = __ui_nodes[nodeIdx].box.w;
+  int16_t faceH = __ui_nodes[nodeIdx].box.h;
+  if (__ui_nodes[nodeIdx].kind == NODE_TEXT || __ui_nodes[nodeIdx].kind == NODE_CHECK || __ui_nodes[nodeIdx].kind == NODE_RADIO) {
+    if (__ui_nodes[nodeIdx].lastTextWidth > faceW) faceW = __ui_nodes[nodeIdx].lastTextWidth;
+    if (__ui_nodes[nodeIdx].lastTextHeight > faceH) faceH = __ui_nodes[nodeIdx].lastTextHeight;
+    if ((int16_t)textW > faceW) faceW = (int16_t)textW;
+    if ((int16_t)textH > faceH) faceH = (int16_t)textH;
+  }
+  int16_t unrotatedFaceW = faceW;
+  int16_t unrotatedFaceH = faceH;
+  faceW = ui_rotated_face_w(nodeIdx, unrotatedFaceW, unrotatedFaceH);
+  faceH = ui_rotated_face_h(nodeIdx, unrotatedFaceW, unrotatedFaceH);
+
+  int16_t shadowX0 = baseX - shadowL;
+  int16_t shadowY0 = baseY - shadowT;
+  int16_t shadowX1 = baseX + faceW + shadowR;
+  int16_t shadowY1 = baseY + faceH + shadowB;
+  int16_t faceX0 = drawX;
+  int16_t faceY0 = drawY;
+  int16_t faceX1 = drawX + faceW;
+  int16_t faceY1 = drawY + faceH;
+  int16_t x0 = shadowX0 < faceX0 ? shadowX0 : faceX0;
+  int16_t y0 = shadowY0 < faceY0 ? shadowY0 : faceY0;
+  int16_t x1 = shadowX1 > faceX1 ? shadowX1 : faceX1;
+  int16_t y1 = shadowY1 > faceY1 ? shadowY1 : faceY1;
+  if (__ui_nodes[nodeIdx].outlineStyle != 0 && __ui_nodes[nodeIdx].outlineWidth > 0) {
+    int16_t o = __ui_nodes[nodeIdx].outlineWidth;
+    ui_expand_rect(&x0, &y0, &x1, &y1, drawX - o, drawY - o, drawX + faceW + o, drawY + faceH + o);
+  }
+  out->x = x0;
+  out->y = y0;
+  out->w = x1 - x0;
+  out->h = y1 - y0;
+}
+
+static inline void ui_node_current_paint_rect(uint16_t nodeIdx, UIRect* out) {
+  uint16_t tw = 0;
+  uint16_t th = 0;
+  uint16_t textMaxW = ui_node_text_max_width(nodeIdx);
+  ui_node_text_layout_metrics(nodeIdx, textMaxW, &tw, &th);
+  if (__ui_nodes[nodeIdx].kind == NODE_CHECK || __ui_nodes[nodeIdx].kind == NODE_RADIO) {
+    tw += 22;
+    if (th < 16) th = 16;
+  }
+  ui_node_paint_rect(nodeIdx,
+    ui_base_draw_x_for_node(nodeIdx),
+    ui_base_draw_y_for_node(nodeIdx),
+    ui_draw_x_for_node(nodeIdx),
+    ui_draw_y_for_node(nodeIdx),
+    tw,
+    th,
+    out);
+}
+
+static inline uint8_t ui_subtree_current_paint_rect(uint16_t nodeIdx, UIRect* out) {
+  if (nodeIdx >= __ui_node_count) return 0;
+  int16_t end = __ui_nodes[nodeIdx].subtreeEnd;
+  if (end > __ui_node_count) end = __ui_node_count;
+  uint8_t hasRect = 0;
+  int16_t x0 = 0;
+  int16_t y0 = 0;
+  int16_t x1 = 0;
+  int16_t y1 = 0;
+  for (uint16_t c = nodeIdx; c < end; c++) {
+    if (__ui_nodes[c].screenId != __ui_active_screen) continue;
+    if (!ui_is_effectively_visible(c)) continue;
+    UIRect r;
+    ui_node_current_paint_rect(c, &r);
+    if (r.w <= 0 || r.h <= 0) continue;
+    if (!hasRect) {
+      x0 = r.x;
+      y0 = r.y;
+      x1 = r.x + r.w;
+      y1 = r.y + r.h;
+      hasRect = 1;
+    } else {
+      ui_expand_rect(&x0, &y0, &x1, &y1, r.x, r.y, r.x + r.w, r.y + r.h);
+    }
+  }
+  if (!hasRect) return 0;
+  out->x = x0;
+  out->y = y0;
+  out->w = x1 - x0;
+  out->h = y1 - y0;
+  return 1;
+}
+
+static inline void ui_mark_overlapping_higher_layers_dirty(uint16_t nodeIdx) {
+  if (nodeIdx >= __ui_node_count) return;
+  if (!ui_is_effectively_visible(nodeIdx)) return;
+  if (__ui_nodes[nodeIdx].screenId != __ui_active_screen) return;
+  UIRect r;
+  ui_node_current_paint_rect(nodeIdx, &r);
+  ui_mark_overlapping_higher_layers_dirty_for_rect(nodeIdx, &r);
+}
+
+static inline void ui_mark_overlapping_higher_layers_dirty_for_rect(uint16_t nodeIdx, const UIRect* r) {
+  if (nodeIdx >= __ui_node_count || !r) return;
+  if (!ui_is_effectively_visible(nodeIdx)) return;
+  if (__ui_nodes[nodeIdx].screenId != __ui_active_screen) return;
+  if (r->w <= 0 || r->h <= 0) return;
+  for (uint16_t c = 0; c < __ui_node_count; c++) {
+    if (c == nodeIdx) continue;
+    if (__ui_nodes[c].dirty) continue;
+    if (!ui_is_effectively_visible(c)) continue;
+    if (__ui_nodes[c].screenId != __ui_active_screen) continue;
+    if (!ui_node_draws_before(nodeIdx, c)) continue;
+    UIRect cr;
+    ui_node_current_paint_rect(c, &cr);
+    if (cr.w <= 0 || cr.h <= 0) continue;
+    if (ui_rects_intersect(r->x, r->y, r->w, r->h, cr.x, cr.y, cr.w, cr.h)) {
+      __ui_nodes[c].dirty = 1;
+    }
+  }
+}
+
+static inline void ui_clear_press_offset_area(uint16_t nodeIdx, int16_t baseX, int16_t baseY, int16_t drawX, int16_t drawY, uint16_t textW, uint16_t textH) {
+  if (__ui_nodes[nodeIdx].pressedOffsetX == 0 && __ui_nodes[nodeIdx].pressedOffsetY == 0) return;
+  UIRect r;
+  ui_node_paint_rect(nodeIdx, baseX, baseY, drawX, drawY, textW, textH, &r);
+  int16_t x0 = r.x;
+  int16_t y0 = r.y;
+  int16_t x1 = r.x + r.w;
+  int16_t y1 = r.y + r.h;
+  if (ui_display_is_default_target() && ui_repair_current_node_paint_with_parent(nodeIdx, &r)) return;
+  ui_display_fill_rect(x0, y0, x1 - x0, y1 - y0, ui_parent_clear_color(nodeIdx));
+}
+
+// Generated-font / AA text and images draw per-pixel when sent straight to SPI.
+// Prefer the RAM paint canvas for these kinds (within the pixel budget).
+static inline uint8_t ui_pixel_heavy_node(uint16_t nodeIdx) {
+  if (nodeIdx >= __ui_node_count) return 0;
+  if (__ui_nodes[nodeIdx].kind == NODE_IMG) return 1;
+  if (__ui_nodes[nodeIdx].kind == NODE_TEXT &&
+      (__ui_nodes[nodeIdx].fontFace || __ui_nodes[nodeIdx].fontAntialias)) return 1;
+  return 0;
+}
+
+static inline uint8_t ui_should_buffer_paint(uint16_t nodeIdx, int16_t w, int16_t h) {
+  if (w <= 0 || h <= 0) return 0;
+  if (__ui_nodes[nodeIdx].kind == NODE_LIST) return 0;
+  // <canvas> elements batch via __ui_node_canvas when drawing to the display.
+  if (__ui_nodes[nodeIdx].kind == NODE_CANVAS) return 0;
+  if ((uint32_t)w * (uint32_t)h > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
+  if (ui_pixel_heavy_node(nodeIdx)) return 1;
+  if (__ui_nodes[nodeIdx].kind == NODE_FILL &&
+      __ui_nodes[nodeIdx].hasBg &&
+      __ui_nodes[nodeIdx].gradientEnabled == 0 &&
+      __ui_nodes[nodeIdx].borderRadius == 0 &&
+      __ui_nodes[nodeIdx].borderStyle == 0 &&
+      __ui_nodes[nodeIdx].outlineStyle == 0 &&
+      __ui_nodes[nodeIdx].shadowCount == 0) return 0;
+  if (__ui_nodes[nodeIdx].kind == NODE_FILL &&
+      !__ui_nodes[nodeIdx].hasBg &&
+      __ui_nodes[nodeIdx].borderStyle == 0 &&
+      __ui_nodes[nodeIdx].outlineStyle == 0 &&
+      __ui_nodes[nodeIdx].shadowCount == 0) return 0;
+  return 1;
+}
+
+static inline void ui_seed_paint_canvas_for_node(uint16_t nodeIdx, CuttlefishCanvas16* canvas, int16_t canvasX, int16_t canvasY) {
+  if (!canvas || !display_canvasBuffer(canvas)) return;
+  uint16_t p = __ui_nodes[nodeIdx].parent;
+  if (p == UI_NO_PARENT || p >= __ui_node_count) {
+    display_canvasFillScreen(canvas, __ui_nodes[nodeIdx].clearColor);
+    return;
+  }
+
+  uint16_t parentDecorated =
+    (__ui_nodes[p].hasBg && (__ui_nodes[p].borderRadius > 0 || __ui_nodes[p].gradientEnabled > 0)) ||
+    __ui_nodes[p].borderStyle != 0 ||
+    __ui_nodes[p].outlineStyle != 0;
+  if (!parentDecorated) {
+    display_canvasFillScreen(canvas, ui_parent_clear_color(nodeIdx));
+    return;
+  }
+
+  display_canvasFillScreen(canvas, ui_parent_clear_color(p));
+  int16_t parentDrawX = ui_draw_x_for_node(p);
+  int16_t parentDrawY = ui_draw_y_for_node(p);
+  int16_t origParentX = __ui_nodes[p].box.x;
+  CuttlefishDisplayTarget* previousGfx = ui_display_get_target();
+  ui_display_set_target(canvas);
+  __ui_nodes[p].box.x = parentDrawX - canvasX;
+  int16_t localY = parentDrawY - canvasY;
+
+  // Parent fill color: blended toward the parent's backdrop when the parent is
+  // translucent (matching the main NODE_FILL draw, which uses fillBg). Without
+  // this, scroll repair seeds the canvas with the parent's RAW bg while the
+  // main draw used the blended color → shearing on translucent nodes during scroll.
+  UI_COLOR_T parentFillBg = __ui_nodes[p].bg;
+  if (__ui_nodes[p].opacity < 100) {
+    parentFillBg = ui_blend(__ui_nodes[p].bg, ui_parent_clear_color(p), __ui_nodes[p].opacity);
+  }
+
+  if (__ui_nodes[p].gradientEnabled > 0) {
+    ui_draw_gradient_fill(p, localY);
+  } else if (__ui_nodes[p].borderRadius > 0 && __ui_nodes[p].hasBg) {
+    ui_display_fill_round_rect(__ui_nodes[p].box.x, localY, __ui_nodes[p].box.w, __ui_nodes[p].box.h,
+      __ui_nodes[p].borderRadius, parentFillBg);
+  } else if (__ui_nodes[p].hasBg) {
+    ui_display_fill_rect(__ui_nodes[p].box.x, localY, __ui_nodes[p].box.w, __ui_nodes[p].box.h, parentFillBg);
+  }
+  if (__ui_nodes[p].borderStyle != 0) {
+    UI_COLOR_T bColor = __ui_nodes[p].borderColor ? __ui_nodes[p].borderColor : __ui_nodes[p].fg;
+    ui_draw_node_border(p, __ui_nodes[p].box.x, localY, bColor);
+  }
+  ui_draw_node_outline(p, __ui_nodes[p].box.x, localY);
+
+  __ui_nodes[p].box.x = origParentX;
+  ui_display_set_target(previousGfx);
+}
+
+static inline uint8_t ui_repair_current_node_paint_with_parent(uint16_t nodeIdx, UIRect* r) {
+  if (!r || r->w <= 0 || r->h <= 0) return 0;
+  if ((uint32_t)r->w * (uint32_t)r->h > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
+  CuttlefishCanvas16* repairCanvas = ui_get_repair_canvas(r->w, r->h);
+  if (!repairCanvas) return 0;
+  ui_seed_paint_canvas_for_node(nodeIdx, repairCanvas, r->x, r->y);
+  ui_display_use_default_target();
+  ui_push_canvas_rect(repairCanvas, r->x, r->y, r->w, r->h);
+  return 1;
+}
+
+static inline uint8_t ui_is_rect_clipped_by_scroll(uint16_t nodeIdx, int16_t drawX, int16_t drawY, int16_t drawW, int16_t drawH) {
+  uint16_t p = __ui_nodes[nodeIdx].parent;
+  while (p != UI_NO_PARENT && p < __ui_node_count) {
+    if (__ui_nodes[p].scrollable) {
+      if (drawX < __ui_nodes[p].box.x ||
+          drawX + drawW > __ui_nodes[p].box.x + __ui_nodes[p].box.w ||
+          drawY < __ui_nodes[p].box.y ||
+          drawY + drawH > __ui_nodes[p].box.y + __ui_nodes[p].box.h) {
+        return 1;
+      }
+    }
+    p = __ui_nodes[p].parent;
+  }
+  return 0;
+}
+
+static inline uint8_t ui_is_clipped_by_scroll(uint16_t nodeIdx, int16_t drawX, int16_t drawY) {
+  return ui_is_rect_clipped_by_scroll(nodeIdx, drawX, drawY, __ui_nodes[nodeIdx].box.w, __ui_nodes[nodeIdx].box.h);
+}
+
+// Point-in-viewport test for hit-testing. A tap point is tappable if it lies
+// within EVERY scrollable ancestor's viewport (logical AND, matching the
+// preview's intersected scroll clip). This differs from ui_is_clipped_by_scroll,
+// which tests the node's whole bounding box — a tall node (e.g. a wrapped
+// rich-text paragraph) can overflow below the fold yet have a tappable link in
+// its visible portion. Use this in the hit-test path; keep the whole-box check
+// for draw culling, where a partially-visible node still needs repainting.
+static inline uint8_t ui_is_point_clipped_by_scroll(uint16_t nodeIdx, int16_t px, int16_t py) {
+  uint16_t p = __ui_nodes[nodeIdx].parent;
+  while (p != UI_NO_PARENT && p < __ui_node_count) {
+    if (__ui_nodes[p].scrollable) {
+      if (px < __ui_nodes[p].box.x ||
+          px >= __ui_nodes[p].box.x + __ui_nodes[p].box.w ||
+          py < __ui_nodes[p].box.y ||
+          py >= __ui_nodes[p].box.y + __ui_nodes[p].box.h) {
+        return 1;
+      }
+    }
+    p = __ui_nodes[p].parent;
+  }
+  return 0;
+}
+
+static inline uint8_t ui_clip_rect_to_rect(UIRect* r, const UIRect* clip) {
+  int16_t x0 = r->x > clip->x ? r->x : clip->x;
+  int16_t y0 = r->y > clip->y ? r->y : clip->y;
+  int16_t x1 = r->x + r->w < clip->x + clip->w ? r->x + r->w : clip->x + clip->w;
+  int16_t y1 = r->y + r->h < clip->y + clip->h ? r->y + r->h : clip->y + clip->h;
+  if (x1 <= x0 || y1 <= y0) return 0;
+  r->x = x0;
+  r->y = y0;
+  r->w = x1 - x0;
+  r->h = y1 - y0;
+  return 1;
+}
+
+static inline void ui_fill_rect_clipped(int16_t x, int16_t y, int16_t w, int16_t h, const UIRect* clip, UI_COLOR_T color) {
+  UIRect r = { x, y, w, h };
+  if (!ui_clip_rect_to_rect(&r, clip)) return;
+  ui_display_fill_rect(r.x, r.y, r.w, r.h, color);
+}
+
+static inline void ui_hline_clipped(int16_t x, int16_t y, int16_t w, const UIRect* clip, UI_COLOR_T color) {
+  if (w <= 0 || y < clip->y || y >= clip->y + clip->h) return;
+  int16_t x0 = x > clip->x ? x : clip->x;
+  int16_t x1 = x + w < clip->x + clip->w ? x + w : clip->x + clip->w;
+  if (x1 <= x0) return;
+  ui_display_draw_fast_hline(x0, y, x1 - x0, color);
+}
+
+static inline void ui_vline_clipped(int16_t x, int16_t y, int16_t h, const UIRect* clip, UI_COLOR_T color) {
+  if (h <= 0 || x < clip->x || x >= clip->x + clip->w) return;
+  int16_t y0 = y > clip->y ? y : clip->y;
+  int16_t y1 = y + h < clip->y + clip->h ? y + h : clip->y + clip->h;
+  if (y1 <= y0) return;
+  ui_display_draw_fast_vline(x, y0, y1 - y0, color);
+}
+
+static inline void ui_draw_rect_outline_clipped(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t style, uint8_t width, const UIRect* clip, UI_COLOR_T color) {
+  if (style == 0 || width == 0 || w <= 0 || h <= 0) return;
+  for (uint8_t b = 0; b < width; b++) {
+    int16_t rx = x + b;
+    int16_t ry = y + b;
+    int16_t rw = w - 2 * b;
+    int16_t rh = h - 2 * b;
+    if (rw <= 0 || rh <= 0) return;
+    if (style == 1) {
+      ui_hline_clipped(rx, ry, rw, clip, color);
+      ui_hline_clipped(rx, ry + rh - 1, rw, clip, color);
+      ui_vline_clipped(rx, ry, rh, clip, color);
+      ui_vline_clipped(rx + rw - 1, ry, rh, clip, color);
+    } else {
+      for (int16_t dx = 0; dx < rw; dx += 8) {
+        int16_t seg = (dx + 4 <= rw) ? 4 : (rw - dx);
+        ui_hline_clipped(rx + dx, ry, seg, clip, color);
+        ui_hline_clipped(rx + dx, ry + rh - 1, seg, clip, color);
+      }
+      for (int16_t dy = 0; dy < rh; dy += 8) {
+        int16_t seg = (dy + 4 <= rh) ? 4 : (rh - dy);
+        ui_vline_clipped(rx, ry + dy, seg, clip, color);
+        ui_vline_clipped(rx + rw - 1, ry + dy, seg, clip, color);
+      }
+    }
+  }
+}
+
+static inline void ui_draw_node_decoration_clipped(uint16_t nodeIdx, int16_t drawY, const UIRect* clip) {
+  if (nodeIdx >= __ui_node_count) return;
+  if (__ui_nodes[nodeIdx].borderStyle != 0) {
+    UI_COLOR_T bColor = __ui_nodes[nodeIdx].borderColor ? __ui_nodes[nodeIdx].borderColor : __ui_nodes[nodeIdx].fg;
+    int16_t x = __ui_nodes[nodeIdx].box.x;
+    int16_t y = drawY;
+    int16_t w = __ui_nodes[nodeIdx].box.w;
+    int16_t h = __ui_nodes[nodeIdx].box.h;
+    if (__ui_nodes[nodeIdx].borderRadius > 0) {
+      if (x >= clip->x && y >= clip->y && x + w <= clip->x + clip->w && y + h <= clip->y + clip->h) {
+        ui_draw_node_border(nodeIdx, x, drawY, bColor);
+      }
+    } else {
+      ui_draw_rect_outline_clipped(x, y, w, h,
+        __ui_nodes[nodeIdx].borderStyle, __ui_nodes[nodeIdx].borderWidth, clip, bColor);
+    }
+  }
+  if (__ui_nodes[nodeIdx].outlineStyle != 0 && __ui_nodes[nodeIdx].outlineWidth > 0) {
+    uint8_t w = __ui_nodes[nodeIdx].outlineWidth;
+    int16_t x = __ui_nodes[nodeIdx].box.x - w;
+    int16_t y = drawY - w;
+    int16_t ow = __ui_nodes[nodeIdx].box.w + 2 * w;
+    int16_t oh = __ui_nodes[nodeIdx].box.h + 2 * w;
+    if (__ui_nodes[nodeIdx].borderRadius > 0) {
+      if (x >= clip->x && y >= clip->y && x + ow <= clip->x + clip->w && y + oh <= clip->y + clip->h) {
+        ui_draw_node_outline(nodeIdx, __ui_nodes[nodeIdx].box.x, drawY);
+      }
+    } else {
+      ui_draw_rect_outline_clipped(x, y, ow, oh,
+        __ui_nodes[nodeIdx].outlineStyle, w, clip, __ui_nodes[nodeIdx].outlineColor);
+    }
+  }
+}
+
+static inline void ui_clear_node_paint_rect(uint16_t nodeIdx, const UIRect* paintRect) {
+  if (nodeIdx >= __ui_node_count || !paintRect || paintRect->w <= 0 || paintRect->h <= 0) return;
+  int16_t scrollParent = ui_scroll_ancestor_for_node(nodeIdx);
+  UIRect r = *paintRect;
+  ui_display_use_default_target();
+  if (scrollParent >= 0) {
+    UIRect clip = {
+      __ui_nodes[scrollParent].box.x,
+      __ui_nodes[scrollParent].box.y,
+      __ui_nodes[scrollParent].box.w,
+      __ui_nodes[scrollParent].box.h
+    };
+    UIRect clipped = r;
+    if (!ui_clip_rect_to_rect(&clipped, &clip)) return;
+    if (ui_repair_current_node_paint_with_parent(nodeIdx, &clipped)) return;
+    ui_fill_rect_clipped(clipped.x, clipped.y, clipped.w, clipped.h, &clip, ui_parent_clear_color(nodeIdx));
+    uint16_t p = __ui_nodes[nodeIdx].parent;
+    if (p != UI_NO_PARENT && p < __ui_node_count) {
+      ui_draw_node_decoration_clipped(p, ui_draw_y_for_node(p), &clip);
+    }
+    return;
+  }
+  if (ui_is_rect_clipped_by_scroll(nodeIdx, r.x, r.y, r.w, r.h)) return;
+  ui_display_fill_rect(r.x, r.y, r.w, r.h, ui_parent_clear_color(nodeIdx));
+  uint16_t p = __ui_nodes[nodeIdx].parent;
+  if (p != UI_NO_PARENT && p < __ui_node_count) {
+    int16_t parentDrawY = ui_draw_y_for_node(p);
+    if (__ui_nodes[p].borderStyle != 0) {
+      UI_COLOR_T bColor = __ui_nodes[p].borderColor ? __ui_nodes[p].borderColor : __ui_nodes[p].fg;
+      ui_draw_node_border(p, ui_draw_x_for_node(p), parentDrawY, bColor);
+    }
+    ui_draw_node_outline(p, ui_draw_x_for_node(p), parentDrawY);
+  }
+}
+
+static inline void ui_clear_current_node_paint(uint16_t nodeIdx) {
+  if (nodeIdx >= __ui_node_count) return;
+  uint16_t tw = 0;
+  uint16_t th = 0;
+  uint16_t textMaxW = ui_node_text_max_width(nodeIdx);
+  ui_node_text_layout_metrics(nodeIdx, textMaxW, &tw, &th);
+  if (__ui_nodes[nodeIdx].kind == NODE_CHECK || __ui_nodes[nodeIdx].kind == NODE_RADIO) tw += 22;
+  int16_t baseDrawX = ui_base_draw_x_for_node(nodeIdx);
+  int16_t baseDrawY = ui_base_draw_y_for_node(nodeIdx);
+  int16_t drawX = ui_draw_x_for_node(nodeIdx);
+  int16_t drawY = ui_draw_y_for_node(nodeIdx);
+  UIRect r;
+  ui_node_paint_rect(nodeIdx, baseDrawX, baseDrawY, drawX, drawY, tw, th, &r);
+  ui_clear_node_paint_rect(nodeIdx, &r);
+}
+
+static inline uint8_t ui_try_repair_geometry_fill(uint16_t nodeIdx, const UIRect* oldRect) {
+  if (nodeIdx >= __ui_node_count || !oldRect || oldRect->w <= 0 || oldRect->h <= 0) return 0;
+  if (__ui_nodes[nodeIdx].kind != NODE_FILL) return 0;
+  if (!__ui_nodes[nodeIdx].hasBg) return 0;
+  if (__ui_nodes[nodeIdx].gradientEnabled != 0) return 0;
+  if (__ui_nodes[nodeIdx].borderRadius != 0 ||
+      __ui_nodes[nodeIdx].borderStyle != 0 ||
+      __ui_nodes[nodeIdx].outlineStyle != 0 ||
+      __ui_nodes[nodeIdx].shadowCount != 0) return 0;
+
+  UIRect newRect;
+  ui_node_current_paint_rect(nodeIdx, &newRect);
+  if (newRect.w <= 0 || newRect.h <= 0) return 0;
+  int16_t x0 = oldRect->x < newRect.x ? oldRect->x : newRect.x;
+  int16_t y0 = oldRect->y < newRect.y ? oldRect->y : newRect.y;
+  int16_t x1 = oldRect->x + oldRect->w > newRect.x + newRect.w ? oldRect->x + oldRect->w : newRect.x + newRect.w;
+  int16_t y1 = oldRect->y + oldRect->h > newRect.y + newRect.h ? oldRect->y + oldRect->h : newRect.y + newRect.h;
+  UIRect repair = { x0, y0, (int16_t)(x1 - x0), (int16_t)(y1 - y0) };
+  int16_t scrollParent = ui_scroll_ancestor_for_node(nodeIdx);
+  if (scrollParent >= 0) {
+    UIRect clip = {
+      __ui_nodes[scrollParent].box.x,
+      __ui_nodes[scrollParent].box.y,
+      __ui_nodes[scrollParent].box.w,
+      __ui_nodes[scrollParent].box.h
+    };
+    if (!ui_clip_rect_to_rect(&repair, &clip)) {
+      ui_invalidate_scroll_canvas_for_node(nodeIdx);
+      return 1;
+    }
+  } else if (ui_is_rect_clipped_by_scroll(nodeIdx, repair.x, repair.y, repair.w, repair.h)) {
+    return 0;
+  }
+  if (repair.w <= 0 || repair.h <= 0) return 0;
+  if ((uint32_t)repair.w * (uint32_t)repair.h > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
+  CuttlefishCanvas16* repairCanvas = ui_get_repair_canvas(repair.w, repair.h);
+  if (!repairCanvas) return 0;
+
+  ui_seed_paint_canvas_for_node(nodeIdx, repairCanvas, repair.x, repair.y);
+  CuttlefishDisplayTarget* previousGfx = ui_display_get_target();
+  ui_display_set_target(repairCanvas);
+  UI_COLOR_T fillBg = __ui_nodes[nodeIdx].bg;
+  if (__ui_nodes[nodeIdx].opacity < 100) {
+    fillBg = ui_blend(__ui_nodes[nodeIdx].bg, ui_parent_clear_color(nodeIdx), __ui_nodes[nodeIdx].opacity);
+  }
+  int16_t drawX = ui_draw_x_for_node(nodeIdx) - repair.x;
+  int16_t drawY = ui_draw_y_for_node(nodeIdx) - repair.y;
+  int16_t fillW = ui_rotated_face_w(nodeIdx, __ui_nodes[nodeIdx].box.w, __ui_nodes[nodeIdx].box.h);
+  int16_t fillH = ui_rotated_face_h(nodeIdx, __ui_nodes[nodeIdx].box.w, __ui_nodes[nodeIdx].box.h);
+  ui_display_fill_rect(drawX, drawY, fillW, fillH, fillBg);
+  ui_display_set_target(previousGfx);
+  ui_display_use_default_target();
+  ui_push_canvas_rect(repairCanvas, repair.x, repair.y, repair.w, repair.h);
+  if (scrollParent >= 0) ui_invalidate_scroll_canvas_for_node(nodeIdx);
+  ui_mark_overlapping_higher_layers_dirty_for_rect(nodeIdx, &repair);
+  return 1;
+}
+
+static inline void ui_clear_subtree_current_paint(uint16_t nodeIdx) {
+  if (nodeIdx >= __ui_node_count) return;
+  UIRect r;
+  if (!ui_subtree_current_paint_rect(nodeIdx, &r)) return;
+  ui_display_use_default_target();
+  int16_t scrollParent = ui_scroll_ancestor_for_node(nodeIdx);
+  if (scrollParent >= 0) {
+    UIRect clip = {
+      __ui_nodes[scrollParent].box.x,
+      __ui_nodes[scrollParent].box.y,
+      __ui_nodes[scrollParent].box.w,
+      __ui_nodes[scrollParent].box.h
+    };
+    UIRect clipped = r;
+    if (!ui_clip_rect_to_rect(&clipped, &clip)) return;
+    if (ui_repair_current_node_paint_with_parent(nodeIdx, &clipped)) return;
+    ui_fill_rect_clipped(clipped.x, clipped.y, clipped.w, clipped.h, &clip, ui_parent_clear_color(nodeIdx));
+    uint16_t p = __ui_nodes[nodeIdx].parent;
+    if (p != UI_NO_PARENT && p < __ui_node_count) {
+      ui_draw_node_decoration_clipped(p, ui_draw_y_for_node(p), &clip);
+    }
+    return;
+  }
+  if (ui_repair_current_node_paint_with_parent(nodeIdx, &r)) return;
+  ui_display_fill_rect(r.x, r.y, r.w, r.h, ui_parent_clear_color(nodeIdx));
+  uint16_t p = __ui_nodes[nodeIdx].parent;
+  if (p != UI_NO_PARENT && p < __ui_node_count) {
+    int16_t parentDrawY = ui_draw_y_for_node(p);
+    if (__ui_nodes[p].borderStyle != 0) {
+      UI_COLOR_T bColor = __ui_nodes[p].borderColor ? __ui_nodes[p].borderColor : __ui_nodes[p].fg;
+      ui_draw_node_border(p, ui_draw_x_for_node(p), parentDrawY, bColor);
+    }
+    ui_draw_node_outline(p, ui_draw_x_for_node(p), parentDrawY);
+  }
+}
+
+static inline void ui_set_visible(uint16_t nodeIdx, uint8_t visible) {
+  if (nodeIdx >= __ui_node_count) return;
+  visible = visible ? 1 : 0;
+  if (__ui_nodes[nodeIdx].visible == visible) return;
+
+  if (!visible) {
+    // Clear the whole subtree in one clipped repair. This removes child pixels
+    // even when the container itself is transparent, without separate display
+    // writes for each descendant.
+    UIRect subtreeRect;
+    uint8_t hasSubtreeRect = ui_subtree_current_paint_rect(nodeIdx, &subtreeRect);
+    ui_clear_subtree_current_paint(nodeIdx);
+    int16_t end = __ui_nodes[nodeIdx].subtreeEnd;
+    if (end > __ui_node_count) end = __ui_node_count;
+    for (int16_t c = end - 1; c >= (int16_t)nodeIdx; c--) {
+      if (__ui_nodes[c].screenId != __ui_active_screen) continue;
+      __ui_nodes[c].dirty = 0;
+    }
+    if (hasSubtreeRect) ui_mark_overlapping_higher_layers_dirty_for_rect(nodeIdx, &subtreeRect);
+    __ui_nodes[nodeIdx].visible = 0;
+    return;
+  }
+
+  __ui_nodes[nodeIdx].visible = 1;
+  int16_t end = __ui_nodes[nodeIdx].subtreeEnd;
+  if (end > __ui_node_count) end = __ui_node_count;
+  for (uint16_t c = nodeIdx; c < end; c++) {
+    if (__ui_nodes[c].screenId == __ui_active_screen && ui_is_effectively_visible(c)) {
+      __ui_nodes[c].dirty = 1;
+      ui_mark_overlapping_higher_layers_dirty(c);
+    }
+  }
+}
+`;
+}