Skip to main content

xrack_runtime/
table_selection.rs

1use crate::table_clipboard::{MAX_CLIPBOARD_BYTES, MAX_CLIPBOARD_CELLS};
2use crate::{ChangeSignal, ListModel, Node, RowKey};
3use std::{
4    cell::RefCell,
5    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
6    ops::Range,
7    sync::Arc,
8};
9
10#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
11pub enum SelectionTarget {
12    #[default]
13    Rows,
14    Cells,
15    Columns,
16}
17
18#[derive(Clone, Copy, Debug, PartialEq, Eq)]
19pub enum RowSelection {
20    Replace,
21    Toggle,
22    Extend,
23    AddRange,
24    Move,
25}
26
27#[derive(Clone, Copy, Debug, PartialEq, Eq)]
28pub enum TableSelectionAction {
29    Row {
30        index: usize,
31        operation: RowSelection,
32    },
33    Cell {
34        row: usize,
35        column: usize,
36        operation: RowSelection,
37    },
38    Column {
39        column: usize,
40        operation: RowSelection,
41    },
42    DragRange {
43        anchor: (usize, usize),
44        end: (usize, usize),
45        additive: bool,
46    },
47    All,
48    Clear,
49}
50
51type RowKeys = Arc<BTreeSet<RowKey>>;
52type ColumnCells = BTreeMap<usize, RowKeys>;
53
54#[derive(Clone, Debug)]
55enum Selected {
56    Rows(RowKeys),
57    Columns(Arc<BTreeSet<usize>>),
58    Cells(Arc<ColumnCells>),
59}
60
61impl PartialEq for Selected {
62    fn eq(&self, other: &Self) -> bool {
63        match (self, other) {
64            (Self::Rows(a), Self::Rows(b)) => a == b,
65            (Self::Columns(a), Self::Columns(b)) => a == b,
66            (Self::Cells(a), Self::Cells(b)) => {
67                let mut compared = HashSet::new();
68                Arc::ptr_eq(a, b)
69                    || a.len() == b.len()
70                        && a.iter()
71                            .zip(b.iter())
72                            .all(|((a_col, a_rows), (b_col, b_rows))| {
73                                a_col == b_col
74                                    && (!compared
75                                        .insert((Arc::as_ptr(a_rows), Arc::as_ptr(b_rows)))
76                                        || a_rows == b_rows)
77                            })
78            }
79            _ => false,
80        }
81    }
82}
83
84impl Eq for Selected {}
85
86impl Selected {
87    fn empty(target: SelectionTarget) -> Self {
88        match target {
89            SelectionTarget::Rows => Self::Rows(Arc::default()),
90            SelectionTarget::Cells => Self::Cells(Arc::default()),
91            SelectionTarget::Columns => Self::Columns(Arc::default()),
92        }
93    }
94
95    fn len(&self) -> usize {
96        match self {
97            Self::Rows(rows) => rows.len(),
98            Self::Columns(columns) => columns.len(),
99            Self::Cells(cells) => cells.values().map(|rows| rows.len()).sum(),
100        }
101    }
102
103    fn retain_live(&mut self, model: &impl ListModel) {
104        if matches!(self, Self::Columns(_)) || self.len() == 0 {
105            return;
106        }
107        match self {
108            Self::Rows(rows) => {
109                let mut live = BTreeSet::new();
110                model.visit_source_row_keys(|key| {
111                    if rows.contains(&key) {
112                        live.insert(key);
113                    }
114                });
115                if live.len() != rows.len() {
116                    *rows = Arc::new(live);
117                }
118            }
119            Self::Cells(cells) => {
120                let mut live = BTreeSet::new();
121                model.visit_source_row_keys(|key| {
122                    live.insert(key);
123                });
124                // A rectangular range can share a single row set across many columns.
125                let mut pruned = HashMap::<_, RowKeys>::new();
126                let cells = Arc::make_mut(cells);
127                cells.retain(|_, rows| {
128                    *rows = pruned
129                        .entry(Arc::as_ptr(rows))
130                        .or_insert_with(|| {
131                            if rows.is_subset(&live) {
132                                rows.clone()
133                            } else {
134                                Arc::new(rows.intersection(&live).copied().collect())
135                            }
136                        })
137                        .clone();
138                    !rows.is_empty()
139                });
140            }
141            Self::Columns(_) => {}
142        }
143    }
144}
145
146fn row_keys(model: &impl ListModel, range: Range<usize>) -> BTreeSet<RowKey> {
147    let mut keys = BTreeSet::new();
148    model.visit_row_keys(range, |key| {
149        keys.insert(key);
150    });
151    keys
152}
153
154fn span(a: usize, b: usize) -> Range<usize> {
155    a.min(b)..a.max(b) + 1
156}
157
158/// Selection in a table snapshot, including units outside the viewport.
159#[derive(Clone, Debug, PartialEq, Eq)]
160pub struct TableSelectionSnapshot {
161    stamp: (u64, u64),
162    target: SelectionTarget,
163    column_count: usize,
164    order: crate::TableColumnOrder,
165    multiple: bool,
166    current_column: Option<usize>,
167    selected: Selected,
168    drag_range: Option<CommittedRange>,
169}
170
171#[derive(Clone, Debug, PartialEq, Eq)]
172struct CommittedRange {
173    endpoints: [(usize, usize); 2],
174    order: crate::TableColumnOrder,
175}
176
177impl TableSelectionSnapshot {
178    #[doc(hidden)]
179    pub fn with_column_order(mut self, order: crate::TableColumnOrder) -> Self {
180        self.order = order;
181        self
182    }
183
184    pub fn target(&self) -> SelectionTarget {
185        self.target
186    }
187
188    pub fn current_column(&self) -> Option<usize> {
189        self.current_column
190    }
191
192    pub fn multiple(&self) -> bool {
193        self.multiple
194    }
195
196    #[doc(hidden)]
197    pub fn structure_stamp(&self) -> (u64, u64) {
198        self.stamp
199    }
200
201    /// Endpoints of the last replacement drag, in row and logical column indices.
202    pub fn drag_range(&self) -> Option<[(usize, usize); 2]> {
203        let range = self.drag_range.as_ref()?;
204        (range.order == self.order).then_some(range.endpoints)
205    }
206
207    /// Number of selected rows, cells, or columns, depending on the target.
208    pub fn len(&self) -> usize {
209        self.selected.len()
210    }
211
212    pub fn is_empty(&self) -> bool {
213        self.len() == 0
214    }
215
216    pub fn keys(&self) -> &BTreeSet<RowKey> {
217        static EMPTY: BTreeSet<RowKey> = BTreeSet::new();
218        match &self.selected {
219            Selected::Rows(rows) => rows,
220            _ => &EMPTY,
221        }
222    }
223
224    pub fn columns(&self) -> &BTreeSet<usize> {
225        static EMPTY: BTreeSet<usize> = BTreeSet::new();
226        match &self.selected {
227            Selected::Columns(columns) => columns,
228            _ => &EMPTY,
229        }
230    }
231
232    /// Explicit cell selection in a column, without expanding whole-row or whole-column selections.
233    pub fn cell_keys(&self, column: usize) -> Option<&BTreeSet<RowKey>> {
234        match &self.selected {
235            Selected::Cells(cells) => cells.get(&column).map(Arc::as_ref),
236            _ => None,
237        }
238    }
239
240    pub fn contains_cell(&self, row: RowKey, column: usize) -> bool {
241        column < self.column_count
242            && row.model == self.stamp.0
243            && match &self.selected {
244                Selected::Rows(rows) => rows.contains(&row),
245                Selected::Columns(columns) => columns.contains(&column),
246                Selected::Cells(cells) => {
247                    cells.get(&column).is_some_and(|rows| rows.contains(&row))
248                }
249            }
250    }
251
252    pub fn row_header_selected(&self, row: RowKey) -> bool {
253        match &self.selected {
254            Selected::Rows(rows) => rows.contains(&row),
255            Selected::Cells(cells) => whole_row_selected(cells, self.column_count, row),
256            Selected::Columns(_) => false,
257        }
258    }
259
260    pub fn row_header_action(&self, index: usize, operation: RowSelection) -> TableSelectionAction {
261        match self.target {
262            SelectionTarget::Cells if !self.multiple => {
263                let column = self
264                    .current_column
265                    .filter(|column| *column < self.column_count)
266                    .or_else(|| self.order.iter(self.column_count).next())
267                    .unwrap_or_default();
268                TableSelectionAction::Cell {
269                    row: index,
270                    column,
271                    operation,
272                }
273            }
274            SelectionTarget::Columns => TableSelectionAction::Row {
275                index,
276                operation: RowSelection::Move,
277            },
278            _ => TableSelectionAction::Row { index, operation },
279        }
280    }
281
282    /// Resolve selected rows in the model's current order with one model pass.
283    pub fn indices(&self, model: &impl ListModel) -> Vec<usize> {
284        let keys = self.keys();
285        if keys.is_empty() || self.stamp.0 != model.structure_stamp().0 {
286            return Vec::new();
287        }
288        let mut indices = Vec::with_capacity(keys.len());
289        let mut index = 0;
290        model.visit_row_keys(0..model.row_count(), |key| {
291            if keys.contains(&key) {
292                indices.push(index);
293            }
294            index += 1;
295        });
296        indices
297    }
298}
299
300/// Serialize the selected model rows in the supplied visual column order.
301#[doc(hidden)]
302pub fn copy_table_text_in_order<M: ListModel>(
303    rows: &crate::TableRows<M>,
304    table: &Node,
305    columns: &[usize],
306    mut cell: impl FnMut(usize, usize, &M::Item) -> Option<String>,
307) -> Option<String> {
308    if table.standard_list_stamp != Some(rows.positions().stamp()) {
309        return None;
310    }
311    copy_table_text(rows, table, columns, |row, column, item| {
312        cell(rows.positions().source_index(row)?, column, item)
313    })
314}
315
316#[doc(hidden)]
317pub fn copy_table_text<M: ListModel>(
318    model: &M,
319    table: &Node,
320    displayed_columns: &[usize],
321    mut cell: impl FnMut(usize, usize, &M::Item) -> Option<String>,
322) -> Option<String> {
323    let count = model.row_count();
324    let column_count = table.table_header.as_ref()?.columns.len();
325    let mut columns: Vec<_> = displayed_columns
326        .iter()
327        .copied()
328        .filter(|&column| column < column_count)
329        .collect();
330    let mut rows = Vec::new();
331    let mut range = 0..count;
332    let mut cells = None;
333    if let Some(selection) = table.table_selection.as_deref() {
334        if selection.stamp.0 != model.structure_stamp().0 {
335            return None;
336        }
337        match &selection.selected {
338            Selected::Rows(selected) => {
339                if selected.len().checked_mul(columns.len())? > MAX_CLIPBOARD_CELLS {
340                    return None;
341                }
342                let current = table
343                    .int("current-row")
344                    .and_then(|row| usize::try_from(row).ok());
345                if let Some(row) = current.filter(|&row| {
346                    selected.len() == 1 && row < count && selected.contains(&model.row_key(row))
347                }) {
348                    rows.push(row);
349                } else {
350                    rows = selection.indices(model);
351                }
352                range = 0..0;
353            }
354            Selected::Columns(selected) => columns.retain(|column| selected.contains(column)),
355            Selected::Cells(selected) => {
356                let start = columns
357                    .iter()
358                    .position(|column| selected.contains_key(column))?;
359                let end = columns
360                    .iter()
361                    .rposition(|column| selected.contains_key(column))?
362                    + 1;
363                columns = columns[start..end].to_vec();
364                let selected_count = columns
365                    .iter()
366                    .filter_map(|column| selected.get(column))
367                    .try_fold(0usize, |count, keys| count.checked_add(keys.len()))?;
368                if selected_count > MAX_CLIPBOARD_CELLS {
369                    return None;
370                }
371                let mut seen = HashSet::new();
372                let row_sets: Vec<_> = columns
373                    .iter()
374                    .filter_map(|column| selected.get(column))
375                    .filter(|keys| seen.insert(Arc::as_ptr(keys)))
376                    .collect();
377                let union: HashSet<_> = if row_sets.len() > 1 {
378                    row_sets
379                        .iter()
380                        .flat_map(|rows| rows.iter().copied())
381                        .collect()
382                } else {
383                    HashSet::new()
384                };
385                let mut index = 0;
386                let mut first = count;
387                let mut last = 0;
388                model.visit_row_keys(0..count, |key| {
389                    let included = if let [keys] = row_sets.as_slice() {
390                        keys.contains(&key)
391                    } else {
392                        union.contains(&key)
393                    };
394                    if included {
395                        first = first.min(index);
396                        last = index + 1;
397                    }
398                    index += 1;
399                });
400                range = first..last;
401                cells = Some(selection);
402            }
403        }
404    } else {
405        let row = usize::try_from(table.int("current-row")?).ok()?;
406        if row >= count {
407            return None;
408        }
409        range = row..row + 1;
410    }
411
412    let size = (rows.len() + range.len()).checked_mul(columns.len())?;
413    if size == 0 || size > MAX_CLIPBOARD_CELLS {
414        return None;
415    }
416    let mut text = String::new();
417    for (line, row) in rows.into_iter().chain(range).enumerate() {
418        if line != 0 {
419            text.push('\n');
420        }
421        let line_start = text.len();
422        let key = model.row_key(row);
423        let item = model.item(row);
424        for (slot, &column) in columns.iter().enumerate() {
425            if slot != 0 {
426                text.push('\t');
427            }
428            if cells.is_none_or(|selection| selection.contains_cell(key, column))
429                && let Some(value) = cell(row, column, &item)
430            {
431                append_cell(&mut text, &value)?;
432            }
433            if text.len() > MAX_CLIPBOARD_BYTES {
434                return None;
435            }
436        }
437        if text.len() == line_start {
438            // A blank final single-column row would otherwise look like a trailing newline.
439            if text.len().checked_add(2)? > MAX_CLIPBOARD_BYTES {
440                return None;
441            }
442            text.push_str("\"\"");
443        }
444    }
445    Some(text)
446}
447
448fn append_cell(text: &mut String, value: &str) -> Option<()> {
449    let quoted = value.contains(['\t', '\n', '\r', '"']);
450    let extra = if quoted {
451        value.bytes().filter(|&byte| byte == b'"').count() + 2
452    } else {
453        0
454    };
455    if text.len().saturating_add(value.len()).saturating_add(extra) > MAX_CLIPBOARD_BYTES {
456        return None;
457    }
458    if quoted {
459        text.push('"');
460        for (index, part) in value.split('"').enumerate() {
461            if index != 0 {
462                text.push_str("\"\"");
463            }
464            text.push_str(part);
465        }
466        text.push('"');
467    } else {
468        text.push_str(value);
469    }
470    Some(())
471}
472
473#[doc(hidden)]
474pub struct TableSelectionChange {
475    pub current: Option<usize>,
476    pub column_changed: bool,
477    pub selected_count: Option<usize>,
478}
479
480#[derive(Default)]
481struct Selection {
482    stamp: Option<(u64, u64)>,
483    source_stamp: Option<(u64, u64)>,
484    target: SelectionTarget,
485    multiple: bool,
486    selected: Option<Selected>,
487    row_anchor: Option<(usize, RowKey)>,
488    column_anchor: Option<usize>,
489    current_column: Option<usize>,
490    drag_range: Option<CommittedRange>,
491}
492
493impl Selection {
494    fn refresh(
495        &mut self,
496        model: &impl ListModel,
497        stamp: (u64, u64),
498        target: SelectionTarget,
499        multiple: bool,
500    ) {
501        let source = model.source_structure_stamp();
502        if self.target != target || self.multiple != multiple {
503            *self = Self {
504                target,
505                multiple,
506                stamp: Some(stamp),
507                source_stamp: Some(source),
508                ..Self::default()
509            };
510            return;
511        }
512        if self.stamp == Some(stamp) {
513            return;
514        }
515        self.drag_range = None;
516        let source_changed = self.source_stamp.replace(source) != Some(source);
517        if let Some(previous) = self.stamp.replace(stamp) {
518            if previous.0 != stamp.0 && target != SelectionTarget::Columns {
519                self.selected = Some(Selected::empty(target));
520                self.row_anchor = None;
521            } else if source_changed && let Some(selected) = &mut self.selected {
522                selected.retain_live(model);
523            }
524        }
525    }
526
527    fn selected(&self, model: &impl ListModel, current: Option<usize>) -> Selected {
528        self.selected.clone().unwrap_or_else(|| {
529            if self.target == SelectionTarget::Rows {
530                Selected::Rows(Arc::new(
531                    current
532                        .filter(|&index| index < model.row_count())
533                        .map(|index| model.row_key(index))
534                        .into_iter()
535                        .collect(),
536                ))
537            } else {
538                Selected::empty(self.target)
539            }
540        })
541    }
542
543    fn row_range(
544        &mut self,
545        model: &impl ListModel,
546        current: Option<usize>,
547        row: usize,
548    ) -> Range<usize> {
549        let count = model.row_count();
550        let anchor = self
551            .row_anchor
552            .and_then(|(old, key)| {
553                if old < count && model.row_key(old) == key {
554                    Some(old)
555                } else {
556                    model.index_of_key(key)
557                }
558            })
559            .or(current.filter(|&index| index < count))
560            .unwrap_or(row);
561        self.row_anchor = Some((anchor, model.row_key(anchor)));
562        span(anchor, row)
563    }
564
565    fn column_range<'a>(
566        &mut self,
567        column: usize,
568        view: &'a TableSelectionSnapshot,
569    ) -> impl Iterator<Item = usize> + use<'a> {
570        let anchor = self
571            .column_anchor
572            .or(self.current_column)
573            .filter(|&column| column < view.column_count)
574            .unwrap_or(column);
575        self.column_anchor = Some(anchor);
576        column_span(view, anchor, column)
577    }
578}
579
580fn column_span(
581    view: &TableSelectionSnapshot,
582    anchor: usize,
583    column: usize,
584) -> impl Iterator<Item = usize> + use<'_> {
585    let index = |column| view.order.visual_index(view.column_count, column);
586    let range = span(index(anchor).unwrap_or(0), index(column).unwrap_or(0));
587    view.order
588        .iter(view.column_count)
589        .skip(range.start)
590        .take(range.len())
591}
592
593fn select_cells(
594    cells: &mut Arc<ColumnCells>,
595    columns: impl Iterator<Item = usize>,
596    rows: RowKeys,
597    additive: bool,
598) {
599    if !additive {
600        *cells = Arc::new(columns.map(|column| (column, rows.clone())).collect());
601        return;
602    }
603    let cells = Arc::make_mut(cells);
604    let mut merged = HashMap::<_, RowKeys>::new();
605    for column in columns {
606        let keys = cells.entry(column).or_insert_with(|| rows.clone());
607        if !rows.is_subset(keys) {
608            *keys = merged
609                .entry(Arc::as_ptr(keys))
610                .or_insert_with(|| Arc::new(keys.union(&rows).copied().collect()))
611                .clone();
612        }
613    }
614}
615
616fn whole_row_selected(cells: &ColumnCells, column_count: usize, row: RowKey) -> bool {
617    column_count > 0
618        && cells.len() == column_count
619        && cells.values().all(|keys| keys.contains(&row))
620}
621
622fn remove_row_from_cells(cells: &mut Arc<ColumnCells>, row: RowKey) {
623    let mut trimmed = HashMap::new();
624    Arc::make_mut(cells).retain(|_, keys| {
625        *keys = trimmed
626            .entry(Arc::as_ptr(keys))
627            .or_insert_with(|| {
628                let mut remaining = (**keys).clone();
629                remaining.remove(&row);
630                Arc::new(remaining)
631            })
632            .clone();
633        !keys.is_empty()
634    });
635}
636
637fn toggle<T: Ord>(set: &mut BTreeSet<T>, key: T) {
638    if !set.remove(&key) {
639        set.insert(key);
640    }
641}
642
643/// Generated per table so gestures and data changes share the same selection.
644#[doc(hidden)]
645#[derive(Default)]
646pub struct TableSelection {
647    state: RefCell<Selection>,
648    changed: ChangeSignal,
649}
650
651impl TableSelection {
652    pub fn has_explicit_selection(&self) -> bool {
653        self.changed.track();
654        self.state.borrow().selected.is_some()
655    }
656
657    pub fn snapshot(
658        &self,
659        model: &impl ListModel,
660        current: Option<usize>,
661        target: SelectionTarget,
662        column_count: usize,
663        multiple: bool,
664    ) -> TableSelectionSnapshot {
665        self.changed.track();
666        let stamp = model.structure_stamp();
667        let mut state = self.state.borrow_mut();
668        state.refresh(model, stamp, target, multiple);
669        TableSelectionSnapshot {
670            stamp,
671            target,
672            column_count,
673            order: crate::TableColumnOrder::default(),
674            multiple,
675            current_column: state.current_column,
676            selected: state.selected(model, current),
677            drag_range: state.drag_range.clone(),
678        }
679    }
680
681    pub fn apply(
682        &self,
683        model: &impl ListModel,
684        view: &TableSelectionSnapshot,
685        current: Option<usize>,
686        action: TableSelectionAction,
687    ) -> Option<TableSelectionChange> {
688        let stamp = model.structure_stamp();
689        let mut state = self.state.borrow_mut();
690        if stamp != view.stamp || state.target != view.target || state.multiple != view.multiple {
691            return None;
692        }
693        let count = model.row_count();
694        let column_count = view.column_count;
695        state.refresh(model, stamp, view.target, view.multiple);
696        let previous = state.selected(model, current);
697        let mut next = previous.clone();
698        let mut cursor = None;
699        let mut drag_range = None;
700        let old_column = state.current_column;
701        let operation_for = |operation| {
702            if view.multiple || operation == RowSelection::Move {
703                operation
704            } else {
705                RowSelection::Replace
706            }
707        };
708        match action {
709            TableSelectionAction::Row { index, operation } if index < count => {
710                let operation = operation_for(operation);
711                cursor = Some(index);
712                if let Selected::Rows(rows) = &mut next {
713                    let key = model.row_key(index);
714                    match operation {
715                        RowSelection::Replace => {
716                            state.row_anchor = Some((index, key));
717                            *rows = Arc::new(BTreeSet::from([key]));
718                        }
719                        RowSelection::Toggle => {
720                            state.row_anchor = Some((index, key));
721                            toggle(Arc::make_mut(rows), key);
722                        }
723                        RowSelection::Extend | RowSelection::AddRange => {
724                            let keys = row_keys(model, state.row_range(model, current, index));
725                            if operation == RowSelection::Extend {
726                                *rows = Arc::new(keys);
727                            } else {
728                                Arc::make_mut(rows).extend(keys);
729                            }
730                        }
731                        RowSelection::Move => {}
732                    }
733                } else if let Selected::Cells(cells) = &mut next
734                    && view.multiple
735                    && column_count > 0
736                {
737                    match operation {
738                        RowSelection::Replace | RowSelection::Toggle => {
739                            let key = model.row_key(index);
740                            state.row_anchor = Some((index, key));
741                            state.column_anchor = state
742                                .current_column
743                                .or_else(|| view.order.iter(column_count).next());
744                            state.current_column = state.column_anchor;
745                            if operation == RowSelection::Toggle
746                                && whole_row_selected(cells, column_count, key)
747                            {
748                                remove_row_from_cells(cells, key);
749                            } else {
750                                select_cells(
751                                    cells,
752                                    0..column_count,
753                                    Arc::new(BTreeSet::from([key])),
754                                    operation == RowSelection::Toggle,
755                                );
756                            }
757                        }
758                        RowSelection::Extend | RowSelection::AddRange => {
759                            let rows =
760                                Arc::new(row_keys(model, state.row_range(model, current, index)));
761                            select_cells(
762                                cells,
763                                0..column_count,
764                                rows,
765                                operation == RowSelection::AddRange,
766                            );
767                        }
768                        RowSelection::Move => {}
769                    }
770                } else if operation != RowSelection::Move {
771                    return None;
772                }
773            }
774            TableSelectionAction::Column { column, operation } if column < column_count => {
775                let operation = operation_for(operation);
776                let Selected::Columns(columns) = &mut next else {
777                    return None;
778                };
779                match operation {
780                    RowSelection::Replace => {
781                        state.column_anchor = Some(column);
782                        *columns = Arc::new(BTreeSet::from([column]));
783                    }
784                    RowSelection::Toggle => {
785                        state.column_anchor = Some(column);
786                        toggle(Arc::make_mut(columns), column);
787                    }
788                    RowSelection::Extend | RowSelection::AddRange => {
789                        let range = state.column_range(column, view);
790                        if operation == RowSelection::Extend {
791                            *columns = Arc::new(range.collect());
792                        } else {
793                            Arc::make_mut(columns).extend(range);
794                        }
795                    }
796                    RowSelection::Move => {}
797                }
798                state.current_column = Some(column);
799            }
800            TableSelectionAction::Cell {
801                row,
802                column,
803                operation,
804            } if row < count && column < column_count => {
805                let operation = operation_for(operation);
806                let Selected::Cells(cells) = &mut next else {
807                    return None;
808                };
809                cursor = Some(row);
810                match operation {
811                    RowSelection::Replace | RowSelection::Toggle => {
812                        let key = model.row_key(row);
813                        state.row_anchor = Some((row, key));
814                        state.column_anchor = Some(column);
815                        if operation == RowSelection::Replace {
816                            *cells = Arc::new(BTreeMap::from([(
817                                column,
818                                Arc::new(BTreeSet::from([key])),
819                            )]));
820                        } else {
821                            let cells = Arc::make_mut(cells);
822                            let rows = cells.entry(column).or_default();
823                            toggle(Arc::make_mut(rows), key);
824                            if rows.is_empty() {
825                                cells.remove(&column);
826                            }
827                        }
828                    }
829                    RowSelection::Extend | RowSelection::AddRange => {
830                        let range = state.column_range(column, view);
831                        let rows = Arc::new(row_keys(model, state.row_range(model, current, row)));
832                        select_cells(cells, range, rows, operation == RowSelection::AddRange);
833                    }
834                    RowSelection::Move => {}
835                }
836                state.current_column = Some(column);
837            }
838            TableSelectionAction::DragRange {
839                anchor: (first_row, first_column),
840                end: (row, column),
841                additive,
842            } if view.multiple
843                && first_row < count
844                && row < count
845                && first_column < column_count
846                && column < column_count =>
847            {
848                drag_range = (!additive).then(|| CommittedRange {
849                    endpoints: [(first_row, first_column), (row, column)],
850                    order: view.order.clone(),
851                });
852                match &mut next {
853                    Selected::Rows(rows) => {
854                        let range = row_keys(model, span(first_row, row));
855                        if additive {
856                            Arc::make_mut(rows).extend(range);
857                        } else {
858                            *rows = Arc::new(range);
859                        }
860                    }
861                    Selected::Columns(columns) => {
862                        let range = column_span(view, first_column, column);
863                        if additive {
864                            Arc::make_mut(columns).extend(range);
865                        } else {
866                            *columns = Arc::new(range.collect());
867                        }
868                    }
869                    Selected::Cells(cells) => select_cells(
870                        cells,
871                        column_span(view, first_column, column),
872                        Arc::new(row_keys(model, span(first_row, row))),
873                        additive,
874                    ),
875                }
876                if view.target != SelectionTarget::Columns {
877                    state.row_anchor = Some((first_row, model.row_key(first_row)));
878                    cursor = Some(row);
879                }
880                if view.target != SelectionTarget::Rows {
881                    state.column_anchor = Some(first_column);
882                    state.current_column = Some(column);
883                }
884            }
885            TableSelectionAction::All if view.multiple => {
886                let total = match view.target {
887                    SelectionTarget::Rows => count,
888                    SelectionTarget::Columns => column_count,
889                    SelectionTarget::Cells => count.saturating_mul(column_count),
890                };
891                if previous.len() == total {
892                    if state.drag_range.take().is_some() {
893                        self.changed.notify();
894                    }
895                    return Some(TableSelectionChange {
896                        current: None,
897                        column_changed: false,
898                        selected_count: None,
899                    });
900                }
901                next = match view.target {
902                    SelectionTarget::Rows => Selected::Rows(Arc::new(row_keys(model, 0..count))),
903                    SelectionTarget::Columns => {
904                        Selected::Columns(Arc::new((0..column_count).collect()))
905                    }
906                    SelectionTarget::Cells => {
907                        if count == 0 {
908                            Selected::empty(view.target)
909                        } else {
910                            let rows = Arc::new(row_keys(model, 0..count));
911                            Selected::Cells(Arc::new(
912                                (0..column_count)
913                                    .map(|column| (column, rows.clone()))
914                                    .collect(),
915                            ))
916                        }
917                    }
918                };
919            }
920            TableSelectionAction::Clear => {
921                state.row_anchor = None;
922                state.column_anchor = None;
923                next = Selected::empty(view.target);
924            }
925            _ => return None,
926        }
927        let selected_count = (next != previous).then_some(next.len());
928        let column_changed = state.current_column != old_column;
929        let range_changed = state.drag_range != drag_range;
930        state.drag_range = drag_range;
931        state.selected = Some(next);
932        if selected_count.is_some() || column_changed || range_changed {
933            self.changed.notify();
934        }
935        Some(TableSelectionChange {
936            current: cursor.filter(|index| Some(*index) != current),
937            column_changed,
938            selected_count,
939        })
940    }
941}
942
943#[cfg(test)]
944mod tests {
945    use super::*;
946
947    #[test]
948    fn drag_ranges_use_the_explicit_anchor_in_each_selection_mode() {
949        let selection = TableSelection::default();
950        let model = 6_i64;
951        let rows = selection.snapshot(&model, Some(0), SelectionTarget::Rows, 3, true);
952        let action = TableSelectionAction::DragRange {
953            anchor: (4, 2),
954            end: (1, 0),
955            additive: false,
956        };
957        let change = selection.apply(&model, &rows, Some(0), action).unwrap();
958        assert_eq!(change.current, Some(1));
959        assert_eq!(change.selected_count, Some(4));
960        assert_eq!(
961            selection
962                .snapshot(&model, Some(1), SelectionTarget::Rows, 3, true)
963                .indices(&model),
964            [1, 2, 3, 4],
965        );
966
967        let (_, order) = crate::TableColumnOrder::default().moved(3, 2, 0).unwrap();
968        let columns = selection
969            .snapshot(&model, Some(1), SelectionTarget::Columns, 3, true)
970            .with_column_order(order.clone());
971        let change = selection.apply(&model, &columns, Some(1), action).unwrap();
972        assert_eq!(change.current, None);
973        assert_eq!(change.selected_count, Some(2));
974        let view = selection.snapshot(&model, Some(1), SelectionTarget::Columns, 3, true);
975        assert_eq!(view.columns().iter().copied().collect::<Vec<_>>(), [0, 2]);
976        assert_eq!(view.current_column(), Some(0));
977        assert_eq!(view.drag_range(), None);
978        assert_eq!(
979            view.with_column_order(order).drag_range(),
980            Some([(4, 2), (1, 0)])
981        );
982        let single = selection.snapshot(&model, Some(1), SelectionTarget::Columns, 3, false);
983        assert!(selection.apply(&model, &single, Some(1), action).is_none());
984    }
985
986    #[test]
987    fn whole_column_copy_is_ordered_and_checks_the_budget_before_projecting() {
988        let selection = TableSelection::default();
989        let model = 3_i64;
990        let mut table = Node::new("TableView", None);
991        table.table_header = Some(Box::new(crate::TableHeader {
992            columns: (0..3).map(|_| Node::new("TableColumn", None)).collect(),
993            sort: None,
994            column_widths: Vec::new(),
995        }));
996        for (column, operation) in [(1, RowSelection::Replace), (2, RowSelection::Toggle)] {
997            let view = selection.snapshot(&model, None, SelectionTarget::Columns, 3, true);
998            assert!(
999                selection
1000                    .apply(
1001                        &model,
1002                        &view,
1003                        None,
1004                        TableSelectionAction::Column { column, operation }
1005                    )
1006                    .is_some()
1007            );
1008        }
1009        table.table_selection = Some(Box::new(selection.snapshot(
1010            &model,
1011            None,
1012            SelectionTarget::Columns,
1013            3,
1014            true,
1015        )));
1016        let text = copy_table_text(&model, &table, &[2, 0, 1], |_, column, value| {
1017            Some(format!("{value}:{column}"))
1018        });
1019        assert_eq!(text.as_deref(), Some("0:2\t0:1\n1:2\t1:1\n2:2\t2:1"));
1020        assert!(
1021            copy_table_text(&600_000_i64, &table, &[2, 0, 1], |_, _, _| panic!(
1022                "oversized selection must be rejected before projection"
1023            ))
1024            .is_none()
1025        );
1026    }
1027
1028    #[test]
1029    fn numeric_models_prune_removed_positions_and_reject_stale_actions() {
1030        let selection = TableSelection::default();
1031        let view = selection.snapshot(&5_i64, Some(1), SelectionTarget::Rows, 1, true);
1032        assert_eq!(view.indices(&5_i64), [1]);
1033        let change = selection
1034            .apply(
1035                &5_i64,
1036                &view,
1037                Some(1),
1038                TableSelectionAction::Row {
1039                    index: 4,
1040                    operation: RowSelection::Extend,
1041                },
1042            )
1043            .unwrap();
1044        assert_eq!(change.selected_count, Some(4));
1045        assert_eq!(change.current, Some(4));
1046        let stale = selection.snapshot(&5_i64, Some(4), SelectionTarget::Rows, 1, true);
1047        assert!(
1048            selection
1049                .apply(&3_i64, &stale, None, TableSelectionAction::All)
1050                .is_none()
1051        );
1052        assert_eq!(
1053            selection
1054                .snapshot(&3_i64, None, SelectionTarget::Rows, 1, true)
1055                .indices(&3_i64),
1056            [1, 2]
1057        );
1058    }
1059
1060    #[test]
1061    fn cell_select_all_shares_row_keys_across_columns() {
1062        let selection = TableSelection::default();
1063        let model = crate::VecModel::from((0..10_000).collect::<Vec<_>>());
1064        let view = selection.snapshot(&model, None, SelectionTarget::Cells, 128, true);
1065        selection
1066            .apply(&model, &view, None, TableSelectionAction::All)
1067            .unwrap();
1068        let view = selection.snapshot(&model, None, SelectionTarget::Cells, 128, true);
1069        assert_eq!(view.len(), 1_280_000);
1070        assert!(std::ptr::eq(
1071            view.cell_keys(0).unwrap(),
1072            view.cell_keys(127).unwrap()
1073        ));
1074        let removed = model.row_key(0).unwrap();
1075        model.remove(0);
1076        let view = selection.snapshot(&model, None, SelectionTarget::Cells, 128, true);
1077        assert_eq!(view.len(), 1_279_872);
1078        assert!(!view.contains_cell(removed, 0));
1079        assert!(std::ptr::eq(
1080            view.cell_keys(0).unwrap(),
1081            view.cell_keys(127).unwrap()
1082        ));
1083    }
1084
1085    #[test]
1086    fn grid_selection_can_be_single_and_mode_changes_reject_old_gestures() {
1087        let selection = TableSelection::default();
1088        let view = selection.snapshot(&5_i64, None, SelectionTarget::Cells, 2, false);
1089        assert!(
1090            selection
1091                .apply(&5_i64, &view, None, TableSelectionAction::All)
1092                .is_none()
1093        );
1094        for (row, column, operation) in
1095            [(0, 0, RowSelection::Replace), (4, 1, RowSelection::Extend)]
1096        {
1097            selection
1098                .apply(
1099                    &5_i64,
1100                    &view,
1101                    None,
1102                    TableSelectionAction::Cell {
1103                        row,
1104                        column,
1105                        operation,
1106                    },
1107                )
1108                .unwrap();
1109        }
1110        let view = selection.snapshot(&5_i64, None, SelectionTarget::Cells, 2, false);
1111        assert_eq!(view.len(), 1);
1112        assert!(view.contains_cell(5_i64.row_key(4), 1));
1113        let columns = selection.snapshot(&5_i64, None, SelectionTarget::Columns, 2, true);
1114        assert!(columns.is_empty());
1115        assert!(
1116            selection
1117                .apply(&5_i64, &view, None, TableSelectionAction::Clear)
1118                .is_none()
1119        );
1120    }
1121}