fix(grid): column sort beyond 1st click — listen to order-notify too

**Root cause**: `connect_primary_sort_column_notify` in `grid.rs` only
fires when the primary sort *column* changes. Clicking the same
column a second time keeps the column constant — GTK only flips the
direction (Ascending ↔ Descending). The chevron icon updates
because GTK manages it internally, but the model never sees a
SortChanged dispatch, so `current_sort` stays stale and the next
FetchPage emits the same `ORDER BY` clause as the previous one.
End result: chevron flips, data doesn't.

**Fix**:

1. Wire `connect_primary_sort_order_notify` alongside
   `connect_primary_sort_column_notify`. Either signal now
   dispatches SortChanged.
2. Pass the post-click `(col_idx, ascending)` directly in the
   message instead of toggling at the receiver. Reading off the
   sorter is idempotent — both notify signals carry the same
   resolved pair, so receiver short-circuits when it already
   matches `current_sort`. Without the short-circuit, clicking a
   different column (which fires BOTH notifies because column
   changes AND order resets) would have flipped twice.

`GridMsg::SortChanged(usize)` → `SortChanged(usize, bool)`.
`BrowseTabInput::SortChanged(usize)` →
`SortChanged { col_idx, ascending }`. Receiver no longer holds
toggle state — sorter is the source of truth.

Author: datlechin

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

@@ -131,7 +131,10 @@ pub enum BrowseTabInput {
     /// User clicked Next page.
     NextPage,
     /// Sort flipped on column idx (from grid sorter).
-    SortChanged(usize),
+    SortChanged {
+        col_idx: usize,
+        ascending: bool,
+    },
     /// Page size dropdown changed.
     PageSizeChanged(u64),
     /// User clicked the Insert button on this tab's paginator bar.
@@ -1348,7 +1351,7 @@ impl SimpleComponent for BrowseTab {
         // outputs that App's forwarder tags with this tab's id.
         let grid_input = sender.input_sender().clone();
         relm4::spawn_local(grid_receiver.forward(grid_input, |msg| match msg {
-            GridMsg::SortChanged(idx) => BrowseTabInput::SortChanged(idx),
+            GridMsg::SortChanged(col_idx, ascending) => BrowseTabInput::SortChanged { col_idx, ascending },
             GridMsg::CellEdited {
                 table,
                 row_position,
@@ -1543,12 +1546,18 @@ impl SimpleComponent for BrowseTab {
                 let _ = sender.output(BrowseTabOutput::FetchPage);
                 let _ = sender.output(BrowseTabOutput::StateChanged);
             }
-            BrowseTabInput::SortChanged(col_idx) => {
-                let next = match self.current_sort {
-                    Some((c, asc)) if c == col_idx => Some((c, !asc)),
-                    _ => Some((col_idx, true)),
-                };
-                self.current_sort = next;
+            BrowseTabInput::SortChanged { col_idx, ascending } => {
+                // Idempotent: GtkColumnViewSorter fires both
+                // `primary-sort-column` and `primary-sort-order`
+                // notifies for one logical click on a different
+                // column (column changes; order resets). Each
+                // notify dispatches the same post-state pair, so
+                // we short-circuit when the pair already matches.
+                let next = (col_idx, ascending);
+                if self.current_sort == Some(next) {
+                    return;
+                }
+                self.current_sort = Some(next);
                 self.current_offset = 0;
                 self.capture_focus_for_restore();
                 let _ = sender.output(BrowseTabOutput::FetchPage);

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

@@ -14,7 +14,14 @@ pub type FilterSetter = Rc<dyn Fn(&str)>;
 
 #[derive(Debug)]
 pub enum GridMsg {
-    SortChanged(usize),
+    /// User clicked a column header. `(col_idx, ascending)` is the
+    /// resolved post-click state read from the GtkColumnViewSorter
+    /// — not a "toggle" hint. Reading the sorter directly avoids
+    /// the receiver having to keep its own toggle state in sync,
+    /// which broke when both `primary-sort-column` and
+    /// `primary-sort-order` notify fired for the same logical
+    /// click (column change resets order; two events, two flips).
+    SortChanged(usize, bool),
     CellEdited {
         table: String,
         row_position: u32,
@@ -166,17 +173,43 @@ pub fn build_column_view(
             .sorter()
             .and_then(|s| s.downcast::<gtk::ColumnViewSorter>().ok())
     {
-        view_sorter.connect_primary_sort_column_notify(move |sorter| {
-            let Some(active) = sorter.primary_sort_column() else {
-                return;
-            };
-            for (idx, col) in columns.iter().enumerate() {
-                if col == &active {
-                    app_sender.send(GridMsg::SortChanged(idx)).ok();
-                    break;
+        // Wire BOTH `primary-sort-column` AND `primary-sort-order`
+        // notify. Listening only to the former misses the case
+        // where the user clicks the same column a second time:
+        // GTK keeps `primary-sort-column` constant and just flips
+        // `primary-sort-order` (Ascending ↔ Descending). The
+        // chevron updates because GTK manages it internally, but
+        // without an order-notify listener the model never sees
+        // SortChanged, `current_sort` stays stale, and the next
+        // FetchPage issues the same ORDER BY as the previous one.
+        //
+        // Reading both column AND order off the sorter (rather
+        // than dispatching a "toggle" hint) makes the receiver's
+        // job idempotent: clicking a different column fires both
+        // notifies in some order, but each carries the post-state
+        // pair, and the receiver short-circuits when the pair
+        // already matches `current_sort`.
+        let dispatch = {
+            let app_sender = app_sender.clone();
+            let columns = columns.clone();
+            move |sorter: &gtk::ColumnViewSorter| {
+                let Some(active) = sorter.primary_sort_column() else {
+                    return;
+                };
+                let ascending = matches!(sorter.primary_sort_order(), gtk::SortType::Ascending);
+                for (idx, col) in columns.iter().enumerate() {
+                    if col == &active {
+                        app_sender.send(GridMsg::SortChanged(idx, ascending)).ok();
+                        break;
+                    }
                 }
             }
+        };
+        view_sorter.connect_primary_sort_column_notify({
+            let dispatch = dispatch.clone();
+            move |sorter| dispatch(sorter)
         });
+        view_sorter.connect_primary_sort_order_notify(move |sorter| dispatch(sorter));
     }
 
     (column_view, selection, setter)