//! Narrow-trait `Spreadsheet` (Phase 5l) — a read-only table with a header row, zebra rows,
 //! selectable rows (a press selects one, ctrl toggles one, shift extends from the last
 //! pressed — see [`Spreadsheet::press_row`]),
 //! column dividers, and an inertially-scrolled body: wheel input feeds a velocity that
 //! [`Input::tick`] integrates and decays each frame, the scrollbar thumb is host-drag-driven
 //! through the drag surface, and arrow/page/home/end keys jump the scroll. The scroll geometry
 //! (content/viewport heights, thumb position) is derived in one place ([`ScrollGeom`]) — legacy
 //! re-derived it in seven. [`SpreadsheetController`] rides the `Input` capability hooks.
 //!
 //! **The two scrollbars cross at the body's centre** (since 2026-10-06): the vertical bar
 //! rides the pane's vertical centre line and the horizontal one the body's horizontal centre
 //! line, as the params pane's and the designer dialog's bars ride theirs — over the cells,
 //! reserving no lane. They idle BEHIND the pane's plate ([`ScrollbarActivity`]): a scroll,
 //! a key or a thumb drag raises them in front, a pointer over a raised bar keeps it there,
 //! and once nothing holds them for the hold window they sink again. Sunk they take no input,
 //! so a press on their lane reaches the row beneath. The fore copy is painted by
 //! [`Paint::paint`] at the activity's fade; the copy behind the plate is the HOST's to
 //! draw, before the plate, through [`Spreadsheet::paint_scrollbars`] — the plate is the
 //! host's too.
 //!
 //! **The table is COLUMNS of values, formatted as they are painted** (since 2026-10-07,
 //! [`SheetColumn`], [`SpreadsheetController::set_spreadsheet_columns`]). A host that
 //! refills the table every frame — the designer's, during a simulation's playback — used
 //! to format every cell of every row into a `String` for a pane that shows thirty rows:
 //! at ten thousand points that was most of what the table cost a frame. A column of
 //! numbers is now the numbers, the cells on screen are written when painted, and a sort
 //! compares the numbers rather than parsing their text. `set_spreadsheet_data` (rows of
 //! strings) still works: its cells become text columns.
 //!
 //! The `PARAM_BG` background is NOT emitted here: the designer's render path draws every
 //! widget's background itself from `color()` + `corner_style()` (`append_widget_plate`), and
 //! `PARAM_BG` is translucent — emitting it again would double-blend. This widget's own
 //! geometry starts at the header strip, exactly like the legacy `extra_quads`.
 
 use crate::colors;
 use crate::scene::layout::Rect;
 use crate::scene::paint::PaintCtx;
 use crate::widget::scroll_motion::{scroll_settings, Bounds, ScrollMotion};
 use crate::widget::{
     Adapted, ElementState, Event, EventCtx, Input, Key, Layout, MouseButton, MouseScrollDelta,
     NamedKey, Paint, ScrollbarActivity, SpreadsheetController,
 };
 
 /// One column of a [`Spreadsheet`], as its values: the widget writes the
 /// cells it paints, so a column of a hundred thousand numbers costs a copy
 /// of them, not a hundred thousand strings.
 #[derive(Debug, Clone, PartialEq)]
 pub enum SheetColumn {
     /// Cells as given. Sorted numerically where both cells parse as numbers,
     /// as text otherwise.
     Text(Vec<String>),
     /// Whole numbers.
     Int(Vec<i64>),
     /// Numbers written to `decimals` places (`format!("{:.*}")`).
     Float { values: Vec<f32>, decimals: usize },
 }
 
 impl SheetColumn {
     /// How many cells the column has.
     pub fn len(&self) -> usize {
         match self {
             SheetColumn::Text(v) => v.len(),
             SheetColumn::Int(v) => v.len(),
             SheetColumn::Float { values, .. } => values.len(),
         }
     }
 
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Row `row`'s cell as it is shown; empty past the column's end.
     pub fn cell(&self, row: usize) -> String {
         match self {
             SheetColumn::Text(v) => v.get(row).cloned().unwrap_or_default(),
             SheetColumn::Int(v) => v.get(row).map(|n| n.to_string()).unwrap_or_default(),
             SheetColumn::Float { values, decimals } => {
                 values.get(row).map(|x| format!("{:.*}", decimals, x)).unwrap_or_default()
             }
         }
     }
 
     /// The widest cell, in characters, as [`Self::cell`] writes it — worked
     /// out from the values without writing them: a whole number's widest is
     /// its least or its greatest, a float's too (the sign and the integer
     /// digits are what vary; the decimals are fixed), plus `NaN` / `inf` /
     /// `-inf` where those occur. 0 for an empty column.
     pub fn max_chars(&self) -> usize {
         match self {
             SheetColumn::Text(v) => v.iter().map(|c| c.chars().count()).max().unwrap_or(0),
             SheetColumn::Int(v) => {
                 let Some(&first) = v.first() else { return 0 };
                 let (lo, hi) = v.iter().fold((first, first), |(lo, hi), &x| (lo.min(x), hi.max(x)));
                 lo.to_string().len().max(hi.to_string().len())
             }
             SheetColumn::Float { values, decimals } => {
                 // Plain comparisons, which the compiler vectorizes, where
                 // `f32::min` / `max` carry NaN handling a finite value does
                 // not need: at a million values a refill (the designer's
                 // table at 57k points, every frame of a playback) this pass
                 // was 1.35 ms (until 2026-10-07). A tie between 0 and -0
                 // takes -0, whose `-` is a character wider.
                 // No branch in the loop: a value that is not finite stands
                 // out of the range it does not belong to, and what is
                 // special is OR'd up and settled after.
                 let (mut lo, mut hi) = (f32::INFINITY, f32::NEG_INFINITY);
                 let (mut neg_zero, mut nan_or_inf, mut neg_inf) = (false, false, false);
                 for &x in values {
                     let finite = x.is_finite();
                     let a = if finite { x } else { f32::INFINITY };
                     let b = if finite { x } else { f32::NEG_INFINITY };
                     lo = if a < lo { a } else { lo };
                     hi = if b > hi { b } else { hi };
                     neg_zero |= x == 0.0 && x.is_sign_negative();
                     nan_or_inf |= !finite && x != f32::NEG_INFINITY;
                     neg_inf |= x == f32::NEG_INFINITY;
                 }
                 if lo == 0.0 && neg_zero {
                     lo = -0.0;
                 }
                 let odd = if neg_inf { 4 } else if nan_or_inf { 3 } else { 0 };
                 let w = |x: f32| format!("{:.*}", decimals, x).len();
                 let finite = if lo <= hi { w(lo).max(w(hi)) } else { 0 };
                 finite.max(odd)
             }
         }
     }
 
     /// The order of rows `a` and `b` by this column: by value for numbers
     /// (a NaN is equal to anything, so it keeps its place), by
     /// `Spreadsheet::cmp_cells` for text.
     fn cmp_rows(&self, a: usize, b: usize) -> std::cmp::Ordering {
         use std::cmp::Ordering::Equal;
         match self {
             SheetColumn::Text(v) => Spreadsheet::cmp_cells(
                 v.get(a).map(String::as_str).unwrap_or(""),
                 v.get(b).map(String::as_str).unwrap_or(""),
             ),
             SheetColumn::Int(v) => v.get(a).cmp(&v.get(b)),
             SheetColumn::Float { values, .. } => match (values.get(a), values.get(b)) {
                 (Some(x), Some(y)) => x.partial_cmp(y).unwrap_or(Equal),
                 (x, y) => x.is_some().cmp(&y.is_some()),
             },
         }
     }
 }
 
 const HEADER_H: f32 = 24.0;
 const ROW_H: f32 = 24.0;
 /// How far a track stops short of each end of what it spans, as every toolkit bar's does.
 const TRACK_INSET: f32 = 4.0;
 /// How far either side of a bar a press or the pointer still counts as on it.
 const BAR_SLOP: f32 = 4.0;
 /// A column's width beyond its text: the 8 px a label stands in from the
 /// column's left edge, and the 4 px gutter it is clamped short of the divider
 /// by, with room to spare.
 const CELL_PAD: f32 = 16.0;
 /// Room after a header's name for the sort glyph, in characters — kept
 /// whether or not the column is sorted, so sorting moves no column.
 const SORT_MARK_CHARS: usize = 2;
 /// The narrowest a column is, in characters, so a header is a target.
 const MIN_COL_CHARS: usize = 3;
 
 pub struct Spreadsheet {
     hovered: bool,
     headers: Vec<String>,
     /// The table, a column a header ([`SheetColumn`]); `row_count` rows.
     columns: Vec<SheetColumn>,
     row_count: usize,
     /// Display order into the rows — the identity permutation unless `sort` is set.
     /// Rebuilt by `apply_sort` at both mutation sites (header click, data refresh),
     /// so `order.len() == row_count` always holds.
     order: Vec<usize>,
     /// Active sort: `(column, ascending)`. A header click cycles
     /// ascending → descending → natural order (matching the source data).
     sort: Option<(usize, bool)>,
     /// Header cell the pointer is over — hover tint, like the Processes page's
     /// sortable headers.
     header_hover_col: Option<usize>,
     /// Each column's width in characters: its header with room for the
     /// sort glyph, or its widest cell, whichever is wider (`set_columns`).
     col_chars: Vec<usize>,
     scroll_y: f32,
     dragging_scrollbar: bool,
     drag_offset_y: f32,
     scroll_x: f32,
     /// Smooth-scroll driver behind `scroll_y`/`scroll_x`: wheel notches
     /// glide, trackpad flicks coast (the widget's former velocity model,
     /// now the toolkit-wide one).
     motion: ScrollMotion,
     dragging_hscrollbar: bool,
     drag_offset_x: f32,
     /// Whether the two bars are raised in front of the plate or sunk behind
     /// it — one latch for both, since they are one cross.
     activity: ScrollbarActivity,
     /// The selected rows, as indices into `rows` — the SOURCE order, so a
     /// sort moves a selected row's place in the pane and not what it names.
     selected: std::collections::BTreeSet<usize>,
     /// The row a shift press extends from: the last one pressed without it.
     anchor: Option<usize>,
     /// Set by whatever changed `selected`, taken by the host.
     selection_changed: bool,
     /// The modifiers the host pushed in ahead of the press.
     ctrl: bool,
     shift: bool,
 }
 
 /// Scroll/scrollbar geometry for one (row count, rect) pair. Present only when the content
 /// overflows the viewport — every scroll behavior is gated on that, as in legacy.
 struct ScrollGeom {
     visible_h: f32,
     max_scroll: f32,
     /// `scroll_y` clamped to the current bounds (data changes can leave the raw value stale).
     scroll: f32,
     /// The bar's left edge: it is centred on the pane's width.
     bar_x: f32,
     bar_w: f32,
     track_y: f32,
     track_h: f32,
     thumb_h: f32,
     thumb_y: f32,
     track_range: f32,
 }
 
 /// [`ScrollGeom`]'s horizontal twin, for the bottom scrollbar. Present only
 /// when the column run overflows the pane width.
 struct HScrollGeom {
     max_scroll: f32,
     /// `scroll_x` clamped to the current bounds.
     scroll: f32,
     track_x: f32,
     track_w: f32,
     /// The bar's top edge: it is centred on the body's height.
     bar_y: f32,
     bar_h: f32,
     thumb_w: f32,
     thumb_x: f32,
     track_range: f32,
 }
 
 impl Spreadsheet {
     pub fn new() -> Adapted<Spreadsheet> {
         let mut s = Adapted::new(Spreadsheet {
             hovered: false,
             headers: Vec::new(),
             columns: Vec::new(),
             row_count: 0,
             order: Vec::new(),
             sort: None,
             header_hover_col: None,
             col_chars: Vec::new(),
             scroll_y: 0.0,
             dragging_scrollbar: false,
             drag_offset_y: 0.0,
             scroll_x: 0.0,
             motion: ScrollMotion::new(),
             dragging_hscrollbar: false,
             drag_offset_x: 0.0,
             activity: ScrollbarActivity::new(),
             selected: std::collections::BTreeSet::new(),
             anchor: None,
             selection_changed: false,
             ctrl: false,
             shift: false,
         });
         // The spreadsheet pane starts hidden (the designer toggles it in later).
         crate::widget::WidgetHost::set_visible(&mut s, false);
         s
     }
 
     fn geom(&self, rect: Rect) -> Option<ScrollGeom> {
         let content_h = self.row_count as f32 * ROW_H;
         let visible_h = (rect.height - HEADER_H).max(0.0);
         if visible_h <= 0.0 || content_h <= visible_h {
             return None;
         }
         let max_scroll = content_h - visible_h;
         let scroll = self.scroll_y.clamp(0.0, max_scroll);
         let bar_w = Self::bar_w();
         let track_y = rect.y + HEADER_H + TRACK_INSET;
         let track_h = (visible_h - 2.0 * TRACK_INSET).max(0.0);
         let thumb_h = Self::thumb_len(track_h, visible_h / content_h);
         let track_range = track_h - thumb_h;
         Some(ScrollGeom {
             visible_h,
             max_scroll,
             scroll,
             bar_x: rect.x + (rect.width - bar_w) * 0.5,
             bar_w,
             track_y,
             track_h,
             thumb_h,
             thumb_y: track_y + (scroll / max_scroll) * track_range,
             track_range,
         })
     }
 
     /// One character's width in the label font, which is monospace.
     fn char_w() -> f32 {
         let fam = crate::layout::control_label_font();
         (crate::widget::display::measure_text_width("0123456789", &fam, 12.0) / 10.0).max(1.0)
     }
 
     /// The columns' edges from the table's left, `n + 1` of them: each
     /// column is as wide as its content (`col_chars`) — its header and sort
     /// glyph, or its widest cell — and no wider. The table does not stretch
     /// to the pane: what is left of a wide pane is left empty, and a table
     /// wider than the pane scrolls. (Until 2026-10-07 every column was an
     /// even share of the pane, floored at 76 px, so a point index or a
     /// group's 0 and 1 took as much room as a four-decimal float.)
     fn col_edges(&self) -> Vec<f32> {
         let cw = Self::char_w();
         let mut edges = Vec::with_capacity(self.headers.len() + 1);
         let mut x = 0.0;
         edges.push(x);
         for i in 0..self.headers.len() {
             let chars = self.col_chars.get(i).copied().unwrap_or(0).max(MIN_COL_CHARS);
             x += chars as f32 * cw + CELL_PAD;
             edges.push(x);
         }
         edges
     }
 
     /// How wide the table is: its columns, each as wide as its content. A
     /// host sizes the pane by it — the designer's plate is as wide as the
     /// table, up to the room it has (since 2026-10-07).
     pub fn content_width(&self) -> f32 {
         self.col_edges().last().copied().unwrap_or(0.0)
     }
 
     /// Horizontal counterpart of [`geom`]: present only when the column run is
     /// wider than the pane.
     fn hgeom(&self, rect: Rect) -> Option<HScrollGeom> {
         let content_w = self.col_edges().last().copied().unwrap_or(0.0);
         let visible_w = rect.width;
         if visible_w <= 0.0 || content_w <= visible_w {
             return None;
         }
         let max_scroll = content_w - visible_w;
         let scroll = self.scroll_x.clamp(0.0, max_scroll);
         let bar_h = Self::bar_w();
         let track_x = rect.x + TRACK_INSET;
         let track_w = (visible_w - 2.0 * TRACK_INSET).max(0.0);
         let thumb_w = Self::thumb_len(track_w, visible_w / content_w);
         let track_range = track_w - thumb_w;
         let body_h = (rect.height - HEADER_H).max(0.0);
         Some(HScrollGeom {
             max_scroll,
             scroll,
             track_x,
             track_w,
             bar_y: rect.y + HEADER_H + (body_h - bar_h) * 0.5,
             bar_h,
             thumb_w,
             thumb_x: track_x + (scroll / max_scroll) * track_range,
             track_range,
         })
     }
 
     /// A bar's thickness — the DE's centred width, as the params pane's bar
     /// is, since it sits over cells rather than in a lane.
     fn bar_w() -> f32 {
         crate::layout::centred_scrollbar_width()
     }
 
     /// A thumb's length on a track `track` long showing `ratio` of the content.
     fn thumb_len(track: f32, ratio: f32) -> f32 {
         if track <= 20.0 {
             track
         } else {
             (track * ratio).clamp(20.0, track)
         }
     }
 
     /// Whether `(px, py)` is on the vertical bar's strip (with slop).
     fn over_vbar(&self, px: f32, py: f32, rect: Rect) -> bool {
         self.geom(rect).is_some_and(|g| {
             px >= g.bar_x - BAR_SLOP
                 && px <= g.bar_x + g.bar_w + BAR_SLOP
                 && py >= g.track_y
                 && py <= g.track_y + g.track_h
         })
     }
 
     /// Whether `(px, py)` is on the horizontal bar's strip (with slop).
     fn over_hbar(&self, px: f32, py: f32, rect: Rect) -> bool {
         self.hgeom(rect).is_some_and(|g| {
             py >= g.bar_y - BAR_SLOP
                 && py <= g.bar_y + g.bar_h + BAR_SLOP
                 && px >= g.track_x
                 && px <= g.track_x + g.track_w
         })
     }
 
     /// Whether the pane has either bar at all.
     pub fn scrollbars_shown(&self, rect: Rect) -> bool {
         self.geom(rect).is_some() || self.hgeom(rect).is_some()
     }
 
     /// Whether the bars are raised in front of the plate — the latch, which
     /// gates input. Paint the fore copy with [`Self::scrollbar_fade`].
     pub fn scrollbars_raised(&self) -> bool {
         self.activity.raised()
     }
 
     /// How far the fore copy has faded in, 0..=1.
     pub fn scrollbar_fade(&self) -> f32 {
         self.activity.fade()
     }
 
     /// The cross of pill scrollbars on `rect`, scaled to `alpha`: both
     /// tracks, then both thumbs, so neither track covers the other's thumb
     /// where they cross. [`Paint::paint`] draws the fore copy; the host draws
     /// the copy that idles behind its plate, at full alpha, BEFORE the plate.
     pub fn paint_scrollbars(&self, rect: Rect, ctx: &mut PaintCtx, alpha: f32) {
         let a = alpha.clamp(0.0, 1.0);
         if a <= 0.001 {
             return;
         }
         let dim = |mut c: [f32; 4]| {
             c[3] *= a;
             c
         };
         let all = (true, true, true, true);
         let track = dim(crate::color::scrollbar_track_color());
         let thumb = dim(crate::color::scrollbar_thumb_color());
         let pill = |ctx: &mut PaintCtx, r: Rect, c: [f32; 4]| {
             if r.width > 0.0 && r.height > 0.0 {
                 ctx.rounded_rect(r, r.width.min(r.height) * 0.5, all, c);
             }
         };
         let v = self.geom(rect);
         let h = self.hgeom(rect);
         if let Some(g) = &v {
             pill(ctx, Rect { x: g.bar_x, y: g.track_y, width: g.bar_w, height: g.track_h }, track);
         }
         if let Some(g) = &h {
             pill(ctx, Rect { x: g.track_x, y: g.bar_y, width: g.track_w, height: g.bar_h }, track);
         }
         if let Some(g) = &v {
             pill(ctx, Rect { x: g.bar_x, y: g.thumb_y, width: g.bar_w, height: g.thumb_h }, thumb);
         }
         if let Some(g) = &h {
             pill(ctx, Rect { x: g.thumb_x, y: g.bar_y, width: g.thumb_w, height: g.bar_h }, thumb);
         }
     }
 
     /// Re-latch the raise/sink, returning whether it flipped.
     fn recompute_bars(&mut self, rect: Rect) -> bool {
         let shown = self.scrollbars_shown(rect);
         let dragging = self.dragging_scrollbar || self.dragging_hscrollbar;
         self.activity.recompute(shown, dragging)
     }
 
     /// The clamped horizontal scroll — 0 while everything fits.
     fn hscroll(&self, rect: Rect) -> f32 {
         self.hgeom(rect).map_or(0.0, |g| g.scroll)
     }
 
     /// The header column under `(px, py)`, if the point is inside the header band.
     fn header_col_at(&self, px: f32, py: f32, rect: Rect) -> Option<usize> {
         if self.headers.is_empty() || rect.width <= 0.0 {
             return None;
         }
         if px < rect.x || px > rect.x + rect.width || py < rect.y || py >= rect.y + HEADER_H {
             return None;
         }
         let at = px - rect.x + self.hscroll(rect);
         let edges = self.col_edges();
         (0..self.headers.len()).find(|&c| at >= edges[c] && at < edges[c + 1])
     }
 
     /// Scroll to where a thumb dragged to `thumb_x` puts the columns.
     fn hscroll_to_thumb(&mut self, g: &HScrollGeom, thumb_x: f32) {
         let ratio = if g.track_range > 0.0 {
             ((thumb_x - g.track_x) / g.track_range).clamp(0.0, 1.0)
         } else {
             0.0
         };
         self.scroll_x = ratio * g.max_scroll;
     }
 
     /// Cell comparison: numeric when both cells parse (so "10" sorts after "9"),
     /// lexicographic otherwise.
     fn cmp_cells(a: &str, b: &str) -> std::cmp::Ordering {
         match (a.parse::<f64>(), b.parse::<f64>()) {
             (Ok(x), Ok(y)) => x.partial_cmp(&y).unwrap_or(std::cmp::Ordering::Equal),
             _ => a.cmp(b),
         }
     }
 
     /// Rebuild `order` from `sort`. Stable, so equal cells keep their source order.
     fn apply_sort(&mut self) {
         // A refresh can shrink the column set out from under the sort.
         if let Some((col, _)) = self.sort {
             if col >= self.headers.len() {
                 self.sort = None;
             }
         }
         self.order = (0..self.row_count).collect();
         if let Some((col, ascending)) = self.sort {
             if let Some(column) = self.columns.get(col) {
                 self.order.sort_by(|&a, &b| {
                     let ord = column.cmp_rows(a, b);
                     if ascending { ord } else { ord.reverse() }
                 });
             }
         }
     }
 
     /// What a body press at `(px, py)` lands on: `Some(Some(place))` for the
     /// row at that place in the DISPLAY order, `Some(None)` for the empty
     /// body under the last row, `None` for a press that is not the body's —
     /// outside it, or on a RAISED scrollbar, which the drag surface owns. A
     /// sunk bar is behind the plate and the press is the row's.
     fn body_row_at(&self, px: f32, py: f32, rect: Rect) -> Option<Option<usize>> {
         let body_top = rect.y + HEADER_H;
         if px < rect.x || px > rect.x + rect.width || py < body_top || py > rect.y + rect.height {
             return None;
         }
         if self.activity.raised() && (self.over_vbar(px, py, rect) || self.over_hbar(px, py, rect)) {
             return None;
         }
         let scroll = self.geom(rect).map_or(0.0, |g| g.scroll);
         let place = ((py - body_top + scroll) / ROW_H) as usize;
         Some((place < self.order.len()).then_some(place))
     }
 
     /// A press on the row at `place` of the display order, or on the empty
     /// body (`None`). Plain, it selects that row alone — or nothing, where
     /// the row was the whole selection already or the press met no row.
     /// With ctrl it toggles the row and leaves the rest. With shift it
     /// selects the run from the anchor to the row AS DISPLAYED, so under a
     /// sort the run is what the eye sees between the two; with ctrl as well
     /// the run is added to what is selected.
     fn press_row(&mut self, place: Option<usize>, ctrl: bool, shift: bool) {
         let before = self.selected.clone();
         match place {
             None => {
                 if !ctrl && !shift {
                     self.selected.clear();
                     self.anchor = None;
                 }
             }
             Some(place) => {
                 let src = self.order[place];
                 let anchor_place = self.anchor.and_then(|a| self.order.iter().position(|&r| r == a));
                 match (shift, anchor_place) {
                     (true, Some(from)) => {
                         if !ctrl {
                             self.selected.clear();
                         }
                         let (lo, hi) = (from.min(place), from.max(place));
                         self.selected.extend(self.order[lo..=hi].iter().copied());
                     }
                     _ if ctrl => {
                         if !self.selected.remove(&src) {
                             self.selected.insert(src);
                         }
                         self.anchor = Some(src);
                     }
                     _ => {
                         let alone = self.selected.len() == 1 && self.selected.contains(&src);
                         self.selected.clear();
                         if !alone {
                             self.selected.insert(src);
                         }
                         self.anchor = Some(src);
                     }
                 }
             }
         }
         if self.selected != before {
             self.selection_changed = true;
         }
     }
 
     /// Scroll to where a thumb dragged to `thumb_y` puts the content.
     fn scroll_to_thumb(&mut self, g: &ScrollGeom, thumb_y: f32) {
         let ratio = if g.track_range > 0.0 {
             ((thumb_y - g.track_y) / g.track_range).clamp(0.0, 1.0)
         } else {
             0.0
         };
         self.scroll_y = ratio * g.max_scroll;
     }
 }
 
 impl Layout for Spreadsheet {}
 
 impl Paint for Spreadsheet {
     /// The pane IS its own background plate, wearing the parameter plate's fill —
     /// same tint, opacity, and blur-behind marker (`param_plate_fill`) — so it
     /// bevels like the params plate and tracks a live retint / opacity / blur
     /// toggle with it.
     fn color(&self) -> [f32; 4] {
         colors::param_plate_fill()
     }
 
     /// The shared plate corner radius (rounded on all four corners when non-zero),
     /// matching the rounded clip hosts carve for the pane's content.
     fn corner_style(&self, _rect: Rect) -> Option<(f32, (bool, bool, bool, bool))> {
         let r = crate::layout::plate_corner_radius();
         let on = r > 0.0;
         Some((r, (on, on, on, on)))
     }
 
     /// The shared plate border — under `control_relief` the host promotes this to
     /// the plate bevel, like `ParametersBg`.
     fn solid_border(&self) -> Option<([f32; 4], f32)> {
         colors::plate_border_color().map(|bc| (bc, colors::plate_border_thickness()))
     }
 
     /// Subtree painter: `paint` authors the pane's complete text with
     /// per-column clamp bounds, so its Text prims must pass through
     /// `paint_self` verbatim — the own-labels re-derivation drops per-prim
     /// bounds, which is exactly how long cell values used to overlap into
     /// their neighbor columns on narrow panes.
     fn paints_own_subtree(&self) -> bool {
         true
     }
 
     fn paint(&self, rect: Rect, ctx: &mut PaintCtx) {
         let (x, y, w, h) = (rect.x, rect.y, rect.width, rect.height);
         let scroll = self.geom(rect).map_or(0.0, |g| g.scroll);
 
         // Header bg
         ctx.quad(Rect { x, y, width: w, height: HEADER_H }, [0.12, 0.12, 0.16, 0.4]);
 
         // Zebra rows + separators, clipped to the body band
         let body_top = y + HEADER_H;
         let body_bottom = y + h;
         let selected_fill = {
             let [r, g, b, _] = colors::highlight_primary_color();
             [r, g, b, 0.28]
         };
         for i in 0..self.row_count {
             let ry = y + HEADER_H + i as f32 * ROW_H - scroll;
             if ry + ROW_H <= body_top || ry >= body_bottom {
                 continue;
             }
             let draw_y = ry.max(body_top);
             let draw_h = (ry + ROW_H).min(body_bottom) - draw_y;
             if draw_h > 0.0 {
                 let row_color = if i % 2 == 0 {
                     [0.10, 0.10, 0.13, 0.15]
                 } else {
                     [0.08, 0.08, 0.11, 0.05]
                 };
                 ctx.quad(Rect { x, y: draw_y, width: w, height: draw_h }, row_color);
                 if self.order.get(i).is_some_and(|src| self.selected.contains(src)) {
                     ctx.quad(Rect { x, y: draw_y, width: w, height: draw_h }, selected_fill);
                 }
 
                 let sep_y = ry + ROW_H;
                 if sep_y >= body_top && sep_y < body_bottom {
                     ctx.quad(Rect { x, y: sep_y, width: w, height: 1.0 }, [0.20, 0.20, 0.25, 0.15]);
                 }
             }
         }
 
         // Header separator
         ctx.quad(Rect { x, y: y + HEADER_H, width: w, height: 1.0 }, [0.20, 0.20, 0.25, 0.25]);
 
         // Vertical column dividers, at scrolled column edges, kept inside the pane.
         let hscroll = self.hscroll(rect);
         // The last edge too: the table stops short of a wide pane, and the
         // line says where.
         let edges = self.col_edges();
         if h > 0.0 && !self.headers.is_empty() {
             for &edge in &edges[1..] {
                 let dx = x + edge - hscroll;
                 if dx <= x || dx >= x + w {
                     continue;
                 }
                 ctx.quad(Rect { x: dx, y, width: 1.0, height: h }, [0.20, 0.20, 0.25, 0.15]);
             }
         }
 
         // The scrollbars' fore copy, over the cells, at the activity's fade —
         // the fade rather than the latch, so it draws all the way out. The
         // copy behind the plate is the host's (`paint_scrollbars`).
         self.paint_scrollbars(rect, ctx, self.activity.fade());
 
         // Header + cell text, each cell clamped to its column and the body band.
         if self.headers.is_empty() {
             return;
         }
         let n_cols = self.headers.len();
         // Scrolled column origin; columns fully outside the pane skip.
         let xoff = x - hscroll;
         let col_visible = |col: usize| -> bool {
             xoff + edges[col + 1] > x && xoff + edges[col] < x + w
         };
         if let Some(hc) = self.header_hover_col.filter(|&hc| hc < n_cols) {
             // Subtle hover tint on the clickable header cell (the Processes-page
             // sortable-header convention), clamped to the pane.
             let hx0 = (xoff + edges[hc]).max(x);
             let hx1 = (xoff + edges[hc + 1]).min(x + w);
             if hx1 > hx0 {
                 ctx.quad(Rect { x: hx0, y, width: hx1 - hx0, height: HEADER_H }, [1.0, 1.0, 1.0, 0.05]);
             }
         }
         // Every label clamps to its own column (a 4px gutter short of the
         // divider) AND to the pane, so a long value cuts off instead of
         // running under its neighbor, and half-scrolled edge columns stop at
         // the plate instead of bleeding past it.
         let col_bounds = |col: usize, top: f32, height: f32| -> Option<[f32; 4]> {
             let x0 = (xoff + edges[col]).max(x);
             let x1 = (xoff + edges[col + 1] - 4.0).min(x + w);
             if x1 <= x0 {
                 return None;
             }
             Some([x0, top, x1, top + height])
         };
         // Ellipsize what the clamp would cut, so truncation reads as
         // deliberate. A char budget from ONE cached measurement is exact
         // because the DE label font is monospace; the clamp bounds stay on
         // as the backstop for any fallback-font drift. Below three columns'
         // worth of budget the mark would REPLACE the content (a 19px column
         // fits one glyph — a bare "…" says less than a clipped digit), so
         // very narrow columns keep the raw string and let the clamp cut it.
         let char_w = Self::char_w();
         // Columns fit their content, so the budget is met but for a
         // fallback font's drift.
         let budget_of = |col: usize| (((edges[col + 1] - edges[col]) - 12.0) / char_w).floor() as usize;
         let fit = |s: String, budget: usize| -> String {
             if budget < 3 || s.chars().count() <= budget {
                 return s;
             }
             let mut out: String = s.chars().take(budget - 1).collect();
             out.push('\u{2026}');
             out
         };
         for (i, header) in self.headers.iter().enumerate() {
             if !col_visible(i) {
                 continue;
             }
             let cx = xoff + edges[i] + 8.0;
             let budget = budget_of(i);
             match self.sort {
                 Some((col, ascending)) if col == i => {
                     // The sorted column: its name, then the `chevron-up` or
                     // `chevron-down` glyph a cell after it — the room of
                     // the " ▲" it was until 2026-10-05, taken out of the
                     // name's budget.
                     let b = budget.saturating_sub(2);
                     let shown: String = if b < 3 || header.chars().count() <= b {
                         header.clone()
                     } else {
                         let mut out: String = header.chars().take(b - 1).collect();
                         out.push('\u{2026}');
                         out
                     };
                     let tx = cx + shown.chars().count() as f32 * char_w + 0.5 * char_w;
                     ctx.text_with(shown, cx, y + 6.0, 12.0, [0xff, 0xff, 0xff], None, col_bounds(i, y, HEADER_H));
                     const SIDE: f32 = 8.0;
                     let r = Rect { x: tx, y: y + 0.5 * (HEADER_H - SIDE), width: SIDE, height: SIDE };
                     ctx.icon(if ascending { "chevron-up" } else { "chevron-down" }, r, [1.0, 1.0, 1.0, 1.0]);
                 }
                 _ => ctx.text_with(fit(header.clone(), budget), cx, y + 6.0, 12.0, [0xdd, 0xdd, 0xee], None, col_bounds(i, y, HEADER_H)),
             }
         }
         // A row half scrolled under the header or off the bottom draws its
         // text CUT at the body band, as its zebra fill is. Until 2026-09-30
         // it drew no text until it was wholly inside, so a scrolling row's
         // band arrived empty and its values popped in a row's height late.
         for (i, &src) in self.order.iter().enumerate() {
             let ry = y + HEADER_H + i as f32 * ROW_H - scroll;
             let top = ry.max(body_top);
             let bottom = (ry + ROW_H).min(body_bottom);
             if bottom <= top {
                 continue;
             }
             // Written here, for the cells on screen only (`SheetColumn`).
             for (col_idx, column) in self.columns.iter().enumerate().take(n_cols) {
                 if !col_visible(col_idx) {
                     continue;
                 }
                 let cx = xoff + edges[col_idx] + 8.0;
                 ctx.text_with(fit(column.cell(src), budget_of(col_idx)), cx, ry + 6.0, 12.0, [0xbb, 0xbb, 0xcc], None, col_bounds(col_idx, top, bottom - top));
             }
         }
     }
 }
 
 impl Input for Spreadsheet {
     fn on_event(&mut self, event: &Event, ectx: &mut EventCtx) -> bool {
         match event {
             Event::PointerMove { x: px, y: py, .. } => {
                 let r = ectx.rect;
                 let was_hovered = self.hovered;
                 self.hovered =
                     *px >= r.x && *px <= r.x + r.width && *py >= r.y && *py <= r.y + r.height;
 
                 // Over a bar: hover only SUSTAINS a raised bar — a sunk one
                 // is behind the plate, and the pointer is on the plate.
                 let over = self.over_vbar(*px, *py, r) || self.over_hbar(*px, *py, r);
                 self.activity.set_hover(over);
                 let flipped = self.recompute_bars(r);
                 let was_header = self.header_hover_col;
                 self.header_hover_col = self.header_col_at(*px, *py, r);
                 was_hovered != self.hovered || flipped || was_header != self.header_hover_col
             }
             // A left press on a column header cycles that column's sort:
             // ascending → descending → back to natural order.
             Event::MouseButton {
                 button: MouseButton::Left,
                 state: ElementState::Pressed,
                 x: px,
                 y: py,
                 ..
             } => {
                 let Some(col) = self.header_col_at(*px, *py, ectx.rect) else {
                     // Not the header: a row of the body, or nothing of ours.
                     let Some(place) = self.body_row_at(*px, *py, ectx.rect) else {
                         return false;
                     };
                     let had = self.selection_changed;
                     self.selection_changed = false;
                     self.press_row(place, self.ctrl, self.shift);
                     let changed = self.selection_changed;
                     self.selection_changed |= had;
                     return changed;
                 };
                 self.sort = match self.sort {
                     Some((c, true)) if c == col => Some((col, false)),
                     Some((c, false)) if c == col => None,
                     _ => Some((col, true)),
                 };
                 self.apply_sort();
                 true
             }
             // Hit-gated by the adapter (which also rejects hidden widgets).
             Event::MouseWheel { delta, .. } => {
                 // Delta signs follow the ScrollRegion/TextBox convention (negate the
                 // event delta); natural scroll is already applied upstream by libinput.
                 let (dx, dy) = ScrollMotion::delta_px(delta, (ROW_H, ROW_H));
                 let by = self.geom(ectx.rect).map_or(Bounds::max(0.0), |g| Bounds::max(g.max_scroll));
                 let bx = self.hgeom(ectx.rect).map_or(Bounds::max(0.0), |g| Bounds::max(g.max_scroll));
                 // Claimed whenever the pointed axis can scroll at all (an
                 // overflowing table swallows its wheel), moved or not.
                 let used = (dy != 0.0 && by.hi > 0.0) || (dx != 0.0 && bx.hi > 0.0);
                 self.motion.reconcile(self.scroll_x, self.scroll_y);
                 let discrete = matches!(delta, MouseScrollDelta::LineDelta(..));
                 self.motion.apply_px(dx, dy, discrete, bx, by);
                 self.scroll_x = self.motion.x.pos();
                 self.scroll_y = self.motion.y.pos();
                 if used {
                     // A scroll is what brings the bars to the fore.
                     self.activity.bump();
                     self.recompute_bars(ectx.rect);
                 }
                 used
             }
             Event::KeyInput(key_event) => {
                 if key_event.state != ElementState::Pressed {
                     return false;
                 }
                 let Some(g) = self.geom(ectx.rect) else {
                     return false;
                 };
                 // Steps glide, and a held key accumulates from the glide's
                 // target rather than the offset drawn this frame.
                 self.motion.reconcile(self.scroll_x, self.scroll_y);
                 let by = Bounds::max(g.max_scroll);
                 let old = by.clamp(self.motion.y.target());
                 let new = match &key_event.logical_key {
                     Key::Named(NamedKey::ArrowDown) => old + ROW_H,
                     Key::Named(NamedKey::ArrowUp) => old - ROW_H,
                     Key::Named(NamedKey::PageDown) => old + g.visible_h,
                     Key::Named(NamedKey::PageUp) => old - g.visible_h,
                     Key::Named(NamedKey::Home) => 0.0,
                     Key::Named(NamedKey::End) => g.max_scroll,
                     _ => return false,
                 };
                 let moved = self.motion.y.scroll_to(new, by, &scroll_settings());
                 self.scroll_y = self.motion.y.pos();
                 if moved {
                     self.activity.bump();
                     self.recompute_bars(ectx.rect);
                 }
                 moved
             }
             _ => false,
         }
     }
 
     fn scrollable(&self) -> bool {
         true
     }
 
     fn set_modifiers(&mut self, ctrl: bool, shift: bool, _alt: bool) {
         self.ctrl = ctrl;
         self.shift = shift;
     }
 
     // --- Scrollbar drag, host-driven (the designer checks `draggable()` on the pressed widget
     // and then streams `drag_update` at it). `drag_begin` decides whether the press actually
     // landed on a RAISED scrollbar; a body press, or one on a bar sunk behind the plate,
     // starts no drag.
 
     fn draggable(&self, rect: Rect) -> bool {
         self.geom(rect).is_some() || self.hgeom(rect).is_some()
     }
 
     fn is_dragging(&self) -> bool {
         self.dragging_scrollbar || self.dragging_hscrollbar
     }
 
     fn drag_begin(&mut self, px: f32, py: f32, rect: Rect) {
         if !self.activity.raised() {
             return;
         }
         // A grab or release cancels any glide/coast in flight.
         self.motion = ScrollMotion::at(self.scroll_x, self.scroll_y);
         // The vertical bar owns the middle of the cross, where the two meet.
         if let Some(g) = self.geom(rect) {
             if self.over_vbar(px, py, rect) {
                 self.dragging_scrollbar = true;
                 if py >= g.thumb_y && py <= g.thumb_y + g.thumb_h {
                     self.drag_offset_y = py - g.thumb_y;
                 } else {
                     // Track click: jump the thumb's center to the pointer.
                     self.drag_offset_y = g.thumb_h / 2.0;
                     self.scroll_to_thumb(&g, py - self.drag_offset_y);
                 }
                 return;
             }
         }
         if let Some(g) = self.hgeom(rect) {
             if self.over_hbar(px, py, rect) {
                 self.dragging_hscrollbar = true;
                 if px >= g.thumb_x && px <= g.thumb_x + g.thumb_w {
                     self.drag_offset_x = px - g.thumb_x;
                 } else {
                     self.drag_offset_x = g.thumb_w / 2.0;
                     self.hscroll_to_thumb(&g, px - self.drag_offset_x);
                 }
             }
         }
     }
 
     fn drag_update(&mut self, px: f32, py: f32, rect: Rect) -> bool {
         if self.dragging_scrollbar {
             self.motion.y.jump_to(self.scroll_y);
             if let Some(g) = self.geom(rect) {
                 let old = g.scroll;
                 self.scroll_to_thumb(&g, py - self.drag_offset_y);
                 return (self.scroll_y - old).abs() > 0.01;
             }
             return false;
         }
         if self.dragging_hscrollbar {
             self.motion.x.jump_to(self.scroll_x);
             if let Some(g) = self.hgeom(rect) {
                 let old = g.scroll;
                 self.hscroll_to_thumb(&g, px - self.drag_offset_x);
                 return (self.scroll_x - old).abs() > 0.01;
             }
         }
         false
     }
 
     fn drag_end(&mut self) {
         if self.dragging_scrollbar || self.dragging_hscrollbar {
             // A release holds the bars up for the hold window, as a scroll does.
             self.activity.bump();
         }
         self.dragging_scrollbar = false;
         self.dragging_hscrollbar = false;
         // A grab or release cancels any glide/coast in flight.
         self.motion = ScrollMotion::at(self.scroll_x, self.scroll_y);
     }
 
     // --- Smooth scroll: the wheel/finger feed the shared motion; each frame advances it.
 
     fn tick(&mut self, dt: f32, rect: Rect) -> bool {
         self.motion.reconcile(self.scroll_x, self.scroll_y);
         let mut moved = false;
         if self.motion.is_animating() {
             let by = self.geom(rect).map_or(Bounds::max(0.0), |g| Bounds::max(g.max_scroll));
             let bx = self.hgeom(rect).map_or(Bounds::max(0.0), |g| Bounds::max(g.max_scroll));
             moved = self.motion.tick(dt, bx, by);
             self.scroll_x = self.motion.x.pos();
             self.scroll_y = self.motion.y.pos();
             if moved {
                 // A glide or a coast is scrolling too: the bars stay up for
                 // the whole of it, not only the hold after its first event.
                 self.activity.bump();
             }
         }
         // The raise/sink latch and its fade. Frames keep coming while the
         // hold runs and while the fade chases the latch, so the sink is
         // actually drawn rather than frozen at the last input event.
         let holding = self.activity.holding();
         let shown = self.scrollbars_shown(rect);
         let dragging = self.dragging_scrollbar || self.dragging_hscrollbar;
         let flipped = self.activity.tick(dt, shown, dragging);
         let fade = self.activity.fade();
         let fading = if self.activity.raised() { fade < 1.0 } else { fade > 0.0 };
         moved || self.motion.is_animating() || holding || flipped || fading
     }
 
     fn wants_tick(&self) -> bool {
         true
     }
 
 }
 
 impl Spreadsheet {
     /// Take a table: its headers, its columns and how many rows they hold.
     fn set_columns(&mut self, headers: Vec<String>, columns: Vec<SheetColumn>, rows: usize) {
         // Each column's width, from its header and its values: a refill
         // is a scan of the values it already copies.
         // The columns' widths are independent, so a large table works
         // them out a share of columns a thread (since 2026-10-07: at a
         // million values this pass was most of what a refill cost).
         let cells: Vec<usize> = {
             let values: usize = columns.iter().map(SheetColumn::len).sum();
             let threads = std::thread::available_parallelism().map_or(1, |n| n.get()).min(columns.len());
             if values < 200_000 || threads < 2 {
                 columns.iter().map(SheetColumn::max_chars).collect()
             } else {
                 let per = columns.len().div_ceil(threads);
                 std::thread::scope(|scope| {
                     let pieces: Vec<_> = columns
                         .chunks(per)
                         .map(|share| scope.spawn(move || share.iter().map(SheetColumn::max_chars).collect::<Vec<_>>()))
                         .collect();
                     pieces.into_iter().flat_map(|p| p.join().expect("a column's width")).collect()
                 })
             }
         };
         self.col_chars = headers
             .iter()
             .enumerate()
             .map(|(i, h)| (h.chars().count() + SORT_MARK_CHARS).max(cells.get(i).copied().unwrap_or(0)))
             .collect();
         self.headers = headers;
         self.columns = columns;
         self.row_count = rows;
         // Re-derive the display order so an active sort survives a data refresh
         // (the designer re-sets the whole table on selection/param changes).
         self.apply_sort();
         // The raw scroll may now exceed the new content; every consumer clamps through
         // `geom()`, and the next scroll write re-clamps it for real.
         //
         // The selection is of rows by index, and stands across a refresh:
         // the designer re-sets the table on every frame of a playback, and
         // the rows selected are still the elements they were. What a
         // shorter table no longer has goes.
         let n = self.row_count;
         let kept = self.selected.len();
         self.selected.retain(|&r| r < n);
         if self.selected.len() != kept {
             self.selection_changed = true;
         }
         if self.anchor.is_some_and(|a| a >= n) {
             self.anchor = None;
         }
     }
 }
 
 impl SpreadsheetController for Spreadsheet {
     fn set_spreadsheet_data(&mut self, headers: Vec<String>, rows: Vec<Vec<String>>) {
         // Rows of text become text columns, a cell a row; a short row's
         // missing cells are empty.
         let width = headers.len();
         let mut columns: Vec<Vec<String>> = (0..width).map(|_| Vec::with_capacity(rows.len())).collect();
         for row in &rows {
             for (c, column) in columns.iter_mut().enumerate() {
                 column.push(row.get(c).cloned().unwrap_or_default());
             }
         }
         self.set_columns(headers, columns.into_iter().map(SheetColumn::Text).collect(), rows.len());
     }
 
     fn set_spreadsheet_columns(&mut self, headers: Vec<String>, columns: Vec<SheetColumn>) {
         let rows = columns.iter().map(SheetColumn::len).max().unwrap_or(0);
         self.set_columns(headers, columns, rows);
     }
 
     fn selected_rows(&self) -> Vec<usize> {
         self.selected.iter().copied().collect()
     }
 
     fn set_selected_rows(&mut self, rows: &[usize]) {
         let n = self.row_count;
         let next: std::collections::BTreeSet<usize> = rows.iter().copied().filter(|&r| r < n).collect();
         if next != self.selected {
             self.selected = next;
             self.selection_changed = true;
         }
         if self.anchor.is_some_and(|a| !self.selected.contains(&a)) {
             self.anchor = None;
         }
     }
 
     fn take_selection_change(&mut self) -> bool {
         std::mem::take(&mut self.selection_changed)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::context::UiContext;
     use crate::widget::WidgetHost;
 
     fn filled(rows: usize) -> Adapted<Spreadsheet> {
         let mut s = Spreadsheet::new();
         s.set_visible(true);
         WidgetHost::set_rect(&mut s, 0.0, 0.0, 200.0, 124.0); // viewport: 100 = ~4 rows of 24
         let data: Vec<Vec<String>> =
             (0..rows).map(|i| vec![format!("r{i}"), format!("v{i}")]).collect();
         SpreadsheetController::set_spreadsheet_data(&mut *s, vec!["a".into(), "b".into()], data);
         s
     }
 
     fn wide(cols: usize) -> Adapted<Spreadsheet> {
         let mut s = Spreadsheet::new();
         s.set_visible(true);
         WidgetHost::set_rect(&mut s, 0.0, 0.0, 200.0, 124.0);
         let headers: Vec<String> = (0..cols).map(|i| format!("c{i}")).collect();
         let rows = vec![(0..cols).map(|i| format!("v{i}")).collect::<Vec<String>>(); 2];
         SpreadsheetController::set_spreadsheet_data(&mut *s, headers, rows);
         s
     }
 
     /// A row half scrolled out at either edge of the body draws its text cut
     /// at the band — it used to draw none until it was wholly inside.
     #[test]
     fn a_half_scrolled_row_draws_its_text_cut_at_the_body() {
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         let mut s = filled(20);
         s.scroll_y = ROW_H * 0.5;
         let mut pc = crate::scene::paint::PaintCtx::new();
         Paint::paint(&*s, rect, &mut pc);
         let items = pc.finish().items;
         let cell = |want: &str| {
             items.iter().find_map(|item| match &item.prim {
                 crate::scene::paint::Prim::Text { text, bounds, .. } if text == want => *bounds,
                 _ => None,
             })
         };
         let body_top = HEADER_H;
         let body_bottom = rect.height;
         // r0 spans -12..12 of the body; r4 runs 12 px past its bottom.
         let top = cell("r0").expect("the row under the header draws its text");
         assert_eq!((top[1], top[3]), (body_top, body_top + ROW_H * 0.5), "cut at the header");
         let bottom = cell("r4").expect("the row off the bottom draws its text");
         assert_eq!(bottom[3], body_bottom, "cut at the pane's bottom");
         assert!(bottom[1] < bottom[3]);
         assert!(cell("r5").is_none(), "a row wholly out of the body draws nothing");
     }
 
     /// Each column is as wide as its content — its header with room for the
     /// sort glyph, or its widest cell — and not a share of the pane: a
     /// narrow table leaves the rest of a wide pane empty, a wide one scrolls.
     #[test]
     fn columns_fit_their_content_and_overflow_scrolls() {
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         let cw = Spreadsheet::char_w();
         let mut s = Spreadsheet::new();
         s.set_visible(true);
         WidgetHost::set_rect(&mut s, 0.0, 0.0, 200.0, 124.0);
         SpreadsheetController::set_spreadsheet_columns(
             &mut *s,
             vec!["#".into(), "a_long_header_name".into(), "x".into()],
             vec![
                 SheetColumn::Int((0..1000).collect()),
                 SheetColumn::Int(vec![0, 1]),
                 SheetColumn::Float { values: vec![-1.5, 12.25], decimals: 4 },
             ],
         );
         let edges = (*s).col_edges();
         let w = |c: usize| edges[c + 1] - edges[c];
         // "999" is three; "#" and its sort room three too.
         assert!((w(0) - (3.0 * cw + CELL_PAD)).abs() < 0.01);
         // The header, not the 0 and 1, sizes the second.
         assert!((w(1) - ((18 + SORT_MARK_CHARS) as f32 * cw + CELL_PAD)).abs() < 0.01);
         // "-1.5000" and "12.2500" are seven.
         assert!((w(2) - (7.0 * cw + CELL_PAD)).abs() < 0.01);
         let g = (*s).hgeom(rect).expect("a run wider than 200 px scrolls");
         assert!((g.max_scroll - (edges[3] - 200.0)).abs() < 0.01);
 
         let fits = wide(2);
         assert!((*fits).hgeom(rect).is_none(), "2 short columns fit, no h-scroll");
         assert!(*(*fits).col_edges().last().unwrap() < 200.0, "and do not stretch to the pane");
     }
 
     /// A column's widest cell, from its values: a whole number's least or
     /// greatest, a float's sign and integer digits plus its decimals, and
     /// the non-finite spellings.
     #[test]
     fn a_columns_widest_cell_is_worked_out_from_its_values() {
         assert_eq!(SheetColumn::Int(vec![-12, 5, 300]).max_chars(), 3);
         assert_eq!(SheetColumn::Int(vec![-1200, 5]).max_chars(), 5);
         assert_eq!(SheetColumn::Float { values: vec![0.5, -0.25], decimals: 4 }.max_chars(), 7);
         assert_eq!(SheetColumn::Float { values: vec![0.5, f32::NEG_INFINITY], decimals: 1 }.max_chars(), 4);
         assert_eq!(SheetColumn::Float { values: vec![f32::NAN], decimals: 4 }.max_chars(), 3);
         assert_eq!(SheetColumn::Text(vec!["ab".into(), "abcd".into()]).max_chars(), 4);
         assert_eq!(SheetColumn::Int(vec![]).max_chars(), 0);
         for col in [SheetColumn::Int(vec![-7, 42]), SheetColumn::Float { values: vec![-3.25, 120.0], decimals: 3 }] {
             let written = (0..col.len()).map(|r| col.cell(r).chars().count()).max().unwrap();
             assert_eq!(col.max_chars(), written, "as `cell` writes them");
         }
     }
 
     /// The sort hit-test must look up columns through the scrolled origin, or
     /// clicking a header would sort the column that USED to be under the pointer.
     #[test]
     fn header_hit_test_tracks_horizontal_scroll() {
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         let mut s = wide(6);
         assert_eq!((*s).header_col_at(10.0, 5.0, rect), Some(0));
         s.scroll_x = (*s).col_edges()[1];
         assert_eq!((*s).header_col_at(10.0, 5.0, rect), Some(1));
     }
 
     /// A horizontal wheel feeds hscroll velocity, tick integrates and decays it,
     /// and the scroll clamps inside the overflow.
     #[test]
     fn horizontal_wheel_integrates_and_decays_through_tick() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(wide(6));
 
         let wheel = Event::MouseWheel {
             delta: MouseScrollDelta::LineDelta(-2.0, 0.0),
             x: 50.0,
             y: 60.0,
             local_x: 50.0,
             local_y: 60.0,
         };
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&wheel, ctx)).unwrap(), "in-rect horizontal wheel consumed");
         assert!(ctx.lend_h(s, |w, ctx| WidgetHost::tick(w, 0.016, ctx)).unwrap(), "first tick moves the h-scroll");
         let mut guard = 0;
         while ctx.lend_h(s, |w, ctx| WidgetHost::tick(w, 0.016, ctx)).unwrap() {
             guard += 1;
             assert!(guard < 1000, "h-inertia must decay to a stop");
         }
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         let max = (*ctx[s]).hgeom(rect).unwrap().max_scroll;
         assert!(ctx[s].scroll_x >= 0.0 && ctx[s].scroll_x <= max, "h-scroll stays clamped");
         assert!(ctx[s].scroll_x > 0.0, "negative dx scrolled the columns (ScrollRegion sign convention)");
 
         // A pane whose columns fit ignores horizontal wheels.
         let fits = ctx.insert(wide(2));
         assert!(!ctx.lend_h(fits, |w, ctx| w.handle_event(&wheel, ctx)).unwrap(), "no overflow, wheel passes through");
     }
 
     #[test]
     fn wheel_velocity_integrates_and_decays_through_tick() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(filled(50));
 
         // A wheel over the body feeds velocity (negated delta, the ScrollRegion
         // convention: a negative line delta scrolls the view down)…
         let wheel = Event::MouseWheel {
             delta: MouseScrollDelta::LineDelta(0.0, -2.0),
             x: 50.0,
             y: 60.0,
             local_x: 50.0,
             local_y: 60.0,
         };
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&wheel, ctx)).unwrap(), "in-rect wheel consumed");
 
         // …which tick integrates into scroll movement and decays to a stop.
         assert!(ctx.lend_h(s, |w, ctx| WidgetHost::tick(w, 0.016, ctx)).unwrap(), "first tick moves the scroll");
         let mut guard = 0;
         while ctx.lend_h(s, |w, ctx| WidgetHost::tick(w, 0.016, ctx)).unwrap() {
             guard += 1;
             assert!(guard < 1000, "inertia must decay to a stop");
         }
 
         // Hidden spreadsheets are not hittable, so the wheel passes through.
         ctx[s].set_visible(false);
         assert!(!ctx.lend_h(s, |w, ctx| w.handle_event(&wheel, ctx)).unwrap(), "hidden widget ignores wheel");
     }
 
     #[test]
     fn scrollbar_drag_and_keys_move_the_scroll() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(filled(50));
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
 
         // content 1200, viewport 100 -> overflowing, so the host may drag it.
         assert!(ctx[s].draggable());
 
         // Sunk behind the plate, the bar takes no press.
         ctx[s].drag_begin(100.0, 80.0);
         assert!(!ctx[s].is_dragging(), "a sunk bar is not grabbed");
 
         // Raised, a press on its track (the pane'ctx[s] centre line) jumps the
         // thumb and engages the drag.
         ctx[s].inner_mut().activity.bump();
         ctx[s].inner_mut().recompute_bars(rect);
         ctx[s].drag_begin(100.0, 80.0);
         assert!(ctx[s].is_dragging());
         assert!(ctx[s].drag_update(100.0, 90.0), "thumb drag scrolls");
         let dragged_to = ctx[s].inner().geom(rect).unwrap().scroll;
         assert!(dragged_to > 0.0);
         ctx[s].drag_end();
         assert!(!ctx[s].is_dragging());
 
         // A body press (left of the scrollbar) engages no drag.
         ctx[s].drag_begin(50.0, 60.0);
         assert!(!ctx[s].is_dragging(), "body press is not a scrollbar drag");
 
         // End key jumps to max; Home returns to zero. (Keys route via keyboard_input.)
         let end = crate::widget::KeyEvent {
             state: ElementState::Pressed,
             logical_key: Key::Named(NamedKey::End),
             text: None,
             repeat: false,
             ctrl: false,
             shift: false,
             alt: false,
         };
         assert!(ctx.lend_h(s, |w, ctx| w.keyboard_input(&end, ctx)).unwrap());
         // The key glides: run the motion out before reading the offset.
         for _ in 0..1000 {
             if !Input::tick(&mut *ctx[s].inner_mut(), 1.0 / 60.0, rect) {
                 break;
             }
         }
         let g = ctx[s].inner().geom(rect).unwrap();
         assert_eq!(g.scroll, g.max_scroll);
 
         // Hidden: the focused-widget keyboard path must not consume keys.
         ctx[s].set_visible(false);
         assert!(!ctx.lend_h(s, |w, ctx| w.keyboard_input(&end, ctx)).unwrap(), "hidden widget ignores keys");
     }
 
     /// The middle of column `c`'s header — columns are as wide as their
     /// content, so a press is placed by the edges, not by a share of the pane.
     fn mid(s: &Adapted<Spreadsheet>, c: usize) -> f32 {
         let e = s.inner().col_edges();
         (e[c] + e[c + 1]) * 0.5
     }
 
     fn header_click(x: f32) -> Event {
         Event::MouseButton {
             button: MouseButton::Left,
             state: ElementState::Pressed,
             x,
             y: 10.0,
             local_x: x,
             local_y: 10.0,
         }
     }
 
     #[test]
     fn header_click_cycles_ascending_descending_natural() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(Spreadsheet::new());
         ctx[s].set_visible(true);
         WidgetHost::set_rect(&mut ctx[s], 0.0, 0.0, 200.0, 124.0);
         // Numeric strings out of lexicographic order: "10" must sort after "9".
         let rows = vec![
             vec!["10".to_string(), "b".to_string()],
             vec!["9".to_string(), "c".to_string()],
             vec!["2".to_string(), "a".to_string()],
         ];
         SpreadsheetController::set_spreadsheet_data(&mut *ctx[s], vec!["n".into(), "s".into()], rows);
         assert_eq!(ctx[s].inner().order, vec![0, 1, 2], "unsorted = natural order");
 
         // Click 1 on column 0: ascending, numeric.
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 0)), ctx)).unwrap());
         assert_eq!(ctx[s].inner().sort, Some((0, true)));
         assert_eq!(ctx[s].inner().order, vec![2, 1, 0], "2 < 9 < 10 numerically");
 
         // Click 2: descending.
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 0)), ctx)).unwrap());
         assert_eq!(ctx[s].inner().sort, Some((0, false)));
         assert_eq!(ctx[s].inner().order, vec![0, 1, 2]);
 
         // Click 3: back to natural order.
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 0)), ctx)).unwrap());
         assert_eq!(ctx[s].inner().sort, None);
         assert_eq!(ctx[s].inner().order, vec![0, 1, 2]);
 
         // Column 1 (lexicographic), then a body click changes nothing.
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 1)), ctx)).unwrap());
         assert_eq!(ctx[s].inner().order, vec![2, 0, 1], "a < b < c");
         let body = Event::MouseButton {
             button: MouseButton::Left,
             state: ElementState::Pressed,
             x: 50.0,
             y: 60.0,
             local_x: 50.0,
             local_y: 60.0,
         };
         ctx.lend_h(s, |w, ctx| w.handle_event(&body, ctx)).unwrap();
         assert_eq!(ctx[s].inner().sort, Some((1, true)), "body press is not a sort");
     }
 
     fn body_click(y: f32) -> Event {
         Event::MouseButton {
             button: MouseButton::Left,
             state: ElementState::Pressed,
             x: 50.0,
             y,
             local_x: 50.0,
             local_y: y,
         }
     }
 
     /// A press selects a row, ctrl toggles one, shift extends from the last
     /// pressed; the rows are named by their place in the DATA, so a sort
     /// moves the highlight and not what is selected; and a press on the
     /// scrollbar is not a press on a row.
     #[test]
     fn rows_select_alone_toggled_and_in_runs() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(filled(50));
         // Rows are 24 tall under a 24 header: row k spans 24 + 24k.
         let row_y = |k: usize| 24.0 + 24.0 * k as f32 + 12.0;
 
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(1)), ctx)).unwrap());
         assert_eq!(ctx[s].inner().selected_rows(), vec![1]);
         assert!(ctx[s].inner_mut().take_selection_change());
         assert!(!ctx[s].inner_mut().take_selection_change(), "taken once");
 
         // Plain press elsewhere replaces it.
         ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(2)), ctx)).unwrap();
         assert_eq!(ctx[s].inner().selected_rows(), vec![2]);
 
         // Ctrl adds and removes.
         crate::widget::WidgetHostExt::set_modifiers(&mut ctx[s], true, false, false);
         ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(0)), ctx)).unwrap();
         assert_eq!(ctx[s].inner().selected_rows(), vec![0, 2]);
         ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(2)), ctx)).unwrap();
         assert_eq!(ctx[s].inner().selected_rows(), vec![0]);
 
         // Shift runs from the last row pressed without it (row 2, the ctrl
         // press) to this one.
         crate::widget::WidgetHostExt::set_modifiers(&mut ctx[s], false, true, false);
         ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(0)), ctx)).unwrap();
         assert_eq!(ctx[s].inner().selected_rows(), vec![0, 1, 2]);
 
         // A plain press on the one selected row clears it.
         crate::widget::WidgetHostExt::set_modifiers(&mut ctx[s], false, false, false);
         ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(3)), ctx)).unwrap();
         ctx.lend_h(s, |w, ctx| w.handle_event(&body_click(row_y(3)), ctx)).unwrap();
         assert!(ctx[s].inner().selected_rows().is_empty());
 
         // A RAISED scrollbar'ctx[s] lane is the drag surface'ctx[s].
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         ctx[s].inner_mut().activity.bump();
         ctx[s].inner_mut().recompute_bars(rect);
         let press = Event::MouseButton {
             button: MouseButton::Left,
             state: ElementState::Pressed,
             x: 100.0,
             y: row_y(1),
             local_x: 100.0,
             local_y: row_y(1),
         };
         ctx.lend_h(s, |w, ctx| w.handle_event(&press, ctx));
         assert!(ctx[s].inner().selected_rows().is_empty(), "a scrollbar press selects nothing");
 
         // Under a sort the row pressed is the row SHOWN there, and a shift
         // run is the rows shown between.
         let t = ctx.insert(Spreadsheet::new());
         ctx[t].set_visible(true);
         WidgetHost::set_rect(&mut ctx[t], 0.0, 0.0, 200.0, 124.0);
         let rows = vec![
             vec!["10".to_string(), "b".to_string()],
             vec!["9".to_string(), "c".to_string()],
             vec!["2".to_string(), "a".to_string()],
         ];
         SpreadsheetController::set_spreadsheet_data(&mut *ctx[t], vec!["n".into(), "s".into()], rows.clone());
         ctx.lend_h(t, |w, ctx| w.handle_event(&header_click(mid(&*w, 0)), ctx)).unwrap(); // ascending: 2, 9, 10 = rows 2, 1, 0
         ctx.lend_h(t, |w, ctx| w.handle_event(&body_click(row_y(0)), ctx)).unwrap();
         assert_eq!(ctx[t].inner().selected_rows(), vec![2], "the first row shown is the data's third");
         crate::widget::WidgetHostExt::set_modifiers(&mut ctx[t], false, true, false);
         ctx.lend_h(t, |w, ctx| w.handle_event(&body_click(row_y(1)), ctx)).unwrap();
         assert_eq!(ctx[t].inner().selected_rows(), vec![1, 2]);
 
         // A refresh keeps what is selected, less what the table lost.
         SpreadsheetController::set_spreadsheet_data(&mut *ctx[t], vec!["n".into(), "s".into()], rows[..2].to_vec());
         assert_eq!(ctx[t].inner().selected_rows(), vec![1]);
         ctx[t].inner_mut().set_selected_rows(&[]);
         assert!(ctx[t].inner().selected_rows().is_empty());
         assert!(ctx[t].inner_mut().take_selection_change());
     }
 
     /// The two bars cross at the middle of the body; they idle behind the
     /// plate, where a press on them is the row's; a scroll brings them to the
     /// fore, a pointer over a raised bar holds it there past the hold, and
     /// with nothing holding them they sink again. Hover alone never raises.
     #[test]
     fn the_scrollbars_cross_at_the_body_and_sink_until_scrolled() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(Spreadsheet::new());
         ctx[s].set_visible(true);
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         WidgetHost::set_rect(&mut ctx[s], rect.x, rect.y, rect.width, rect.height);
         let headers: Vec<String> = (0..6).map(|i| format!("c{i}")).collect();
         let rows: Vec<Vec<String>> = (0..50).map(|r| (0..6).map(|c| format!("{r}.{c}")).collect()).collect();
         SpreadsheetController::set_spreadsheet_data(&mut *ctx[s], headers, rows);
 
         // A cross: the vertical bar centred on the width, the horizontal on
         // the body'ctx[s] height, each spanning its axis less the inset.
         let v = ctx[s].inner().geom(rect).expect("50 rows overflow");
         let h = ctx[s].inner().hgeom(rect).expect("6 floored columns overflow");
         let body_mid = HEADER_H + (rect.height - HEADER_H) * 0.5;
         assert!((v.bar_x + v.bar_w * 0.5 - rect.width * 0.5).abs() < 0.01, "vertical bar on the centre line");
         assert!((h.bar_y + h.bar_h * 0.5 - body_mid).abs() < 0.01, "horizontal bar on the body's centre line");
         assert_eq!((v.track_y, v.track_h), (HEADER_H + TRACK_INSET, rect.height - HEADER_H - 2.0 * TRACK_INSET));
         assert_eq!((h.track_x, h.track_w), (TRACK_INSET, rect.width - 2.0 * TRACK_INSET));
 
         let at = |x: f32, y: f32| Event::PointerMove { x, y, local_x: x, local_y: y };
         let mid = (rect.width * 0.5, body_mid);
 
         // Sunk: hovering raises nothing, and a press on the middle of the
         // cross is a press on the row there.
         assert!(!ctx[s].inner().scrollbars_raised());
         ctx.lend_h(s, |w, ctx| w.handle_event(&at(mid.0, mid.1), ctx)).unwrap();
         assert!(!ctx[s].inner().scrollbars_raised(), "hover never raises a sunk bar");
         assert!(ctx[s].inner().body_row_at(mid.0, mid.1, rect).is_some(), "a sunk bar's lane is the row's");
 
         // A scroll raises both; the lane is the bars' now, and the fore copy
         // fades in over the next frames.
         let wheel = Event::MouseWheel {
             delta: MouseScrollDelta::LineDelta(0.0, -1.0),
             x: 30.0,
             y: 40.0,
             local_x: 30.0,
             local_y: 40.0,
         };
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&wheel, ctx)).unwrap());
         assert!(ctx[s].inner().scrollbars_raised(), "a scroll raises the bars");
         assert!(ctx[s].inner().body_row_at(mid.0, mid.1, rect).is_none(), "a raised bar's lane is the drag's");
         assert!(ctx[s].inner().body_row_at(mid.0, mid.1 + 30.0, rect).is_none(), "the vertical bar off the middle too");
         for _ in 0..20 {
             Input::tick(&mut *ctx[s].inner_mut(), 0.016, rect);
         }
         assert_eq!(ctx[s].inner().scrollbar_fade(), 1.0, "faded all the way in");
 
         // The pointer on a bar holds it up long past the hold…
         ctx.lend_h(s, |w, ctx| w.handle_event(&at(mid.0, mid.1 + 30.0), ctx)).unwrap();
         for _ in 0..200 {
             Input::tick(&mut *ctx[s].inner_mut(), 0.016, rect);
         }
         assert!(ctx[s].inner().scrollbars_raised(), "hovered, a raised bar stays in front");
 
         // …and off it, the bars sink once the hold runs out, and fade away.
         ctx.lend_h(s, |w, ctx| w.handle_event(&at(30.0, 40.0), ctx)).unwrap();
         let mut guard = 0;
         while Input::tick(&mut *ctx[s].inner_mut(), 0.016, rect) {
             guard += 1;
             assert!(guard < 1000, "the sink settles");
         }
         assert!(!ctx[s].inner().scrollbars_raised(), "unheld, the bars sink");
         assert_eq!(ctx[s].inner().scrollbar_fade(), 0.0);
 
         // Painted: nothing of the bars while sunk (the host draws that copy
         // behind its plate), four pills while raised.
         let pills = |s: &Adapted<Spreadsheet>| {
             let mut pc = crate::scene::paint::PaintCtx::new();
             Paint::paint(&**s, rect, &mut pc);
             pc.finish().items.iter().filter(|i| matches!(i.prim, crate::scene::paint::Prim::RoundedRect { .. })).count()
         };
         assert_eq!(pills(&ctx[s]), 0, "a sunk bar is not painted over the cells");
         ctx.lend_h(s, |w, ctx| w.handle_event(&wheel, ctx)).unwrap();
         for _ in 0..20 {
             Input::tick(&mut *ctx[s].inner_mut(), 0.016, rect);
         }
         assert_eq!(pills(&ctx[s]), 4, "two tracks and two thumbs");
     }
 
     /// A table large enough to work its columns' widths out on several
     /// threads gets the widths one thread works out.
     #[test]
     fn a_large_tables_widths_are_worked_out_in_parallel_alike() {
         let n = 60_000;
         let columns: Vec<SheetColumn> = (0..6)
             .map(|c| {
                 if c % 2 == 0 {
                     SheetColumn::Float { values: (0..n).map(|r| ((r * 7919 + c * 13) % 100_003) as f32 * if c == 2 { -0.37 } else { 0.011 }).collect(), decimals: 4 }
                 } else {
                     SheetColumn::Int((0..n as i64).map(|r| r * (c as i64) - 1000).collect())
                 }
             })
             .collect();
         let headers: Vec<String> = (0..6).map(|c| format!("c{c}")).collect();
         let want: Vec<usize> = headers.iter().zip(&columns).map(|(h, c)| (h.chars().count() + SORT_MARK_CHARS).max(c.max_chars())).collect();
         let mut s = Spreadsheet::new();
         SpreadsheetController::set_spreadsheet_columns(&mut *s, headers, columns);
         assert_eq!(s.inner().col_chars, want);
     }
 
     /// A column's width in characters is its widest cell's, numbers by
     /// their range: over negatives, positives, values that round to zero
     /// either side, both zeros, the non-finite spellings, and integers.
     #[test]
     fn max_chars_is_the_widest_cell() {
         let widest = |c: &SheetColumn| (0..c.len()).map(|r| c.cell(r).chars().count()).max().unwrap_or(0);
         let floats = [
             vec![0.0, -0.0],
             vec![-0.0, 0.0],
             vec![1.5, -0.00001, 2.0],
             vec![123.456, -9.99996, 0.5],
             vec![-1234.5, 99999.0, 0.0],
             vec![f32::NAN, 1.0],
             vec![f32::NEG_INFINITY, 0.25],
             vec![f32::INFINITY],
             vec![],
         ];
         for values in floats {
             for decimals in [0, 2, 4] {
                 let c = SheetColumn::Float { values: values.clone(), decimals };
                 assert_eq!(c.max_chars(), widest(&c), "{values:?} at {decimals}");
             }
         }
         for ints in [vec![], vec![0], vec![-7, 3, 1200], vec![i64::MIN, 5], vec![-1, -100]] {
             let c = SheetColumn::Int(ints.clone());
             assert_eq!(c.max_chars(), widest(&c), "{ints:?}");
         }
     }
 
     /// A table of columns: the cells on screen are written as they are
     /// painted — to a float column's decimals, an integer as one — and only
     /// those; a sort compares the values, so 10 sorts after 9 without a
     /// cell being parsed, and an integer column likewise.
     #[test]
     fn a_column_table_is_written_as_painted_and_sorts_by_value() {
         let rect = Rect { x: 0.0, y: 0.0, width: 200.0, height: 124.0 };
         let mut ctx = UiContext::new();
         let s = ctx.insert(Spreadsheet::new());
         ctx[s].set_visible(true);
         WidgetHost::set_rect(&mut ctx[s], 0.0, 0.0, 200.0, 124.0);
         let n = 1000;
         SpreadsheetController::set_spreadsheet_columns(
             &mut *ctx[s],
             vec!["i".into(), "x".into()],
             vec![
                 SheetColumn::Int((0..n as i64).collect()),
                 SheetColumn::Float { values: (0..n).map(|r| ((r * 7919) % n) as f32 * 0.5 - 3.25).collect(), decimals: 4 },
             ],
         );
         assert_eq!(ctx[s].inner().row_count, n);
         let texts = |s: &Adapted<Spreadsheet>| -> Vec<String> {
             let mut pc = crate::scene::paint::PaintCtx::new();
             Paint::paint(&**s, rect, &mut pc);
             pc.finish()
                 .items
                 .iter()
                 .filter_map(|item| match &item.prim {
                     crate::scene::paint::Prim::Text { text, .. } => Some(text.clone()),
                     _ => None,
                 })
                 .collect()
         };
         let shown = texts(&ctx[s]);
         assert!(shown.contains(&"0".to_string()) && shown.contains(&"-3.2500".to_string()), "{shown:?}");
         assert!(!shown.contains(&"999".to_string()), "a row off screen is not written");
 
         // Sorted by x, ascending: the least value first, by value.
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 1)), ctx)).unwrap());
         let order = ctx[s].inner().order.clone();
         let x = |r: usize| ((r * 7919) % n) as f32 * 0.5 - 3.25;
         assert!(order.windows(2).all(|w| x(w[0]) <= x(w[1])));
         // And by i, descending (two more clicks on the first header).
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 0)), ctx)).unwrap());
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 0)), ctx)).unwrap());
         assert_eq!(ctx[s].inner().order[0], n - 1, "999 sorts after 99 and 100");
         assert_eq!(SheetColumn::Float { values: vec![1.0 / 3.0], decimals: 2 }.cell(0), "0.33");
         assert_eq!(SheetColumn::Int(vec![-4]).cell(0), "-4");
         assert_eq!(SheetColumn::Int(vec![]).cell(3), "", "past the end is empty");
     }
 
     #[test]
     fn data_refresh_reapplies_sort_and_column_shrink_clears_it() {
         let mut ctx = UiContext::new();
         let s = ctx.insert(Spreadsheet::new());
         ctx[s].set_visible(true);
         WidgetHost::set_rect(&mut ctx[s], 0.0, 0.0, 200.0, 124.0);
         SpreadsheetController::set_spreadsheet_data(
             &mut *ctx[s],
             vec!["a".into(), "b".into()],
             vec![vec!["1".into(), "x".into()], vec!["2".into(), "y".into()]],
         );
         assert!(ctx.lend_h(s, |w, ctx| w.handle_event(&header_click(mid(&*w, 1)), ctx)).unwrap()); // sort col 1 asc
 
         // A refresh with new rows keeps the sort and re-derives the order.
         SpreadsheetController::set_spreadsheet_data(
             &mut *ctx[s],
             vec!["a".into(), "b".into()],
             vec![vec!["1".into(), "z".into()], vec!["2".into(), "w".into()]],
         );
         assert_eq!(ctx[s].inner().sort, Some((1, true)));
         assert_eq!(ctx[s].inner().order, vec![1, 0], "w < z");
 
         // A refresh that drops the sorted column clears the sort.
         SpreadsheetController::set_spreadsheet_data(
             &mut *ctx[s],
             vec!["a".into()],
             vec![vec!["1".into()], vec!["2".into()]],
         );
         assert_eq!(ctx[s].inner().sort, None);
         assert_eq!(ctx[s].inner().order, vec![0, 1]);
     }
 }