From d8ffd860d15fc470a0f82ffceb1129b935bce695 Mon Sep 17 00:00:00 2001 From: daniel-c-harvey Date: Fri, 31 Jul 2026 22:43:13 -0400 Subject: [PATCH] instrument: a deck group's reserved cell width goes to the cells present A Trigger face dropping Sustain and Release now gets wider cells instead of 144 px of dead slots. Group widths, row packing and Gate are untouched. --- src/core/instrument/CLAUDE.md | 2 +- src/core/instrument/ui/deck_groups.cpp | 5 +- src/core/instrument/ui/deck_groups.h | 4 +- src/core/instrument/ui/knob_deck.cpp | 26 +++-- src/core/instrument/ui/knob_deck.h | 11 +- src/shell/instrument/editor_paint_deck.cpp | 1 - tests/test_deck_groups.cpp | 124 ++++++++++++++++++++- tests/test_knob_deck.cpp | 69 ++++++++++-- 8 files changed, 213 insertions(+), 29 deletions(-) diff --git a/src/core/instrument/CLAUDE.md b/src/core/instrument/CLAUDE.md index 68cbcfc..19af2d9 100644 --- a/src/core/instrument/CLAUDE.md +++ b/src/core/instrument/CLAUDE.md @@ -307,7 +307,7 @@ anything for a trigger shape. - `browser_scroll` — scroll + type-to-filter layered over `capture_browser`: vertical scroll offset, scrollbar thumb, thumb-drag mapping, and name-substring search. - `param_slider` — parameter control-panel: vertical stack of TOGGLE (two-segment selector) and SLIDER (horizontal track) rows; maps normalized value to/from handle pixel. - `embed_strip` — compact single-row control layout for embed mode in the track FX chain. -- `knob_deck` — pure knob-deck layout + hit-test (FB1): group-box / caption-row / compact-toggle / knob-cell geometry, deterministic whole-group wrap, `DeckLayout` / `DeckHit`. Mirror of `action_bar`/`param_slider`; no LICE or REAPER types. A group carries TWO caption-toggle slots, laid right-to-left: the second exists because a group whose knob row is wider than its caption row has caption slack a toggle can occupy for free, and the deck has six pixels of headroom on its first row at the editor's floor width — a `rowToggle` would widen the GROUP and wrap the deck to a fourth row, past what the minimum window holds. +- `knob_deck` — pure knob-deck layout + hit-test (FB1): group-box / caption-row / compact-toggle / knob-cell geometry, deterministic whole-group wrap, `DeckLayout` / `DeckHit`. Mirror of `action_bar`/`param_slider`; no LICE or REAPER types. A group carries TWO caption-toggle slots, laid right-to-left: the second exists because a group whose knob row is wider than its caption row has caption slack a toggle can occupy for free, and the deck has six pixels of headroom on its first row at the editor's floor width — a `rowToggle` would widen the GROUP and wrap the deck to a fourth row, past what the minimum window holds. **A group's cell run is a RESERVED WIDTH, not a fixed cell size**: a `-1` id reserves one cell's width without a cell, and the cells present divide the whole run between them at one uniform integer width (residue in symmetric end margins). That is what lets a mode flip drop controls from a face — Trigger's AMP and FILTER ENV lose their Sustain/Release stages — without either reflowing the deck or leaving dead slots in the box; a face with fewer controls simply gets roomier cells. Do not reintroduce fixed-width cells with blank slots. - `deck_groups` — also home to `isLiveDeckParam` and `liveCommitFor`, the editor's whole commit-tier routing decision (see "Live parameter delivery" above), and to `OverlayEnv` + `nextOverlaySelection`/`overlayEnvEnabled`/`overlayEnvInert`, the whole overlay-selection state machine (exclusivity, the none resting state, and which selections a disabled or DRAWN group makes inert); WHICH groups the Sample face's deck carries, split from `knob_deck`'s HOW they lay out: the `DeckParam` control-id space (the editor's `ParamControl` is an alias of it), the `DeckGroupId` list, `sampleDeckGroups` in signal-flow order (**pitch → filter → amp**, then velocity/voice/master), and the deck's bipolar-knob law. Reads `PlayMode` for the AMP group's Gate/Trigger face, which is why this and not `knob_deck` is the module that touches the engine's value layer. Also home to `CurveTarget` + `curveTargetFor` — the VELOCITY group's three cells are popup openers, not dials, and that predicate is the ONE place they are named, so paint, hit-test routing and the popup's title all agree. MASTER is reserved for post-voice-mixer concerns, which is why the curves sit in their own group immediately left of VOICE rather than there. - `spline_edit` — THE point-editing grammar, and the one place it is written down: left-click grabs a node and adds one in empty space, right-click deletes, control-click toggles hard/smooth. Both spline consumers — the velocity-curve popup and the spline EG overlay — route their mouse-down through `resolveSplineEdit`, so the two cannot drift into two grammars. The endpoint and point-count rules are NOT restated here: `deletePoint` and `addPoint` own them, and the caller applies the resolved action to the curve. Also home to `splineOverlayBox`, the contour's mapping box inside the waveform overlay — the FULL area, no inset, so the drawn contour stays 1:1 with the sample's time axis. - `curve_popup` — pure curve-popup geometry + dismissal test (FB1): centered sheet over the Sample face — width/height clamps, title row, Close button rect, curve-box rect, outside-sheet dismissal test. Mirror of `overflow_menu`; no LICE or REAPER types. diff --git a/src/core/instrument/ui/deck_groups.cpp b/src/core/instrument/ui/deck_groups.cpp index 7798f99..28de21f 100644 --- a/src/core/instrument/ui/deck_groups.cpp +++ b/src/core/instrument/ui/deck_groups.cpp @@ -88,8 +88,9 @@ std::vector sampleDeckGroups(PlayMode playMode) { amp.captionToggle2 = {id(DeckParam::kAmpEnvMode), kEnvModeSegW}; if (trigger) { // The play span first, then the AHD that shapes it, time-ordered left-to-right so - // the row reads like the drawn envelope. One blank keeps the group's width — and - // therefore its neighbours' placement — identical across a mode flip. + // the row reads like the drawn envelope. One reserve (-1) keeps the group's width — + // and therefore its neighbours' placement — identical across a mode flip; its + // pixels go to the four cells that remain (knob_deck.h). amp.cellIds = {id(DeckParam::kTrigLength), id(DeckParam::kTrigAttack), id(DeckParam::kTrigHold), id(DeckParam::kTrigDecay), -1}; } else { diff --git a/src/core/instrument/ui/deck_groups.h b/src/core/instrument/ui/deck_groups.h index c6aaaf5..f338102 100644 --- a/src/core/instrument/ui/deck_groups.h +++ b/src/core/instrument/ui/deck_groups.h @@ -111,8 +111,8 @@ CurveTarget curveTargetFor(int controlId); // The deck's groups, left to right, in SIGNAL-FLOW order: pitch -> filter -> amp, then the // two instance-wide groups. `playMode` picks the AMP and FILTER ENV groups' faces — AHDSR in -// Gate, AHD in Trigger — via knob_deck's blank-cell reservation (knob_deck.h) so a mode flip -// never reflows the neighbouring groups. +// Gate, AHD in Trigger — via knob_deck's cell-width reservation (knob_deck.h) so a mode flip +// never reflows the neighbouring groups and never leaves a hole in the narrower face. std::vector sampleDeckGroups(PlayMode playMode); // The curve-exponent control a stage knob's INNER DIAL edits, or kCount when the knob shapes diff --git a/src/core/instrument/ui/knob_deck.cpp b/src/core/instrument/ui/knob_deck.cpp index 97cb051..273473d 100644 --- a/src/core/instrument/ui/knob_deck.cpp +++ b/src/core/instrument/ui/knob_deck.cpp @@ -65,14 +65,23 @@ DeckGroupLayout layoutGroup(const DeckGroupDesc& g, const Rect& box) { placeToggle(g.captionToggle, out.captionToggle); placeToggle(g.captionToggle2, out.captionToggle2); - // Knob row: fixed cells left-to-right, then the optional row toggle. + // Knob row: the cells present divide the whole reserved run (one kDeckCellW per declared + // id, reserves included). Integer division puts an indivisible residue in symmetric end + // margins rather than in one odd-width cell — keyboard_strip's uniformity-wins rule. const int cellTop = captionTop + kDeckCaptionH + kDeckCaptionGap; - int x = innerLeft; + const int runWidth = static_cast(g.cellIds.size()) * kDeckCellW; + int presentCells = 0; for (int id : g.cellIds) { + if (id >= 0) ++presentCells; + } + const int cellW = presentCells > 0 ? runWidth / presentCells : 0; + int x = innerLeft + (runWidth - presentCells * cellW) / 2; + for (int id : g.cellIds) { + if (id < 0) continue; DeckCellLayout c; c.id = id; - c.cell = Rect::ltrb(x, cellTop, x + kDeckCellW, cellTop + kDeckCellH); - const int knobLeft = x + (kDeckCellW - kDeckKnobSize) / 2; + c.cell = Rect::ltrb(x, cellTop, x + cellW, cellTop + kDeckCellH); + const int knobLeft = x + (cellW - kDeckKnobSize) / 2; const int knobTop = cellTop + 4; c.knob = Rect::ltrb(knobLeft, knobTop, knobLeft + kDeckKnobSize, knobTop + kDeckKnobSize); const int innerLeftPx = knobLeft + (kDeckKnobSize - kDeckInnerDialSize) / 2; @@ -82,13 +91,16 @@ DeckGroupLayout layoutGroup(const DeckGroupDesc& g, const Rect& box) { const int labelTop = knobTop + kDeckKnobSize + 4; c.label = Rect::ltrb(c.cell.x, labelTop, c.cell.right(), labelTop + kDeckCellLabelH); out.cells.push_back(c); - x += kDeckCellW; + x += cellW; } if (g.rowToggle.id >= 0) { - if (!g.cellIds.empty()) x += kDeckToggleGap; + // Anchored past the whole reserved run, not past the last cell, so a residue margin + // cannot shift it. + int tx = innerLeft + runWidth; + if (!g.cellIds.empty()) tx += kDeckToggleGap; const int segW = g.rowToggle.segWidth; const int togTop = cellTop + (kDeckCellH - kDeckToggleH) / 2; - const Rect seg0 = Rect::ltrb(x, togTop, x + segW, togTop + kDeckToggleH); + const Rect seg0 = Rect::ltrb(tx, togTop, tx + segW, togTop + kDeckToggleH); const Rect seg1 = Rect::ltrb(seg0.right(), togTop, seg0.right() + segW, togTop + kDeckToggleH); out.rowToggle = DeckToggleLayout{g.rowToggle.id, seg0, seg1}; } diff --git a/src/core/instrument/ui/knob_deck.h b/src/core/instrument/ui/knob_deck.h index 4014770..8dd4f36 100644 --- a/src/core/instrument/ui/knob_deck.h +++ b/src/core/instrument/ui/knob_deck.h @@ -5,9 +5,9 @@ // // The deck is a horizontal run of fenced groups, left->right, each a bordered box with a // caption row (caption left, the group's compact mode toggle right-anchored) over a knob -// row of fixed cells (knob centered, label band beneath). A group may also place one +// row of equal-width cells (knob centered, label band beneath). A group may also place one // two-segment toggle in the knob row after its cells. Groups that must keep stable -// geometry across a mode flip reserve blank cells (id -1) so a mode flip never reflows +// geometry across a mode flip reserve cell width (id -1) so a mode flip never reflows // neighbouring groups. // // Wrap is deterministic: groups place left-to-right with kDeckGroupGap between; a group @@ -57,7 +57,8 @@ struct DeckRadioDesc { }; // One fenced group, in deck order. `cellIds` are the knob cells left-to-right; an id of -1 -// is a reserved blank cell (geometry held, never hit). `captionWidth` is the px the shell +// reserves one cell's WIDTH without a cell, and the cells present divide the whole run — +// see this module's CLAUDE.md bullet for what that buys. `captionWidth` is the px the shell // reserves for the caption text (this module does not measure text). struct DeckGroupDesc { int id = 0; // shell group id (opaque here) @@ -87,7 +88,7 @@ struct DeckRadioLayout { struct DeckCellLayout { int id = -1; - Rect cell; // the full 48x58 cell + Rect cell; // the whole cell; width is the group's reserved run divided by its cell count Rect knob; // the centered kDeckKnobSize square (the knob circle inscribes it) Rect inner; // the concentric kDeckInnerDialSize square inside `knob` Rect label; // the 12px label band beneath the knob @@ -141,7 +142,7 @@ struct DeckHit { // The deck element a point lands on: a knob cell (the whole cell, not just the knob // circle — the shell anchors the vertical drag wherever the grab lands, with `inner` marking // a grab on the concentric inner dial), a caption-toggle segment, a row-toggle segment, or -// the caption-row corner radio. Blank cells (id -1) and everything else miss. +// the caption-row corner radio. Everything else — fence, padding, outside — misses. DeckHit hitTestDeck(const DeckLayout& layout, int x, int y); } // namespace reasampler::instrument::ui diff --git a/src/shell/instrument/editor_paint_deck.cpp b/src/shell/instrument/editor_paint_deck.cpp index 3436162..780c0fe 100644 --- a/src/shell/instrument/editor_paint_deck.cpp +++ b/src/shell/instrument/editor_paint_deck.cpp @@ -186,7 +186,6 @@ void ReaSamplerEditor::paintDeck(LICE_IBitmap* bmp, const FaceLayout& fl) { // The knobs. A dependent group's knobs draw Disabled (not hidden) — stable geometry. // The predicate is the input side's, so the drawn state and the inert grab agree. for (const DeckCellLayout& c : g.cells) { - if (c.id < 0) continue; // reserved blank cell (the Trigger face's spare) const bool disabled = deckKnobDisabled(c.id); // A VELOCITY cell is a popup opener, not a dial: it shows its curve in miniature // where a knob face would be, and its whole cell is the click target. diff --git a/tests/test_deck_groups.cpp b/tests/test_deck_groups.cpp index 1f831a2..d65564b 100644 --- a/tests/test_deck_groups.cpp +++ b/tests/test_deck_groups.cpp @@ -3,8 +3,9 @@ // descriptors the Sample face carries: the signal-flow group order (pitch -> filter -> amp), // the Filter group's contents, the VELOCITY group's exclusive ownership of the three curve // cells and its placement immediately left of VOICE, the wrapped deck height at the editor's -// floor width and its fit -// inside the floor window, the hit-test reaching the new filter controls, the bipolar knob +// floor width and its fit inside the floor window, the pinned Gate widths and row assignment, +// that no face leaves slack where its dropped controls were and that a Gate/Spline/Gate round +// trip restores the layout exactly, the hit-test reaching the new filter controls, the bipolar knob // law's inverse pair, the commit-tier routing — which controls are live, and which drags take // the live tier — and the overlay-selection state machine (exclusivity, the none resting state, // and which selections are inert). @@ -89,7 +90,7 @@ static void testCurveTargetNamesEachCellsOwnDestination() { CHECK(curveTargetFor(cell(DeckParam::kFilterVelCurve)) == CurveTarget::kFilter); CHECK(curveTargetFor(cell(DeckParam::kFilterCutoff)) == CurveTarget::kNone); CHECK(curveTargetFor(cell(DeckParam::kMasterGain)) == CurveTarget::kNone); - CHECK(curveTargetFor(-1) == CurveTarget::kNone); // a blank reserved cell + CHECK(curveTargetFor(-1) == CurveTarget::kNone); // a width reserve, not a control CHECK(curveTargetFor(9999) == CurveTarget::kNone); // out of the id space } @@ -264,6 +265,7 @@ static void testDeckFitsInsideTheEnforcedMinimumWindow() { const std::vector g = sampleDeckGroups(mode); const int h = deckHeight(g, kAvailAtMinWidth); const SampleBands b = computeSampleBands(kEditorMinWidth, kEditorMinHeight, h); + CHECK(deckRowCount(g, kAvailAtMinWidth) == 3); // either face, three rows at the floor CHECK(b.decks.height == h); // Bottom-anchored INSIDE the pad is the whole assertion: the degrade path pushes the // deck down until the waveform hits its floor, so any deck too tall to fit stops @@ -529,6 +531,119 @@ static void testTheModeTogglesCostNoGroupWidth() { } } +// A typical larger window, to check the same properties once the deck has re-wrapped. +static constexpr int kAvailAtLargerWidth = 1100 - 2 * kPad; + +// The gap fix as a property of the shipped descriptors, not a picture: whichever face a +// mode-dependent group shows, its knob row still spans the group's whole reserved run. The +// Trigger faces drop Sustain and Release and get wider cells for it — never a hole where the +// dropped control was. What the run does not cover is the indivisible residue alone, strictly +// under one pixel per cell. +static void testNoFaceLeavesSlackWhereItsDroppedControlsWere() { + for (int avail : {kAvailAtMinWidth, kAvailAtLargerWidth}) { + for (PlayMode mode : {PlayMode::Gate, PlayMode::Trigger}) { + const std::vector g = sampleDeckGroups(mode); + const DeckLayout dl = layoutDeck(g, kPad, 0, avail); + CHECK(dl.groups.size() == g.size()); + for (std::size_t i = 0; i < dl.groups.size(); ++i) { + const DeckGroupLayout& lay = dl.groups[i]; + const int reserved = static_cast(g[i].cellIds.size()) * kDeckCellW; + const std::size_t present = lay.cells.size(); + CHECK(present > 0); + for (std::size_t k = 0; k < present; ++k) { + const DeckCellLayout& c = lay.cells[k]; + CHECK(c.id >= 0); // a reserve yields width, never a dead rect + CHECK(c.cell.width == lay.cells[0].cell.width); + if (k > 0) CHECK(c.cell.x == lay.cells[k - 1].cell.right()); + } + const int covered = lay.cells.back().cell.right() - lay.cells.front().cell.x; + CHECK(reserved - covered < static_cast(present)); + CHECK(lay.cells.front().cell.x >= lay.box.x + kDeckGroupPadX); + CHECK(lay.cells.back().cell.right() <= lay.box.right() - kDeckGroupPadX); + } + } + } +} + +// Gate is the common face and it already packs correctly: pin its group widths and row +// assignment at the floor so a later edit anywhere in the deck cannot reflow it silently. +// (Measured from the shipped descriptors, not copied out of a failing run.) +static void testGateModeWidthsAndRowAssignmentAreUnchanged() { + const std::vector g = sampleDeckGroups(PlayMode::Gate); + const struct { int id; int width; int row; } want[] = { + {kGroupPitch, 150, 0}, {kGroupPitchEnv, 204, 0}, {kGroupFilter, 440, 0}, + {kGroupFilterEnv, 252, 1}, {kGroupAmpEnv, 252, 1}, {kGroupVelocity, 156, 1}, + {kGroupVoice, 152, 2}, {kGroupMaster, 60, 2}, + }; + CHECK(g.size() == sizeof(want) / sizeof(want[0])); + const DeckLayout dl = layoutDeck(g, kPad, 0, kAvailAtMinWidth); + for (std::size_t i = 0; i < dl.groups.size(); ++i) { + CHECK(dl.groups[i].id == want[i].id); + CHECK(deckGroupWidth(g[i]) == want[i].width); + CHECK(dl.groups[i].box.width == want[i].width); + CHECK(dl.groups[i].box.y == want[i].row * (kDeckGroupH + kDeckRowGap)); + // Gate carries no reserves, so its cells are the deck's base size. + for (const DeckCellLayout& c : dl.groups[i].cells) CHECK(c.cell.width == kDeckCellW); + } +} + +static bool sameToggle(const DeckToggleLayout& a, const DeckToggleLayout& b) { + return a.id == b.id && a.seg0 == b.seg0 && a.seg1 == b.seg1; +} + +static bool sameLayout(const DeckLayout& a, const DeckLayout& b) { + if (a.rowCount != b.rowCount || a.height != b.height || + a.groups.size() != b.groups.size()) return false; + for (std::size_t i = 0; i < a.groups.size(); ++i) { + const DeckGroupLayout& x = a.groups[i]; + const DeckGroupLayout& y = b.groups[i]; + if (x.id != y.id || !(x.box == y.box) || !(x.caption == y.caption)) return false; + if (x.captionRadio.id != y.captionRadio.id || !(x.captionRadio.box == y.captionRadio.box)) + return false; + if (!sameToggle(x.captionToggle, y.captionToggle) || + !sameToggle(x.captionToggle2, y.captionToggle2) || + !sameToggle(x.rowToggle, y.rowToggle)) return false; + if (x.cells.size() != y.cells.size()) return false; + for (std::size_t k = 0; k < x.cells.size(); ++k) { + const DeckCellLayout& c = x.cells[k]; + const DeckCellLayout& d = y.cells[k]; + if (c.id != d.id || !(c.cell == d.cell) || !(c.knob == d.knob) || + !(c.inner == d.inner) || !(c.label == d.label)) return false; + } + } + return true; +} + +// A Spline excursion is fully reversible at the layout level: the mode forcing swaps the amp +// and filter faces onto their wider cells and back, leaving no residue in the geometry. Driven +// through splineActive and the editor's own forcing rule, so the deck cannot agree with a +// forcing rule the shell does not use. +static void testGateSplineGateRoundTripsToTheSameLayout() { + PlayParams p; // Gate, all three envelopes staged + const DeckLayout before = layoutDeck(sampleDeckGroups(p.playMode), kPad, 0, kAvailAtMinWidth); + + p.ampSpline.mode = EnvMode::Spline; + if (splineActive(p)) p.playMode = PlayMode::Trigger; // editor_controls' forcing, verbatim + CHECK(p.playMode == PlayMode::Trigger); + const DeckLayout drawn = layoutDeck(sampleDeckGroups(p.playMode), kPad, 0, kAvailAtMinWidth); + // The excursion is real: the amp face's cells are strictly wider than Gate's. + const DeckGroupLayout& gateAmp = + before.groups[static_cast(indexOfGroup(sampleDeckGroups(PlayMode::Gate), + kGroupAmpEnv))]; + const DeckGroupLayout& trigAmp = + drawn.groups[static_cast(indexOfGroup(sampleDeckGroups(PlayMode::Trigger), + kGroupAmpEnv))]; + CHECK(trigAmp.cells.size() < gateAmp.cells.size()); + CHECK(trigAmp.cells[0].cell.width > gateAmp.cells[0].cell.width); + CHECK(!sameLayout(before, drawn)); + + p.ampSpline.mode = EnvMode::Staged; + CHECK(!splineActive(p)); + p.playMode = PlayMode::Gate; // Gate is selectable again once nothing is drawn + const DeckLayout after = layoutDeck(sampleDeckGroups(p.playMode), kPad, 0, kAvailAtMinWidth); + CHECK(sameLayout(before, after)); +} + int main() { testOverlaySelectionIsExclusiveAcrossTheThreeEnvelopeDecks(); testClickingTheActiveOverlayRadioClearsToNone(); @@ -550,6 +665,9 @@ int main() { testAmpGroupWidthSurvivesAGateTriggerFlip(); testWrappedDeckHeightAtTheEditorFloorWidth(); testDeckFitsInsideTheEnforcedMinimumWindow(); + testNoFaceLeavesSlackWhereItsDroppedControlsWere(); + testGateModeWidthsAndRowAssignmentAreUnchanged(); + testGateSplineGateRoundTripsToTheSameLayout(); testHitTestResolvesTheNewFilterControls(); testBipolarKnobLawRoundTripsAndIsExactAtCentre(); if (g_fail == 0) std::printf("deck_groups: all tests passed\n"); diff --git a/tests/test_knob_deck.cpp b/tests/test_knob_deck.cpp index d6fa6fa..95d47f3 100644 --- a/tests/test_knob_deck.cpp +++ b/tests/test_knob_deck.cpp @@ -2,15 +2,17 @@ // assert loop as the sibling pure tests. Assert the r11 deck layout HARD: // // * group width — caption row vs knob row max + padding; row-toggle and caption-toggle widths. -// * layout — caption toggle right-anchored IN the caption row; cells fixed 48x58 left-to-right +// * layout — caption toggle right-anchored IN the caption row; cells abutting left-to-right // inside the box; knob square centered; label band beneath; row toggle after the cells. +// * reserves — a -1 id holds the group's width and hands its pixels to the cells present. // * wrap — deterministic whole-group wrap at a narrowing width; the first group of a row // always places; deckHeight consistency with deckRowCount. -// * hit-test — knob cell hit (whole cell), toggle segment 0/1 boundaries, blank (-1) cells -// and fence padding miss, outside-deck miss. +// * hit-test — knob cell hit (whole cell), toggle segment 0/1 boundaries, fence padding +// misses, outside-deck misses. #include "../src/core/instrument/ui/knob_deck.h" +#include #include #include @@ -146,14 +148,19 @@ static void testHitTest() { h = hitTestDeck(dl, voice.rowToggle.seg1.x + 1, voice.rowToggle.seg1.y + 1); CHECK(h.kind == DeckHitKind::RowToggle && h.id == 104 && h.segment == 1); - // A blank cell (id -1) misses even though its rect exists. + // A reserve (id -1) yields no cell of its own, so every point of the knob row lands on a + // real control: no dead rect survives for a grab to fall into. std::vector trig; trig.push_back({0, 78, {}, {100, 44}, {}, {20, 21, 22, -1, -1}, {}}); const DeckLayout tl = layoutDeck(trig, 0, 0, 824); - const DeckCellLayout& blank = tl.groups[0].cells[4]; - CHECK(blank.id == -1); - h = hitTestDeck(tl, blank.cell.x + 5, blank.cell.y + 5); - CHECK(h.kind == DeckHitKind::None); + const DeckGroupLayout& tg = tl.groups[0]; + CHECK(tg.cells.size() == 3); + for (const DeckCellLayout& c : tg.cells) CHECK(c.id >= 0); + const DeckCellLayout& last = tg.cells.back(); + for (int px = tg.cells[0].cell.x; px < last.cell.right(); ++px) { + const DeckHit rowHit = hitTestDeck(tl, px, last.cell.y + 5); + CHECK(rowHit.kind == DeckHitKind::Knob && rowHit.id >= 0); + } // The fence padding inside the box misses; outside the deck misses. h = hitTestDeck(dl, amp.box.x + 1, amp.box.bottom() - 1); @@ -162,6 +169,51 @@ static void testHitTest() { CHECK(h.kind == DeckHitKind::None); } +// A reserve holds the group's WIDTH and hands its pixels to the cells that are present. The +// three properties together are what stops a narrower face reading as a hole: the group is +// exactly as wide as the full-face one, the cells are uniform and abutting, and what they do +// not cover is smaller than one pixel per cell. +static void testReservedCellWidthGoesToTheCellsPresent() { + const DeckGroupDesc full{0, 78, {}, {100, 44}, {}, {20, 21, 22, 23, 24}, {}}; + // Three, four, and a lone cell against the same five-slot reserve — 240/3, 240/4, 240/1. + const std::vector> faces = { + {20, 21, 22, -1, -1}, {20, 21, 22, 23, -1}, {20, -1, -1, -1, -1}}; + for (const std::vector& ids : faces) { + DeckGroupDesc narrow = full; + narrow.cellIds = ids; + CHECK(deckGroupWidth(narrow) == deckGroupWidth(full)); + + std::vector g{narrow}; + const DeckLayout dl = layoutDeck(g, 0, 0, 824); + const DeckGroupLayout& lay = dl.groups[0]; + const int present = static_cast(lay.cells.size()); + CHECK(present == 5 - static_cast(std::count(ids.begin(), ids.end(), -1))); + + const int run = 5 * kDeckCellW; + for (int i = 0; i < present; ++i) { + const DeckCellLayout& c = lay.cells[static_cast(i)]; + CHECK(c.cell.width == lay.cells[0].cell.width); // uniform + CHECK(c.knob.width == kDeckKnobSize); // the dial itself is fixed + CHECK(c.knob.x - c.cell.x == c.cell.right() - c.knob.right()); + if (i > 0) CHECK(c.cell.x == lay.cells[static_cast(i - 1)].cell.right()); + } + // Uncovered run is the indivisible residue only, split evenly at the two ends. + const int covered = lay.cells.back().cell.right() - lay.cells[0].cell.x; + CHECK(run - covered < present); + const int leadPad = lay.cells[0].cell.x - (lay.box.x + kDeckGroupPadX); + CHECK(leadPad == (run - covered) / 2); + } + + // A reserve does not move the row toggle: it anchors past the whole run, so the FILTER + // group's law switch cannot drift when a neighbouring face changes shape. + DeckGroupDesc withToggle{1, 40, {}, {}, {}, {20, 21, 22, 23, 24}, {104, 44}}; + std::vector a{withToggle}; + withToggle.cellIds = {20, 21, -1, -1, -1}; + std::vector b{withToggle}; + CHECK(layoutDeck(a, 0, 0, 824).groups[0].rowToggle.seg0 == + layoutDeck(b, 0, 0, 824).groups[0].rowToggle.seg0); +} + // The corner radio widens the caption row, takes the far corner, and pushes the caption // toggle left of itself — the three properties the overlay-select switch relies on. static void testCaptionRadioGeometryAndHit() { @@ -254,6 +306,7 @@ int main() { testFirstGroupAlwaysPlaces(); testGroupInnerGeometry(); testHitTest(); + testReservedCellWidthGoesToTheCellsPresent(); testCaptionRadioGeometryAndHit(); testInnerDialHit(); testCaptionToggle2();