From 33813ba455a040b64d419d5a489d81f2a8019784 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:33:58 +0100 Subject: [PATCH 01/13] feat(linux-browse): switch a table tab between Data and Structure from its bottom bar --- linux/crates/app/src/ui/browse_tab/imp.rs | 11 + linux/crates/app/src/ui/browse_tab/mod.rs | 44 +++ .../crates/app/src/ui/browse_tab/tests/mod.rs | 31 ++ linux/crates/app/src/ui/workspace/mod.rs | 13 +- linux/crates/app/src/ui/workspace/saves.rs | 30 +- .../crates/app/src/ui/workspace/structure.rs | 23 +- .../app/src/ui/workspace/tab_factory.rs | 36 ++- .../app/src/ui/workspace/workspace_tabs.rs | 8 + .../app/src/workspace/workspace_event.rs | 2 + .../app/src/workspace/workspace_handle.rs | 61 +++- linux/data/resources/ui/browse-tab.ui | 306 ++++++++++-------- 11 files changed, 409 insertions(+), 156 deletions(-) diff --git a/linux/crates/app/src/ui/browse_tab/imp.rs b/linux/crates/app/src/ui/browse_tab/imp.rs index b6c8158638..12b0218c2d 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, @@ -111,6 +121,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/mod.rs b/linux/crates/app/src/ui/browse_tab/mod.rs index 3992ec5199..642f1474a6 100644 --- a/linux/crates/app/src/ui/browse_tab/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/mod.rs @@ -388,6 +388,50 @@ impl BrowseTab { self.connect_closure("save-requested", false, glib::closure_local!(move |tab: &Self| f(tab))) } + /// The Structure view opened for the first time and has nothing to show. + pub fn connect_structure_requested(&self, f: F) -> glib::SignalHandlerId { + self.connect_closure( + "structure-requested", + false, + glib::closure_local!(move |tab: &Self| f(tab)), + ) + } + + /// Offer the Data and Structure switch, where the engine has a + /// structure to show. + pub fn offer_structure(&self) { + let imp = self.imp(); + imp.view_toggle.set_visible(true); + let tab = self.downgrade(); + imp.view_toggle.connect_active_name_notify(move |_| { + if let Some(tab) = tab.upgrade() { + tab.follow_view_toggle(); + } + }); + } + + /// Show `structure` as the tab's Structure view. + pub fn set_structure(&self, structure: &impl IsA) { + libadwaita::prelude::BinExt::set_child(&*self.imp().structure_host, Some(structure)); + } + + fn follow_view_toggle(&self) { + let imp = self.imp(); + let structure = imp.view_toggle.active_name().as_deref() == Some("structure"); + if structure && libadwaita::prelude::BinExt::child(&*imp.structure_host).is_none() { + self.emit_by_name::<()>("structure-requested", &[]); + } + imp.view_stack + .set_visible_child_name(if structure { "structure" } else { "data" }); + // Each says something about the rows, and is hidden rather than + // unrevealed because the data view decides whether it is revealed. + imp.stale_banner.set_visible(!structure); + imp.read_only_banner.set_visible(!structure); + imp.no_pk_banner.set_visible(!structure); + imp.data_start.set_visible(!structure); + imp.data_end.set_visible(!structure); + } + /// 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/tests/mod.rs b/linux/crates/app/src/ui/browse_tab/tests/mod.rs index f9b9de38a4..360d3f2298 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/mod.rs @@ -1536,3 +1536,34 @@ fn a_dotted_field_of_a_document_neither_sorts_nor_takes_an_edit() { assert!(!grid.edit().edit_cell(&cell), "the dotted field opened for editing"); assert_eq!(harness.tracker.pending_count(), 0); } + +/// The Structure view is asked for once, the first time it is switched to, +/// and the data view's controls leave the bottom bar for it. +#[gtk4::test] +fn the_bottom_bar_switches_between_data_and_structure() { + use gtk4::prelude::*; + use gtk4::subclass::prelude::ObjectSubclassIsExt; + + let harness = Harness::open(serving_table(), []); + let tab = harness.tab().clone(); + 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(); + assert!(imp.view_toggle.is_visible()); + + imp.view_toggle.set_active_name(Some("structure")); + assert_eq!(asked.get(), 1); + assert_eq!(imp.view_stack.visible_child_name().as_deref(), Some("structure")); + assert!(!imp.data_start.is_visible()); + + tab.set_structure(>k4::Label::new(None)); + imp.view_toggle.set_active_name(Some("data")); + imp.view_toggle.set_active_name(Some("structure")); + assert_eq!(asked.get(), 1, "a view that is built is asked for again"); + + imp.view_toggle.set_active_name(Some("data")); + assert_eq!(imp.view_stack.visible_child_name().as_deref(), Some("data")); + assert!(imp.data_start.is_visible()); +} diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 6e4edd63b6..b903bca031 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -362,6 +362,8 @@ pub struct TableTabSlot { pub schema: Option, pub table: String, pub browse: BrowseTab, + /// The Structure view, made the first time it is asked for. + pub structure: Option, } /// A tab showing one key of a key-value engine. @@ -396,11 +398,12 @@ impl WorkspaceTab { } } - /// The Structure-side controller. Only `Structure` slots carry - /// one. + /// The Structure-side controller: a `Structure` slot's, or the + /// Structure view of a `Table` slot that has opened it. 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, } } @@ -588,6 +591,10 @@ pub(crate) enum WorkspaceInput { /// workspace is saved. WorkspaceTabsChanged, SaveTab(Uuid), + /// Save a table tab's Structure view, whatever its rows hold. + SaveStructure(Uuid), + /// A table tab's Structure view opened for the first time. + ShowTableStructure(Uuid), // A query tab's changed rows alone, never its SQL file. SaveRows(Uuid), StopSaving(Uuid), @@ -1342,6 +1349,8 @@ impl WorkspaceModel { WorkspaceInput::WorkspaceTabsChanged => self.on_workspace_tabs_changed(), WorkspaceInput::SaveTab(id) => self.request_save(id), WorkspaceInput::SaveRows(id) => self.request_save_rows(id), + WorkspaceInput::SaveStructure(id) => self.request_save_structure(id), + WorkspaceInput::ShowTableStructure(id) => self.on_show_table_structure(id), WorkspaceInput::StopSaving(id) => self.stop_saving(id), WorkspaceInput::Workspace(event) => self.on_workspace_event(event), WorkspaceInput::SavesInFlightChanged(count) => self.on_saves_in_flight_changed(count), diff --git a/linux/crates/app/src/ui/workspace/saves.rs b/linux/crates/app/src/ui/workspace/saves.rs index ebf439390a..023989f851 100644 --- a/linux/crates/app/src/ui/workspace/saves.rs +++ b/linux/crates/app/src/ui/workspace/saves.rs @@ -53,17 +53,37 @@ impl WorkspaceModel { }); } + pub(super) 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 stop_saving(&self, tab: Uuid) { self.workspace_handle.stop_saves(CloseScope::Tab(tab)); } 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..3c8baab0ef 100644 --- a/linux/crates/app/src/ui/workspace/structure.rs +++ b/linux/crates/app/src/ui/workspace/structure.rs @@ -70,6 +70,21 @@ impl WorkspaceModel { }); } + /// Build a table tab's Structure view, the first time it opens. + 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 +268,12 @@ impl WorkspaceModel { SaveKind::UpdateInPlace(slot.schema.clone(), slot.table.clone()) } }, + // The rows are read by the name the tab was built with, + // so a renamed table opens again under its new one. + Some(WorkspaceTab::Table(slot)) => match new_table_name.clone() { + Some(name) => SaveKind::PromoteNewToTable(slot.schema.clone(), name), + None => SaveKind::UpdateInPlace(slot.schema.clone(), slot.table.clone()), + }, _ => SaveKind::Skip, } }; @@ -368,7 +389,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 55b8f44575..7e9720c0df 100644 --- a/linux/crates/app/src/ui/workspace/tab_factory.rs +++ b/linux/crates/app/src/ui/workspace/tab_factory.rs @@ -228,6 +228,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, @@ -261,6 +262,9 @@ 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)); @@ -270,6 +274,7 @@ impl TabFactory { schema, table: name, browse, + structure: None, })) } @@ -289,7 +294,7 @@ impl TabFactory { tasks: parts.context.tasks.clone(), first_load, }); - connect_structure(&structure, id, &parts.input); + connect_structure(&structure, id, &parts.input, WorkspaceInput::SaveTab); let page = self.append(&structure, id, None); let follow = follow_loading(&page, structure.is_loading()); structure.connect_loading_changed(move |_, loading| follow(loading)); @@ -303,6 +308,24 @@ impl TabFactory { })) } + /// The Structure view of the table tab `id`. It goes under the tab's + /// own id, so the tab's close and save prompts cover its edits. + 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, WorkspaceInput::SaveStructure); + Some(structure) + } + fn diagram(&self, id: Uuid, opening: DiagramOpening) -> Option { let parts = &self.parts; let session = parts.context.active.get()?; @@ -406,11 +429,16 @@ 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_message: fn(Uuid) -> WorkspaceInput, +) { 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(save_message(tab_id))); let stop = input.clone(); structure.connect_stop_save_requested(move |_| stop.deliver(WorkspaceInput::StopSaving(tab_id))); let drop_table = input.clone(); @@ -480,6 +508,8 @@ fn connect_browse(browse: &BrowseTab, tab_id: Uuid, input: &WorkspaceSender) { browse.connect_dirty_changed(move |_, _| dirty.deliver(WorkspaceInput::TabDirtyChanged)); let save = input.clone(); browse.connect_save_requested(move |_| save.deliver(WorkspaceInput::SaveTab(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))); let refresh = input.clone(); diff --git a/linux/crates/app/src/ui/workspace/workspace_tabs.rs b/linux/crates/app/src/ui/workspace/workspace_tabs.rs index b599dce1d3..dbee8bb060 100644 --- a/linux/crates/app/src/ui/workspace/workspace_tabs.rs +++ b/linux/crates/app/src/ui/workspace/workspace_tabs.rs @@ -307,6 +307,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(), @@ -549,6 +553,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(), 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..f0b64de6e9 100644 --- a/linux/crates/app/src/workspace/workspace_handle.rs +++ b/linux/crates/app/src/workspace/workspace_handle.rs @@ -199,6 +199,15 @@ impl WorkspaceHandle { self.save_rows(tab, tracker) } + /// Save the Structure view's edits of a table tab, whose rows may + /// have edits of their own. + 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 +283,16 @@ 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(|tracker| tracker.pending_state()); + match rows { + // A table tab holds both, with its Structure view's edits + // waiting behind clean rows. + Some(state) if state != PendingState::Clean => state, + _ => self.structure_state(tab), } + } + + fn structure_state(&self, tab: Uuid) -> PendingState { self.0 .deps .structures @@ -290,10 +306,14 @@ impl WorkspaceHandle { 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 +339,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 +350,23 @@ 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. + 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. @@ -408,7 +437,7 @@ impl WorkspaceHandle { return Err(SaveStart::Rejected(rejection)); } }; - self.emit(WorkspaceEvent::SaveStarted { tab }); + self.emit(WorkspaceEvent::SaveStarted { tab, kind }); Ok((session, ticket, taken)) } diff --git a/linux/data/resources/ui/browse-tab.ui b/linux/data/resources/ui/browse-tab.ui index 53d43a0eb7..8d25edb150 100644 --- a/linux/data/resources/ui/browse-tab.ui +++ b/linux/data/resources/ui/browse-tab.ui @@ -41,54 +41,74 @@ - + + crossfade - loading + data - - Loading… - - - 32 - 32 - center - - - - - - - - - grid - - - vertical - true - + + crossfade + + + loading + + + Loading… + + + 32 + 32 + center + + + + + + + + + grid + + + vertical + true + + + + + + + error + + + dialog-error-symbolic + Couldn't Load Rows + + + Try Again + center + + + + + + + + - error + structure - - dialog-error-symbolic - Couldn't Load Rows - - - Try Again - center - - - - + @@ -97,118 +117,146 @@ - - list-add-symbolic - grid.insert-row - - - - - - list-remove-symbolic - grid.delete-rows - - - - - - - - + false - end - 12 - status - - - - - - sidebar-show-right-symbolic - Row Details - grid.show-details - - - Row Details - - - - - - view-more-symbolic - false - More Actions - - More Actions - - + data + + + data + Data + + + + + structure + Structure + + - - - document-save-symbolic - + + + 6 + + + list-add-symbolic + grid.insert-row + + + + + + list-remove-symbolic + grid.delete-rows + + + + + + + + + false + end + 12 + status + + + - - - Filter Rows - browse.toggle-filter - - - + + 6 + + 6 - Filter - - - - - false + Rows: + page_size_dropdown + + + - - - - - - 6 + + + + + Filter Rows + browse.toggle-filter + + + + 6 + + + Filter + + + + + false + + + + + + + - - Rows: - page_size_dropdown + + document-save-symbolic - + + view-more-symbolic + false + More Actions + + More Actions + + + + + + + sidebar-show-right-symbolic + Row Details + grid.show-details + + + Row Details + + From 340e9ca1656091e08e66ea308fa56bd9fb30f5a8 Mon Sep 17 00:00:00 2001 From: sedax90 <5001801+sedax90@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:39:43 +0100 Subject: [PATCH 02/13] docs(linux-browse): add the changelog entry --- linux/changelog.d/4108.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 linux/changelog.d/4108.added.md diff --git a/linux/changelog.d/4108.added.md b/linux/changelog.d/4108.added.md new file mode 100644 index 0000000000..6ac424859c --- /dev/null +++ b/linux/changelog.d/4108.added.md @@ -0,0 +1 @@ +A table tab switches between its data and its structure from the bottom bar, as on macOS. From 6d73a7cb0264794c0431c8bc83e3980bbf799e42 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 20:33:32 +0700 Subject: [PATCH 03/13] fix(linux-browse): route table commands by selected view --- linux/ARCHITECTURE.md | 4 +- linux/changelog.d/4108.added.md | 2 +- .../app/src/application/accelerators.rs | 4 +- .../app/src/ui/browse_tab/browse_actions.rs | 23 +- .../app/src/ui/browse_tab/data_handlers.rs | 25 +- .../app/src/ui/browse_tab/data_input.rs | 1 + linux/crates/app/src/ui/browse_tab/imp.rs | 6 +- linux/crates/app/src/ui/browse_tab/layout.rs | 2 +- linux/crates/app/src/ui/browse_tab/mod.rs | 66 ++++-- .../app/src/ui/browse_tab/page_label.rs | 1 - .../crates/app/src/ui/browse_tab/pager_bar.rs | 4 + .../src/ui/browse_tab/pending_changes_bar.rs | 2 +- .../crates/app/src/ui/browse_tab/row_count.rs | 24 +- .../crates/app/src/ui/browse_tab/row_total.rs | 32 ++- .../app/src/ui/browse_tab/save_handlers.rs | 25 +- .../crates/app/src/ui/browse_tab/tests/mod.rs | 86 +++++-- .../app/src/ui/browse_tab/tests/save.rs | 2 +- .../app/src/ui/browse_tab/tests/total.rs | 103 ++++++++ linux/crates/app/src/ui/data_grid/columns.rs | 6 +- .../crates/app/src/ui/data_grid/copy/tests.rs | 19 ++ .../crates/app/src/ui/data_grid/grid_menu.rs | 8 +- linux/crates/app/src/ui/data_grid/imp.rs | 2 +- linux/crates/app/src/ui/data_grid/mod.rs | 39 +++- .../app/src/ui/data_grid/references/mod.rs | 3 +- .../app/src/ui/data_grid/tests/columns.rs | 29 +++ linux/crates/app/src/ui/discard_alert.rs | 52 ++++- .../app/src/ui/editor/result_editing.rs | 46 +++- linux/crates/app/src/ui/structure_tab/mod.rs | 7 +- .../app/src/ui/structure_tab/save_handlers.rs | 76 +++++- .../app/src/ui/structure_tab/save_input.rs | 4 + .../crates/app/src/ui/structure_tab/tests.rs | 208 +++++++++++++++++ linux/crates/app/src/ui/workspace/mod.rs | 5 - .../crates/app/src/ui/workspace/structure.rs | 25 +- .../app/src/ui/workspace/tab_factory.rs | 15 +- .../app/src/ui/workspace/tests/close_tab.rs | 178 ++++++++++++++ .../app/src/ui/workspace/workspace_tabs.rs | 90 +++++-- .../app/src/workspace/workspace_handle.rs | 176 +++++++++++++- linux/data/resources/shortcuts-dialog.ui | 4 +- linux/data/resources/ui/browse-tab.ui | 221 ++++++++---------- linux/docs/state-management.md | 4 + 40 files changed, 1348 insertions(+), 281 deletions(-) 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 index 6ac424859c..ba67bd84fe 100644 --- a/linux/changelog.d/4108.added.md +++ b/linux/changelog.d/4108.added.md @@ -1 +1 @@ -A table tab switches between its data and its structure from the bottom bar, as on macOS. +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 a59a763415..de17810217 100644 --- a/linux/crates/app/src/application/accelerators.rs +++ b/linux/crates/app/src/application/accelerators.rs @@ -118,11 +118,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..9c93fc7ab3 100644 --- a/linux/crates/app/src/ui/browse_tab/browse_actions.rs +++ b/linux/crates/app/src/ui/browse_tab/browse_actions.rs @@ -62,7 +62,6 @@ pub(super) fn install_browse_actions(tab: &BrowseTab, page_size: u64) -> BrowseA } }); group.add_action(&page_size); - add("refresh", || PagingInput::RequestRefresh.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); @@ -76,8 +75,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 +102,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 3ed7a75cb7..d284c0e2b3 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 1584704e01..9cef2be03a 100644 --- a/linux/crates/app/src/ui/browse_tab/data_input.rs +++ b/linux/crates/app/src/ui/browse_tab/data_input.rs @@ -8,6 +8,7 @@ use super::BrowseCommand; pub(crate) enum DataInput { /// The tab is built: read the columns, then the page and the count. Start, + Renamed(String), /// A reply to one of the tab's reads. Command(BrowseCommand), /// A reconnect replaced the session's connection. diff --git a/linux/crates/app/src/ui/browse_tab/imp.rs b/linux/crates/app/src/ui/browse_tab/imp.rs index 12b0218c2d..66ee1d7eb0 100644 --- a/linux/crates/app/src/ui/browse_tab/imp.rs +++ b/linux/crates/app/src/ui/browse_tab/imp.rs @@ -28,11 +28,11 @@ pub struct BrowseTab { #[template_child] pub no_pk_banner: TemplateChild, #[template_child] - pub view_stack: TemplateChild, + pub view_stack: TemplateChild, #[template_child] pub structure_host: TemplateChild, #[template_child] - pub view_toggle: TemplateChild, + pub view_toggle: TemplateChild, #[template_child] pub data_start: TemplateChild, #[template_child] @@ -75,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, diff --git a/linux/crates/app/src/ui/browse_tab/layout.rs b/linux/crates/app/src/ui/browse_tab/layout.rs index 95a8522f33..dfcd0e2e56 100644 --- a/linux/crates/app/src/ui/browse_tab/layout.rs +++ b/linux/crates/app/src/ui/browse_tab/layout.rs @@ -158,7 +158,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 642f1474a6..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,7 +392,6 @@ impl BrowseTab { self.connect_closure("save-requested", false, glib::closure_local!(move |tab: &Self| f(tab))) } - /// The Structure view opened for the first time and has nothing to show. pub fn connect_structure_requested(&self, f: F) -> glib::SignalHandlerId { self.connect_closure( "structure-requested", @@ -397,39 +400,68 @@ impl BrowseTab { ) } - /// Offer the Data and Structure switch, where the engine has a - /// structure to show. pub fn offer_structure(&self) { let imp = self.imp(); imp.view_toggle.set_visible(true); let tab = self.downgrade(); - imp.view_toggle.connect_active_name_notify(move |_| { + imp.view_stack.connect_visible_child_name_notify(move |_| { if let Some(tab) = tab.upgrade() { - tab.follow_view_toggle(); + tab.follow_selected_view(); } }); } - /// Show `structure` as the tab's Structure view. - pub fn set_structure(&self, structure: &impl IsA) { + pub fn set_structure(&self, structure: &crate::ui::structure_tab::StructureTab) { libadwaita::prelude::BinExt::set_child(&*self.imp().structure_host, Some(structure)); } - fn follow_view_toggle(&self) { + 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 = imp.view_toggle.active_name().as_deref() == Some("structure"); - if structure && libadwaita::prelude::BinExt::child(&*imp.structure_host).is_none() { + 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.view_stack - .set_visible_child_name(if structure { "structure" } else { "data" }); - // Each says something about the rows, and is hidden rather than - // unrevealed because the data view decides whether it is revealed. - imp.stale_banner.set_visible(!structure); - imp.read_only_banner.set_visible(!structure); - imp.no_pk_banner.set_visible(!structure); 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. diff --git a/linux/crates/app/src/ui/browse_tab/page_label.rs b/linux/crates/app/src/ui/browse_tab/page_label.rs index 94aefc2f11..bb718ed50a 100644 --- a/linux/crates/app/src/ui/browse_tab/page_label.rs +++ b/linux/crates/app/src/ui/browse_tab/page_label.rs @@ -2,7 +2,6 @@ use super::page_state::PageState; use super::row_total::RowTotal; use crate::ui::format::format_thousands; -/// The paginator's text for the page on screen. pub(super) fn page_range_label(page: &PageState, total: &RowTotal) -> String { label_with(page, total, format_thousands) } 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 5e19a53d64..2370a73c03 100644 --- a/linux/crates/app/src/ui/browse_tab/pager_bar.rs +++ b/linux/crates/app/src/ui/browse_tab/pager_bar.rs @@ -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) { 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 360d3f2298..51a1dd319a 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/mod.rs @@ -1185,7 +1185,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() @@ -1537,33 +1537,89 @@ fn a_dotted_field_of_a_document_neither_sorts_nor_takes_an_edit() { assert_eq!(harness.tracker.pending_count(), 0); } -/// The Structure view is asked for once, the first time it is switched to, -/// and the data view's controls leave the bottom bar for it. #[gtk4::test] fn the_bottom_bar_switches_between_data_and_structure() { - use gtk4::prelude::*; use gtk4::subclass::prelude::ObjectSubclassIsExt; let harness = Harness::open(serving_table(), []); - let tab = harness.tab().clone(); + 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()); - - imp.view_toggle.set_active_name(Some("structure")); + 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_eq!(imp.view_stack.visible_child_name().as_deref(), Some("structure")); 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); +} - tab.set_structure(>k4::Label::new(None)); - imp.view_toggle.set_active_name(Some("data")); - imp.view_toggle.set_active_name(Some("structure")); - assert_eq!(asked.get(), 1, "a view that is built is asked for again"); +#[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; - imp.view_toggle.set_active_name(Some("data")); - assert_eq!(imp.view_stack.visible_child_name().as_deref(), Some("data")); - assert!(imp.data_start.is_visible()); + 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); } 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 90fc76daff..834ad34eb2 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/total.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/total.rs @@ -395,3 +395,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 4a7ffe816d..2bdbb9750c 100644 --- a/linux/crates/app/src/ui/data_grid/columns.rs +++ b/linux/crates/app/src/ui/data_grid/columns.rs @@ -141,7 +141,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(), @@ -534,7 +534,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())); } @@ -685,7 +685,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 a245acb32c..bec10343c8 100644 --- a/linux/crates/app/src/ui/data_grid/grid_menu.rs +++ b/linux/crates/app/src/ui/data_grid/grid_menu.rs @@ -111,8 +111,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(); @@ -157,7 +159,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 1b043907fd..5723e67a66 100644 --- a/linux/crates/app/src/ui/data_grid/imp.rs +++ b/linux/crates/app/src/ui/data_grid/imp.rs @@ -55,7 +55,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 f1b2db8c4b..7d301f617f 100644 --- a/linux/crates/app/src/ui/data_grid/mod.rs +++ b/linux/crates/app/src/ui/data_grid/mod.rs @@ -77,7 +77,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)); @@ -95,8 +95,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/tests/columns.rs b/linux/crates/app/src/ui/data_grid/tests/columns.rs index 887d76ac09..87fffdcb99 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/mod.rs b/linux/crates/app/src/ui/structure_tab/mod.rs index 64ce0d586f..5baaa981e4 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..0abed918bb 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,6 +111,45 @@ impl StructureModel { } } + fn request_refresh(&mut self, fx: &mut StructureEffects) { + if self.saving || self.tracker.is_saving() { + 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) { let pending = self.pending(); match SaveGate::of(&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 f4779531f3..86e68c68b2 100644 --- a/linux/crates/app/src/ui/structure_tab/tests.rs +++ b/linux/crates/app/src/ui/structure_tab/tests.rs @@ -1313,6 +1313,214 @@ 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(definition("id"))) + .always(FakeReply::ok(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(); + drain_main_context(); + + 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) diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index b903bca031..1e3fde6569 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -362,7 +362,6 @@ pub struct TableTabSlot { pub schema: Option, pub table: String, pub browse: BrowseTab, - /// The Structure view, made the first time it is asked for. pub structure: Option, } @@ -398,8 +397,6 @@ impl WorkspaceTab { } } - /// The Structure-side controller: a `Structure` slot's, or the - /// Structure view of a `Table` slot that has opened it. pub fn structure_tab(&self) -> Option<&crate::ui::structure_tab::StructureTab> { match self { WorkspaceTab::Structure(s) => Some(&s.structure), @@ -591,9 +588,7 @@ pub(crate) enum WorkspaceInput { /// workspace is saved. WorkspaceTabsChanged, SaveTab(Uuid), - /// Save a table tab's Structure view, whatever its rows hold. SaveStructure(Uuid), - /// A table tab's Structure view opened for the first time. ShowTableStructure(Uuid), // A query tab's changed rows alone, never its SQL file. SaveRows(Uuid), diff --git a/linux/crates/app/src/ui/workspace/structure.rs b/linux/crates/app/src/ui/workspace/structure.rs index 3c8baab0ef..4930930fab 100644 --- a/linux/crates/app/src/ui/workspace/structure.rs +++ b/linux/crates/app/src/ui/workspace/structure.rs @@ -70,7 +70,6 @@ impl WorkspaceModel { }); } - /// Build a table tab's Structure view, the first time it opens. 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())), @@ -268,12 +267,12 @@ impl WorkspaceModel { SaveKind::UpdateInPlace(slot.schema.clone(), slot.table.clone()) } }, - // The rows are read by the name the tab was built with, - // so a renamed table opens again under its new one. - Some(WorkspaceTab::Table(slot)) => match new_table_name.clone() { - Some(name) => SaveKind::PromoteNewToTable(slot.schema.clone(), name), - None => 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, } }; @@ -295,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 { diff --git a/linux/crates/app/src/ui/workspace/tab_factory.rs b/linux/crates/app/src/ui/workspace/tab_factory.rs index 7e9720c0df..49d1f29833 100644 --- a/linux/crates/app/src/ui/workspace/tab_factory.rs +++ b/linux/crates/app/src/ui/workspace/tab_factory.rs @@ -267,7 +267,9 @@ impl TabFactory { } 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, @@ -308,8 +310,6 @@ impl TabFactory { })) } - /// The Structure view of the table tab `id`. It goes under the tab's - /// own id, so the tab's close and save prompts cover its edits. pub(super) fn table_structure(&self, id: Uuid, schema: Option, table: String) -> Option { let parts = &self.parts; let session = parts.context.active.get()?; @@ -323,6 +323,13 @@ impl TabFactory { first_load: FirstLoad::Now, }); connect_structure(&structure, id, &parts.input, WorkspaceInput::SaveStructure); + 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) } @@ -507,7 +514,7 @@ 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::SaveRows(tab_id))); let structure = input.clone(); browse.connect_structure_requested(move |_| structure.deliver(WorkspaceInput::ShowTableStructure(tab_id))); let stop = 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 b98e455209..04528ac03f 100644 --- a/linux/crates/app/src/ui/workspace/tests/close_tab.rs +++ b/linux/crates/app/src/ui/workspace/tests/close_tab.rs @@ -334,3 +334,181 @@ fn close_all_tabs_asks_before_closing_unsaved_work() { assert!(tab_is_open(&test, id), "the tab with unsaved changes closed"); 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::SaveRows(id)); + wait_until(WAIT, || { + tracker.pending_state() == crate::workspace::PendingState::Saving + }) + .expect("the row save starts"); + + if refresh_first { + assert!(answer(&test.window, "discard")); + } else { + workspace.with_model(|model| model.on_refresh_tab(id)); + drain_main_context(); + assert!( + visible_alert(&test.window).is_none(), + "refresh offered to discard an active save" + ); + } + 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")); +} diff --git a/linux/crates/app/src/ui/workspace/workspace_tabs.rs b/linux/crates/app/src/ui/workspace/workspace_tabs.rs index dbee8bb060..475449a366 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; @@ -431,47 +432,89 @@ impl WorkspaceModel { let Some(id) = self.selected_workspace_tab_id() else { return; }; - let key = match self.workspace_tabs.borrow().get(&id) { - Some(WorkspaceTab::Key(slot)) => Some(slot.tab.clone()), - _ => None, + let (key, table) = match self.workspace_tabs.borrow().get(&id) { + Some(WorkspaceTab::Key(slot)) => (Some(slot.tab.clone()), false), + Some(WorkspaceTab::Table(_) | WorkspaceTab::Structure(_)) => (None, true), + _ => (None, false), }; - match key { - Some(tab) => tab.refresh(), - None => { - if let Some(id) = self.selected_browse_tab_id() { - self.on_refresh_tab(id); - } - } + if let Some(tab) = key { + tab.refresh(); + } else if table { + self.on_refresh_tab(id); } } 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; + } + if state == PendingState::Clean { + browse.send(PagingInput::Refresh); 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( + 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) @@ -708,6 +751,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_handle.rs b/linux/crates/app/src/workspace/workspace_handle.rs index f0b64de6e9..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,8 +202,6 @@ impl WorkspaceHandle { self.save_rows(tab, tracker) } - /// Save the Structure view's edits of a table tab, whose rows may - /// have edits of their own. 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; @@ -283,12 +284,19 @@ impl WorkspaceHandle { } fn pending_state(&self, tab: Uuid) -> PendingState { - let rows = self.0.deps.rows.get(tab).map(|tracker| tracker.pending_state()); - match rows { - // A table tab holds both, with its Structure view's edits - // waiting behind clean rows. - Some(state) if state != PendingState::Clean => state, - _ => self.structure_state(tab), + 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, } } @@ -300,6 +308,17 @@ 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); } @@ -358,6 +377,9 @@ impl WorkspaceHandle { ) -> 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); }; @@ -418,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), @@ -807,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 0ee1676eb7..d53988a2c6 100644 --- a/linux/data/resources/shortcuts-dialog.ui +++ b/linux/data/resources/shortcuts-dialog.ui @@ -141,13 +141,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 8d25edb150..d8a410d868 100644 --- a/linux/data/resources/ui/browse-tab.ui +++ b/linux/data/resources/ui/browse-tab.ui @@ -1,10 +1,7 @@ - - - + + diff --git a/linux/docs/state-management.md b/linux/docs/state-management.md index 8550e8077c..400d43a1c4 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`). From 4c31e3836994138c342e51142150239474b569cb Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 20:40:25 +0700 Subject: [PATCH 04/13] fix(linux-browse): protect structure drafts during reloads --- .../app/src/ui/structure_tab/load_handlers.rs | 13 +- .../app/src/ui/structure_tab/save_handlers.rs | 31 ++-- .../crates/app/src/ui/structure_tab/tests.rs | 151 ++++++++++++++++++ 3 files changed, 180 insertions(+), 15 deletions(-) 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/save_handlers.rs b/linux/crates/app/src/ui/structure_tab/save_handlers.rs index 0abed918bb..48c609e374 100644 --- a/linux/crates/app/src/ui/structure_tab/save_handlers.rs +++ b/linux/crates/app/src/ui/structure_tab/save_handlers.rs @@ -112,7 +112,11 @@ impl StructureModel { } fn request_refresh(&mut self, fx: &mut StructureEffects) { - if self.saving || self.tracker.is_saving() { + if self.saving || self.tracker.is_saving() || self.load.is_running() { + return; + } + if self.refetching { + fx.input(SaveInput::Reload); return; } let unknown = matches!( @@ -151,6 +155,10 @@ impl StructureModel { } 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 => {} @@ -197,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(), @@ -231,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)); } @@ -270,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/tests.rs b/linux/crates/app/src/ui/structure_tab/tests.rs index 86e68c68b2..717bce2c62 100644 --- a/linux/crates/app/src/ui/structure_tab/tests.rs +++ b/linux/crates/app/src/ui/structure_tab/tests.rs @@ -405,6 +405,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(), []); From 4ee4c26fcadb0e4b53c473f9072c7ffe8b95a674 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 20:50:21 +0700 Subject: [PATCH 05/13] fix(linux-browse): keep table commands reachable in narrow tabs --- .../app/src/ui/browse_tab/browse_actions.rs | 6 +- linux/crates/app/src/ui/browse_tab/layout.rs | 11 +++- .../crates/app/src/ui/browse_tab/pager_bar.rs | 41 +++++++++--- .../crates/app/src/ui/browse_tab/tests/mod.rs | 66 +++++++++++++++++++ .../app/src/ui/workspace/tests/shell.rs | 20 ++++-- linux/data/resources/ui/browse-tab.ui | 39 ++++++----- 6 files changed, 151 insertions(+), 32 deletions(-) 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 9c93fc7ab3..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,9 +62,13 @@ pub(super) fn install_browse_actions(tab: &BrowseTab, page_size: u64) -> BrowseA } }); group.add_action(&page_size); + 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()), diff --git a/linux/crates/app/src/ui/browse_tab/layout.rs b/linux/crates/app/src/ui/browse_tab/layout.rs index dfcd0e2e56..4bc60a34ce 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. @@ -79,8 +77,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 } 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 2370a73c03..6c1ad61782 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(); } @@ -258,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() @@ -346,18 +355,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), @@ -368,8 +381,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] @@ -504,17 +521,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/tests/mod.rs b/linux/crates/app/src/ui/browse_tab/tests/mod.rs index 51a1dd319a..6007b4fa68 100644 --- a/linux/crates/app/src/ui/browse_tab/tests/mod.rs +++ b/linux/crates/app/src/ui/browse_tab/tests/mod.rs @@ -1243,6 +1243,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; diff --git a/linux/crates/app/src/ui/workspace/tests/shell.rs b/linux/crates/app/src/ui/workspace/tests/shell.rs index b264b074a4..44183216c7 100644 --- a/linux/crates/app/src/ui/workspace/tests/shell.rs +++ b/linux/crates/app/src/ui/workspace/tests/shell.rs @@ -276,16 +276,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/data/resources/ui/browse-tab.ui b/linux/data/resources/ui/browse-tab.ui index d8a410d868..13feb86675 100644 --- a/linux/data/resources/ui/browse-tab.ui +++ b/linux/data/resources/ui/browse-tab.ui @@ -7,7 +7,9 @@ 160 - max-width: 680sp + max-width: 860sp + false + false false false false @@ -127,21 +129,26 @@ 6 - - list-add-symbolic - grid.insert-row - - - - - - list-remove-symbolic - grid.delete-rows - + + 6 + + + list-add-symbolic + grid.insert-row + + + + + + list-remove-symbolic + grid.delete-rows + + + From 2816b11c4f821e4a27b2c6311e68d57a8260203d Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 21:42:29 +0700 Subject: [PATCH 06/13] refactor(linux-browse): group workspace save requests --- linux/crates/app/src/ui/workspace/mod.rs | 12 ++------ linux/crates/app/src/ui/workspace/saves.rs | 29 +++++++++++++------ .../app/src/ui/workspace/tab_factory.rs | 21 +++++++------- .../app/src/ui/workspace/tests/close_tab.rs | 4 +-- .../app/src/ui/workspace/workspace_tabs.rs | 7 ----- 5 files changed, 35 insertions(+), 38 deletions(-) diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 1e3fde6569..c0598447f8 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; @@ -587,12 +588,8 @@ pub(crate) enum WorkspaceInput { /// The tab order, the selection or a tab's state changed, so the /// workspace is saved. WorkspaceTabsChanged, - SaveTab(Uuid), - SaveStructure(Uuid), + Save(SaveRequest), ShowTableStructure(Uuid), - // A query tab's changed rows alone, never its SQL file. - SaveRows(Uuid), - StopSaving(Uuid), /// A save started or settled, or tabs' changes were dropped. Workspace(crate::workspace::WorkspaceEvent), SavesInFlightChanged(usize), @@ -1342,11 +1339,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::SaveStructure(id) => self.request_save_structure(id), + WorkspaceInput::Save(request) => self.on_save_request(request), WorkspaceInput::ShowTableStructure(id) => self.on_show_table_structure(id), - WorkspaceInput::StopSaving(id) => self.stop_saving(id), WorkspaceInput::Workspace(event) => self.on_workspace_event(event), WorkspaceInput::SavesInFlightChanged(count) => self.on_saves_in_flight_changed(count), WorkspaceInput::EditorTransactionChanged => self.on_editor_transaction_changed(), diff --git a/linux/crates/app/src/ui/workspace/saves.rs b/linux/crates/app/src/ui/workspace/saves.rs index 023989f851..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,7 +68,7 @@ impl WorkspaceModel { }); } - pub(super) fn request_save_structure(&self, tab: Uuid) { + fn request_save_structure(&self, tab: Uuid) { let Some(parent) = self.dialog_parent() else { return; }; @@ -69,10 +84,6 @@ impl WorkspaceModel { }); } - pub(super) fn stop_saving(&self, tab: Uuid) { - self.workspace_handle.stop_saves(CloseScope::Tab(tab)); - } - pub(super) fn on_workspace_event(&mut self, event: WorkspaceEvent) { match event { WorkspaceEvent::SaveStarted { tab, kind } => { diff --git a/linux/crates/app/src/ui/workspace/tab_factory.rs b/linux/crates/app/src/ui/workspace/tab_factory.rs index 49d1f29833..58261b393c 100644 --- a/linux/crates/app/src/ui/workspace/tab_factory.rs +++ b/linux/crates/app/src/ui/workspace/tab_factory.rs @@ -19,7 +19,7 @@ use super::tab_title::{ConnectionLabel, apply_tab_title, resolve_tab_title}; use super::table_naming::TableNaming; use super::workspace_persistence::WorkspaceTabs; use super::{ - DiagramTabSlot, EditorTabSlot, KeyTabSlot, OpenMode, StructureTabSlot, TableTabSlot, WorkspaceInput, + DiagramTabSlot, EditorTabSlot, KeyTabSlot, OpenMode, SaveRequest, StructureTabSlot, TableTabSlot, WorkspaceInput, WorkspaceSender, WorkspaceShell, WorkspaceTab, }; use crate::runtime::DeliverInput; @@ -296,7 +296,7 @@ impl TabFactory { tasks: parts.context.tasks.clone(), first_load, }); - connect_structure(&structure, id, &parts.input, WorkspaceInput::SaveTab); + 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)); @@ -322,7 +322,7 @@ impl TabFactory { tasks: parts.context.tasks.clone(), first_load: FirstLoad::Now, }); - connect_structure(&structure, id, &parts.input, WorkspaceInput::SaveStructure); + 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(); @@ -435,19 +435,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, - save_message: fn(Uuid) -> WorkspaceInput, + 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(save_message(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 }); @@ -514,11 +513,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::SaveRows(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(); @@ -558,9 +557,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 04528ac03f..f4c4b851b6 100644 --- a/linux/crates/app/src/ui/workspace/tests/close_tab.rs +++ b/linux/crates/app/src/ui/workspace/tests/close_tab.rs @@ -9,7 +9,7 @@ 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}; @@ -398,7 +398,7 @@ fn refreshing_cannot_discard_rows_while_their_save_is_running() { workspace .sender() .expect("workspace input") - .deliver(WorkspaceInput::SaveRows(id)); + .deliver(WorkspaceInput::Save(SaveRequest::Rows(id))); wait_until(WAIT, || { tracker.pending_state() == crate::workspace::PendingState::Saving }) diff --git a/linux/crates/app/src/ui/workspace/workspace_tabs.rs b/linux/crates/app/src/ui/workspace/workspace_tabs.rs index 475449a366..1da5f3418c 100644 --- a/linux/crates/app/src/ui/workspace/workspace_tabs.rs +++ b/linux/crates/app/src/ui/workspace/workspace_tabs.rs @@ -572,13 +572,6 @@ impl WorkspaceModel { self.index.id_of(&self.tab_view.selected_page()?) } - pub(super) fn selected_browse_tab_id(&self) -> Option { - let id = self.selected_workspace_tab_id()?; - let tabs = self.workspace_tabs.borrow(); - let slot = tabs.get(&id)?; - if slot.browse_tab().is_some() { Some(id) } else { None } - } - /// Stop every tab and let go of the tab view. The pending edits /// name rows of the connection going away, so they cannot be saved /// after it. From 9fb78f6015f01e3a8cab505c15845be05cdc3fdf Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 22:51:47 +0700 Subject: [PATCH 07/13] test(linux-browse): exercise refresh guards during valid saves --- linux/crates/app/src/ui/structure_tab/tests.rs | 10 ++++++++-- .../crates/app/src/ui/workspace/tests/close_tab.rs | 13 +++++++++---- 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/linux/crates/app/src/ui/structure_tab/tests.rs b/linux/crates/app/src/ui/structure_tab/tests.rs index 717bce2c62..c275bb301f 100644 --- a/linux/crates/app/src/ui/structure_tab/tests.rs +++ b/linux/crates/app/src/ui/structure_tab/tests.rs @@ -1468,8 +1468,14 @@ fn refreshable_structure() -> Harness { let mut script = postgres_script(); script .fetch_table_definition - .once(FakeReply::ok(definition("id"))) - .always(FakeReply::ok(definition("server_id"))); + .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 { 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 f4c4b851b6..191df0e142 100644 --- a/linux/crates/app/src/ui/workspace/tests/close_tab.rs +++ b/linux/crates/app/src/ui/workspace/tests/close_tab.rs @@ -399,19 +399,24 @@ fn refreshing_cannot_discard_rows_while_their_save_is_running() { .sender() .expect("workspace input") .deliver(WorkspaceInput::Save(SaveRequest::Rows(id))); + let connection = test.connection(); wait_until(WAIT, || { tracker.pending_state() == crate::workspace::PendingState::Saving + && !connection.observed_cancels("write_batch").is_empty() }) - .expect("the row save starts"); + .expect("the row save reaches the driver"); if refresh_first { assert!(answer(&test.window, "discard")); } else { workspace.with_model(|model| model.on_refresh_tab(id)); - drain_main_context(); + // 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!( - visible_alert(&test.window).is_none(), - "refresh offered to discard an active save" + 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); From e703e5840ee084b743681e038d250bac29016b9f Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 23:00:04 +0700 Subject: [PATCH 08/13] test(linux-browse): bound structure save frame waits --- linux/crates/app/src/ui/structure_tab/tests.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/linux/crates/app/src/ui/structure_tab/tests.rs b/linux/crates/app/src/ui/structure_tab/tests.rs index c275bb301f..8c3345e8fb 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); @@ -1581,7 +1581,7 @@ fn structure_refresh_during_a_save_keeps_the_draft_without_a_read_or_prompt() { harness.tab().send(SaveInput::SaveStarted); harness.tab().request_refresh(); - drain_main_context(); + after_next_frame(&window); assert!(window.visible_dialog().is_none()); assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); @@ -1686,7 +1686,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] From bcc5d790d5cd044718fd3cf1e784ac8fe6799886 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Sun, 8 Nov 2026 23:45:47 +0700 Subject: [PATCH 09/13] test(linux-browse): pass the owned window to the frame wait --- linux/crates/app/src/ui/structure_tab/tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/linux/crates/app/src/ui/structure_tab/tests.rs b/linux/crates/app/src/ui/structure_tab/tests.rs index 8c3345e8fb..4556f93105 100644 --- a/linux/crates/app/src/ui/structure_tab/tests.rs +++ b/linux/crates/app/src/ui/structure_tab/tests.rs @@ -1581,7 +1581,7 @@ fn structure_refresh_during_a_save_keeps_the_draft_without_a_read_or_prompt() { harness.tab().send(SaveInput::SaveStarted); harness.tab().request_refresh(); - after_next_frame(&window); + after_next_frame(&*window); assert!(window.visible_dialog().is_none()); assert_eq!(harness.comments(), [Some("pending comment".to_owned())]); From 6bd9152db2434504b6b164f75eeeb3ab58e3fc65 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 01:17:18 +0700 Subject: [PATCH 10/13] test(linux-browse): report refresh save wait state --- .../app/src/ui/workspace/tests/close_tab.rs | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) 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 191df0e142..fe1a3a7a23 100644 --- a/linux/crates/app/src/ui/workspace/tests/close_tab.rs +++ b/linux/crates/app/src/ui/workspace/tests/close_tab.rs @@ -400,11 +400,24 @@ fn refreshing_cannot_discard_rows_while_their_save_is_running() { .expect("workspace input") .deliver(WorkspaceInput::Save(SaveRequest::Rows(id))); let connection = test.connection(); - wait_until(WAIT, || { + 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() - }) - .expect("the row save reaches the driver"); + }); + 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")); From 560c913e67d39a61c4bebd1699a44ae629b4b0db Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 02:14:57 +0700 Subject: [PATCH 11/13] test(linux-browse): use typed columns in row save fixtures --- linux/crates/app/src/ui/workspace/tests/close_tab.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) 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 fe1a3a7a23..3ad1711c17 100644 --- a/linux/crates/app/src/ui/workspace/tests/close_tab.rs +++ b/linux/crates/app/src/ui/workspace/tests/close_tab.rs @@ -3,7 +3,7 @@ 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}; @@ -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()], From 3fb1996cd71ad2169218347e0d4428291c73fcfd Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 16:46:32 +0700 Subject: [PATCH 12/13] fix(linux-workspace): drop the line-count expectation the shorter update no longer meets --- linux/crates/app/src/ui/workspace/mod.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 8f6f3673e5..0e99c0bf75 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -1329,10 +1329,6 @@ impl WorkspaceModel { } } - #[expect( - clippy::too_many_lines, - reason = "Each workspace input dispatches to its own handler" - )] fn update(&mut self, msg: WorkspaceInput) { match msg { WorkspaceInput::HealthChanged(health) => self.refresh_health_banner(&health), From 6f8ac5096e5504f6ac7dd2178b7d84feadf0751c Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Mon, 9 Nov 2026 21:32:34 +0700 Subject: [PATCH 13/13] fix(linux-grid): pass the NULL text to the row details field search #4113 and #4134 landed one after the other, and main stopped compiling at this call. --- linux/crates/app/src/ui/data_grid/row_detail/fields.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) 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) }