//! The dialog (`Alt+D`, `Ctrl+P`, `Tab`): one filterable list of everything
 //! the app can be asked to do or to show differently.
 //!
 //! Every registry command is a row, and so is every display setting
 //! `DesignSettings` persists — a colour, a size, a unit — each carrying its
 //! control inline: a switch, a slider, a choice, a colour well. Until
 //! 2026-09-24 the settings were a second HALF behind a tab strip, a
 //! `ParametersBg` laid out inside the plate: two lists behind one chord, one
 //! of which could not be filtered, with the tab strip and its section
 //! headers as the only way to tell them apart. A setting is something you
 //! ask the app for by name, exactly as a command is, so it ranks in the same
 //! list and the strip is gone.
 //!
 //! This widget owns the FRAME — plate, query line, row list — and paints the
 //! rows' controls from the toolkit's own stamps (`Toggle`, `Slider`) and
 //! hosted `ColorSelector`s, so a slider in the dialog is the same slider as
 //! a slider in the params pane. The values behind the setting rows are the
 //! live `State` fields — see [`SETTINGS`] and [`Owner`].
 //!
 //! App-owned on the narrow traits wrapped in `Adapted<Dialog>`, like
 //! [`crate::playbar::Playbar`], and a subtree painter for the same reason:
 //! `paint` authors geometry AND text, so `append_frame_text` skips the slot.
 //! Geometry helpers take the laid-out `rect` rather than caching one, again
 //! like the playbar — the designer computes the same rects from
 //! `positions[DIALOG_IDX]` when it needs them outside a paint.
 
 use std::cell::RefCell;
 
 use cce_ui::colors;
 use cce_ui::scene::layout::Rect;
 use cce_ui::scene::paint::{PaintCtx, Prim};
 use cce_ui::widget::*;
 
 /// What the dialog was opened to do.
 ///
 /// One widget, two entry points, because a picker and a settings list are
 /// the same plate with the same keys — what differs is what a row MEANS.
 /// Splitting them into two widgets is how an app ends up with two filterable
 /// lists that behave differently, which is the thing this dialog replaced.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Mode {
     /// `Alt+D` / `Ctrl+P`: the commands and the settings, one list.
     Commands,
     /// `Tab` in the network pane: one list of node templates, and a pick
     /// that instantiates one at the grid cursor. Tab is what opened it, so
     /// Tab closes it again.
     AddNode,
     /// The node menu's Rename and the `rename_node` command: the query
     /// line is the NAME, opened holding the one the node has, and the one
     /// row says what Enter will do with it.
     Rename,
     /// The `group_markers` command: the scene's point groups, a switch
     /// each, marking the group's members in the viewport while it is on.
     /// The palette TURNS INTO this list, the way it turns into the node
     /// list — one plate, one filter.
     Groups,
 }
 
 /// The control a row carries, drawn over its right end and worked in place —
 /// the dialog stays up while any of these is used, since a setting you can
 /// only touch once before the panel vanishes is a button with extra steps.
 #[derive(Debug, Clone, PartialEq)]
 pub enum Control {
     /// A switch: a toggle command's state, or a boolean setting. Picking
     /// the row flips it.
     Toggle(bool),
     /// A slider over `min..=max`, read out to `dec` decimals with `suffix`;
     /// the arrows nudge it by `step` while the row is selected, the wheel
     /// over the band turns it, a press on the band jumps to the pointer.
     /// A `dec` of zero snaps to whole numbers — the spinbox shape.
     Slider { value: f32, min: f32, max: f32, dec: usize, step: f32, suffix: &'static str },
     /// One of a fixed set: picking the row opens a dropdown of the options
     /// under its value ([`State::open_dialog_dropdown`]); the arrows step
     /// either way without it.
     Choice { options: Vec<String>, index: usize },
     /// A colour, `#rrggbb`, drawn as the toolkit's colour selector: a hex
     /// well and a swatch that opens the picker.
     Color { hex: String },
 }
 
 impl Control {
     /// The value a setting row writes back, in the string the setting's
     /// writer takes — the same encodings the params pane uses.
     pub fn value_string(&self) -> String {
         match self {
             Control::Toggle(on) => if *on { "true" } else { "false" }.to_string(),
             Control::Slider { value, dec, .. } => format!("{:.*}", dec, value),
             Control::Choice { options, index } => options.get(*index).cloned().unwrap_or_default(),
             Control::Color { hex, .. } => hex.clone(),
         }
     }
 
     /// Clamp `v` into a slider's range, snapping to whole numbers when the
     /// readout shows none.
     fn quantize(&self, v: f32) -> f32 {
         match self {
             Control::Slider { min, max, dec, .. } => {
                 let v = v.clamp(min.min(*max), max.max(*min));
                 if *dec == 0 { v.round() } else { v }
             }
             _ => v,
         }
     }
 
     /// Slider `k` of the control, as (value, min, max): a slider's one, a
     /// float2's two.
     fn slider_part(&self, k: usize) -> Option<(f32, f32, f32)> {
         match self {
             Control::Slider { value, min, max, .. } if k == 0 => Some((*value, *min, *max)),
             _ => None,
         }
     }
 
     /// Move slider `k` to `v`, clamped and snapped as the control says.
     fn set_slider_part(&mut self, k: usize, v: f32) {
         let q = self.quantize(v);
         match self {
             Control::Slider { value, .. } if k == 0 => *value = q,
             _ => {}
         }
     }
 }
 
 /// One row: what picking it means, plus what to draw.
 #[derive(Debug, Clone)]
 pub struct Row {
     /// What the app does with this row: a command id or a setting row id
     /// in [`Mode::Commands`], a node template's name in [`Mode::AddNode`].
     /// Owned rather than `&'static str` because a template name is read
     /// off disk.
     pub id: String,
     pub label: String,
     /// The chord as a human reads it, empty when there is none. Drawn in its
     /// own right-hand column so the dialog teaches the keyboard rather than
     /// replacing it — which the `cce-cloud` palette could only approximate by
     /// padding the label out, since all it could send was one line of text.
     pub chord: String,
     /// The row's control, if it is one — see [`Control`]. `None` for a
     /// command that runs and is done.
     pub control: Option<Control>,
     /// Truncate the label on the LEFT when it does not fit, rather than on
     /// the right: the tail of a path is what identifies it, and a row that
     /// cut `/home/me/projects/thing` down to `/home/me/pro...` would name
     /// every project in the directory equally badly.
     pub truncate_head: bool,
 }
 
 impl Row {
     /// A row with no control: a command, a template, a path.
     pub fn plain(id: impl Into<String>, label: impl Into<String>, chord: impl Into<String>) -> Row {
         Row { id: id.into(), label: label.into(), chord: chord.into(), control: None, truncate_head: false }
     }
 
     /// The switch's state, for a toggle row.
     pub fn toggle(&self) -> Option<bool> {
         match self.control {
             Some(Control::Toggle(on)) => Some(on),
             _ => None,
         }
     }
 
     /// The slider's value, for a slider row.
     pub fn slider_value(&self) -> Option<f32> {
         match self.control {
             Some(Control::Slider { value, .. }) => Some(value),
             _ => None,
         }
     }
 
     /// Whether the row's control is made of sliders: a slider, or a
     /// float2's two.
     fn is_slider(&self) -> bool {
         matches!(self.control, Some(Control::Slider { .. }))
     }
 
     fn is_color(&self) -> bool {
         matches!(self.control, Some(Control::Color { .. }))
     }
 }
 
 /// The dialog's outer size. Fixed rather than proportional: it is a focused
 /// list, and a list that grows with the window turns into a wall of rows with
 /// the one you want somewhere in it.
 const DIALOG_W: f32 = 520.0;
 /// The plate's height, clamped to the window by [`layout_in`].
 ///
 /// 420 until 2026-09-23, which was sized for a Settings half of thirteen
 /// rows. Retiring the root meta node moved everything its four utility
 /// subnets held into that table — it is nearer thirty now — and a list that
 /// shows eight of them is a list you scroll rather than read.
 const DIALOG_H: f32 = 640.0;
 
 const PAD: f32 = 12.0;
 /// The query line's height: the toolkit's text box height, since the line
 /// is the dialog's text field.
 fn query_h() -> f32 {
     cce_ui::layout::textbox_height()
 }
 pub const ROW_H: f32 = 24.0;
 /// A toggle row's switch: the toolkit's `Toggle`, at the row's height less a
 /// hair of air, and about twice as wide as tall — the proportion the params
 /// pane's toggles have.
 pub const TOGGLE_W: f32 = 36.0;
 const TOGGLE_H: f32 = ROW_H - 4.0;
 /// How far in from the row's right end a slider or colour row's BAND begins.
 /// It runs from there out to the CHORD column's right edge, so it ends
 /// exactly where every other row's key binding ends and the toggle column
 /// stays clear — a band that stopped short of the chords read as a control
 /// someone had forgotten to finish. Not reserved on the other rows: a
 /// control row has no chord, so it borrows the chord column rather than
 /// pushing every chord in the list left by half the plate.
 pub const SLIDER_W: f32 = 180.0;
 /// The readout's width and its gap from the band. It sits to the LEFT of the
 /// band, because the band's right end is spoken for. The readout is drawn by
 /// the dialog, not by the toolkit slider's own: the dialog claims its rect as
 /// a text occluder, and the clamp lets through only text carrying the
 /// dialog's exact bounds (see `Dialog::popover`), so the stamp's readout
 /// would paint and never show.
 const READOUT_W: f32 = 60.0;
 const READOUT_GAP: f32 = 8.0;
 /// Gap between the query line and the list.
 const GAP: f32 = 8.0;
 
 /// The dialog's rect inside a `width` x `height` window: centered
 /// horizontally, and a little above centre vertically so the list grows into
 /// the window's roomier half rather than down over the status bar.
 pub fn layout_in(width: f32, height: f32) -> (f32, f32, f32, f32) {
     let w = DIALOG_W.min((width - 2.0 * PAD).max(200.0));
     let h = DIALOG_H.min((height - 2.0 * PAD).max(160.0));
     let x = ((width - w) * 0.5).max(0.0).round();
     let y = ((height - h) * 0.4).max(0.0).round();
     (x, y, w, h)
 }
 
 /// The least height an anchored plate shrinks to before it moves up
 /// instead: a query line and a dozen rows.
 const ANCHORED_MIN_H: f32 = 340.0;
 
 /// The dialog's rect when it opens where something else stood — the network
 /// menu's Add Node, which turns the menu into the list. The top-left corner
 /// is the anchor's wherever the plate fits there: short of room below, it
 /// gives up height down to [`ANCHORED_MIN_H`] and only then rises, and it is
 /// pulled in from the right edge. The width is the centred plate's.
 pub fn layout_at(width: f32, height: f32, ax: f32, ay: f32) -> (f32, f32, f32, f32) {
     let (_, _, w, full_h) = layout_in(width, height);
     let x = ax.min(width - PAD - w).max(0.0).round();
     let below = height - PAD - ay;
     let (y, h) = if below >= full_h {
         (ay, full_h)
     } else if below >= ANCHORED_MIN_H.min(full_h) {
         (ay, below)
     } else {
         let h = ANCHORED_MIN_H.min(full_h);
         ((height - PAD - h).max(0.0), h)
     };
     (x, y.round(), w, h.floor())
 }
 
 /// The query line, at the top of the plate.
 fn query_rect(rect: Rect) -> Rect {
     Rect { x: rect.x + PAD, y: rect.y + PAD, width: (rect.width - 2.0 * PAD).max(0.0), height: query_h() }
 }
 
 /// The list's viewport.
 fn list_rect(rect: Rect) -> Rect {
     let q = query_rect(rect);
     let top = q.y + q.height + GAP;
     Rect { x: q.x, y: top, width: q.width, height: (rect.y + rect.height - PAD - top).max(0.0) }
 }
 
 /// How many rows the list can show at once, for a dialog of this size.
 pub fn visible_rows(x: f32, y: f32, w: f32, h: f32) -> usize {
     (list_rect(Rect { x, y, width: w, height: h }).height / ROW_H).floor().max(0.0) as usize
 }
 
 /// The dialog turning into what it now shows — from the menu it replaced,
 /// or from the list it was in another mode — animated as the context
 /// menu's page turns are (`context_menu::TURN_MS`): the plate on its way
 /// from `from` to its own rect, the rows sliding in and coming up.
 #[derive(Debug, Clone, Copy)]
 pub struct DialogTurn {
     /// The plate it turned from, when that was another size: a menu.
     pub from: Option<Rect>,
     pub start: std::time::Instant,
     /// +1 forward (the rows come in from the right), -1 back.
     pub dir: f32,
 }
 
 pub struct Dialog {
     pub mode: Mode,
     /// The turn being animated, if one is.
     pub turning: Option<DialogTurn>,
     /// Where the plate's top-left corner goes, when it opened in place of
     /// something else (see [`layout_at`]); `None` centres it.
     pub anchor: Option<(f32, f32)>,
     /// What has been typed into the filter.
     pub query: String,
     /// The filtered, ranked rows — rebuilt by the app whenever `query`
     /// changes, never here: ranking needs the registry AND the focused pane,
     /// and this widget knows neither.
     pub rows: Vec<Row>,
     /// Which row Enter would run. Kept in range by [`Dialog::set_rows`].
     pub selected: usize,
     /// The list's scroll offset in px (0 = row 0 flush with the list top),
     /// the drawn value: rows paint at `i * ROW_H - scroll_px`, clipped to the
     /// list. Driven by `scroll_motion` — the DE's one wheel→offset model, so
     /// a notch glides and a trackpad tracks and coasts — and jumped by the
     /// keyboard (`scroll_to_selected`). Until 2026-09-20 this was a ROW
     /// index: every wheel event rounded to whole rows, so a trackpad's small
     /// deltas did nothing until one crossed half a row and then jumped it —
     /// the choppy commands list.
     pub scroll_px: f32,
     scroll_motion: cce_ui::widget::scroll_motion::ScrollMotion,
     /// The list's scrollbar, in the DE's sink-behind idiom (cce-mail's
     /// body bar, `ScrollRegion` with `sink_behind`): pills at the list's
     /// right edge that fade in on a scroll, stay while hovered or dragged,
     /// and fade out after the hold. Sunk, it is not drawn and takes no
     /// input — a press on its lane reaches the row beneath.
     sb_activity: cce_ui::widget::ScrollbarActivity,
     sb_dragging: bool,
     /// Where in the thumb the drag grabbed it, so the thumb does not jump
     /// to centre itself under the pointer.
     sb_drag_offset: f32,
     /// How many rows fit — pushed in from the layout, since `on_event` and the
     /// app's key handling both need it and neither has the rect to hand.
     page: usize,
     hover_row: Option<usize>,
     /// The row whose CONTROL the pointer is over — its switch, its slider
     /// (readout lane included), its colour well — so the control lifts
     /// under the pointer as the same control does in the params pane. The
     /// toggle and slider stamps are set from it as each row is painted; a
     /// colour row's selector is a widget of its own and is told by
     /// `MouseEnter` / `MouseLeave` as the pointer crosses its band.
     hover_ctl: Option<usize>,
     /// A row the pointer activated, drained by the app.
     activated: Option<String>,
     /// The choice rows' closed dropdowns: one toolkit `Dropdown`, handed
     /// each row's options and selection as the row is painted, as the
     /// toggle and slider stamps are.
     dropdown_stamp: RefCell<Adapted<Dropdown>>,
     /// The OPEN dropdown: a real toolkit `Dropdown` — the params pane's —
     /// given the options of the row it serves (`dropdown_row`) when that
     /// row is opened, laid out on the row's band, and handed the pointer
     /// and the keys while it is open (`State::dialog_dropdown_event`). Its
     /// plate grows out of the trigger into the list and back. Boxed and
     /// never replaced, because the UI context holds a pointer to it while
     /// it is registered as an occluder.
     /// An [`Embedded`] child, the context's once the dialog is (the designer reaches it
     /// through [`State::dialog_dd`]); invisible while closed, so it is no Tab stop and
     /// nothing hits it.
     pub dropdown: Embedded<Adapted<Dropdown>>,
     /// The row id the open dropdown serves.
     pub dropdown_row: Option<String>,
     /// Whether the dropdown was last seen expanded. The runner hands every
     /// left press to an open popover it thinks the press MISSED before the
     /// app sees the press, and the dialog's own claim covers the dropdown,
     /// so every press reaches the dropdown that way first: a press that
     /// finds it no longer expanded, while this is still set, is one the
     /// dropdown has already taken (`State::dialog_dropdown_press`).
     pub dropdown_armed: bool,
     /// Whether the dialog is currently claiming its rect as an occluder — see
     /// [`Paint::popover`]. Lowered for the length of an event dispatch into
     /// the dialog, because the one claim serves two mechanisms that want
     /// opposite answers.
     occluding: bool,
     /// The switch a toggle row draws, off and on — the toolkit's own
     /// `Toggle`, painted by hand into the row, so a switch in the dialog IS
     /// the switch in the params pane. Two stamps rather than one set per row
     /// because `paint` takes `&self`, and building a widget per row per
     /// frame would be silly.
     toggle_stamps: RefCell<[Adapted<Toggle>; 2]>,
     /// The slider every slider row draws — the toolkit's own `Slider`, so a
     /// slider in the dialog IS the slider in the params pane. One stamp for
     /// all of them, set to each row's range and value as it is painted;
     /// interior mutability because `paint` takes `&self`.
     slider_stamp: RefCell<Adapted<Slider>>,
     /// The row whose band a press took hold of, while the pointer is moving
     /// it — the app drives this through its widget-drag protocol
     /// (`draggable` and the `drag_*` hooks), so the drag survives the
     /// pointer leaving the plate.
     slider_drag: Option<usize>,
     /// Which of the dragged row's sliders the press took: 0 for a slider,
     /// either end of a float2.
     slider_part: usize,
     /// The float2 end under the pointer, while its row's control is
     /// hovered — the one that lifts.
     hover_part: usize,
     /// The band's (x, width) captured at the press, so a drag keeps
     /// mapping the pointer while the row scrolls under it.
     slider_track: (f32, f32),
     /// The row and value the pointer moved a slider to, drained by the app.
     slider_change: Option<(String, f32)>,
     /// One toolkit colour selector per colour row, by row id — real widgets,
     /// not stamps, because each carries state of its own: a hex edit in
     /// progress, a picker process streaming values. Kept across
     /// re-rankings so a query that drops the row does not kill its picker.
     colors: Vec<(String, Adapted<ColorSelector>)>,
     /// Colour rows the selectors changed, `(row id, hex)`, drained by the app.
     color_changes: Vec<(String, String)>,
 }
 
 impl Dialog {
     pub fn new() -> Adapted<Dialog> {
         let mut off = Toggle::new();
         off.set_toggled(false);
         let mut on = Toggle::new();
         on.set_toggled(true);
         let mut slider_stamp = Slider::new().with_readout(false);
         slider_stamp.set_scroll(false);
         let mut d = Adapted::new(Dialog {
             mode: Mode::Commands,
             turning: None,
             anchor: None,
             query: String::new(),
             rows: Vec::new(),
             selected: 0,
             scroll_px: 0.0,
             scroll_motion: cce_ui::widget::scroll_motion::ScrollMotion::new(),
             sb_activity: cce_ui::widget::ScrollbarActivity::new(),
             sb_dragging: false,
             sb_drag_offset: 0.0,
             page: 1,
             hover_row: None,
             hover_ctl: None,
             activated: None,
             dropdown_stamp: RefCell::new(Dropdown::new(Vec::new(), 0)),
             dropdown: Embedded::new({
                 let mut dd = Dropdown::new(Vec::new(), 0);
                 dd.set_visible(false);
                 dd
             }),
             dropdown_row: None,
             dropdown_armed: false,
             occluding: true,
             toggle_stamps: RefCell::new([off, on]),
             slider_stamp: RefCell::new(slider_stamp),
             slider_drag: None,
             slider_part: 0,
             hover_part: 0,
             slider_track: (0.0, 1.0),
             slider_change: None,
             colors: Vec::new(),
             color_changes: Vec::new(),
         });
         d.set_visible(false);
         d
     }
 
     /// Record how many rows fit, from the laid-out rect. Re-clamps the
     /// offset to the new range and nothing more: this runs on EVERY
     /// relayout (`layout_dialog`, off `rebuild_positions`, which the frame
     /// tick reaches whenever anything animates), and snapping to the
     /// selection here undid every wheel and finger scroll within a frame
     /// (2026-09-20 — the list "would not scroll at all"). Keeping the
     /// selection in view is the keyboard's job: `move_selection` and
     /// `scroll_to_selected` at the call sites that change it.
     pub fn set_page(&mut self, page: usize) {
         self.page = page.max(1);
         self.set_scroll_px(self.scroll_px);
     }
 
     /// How many rows fit — what PageUp/PageDown step by.
     pub fn page_len(&self) -> usize {
         self.page.max(1)
     }
 
     /// Claim, or stop claiming, the dialog's rect as an occluder.
     pub fn set_occluding(&mut self, on: bool) {
         self.occluding = on;
     }
 
     /// The furthest the list scrolls: the last page flush with the bottom.
     fn max_scroll_px(&self) -> f32 {
         ((self.rows.len() as f32 - self.page.max(1) as f32) * ROW_H).max(0.0)
     }
 
     /// The first row with any part in view.
     fn first_row(&self) -> usize {
         (self.scroll_px / ROW_H).floor().max(0.0) as usize
     }
 
     /// Jump the list to `px` (clamped) — the keyboard's move, not a glide.
     fn set_scroll_px(&mut self, px: f32) {
         self.scroll_px = px.clamp(0.0, self.max_scroll_px());
         self.scroll_motion.y.jump_to(self.scroll_px);
     }
 
     /// The scrollbar's geometry — `(sb_x, track_y, sb_w, track_h, thumb_y,
     /// thumb_h)`, mirroring `ScrollRegion::scrollbar_geom` as cce-mail's
     /// body bar does — or `None` when the rows fit and there is no bar. The
     /// one source for paint, the press and the drag. The bar rides the
     /// plate's CENTRE line, as both of cce-mail's bars ride theirs — over
     /// the rows, reserving no lane, in front only while raised; the track
     /// stops 4px short at each end like every toolkit bar.
     pub fn scrollbar_geom(&self, rect: Rect) -> Option<(f32, f32, f32, f32, f32, f32)> {
         let max_scroll = self.max_scroll_px();
         if max_scroll <= 0.0 {
             return None;
         }
         let list = list_rect(rect);
         let sb_w = cce_ui::layout::centred_scrollbar_width();
         let sb_x = rect.x + (rect.width - sb_w) * 0.5;
         let track_y = list.y + 4.0;
         let track_h = (list.height - 8.0).max(0.0);
         let content_h = self.rows.len() as f32 * ROW_H;
         let visible_ratio = list.height / content_h.max(1.0);
         let thumb_h = if track_h <= 20.0 { track_h } else { (track_h * visible_ratio).clamp(20.0, track_h) };
         let thumb_y = track_y + (self.scroll_px / max_scroll) * (track_h - thumb_h);
         Some((sb_x, track_y, sb_w, track_h, thumb_y, thumb_h))
     }
 
     fn over_scrollbar(&self, rect: Rect, px: f32, py: f32) -> bool {
         self.scrollbar_geom(rect).is_some_and(|(sb_x, track_y, sb_w, track_h, _, _)| {
             px >= sb_x - 4.0 && px <= sb_x + sb_w + 4.0 && py >= track_y && py <= track_y + track_h
         })
     }
 
     /// A left press on the bar's strip (±4px slop, like `ScrollRegion`):
     /// grab the thumb where it was clicked, or jump the track there and
     /// drag from the thumb's centre. A sunk bar is not drawn and takes no
     /// input — the press falls through to the row beneath.
     fn sb_press(&mut self, rect: Rect, px: f32, py: f32) -> bool {
         if !self.sb_activity.raised() {
             return false;
         }
         let Some((sb_x, track_y, sb_w, track_h, thumb_y, thumb_h)) = self.scrollbar_geom(rect) else {
             return false;
         };
         if px < sb_x - 4.0 || px > sb_x + sb_w + 4.0 || py < track_y || py > track_y + track_h {
             return false;
         }
         self.sb_dragging = true;
         let click_offset = py - thumb_y;
         if (0.0..=thumb_h).contains(&click_offset) {
             self.sb_drag_offset = click_offset;
         } else {
             self.sb_drag_offset = thumb_h / 2.0;
             self.sb_drag_to(rect, py);
         }
         true
     }
 
     fn sb_drag_to(&mut self, rect: Rect, py: f32) -> bool {
         let Some((_, track_y, _, track_h, _, thumb_h)) = self.scrollbar_geom(rect) else {
             return false;
         };
         let target = py - self.sb_drag_offset;
         let ratio = if track_h - thumb_h > 0.0 { ((target - track_y) / (track_h - thumb_h)).clamp(0.0, 1.0) } else { 0.0 };
         let old = self.scroll_px;
         self.set_scroll_px(ratio * self.max_scroll_px());
         (self.scroll_px - old).abs() > 0.01
     }
 
     /// Whether the bar is raised — for the app's press cascade and tests.
     pub fn scrollbar_raised(&self) -> bool {
         self.sb_activity.raised()
     }
 
     /// A row's rect in the list, `Some` while any part of it is in view
     /// (the paint clips to the list, so a partly scrolled row draws cut).
     fn row_rect(&self, rect: Rect, i: usize) -> Option<Rect> {
         let list = list_rect(rect);
         let offset = i as f32 * ROW_H - self.scroll_px;
         if offset + ROW_H <= 0.0 || offset >= list.height {
             return None;
         }
         Some(Rect { x: list.x, y: list.y + offset, width: list.width, height: ROW_H })
     }
 
     /// How far the turn in progress has gone, eased; `None` when none is.
     pub fn turn_progress(&self) -> Option<f32> {
         let t = self.turning.as_ref()?;
         let raw = t.start.elapsed().as_secs_f32() * 1000.0 / cce_ui::widget::context_menu::turn_ms();
         (raw < 1.0).then(|| cce_ui::widget::context_menu::turn_ease(raw))
     }
 
     /// The plate as it is drawn on `rect`: there, or on its way there from
     /// the plate it turned from.
     pub fn drawn_rect(&self, rect: Rect) -> Rect {
         match (self.turn_progress(), self.turning.and_then(|t| t.from)) {
             (Some(e), Some(f)) => Rect {
                 x: f.x + (rect.x - f.x) * e,
                 y: f.y + (rect.y - f.y) * e,
                 width: f.width + (rect.width - f.width) * e,
                 height: f.height + (rect.height - f.height) * e,
             },
             _ => rect,
         }
     }
 
     /// The row under `(x, y)` in a dialog laid out on `rect`.
     pub fn row_index_at(&self, rect: Rect, x: f32, y: f32) -> Option<usize> {
         self.row_at(rect, x, y)
     }
 
     fn row_at(&self, rect: Rect, x: f32, y: f32) -> Option<usize> {
         let list = list_rect(rect);
         if x < list.x || x >= list.x + list.width || y < list.y || y >= list.y + list.height {
             return None;
         }
         let i = ((y - list.y + self.scroll_px) / ROW_H).floor();
         (i >= 0.0 && (i as usize) < self.rows.len()).then_some(i as usize)
     }
 
     /// Keep `selected` inside the scrolled window.
     pub fn scroll_to_selected(&mut self) {
         let view = self.page.max(1) as f32 * ROW_H;
         let top = self.selected as f32 * ROW_H;
         let bottom = top + ROW_H;
         if top < self.scroll_px {
             self.set_scroll_px(top);
             self.sb_activity.bump();
         } else if bottom > self.scroll_px + view {
             self.set_scroll_px(bottom - view);
             self.sb_activity.bump();
         }
     }
 
     pub fn move_selection(&mut self, delta: i32) {
         if self.rows.is_empty() {
             self.selected = 0;
             self.set_scroll_px(0.0);
             return;
         }
         let n = self.rows.len() as i32;
         // Wrapping, not clamping: a list you can fall off the bottom of makes
         // the last row harder to reach than the first, and this one is short.
         self.selected = (self.selected as i32 + delta).rem_euclid(n) as usize;
         self.scroll_to_selected();
     }
 
     /// What Enter would pick.
     pub fn selected_id(&self) -> Option<&str> {
         self.rows.get(self.selected).map(|r| r.id.as_str())
     }
 
     /// The selected row's control, if it has one.
     pub fn selected_control(&self) -> Option<&Control> {
         self.rows.get(self.selected).and_then(|r| r.control.as_ref())
     }
 
     pub fn take_activated(&mut self) -> Option<String> {
         self.activated.take()
     }
 
     /// Put the scroll back where it was after a re-rank, clamped to the
     /// list the rows now make.
     pub fn restore_scroll_px(&mut self, px: f32) {
         self.set_scroll_px(px);
     }
 
     /// Replace one row's control in place — the app re-reads a control from
     /// the live value after applying it, without touching the ranking, the
     /// selection or the scroll.
     pub fn set_control(&mut self, id: &str, control: Option<Control>) {
         if let Some(row) = self.rows.iter_mut().find(|r| r.id == id) {
             row.control = control;
         }
         self.sync_color_selectors();
     }
 
     /// Move a slider row to a value, clamped and snapped as the row says.
     pub fn set_slider_value(&mut self, i: usize, v: f32) {
         self.set_slider_part(i, 0, v);
     }
 
     /// Move slider `k` of row `i` — a float2's either end — to a value.
     pub fn set_slider_part(&mut self, i: usize, k: usize, v: f32) {
         if let Some(c) = self.rows.get_mut(i).and_then(|r| r.control.as_mut()) {
             c.set_slider_part(k, v);
         }
     }
 
     pub fn take_slider_change(&mut self) -> Option<(String, f32)> {
         self.slider_change.take()
     }
 
     /// Say what row `i`'s sliders now hold, for the app to land.
     fn note_slider_change(&mut self, i: usize) {
         let Some(row) = self.rows.get(i) else { return };
         match row.control {
             Some(Control::Slider { value, .. }) => self.slider_change = Some((row.id.clone(), value)),
             _ => {}
         }
     }
 
     /// Whether a press has taken hold of a slider — the app arms its
     /// widget drag on this.
     pub fn slider_dragging(&self) -> bool {
         self.slider_drag.is_some()
     }
 
     /// The colour selector behind a colour row, if that row has one.
     pub fn color_selector(&self, id: &str) -> Option<&Adapted<ColorSelector>> {
         self.colors.iter().find(|(k, _)| k == id).map(|(_, s)| s)
     }
 
     /// The colour selector whose hex well is being typed into, if any — the
     /// app hands it the keyboard ahead of the filter.
     pub fn editing_color(&mut self) -> Option<&mut Adapted<ColorSelector>> {
         self.colors.iter_mut().find(|(_, s)| s.inner().editing).map(|(_, s)| s)
     }
 
     pub fn take_color_changes(&mut self) -> Vec<(String, String)> {
         std::mem::take(&mut self.color_changes)
     }
 
     /// Give every colour row a selector, and set each from its row — unless
     /// the selector is mid-edit, when the buffer is the user's and the row's
     /// value is what it was opened on. A value the APP put in is not a
     /// change to report back, so the flag it raises is dropped here.
     fn sync_color_selectors(&mut self) {
         for row in &self.rows {
             let Some(Control::Color { hex }) = &row.control else { continue };
             let k = match self.colors.iter().position(|(k, _)| *k == row.id) {
                 Some(k) => k,
                 None => {
                     self.colors.push((row.id.clone(), ColorSelector::new([0; 3])));
                     self.colors.len() - 1
                 }
             };
             let sel = &mut self.colors[k].1;
             if !sel.inner().editing {
                 sel.set_value_string(hex);
                 let _ = sel.take_change();
             }
         }
     }
 
     /// Collect what the selectors changed — a picker line, a hex committed
     /// by Enter — as `(row id, hex)`, and move the rows to match.
     fn drain_color_selectors(&mut self) -> bool {
         let mut changed = false;
         for (id, sel) in &mut self.colors {
             if !sel.take_change() {
                 continue;
             }
             let Some(hex) = sel.get_value_string() else { continue };
             if let Some(Control::Color { hex: h, .. }) =
                 self.rows.iter_mut().find(|r| r.id == *id).and_then(|r| r.control.as_mut())
             {
                 *h = hex.clone();
             }
             self.color_changes.push((id.clone(), hex));
             changed = true;
         }
         changed
     }
 
     /// The switch column's width: reserved on EVERY row as soon as any row
     /// has a toggle, so the chord column keeps a straight edge.
     fn toggle_col(&self) -> f32 {
         if self.rows.iter().any(|r| r.toggle().is_some()) { TOGGLE_W + 12.0 } else { 0.0 }
     }
 
     /// The band a slider or colour row draws its control over — so the
     /// pointer maps to the value where the band is drawn. It ends at the
     /// chord column's right edge, not the row's, which is why it needs the
     /// roster rather than the rect alone.
     fn slider_band_rect(&self, r: Rect) -> Rect {
         let x = r.x + r.width - 8.0 - SLIDER_W;
         let right = r.x + r.width - 8.0 - self.toggle_col();
         Rect { x, y: r.y + 2.0, width: (right - x).max(10.0), height: ROW_H - 4.0 }
     }
 
     /// The open dropdown's trigger, in window coordinates: its row's control
     /// band, while the row is in view. What the live dropdown is laid out
     /// on, so it opens from where the row's stamp was drawn.
     pub fn dropdown_trigger(&self, rect: Rect) -> Option<Rect> {
         let id = self.dropdown_row.as_deref()?;
         let i = self.rows.iter().position(|r| r.id == id)?;
         self.row_rect(rect, i).map(|r| self.slider_band_rect(r))
     }
 
     /// Where a row's control is, for the hover: the switch, the whole
     /// slider (readout lane included), the colour band, a choice's
     /// dropdown trigger. None for a row with no control the pointer can
     /// lift.
     fn control_rect(&self, r: Rect, row: &Row) -> Option<Rect> {
         match &row.control {
             Some(Control::Toggle(_)) => Some(Rect {
                 x: r.x + r.width - 8.0 - TOGGLE_W,
                 y: r.y + (r.height - TOGGLE_H) * 0.5,
                 width: TOGGLE_W,
                 height: TOGGLE_H,
             }),
             Some(Control::Slider { .. }) => Some(self.slider_rect(r)),
             Some(Control::Color { .. }) => Some(self.slider_band_rect(r)),
             Some(Control::Choice { .. }) => Some(self.slider_band_rect(r)),
             None => None,
         }
     }
 
     /// The row whose control is under the pointer.
     pub fn hovered_control(&self) -> Option<usize> {
         self.hover_ctl
     }
 
     /// The whole slider control: the band plus the readout lane ahead of it.
     /// This is what the pointer tests against, so the wheel turns the slider
     /// over the readout too.
     fn slider_rect(&self, r: Rect) -> Rect {
         let b = self.slider_band_rect(r);
         Rect { x: b.x - READOUT_W - READOUT_GAP, width: b.width + READOUT_W + READOUT_GAP, ..b }
     }
 
     /// A slider row's sliders, each as (band, the whole control): one for a
     /// slider, two for a float2.
     fn slider_parts(&self, r: Rect, row: &Row) -> Vec<(Rect, Rect)> {
         match row.control {
             Some(Control::Slider { .. }) => vec![(self.slider_band_rect(r), self.slider_rect(r))],
             _ => Vec::new(),
         }
     }
 
     /// Which of row `i`'s sliders is under `x`, testing the band alone when
     /// `band_only` (a press) and band and readout together otherwise (the
     /// wheel, the hover).
     fn slider_part_at(&self, r: Rect, i: usize, x: f32, band_only: bool) -> Option<(usize, Rect)> {
         let row = self.rows.get(i)?;
         self.slider_parts(r, row).into_iter().enumerate().find_map(|(k, (band, whole))| {
             let s = if band_only { band } else { whole };
             (x >= s.x && x < s.x + s.width).then_some((k, band))
         })
     }
 
     /// Row `i`'s slider bands in window coordinates, while the row is in
     /// view inside the dialog at `(x, y, w, h)` — for the suite to press
     /// on where the pointer would.
     #[cfg(test)]
     pub fn slider_bands(&self, (x, y, w, h): (f32, f32, f32, f32), i: usize) -> Vec<Rect> {
         let rect = Rect { x, y, width: w, height: h };
         let Some(r) = self.row_rect(rect, i) else { return Vec::new() };
         self.slider_parts(r, &self.rows[i]).into_iter().map(|(band, _)| band).collect()
     }
 
     /// Step slider `k` of row `i` by wheel notches: 2% of the range each,
     /// the toolkit slider's own rate, up meaning more — the sign the
     /// viewport's zoom wheel has.
     fn scroll_slider(&mut self, i: usize, k: usize, notches: f32) -> bool {
         let Some((cur, min, max)) = self.rows.get(i).and_then(|r| r.control.as_ref()).and_then(|c| c.slider_part(k)) else {
             return false;
         };
         self.set_slider_part(i, k, cur + notches * 0.02 * (max - min));
         let Some((now, ..)) = self.rows[i].control.as_ref().and_then(|c| c.slider_part(k)) else { return false };
         if (now - cur).abs() < 1e-6 {
             return false;
         }
         self.note_slider_change(i);
         true
     }
 
     /// Put the dragged slider where the pointer is along the captured band.
     /// Jumps, rather than dragging relative to a grab: the band has no thumb
     /// to grab, and a click on a scale should mean "this much".
     fn slide_to(&mut self, px: f32) -> bool {
         let Some(i) = self.slider_drag else { return false };
         let k = self.slider_part;
         let Some((old, min, max)) = self.rows.get(i).and_then(|r| r.control.as_ref()).and_then(|c| c.slider_part(k)) else {
             return false;
         };
         let (tx, tw) = self.slider_track;
         let t = ((px - tx) / tw).clamp(0.0, 1.0);
         self.set_slider_part(i, k, min + t * (max - min));
         let Some((now, ..)) = self.rows[i].control.as_ref().and_then(|c| c.slider_part(k)) else { return false };
         self.note_slider_change(i);
         now != old
     }
 
     /// Swap in a freshly ranked row list, keeping the selection in range.
     ///
     /// The selection goes back to the top rather than trying to follow the
     /// row it was on: the rows are re-ranked by the query, so "the same row"
     /// after a keystroke is a different one, and the best match being
     /// preselected is the whole point of ranking them.
     pub fn set_rows(&mut self, rows: Vec<Row>) {
         self.rows = rows;
         self.selected = 0;
         self.set_scroll_px(0.0);
         self.sync_color_selectors();
     }
 
     /// Hand a press or wheel on a colour row's band to its selector: the well
     /// begins a hex edit, the swatch opens the picker. The selector's rect is
     /// the band, set here because the band moves with the scroll.
     fn color_event(&mut self, i: usize, band: Rect, event: &Event, ectx: &mut EventCtx) -> bool {
         let id = self.rows[i].id.clone();
         let Some(k) = self.colors.iter().position(|(k, _)| *k == id) else { return false };
         let Some(ui) = ectx.ui.as_deref_mut() else { return false };
         let sel = &mut self.colors[k].1;
         WidgetHost::set_rect(sel, band.x, band.y, band.width, band.height);
         let taken = sel.handle_event(event, ui);
         self.drain_color_selectors();
         taken
     }
 }
 
 impl Layout for Dialog {
     /// Above every pane: the dialog is modal in practice — a press inside it never reaches what it
     /// covers — so it has to be drawn that way too.
     fn z_order(&self) -> i32 {
         900
     }
 
     /// The live dropdown into the context with the dialog. Not linked: the designer routes
     /// to it itself (`State::dialog_dropdown_event`).
     fn register_embedded_children(&mut self, _host_id: WidgetId, ctx: &mut UiContext) {
         self.dropdown.attach(ctx);
     }
 
     fn release_embedded_children(&mut self, ctx: &mut UiContext) {
         self.dropdown.detach(ctx);
     }
 }
 
 /// How wide `text` draws: shaped by the frame's own font system, as
 /// `Button::label_width` measures. `measure_text_width` resolves the family
 /// through usvg's font database and measured a choice's value some 8 px
 /// wider than it drew, which put the right arrow twice as far from it as
 /// the left; it is the fallback for a font system that shapes nothing.
 pub(crate) fn shaped_width(text: &str, family: &str, font_size: f32) -> f32 {
     cce_ui::geometry_font_system()
         .lock()
         .ok()
         .and_then(|mut fs| {
             cce_ui::backend::window_runner::shaped_cluster_offsets(&mut fs, text, font_size, Some(family))
                 .last()
                 .map(|&(_, total)| total)
         })
         .filter(|&w| w > 0.0)
         .unwrap_or_else(|| display::measure_text_width(text, family, font_size))
 }
 
 /// Paint `w` into `r` with its text re-emitted under the dialog's own bounds
 /// `own`. Painted twice, on purpose: a hosted widget's text has to carry the
 /// DIALOG's bounds or the occluder the dialog registers clamps it away, and a
 /// `PaintCtx` cannot be handed a prim back — the first pass lays down the
 /// geometry (its text lands inside the occluder and is clamped to nothing),
 /// the second is a scratch pass whose text alone is re-emitted retagged.
 fn paint_retagged(w: &dyn Paint, r: Rect, ctx: &mut PaintCtx, own: Option<[f32; 4]>) {
     Paint::paint(w, r, ctx);
     let mut scratch = PaintCtx::new();
     Paint::paint(w, r, &mut scratch);
     for item in scratch.finish().items {
         if let Prim::Text { text, x, y, font_size, color, font, .. } = item.prim {
             ctx.text_with(text, x, y, font_size, color, font, own);
         }
     }
 }
 
 impl Paint for Dialog {
     /// `paint` authors geometry AND text, so the Text prims pass through
     /// `paint_self` verbatim instead of the single-font own-labels bridge —
     /// the chord column needs its own family and its own clip bounds.
     fn paints_own_subtree(&self) -> bool {
         true
     }
 
     /// The dialog IS a menu plate: `Material::menu` — `style.surface.menu`'s
     /// colour, opacity and compression — the material the context menus
     /// wear, so the palette and a right-click menu are configured in one
     /// block and cannot drift apart. Until 2026-09-28 it was the parameter
     /// plate's fill with a backdrop compression of its own (a constant, and
     /// a `surface.dialog` config key), an in-app override the menus did not
     /// share.
     fn color(&self) -> [f32; 4] {
         cce_ui::scene::Material::menu().fill(cce_ui::scene::PlateRole::Nested)
     }
 
     /// A menu has no border: its edge is the rolled perimeter
     /// `context_menu::paint_menu_plate` draws.
     fn solid_border(&self) -> Option<([f32; 4], f32)> {
         None
     }
 
     fn corner_style(&self, _rect: Rect) -> Option<(f32, (bool, bool, bool, bool))> {
         let r = cce_ui::layout::menu_corner_radius();
         (r > 0.0).then_some((r, (true, true, true, true)))
     }
 
     /// The dialog's whole rect, as an occluder.
     ///
     /// Text is not painted in display-list order — the engine collects every
     /// Text prim and lays them all out at the end — so a plate drawn over a
     /// label does not hide it, whatever the z. What hides it is the
     /// popover-occlusion clamp, which reads `UiContext::active_popovers`; the
     /// designer registers every visible widget whose `popover_rect` is `Some`,
     /// so claiming one here is how the graph's node labels and the viewport's
     /// readouts stop bleeding through the plate.
     ///
     /// The clamp exempts text whose OWN bounds coincide with the occluder, so
     /// everything drawn inside the dialog carries these exact bounds and does
     /// its own truncating — the hosted colour selectors' text included, which
     /// is re-emitted retagged (see `paint`).
     ///
     /// **`occluding` exists because one claim serves two mechanisms that want
     /// opposite answers.** `UiContext::is_coordinate_covered` reads the same
     /// `popover_rect` — off every REGISTERED widget, not only the ones in
     /// `active_popovers` — to decide that a press has landed under something
     /// else. With the claim standing, every control inside the dialog is
     /// covered by the plate it is drawn on and nothing can be clicked.
     /// `State::dispatch_uncovered` lowers the flag for the length of a
     /// dispatch into the dialog and puts it straight back.
     fn popover(&self, rect: Rect) -> Option<(f32, f32, f32, f32)> {
         // While it turns, the plate as it is drawn: the labels are cut there.
         let r = self.drawn_rect(rect);
         self.occluding.then_some((r.x, r.y, r.width, r.height))
     }
 
     /// Without a context the live dropdown is reached only while the dialog holds it; a
     /// dialog in the context paints through `paint_ui`, which reaches it there.
     fn paint(&self, rect: Rect, ctx: &mut PaintCtx) {
         self.paint_with(self.dropdown.here(), rect, ctx);
     }
 
     fn paint_ui(&self, ui: &UiContext, rect: Rect, ctx: &mut PaintCtx) {
         self.paint_with(Some(self.dropdown.get(ui)), rect, ctx);
     }
 }
 
 impl Dialog {
     /// The dialog's paint, with the live dropdown when it can be reached.
     fn paint_with(&self, dropdown: Option<&Adapted<Dropdown>>, rect: Rect, ctx: &mut PaintCtx) {
         if rect.width <= 0.0 || rect.height <= 0.0 {
             return;
         }
         let open = dropdown.is_some_and(|d| d.open);
         let (family, font_size) = cce_ui::layout::control_label_font_parsed();
         let accent = colors::highlight_primary_color();
         let tint = [accent[0], accent[1], accent[2]];
         let depth = colors::plate_bevel_width();
         let ctrl_r = cce_ui::layout::control_corner_radius();
         let radii = (ctrl_r, ctrl_r, ctrl_r, ctrl_r);
         // The occlusion-clamp exemption (see `popover`): every label in here
         // carries the dialog's own rect, so none of them is clipped away by
         // the occluder the dialog itself registers. The cost is that bounds
         // no longer trim an overlong label, so the rows truncate by hand.
         let own = Some([rect.x, rect.y, rect.x + rect.width, rect.y + rect.height]);
         let cols_for = |width: f32| -> usize {
             (width / display::measure_text_width("M", &family, font_size).max(1.0)).floor() as usize
         };
         let fit = |text: &str, width: f32| -> String {
             if width <= 0.0 {
                 return String::new();
             }
             display::truncate_tail(text, cols_for(width))
         };
         // The same budget, cut from the other end — a path's tail is what
         // identifies it.
         let fit_head = |text: &str, width: f32| -> String {
             if width <= 0.0 {
                 return String::new();
             }
             display::truncate_head(text, cols_for(width))
         };
 
         // --- The query line: a well, like the text rows in the params pane.
         // The caret is a plain rule and does not blink: the dialog owns the
         // keyboard outright while it is open, so there is no focus to signal.
         // In AddNode the hint says what this opening of the plate is for;
         // there is no title band, so the two openings are the same height.
         let q = query_rect(rect);
         ctx.rounded_rect(q, ctrl_r, (true, true, true, true), [0.0, 0.0, 0.0, 0.22]);
         let qty = cce_ui::layout::align_text_y(q.y, q.height, font_size, 0.0);
         let qtx = q.x + 8.0;
         let q_w = q.width - 16.0;
         if self.query.is_empty() {
             let hint = fit(
                 match self.mode {
                     Mode::Commands => "Type to filter commands and settings",
                     Mode::AddNode => "Add Node: type to filter nodes",
                     Mode::Rename => "Rename: type the node's name",
                     Mode::Groups => "Group Markers: type to filter groups",
                 },
                 q_w,
             );
             ctx.text_with(hint, qtx, qty, font_size, [0x70, 0x70, 0x7c], Some(family.clone()), own);
         } else {
             // Head-truncated: what matters while typing is the end of the
             // query, which is where the caret is.
             let shown = display::truncate_head(&self.query, (q_w / display::measure_text_width("M", &family, font_size).max(1.0)).floor() as usize);
             ctx.text_with(shown, qtx, qty, font_size, [0xe6, 0xe6, 0xee], Some(family.clone()), own);
         }
         let caret_x = qtx + display::measure_text_width(&self.query, &family, font_size) + 1.0;
         // The query owns the keyboard while the palette is up: say so, so a
         // touch raises the on-screen keyboard. The field stands in for the
         // caret (and is off by the slide while the palette turns — brief, and
         // the board does not care where).
         cce_ui::text_input::claim(q.x, q.y, q.width, q.height);
         if caret_x < q.x + q.width - 4.0 {
             ctx.quad(
                 Rect { x: caret_x, y: q.y + 6.0, width: 1.0, height: q.height - 12.0 },
                 [accent[0], accent[1], accent[2], 0.9],
             );
         }
 
         // --- The rows. The chord column is right-aligned against the list's
         // right edge rather than padded out to a fixed width: the label is
         // what gets read, so it is the label that keeps the stable left edge.
         //
         // The switches get a column of their own at the far right, reserved
         // for EVERY row as soon as any row has one, so the chord column keeps
         // a straight edge whether or not the row beside it toggles. Without
         // the reservation the chords step left on toggle rows and the column
         // reads as ragged, which is worse than the strip of air it costs.
         let list = list_rect(rect);
         let toggle_col = self.toggle_col();
         if self.rows.is_empty() {
             let ty = cce_ui::layout::align_text_y(list.y, ROW_H, font_size, 0.0);
             let empty = match self.mode {
                 Mode::Commands => "No matching command or setting",
                 Mode::AddNode => "No matching node",
                 Mode::Rename => "No node to rename",
                 Mode::Groups => "No point group in the scene",
             };
             ctx.text_with(empty, list.x + 8.0, ty, font_size, [0x70, 0x70, 0x7c], Some(family.clone()), own);
             return;
         }
         ctx.clip(list, |ctx| {
         for i in self.first_row()..self.rows.len() {
             let Some(r) = self.row_rect(rect, i) else { break };
             let row = &self.rows[i];
             // The highlight stops short of the switch column. A switch has
             // no face of its own — it is carved out of whatever it stands
             // on, the DE's convention — and carved out of the selection's
             // tinted bevel it vanished outright: the selected row, the one
             // row whose state Enter is about to flip, was the one row whose
             // state could not be read. On the plate it reads like the rest.
             // A slider or colour row's control is wider than the toggle
             // column and takes the chord column's place on that one row.
             let ctl_col = if let Some(c) = row.is_slider().then(|| self.control_rect(r, row)).flatten() {
                 (r.x + r.width) - c.x + 4.0
             } else if row.is_color() {
                 (r.x + r.width) - self.slider_band_rect(r).x + 4.0
             } else {
                 toggle_col
             };
             let hl = Rect { width: (r.width - ctl_col).max(0.0), ..r };
             if i == self.selected {
                 ctx.rounded_rect(hl, ctrl_r, (true, true, true, true), [accent[0], accent[1], accent[2], 0.16]);
                 ctx.bevel_tinted(hl, radii, &cce_ui::scene::Material::from_fill([0.0; 4]), depth, tint);
             } else if self.hover_row == Some(i) {
                 ctx.rounded_rect(hl, ctrl_r, (true, true, true, true), [1.0, 1.0, 1.0, 0.05]);
             }
             let ty = cce_ui::layout::align_text_y(r.y, r.height, font_size, 0.0);
             let label_color = if i == self.selected { [0xf4, 0xf4, 0xfa] } else { [0xcc, 0xcc, 0xd4] };
             // What the chord column shows: the chord. A choice row shows a
             // dropdown in the control band instead, as a slider or a colour
             // row does.
             let (right_text, right_color) = match &row.control {
                 Some(Control::Choice { .. }) => (String::new(), label_color),
                 _ => (row.chord.clone(), [0x85, 0x85, 0x92]),
             };
             // A row that leads to another list ends in the page mark
             // (`refresh_dialog_rows`): drawn as the `chevron-right` glyph a
             // menu's page row wears, never as the character. Likewise the
             // back mark that leads a label (a visualizer's Back row) is the
             // `chevron-left` glyph, as a menu page's back band is.
             let (right_text, leads) = match right_text.strip_suffix(PAGE_MARK) {
                 Some(t) => (t.trim_end().to_string(), true),
                 None => (right_text, false),
             };
             let (label, back) = match row.label.strip_prefix(BACK_MARK) {
                 Some(rest) => (rest.trim_start(), true),
                 None => (row.label.as_str(), false),
             };
             let chev = (font_size * 0.8).round();
             let text_w = if right_text.is_empty() { 0.0 } else { shaped_width(&right_text, &family, font_size) };
             let right_w = text_w + if !leads { 0.0 } else if text_w > 0.0 { chev + GLYPH_GAP } else { chev };
             // The label's clip stops short of the chord column so a long
             // label is cut by it rather than running under it — or short of
             // the band, for a choice row.
             let chord_right = r.x + r.width - 8.0 - ctl_col;
             let label_right = match &row.control {
                 Some(Control::Choice { .. }) => self.slider_band_rect(r).x - 12.0,
                 _ => chord_right - if right_w > 0.0 { right_w + 12.0 } else { 0.0 },
             };
             let glyph_y = r.y + (r.height - chev) * 0.5;
             let glyph_color = |c: [u8; 3]| [c[0] as f32 / 255.0, c[1] as f32 / 255.0, c[2] as f32 / 255.0, 1.0];
             if back {
                 let at = Rect { x: r.x + 8.0, y: glyph_y, width: chev, height: chev };
                 ctx.icon("chevron-left", at, glyph_color(label_color));
             }
             let label_x = r.x + 8.0 + if back { chev + GLYPH_GAP } else { 0.0 };
             ctx.text_with(
                 if row.truncate_head {
                     fit_head(label, label_right - label_x)
                 } else {
                     fit(label, label_right - label_x)
                 },
                 label_x,
                 ty,
                 font_size,
                 label_color,
                 Some(family.clone()),
                 own,
             );
             if text_w > 0.0 {
                 ctx.text_with(right_text, chord_right - right_w, ty, font_size, right_color, Some(family.clone()), own);
             }
             if leads {
                 let at = Rect { x: chord_right - chev, y: glyph_y, width: chev, height: chev };
                 ctx.icon("chevron-right", at, glyph_color(right_color));
             }
             match &row.control {
                 Some(Control::Toggle(on)) => {
                     let tr = Rect {
                         x: r.x + r.width - 8.0 - TOGGLE_W,
                         y: r.y + (r.height - TOGGLE_H) * 0.5,
                         width: TOGGLE_W,
                         height: TOGGLE_H,
                     };
                     let mut stamps = self.toggle_stamps.borrow_mut();
                     stamps[*on as usize].set_hovered(self.hover_ctl == Some(i));
                     Paint::paint(&*stamps[*on as usize], tr, ctx);
                 }
                 Some(Control::Slider { value, min, max, dec, suffix, .. }) => {
                     let band = self.slider_band_rect(r);
                     {
                         let mut stamp = self.slider_stamp.borrow_mut();
                         stamp.set_range(*min, *max);
                         stamp.set_scaled_value(*value);
                         stamp.set_hovered(self.hover_ctl == Some(i));
                         Paint::paint(&**stamp, band, ctx);
                     }
                     // The readout, right-aligned in its lane ahead of the
                     // band — the dialog's own text, so it clears the
                     // occlusion clamp.
                     let readout = format!("{:.*}{}", *dec, value, suffix);
                     let rw = display::measure_text_width(&readout, &family, font_size);
                     ctx.text_with(
                         readout,
                         band.x - READOUT_GAP - rw,
                         ty,
                         font_size,
                         label_color,
                         Some(family.clone()),
                         own,
                     );
                 }
                 Some(Control::Color { .. }) => {
                     if let Some(sel) = self.color_selector(&row.id) {
                         let band = self.slider_band_rect(r);
                         // Painted twice, on purpose. The selector's hex text
                         // has to carry the DIALOG's bounds or the occluder
                         // the dialog registers clamps it away, and a
                         // `PaintCtx` cannot be handed a prim back: the first
                         // pass lays down the well and the swatch (its text
                         // lands inside the occluder and is clamped to
                         // nothing), the second is a scratch pass whose text
                         // alone is re-emitted retagged.
                         Paint::paint(&**sel, band, ctx);
                         let mut scratch = PaintCtx::new();
                         Paint::paint(&**sel, band, &mut scratch);
                         for item in scratch.finish().items {
                             if let Prim::Text { text, x, y, font_size, color, font, .. } = item.prim {
                                 ctx.text_with(text, x, y, font_size, color, font, own);
                             }
                         }
                     }
                 }
                 Some(Control::Choice { options, index }) => {
                     // The params pane's dropdown: the live one while this
                     // row's is open (it grows out of this trigger, painted
                     // over the rows below), else the shared stamp.
                     let band = self.slider_band_rect(r);
                     if let Some(dd) = dropdown.filter(|_| open && self.dropdown_row.as_deref() == Some(row.id.as_str())) {
                         paint_retagged(dd.inner(), band, ctx, own);
                     } else {
                         let mut stamp = self.dropdown_stamp.borrow_mut();
                         stamp.inner_mut().options = options.clone();
                         stamp.inner_mut().selected = *index;
                         paint_retagged(stamp.inner(), band, ctx, own);
                     }
                 }
                 None => {}
             }
         }
         });
 
         // The open dropdown's plate, grown out of its trigger over the rows
         // — after them, so it covers them. Its labels carry its own rect,
         // which `State::collect_display_list` registers as an occluder
         // AFTER the dialog's, so the dialog's labels under it are clamped
         // and its own are not.
         if let Some(dd) = dropdown.filter(|_| open && self.dropdown_trigger(rect).is_some()) {
             WidgetHost::render_popover(dd, ctx);
         }
 
         // The scrollbar's fore copy, over the rows, at the activity's fade:
         // pills, as `ScrollRegion::push_scrollbar_prims` and cce-mail's body
         // bar draw them. Driven by the fade rather than the latch so it
         // draws all the way out. The dialog's plate is the host's, so there
         // is no under-plate copy to show through while sunk — sunk is
         // simply not drawn, as cce-mail's body bar over its opaque window.
         let a = self.sb_activity.fade().clamp(0.0, 1.0);
         if a > 0.001 {
             if let Some((sb_x, track_y, sb_w, track_h, thumb_y, thumb_h)) = self.scrollbar_geom(rect) {
                 let dim = |mut c: [f32; 4]| {
                     c[3] *= a;
                     c
                 };
                 let all = (true, true, true, true);
                 ctx.rounded_rect(
                     Rect { x: sb_x, y: track_y, width: sb_w, height: track_h },
                     sb_w.min(track_h) * 0.5,
                     all,
                     dim(cce_ui::color::scrollbar_track_color()),
                 );
                 ctx.rounded_rect(
                     Rect { x: sb_x, y: thumb_y, width: sb_w, height: thumb_h },
                     sb_w.min(thumb_h) * 0.5,
                     all,
                     dim(cce_ui::color::scrollbar_thumb_color()),
                 );
             }
         }
     }
 }
 
 impl Input for Dialog {
     /// Advance the list's glide / coast (see `scroll_px`), and poll the
     /// colour selectors — a picker streams its values through a reader
     /// thread that only a tick can see.
     fn tick(&mut self, dt: f32, rect: Rect) -> bool {
         let max = self.max_scroll_px();
         self.scroll_motion.reconcile(0.0, self.scroll_px);
         let moved = self.scroll_motion.tick(dt, cce_ui::widget::Bounds::max(0.0), cce_ui::widget::Bounds::max(max));
         if moved {
             self.scroll_px = self.scroll_motion.y.pos();
         }
         // The bar's raise/sink latch and its fade: frames keep coming while
         // the hold runs and while the fore copy is still chasing the latch,
         // so the sink actually renders instead of freezing mid-fade.
         let visible = self.scrollbar_geom(rect).is_some();
         let flipped = self.sb_activity.tick(dt, visible, self.sb_dragging);
         let fade = self.sb_activity.fade();
         let fading = if self.sb_activity.raised() { fade < 1.0 } else { fade > 0.0 };
         let mut picking = false;
         for (_, sel) in &mut self.colors {
             picking |= Input::tick(sel.inner_mut(), dt, rect);
         }
         let colored = self.drain_color_selectors();
         // The open dropdown's grow and shrink is ticked in `tick_ctx`: it is the context's.
         let turning = self.turn_progress().is_some();
         moved || self.scroll_motion.is_animating() || flipped || self.sb_activity.holding() || fading || picking || colored || turning
     }
 
     /// The open dropdown's grow and shrink: frames while it runs, and a landed close settled
     /// back to a closed trigger — then out of sight again, so a closed one is no Tab stop.
     fn tick_ctx(&mut self, dt: f32, ectx: &mut EventCtx) -> bool {
         let rect = ectx.rect;
         let Some(ui) = ectx.ui.as_deref_mut() else { return false };
         let band = self.dropdown_trigger(rect).unwrap_or(rect);
         let dd = self.dropdown.get_mut(ui);
         let unfolding = dd.open && Input::tick(dd.inner_mut(), dt, band);
         let open = dd.open;
         if dd.visible() != open {
             dd.set_visible(open);
         }
         unfolding
     }
 
     /// The whole rect, always — this is what makes the dialog modal over what
     /// it covers: the designer's press cascade asks the dialog first and a hit
     /// never falls through to the pane underneath.
     fn hit(&self, rect: Rect, x: f32, y: f32) -> bool {
         x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height
     }
 
     fn on_event(&mut self, event: &Event, ectx: &mut EventCtx) -> bool {
         let rect = ectx.rect;
         match event {
             Event::MouseButton { button: MouseButton::Left, state: ElementState::Pressed, x, y, .. } => {
                 // The raised bar is in front of the rows; sunk, it is not
                 // there and the press reaches the row.
                 if self.sb_press(rect, *x, *y) {
                     return true;
                 }
                 if let Some(i) = self.row_at(rect, *x, *y) {
                     self.selected = i;
                     let r = self.row_rect(rect, i);
                     if self.rows[i].is_slider() {
                         // On the band: take hold and jump there. On the
                         // rest of the row — the readout lane included:
                         // selected, and nothing to run. A press tests the
                         // BAND rather than the whole control, or a click
                         // on the readout would jump the value to the end
                         // of the range nearest it.
                         if let Some((k, band)) = r.and_then(|r| self.slider_part_at(r, i, *x, true)) {
                             self.slider_track = (band.x, band.width);
                             self.slider_drag = Some(i);
                             self.slider_part = k;
                             self.slide_to(*x);
                         }
                         return true;
                     }
                     if self.rows[i].is_color() {
                         // On the band: the selector's — a hex edit or the
                         // picker. Elsewhere on the row: selected, nothing
                         // to run.
                         if let Some(r) = r {
                             let s = self.slider_band_rect(r);
                             if *x >= s.x && *x < s.x + s.width {
                                 self.color_event(i, s, event, ectx);
                             }
                         }
                         return true;
                     }
                     self.activated = self.rows.get(i).map(|r| r.id.clone());
                     return true;
                 }
                 // Inside the plate but on no control: consumed anyway, so the
                 // press cannot reach the pane the dialog is covering.
                 true
             }
             Event::MouseButton { button: MouseButton::Left, state: ElementState::Released, .. } => {
                 if self.slider_drag.take().is_some() {
                     return true;
                 }
                 if std::mem::take(&mut self.sb_dragging) {
                     // The release starts the hold before the bar sinks.
                     self.sb_activity.bump();
                     return true;
                 }
                 false
             }
             Event::PointerMove { x, y, .. } => {
                 if self.slider_drag.is_some() {
                     return self.slide_to(*x);
                 }
                 if self.sb_dragging {
                     return self.sb_drag_to(rect, *y);
                 }
                 self.sb_activity.set_hover(self.over_scrollbar(rect, *x, *y));
                 let row = self.row_at(rect, *x, *y);
                 let ctl = row.filter(|&i| {
                     self.row_rect(rect, i)
                         .and_then(|r| self.control_rect(r, &self.rows[i]))
                         .is_some_and(|c| *x >= c.x && *x < c.x + c.width && *y >= c.y && *y < c.y + c.height)
                 });
                 let part = ctl
                     .and_then(|i| self.row_rect(rect, i).and_then(|r| self.slider_part_at(r, i, *x, false)))
                     .map_or(0, |(k, _)| k);
                 let changed = row != self.hover_row || ctl != self.hover_ctl || part != self.hover_part;
                 self.hover_row = row;
                 self.hover_part = part;
                 if ctl != self.hover_ctl {
                     // A colour well is a widget of its own: told the way
                     // the runner tells any widget.
                     for (i, entering) in [(self.hover_ctl, false), (ctl, true)] {
                         let Some(i) = i else { continue };
                         if self.rows.get(i).is_some_and(Row::is_color) {
                             if let Some(band) = self.row_rect(rect, i).map(|r| self.slider_band_rect(r)) {
                                 let ev = if entering { Event::MouseEnter } else { Event::MouseLeave };
                                 self.color_event(i, band, &ev, ectx);
                             }
                         }
                     }
                     self.hover_ctl = ctl;
                 }
                 changed
             }
             Event::MouseWheel { delta, x, y, .. } => {
                 if self.rows.is_empty() {
                     return false;
                 }
                 // Over a slider row's control the wheel turns the slider,
                 // not the list — the rest of the row still scrolls.
                 if let Some(i) = self.row_at(rect, *x, *y) {
                     if let Some((k, _)) = self.row_rect(rect, i).and_then(|r| self.slider_part_at(r, i, *x, false)) {
                         // Up is more, for a wheel and for a finger alike
                         // (`value_notches_y`).
                         return self.scroll_slider(i, k, delta.value_notches_y());
                     }
                 }
                 // The DE scroll model: a notch is one row and glides there, a
                 // trackpad tracks 1:1 and coasts on the lift (`tick` advances).
                 let max = self.max_scroll_px();
                 self.scroll_motion.reconcile(0.0, self.scroll_px);
                 let moved = self.scroll_motion.apply(
                     delta,
                     (ROW_H, ROW_H),
                     cce_ui::widget::Bounds::max(0.0),
                     cce_ui::widget::Bounds::max(max),
                 );
                 self.scroll_px = self.scroll_motion.y.pos();
                 // A scroll raises the bar and starts its hold.
                 self.sb_activity.bump();
                 moved || self.scroll_motion.is_animating()
             }
             _ => false,
         }
     }
 
     // A slider drag rides the app's widget-drag protocol (armed by
     // `State::dialog_mouse_input` once a press has taken a band), so the
     // pointer keeps moving the value after it leaves the plate, as a params
     // pane slider's does.
     fn draggable(&self, _rect: Rect) -> bool {
         self.slider_drag.is_some()
     }
     fn is_dragging(&self) -> bool {
         self.slider_drag.is_some()
     }
     fn drag_begin(&mut self, px: f32, _py: f32, _rect: Rect) {
         self.slide_to(px);
     }
     fn drag_update(&mut self, px: f32, _py: f32, _rect: Rect) -> bool {
         self.slide_to(px)
     }
     fn drag_end(&mut self) {
         self.slider_drag = None;
     }
 }
 
 // ---------------------------------------------------------------------------
 // The designer's half: what the dialog shows, and what choosing a row does.
 // ---------------------------------------------------------------------------
 
 use crate::app::State;
 use crate::command::Context;
 use crate::slots::DIALOG_IDX;
 
 /// The list's zoom row: not a registry command but a control — a slider
 /// over the network zoom, present only while the network pane is focused,
 /// since zoom is that pane's and a slider for a pane you are not looking at
 /// would be a strange thing to offer. Picking it runs nothing; dragging it,
 /// or the arrow keys while it is selected, zoom in place with the dialog
 /// up, the way the toggle rows stay up.
 pub const ZOOM_ROW_ID: &str = "zoom_level";
 
 /// The list's other non-command row: the open project's PATH, with its file
 /// name in the chord column the way a command's chord sits there — the
 /// palette's readout of what is being edited. Picking it copies the path to
 /// the clipboard, which is the one thing anyone wants a path on screen for.
 /// It heads the list, where it reads as the document the rest of the
 /// commands act on.
 pub const PATH_ROW_ID: &str = "project_path";
 
 /// Prefix of a recent-project row's id; the rest is the path.
 ///
 /// The recent list was the Main utility node's "Open" dropdown, and it went
 /// with that node — leaving `State::recent_files` written on every save and
 /// read by nothing. It is a list of documents, so it belongs where the open
 /// document's own path already is: rows under the path row, each opening its
 /// project. Ranked against the path text like everything else.
 pub const RECENT_ROW_PREFIX: &str = "recent:";
 /// The one row of [`Mode::Rename`].
 pub const RENAME_ROW_ID: &str = "rename:";
 /// A camera NODE of the current level, as a palette row: picking it looks
 /// through that camera. The Default Camera is a registry command instead
 /// (`default_camera`), there being always exactly one.
 pub const CAMERA_ROW_PREFIX: &str = "camera:";
 
 /// A row of [`Mode::Groups`]: the prefix, then the group's name.
 pub const GROUP_ROW_PREFIX: &str = "group:";
 
 /// How many recent projects the list offers. `recent_files` keeps ten; five
 /// is what fits above the commands without the palette reading as a file
 /// manager, and a query narrows the rest.
 pub const RECENT_ROW_LIMIT: usize = 5;
 
 /// Prefix of a setting row's id; the rest is the [`Setting`]'s label, which
 /// is unique across the table (`dialog_settings_labels_are_unique`).
 pub const SETTING_ROW_PREFIX: &str = "setting:";
 
 pub fn setting_row_id(label: &str) -> String {
     format!("{SETTING_ROW_PREFIX}{label}")
 }
 
 /// The setting a row id names, if it is a setting row.
 pub fn setting_of_row(id: &str) -> Option<&'static Setting> {
     let label = id.strip_prefix(SETTING_ROW_PREFIX)?;
     SETTINGS.iter().find(|s| s.label == label)
 }
 
 /// Where a setting row's value lives.
 ///
 /// It used to be neither the live `State` fields nor `DesignSettings`: both
 /// were DOWNSTREAM of the root meta node, whose utility subnets were copied
 /// over live state on every param change, so a write straight to
 /// `State::grid_thickness` survived exactly until the next one. With that
 /// node retired the live field IS the value, and it is the one kind of owner
 /// left. (A toggle the command registry owns went when the settings joined
 /// the commands list: those toggles ARE command rows there, and a second row
 /// for each would have listed every switch twice. A param on the ACTIVE
 /// camera, the Camera Pivot Size row's, went on 2026-09-30: no camera node
 /// has the param, so the row only ever wrote the live field, which the
 /// viewport menu's slider sets.)
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Owner {
     /// A display setting the app owns outright: a live field on `State`,
     /// persisted by `DesignSettings` into `state.kdl`. Named by the key
     /// `settings_field_*` dispatch on.
     Field(&'static str),
 }
 
 /// The control a [`Setting`] row draws.
 ///
 /// A bare Rust field carries no type and no range the way a param did, so
 /// the table spells it; the row's [`Control`] is built from it and the live
 /// value. The value strings are the params pane's encodings, so a setting
 /// reads and writes the way a node parameter of the same shape does.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Ctl {
     Toggle,
     /// `#rrggbb`.
     Color,
     /// A whole number over `min..=max`. The stored float is scaled by
     /// `unit` (thousandths for Grid Thickness, tenths for Origin Size),
     /// which is the convention those params already used.
     Spin { min: f32, max: f32, unit: f32 },
     /// A float slider, `min..=max`, shown to `dec` decimals.
     Slider { min: f32, max: f32, dec: usize },
     /// A fixed set of strings.
     Choice(&'static [&'static str]),
 }
 
 /// One setting row of the list.
 pub struct Setting {
     /// What the dialog calls it — and the row's identity: the row id is
     /// the label under [`SETTING_ROW_PREFIX`], and the writeback resolves
     /// it back to this row. Unique across the table.
     pub label: &'static str,
     pub owner: Owner,
     pub ctl: Ctl,
 }
 
 impl Setting {
     /// A row over a live field.
     const fn field(label: &'static str, key: &'static str, ctl: Ctl) -> Self {
         Setting { label, owner: Owner::Field(key), ctl }
     }
 }
 
 /// The setting rows, in the order an empty query lists them.
 ///
 /// Scope is exactly what `DesignSettings` persists: the DISPLAY state, which
 /// is the part of the app's configuration that is a preference rather than
 /// part of a project. The four utility subnets under the root meta node
 /// (`main`, `view`, `guides`, `render`) held these values until 2026-09-23,
 /// and every one of them that was reachable only by selecting one of those
 /// nodes is a row here or a command in the registry. Anything left out would
 /// not be "hidden in the node tree", it would be gone —
 /// `every_retired_subnet_setting_is_reachable` is the backstop.
 ///
 /// The TOGGLES those subnets held (Show Grid, Show Wireframe, Square Aspect
 /// …) are not here: each is a registry command with a switch on its own
 /// row, and this table lists what is not a command. Still deliberately NOT
 /// here either: the pane-visibility toggles (commands too), the active
 /// camera (the viewport menubar's own menu, whose entries are the camera
 /// NODES and so cannot be a fixed table), and keybindings, which this DE
 /// edits as `input.kdl` on purpose.
 pub const SETTINGS: &[Setting] = &[
     Setting::field("Background Color", "bg_color", Ctl::Color),
     Setting::field("World Unit", "world_unit", Ctl::Choice(&["mm", "cm", "m", "in"])),
     // How the network's node wires run — not the wireframe's wires below.
     Setting::field("Node Wire Style", "node_wire_style", Ctl::Choice(&["Orthogonal", "Rounded", "Bezier", "Straight"])),
     // Takes effect at the next launch — the renderer's device is chosen
     // once, when it is created (`app::apply_gpu_preference`).
     Setting::field("GPU", "gpu", Ctl::Choice(crate::app::GPU_CHOICES)),
     Setting::field("Geometry Opacity", "geo_opacity", Ctl::Slider { min: 0.0, max: 1.0, dec: 2 }),
     // The colour applies only in single-colour mode (off, the wires carry
     // the geometry's vertex colours) — so a colour edit turns that mode on,
     // or a colour set here looks ignored.
     Setting::field("Wireframe Color", "wire_color", Ctl::Color),
     // The wires' own opacity, in both colour modes; Geometry Opacity is the
     // polygons'. It was the wire colour's alpha until 2026-09-25.
     Setting::field("Wire Opacity", "wire_opacity", Ctl::Slider { min: 0.0, max: 1.0, dec: 2 }),
     Setting::field("Wire Thickness", "wire_width", Ctl::Slider { min: 1.0, max: 8.0, dec: 1 }),
     // The Selected-Group markers' radius, in world units.
     Setting::field("Group Marker Size", "group_marker_size", Ctl::Slider { min: 0.0, max: crate::app::GROUP_MARKER_SIZE_MAX, dec: 3 }),
     // The pull arrows' length over the true displacement; 1 is the vector
     // as it is.
     Setting::field("Pull Arrow Scale", "pull_arrow_scale", Ctl::Slider { min: 0.25, max: 10.0, dec: 2 }),
     // In world units, as Group Marker Size is, and as the viewport menu's
     // slider always read it: until 2026-09-29 this row was a spin in
     // THOUSANDTHS (5..100), so the two sizes read as different numbers for
     // one radius, and 0.025 typed here landed on the spin's floor.
     Setting::field("Point Marker Size", "point_marker_size", Ctl::Slider { min: 0.005, max: 0.1, dec: 3 }),
     Setting::field("Point Marker Color", "point_marker_color", Ctl::Color),
     Setting::field("Grid Color", "grid_color", Ctl::Color),
     Setting::field("Grid Thickness", "grid_thickness", Ctl::Spin { min: 2.0, max: 200.0, unit: 1000.0 }),
     Setting::field("Origin Size", "origin_size", Ctl::Spin { min: 1.0, max: 50.0, unit: 10.0 }),
 ];
 
 /// The page mark, as a menu's page row wears it, and the back mark a menu
 /// page's back band leads with. Both ride the row's TEXT (the chord and the
 /// label) and are drawn as cce-icons chevrons by the row painter.
 pub use cce_ui::widget::context_menu::{BACK_MARK, PAGE_MARK};
 
 /// The gap between a row's chevron glyph and the text beside it — the
 /// toolkit menu's own.
 const GLYPH_GAP: f32 = 6.0;
 
 /// Whether a row of the dialog in `mode` turns it into another list: the
 /// palette's Group Markers. A press runs it, as before; a side swipe forward
 /// with the pointer on it does too. (Attribute Visualizers led into the
 /// dialog's visualizer list until 2026-10-06; they are edited in the params
 /// HUD now, and the row closes the palette and opens them there.)
 pub fn dialog_row_leads(mode: Mode, id: &str) -> bool {
     match mode {
         Mode::Commands => matches!(id, "group_markers"),
         _ => false,
     }
 }
 
 impl State {
     pub fn dialog_visible(&self) -> bool {
         self.ui_context[self.slots.dialog].visible()
     }
 
     pub fn toggle_dialog(&mut self) {
         if self.dialog_visible() && self.ui_context[self.slots.dialog].mode == Mode::Commands {
             self.close_dialog();
         } else {
             self.open_dialog();
         }
     }
 
     /// Open the dialog on its commands-and-settings list — `Alt+D`, and what
     /// `Ctrl+P` reaches instead of spawning a popup process.
     pub fn open_dialog(&mut self) {
         self.open_dialog_in(Mode::Commands);
     }
 
     /// The add-node palette: the same plate, one list, and a pick that
     /// instantiates a template at the grid cursor.
     ///
     /// Was a `cce-cloud --dmenu` popup — a second process with its own
     /// window, fed one line of text per row and answering with one line back.
     /// It could not show a chord in a column of its own, could not be styled
     /// with the app, and put a second filterable list in front of the user
     /// that looked nothing like the first.
     pub fn open_node_palette(&mut self) {
         if self.dialog_visible() && self.ui_context[self.slots.dialog].mode == Mode::AddNode {
             self.close_dialog();
             return;
         }
         self.open_dialog_in(Mode::AddNode);
     }
 
     /// The add-node palette opened where the network menu stood, by that
     /// menu's Add Node row: the menu TRANSFORMS into the list, as the
     /// palette transforms into Group Markers. The two plates are one
     /// material (`paint_menu_plate`), so the list taking the menu's corner
     /// is what makes it read as the same plate grown, not a second one
     /// arriving across the window.
     pub fn open_node_palette_at(&mut self, x: f32, y: f32) {
         self.open_dialog_from(Mode::AddNode, crate::menu_page::MenuOrigin::Network, (x, y));
     }
 
     /// The dialog in `mode`, turned to from the menu `origin` by one of its
     /// page rows: its top-left where the menu's was, and a swipe back shows
     /// the menu again (see `crate::menu_page`).
     ///
     /// The plate grows out of the menu just put down: its size is what the
     /// context menu still holds after the hide.
     pub fn open_dialog_from(&mut self, mode: Mode, origin: crate::menu_page::MenuOrigin, at: (f32, f32)) {
         use cce_ui::widget::context_menu;
         let from = Rect { x: at.0, y: at.1, width: context_menu::w(), height: context_menu::h() };
         self.close_dialog();
         self.open_dialog_anchored(mode, Some(at));
         self.dialog_from = Some(origin);
         self.ui_context[self.slots.dialog].turning = Some(DialogTurn { from: Some(from), start: std::time::Instant::now(), dir: 1.0 });
     }
 
     /// Turn the open dialog to `mode`, as the row or key that leads there
     /// does.
     pub(crate) fn open_dialog_mode(&mut self, mode: Mode) {
         self.open_dialog_in(mode);
     }
 
     /// Wire the node just added (the level's last) into the wire from the
     /// node `src_id` to `dest_id`, and say so. A node with no Input — a
     /// generator — is left unwired: it cannot sit mid-chain.
     fn splice_new_node(&mut self, src_id: &str, dest_id: &str) {
         let dir = self.current_dir();
         let (Some(new), Some(src)) = (dir.children.last(), dir.children.iter().find(|c| c.id == src_id)) else { return };
         let (new_id, new_name, src_name) = (new.id.clone(), new.name.clone(), src.name.clone());
         if crate::app::splice_into_wire(self.current_dir_mut(), &new_id, src_name.clone(), dest_id) {
             self.sync_nodes();
             self.rebuild_scene_geometry();
             self.sync_parameters_pane();
             let dest = self.current_dir().children.iter().find(|c| c.id == dest_id).map(|c| c.name.clone()).unwrap_or_default();
             self.update_status_text(&format!("Added {new_name} between {src_name} and {dest}."));
         }
     }
 
     /// Open the dialog to rename the node in `slot` of the current level.
     /// The query line is the name: it opens holding the one the node has,
     /// so a rename that changes a letter is a letter typed.
     pub fn open_rename_dialog(&mut self, slot: usize) {
         self.open_rename_dialog_from(slot, None);
     }
 
     /// [`Self::open_rename_dialog`], turned to from a menu's Rename row
     /// standing at a corner, when `from` says so.
     pub fn open_rename_dialog_from(&mut self, slot: usize, from: Option<(crate::menu_page::MenuOrigin, (f32, f32))>) {
         let Some((id, name)) = self.current_dir().children.get(slot).map(|n| (n.id.clone(), n.name.clone())) else {
             self.update_status_text("Select a node to rename.");
             return;
         };
         self.rename_target = Some(id);
         match from {
             Some((origin, at)) => self.open_dialog_from(Mode::Rename, origin, at),
             None => self.open_dialog_in(Mode::Rename),
         }
         self.ui_context[self.slots.dialog].query = name;
         self.refresh_dialog_rows();
     }
 
     /// The Group Markers list: the `group_markers` command. From the
     /// palette this is the palette transformed — the same plate, with the
     /// groups where the commands were.
     pub fn open_group_markers_dialog(&mut self) {
         self.open_dialog_in(Mode::Groups);
     }
 
     /// What renaming the dialog's node to `typed` would do: the name it
     /// has and the one it would get, or why not. None when the node is
     /// gone.
     pub fn rename_outcome(&self, typed: &str) -> Option<Result<(String, String), String>> {
         let id = self.rename_target.as_ref()?;
         let node = crate::viewer_state::find_node_by_id(&self.fs_root, id)?;
         Some(self.rename_check(id, typed).map(|new| (node.name.clone(), new)))
     }
 
     fn open_dialog_in(&mut self, mode: Mode) {
         self.open_dialog_anchored(mode, None);
     }
 
     fn open_dialog_anchored(&mut self, mode: Mode, anchor: Option<(f32, f32)>) {
         // A dialog that is up and turns to another mode stays where it
         // stands, turned to from where it was: the mode it leaves goes on
         // the trail a swipe back follows — or, when the mode it turns to IS
         // the trail's last, it is going back, and comes off. Opened afresh
         // it has neither, and whoever opened it from a menu says so after.
         let was = self.dialog_visible().then_some(self.ui_context[self.slots.dialog].mode);
         self.ui_context[self.slots.dialog].turning = None;
         match was {
             Some(prev) if anchor.is_none() => {
                 // The same plate turned to another list: the rows slide in,
                 // from the right going on, from the left coming back.
                 let dir = if self.dialog_trail.last() == Some(&mode) {
                     self.dialog_trail.pop();
                     Some(-1.0)
                 } else if prev != mode {
                     self.dialog_trail.push(prev);
                     Some(1.0)
                 } else {
                     None
                 };
                 self.ui_context[self.slots.dialog].turning = dir.map(|dir| DialogTurn { from: None, start: std::time::Instant::now(), dir });
             }
             _ => {
                 self.ui_context[self.slots.dialog].anchor = anchor;
                 self.dialog_trail.clear();
                 self.dialog_from = None;
             }
         }
         // Always with an empty query: a dialog that reopens holding the last
         // search has to be cleared before it can be used, which is a step
         // every single time to save one occasionally.
         self.ui_context[self.slots.dialog].mode = mode;
         self.ui_context[self.slots.dialog].query.clear();
         self.ui_context[self.slots.dialog].set_visible(true);
         self.refresh_dialog_rows();
         self.rebuild_positions();
         self.apply_layout();
         // Modal: the panes lose the pointer while it is up.
         self.broadcast_pointer();
         self.update_status_text(match mode {
             Mode::Commands => "Dialog: type to filter commands and settings, Escape closes.",
             Mode::AddNode => "Add Node: type to filter, Enter adds at the cursor, Escape closes.",
             Mode::Rename => "Rename: type the name, Enter renames, Escape closes.",
             Mode::Groups => "Group Markers: Enter or a click marks a group's points in the scene, Escape closes.",
         });
     }
 
     pub fn close_dialog(&mut self) {
         if !self.dialog_visible() {
             return;
         }
         // Shut, not animated: with the dialog gone there is nothing to
         // shrink into, and a plate still reporting itself open would keep
         // covering presses meant for the panes.
         let dd = self.dialog_dd();
         self.ui_context[dd].inner_mut().open = false;
         self.ui_context[dd].set_visible(false);
         self.ui_context[self.slots.dialog].dropdown_row = None;
         self.ui_context[self.slots.dialog].dropdown_armed = false;
         self.ui_context[self.slots.dialog].set_visible(false);
         self.dialog_from = None;
         self.dialog_trail.clear();
         if self.focused_widget == Some(DIALOG_IDX) {
             self.focused_widget = None;
         }
         self.rebuild_positions();
         self.apply_layout();
         // The pane under the pointer hovers again without a motion.
         self.broadcast_pointer();
     }
 
     /// Re-rank the row list against the current query, for whichever mode is
     /// up.
     ///
     /// Commands and settings rank together through the one
     /// [`crate::command::fuzzy_rank`], with the focused pane's commands
     /// partitioned to the front as [`crate::command::palette_entries`] does
     /// (a setting belongs to no pane, so it ranks among the rest). Node
     /// templates rank through the same function, so typing means the same
     /// thing in every list; they carry no chord, so the column is simply
     /// empty for them.
     pub fn refresh_dialog_rows(&mut self) {
         let query = self.ui_context[self.slots.dialog].query.clone();
         let rows: Vec<Row> = match self.ui_context[self.slots.dialog].mode {
             // One row, which is what Enter will do: the name as it will be
             // written, or why it will not be.
             Mode::Rename => match self.rename_outcome(&query) {
                 Some(Ok((old, new))) => vec![Row::plain(RENAME_ROW_ID, format!("Rename {old} to {new}"), "")],
                 Some(Err(why)) => vec![Row::plain(RENAME_ROW_ID, why, "")],
                 None => vec![],
             },
             Mode::Commands => {
                 let cmds = crate::command::COMMANDS;
                 // The level's camera nodes rank among the commands, as
                 // the viewport's: "Camera: camera1".
                 let cameras: Vec<String> = self.camera_names().into_iter().skip(1).collect();
                 let camera_labels: Vec<String> = cameras.iter().map(|n| format!("Camera: {n}")).collect();
                 let mut labels: Vec<&str> = cmds.iter().map(|c| c.label).collect();
                 labels.extend(SETTINGS.iter().map(|s| s.label));
                 labels.extend(camera_labels.iter().map(|l| l.as_str()));
                 let contexts: Vec<Context> = cmds
                     .iter()
                     .map(|c| c.context)
                     .chain(SETTINGS.iter().map(|_| Context::Always))
                     .chain(cameras.iter().map(|_| Context::Viewport))
                     .collect();
                 let ranked = crate::command::rank_with_focus(&query, &labels, &contexts, self.focused_context());
                 let mut rows: Vec<Row> = ranked
                     .into_iter()
                     .map(|i| {
                         if i < cmds.len() {
                             let c = &cmds[i];
                             Row {
                                 id: c.id.to_string(),
                                 label: c.label.to_string(),
                                 chord: self
                                     .shortcut_manager
                                     .chord_for(c.id)
                                     .map(|s| s.describe())
                                     .unwrap_or_default(),
                                 control: self.command_toggle_state(c.id).map(Control::Toggle),
                                 truncate_head: false,
                             }
                         } else if i < cmds.len() + SETTINGS.len() {
                             self.setting_row(&SETTINGS[i - cmds.len()])
                         } else {
                             let at = i - cmds.len() - SETTINGS.len();
                             let active = cameras[at] == self.active_camera;
                             Row {
                                 id: format!("{CAMERA_ROW_PREFIX}{}", cameras[at]),
                                 label: camera_labels[at].clone(),
                                 // The column a chord would use says which
                                 // camera the viewport is looking through.
                                 chord: if active { "active".to_string() } else { String::new() },
                                 control: None,
                                 truncate_head: false,
                             }
                         }
                     })
                     .collect();
                 // The open project's path heads the list — ranked against
                 // the path text, so typing any part of it (the project's
                 // name included, that being the tail) finds or drops the row
                 // like any other. Absent when no project is loaded: the
                 // bundled `default_project.json` leaves `loaded_project_path`
                 // None on purpose, and a row offering to copy a path to a
                 // versioned file in the source tree would be a trap.
                 if let Some((path, name)) = self.project_path_readout() {
                     if !crate::command::fuzzy_rank(&query, &[path.as_str()]).is_empty() {
                         rows.insert(
                             0,
                             Row { id: PATH_ROW_ID.to_string(), label: path, chord: name, control: None, truncate_head: true },
                         );
                     }
                 }
                 // The recent projects, under the path row — the open
                 // document, then the ones before it. The project already
                 // open is not offered again.
                 let open_now = self.loaded_project_path.clone();
                 let recent: Vec<std::path::PathBuf> = self
                     .recent_files
                     .iter()
                     .filter(|p| Some(*p) != open_now.as_ref())
                     .take(RECENT_ROW_LIMIT)
                     .cloned()
                     .collect();
                 for path in recent.iter().rev() {
                     let text = path.to_string_lossy().to_string();
                     if crate::command::fuzzy_rank(&query, &[text.as_str()]).is_empty() {
                         continue;
                     }
                     let name = path
                         .file_name()
                         .map(|n| n.to_string_lossy().to_string())
                         .unwrap_or_default();
                     rows.insert(
                         0,
                         Row {
                             id: format!("{RECENT_ROW_PREFIX}{text}"),
                             label: text,
                             chord: name,
                             control: None,
                             // Same reason as the path row: the tail of a
                             // path is what identifies it.
                             truncate_head: true,
                         },
                     );
                 }
                 // The zoom slider heads the network pane's list, ranked like
                 // a row labelled "Zoom" so a query still finds (or drops) it.
                 if self.focused_context() == Context::Network
                     && !crate::command::fuzzy_rank(&query, &["Zoom"]).is_empty()
                 {
                     rows.insert(
                         0,
                         Row {
                             id: ZOOM_ROW_ID.to_string(),
                             label: "Zoom".to_string(),
                             chord: String::new(),
                             control: Some(self.zoom_control()),
                             truncate_head: false,
                         },
                     );
                 }
                 rows
             }
             // The scene's point groups, ranked by name, a switch each and the
             // member count in the chord column.
             Mode::Groups => {
                 let names: Vec<&str> = self.scene_groups.iter().map(|(n, _)| n.as_str()).collect();
                 crate::command::fuzzy_rank(&query, &names)
                     .into_iter()
                     .map(|i| {
                         let (name, members) = &self.scene_groups[i];
                         Row {
                             id: format!("{GROUP_ROW_PREFIX}{name}"),
                             label: name.clone(),
                             chord: format!("{} point{}", members.len(), if members.len() == 1 { "" } else { "s" }),
                             control: Some(Control::Toggle(self.group_marked(name))),
                             truncate_head: false,
                         }
                     })
                     .collect()
             }
             Mode::AddNode => {
                 // The templates that may stand at this level: at the root
                 // the Geometry node, cameras and pages; inside a geometry
                 // node everything but the first two (`context::placement`).
                 // The settings directories that refused geometry once were
                 // the root meta node's utility subnets, and they are gone.
                 let here = crate::context::context_at(&self.current_path);
                 let offered: Vec<&str> = self
                     .node_templates
                     .iter()
                     .filter(|t| crate::context::fits(crate::context::placement(&t.node.node_type), here))
                     .map(|t| t.label.as_str())
                     .collect();
                 crate::command::fuzzy_rank(&query, &offered)
                     .into_iter()
                     .map(|i| Row::plain(offered[i], offered[i], ""))
                     .collect()
             }
         };
         // A row that turns the dialog into another list says so where a
         // menu's page row does, at its right end.
         let mode = self.ui_context[self.slots.dialog].mode;
         let rows = rows
             .into_iter()
             .map(|mut r| {
                 if dialog_row_leads(mode, &r.id) {
                     r.chord = if r.chord.is_empty() { PAGE_MARK.to_string() } else { format!("{}  {PAGE_MARK}", r.chord) };
                 }
                 r
             })
             .collect();
         self.ui_context[self.slots.dialog].set_rows(rows);
     }
 
     /// The open project's path and its file name, for the palette's path row
     /// — `None` when no project is loaded.
     ///
     /// The name is `file_name()`, which is the same thing the WINDOW TITLE
     /// shows, so the palette and the title bar cannot disagree about what is
     /// open. A project is a DIRECTORY holding `state.json`, so that name is
     /// the directory's; the bundled `default_project.json` is the one single
     /// file, and it never gets here because loading it leaves
     /// `loaded_project_path` None — the app's own position is that nothing is
     /// loaded, and Set As Default says the same.
     pub fn project_path_readout(&self) -> Option<(String, String)> {
         let path = self.loaded_project_path.as_ref()?;
         let name = path.file_name()?.to_string_lossy().into_owned();
         Some((path.to_string_lossy().into_owned(), name))
     }
 
     /// Put the open project's path on the clipboard, returning what was
     /// copied — the palette's path row, and the only thing a path on screen
     /// is ever wanted for. `None` when there is no project to name.
     pub fn copy_project_path(&mut self) -> Option<String> {
         let (path, _) = self.project_path_readout()?;
         // Not under test. `wl-copy` has to OUTLIVE its caller to serve the
         // selection, and it inherits the test binary's captured stdout — so a
         // test that really copied left cargo waiting on a pipe held open by a
         // clipboard daemon, which looks exactly like a hung test suite.
         #[cfg(not(test))]
         cce_ui::widget::clipboard::copy_to_clipboard(&path);
         self.update_status_text(&format!("Copied {path}"));
         Some(path)
     }
 
     /// The network zoom as the slider row reads it: the current x pitch as a
     /// percentage of the configured one, so 100 is Reset Zoom.
     pub fn zoom_percent(&self) -> f32 {
         let cfg = crate::app::configured_grid_geometry();
         if cfg.pitch_x > 0.0 {
             self.grid_pitch_x / cfg.pitch_x * 100.0
         } else {
             100.0
         }
     }
 
     /// The zoom row's control: the live percentage over the pitch limits,
     /// nudged ten points at a time.
     fn zoom_control(&self) -> Control {
         let cfg = crate::app::configured_grid_geometry();
         let pct = |pitch: f32| pitch / cfg.pitch_x.max(1e-3) * 100.0;
         Control::Slider {
             value: self.zoom_percent(),
             min: pct(crate::app::MIN_PITCH_X),
             max: pct(crate::app::MAX_PITCH_X),
             dec: 0,
             step: 10.0,
             suffix: "%",
         }
     }
 
     /// Zoom the network to a percentage of the configured grid, about the
     /// cursor cell — what the slider row's drag lands on. `zoom` clamps, so
     /// the row is re-read afterwards rather than trusted.
     pub fn set_zoom_percent(&mut self, pct: f32) {
         let cfg = crate::app::configured_grid_geometry();
         if self.grid_pitch_x > 0.0 {
             let factor = cfg.pitch_x * pct / 100.0 / self.grid_pitch_x;
             if (factor - 1.0).abs() > 1e-4 {
                 self.zoom(factor, None);
             }
         }
         self.refresh_dialog_zoom();
     }
 
     /// Re-read the zoom row from the live zoom, in place.
     fn refresh_dialog_zoom(&mut self) {
         let c = self.zoom_control();
         if self.ui_context[self.slots.dialog].rows.iter().any(|r| r.id == ZOOM_ROW_ID) {
             self.ui_context[self.slots.dialog].set_control(ZOOM_ROW_ID, Some(c));
         }
     }
 
     /// What a toggle command's switch currently shows, or `None` for a
     /// command that is not a toggle.
     ///
     /// Read off the very field each command flips in `execute_action` /
     /// `execute_menu_action` — the same read the View menu's checkmarks are
     /// set from — so the switch cannot disagree with the menu. Snapping is
     /// a toggle only INSIDE a viewer state; outside one the command does
     /// nothing but say so, and a switch on a row that cannot flip would be a
     /// lie, so the row is plain until a state is entered.
     /// `dialog_toggle_rows_cover_every_toggle_command` keeps this list and
     /// the registry's `toggle_*` / `show_*_pane` rows in step.
     pub fn command_toggle_state(&self, id: &str) -> Option<bool> {
         Some(match id {
             "toggle_grid" => self.viewport().show_grid,
             "toggle_origin" => self.viewport().show_origin,
             "toggle_camera_pivot" => self.viewport().show_camera_pivot,
             "toggle_wireframe" => self.wireframe,
             "toggle_smooth_shading" => self.smooth_shading,
             "toggle_show_occluded" => self.show_occluded,
             "toggle_point_markers" => self.show_point_markers,
             "toggle_point_numbers" => self.show_point_numbers,
             "toggle_point_normals" => self.show_point_normals,
             "toggle_prim_numbers" => self.show_prim_numbers,
             "toggle_prim_normals" => self.show_prim_normals,
             "toggle_vertex_numbers" => self.show_vertex_numbers,
             "toggle_vertex_markers" => self.show_vertex_markers,
             "toggle_vertex_normals" => self.show_vertex_normals,
             "toggle_wire_single_color" => self.wire_single_color,
             "toggle_ray_traced_preview" => self.viewport().rt_mode,
             "toggle_square_viewport" => self.square_viewport,
             "toggle_params_plate" => self.params_plate,
             "toggle_circular_pane" => self.circular_network_pane,
             "detach_circular_window" => self.detached_circular_network,
             "toggle_spreadsheet" => self.show_spreadsheet,
             "show_network_pane" => self.show_network,
             "show_viewport_pane" => self.show_viewport,
             "show_parameters_pane" => self.show_parameters,
             "show_playbar_pane" => self.show_playbar,
             "toggle_playbar_repeat" => self.ui_context[self.slots.playbar].inner().repeat,
             "toggle_playbar_step_buttons" => self.ui_context[self.slots.playbar].inner().step_buttons,
             "toggle_snap" => self.viewer_tool.as_ref()?.snap.is_some(),
             _ => return None,
         })
     }
 
     /// Re-read every row's control from the live state, touching nothing
     /// else — not the ranking, not the selection, not the scroll. This is
     /// what a toggle pick or a setting edit runs instead of
     /// `refresh_dialog_rows`: the rows are the same rows, only a control has
     /// moved, and re-ranking would throw the selection back to the top of a
     /// list the user is still working down.
     pub(crate) fn refresh_dialog_controls(&mut self) {
         if self.ui_context[self.slots.dialog].mode == Mode::Groups {
             let ids: Vec<String> = self.ui_context[self.slots.dialog].rows.iter().map(|r| r.id.clone()).collect();
             for id in ids {
                 if let Some(name) = id.strip_prefix(GROUP_ROW_PREFIX) {
                     let on = self.group_marked(name);
                     self.ui_context[self.slots.dialog].set_control(&id, Some(Control::Toggle(on)));
                 }
             }
             return;
         }
         if self.ui_context[self.slots.dialog].mode != Mode::Commands {
             return;
         }
         let ids: Vec<String> = self.ui_context[self.slots.dialog].rows.iter().map(|r| r.id.clone()).collect();
         for id in ids {
             let control = if let Some(s) = setting_of_row(&id) {
                 Some(self.setting_control(s))
             } else if id == ZOOM_ROW_ID {
                 Some(self.zoom_control())
             } else if let Some(on) = self.command_toggle_state(&id) {
                 Some(Control::Toggle(on))
             } else {
                 continue;
             };
             self.ui_context[self.slots.dialog].set_control(&id, control);
         }
     }
 
     /// A setting's row: its label, no chord, and the control its `Ctl`
     /// names over the live value.
     fn setting_row(&self, s: &Setting) -> Row {
         Row {
             id: setting_row_id(s.label),
             label: s.label.to_string(),
             chord: String::new(),
             control: Some(self.setting_control(s)),
             truncate_head: false,
         }
     }
 
     /// The control a setting draws, built from its `Ctl` and the value as
     /// [`State::setting_value`] reads it — so the control and the string the
     /// writer takes cannot disagree about what the value is.
     fn setting_control(&self, s: &Setting) -> Control {
         let value = self.setting_value(s);
         match s.ctl {
             Ctl::Toggle => Control::Toggle(value == "true"),
             Ctl::Color => Control::Color { hex: value },
             Ctl::Spin { min, max, .. } => Control::Slider {
                 value: value.parse().unwrap_or(min),
                 min,
                 max,
                 dec: 0,
                 step: 1.0,
                 suffix: "",
             },
             Ctl::Slider { min, max, dec } => Control::Slider {
                 value: value.parse().unwrap_or(min),
                 min,
                 max,
                 dec,
                 // Twenty nudges across the range: fine enough to land on a
                 // value, coarse enough that holding the arrow gets somewhere.
                 step: (max - min) / 20.0,
                 suffix: "",
             },
             Ctl::Choice(options) => Control::Choice {
                 options: options.iter().map(|o| o.to_string()).collect(),
                 index: options.iter().position(|o| o.eq_ignore_ascii_case(&value)).unwrap_or(0),
             },
         }
     }
 
     /// One setting's value as its row shows it — the params pane's
     /// encodings: a hex colour, a whole number in the spin's unit, a float
     /// to the slider's decimals, an option's text.
     pub(crate) fn setting_value(&self, s: &Setting) -> String {
         match s.owner {
             Owner::Field(key) => match s.ctl {
                 Ctl::Toggle => if self.settings_field_bool(key) { "true" } else { "false" }.to_string(),
                 Ctl::Color => crate::project::color_to_hex(self.settings_field_color(key)),
                 Ctl::Spin { unit, .. } => ((self.settings_field_f32(key) * unit).round() as i32).to_string(),
                 Ctl::Slider { dec, .. } => format!("{:.*}", dec, self.settings_field_f32(key)),
                 Ctl::Choice(_) => self.settings_field_text(key),
             },
         }
     }
 
     /// The value one setting row reads, by label. Test-facing:
     /// `dialog_settings_rows_name_owners_that_exist` round-trips every
     /// `Owner::Field` row through this and [`State::settings_write_row`],
     /// which is the only way to catch a key that no dispatch arm names.
     #[cfg(test)]
     pub(crate) fn settings_row_value(&self, label: &str) -> String {
         let s = SETTINGS.iter().find(|s| s.label == label).expect("no such Settings row");
         self.setting_value(s)
     }
 
     /// Write one setting row by label, as the writeback does — the value
     /// only, none of the apply pass.
     #[cfg(test)]
     pub(crate) fn settings_write_row(&mut self, label: &str, value: &str) {
         let s = SETTINGS.iter().find(|s| s.label == label).expect("no such Settings row");
         self.setting_write(s, value);
     }
 
     fn settings_field_bool(&self, key: &str) -> bool {
         match key {
             "wire_single_color" => self.wire_single_color,
             _ => false,
         }
     }
 
     fn settings_field_color(&self, key: &str) -> [f32; 3] {
         match key {
             "bg_color" => self.viewport().bg_color,
             "grid_color" => self.viewport().grid_color,
             "point_marker_color" => self.point_marker_color,
             "wire_color" => self.wire_color,
             _ => [0.0; 3],
         }
     }
 
     fn settings_field_f32(&self, key: &str) -> f32 {
         match key {
             "grid_thickness" => self.grid_thickness,
             "origin_size" => self.origin_size,
             "point_marker_size" => self.point_marker_size,
             "wire_width" => self.wire_width,
             "geo_opacity" => self.geo_opacity,
             "wire_opacity" => self.wire_opacity,
             "group_marker_size" => self.group_marker_size,
             "pull_arrow_scale" => self.pull_arrow_scale,
             _ => 0.0,
         }
     }
 
     fn settings_field_text(&self, key: &str) -> String {
         match key {
             "world_unit" => self.world_unit.suffix().to_string(),
             "gpu" => self.gpu_preference.clone(),
             "node_wire_style" => self.ui_context[self.slots.content].inner().wire_style().label().to_string(),
             _ => String::new(),
         }
     }
 
     /// Write one `Owner::Field` row's new value onto the live state.
     ///
     /// `dialog_settings_rows_name_owners_that_exist` walks the table against
     /// the four readers and this writer, because a key that no arm names
     /// reads as a default and writes nowhere — a row that looks live and is
     /// inert.
     fn settings_field_write(&mut self, key: &str, ctl: Ctl, value: &str) {
         match ctl {
             Ctl::Toggle => {
                 let on = value == "true";
                 match key {
                     "wire_single_color" => self.wire_single_color = on,
                     _ => {}
                 }
             }
             Ctl::Color => {
                 let Some(c) = crate::project::hex_to_color(value) else { return };
                 match key {
                     "bg_color" => self.viewport_mut().bg_color = c,
                     "grid_color" => self.viewport_mut().grid_color = c,
                     "point_marker_color" => self.point_marker_color = c,
                     "wire_color" => {
                         // Setting a wire colour means wanting to see it: the
                         // colour applies in single-colour mode only, so a
                         // colour edit turns that mode on if it was off. Twice
                         // read as "the colour did not take" (2026-09-21).
                         let changed = c != self.wire_color;
                         self.wire_color = c;
                         if changed && !self.wire_single_color {
                             self.wire_single_color = true;
                         }
                     }
                     _ => {}
                 }
             }
             Ctl::Spin { unit, .. } => {
                 let Ok(v) = value.parse::<f32>() else { return };
                 let v = v / unit;
                 match key {
                     "grid_thickness" => self.grid_thickness = v,
                     "origin_size" => self.origin_size = v,
                     _ => {}
                 }
             }
             Ctl::Slider { min, max, .. } => {
                 let Ok(v) = value.parse::<f32>() else { return };
                 let v = v.clamp(min, max);
                 match key {
                     "wire_width" => self.wire_width = v,
                     "geo_opacity" => self.geo_opacity = v,
                     "wire_opacity" => self.wire_opacity = v,
                     "group_marker_size" => self.group_marker_size = v,
                     "point_marker_size" => self.point_marker_size = v,
                     "pull_arrow_scale" => {
                         self.pull_arrow_scale = v;
                         self.rebuild_pull_arrow_verts();
                     }
                     _ => {}
                 }
             }
             Ctl::Choice(options) => match key {
                 "world_unit" => {
                     if let Some(u) = cce_ui::units::Unit::parse(value) {
                         self.world_unit = u;
                         self.viewport_dirty = true;
                     }
                 }
                 "gpu" => {
                     let Some(v) = options.iter().find(|o| o.eq_ignore_ascii_case(value)) else { return };
                     self.gpu_preference = v.to_string();
                 }
                 "node_wire_style" => {
                     if let Some(w) = cce_ui::widget::display::WireStyle::parse(value) {
                         self.set_node_wire_style(Some(w));
                     }
                 }
                 _ => {}
             },
         }
     }
 
     /// The node wires' style on the network editor — `None` follows the
     /// config's `wire_style`. The widget holds it; the save reads it back
     /// off it.
     pub(crate) fn set_node_wire_style(&mut self, style: Option<cce_ui::widget::display::WireStyle>) {
         self.ui_context[self.slots.content].inner_mut().set_wire_style(style);
     }
 
     /// Write one setting's value to whatever owns it.
     fn setting_write(&mut self, s: &Setting, value: &str) {
         match s.owner {
             Owner::Field(key) => self.settings_field_write(key, s.ctl, value),
         }
     }
 
     /// Apply a setting row's new value: write it to its owner, then run the
     /// one apply-and-persist pass and re-read the row.
     ///
     /// The viewport meshes bake their sizes and colours in, so a changed
     /// thickness/size/tint is a re-generate, not a re-draw. This is the same
     /// set the settings-file reload in `tick_frame` regenerates. Re-read
     /// rather than trusting the control: an apply can normalize a value (a
     /// clamp), and the row has to show what the state now holds.
     pub(crate) fn apply_setting(&mut self, label: &str, value: &str) {
         let Some(s) = SETTINGS.iter().find(|s| s.label == label) else { return };
         self.setting_write(s, value);
         self.update_grid_geometry();
         self.update_origin_geometry();
         self.update_pivot_geometry();
         self.update_viewport_bg_geometry();
         self.sync_grid_settings();
         self.rebuild_scene_geometry();
         self.sync_nodes();
         // A slider drag saves once, when it ends (`tick_frame`).
         if self.ui_context[self.slots.dialog].slider_dragging() {
             self.settings_save_pending = true;
         } else {
             self.save_settings();
         }
         // The params pane may be showing one of these very nodes.
         self.sync_parameters_pane();
         self.refresh_dialog_controls();
         // After the pass above, whose own status line would bury it.
         if s.owner == Owner::Field("gpu") {
             self.announce_gpu_setting();
         }
     }
 
     /// The renderer's device is fixed for the life of the process, so the
     /// GPU row says plainly whether this one is on it — a row that changed
     /// and a picture that did not would read as a setting that does nothing.
     fn announce_gpu_setting(&mut self) {
         let (want, have) = (&self.gpu_preference, &self.gpu_at_launch);
         let note = if want == have {
             format!("GPU: {want} — in use now.")
         } else {
             format!("GPU: {want} — takes effect when cce-designer restarts (running on {have}).")
         };
         self.update_status_text(&note);
     }
 
     /// Lay the dialog out over the window.
     ///
     /// Called at the end of `rebuild_positions`, after every layout branch has
     /// run — like the 2D page pane, the rect it wants never depends on which
     /// branch produced the panes underneath it.
     pub(crate) fn layout_dialog(&mut self) {
         if !self.dialog_visible() {
             self.positions[DIALOG_IDX] = (0.0, 0.0, 0.0, 0.0);
             return;
         }
         let (x, y, w, h) = match self.ui_context[self.slots.dialog].anchor {
             Some((ax, ay)) => layout_at(self.width, self.height, ax, ay),
             None => layout_in(self.width, self.height),
         };
         self.positions[DIALOG_IDX] = (x, y, w, h);
         self.ui_context[self.slots.dialog].set_page(visible_rows(x, y, w, h));
     }
 
     /// Every key, while the dialog is open.
     ///
     /// Total, not layered: the branch that calls this returns whatever it
     /// returns, so nothing below reaches the panes. A modal that leaks its
     /// typing is worse than no modal — typing "frame" into the filter would
     /// otherwise step the grid cursor and flip a node's geometry flag on the
     /// way past, since the network pane's bare-letter family is ungated.
     pub(crate) fn dialog_key_input(&mut self, event: &KeyEvent) -> bool {
         if event.state != ElementState::Pressed {
             return true;
         }
         // A colour row's hex well, while it is being typed into, has the
         // keyboard ahead of everything — Escape and Enter included, which
         // end the edit rather than the dialog.
         if let Some(sel) = self.ui_context[self.slots.dialog].editing_color() {
             let ptr = sel as *mut cce_ui::widget::Adapted<ColorSelector>;
             unsafe {
                 (*ptr).keyboard_input(event, &mut self.ui_context);
             }
             self.drain_dialog_clicks();
             return true;
         }
         // An open dropdown has the keys next: it is in front of the rows.
         if self.dialog_dropdown_open() {
             return self.dialog_dropdown_key(event);
         }
         // The dialog's own chord closes it, wherever the user has bound it —
         // asked for by id rather than hardcoded to Alt+D, so a rebind in
         // `input.kdl` keeps working both ways.
         if self.shortcut_manager.match_command(&self.modifiers, &event.logical_key)
             == Some("toggle_dialog")
         {
             self.close_dialog();
             return true;
         }
         match &event.logical_key {
             Key::Named(NamedKey::Escape) => {
                 self.close_dialog();
                 return true;
             }
             Key::Named(NamedKey::Tab) => {
                 // Tab is what opened the add-node palette, so the same key
                 // closes it again. In the commands list it means nothing.
                 if self.ui_context[self.slots.dialog].mode == Mode::AddNode {
                     self.close_dialog();
                 }
                 return true;
             }
             _ => {}
         }
 
         match &event.logical_key {
             Key::Named(NamedKey::ArrowDown) => self.ui_context[self.slots.dialog].move_selection(1),
             Key::Named(NamedKey::ArrowUp) => self.ui_context[self.slots.dialog].move_selection(-1),
             Key::Named(NamedKey::PageDown) => {
                 let page = self.ui_context[self.slots.dialog].page_len() as i32;
                 self.ui_context[self.slots.dialog].move_selection(page);
             }
             Key::Named(NamedKey::PageUp) => {
                 let page = self.ui_context[self.slots.dialog].page_len() as i32;
                 self.ui_context[self.slots.dialog].move_selection(-page);
             }
             Key::Named(NamedKey::Home) => {
                 self.ui_context[self.slots.dialog].selected = 0;
                 self.ui_context[self.slots.dialog].scroll_to_selected();
             }
             Key::Named(NamedKey::End) => {
                 let last = self.ui_context[self.slots.dialog].rows.len().saturating_sub(1);
                 self.ui_context[self.slots.dialog].selected = last;
                 self.ui_context[self.slots.dialog].scroll_to_selected();
             }
             Key::Named(NamedKey::Enter) => {
                 if let Some(id) = self.ui_context[self.slots.dialog].selected_id().map(str::to_string) {
                     self.take_dialog_pick(id);
                 }
             }
             // The arrows work the selected row's control in place: a
             // slider by its step, a choice to the next or previous option,
             // a float2's first end — its second with shift. On any other
             // row they mean nothing here.
             Key::Named(NamedKey::ArrowLeft) | Key::Named(NamedKey::ArrowRight) => {
                 let dir: i32 = if matches!(event.logical_key, Key::Named(NamedKey::ArrowRight)) { 1 } else { -1 };
                 self.nudge_dialog_selection(dir);
             }
             Key::Named(NamedKey::Backspace) => {
                 if self.ui_context[self.slots.dialog].query.pop().is_some() {
                     self.refresh_dialog_rows();
                 }
             }
             Key::Named(NamedKey::Space) => {
                 self.ui_context[self.slots.dialog].query.push(' ');
                 self.refresh_dialog_rows();
             }
             Key::Character(c) => {
                 // Bare typing only: a modified key is a chord, and the ones
                 // this dialog answers to are handled above.
                 if !self.modifiers.control_key()
                     && !self.modifiers.alt_key()
                     && !self.modifiers.super_key()
                 {
                     self.ui_context[self.slots.dialog].query.push_str(c);
                     self.refresh_dialog_rows();
                 }
             }
             _ => {}
         }
         true
     }
 
     /// Step the selected row's control by `dir` (-1 or 1) and land the
     /// value: a slider by its step, a choice to its neighbouring option.
     fn nudge_dialog_selection(&mut self, dir: i32) {
         let Some(id) = self.ui_context[self.slots.dialog].selected_id().map(str::to_string) else { return };
         let Some(control) = self.ui_context[self.slots.dialog].selected_control().cloned() else { return };
         match control {
             Control::Slider { value, step, .. } => {
                 let i = self.ui_context[self.slots.dialog].selected;
                 self.ui_context[self.slots.dialog].set_slider_value(i, value + dir as f32 * step);
                 let Some(v) = self.ui_context[self.slots.dialog].rows[i].slider_value() else { return };
                 self.land_dialog_slider(&id, v);
             }
             Control::Choice { options, index } => {
                 if options.is_empty() {
                     return;
                 }
                 let n = options.len() as i32;
                 let next = (index as i32 + dir).rem_euclid(n) as usize;
                 self.land_dialog_choice(&id, &options[next]);
             }
             _ => {}
         }
     }
 
     /// A choice row's new option, from its dropdown or an arrow key: a
     /// setting row writes its setting.
     pub(crate) fn land_dialog_choice(&mut self, id: &str, value: &str) {
         if let Some(label) = id.strip_prefix(SETTING_ROW_PREFIX) {
             let label = label.to_string();
             self.apply_setting(&label, value);
         }
     }
 
     /// Open row `id`'s dropdown: the params pane's own control. The live
     /// `Dialog::dropdown` takes the row's options and selection, is laid out
     /// on the row's band, and opens — its plate growing out of the trigger
     /// into the list, the current option highlighted. A pick lands through
     /// [`Self::land_dialog_choice`]; the dialog stays up.
     pub(crate) fn open_dialog_dropdown(&mut self, id: &str) {
         let Some(i) = self.ui_context[self.slots.dialog].rows.iter().position(|r| r.id == id) else { return };
         let Some(Control::Choice { options, index }) = self.ui_context[self.slots.dialog].rows[i].control.clone() else { return };
         if options.is_empty() {
             return;
         }
         self.ui_context[self.slots.dialog].selected = i;
         self.ui_context[self.slots.dialog].scroll_to_selected();
         {
             let dd = self.dialog_dd();
             let dd = self.ui_context[dd].inner_mut();
             dd.options = options;
             dd.selected = index;
         }
         self.ui_context[self.slots.dialog].dropdown_row = Some(id.to_string());
         if !self.sync_dialog_dropdown() {
             self.ui_context[self.slots.dialog].dropdown_row = None;
             return;
         }
         // Opened as the toolkit opens one from the keyboard: focused, then
         // Enter, which unfolds it with the current option highlighted.
         // In sight while it is open (`Dialog::tick_ctx` hides it again once it has closed).
         let dd = self.dialog_dd();
         self.ui_context[dd].set_visible(true);
         // The keys are the dropdown's (the focus record names it, which a closed dropdown
         // checks before it takes Enter), but it is not told it is focused, so its trigger
         // wears no focus ring: the row's band already says which control is open, as the
         // params pane's dropdowns do.
         self.ui_context.claim_focus(dd.id());
         let enter = Event::KeyInput(KeyEvent {
             state: ElementState::Pressed,
             logical_key: Key::Named(NamedKey::Enter),
             text: None,
             repeat: false,
             ctrl: false,
             shift: false,
             alt: false,
         });
         self.ui_context.lend_h(dd, |w, ctx| w.handle_event(&enter, ctx));
         self.ui_context[self.slots.dialog].dropdown_armed = true;
     }
 
     /// The dialog's live dropdown: the context's since the dialog was inserted (an
     /// `Embedded` child of the dialog).
     pub(crate) fn dialog_dd(&self) -> Handle<Adapted<Dropdown>> {
         self.ui_context[self.slots.dialog].dropdown.handle().expect("the dialog's dropdown is the context's")
     }
 
     /// Lay the live dropdown out on its row's band, as the dialog now
     /// stands. False when there is no such row in view.
     pub(crate) fn sync_dialog_dropdown(&mut self) -> bool {
         let (x, y, w, h) = self.positions[DIALOG_IDX];
         let Some(band) = self.ui_context[self.slots.dialog].dropdown_trigger(Rect { x, y, width: w, height: h }) else { return false };
         let dd = self.dialog_dd();
         WidgetHost::set_rect(&mut self.ui_context[dd], band.x, band.y, band.width, band.height);
         true
     }
 
     /// Whether the dropdown is open and taking input — not while it
     /// shrinks closed, when the dialog under it has the pointer again.
     pub(crate) fn dialog_dropdown_open(&self) -> bool {
         self.dialog_visible() && self.ui_context[self.slots.dialog].dropdown_row.is_some() && self.ui_context[self.dialog_dd()].is_expanded()
     }
 
     /// Close the dropdown — animated, as an outside press closes it.
     pub(crate) fn close_dialog_dropdown(&mut self) {
         self.ui_context[self.slots.dialog].dropdown_armed = false;
         let dd = self.dialog_dd();
         if self.ui_context[dd].open {
             self.ui_context.lend_h(dd, |w, ctx| w.handle_event(&Event::FocusOut, ctx));
         }
     }
 
     /// Hand `ev` to the open dropdown, and land what it picked. True when
     /// it took the event; a press it does not take (one made while it
     /// shrinks closed) goes on to the dialog.
     pub(crate) fn dialog_dropdown_event(&mut self, ev: &Event) -> bool {
         if !self.dialog_dropdown_open() {
             return false;
         }
         self.sync_dialog_dropdown();
         let dd = self.dialog_dd();
         let taken = self.ui_context.lend_h(dd, |w, ctx| w.handle_event(ev, ctx)).unwrap_or(false);
         self.land_dialog_dropdown_pick();
         taken
     }
 
     /// Land what the dropdown picked, however the event that picked it
     /// reached it, and note whether it is still expanded.
     fn land_dialog_dropdown_pick(&mut self) {
         let picked = {
             let dd = self.dialog_dd();
             let dd = self.ui_context[dd].inner_mut();
             dd.take_change().then(|| dd.options.get(dd.selected).cloned()).flatten()
         };
         self.ui_context[self.slots.dialog].dropdown_armed = self.ui_context[self.dialog_dd()].is_expanded();
         if let (Some(value), Some(id)) = (picked, self.ui_context[self.slots.dialog].dropdown_row.clone()) {
             self.land_dialog_choice(&id, &value);
         }
     }
 
     /// Whether a press has to be the dropdown's: it is expanded, or it was
     /// until this very press — which the runner then handed it first (see
     /// `Dialog::dropdown_armed`).
     pub(crate) fn dialog_dropdown_takes_press(&self) -> bool {
         self.dialog_dropdown_open() || (self.dialog_visible() && self.ui_context[self.slots.dialog].dropdown_armed)
     }
 
     /// A press while the dropdown is open: on a row it picks it, on the
     /// trigger it closes it, anywhere else it closes it and is swallowed —
     /// the dialog stays up, as under any menu's dismissing press.
     pub(crate) fn dialog_dropdown_press(&mut self, button: MouseButton) -> bool {
         let (x, y) = (self.cursor_x, self.cursor_y);
         if !self.dialog_dropdown_open() {
             // The runner handed it the press already: a pick, or the close
             // a press anywhere else makes. Land it, and the press is spent.
             self.land_dialog_dropdown_pick();
             self.ui_context[self.slots.dialog].dropdown_armed = false;
             return true;
         }
         if button != MouseButton::Left {
             self.close_dialog_dropdown();
             return true;
         }
         let ev = Event::MouseButton { button, state: ElementState::Pressed, x, y, local_x: x, local_y: y };
         self.dialog_dropdown_event(&ev);
         true
     }
 
     /// A key while the dropdown is open: Up and Down walk it, Enter picks
     /// the highlighted option, Escape closes it, Tab closes it too; nothing
     /// reaches the dialog behind it.
     fn dialog_dropdown_key(&mut self, event: &KeyEvent) -> bool {
         if event.state == ElementState::Pressed && matches!(event.logical_key, Key::Named(NamedKey::Tab)) {
             self.close_dialog_dropdown();
             return true;
         }
         self.dialog_dropdown_event(&Event::KeyInput(event.clone()));
         true
     }
 
     /// A slider row's value arriving from a drag, a wheel or an arrow: the
     /// zoom row zooms, a setting row writes its setting.
     ///
     /// A slider or spin row is a draw-time value, so it lands through the
     /// viewport menu's own `land_draw_time_setting` — the field, the one
     /// mesh it feeds, a redraw — and the row re-reads in place. During a
     /// drag this runs on every motion, so state.kdl is written on the
     /// RELEASE (`dialog_mouse_input`) rather than here; a wheel notch or an
     /// arrow key is a single landing and saves at once, as the menu's wheel
     /// does. A spin row lands its whole number over the row's unit. A row the landing
     /// does not know falls through to `apply_setting`.
     pub(crate) fn land_dialog_slider(&mut self, id: &str, v: f32) {
         if id == ZOOM_ROW_ID {
             self.set_zoom_percent(v);
         } else if let Some(s) = setting_of_row(id) {
             let landed = match (s.owner, s.ctl) {
                 (Owner::Field(key), Ctl::Slider { dec, .. }) => {
                     // Rounded as the row shows it, so the field holds the
                     // value the readout names rather than the pointer's raw
                     // fraction.
                     let shown: f32 = format!("{:.*}", dec, v).parse().unwrap_or(v);
                     self.land_draw_time_setting(key, shown)
                 }
                 (Owner::Field(key), Ctl::Spin { unit, .. }) => self.land_draw_time_setting(key, v.round() / unit),
                 _ => false,
             };
             if landed {
                 self.refresh_dialog_controls();
                 if !self.ui_context[self.slots.dialog].slider_dragging() {
                     self.save_settings();
                 }
                 return;
             }
             let value = match s.ctl {
                 Ctl::Slider { dec, .. } => format!("{:.*}", dec, v),
                 _ => (v.round() as i64).to_string(),
             };
             self.apply_setting(s.label, &value);
         }
     }
 
     /// Run a command the dialog chose, and close.
     ///
     /// Closing FIRST, so a command that opens something of its own (a file
     /// chooser) does not come up behind the dialog. The dialog's own row is
     /// the exception: toggling it here would reopen what was just closed.
     ///
     /// A CONTROL row does not close at all. A switch you can only flip once
     /// before the panel it is on vanishes is a button with extra steps: Show
     /// Grid, Show Origin and Square Aspect are the kind of thing you set
     /// together, looking at the viewport, and the dialog staying up is what
     /// lets you. A toggle flips, a choice steps to its next option, a slider
     /// or a colour is worked by the pointer or the arrows and Enter on it
     /// does nothing; the controls re-read, and the selection stays where it
     /// was — by Enter or by a click, since both arrive here.
     pub(crate) fn take_dialog_pick(&mut self, id: String) {
         let mode = self.ui_context[self.slots.dialog].mode;
         if mode == Mode::Commands && id == ZOOM_ROW_ID {
             return;
         }
         // A group's row is its switch: flipped in place, the list stays up.
         if mode == Mode::Groups {
             if let Some(name) = id.strip_prefix(GROUP_ROW_PREFIX) {
                 let name = name.to_string();
                 let on = !self.group_marked(&name);
                 self.set_group_marked(&name, on);
                 self.refresh_dialog_controls();
             }
             return;
         }
         if mode == Mode::Commands {
             if let Some(s) = setting_of_row(&id) {
                 let control = self.ui_context[self.slots.dialog].rows.iter().find(|r| r.id == id).and_then(|r| r.control.clone());
                 match control {
                     Some(Control::Toggle(on)) => {
                         let v = if on { "false" } else { "true" };
                         self.apply_setting(s.label, v);
                     }
                     Some(Control::Choice { .. }) => self.open_dialog_dropdown(&id),
                     _ => {}
                 }
                 return;
             }
         }
         // The path row: copy, say so, and close. A copy is done the moment it
         // happens — unlike a toggle, there is nothing to sit and adjust — so
         // it leaves the way a command does.
         if mode == Mode::Commands && id == PATH_ROW_ID {
             self.close_dialog();
             self.copy_project_path();
             return;
         }
         // A recent project: open it, and say so if it will not open — a
         // path in this list can have been moved or deleted since.
         if mode == Mode::Commands {
             if let Some(path) = id.strip_prefix(RECENT_ROW_PREFIX) {
                 let path = std::path::PathBuf::from(path);
                 self.close_dialog();
                 if let Err(e) = self.load_from_file(&path) {
                     self.update_status_text(&format!("Could not open {}: {e}", path.display()));
                 }
                 return;
             }
         }
         if mode == Mode::Commands {
             if let Some(name) = id.strip_prefix(CAMERA_ROW_PREFIX) {
                 let name = name.to_string();
                 self.close_dialog();
                 self.choose_camera(&name);
                 return;
             }
         }
         // A row that turns the palette into another list does so in place,
         // the palette left on the trail for a swipe back.
         if mode == Mode::Commands && dialog_row_leads(mode, &id) {
             self.run_command(&id);
             return;
         }
         if mode == Mode::Commands && self.command_toggle_state(&id).is_some() {
             self.run_command(&id);
             self.refresh_dialog_controls();
             return;
         }
         let (gx, gy) = (self.grid_cursor_col as f32, self.grid_cursor_row as f32);
         self.close_dialog();
         match mode {
             // Not `toggle_dialog`: toggling here would reopen what was just
             // closed. Picking the dialog's own row is a no-op, which is the
             // least surprising thing it could be.
             Mode::Commands => {
                 if id != "toggle_dialog" {
                     self.run_command(&id);
                 }
             }
             // Fire-and-forget at the grid cursor, exactly as the popup's
             // answer used to arrive — read BEFORE the close, since closing
             // relays the panes.
             Mode::Rename => {
                 let Some(target) = self.rename_target.take() else { return };
                 let typed = self.ui_context[self.slots.dialog].query.clone();
                 match self.rename_node(&target, &typed) {
                     Ok(said) | Err(said) => self.update_status_text(&said),
                 }
             }
             Mode::Groups => {}
             Mode::AddNode => {
                 // A free cursor cell a wire runs through is a place in that
                 // chain: the new node is spliced into the wire, as a node
                 // dropped there would be. Asked before the add, which puts
                 // a node on the cell and its own wires through it.
                 let free = !self.current_dir().children.iter().any(|c| c.position == (gx, gy));
                 let wire = if free { self.graph().input_wire_through_cell(gx, gy) } else { None };
                 let mut redraw = false;
                 let action = crate::app::McpAction::AddNode {
                     template_name: id,
                     name: None,
                     x: gx,
                     y: gy,
                 };
                 match self.apply_action(action, &mut redraw) {
                     Ok(_) => {
                         if let Some((src_id, dest_id)) = wire {
                             self.splice_new_node(&src_id, &dest_id);
                         }
                     }
                     // The one refusal this can hit is a template that does
                     // not belong at this level, which `refresh_dialog_rows`
                     // already filters out — but the rule lives in
                     // `apply_action`, so say what it said rather than assume
                     // it cannot fire.
                     Err(e) => self.update_status_text(&e),
                 }
             }
         }
     }
 
     /// Drain what the pointer (or a picker, or a hex edit) did inside the
     /// dialog. Returns whether anything changed.
     pub(crate) fn drain_dialog_clicks(&mut self) -> bool {
         let mut changed = false;
         if let Some(id) = self.ui_context[self.slots.dialog].take_activated() {
             self.take_dialog_pick(id);
             changed = true;
         }
         if let Some((id, v)) = self.ui_context[self.slots.dialog].take_slider_change() {
             self.land_dialog_slider(&id, v);
             changed = true;
         }
         for (id, hex) in self.ui_context[self.slots.dialog].take_color_changes() {
             if let Some(s) = setting_of_row(&id) {
                 self.apply_setting(s.label, &hex);
                 changed = true;
             }
         }
         changed
     }
 
     /// A mouse button, while the dialog is open.
     ///
     /// `None` hands the press back to the ordinary cascade — only the middle
     /// button, which the dialog has no use for. `Some(handled)` means the
     /// dialog dealt with it and nothing else should. A RIGHT press is the
     /// dialog's too: inside the plate it is swallowed (nothing in the dialog
     /// has a context menu, and until 2026-09-22 it fell through to the pane
     /// beneath, whose menu then opened over a modal with its labels clipped
     /// by the dialog's occluder — a menu with no legible entries), outside
     /// it dismisses, exactly as a left press does.
     pub(crate) fn dialog_mouse_input(
         &mut self,
         button: MouseButton,
         state: ElementState,
     ) -> Option<bool> {
         let (x, y) = (self.cursor_x, self.cursor_y);
         if button == MouseButton::Right {
             if !self.in_dialog_slot(DIALOG_IDX, x, y) && state == ElementState::Pressed {
                 self.close_dialog();
             }
             return Some(true);
         }
         if button != MouseButton::Left {
             return None;
         }
 
         // A slider drag ends wherever the pointer happens to be — including
         // outside the plate. Ending it has to come before the dismiss test
         // below, or dragging a value past the dialog's edge and letting go
         // would close the dialog instead of committing.
         if state == ElementState::Released && self.drag_widget == Some(DIALOG_IDX) {
             self.ui_context.lend_h(self.slots.dialog, |d, ui| {
                 d.handle_event(&cce_ui::widget::Event::DragEnd, ui);
                 d.handle_event(&cce_ui::widget::Event::MouseButton { button, state, x, y, local_x: x, local_y: y }, ui);
             });
             self.drag_widget = None;
             self.drag_press_cursor = None;
             self.drain_dialog_clicks();
             // The drag's motions landed without saving; the release does.
             self.save_settings();
             return Some(true);
         }
 
         if !self.in_dialog_slot(DIALOG_IDX, x, y) {
             // Outside: a press dismisses, a release is the tail of that press
             // and is simply eaten.
             if state == ElementState::Pressed {
                 self.close_dialog();
             }
             return Some(true);
         }
 
         let ev = cce_ui::widget::Event::MouseButton { button, state, x, y, local_x: x, local_y: y };
         self.dispatch_uncovered(DIALOG_IDX, &ev);
         // A press that took a slider's band arms the same widget drag the
         // params pane's sliders arm, so the value follows the pointer
         // wherever it goes until the release.
         if state == ElementState::Pressed && self.ui_context[self.slots.dialog].slider_dragging() {
             let ev = cce_ui::widget::Event::DragStart { start_x: x, start_y: y };
             self.ui_context.lend_h(self.slots.dialog, |d, ui| d.handle_event(&ev, ui));
             self.drag_widget = Some(DIALOG_IDX);
             self.drag_press_cursor = Some((x, y));
         }
         self.drain_dialog_clicks();
         Some(true)
     }
 
     /// The wheel, while the dialog is open: the dialog's, and no further —
     /// it scrolls its own list, so there is nothing to fall through to.
     pub(crate) fn dialog_mouse_wheel(&mut self, delta: MouseScrollDelta) -> bool {
         let (x, y) = (self.cursor_x, self.cursor_y);
         let ev = cce_ui::widget::Event::MouseWheel { delta, x, y, local_x: x, local_y: y };
         if self.in_dialog_slot(DIALOG_IDX, x, y) {
             // A side swipe turns the dialog: into what the row under the
             // pointer leads to, or back to where it was turned from.
             match cce_ui::widget::side_swipe::feed(&delta) {
                 Some(cce_ui::widget::SwipeDir::Forward) => {
                     let (rx, ry, rw, rh) = self.positions[DIALOG_IDX];
                     let rect = Rect { x: rx, y: ry, width: rw, height: rh };
                     let mode = self.ui_context[self.slots.dialog].mode;
                     let row = self.ui_context[self.slots.dialog].row_index_at(rect, x, y).and_then(|i| self.ui_context[self.slots.dialog].rows.get(i)).map(|r| r.id.clone());
                     if let Some(id) = row.filter(|id| dialog_row_leads(mode, id)) {
                         self.take_dialog_pick(id);
                         return true;
                     }
                 }
                 Some(cce_ui::widget::SwipeDir::Back) => {
                     if self.dialog_back() {
                         return true;
                     }
                 }
                 None => {}
             }
             let taken = self.dispatch_uncovered(DIALOG_IDX, &ev);
             // A wheel over a slider row moved it: land the value.
             self.drain_dialog_clicks();
             return taken;
         }
         false
     }
 
     /// Is `(x, y)` inside a dialog slot's laid-out rect?
     ///
     /// The rect, not `hit_test`: the dialog registers itself as a text
     /// occluder (see `Dialog::popover`) and `Adapted::hit_test` reads that
     /// same list as COVERAGE, so every point inside the dialog reports as
     /// covered — by the dialog's own plate. Inside a modal the geometry IS
     /// the answer.
     pub(crate) fn in_dialog_slot(&self, idx: usize, x: f32, y: f32) -> bool {
         if !self.slots.get_dyn(&self.ui_context, idx).visible() {
             return false;
         }
         let (rx, ry, rw, rh) = self.positions[idx];
         rw > 0.0 && rh > 0.0 && x >= rx && x < rx + rw && y >= ry && y < ry + rh
     }
 
     /// Deliver `ev` to a dialog slot with the dialog's occluder claim lowered.
     ///
     /// `Adapted::handle_event` hit-gates presses and wheels through
     /// `is_coordinate_covered`, which asks every REGISTERED widget for its
     /// `popover_rect` — including the dialog's, which covers the whole plate
     /// (see [`Dialog::popover`]). So while the claim stands, every press
     /// aimed at a control inside the plate is rejected as covered by the
     /// surface the control is drawn on. The dialog's own routing has already
     /// decided who gets this event, so the claim comes down for the dispatch
     /// and goes straight back up.
     pub(crate) fn dispatch_uncovered(&mut self, idx: usize, ev: &cce_ui::widget::Event) -> bool {
         self.ui_context[self.slots.dialog].set_occluding(false);
         // The coverage answer is memoized per point, so lowering the claim is
         // not enough — a query from earlier this frame is served from the
         // cache, and the engine makes one on every left press
         // (`close_popovers_missed_by_press`).
         self.ui_context.invalidate_coverage_cache();
         // Straight to handle_event, not propagate_event: so the gesture
         // bookkeeping the router would have done is done here, or the
         // dialog's panes inherit the main pane's gesture state.
         if matches!(ev, cce_ui::widget::Event::MouseWheel { .. }) {
             self.ui_context.note_scroll_event();
         }
         let ptr = self.slots.get_dyn_mut(&mut self.ui_context, idx) as *mut (dyn cce_ui::widget::WidgetHost + 'static);
         let taken = unsafe { (*ptr).handle_event(ev, &mut self.ui_context) };
         self.ui_context[self.slots.dialog].set_occluding(true);
         self.ui_context.invalidate_coverage_cache();
         taken
     }
 }