teksilo_widgets/table_view/

selection.rs

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

//! Selection types for `TableView` and `TreeTableView`.
//!
//! For row selection (`SingleRow` / `MultiRow`) the table re-uses the
//! existing `teksilo_data::SelectionModel` keyed by visible row index.
//!
//! For cell selection (`SingleCell` / `MultiCell`) the table uses
//! [`CellSelectionModel`] which tracks `(row, col)` pairs as a
//! `Signal<BTreeSet<(usize, usize)>>`. Anchor-rectangle extension supports
//! Excel-style Shift-Arrow / Shift-Click semantics.

use std::cell::Cell;
use std::cell::RefCell;
use std::collections::BTreeSet;
use std::rc::Rc;

use teksilo_core::build_context::BuildContext;
use teksilo_core::signal::Signal;

use crate::common::list_nav::Cardinality;
use crate::data_views::RowSelection;

/// Selection mode for a `TableView` or `TreeTableView`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TableSelectionMode {
    /// No selection allowed.
    None,
    /// At most one row selected at a time.
    SingleRow,
    /// Multiple rows selectable; Ctrl-click toggles, Shift-click extends.
    /// **Default.**
    #[default]
    MultiRow,
    /// Excel-style: at most one cell selected at a time.
    SingleCell,
    /// Excel-style: rectangular cell selection.
    MultiCell,
}

impl TableSelectionMode {
    /// Whether the mode operates on cells rather than entire rows.
    pub fn is_cell_mode(self) -> bool {
        matches!(self, Self::SingleCell | Self::MultiCell)
    }

    /// Whether the mode allows more than one entry to be selected.
    pub fn is_multi(self) -> bool {
        matches!(self, Self::MultiRow | Self::MultiCell)
    }
}

/// How many rows or cells a table's selection can hold.
///
/// The mode and the model are set separately, so either can hold the table
/// to one entry: a `SingleRow` or `SingleCell` table holds one whatever its
/// model allows, and a `MultiRow` or `MultiCell` table handed a model that is
/// itself single holds one row or cell whatever the mode claims — which is how
/// the key handler's `apply_selection_extension` already reads a `MultiRow`
/// table.
pub(crate) fn cardinality(
    mode: TableSelectionMode,
    selection: Option<&RowSelection>,
    cell_selection: Option<&CellSelectionModel>,
) -> Cardinality {
    let multi = match mode {
        TableSelectionMode::MultiRow => {
            selection.is_none_or(|s| s.mode() == teksilo_data::SelectionMode::Multi)
        }
        TableSelectionMode::MultiCell => cell_selection.is_none_or(|cs| cs.mode().is_multi()),
        TableSelectionMode::SingleRow
        | TableSelectionMode::SingleCell
        | TableSelectionMode::None => false,
    };
    if multi {
        Cardinality::Multi
    } else {
        Cardinality::Single
    }
}

/// In a table whose selection holds one entry, put the cell cursor back on
/// the selection whenever the selection moves without it.
///
/// `ListView::follow_the_selection_in_single_mode` states the defect: a
/// selection written from outside left the cursor, which the view publishes
/// as its active descendant, on a row no action used. The observers
/// registered here catch a selection the application writes. A data change
/// that moves the selected row without writing the selection — a keyed
/// selection carried through a sort or an insert above it — is caught by each
/// table's own data observer, which calls [`put_the_cursor_on_the_selection`]
/// after adjusting the selection.
///
/// A table in `TableSelectionMode::None` selects nothing of its own and is
/// left alone, whatever model it is handed.
pub(crate) fn follow_the_selection_in_single_mode(
    ctx: &mut BuildContext,
    mode: TableSelectionMode,
    focused_cell: &Signal<Option<(usize, usize)>>,
    selection: Option<&RowSelection>,
    cell_selection: Option<&CellSelectionModel>,
) {
    if mode == TableSelectionMode::None
        || cardinality(mode, selection, cell_selection) != Cardinality::Single
    {
        return;
    }
    let focused = focused_cell.clone();
    let rows = selection.cloned();
    let cells = cell_selection.cloned();
    let follow = move || {
        put_the_cursor_on_the_selection(mode, &focused, rows.as_ref(), cells.as_ref());
    };
    if mode.is_cell_mode() {
        if let Some(cells) = cell_selection {
            ctx.effect(&cells.selection_signal(), move |_| follow());
        }
    } else if let Some(rows) = selection {
        let handle = rows.observe_for_rebuild(follow);
        ctx.own_handle(handle);
    }
}

/// If the table holds one entry and its cell cursor is off the selection,
/// move the cursor onto it.
///
/// Moved rather than cleared: a table publishes `focused_cell` alone as its
/// active descendant, with no fallback to the selection, so a cleared cursor
/// would leave a screen reader told nothing. A row selection keeps the
/// cursor's column. A cursor that does not exist yet, or a selection with no
/// row this table shows, leaves the cursor as it is.
///
/// The selection is read live, never from a notification's value: an
/// observer registered earlier may rewrite the selection while it is being
/// notified, and the notification it interrupted still arrives afterwards,
/// carrying the value that was just discarded.
pub(crate) fn put_the_cursor_on_the_selection(
    mode: TableSelectionMode,
    focused_cell: &Signal<Option<(usize, usize)>>,
    selection: Option<&RowSelection>,
    cell_selection: Option<&CellSelectionModel>,
) {
    if mode == TableSelectionMode::None
        || cardinality(mode, selection, cell_selection) != Cardinality::Single
    {
        return;
    }
    let Some((row, col)) = focused_cell.get() else {
        return;
    };
    if mode.is_cell_mode() {
        let Some(cells) = cell_selection else {
            return;
        };
        if !cells.is_selected(row, col)
            && let Some(&cell) = cells.selection_signal().get().iter().next()
        {
            focused_cell.set(Some(cell));
        }
    } else {
        let Some(rows) = selection else {
            return;
        };
        if !rows.is_selected(row)
            && let Some(&selected) = rows.selected_indices().first()
        {
            focused_cell.set(Some((selected, col)));
        }
    }
}

/// Cell-level selection state for `TableSelectionMode::SingleCell` /
/// `MultiCell`. Tracks `(row, col)` pairs in visible-index space.
///
/// Mirrors `teksilo_data::SelectionModel`'s API surface (signal-backed,
/// auto-adjustable on data mutations) but keyed by `(row, col)` instead of
/// `row` alone.
pub struct CellSelectionModel {
    mode: TableSelectionMode,
    selection: Signal<BTreeSet<(usize, usize)>>,
    anchor: Rc<Cell<Option<(usize, usize)>>>,
    /// Cells committed by prior clicks/toggles, kept *separate* from the live
    /// Shift-drag rectangle. `extend_to` recomputes the selection as
    /// `base ∪ rectangle(anchor, target)` each time, so a Shift+click to a
    /// smaller rectangle *shrinks* it (Excel semantics) instead of only ever
    /// growing it, while Ctrl-committed cells survive.
    base: Rc<RefCell<BTreeSet<(usize, usize)>>>,
}

impl CellSelectionModel {
    /// Construct a model. **Panics** if `mode` is not a cell mode —
    /// callers in row mode should use `teksilo_data::SelectionModel`.
    pub fn new(mode: TableSelectionMode) -> Self {
        assert!(
            mode.is_cell_mode(),
            "CellSelectionModel requires SingleCell or MultiCell mode (got {mode:?})"
        );
        Self {
            mode,
            selection: Signal::new(BTreeSet::new()),
            anchor: Rc::new(Cell::new(None)),
            base: Rc::new(RefCell::new(BTreeSet::new())),
        }
    }

    pub fn mode(&self) -> TableSelectionMode {
        self.mode
    }

    pub fn selection_signal(&self) -> Signal<BTreeSet<(usize, usize)>> {
        self.selection.clone()
    }

    pub fn is_selected(&self, row: usize, col: usize) -> bool {
        self.selection.get().contains(&(row, col))
    }

    pub fn count(&self) -> usize {
        self.selection.get().len()
    }

    /// Replace the selection with the single cell `(row, col)` and set
    /// the anchor.
    pub fn select(&self, row: usize, col: usize) {
        if self.mode == TableSelectionMode::None {
            return;
        }
        let mut s = BTreeSet::new();
        s.insert((row, col));
        self.selection.set(s);
        self.anchor.set(Some((row, col)));
        // A plain click starts a fresh range: nothing committed beneath the
        // (about-to-be-dragged) rectangle.
        self.base.borrow_mut().clear();
    }

    /// Toggle the cell `(row, col)` (Ctrl-click). In `SingleCell` mode
    /// this behaves like [`select`](Self::select).
    pub fn toggle(&self, row: usize, col: usize) {
        match self.mode {
            TableSelectionMode::None => {}
            TableSelectionMode::SingleCell => self.select(row, col),
            TableSelectionMode::MultiCell => {
                let mut s = self.selection.get();
                if !s.insert((row, col)) {
                    s.remove(&(row, col));
                }
                self.selection.set(s.clone());
                self.anchor.set(Some((row, col)));
                // Ctrl-click commits the whole current selection as the base,
                // so a subsequent Shift-extend keeps it while the new
                // rectangle (anchored here) can still grow and shrink.
                *self.base.borrow_mut() = s;
            }
            TableSelectionMode::SingleRow | TableSelectionMode::MultiRow => {}
        }
    }

    /// Extend the selection to include the rectangular range from the
    /// anchor to `(row, col)`. In `SingleCell` mode this falls back to
    /// [`select`](Self::select).
    pub fn extend_to(&self, row: usize, col: usize) {
        match self.mode {
            TableSelectionMode::None => {}
            TableSelectionMode::SingleCell => self.select(row, col),
            TableSelectionMode::MultiCell => {
                let anchor = self.anchor.get().unwrap_or((row, col));
                let r0 = anchor.0.min(row);
                let r1 = anchor.0.max(row);
                let c0 = anchor.1.min(col);
                let c1 = anchor.1.max(col);
                // Recompute from the committed base ∪ the current rectangle,
                // rather than merging into the previous selection — so moving
                // the Shift target inward SHRINKS the rectangle (Excel
                // semantics) instead of only ever accreting cells.
                let mut s = self.base.borrow().clone();
                for r in r0..=r1 {
                    for c in c0..=c1 {
                        s.insert((r, c));
                    }
                }
                self.selection.set(s);
                // Anchor stays in place.
            }
            TableSelectionMode::SingleRow | TableSelectionMode::MultiRow => {}
        }
    }

    /// Replace the selection with an arbitrary set of cells, committing it as
    /// the base a following Shift range extends around.
    ///
    /// Backs the two spreadsheet chords a rectangle cannot express: Ctrl+Space
    /// selects a column and Shift+Space a row, neither of which is an
    /// anchor-to-cursor block.
    /// Declines outside `MultiCell` for the reason [`select_all`](Self::select_all)
    /// declines outside a cell mode: a set of cells is not something a
    /// single-selection or row-selection model can hold, and quietly storing
    /// one would break the mode's own invariant.
    pub fn select_cells(&self, cells: impl IntoIterator<Item = (usize, usize)>) {
        if self.mode != TableSelectionMode::MultiCell {
            return;
        }
        let set: BTreeSet<(usize, usize)> = cells.into_iter().collect();
        self.selection.set(set.clone());
        *self.base.borrow_mut() = set;
        self.anchor.set(None);
    }

    pub fn select_all(&self, row_count: usize, col_count: usize) {
        if self.mode == TableSelectionMode::None {
            return;
        }
        let mut s = BTreeSet::new();
        for r in 0..row_count {
            for c in 0..col_count {
                s.insert((r, c));
            }
        }
        self.selection.set(s.clone());
        // Treat select-all as a committed base, so a following Shift-extend
        // keeps it rather than collapsing to the bare rectangle.
        *self.base.borrow_mut() = s;
    }

    pub fn clear(&self) {
        self.selection.set(BTreeSet::new());
        self.anchor.set(None);
        self.base.borrow_mut().clear();
    }

    /// Re-key the committed `base` set with the same transform applied to the
    /// live selection on a row/column insert or remove, so a later Shift-extend
    /// unions a correctly-shifted base rather than stale coordinates.
    fn remap_base(&self, f: impl Fn((usize, usize)) -> Option<(usize, usize)>) {
        let mut b = self.base.borrow_mut();
        if b.is_empty() {
            return;
        }
        *b = b.iter().filter_map(|&cell| f(cell)).collect();
    }

    /// Adjust selection after `count` rows are inserted starting at
    /// `at_row`. Existing selections at indices `>= at_row` shift up.
    pub fn adjust_for_row_insert(&self, at_row: usize, count: usize) {
        let old = self.selection.get();
        let mut new = BTreeSet::new();
        for &(r, c) in &old {
            if r >= at_row {
                new.insert((r + count, c));
            } else {
                new.insert((r, c));
            }
        }
        if new != old {
            self.selection.set(new);
        }
        self.remap_base(|(r, c)| Some(if r >= at_row { (r + count, c) } else { (r, c) }));
        if let Some((r, c)) = self.anchor.get()
            && r >= at_row
        {
            self.anchor.set(Some((r + count, c)));
        }
    }

    /// Adjust selection after `count` rows starting at `at_row` are
    /// removed. Selections within the removed range are dropped; later
    /// rows shift down.
    pub fn adjust_for_row_remove(&self, at_row: usize, count: usize) {
        let old = self.selection.get();
        let end = at_row + count;
        let mut new = BTreeSet::new();
        for &(r, c) in &old {
            if r < at_row {
                new.insert((r, c));
            } else if r >= end {
                new.insert((r - count, c));
            }
            // r in [at_row, end) is dropped
        }
        if new != old {
            self.selection.set(new);
        }
        self.remap_base(|(r, c)| {
            if r < at_row {
                Some((r, c))
            } else if r >= end {
                Some((r - count, c))
            } else {
                None
            }
        });
        if let Some((r, c)) = self.anchor.get() {
            if r >= end {
                self.anchor.set(Some((r - count, c)));
            } else if r >= at_row {
                self.anchor.set(None);
            }
        }
    }

    /// Adjust selection after a block of `count` rows moved from `from` to
    /// `to` (a post-removal index, matching `ListModel::move_item`). Selected
    /// cells follow their rows; columns are untouched.
    pub fn adjust_for_row_move(&self, from: usize, to: usize, count: usize) {
        if from == to || count == 0 {
            return;
        }
        let map = |r: usize| teksilo_data::map_index_after_move(r, from, to, count);
        let old = self.selection.get();
        let new: BTreeSet<(usize, usize)> = old.iter().map(|&(r, c)| (map(r), c)).collect();
        if new != old {
            self.selection.set(new);
        }
        self.remap_base(|(r, c)| Some((map(r), c)));
        if let Some((r, c)) = self.anchor.get() {
            self.anchor.set(Some((map(r), c)));
        }
    }

    /// Adjust selection after `count` columns are inserted at `at_col`.
    ///
    /// Reserved for future dynamic-column support. `TableView`/`TreeTableView`
    /// columns are declared once via `.add_column()`/`.columns()` and are
    /// static for the widget's lifetime — there is no runtime insert/remove
    /// API today, so nothing calls this. A column *reorder* or pin-toggle
    /// permutes positions instead (see `remap_columns`),
    /// which is what the current views actually use. Kept (not removed) as
    /// public API in case a future dynamic-column feature needs the
    /// offset-shift semantics this and [`adjust_for_column_remove`](Self::adjust_for_column_remove)
    /// already implement and test.
    pub fn adjust_for_column_insert(&self, at_col: usize, count: usize) {
        let old = self.selection.get();
        let mut new = BTreeSet::new();
        for &(r, c) in &old {
            if c >= at_col {
                new.insert((r, c + count));
            } else {
                new.insert((r, c));
            }
        }
        if new != old {
            self.selection.set(new);
        }
        self.remap_base(|(r, c)| Some(if c >= at_col { (r, c + count) } else { (r, c) }));
        if let Some((r, c)) = self.anchor.get()
            && c >= at_col
        {
            self.anchor.set(Some((r, c + count)));
        }
    }

    /// Adjust selection after `count` columns starting at `at_col` are
    /// removed.
    ///
    /// Reserved for future dynamic-column support — see the doc comment on
    /// [`adjust_for_column_insert`](Self::adjust_for_column_insert); nothing
    /// calls this today for the same reason.
    pub fn adjust_for_column_remove(&self, at_col: usize, count: usize) {
        let old = self.selection.get();
        let end = at_col + count;
        let mut new = BTreeSet::new();
        for &(r, c) in &old {
            if c < at_col {
                new.insert((r, c));
            } else if c >= end {
                new.insert((r, c - count));
            }
        }
        if new != old {
            self.selection.set(new);
        }
        self.remap_base(|(r, c)| {
            if c < at_col {
                Some((r, c))
            } else if c >= end {
                Some((r, c - count))
            } else {
                None
            }
        });
        if let Some((r, c)) = self.anchor.get() {
            if c >= end {
                self.anchor.set(Some((r, c - count)));
            } else if c >= at_col {
                self.anchor.set(None);
            }
        }
    }

    /// Remap the column half of every stored `(row, col)` pair through
    /// `old_to_new` — `old_to_new[old_col]` gives that column's new display
    /// position, or `None` if it dropped out of the visible set. Rows are
    /// untouched.
    ///
    /// A column reorder or pin toggle permutes display positions rather than
    /// shifting a contiguous run, so it can't reuse
    /// `adjust_for_column_insert`/`remove`'s offset arithmetic — the caller
    /// (a rebuild that recomputed display order) hands over the full
    /// old-position -> new-position mapping instead.
    pub(crate) fn remap_columns(&self, old_to_new: &[Option<usize>]) {
        let map = |c: usize| old_to_new.get(c).copied().flatten();
        let old = self.selection.get();
        let new: BTreeSet<(usize, usize)> = old
            .iter()
            .filter_map(|&(r, c)| map(c).map(|nc| (r, nc)))
            .collect();
        if new != old {
            self.selection.set(new);
        }
        self.remap_base(|(r, c)| map(c).map(|nc| (r, nc)));
        if let Some((r, c)) = self.anchor.get() {
            self.anchor.set(map(c).map(|nc| (r, nc)));
        }
    }
}

impl Clone for CellSelectionModel {
    fn clone(&self) -> Self {
        Self {
            mode: self.mode,
            selection: self.selection.clone(),
            anchor: self.anchor.clone(),
            base: self.base.clone(),
        }
    }
}

impl std::fmt::Debug for CellSelectionModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CellSelectionModel")
            .field("mode", &self.mode)
            .field("selected_count", &self.selection.get().len())
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn select_replaces_and_sets_anchor() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(2, 3);
        assert!(m.is_selected(2, 3));
        assert_eq!(m.count(), 1);
        m.select(5, 5);
        assert!(m.is_selected(5, 5));
        assert!(!m.is_selected(2, 3));
    }

    #[test]
    fn toggle_in_multi_cell_adds_and_removes() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.toggle(0, 0);
        m.toggle(1, 1);
        assert_eq!(m.count(), 2);
        m.toggle(0, 0);
        assert_eq!(m.count(), 1);
    }

    #[test]
    fn extend_in_multi_cell_fills_rectangle() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(2, 1);
        m.extend_to(4, 3);
        // 3 rows × 3 cols = 9 cells.
        assert_eq!(m.count(), 9);
        assert!(m.is_selected(3, 2));
    }

    #[test]
    fn extend_shrinks_when_target_moves_inward() {
        // Excel semantics: a second Shift extend to a smaller rectangle must
        // SHRINK the selection, not keep the larger one.
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(0, 0);
        m.extend_to(2, 2); // 3×3 = 9
        assert_eq!(m.count(), 9);
        m.extend_to(1, 1); // 2×2 = 4
        assert_eq!(m.count(), 4, "rectangle must shrink, not accrete");
        assert!(
            !m.is_selected(2, 2),
            "the dropped corner must be deselected"
        );
    }

    #[test]
    fn ctrl_committed_cells_survive_a_later_shift_extend() {
        // Ctrl-click commits a base; a subsequent Shift-extend keeps it while
        // the new rectangle can still shrink.
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(0, 0); // {(0,0)}
        m.toggle(5, 5); // Ctrl-click → base now {(0,0),(5,5)}, anchor (5,5)
        m.extend_to(6, 6); // base ∪ rect((5,5),(6,6))
        assert!(m.is_selected(0, 0), "Ctrl-committed cell must survive");
        assert!(m.is_selected(6, 6));
        m.extend_to(5, 5); // shrink the rect back to a single cell
        assert!(m.is_selected(0, 0), "committed cell still there");
        assert!(!m.is_selected(6, 6), "shrunk-away cell gone");
        assert_eq!(m.count(), 2); // (0,0) committed + (5,5) rect
    }

    #[test]
    fn select_all_in_multi_cell() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select_all(3, 4);
        assert_eq!(m.count(), 12);
    }

    #[test]
    fn single_cell_mode_keeps_one_selection() {
        let m = CellSelectionModel::new(TableSelectionMode::SingleCell);
        m.select(1, 1);
        m.toggle(2, 2);
        assert_eq!(m.count(), 1);
        assert!(m.is_selected(2, 2));
    }

    #[test]
    fn adjust_for_row_insert_shifts_higher_rows() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(2, 0);
        m.toggle(4, 0);
        m.adjust_for_row_insert(3, 2);
        assert!(m.is_selected(2, 0));
        assert!(m.is_selected(6, 0));
    }

    #[test]
    fn adjust_for_row_remove_drops_in_range() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(1, 0);
        m.toggle(3, 0);
        m.toggle(5, 0);
        m.adjust_for_row_remove(2, 2);
        // Row 1 stays, rows 2..4 are removed (so row 3 is dropped),
        // and row 5 shifts down by 2 to 3.
        assert!(m.is_selected(1, 0));
        // After the shift, row 3 is now occupied by what used to be row 5.
        assert!(m.is_selected(3, 0));
        let v: Vec<_> = m.selection_signal().get().into_iter().collect();
        assert_eq!(v, vec![(1, 0), (3, 0)]);
    }

    #[test]
    fn adjust_for_row_move_follows_cells() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(0, 1); // cell in row 0
        m.toggle(1, 2); // cell in row 1
        // Move row 0 to index 2: rows [B,C,A] — A's cell follows to row 2,
        // B's cell shifts down to row 0.
        m.adjust_for_row_move(0, 2, 1);
        let v: Vec<_> = m.selection_signal().get().into_iter().collect();
        assert_eq!(v, vec![(0, 2), (2, 1)]);
    }

    #[test]
    fn adjust_for_column_insert_and_remove() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(0, 1);
        m.toggle(0, 4);
        m.adjust_for_column_insert(2, 2);
        // col 1 stays, col 4 → 6
        let v: Vec<_> = m.selection_signal().get().into_iter().collect();
        assert_eq!(v, vec![(0, 1), (0, 6)]);

        m.adjust_for_column_remove(0, 2);
        let v: Vec<_> = m.selection_signal().get().into_iter().collect();
        // col 1 dropped (in range), col 6 shifts to 4.
        assert_eq!(v, vec![(0, 4)]);
    }

    #[test]
    fn remap_columns_follows_reorder_and_drops_removed_columns() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(0, 0); // anchor + base cleared by `select`
        m.toggle(1, 2); // Ctrl-click: commits {(0,0),(1,2)} as base, anchor (1,2)
        // Column 0 moves to display position 2, column 2 moves to 0; column 1
        // (unselected, but exercised via `extend_to` below) drops out.
        let old_to_new = vec![Some(2), None, Some(0)];
        m.remap_columns(&old_to_new);
        let v: Vec<_> = m.selection_signal().get().into_iter().collect();
        assert_eq!(v, vec![(0, 2), (1, 0)], "columns follow their new position");
        // The anchor moved with column 2 -> 0; a subsequent extend must build
        // its rectangle from the remapped anchor, not the stale one.
        m.extend_to(1, 1);
        assert!(
            m.is_selected(1, 0),
            "remapped anchor (1,0) must survive into the next extend"
        );
    }

    #[test]
    fn remap_columns_drops_selection_in_a_removed_column() {
        let m = CellSelectionModel::new(TableSelectionMode::MultiCell);
        m.select(3, 1);
        // Column 1 (the only selected one) is gone from the new order.
        m.remap_columns(&[Some(0), None]);
        assert_eq!(m.count(), 0);
    }

    #[test]
    #[should_panic]
    fn cell_model_rejects_row_mode() {
        let _ = CellSelectionModel::new(TableSelectionMode::MultiRow);
    }

    #[test]
    fn mode_is_cell_mode() {
        assert!(TableSelectionMode::SingleCell.is_cell_mode());
        assert!(TableSelectionMode::MultiCell.is_cell_mode());
        assert!(!TableSelectionMode::MultiRow.is_cell_mode());
    }
}