teksilo_widgets/table_view/

header.rs

// SPDX-License-Identifier: MPL-2.0
// SPDX-FileCopyrightText: 2026 FernTech

//! Per-column header cells.
//!
//! `HeaderCell` lays out as
//! `Padding → HStack { TextWidget(label), Spacer, SortIndicator? }` and
//! handles click-to-sort plus drag-to-resize on the grip that straddles
//! *either* of the two column dividers it touches (see the type's docs).
//! [`TableHeader`](super::table_header::TableHeader) lays the cells out
//! horizontally using the same shared `column_widths` handle that body rows
//! consume — so a resize commits in one place and reflows everywhere — and
//! paints the column separators that make those grips findable.
//!
//! Supports sort, resize, reuse across pinned panes, per-column filter
//! popovers, and the start of a column-reorder drag (the strip is its drop
//! target).
//!
//! ## Touch and pen
//!
//! A header cell paints three things inside one node and tells them apart by
//! coordinate: the label (whose press cycles the sort or starts the column
//! reorder), the filter-popover trigger, and the resize band on its trailing edge.
//!
//! The label and filter zones come from
//! [`partition_targets`](teksilo_core::partition::partition_targets), which gives
//! the filter zone the density's target floor by clamp-and-redistribute — the glyph
//! and its padding are below the conformance floor at every density — answers in
//! reading order so nothing mirrors for RTL, and splits evenly when the two floors
//! cannot both be met. The same function answers
//! [`teksilo_core::widget::Widget::target_regions`], so the
//! geometry an audit measures is the geometry the press test uses.
//!
//! The plain press stays `Ignored` so a finger can pan the table from its header
//! strip, and a coarse pointer's column reorder waits for a hold.

use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use teksilo_i18n::lit;

use teksilo_canvas::{Canvas, Path, Point, Rect, Size, SizeProposal};
use teksilo_core::accessibility::AccessNodeBuilder;
use teksilo_core::build_context::BuildContext;
use teksilo_core::color_prop::ColorProp;
use teksilo_core::drag_payload::DragPayload;
use teksilo_core::event::{EventResponse, PointerButton, WidgetEvent};
use teksilo_core::signal::Signal;
use teksilo_core::styles::{
    SharedTableStyle, SortDirection as StyleSortDirection, TableHeaderCellConfig,
};
use teksilo_core::widget::{
    CursorIcon, EventContext, LayoutContext, PaintContext, Widget, WidgetPlacement,
};
use teksilo_core::widget_builder::HandlerSet;
use teksilo_core::widget_id::WidgetId;
use teksilo_data::SortDirection;
use teksilo_tokens::{TextRole, TextStyleRole};

/// Convert the data-layer `SortDirection` (teksilo-data) to the
/// styles-layer one (teksilo-core::styles). They share the same shape
/// but are distinct types because teksilo-core cannot depend on
/// teksilo-data.
fn style_sort(d: SortDirection) -> StyleSortDirection {
    match d {
        SortDirection::Ascending => StyleSortDirection::Ascending,
        SortDirection::Descending => StyleSortDirection::Descending,
    }
}

use crate::primitives::{HStack, Padding, Spacer, TextWidget};

use super::ColumnReorderDragData;
use super::PaneBoundaries;
use super::body::SharedColumnWidths;
use super::column::ColumnResizePolicy;
use super::filter::FilterIndicator;
use super::filter::FilterPopoverContent;
use crate::overlay_trigger::OverlayTrigger;
use crate::popover_widget::PopoverWidget;
use teksilo_core::overlay::OverlayPlacement;

const DRAG_REORDER_THRESHOLD: f32 = 5.0;

/// Per-column resize metadata, in **display order** — the table a
/// [`HeaderCell`] consults to resolve a grabbed divider into the column it
/// actually resizes, and to clamp the committed width to exactly the bounds
/// [`ColumnSolver::resolve_in_order`](super::layout::ColumnSolver::resolve_in_order)
/// will re-apply to the override.
///
/// A cell owns *two* dividers (the one at its trailing edge and the one at
/// its leading edge, shared with its predecessor), so it cannot resize from
/// its own column's declaration alone — hence a shared table rather than
/// per-cell scalars.
#[derive(Debug, Clone)]
pub(crate) struct ColumnResizeInfo {
    /// Stable column id — the key `column_widths_signal` is written under.
    pub id: String,
    /// Floor a resize can't push this column below — the column's own
    /// `min_width` if declared, else the table's `min_column_width_default`.
    pub min_width: f32,
    /// Ceiling, if the column declared one.
    pub max_width: Option<f32>,
    /// Whether the column opted into drag-resize at all.
    pub resizable: bool,
    /// Whether the column's declared width is `Flex` — it shares the pane's
    /// leftover, so it would absorb part of any resize made *after* it in
    /// display order unless [`commit_resize`] freezes it first.
    pub flex: bool,
}

/// Shared, display-ordered [`ColumnResizeInfo`] table. Rebuilt (and re-shared
/// into every `HeaderCell`) on each view rebuild, which is also when the
/// display order can change — so an index into it is always current.
pub(crate) type ColumnResizeTable = Rc<Vec<ColumnResizeInfo>>;

/// Which pane a display slot belongs to (0 = Leading-pinned, 1 = Middle /
/// scrollable, 2 = Trailing-pinned). Only used to decide whether two adjacent
/// slots share a *column* divider or a *pane seam* — a seam is not a resize
/// boundary, because under a nonzero `scroll_x` the column on its far side is
/// not the one visually adjacent to it.
fn pane_of(slot: usize, b: PaneBoundaries) -> u8 {
    if slot < b.leading_count {
        0
    } else if slot < b.middle_end {
        1
    } else {
        2
    }
}

/// Clamp a dragged width to the same `[min, max]` window the column solver
/// re-applies to the stored override. Keeping the two in lock-step is what
/// stops `column_widths_signal` — a *public* handle apps read back and
/// persist — from holding a width the table never renders.
fn clamp_width(w: f32, min: f32, max: Option<f32>) -> f32 {
    w.max(min).min(max.unwrap_or(f32::INFINITY))
}

/// Active resize state for one column. Anchored at PointerDown,
/// advanced on PointerMove, committed (and cleared) on PointerUp.
#[derive(Debug, Clone)]
pub(crate) struct ResizeState {
    /// Id of the column being resized — not necessarily the cell that owns
    /// the gesture, since grabbing a cell's *leading* edge resizes its
    /// predecessor (see [`HeaderCell`]'s grip docs).
    pub col_id: String,
    /// Display slot of the column being resized — the slot `col_id` occupies
    /// in the shared [`ColumnResizeTable`] / widths vector, so the commit can
    /// tell which columns precede it.
    pub target_index: usize,
    /// Display slot of the cell that took the pointer capture. Only that
    /// cell may advance or commit the drag; a mismatch means the event
    /// reached the wrong cell (capture lost) and must not move a column.
    pub anchor_index: usize,
    /// Pointer x at PointerDown, in **window** coordinates. Window-space
    /// (not cell-local) so the delta stays stable across the relayouts a
    /// Live-policy resize triggers: under RTL a widening column's
    /// physical-left edge — and thus the cell's local origin — moves
    /// mid-drag, so a cell-local anchor would drift. Window x doesn't.
    pub start_pointer_x: f32,
    /// Target column's width at PointerDown (in pixels).
    pub start_width: f32,
    /// Window x of the grabbed divider at PointerDown — the anchor the
    /// `OnRelease` preview line is offset from.
    pub start_divider_x: f32,
    /// Resolved floor / ceiling of the target column, snapshotted so the
    /// commit path needs no second lookup.
    pub min_width: f32,
    pub max_width: Option<f32>,
}

pub(crate) type ResizeStateHandle = Rc<RefCell<Option<ResizeState>>>;

/// Press state recorded on PointerDown in the label region of a
/// HeaderCell. If the pointer moves past `DRAG_REORDER_THRESHOLD`
/// before PointerUp, the cell starts a reorder drag; otherwise the
/// cell cycles its sort on PointerUp.
#[derive(Debug, Clone, Copy)]
struct PressState {
    pointer_x: f32,
    pointer_y: f32,
}

/// Everything one [`HeaderCell`] needs, gathered into a struct because the
/// positional constructor had outgrown readability (and clippy's
/// `too_many_arguments`) long before the resize grip needed three more
/// fields. Both `TableView` and `TreeTableView` fill this in the same shape.
pub(crate) struct HeaderCellSpec {
    pub col_id: String,
    pub label: String,
    pub col_index_1based: usize,
    pub sortable: bool,
    pub reorderable: bool,
    pub filterable: bool,
    /// Half-width of the resize grip: the grabbable band extends this far on
    /// **each** side of a column divider (the Qt `PM_HeaderGripMargin`
    /// convention), not just inside the cell that owns the divider.
    pub resize_grip: f32,
    /// Width of the trailing region reserved for the filter popover trigger
    /// (glyph + padding). Ignored when `filterable` is false.
    pub filter_zone_width: f32,
    pub current_sort: Option<SortDirection>,
    pub width_index: usize,
    pub pane_boundaries: PaneBoundaries,
    pub resize_columns: ColumnResizeTable,
    pub resize_policy: ColumnResizePolicy,
    pub resize_state: ResizeStateHandle,
    /// Display slot of the column under an active resize, or `None`. Shared
    /// view-wide: the *target* cell derives its `is_resizing` chrome from it,
    /// which is not always the cell holding the capture.
    pub resize_target: Signal<Option<usize>>,
    /// Window x of the prospective divider while an `OnRelease` drag is in
    /// flight, or `None`. The view paints it as a guide line — without it
    /// `OnRelease` gives the user no feedback at all until the button comes up.
    pub resize_preview_x: Signal<Option<f32>>,
    pub table_id: usize,
    pub sort_signal: Signal<Option<(String, SortDirection)>>,
    pub column_widths_signal: Signal<HashMap<String, f32>>,
    /// `Some` when `column_widths_signal` is adopted: where a resize keeps
    /// the widths it freezes instead (see [`commit_resize`]).
    pub frozen_widths: Option<SharedFrozenWidths>,
    pub column_widths: SharedColumnWidths,
    pub filters_signal: Signal<HashMap<String, String>>,
}

/// One header cell — label, optional sort indicator, click-to-sort,
/// drag-to-resize on either of the two dividers it touches.
///
/// ## The resize grip
///
/// A column divider is a boundary *between* two cells, so the grabbable band
/// straddles it: `resize_grip` px inside the cell on each side. Consequently
/// a cell claims two zones — its reading-order **trailing** edge (which
/// resizes *this* column) and its **leading** edge (which resizes its
/// **predecessor**, whose trailing edge that same divider is). Claiming only
/// the former, as this widget originally did, left the outer half of every
/// divider owned by the next cell's label region: a grab that missed by one
/// pixel cycled the sort or started a column-reorder drag instead of
/// resizing.
///
/// Under RTL the display order runs right-to-left, so "reading-order
/// trailing" is the cell's physical-**left** edge and the two zones swap
/// sides; the drag sign inverts with them (see `on_pointer_event`).
///
/// The leading zone is suppressed when the predecessor sits in a different
/// pane: that boundary is a pane *seam*, and under a nonzero `scroll_x` the
/// column on its far side is not the one visually adjacent to it.
pub(crate) struct HeaderCell {
    col_id: String,
    label: String,
    col_index_1based: usize,
    sortable: bool,
    reorderable: bool,
    /// Half-width of the resize grip — see the type docs.
    resize_grip: f32,
    /// Sort direction for *this* column, or `None` if it isn't the
    /// active sort column. Captured at build time and reflected in the
    /// AccessKit node + the chevron child.
    current_sort: Option<SortDirection>,
    sort_signal: Signal<Option<(String, SortDirection)>>,
    column_widths_signal: Signal<HashMap<String, f32>>,
    /// See [`HeaderCellSpec::frozen_widths`].
    frozen_widths: Option<SharedFrozenWidths>,
    /// Live resolved widths, shared with the row layout. Read at
    /// PointerDown to record the starting width of whichever column the
    /// grabbed divider belongs to.
    column_widths: SharedColumnWidths,
    /// Index of this column in the resolved-widths vector.
    width_index: usize,
    /// Pane partition, so the leading grip can be suppressed across a seam.
    pane_boundaries: PaneBoundaries,
    /// Display-ordered resize metadata for **all** columns — this cell needs
    /// its predecessor's floor/ceiling too.
    resize_columns: ColumnResizeTable,
    resize_policy: ColumnResizePolicy,
    resize_state: ResizeStateHandle,
    resize_target: Signal<Option<usize>>,
    resize_preview_x: Signal<Option<f32>>,
    /// Stable id of the owning TableView, propagated into the reorder
    /// drag payload so inter-table drops are rejected.
    table_id: usize,
    /// This cell's window-space leading edge, written by `place_children`
    /// and read by `on_pointer_event` to translate the window-coord
    /// pointer position into cell-local coords. Without this, the
    /// trailing-edge resize-zone test (`local_x > cell_w - resize_zone`)
    /// would compare against a window x that's always huge for any
    /// column past the first one, firing resize from the wrong region.
    cell_window_x: Rc<Cell<f32>>,
    /// This cell's placed width, written by `place_children`. The grip test
    /// runs against the geometry actually on screen rather than against the
    /// shared widths vector, so the two can never disagree (they do when the
    /// vector is shorter than the cell list and `TableHeader` falls back to an
    /// even split).
    cell_window_w: Rc<Cell<f32>>,
    /// The partition floor and reading direction, so `target_regions` — which
    /// is handed a rectangle and nothing else — can carve the same zones the
    /// press test carves. Written in `build` and `place_children`.
    zone_floor: Cell<f32>,
    zone_rtl: Cell<bool>,
    /// This cell's resolved height, written by `place_children` and read
    /// by `on_pointer_event` to reject pointer events that bubble up from
    /// the in-tree filter popover (a descendant overlay anchored below the
    /// cell). Without it the x-only resize-zone test paints a `ColResize`
    /// cursor across the whole popover.
    cell_window_h: Rc<Cell<f32>>,
    /// `true` when the column's `filterable` flag is set. Drives the
    /// filter popover affordance and a "leave-this-region-alone" zone
    /// in the cell's pointer handler so PointerDown over the popover
    /// trigger reaches the trigger instead of being eaten by sort.
    filterable: bool,
    /// Width of the trailing region reserved for the filter popover
    /// trigger (glyph + padding). Zero when `filterable` is false.
    filter_zone_width: f32,
    /// Live per-column filter map. The popover edits this signal in
    /// place via `set_filter` semantics — empty string removes the
    /// entry, non-empty string inserts/replaces it.
    filters_signal: Signal<HashMap<String, String>>,
    /// `true` while the pointer is inside the cell — drives the
    /// `Hover` overlay supplied by `TableStyle::make_header_cell`.
    /// Toggled by the cell's `on_hover` handler.
    is_hovered: Signal<bool>,
    /// `true` while **this column** is the one being resized — drives the
    /// `Pressed` overlay supplied by `TableStyle::make_header_cell`. Derived
    /// from the shared `resize_target` rather than set locally, so the
    /// highlight follows the column that moves even when the gesture is
    /// anchored on its neighbour's leading grip.
    is_resizing: Signal<bool>,

    // Build state
    root_child_id: Option<WidgetId>,
}

impl HeaderCell {
    pub(crate) fn new(spec: HeaderCellSpec) -> Self {
        let width_index = spec.width_index;
        let is_resizing = spec.resize_target.map(move |t| *t == Some(width_index));
        Self {
            col_id: spec.col_id,
            label: spec.label,
            col_index_1based: spec.col_index_1based,
            sortable: spec.sortable,
            reorderable: spec.reorderable,
            resize_grip: spec.resize_grip,
            current_sort: spec.current_sort,
            sort_signal: spec.sort_signal,
            column_widths_signal: spec.column_widths_signal,
            frozen_widths: spec.frozen_widths,
            column_widths: spec.column_widths,
            width_index,
            pane_boundaries: spec.pane_boundaries,
            resize_columns: spec.resize_columns,
            resize_policy: spec.resize_policy,
            resize_state: spec.resize_state,
            resize_target: spec.resize_target,
            resize_preview_x: spec.resize_preview_x,
            table_id: spec.table_id,
            cell_window_x: Rc::new(Cell::new(0.0)),
            cell_window_w: Rc::new(Cell::new(0.0)),
            zone_floor: Cell::new(0.0),
            zone_rtl: Cell::new(false),
            cell_window_h: Rc::new(Cell::new(0.0)),
            filterable: spec.filterable,
            filter_zone_width: if spec.filterable {
                spec.filter_zone_width
            } else {
                0.0
            },
            filters_signal: spec.filters_signal,
            is_hovered: Signal::new(false),
            is_resizing,
            root_child_id: None,
        }
    }
}

impl std::fmt::Debug for HeaderCell {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("HeaderCell")
            .field("col_id", &self.col_id)
            .field("label", &self.label)
            .field("sortable", &self.sortable)
            .field(
                "resizable",
                &self
                    .resize_columns
                    .get(self.width_index)
                    .map(|c| c.resizable)
                    .unwrap_or(false),
            )
            .field("current_sort", &self.current_sort)
            .finish()
    }
}

/// `part` discriminator: the sort / reorder zone carrying the column label.
pub const HEADER_PART_LABEL: u16 = 0;
/// `part` discriminator: the filter-popover trigger zone.
pub const HEADER_PART_FILTER: u16 = 1;
/// `part` discriminator: the column-resize band on the cell's trailing edge.
pub const HEADER_PART_RESIZE: u16 = 2;

/// The label / filter partition of one header cell, in the frame of `bounds`.
///
/// One function for the two questions a split cell has to answer the same way:
/// where the press test draws the boundary, and what
/// [`teksilo_core::widget::Widget::target_regions`]
/// reports. Both used to be open-coded — the press test as a physical-x
/// comparison with its own RTL branch, the report not at all — and a cell
/// painting two targets inside one node is exactly what `target_regions`
/// exists for.
///
/// The trailing resize grip is excluded: the resize test above owns that band,
/// on **both** of the cell's edges. What is left is split by
/// [`partition_targets`](teksilo_core::partition::partition_targets), which
/// gives the filter affordance its `floor` by
/// clamp-and-redistribute, answers in reading order (so nothing here mirrors
/// for RTL), and — when the two floors cannot both be met — splits evenly
/// rather than letting either zone vanish.
///
/// Returns `None` for a cell with no filter affordance: there is one zone, it
/// is the cell, and there is nothing to partition.
fn header_cell_zones(
    bounds: Rect,
    filter_zone_w: f32,
    grip: f32,
    floor: f32,
    rtl: bool,
) -> Option<[Rect; 2]> {
    if filter_zone_w <= 0.0 || bounds.width <= 0.0 {
        return None;
    }
    let usable_w = (bounds.width - grip).max(0.0);
    // The grip sits at the reading-order trailing edge, which is the physical
    // left one under RTL, so the usable band starts past it there.
    let usable = Rect::new(
        if rtl { bounds.x + grip } else { bounds.x },
        bounds.y,
        usable_w,
        bounds.height,
    );
    let label_w = (usable_w - filter_zone_w).max(0.0);
    let direction = if rtl {
        teksilo_core::environment::LayoutDirection::RightToLeft
    } else {
        teksilo_core::environment::LayoutDirection::LeftToRight
    };
    let zones = teksilo_core::partition::partition_targets(
        usable,
        &[label_w, filter_zone_w],
        floor,
        direction,
    );
    Some([zones[0], zones[1]])
}

impl Widget for HeaderCell {
    fn build(&mut self, ctx: &mut BuildContext) -> Vec<WidgetId> {
        use crate::styles::recipe_table_style as cp;

        let label_id = ctx.add(
            TextWidget::new(lit!(self.label.clone()))
                .style(TextStyleRole::Body)
                .color(ColorProp::from(TextRole::Primary))
                .single_line()
                .a11y_hidden(),
        );

        let mut row = HStack::new()
            .spacing(4.0)
            .child(label_id)
            .child(ctx.add(Spacer::new()));

        if self.current_sort.is_some() {
            let chevron = ctx.add(SortIndicator::new(
                self.current_sort,
                cp::SORT_INDICATOR_SIZE,
            ));
            row = row.child(chevron);
        }

        // Filter popover trigger — appears at the trailing end of the
        // cell after the sort indicator. The Popover content is a
        // `TextInput` with a trailing clear `IconButton` bound back
        // into `filters_signal`. Callers can also mutate
        // `filters_signal` programmatically.
        if self.filterable {
            let filters_signal = self.filters_signal.clone();
            let col_id = self.col_id.clone();
            let initial = self
                .filters_signal
                .get()
                .get(&self.col_id)
                .cloned()
                .unwrap_or_default();
            let active = !initial.is_empty();
            let glyph = FilterIndicator::new(cp::FILTER_INDICATOR_SIZE, active);
            let on_change = {
                let filters_signal = filters_signal.clone();
                let col_id = col_id.clone();
                move |s: &str| {
                    let mut m = filters_signal.get();
                    if s.is_empty() {
                        m.remove(&col_id);
                    } else {
                        m.insert(col_id.clone(), s.to_string());
                    }
                    filters_signal.set(m);
                }
            };
            // A custom (non-button) trigger, so `PopoverWidget` takes it through
            // `OverlayTrigger`. No `focus_on_show` slot: the popover asks for
            // focus by *panel* id and the framework walks to the first focusable
            // descendant, which is this panel's filter field.
            let popover = PopoverWidget::new(
                OverlayTrigger::around(glyph).named(lit!("Filter").resolve_now()),
            )
            .content(FilterPopoverContent::new(initial).on_change(on_change))
            .placement(OverlayPlacement::BelowPreferred)
            .show_disclosure_caret(false);
            let popover_id = ctx.add(popover);
            row = row.child(popover_id);
        }
        // Route the header cell's chrome through `TableStyle::make_header_cell`.
        // The default `RecipeTableStyle` returns a `ZStack` that overlays
        // a hover/resize background behind the label — apps install a
        // theme-wide `style_slots.table` or pass their own when wrapping
        // the table to swap the chrome wholesale.
        let style: SharedTableStyle = crate::styles::recipe_table_style::resolve_table_style(ctx);
        let row_id = ctx.add(row);
        // The gutter comes from the style, not from `cp::CELL_PADDING_*`: a
        // preset writes its own on the recipe (Fluent's 12 dp `ListViewItem`
        // gutter) and reading the module constant here rendered 8 dp whatever
        // the theme had decided. The two views measure their filter zone from
        // the same accessor, so the padding and the hit zone agree.
        let tokens = ctx.theme().input;
        let padded = ctx.add(
            Padding::symmetric(
                style.cell_padding_vertical(&tokens),
                style.cell_padding_horizontal(&tokens),
            )
            .child(row_id),
        );
        let cell_cfg = TableHeaderCellConfig {
            label: padded,
            sort: self.current_sort.map(style_sort),
            is_hovered: self.is_hovered.clone(),
            is_resizing: self.is_resizing.clone(),
        };
        let cell_root = style.make_header_cell(&cell_cfg, ctx);
        self.root_child_id = Some(cell_root);

        // Build a single pointer-event handler covering: cursor hint,
        // resize start (PointerDown in trailing zone), resize advance
        // (PointerMove with active state), sort cycle (PointerDown
        // outside the resize zone), and resize commit + capture release
        // (PointerUp).
        let sort_signal = self.sort_signal.clone();
        let widths_signal = self.column_widths_signal.clone();
        let frozen_widths = self.frozen_widths.clone();
        let widths_handle = self.column_widths.clone();
        let resize_state = self.resize_state.clone();
        let resize_target = self.resize_target.clone();
        let resize_preview_x = self.resize_preview_x.clone();
        let resize_columns = self.resize_columns.clone();
        let boundaries = self.pane_boundaries;
        let col_id = self.col_id.clone();
        let sortable = self.sortable;
        let reorderable = self.reorderable;
        let grip_base = self.resize_grip;
        let policy = self.resize_policy;
        let width_index = self.width_index;
        let table_id = self.table_id;
        let press_state: Rc<Cell<Option<PressState>>> = Rc::new(Cell::new(None));
        let self_id = ctx.self_id();
        let cell_window_x = self.cell_window_x.clone();
        let cell_window_w = self.cell_window_w.clone();
        let cell_window_h = self.cell_window_h.clone();
        let filter_zone_w = self.filter_zone_width;
        // The zone floor is a build-time read: a density change marks the tree
        // at `BindingLevel::Rebuild`, so a dimension baked here cannot go stale.
        let zone_floor = ctx.theme().input.target_size;
        self.zone_floor.set(zone_floor);
        let is_hovered = self.is_hovered.clone();
        // A coarse pointer's column reorder waits for a hold; see the escalation
        // arm in `PointerMove` for why the raw path cannot read
        // `DragActivation` and what this stands in for.
        let hold_armed: Rc<Cell<bool>> = Rc::new(Cell::new(false));
        let hold_for_press = hold_armed.clone();

        let handlers = HandlerSet::new()
            .on_hover({
                let is_hovered = is_hovered.clone();
                move |entered, _ctx| {
                    is_hovered.set(entered);
                }
            })
            // Arms the coarse-pointer reorder. A `long_press` recognizer is the
            // hold source this cell has: the reorder is a raw `start_drag` out
            // of `PointerMove` rather than an `on_drag` member of the pointer
            // sequence, so the tree resolves no `DragActivation` for it and
            // nothing defers it on the cell's behalf, and nothing on
            // `EventContext` hands a handler the input clock to time a hold
            // itself.
            //
            // Two consequences, both load-bearing. Installing it gives the cell
            // a gesture arena and so the implicit press capture, which is why
            // the escalation arm below must refuse a coarse pointer that has not
            // held — the cell now receives the moves of a pan that has left the
            // strip entirely. And it makes the hold this cell's: a header cell
            // has no context menu today, but anything that wants one has to
            // share a gesture the column reorder has already claimed.
            .on_long_press(move |_event, _ctx| {
                hold_for_press.set(true);
            })
            .on_pointer_event(move |event, ctx: &mut EventContext| {
                // Pointer events now deliver `position` in cell-local
                // coords (the framework converts once at dispatch), so
                // `local_x` is `position.x` directly. The resize math,
                // however, wants a *window-space* x that stays stable
                // across the relayouts a Live resize triggers (the cell's
                // own leading edge moves under RTL) — reconstruct it as
                // `position.x + cell_x0`, where `cell_x0` is the cell's
                // window-space leading edge written by `place_children`
                // (== this cell node's bounds origin).
                let cell_x0 = cell_window_x.get();
                // This cell's height, used to reject pointer events that
                // bubble up from the in-tree filter popover (a descendant
                // overlay anchored *below* the cell). Those arrive with a
                // local y outside `[0, cell_h]`; the resize/cursor logic is
                // x-only, so without this gate it paints a `ColResize`
                // cursor across the entire popover.
                let cell_h = cell_window_h.get();
                // Prefer the width `place_children` actually laid this cell
                // out at; fall back to the shared widths vector only before
                // the first layout has run.
                let cell_w = {
                    let placed = cell_window_w.get();
                    if placed > 0.0 {
                        placed
                    } else {
                        widths_handle
                            .borrow()
                            .get(width_index)
                            .copied()
                            .unwrap_or(0.0)
                    }
                };
                // Under RTL columns run right-to-left, so a cell's
                // reading-order trailing edge is its physical-*left* one and
                // the drag sign inverts. Read direction live.
                let rtl = ctx.is_rtl();

                // Resolve a cell-local x into the display slot of the column
                // whose divider is being grabbed, if any. See the type docs
                // for why a cell owns the grip on *both* of its edges.
                let target_at = |local_x: f32| -> Option<usize> {
                    if cell_w <= 0.0 {
                        return None;
                    }
                    // Never let the two half-grips eat more than half the
                    // cell: a column dragged down to a tiny `min_width` must
                    // keep a central band for sort / reorder, or it becomes
                    // permanently un-sortable and un-draggable.
                    let grip = grip_base.min(cell_w * 0.25);
                    if grip <= 0.0 {
                        return None;
                    }
                    let near_physical_leading = local_x <= grip;
                    let near_physical_trailing = local_x >= cell_w - grip;
                    let (on_own_edge, on_predecessor_edge) = if rtl {
                        (near_physical_leading, near_physical_trailing)
                    } else {
                        (near_physical_trailing, near_physical_leading)
                    };
                    if on_own_edge && resize_columns.get(width_index).is_some_and(|c| c.resizable) {
                        return Some(width_index);
                    }
                    if on_predecessor_edge && width_index > 0 {
                        let prev = width_index - 1;
                        // A pane seam is not a column divider: with the
                        // Middle pane scrolled, the column on its far side
                        // is not the one visually adjacent to it.
                        if pane_of(prev, boundaries) == pane_of(width_index, boundaries)
                            && resize_columns.get(prev).is_some_and(|c| c.resizable)
                        {
                            return Some(prev);
                        }
                    }
                    None
                };

                match event {
                    WidgetEvent::PointerMove { position, .. } => {
                        let local_x = position.x;
                        // 1. Active resize: advance regardless of pointer
                        //    location (the pointer is captured). Only the
                        //    cell that anchored the gesture may advance it —
                        //    an event reaching any other cell means the
                        //    capture was lost, and moving a column then would
                        //    look like the table resizing itself with no
                        //    button held.
                        // …and only while this cell still *owns* the press:
                        // capture is an arbitration act, so a grip that lost it
                        // must stop resizing even though its own state is set.
                        let active = resize_state.borrow().clone();
                        if let Some(state) = active
                            && state.anchor_index == width_index
                            && ctx.owns_pointer()
                        {
                            // Window-space delta — stable across the
                            // relayouts a Live resize triggers (see
                            // ResizeState::start_pointer_x). Reconstruct
                            // window x from the now cell-local position.
                            let delta = position.x + cell_x0 - state.start_pointer_x;
                            let signed = if rtl { -delta } else { delta };
                            let new_w = clamp_width(
                                state.start_width + signed,
                                state.min_width,
                                state.max_width,
                            );
                            match policy {
                                ColumnResizePolicy::Live => {
                                    commit_resize(
                                        &widths_signal,
                                        frozen_widths.as_ref(),
                                        &widths_handle,
                                        &resize_columns,
                                        state.target_index,
                                        new_w,
                                    );
                                }
                                ColumnResizePolicy::OnRelease => {
                                    // Nothing moves until release, so show
                                    // where the divider would land.
                                    let dir = if rtl { -1.0 } else { 1.0 };
                                    resize_preview_x.set(Some(
                                        state.start_divider_x + (new_w - state.start_width) * dir,
                                    ));
                                }
                            }
                            // Hold the resize shape for the whole drag: the
                            // pointer is captured, so it can travel far
                            // outside the grip (and outside the header) and
                            // must not look like it stopped resizing.
                            ctx.set_cursor(CursorIcon::ColResize);
                            return EventResponse::Handled;
                        }
                        // 2. Press state set, no resize: if movement
                        //    crosses the threshold, escalate to a
                        //    reorder drag.
                        //    A coarse pointer must have held first: a
                        //    horizontal swipe along the strip is a horizontal
                        //    pan, and at 5 dp the reorder used to take it
                        //    (measured: `max_scroll_x` 512, `scroll_x` 0, and
                        //    the columns swapped). A held contact is picking the
                        //    column up, which is the same ruling the row reorder
                        //    settles with `DragActivation` — reached here by a
                        //    `long_press` recognizer, because a raw `start_drag`
                        //    is not a sequence member and has no activation to
                        //    resolve.
                        if reorderable
                            && (hold_armed.get() || !ctx.pointer_kind().is_coarse())
                            && let Some(p) = press_state.get()
                        {
                            let dx = local_x - p.pointer_x;
                            let dy = position.y - p.pointer_y;
                            if (dx * dx + dy * dy).sqrt() > DRAG_REORDER_THRESHOLD {
                                press_state.set(None);
                                let payload = DragPayload::typed(ColumnReorderDragData {
                                    col_id: col_id.clone(),
                                    source_table_id: table_id,
                                });
                                ctx.start_drag(self_id, payload);
                                return EventResponse::Handled;
                            }
                        }
                        // 3. Cursor hint over either grip. Outside them we
                        //    explicitly reset to Default so the cursor shape
                        //    doesn't stay stuck on `ColResize` after the
                        //    pointer moves off the handle (PointerLeave alone
                        //    can't rescue this — it never fires while the
                        //    pointer stays inside the same cell, and the
                        //    node-level `Default` cursor installed below is
                        //    only restored on leave).
                        // Only manage the cursor for moves that are
                        // genuinely over this cell. Moves bubbling up from
                        // the filter popover (out-of-cell y) must leave the
                        // cursor alone, or the x-only grip test below paints
                        // `ColResize` across the popover.
                        let in_cell_y =
                            cell_h <= 0.0 || (position.y >= 0.0 && position.y <= cell_h);
                        if in_cell_y {
                            if target_at(local_x).is_some() {
                                ctx.set_cursor(CursorIcon::ColResize);
                                return EventResponse::Handled;
                            }
                            ctx.set_cursor(CursorIcon::Default);
                        }
                        EventResponse::Ignored
                    }
                    WidgetEvent::PointerDown {
                        position,
                        button: PointerButton::Primary,
                        ..
                    } => {
                        // Ignore presses bubbling up from the filter popover
                        // (out-of-cell y) — they must not record a header
                        // press / sort cycle.
                        if cell_h > 0.0 && (position.y < 0.0 || position.y > cell_h) {
                            return EventResponse::Ignored;
                        }
                        let local_x = position.x;
                        if let Some(target) = target_at(local_x) {
                            let info = &resize_columns[target];
                            let start_width =
                                widths_handle.borrow().get(target).copied().unwrap_or(0.0);
                            // Window x of the divider under the pointer: this
                            // cell's own trailing edge when resizing itself,
                            // its leading edge when resizing the predecessor
                            // — mirrored under RTL.
                            let resizing_self = target == width_index;
                            let own_edge_is_physical_leading = rtl;
                            let on_physical_leading = if resizing_self {
                                own_edge_is_physical_leading
                            } else {
                                !own_edge_is_physical_leading
                            };
                            let start_divider_x = if on_physical_leading {
                                cell_x0
                            } else {
                                cell_x0 + cell_w
                            };
                            *resize_state.borrow_mut() = Some(ResizeState {
                                col_id: info.id.clone(),
                                target_index: target,
                                anchor_index: width_index,
                                start_pointer_x: position.x + cell_x0,
                                start_width,
                                start_divider_x,
                                min_width: info.min_width,
                                max_width: info.max_width,
                            });
                            resize_target.set(Some(target));
                            ctx.set_cursor(CursorIcon::ColResize);
                            ctx.capture_pointer();
                            return EventResponse::Handled;
                        }
                        // Filter-popover trigger zone — leave it alone
                        // so the Popover's gesture-based tap handler
                        // running in the bubble pass can fire. Without
                        // this carve-out, the preview-pass handler
                        // would consume PointerDown and the popover
                        // would never open. The filter glyph sits at the
                        // trailing inner edge — physical-right under LTR,
                        // physical-left under RTL (the header HStack
                        // reverses), just inside the resize handle.
                        let in_filter_zone = header_cell_zones(
                            Rect::new(0.0, 0.0, cell_w, cell_h),
                            filter_zone_w,
                            grip_base,
                            zone_floor,
                            rtl,
                        )
                        .is_some_and(|[_, filter]| {
                            local_x >= filter.x && local_x <= filter.right()
                        });
                        if in_filter_zone {
                            return EventResponse::Ignored;
                        }
                        // Record press: PointerUp without movement →
                        // sort cycle; PointerMove past threshold →
                        // reorder drag. A fresh press has not held yet,
                        // whatever the last one did.
                        hold_armed.set(false);
                        press_state.set(Some(PressState {
                            pointer_x: local_x,
                            pointer_y: position.y,
                        }));
                        // **`Ignored`, deliberately, and it is what lets a
                        // finger scroll the table from its header strip.**
                        //
                        // This handler runs in the root-first preview pass for
                        // every press that lands on one of the cell's own
                        // children (its label, its indicators), and the first
                        // `Handled` there is step 1 of the decision procedure:
                        // the router reads it as a preview claim and *decides
                        // the sequence* for this cell. A decided sequence yields
                        // no candidates, so the table's own `PanClaim` was never
                        // evaluated and neither axis moved — measured, on the
                        // same 120 dp pan from the header of a table scrolled to
                        // 400: offset stayed 400 with `Handled`, reached 557
                        // with `Ignored`. It was not the reorder drag: the same
                        // 0 was measured with every column `reorderable(false)`.
                        //
                        // Nothing needed the claim. The two things this cell
                        // commits are the sort (which rides `press_state` and
                        // the framework's own press record) and the reorder
                        // (which escalates from `PointerMove`); the resize grip
                        // above still answers `Handled` and takes an explicit
                        // capture of its own.
                        EventResponse::Ignored
                    }
                    WidgetEvent::PointerUp { position, .. } => {
                        // Resize commit / release. Delta is window-space
                        // (reconstruct window x from cell-local position).
                        let taken = resize_state.borrow_mut().take();
                        if let Some(state) = taken {
                            // Only the anchoring cell commits. A mismatch
                            // means the capture was lost mid-gesture and this
                            // Up landed on a bystander by hit-test — clear the
                            // orphaned state so the next press starts clean,
                            // but never write a width from the wrong origin.
                            if state.anchor_index == width_index {
                                if policy == ColumnResizePolicy::OnRelease {
                                    let delta = position.x + cell_x0 - state.start_pointer_x;
                                    let signed = if rtl { -delta } else { delta };
                                    let new_w = clamp_width(
                                        state.start_width + signed,
                                        state.min_width,
                                        state.max_width,
                                    );
                                    commit_resize(
                                        &widths_signal,
                                        frozen_widths.as_ref(),
                                        &widths_handle,
                                        &resize_columns,
                                        state.target_index,
                                        new_w,
                                    );
                                }
                                resize_target.set(None);
                                resize_preview_x.set(None);
                                ctx.release_pointer();
                                return EventResponse::Handled;
                            }
                            resize_target.set(None);
                            resize_preview_x.set(None);
                        }
                        // Click without significant movement → sort cycle,
                        // and the `Down` arm's comment promises exactly that.
                        //
                        // Both halves come from
                        // [`release_completes_the_press`]. A press is closed
                        // when a peer claim takes it — which is how a header
                        // press that a scrollable's `PanClaim` won stops sorting
                        // the table it just scrolled — *and* when the pointer
                        // leaves the press's `TapBoundary`, which is the
                        // movement check, sized for the pointer holding it: a
                        // `tap_slop` radius for a mouse (5 dp — the same figure
                        // this cell's reorder threshold uses), the pressed
                        // node's own bounds for a finger. Measuring it here as
                        // well, against `PressState`, would be a second
                        // hardcoded radius for the framework's own question, and
                        // no case in the suite can tell the two apart.
                        //
                        // That delegation needs the press to *have* an owner,
                        // which it has because the `long_press` recognizer above
                        // gives this cell a gesture arena. Removing that
                        // recognizer without restoring a local distance check
                        // would leave the sort firing on a press dragged across
                        // the window;
                        // `a_mouse_click_on_a_column_header_sorts_it_and_a_wander_off_does_not`
                        // is what fails if anyone does.
                        //
                        // [`release_completes_the_press`]: crate::data_views::release_completes_the_press
                        let recorded_press = press_state.replace(None).is_some();
                        if recorded_press
                            && sortable
                            && crate::data_views::release_completes_the_press(ctx)
                        {
                            let next = match sort_signal.get() {
                                None => Some((col_id.clone(), SortDirection::Ascending)),
                                Some((id, SortDirection::Ascending)) if id == col_id => {
                                    Some((col_id.clone(), SortDirection::Descending))
                                }
                                Some((id, SortDirection::Descending)) if id == col_id => None,
                                Some(_) => Some((col_id.clone(), SortDirection::Ascending)),
                            };
                            sort_signal.set(next);
                            return EventResponse::Handled;
                        }
                        EventResponse::Ignored
                    }
                    _ => EventResponse::Ignored,
                }
            })
            // Assistive-technology path to the resize grip. Pointer-only
            // resize is unreachable by a screen reader, switch access, or the
            // automation MCP (whose action tools route through AccessKit), so
            // a resizable column advertises Increment / Decrement and steps
            // its width by `COLUMN_RESIZE_STEP` — clamped exactly like a drag,
            // so the two paths cannot disagree about the stored override.
            .on_access_action({
                let resize_columns = self.resize_columns.clone();
                let widths_handle = self.column_widths.clone();
                let widths_signal = self.column_widths_signal.clone();
                let frozen_widths = self.frozen_widths.clone();
                move |action, _ctx| {
                    use teksilo_core::accesskit::Action;
                    if !matches!(action, Action::Increment | Action::Decrement) {
                        return EventResponse::Ignored;
                    }
                    let Some(info) = resize_columns.get(width_index) else {
                        return EventResponse::Ignored;
                    };
                    if !info.resizable {
                        return EventResponse::Ignored;
                    }
                    let current = widths_handle
                        .borrow()
                        .get(width_index)
                        .copied()
                        .unwrap_or(0.0);
                    if current <= 0.0 {
                        return EventResponse::Ignored;
                    }
                    let step = if matches!(action, Action::Increment) {
                        crate::styles::recipe_table_style::COLUMN_RESIZE_STEP
                    } else {
                        -crate::styles::recipe_table_style::COLUMN_RESIZE_STEP
                    };
                    let next = clamp_width(current + step, info.min_width, info.max_width);
                    commit_resize(
                        &widths_signal,
                        frozen_widths.as_ref(),
                        &widths_handle,
                        &resize_columns,
                        width_index,
                        next,
                    );
                    EventResponse::Handled
                }
            })
            // Default node cursor — the framework restores this on
            // PointerLeave, which guarantees the resize cursor doesn't
            // bleed across cells when the pointer exits HeaderCell from
            // inside the resize zone (where on_pointer_event last set
            // it to `ColResize`).
            .cursor(CursorIcon::Default)
            .focusable(false);
        ctx.apply_self_handlers(handlers);

        vec![cell_root]
    }

    fn layout_response(
        &self,
        proposal: SizeProposal,
        ctx: &LayoutContext,
    ) -> teksilo_core::widget::LayoutResponse {
        match self.root_child_id {
            Some(id) => ctx
                .child_size(id, proposal)
                .unwrap_or_else(|| proposal.resolve(0.0, 0.0)),
            None => proposal.resolve(0.0, 0.0),
        }
        .into()
    }

    fn place_children(
        &self,
        bounds: Rect,
        _proposal: SizeProposal,
        children: &mut [WidgetPlacement],
        ctx: &LayoutContext,
    ) {
        // Snapshot the cell's window-space physical-left edge so the
        // pointer-event handler can convert window x to cell-local x
        // (`local_x ∈ [0, cell_w]` in both directions), plus the placed
        // size the grip test runs against.
        self.cell_window_x.set(bounds.x);
        self.cell_window_w.set(bounds.width);
        self.cell_window_h.set(bounds.height);
        // `target_regions` is handed a rectangle and no context, so the
        // direction it must partition in is recorded here.
        self.zone_rtl.set(ctx.is_rtl());
        for child in children.iter_mut() {
            child.origin = bounds.origin();
            child.size = bounds.size();
        }
    }

    /// The label zone, the filter zone, and the resize band on the cell's
    /// reading-order trailing edge.
    ///
    /// All three are geometry inside one node — the cell's chrome is one
    /// composed subtree and its parts are told apart by coordinate at press
    /// time — so without this report the filter affordance and the grip do not
    /// exist to anything outside the press handler: not to a conformance audit,
    /// and not to a router that would route a coarse press to the nearest
    /// target. The rectangles come from [`header_cell_zones`], the same
    /// function the press test asks, so the report and the routing cannot
    /// drift.
    ///
    /// A cell with no filter affordance reports nothing: its one target is its
    /// own node, which every consumer can already see.
    fn target_regions(&self, bounds: Rect) -> Vec<teksilo_core::partition::TargetRegion> {
        use teksilo_core::partition::TargetRegion;
        let Some([label, filter]) = header_cell_zones(
            bounds,
            self.filter_zone_width,
            self.resize_grip,
            self.zone_floor.get(),
            self.zone_rtl.get(),
        ) else {
            return Vec::new();
        };
        let grip = if self.zone_rtl.get() {
            Rect::new(bounds.x, bounds.y, self.resize_grip, bounds.height)
        } else {
            Rect::new(
                bounds.right() - self.resize_grip,
                bounds.y,
                self.resize_grip,
                bounds.height,
            )
        };
        vec![
            TargetRegion::target(label, HEADER_PART_LABEL),
            TargetRegion::target(filter, HEADER_PART_FILTER),
            TargetRegion::grab(grip, HEADER_PART_RESIZE),
        ]
    }

    // No `paint()` — the cell's visual chrome is composed via
    // `TableStyle::make_header_cell`, layered behind the label inside
    // a `ZStack`. The outer `TableHeader` paints the shared `Raised`
    // background for the whole strip, so a transparent cell default
    // (`SurfaceRole::Transparent`) lets the row chrome show through
    // while hover / resize overlays come from the composed body.

    fn accessibility(&self, builder: &mut AccessNodeBuilder) {
        builder.set_role(teksilo_core::accesskit::Role::ColumnHeader);
        builder.set_name(self.label.clone());
        // Advertise the resize grip to assistive technology. Deliberately
        // actions only, with no `numeric_value` / range: a value on a
        // `ColumnHeader` would be read out on every ordinary pass over the
        // table, trading a noisier common case for a rarer one. The actions
        // are invocable without being announced.
        if self
            .resize_columns
            .get(self.width_index)
            .is_some_and(|c| c.resizable)
        {
            builder.add_action(teksilo_core::accesskit::Action::Increment);
            builder.add_action(teksilo_core::accesskit::Action::Decrement);
        }
        // Through the typed wrapper, which converts the ARIA 1-based index to
        // AccessKit's zero-based `column_index`. `inner_mut()` would not.
        builder.set_column_index(self.col_index_1based);
        let n = builder.inner_mut();
        if let Some(dir) = self.current_sort {
            let ak_dir = match dir {
                SortDirection::Ascending => teksilo_core::accesskit::SortDirection::Ascending,
                SortDirection::Descending => teksilo_core::accesskit::SortDirection::Descending,
            };
            n.set_sort_direction(ak_dir);
        }
    }

    fn children(&self) -> Vec<WidgetId> {
        self.root_child_id.into_iter().collect()
    }
}

/// Commit a user resize of the column at display slot `target` to `new_w`.
///
/// Writes the target's override and, in the **same** update, freezes every
/// un-overridden `Flex` column that *precedes* it in display order at its
/// current resolved width. Without that, the solver shares the leftover the
/// resize consumed (or freed) among every flex column — the ones before the
/// target included — so the target's leading edge slides the other way and
/// the grabbed divider tracks the pointer at a fraction of its speed
/// (`1 − p/m`, for `p` of the `m` remaining flex weights ahead of it), or not
/// at all once every remaining flex column is ahead of it. What the user then
/// sees is the dividers on the far side of the grip sweeping *against* the
/// mouse while the grabbed one barely moves.
///
/// Every desktop table keeps the columns before a dragged divider where they
/// are and reflows only the ones after it (NSTableView's column autoresizing,
/// `QHeaderView`'s interactive sections with a stretch-last). Freezing the
/// preceding flex columns is what makes that hold here. Columns *after* the
/// target are left alone on purpose: they are the ones meant to absorb the
/// change, and once none of them can, the pane overflows into horizontal
/// scroll rather than moving the divider away from the pointer.
///
/// Where the freezes go depends on whose map `signal` is:
///
/// - The view's own (`frozen` is `None`): into the map, with the target. It
///   then records exactly what is on screen, so a persisted
///   `column_widths_signal` keeps matching the picture.
/// - An adopted one (`frozen` is `Some`): into `frozen`, which only this view
///   reads, and the map gets the target alone. An adopted map may be shared
///   by views of other widths, and a width frozen here is not the width the
///   column has there: written into the map, it would stop that view's flex
///   column flexing too, and leave it a gap or an overflow nobody asked for.
///
/// The frozen values come from the widths `place_children` last resolved —
/// already clamped to each column's `[min, max]` — so re-resolving them as
/// overrides changes nothing visible.
fn commit_resize(
    signal: &Signal<HashMap<String, f32>>,
    frozen: Option<&SharedFrozenWidths>,
    resolved: &SharedColumnWidths,
    columns: &ColumnResizeTable,
    target: usize,
    new_w: f32,
) {
    let mut m = signal.get();
    let own = || columns.iter().map(|c| c.id.as_str());
    let mut kept = frozen.map(|f| f.borrow_mut());
    if let Some(kept) = kept.as_mut()
        && !kept.hold(&m, own())
    {
        // The view has been laid out from the map alone since it changed, so
        // what is on screen is what to freeze from.
        kept.frozen.clear();
    }
    {
        let widths = resolved.borrow();
        for (slot, info) in columns.iter().enumerate().take(target) {
            let Some(&w) = widths.get(slot) else {
                continue;
            };
            if !info.flex || m.contains_key(&info.id) {
                continue;
            }
            match kept.as_mut() {
                Some(kept) => {
                    kept.frozen.entry(info.id.clone()).or_insert(w);
                }
                None => {
                    m.insert(info.id.clone(), w);
                }
            }
        }
    }
    if let Some(info) = columns.get(target) {
        m.insert(info.id.clone(), new_w);
    }
    if let Some(kept) = kept.as_mut() {
        kept.written = own()
            .filter_map(|id| m.get(id).map(|&w| (id.to_string(), w)))
            .collect();
    }
    // Released before the write, which notifies observers synchronously.
    drop(kept);
    signal.set(m);
}

/// The widths a resize froze in a view whose width map is adopted, kept out
/// of that map — see [`commit_resize`].
#[derive(Debug, Default)]
pub(crate) struct FrozenWidths {
    /// Column id → the width it was frozen at.
    frozen: HashMap<String, f32>,
    /// This view's own entries in the map just after its last resize.
    written: HashMap<String, f32>,
}

/// One view's [`FrozenWidths`], shared by its header cells and its layout.
pub(crate) type SharedFrozenWidths = Rc<RefCell<FrozenWidths>>;

impl FrozenWidths {
    /// Whether the freezes still apply: the map gives the view's columns
    /// (`own`) exactly what its last resize left there. Any other write to
    /// one of them (a reset, a setter, another view resizing a column the two
    /// share) puts the view back on the map alone. A write to a column the
    /// view lacks does not.
    fn hold<'a>(&self, map: &HashMap<String, f32>, mut own: impl Iterator<Item = &'a str>) -> bool {
        own.all(|id| map.get(id) == self.written.get(id))
    }
}

/// The width overrides a view resolves its columns from: `map`, plus the
/// widths `frozen` holds for it while they still apply. An entry in `map`
/// wins over a frozen one.
pub(crate) fn width_overrides<'a>(
    map: HashMap<String, f32>,
    frozen: Option<&SharedFrozenWidths>,
    own: impl Iterator<Item = &'a str>,
) -> HashMap<String, f32> {
    let Some(frozen) = frozen else {
        return map;
    };
    let frozen = frozen.borrow();
    if frozen.frozen.is_empty() || !frozen.hold(&map, own) {
        return map;
    }
    let mut out = map;
    for (id, &w) in &frozen.frozen {
        out.entry(id.clone()).or_insert(w);
    }
    out
}

/// Tiny chevron drawn as a triangle path.
#[derive(Debug)]
struct SortIndicator {
    direction: Option<SortDirection>,
    size: f32,
}

impl SortIndicator {
    fn new(direction: Option<SortDirection>, size: f32) -> Self {
        Self { direction, size }
    }
}

impl Widget for SortIndicator {
    fn layout_response(
        &self,
        _proposal: SizeProposal,
        _ctx: &LayoutContext,
    ) -> teksilo_core::widget::LayoutResponse {
        Size::new(self.size, self.size).into()
    }

    fn paint(&self, bounds: Rect, canvas: &mut Canvas, ctx: &PaintContext) {
        let Some(dir) = self.direction else {
            return;
        };
        let color = TextRole::Accent.resolve(&ctx.theme.colors);
        let cx = bounds.x + bounds.width / 2.0;
        let pad = bounds.height * 0.15;
        let top_y = bounds.y + pad;
        let bot_y = bounds.y + bounds.height - pad;
        let half_w = bounds.width / 2.0 - pad;
        let mut path = Path::new();
        match dir {
            SortDirection::Ascending => {
                path.move_to(Point::new(cx, top_y));
                path.line_to(Point::new(cx + half_w, bot_y));
                path.line_to(Point::new(cx - half_w, bot_y));
                path.close();
            }
            SortDirection::Descending => {
                path.move_to(Point::new(cx - half_w, top_y));
                path.line_to(Point::new(cx + half_w, top_y));
                path.line_to(Point::new(cx, bot_y));
                path.close();
            }
        }
        canvas.fill_path(&path, color);
    }

    fn accessibility(&self, builder: &mut AccessNodeBuilder) {
        builder.set_hidden();
    }
}