diff --git a/linux/ARCHITECTURE.md b/linux/ARCHITECTURE.md index df1511b24c..5557dcb75f 100644 --- a/linux/ARCHITECTURE.md +++ b/linux/ARCHITECTURE.md @@ -100,7 +100,7 @@ See [docs/state-management.md](docs/state-management.md) for the patterns and na Every key the app binds or relies on is one `Accelerator` in `ACCELERATORS` (`crates/app/src/application/accelerators.rs`): the action it fires, its triggers, its `AcceleratorScope` and where the shortcuts dialog lists it. - **Application** keys go in with `set_accels_for_action` at startup. GtkWindow runs them in the capture phase, before the focused widget, so none of them is a key a text field or a list uses. -- **Local** keys are a `local_shortcut_controller(owner)` on the owner's widget, firing the owner's action group through `NamedAction`: `browse` on a table tab, `grid` on a data grid's column view (two owners, one per phase), `editor` on the SQL editor's source view and, for find and replace, on the whole editor tab, `structure`, `filter`, the sidebar's list, which opens the selected table's menu, the query history's list, which opens the focused row's menu, and a picker row, which opens its menu. A disabled action lets its key go on. Bubble phase leaves a text field inside the owner its own Ctrl+Z and Ctrl+C; the source view's keys run in the capture phase, because GtkTextView binds Ctrl+/ itself. +- **Local** keys are a `local_shortcut_controller(owner)` on the owner's widget, firing the owner's action group through `NamedAction`: `table` for a table tab’s selected view and `browse` for its rows, `grid` on a data grid's column view (two owners, one per phase), `editor` on the SQL editor's source view and, for find and replace, on the whole editor tab, `structure`, `filter`, the sidebar's list, which opens the selected table's menu, the query history's list, which opens the focused row's menu, and a picker row, which opens its menu. A disabled action lets its key go on. Bubble phase leaves a text field inside the owner its own Ctrl+Z and Ctrl+C; the source view's keys run in the capture phase, because GtkTextView binds Ctrl+/ itself. - **Component** keys are bound by a component's own controller (the grid's inline and detail pane editors), which reads them from the table through `component_trigger` or `component_matches`. - **Stock** keys belong to GTK or libadwaita: GtkListBase's selection and movement, AdwTabView's tab switching, AdwApplication's Ctrl+?. The workspace removes AdwTabView's Ctrl+Home and Ctrl+End pairs so the lists and the editor in its tabs keep them. @@ -150,7 +150,7 @@ pub enum WorkspaceTab { } ``` -A table's structure opens in a Structure tab of its own. Saving a new table closes its Structure tab and opens a Table tab on it. A schema's ER diagram opens in a Diagram tab, one per schema: it reads each table's columns, foreign keys and indexes on one connection lease, two tables at a time, and draws the cards and lines on a canvas of its own (`crates/app/src/ui/diagram/`), with a focusable `DiagramNode` where each card is so the keyboard and a screen reader reach the tables. Its record keeps the schema and where the user moved tables, so a restore reads the tables again, lays them out and puts the moved ones back. +A table's structure opens inside its Table tab or in an Edit Structure tab of its own ([state-management.md](docs/state-management.md#tabs)). Saving a new table closes its Structure tab and opens a Table tab on it. A schema's ER diagram opens in a Diagram tab, one per schema: it reads each table's columns, foreign keys and indexes on one connection lease, two tables at a time, and draws the cards and lines on a canvas of its own (`crates/app/src/ui/diagram/`), with a focusable `DiagramNode` where each card is so the keyboard and a screen reader reach the tables. Its record keeps the schema and where the user moved tables, so a restore reads the tables again, lays them out and puts the moved ones back. Each tab is a gtk-rs widget with a composite template, which the `AdwTabView` adopts. The workspace keeps a `HashMap` keyed by the tab's UUID; the canonical display order comes from `tab_view.pages()` (drag-reorderable). A `TabIndex` maps each `AdwTabPage` to its tab's UUID, so close and right-click actions can recover it. `TabFactory` builds every tab from a `TabSpec`, whether the sidebar, the overview's new-tab button, a restore or a reopen asks for it. Every tab's title comes from its `TabIdentity` through `resolve_tab_title`, and the window's from the tab in front through `resolve_window_title`. A tab that closing would lose something in shows `document-modified-symbolic` as its page icon, as GNOME Text Editor does; its title never changes for it. diff --git a/linux/changelog.d/4108.added.md b/linux/changelog.d/4108.added.md new file mode 100644 index 0000000000..ba67bd84fe --- /dev/null +++ b/linux/changelog.d/4108.added.md @@ -0,0 +1 @@ +Switch between Data and Structure from a table tab’s bottom bar while keeping unsaved changes in each view. diff --git a/linux/crates/app/src/application/accelerators.rs b/linux/crates/app/src/application/accelerators.rs index f8e86d71ba..938aa7d5b7 100644 --- a/linux/crates/app/src/application/accelerators.rs +++ b/linux/crates/app/src/application/accelerators.rs @@ -125,11 +125,11 @@ pub const ACCELERATORS: &[Accelerator] = &[ local( BrowseTab, BUBBLE, - "browse.refresh", + "table.refresh", &["F5", "r"], Listed(BrowseTable), ), - local(BrowseTab, BUBBLE, "browse.save", &["s"], Listed(BrowseTable)), + local(BrowseTab, BUBBLE, "table.save", &["s"], Listed(BrowseTable)), local(BrowseTab, BUBBLE, "browse.undo", &["z"], Listed(BrowseTable)), local( BrowseTab, diff --git a/linux/crates/app/src/ui/browse_tab/browse_actions.rs b/linux/crates/app/src/ui/browse_tab/browse_actions.rs index 42ebc3c9dc..ade139c22c 100644 --- a/linux/crates/app/src/ui/browse_tab/browse_actions.rs +++ b/linux/crates/app/src/ui/browse_tab/browse_actions.rs @@ -62,10 +62,13 @@ pub(super) fn install_browse_actions(tab: &BrowseTab, page_size: u64) -> BrowseA } }); group.add_action(&page_size); - add("refresh", || PagingInput::RequestRefresh.into()); + let first = add("first-page", || PagingInput::FirstPage.into()); let previous = add("previous-page", || PagingInput::PrevPage.into()); let next = add("next-page", || PagingInput::NextPage.into()); - tab.imp().pager_bar.follow_page_actions(ACTION_GROUP, &previous, &next); + let last = add("last-page", || PagingInput::LastPage.into()); + tab.imp() + .pager_bar + .follow_page_actions(ACTION_GROUP, &first, &previous, &next, &last); let actions = BrowseActions { save: add("save", || SaveInput::CommitSave.into()), undo: add("undo", || GridInput::Undo.into()), @@ -76,8 +79,10 @@ pub(super) fn install_browse_actions(tab: &BrowseTab, page_size: u64) -> BrowseA for action in [&actions.save, &actions.undo, &actions.redo, &actions.count_rows] { action.set_enabled(false); } - tab.imp().pending_bar.announce_save_keys(ACTION_GROUP, &actions.save); + tab.imp().pending_bar.announce_save_keys("table", &actions.save); tab.insert_action_group(ACTION_GROUP, Some(&group)); + let _ = tab.imp().browse_actions.set(group); + install_view_actions(tab); tab.add_controller(local_shortcut_controller(ShortcutOwner::BrowseTab)); actions } @@ -101,3 +106,21 @@ pub(super) fn describe_buttons(tab: &BrowseTab) { announce_key_shortcuts(&imp.filter_button.get(), "browse.filter"); announce_key_shortcuts(&imp.details_toggle.get(), "grid.show-details"); } + +fn install_view_actions(tab: &BrowseTab) { + let group = gio::SimpleActionGroup::new(); + for (name, callback) in [ + ("save", BrowseTab::save_selected_view as fn(&BrowseTab)), + ("refresh", BrowseTab::refresh_selected_view), + ] { + let action = gio::SimpleAction::new(name, None); + let weak = tab.downgrade(); + action.connect_activate(move |_, _| { + if let Some(tab) = weak.upgrade() { + callback(&tab); + } + }); + group.add_action(&action); + } + tab.insert_action_group("table", Some(&group)); +} diff --git a/linux/crates/app/src/ui/browse_tab/data_handlers.rs b/linux/crates/app/src/ui/browse_tab/data_handlers.rs index 9f49164435..434ed8ef31 100644 --- a/linux/crates/app/src/ui/browse_tab/data_handlers.rs +++ b/linux/crates/app/src/ui/browse_tab/data_handlers.rs @@ -31,6 +31,27 @@ impl BrowseModel { self.begin_read(fx); self.reload_from_columns(ColumnFreshness::Refetch); } + DataInput::Renamed(name) => { + self.grid.commit_edit(); + self.sequencer.cancel_all(); + self.table = name; + if let Some(connection) = self.connection_id { + self.filter_settings.set_filters( + connection, + self.schema.as_deref(), + &self.table, + self.current_filter.clone(), + ); + } + self.grid.rename_table(&self.table); + let delta = self.tracker.set_target(SaveTarget { + table: self.table_ref(), + columns: self.current_columns.clone(), + }); + self.grid.apply_delta(&delta); + self.reload(fx); + fx.output(BrowseTabOutput::StateChanged); + } DataInput::Command(command) => self.on_command(*command, fx), DataInput::LinkChanged(generation) => self.on_link_changed(generation, fx), DataInput::SchemaChanged => { @@ -113,8 +134,8 @@ impl BrowseModel { /// The grid's actions reach the tab's buttons only while its rows are /// on screen: rows behind the loading or the error page are not what /// the table holds under the tab's filter. - fn show_grid_actions(&mut self) { - let shown = self.load.has_content(); + pub(super) fn show_grid_actions(&mut self) { + let shown = self.load.has_content() && self.this.upgrade().is_some_and(|tab| !tab.shows_structure()); if self.grid_actions_shown == shown { return; } diff --git a/linux/crates/app/src/ui/browse_tab/data_input.rs b/linux/crates/app/src/ui/browse_tab/data_input.rs index 0bd9611071..213c3db159 100644 --- a/linux/crates/app/src/ui/browse_tab/data_input.rs +++ b/linux/crates/app/src/ui/browse_tab/data_input.rs @@ -5,6 +5,7 @@ use super::BrowseCommand; #[derive(Debug)] pub(crate) enum DataInput { Start, + Renamed(String), // Replies own page data; keep that payload out of every queued input. Command(Box), LinkChanged(LinkGeneration), diff --git a/linux/crates/app/src/ui/browse_tab/imp.rs b/linux/crates/app/src/ui/browse_tab/imp.rs index b6c8158638..66ee1d7eb0 100644 --- a/linux/crates/app/src/ui/browse_tab/imp.rs +++ b/linux/crates/app/src/ui/browse_tab/imp.rs @@ -28,6 +28,16 @@ pub struct BrowseTab { #[template_child] pub no_pk_banner: TemplateChild, #[template_child] + pub view_stack: TemplateChild, + #[template_child] + pub structure_host: TemplateChild, + #[template_child] + pub view_toggle: TemplateChild, + #[template_child] + pub data_start: TemplateChild, + #[template_child] + pub data_end: TemplateChild, + #[template_child] pub inner_stack: TemplateChild, #[template_child] pub loading_page: TemplateChild, @@ -65,6 +75,8 @@ pub struct BrowseTab { /// The tab's one grid, reachable while an input is being handled /// and the model is borrowed. pub(super) grid: OnceCell, + pub(super) browse_actions: OnceCell, + pub(super) structure_requested: Cell, pub(super) model: RefCell>, pub(super) queue: RefCell>, pub(super) dispatching: Cell, @@ -111,6 +123,7 @@ impl ObjectImpl for BrowseTab { .param_types([bool::static_type()]) .build(), Signal::builder("save-requested").build(), + Signal::builder("structure-requested").build(), Signal::builder("loading-changed") .param_types([bool::static_type()]) .build(), diff --git a/linux/crates/app/src/ui/browse_tab/layout.rs b/linux/crates/app/src/ui/browse_tab/layout.rs index d4b8ea48e9..ce1e4799bc 100644 --- a/linux/crates/app/src/ui/browse_tab/layout.rs +++ b/linux/crates/app/src/ui/browse_tab/layout.rs @@ -61,8 +61,6 @@ pub(super) fn build(tab: &BrowseTab, init: &LayoutInit<'_>) -> BrowseTabWidgets } } -/// What the bottom bar holds past the tab's breakpoint, where it has no -/// room for it. fn more_menu(page_sizes: &[u64]) -> gio::Menu { let export = gio::MenuItem::new(Some(&gettext("_Export Rows…")), Some("browse.export")); // The window's Export Results key reaches this tab's Export. @@ -80,8 +78,17 @@ fn more_menu(page_sizes: &[u64]) -> gio::Menu { item.set_action_and_target_value(Some("browse.page-size"), Some(&size.to_variant())); sizes.append_item(&item); } + let rows = gio::Menu::new(); + rows.append(Some(&gettext("_Insert Row")), Some("grid.insert-row")); + rows.append(Some(&gettext("_Delete Selected Rows")), Some("grid.delete-rows")); + rows.append(Some(&gettext("_Row Details")), Some("grid.show-details")); + let pages = gio::Menu::new(); + pages.append(Some(&gettext("First _Page")), Some("browse.first-page")); + pages.append(Some(&gettext("_Last Page")), Some("browse.last-page")); let menu = gio::Menu::new(); menu.append_section(None, &actions); + menu.append_section(None, &rows); + menu.append_section(None, &pages); menu.append_section(Some(&gettext("Rows per Page")), &sizes); menu } @@ -159,7 +166,7 @@ pub(super) fn grid(tab: &BrowseTab, init: GridInit) -> DataGrid { grid.set_hexpand(true); let imp = tab.imp(); imp.grid_holder.append(&grid); - imp.action_bar.pack_start(&grid.selection_summary()); + imp.data_start.append(&grid.selection_summary()); let _ = imp.grid.set(grid.clone()); connect_grid(tab, &grid); grid diff --git a/linux/crates/app/src/ui/browse_tab/mod.rs b/linux/crates/app/src/ui/browse_tab/mod.rs index 3992ec5199..c81b355936 100644 --- a/linux/crates/app/src/ui/browse_tab/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/mod.rs @@ -306,6 +306,10 @@ impl BrowseTab { .unwrap_or_default() } + pub fn rename_table(&self, name: &str) { + self.send(DataInput::Renamed(name.to_owned())); + } + pub fn table(&self) -> String { self.read(|model| model.table.clone()).unwrap_or_default() } @@ -388,6 +392,78 @@ impl BrowseTab { self.connect_closure("save-requested", false, glib::closure_local!(move |tab: &Self| f(tab))) } + pub fn connect_structure_requested(&self, f: F) -> glib::SignalHandlerId { + self.connect_closure( + "structure-requested", + false, + glib::closure_local!(move |tab: &Self| f(tab)), + ) + } + + pub fn offer_structure(&self) { + let imp = self.imp(); + imp.view_toggle.set_visible(true); + let tab = self.downgrade(); + imp.view_stack.connect_visible_child_name_notify(move |_| { + if let Some(tab) = tab.upgrade() { + tab.follow_selected_view(); + } + }); + } + + pub fn set_structure(&self, structure: &crate::ui::structure_tab::StructureTab) { + libadwaita::prelude::BinExt::set_child(&*self.imp().structure_host, Some(structure)); + } + + pub fn structure_tab(&self) -> Option { + libadwaita::prelude::BinExt::child(&*self.imp().structure_host)? + .downcast() + .ok() + } + + pub fn shows_structure(&self) -> bool { + self.imp().view_stack.visible_child_name().as_deref() == Some("structure") + } + + fn follow_selected_view(&self) { + let imp = self.imp(); + let structure = self.shows_structure(); + // Finish an open cell before hiding its editor, so close and Save see the draft. + if structure { + self.commit_cell_edit(); + } + if structure && !imp.structure_requested.replace(true) { + self.emit_by_name::<()>("structure-requested", &[]); + } + imp.data_start.set_visible(!structure); + imp.data_end.set_visible(!structure); + let actions = imp.browse_actions.get().filter(|_| !structure); + self.insert_action_group("browse", actions); + if let Some(model) = imp.model.borrow_mut().as_mut() { + model.show_grid_actions(); + } + } + + fn save_selected_view(&self) { + if self.shows_structure() { + if let Some(structure) = self.structure_tab() { + let _ = structure.activate_action("structure.save", None); + } + } else { + let _ = self.activate_action("browse.save", None); + } + } + + fn refresh_selected_view(&self) { + if self.shows_structure() { + if let Some(structure) = self.structure_tab() { + structure.request_refresh(); + } + } else { + self.send(PagingInput::RequestRefresh); + } + } + /// F5 asked the window to read the tab again. pub fn connect_refresh_requested(&self, f: F) -> glib::SignalHandlerId { self.connect_closure( diff --git a/linux/crates/app/src/ui/browse_tab/pager_bar.rs b/linux/crates/app/src/ui/browse_tab/pager_bar.rs index 7a0c71dbd7..b03d64130e 100644 --- a/linux/crates/app/src/ui/browse_tab/pager_bar.rs +++ b/linux/crates/app/src/ui/browse_tab/pager_bar.rs @@ -62,8 +62,6 @@ mod imp { pub count_spinner: TemplateChild, #[template_child] pub count_label: TemplateChild, - /// Below the tab's breakpoint, Count Rows is in the tab's More - /// menu instead. #[property(get, set = Self::set_compact)] compact: Cell, count_offered: Cell, @@ -72,6 +70,8 @@ mod imp { impl PagerBar { fn set_compact(&self, compact: bool) { self.compact.set(compact); + self.first_button.set_visible(!compact); + self.last_button.set_visible(!compact); self.show_count_button(); } @@ -202,6 +202,10 @@ impl PagerBar { ] } + pub(super) fn set_count_enabled(&self, enabled: bool) { + self.turn(&[(self.imp().count_button.get(), enabled)]); + } + /// The rows on the page, Count Rows and Last, which only an exact /// total enables. pub(super) fn show_total(&self, pager: &BrowsePager, shown: Option<&PageState>, total: &RowTotal) { @@ -254,12 +258,21 @@ impl PagerBar { } } - /// The keys for Previous and Next turn a page only where the button - /// would, so the tab's actions follow the buttons, and the buttons - /// announce the actions' keys. - pub(super) fn follow_page_actions(&self, group: &str, previous: &gio::SimpleAction, next: &gio::SimpleAction) { + pub(super) fn follow_page_actions( + &self, + group: &str, + first: &gio::SimpleAction, + previous: &gio::SimpleAction, + next: &gio::SimpleAction, + last: &gio::SimpleAction, + ) { let imp = self.imp(); - for (button, action) in [(&imp.prev_button, previous), (&imp.next_button, next)] { + for (button, action) in [ + (&imp.first_button, first), + (&imp.prev_button, previous), + (&imp.next_button, next), + (&imp.last_button, last), + ] { button .bind_property("sensitive", action, "enabled") .sync_create() @@ -343,18 +356,22 @@ mod tests { fn page_actions_follow_the_buttons_and_announce_their_keys() { let bar = bar(); let imp = bar.imp(); + let first = gio::SimpleAction::new("first-page", None); let previous = gio::SimpleAction::new("previous-page", None); let next = gio::SimpleAction::new("next-page", None); + let last = gio::SimpleAction::new("last-page", None); assert!(!gtk::test_accessible_has_property( &imp.next_button.get(), AccessibleProperty::KeyShortcuts )); - bar.follow_page_actions("browse", &previous, &next); + bar.follow_page_actions("browse", &first, &previous, &next, &last); bar.show_position(&BrowsePager::new(100, 0), 100); + assert!(!first.is_enabled(), "First turned a page before the first"); assert!(!previous.is_enabled(), "Previous turned a page before the first"); assert!(next.is_enabled()); + assert!(!last.is_enabled(), "Last needs an exact total"); for button in [imp.prev_button.get(), imp.next_button.get()] { assert!( gtk::test_accessible_has_property(&button, AccessibleProperty::KeyShortcuts), @@ -365,8 +382,12 @@ mod tests { bar.show_position(&BrowsePager::new(100, 200), 40); + assert!(first.is_enabled()); assert!(previous.is_enabled()); assert!(!next.is_enabled(), "Next turned past the last page"); + bar.set_compact(true); + bar.show_total(&BrowsePager::new(100, 0), Some(&page(0, 100)), &RowTotal::Exact(240)); + assert!(last.is_enabled(), "the menu's Last lost the hidden button's state"); } #[gtk4::test] @@ -501,17 +522,23 @@ mod tests { } #[gtk4::test] - fn a_compact_bar_leaves_count_rows_to_the_menu() { + fn a_compact_bar_leaves_first_last_and_count_rows_to_the_menu() { let bar = bar(); let count = bar.imp().count_button.get(); bar.show_total(&BrowsePager::new(100, 0), Some(&page(0, 100)), &RowTotal::Unknown); bar.set_compact(true); + assert!(!bar.imp().first_button.is_visible()); + assert!(!bar.imp().last_button.is_visible()); + assert!(bar.imp().prev_button.is_visible()); + assert!(bar.imp().next_button.is_visible()); assert!(!count.is_visible()); bar.show_total(&BrowsePager::new(100, 0), Some(&page(0, 100)), &RowTotal::Unknown); assert!(!count.is_visible(), "a new total put Count Rows back on a compact bar"); bar.set_compact(false); + assert!(bar.imp().first_button.is_visible()); + assert!(bar.imp().last_button.is_visible()); assert!(count.is_visible()); } diff --git a/linux/crates/app/src/ui/browse_tab/pending_changes_bar.rs b/linux/crates/app/src/ui/browse_tab/pending_changes_bar.rs index ae47683553..2fe2d7b65f 100644 --- a/linux/crates/app/src/ui/browse_tab/pending_changes_bar.rs +++ b/linux/crates/app/src/ui/browse_tab/pending_changes_bar.rs @@ -214,7 +214,7 @@ mod tests { AccessibleProperty::KeyShortcuts )); - bar.announce_save_keys("browse", &gio::SimpleAction::new("save", None)); + bar.announce_save_keys("table", &gio::SimpleAction::new("save", None)); assert!(gtk::test_accessible_has_property( &save, diff --git a/linux/crates/app/src/ui/browse_tab/row_count.rs b/linux/crates/app/src/ui/browse_tab/row_count.rs index 589b8d2a6d..92fbfeff2e 100644 --- a/linux/crates/app/src/ui/browse_tab/row_count.rs +++ b/linux/crates/app/src/ui/browse_tab/row_count.rs @@ -11,6 +11,9 @@ impl BrowseModel { /// The server's guess at the table's size, which is all the "of N" /// total needs, and which decides whether a count runs on its own. pub(super) fn fetch_estimate(&mut self) { + if self.saving.get() { + return; + } let ticket = self.issue(BrowseRequestKind::Estimate); let session = self.session.clone(); let table = self.table_ref(); @@ -65,6 +68,9 @@ impl BrowseModel { /// Count the rows under the tab's filter. `estimate` shows while it /// runs. pub(super) fn start_count(&mut self, estimate: Option, fx: &mut Effects) { + if self.saving.get() { + return; + } let Some(plan) = self.read_plan() else { return; }; @@ -101,9 +107,15 @@ impl BrowseModel { } } - /// A refresh or a new filter reads other rows than the running count - /// counts, so it stops. A refresh keeps what the count started from; - /// a filter has no total until its own estimate lands. + pub(super) fn stop_total_reads(&mut self) { + // Counts begun before a write cannot replace its adjusted total, even if cancellation arrives late. + self.sequencer.cancel(BrowseRequestKind::Estimate); + self.after_columns.remove(&BrowseRequestKind::Estimate); + self.after_columns.remove(&BrowseRequestKind::Count); + self.failed.record(BrowseRequestKind::Estimate, &Ok::<(), ()>(())); + self.stop_count(true); + } + pub(super) fn stop_count(&mut self, keep_total: bool) { self.sequencer.cancel(BrowseRequestKind::Count); self.total = match (keep_total, &self.total) { @@ -147,8 +159,8 @@ impl BrowseModel { .pager_bar .show_total(&self.pager, self.shown_page(), &self.total); let counting = matches!(self.total, RowTotal::Counting { .. }); - self.actions - .count_rows - .set_enabled(self.shown_page().is_some() && self.total.exact().is_none() && !counting); + let can_count = self.shown_page().is_some() && self.total.exact().is_none() && !counting && !self.saving.get(); + self.actions.count_rows.set_enabled(can_count); + self.widgets.pager_bar.set_count_enabled(can_count); } } diff --git a/linux/crates/app/src/ui/browse_tab/row_total.rs b/linux/crates/app/src/ui/browse_tab/row_total.rs index 5878364946..7e990c930f 100644 --- a/linux/crates/app/src/ui/browse_tab/row_total.rs +++ b/linux/crates/app/src/ui/browse_tab/row_total.rs @@ -1,4 +1,3 @@ -/// What the tab knows of how many rows the table has under its filter. #[derive(Debug, Clone, PartialEq, Eq, Default)] pub(crate) enum RowTotal { #[default] @@ -18,11 +17,11 @@ pub(crate) enum RowTotal { } impl RowTotal { - /// "Rows 1 – 1,000 of 5,000", "of about 5,000,000", or no total. pub(super) fn label_with(&self, start: u64, end: u64, format: impl Fn(u64) -> String) -> String { + let last = end; let (start, end) = (format(start), format(end)); match self { - Self::Exact(total) => crate::i18n::gettext_f( + Self::Exact(total) if *total >= last => crate::i18n::gettext_f( "Rows {start} – {end} of {total}", &[("start", &start), ("end", &end), ("total", &format(*total))], ), @@ -33,13 +32,12 @@ impl RowTotal { | Self::Unavailable { estimate: Some(estimate), .. - } => crate::i18n::gettext_f( + } if *estimate >= last => crate::i18n::gettext_f( "Rows {start} – {end} of about {total}", &[("start", &start), ("end", &end), ("total", &format(*estimate))], ), - Self::Unknown | Self::Counting { estimate: None } | Self::Unavailable { estimate: None, .. } => { - crate::i18n::gettext_f("Rows {start} – {end}", &[("start", &start), ("end", &end)]) - } + // Separate reads can describe different snapshots; the range comes from the rows on screen. + _ => crate::i18n::gettext_f("Rows {start} – {end}", &[("start", &start), ("end", &end)]), } } @@ -50,7 +48,6 @@ impl RowTotal { } } - /// The estimate a count started from, or the total it replaces. pub(crate) fn estimate(&self) -> Option { match self { Self::Exact(total) | Self::Estimated(total) => Some(*total), @@ -59,9 +56,7 @@ impl RowTotal { } } - /// A committed save moved the total by what it inserted and deleted. - /// Under a filter, an inserted or updated row may not match it, so - /// an exact total becomes an estimate there. + // Under a filter, an inserted or updated row may no longer match. pub(crate) fn adjust_after_save(&mut self, inserted: u64, deleted: u64, filtered: bool) { let moved = |total: u64| total.saturating_add(inserted).saturating_sub(deleted); *self = match std::mem::take(self) { @@ -115,6 +110,21 @@ mod tests { ); } + #[test] + fn totals_older_than_the_displayed_range_are_omitted() { + for total in [ + RowTotal::Exact(2), + RowTotal::Estimated(2), + RowTotal::Counting { estimate: Some(2) }, + RowTotal::Unavailable { + estimate: Some(2), + reason: "Stopped.".to_owned(), + }, + ] { + assert_eq!(label(&total, 1, 3), "Rows 1 – 3", "{total:?}"); + } + } + #[test] fn adjust_after_save_keeps_exact_only_when_unfiltered() { let mut unfiltered = RowTotal::Exact(100); diff --git a/linux/crates/app/src/ui/browse_tab/save_handlers.rs b/linux/crates/app/src/ui/browse_tab/save_handlers.rs index e740530b93..4f31634854 100644 --- a/linux/crates/app/src/ui/browse_tab/save_handlers.rs +++ b/linux/crates/app/src/ui/browse_tab/save_handlers.rs @@ -14,11 +14,14 @@ impl BrowseModel { } SaveInput::SaveStarted => { self.show_saving(true); + self.stop_total_reads(); // Starting the save took a failed row's mark off. self.grid.redraw(); } SaveInput::StopSaving => fx.output(BrowseTabOutput::StopSaveRequested), SaveInput::ConfirmDiscard => self.confirm_discard(), + SaveInput::DiscardAll | SaveInput::DiscardAndRefresh + if self.tracker.pending_state() == crate::workspace::PendingState::Saving => {} SaveInput::DiscardAll => { self.discard(); self.fetch(BrowseRequestKind::Page, fx); @@ -47,21 +50,30 @@ impl BrowseModel { fn confirm_discard(&self) { self.grid.commit_edit(); let pending = self.tracker.pending_count(); - if pending == 0 { + if pending == 0 && self.tracker.pending_state() == crate::workspace::PendingState::Clean { return; } let tab = self.this.clone(); - confirm_discard(&self.widgets.inner_stack, pending, move || { - if let Some(tab) = tab.upgrade() { - tab.send(SaveInput::DiscardAll); - } - }); + confirm_discard( + &self.widgets.inner_stack, + pending, + { + let tracker = self.tracker.clone(); + move || tracker.pending_state() + }, + move || { + if let Some(tab) = tab.upgrade() { + tab.send(SaveInput::DiscardAll); + } + }, + ); } /// The tracker already let go of what the save wrote, and the page /// read next replaces every row. The rows are not drawn again before /// it lands: a saved draft would draw empty. fn save_committed(&mut self, origins: &ChangeOrigins, fx: &mut Effects) { + self.stop_total_reads(); self.show_saving(false); self.sync_pending_chrome(self.tracker.pending_count(), fx); // The save says how the total moved, so nothing is counted @@ -86,6 +98,7 @@ impl BrowseModel { /// cannot send two, and Stop Saving takes their place. fn show_saving(&self, saving: bool) { self.saving.set(saving); + self.sync_total_chrome(); self.follow_tracker(); self.widgets.pending_bar.show_saving(saving); } diff --git a/linux/crates/app/src/ui/browse_tab/tests/mod.rs b/linux/crates/app/src/ui/browse_tab/tests/mod.rs index bd806d6088..73c7f5278d 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/mod.rs @@ -1203,7 +1203,7 @@ fn refresh_asks_the_window_and_filter_opens_the_strip() { harness .tab() - .activate_action("browse.refresh", None) + .activate_action("table.refresh", None) .expect("the browse group"); harness .tab() @@ -1261,6 +1261,72 @@ fn a_read_only_tab_refuses_insert_row() { assert_eq!(harness.tracker.pending_count(), 0, "a read-only table took a new row"); } +#[gtk4::test] +fn the_compact_menu_reaches_row_commands_only_in_data() { + use gtk4::subclass::prelude::ObjectSubclassIsExt; + let mut script = serving_table(); + script.query_bound.always(FakeReply::ok(rows(&["Ada"]))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + tab.offer_structure(); + let shown = Shown::new(tab); + let imp = tab.imp(); + wait_until(WAIT, || harness.shown().len() == 1 && imp.more_button.is_mapped()).expect("the compact Data bar"); + assert!(!imp.insert_button.is_mapped()); + assert!(!imp.delete_button.is_mapped()); + assert!(!imp.details_toggle.is_mapped()); + assert!(!imp.pager_bar.imp().first_button.is_visible()); + assert!(!imp.pager_bar.imp().last_button.is_visible()); + let menu = imp.more_button.menu_model().expect("the overflow menu"); + let actions: Vec = (0..menu.n_items()) + .filter_map(|index| menu.item_link(index, "section")) + .flat_map(|section| { + (0..section.n_items()) + .filter_map(|index| { + section + .item_attribute_value(index, "action", None) + .and_then(|value| value.get::()) + }) + .collect::>() + }) + .collect(); + for action in [ + "grid.insert-row", + "grid.delete-rows", + "grid.show-details", + "browse.first-page", + "browse.last-page", + ] { + assert!(actions.iter().any(|found| found == action), "missing {action}"); + } + imp.more_button.activate_action("grid.insert-row", None).unwrap(); + drain_main_context(); + assert_eq!(harness.tracker.pending_count(), 1); + imp.more_button.activate_action("grid.show-details", None).unwrap(); + assert_eq!( + harness + .grid() + .actions() + .action_state("show-details") + .and_then(|state| state.get::()), + Some(true) + ); + + imp.view_stack.set_visible_child_name("structure"); + assert!(imp.more_button.activate_action("grid.insert-row", None).is_err()); + assert!(imp.more_button.activate_action("browse.last-page", None).is_err()); + assert_eq!(harness.tracker.pending_count(), 1); + + imp.view_stack.set_visible_child_name("data"); + shown.0.set_size_request(1_000, 400); + wait_until(WAIT, || imp.insert_button.is_mapped() && !imp.more_button.is_mapped()) + .expect("the wide Data bar restores its controls"); + assert!(imp.details_toggle.is_mapped()); + assert!(imp.pager_bar.imp().first_button.is_visible()); + assert!(imp.pager_bar.imp().last_button.is_visible()); + assert!(imp.view_toggle.is_mapped()); +} + #[gtk4::test] fn browse_buttons_announce_their_keys() { use gtk4::subclass::prelude::ObjectSubclassIsExt; @@ -1555,6 +1621,93 @@ fn a_dotted_field_of_a_document_neither_sorts_nor_takes_an_edit() { assert_eq!(harness.tracker.pending_count(), 0); } +#[gtk4::test] +fn the_bottom_bar_switches_between_data_and_structure() { + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let harness = Harness::open(serving_table(), []); + let tab = harness.tab(); + let shown = Shown::new(tab); + let asked = std::rc::Rc::new(std::cell::Cell::new(0)); + let counted = asked.clone(); + tab.connect_structure_requested(move |_| counted.set(counted.get() + 1)); + tab.offer_structure(); + let imp = tab.imp(); + wait_until(WAIT, || shown.0.is_mapped()).expect("the window is mapped"); + tab.send(PagingInput::ShowFilterStrip); + assert!(imp.view_toggle.is_visible()); + assert!(imp.view_toggle.child_focus(gtk4::DirectionType::TabForward)); + assert!(crate::ui::a11y::holds_focus(&imp.view_toggle.get())); + let tabs: Vec<_> = crate::test_support::descendants(&imp.view_toggle.get()) + .into_iter() + .filter(|widget| widget.accessible_role() == gtk4::AccessibleRole::Tab) + .collect(); + assert_eq!(tabs.len(), 2); + assert!(tabs[1].activate()); + wait_until(WAIT, || tab.shows_structure()).expect("keyboard activation selects Structure"); + assert_eq!(asked.get(), 1); + assert!(!imp.data_start.is_visible()); + wait_until(WAIT, || !imp.toolbar.is_mapped()).expect("the Data toolbar is hidden"); + assert!(tab.activate_action("browse.filter", None).is_err()); + imp.view_stack.set_visible_child_name("data"); + imp.view_stack.set_visible_child_name("structure"); + assert_eq!(asked.get(), 1, "lazy construction was requested twice before delivery"); + imp.view_stack.set_visible_child_name("data"); + wait_until(WAIT, || imp.toolbar.is_mapped()).expect("the Data toolbar returns"); + assert!(imp.data_start.is_visible()); + assert!(tab.read(|model| model.filter_strip.revealed()).unwrap()); + drop(shown); +} + +#[gtk4::test] +fn table_commands_follow_the_selected_view_from_the_switch_and_controls() { + use crate::ui::structure_tab::{ColumnsInput, StructureMode, StructureTab, StructureTabInit}; + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let mut script = serving_table(); + script.dialect = Arc::new(tablepro_driver_postgres::PgDialect::new( + &tablepro_core::ServerInfo::new("PostgreSQL", "18.0", 18, 0, 0), + )); + script.query_bound.always(FakeReply::ok(rows(&["Ada", "Grace"]))); + let harness = Harness::open(script, []); + let tab = harness.tab(); + let shown = Shown::new(tab); + wait_until(WAIT, || harness.shown().len() == 2).expect("the rows"); + let delta = harness.tracker.apply(rename(0, "Ada", "Edited")); + harness.grid().apply_delta(&delta); + tab.send(GridInput::EditingChanged); + tab.offer_structure(); + let structure = StructureTab::new(StructureTabInit { + tracker: crate::services::structure_tracker_handle::StructureTrackerHandle::default(), + schema: None, + table: "new_table".into(), + mode: StructureMode::New, + session: harness.session.clone(), + tasks: harness.runtime.as_ref().unwrap().tasks(), + first_load: crate::ui::tab_load::FirstLoad::Now, + }); + structure.send(ColumnsInput::AddColumn); + tab.set_structure(&structure); + let row_saves = crate::test_support::SignalLog::connect(tab, "save-requested", |_| ()); + let schema_saves = crate::test_support::SignalLog::connect(&structure, "save-requested", |_| ()); + let row_refreshes = crate::test_support::SignalLog::connect(tab, "refresh-requested", |_| ()); + tab.imp().view_stack.set_visible_child_name("structure"); + assert!(tab.imp().view_toggle.child_focus(gtk4::DirectionType::TabForward)); + tab.imp().view_toggle.activate_action("table.save", None).unwrap(); + assert_eq!(schema_saves.count(), 1); + assert_eq!(row_saves.count(), 0); + assert!(tab.activate_action("grid.insert-row", None).is_err()); + tab.imp().view_toggle.activate_action("table.refresh", None).unwrap(); + assert_eq!(row_refreshes.count(), 0); + assert_eq!(harness.tracker.pending_count(), 1); + tab.imp().view_stack.set_visible_child_name("data"); + tab.activate_action("table.save", None).unwrap(); + assert_eq!(row_saves.count(), 1); + assert_eq!(schema_saves.count(), 1); + structure.shutdown(); + drop(shown); +} + #[gtk4::test] fn the_paginator_says_how_long_the_page_took() { use gtk4::subclass::prelude::ObjectSubclassIsExt; diff --git a/linux/crates/app/src/ui/browse_tab/tests/save.rs b/linux/crates/app/src/ui/browse_tab/tests/save.rs index a7f4a5d48d..b6ff4d52ec 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/save.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/save.rs @@ -77,7 +77,7 @@ fn a_refresh_counts_what_is_typed_in_an_open_editor() { harness .tab() - .activate_action("browse.refresh", None) + .activate_action("table.refresh", None) .expect("the browse group"); assert_eq!(refreshes.count(), 1); diff --git a/linux/crates/app/src/ui/browse_tab/tests/total.rs b/linux/crates/app/src/ui/browse_tab/tests/total.rs index e71f3d4cf0..e7501e574c 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/total.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/total.rs @@ -400,3 +400,106 @@ fn count_rows_under_a_filter_that_no_longer_fits_says_why() { assert_eq!(count_button(&harness).tooltip_text(), banner.tooltip_text()); assert_eq!(count_calls(&harness), 0); } + +#[gtk4::test] +fn independent_page_and_count_reads_never_show_a_total_below_the_range() { + for count_first in [false, true] { + let mut script = estimated(RowCountEstimate::Approximate(40)); + script.query_bound = Default::default(); + script.count_rows = Default::default(); + let result = rows(&["Ada", "Grace", "Linus"]); + if count_first { + script.query_bound.always(FakeReply::Late { + after: Duration::from_millis(100), + outcome: Ok(result), + }); + script.count_rows.always(FakeReply::ok(2)); + } else { + script.query_bound.always(FakeReply::ok(result)); + script.count_rows.always(FakeReply::Late { + after: Duration::from_millis(100), + outcome: Ok(2), + }); + } + let harness = Harness::open(script, []); + wait_until(WAIT, || { + harness.shown().len() == 3 && !count_button(&harness).is_visible() + }) + .expect("both page and count have landed"); + + assert_eq!(paginator(&harness), "Rows 1 – 3"); + } +} + +#[gtk4::test] +fn deleting_rows_does_not_pair_the_old_page_with_a_smaller_total() { + let mut script = estimated(RowCountEstimate::Approximate(40)); + script.query_bound = Default::default(); + script + .query_bound + .once(FakeReply::ok(rows(&["Ada", "Grace"]))) + .always(FakeReply::err(DriverError::server("refresh failed"))); + let harness = Harness::open(script, []); + wait_until(WAIT, || paginator(&harness) == "Rows 1 – 2 of 2").expect("the original page and total"); + + harness + .tab() + .send(SaveInput::SaveCommitted(ChangeOrigins { inserts: 0, deletes: 1 })); + + assert_eq!(paginator(&harness), "Rows 1 – 2"); + wait_until(WAIT, || harness.tab().imp().stale_banner.is_revealed()).expect("the failed refresh"); + assert_eq!(paginator(&harness), "Rows 1 – 2"); +} + +#[gtk4::test] +fn a_count_started_before_saving_cannot_replace_the_adjusted_total() { + let mut script = estimated(RowCountEstimate::Approximate(40)); + script.count_rows = Default::default(); + script.count_rows.always(FakeReply::Late { + after: Duration::from_millis(300), + outcome: Ok(999), + }); + let harness = Harness::open(script, []); + wait_until(WAIT, || count_calls(&harness) == 1 && harness.shown().len() == 2) + .expect("the count is running beside the loaded page"); + + harness.tab().send(SaveInput::SaveStarted); + assert_eq!(count_label(&harness), "Count Rows"); + assert!(!count_button(&harness).is_sensitive()); + harness.tab().send(PagingInput::CountRows); + harness + .tab() + .send(SaveInput::SaveCommitted(ChangeOrigins { inserts: 1, deletes: 0 })); + std::thread::sleep(Duration::from_millis(400)); + drain_main_context(); + + assert_eq!(paginator(&harness), "Rows 1 – 2 of about 41"); + assert_eq!(count_calls(&harness), 1); + assert!(count_button(&harness).is_sensitive()); +} + +#[gtk4::test] +fn an_estimate_started_before_saving_cannot_restore_an_old_total() { + let mut script = estimated(RowCountEstimate::Unknown); + script.table_estimate = Default::default(); + script.table_estimate.always(FakeReply::Late { + after: Duration::from_millis(300), + outcome: Ok(estimate(RowCountEstimate::Exact(2))), + }); + let harness = Harness::open(script, []); + wait_until(WAIT, || { + CallCounters::get(&harness.connection.counters().table_estimate) == 1 && harness.shown().len() == 2 + }) + .expect("the estimate is running beside the loaded page"); + + harness.tab().send(SaveInput::SaveStarted); + harness + .tab() + .send(SaveInput::SaveCommitted(ChangeOrigins { inserts: 1, deletes: 0 })); + std::thread::sleep(Duration::from_millis(400)); + drain_main_context(); + + assert_eq!(paginator(&harness), "Rows 1 – 2"); + assert!(count_button(&harness).is_sensitive()); + assert_eq!(count_calls(&harness), 0); +} diff --git a/linux/crates/app/src/ui/data_grid/columns.rs b/linux/crates/app/src/ui/data_grid/columns.rs index 5c416d7fba..66ec7fadd3 100644 --- a/linux/crates/app/src/ui/data_grid/columns.rs +++ b/linux/crates/app/src/ui/data_grid/columns.rs @@ -142,7 +142,7 @@ impl DataGrid { while let Some(column) = view.columns().item(0).and_downcast::() { view.remove_column(&column); } - let layout = match self.config().and_then(|config| config.layout.as_ref()) { + let layout = match self.config().and_then(|config| config.layout.clone()) { Some(binding) => binding.load(), None if same_names(&old_layout, &columns) => old_layout, None => ColumnLayout::default(), @@ -568,7 +568,7 @@ impl DataGrid { )); } if layout != before - && let Some(binding) = self.config().and_then(|config| config.layout.as_ref()) + && let Some(binding) = self.config().and_then(|config| config.layout.clone()) { binding.save(&layout.rebased(&before, &binding.load())); } @@ -719,7 +719,7 @@ impl DataGrid { set.layout = ColumnLayout::default(); (set.columns.clone(), set.sorting()) }; - if let Some(binding) = self.config().and_then(|config| config.layout.as_ref()) { + if let Some(binding) = self.config().and_then(|config| config.layout.clone()) { binding.save(&ColumnLayout::default()); } let rows: Vec<_> = self.store().rows().map(|row| row.data()).collect(); diff --git a/linux/crates/app/src/ui/data_grid/copy/tests.rs b/linux/crates/app/src/ui/data_grid/copy/tests.rs index ba7573fda6..8a46da5545 100644 --- a/linux/crates/app/src/ui/data_grid/copy/tests.rs +++ b/linux/crates/app/src/ui/data_grid/copy/tests.rs @@ -539,6 +539,25 @@ fn copy_as_insert_writes_the_columns_on_screen_with_pending_edits() { ); } +#[gtk4::test] +fn renaming_the_table_keeps_edits_and_selection_in_insert_copies() { + let grid = sql_grid(people(), people_rows(), Arc::new(FakeDialect)); + grid.grid.set_column_visible(2, false); + grid.grid + .apply_delta(&rename(&grid.tracker, 2, "Grace", "Grace Hopper")); + select_all(&grid); + + grid.grid.rename_table("members"); + let text = copied(&grid, || activate(&grid.grid, "copy-insert")); + + assert_eq!(grid.tracker.pending_count(), 1); + assert_eq!( + text, + "INSERT INTO \"members\" (\"id\", \"name\") VALUES (1, 'Ada');\n\ + INSERT INTO \"members\" (\"id\", \"name\") VALUES (2, 'Grace Hopper');" + ); +} + #[gtk4::test] fn copy_as_insert_on_a_draft_leaves_what_the_server_fills_out() { let mut id = named("id", "integer", true); diff --git a/linux/crates/app/src/ui/data_grid/grid_menu.rs b/linux/crates/app/src/ui/data_grid/grid_menu.rs index 17a54897ae..e61edcf694 100644 --- a/linux/crates/app/src/ui/data_grid/grid_menu.rs +++ b/linux/crates/app/src/ui/data_grid/grid_menu.rs @@ -114,8 +114,10 @@ fn popover(grid: &DataGrid, model: &gio::Menu) -> gtk::PopoverMenu { fn cell_menu(grid: &DataGrid, references: &gio::Menu, expressions: &gio::Menu) -> gio::Menu { let config = grid.config(); - let editable = config.is_some_and(|config| config.tracker.is_some()); - let sorts = config.is_some_and(|config| config.sorting != GridSorting::None); + let editable = config.as_ref().is_some_and(|config| config.tracker.is_some()); + let sorts = config + .as_ref() + .is_some_and(|config| config.sorting != GridSorting::None); let menu = gio::Menu::new(); if editable { let edits = presets_section(); @@ -160,7 +162,7 @@ fn cell_menu(grid: &DataGrid, references: &gio::Menu, expressions: &gio::Menu) - clipboard.append_item(&item(&gettext("_Paste"), "grid.paste")); } menu.append_section(None, &clipboard); - if config.is_some_and(|config| config.filter_by_value) { + if config.as_ref().is_some_and(|config| config.filter_by_value) { menu.append_section( None, §ion([ diff --git a/linux/crates/app/src/ui/data_grid/imp.rs b/linux/crates/app/src/ui/data_grid/imp.rs index 10275e0d52..feb729681c 100644 --- a/linux/crates/app/src/ui/data_grid/imp.rs +++ b/linux/crates/app/src/ui/data_grid/imp.rs @@ -61,7 +61,7 @@ pub struct DataGrid { #[template_child] pub detail_pane: TemplateChild, - pub config: OnceCell, + pub config: RefCell>, pub store: GridStore, pub selection: Selection, /// Set for a grid that sorts the rows it holds. diff --git a/linux/crates/app/src/ui/data_grid/mod.rs b/linux/crates/app/src/ui/data_grid/mod.rs index 70d3a25ddd..e5754e809c 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -79,7 +79,7 @@ impl DataGrid { let rules = config.rules.clone(); imp.column_view .update_property(&[gtk::accessible::Property::Label(&config.label)]); - let _ = imp.config.set(config); + imp.config.replace(Some(config)); grid.build_models(); imp.edit.attach(&grid); grid.insert_action_group("grid", Some(&imp.actions)); @@ -98,8 +98,41 @@ impl DataGrid { } /// `None` only inside `glib::Object::new`, before `new` sets it. - pub(crate) fn config(&self) -> Option<&GridConfig> { - self.imp().config.get() + pub(crate) fn config(&self) -> Option> { + std::cell::Ref::filter_map(self.imp().config.borrow(), Option::as_ref).ok() + } + + pub(crate) fn rename_table(&self, name: &str) { + let imp = self.imp(); + let renamed = { + let mut config = imp.config.borrow_mut(); + let Some(config) = config.as_mut() else { + return; + }; + let Some(table) = config.table.as_mut() else { + return; + }; + table.name = name.to_owned(); + config.label = match table.schema.as_deref() { + Some(schema) => format!("{schema}.{name}"), + None => name.to_owned(), + }; + if let Some(binding) = config.layout.as_mut() { + binding.table = name.to_owned(); + } + if let Some(keys) = config.references.as_ref() { + keys.set(TableKeys::none(table.clone())); + } + (config.label.clone(), config.layout.clone()) + }; + self.arm_references(None); + self.keys_changed(); + imp.column_view + .update_property(&[gtk::accessible::Property::Label(&renamed.0)]); + // A metadata refresh rebuilds columns from this key, so preserve their current arrangement. + if let Some(binding) = renamed.1 { + binding.save(imp.columns.borrow().layout()); + } } /// The connection's dialect, where the rows have an SQL spelling. diff --git a/linux/crates/app/src/ui/data_grid/references/mod.rs b/linux/crates/app/src/ui/data_grid/references/mod.rs index a5203f1b90..a55f681954 100644 --- a/linux/crates/app/src/ui/data_grid/references/mod.rs +++ b/linux/crates/app/src/ui/data_grid/references/mod.rs @@ -206,8 +206,7 @@ fn add_choice(grid: &DataGrid, name: &str, act: impl Fn(&DataGrid, usize) + 'sta fn offers(grid: &DataGrid, row: &GridRow, column: usize) -> Offers { let Some(keys) = grid .config() - .and_then(|config| config.references.as_ref()) - .map(KeysHandle::get) + .and_then(|config| config.references.as_ref().map(KeysHandle::get)) else { return Offers::default(); }; diff --git a/linux/crates/app/src/ui/data_grid/row_detail/fields.rs b/linux/crates/app/src/ui/data_grid/row_detail/fields.rs index ce300f2e15..b06cfdb1c5 100644 --- a/linux/crates/app/src/ui/data_grid/row_detail/fields.rs +++ b/linux/crates/app/src/ui/data_grid/row_detail/fields.rs @@ -328,7 +328,11 @@ impl RowDetailPane { if wanted.is_empty() || column.name.to_lowercase().contains(&wanted) { return true; } - let value = field_value(&grid.tracked(), &row, &column); + let Some(config) = grid.config() else { + return false; + }; + let preferences = config.settings.grid_preferences().snapshot(); + let value = field_value(&grid.tracked(), &row, &column, &preferences.null_display); !value.null && value.text.to_lowercase().contains(&wanted) } diff --git a/linux/crates/app/src/ui/data_grid/tests/columns.rs b/linux/crates/app/src/ui/data_grid/tests/columns.rs index 6858622954..b03a7c5e21 100644 --- a/linux/crates/app/src/ui/data_grid/tests/columns.rs +++ b/linux/crates/app/src/ui/data_grid/tests/columns.rs @@ -130,6 +130,35 @@ fn a_width_set_from_the_keyboard_comes_back_at_that_width() { wait_until(WAIT, || shown_width(&grid, 1) == saved).expect("the column drawn at its saved width"); } +#[gtk4::test] +fn renaming_the_table_keeps_column_layout_under_the_new_name() { + let layouts = Layouts::new(); + let grid = laid_out(Grid::build( + GridSpec { + layout: Some(layouts.binding("t")), + table: Some(tablepro_core::meta::TableRef::new(Some("public".to_owned()), "t")), + ..GridSpec::table(two_text_columns()) + }, + keyed(&[1, 2]), + )); + data_column(&grid, 1).set_fixed_width(200); + let old_layout = layouts.saved("t"); + + grid.grid.rename_table("members"); + + assert_eq!(layouts.saved("members"), old_layout); + data_column(&grid, 1).set_fixed_width(240); + assert_eq!(layouts.saved("members").widths.get("name"), Some(&240)); + assert_eq!(layouts.saved("t"), old_layout); + grid.grid.set_columns( + grid.columns.clone(), + super::super::GridSorting::Server { initial: None }, + None, + ); + assert_eq!(data_column(&grid, 1).fixed_width(), 240); + assert_eq!(grid.grid.config().expect("configured grid").label, "public.members"); +} + /// GtkColumnView's header drag sets the fixed width and nothing else, as /// this does. #[gtk4::test] diff --git a/linux/crates/app/src/ui/discard_alert.rs b/linux/crates/app/src/ui/discard_alert.rs index 27fb6d3ad2..9172b71368 100644 --- a/linux/crates/app/src/ui/discard_alert.rs +++ b/linux/crates/app/src/ui/discard_alert.rs @@ -1,32 +1,60 @@ +use std::rc::Rc; + use gtk4 as gtk; use gtk4::prelude::*; use libadwaita as adw; use libadwaita::prelude::*; -/// Ask before Discard drops a tab's pending changes. The undo history -/// goes with them, so the alert is the only chance to keep them. +use crate::workspace::PendingState; + pub(crate) fn confirm_discard( parent: &impl IsA, pending: usize, + state: impl Fn() -> PendingState + 'static, discard: impl Fn() + 'static, -) -> adw::AlertDialog { - let body = crate::i18n::ngettext_f( - "{n} unsaved change on this tab will be lost, and Undo cannot bring it back.", - "{n} unsaved changes on this tab will be lost, and Undo cannot bring them back.", - pending, - &[("n", &pending.to_string())], - ); +) { + present(parent.as_ref(), pending, Rc::new(state), Rc::new(discard)); +} + +fn present(parent: >k::Widget, pending: usize, state: Rc PendingState>, discard: Rc) { + let current = state(); + if current == PendingState::Saving { + return; + } + let unknown = matches!(current, PendingState::OutcomeUnknown(_)); + let body = if unknown { + crate::i18n::gettext( + "The last save may have changed the database. Discarding this draft does not undo changes already saved.", + ) + } else { + crate::i18n::ngettext_f( + "{n} unsaved change on this tab will be lost, and Undo cannot bring it back.", + "{n} unsaved changes on this tab will be lost, and Undo cannot bring them back.", + pending, + &[("n", &pending.to_string())], + ) + }; let dialog = adw::AlertDialog::new(Some(&crate::i18n::gettext("Discard Changes?")), Some(&body)); dialog.add_response("cancel", &crate::i18n::gettext("Cancel")); dialog.add_response("discard", &crate::i18n::gettext("Discard")); dialog.set_response_appearance("discard", adw::ResponseAppearance::Destructive); dialog.set_default_response(Some("cancel")); dialog.set_close_response("cancel"); + let weak = parent.downgrade(); dialog.connect_response(None, move |_, response| { - if response == "discard" { - discard(); + if response != "discard" { + return; + } + match state() { + PendingState::Saving => {} + PendingState::OutcomeUnknown(_) if !unknown => { + // A save can settle while the prompt is open; its first warning no longer applies. + if let Some(parent) = weak.upgrade() { + present(&parent, pending, state.clone(), discard.clone()); + } + } + _ => discard(), } }); dialog.present(Some(parent)); - dialog } diff --git a/linux/crates/app/src/ui/editor/result_editing.rs b/linux/crates/app/src/ui/editor/result_editing.rs index 505691f281..f816e5408b 100644 --- a/linux/crates/app/src/ui/editor/result_editing.rs +++ b/linux/crates/app/src/ui/editor/result_editing.rs @@ -181,13 +181,24 @@ impl SqlEditor { return true; } let editor = self.downgrade(); - confirm_discard(self, pending.max(1), move || { - if let Some(editor) = editor.upgrade() { - // The run about to start replaces these rows, so they are not read again first. - editor.drop_rows(); - then(&editor); - } - }); + confirm_discard( + self, + pending.max(1), + move || tracker.pending_state(), + move || { + if let Some(editor) = editor.upgrade() { + if editor + .row_tracker() + .is_some_and(|tracker| tracker.pending_state() == PendingState::Saving) + { + return; + } + // The run about to start replaces these rows, so they are not read again first. + editor.drop_rows(); + then(&editor); + } + }, + ); false } @@ -465,11 +476,16 @@ impl SqlEditor { return; } let editor = self.downgrade(); - confirm_discard(self, pending, move || { - if let Some(editor) = editor.upgrade() { - editor.discard_rows(); - } - }); + confirm_discard( + self, + pending, + move || tracker.pending_state(), + move || { + if let Some(editor) = editor.upgrade() { + editor.discard_rows(); + } + }, + ); } // The owner's grid, built or not; the tracker's changes are drawn by no other. @@ -480,6 +496,12 @@ impl SqlEditor { // After a save whose outcome is unknown the rows on screen may not be what the table holds, so they are read again. fn discard_rows(&self) { + if self + .row_tracker() + .is_some_and(|tracker| tracker.pending_state() == PendingState::Saving) + { + return; + } let unknown = self .row_tracker() .is_some_and(|tracker| matches!(tracker.pending_state(), PendingState::OutcomeUnknown(_))); diff --git a/linux/crates/app/src/ui/structure_tab/load_handlers.rs b/linux/crates/app/src/ui/structure_tab/load_handlers.rs index 1229452003..eae4adf6db 100644 --- a/linux/crates/app/src/ui/structure_tab/load_handlers.rs +++ b/linux/crates/app/src/ui/structure_tab/load_handlers.rs @@ -9,7 +9,7 @@ use super::context::CharacterSets; use super::draft_column_object::DraftColumnObject; use super::structure_fetch::fetch_structure; use super::{ - LoadInput, LoadedStructure, StructureCommand, StructureEffects, StructureMode, StructureModel, + LoadInput, LoadedStructure, SaveInput, StructureCommand, StructureEffects, StructureMode, StructureModel, StructureRequestKind, StructureTabOutput, items, replace_items, }; use crate::runtime::{RequestTicket, Stamped}; @@ -38,7 +38,7 @@ impl StructureModel { } } } - LoadInput::Retry => self.read_definition(fx), + LoadInput::Retry => fx.input(SaveInput::RequestRefresh), } } @@ -68,6 +68,9 @@ impl StructureModel { } } self.widgets.stale_banner.show(presentation.stale.as_ref()); + self.sync_editable(); + let pending = self.pending(); + self.refresh_buttons(pending.change_count(), pending.typed_values_hold()); if self.tab_loading != presentation.tab_loading { self.tab_loading = presentation.tab_loading; fx.output(StructureTabOutput::LoadingChanged(presentation.tab_loading)); @@ -221,7 +224,11 @@ impl StructureModel { fn retry_failed(&mut self, fx: &mut StructureEffects) { let failed = self.failed.take(); if failed.contains(&StructureRequestKind::Definition) { - self.read_definition(fx); + if self.last_dirty || self.tracker.is_saving() { + self.definition_stale = true; + } else { + self.read_definition(fx); + } } if failed.contains(&StructureRequestKind::CharacterSets) { self.read_character_sets(); diff --git a/linux/crates/app/src/ui/structure_tab/mod.rs b/linux/crates/app/src/ui/structure_tab/mod.rs index 8b51903e37..c382790e37 100644 --- a/linux/crates/app/src/ui/structure_tab/mod.rs +++ b/linux/crates/app/src/ui/structure_tab/mod.rs @@ -296,9 +296,10 @@ impl StructureTab { imp.dispatching.set(false); } - /// Stop the read the tab has running and stop following reconnects - /// now, rather than at dispose, which waits for the last reference - /// to the widget. + pub fn request_refresh(&self) { + self.send(SaveInput::RequestRefresh); + } + pub fn shutdown(&self) { let imp = self.imp(); imp.link_watch.take(); diff --git a/linux/crates/app/src/ui/structure_tab/save_handlers.rs b/linux/crates/app/src/ui/structure_tab/save_handlers.rs index 3ecc867e68..48c609e374 100644 --- a/linux/crates/app/src/ui/structure_tab/save_handlers.rs +++ b/linux/crates/app/src/ui/structure_tab/save_handlers.rs @@ -1,5 +1,6 @@ use gtk4 as gtk; use gtk4::prelude::*; +use libadwaita::prelude::*; use tablepro_core::ddl::TableDraft; use super::save_gate::SaveGate; @@ -15,15 +16,42 @@ impl StructureModel { pub(super) fn on_save(&mut self, input: SaveInput, fx: &mut StructureEffects) { match input { SaveInput::Save => self.save(fx), + SaveInput::RequestRefresh => self.request_refresh(fx), + SaveInput::DiscardAndReload { acknowledged_unknown } => { + if !acknowledged_unknown + && matches!( + self.tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + ) + { + fx.input(SaveInput::RequestRefresh); + } else if !self.saving && !self.tracker.is_saving() { + fx.input(SaveInput::Discard); + fx.input(SaveInput::Reload); + } + } SaveInput::SaveStarted => self.show_saving(true), SaveInput::StopSaving => fx.output(StructureTabOutput::StopSaveRequested), SaveInput::ConfirmDiscard => { let pending = self.pending().change_count(); - if pending > 0 { + if pending > 0 + || matches!( + self.tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + ) + { let sender = StructureTabSender { tab: self.this.clone() }; - confirm_discard(&self.widgets.inner_stack, pending, move || { - sender.input(SaveInput::Discard); - }); + confirm_discard( + &self.widgets.inner_stack, + pending, + { + let tracker = self.tracker.clone(); + move || tracker.pending_state() + }, + move || { + sender.input(SaveInput::Discard); + }, + ); } } SaveInput::Reload => { @@ -34,6 +62,7 @@ impl StructureModel { StructureMode::New => fx.input(SaveInput::Discard), } } + SaveInput::Discard if self.tracker.is_saving() => {} SaveInput::Discard => { // This also lets go of a save whose outcome was unknown. self.tracker.clear(); @@ -82,7 +111,54 @@ impl StructureModel { } } + fn request_refresh(&mut self, fx: &mut StructureEffects) { + if self.saving || self.tracker.is_saving() || self.load.is_running() { + return; + } + if self.refetching { + fx.input(SaveInput::Reload); + return; + } + let unknown = matches!( + self.tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + ); + if !unknown && self.pending().change_count() == 0 { + fx.input(SaveInput::Reload); + return; + } + let body = if unknown { + crate::i18n::gettext( + "The last save may have changed the database. Reload to read its current structure and discard this draft.", + ) + } else { + crate::i18n::gettext( + "Refreshing reloads the table structure from the database and discards its unsaved changes.", + ) + }; + let dialog = + libadwaita::AlertDialog::new(Some(&crate::i18n::gettext("Discard Structure Changes?")), Some(&body)); + dialog.add_response("cancel", &crate::i18n::gettext("Cancel")); + dialog.add_response("discard", &crate::i18n::gettext("Discard and Refresh")); + dialog.set_response_appearance("discard", libadwaita::ResponseAppearance::Destructive); + dialog.set_default_response(Some("cancel")); + dialog.set_close_response("cancel"); + let sender = StructureTabSender { tab: self.this.clone() }; + dialog.connect_response(None, move |_, response| { + if response == "discard" { + sender.input(SaveInput::DiscardAndReload { + acknowledged_unknown: unknown, + }); + } + }); + dialog.present(Some(&self.widgets.inner_stack)); + } + fn save(&self, fx: &mut StructureEffects) { + if self.edits_locked() { + self.refuse_edit(&SaveInput::Save.into(), fx); + return; + } let pending = self.pending(); match SaveGate::of(&pending) { SaveGate::Enabled => {} @@ -129,15 +205,13 @@ impl StructureModel { self.sync_editable(); } - /// The draft holds still from the moment a save takes it until the - /// table is read again after a commit. That read replaces the draft, - /// so an edit made before it would be lost without a prompt. pub(super) fn edits_locked(&self) -> bool { - self.saving || self.refetching || self.tracker.is_saving() + // Every definition read replaces the draft, including refreshes that did not follow a save. + self.saving || self.refetching || self.tracker.is_saving() || self.load.is_running() } pub(super) fn sync_editable(&self) { - let editable = !self.saving && !self.refetching; + let editable = !self.edits_locked(); for widget in [ self.widgets.name_row.upcast_ref::(), self.widgets.columns_box.upcast_ref(), @@ -163,11 +237,12 @@ impl StructureModel { // The save landed and the read after it failed, so only Retry // unlocks the draft. let read_failed = self.refetching && !self.saving && !self.tracker.is_saving() && !self.load.is_running(); - let text = match read_failed { - true => { - crate::i18n::gettext("The table couldn't be read after the save. Retry, then make the change again.") - } - false => crate::i18n::gettext("Wait for the save to finish, then make the change again."), + let text = if read_failed { + crate::i18n::gettext("The table couldn't be read after the save. Retry, then make the change again.") + } else if self.load.is_running() { + crate::i18n::gettext("Wait for the table structure to load, then make the change again.") + } else { + crate::i18n::gettext("Wait for the save to finish, then make the change again.") }; fx.output(StructureTabOutput::ShowToast(text)); } @@ -202,7 +277,7 @@ impl StructureModel { } pub(super) fn refresh_buttons(&self, pending_count: usize, defaults_parsed: bool) { - let has_pending = pending_count > 0 && !self.saving; + let has_pending = pending_count > 0 && !self.edits_locked(); self.widgets.save_button.set_sensitive(has_pending && defaults_parsed); self.widgets.discard_button.set_sensitive(has_pending); if has_pending { diff --git a/linux/crates/app/src/ui/structure_tab/save_input.rs b/linux/crates/app/src/ui/structure_tab/save_input.rs index 8d211c3350..9ae248810b 100644 --- a/linux/crates/app/src/ui/structure_tab/save_input.rs +++ b/linux/crates/app/src/ui/structure_tab/save_input.rs @@ -3,6 +3,10 @@ #[derive(Debug)] pub(crate) enum SaveInput { Save, + RequestRefresh, + DiscardAndReload { + acknowledged_unknown: bool, + }, /// The window started saving the tab's pending structure. SaveStarted, StopSaving, diff --git a/linux/crates/app/src/ui/structure_tab/tests.rs b/linux/crates/app/src/ui/structure_tab/tests.rs index 0d2ac935f8..5964a480ad 100644 --- a/linux/crates/app/src/ui/structure_tab/tests.rs +++ b/linux/crates/app/src/ui/structure_tab/tests.rs @@ -21,7 +21,7 @@ use tablepro_test_support::{CallCounters, ConnectionScript, FakeReply}; use super::*; use crate::test_support::{ - FakeSession, OwnedWindow, descendants, drain_main_context, first_descendant_of_type, wait_until, + FakeSession, OwnedWindow, after_next_frame, descendants, drain_main_context, first_descendant_of_type, wait_until, }; const WAIT: Duration = Duration::from_secs(10); @@ -426,6 +426,157 @@ fn banner_tooltip(harness: &Harness) -> String { .unwrap_or_default() } +#[gtk4::test] +fn replacing_structure_reads_lock_edits_and_save_until_the_definition_lands() { + let triggers: [StructureTabInput; 3] = [ + SaveInput::RequestRefresh.into(), + LoadInput::SchemaChanged.into(), + LoadInput::Retry.into(), + ]; + for trigger in triggers { + let release = tokio_util::sync::CancellationToken::new(); + let mut script = postgres_script(); + script + .fetch_table_definition + .once(FakeReply::ok(definition("id"))) + .always(FakeReply::UntilReleased { + release: release.clone(), + outcome: Ok(definition("server_id")), + }); + let harness = Harness::open(StructureMode::Edit, script, []); + harness.wait_for_structure(); + let saves = Rc::new(std::cell::Cell::new(0)); + let sink = saves.clone(); + harness.tab().connect_save_requested(move |_| sink.set(sink.get() + 1)); + let notices = toasts(harness.tab()); + + harness.tab().send(trigger); + wait_until(WAIT, || { + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition) == 2 + }) + .expect("the replacement read is waiting"); + let imp = harness.tab().imp(); + assert!(harness.tab().is_loading()); + assert!(!imp.columns_box.is_sensitive()); + assert!(!imp.save_button.is_sensitive()); + harness.tab().send(ColumnsInput::ColumnEdited { + column: harness.column(0), + field: ColumnField::Comment(Some("would be lost".to_owned())), + }); + harness.tab().send(ColumnsInput::AddColumn); + harness.tab().send(SaveInput::Save); + + assert_eq!(harness.column_names(), ["id"]); + assert_eq!(harness.comments(), [None]); + assert_eq!(saves.get(), 0); + assert_eq!(harness.tracker().pending_state(), crate::workspace::PendingState::Clean); + assert_eq!(notices.borrow().len(), 3); + assert!( + notices + .borrow() + .iter() + .all(|text| text.contains("table structure to load")) + ); + + release.cancel(); + wait_until(WAIT, || { + harness.column_names() == ["server_id"] && imp.columns_box.is_sensitive() + }) + .expect("the loaded definition unlocks editing"); + harness.tab().send(ColumnsInput::ColumnEdited { + column: harness.column(0), + field: ColumnField::Comment(Some("new draft".to_owned())), + }); + assert_eq!(harness.comments(), [Some("new draft".to_owned())]); + assert!(imp.save_button.is_sensitive()); + } +} + +#[gtk4::test] +fn retrying_a_failed_structure_refresh_asks_before_replacing_a_new_draft() { + let mut script = postgres_script(); + script + .fetch_table_definition + .once(FakeReply::ok(definition("id"))) + .once(FakeReply::err(DriverError::server("denied"))) + .always(FakeReply::ok(definition("server_id"))); + let harness = Harness::open(StructureMode::Edit, script, []); + harness.wait_for_structure(); + let window = in_window(&harness); + harness.tab().request_refresh(); + wait_until(WAIT, || banner(&harness).is_revealed()).expect("the failed refresh"); + assert!(harness.tab().imp().columns_box.is_sensitive()); + harness.tab().send(ColumnsInput::ColumnEdited { + column: harness.column(0), + field: ColumnField::Comment(Some("new draft".to_owned())), + }); + + banner(&harness).emit_by_name::<()>("button-clicked", &[]); + answer_discard(&window, "cancel"); + + assert_eq!(harness.comments(), [Some("new draft".to_owned())]); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 2 + ); + banner(&harness).emit_by_name::<()>("button-clicked", &[]); + answer_discard(&window, "discard"); + wait_until(WAIT, || harness.column_names() == ["server_id"]).expect("the confirmed replacement definition"); + assert_eq!(harness.tracker().pending_state(), crate::workspace::PendingState::Clean); +} + +#[gtk4::test] +fn reconnect_keeps_edits_made_after_a_failed_structure_refresh() { + let mut first = postgres_script(); + first + .fetch_table_definition + .once(FakeReply::ok(definition("id"))) + .always(FakeReply::err(DriverError::server("denied"))); + let mut second = postgres_script(); + second + .fetch_table_definition + .always(FakeReply::ok(definition("server_id"))); + let harness = Harness::open(StructureMode::Edit, first, [FakeEstablish::Connect(second)]); + harness.wait_for_structure(); + let window = in_window(&harness); + harness.tab().request_refresh(); + wait_until(WAIT, || banner(&harness).is_revealed()).expect("the failed refresh"); + harness.tab().send(ColumnsInput::ColumnEdited { + column: harness.column(0), + field: ColumnField::Comment(Some("new draft".to_owned())), + }); + + harness.fake.connection.mark_lost(); + wait_until(WAIT, || { + harness + .tab() + .imp() + .model + .borrow() + .as_ref() + .is_some_and(|model| model.link_generation.get() == 1) + }) + .expect("the tab heard the reconnect"); + + assert_eq!(harness.comments(), [Some("new draft".to_owned())]); + assert_eq!( + harness.tracker().pending_state(), + crate::workspace::PendingState::Unsaved + ); + assert_eq!( + CallCounters::get(&harness.fake.replacement().counters().fetch_table_definition), + 0 + ); + + harness.tab().send(SaveInput::ConfirmDiscard); + answer_discard(&window, "discard"); + wait_until(WAIT, || harness.column_names() == ["server_id"]).expect("discard reads the replacement connection"); + assert_eq!( + CallCounters::get(&harness.fake.replacement().counters().fetch_table_definition), + 1 + ); +} + #[gtk4::test] fn structure_refresh_failure_keeps_editor_and_shows_banner() { let harness = Harness::open(StructureMode::Edit, readable_once(), []); @@ -1334,6 +1485,220 @@ fn a_discard_not_confirmed_keeps_every_change() { assert_eq!(imp.pending_label.label(), "1 unsaved change"); } +fn refreshable_structure() -> Harness { + let mut script = postgres_script(); + script + .fetch_table_definition + .once(FakeReply::ok(TableDefinition { + columns: vec![integer_column("id", false)], + ..definition("id") + })) + .always(FakeReply::ok(TableDefinition { + columns: vec![integer_column("server_id", false)], + ..definition("server_id") + })); + let harness = Harness::open(StructureMode::Edit, script, []); + harness.wait_for_structure(); + harness.tab().send(ColumnsInput::ColumnEdited { + column: harness.column(0), + field: ColumnField::Comment(Some("pending comment".to_owned())), + }); + harness +} + +#[gtk4::test] +fn cancelling_structure_refresh_keeps_the_draft_and_does_not_read() { + let harness = refreshable_structure(); + let window = in_window(&harness); + + harness.tab().request_refresh(); + + let alert = shown_form(&window) + .downcast::() + .expect("the refresh prompt"); + assert_eq!(alert.default_response().as_deref(), Some("cancel")); + assert_eq!(alert.close_response(), "cancel"); + answer_discard(&window, "cancel"); + assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); + assert_eq!( + harness.tracker().pending_state(), + crate::workspace::PendingState::Unsaved + ); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 1 + ); +} + +#[gtk4::test] +fn confirming_structure_refresh_discards_the_draft_and_reads_the_server() { + let harness = refreshable_structure(); + let window = in_window(&harness); + + harness.tab().request_refresh(); + answer_discard(&window, "discard"); + + wait_until(WAIT, || harness.column_names() == ["server_id"]).expect("the current server definition"); + assert_eq!(harness.comments(), [None]); + assert_eq!(harness.tracker().pending_state(), crate::workspace::PendingState::Clean); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 2 + ); +} + +#[gtk4::test] +fn structure_refresh_warns_about_an_unknown_save_before_discarding_it() { + let harness = refreshable_structure(); + let window = in_window(&harness); + let tracker = harness.tracker(); + let _pending = tracker + .begin_save() + .expect("the draft can save") + .expect("a pending draft"); + tracker.settle_save(&crate::workspace::SaveOutcome::Unknown( + crate::workspace::UnknownCause::Interrupted, + )); + + harness.tab().request_refresh(); + + let alert = shown_form(&window) + .downcast::() + .expect("the refresh prompt"); + assert!(alert.body().contains("The last save may have changed the database.")); + assert!(alert.body().contains("discard this draft")); + assert_eq!(alert.default_response().as_deref(), Some("cancel")); + answer_discard(&window, "cancel"); + assert!(matches!( + tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + )); + assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 1 + ); + + harness.tab().request_refresh(); + answer_discard(&window, "discard"); + + wait_until(WAIT, || harness.column_names() == ["server_id"]).expect("the server definition after the unknown save"); + assert_eq!(tracker.pending_state(), crate::workspace::PendingState::Clean); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 2 + ); +} + +#[gtk4::test] +fn structure_refresh_during_a_save_keeps_the_draft_without_a_read_or_prompt() { + let harness = refreshable_structure(); + let window = in_window(&harness); + let tracker = harness.tracker(); + let _pending = tracker + .begin_save() + .expect("the draft can save") + .expect("a pending draft"); + harness.tab().send(SaveInput::SaveStarted); + + harness.tab().request_refresh(); + after_next_frame(&*window); + + assert!(window.visible_dialog().is_none()); + assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); + assert_eq!(tracker.pending_state(), crate::workspace::PendingState::Saving); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 1 + ); +} + +#[gtk4::test] +fn a_refresh_prompt_cannot_discard_a_structure_save_started_since_it_opened() { + let harness = refreshable_structure(); + let window = in_window(&harness); + harness.tab().request_refresh(); + let _alert = shown_form(&window); + let tracker = harness.tracker(); + let _pending = tracker + .begin_save() + .expect("the draft can save") + .expect("a pending draft"); + harness.tab().send(SaveInput::SaveStarted); + + answer_discard(&window, "discard"); + + assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); + assert_eq!(tracker.pending_state(), crate::workspace::PendingState::Saving); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 1 + ); +} + +#[gtk4::test] +fn structure_discard_warns_that_an_unknown_save_is_not_undone() { + let harness = refreshable_structure(); + let window = in_window(&harness); + let tracker = harness.tracker(); + let _pending = tracker + .begin_save() + .expect("the draft can save") + .expect("a pending draft"); + tracker.settle_save(&crate::workspace::SaveOutcome::Unknown( + crate::workspace::UnknownCause::Interrupted, + )); + + harness.tab().send(SaveInput::ConfirmDiscard); + + let alert = shown_form(&window) + .downcast::() + .expect("the discard prompt"); + assert!(alert.body().contains("may have changed the database")); + assert!(alert.body().contains("does not undo")); + assert_eq!(alert.default_response().as_deref(), Some("cancel")); + answer_discard(&window, "cancel"); + assert!(matches!( + tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + )); + assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); + + harness.tab().send(SaveInput::ConfirmDiscard); + answer_discard(&window, "discard"); + + assert_eq!(tracker.pending_state(), crate::workspace::PendingState::Clean); + assert_eq!(harness.column_names(), ["id"]); + assert_eq!(harness.comments(), [None]); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 1 + ); +} + +#[gtk4::test] +fn structure_discard_rechecks_the_tracker_before_the_save_notification_arrives() { + let harness = refreshable_structure(); + let window = in_window(&harness); + harness.tab().send(SaveInput::ConfirmDiscard); + let _alert = shown_form(&window); + let tracker = harness.tracker(); + let _pending = tracker + .begin_save() + .expect("the draft can save") + .expect("a pending draft"); + + answer_discard(&window, "discard"); + + assert_eq!(tracker.pending_state(), crate::workspace::PendingState::Saving); + assert!(tracker.has_pending()); + assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); + assert_eq!( + CallCounters::get(&harness.fake.connection.counters().fetch_table_definition), + 1 + ); +} + /// Answer the alert Discard opens. fn answer_discard(window: &adw::Window, response: &str) { let alert = shown_form(window) @@ -1342,7 +1707,8 @@ fn answer_discard(window: &adw::Window, response: &str) { assert_eq!(alert.close_response(), "cancel"); alert.emit_by_name::<()>("response", &[&response]); alert.force_close(); - drain_main_context(); + // A pending save animates continuously, so the context need not become idle. + after_next_frame(window); } #[gtk4::test] diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 1546b9b017..0e99c0bf75 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -64,6 +64,7 @@ use uuid::Uuid; pub(crate) use self::catalog_ops::DatabaseDrop; pub(crate) use self::database_transfer::TransferInput; +pub(crate) use self::saves::SaveRequest; use self::session_watches::SessionWatches; use self::tab_title::ConnectionLabel; pub(crate) use self::workspace_actions::show_transfer_actions; @@ -362,6 +363,7 @@ pub struct TableTabSlot { pub schema: Option, pub table: String, pub browse: BrowseTab, + pub structure: Option, } /// A tab showing one key of a key-value engine. @@ -396,11 +398,10 @@ impl WorkspaceTab { } } - /// The Structure-side controller. Only `Structure` slots carry - /// one. pub fn structure_tab(&self) -> Option<&crate::ui::structure_tab::StructureTab> { match self { WorkspaceTab::Structure(s) => Some(&s.structure), + WorkspaceTab::Table(s) => s.structure.as_ref(), _ => None, } } @@ -589,10 +590,8 @@ pub(crate) enum WorkspaceInput { /// The tab order, the selection or a tab's state changed, so the /// workspace is saved. WorkspaceTabsChanged, - SaveTab(Uuid), - // A query tab's changed rows alone, never its SQL file. - SaveRows(Uuid), - StopSaving(Uuid), + Save(SaveRequest), + ShowTableStructure(Uuid), /// A save started or settled, or tabs' changes were dropped. Workspace(crate::workspace::WorkspaceEvent), SavesInFlightChanged(usize), @@ -1353,9 +1352,8 @@ impl WorkspaceModel { open_mode, } => self.dispatch_select_table(schema, name, open_mode), WorkspaceInput::WorkspaceTabsChanged => self.on_workspace_tabs_changed(), - WorkspaceInput::SaveTab(id) => self.request_save(id), - WorkspaceInput::SaveRows(id) => self.request_save_rows(id), - WorkspaceInput::StopSaving(id) => self.stop_saving(id), + WorkspaceInput::Save(request) => self.on_save_request(request), + WorkspaceInput::ShowTableStructure(id) => self.on_show_table_structure(id), WorkspaceInput::Workspace(event) => self.on_workspace_event(event), WorkspaceInput::SavesInFlightChanged(count) => self.on_saves_in_flight_changed(count), WorkspaceInput::ShowTransactionTab => self.show_transaction_tab(), diff --git a/linux/crates/app/src/ui/workspace/saves.rs b/linux/crates/app/src/ui/workspace/saves.rs index ebf439390a..aacdb0ffa3 100644 --- a/linux/crates/app/src/ui/workspace/saves.rs +++ b/linux/crates/app/src/ui/workspace/saves.rs @@ -13,10 +13,25 @@ use crate::workspace::{ CloseScope, DirtyTab, SaveOutcome, SaveSettled, SaveStart, WorkKind, WorkOutcome, WorkspaceEvent, }; +#[derive(Debug)] +pub(crate) enum SaveRequest { + Tab(Uuid), + Rows(Uuid), + Structure(Uuid), + Stop(Uuid), +} + impl WorkspaceModel { - /// Save one tab, from its own Save button or Ctrl+S. A structure - /// save may wait on its review first. - pub(super) fn request_save(&self, tab: Uuid) { + pub(super) fn on_save_request(&self, request: SaveRequest) { + match request { + SaveRequest::Tab(tab) => self.request_save(tab), + SaveRequest::Rows(tab) => self.request_save_rows(tab), + SaveRequest::Structure(tab) => self.request_save_structure(tab), + SaveRequest::Stop(tab) => self.workspace_handle.stop_saves(CloseScope::Tab(tab)), + } + } + + fn request_save(&self, tab: Uuid) { let Some(parent) = self.dialog_parent() else { return; }; @@ -37,7 +52,7 @@ impl WorkspaceModel { }); } - pub(super) fn request_save_rows(&self, tab: Uuid) { + fn request_save_rows(&self, tab: Uuid) { let Some(parent) = self.dialog_parent() else { return; }; @@ -53,17 +68,33 @@ impl WorkspaceModel { }); } - pub(super) fn stop_saving(&self, tab: Uuid) { - self.workspace_handle.stop_saves(CloseScope::Tab(tab)); + fn request_save_structure(&self, tab: Uuid) { + let Some(parent) = self.dialog_parent() else { + return; + }; + let (handle, input) = (self.workspace_handle.clone(), self.input.clone()); + glib::spawn_future_local(async move { + match handle.save_structure_of(&parent, tab).await { + SaveStart::Rejected(rejection) if rejection.needs_alert() => input.deliver(WorkspaceInput::ShowAlert { + title: crate::i18n::gettext("Cannot Save"), + body: rejection.message(), + }), + start => tracing::debug!(?start, %tab, "structure save"), + } + }); } pub(super) fn on_workspace_event(&mut self, event: WorkspaceEvent) { match event { - WorkspaceEvent::SaveStarted { tab } => { - self.dispatch_to_tab(tab, browse_tab::SaveInput::SaveStarted); - self.send_to_structure_tab(tab, structure_tab::SaveInput::SaveStarted); - if let Some(editor) = self.editor_tab(tab) { - editor.rows_save_started(); + WorkspaceEvent::SaveStarted { tab, kind } => { + // A table tab holds both, and only one of them is saving. + if kind == WriteKind::SchemaChanges { + self.send_to_structure_tab(tab, structure_tab::SaveInput::SaveStarted); + } else { + self.dispatch_to_tab(tab, browse_tab::SaveInput::SaveStarted); + if let Some(editor) = self.editor_tab(tab) { + editor.rows_save_started(); + } } } WorkspaceEvent::SaveSettled { settled, in_prompt } => self.on_save_settled(*settled, in_prompt), diff --git a/linux/crates/app/src/ui/workspace/structure.rs b/linux/crates/app/src/ui/workspace/structure.rs index 3e856f78dd..4930930fab 100644 --- a/linux/crates/app/src/ui/workspace/structure.rs +++ b/linux/crates/app/src/ui/workspace/structure.rs @@ -70,6 +70,20 @@ impl WorkspaceModel { }); } + pub(super) fn on_show_table_structure(&self, id: Uuid) { + let target = match self.workspace_tabs.borrow().get(&id) { + Some(WorkspaceTab::Table(slot)) => Some((slot.schema.clone(), slot.table.clone())), + _ => None, + }; + let Some(structure) = target.and_then(|(schema, table)| self.factory.table_structure(id, schema, table)) else { + return; + }; + if let Some(WorkspaceTab::Table(slot)) = self.workspace_tabs.borrow_mut().get_mut(&id) { + slot.browse.set_structure(&structure); + slot.structure = Some(structure); + } + } + /// Right-click → "Drop Table…", or in-tab destructive button. The /// table's definition is read first, so a table other tables point /// at is refused before the user is asked. @@ -253,6 +267,12 @@ impl WorkspaceModel { SaveKind::UpdateInPlace(slot.schema.clone(), slot.table.clone()) } }, + Some(WorkspaceTab::Table(slot)) => { + if let Some(name) = new_table_name.as_ref() { + slot.table.clone_from(name); + } + SaveKind::UpdateInPlace(slot.schema.clone(), slot.table.clone()) + } _ => SaveKind::Skip, } }; @@ -274,8 +294,18 @@ impl WorkspaceModel { }); } SaveKind::UpdateInPlace(schema, table) => { - if new_table_name.is_some() { + if let Some(name) = new_table_name.as_ref() { + let browse = self + .workspace_tabs + .borrow() + .get(&tab_id) + .and_then(|tab| tab.browse_tab()) + .cloned(); + if let Some(browse) = browse { + browse.rename_table(name); + } self.retitle_tab(tab_id); + self.persist_workspace_state(); } self.send_to_structure_tab(tab_id, SaveInput::SaveCompleted { new_table_name }); self.input.deliver(WorkspaceInput::SchemaChanged { @@ -368,7 +398,7 @@ impl WorkspaceModel { .values() .filter_map(|tab| match tab { WorkspaceTab::Table(slot) if slot.schema == table.schema && slot.table == table.name => { - Some((Some(slot.browse.clone()), None)) + Some((Some(slot.browse.clone()), slot.structure.clone())) } WorkspaceTab::Structure(slot) if slot.schema == table.schema && slot.table == table.name => { Some((None, Some(slot.structure.clone()))) diff --git a/linux/crates/app/src/ui/workspace/tab_factory.rs b/linux/crates/app/src/ui/workspace/tab_factory.rs index d55e70d5c6..df3e160158 100644 --- a/linux/crates/app/src/ui/workspace/tab_factory.rs +++ b/linux/crates/app/src/ui/workspace/tab_factory.rs @@ -19,8 +19,8 @@ use super::tab_title::{ConnectionLabel, apply_tab_title, resolve_tab_title}; use super::table_naming::TableNaming; use super::workspace_persistence::WorkspaceTabs; use super::{ - DiagramTabSlot, EditorInput, EditorTabSlot, KeyTabSlot, OpenMode, StructureTabSlot, TableTabSlot, WorkspaceInput, - WorkspaceSender, WorkspaceShell, WorkspaceTab, + DiagramTabSlot, EditorInput, EditorTabSlot, KeyTabSlot, OpenMode, SaveRequest, StructureTabSlot, TableTabSlot, + WorkspaceInput, WorkspaceSender, WorkspaceShell, WorkspaceTab, }; use crate::runtime::DeliverInput; use crate::services::change_tracker_registry::ChangeTrackerRegistry; @@ -230,6 +230,7 @@ impl TabFactory { fn table(&self, id: Uuid, opening: TableOpening<'_>) -> Option { let parts = &self.parts; let session = parts.context.active.get()?; + let session_has_ddl = session.current_dialect().is_some_and(|dialect| dialect.ddl().is_some()); let TableOpening { table: TableRef { schema, name }, page, @@ -263,15 +264,21 @@ impl TabFactory { first_load, }); connect_browse(&browse, id, &parts.input); + if session_has_ddl { + browse.offer_structure(); + } let tab_page = self.append(&browse, id, parent); let follow = follow_loading(&tab_page, browse.is_loading()); - browse.connect_loading_changed(move |_, loading| follow(loading)); + browse.connect_loading_changed(move |browse, loading| { + follow(loading || browse.structure_tab().is_some_and(|structure| structure.is_loading())); + }); Some(WorkspaceTab::Table(TableTabSlot { id, page: tab_page, schema, table: name, browse, + structure: None, })) } @@ -291,7 +298,7 @@ impl TabFactory { tasks: parts.context.tasks.clone(), first_load, }); - connect_structure(&structure, id, &parts.input); + connect_structure(&structure, id, &parts.input, SaveRequest::Tab); let page = self.append(&structure, id, None); let follow = follow_loading(&page, structure.is_loading()); structure.connect_loading_changed(move |_, loading| follow(loading)); @@ -305,6 +312,29 @@ impl TabFactory { })) } + pub(super) fn table_structure(&self, id: Uuid, schema: Option, table: String) -> Option { + let parts = &self.parts; + let session = parts.context.active.get()?; + let structure = StructureTab::new(StructureTabInit { + tracker: parts.structure_trackers.register(id), + schema, + table, + mode: StructureMode::Edit, + session, + tasks: parts.context.tasks.clone(), + first_load: FirstLoad::Now, + }); + connect_structure(&structure, id, &parts.input, SaveRequest::Structure); + if let Some(WorkspaceTab::Table(slot)) = parts.tabs.borrow().get(&id) { + let follow = follow_loading(&slot.page, structure.is_loading() || slot.browse.is_loading()); + let browse = slot.browse.downgrade(); + structure.connect_loading_changed(move |_, loading| { + follow(loading || browse.upgrade().is_some_and(|browse| browse.is_loading())); + }); + } + Some(structure) + } + fn diagram(&self, id: Uuid, opening: DiagramOpening) -> Option { let parts = &self.parts; let session = parts.context.active.get()?; @@ -407,14 +437,18 @@ impl EditorPreview { } } -/// The structure tab's signals, as the workspace's inputs for the tab. -fn connect_structure(structure: &StructureTab, tab_id: Uuid, input: &WorkspaceSender) { +fn connect_structure( + structure: &StructureTab, + tab_id: Uuid, + input: &WorkspaceSender, + save_request: fn(Uuid) -> SaveRequest, +) { let dirty = input.clone(); structure.connect_dirty_changed(move |_, _| dirty.deliver(WorkspaceInput::TabDirtyChanged)); let save = input.clone(); - structure.connect_save_requested(move |_| save.deliver(WorkspaceInput::SaveTab(tab_id))); + structure.connect_save_requested(move |_| save.deliver(WorkspaceInput::Save(save_request(tab_id)))); let stop = input.clone(); - structure.connect_stop_save_requested(move |_| stop.deliver(WorkspaceInput::StopSaving(tab_id))); + structure.connect_stop_save_requested(move |_| stop.deliver(WorkspaceInput::Save(SaveRequest::Stop(tab_id)))); let drop_table = input.clone(); structure.connect_drop_table_requested(move |_, schema, table| { drop_table.deliver(WorkspaceInput::DropTablePrompt { schema, table }); @@ -481,9 +515,11 @@ fn connect_browse(browse: &BrowseTab, tab_id: Uuid, input: &WorkspaceSender) { let dirty = input.clone(); browse.connect_dirty_changed(move |_, _| dirty.deliver(WorkspaceInput::TabDirtyChanged)); let save = input.clone(); - browse.connect_save_requested(move |_| save.deliver(WorkspaceInput::SaveTab(tab_id))); + browse.connect_save_requested(move |_| save.deliver(WorkspaceInput::Save(SaveRequest::Rows(tab_id)))); + let structure = input.clone(); + browse.connect_structure_requested(move |_| structure.deliver(WorkspaceInput::ShowTableStructure(tab_id))); let stop = input.clone(); - browse.connect_stop_save_requested(move |_| stop.deliver(WorkspaceInput::StopSaving(tab_id))); + browse.connect_stop_save_requested(move |_| stop.deliver(WorkspaceInput::Save(SaveRequest::Stop(tab_id)))); let refresh = input.clone(); browse.connect_refresh_requested(move |_| refresh.deliver(WorkspaceInput::RefreshTab(tab_id))); let follow = input.clone(); @@ -528,9 +564,9 @@ pub(super) fn connect_editor( let toast = input.clone(); editor.connect_toast(move |_, text| toast.deliver(WorkspaceInput::ShowToast(text))); let save = input.clone(); - editor.connect_save_rows(move |_| save.deliver(WorkspaceInput::SaveRows(tab_id))); + editor.connect_save_rows(move |_| save.deliver(WorkspaceInput::Save(SaveRequest::Rows(tab_id)))); let stop = input.clone(); - editor.connect_stop_saving_rows(move |_| stop.deliver(WorkspaceInput::StopSaving(tab_id))); + editor.connect_stop_saving_rows(move |_| stop.deliver(WorkspaceInput::Save(SaveRequest::Stop(tab_id)))); let dirty = input.clone(); editor.connect_rows_dirty_changed(move |_| dirty.deliver(WorkspaceInput::TabDirtyChanged)); let close = input.clone(); diff --git a/linux/crates/app/src/ui/workspace/tests/close_tab.rs b/linux/crates/app/src/ui/workspace/tests/close_tab.rs index b62fd407b2..1017d35603 100644 --- a/linux/crates/app/src/ui/workspace/tests/close_tab.rs +++ b/linux/crates/app/src/ui/workspace/tests/close_tab.rs @@ -3,13 +3,13 @@ use gtk4::glib; use gtk4::prelude::*; use gtk4::subclass::prelude::*; use libadwaita::prelude::*; -use tablepro_core::column::{ColumnDefault, ColumnType}; +use tablepro_core::column::ColumnDefault; use tablepro_core::meta::{RowCountEstimate, RowIdentity, TableEstimate}; use tablepro_core::{ColumnInfo, QueryResult, Value}; use tablepro_test_support::{ConnectionScript, FakeReply}; use uuid::Uuid; -use super::super::{OpenMode, WorkspaceInput}; +use super::super::{OpenMode, SaveRequest, WorkspaceInput}; use super::shell_of; use crate::runtime::DeliverInput; use crate::test_support::{after_next_frame, drain_main_context, wait_until}; @@ -18,10 +18,12 @@ use crate::ui::data_grid::GridCell; use crate::ui::session_window::tests::{TestWindow, WAIT}; use crate::workspace::{answer, visible_alert}; -fn column(name: &str, primary_key: bool) -> ColumnInfo { +fn column(name: &str, sql_type: &str, primary_key: bool) -> ColumnInfo { ColumnInfo { name: name.to_owned(), - column_type: ColumnType::untyped_text("text"), + column_type: crate::workspace::test_workspace::sqlite() + .parse_type(sql_type) + .expect("a fixture column type"), nullable: !primary_key, primary_key, is_auto_increment: false, @@ -34,7 +36,7 @@ fn column(name: &str, primary_key: bool) -> ColumnInfo { /// Every table has the same two keyed rows. fn serving_tables(script: &mut ConnectionScript) { - let columns = [column("id", true), column("name", false)]; + let columns = [column("id", "INTEGER", true), column("name", "TEXT", false)]; script.fetch_columns.always(FakeReply::ok(columns.to_vec())); script.row_identity.always(FakeReply::ok(RowIdentity::UniqueKey { columns: vec!["id".to_owned()], @@ -335,6 +337,202 @@ fn close_all_tabs_asks_before_closing_unsaved_work() { assert_eq!(crate::test_support::read_text_file(&path), "SELECT 1;"); } +#[gtk4::test] +fn a_schema_rename_keeps_the_table_tab_and_its_pending_rows() { + let test = TestWindow::connected_with("RenameCombinedTable", serving_tables); + let workspace = test.workspace(); + let (id, tab) = open_table(&test, "users"); + type_a_name(&tab); + tab.commit_cell_edit(); + let page = shell_of(&workspace) + .imp() + .tab_view + .selected_page() + .expect("the table page"); + let tracker = super::row_tracker(&workspace, id).expect("row changes"); + assert_eq!(tracker.pending_count(), 1); + + workspace.with_model(|model| model.on_structure_save_completed(id, Some("people".to_owned()))); + drain_main_context(); + + assert_eq!(workspace.selected_tab(), Some(id)); + assert_eq!(shell_of(&workspace).imp().tab_view.selected_page(), Some(page.clone())); + assert_eq!(tab.table(), "people"); + assert_eq!(tracker.pending_count(), 1); + assert_eq!( + super::row_tracker(&workspace, id) + .expect("the same tab's rows") + .pending_count(), + 1 + ); + workspace.with_model(|model| { + let tabs = model.workspace_tabs.borrow(); + let Some(super::super::WorkspaceTab::Table(slot)) = tabs.get(&id) else { + panic!("the renamed tab was replaced"); + }; + assert_eq!(slot.table, "people"); + assert_eq!(slot.browse, tab); + }); + assert!(page.title().contains("people")); +} + +#[gtk4::test] +fn refreshing_cannot_discard_rows_while_their_save_is_running() { + for refresh_first in [false, true] { + let test = TestWindow::connected_with("RefreshDuringSave", |script| { + serving_tables(script); + script + .write_batch + .always(FakeReply::StoppedWith(Err(tablepro_core::DriverError::RolledBack { + statement_index: 0, + source: Box::new(tablepro_core::DriverError::Cancelled), + }))); + }); + let workspace = test.workspace(); + let (id, tab) = open_table(&test, "users"); + type_a_name(&tab); + tab.commit_cell_edit(); + let tracker = super::row_tracker(&workspace, id).expect("row changes"); + if refresh_first { + workspace.with_model(|model| model.on_refresh_tab(id)); + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("the discard question"); + } + workspace + .sender() + .expect("workspace input") + .deliver(WorkspaceInput::Save(SaveRequest::Rows(id))); + let connection = test.connection(); + let began_waiting = std::time::Instant::now(); + let started = wait_until(WAIT, || { + tracker.pending_state() == crate::workspace::PendingState::Saving + && !connection.observed_cancels("write_batch").is_empty() + }); + assert!( + started.is_ok(), + "row save did not reach the driver: refresh_first={refresh_first}, elapsed={:?}, state={:?}, observed_writes={}, connections={:?}, alert={:?}", + began_waiting.elapsed(), + tracker.pending_state(), + connection.observed_cancels("write_batch").len(), + test.connector + .connections() + .iter() + .map(|connection| (connection.is_closed(), connection.observed_sql("write_batch"))) + .collect::>(), + visible_alert(&test.window).map(|alert| (alert.heading(), alert.body())), + ); + + if refresh_first { + assert!(answer(&test.window, "discard")); + } else { + workspace.with_model(|model| model.on_refresh_tab(id)); + // A saving spinner keeps scheduling frames, so draining until idle can outlive the save's deadline. + after_next_frame(&test.window); + let alert = visible_alert(&test.window); + assert!( + alert.is_none(), + "refresh showed an alert during an active save: {:?}", + alert.map(|alert| (alert.heading(), alert.body())) + ); + } + assert_eq!(tracker.pending_state(), crate::workspace::PendingState::Saving); + workspace.with_model(|model| model.workspace_handle.stop_saves(crate::workspace::CloseScope::Tab(id))); + wait_until(WAIT, || { + tracker.pending_state() == crate::workspace::PendingState::Unsaved + }) + .expect("the cancelled save rolls back"); + assert_eq!(tracker.pending_count(), 1, "refresh lost the rolled-back row draft"); + } +} + +#[gtk4::test] +fn refreshing_unknown_rows_warns_that_the_save_may_have_changed_the_database() { + let test = TestWindow::connected_with("RefreshUnknownSave", serving_tables); + let workspace = test.workspace(); + let (id, tab) = open_table(&test, "users"); + type_a_name(&tab); + tab.commit_cell_edit(); + let tracker = super::row_tracker(&workspace, id).expect("row changes"); + let batch = tracker.begin_save().expect("a save").expect("the row draft"); + let unknown = crate::workspace::SaveOutcome::Unknown(crate::workspace::UnknownCause::Interrupted); + let _ = tracker.settle_save(&unknown, batch.snapshot); + + workspace.with_model(|model| model.on_refresh_tab(id)); + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("the refresh warning"); + let dialog = visible_alert(&test.window).expect("the warning"); + assert_eq!( + dialog.body(), + "The last save may have changed the database. Reload to read its current rows and discard these changes." + ); + assert_eq!(dialog.default_response().as_deref(), Some("cancel")); + assert!(answer(&test.window, "cancel")); + assert!(matches!( + tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + )); + + workspace.with_model(|model| model.on_refresh_tab(id)); + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("the warning again"); + assert!(answer(&test.window, "discard")); + wait_until(WAIT, || { + tracker.pending_state() == crate::workspace::PendingState::Clean + }) + .expect("the confirmed reload discards the uncertain draft"); +} + +#[gtk4::test] +fn workspace_refresh_commits_an_open_cell_before_asking_to_discard_it() { + let test = TestWindow::connected_with("RefreshOpenCell", serving_tables); + let workspace = test.workspace(); + let (id, tab) = open_table(&test, "users"); + let cell = type_a_name(&tab); + let tracker = super::row_tracker(&workspace, id).expect("row changes"); + assert_eq!(tracker.pending_count(), 0); + + workspace.with_model(|model| model.on_refresh_tab(id)); + + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("the open edit needs confirmation"); + assert_eq!(tracker.pending_count(), 1); + assert!(!cell.is_editing()); + assert!(answer(&test.window, "cancel")); + assert_eq!(tracker.pending_count(), 1); +} + +#[gtk4::test] +fn a_refresh_answer_cannot_silently_discard_a_new_unknown_outcome() { + let test = TestWindow::connected_with("RefreshBecomesUnknown", serving_tables); + let workspace = test.workspace(); + let (id, tab) = open_table(&test, "users"); + type_a_name(&tab); + tab.commit_cell_edit(); + let tracker = super::row_tracker(&workspace, id).expect("row changes"); + workspace.with_model(|model| model.on_refresh_tab(id)); + wait_until(WAIT, || visible_alert(&test.window).is_some()).expect("the discard question"); + let original = visible_alert(&test.window).expect("the ordinary discard question"); + let batch = tracker.begin_save().expect("a save").expect("the row draft"); + let _ = tracker.settle_save( + &crate::workspace::SaveOutcome::Unknown(crate::workspace::UnknownCause::Interrupted), + batch.snapshot, + ); + + assert!(answer(&test.window, "discard")); + + wait_until(WAIT, || { + visible_alert(&test.window).is_some_and(|dialog| dialog != original) + }) + .expect("a warning about the new unknown outcome"); + assert!( + visible_alert(&test.window) + .expect("the warning") + .body() + .contains("may have changed the database") + ); + assert!(matches!( + tracker.pending_state(), + crate::workspace::PendingState::OutcomeUnknown(_) + )); + assert!(answer(&test.window, "cancel")); +} + #[gtk4::test] fn header_refresh_commits_the_inline_edit_before_asking_to_discard() { let test = TestWindow::connected_with("HeaderRefreshEdit", serving_tables); diff --git a/linux/crates/app/src/ui/workspace/tests/shell.rs b/linux/crates/app/src/ui/workspace/tests/shell.rs index eab94ed2a6..d9731b7f64 100644 --- a/linux/crates/app/src/ui/workspace/tests/shell.rs +++ b/linux/crates/app/src/ui/workspace/tests/shell.rs @@ -289,16 +289,28 @@ fn every_page_fits_the_window_floor() { fits_the_floor(&content()); } -/// The floor measured on the tab's own content, with its widest -/// bars up: the pager's longest label, pending changes and the -/// filter strip. #[gtk4::test] fn an_open_table_tab_fits_the_window_floor() { + table_tab_fits_the_window_floor(false); +} + +#[gtk4::test] +fn a_table_tab_with_structure_switch_fits_the_window_floor() { + table_tab_fits_the_window_floor(true); +} + +fn table_tab_fits_the_window_floor(with_structure: bool) { use crate::ui::browse_tab::{BrowseTab, PagingInput}; + let mut connection = served_table(); + if with_structure { + connection.dialect = Arc::new(tablepro_driver_postgres::PgDialect::new( + &tablepro_core::ServerInfo::new("PostgreSQL", "18.0", 18, 0, 0), + )); + } let test = TestWindow::with_script( "TableFloor", Script { - connection: served_table(), + connection, window_size: Some((360, 294)), ..Script::default() }, diff --git a/linux/crates/app/src/ui/workspace/workspace_tabs.rs b/linux/crates/app/src/ui/workspace/workspace_tabs.rs index 1495f74e7c..98e2fe5436 100644 --- a/linux/crates/app/src/ui/workspace/workspace_tabs.rs +++ b/linux/crates/app/src/ui/workspace/workspace_tabs.rs @@ -17,7 +17,8 @@ use crate::ui::browse_tab::{BrowseTabInput, GridInput, PagingInput, SaveInput, T use crate::ui::editor::SqlEditor; use crate::ui::structure_tab::StructureMode; use crate::workspace::{ - EditorFileRecord, RestoredDrafts, TabRecord, WorkspaceFileName, WorkspaceLoad, WorkspaceRecord, WorkspaceSaveError, + CloseScope, EditorFileRecord, PendingState, RestoredDrafts, TabRecord, WorkspaceFileName, WorkspaceLoad, + WorkspaceRecord, WorkspaceSaveError, }; use super::editor_label::EditorLabel; @@ -326,6 +327,10 @@ impl WorkspaceModel { WorkspaceTab::Table(slot) => { slot.browse.shutdown(); self.change_trackers.unregister(slot.id); + if let Some(structure) = &slot.structure { + structure.shutdown(); + self.structure_trackers.unregister(slot.id); + } } WorkspaceTab::Diagram(slot) => slot.diagram.shutdown(), WorkspaceTab::Key(slot) => slot.tab.shutdown(), @@ -470,32 +475,76 @@ impl WorkspaceModel { } pub(super) fn on_refresh_tab(&self, id: Uuid) { - let dirty = self + let (showing_structure, structure) = + self.workspace_tabs + .borrow() + .get(&id) + .map_or((false, None), |tab| match tab { + WorkspaceTab::Table(slot) if slot.browse.shows_structure() => (true, slot.structure.clone()), + WorkspaceTab::Structure(slot) => (true, Some(slot.structure.clone())), + _ => (false, None), + }); + if showing_structure { + if let Some(structure) = structure { + structure.request_refresh(); + } + return; + } + let browse = self + .workspace_tabs + .borrow() + .get(&id) + .and_then(|tab| tab.browse_tab()) + .cloned(); + let Some(browse) = browse else { + return; + }; + browse.commit_cell_edit(); + let state = self .change_trackers .get(id) - .is_some_and(|tracker| tracker.pending_count() > 0); - if !dirty { - self.dispatch_to_tab(id, PagingInput::Refresh); + .map_or(PendingState::Clean, |tracker| tracker.pending_state()); + if state == PendingState::Saving || self.workspace_handle.ledger().in_flight_in(CloseScope::Tab(id)) > 0 { return; } - // A refetch replaces the rows and with them every pending edit, - // so F5 mid-edit asks first, as closing a dirty tab does. - let dialog = adw::AlertDialog::new( - Some(&crate::i18n::gettext("Discard Pending Changes?")), - Some(&crate::i18n::gettext( + if state == PendingState::Clean { + browse.send(PagingInput::Refresh); + return; + } + let unknown = matches!(state, PendingState::OutcomeUnknown(_)); + let body = if unknown { + crate::i18n::gettext( + "The last save may have changed the database. Reload to read its current rows and discard these changes.", + ) + } else { + crate::i18n::gettext( "Refreshing reloads the table from the database and drops every unsaved edit on this tab.", - )), - ); + ) + }; + let dialog = adw::AlertDialog::new(Some(&crate::i18n::gettext("Discard Pending Changes?")), Some(&body)); dialog.add_response("cancel", &crate::i18n::gettext("Cancel")); dialog.add_response("discard", &crate::i18n::gettext("Discard and Refresh")); dialog.set_response_appearance("discard", adw::ResponseAppearance::Destructive); dialog.set_default_response(Some("cancel")); dialog.set_close_response("cancel"); let workspace_tabs = self.workspace_tabs.clone(); + let trackers = self.change_trackers.clone(); + let handle = self.workspace_handle.clone(); + let input = self.input.clone(); dialog.connect_response(None, move |_, response| { if response != "discard" { return; } + let state = trackers + .get(id) + .map_or(PendingState::Clean, |tracker| tracker.pending_state()); + if state == PendingState::Saving || handle.ledger().in_flight_in(CloseScope::Tab(id)) > 0 { + return; + } + if !unknown && matches!(state, PendingState::OutcomeUnknown(_)) { + input.deliver(WorkspaceInput::RefreshTab(id)); + return; + } let browse = workspace_tabs .borrow() .get(&id) @@ -596,6 +645,10 @@ impl WorkspaceModel { WorkspaceTab::Table(slot) => { slot.browse.shutdown(); self.change_trackers.unregister(slot.id); + if let Some(structure) = &slot.structure { + structure.shutdown(); + self.structure_trackers.unregister(slot.id); + } } WorkspaceTab::Diagram(slot) => slot.diagram.shutdown(), WorkspaceTab::Key(slot) => slot.tab.shutdown(), @@ -746,6 +799,9 @@ impl WorkspaceModel { match self.workspace_tabs.borrow().get(&id) { // A table tab says itself when it has nothing to export. Some(WorkspaceTab::Table(slot)) => { + if slot.browse.shows_structure() { + return false; + } slot.browse.send(GridInput::Export); true } diff --git a/linux/crates/app/src/workspace/workspace_event.rs b/linux/crates/app/src/workspace/workspace_event.rs index 370614c1ea..bd14fae980 100644 --- a/linux/crates/app/src/workspace/workspace_event.rs +++ b/linux/crates/app/src/workspace/workspace_event.rs @@ -1,3 +1,4 @@ +use tablepro_core::WriteKind; use uuid::Uuid; use super::SaveSettled; @@ -7,6 +8,7 @@ use super::SaveSettled; pub enum WorkspaceEvent { SaveStarted { tab: Uuid, + kind: WriteKind, }, SaveSettled { settled: Box, diff --git a/linux/crates/app/src/workspace/workspace_handle.rs b/linux/crates/app/src/workspace/workspace_handle.rs index 62b66be915..ee4f60f196 100644 --- a/linux/crates/app/src/workspace/workspace_handle.rs +++ b/linux/crates/app/src/workspace/workspace_handle.rs @@ -190,6 +190,9 @@ impl WorkspaceHandle { } async fn save_tracked_rows(&self, parent: >k::Widget, tab: Uuid, tracker: &TabTrackerHandle) -> SaveStart { + if let Err(rejection) = self.check_save(tab) { + return SaveStart::Rejected(rejection); + } let Some(_claim) = ReviewClaim::take(&self.0.reviewing, tab) else { return SaveStart::Rejected(SaveRejection::InReview); }; @@ -199,6 +202,13 @@ impl WorkspaceHandle { self.save_rows(tab, tracker) } + pub async fn save_structure_of(&self, parent: >k::Widget, tab: Uuid) -> SaveStart { + let Some(tracker) = self.0.deps.structures.get(tab) else { + return SaveStart::NothingToSave; + }; + self.save_tracked_structure(parent, tab, &tracker).await + } + /// Stop the saves `scope` covers. Each settles when its driver /// answers the cancel, as rolled back or with an unknown outcome. pub fn stop_saves(&self, scope: CloseScope) { @@ -274,9 +284,23 @@ impl WorkspaceHandle { } fn pending_state(&self, tab: Uuid) -> PendingState { - if let Some(tracker) = self.0.deps.rows.get(tab) { - return tracker.pending_state(); + let rows = self + .0 + .deps + .rows + .get(tab) + .map_or(PendingState::Clean, |tracker| tracker.pending_state()); + match (rows, self.structure_state(tab)) { + (PendingState::OutcomeUnknown(cause), _) | (_, PendingState::OutcomeUnknown(cause)) => { + PendingState::OutcomeUnknown(cause) + } + (PendingState::Saving, _) | (_, PendingState::Saving) => PendingState::Saving, + (PendingState::Unsaved, _) | (_, PendingState::Unsaved) => PendingState::Unsaved, + (PendingState::Clean, PendingState::Clean) => PendingState::Clean, } + } + + fn structure_state(&self, tab: Uuid) -> PendingState { self.0 .deps .structures @@ -284,16 +308,31 @@ impl WorkspaceHandle { .map_or(PendingState::Clean, |tracker| tracker.pending_state()) } + fn check_save(&self, tab: Uuid) -> Result<(), SaveRejection> { + // A schema write can change the identity and columns used by a row write. + if self.0.ledger.in_flight_in(CloseScope::Tab(tab)) > 0 { + return Err(SaveRejection::AlreadySaving); + } + if matches!(self.pending_state(tab), PendingState::OutcomeUnknown(_)) { + return Err(SaveRejection::OutcomeUnknown); + } + Ok(()) + } + fn emit(&self, event: WorkspaceEvent) { (self.0.deps.events)(event); } async fn save_tab(&self, parent: >k::Widget, tab: Uuid) -> SaveStart { // An editor tab holds a row tracker beside its file; a clean one leaves the save to the file. - let rows = - self.0.deps.rows.get(tab).filter(|tracker| { - tracker.pending_state() != PendingState::Clean || !self.0.deps.directory.has_file(tab) - }); + // Neither does a table tab whose only edits are its Structure view's. + let rows_are_all = !self.0.deps.directory.has_file(tab) && self.structure_state(tab) == PendingState::Clean; + let rows = self + .0 + .deps + .rows + .get(tab) + .filter(|tracker| tracker.pending_state() != PendingState::Clean || rows_are_all); if let Some(tracker) = rows { let start = self.save_tracked_rows(parent, tab, &tracker).await; if !matches!( @@ -319,15 +358,7 @@ impl WorkspaceHandle { }; } if let Some(tracker) = self.0.deps.structures.get(tab) { - // A close that saves its tabs can ask again while the review is - // open, and the review on screen is the one to answer. - let Some(_claim) = ReviewClaim::take(&self.0.reviewing, tab) else { - return SaveStart::Rejected(SaveRejection::InReview); - }; - return match self.review_structure(parent, &tracker).await { - Ok(reviewed) => self.save_structure(tab, &tracker, reviewed), - Err(start) => start, - }; + return self.save_tracked_structure(parent, tab, &tracker).await; } match self.0.deps.directory.save_file(tab) { Some(saving) => match saving.await { @@ -338,6 +369,26 @@ impl WorkspaceHandle { } } + async fn save_tracked_structure( + &self, + parent: >k::Widget, + tab: Uuid, + tracker: &StructureTrackerHandle, + ) -> SaveStart { + // A close that saves its tabs can ask again while the review is + // open, and the review on screen is the one to answer. + if let Err(rejection) = self.check_save(tab) { + return SaveStart::Rejected(rejection); + } + let Some(_claim) = ReviewClaim::take(&self.0.reviewing, tab) else { + return SaveStart::Rejected(SaveRejection::InReview); + }; + match self.review_structure(parent, tracker).await { + Ok(reviewed) => self.save_structure(tab, tracker, reviewed), + Err(start) => start, + } + } + /// On a connection that asks before every write, the row save's SQL /// is shown first. What is saved has to be what was shown: the tab /// can change while the question is open. @@ -389,6 +440,7 @@ impl WorkspaceHandle { state: PendingState, take: impl FnOnce() -> Result, SaveRejection>, ) -> Result<(Arc, SaveTicket, T), SaveStart> { + self.check_save(tab).map_err(SaveStart::Rejected)?; let session = match self.writable_session(state) { Ok(Some(session)) => session, Ok(None) => return Err(SaveStart::NothingToSave), @@ -408,7 +460,7 @@ impl WorkspaceHandle { return Err(SaveStart::Rejected(rejection)); } }; - self.emit(WorkspaceEvent::SaveStarted { tab }); + self.emit(WorkspaceEvent::SaveStarted { tab, kind }); Ok((session, ticket, taken)) } @@ -778,6 +830,143 @@ mod tests { script } + fn add_structure(workspace: &Workspace) -> StructureTrackerHandle { + let structure = workspace.handle.0.deps.structures.register(workspace.tab); + structure.set_pending(Some(crate::workspace::test_workspace::edited_table(|draft| { + draft.columns.push(tablepro_core::ddl::DraftColumn::new( + "extra", + tablepro_core::ddl::DraftType::Typed("TEXT".to_owned()), + )); + }))); + structure + } + + fn save_view(workspace: &Workspace, structure: bool) -> SaveStart { + let parent: gtk::Widget = gtk::Label::new(None).into(); + let (handle, tab) = (workspace.handle.clone(), workspace.tab); + crate::test_support::finish_on_main(WAIT, async move { + if structure { + handle.save_structure_of(&parent, tab).await + } else { + handle.save_rows_of(&parent, tab).await + } + }) + .expect("the selected view's save") + } + + #[gtk4::test] + fn unknown_schema_outcome_precedes_unsaved_rows_in_the_close_prompt() { + let workspace = Workspace::open(ConnectionScript::default()); + let structure = add_structure(&workspace); + structure + .begin_save() + .expect("the schema changes") + .expect("a schema draft"); + structure.settle_save(&SaveOutcome::Unknown(UnknownCause::PartiallyApplied)); + + assert!(matches!( + workspace.handle.close_step(CloseScope::Tab(workspace.tab), &HashSet::new()), + CloseStep::ResolveUnknownOutcome(tabs) + if tabs.len() == 1 && tabs[0].kind == DirtyKind::OutcomeUnknown(UnknownCause::PartiallyApplied) + )); + assert_eq!( + save_view(&workspace, false), + SaveStart::Rejected(SaveRejection::OutcomeUnknown) + ); + assert_eq!(workspace.tracker.pending_count(), 1); + workspace.handle.discard(&[workspace.tab], true); + assert_eq!(workspace.tracker.pending_state(), PendingState::Clean); + assert_eq!(structure.pending_state(), PendingState::Clean); + assert!(matches!( + workspace.events.borrow().last(), + Some(WorkspaceEvent::Discarded { reload: true, .. }) + )); + } + + #[gtk4::test] + fn unknown_row_outcome_precedes_unsaved_schema_in_the_close_prompt() { + let workspace = Workspace::open(ConnectionScript::default()); + let structure = add_structure(&workspace); + let batch = workspace.tracker.begin_save().expect("a save").expect("row changes"); + let _ = workspace + .tracker + .settle_save(&SaveOutcome::Unknown(UnknownCause::Interrupted), batch.snapshot); + + assert!(matches!( + workspace.handle.close_step(CloseScope::Tab(workspace.tab), &HashSet::new()), + CloseStep::ResolveUnknownOutcome(tabs) + if tabs.len() == 1 && tabs[0].kind == DirtyKind::OutcomeUnknown(UnknownCause::Interrupted) + )); + assert_eq!( + save_view(&workspace, true), + SaveStart::Rejected(SaveRejection::OutcomeUnknown) + ); + assert!(structure.has_pending()); + } + + #[gtk4::test] + fn a_table_saves_rows_and_schema_separately_without_overlapping_writes() { + for structure_first in [false, true] { + let mut script = ConnectionScript::default(); + script + .write_batch + .always(FakeReply::StoppedWith(Err(DriverError::RolledBack { + statement_index: 0, + source: Box::new(DriverError::Cancelled), + }))); + let workspace = Workspace::open(script); + let structure = add_structure(&workspace); + assert!(matches!(save_view(&workspace, structure_first), SaveStart::Started(_))); + wait_until(WAIT, || CallCounters::get(&workspace.counters().write_batch) == 1).expect("the write starts"); + + assert_eq!( + save_view(&workspace, !structure_first), + SaveStart::Rejected(SaveRejection::AlreadySaving) + ); + assert_eq!(workspace.handle.ledger().in_flight(), 1); + assert_eq!(CallCounters::get(&workspace.counters().write_batch), 1); + workspace.handle.stop_saves(CloseScope::Tab(workspace.tab)); + workspace.settle(); + assert_eq!(workspace.tracker.pending_state(), PendingState::Unsaved); + assert_eq!(structure.pending_state(), PendingState::Unsaved); + } + } + + #[gtk4::test] + fn closing_a_combined_tab_saves_rows_before_schema_and_discards_both() { + let mut script = ConnectionScript::default(); + script + .write_batch + .always(FakeReply::ok(WriteReport::new(vec![Some(1)]))); + let workspace = Workspace::open(script); + let structure = add_structure(&workspace); + assert!(matches!(workspace.start().as_slice(), [SaveStart::Started(_)])); + assert_eq!(workspace.settle().kind, WriteKind::RowChanges); + assert_eq!(workspace.tracker.pending_state(), PendingState::Clean); + assert_eq!(structure.pending_state(), PendingState::Unsaved); + assert!(matches!( + workspace + .handle + .close_step(CloseScope::Tab(workspace.tab), &HashSet::new()), + CloseStep::AskSaveChanges(_) + )); + assert!(matches!(workspace.start().as_slice(), [SaveStart::Started(_)])); + assert_eq!(workspace.settle().kind, WriteKind::SchemaChanges); + assert_eq!(structure.pending_state(), PendingState::Clean); + assert!(matches!( + workspace + .handle + .close_step(CloseScope::Tab(workspace.tab), &HashSet::new()), + CloseStep::Approve + )); + + workspace.edit(3); + let structure = add_structure(&workspace); + workspace.handle.discard(&[workspace.tab], false); + assert_eq!(workspace.tracker.pending_state(), PendingState::Clean); + assert_eq!(structure.pending_state(), PendingState::Clean); + } + #[gtk4::test] fn changed_rows_and_an_unsaved_file_of_one_tab_are_one_choice() { let workspace = Workspace::open(ConnectionScript::default()); diff --git a/linux/data/resources/shortcuts-dialog.ui b/linux/data/resources/shortcuts-dialog.ui index bff1f816b9..faac50372b 100644 --- a/linux/data/resources/shortcuts-dialog.ui +++ b/linux/data/resources/shortcuts-dialog.ui @@ -147,13 +147,13 @@ - + Read the Table Again F5 <Primary>r - + Save Pending Changes <Primary>s diff --git a/linux/data/resources/ui/browse-tab.ui b/linux/data/resources/ui/browse-tab.ui index 7a4ec1a04d..e3441ac4e4 100644 --- a/linux/data/resources/ui/browse-tab.ui +++ b/linux/data/resources/ui/browse-tab.ui @@ -1,16 +1,15 @@ - - - + + diff --git a/linux/docs/state-management.md b/linux/docs/state-management.md index e7825026c2..8ff4f52176 100644 --- a/linux/docs/state-management.md +++ b/linux/docs/state-management.md @@ -79,6 +79,10 @@ The closure holds only the sender, so a window that closed before the read ends A browse or structure tab is a subclass whose model sits in its `imp` struct. `send` hands the model one input and handles it at once; an input a widget signal sets off while another is being handled waits in the tab's queue until that one finishes. The model's update returns effects: more inputs for the queue, and outputs the tab emits as signals. The workspace connects those signals, tags them with the tab's id and queues them as `WorkspaceInput`, so the tabs never call each other. +A table tab owns Data and Structure pages in one `AdwViewStack`, selected by an `AdwInlineViewSwitcher` in its bottom bar. Structure is built on first selection. Data banners, filters and pending edits stay inside the Data page. Save and Refresh route from the selected page, including when focus is on the switch. Row actions are unavailable while Structure is selected. + +The workspace registers both trackers under the same tab id. A close considers both, with an unknown save outcome taking precedence over pending changes. A row save and a structure save cannot run together on that tab. Rename keeps the tab, its row drafts and its selection, and updates the grid and persistence keys to the new table name. + A tab belongs to its session, and a session to one window ([decisions/0028-sessions-share-a-window.md](decisions/0028-sessions-share-a-window.md)). libadwaita 1.9 lets every tab bar of the process take a dragged tab, so the shell holds a tab to that while the drag moves it: - When a drag takes a tab out of the view, the shell of its session's window records the position it left (`Departure`, from `page-detached`).