Q-W1 pt2: core/shell/app relocation + sub-namespaces; one concrete ui::Rect (LTRB fork retired); slot_map split from bank_book; BankIndex→BankModel; 59/59 green

src/core/ui/rect.h

@@ -0,0 +1,56 @@
+#pragma once
+// rect.h — the ONE concrete pixel rectangle (Q-W1, T2-05 ≡ T4-21).
+//
+// Before Q-W1 the codebase carried 12+ byte-identical {x, y, width, height} structs
+// (ButtonRect / FooterRect / CellRect / KitBox / ...) plus a second LTRB grammar on
+// the VST side (editor_geometry's left/top/right/bottom Rect). This is the single
+// owner: one CONCRETE type (deliberately NOT a template — the role types differed in
+// name only, so a template would model nothing), with per-role aliases at the old
+// definition sites so call sites keep their semantic names
+// (`using ButtonRect = ui::Rect;`).
+//
+// Grammar: XYWH storage (the majority grammar — every extension role struct), with
+// right()/bottom() accessors and an ltrb() factory so the former LTRB call sites
+// convert mechanically. Half-open on both axes: a rect covers
+// [x, x+width) × [y, y+height) — the same convention LICE/SWELL RECTs use, and the
+// one every hitTest* in the codebase already implements.
+//
+// PURE MODULE: standard library only. Header-only; behavior is covered by the role
+// modules' own test executables (prune_button / footer_bar / bank_grid / ... and the
+// instrument-ui suites), which exercise every alias against these semantics.
+
+namespace reasampler::ui {
+
+struct Rect {
+    int x = 0;
+    int y = 0;
+    int width = 0;
+    int height = 0;
+
+    // Exclusive edges (half-open convention).
+    int right() const { return x + width; }
+    int bottom() const { return y + height; }
+
+    // A zero-or-negative-area rect means "not placed / suppressed": the caller must
+    // not draw or hit-test it (the shared graceful-degradation contract).
+    bool empty() const { return width <= 0 || height <= 0; }
+
+    // The former LTRB grammar's constructor (editor_geometry and friends): edges in,
+    // extents stored. right/bottom exclusive, matching right()/bottom().
+    static Rect ltrb(int left, int top, int right, int bottom) {
+        return Rect{left, top, right - left, bottom - top};
+    }
+
+    bool operator==(const Rect& o) const {
+        return x == o.x && y == o.y && width == o.width && height == o.height;
+    }
+    bool operator!=(const Rect& o) const { return !(*this == o); }
+};
+
+// True iff (px, py) falls inside r under the half-open convention. An empty rect
+// contains nothing, so a suppressed affordance can never claim a click.
+inline bool contains(const Rect& r, int px, int py) {
+    return px >= r.x && px < r.x + r.width && py >= r.y && py < r.y + r.height;
+}
+
+}  // namespace reasampler::ui