fix(linux): unified-tabs audit cleanup (B1-B5+B8)

Five fixes from the post-a8f573fc audit. All observable in normal use.

B1 — Window title now updates on tab switch.
WorkspaceTabsChanged previously only persisted state. The title
shows "<table> · <connection> · <driver>" when a Browse tab is
active, so the previous tab's table name lingered after switching.

  Fix: introduce on_workspace_tabs_changed that does
  persist_workspace_state + refresh_window_title + sync_sidebar_selection
  in one shot. Single dispatcher handler so the trio stays in lockstep.

B2 — Drag-reorder now persists.
Only connect_selected_page_notify was wired, so dragging tabs into
a new order didn't write workspace_state.json until the next other
event (e.g. selecting a tab). Restart-then the order was wrong.

  Fix: also wire connect_pages_notify → AppMsg::WorkspaceTabsChanged.
  Insert/remove/reorder all flow through the same persist path.

B3 — Overview "+" tab labelling.
The AdwTabOverview "+" button entry-point synthesised an editor
slot inline with the hardcoded label "Empty query"; append_editor_tab
labels new tabs "Query 1", "Query 2", … via default_editor_tab_label.
Same widget kind, two different labels depending on entry point.

  Fix: count existing editor tabs in the overview closure and use
  default_editor_tab_label(count + 1). Both paths now produce the
  same label.

B4 — Sidebar selection now follows the active Browse tab.
Switching from `users` tab to `orders` tab left the sidebar's
highlighted row on whichever was last *clicked*, regardless of
the active tab. Visually misleading.

  Fix: sync_sidebar_selection (called from on_workspace_tabs_changed)
  walks the listbox children, finds the row whose title + paired
  schema matches the active Browse tab, and calls listbox.select_row.
  No-op when active is an Editor tab (sidebar selection persists,
  matching user intuition: you switch to editor and back, sidebar
  state shouldn't reshuffle). select_row doesn't fire row-activated
  (user gesture only) so this can't recurse into SelectTable.

B5 — "Replace current tab" from history with a Browse tab active.
HistoryDialogOutput::ReplaceCurrentTabQuery → AppMsg::ReplaceActiveTabQuery
→ on_replace_active_tab_query previously checked if the active tab
was an Editor; if not, silent no-op. User clicked "Replace" while
browsing → nothing happened, no feedback.

  Fix: when active is Browse (or no tab), fall back to opening a
  new Editor tab with the query. Mirrors "Open in new tab" semantics
  but keeps the user's intent of running this query right now.

B8 — History "Open/Replace" while disconnected.
History is app-wide (Ctrl+H works disconnected to view past queries
across sessions). But OpenHistoryQuery / ReplaceActiveTabQuery without
an active connection silently created an invisible tab in the
workspace_root that was never displayed.

  Fix: gate both OpenHistoryQuery and ReplaceActiveTabQuery on
  self.connected; show a "Connect to a database first" toast when
  the user clicks while disconnected.

Deferred from the audit:
  B6 (F5 / Ctrl+F context-sensitivity) — design choice, separate fix
  B7 (read-only fan-out) — no path triggers a live read-only flip today
  B9 (double persist on selection change) — minor I/O wastage
  B10 (monotonic editor labels) — cosmetic; user retypes anyway

Verification:
- cargo clippy --workspace --all-targets -- -D warnings: zero warnings
- cargo test --workspace --lib: 43 pass, 1 ignored
- cargo fmt --all -- --check: clean
- cargo build -p tablepro-app: clean

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: datlechin

linux/crates/app/src/ui/app/mod.rs

@@ -690,7 +690,7 @@ impl SimpleComponent for App {
             AppMsg::FetchBrowsePage(tab_id) => self.fetch_browse_page(tab_id, sender),
             AppMsg::FetchBrowseColumns(tab_id) => self.fetch_browse_columns(tab_id, sender),
             AppMsg::FetchBrowseRowCount(tab_id) => self.fetch_browse_row_count(tab_id, sender),
-            AppMsg::WorkspaceTabsChanged => self.persist_workspace_state(),
+            AppMsg::WorkspaceTabsChanged => self.on_workspace_tabs_changed(),
             AppMsg::WorkspaceSchemaWordsChanged => self.rebuild_schema_buffer(),
             AppMsg::WorkspaceTabClosed(id) => self.close_workspace_tab_by_id(id, sender),
             AppMsg::CloseActiveWorkspaceTab => self.close_active_workspace_tab(sender),
@@ -757,9 +757,19 @@ impl SimpleComponent for App {
             AppMsg::EditorTabQueryChanged(id, text) => self.on_editor_tab_query_changed(id, text),
             AppMsg::ShowHistory => self.on_show_history(sender),
             AppMsg::OpenHistoryQuery(text) => {
-                self.append_editor_tab(Some(text), sender);
+                if self.connected {
+                    self.append_editor_tab(Some(text), sender);
+                } else {
+                    self.show_toast(&crate::tr!("Connect to a database first to run SQL."));
+                }
+            }
+            AppMsg::ReplaceActiveTabQuery(text) => {
+                if self.connected {
+                    self.on_replace_active_tab_query(text, sender);
+                } else {
+                    self.show_toast(&crate::tr!("Connect to a database first to run SQL."));
+                }
             }
-            AppMsg::ReplaceActiveTabQuery(text) => self.on_replace_active_tab_query(text),
             AppMsg::PollHealth => self.on_poll_health(),
             AppMsg::RefreshPage => self.on_refresh_active_tab(),
             AppMsg::ShowShortcuts => self.on_show_shortcuts(),

linux/crates/app/src/ui/app/workspace_tabs.rs

@@ -69,10 +69,18 @@ impl App {
             glib::Propagation::Stop
         });
 
+        // Both selection-change AND any pages-list change (insert /
+        // remove / drag-reorder) trigger persist + title-refresh.
+        // Without connect_pages_notify, drag-reorder doesn't persist
+        // until the next other event.
         let pages_sender = sender.clone();
         tab_view.connect_selected_page_notify(move |_| {
             pages_sender.input(AppMsg::WorkspaceTabsChanged);
         });
+        let reorder_sender = sender.clone();
+        tab_view.connect_pages_notify(move |_| {
+            reorder_sender.input(AppMsg::WorkspaceTabsChanged);
+        });
 
         let inner = gtk::Box::builder().orientation(gtk::Orientation::Vertical).build();
         inner.append(&tab_bar);
@@ -88,6 +96,10 @@ impl App {
         // we build an SqlEditor inline, register the slot, and return
         // the page. Browse tabs aren't creatable from the overview
         // (they need a sidebar table target).
+        // Overview "+" must return a real TabPage synchronously. We
+        // construct an editor slot inline using the same label scheme
+        // as `append_editor_tab` ("Query 1", "Query 2", …) so the two
+        // entry points are visually indistinguishable.
         let workspace_tabs_for_create = self.workspace_tabs.clone();
         let tab_view_for_create = tab_view.clone();
         let schema_buffer_for_create = self.schema_buffer.clone();
@@ -104,7 +116,12 @@ impl App {
                     SqlEditorOutput::QueryChanged(text) => AppMsg::EditorTabQueryChanged(tab_id, text),
                 });
             let page = tab_view_for_create.append(editor.widget());
-            let label = crate::tr!("Empty query");
+            let editor_count = workspace_tabs_for_create
+                .borrow()
+                .values()
+                .filter(|t| matches!(t, WorkspaceTab::Editor(_)))
+                .count();
+            let label = default_editor_tab_label(editor_count + 1);
             page.set_title(&label);
             page.set_tooltip(&label);
             write_workspace_tab_id(&page, tab_id);
@@ -495,6 +512,44 @@ impl App {
         workspace_state::save_connection(connection_id, conn_state);
     }
 
+    /// Single handler for `WorkspaceTabsChanged`. Persists tab state,
+    /// refreshes the window title (so tab switches update the subtitle),
+    /// and syncs the sidebar selection to the active Browse tab's table.
+    pub(super) fn on_workspace_tabs_changed(&self) {
+        self.persist_workspace_state();
+        self.refresh_window_title();
+        self.sync_sidebar_selection();
+    }
+
+    /// Highlight the sidebar row matching the active Browse tab's
+    /// `(schema, table)`. No-op when active is an Editor tab (we leave
+    /// the sidebar selection on whatever was last clicked, so switching
+    /// to editor and back doesn't disorient).
+    fn sync_sidebar_selection(&self) {
+        let Some((schema, table)) = self.selected_browse_slot_table() else {
+            return;
+        };
+        let listbox = self.sidebar_factory.widget();
+        let schemas = self.sidebar_schemas.borrow();
+        let mut idx = 0_i32;
+        while let Some(row) = listbox.row_at_index(idx) {
+            // The factory builds one row per TableInfo, in the same order
+            // as `sidebar_schemas`, so we can pair each row with its
+            // schema-Option by index.
+            if let Some(action_row) = row.downcast_ref::<adw::ActionRow>() {
+                let row_table = action_row.title().to_string();
+                let row_schema = schemas.get(idx as usize).cloned().unwrap_or(None);
+                if row_table == table && row_schema.as_deref() == schema.as_deref() {
+                    // select_row doesn't trigger row-activated (user-only
+                    // signal), so this won't recurse into SelectTable.
+                    listbox.select_row(Some(action_row));
+                    return;
+                }
+            }
+            idx += 1;
+        }
+    }
+
     pub(super) fn selected_workspace_tab_id(&self) -> Option<Uuid> {
         let tab_view = self.workspace_tab_view.as_ref()?;
         let page = tab_view.selected_page()?;
@@ -594,13 +649,19 @@ impl App {
         }
     }
 
-    pub(super) fn on_replace_active_tab_query(&self, text: String) {
-        let Some(id) = self.selected_workspace_tab_id() else {
-            return;
-        };
-        if let Some(WorkspaceTab::Editor(slot)) = self.workspace_tabs.borrow().get(&id) {
+    pub(super) fn on_replace_active_tab_query(&mut self, text: String, sender: ComponentSender<Self>) {
+        // If an editor tab is active, replace its buffer in-place. If a
+        // browse tab is active (or no tab at all), fall back to opening
+        // a new editor tab with the query — silent no-op was the prior
+        // (annoying) behaviour for users invoking from history while
+        // browsing.
+        if let Some(id) = self.selected_workspace_tab_id()
+            && let Some(WorkspaceTab::Editor(slot)) = self.workspace_tabs.borrow().get(&id)
+        {
             let _ = slot.controller.sender().send(SqlEditorInput::ReplaceQuery(text));
+            return;
         }
+        self.append_editor_tab(Some(text), sender);
     }
 
     fn editor_tab_count(&self) -> usize {