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