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_row_keys(0..model.row_count(), |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 live = row_keys(model, 0..model.row_count());
121                // A rectangular range can share a single row set across many columns.
122                let mut pruned = HashMap::<_, RowKeys>::new();
123                let cells = Arc::make_mut(cells);
124                cells.retain(|_, rows| {
125                    *rows = pruned
126                        .entry(Arc::as_ptr(rows))
127                        .or_insert_with(|| {
128                            if rows.is_subset(&live) {
129                                rows.clone()
130                            } else {
131                                Arc::new(rows.intersection(&live).copied().collect())
132                            }
133                        })
134                        .clone();
135                    !rows.is_empty()
136                });
137            }
138            Self::Columns(_) => {}
139        }
140    }
141}
142
143fn row_keys(model: &impl ListModel, range: Range<usize>) -> BTreeSet<RowKey> {
144    let mut keys = BTreeSet::new();
145    model.visit_row_keys(range, |key| {
146        keys.insert(key);
147    });
148    keys
149}
150
151fn span(a: usize, b: usize) -> Range<usize> {
152    a.min(b)..a.max(b) + 1
153}
154
155/// Selection in a table snapshot, including units outside the viewport.
156#[derive(Clone, Debug, PartialEq, Eq)]
157pub struct TableSelectionSnapshot {
158    stamp: (u64, u64),
159    target: SelectionTarget,
160    column_count: usize,
161    order: crate::TableColumnOrder,
162    multiple: bool,
163    current_column: Option<usize>,
164    selected: Selected,
165}
166
167impl TableSelectionSnapshot {
168    #[doc(hidden)]
169    pub fn with_column_order(mut self, order: crate::TableColumnOrder) -> Self {
170        self.order = order;
171        self
172    }
173
174    pub fn target(&self) -> SelectionTarget {
175        self.target
176    }
177
178    pub fn current_column(&self) -> Option<usize> {
179        self.current_column
180    }
181
182    pub fn multiple(&self) -> bool {
183        self.multiple
184    }
185
186    #[doc(hidden)]
187    pub fn structure_stamp(&self) -> (u64, u64) {
188        self.stamp
189    }
190
191    /// Number of selected rows, cells, or columns, depending on the target.
192    pub fn len(&self) -> usize {
193        self.selected.len()
194    }
195
196    pub fn is_empty(&self) -> bool {
197        self.len() == 0
198    }
199
200    pub fn keys(&self) -> &BTreeSet<RowKey> {
201        static EMPTY: BTreeSet<RowKey> = BTreeSet::new();
202        match &self.selected {
203            Selected::Rows(rows) => rows,
204            _ => &EMPTY,
205        }
206    }
207
208    pub fn columns(&self) -> &BTreeSet<usize> {
209        static EMPTY: BTreeSet<usize> = BTreeSet::new();
210        match &self.selected {
211            Selected::Columns(columns) => columns,
212            _ => &EMPTY,
213        }
214    }
215
216    /// Explicit cell selection in a column, without expanding whole-row or whole-column selections.
217    pub fn cell_keys(&self, column: usize) -> Option<&BTreeSet<RowKey>> {
218        match &self.selected {
219            Selected::Cells(cells) => cells.get(&column).map(Arc::as_ref),
220            _ => None,
221        }
222    }
223
224    pub fn contains_cell(&self, row: RowKey, column: usize) -> bool {
225        column < self.column_count
226            && row.model == self.stamp.0
227            && match &self.selected {
228                Selected::Rows(rows) => rows.contains(&row),
229                Selected::Columns(columns) => columns.contains(&column),
230                Selected::Cells(cells) => {
231                    cells.get(&column).is_some_and(|rows| rows.contains(&row))
232                }
233            }
234    }
235
236    /// Resolve selected rows in the model's current order with one model pass.
237    pub fn indices(&self, model: &impl ListModel) -> Vec<usize> {
238        let keys = self.keys();
239        if keys.is_empty() || self.stamp.0 != model.structure_stamp().0 {
240            return Vec::new();
241        }
242        let mut indices = Vec::with_capacity(keys.len());
243        let mut index = 0;
244        model.visit_row_keys(0..model.row_count(), |key| {
245            if keys.contains(&key) {
246                indices.push(index);
247            }
248            index += 1;
249        });
250        indices
251    }
252}
253
254/// Serialize the selected model rows in the supplied visual column order.
255#[doc(hidden)]
256pub fn copy_table_text<M: ListModel>(
257    model: &M,
258    table: &Node,
259    displayed_columns: &[usize],
260    mut cell: impl FnMut(usize, usize, &M::Item) -> Option<String>,
261) -> Option<String> {
262    let count = model.row_count();
263    let column_count = table.table_header.as_ref()?.columns.len();
264    let mut columns: Vec<_> = displayed_columns
265        .iter()
266        .copied()
267        .filter(|&column| column < column_count)
268        .collect();
269    let mut rows = Vec::new();
270    let mut range = 0..count;
271    let mut cells = None;
272    if let Some(selection) = table.table_selection.as_deref() {
273        if selection.stamp.0 != model.structure_stamp().0 {
274            return None;
275        }
276        match &selection.selected {
277            Selected::Rows(selected) => {
278                if selected.len().checked_mul(columns.len())? > MAX_CLIPBOARD_CELLS {
279                    return None;
280                }
281                let current = table
282                    .int("current-row")
283                    .and_then(|row| usize::try_from(row).ok());
284                if let Some(row) = current.filter(|&row| {
285                    selected.len() == 1 && row < count && selected.contains(&model.row_key(row))
286                }) {
287                    rows.push(row);
288                } else {
289                    rows = selection.indices(model);
290                }
291                range = 0..0;
292            }
293            Selected::Columns(selected) => columns.retain(|column| selected.contains(column)),
294            Selected::Cells(selected) => {
295                let start = columns
296                    .iter()
297                    .position(|column| selected.contains_key(column))?;
298                let end = columns
299                    .iter()
300                    .rposition(|column| selected.contains_key(column))?
301                    + 1;
302                columns = columns[start..end].to_vec();
303                let selected_count = columns
304                    .iter()
305                    .filter_map(|column| selected.get(column))
306                    .try_fold(0usize, |count, keys| count.checked_add(keys.len()))?;
307                if selected_count > MAX_CLIPBOARD_CELLS {
308                    return None;
309                }
310                let mut seen = HashSet::new();
311                let row_sets: Vec<_> = columns
312                    .iter()
313                    .filter_map(|column| selected.get(column))
314                    .filter(|keys| seen.insert(Arc::as_ptr(keys)))
315                    .collect();
316                let union: HashSet<_> = if row_sets.len() > 1 {
317                    row_sets
318                        .iter()
319                        .flat_map(|rows| rows.iter().copied())
320                        .collect()
321                } else {
322                    HashSet::new()
323                };
324                let mut index = 0;
325                let mut first = count;
326                let mut last = 0;
327                model.visit_row_keys(0..count, |key| {
328                    let included = if let [keys] = row_sets.as_slice() {
329                        keys.contains(&key)
330                    } else {
331                        union.contains(&key)
332                    };
333                    if included {
334                        first = first.min(index);
335                        last = index + 1;
336                    }
337                    index += 1;
338                });
339                range = first..last;
340                cells = Some(selection);
341            }
342        }
343    } else {
344        let row = usize::try_from(table.int("current-row")?).ok()?;
345        if row >= count {
346            return None;
347        }
348        range = row..row + 1;
349    }
350
351    let size = (rows.len() + range.len()).checked_mul(columns.len())?;
352    if size == 0 || size > MAX_CLIPBOARD_CELLS {
353        return None;
354    }
355    let mut text = String::new();
356    for (line, row) in rows.into_iter().chain(range).enumerate() {
357        if line != 0 {
358            text.push('\n');
359        }
360        let line_start = text.len();
361        let key = model.row_key(row);
362        let item = model.item(row);
363        for (slot, &column) in columns.iter().enumerate() {
364            if slot != 0 {
365                text.push('\t');
366            }
367            if cells.is_none_or(|selection| selection.contains_cell(key, column))
368                && let Some(value) = cell(row, column, &item)
369            {
370                append_cell(&mut text, &value)?;
371            }
372            if text.len() > MAX_CLIPBOARD_BYTES {
373                return None;
374            }
375        }
376        if text.len() == line_start {
377            // A blank final single-column row would otherwise look like a trailing newline.
378            if text.len().checked_add(2)? > MAX_CLIPBOARD_BYTES {
379                return None;
380            }
381            text.push_str("\"\"");
382        }
383    }
384    Some(text)
385}
386
387fn append_cell(text: &mut String, value: &str) -> Option<()> {
388    let quoted = value.contains(['\t', '\n', '\r', '"']);
389    let extra = if quoted {
390        value.bytes().filter(|&byte| byte == b'"').count() + 2
391    } else {
392        0
393    };
394    if text.len().saturating_add(value.len()).saturating_add(extra) > MAX_CLIPBOARD_BYTES {
395        return None;
396    }
397    if quoted {
398        text.push('"');
399        for (index, part) in value.split('"').enumerate() {
400            if index != 0 {
401                text.push_str("\"\"");
402            }
403            text.push_str(part);
404        }
405        text.push('"');
406    } else {
407        text.push_str(value);
408    }
409    Some(())
410}
411
412#[doc(hidden)]
413pub struct TableSelectionChange {
414    pub current: Option<usize>,
415    pub column_changed: bool,
416    pub selected_count: Option<usize>,
417}
418
419#[derive(Default)]
420struct Selection {
421    stamp: Option<(u64, u64)>,
422    target: SelectionTarget,
423    multiple: bool,
424    selected: Option<Selected>,
425    row_anchor: Option<(usize, RowKey)>,
426    column_anchor: Option<usize>,
427    current_column: Option<usize>,
428}
429
430impl Selection {
431    fn refresh(
432        &mut self,
433        model: &impl ListModel,
434        stamp: (u64, u64),
435        target: SelectionTarget,
436        multiple: bool,
437    ) {
438        if self.target != target || self.multiple != multiple {
439            *self = Self {
440                target,
441                multiple,
442                stamp: Some(stamp),
443                ..Self::default()
444            };
445            return;
446        }
447        if self.stamp == Some(stamp) {
448            return;
449        }
450        if let Some(previous) = self.stamp.replace(stamp) {
451            if previous.0 != stamp.0 && target != SelectionTarget::Columns {
452                self.selected = Some(Selected::empty(target));
453                self.row_anchor = None;
454            } else if let Some(selected) = &mut self.selected {
455                selected.retain_live(model);
456            }
457        }
458    }
459
460    fn selected(&self, model: &impl ListModel, current: Option<usize>) -> Selected {
461        self.selected.clone().unwrap_or_else(|| {
462            if self.target == SelectionTarget::Rows {
463                Selected::Rows(Arc::new(
464                    current
465                        .filter(|&index| index < model.row_count())
466                        .map(|index| model.row_key(index))
467                        .into_iter()
468                        .collect(),
469                ))
470            } else {
471                Selected::empty(self.target)
472            }
473        })
474    }
475
476    fn row_range(
477        &mut self,
478        model: &impl ListModel,
479        current: Option<usize>,
480        row: usize,
481    ) -> Range<usize> {
482        let count = model.row_count();
483        let anchor = self
484            .row_anchor
485            .and_then(|(old, key)| {
486                if old < count && model.row_key(old) == key {
487                    Some(old)
488                } else {
489                    model.index_of_key(key)
490                }
491            })
492            .or(current.filter(|&index| index < count))
493            .unwrap_or(row);
494        self.row_anchor = Some((anchor, model.row_key(anchor)));
495        span(anchor, row)
496    }
497
498    fn column_range<'a>(
499        &mut self,
500        column: usize,
501        view: &'a TableSelectionSnapshot,
502    ) -> impl Iterator<Item = usize> + use<'a> {
503        let anchor = self
504            .column_anchor
505            .or(self.current_column)
506            .filter(|&column| column < view.column_count)
507            .unwrap_or(column);
508        self.column_anchor = Some(anchor);
509        column_span(view, anchor, column)
510    }
511}
512
513fn column_span(
514    view: &TableSelectionSnapshot,
515    anchor: usize,
516    column: usize,
517) -> impl Iterator<Item = usize> + use<'_> {
518    let index = |column| view.order.visual_index(view.column_count, column);
519    let range = span(index(anchor).unwrap_or(0), index(column).unwrap_or(0));
520    view.order
521        .iter(view.column_count)
522        .skip(range.start)
523        .take(range.len())
524}
525
526fn select_cells(
527    cells: &mut Arc<ColumnCells>,
528    columns: impl Iterator<Item = usize>,
529    rows: RowKeys,
530    additive: bool,
531) {
532    if !additive {
533        *cells = Arc::new(columns.map(|column| (column, rows.clone())).collect());
534        return;
535    }
536    let cells = Arc::make_mut(cells);
537    let mut merged = HashMap::<_, RowKeys>::new();
538    for column in columns {
539        let keys = cells.entry(column).or_insert_with(|| rows.clone());
540        if !rows.is_subset(keys) {
541            *keys = merged
542                .entry(Arc::as_ptr(keys))
543                .or_insert_with(|| Arc::new(keys.union(&rows).copied().collect()))
544                .clone();
545        }
546    }
547}
548
549fn toggle<T: Ord>(set: &mut BTreeSet<T>, key: T) {
550    if !set.remove(&key) {
551        set.insert(key);
552    }
553}
554
555/// Generated per table so gestures and data changes share the same selection.
556#[doc(hidden)]
557#[derive(Default)]
558pub struct TableSelection {
559    state: RefCell<Selection>,
560    changed: ChangeSignal,
561}
562
563impl TableSelection {
564    pub fn snapshot(
565        &self,
566        model: &impl ListModel,
567        current: Option<usize>,
568        target: SelectionTarget,
569        column_count: usize,
570        multiple: bool,
571    ) -> TableSelectionSnapshot {
572        self.changed.track();
573        let stamp = model.structure_stamp();
574        let mut state = self.state.borrow_mut();
575        state.refresh(model, stamp, target, multiple);
576        TableSelectionSnapshot {
577            stamp,
578            target,
579            column_count,
580            order: crate::TableColumnOrder::default(),
581            multiple,
582            current_column: state.current_column,
583            selected: state.selected(model, current),
584        }
585    }
586
587    pub fn apply(
588        &self,
589        model: &impl ListModel,
590        view: &TableSelectionSnapshot,
591        current: Option<usize>,
592        action: TableSelectionAction,
593    ) -> Option<TableSelectionChange> {
594        let stamp = model.structure_stamp();
595        let mut state = self.state.borrow_mut();
596        if stamp != view.stamp || state.target != view.target || state.multiple != view.multiple {
597            return None;
598        }
599        let count = model.row_count();
600        let column_count = view.column_count;
601        state.refresh(model, stamp, view.target, view.multiple);
602        let previous = state.selected(model, current);
603        let mut next = previous.clone();
604        let mut cursor = None;
605        let old_column = state.current_column;
606        let operation_for = |operation| {
607            if view.multiple || operation == RowSelection::Move {
608                operation
609            } else {
610                RowSelection::Replace
611            }
612        };
613        match action {
614            TableSelectionAction::Row { index, operation } if index < count => {
615                let operation = operation_for(operation);
616                cursor = Some(index);
617                if let Selected::Rows(rows) = &mut next {
618                    let key = model.row_key(index);
619                    match operation {
620                        RowSelection::Replace => {
621                            state.row_anchor = Some((index, key));
622                            *rows = Arc::new(BTreeSet::from([key]));
623                        }
624                        RowSelection::Toggle => {
625                            state.row_anchor = Some((index, key));
626                            toggle(Arc::make_mut(rows), key);
627                        }
628                        RowSelection::Extend | RowSelection::AddRange => {
629                            let keys = row_keys(model, state.row_range(model, current, index));
630                            if operation == RowSelection::Extend {
631                                *rows = Arc::new(keys);
632                            } else {
633                                Arc::make_mut(rows).extend(keys);
634                            }
635                        }
636                        RowSelection::Move => {}
637                    }
638                } else if operation != RowSelection::Move {
639                    return None;
640                }
641            }
642            TableSelectionAction::Column { column, operation } if column < column_count => {
643                let operation = operation_for(operation);
644                let Selected::Columns(columns) = &mut next else {
645                    return None;
646                };
647                match operation {
648                    RowSelection::Replace => {
649                        state.column_anchor = Some(column);
650                        *columns = Arc::new(BTreeSet::from([column]));
651                    }
652                    RowSelection::Toggle => {
653                        state.column_anchor = Some(column);
654                        toggle(Arc::make_mut(columns), column);
655                    }
656                    RowSelection::Extend | RowSelection::AddRange => {
657                        let range = state.column_range(column, view);
658                        if operation == RowSelection::Extend {
659                            *columns = Arc::new(range.collect());
660                        } else {
661                            Arc::make_mut(columns).extend(range);
662                        }
663                    }
664                    RowSelection::Move => {}
665                }
666                state.current_column = Some(column);
667            }
668            TableSelectionAction::Cell {
669                row,
670                column,
671                operation,
672            } if row < count && column < column_count => {
673                let operation = operation_for(operation);
674                let Selected::Cells(cells) = &mut next else {
675                    return None;
676                };
677                cursor = Some(row);
678                match operation {
679                    RowSelection::Replace | RowSelection::Toggle => {
680                        let key = model.row_key(row);
681                        state.row_anchor = Some((row, key));
682                        state.column_anchor = Some(column);
683                        if operation == RowSelection::Replace {
684                            *cells = Arc::new(BTreeMap::from([(
685                                column,
686                                Arc::new(BTreeSet::from([key])),
687                            )]));
688                        } else {
689                            let cells = Arc::make_mut(cells);
690                            let rows = cells.entry(column).or_default();
691                            toggle(Arc::make_mut(rows), key);
692                            if rows.is_empty() {
693                                cells.remove(&column);
694                            }
695                        }
696                    }
697                    RowSelection::Extend | RowSelection::AddRange => {
698                        let range = state.column_range(column, view);
699                        let rows = Arc::new(row_keys(model, state.row_range(model, current, row)));
700                        select_cells(cells, range, rows, operation == RowSelection::AddRange);
701                    }
702                    RowSelection::Move => {}
703                }
704                state.current_column = Some(column);
705            }
706            TableSelectionAction::DragRange {
707                anchor: (first_row, first_column),
708                end: (row, column),
709                additive,
710            } if view.multiple
711                && first_row < count
712                && row < count
713                && first_column < column_count
714                && column < column_count =>
715            {
716                match &mut next {
717                    Selected::Rows(rows) => {
718                        let range = row_keys(model, span(first_row, row));
719                        if additive {
720                            Arc::make_mut(rows).extend(range);
721                        } else {
722                            *rows = Arc::new(range);
723                        }
724                    }
725                    Selected::Columns(columns) => {
726                        let range = column_span(view, first_column, column);
727                        if additive {
728                            Arc::make_mut(columns).extend(range);
729                        } else {
730                            *columns = Arc::new(range.collect());
731                        }
732                    }
733                    Selected::Cells(cells) => select_cells(
734                        cells,
735                        column_span(view, first_column, column),
736                        Arc::new(row_keys(model, span(first_row, row))),
737                        additive,
738                    ),
739                }
740                if view.target != SelectionTarget::Columns {
741                    state.row_anchor = Some((first_row, model.row_key(first_row)));
742                    cursor = Some(row);
743                }
744                if view.target != SelectionTarget::Rows {
745                    state.column_anchor = Some(first_column);
746                    state.current_column = Some(column);
747                }
748            }
749            TableSelectionAction::All if view.multiple => {
750                let total = match view.target {
751                    SelectionTarget::Rows => count,
752                    SelectionTarget::Columns => column_count,
753                    SelectionTarget::Cells => count.saturating_mul(column_count),
754                };
755                if previous.len() == total {
756                    return Some(TableSelectionChange {
757                        current: None,
758                        column_changed: false,
759                        selected_count: None,
760                    });
761                }
762                next = match view.target {
763                    SelectionTarget::Rows => Selected::Rows(Arc::new(row_keys(model, 0..count))),
764                    SelectionTarget::Columns => {
765                        Selected::Columns(Arc::new((0..column_count).collect()))
766                    }
767                    SelectionTarget::Cells => {
768                        if count == 0 {
769                            Selected::empty(view.target)
770                        } else {
771                            let rows = Arc::new(row_keys(model, 0..count));
772                            Selected::Cells(Arc::new(
773                                (0..column_count)
774                                    .map(|column| (column, rows.clone()))
775                                    .collect(),
776                            ))
777                        }
778                    }
779                };
780            }
781            TableSelectionAction::Clear => {
782                state.row_anchor = None;
783                state.column_anchor = None;
784                next = Selected::empty(view.target);
785            }
786            _ => return None,
787        }
788        let selected_count = (next != previous).then_some(next.len());
789        let column_changed = state.current_column != old_column;
790        state.selected = Some(next);
791        if selected_count.is_some() || column_changed {
792            self.changed.notify();
793        }
794        Some(TableSelectionChange {
795            current: cursor.filter(|index| Some(*index) != current),
796            column_changed,
797            selected_count,
798        })
799    }
800}
801
802#[cfg(test)]
803mod tests {
804    use super::*;
805
806    #[test]
807    fn drag_ranges_use_the_explicit_anchor_in_each_selection_mode() {
808        let selection = TableSelection::default();
809        let model = 6_i64;
810        let rows = selection.snapshot(&model, Some(0), SelectionTarget::Rows, 3, true);
811        let action = TableSelectionAction::DragRange {
812            anchor: (4, 2),
813            end: (1, 0),
814            additive: false,
815        };
816        let change = selection.apply(&model, &rows, Some(0), action).unwrap();
817        assert_eq!(change.current, Some(1));
818        assert_eq!(change.selected_count, Some(4));
819        assert_eq!(
820            selection
821                .snapshot(&model, Some(1), SelectionTarget::Rows, 3, true)
822                .indices(&model),
823            [1, 2, 3, 4],
824        );
825
826        let (_, order) = crate::TableColumnOrder::default().moved(3, 2, 0).unwrap();
827        let columns = selection
828            .snapshot(&model, Some(1), SelectionTarget::Columns, 3, true)
829            .with_column_order(order);
830        let change = selection.apply(&model, &columns, Some(1), action).unwrap();
831        assert_eq!(change.current, None);
832        assert_eq!(change.selected_count, Some(2));
833        let view = selection.snapshot(&model, Some(1), SelectionTarget::Columns, 3, true);
834        assert_eq!(view.columns().iter().copied().collect::<Vec<_>>(), [0, 2]);
835        assert_eq!(view.current_column(), Some(0));
836        let single = selection.snapshot(&model, Some(1), SelectionTarget::Columns, 3, false);
837        assert!(selection.apply(&model, &single, Some(1), action).is_none());
838    }
839
840    #[test]
841    fn whole_column_copy_is_ordered_and_checks_the_budget_before_projecting() {
842        let selection = TableSelection::default();
843        let model = 3_i64;
844        let mut table = Node::new("TableView", None);
845        table.table_header = Some(Box::new(crate::TableHeader {
846            columns: (0..3).map(|_| Node::new("TableColumn", None)).collect(),
847            sort: None,
848            column_widths: Vec::new(),
849        }));
850        for (column, operation) in [(1, RowSelection::Replace), (2, RowSelection::Toggle)] {
851            let view = selection.snapshot(&model, None, SelectionTarget::Columns, 3, true);
852            assert!(
853                selection
854                    .apply(
855                        &model,
856                        &view,
857                        None,
858                        TableSelectionAction::Column { column, operation }
859                    )
860                    .is_some()
861            );
862        }
863        table.table_selection = Some(Box::new(selection.snapshot(
864            &model,
865            None,
866            SelectionTarget::Columns,
867            3,
868            true,
869        )));
870        let text = copy_table_text(&model, &table, &[2, 0, 1], |_, column, value| {
871            Some(format!("{value}:{column}"))
872        });
873        assert_eq!(text.as_deref(), Some("0:2\t0:1\n1:2\t1:1\n2:2\t2:1"));
874        assert!(
875            copy_table_text(&600_000_i64, &table, &[2, 0, 1], |_, _, _| panic!(
876                "oversized selection must be rejected before projection"
877            ))
878            .is_none()
879        );
880    }
881
882    #[test]
883    fn numeric_models_prune_removed_positions_and_reject_stale_actions() {
884        let selection = TableSelection::default();
885        let view = selection.snapshot(&5_i64, Some(1), SelectionTarget::Rows, 1, true);
886        assert_eq!(view.indices(&5_i64), [1]);
887        let change = selection
888            .apply(
889                &5_i64,
890                &view,
891                Some(1),
892                TableSelectionAction::Row {
893                    index: 4,
894                    operation: RowSelection::Extend,
895                },
896            )
897            .unwrap();
898        assert_eq!(change.selected_count, Some(4));
899        assert_eq!(change.current, Some(4));
900        let stale = selection.snapshot(&5_i64, Some(4), SelectionTarget::Rows, 1, true);
901        assert!(
902            selection
903                .apply(&3_i64, &stale, None, TableSelectionAction::All)
904                .is_none()
905        );
906        assert_eq!(
907            selection
908                .snapshot(&3_i64, None, SelectionTarget::Rows, 1, true)
909                .indices(&3_i64),
910            [1, 2]
911        );
912    }
913
914    #[test]
915    fn cell_select_all_shares_row_keys_across_columns() {
916        let selection = TableSelection::default();
917        let model = crate::VecModel::from((0..10_000).collect::<Vec<_>>());
918        let view = selection.snapshot(&model, None, SelectionTarget::Cells, 128, true);
919        selection
920            .apply(&model, &view, None, TableSelectionAction::All)
921            .unwrap();
922        let view = selection.snapshot(&model, None, SelectionTarget::Cells, 128, true);
923        assert_eq!(view.len(), 1_280_000);
924        assert!(std::ptr::eq(
925            view.cell_keys(0).unwrap(),
926            view.cell_keys(127).unwrap()
927        ));
928        let removed = model.row_key(0).unwrap();
929        model.remove(0);
930        let view = selection.snapshot(&model, None, SelectionTarget::Cells, 128, true);
931        assert_eq!(view.len(), 1_279_872);
932        assert!(!view.contains_cell(removed, 0));
933        assert!(std::ptr::eq(
934            view.cell_keys(0).unwrap(),
935            view.cell_keys(127).unwrap()
936        ));
937    }
938
939    #[test]
940    fn grid_selection_can_be_single_and_mode_changes_reject_old_gestures() {
941        let selection = TableSelection::default();
942        let view = selection.snapshot(&5_i64, None, SelectionTarget::Cells, 2, false);
943        assert!(
944            selection
945                .apply(&5_i64, &view, None, TableSelectionAction::All)
946                .is_none()
947        );
948        for (row, column, operation) in
949            [(0, 0, RowSelection::Replace), (4, 1, RowSelection::Extend)]
950        {
951            selection
952                .apply(
953                    &5_i64,
954                    &view,
955                    None,
956                    TableSelectionAction::Cell {
957                        row,
958                        column,
959                        operation,
960                    },
961                )
962                .unwrap();
963        }
964        let view = selection.snapshot(&5_i64, None, SelectionTarget::Cells, 2, false);
965        assert_eq!(view.len(), 1);
966        assert!(view.contains_cell(5_i64.row_key(4), 1));
967        let columns = selection.snapshot(&5_i64, None, SelectionTarget::Columns, 2, true);
968        assert!(columns.is_empty());
969        assert!(
970            selection
971                .apply(&5_i64, &view, None, TableSelectionAction::Clear)
972                .is_none()
973        );
974    }
975}