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 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#[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 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 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 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#[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 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#[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}