From c71d9ce9715889c188cc4f31608337e957fb8e94 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:52:51 +0100 Subject: [PATCH 1/5] feat(linux-grid): set a value in every selected row --- linux/changelog.d/4136.changed.md | 1 + .../app/src/ui/data_grid/edit/row_edits.rs | 75 +++++++++++++++---- .../app/src/ui/data_grid/edit/tests/rows.rs | 15 +++- 3 files changed, 74 insertions(+), 17 deletions(-) create mode 100644 linux/changelog.d/4136.changed.md diff --git a/linux/changelog.d/4136.changed.md b/linux/changelog.d/4136.changed.md new file mode 100644 index 0000000000..1b7ccc0611 --- /dev/null +++ b/linux/changelog.d/4136.changed.md @@ -0,0 +1 @@ +Set to Empty, NULL or DEFAULT now changes the focused column in every selected row. diff --git a/linux/crates/app/src/ui/data_grid/edit/row_edits.rs b/linux/crates/app/src/ui/data_grid/edit/row_edits.rs index 6dd144e27d..57740d3912 100644 --- a/linux/crates/app/src/ui/data_grid/edit/row_edits.rs +++ b/linux/crates/app/src/ui/data_grid/edit/row_edits.rs @@ -5,7 +5,7 @@ use tablepro_core::column::{BoolStorage, ColumnKind}; use tablepro_core::edit::{CellInput, EditParseError, new_draft_cell, parse_edit_text}; use super::{EditController, edit_start}; -use crate::i18n::gettext; +use crate::i18n::{gettext, ngettext_f}; use crate::services::change_tracker::RowKey; use crate::services::grid::{ CellPreset, CommitResult, EditStart, GridColumn, cell_presets, commit_input, edit_context, @@ -38,18 +38,68 @@ impl EditController { } } - /// Set to Empty, NULL or DEFAULT on the cell an action names. The - /// menu offers only what the cell takes; a column that refuses the - /// value says why, as committing an empty cell would. + /// Set to Empty, NULL or DEFAULT on the focused cell's column, in + /// every selected row as macOS does. The menu offers only what the + /// focused cell takes; a row that refuses the value is left out, and a + /// column that refuses it everywhere says why, as committing an empty + /// cell would. pub(super) fn set_preset(&self, grid: &DataGrid, preset: CellPreset) { - let Some((row, column)) = grid.target().and_then(|target| target.cell) else { + let Some(target) = grid.target() else { return; }; - let Some(grid_column) = self.unlocked_column(grid, &row, column) else { + let Some((focused, column)) = target.cell.clone() else { return; }; - let Some(catalog) = grid_column.catalog.as_ref() else { + let rows = if target.rows.len() > 1 && target.rows.iter().any(|row| row.id() == focused.id()) { + target.rows.clone() + } else { + vec![focused] + }; + let mut writes = Vec::new(); + let mut refusal = None; + for row in &rows { + match self.preset_input(grid, row, column, preset) { + Ok(Some((grid_column, input))) => writes.push((row.clone(), grid_column, input)), + Ok(None) => {} + Err(message) => refusal = refusal.or(Some(message)), + } + } + if writes.is_empty() { + if let Some(message) = refusal { + grid.toast(message); + } return; + } + grid.commit_editors(); + let skipped = rows.len() - writes.len(); + for (row, grid_column, input) in writes { + let start = edit_start(&self.tracked(), &row, column); + self.commit_input(grid, &grid_column, &start, input); + } + if skipped > 0 { + grid.toast(ngettext_f( + "{count} row can't take this value and was left as it was", + "{count} rows can't take this value and were left as they were", + skipped as u32, + &[("count", &skipped.to_string())], + )); + } + } + + /// What `preset` writes into one row's cell. `Ok(None)` for a cell + /// that is locked, `Err` for one whose column refuses the value. + fn preset_input( + &self, + grid: &DataGrid, + row: &GridRow, + column: usize, + preset: CellPreset, + ) -> Result, String> { + let Some(grid_column) = self.unlocked_column(grid, row, column) else { + return Ok(None); + }; + let Some(catalog) = grid_column.catalog.as_ref() else { + return Ok(None); }; let presets = cell_presets(&grid_column, &row.id(), grid.sql_dialect().as_deref()); let input = match preset { @@ -60,15 +110,8 @@ impl EditController { CellPreset::Null => Err(edit_parse_message(&EditParseError::Required)), CellPreset::Default if presets.default => Ok(CellInput::Default), CellPreset::Default => Err(gettext("This cell can't take the column's default")), - }; - match input { - Ok(input) => { - grid.commit_editors(); - let start = edit_start(&self.tracked(), &row, column); - self.commit_input(grid, &grid_column, &start, input); - } - Err(message) => grid.toast(message), - } + }?; + Ok(Some((grid_column, input))) } /// Only a table whose rows can be saved takes a new one (D1). diff --git a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs index eb57aefbbf..3d1a8e2662 100644 --- a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs +++ b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs @@ -6,7 +6,7 @@ use libadwaita::prelude::*; use tablepro_core::Value; use tablepro_core::edit::CellInput; -use super::{editing, none, press, two_text_rows}; +use super::{editing, none, pending, press, two_text_rows}; use crate::services::change_tracker::RowState; use crate::services::grid::edit_policy; use crate::test_support::{drain_main_context, respond, wait_until}; @@ -269,3 +269,16 @@ fn discard_drops_every_pending_change() { assert_eq!(grid.tracker.pending_count(), 0); assert!(super::editing_cell(&grid).is_none(), "the editor outlived the discard"); } + +#[gtk4::test] +fn set_to_null_reaches_every_selected_row_in_the_focused_column() { + let grid = two_text_rows(); + select_all_from(&grid, 0, 1); + + grid.grid.activate_action("grid.set-null", None).expect("Set to NULL"); + drain_main_context(); + + assert_eq!(pending(&grid, 1, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(pending(&grid, 2, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(pending(&grid, 1, 0), None, "another column stayed"); +} From 777e0e96b1ca666c2c62f2cbdfa9bb0412b58b08 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 23:53:17 +0700 Subject: [PATCH 2/5] fix(linux-grid): group selected row presets into one undo step --- linux/changelog.d/4136.changed.md | 2 +- .../crates/app/src/services/change_tracker.rs | 531 +++++++++++++----- .../app/src/services/tab_tracker_handle.rs | 5 + linux/crates/app/src/services/undo_op.rs | 10 + linux/crates/app/src/ui/data_grid/edit/mod.rs | 9 +- .../app/src/ui/data_grid/edit/row_edits.rs | 60 +- .../app/src/ui/data_grid/edit/tests/rows.rs | 201 +++++++ 7 files changed, 657 insertions(+), 161 deletions(-) diff --git a/linux/changelog.d/4136.changed.md b/linux/changelog.d/4136.changed.md index 1b7ccc0611..3df7a6bb21 100644 --- a/linux/changelog.d/4136.changed.md +++ b/linux/changelog.d/4136.changed.md @@ -1 +1 @@ -Set to Empty, NULL or DEFAULT now changes the focused column in every selected row. +Set to Empty, NULL or DEFAULT changes every selected row in one undo step. diff --git a/linux/crates/app/src/services/change_tracker.rs b/linux/crates/app/src/services/change_tracker.rs index b4d01d5c07..acf78ec9d8 100644 --- a/linux/crates/app/src/services/change_tracker.rs +++ b/linux/crates/app/src/services/change_tracker.rs @@ -163,21 +163,39 @@ impl TabChangeTracker { self.drafts.len() + self.deletes.len() + self.updates.len() + self.set_aside.len() } - /// An edit the running save holds back comes back as a redraw of its - /// row, so the grid stops showing what was typed into it. pub fn apply(&mut self, edit: TrackerEdit) -> TrackerDelta { - let delta = match edit { - TrackerEdit::DeleteRows { persisted, drafts } => self.delete_rows(persisted, drafts), - edit if self.edit_is_in_flight(&edit) => self.delta(edit.row_keys()), - TrackerEdit::Cell { - row_key, - col, - original, - value, - } => self.track_cell_edit(row_key, col, original, value), - TrackerEdit::DraftCell { draft_id, col, input } => self.track_draft_cell_edit(draft_id, col, input), - TrackerEdit::InsertDrafts { rows } => self.track_insert(rows), - }; + self.apply_all(vec![edit]) + } + + pub fn apply_all(&mut self, edits: Vec) -> TrackerDelta { + let mut steps = Vec::new(); + let mut delta = TrackerDelta::default(); + for edit in edits { + let next = match edit { + TrackerEdit::DeleteRows { persisted, drafts } => self.delete_rows(persisted, drafts, &mut steps), + edit if self.edit_is_in_flight(&edit) => self.delta(edit.row_keys()), + TrackerEdit::Cell { + row_key, + col, + original, + value, + } => self.track_cell_edit(row_key, col, original, value, &mut steps), + TrackerEdit::DraftCell { draft_id, col, input } => { + self.track_draft_cell_edit(draft_id, col, input, &mut steps) + } + TrackerEdit::InsertDrafts { rows } => self.track_insert(rows, &mut steps), + }; + delta.changed.extend(next.changed); + delta.inserted_drafts.extend(next.inserted_drafts); + delta.removed_drafts.extend(next.removed_drafts); + } + if !steps.is_empty() { + // The history limit counts user commands, not the cells they change. + self.push_undo(UndoOp::Group { steps }); + } + delta.inserted_drafts.retain(|id| self.drafts.contains_key(id)); + dedup(&mut delta.changed); + delta.pending_count = self.pending_count(); self.unmark_changed_error_row(&delta); delta } @@ -246,7 +264,14 @@ impl TabChangeTracker { self.redo.clear(); } - fn track_cell_edit(&mut self, row_key: RowKey, col: usize, original: Value, value: CellInput) -> TrackerDelta { + fn track_cell_edit( + &mut self, + row_key: RowKey, + col: usize, + original: Value, + value: CellInput, + steps: &mut Vec, + ) -> TrackerDelta { let key = (row_key.clone(), col); let before = self.updates.get(&key).cloned(); let in_flight = self.is_being_written(&key); @@ -260,7 +285,7 @@ impl TabChangeTracker { touched: self.touch(), ..edit }); - self.push_undo(UndoOp::CellEdit { + steps.push(UndoOp::CellEdit { row_key: row_key.clone(), col, before, @@ -269,7 +294,7 @@ impl TabChangeTracker { self.put_cell_edit(&row_key, col, after) } - fn track_insert(&mut self, rows: Vec>) -> TrackerDelta { + fn track_insert(&mut self, rows: Vec>, steps: &mut Vec) -> TrackerDelta { if rows.is_empty() { return self.delta(Vec::new()); } @@ -289,19 +314,25 @@ impl TabChangeTracker { // rows go in last first to read down in their own order. Their // touches keep that order for the save. drafts.reverse(); - self.push_undo(UndoOp::Insert { drafts: drafts.clone() }); + steps.push(UndoOp::Insert { drafts: drafts.clone() }); self.put_drafts(drafts) } /// Marks the saved rows and drops the drafts. The marks are one undo /// step; a row the running save is deleting already is held back and /// only drawn again. - fn delete_rows(&mut self, persisted: Vec<(RowKey, Arc<[Value]>)>, drafts: Vec) -> TrackerDelta { + fn delete_rows( + &mut self, + persisted: Vec<(RowKey, Arc<[Value]>)>, + drafts: Vec, + undo: &mut Vec, + ) -> TrackerDelta { let mut changed = Vec::new(); let mut removed_drafts = Vec::new(); for draft_id in drafts { if !self.draft_in_flight(draft_id) && self.drop_draft(draft_id) { removed_drafts.push(draft_id); + undo.retain_mut(|op| op.forget_draft(draft_id)); } changed.push(RowKey::Draft(draft_id)); } @@ -319,7 +350,7 @@ impl TabChangeTracker { steps.push(DeleteStep { row_key, before, after }); } if !steps.is_empty() { - self.push_undo(UndoOp::Delete { steps }); + undo.push(UndoOp::Delete { steps }); } dedup(&mut changed); TrackerDelta { @@ -343,12 +374,18 @@ impl TabChangeTracker { true } - fn track_draft_cell_edit(&mut self, draft_id: u64, col: usize, input: CellInput) -> TrackerDelta { + fn track_draft_cell_edit( + &mut self, + draft_id: u64, + col: usize, + input: CellInput, + steps: &mut Vec, + ) -> TrackerDelta { let Some((before, before_touch)) = self.draft_cell(draft_id, col) else { return self.delta(Vec::new()); }; let after_touch = self.touch(); - self.push_undo(UndoOp::DraftCell { + steps.push(UndoOp::DraftCell { draft_id, col, before, @@ -439,7 +476,26 @@ impl TabChangeTracker { return None; } let op = self.undo.pop_back()?; - let delta = match &op { + let delta = self.undo_op(&op); + self.unmark_changed_error_row(&delta); + self.redo.push_back(op); + Some(delta) + } + + fn undo_op(&mut self, op: &UndoOp) -> TrackerDelta { + match op { + UndoOp::Group { steps } => { + let mut changed = TrackerDelta::default(); + for step in steps.iter().rev() { + let next = self.undo_op(step); + changed.changed.extend(next.changed); + changed.inserted_drafts.extend(next.inserted_drafts); + changed.removed_drafts.extend(next.removed_drafts); + } + changed.pending_count = self.pending_count(); + dedup(&mut changed.changed); + changed + } UndoOp::CellEdit { row_key, col, before, .. } => self.put_cell_edit(row_key, *col, before.clone()), @@ -452,10 +508,7 @@ impl TabChangeTracker { } => self.put_draft_cell(*draft_id, *col, before.clone(), *before_touch), UndoOp::Insert { drafts } => self.remove_drafts(drafts), UndoOp::Delete { steps } => self.put_delete_marks(steps, true), - }; - self.unmark_changed_error_row(&delta); - self.redo.push_back(op); - Some(delta) + } } pub fn redo(&mut self) -> Option { @@ -463,7 +516,26 @@ impl TabChangeTracker { return None; } let op = self.redo.pop_back()?; - let delta = match &op { + let delta = self.redo_op(&op); + self.unmark_changed_error_row(&delta); + self.undo.push_back(op); + Some(delta) + } + + fn redo_op(&mut self, op: &UndoOp) -> TrackerDelta { + match op { + UndoOp::Group { steps } => { + let mut changed = TrackerDelta::default(); + for step in steps { + let next = self.redo_op(step); + changed.changed.extend(next.changed); + changed.inserted_drafts.extend(next.inserted_drafts); + changed.removed_drafts.extend(next.removed_drafts); + } + changed.pending_count = self.pending_count(); + dedup(&mut changed.changed); + changed + } UndoOp::CellEdit { row_key, col, after, .. } => self.put_cell_edit(row_key, *col, after.clone()), @@ -476,10 +548,7 @@ impl TabChangeTracker { } => self.put_draft_cell(*draft_id, *col, after.clone(), *after_touch), UndoOp::Insert { drafts } => self.put_drafts(drafts.clone()), UndoOp::Delete { steps } => self.put_delete_marks(steps, false), - }; - self.unmark_changed_error_row(&delta); - self.undo.push_back(op); - Some(delta) + } } pub fn can_undo(&self) -> bool { @@ -1109,7 +1178,9 @@ mod tests { fn insert(t: &mut TabChangeTracker, values: Vec) -> u64 { match t - .track_insert(vec![values.into_iter().map(CellInput::Value).collect()]) + .apply(TrackerEdit::InsertDrafts { + rows: vec![values.into_iter().map(CellInput::Value).collect()], + }) .inserted_drafts .as_slice() { @@ -1136,12 +1207,12 @@ mod tests { fn cell_edit_creates_modified_state() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); assert_eq!(t.cell_state(&key, 1), CellState::Modified); assert_eq!(t.row_state(&key), RowState::Modified); assert_eq!(t.pending_count(), 1); @@ -1151,19 +1222,19 @@ mod tests { fn cell_edit_back_to_original_drops_modification() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); // User edits again, this time back to "a" - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("a".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("a".into())), + }); assert_eq!(t.cell_state(&key, 1), CellState::Clean); // pending_count drops; undo stack still has 2 ops assert_eq!(t.pending_count(), 0); @@ -1184,12 +1255,12 @@ mod tests { fn cell_marks_tint_a_cell_by_its_own_edit_and_its_rows_delete() { let mut t = TabChangeTracker::default(); let (edited, deleted) = (rk(&[Value::Int(1)]), rk(&[Value::Int(2)])); - t.track_cell_edit( - edited.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: edited.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); delete(&mut t, deleted.clone(), vec![Value::Int(2), Value::Text("c".into())]); let draft = RowKey::Draft(insert(&mut t, vec![Value::Null, Value::Null])); @@ -1216,12 +1287,12 @@ mod tests { fn undo_reverts_cell_edit() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); let undone = t.undo(); assert_eq!(undone.map(|delta| delta.changed), Some(vec![key.clone()])); assert_eq!(t.cell_state(&key, 1), CellState::Clean); @@ -1232,12 +1303,12 @@ mod tests { fn redo_reapplies_cell_edit() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); t.undo(); t.redo(); assert_eq!(t.cell_state(&key, 1), CellState::Modified); @@ -1248,7 +1319,12 @@ mod tests { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); for i in 0..100 { - t.track_cell_edit(key.clone(), 1, Value::Int(i), CellInput::Value(Value::Int(i + 1))); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Int(i), + value: CellInput::Value(Value::Int(i + 1)), + }); } assert_eq!(t.undo.len(), UNDO_LIMIT); } @@ -1257,13 +1333,15 @@ mod tests { fn clear_removes_all_state() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); - t.track_insert(vec![vec![CellInput::Value(Value::Null)]]); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); + t.apply(TrackerEdit::InsertDrafts { + rows: vec![vec![CellInput::Value(Value::Null)]], + }); delete(&mut t, rk(&[Value::Int(2)]), vec![Value::Int(2)]); t.discard(); assert_eq!(t.pending_count(), 0); @@ -1288,7 +1366,12 @@ mod tests { } fn edit(t: &mut TabChangeTracker, id: i64, from: &str, to: &str) { - t.track_cell_edit(rk(&[Value::Int(id)]), 1, text(from), CellInput::Value(text(to))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(id)]), + col: 1, + original: text(from), + value: CellInput::Value(text(to)), + }); } /// The cell as the grid draws it, over a fetched "a". @@ -1532,13 +1615,17 @@ mod tests { for id in (0..40).rev() { match id % 3 { 0 => delete(t, rk(&[Value::Int(id)]), vec![Value::Int(id)]), - _ => t.track_cell_edit(rk(&[Value::Int(id)]), 1, text("a"), CellInput::Value(text("b"))), + _ => t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(id)]), + col: 1, + original: text("a"), + value: CellInput::Value(text("b")), + }), }; } - let _ = t.track_insert(vec![vec![ - CellInput::Value(Value::Null), - CellInput::Value(text("draft")), - ]]); + let _ = t.apply(TrackerEdit::InsertDrafts { + rows: vec![vec![CellInput::Value(Value::Null), CellInput::Value(text("draft"))]], + }); }; let mut first = TabChangeTracker::default(); let mut second = TabChangeTracker::default(); @@ -1577,10 +1664,12 @@ mod tests { let mut t = TabChangeTracker::default(); let columns = vec![pk_col("id"), data_col("name")]; let doomed = rk(&[Value::Int(9)]); - t.track_insert(vec![vec![ - CellInput::Value(Value::Null), - CellInput::Value(Value::Text("draft".into())), - ]]); + t.apply(TrackerEdit::InsertDrafts { + rows: vec![vec![ + CellInput::Value(Value::Null), + CellInput::Value(Value::Text("draft".into())), + ]], + }); delete( &mut t, doomed.clone(), @@ -1599,12 +1688,12 @@ mod tests { let mut t = TabChangeTracker::default(); let columns = vec![pk_col("a"), pk_col("b"), data_col("name")]; let key = RowKey::from_pk_values(&[Value::Int(1), Value::Int(2)]).unwrap(); - t.track_cell_edit( - key, - 2, - Value::Text("old".into()), - CellInput::Value(Value::Text("new".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key, + col: 2, + original: Value::Text("old".into()), + value: CellInput::Value(Value::Text("new".into())), + }); let tracked = t.change_set(&columns).unwrap(); @@ -1637,7 +1726,11 @@ mod tests { let columns = vec![pk_col("id"), data_col("name"), stamped]; let mut cells: Vec = columns.iter().map(new_draft_cell).collect(); cells[1] = CellInput::Value(Value::Text("draft".into())); - let draft_id = match t.track_insert(vec![cells]).inserted_drafts.as_slice() { + let draft_id = match t + .apply(TrackerEdit::InsertDrafts { rows: vec![cells] }) + .inserted_drafts + .as_slice() + { [draft_id] => *draft_id, other => panic!("an insert adds one draft row: {other:?}"), }; @@ -1689,12 +1782,12 @@ mod tests { fn a_table_without_a_primary_key_cannot_save_an_update() { let mut t = TabChangeTracker::default(); let columns = vec![data_col("name")]; - t.track_cell_edit( - rk(&[Value::Int(1)]), - 0, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 0, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); assert!(matches!(t.change_set(&columns), Err(BuildSqlError::NoRowIdentity))); } @@ -1704,7 +1797,11 @@ mod tests { let mut t = TabChangeTracker::default(); let draft_id = insert(&mut t, vec![Value::Null, Value::Text("hi".into())]); // Edit the draft so undo stack has a CellEdit on top of Insert. - t.track_draft_cell_edit(draft_id, 1, CellInput::Value(Value::Text("edited".into()))); + t.apply(TrackerEdit::DraftCell { + draft_id: draft_id, + col: 1, + input: CellInput::Value(Value::Text("edited".into())), + }); assert_eq!(t.drafts().len(), 1); assert!(t.can_undo()); @@ -1745,7 +1842,7 @@ mod tests { let rows = (0..tablepro_core::import::MAX_PASTED_ROWS) .map(|row| vec![CellInput::Value(Value::Int(row as i64))]) .collect(); - let drafts = t.track_insert(rows).inserted_drafts; + let drafts = t.apply(TrackerEdit::InsertDrafts { rows: rows }).inserted_drafts; let started = std::time::Instant::now(); let read = drafts @@ -1944,12 +2041,12 @@ mod tests { fn redo_of_a_persisted_cell_edit_leaves_the_fetched_row_alone() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit( - key.clone(), - 1, - Value::Text("a".into()), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Text("a".into()), + value: CellInput::Value(Value::Text("b".into())), + }); let _ = t.undo(); let redone = t.redo(); @@ -1964,8 +2061,18 @@ mod tests { fn discard_drops_every_draft_row_and_reports_each_touched_row_once() { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); - t.track_cell_edit(key.clone(), 1, Value::Int(1), CellInput::Value(Value::Int(2))); - t.track_cell_edit(key.clone(), 2, Value::Int(3), CellInput::Value(Value::Int(4))); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: Value::Int(1), + value: CellInput::Value(Value::Int(2)), + }); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 2, + original: Value::Int(3), + value: CellInput::Value(Value::Int(4)), + }); let draft_id = insert(&mut t, vec![Value::Null]); let delta = t.discard(); @@ -1981,12 +2088,12 @@ mod tests { let mut t = TabChangeTracker::default(); let key = rk(&[Value::Int(1)]); let fetched = Value::Text("a".into()); - t.track_cell_edit( - key.clone(), - 1, - fetched.clone(), - CellInput::Value(Value::Text("b".into())), - ); + t.apply(TrackerEdit::Cell { + row_key: key.clone(), + col: 1, + original: fetched.clone(), + value: CellInput::Value(Value::Text("b".into())), + }); let edited = t.cell_overlay(&key, 1); let untouched = t.cell_overlay(&key, 0); @@ -2053,7 +2160,12 @@ mod tests { let columns = vec![pk_col("id"), data_col("name")]; let mut t = saving_on(columns.clone()); let now = tablepro_core::edit::CellExpression::new("NOW()", &[], &[]); - t.track_cell_edit(rk(&[Value::Int(1)]), 1, text("a"), CellInput::Expression(now)); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 1, + original: text("a"), + value: CellInput::Expression(now), + }); let batch = t.begin_save().unwrap().unwrap(); edit(&mut t, 1, "a", "c"); edit(&mut t, 1, "a", "a"); @@ -2118,7 +2230,12 @@ mod tests { let before = vec![pk_col("id"), data_col("nickname"), data_col("name"), data_col("email")]; let after = vec![pk_col("id"), data_col("name"), data_col("email")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 2, text("Ada"), CellInput::Value(text("Grace"))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 2, + original: text("Ada"), + value: CellInput::Value(text("Grace")), + }); retarget(&mut t, &after); @@ -2147,7 +2264,12 @@ mod tests { let before = vec![pk_col("id"), data_col("nickname"), data_col("name")]; let after = vec![pk_col("id"), data_col("name")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 1, text("ada"), CellInput::Value(text("countess"))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 1, + original: text("ada"), + value: CellInput::Value(text("countess")), + }); edit(&mut t, 2, "Grace", "Hopper"); retarget(&mut t, &after); @@ -2175,7 +2297,12 @@ mod tests { let before = vec![pk_col("id"), test_column("score", "text")]; let after = vec![pk_col("id"), test_column("score", "integer")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 1, text("1"), CellInput::Value(text("high"))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 1, + original: text("1"), + value: CellInput::Value(text("high")), + }); retarget(&mut t, &after); @@ -2187,7 +2314,12 @@ mod tests { let before = vec![pk_col("id"), test_column("score", "integer")]; let after = vec![pk_col("id"), test_column("score", "bigint")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 1, Value::Int(1), CellInput::Value(Value::Int(2))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 1, + original: Value::Int(1), + value: CellInput::Value(Value::Int(2)), + }); retarget(&mut t, &after); @@ -2204,7 +2336,12 @@ mod tests { plain_id.nullable = false; let after = vec![plain_id, legacy_key, data_col("name")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 2, text("Ada"), CellInput::Value(text("Grace"))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 2, + original: text("Ada"), + value: CellInput::Value(text("Grace")), + }); delete( &mut t, rk(&[Value::Int(2)]), @@ -2222,8 +2359,18 @@ mod tests { let before = vec![pk_col("id"), data_col("nickname"), data_col("name")]; let after = vec![pk_col("id"), data_col("name")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 2, text("Ada"), CellInput::Value(text("Grace"))); - t.track_cell_edit(rk(&[Value::Int(1)]), 2, text("Ada"), CellInput::Value(text("Hopper"))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 2, + original: text("Ada"), + value: CellInput::Value(text("Grace")), + }); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 2, + original: text("Ada"), + value: CellInput::Value(text("Hopper")), + }); retarget(&mut t, &after); let _ = t.undo(); @@ -2238,7 +2385,12 @@ mod tests { let before = vec![pk_col("id"), data_col("nickname")]; let after = vec![pk_col("id")]; let mut t = saving_on(before); - t.track_cell_edit(rk(&[Value::Int(1)]), 1, text("ada"), CellInput::Value(text("countess"))); + t.apply(TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 1, + original: text("ada"), + value: CellInput::Value(text("countess")), + }); retarget(&mut t, &after); let _ = t.discard(); @@ -2257,7 +2409,12 @@ mod tests { let mut t = TabChangeTracker::default(); let failed = rk(&[Value::Int(1)]); let other = rk(&[Value::Int(2)]); - t.track_cell_edit(failed.clone(), 1, text("a"), CellInput::Value(text("b"))); + t.apply(TrackerEdit::Cell { + row_key: failed.clone(), + col: 1, + original: text("a"), + value: CellInput::Value(text("b")), + }); let marked = t.mark_error_row(failed.clone()); assert_eq!(marked.changed, std::slice::from_ref(&failed)); @@ -2282,7 +2439,12 @@ mod tests { fn undo_and_discard_of_the_failed_row_take_its_mark_off() { let mut t = TabChangeTracker::default(); let failed = rk(&[Value::Int(1)]); - t.track_cell_edit(failed.clone(), 1, text("a"), CellInput::Value(text("b"))); + t.apply(TrackerEdit::Cell { + row_key: failed.clone(), + col: 1, + original: text("a"), + value: CellInput::Value(text("b")), + }); let _ = t.mark_error_row(failed.clone()); let _ = t.undo(); @@ -2318,11 +2480,124 @@ mod tests { fn starting_a_save_takes_the_mark_off() { let mut t = saving_on(vec![pk_col("id"), data_col("name")]); let failed = rk(&[Value::Int(1)]); - t.track_cell_edit(failed.clone(), 1, text("a"), CellInput::Value(text("b"))); + t.apply(TrackerEdit::Cell { + row_key: failed.clone(), + col: 1, + original: text("a"), + value: CellInput::Value(text("b")), + }); let _ = t.mark_error_row(failed.clone()); assert!(t.begin_save().is_ok_and(|batch| batch.is_some())); assert!(!t.is_error_row(&failed)); } + #[test] + fn grouped_edits_keep_the_previous_forty_nine_commands() { + let mut tracker = TabChangeTracker::default(); + for id in 0..49 { + edit(&mut tracker, id, "before", "older"); + } + let delta = tracker.apply_all( + (49..109) + .map(|id| TrackerEdit::Cell { + row_key: rk(&[Value::Int(id)]), + col: 1, + original: text("before"), + value: CellInput::Value(text("group")), + }) + .collect(), + ); + assert_eq!(delta.changed.len(), 60); + assert_eq!(tracker.undo.len(), UNDO_LIMIT); + assert_eq!(tracker.undo().expect("the group").changed.len(), 60); + assert_eq!(tracker.pending_count(), 49); + for _ in 0..49 { + assert!(tracker.undo().is_some()); + } + assert_eq!(tracker.pending_count(), 0); + assert!(tracker.undo().is_none()); + for _ in 0..50 { + assert!(tracker.redo().is_some()); + } + assert_eq!(tracker.pending_count(), 109); + } + + #[test] + fn deleting_a_draft_prunes_only_its_part_of_a_group() { + let mut tracker = TabChangeTracker::default(); + let draft = insert(&mut tracker, vec![Value::Null, text("draft")]); + tracker.apply_all(vec![ + TrackerEdit::DraftCell { + draft_id: draft, + col: 1, + input: CellInput::Value(text("changed")), + }, + TrackerEdit::Cell { + row_key: rk(&[Value::Int(1)]), + col: 1, + original: text("saved"), + value: CellInput::Value(text("changed")), + }, + ]); + tracker.apply(TrackerEdit::DeleteRows { + persisted: vec![], + drafts: vec![draft], + }); + assert!(tracker.drafts().is_empty()); + tracker.undo().expect("the saved cell still undoes"); + assert_eq!(tracker.pending_count(), 0); + assert!(!tracker.can_undo()); + tracker.redo().expect("the saved cell still redoes"); + assert_eq!(tracker.pending_count(), 1); + assert!(tracker.drafts().is_empty()); + } + + #[test] + fn a_group_follows_columns_on_undo_and_redo() { + let mut tracker = saving_on(vec![pk_col("id"), data_col("unused"), data_col("name")]); + tracker.apply_all( + (1..=2) + .map(|id| TrackerEdit::Cell { + row_key: rk(&[Value::Int(id)]), + col: 2, + original: text("before"), + value: CellInput::Value(text("after")), + }) + .collect(), + ); + retarget(&mut tracker, &[pk_col("id"), data_col("name")]); + tracker.undo().expect("the moved group"); + assert_eq!(tracker.pending_count(), 0); + tracker.redo().expect("the moved group"); + assert_eq!(tracker.pending_count(), 2); + for id in 1..=2 { + assert_eq!(pending_at(&tracker, id, 1), text("after")); + assert_eq!(tracker.cell_state(&rk(&[Value::Int(id)]), 2), CellState::Clean); + } + } + + #[test] + fn an_empty_or_refused_group_keeps_redo() { + let mut tracker = saving_on(vec![pk_col("id"), data_col("name")]); + let draft = insert(&mut tracker, vec![Value::Null, text("draft")]); + edit(&mut tracker, 1, "before", "after"); + tracker.undo().expect("the cell edit"); + assert!(tracker.can_redo()); + let delta = tracker.apply_all(Vec::new()); + assert!(delta.changed.is_empty()); + assert!(tracker.can_redo()); + let batch = tracker.begin_save().expect("a save").expect("the draft"); + let delta = tracker.apply_all(vec![TrackerEdit::DraftCell { + draft_id: draft, + col: 1, + input: CellInput::Value(text("refused")), + }]); + assert_eq!(delta.changed, [RowKey::Draft(draft)]); + assert_eq!(tracker.draft_input(draft, 1), Some(CellInput::Value(text("draft")))); + assert!(tracker.can_redo()); + tracker.settle_save(&rolled_back(), batch.snapshot); + tracker.redo().expect("the earlier edit still redoes"); + assert_eq!(pending_at(&tracker, 1, 1), text("after")); + } } diff --git a/linux/crates/app/src/services/tab_tracker_handle.rs b/linux/crates/app/src/services/tab_tracker_handle.rs index 72346ded52..efcdddf388 100644 --- a/linux/crates/app/src/services/tab_tracker_handle.rs +++ b/linux/crates/app/src/services/tab_tracker_handle.rs @@ -40,6 +40,11 @@ impl TabTrackerHandle { self.0.borrow_mut().apply(edit) } + #[must_use = "the grid shows stale rows until the delta is applied"] + pub fn apply_all(&self, edits: Vec) -> TrackerDelta { + self.0.borrow_mut().apply_all(edits) + } + pub fn cell_is_saving(&self, row_key: &RowKey, col: usize) -> bool { self.0.borrow().cell_is_saving(row_key, col) } diff --git a/linux/crates/app/src/services/undo_op.rs b/linux/crates/app/src/services/undo_op.rs index fafa4a2f6d..e32a877f77 100644 --- a/linux/crates/app/src/services/undo_op.rs +++ b/linux/crates/app/src/services/undo_op.rs @@ -10,6 +10,9 @@ use super::touch::Touch; /// same order it would have before the step. #[derive(Debug, Clone, PartialEq)] pub enum UndoOp { + Group { + steps: Vec, + }, /// `None` on either side means the cell had no pending edit, which /// is also what an edit back to the fetched value leaves. CellEdit { @@ -51,6 +54,9 @@ impl UndoOp { touched: mark.touched, }; match self { + UndoOp::Group { steps } => Some(UndoOp::Group { + steps: steps.iter().map(|step| step.relayout(layout)).collect::>()?, + }), UndoOp::CellEdit { row_key, col, @@ -119,6 +125,10 @@ impl UndoOp { pub fn forget_draft(&mut self, draft_id: u64) -> bool { let gone = RowKey::Draft(draft_id); match self { + UndoOp::Group { steps } => { + steps.retain_mut(|step| step.forget_draft(draft_id)); + !steps.is_empty() + } UndoOp::Insert { drafts } => { drafts.retain(|draft| draft.draft_id != draft_id); !drafts.is_empty() diff --git a/linux/crates/app/src/ui/data_grid/edit/mod.rs b/linux/crates/app/src/ui/data_grid/edit/mod.rs index 240b88ad48..c09e1cd961 100644 --- a/linux/crates/app/src/ui/data_grid/edit/mod.rs +++ b/linux/crates/app/src/ui/data_grid/edit/mod.rs @@ -165,17 +165,20 @@ impl EditController { self.policy.get() } - /// Every tracker write but undo, redo and discard goes through here. fn apply_edit(&self, grid: &DataGrid, edit: TrackerEdit) { + self.apply_edits(grid, vec![edit]); + } + + fn apply_edits(&self, grid: &DataGrid, edits: Vec) { let Some(tracker) = self.tracked().tracker().cloned() else { return; }; - if tracker.refuses(&edit) { + if edits.iter().any(|edit| tracker.refuses(edit)) { grid.toast(gettext( "This row is being saved. Change it again once the save finishes.", )); } - let delta = tracker.apply(edit); + let delta = tracker.apply_all(edits); self.apply_delta(&delta); } diff --git a/linux/crates/app/src/ui/data_grid/edit/row_edits.rs b/linux/crates/app/src/ui/data_grid/edit/row_edits.rs index 57740d3912..2076bb76a2 100644 --- a/linux/crates/app/src/ui/data_grid/edit/row_edits.rs +++ b/linux/crates/app/src/ui/data_grid/edit/row_edits.rs @@ -38,43 +38,47 @@ impl EditController { } } - /// Set to Empty, NULL or DEFAULT on the focused cell's column, in - /// every selected row as macOS does. The menu offers only what the - /// focused cell takes; a row that refuses the value is left out, and a - /// column that refuses it everywhere says why, as committing an empty - /// cell would. pub(super) fn set_preset(&self, grid: &DataGrid, preset: CellPreset) { + grid.commit_editors(); let Some(target) = grid.target() else { return; }; - let Some((focused, column)) = target.cell.clone() else { + let Some((_, column)) = target.cell else { return; }; - let rows = if target.rows.len() > 1 && target.rows.iter().any(|row| row.id() == focused.id()) { - target.rows.clone() - } else { - vec![focused] - }; - let mut writes = Vec::new(); + let tracked = self.tracked(); + let mut edits = Vec::new(); + let mut skipped = 0; let mut refusal = None; - for row in &rows { - match self.preset_input(grid, row, column, preset) { - Ok(Some((grid_column, input))) => writes.push((row.clone(), grid_column, input)), - Ok(None) => {} - Err(message) => refusal = refusal.or(Some(message)), + for row in &target.rows { + let outcome = match self.preset_input(grid, row, column, preset) { + Ok(Some((grid_column, input))) => { + let start = edit_start(&tracked, row, column); + match commit_input(&grid_column, &start, input) { + CommitResult::Edit(edit) => { + edits.push(edit); + Ok(()) + } + CommitResult::Unchanged => Ok(()), + CommitResult::Rejected(error) => Err(Some(edit_parse_message(&error))), + } + } + Ok(None) => Err(None), + Err(message) => Err(Some(message)), + }; + if let Err(message) = outcome { + skipped += 1; + refusal = refusal.or(message); } } - if writes.is_empty() { - if let Some(message) = refusal { - grid.toast(message); - } - return; + if !edits.is_empty() { + self.apply_edits(grid, edits); } - grid.commit_editors(); - let skipped = rows.len() - writes.len(); - for (row, grid_column, input) in writes { - let start = edit_start(&self.tracked(), &row, column); - self.commit_input(grid, &grid_column, &start, input); + if skipped == target.rows.len() + && let Some(message) = refusal + { + grid.toast(message); + return; } if skipped > 0 { grid.toast(ngettext_f( @@ -86,8 +90,6 @@ impl EditController { } } - /// What `preset` writes into one row's cell. `Ok(None)` for a cell - /// that is locked, `Err` for one whose column refuses the value. fn preset_input( &self, grid: &DataGrid, diff --git a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs index 3d1a8e2662..cb7d8ea528 100644 --- a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs +++ b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs @@ -282,3 +282,204 @@ fn set_to_null_reaches_every_selected_row_in_the_focused_column() { assert_eq!(pending(&grid, 2, 1), Some(CellInput::Value(Value::Null))); assert_eq!(pending(&grid, 1, 0), None, "another column stayed"); } + +#[gtk4::test] +fn one_undo_restores_more_than_fifty_selected_rows() { + let grid = Grid::build(GridSpec::table(two_text_columns()), page(0..60)); + select_all_from(&grid, 0, 1); + grid.take_requests(); + + grid.activate("set-null"); + + for id in 0..60 { + assert_eq!(pending(&grid, id, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(pending(&grid, id, 0), None); + } + assert_eq!(grid.grid.selected_count(), 60); + assert_eq!( + grid.take_requests() + .iter() + .filter(|request| matches!(request, GridRequest::PendingChanged)) + .count(), + 1 + ); + grid.grid.undo(); + assert_eq!(grid.tracker.pending_count(), 0); + assert!(!grid.tracker.can_undo()); + grid.grid.redo(); + assert_eq!(grid.tracker.pending_count(), 60); + for id in 0..60 { + assert_eq!(pending(&grid, id, 1), Some(CellInput::Value(Value::Null))); + } +} + +#[gtk4::test] +fn empty_groups_drafts_and_saved_rows_without_removing_the_draft_on_undo() { + let grid = two_text_rows(); + let draft = grid.insert_draft(); + select_all_from(&grid, 0, 1); + + grid.activate("set-empty"); + + assert_eq!(grid.tracker.draft_input(draft, 1), Some(name(""))); + assert_eq!(pending(&grid, 1, 1), Some(name(""))); + assert_eq!(pending(&grid, 2, 1), Some(name(""))); + grid.grid.undo(); + assert_eq!(grid.grid.store().draft_count(), 1); + assert_eq!(grid.tracker.draft_input(draft, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(pending(&grid, 1, 1), None); + assert_eq!(pending(&grid, 2, 1), None); + grid.grid.redo(); + assert_eq!(grid.tracker.draft_input(draft, 1), Some(name(""))); + assert_eq!(pending(&grid, 2, 1), Some(name(""))); +} + +#[gtk4::test] +fn presets_leave_deleted_and_unkeyed_rows_unchanged() { + use crate::services::tracker_edit::TrackerEdit; + let mut rows = persisted(&crate::ui::data_grid::test_grid::two_text_values()); + rows.push(RowData::persisted( + None, + Arc::from([Value::Int(3), Value::Text("No key".into())]), + )); + let grid = Grid::build(GridSpec::table(two_text_columns()), rows); + let delta = grid.tracker.apply(TrackerEdit::DeleteRows { + persisted: vec![(key(2), Arc::from([Value::Int(2), Value::Text("B".into())]))], + drafts: vec![], + }); + grid.grid.apply_delta(&delta); + select_all_from(&grid, 0, 1); + grid.take_requests(); + + grid.activate("set-null"); + + assert_eq!(pending(&grid, 1, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(pending(&grid, 2, 1), None); + assert_eq!(grid.tracker.row_state(&key(2)), RowState::PendingDelete); + assert_eq!( + super::toasts(&grid), + ["2 rows can't take this value and were left as they were"] + ); + grid.grid.undo(); + assert_eq!(grid.tracker.pending_count(), 1); + assert_eq!(grid.tracker.row_state(&key(2)), RowState::PendingDelete); +} + +#[gtk4::test] +fn a_preset_uses_only_the_focused_row_when_it_is_outside_the_selection() { + let grid = Grid::build(GridSpec::table(two_text_columns()), page(0..3)); + grid.focus(0, 1); + grid.grid.selection().select_range(1, 2, true); + drain_main_context(); + + grid.activate("set-null"); + + assert_eq!(pending(&grid, 0, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(pending(&grid, 1, 1), None); + assert_eq!(pending(&grid, 2, 1), None); +} + +#[gtk4::test] +fn unchanged_presets_preserve_redo() { + let grid = two_text_rows(); + select_all_from(&grid, 0, 1); + grid.activate("set-null"); + grid.activate("set-empty"); + grid.grid.undo(); + grid.take_requests(); + + grid.activate("set-null"); + + assert!(grid.tracker.can_redo()); + assert!( + grid.take_requests() + .iter() + .all(|request| !matches!(request, GridRequest::PendingChanged)) + ); + grid.grid.redo(); + assert_eq!(pending(&grid, 1, 1), Some(name(""))); + assert_eq!(pending(&grid, 2, 1), Some(name(""))); +} + +#[gtk4::test] +fn default_is_checked_for_each_selected_row() { + use tablepro_core::column::ColumnDefault; + let mut value = named("value", "integer", false); + value.default = ColumnDefault::Literal(Value::Int(0)); + let grid = Grid::open( + vec![named("id", "integer", true), value], + vec![vec![Value::Int(1), Value::Int(5)]], + ); + let draft = grid.insert_draft(); + select_all_from(&grid, 0, 1); + grid.take_requests(); + + grid.activate("set-default"); + + assert_eq!(grid.tracker.draft_input(draft, 1), Some(CellInput::Default)); + assert_eq!(pending(&grid, 1, 1), None); + assert_eq!( + super::toasts(&grid), + ["1 row can't take this value and was left as it was"] + ); + grid.grid.undo(); + assert_eq!(grid.tracker.draft_input(draft, 1), Some(CellInput::Value(Value::Null))); +} + +#[gtk4::test] +fn presets_recheck_column_and_connection_locks() { + use crate::services::grid::CellPreset; + let mut value = named("value", "integer", false); + value.nullable = false; + let grid = Grid::open( + vec![named("id", "integer", true), value], + vec![vec![Value::Int(1), Value::Int(5)], vec![Value::Int(2), Value::Int(6)]], + ); + select_all_from(&grid, 0, 1); + grid.grid.edit().set_preset(&grid.grid, CellPreset::Empty); + assert_eq!(grid.tracker.pending_count(), 0); + assert_eq!(super::toasts(&grid).len(), 1); + grid.grid.edit().set_preset(&grid.grid, CellPreset::Null); + assert_eq!(grid.tracker.pending_count(), 0); + assert_eq!(super::toasts(&grid).len(), 1); + + let mut spec = GridSpec::table(two_text_columns()); + spec.policy = Some(edit_policy(true, true, true)); + let read_only = Grid::build(spec, page(0..2)); + select_all_from(&read_only, 0, 1); + read_only.grid.edit().set_preset(&read_only.grid, CellPreset::Null); + assert_eq!(read_only.tracker.pending_count(), 0); +} + +#[gtk4::test] +fn a_preset_skips_cells_in_a_running_save() { + let grid = two_text_rows(); + let _ = grid.tracker.set_target(crate::services::save_batch::SaveTarget { + table: tablepro_core::meta::TableRef::unqualified("t"), + columns: two_text_columns(), + }); + super::type_into(&grid, &grid.cell_of(1, 1), "saving").emit_activate(); + let batch = grid.tracker.begin_save().expect("a save").expect("changes"); + grid.grid.redraw(); + select_all_from(&grid, 1, 1); + grid.take_requests(); + + grid.activate("set-null"); + + assert_eq!(pending(&grid, 1, 1), Some(name("saving"))); + assert_eq!(pending(&grid, 2, 1), Some(CellInput::Value(Value::Null))); + assert_eq!( + super::toasts(&grid), + ["1 row can't take this value and was left as it was"] + ); + let delta = grid.tracker.settle_save( + &crate::workspace::SaveOutcome::RolledBack(crate::workspace::RollbackCause::Driver( + tablepro_core::DriverError::server("cancelled"), + )), + batch.snapshot, + ); + grid.grid.apply_delta(&delta); + grid.grid.undo(); + assert_eq!(pending(&grid, 1, 1), Some(name("saving"))); + assert_eq!(pending(&grid, 2, 1), None); +} From ed21c524c2e4fa5e9f4c07690f56eeccdaf6c7d1 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 17:55:34 +0100 Subject: [PATCH 3/5] feat(linux-grid): set an expression in every selected row too --- linux/changelog.d/4136.changed.md | 2 +- .../src/ui/data_grid/edit/expression_menu.rs | 31 +++++++++++------- .../app/src/ui/data_grid/edit/row_edits.rs | 24 ++++++++------ .../ui/data_grid/edit/tests/expressions.rs | 32 +++++++++++++++++++ 4 files changed, 67 insertions(+), 22 deletions(-) diff --git a/linux/changelog.d/4136.changed.md b/linux/changelog.d/4136.changed.md index 1b7ccc0611..bf340dd401 100644 --- a/linux/changelog.d/4136.changed.md +++ b/linux/changelog.d/4136.changed.md @@ -1 +1 @@ -Set to Empty, NULL or DEFAULT now changes the focused column in every selected row. +Set to Empty, NULL, DEFAULT or an expression now changes the focused column in every selected row. diff --git a/linux/crates/app/src/ui/data_grid/edit/expression_menu.rs b/linux/crates/app/src/ui/data_grid/edit/expression_menu.rs index b0438f854d..da3d809560 100644 --- a/linux/crates/app/src/ui/data_grid/edit/expression_menu.rs +++ b/linux/crates/app/src/ui/data_grid/edit/expression_menu.rs @@ -34,22 +34,29 @@ impl EditController { /// The menu item names its expression by its SQL, which is looked up /// in the engine's list again, so only that list reaches a statement. pub(super) fn set_expression(&self, grid: &DataGrid, sql: &str) { - let Some((row, column)) = grid.target().and_then(|target| target.cell) else { + let Some((rows, column)) = self.value_targets(grid) else { return; }; - let Some(grid_column) = self.unlocked_column(grid, &row, column) else { + // Each row asks its own list again, so a row that cannot take it is left as it was. + let writes: Vec<_> = rows + .iter() + .filter_map(|row| { + let grid_column = self.unlocked_column(grid, row, column)?; + let expression = self + .expressions_for(grid, row, column) + .into_iter() + .find(|expression| expression.sql == sql)?; + Some((row.clone(), grid_column, expression)) + }) + .collect(); + if writes.is_empty() { return; - }; - let Some(expression) = self - .expressions_for(grid, &row, column) - .into_iter() - .find(|expression| expression.sql == sql) - else { - return; - }; + } grid.commit_editors(); - let start = edit_start(&self.tracked(), &row, column); - self.commit_input(grid, &grid_column, &start, CellInput::Expression(expression)); + for (row, grid_column, expression) in writes { + let start = edit_start(&self.tracked(), &row, column); + self.commit_input(grid, &grid_column, &start, CellInput::Expression(expression)); + } } fn expressions_for(&self, grid: &DataGrid, row: &GridRow, column: usize) -> Vec { diff --git a/linux/crates/app/src/ui/data_grid/edit/row_edits.rs b/linux/crates/app/src/ui/data_grid/edit/row_edits.rs index 57740d3912..5a0d6c8456 100644 --- a/linux/crates/app/src/ui/data_grid/edit/row_edits.rs +++ b/linux/crates/app/src/ui/data_grid/edit/row_edits.rs @@ -44,17 +44,9 @@ impl EditController { /// column that refuses it everywhere says why, as committing an empty /// cell would. pub(super) fn set_preset(&self, grid: &DataGrid, preset: CellPreset) { - let Some(target) = grid.target() else { + let Some((rows, column)) = self.value_targets(grid) else { return; }; - let Some((focused, column)) = target.cell.clone() else { - return; - }; - let rows = if target.rows.len() > 1 && target.rows.iter().any(|row| row.id() == focused.id()) { - target.rows.clone() - } else { - vec![focused] - }; let mut writes = Vec::new(); let mut refusal = None; for row in &rows { @@ -86,6 +78,20 @@ impl EditController { } } + /// The rows a Set Value command reaches and the column it writes: the + /// focused cell's column in every selected row when the focused row is + /// one of several selected, else the focused cell alone. + pub(super) fn value_targets(&self, grid: &DataGrid) -> Option<(Vec, usize)> { + let target = grid.target()?; + let (focused, column) = target.cell.clone()?; + let rows = if target.rows.len() > 1 && target.rows.iter().any(|row| row.id() == focused.id()) { + target.rows.clone() + } else { + vec![focused] + }; + Some((rows, column)) + } + /// What `preset` writes into one row's cell. `Ok(None)` for a cell /// that is locked, `Err` for one whose column refuses the value. fn preset_input( diff --git a/linux/crates/app/src/ui/data_grid/edit/tests/expressions.rs b/linux/crates/app/src/ui/data_grid/edit/tests/expressions.rs index a5d3d16b7a..5e1e6bb115 100644 --- a/linux/crates/app/src/ui/data_grid/edit/tests/expressions.rs +++ b/linux/crates/app/src/ui/data_grid/edit/tests/expressions.rs @@ -96,3 +96,35 @@ fn only_an_expression_from_the_engines_list_is_staged() { assert_eq!(pending(&grid, 1, 1), None); } + +#[gtk4::test] +fn an_expression_is_staged_in_every_selected_row() { + let dialect: Arc = Arc::new(tablepro_driver_postgres::PgDialect::new(&ServerInfo::new( + "PostgreSQL", + "18.0", + 18, + 0, + 0, + ))); + let grid = Grid::build( + GridSpec { + dialect: Some(Rc::new(move || Some(dialect.clone()))), + ..GridSpec::table(vec![named("id", "integer", true), named("seen", "timestamp", false)]) + }, + persisted(&[vec![Value::Int(1), Value::Null], vec![Value::Int(2), Value::Null]]), + ); + grid.focus(0, 1); + grid.grid.selection().select_all(); + crate::test_support::drain_main_context(); + + grid.grid + .activate_action("grid.set-expression", Some(&"now()".to_variant())) + .expect("Set to now()"); + + for id in [1, 2] { + assert!( + matches!(pending(&grid, id, 1), Some(CellInput::Expression(expression)) if expression.sql == "now()"), + "row {id}" + ); + } +} From 8886c60d0f2a3e41e5247f525a30b42fbaac491f Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 23:55:54 +0700 Subject: [PATCH 4/5] fix(linux-grid): offer presets accepted by any selected row --- .../app/src/ui/data_grid/edit/actions.rs | 14 ++++-- .../app/src/ui/data_grid/edit/tests/rows.rs | 45 ++++++++++++++++++- 2 files changed, 55 insertions(+), 4 deletions(-) diff --git a/linux/crates/app/src/ui/data_grid/edit/actions.rs b/linux/crates/app/src/ui/data_grid/edit/actions.rs index 68ffb34aaf..a2db70e63a 100644 --- a/linux/crates/app/src/ui/data_grid/edit/actions.rs +++ b/linux/crates/app/src/ui/data_grid/edit/actions.rs @@ -66,9 +66,17 @@ pub(super) fn refresh(controller: &EditController, grid: &DataGrid, target: Opti Ok(()) => target.and_then(|target| target.cell.as_ref()), Err(_) => None, }; - let (kind, presets) = cell.map_or((None, CellPresets::default()), |(row, column)| { - cell_state(controller, grid, row, *column) - }); + let kind = cell.and_then(|(row, column)| cell_state(controller, grid, row, *column).0); + let presets = match (cell, target) { + (Some((_, column)), Some(target)) => target.rows.iter().fold(CellPresets::default(), |mut offered, row| { + let (_, presets) = cell_state(controller, grid, row, *column); + offered.empty |= presets.empty; + offered.null |= presets.null; + offered.default |= presets.default; + offered + }), + _ => CellPresets::default(), + }; // The capture-phase keys a focused editor would lose to the grid. let typing = controller.editor_has_focus(); let edits = !typing diff --git a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs index cb7d8ea528..1dc09f2a7a 100644 --- a/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs +++ b/linux/crates/app/src/ui/data_grid/edit/tests/rows.rs @@ -461,9 +461,11 @@ fn a_preset_skips_cells_in_a_running_save() { super::type_into(&grid, &grid.cell_of(1, 1), "saving").emit_activate(); let batch = grid.tracker.begin_save().expect("a save").expect("changes"); grid.grid.redraw(); - select_all_from(&grid, 1, 1); + select_all_from(&grid, 0, 1); grid.take_requests(); + assert!(grid.is_enabled("set-null")); + assert!(!grid.is_enabled("edit")); grid.activate("set-null"); assert_eq!(pending(&grid, 1, 1), Some(name("saving"))); @@ -483,3 +485,44 @@ fn a_preset_skips_cells_in_a_running_save() { assert_eq!(pending(&grid, 1, 1), Some(name("saving"))); assert_eq!(pending(&grid, 2, 1), None); } + +#[gtk4::test] +fn a_saved_focus_does_not_hide_default_for_a_selected_draft() { + use tablepro_core::column::ColumnDefault; + let mut value = named("value", "integer", false); + value.default = ColumnDefault::Literal(Value::Int(0)); + let grid = Grid::open( + vec![named("id", "integer", true), value], + vec![vec![Value::Int(1), Value::Int(5)]], + ); + let draft = grid.insert_draft(); + select_all_from(&grid, 1, 1); + + assert!(grid.is_enabled("set-default")); + grid.activate("set-default"); + + assert_eq!(grid.tracker.draft_input(draft, 1), Some(CellInput::Default)); + assert_eq!(pending(&grid, 1, 1), None); + assert!(!grid.is_enabled("toggle")); +} + +#[gtk4::test] +fn a_deleted_focus_does_not_disable_presets_for_other_selected_rows() { + use crate::services::tracker_edit::TrackerEdit; + let grid = two_text_rows(); + let delta = grid.tracker.apply(TrackerEdit::DeleteRows { + persisted: vec![(key(1), Arc::from([Value::Int(1), Value::Text("A".into())]))], + drafts: vec![], + }); + grid.grid.apply_delta(&delta); + select_all_from(&grid, 0, 1); + + assert!(grid.is_enabled("set-null")); + assert!(grid.is_enabled("set-empty")); + assert!(!grid.is_enabled("edit")); + grid.activate("set-null"); + + assert_eq!(pending(&grid, 1, 1), None); + assert_eq!(pending(&grid, 2, 1), Some(CellInput::Value(Value::Null))); + assert_eq!(grid.tracker.row_state(&key(1)), RowState::PendingDelete); +} From 7fc5ffd43e6adb08ff7df6b211cbddb54222a81e Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 01:03:15 +0700 Subject: [PATCH 5/5] test(linux-grid): use field shorthand in tracker tests --- linux/crates/app/src/services/change_tracker.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/linux/crates/app/src/services/change_tracker.rs b/linux/crates/app/src/services/change_tracker.rs index acf78ec9d8..7e12f7a1ab 100644 --- a/linux/crates/app/src/services/change_tracker.rs +++ b/linux/crates/app/src/services/change_tracker.rs @@ -1798,7 +1798,7 @@ mod tests { let draft_id = insert(&mut t, vec![Value::Null, Value::Text("hi".into())]); // Edit the draft so undo stack has a CellEdit on top of Insert. t.apply(TrackerEdit::DraftCell { - draft_id: draft_id, + draft_id, col: 1, input: CellInput::Value(Value::Text("edited".into())), }); @@ -1842,7 +1842,7 @@ mod tests { let rows = (0..tablepro_core::import::MAX_PASTED_ROWS) .map(|row| vec![CellInput::Value(Value::Int(row as i64))]) .collect(); - let drafts = t.apply(TrackerEdit::InsertDrafts { rows: rows }).inserted_drafts; + let drafts = t.apply(TrackerEdit::InsertDrafts { rows }).inserted_drafts; let started = std::time::Instant::now(); let read = drafts