@typecad/ui 1.0.0-alpha.6 → 1.0.0-alpha.7

package/src/ui-engine/runtime-header/tick/dirty-draw-phase.ts

@@ -27,9 +27,48 @@ export function emitTickDirtyDrawPhase(): string {
     if (__ui_kb_dirty == 1) {
       ui_kb_draw();
     } else if (__ui_kb_dirty == 2) {
-      ui_kb_draw_text_row();
-      if (__ui_kb_repaint_key >= 0 && __ui_kb_keys[__ui_kb_repaint_key].special != 255) {
-        ui_kb_draw_key((uint8_t)__ui_kb_repaint_key);
+      // Buffer the targeted update through the keyboard canvas too — drawing
+      // the text row directly to the display (fill_rect clear + text redraw)
+      // flashes on SPI TFTs because the clear is visible for one frame.
+      // Re-render into the canvas and push in one transaction. The canvas
+      // already holds the last full-keyboard frame, so we only need to redraw
+      // the text row + the single changed key on top of it.
+      // (__ui_kb_canvas is declared static in the keyboard slice, earlier in
+      // this same translation unit — no extern needed.)
+      if (__ui_kb_canvas && display_canvasBuffer(__ui_kb_canvas)) {
+        int16_t kw = __ui_kb_box.w;
+        int16_t saveBoxX = __ui_kb_box.x;
+        int16_t saveBoxY = __ui_kb_box.y;
+        CuttlefishDisplayTarget* __kb_prev = ui_display_get_target();
+        ui_display_set_target(__ui_kb_canvas);
+        __ui_kb_box.x = 0;
+        __ui_kb_box.y = 0;
+        ui_kb_draw_text_row();
+        uint8_t has_key_repaint = (__ui_kb_repaint_key >= 0 && __ui_kb_keys[__ui_kb_repaint_key].special != 255) ? 1 : 0;
+        if (has_key_repaint) {
+          ui_kb_draw_key((uint8_t)__ui_kb_repaint_key);
+        }
+        __ui_kb_box.x = saveBoxX;
+        __ui_kb_box.y = saveBoxY;
+        ui_display_set_target(__kb_prev);
+        // Push only the changed region: text row alone (UI_KB_TEXT_H) when no
+        // key highlight changed, or the full canvas when a key was repainted
+        // (the key could be anywhere in the keyboard grid).
+        display_startWrite();
+        if (has_key_repaint) {
+          display_setAddrWindow(saveBoxX, saveBoxY, kw, __ui_kb_box.h);
+          display_writePixels(display_canvasBuffer(__ui_kb_canvas), (uint32_t)kw * __ui_kb_box.h);
+        } else {
+          display_setAddrWindow(saveBoxX, saveBoxY, kw, UI_KB_TEXT_H);
+          display_writePixels(display_canvasBuffer(__ui_kb_canvas), (uint32_t)kw * UI_KB_TEXT_H);
+        }
+        display_endWrite();
+      } else {
+        // No canvas — fall back to direct draw (slow but correct).
+        ui_kb_draw_text_row();
+        if (__ui_kb_repaint_key >= 0 && __ui_kb_keys[__ui_kb_repaint_key].special != 255) {
+          ui_kb_draw_key((uint8_t)__ui_kb_repaint_key);
+        }
       }
     }
     __ui_kb_dirty = 0;
@@ -272,10 +311,6 @@ export function emitTickDirtyDrawPhase(): string {
 
     UIRect paintRect;
     ui_node_paint_rect(i, baseDrawX, baseDrawY, drawX, drawY, paintTextW, paintTextH, &paintRect);
-    int16_t cullX = paintRect.x;
-    int16_t cullY = paintRect.y;
-    int16_t cullW = paintRect.w;
-    int16_t cullH = paintRect.h;
     if (drawingBufferedScroll) {
       // Canvas-local clip: skip nodes fully outside the viewport (0..vw, 0..vh).
       // Use the node's face rect (box.w/h), NOT the paint rect — the paint rect

package/src/ui-engine/runtime-header/touch-keyboard-fwd.ts

@@ -51,6 +51,7 @@ static UIKeyStyle __ui_kb_styles[UI_KB_MAX];
 static UI_COLOR_T __ui_kb_bg = 0x0000;  // keyboard background (resolved from CSS)
 static uint8_t __ui_kb_bs_held = 0;
 static uint8_t __ui_kb_dirty = 0;     // 0=clean, 1=full redraw, 2=text row + single key
+// (__ui_kb_canvas is declared in forward-decls.ts alongside the other persistent canvases.)
 // Forward-declared here (defined in the keyboard subsystem block below) so the
 // UI_HIDE_OSK caret/blink paths in ui_tick and the input draw can reference it.
 static int16_t  __ui_kb_target;
@@ -268,7 +269,9 @@ static void ui_touch_up() {
   // including holds (released above) and taps on empty space (__ui_touch_node
   // == -1), which is what makes "wake on any touch" work for display-sleep.
   // Placed AFTER the click/release dispatch so onClick always fires first.
-  __ui_tap_seq++;
+  // Note: explicit '+ 1' instead of '++' — GCC 13+ (IDF v6) deprecates '++'
+  // on volatile-qualified types under -Werror=volatile.
+  __ui_tap_seq = __ui_tap_seq + 1;
   __ui_tap_node = __ui_touch_node;
   // Virtualized list item tap: if the touch was inside a list, compute the item
   // index from the touch Y. Use total movement (not drag flag) to distinguish

package/src/ui-engine/runtime-header.ts

@@ -42,7 +42,21 @@ import { emitAntialiasing } from "./runtime-header/antialiasing.js";
 import { emitKeyboard } from "./runtime-header/keyboard.js";
 import { emitGuardClose } from "./runtime-header/guard-close.js";
 
-export function emitRuntimeHeader(): string {
+export interface EmitRuntimeHeaderOptions {
+  /**
+   * True when a native display adapter (AVR, ESP32) is in use. Kept for
+   * backwards compatibility — the CuttlefishGFX slice is now emitted
+   * separately via emitCuttlefishGfx() so it can land BEFORE display adapter
+   * declarations that instantiate CuttlefishGFX by value.
+   */
+  nativeDisplayActive?: boolean;
+}
+
+export function emitRuntimeHeader(opts?: EmitRuntimeHeaderOptions): string {
+  // Note: the CuttlefishGFX slice (emitCuttlefishGfx) is emitted separately
+  // by ui-emitter.ts BEFORE the display adapter declaration. It is NOT
+  // emitted here — passing nativeDisplayActive has no effect.
+  void opts;
   return [
     emitTypesDefines(),
     emitStructs(),

package/src/ui-engine/ui-lowering.ts

@@ -199,7 +199,22 @@ function emitKeyboardLoader(name: string, kb: KeyboardTemplate, rules: CSSRule[]
 
 /** Emit one key's keys[] + styles[] lines, resolving CSS classes to colors. */
 function emitKeyLine(key: UIKeyTemplate, kbClasses: string[] | undefined, rules: CSSRule[], colorFormat: ColorFormat): string {
-  const chEsc = key.ch === "\\" ? "\\\\" : key.ch === "'" ? "\\'" : key.ch;
+  // The C++ UIKey.ch field is a single `char`. Special keys (shift=1, bs=2,
+  // ok=3, page=4) use the `special` field for their behavior and label — the
+  // `ch` value is never read. Their label strings ("OK", "123", "⇧", "⌫") are
+  // multi-char or multi-byte and would overflow `char` if emitted as literals.
+  // Emit a space placeholder for any key whose ch isn't a single ASCII byte.
+  const isSingleAscii = key.special === 0 && key.ch.length === 1 && key.ch.charCodeAt(0) < 128;
+  if (key.special === 0 && !isSingleAscii) {
+    console.warn(
+      `[cuttlefish] keyboard key ch="${key.ch}" is non-ASCII and will be emitted as ` +
+      `a space placeholder. The native C++ UIKey.ch field is a single char and ` +
+      `cannot hold multi-byte codepoints. Use a custom keyboard layout or the ` +
+      `Adafruit path for full Unicode key labels.`,
+    );
+  }
+  const chRaw = isSingleAscii ? key.ch : ' ';
+  const chEsc = chRaw === "\\" ? "\\\\" : chRaw === "'" ? "\\'" : chRaw;
   const style = resolveKeyStyle(key.classes, kbClasses, rules);
   const bg = style.background ? resolveColor(style.background, colorFormat) : DEFAULT_KEY_BG;
   const fg = style.color ? resolveColor(style.color, colorFormat) : DEFAULT_KEY_FG;

package/src/ui-engine/ui-registry.ts

@@ -220,7 +220,8 @@ export function lowerOnMount(htmlPath: string, opts: LowerOptions): LoweredUI {
 
   const imageAssets = loadImageAssets(allStyled.length > 0 ? allStyled : [mod.styled], path.dirname(abs));
 
-  const scrollBudget = resolveScrollConfig(getDisplayProfile(), { buildTarget: getDisplayProfile()._buildTarget }).scrollCanvasBudgetBytes;
+  const _p = getDisplayProfile() as any;
+  const scrollBudget = resolveScrollConfig(_p, { buildTarget: _p._buildTarget, psram: _p._psram } as any).scrollCanvasBudgetBytes;
   const result = lowerUIToCpp(mod.styled, allBoxes, opts.colorFormat, opts.storage, mod.keyboards, mod.rules, getDisplayProfile(), mod.fontAssets, allStyled, imageAssets.nodeIdToAssetIndex, keyframeSets, scrollBudget);
 
   for (const d of result.scrollMemoryDiagnostics) {