tvision_rs/widgets/table/
edit.rs1use super::body::{TEXT_X, row_layout};
22use super::layout::RowLayout;
23use super::model::RowKey;
24use super::{Table, TableData};
25use crate::command::Command;
26use crate::data::FieldValue;
27use crate::dialog::{MessageBoxButtons, MessageBoxKind};
28use crate::event::{Event, Key, KeyEvent};
29use crate::view::{Context, Point, Rect, SelectMode, View, ViewId};
30use crate::widgets::input_line::{InputLine, LimitMode};
31use crate::widgets::list_viewer;
32
33const EDIT_LIMIT: i32 = 4096;
36
37pub(super) struct CellEdit {
39 pub(super) editor: ViewId,
41 pub(super) key: RowKey,
43 pub(super) col: usize,
45 box_open: bool,
49 dropped: bool,
52}
53
54impl TableData {
55 pub(super) fn editable_cols(&self) -> Vec<usize> {
58 self.col_order
59 .iter()
60 .copied()
61 .filter(|&c| self.columns[c].editable && !self.columns[c].hidden)
62 .collect()
63 }
64
65 pub(super) fn cursor_col(&self) -> Option<usize> {
69 let cols = self.editable_cols();
70 self.cursor
71 .filter(|c| cols.contains(c))
72 .or_else(|| cols.first().copied())
73 }
74
75 pub(super) fn col_span(&self, l: &RowLayout, col: usize) -> Option<(i32, i32)> {
78 let lc = self.display_pos(col)? + l.frozen;
79 l.spans()
80 .into_iter()
81 .find(|&(i, _, _)| i == lc)
82 .map(|(_, s, e)| (s, e))
83 }
84
85 pub(super) fn reveal_col(&mut self, size_x: i32, col: usize) -> bool {
89 let l = row_layout(self, size_x);
90 let Some((s, e)) = self.col_span(&l, col) else {
91 return false;
92 };
93 let old = l.clamp(self.h_offset);
94 let off = if s < old {
95 s
96 } else if e > old.saturating_add(l.view) {
97 (e - l.view).min(s)
98 } else {
99 old
100 };
101 self.h_offset = l.clamp(off);
102 self.h_offset != old
103 }
104}
105
106pub(super) fn cell_x(d: &TableData, l: &RowLayout, size_x: i32, col: usize) -> Option<(i32, i32)> {
110 let (s, e) = d.col_span(l, col)?;
111 let lo = TEXT_X + l.frozen_width;
112 let x0 = (TEXT_X + l.text_x(s, d.h_offset)).max(lo);
113 let x1 = (TEXT_X + l.text_x(e, d.h_offset)).min(size_x);
114 (x0 < x1).then_some((x0, x1))
115}
116
117fn editor_rect(d: &TableData, size: Point, top_item: i32, disp: usize, col: usize) -> Option<Rect> {
123 let y = 1 + disp as i32 - top_item;
124 if y < 1 || y >= size.y {
125 return None;
126 }
127 let l = row_layout(d, size.x);
128 let (x0, x1) = cell_x(d, &l, size.x, col)?;
129 let lo = TEXT_X + l.frozen_width - 1;
130 Some(Rect::new((x0 - 1).max(lo), y, (x1 + 1).min(size.x), y + 1))
131}
132
133impl Table {
134 pub fn is_editing(&self) -> bool {
136 self.edit.is_some()
137 }
138
139 pub fn cursor_column(&self) -> Option<usize> {
142 self.data.borrow().cursor_col()
143 }
144
145 pub(super) fn editor_mut(&mut self) -> Option<&mut InputLine> {
147 let id = self.edit.as_ref()?.editor;
148 self.group
149 .child_mut(id)
150 .and_then(|v| v.as_any_mut())
151 .and_then(|a| a.downcast_mut::<InputLine>())
152 }
153
154 pub(super) fn place_editor(&mut self, reveal: bool) -> bool {
159 let Some(e) = &self.edit else {
160 return false;
161 };
162 let (editor, key, col) = (e.editor, e.key.clone(), e.col);
163 let size = self.group.state().size;
164 let disp = if e.dropped {
165 None
166 } else {
167 self.data.borrow().display_of(&key)
168 };
169 if let Some(disp) = disp
170 && reveal
171 {
172 self.data.borrow_mut().reveal_col(size.x, col);
173 let lv = self.body_mut().lv_state();
174 let (row, rows) = (disp as i32, lv.state.size.y);
175 if row < lv.top_item {
176 lv.top_item = row;
177 } else if rows > 0 && row >= lv.top_item + rows {
178 lv.top_item = row - rows + 1;
179 }
180 }
181 let top = self.body_mut().lv_state().top_item;
182 let rect = disp.and_then(|disp| editor_rect(&self.data.borrow(), size, top, disp, col));
183 if let Some(v) = self.group.child_mut(editor) {
184 if let Some(r) = rect {
185 v.change_bounds(r);
186 }
187 v.state_mut().state.visible = rect.is_some();
188 }
189 rect.is_some()
190 }
191
192 fn start_edit(&mut self, col: usize, ctx: &mut Context) -> bool {
196 let Some(key) = self.focused_key() else {
197 return false;
198 };
199 let (text, factory) = {
200 let mut d = self.data.borrow_mut();
201 d.cursor = Some(col);
202 let row = d.order[d.focused];
203 (
204 d.model.cell(row, col).into_owned(),
205 d.columns[col].validator.clone(),
206 )
207 };
208 let limit = EDIT_LIMIT.max(i32::try_from(text.len()).unwrap_or(i32::MAX - 1) + 1);
209 let editor = InputLine::new(
210 Rect::new(0, 0, 0, 0),
211 limit,
212 factory.map(|f| f.make()),
213 LimitMode::MaxBytes,
214 );
215 let id = self.group.insert(Box::new(editor));
216 self.edit = Some(CellEdit {
217 editor: id,
218 key,
219 col,
220 box_open: false,
221 dropped: false,
222 });
223 if !self.place_editor(true) {
224 self.close_editor(ctx);
225 return false;
226 }
227 if let Some(editor) = self.editor_mut() {
229 editor.set_value(FieldValue::Text(text));
230 }
231 self.publish_h(ctx);
232 self.group.set_current(Some(id), SelectMode::Normal, ctx);
233 true
234 }
235
236 fn close_editor(&mut self, ctx: &mut Context) {
238 if let Some(e) = self.edit.take() {
239 self.group.remove(e.editor, ctx);
240 }
241 }
242
243 pub fn cancel_edit(&mut self, ctx: &mut Context) {
245 self.close_editor(ctx);
246 }
247
248 pub(super) fn edit_alive(&self) -> bool {
251 let Some(e) = &self.edit else {
252 return false;
253 };
254 let d = self.data.borrow();
255 !e.dropped
256 && d.display_of(&e.key).is_some()
257 && d.columns
258 .get(e.col)
259 .is_some_and(|c| c.editable && !c.hidden)
260 }
261
262 pub(super) fn drop_edit_unless(&mut self, key: &RowKey) {
265 if let Some(e) = &mut self.edit
266 && e.key != *key
267 {
268 e.dropped = true;
269 }
270 }
271
272 pub(super) fn cancel_edit_unless(&mut self, key: &RowKey, ctx: &mut Context) {
275 if self.edit.as_ref().is_some_and(|e| e.key != *key) {
276 self.cancel_edit(ctx);
277 }
278 }
279
280 pub(super) fn end_dead_edit(&mut self, ctx: &mut Context) {
284 let dropped = self.edit.as_ref().is_some_and(|e| e.dropped);
285 self.cancel_edit(ctx);
286 self.eat_key = !dropped;
287 }
288
289 pub(super) fn close_dropped_edit(&mut self, ctx: &mut Context) {
293 if self.edit.as_ref().is_some_and(|e| e.dropped) {
294 self.end_dead_edit(ctx);
295 }
296 }
297
298 fn reveal_editor(&mut self, ctx: &mut Context) -> bool {
301 let Some(e) = &self.edit else {
302 return false;
303 };
304 let (key, col) = (e.key.clone(), e.col);
305 let size_x = self.group.state().size.x;
306 let disp = {
307 let mut d = self.data.borrow_mut();
308 d.reveal_col(size_x, col);
309 d.display_of(&key)
310 };
311 if let Some(disp) = disp {
312 list_viewer::focus_item_num(self.body_mut(), disp as i32, ctx);
315 }
316 self.publish_h(ctx);
317 self.place_editor(false)
318 }
319
320 pub(super) fn edit_valid(&mut self, cmd: Command, ctx: &mut Context) -> bool {
326 if self.edit.is_none() || cmd == Command::VALID || cmd == Command::RELEASED_FOCUS {
327 return true;
328 }
329 if !self.edit_alive() {
330 self.cancel_edit(ctx);
332 return true;
333 }
334 if cmd == Command::CANCEL {
335 self.cancel_edit(ctx);
336 return true;
337 }
338 let closed = self.commit_edit(ctx);
339 self.drain(ctx);
340 closed
341 }
342
343 pub(super) fn commit_edit(&mut self, ctx: &mut Context) -> bool {
350 let Some(e) = &self.edit else {
351 return false;
352 };
353 let (key, col) = (e.key.clone(), e.col);
354 let Some(editor) = self.editor_mut() else {
355 self.close_editor(ctx);
356 return true;
357 };
358 let boxes = ctx.message_boxes_requested();
359 if !editor.valid(Command::OK, ctx) {
360 if ctx.message_boxes_requested() > boxes {
363 self.box_opened();
364 }
365 return false;
366 }
367 let text = editor.data.clone();
368 let stored = {
369 let mut d = self.data.borrow_mut();
370 match d.display_of(&key).map(|disp| d.order[disp]) {
371 Some(row) if d.model.cell(row, col) != text => Some(
372 d.model
373 .set_cell(row, col, &text)
374 .map(|()| d.model.row_key(row)),
375 ),
376 _ => None,
378 }
379 };
380 match stored {
381 Some(Err(message)) => {
382 ctx.request_message_box(
383 message,
384 MessageBoxKind::Error,
385 MessageBoxButtons::ok(),
386 None,
387 None,
388 );
389 self.box_opened();
390 false
391 }
392 Some(Ok(new_key)) => {
393 self.close_editor(ctx);
394 let idx = {
397 let mut d = self.data.borrow_mut();
398 if new_key != key && d.selected.remove(&key) {
400 d.selected.insert(new_key.clone());
401 }
402 d.reorder();
403 d.prune_selection();
404 d.pending.push(Command::TABLE_CELL_EDITED);
405 d.display_of(&new_key).unwrap_or(d.focused)
406 };
407 list_viewer::focus_item_num(self.body_mut(), idx as i32, ctx);
408 true
409 }
410 None => {
411 self.close_editor(ctx);
412 true
413 }
414 }
415 }
416
417 fn box_opened(&mut self) {
419 if let Some(e) = &mut self.edit {
420 e.box_open = true;
421 }
422 }
423
424 pub(super) fn edit_focus(&mut self, focused: bool, ctx: &mut Context) {
427 match &mut self.edit {
428 Some(e) if focused => e.box_open = false,
429 Some(e) if !e.box_open => self.cancel_edit(ctx),
430 _ => {}
431 }
432 }
433
434 pub(super) fn edit_event(&mut self, ev: &Event, ctx: &mut Context) -> bool {
442 let is_key = matches!(ev, Event::KeyDown(_));
443 if (is_key || matches!(ev, Event::MouseDown(_)))
444 && let Some(e) = &mut self.edit
445 {
446 e.box_open = false;
447 }
448 if !self.edit_alive() {
449 self.end_dead_edit(ctx);
450 if is_key && self.eat_key {
452 self.eat_key = false;
453 return true;
454 }
455 return false;
456 }
457 if !self.place_editor(false) && is_key && !self.reveal_editor(ctx) {
458 self.cancel_edit(ctx);
460 return true;
461 }
462 match *ev {
463 Event::KeyDown(ke) if plain(ke) && ke.key == Key::Enter => {
464 self.commit_edit(ctx);
465 true
466 }
467 Event::KeyDown(ke) if plain(ke) && ke.key == Key::Esc => {
468 self.cancel_edit(ctx);
469 true
470 }
471 Event::KeyDown(ke) if !ke.modifiers.ctrl && !ke.modifiers.alt && ke.key == Key::Tab => {
472 let col = self.edit.as_ref().map(|e| e.col);
473 if !self.commit_edit(ctx) {
474 return true;
475 }
476 col.is_some_and(|col| self.edit_neighbour(col, !ke.modifiers.shift, ctx))
478 }
479 Event::MouseDown(me) => {
480 let editor = self.edit.as_ref().map(|e| e.editor);
481 let inside = editor
482 .and_then(|id| self.group.child_mut(id))
483 .is_some_and(|v| {
484 v.state().state.visible && v.state().get_bounds().contains(me.position)
486 });
487 if !inside {
488 self.cancel_edit(ctx);
489 }
490 false
491 }
492 _ => false,
493 }
494 }
495
496 fn edit_neighbour(&mut self, col: usize, forwards: bool, ctx: &mut Context) -> bool {
501 let next = {
502 let d = self.data.borrow();
503 let cols = d.editable_cols();
504 cols.iter().position(|&c| c == col).and_then(|i| {
505 if forwards {
506 cols.get(i + 1).copied()
507 } else {
508 i.checked_sub(1).map(|j| cols[j])
509 }
510 })
511 };
512 match next {
513 Some(next) => {
514 self.start_edit(next, ctx);
515 true
516 }
517 None => false,
518 }
519 }
520
521 pub(super) fn start_event(&mut self, ev: &Event, ctx: &mut Context) -> bool {
526 match *ev {
527 Event::KeyDown(ke) if plain(ke) && !ke.modifiers.shift && ke.key == Key::F(2) => {
528 match self.cursor_column() {
529 Some(col) => {
530 self.start_edit(col, ctx);
531 true
532 }
533 None => false,
534 }
535 }
536 Event::KeyDown(ke) if plain(ke) && !ke.modifiers.shift && ke.key == Key::Enter => {
537 let Some(col) = self.cursor_column() else {
538 return false;
539 };
540 if self.focused_key().is_none() {
541 return false;
542 }
543 self.start_edit(col, ctx);
546 true
547 }
548 Event::MouseDown(me)
549 if me.flags.double_click && me.buttons.left && me.position.y >= 1 =>
550 {
551 let Some((item, col)) = self.editable_cell_at(me.position) else {
552 return false;
553 };
554 list_viewer::focus_item_num(self.body_mut(), item, ctx);
555 self.start_edit(col, ctx)
556 }
557 _ => false,
558 }
559 }
560
561 fn editable_cell_at(&mut self, at: Point) -> Option<(i32, usize)> {
564 let size_x = self.group.state().size.x;
565 let lv = self.body_mut().lv_state();
566 let item = at.y - 1 + lv.top_item;
567 if item >= lv.range {
568 return None;
569 }
570 let d = self.data.borrow();
571 let l = row_layout(&d, size_x);
572 let col = l
573 .column_at(at.x - TEXT_X, d.h_offset)
574 .and_then(|lc| d.model_col(lc))?;
575 (d.columns[col].editable).then_some((item, col))
576 }
577}
578
579fn plain(ke: KeyEvent) -> bool {
581 !ke.modifiers.ctrl && !ke.modifiers.alt
582}