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

package/dist/ui-engine/runtime-header/keyboard.js

@@ -49,7 +49,7 @@ static inline void ui_kb_insert(char c) {
   if (__ui_kb_target >= 0) {
     strncpy(__ui_nodes[__ui_kb_target].textBuffer, __ui_kb_buffer, UI_TEXT_BUF);
     __ui_nodes[__ui_kb_target].textBuffer[UI_TEXT_BUF] = 0;
-    ui_mark_dirty((uint16_t)__ui_kb_target);
+    ui_mark_dirty(static_cast<uint16_t>(__ui_kb_target));
   }
 #endif
 }
@@ -62,7 +62,7 @@ static inline void ui_kb_delete() {
   if (__ui_kb_target >= 0) {
     strncpy(__ui_nodes[__ui_kb_target].textBuffer, __ui_kb_buffer, UI_TEXT_BUF);
     __ui_nodes[__ui_kb_target].textBuffer[UI_TEXT_BUF] = 0;
-    ui_mark_dirty((uint16_t)__ui_kb_target);
+    ui_mark_dirty(static_cast<uint16_t>(__ui_kb_target));
   }
 #endif
 }
@@ -92,7 +92,7 @@ static inline void ui_kb_open(uint16_t nodeIdx, uint8_t inputPosition) {
   __ui_kb_buffer[UI_TEXT_BUF] = 0;
   __ui_kb_len = strlen(__ui_kb_buffer);
   uint16_t ml = __ui_nodes[nodeIdx].maxlen;
-  __ui_kb_maxlen = (ml > 0 && ml <= UI_TEXT_BUF) ? (uint8_t)ml : UI_TEXT_BUF;
+  __ui_kb_maxlen = (ml > 0 && ml <= UI_TEXT_BUF) ? static_cast<uint8_t>(ml) : UI_TEXT_BUF;
   __ui_kb_shift = 0;
   __ui_kb_bs_held = 0;
   // Load the key set via the dispatch table.
@@ -113,7 +113,7 @@ static inline void ui_kb_open(uint16_t nodeIdx, uint8_t inputPosition) {
   // keystroke. (The full-screen-flash concern above doesn't apply — there's no
   // opaque overlay being skipped.) Seed the blink phase so the caret is ON for
   // the first ~530ms (bit 0x20 set → visible), so focus feels immediate.
-  if (__ui_kb_target >= 0) ui_mark_dirty((uint16_t)__ui_kb_target);
+  if (__ui_kb_target >= 0) ui_mark_dirty(static_cast<uint16_t>(__ui_kb_target));
   __ui_kb_blink = 0x20;
 #endif
 }
@@ -140,7 +140,7 @@ static inline void ui_kb_close() {
   int16_t screenRoot = -1;
   for (uint16_t i = 0; i < __ui_node_count; i++) {
     if (__ui_nodes[i].parent == UI_NO_PARENT && __ui_nodes[i].screenId == __ui_active_screen) {
-      screenRoot = (int16_t)i;
+      screenRoot = static_cast<int16_t>(i);
       break;
     }
   }
@@ -156,7 +156,7 @@ static inline void ui_kb_close() {
   // scroll clipping — safe here since these nodes are bounded in size, unlike
   // the screen root.
   for (uint16_t i = 0; i < __ui_node_count; i++) {
-    if ((int16_t)i == screenRoot) continue;
+    if (static_cast<int16_t>(i) == screenRoot) continue;
     UIRect r;
     ui_node_current_paint_rect(i, &r);
     if (r.w > 0 && r.h > 0 &&
@@ -173,8 +173,8 @@ static inline void ui_kb_key_rect(uint8_t idx, UIRect* out) {
   uint8_t col = idx % __ui_kb_cols;
   uint8_t row = idx / __ui_kb_cols;
   int16_t keysH = __ui_kb_box.h - UI_KB_TEXT_H;  // key area height (below text row)
-  out->x = __ui_kb_box.x + (int16_t)col * __ui_kb_box.w / __ui_kb_cols;
-  out->y = __ui_kb_box.y + UI_KB_TEXT_H + (int16_t)row * keysH / __ui_kb_rows;
+  out->x = __ui_kb_box.x + static_cast<int16_t>(col) * __ui_kb_box.w / __ui_kb_cols;
+  out->y = __ui_kb_box.y + UI_KB_TEXT_H + static_cast<int16_t>(row) * keysH / __ui_kb_rows;
   out->w = __ui_kb_box.w / __ui_kb_cols;
   out->h = keysH / __ui_kb_rows;
 }
@@ -192,8 +192,8 @@ static inline void ui_kb_handle_touch(int16_t tx, int16_t ty) {
     UIRect r;
     ui_kb_key_rect(i, &r);
     if (tx >= r.x && tx < r.x + r.w && ty >= r.y && ty < r.y + r.h) {
-      __ui_kb_pressed_key = (int8_t)i;  // remember for release
-      __ui_kb_repaint_key = (int8_t)i;
+      __ui_kb_pressed_key = static_cast<int8_t>(i);  // remember for release
+      __ui_kb_repaint_key = static_cast<int8_t>(i);
       __ui_kb_dirty = 2;  // targeted: redraw just this key's highlight
       // Backspace starts deleting immediately + arms auto-repeat.
       if (k.special == 2) {
@@ -273,7 +273,7 @@ static inline void ui_kb_draw_key(uint8_t i) {
   UI_COLOR_T border = ks.borderColor;
   // Shift-active highlight: brighten the shift key's background — but only
   // when not pressed, so the press inversion stays high-contrast.
-  if (k.special == 1 && __ui_kb_shift && (int8_t)i != __ui_kb_pressed_key) {
+  if (k.special == 1 && __ui_kb_shift && static_cast<int8_t>(i) != __ui_kb_pressed_key) {
 #if UI_COLOR_DEPTH == 888
     bg = 0xBDEFFF;
 #else
@@ -281,7 +281,7 @@ static inline void ui_kb_draw_key(uint8_t i) {
 #endif
   }
   // Pressed key: invert colors for clear tap feedback.
-  if ((int8_t)i == __ui_kb_pressed_key) { UI_COLOR_T t = bg; bg = fg; fg = t; }
+  if (static_cast<int8_t>(i) == __ui_kb_pressed_key) { UI_COLOR_T t = bg; bg = fg; fg = t; }
   ui_display_fill_rect(r.x + 1, r.y + 1, r.w - 2, r.h - 2, bg);
   ui_display_draw_rect(r.x + 1, r.y + 1, r.w - 2, r.h - 2, border);
   ui_display_set_text_color(fg, bg);
@@ -295,14 +295,14 @@ static inline void ui_kb_draw_key(uint8_t i) {
     case 3:  labelStr = "OK"; break;
     case 4:  labelStr = __ui_kb_cols <= 4 ? "ABC" : "123"; break;
     default:
-      single[0] = (__ui_kb_shift && k.ch >= 'a' && k.ch <= 'z') ? (char)(k.ch - 32) : k.ch;
+      single[0] = (__ui_kb_shift && k.ch >= 'a' && k.ch <= 'z') ? static_cast<char>(k.ch - 32) : k.ch;
       single[1] = 0;
       labelStr = single;
       break;
   }
   // Center: textW = len * 6px, textH = 8px. Position inside the key rect.
   uint8_t len = strlen(labelStr);
-  int16_t textW = (int16_t)len * 6;
+  int16_t textW = static_cast<int16_t>(len) * 6;
   int16_t textH = 8;
   int16_t cx = r.x + (r.w - textW) / 2;
   int16_t cy = r.y + (r.h - textH) / 2;
@@ -328,15 +328,59 @@ static inline void ui_kb_draw_text_row() {
 }
 
 // Draw the full keyboard overlay (background + text row + all keys).
+// Renders into a dedicated offscreen canvas first, then pushes in a single
+// SPI transaction — avoids the per-key/per-rect display writes that show up
+// as visible row-by-row painting on SPI TFTs.
+// (__ui_kb_canvas is forward-declared in the touch-keyboard-fwd slice.)
 static inline void ui_kb_draw() {
-  // Opaque background over the keyboard box.
-  ui_display_fill_rect(__ui_kb_box.x, __ui_kb_box.y, __ui_kb_box.w, __ui_kb_box.h, __ui_kb_bg);
+  int16_t kw = __ui_kb_box.w;
+  int16_t kh = __ui_kb_box.h;
+  if (kw <= 0 || kh <= 0) return;
+  // (Re)allocate the keyboard canvas to exact size (see repair-canvas comment
+  // — stride mismatch corrupts the push when reusing a differently-sized canvas).
+  // ui_create_canvas_best prefers PSRAM when available (a full-width keyboard
+  // canvas can be ~30KB, too big for no-PSRAM internal SRAM) and falls back to
+  // SRAM — same policy as the list/scroll viewport canvases.
+  if (!__ui_kb_canvas || !display_canvasBuffer(__ui_kb_canvas) ||
+      display_canvasWidth(__ui_kb_canvas) != kw ||
+      display_canvasHeight(__ui_kb_canvas) != kh) {
+    display_deleteCanvas(__ui_kb_canvas);
+    __ui_kb_canvas = ui_create_canvas_best(kw, kh);
+  }
+  if (!__ui_kb_canvas || !display_canvasBuffer(__ui_kb_canvas)) {
+    // Canvas alloc failed — fall back to direct draw (slow but correct).
+    ui_display_fill_rect(__ui_kb_box.x, __ui_kb_box.y, kw, kh, __ui_kb_bg);
+    ui_kb_draw_text_row();
+    for (uint8_t i = 0; i < __ui_kb_keyCount; i++) {
+      if (__ui_kb_keys[i].special == 255) continue;
+      ui_kb_draw_key(i);
+    }
+    return;
+  }
+  // Redirect drawing into the canvas. All ui_display_* calls below go to RAM.
+  CuttlefishDisplayTarget* __kb_prev_target = ui_display_get_target();
+  ui_display_set_target(__ui_kb_canvas);
+  // Opaque background over the keyboard box (canvas-local 0,0).
+  ui_display_fill_rect(0, 0, kw, kh, __ui_kb_bg);
+  // Text row + keys: temporarily shift box origin to canvas-local so the
+  // existing draw_text_row / draw_key functions compute coords at (0,0).
+  int16_t saveBoxX = __ui_kb_box.x;
+  int16_t saveBoxY = __ui_kb_box.y;
+  __ui_kb_box.x = 0;
+  __ui_kb_box.y = 0;
   ui_kb_draw_text_row();
-  // Keys: one rect per key, label centered.
   for (uint8_t i = 0; i < __ui_kb_keyCount; i++) {
-    if (__ui_kb_keys[i].special == 255) continue;  // padding cell, skip
+    if (__ui_kb_keys[i].special == 255) continue;
     ui_kb_draw_key(i);
   }
+  __ui_kb_box.x = saveBoxX;
+  __ui_kb_box.y = saveBoxY;
+  // Restore display target and push the canvas in one transaction.
+  ui_display_set_target(__kb_prev_target);
+  display_startWrite();
+  display_setAddrWindow(saveBoxX, saveBoxY, kw, kh);
+  display_writePixels(display_canvasBuffer(__ui_kb_canvas), static_cast<uint32_t>(kw) * kh);
+  display_endWrite();
 }
 `;
 }

package/dist/ui-engine/runtime-header/node-decoration.js

@@ -18,19 +18,19 @@ static inline void ui_draw_gradient_fill(uint16_t i, int16_t drawY) {
   uint8_t dir = __ui_nodes[i].gradientEnabled;  // 1=vertical, 2=horizontal
   if (dir == 1) {
     // Vertical: top=c1, bottom=c2. Draw row by row.
-    int16_t yStart = (int16_t)(clipY - by);
-    int16_t yEnd = (int16_t)(clipY + clipH - by);
+    int16_t yStart = static_cast<int16_t>(clipY - by);
+    int16_t yEnd = static_cast<int16_t>(clipY + clipH - by);
     for (int16_t y = yStart; y < yEnd; y++) {
-      uint8_t op = (uint8_t)((uint16_t)y * 100 / (bh > 1 ? bh - 1 : 1));
+      uint8_t op = static_cast<uint8_t>(static_cast<uint16_t>(y) * 100 / (bh > 1 ? bh - 1 : 1));
       uint32_t col = ui_blend(c1, c2, op);
       ui_display_draw_fast_hline(clipX, by + y, clipW, col);
     }
   } else {
     // Horizontal: left=c1, right=c2. Draw column by column.
-    int16_t xStart = (int16_t)(clipX - bx);
-    int16_t xEnd = (int16_t)(clipX + clipW - bx);
+    int16_t xStart = static_cast<int16_t>(clipX - bx);
+    int16_t xEnd = static_cast<int16_t>(clipX + clipW - bx);
     for (int16_t x = xStart; x < xEnd; x++) {
-      uint8_t op = (uint8_t)((uint16_t)x * 100 / (bw > 1 ? bw - 1 : 1));
+      uint8_t op = static_cast<uint8_t>(static_cast<uint16_t>(x) * 100 / (bw > 1 ? bw - 1 : 1));
       uint32_t col = ui_blend(c1, c2, op);
       ui_display_draw_fast_vline(bx + x, clipY, clipH, col);
     }
@@ -79,7 +79,7 @@ static inline void ui_draw_shadow(uint16_t i, int16_t drawY, uint8_t insetOnly)
     }
 
     for (int8_t pass = blur; pass >= 1; pass--) {
-      uint8_t opacity = (uint8_t)((uint16_t)baseAlpha / (pass + 1));
+      uint8_t opacity = static_cast<uint8_t>(static_cast<uint16_t>(baseAlpha) / (pass + 1));
       uint32_t col = ui_blend(shadowCol, inset ? (__ui_nodes[i].hasBg ? __ui_nodes[i].bg : clearCol) : clearCol, opacity);
       if (inset) {
         // Inset: draw inside the element, shrinking inward by pass.
@@ -104,7 +104,7 @@ static inline void ui_draw_shadow(uint16_t i, int16_t drawY, uint8_t insetOnly)
         int16_t sw = bw + 2 * pass;
         int16_t sh_ = bh + 2 * pass;
         if (radius > 0) {
-          uint8_t r = radius + (uint8_t)pass;
+          uint8_t r = radius + static_cast<uint8_t>(pass);
           if (r > sw / 2) r = sw / 2;
           if (r > sh_ / 2) r = sh_ / 2;
           ui_display_fill_round_rect(sx, sy, sw, sh_, r, col);
@@ -176,7 +176,6 @@ static inline void ui_draw_node_border(uint16_t i, int16_t drawX, int16_t drawY,
   if (__ui_nodes[i].hasPerSideBorder) {
     int16_t w = __ui_nodes[i].box.w;
     int16_t h = __ui_nodes[i].box.h;
-    uint8_t st = __ui_nodes[i].borderStyle;
     // Top edge
     if (__ui_nodes[i].borderTopWidth > 0) {
       ui_display_fill_rect(drawX, drawY, w, __ui_nodes[i].borderTopWidth, color);

package/dist/ui-engine/runtime-header/node-draw-body.d.ts

@@ -0,0 +1 @@
+export declare function emitNodeDrawBody(): string;