Skip to main content

tree_table/types/
table_grid.rs

1use crate::BoundedDeque;
2use crate::EventData;
3use crate::Header;
4use crate::Index;
5use crate::utils::utils_fns::pull_n;
6use crate::utils::utils_fns::push_n;
7use alloc::rc::Rc;
8use alloc::string::String;
9use alloc::vec::Vec;
10use core::cell::RefCell;
11use hashbrown::HashMap;
12
13#[derive(Clone, Debug)]
14pub struct TableGrid {
15    pub index: Index,
16    pub header: Header,
17    pub merged: HashMap<(usize, usize), (usize, usize)>,
18    pub frozen_rows: Vec<usize>,
19    pub frozen_cols: Vec<usize>,
20    pub disp_rows: Vec<usize>,
21    pub disp_cols: Vec<usize>,
22    pub canvas_rows: Vec<u64>,
23    pub canvas_cols: Vec<u64>,
24    pub undo_stack: BoundedDeque<Rc<RefCell<EventData>>>,
25    pub redo_stack: BoundedDeque<Rc<RefCell<EventData>>>,
26}
27
28impl TableGrid {
29    pub fn new(max_undos: usize) -> Self {
30        TableGrid {
31            index: Index::new(),
32            header: Header::new(),
33            merged: HashMap::new(),
34            frozen_rows: Vec::new(),
35            frozen_cols: Vec::new(),
36            disp_rows: Vec::new(),
37            disp_cols: Vec::new(),
38            canvas_rows: Vec::new(),
39            canvas_cols: Vec::new(),
40            undo_stack: BoundedDeque::new(max_undos),
41            redo_stack: BoundedDeque::new(max_undos),
42        }
43    }
44
45    /// Resets all but index, header and undo/redo stacks.
46    pub fn reset(&mut self) {
47        self.merged.clear();
48        self.frozen_rows.clear();
49        self.frozen_cols.clear();
50        self.disp_rows.clear();
51        self.disp_cols.clear();
52        self.canvas_rows.clear();
53        self.canvas_cols.clear();
54    }
55
56    pub fn push_rows(&mut self, sorted_seq: &[usize]) {
57        // TODO: add named spans
58        self.frozen_rows
59            .iter_mut()
60            .for_each(|k| *k = push_n(*k, sorted_seq));
61    }
62
63    pub fn push_cols(&mut self, sorted_seq: &[usize]) {
64        // TODO: add named spans
65        self.frozen_cols
66            .iter_mut()
67            .for_each(|k| *k = push_n(*k, sorted_seq));
68    }
69
70    pub fn pull_rows(&mut self, sorted_seq: &[usize]) {
71        // TODO: add named spans
72        self.frozen_rows
73            .iter_mut()
74            .for_each(|k| *k = pull_n(*k, sorted_seq));
75    }
76
77    pub fn pull_cols(&mut self, sorted_seq: &[usize]) {
78        // TODO: add named spans
79        self.frozen_cols
80            .iter_mut()
81            .for_each(|k| *k = pull_n(*k, sorted_seq));
82    }
83
84    pub fn move_rows(
85        &mut self,
86        full_old_to_new: &[usize],
87        full_new_to_old: &[usize],
88    ) -> Result<(), String> {
89        self.index.move_rows(full_new_to_old)?;
90        // TODO: add named spans
91        self.frozen_rows
92            .iter_mut()
93            .for_each(|k| *k = full_old_to_new[*k as usize]);
94        Ok(())
95    }
96
97    pub fn move_cols(
98        &mut self,
99        full_old_to_new: &[usize],
100        full_new_to_old: &[usize],
101    ) -> Result<(), String> {
102        self.header.move_cols(full_new_to_old)?;
103        self.index.move_cols(full_old_to_new);
104        // TODO: add named spans
105        self.frozen_cols
106            .iter_mut()
107            .for_each(|k| *k = full_old_to_new[*k as usize]);
108        Ok(())
109    }
110}