Skip to main content

tree_table/api/
data_set.rs

1use alloc::{rc::Rc, string::String};
2use core::cell::RefCell;
3
4use crate::args::{FillDataArgs, SetDataArgs};
5use crate::{EventData, Table};
6
7impl Table {
8    // Sets table cell data using row ids/pos and col ids/pos.
9    pub fn set_data(
10        &mut self,
11        kwargs: Option<SetDataArgs>,
12    ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
13        let kwargs = kwargs.unwrap_or_default();
14        let empty_val = &self.opts.empty_val;
15        let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
16        let normalize = kwargs.fmt_normalize;
17        let ignore_fmt_errs = kwargs.ignore_fmt_errs;
18        let mut error: Option<String> = None;
19
20        if kwargs.ignore_id_errs {
21            for (row_pos, cols) in kwargs.data.into_iter() {
22                let Ok(rn) = Self::acr_pos(&self.grid.index.iid_to_row, &row_pos) else {
23                    continue;
24                };
25                for (col_pos, val) in cols.into_iter() {
26                    let Ok(cn) = Self::acr_pos(&self.grid.header.iid_to_col, &col_pos) else {
27                        continue;
28                    };
29                    if let Err(e) = Self::acr_event_data_fmt_set_tval(
30                        &mut self.grid.index.cells,
31                        rn,
32                        cn,
33                        val,
34                        normalize,
35                        ignore_fmt_errs,
36                        empty_val,
37                        &mut event_data,
38                    ) {
39                        error = Some(e);
40                        break;
41                    }
42                }
43            }
44        } else {
45            for (row_pos, cols) in kwargs.data.into_iter() {
46                let rn = Self::acr_pos(&self.grid.index.iid_to_row, &row_pos)?;
47                for (col_pos, val) in cols.into_iter() {
48                    let cn = Self::acr_pos(&self.grid.header.iid_to_col, &col_pos)?;
49                    if let Err(e) = Self::acr_event_data_fmt_set_tval(
50                        &mut self.grid.index.cells,
51                        rn,
52                        cn,
53                        val,
54                        normalize,
55                        ignore_fmt_errs,
56                        empty_val,
57                        &mut event_data,
58                    ) {
59                        error = Some(e);
60                        break;
61                    }
62                }
63            }
64        }
65
66        if let Some(e) = error {
67            self.cr_roll_back(Rc::new(RefCell::new(event_data)));
68            return Err(e);
69        } else {
70            self.cr_finalize_event_if_any_non_selection_change(
71                event_data,
72                kwargs.undo,
73                kwargs.emit,
74                true,
75            )
76        }
77    }
78
79    /// Sets table cell data using a key and a single value.
80    pub fn fill_data(
81        &mut self,
82        kwargs: Option<FillDataArgs>,
83    ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
84        let kwargs = kwargs.unwrap_or_default();
85        let span = self.cr_key_to_span(kwargs.key)?;
86        let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
87        let val = kwargs.val.unwrap_or(self.opts.empty_val.clone());
88        let normalize = kwargs.fmt_normalize;
89        let ignore_fmt_errs = kwargs.ignore_fmt_errs;
90
91        if let Err(e) = (|| -> Result<(), String> {
92            if kwargs.add_rows {
93                let span_max_row = span.max_row(&self.grid);
94                self.cr_ensure_widget_nrows(span_max_row, &mut event_data, true)?;
95            }
96            if kwargs.add_cols {
97                let span_max_col = span.max_col(&self.grid);
98                self.cr_ensure_widget_ncols(span_max_col, &mut event_data, true)?;
99            }
100
101            let row_start = span.row;
102            let row_end = span.max_row(&self.grid);
103            let effective_row_end = if kwargs.add_rows {
104                row_end
105            } else {
106                row_end.min(Self::acr_total_rows(&self.grid.index.cells))
107            };
108
109            let col_start = span.col;
110            let col_end = span.max_col(&self.grid);
111            let effective_col_end = if kwargs.add_cols {
112                col_end
113            } else {
114                col_end.min(Self::acr_total_cols(&self.grid.header.cells))
115            };
116            let empty_val = &self.opts.empty_val;
117
118            for row in row_start..=effective_row_end {
119                for col in col_start..=effective_col_end {
120                    Self::acr_event_data_fmt_set_tval(
121                        &mut self.grid.index.cells,
122                        row,
123                        col,
124                        val.clone(),
125                        normalize,
126                        ignore_fmt_errs,
127                        empty_val,
128                        &mut event_data,
129                    )?;
130                }
131            }
132            Ok(())
133        })() {
134            self.cr_roll_back(Rc::new(RefCell::new(event_data)));
135            return Err(e);
136        }
137
138        self.cr_finalize_event_if_any_non_selection_change(
139            event_data,
140            kwargs.undo,
141            kwargs.emit,
142            true,
143        )
144    }
145}