fix(linux): UX bugs batch A — accidental edits, stale toast, Esc dismiss

Three bugs from the deep UI/UX audit, each with a real failure mode:

- Cell edit was triggered by single click. In a database grid this is
  destructive — a misplaced click on the row a user wanted to select
  silently dropped them into an editable label. Switch to double-click,
  matching GNOME Files filename rename. Implementation: keep editable=
  false at rest so the EditableLabel's internal click→edit path is
  inert, flip to editable=true only on double-click via a GestureClick,
  and reset to false on editing-notify exit.

- "Connecting…" was a fire-and-forget toast that auto-dismissed at 2 s,
  leaving remote / SSH-tunnelled connections with no visible feedback
  for the rest of their handshake. Replaced with a persistent toast
  (timeout 0) tracked on App and dismissed when the connect resolves
  (success in on_connected, failure in on_browse_load_failed/None).

- Escape didn't reliably close the in-grid search bar. SearchBar's own
  Esc handler only fires while the SearchEntry has focus; clicking
  outside the bar (e.g. the page-size dropdown) put Esc out of reach.
  Added a Local-scope ShortcutController on the BrowseTab root that
  catches Escape anywhere in the tab and dismisses the bar when
  search-mode is enabled — matches Files / Text Editor.

Audit also flagged sort-indicator restoration and Ctrl+F scoping as
bugs; investigated both and they're false alarms (sort restore is
guarded by columns.get + self-heals on later FetchPage; Ctrl+F is
ShortcutScope::Global on the window so fires regardless of focus).

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

Author: datlechin

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

@@ -175,11 +175,14 @@ impl App {
         self.dispatch_to_tab(tab_id, BrowseTabInput::RowCountLoaded(count));
     }
 
-    pub(super) fn on_browse_load_failed(&self, tab_id: Option<Uuid>, msg: String) {
+    pub(super) fn on_browse_load_failed(&mut self, tab_id: Option<Uuid>, msg: String) {
         match tab_id {
             Some(id) => self.dispatch_to_tab(id, BrowseTabInput::ShowError(msg)),
             None => {
                 tracing::warn!(error = %msg, "app-level load failed");
+                // Connect attempt failed → drop the in-progress toast so
+                // the alert isn't competing with stale "Connecting…" UI.
+                self.dismiss_loading_page();
                 self.set_status_page(super::StatusKind::Error, &crate::tr!("Failed"), &msg);
             }
         }

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

@@ -26,6 +26,7 @@ impl App {
     }
 
     pub(super) fn on_connected(&mut self, tables: Vec<TableInfo>, driver_id: String, sender: ComponentSender<Self>) {
+        self.dismiss_loading_page();
         self.dialog = None;
         self.connected = true;
         self.current_driver_id = Some(driver_id.clone());
@@ -156,7 +157,7 @@ impl App {
         dialog.present(Some(&self.window));
     }
 
-    pub(super) fn on_open_saved(&self, saved: SavedConnection, sender: ComponentSender<Self>) {
+    pub(super) fn on_open_saved(&mut self, saved: SavedConnection, sender: ComponentSender<Self>) {
         self.connections_popover.popdown();
         self.set_loading_page(
             &crate::tr!("Connecting…"),

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

@@ -39,6 +39,11 @@ pub struct App {
     sidebar_schemas: std::rc::Rc<std::cell::RefCell<Vec<Option<String>>>>,
     content_holder: adw::ToolbarView,
     toast_overlay: adw::ToastOverlay,
+    /// Persistent "Connecting…" toast handle. Held so we can dismiss it
+    /// when the connect attempt resolves (success or failure). Native
+    /// alternative to a fire-and-forget 2 s toast that disappeared
+    /// before the connection actually completed.
+    connect_progress_toast: Option<adw::Toast>,
     reconnect_banner: adw::Banner,
     connections_factory: FactoryVecDeque<ConnectionRow>,
     connections_popover: gtk::Popover,
@@ -664,6 +669,7 @@ impl SimpleComponent for App {
             sidebar_schemas,
             content_holder: widgets.content_holder.clone(),
             toast_overlay: widgets.toast_overlay.clone(),
+            connect_progress_toast: None,
             reconnect_banner: widgets.reconnect_banner.clone(),
             connections_factory,
             connections_popover: widgets.connections_popover.clone(),

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

@@ -13,12 +13,29 @@ impl App {
         self.content_holder.set_content(Some(self.welcome_view.widget()));
     }
 
-    /// Used during connect to convey "Connecting…" — surfaces as a toast
-    /// since the welcome view is still visible. Per-tab loading/error
-    /// states live inside BrowseTab now (replace_status_child there).
-    pub(super) fn set_loading_page(&self, title: &str, description: &str) {
-        let _ = description;
-        self.show_toast(title);
+    /// Used during connect to convey "Connecting…". Persistent toast
+    /// (timeout 0) — held in `connect_progress_toast` until the connect
+    /// resolves, at which point `dismiss_loading_page` clears it. Replaces
+    /// the prior fire-and-forget toast which auto-dismissed at 2 s, well
+    /// before remote / SSH-tunnelled connections resolve.
+    pub(super) fn set_loading_page(&mut self, title: &str, description: &str) {
+        if let Some(prev) = self.connect_progress_toast.take() {
+            prev.dismiss();
+        }
+        let body = if description.is_empty() {
+            title.to_string()
+        } else {
+            format!("{title} {description}")
+        };
+        let toast = adw::Toast::builder().title(&body).timeout(0).build();
+        self.toast_overlay.add_toast(toast.clone());
+        self.connect_progress_toast = Some(toast);
+    }
+
+    pub(super) fn dismiss_loading_page(&mut self) {
+        if let Some(toast) = self.connect_progress_toast.take() {
+            toast.dismiss();
+        }
     }
 
     /// Convenience for `set_status_page(Error, ...)` and similar; in the

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

@@ -501,6 +501,30 @@ impl SimpleComponent for BrowseTab {
         root.add_bottom_bar(&paginator_bar);
         grid_search_bar.set_key_capture_widget(Some(&root));
 
+        // SearchBar's built-in Escape handler only fires while the
+        // SearchEntry (or its close button) has focus. If the user opens
+        // search and then clicks the page-size dropdown or any paginator
+        // control, Esc lands outside the bar's reach. A Local-scope
+        // shortcut on root catches Escape anywhere in this tab and
+        // dismisses the bar — matching the GNOME Files / Text Editor
+        // behaviour where Esc reliably closes search regardless of focus.
+        let search_bar_for_esc = grid_search_bar.clone();
+        let esc_shortcut = gtk::Shortcut::builder()
+            .trigger(&gtk::ShortcutTrigger::parse_string("Escape").expect("valid trigger"))
+            .action(&gtk::CallbackAction::new(move |_, _| {
+                if search_bar_for_esc.is_search_mode() {
+                    search_bar_for_esc.set_search_mode(false);
+                    glib::Propagation::Stop
+                } else {
+                    glib::Propagation::Proceed
+                }
+            }))
+            .build();
+        let esc_controller = gtk::ShortcutController::new();
+        esc_controller.set_scope(gtk::ShortcutScope::Local);
+        esc_controller.add_shortcut(esc_shortcut);
+        root.add_controller(esc_controller);
+
         // Per-tab GridMsg channel: events from this tab's grid (sort
         // change, cell edits, context-menu actions) flow into this tab's
         // own input queue, which then re-emits them as outputs to App

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

@@ -152,15 +152,34 @@ fn build_column(
             return;
         };
         if editable_for_setup {
+            // Double-click-to-edit, matching GNOME Files filename rename.
+            // Single-click triggering edit is destructive in a database
+            // grid: an accidental row-selection click would commit the
+            // user into edit mode on the cell they happened to land on.
+            // Pattern: keep editable=false at rest so the EditableLabel's
+            // internal click→edit path is inert; flip true on double-click,
+            // call start_editing(), and flip back to false on
+            // editing-notify exit.
             let label = gtk::EditableLabel::builder()
                 .xalign(0.0)
                 .hexpand(true)
                 .margin_start(8)
                 .margin_end(8)
                 .build();
-            label.set_editable(true);
+            label.set_editable(false);
             item.set_child(Some(&label));
 
+            let dbl_click = gtk::GestureClick::builder().button(gtk::gdk::BUTTON_PRIMARY).build();
+            let label_for_dbl = label.clone();
+            dbl_click.connect_pressed(move |gesture, n_press, _, _| {
+                if n_press == 2 {
+                    gesture.set_state(gtk::EventSequenceState::Claimed);
+                    label_for_dbl.set_editable(true);
+                    label_for_dbl.start_editing();
+                }
+            });
+            label.add_controller(dbl_click);
+
             if let Some(ctx_sender) = context_sender.clone() {
                 attach_context_menu(label.upcast_ref(), idx, context_table.clone(), ctx_sender);
             }
@@ -178,6 +197,9 @@ fn build_column(
                     return;
                 }
                 label.remove_css_class("accent");
+                // Reset to display-only so the next click won't enter
+                // edit mode via EditableLabel's internal handler.
+                label.set_editable(false);
                 let Some(snap) = SNAPSHOT_SLOT.take(label) else {
                     return;
                 };