refactor(linux): filter goes inline + raw SQL escape hatch

UX shape change: AdwDialog → inline GtkRevealer slid in above the
grid. The user filters data they can see; obscuring the grid with a
modal added a round-trip every rule tweak. Strip stays open while
they edit, applies on demand, collapses with Esc / Close (×).
Matches GtkSearchBar's slide-in pattern (the native idiom for
"transient editor above content"), not AdwDialog's
"form-with-validate-then-apply" flow.

Layout (replaces the dialog):

  Filter rows                       Clear all │ Apply │ ×
  Combine rules with: [ All ▾ ]
  ┌─ boxed-list ──────────────────────────────────────┐
  │ [Column ▾] [Op ▾] [Value …]                  [✕]  │
  │ [+ Add rule]                                       │
  └────────────────────────────────────────────────────┘
  ▸ Advanced (raw SQL)

Module rename: filter_dialog.rs → filter_strip.rs. Public surface
swaps `present(parent, ...)` for `build(columns, initial, on_apply)
-> FilterStrip` returning a holder with the revealer + state +
methods to toggle / update_columns / update_filter so BrowseTab can
react to ColumnsLoaded and external FilterApplied without rebuilding
from scratch.

Raw SQL escape hatch:
- FilterSet gains extra_sql: Option<String>. Appended to the
  structured rules with the chosen combinator, wrapped in parens so
  user OR / NOT precedence stays scoped to their fragment.
- Emitted verbatim — no quoting, no parameterisation. Same security
  model as the SQL editor: the user owns the connection. Power
  feature, not an injection vector.
- Whitespace-only extra_sql treated as None so blank entries don't
  emit `WHERE ()`.
- 5 new core tests covering extra_sql alone / combined with rules /
  with OR combinator / blank handling / is_empty + len semantics.

BrowseTab integration:
- Owns Option<FilterStrip>. Built once at init, added as a top bar
  above grid_search_bar.
- ToggleFilterStrip input wired to win.open-filter / Ctrl+R.
- FilterApplied still persists + refetches; now also calls
  strip.update_filter(set) so the editor reflects the committed
  state.
- ColumnsLoaded calls strip.update_columns so operator allowlists
  re-narrow on schema changes.
- Esc inside the strip collapses without applying (Local-scope
  shortcut on the strip's outer Box; doesn't compete with
  cell-editor / search-bar Esc handlers).

Test counts: app 92 (unchanged), core 108 (was 103, +5 extra_sql).
Clippy clean.

Author: datlechin

linux/crates/app/src/services/filter_settings.rs

@@ -117,6 +117,7 @@ mod tests {
                 op: FilterOp::Eq,
                 value: Some(FilterValue::Single("alice".into())),
             }],
+            extra_sql: None,
         }
     }
 

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

@@ -327,39 +327,15 @@ impl App {
         }
     }
 
-    /// Ctrl+R / Filter button — present the filter editor for the
-    /// active Browse tab. Hands the dialog the tab's columns +
-    /// current FilterSet; the dialog calls back via `on_apply` with
-    /// either the new set or `FilterSet::default()` for "Clear all".
-    /// Either way it routes through `BrowseTabInput::FilterApplied`
-    /// so persistence + chrome update + refetch all run in one place.
+    /// Ctrl+R / Filter button — toggle the inline filter strip on
+    /// the active Browse tab. Strip lives inside the tab (always
+    /// constructed at init), so this is just a reveal flip.
     pub(super) fn on_show_filter_dialog(&self) {
         let Some(id) = self.selected_browse_tab_id() else {
             self.show_toast(&crate::tr!("Open a table to filter rows."));
             return;
         };
-        let (columns, current_filter) = {
-            let tabs = self.workspace_tabs.borrow();
-            let Some(controller) = tabs.get(&id).and_then(|t| t.browse_controller()) else {
-                return;
-            };
-            let model = controller.model();
-            (model.columns().to_vec(), model.current_filter().clone())
-        };
-        if columns.is_empty() {
-            // ColumnsLoaded hasn't fired yet — opening the dialog with
-            // no columns would just show an empty Add Rule list.
-            self.show_toast(&crate::tr!("Loading columns… try again in a moment."));
-            return;
-        }
-        let tab_id = id;
-        let workspace_tabs = self.workspace_tabs.clone();
-        let on_apply: std::rc::Rc<dyn Fn(tablepro_core::FilterSet)> = std::rc::Rc::new(move |set| {
-            if let Some(controller) = workspace_tabs.borrow().get(&tab_id).and_then(|t| t.browse_controller()) {
-                let _ = controller.sender().send(BrowseTabInput::FilterApplied(set));
-            }
-        });
-        crate::ui::filter_dialog::present(&self.window, columns, current_filter, on_apply);
+        self.dispatch_to_tab(id, BrowseTabInput::ToggleFilterStrip);
     }
 
     pub(super) fn on_refresh_active_tab(&self) {

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

@@ -98,11 +98,15 @@ pub struct BrowseTab {
     prev_button: gtk::Button,
     next_button: gtk::Button,
     last_button: gtk::Button,
-    /// Toolbar button that opens the filter dialog. Carries an
+    /// Toolbar button that toggles the filter strip. Carries an
     /// `.accent` CSS class + tooltip suffix when the current filter
     /// has any rules; visually flat otherwise so the user spots an
     /// active filter at a glance.
     filter_button: gtk::Button,
+    /// Inline filter editor — slides in above the grid when
+    /// revealed. Owned per-tab so the rules editor doesn't lose
+    /// in-progress state if the user accidentally clicks outside it.
+    filter_strip: Option<crate::ui::filter_strip::FilterStrip>,
     insert_button: gtk::Button,
     delete_button: gtk::Button,
     save_button: gtk::Button,
@@ -142,10 +146,13 @@ pub enum BrowseTabInput {
     /// selections are intentionally preserved — unselecting the
     /// only-row would strand the keyboard focus indicator.
     ClearSelection,
-    /// User confirmed a new filter set in the filter dialog (or
-    /// hit "Clear all" — that's an empty FilterSet). BrowseTab
-    /// persists, resets pagination to offset 0, refreshes chrome,
-    /// and re-fetches.
+    /// Toggle the inline filter strip's reveal state. Wired to the
+    /// Filter button + Ctrl+R action.
+    ToggleFilterStrip,
+    /// User confirmed a new filter set in the filter strip (or hit
+    /// "Clear all" — that's an empty FilterSet). BrowseTab persists,
+    /// resets pagination to offset 0, refreshes chrome, and
+    /// re-fetches.
     FilterApplied(tablepro_core::FilterSet),
     /// User clicked First page (offset → 0).
     FirstPage,
@@ -1262,6 +1269,14 @@ impl SimpleComponent for BrowseTab {
         // removed. Idempotent — calling twice is a no-op.
         crate::services::change_tracker::open_tab(init.tab_id);
 
+        // Restore the saved filter for this (connection, schema,
+        // table) up front so both the model field and the inline
+        // strip start with the same FilterSet.
+        let initial_filter = init
+            .connection_id
+            .map(|id| crate::services::filter_settings::load(id, init.schema.as_deref(), &init.table))
+            .unwrap_or_default();
+
         let suppress_combo_emit = Rc::new(std::cell::Cell::new(true));
         let grid_holder = gtk::Box::builder()
             .orientation(gtk::Orientation::Vertical)
@@ -1327,6 +1342,17 @@ impl SimpleComponent for BrowseTab {
 
         root.add_top_bar(&read_only_banner);
         root.add_top_bar(&no_pk_banner);
+        // Filter strip — inline editor that slides down above the
+        // grid when revealed. Ownership stays inside this BrowseTab
+        // so the user's in-progress rule edits survive a click into
+        // a cell or the SQL editor.
+        let filter_set_for_strip = initial_filter.clone();
+        let sender_for_strip = sender.clone();
+        let on_apply_filter: std::rc::Rc<dyn Fn(tablepro_core::FilterSet)> = std::rc::Rc::new(move |set| {
+            sender_for_strip.input(BrowseTabInput::FilterApplied(set));
+        });
+        let filter_strip = crate::ui::filter_strip::build(Vec::new(), filter_set_for_strip, on_apply_filter);
+        root.add_top_bar(&filter_strip.widget);
         root.add_top_bar(&grid_search_bar);
         root.set_content(Some(&inner_stack));
         // Mutations bar sits below the paginator (call order = stack
@@ -1558,15 +1584,6 @@ impl SimpleComponent for BrowseTab {
             GridMsg::DuplicateRow { row_position } => BrowseTabInput::DuplicateRow { row_position },
         }));
 
-        // Restore the saved filter for this (connection, schema,
-        // table) before moving init.schema / init.table into the
-        // struct. If none was saved, FilterSet::default() means
-        // "no WHERE clause" which is the same as today's path.
-        let initial_filter = init
-            .connection_id
-            .map(|id| crate::services::filter_settings::load(id, init.schema.as_deref(), &init.table))
-            .unwrap_or_default();
-
         let model = BrowseTab {
             tab_id: init.tab_id,
             schema: init.schema,
@@ -1600,6 +1617,7 @@ impl SimpleComponent for BrowseTab {
             next_button: paginator.next_button,
             last_button: paginator.last_button,
             filter_button: paginator.filter_button,
+            filter_strip: Some(filter_strip),
             insert_button: mutations.insert_button,
             delete_button: mutations.delete_button,
             save_button: mutations.save_button,
@@ -1659,8 +1677,15 @@ impl SimpleComponent for BrowseTab {
             }
             BrowseTabInput::ColumnsLoaded(columns) => {
                 let words: Vec<String> = columns.iter().map(|c| c.name.clone()).collect();
-                self.current_columns = columns;
+                self.current_columns = columns.clone();
                 self.refresh_crud_buttons();
+                // Filter strip rebuilds against the new schema —
+                // operator allowlists narrow per type, so a column
+                // that switched from text to int needs its operator
+                // dropdown refreshed.
+                if let Some(strip) = self.filter_strip.as_ref() {
+                    strip.update_columns(columns);
+                }
                 let _ = sender.output(BrowseTabOutput::SchemaWordsChanged(words));
                 // If rows are already cached, render now with the proper
                 // editability map. Otherwise wait for RowsLoaded.
@@ -1729,6 +1754,11 @@ impl SimpleComponent for BrowseTab {
                 }
                 sel.unselect_all();
             }
+            BrowseTabInput::ToggleFilterStrip => {
+                if let Some(strip) = self.filter_strip.as_ref() {
+                    strip.toggle();
+                }
+            }
             BrowseTabInput::FilterApplied(set) => {
                 // No change to the rule list → don't churn the disk
                 // or refetch. Re-fetch on identical filter would just
@@ -1739,13 +1769,16 @@ impl SimpleComponent for BrowseTab {
                 }
                 self.current_filter = set.clone();
                 if let Some(conn_id) = self.connection_id {
-                    crate::services::filter_settings::save(conn_id, self.schema.as_deref(), &self.table, set);
+                    crate::services::filter_settings::save(conn_id, self.schema.as_deref(), &self.table, set.clone());
                 }
                 // Filtered counts shift; jump back to page 1 so the
                 // user isn't stranded on offset N where N might be
                 // beyond the new filtered total.
                 self.current_offset = 0;
                 self.refresh_filter_chrome();
+                if let Some(strip) = self.filter_strip.as_ref() {
+                    strip.update_filter(set);
+                }
                 let _ = sender.output(BrowseTabOutput::FetchPage);
                 let _ = sender.output(BrowseTabOutput::FetchRowCount);
                 let _ = sender.output(BrowseTabOutput::StateChanged);