Skip to main content

tree_table/api/
cell_align.rs

1use alloc::{rc::Rc, string::String};
2use core::cell::RefCell;
3
4use crate::{CellAlignArgs, EventData, Table};
5
6impl Table {
7    pub fn align(
8        &mut self,
9        kwargs: Option<CellAlignArgs>,
10    ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
11        let kwargs: CellAlignArgs = kwargs.unwrap_or_default();
12        let span = self.cr_key_to_span(kwargs.key)?;
13        let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
14        let align = kwargs.align; // None = clear alignment, Some = set it
15        let (start_row, end_row) = span.rows_start_end(&self.grid);
16        let (start_col, end_col) = span.cols_start_end(&self.grid);
17
18        if let Err(e) = (|| -> Result<(), String> {
19            if kwargs.expand {
20                self.cr_ensure_widget_nrows(span.max_row(&self.grid), &mut event_data, true)?;
21                self.cr_ensure_widget_ncols(span.max_col(&self.grid), &mut event_data, true)?;
22            }
23            let empty_val = &self.opts.empty_val;
24
25            for row in start_row..=end_row {
26                for col in start_col..=end_col {
27                    Self::acr_event_data_set_talign(
28                        &mut self.grid.index.cells,
29                        row,
30                        col,
31                        align,
32                        empty_val,
33                        &mut event_data,
34                    )?;
35                }
36            }
37            Ok(())
38        })() {
39            self.cr_roll_back(Rc::new(RefCell::new(event_data)));
40            return Err(e);
41        }
42
43        self.cr_finalize_event_if_any_non_selection_change(
44            event_data,
45            kwargs.undo,
46            kwargs.emit,
47            true,
48        )
49    }
50
51    pub fn align_i(
52        &mut self,
53        kwargs: Option<CellAlignArgs>,
54    ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
55        let kwargs: CellAlignArgs = kwargs.unwrap_or_default();
56        let span = self.cr_key_to_span(kwargs.key)?;
57        let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
58        if kwargs.expand {
59            self.cr_ensure_widget_nrows(span.max_row(&self.grid), &mut event_data, true)?;
60        }
61        let align = kwargs.align;
62        let (start_row, end_row) = span.rows_start_end(&self.grid);
63        let mut error: Option<String> = None;
64
65        for row in start_row..=end_row {
66            match Self::acr_event_data_set_ialign(
67                &mut self.grid.index.cells,
68                row,
69                align,
70                &mut event_data,
71            ) {
72                Err(e) => {
73                    error = Some(e);
74                    break;
75                }
76                _ => {}
77            }
78        }
79        if let Some(e) = error {
80            self.cr_roll_back(Rc::new(RefCell::new(event_data)));
81            return Err(e);
82        } else {
83            self.cr_finalize_event_if_any_non_selection_change(
84                event_data,
85                kwargs.undo,
86                kwargs.emit,
87                true,
88            )
89        }
90    }
91
92    pub fn align_h(
93        &mut self,
94        kwargs: Option<CellAlignArgs>,
95    ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
96        let kwargs: CellAlignArgs = kwargs.unwrap_or_default();
97        let span = self.cr_key_to_span(kwargs.key)?;
98        let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
99        if kwargs.expand {
100            self.cr_ensure_widget_ncols(span.max_col(&self.grid), &mut event_data, true)?;
101        }
102        let align = kwargs.align;
103        let (start_col, end_col) = span.cols_start_end(&self.grid);
104        let mut error: Option<String> = None;
105
106        for col in start_col..=end_col {
107            match Self::acr_event_data_set_halign(
108                &mut self.grid.header.cells,
109                col,
110                align,
111                &mut event_data,
112            ) {
113                Err(e) => {
114                    error = Some(e);
115                    break;
116                }
117                _ => {}
118            }
119        }
120        if let Some(e) = error {
121            self.cr_roll_back(Rc::new(RefCell::new(event_data)));
122            return Err(e);
123        } else {
124            self.cr_finalize_event_if_any_non_selection_change(
125                event_data,
126                kwargs.undo,
127                kwargs.emit,
128                true,
129            )
130        }
131    }
132}