1use crate::Color3;
2use crate::EventData;
3use crate::Note;
4use crate::NoteArgs;
5use crate::SetNoteArgs;
6use crate::Table;
7use crate::try_hex_to_color3;
8use alloc::rc::Rc;
9use alloc::string::String;
10use core::cell::RefCell;
11
12impl Table {
13 pub fn note(
14 &mut self,
15 kwargs: Option<NoteArgs>,
16 ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
17 let kwargs: NoteArgs = kwargs.unwrap_or_default();
18 let span = self.cr_key_to_span(kwargs.key)?;
19 let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
20 let note = if let Some(note_text) = kwargs.note {
21 Some(Note {
22 note: note_text,
23 bg: try_hex_to_color3(kwargs.bg)?,
24 fg: try_hex_to_color3(kwargs.fg)?,
25 readonly: kwargs.readonly,
26 })
27 } else {
28 None
29 };
30 let (start_row, end_row) = span.rows_start_end(&self.grid);
31 let (start_col, end_col) = span.cols_start_end(&self.grid);
32
33 if let Err(e) = (|| -> Result<(), String> {
34 if kwargs.expand {
35 self.cr_ensure_widget_nrows(span.max_row(&self.grid), &mut event_data, true)?;
36 self.cr_ensure_widget_ncols(span.max_col(&self.grid), &mut event_data, true)?;
37 }
38 let empty_val = &self.opts.empty_val;
39
40 for row in start_row..=end_row {
41 for col in start_col..=end_col {
42 Self::acr_event_data_set_tnote(
43 &mut self.grid.index.cells,
44 row,
45 col,
46 note.clone(),
47 empty_val,
48 &mut event_data,
49 )?;
50 }
51 }
52 Ok(())
53 })() {
54 self.cr_roll_back(Rc::new(RefCell::new(event_data)));
55 return Err(e);
56 }
57
58 self.cr_finalize_event_if_any_non_selection_change(
59 event_data,
60 kwargs.undo,
61 kwargs.emit,
62 true,
63 )
64 }
65
66 pub fn note_i(
67 &mut self,
68 kwargs: Option<NoteArgs>,
69 ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
70 let kwargs: NoteArgs = kwargs.unwrap_or_default();
71 let span = self.cr_key_to_span(kwargs.key)?;
72 let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
73 if kwargs.expand {
74 self.cr_ensure_widget_nrows(span.max_row(&self.grid), &mut event_data, true)?;
75 }
76 let note = if let Some(note_text) = kwargs.note {
77 Some(Note {
78 note: note_text,
79 bg: try_hex_to_color3(kwargs.bg)?,
80 fg: try_hex_to_color3(kwargs.fg)?,
81 readonly: kwargs.readonly,
82 })
83 } else {
84 None
85 };
86 let (start_row, end_row) = span.rows_start_end(&self.grid);
87 let mut error: Option<String> = None;
88
89 for row in start_row..=end_row {
90 if let Err(e) = Self::acr_event_data_set_inote(
91 &mut self.grid.index.cells,
92 row,
93 note.clone(),
94 &mut event_data,
95 ) {
96 error = Some(e);
97 break;
98 }
99 }
100
101 if let Some(e) = error {
102 self.cr_roll_back(Rc::new(RefCell::new(event_data)));
103 return Err(e);
104 } else {
105 self.cr_finalize_event_if_any_non_selection_change(
106 event_data,
107 kwargs.undo,
108 kwargs.emit,
109 true,
110 )
111 }
112 }
113
114 pub fn note_h(
115 &mut self,
116 kwargs: Option<NoteArgs>,
117 ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
118 let kwargs: NoteArgs = kwargs.unwrap_or_default();
119 let span = self.cr_key_to_span(kwargs.key)?;
120 let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
121 if kwargs.expand {
122 self.cr_ensure_widget_ncols(span.max_col(&self.grid), &mut event_data, true)?;
123 }
124 let note = if let Some(note_text) = kwargs.note {
125 Some(Note {
126 note: note_text,
127 bg: try_hex_to_color3(kwargs.bg)?,
128 fg: try_hex_to_color3(kwargs.fg)?,
129 readonly: kwargs.readonly,
130 })
131 } else {
132 None
133 };
134 let (start_col, end_col) = span.cols_start_end(&self.grid);
135 let mut error: Option<String> = None;
136
137 for col in start_col..=end_col {
138 if let Err(e) = Self::acr_event_data_set_hnote(
139 &mut self.grid.header.cells,
140 col,
141 note.clone(),
142 &mut event_data,
143 ) {
144 error = Some(e);
145 break;
146 }
147 }
148
149 if let Some(e) = error {
150 self.cr_roll_back(Rc::new(RefCell::new(event_data)));
151 return Err(e);
152 } else {
153 self.cr_finalize_event_if_any_non_selection_change(
154 event_data,
155 kwargs.undo,
156 kwargs.emit,
157 true,
158 )
159 }
160 }
161
162 pub fn set_note(
163 &mut self,
164 kwargs: Option<SetNoteArgs>,
165 ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
166 let kwargs: SetNoteArgs = kwargs.unwrap_or_default();
167 let span = self.cr_key_to_span(kwargs.key)?;
168 let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
169
170 let bg_color: Option<Option<Color3>> = kwargs.bg.map(try_hex_to_color3).transpose()?;
171 let fg_color: Option<Option<Color3>> = kwargs.fg.map(try_hex_to_color3).transpose()?;
172
173 let (start_row, end_row) = span.rows_start_end(&self.grid);
174 let (start_col, end_col) = span.cols_start_end(&self.grid);
175 let empty_val = &self.opts.empty_val;
176
177 if let Err(e) = (|| -> Result<(), String> {
178 for row in start_row..=end_row {
179 for col in start_col..=end_col {
180 if let Some(text) = &kwargs.note {
181 Self::acr_event_data_set_tnote_text(
182 &mut self.grid.index.cells,
183 row,
184 col,
185 text.clone(),
186 empty_val,
187 &mut event_data,
188 )?;
189 }
190 if let Some(color) = &bg_color {
191 Self::acr_event_data_set_tnote_bg(
192 &mut self.grid.index.cells,
193 row,
194 col,
195 color.clone(),
196 empty_val,
197 &mut event_data,
198 )?;
199 }
200 if let Some(color) = &fg_color {
201 Self::acr_event_data_set_tnote_fg(
202 &mut self.grid.index.cells,
203 row,
204 col,
205 color.clone(),
206 empty_val,
207 &mut event_data,
208 )?;
209 }
210 if let Some(readonly) = kwargs.readonly {
211 Self::acr_event_data_set_tnote_readonly(
212 &mut self.grid.index.cells,
213 row,
214 col,
215 readonly,
216 empty_val,
217 &mut event_data,
218 )?;
219 }
220 }
221 }
222 Ok(())
223 })() {
224 self.cr_roll_back(Rc::new(RefCell::new(event_data)));
225 return Err(e);
226 }
227
228 self.cr_finalize_event_if_any_non_selection_change(
229 event_data,
230 kwargs.undo,
231 kwargs.emit,
232 true,
233 )
234 }
235
236 pub fn set_note_i(
237 &mut self,
238 kwargs: Option<SetNoteArgs>,
239 ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
240 let kwargs: SetNoteArgs = kwargs.unwrap_or_default();
241 let span = self.cr_key_to_span(kwargs.key)?;
242 let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
243
244 let bg_color: Option<Option<Color3>> = kwargs.bg.map(try_hex_to_color3).transpose()?;
245 let fg_color: Option<Option<Color3>> = kwargs.fg.map(try_hex_to_color3).transpose()?;
246
247 let (start_row, end_row) = span.rows_start_end(&self.grid);
248
249 if let Err(e) = (|| -> Result<(), String> {
250 for row in start_row..=end_row {
251 if let Some(text) = &kwargs.note {
252 Self::acr_event_data_set_inote_text(
253 &mut self.grid.index.cells,
254 row,
255 text.clone(),
256 &mut event_data,
257 )?;
258 }
259 if let Some(color) = &bg_color {
260 Self::acr_event_data_set_inote_bg(
261 &mut self.grid.index.cells,
262 row,
263 color.clone(),
264 &mut event_data,
265 )?;
266 }
267 if let Some(color) = &fg_color {
268 Self::acr_event_data_set_inote_fg(
269 &mut self.grid.index.cells,
270 row,
271 color.clone(),
272 &mut event_data,
273 )?;
274 }
275 if let Some(readonly) = kwargs.readonly {
276 Self::acr_event_data_set_inote_readonly(
277 &mut self.grid.index.cells,
278 row,
279 readonly,
280 &mut event_data,
281 )?;
282 }
283 }
284 Ok(())
285 })() {
286 self.cr_roll_back(Rc::new(RefCell::new(event_data)));
287 return Err(e);
288 }
289 self.cr_finalize_event_if_any_non_selection_change(
290 event_data,
291 kwargs.undo,
292 kwargs.emit,
293 true,
294 )
295 }
296
297 pub fn set_note_h(
298 &mut self,
299 kwargs: Option<SetNoteArgs>,
300 ) -> Result<Option<Rc<RefCell<EventData>>>, String> {
301 let kwargs: SetNoteArgs = kwargs.unwrap_or_default();
302 let span = self.cr_key_to_span(kwargs.key)?;
303 let mut event_data: EventData = self.cr_new_event(kwargs.save_selection);
304
305 let bg_color: Option<Option<Color3>> = kwargs.bg.map(try_hex_to_color3).transpose()?;
306 let fg_color: Option<Option<Color3>> = kwargs.fg.map(try_hex_to_color3).transpose()?;
307
308 let (start_col, end_col) = span.cols_start_end(&self.grid);
309
310 if let Err(e) = (|| -> Result<(), String> {
311 for col in start_col..=end_col {
312 if let Some(text) = &kwargs.note {
313 Self::acr_event_data_set_hnote_text(
314 &mut self.grid.header.cells,
315 col,
316 text.clone(),
317 &mut event_data,
318 )?;
319 }
320 if let Some(color) = &bg_color {
321 Self::acr_event_data_set_hnote_bg(
322 &mut self.grid.header.cells,
323 col,
324 color.clone(),
325 &mut event_data,
326 )?;
327 }
328 if let Some(color) = &fg_color {
329 Self::acr_event_data_set_hnote_fg(
330 &mut self.grid.header.cells,
331 col,
332 color.clone(),
333 &mut event_data,
334 )?;
335 }
336 if let Some(readonly) = kwargs.readonly {
337 Self::acr_event_data_set_hnote_readonly(
338 &mut self.grid.header.cells,
339 col,
340 readonly,
341 &mut event_data,
342 )?;
343 }
344 }
345 Ok(())
346 })() {
347 self.cr_roll_back(Rc::new(RefCell::new(event_data)));
348 return Err(e);
349 }
350 self.cr_finalize_event_if_any_non_selection_change(
351 event_data,
352 kwargs.undo,
353 kwargs.emit,
354 true,
355 )
356 }
357}