Walk the grid with the arrow keys, and open with Return

A cull is thousands of decisions. The grid already bound 0-5, P, X and U so
the judgement itself needs no mouse, and then made the photographer reach
for one to move to the next frame — which is most of the gesture, most of
the time. Arrows now move a cursor, shift+arrow extends the selection,
Home/End and PageUp/PageDown cover ground, and Return opens what the cursor
is on.

The cursor is a library ordinal, not a row of the loaded window. The window
is a few screenfuls around wherever the user is looking, so a cursor held as
a row would stop at its edge or keep counting into cells belonging to other
photographs; walking out of the window reloads it around the new position,
exactly as scrolling does. This is the argument the selection already made
by keying on ids rather than rows.

The anchor had that fault for real: it was a window row, so a shift-click
after a scroll extended from whatever image had since drifted into it. It is
an ordinal now, and apply_press takes the window's offset to map between the
two. A range longer than the loaded window truncates to what is loaded,
since selection is by id and an image the catalog has not been asked for has
none.

The pointer and the keyboard share select_row so the two cannot drift apart.
The one deliberate difference: a plain arrow collapses the selection onto
the cursor, where a plain click on an already-selected cell leaves it alone
— that exception exists so a multi-image drag can start from one of its
members, and there is no drag behind a keystroke.

The grid scrolls to the cursor only when the cursor leaves the viewport, and
then by as little as will do it. Reusing the scrub's seek() would put the
cursor's row at the top on every press, which makes a row unreadable as you
walk along it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

ui/dr-ui/src/library_ui.rs

@@ -2252,6 +2252,101 @@ fn to_slint_image(width: u32, height: u32, rgba: &[u8]) -> slint::Image {
     slint::Image::from_rgba8(buf)
 }
 
+/// Walk the keyboard cursor through the library — the arrow keys.
+///
+/// **The cursor is a library ordinal, not a row of the loaded window.** That is
+/// what lets it walk past the window's edge: the window is a few screenfuls
+/// around wherever the user is looking, and a cursor held as a row would stop
+/// at its end or, worse, keep counting into cells belonging to different
+/// photographs. Moving out of the window reloads it around the new position,
+/// which is the same thing scrolling does.
+///
+/// The grid supplies the step, because how far "down" is depends on how many
+/// columns the window happens to be showing, and only the grid knows that. It
+/// does not clamp: `Home` and `End` arrive as a step longer than the library
+/// and are clamped here, where the total is known.
+fn move_cursor(
+    window: &AppWindow,
+    ctl: &Rc<LibraryController>,
+    coll: &Rc<crate::collections_ui::CollectionsController>,
+    delta: i32,
+    extend: bool,
+) {
+    let total = window.get_library_total().max(0) as usize;
+    if total == 0 {
+        return;
+    }
+
+    let Some(from) = coll.cursor() else {
+        // The first press takes hold of the grid rather than moving in it. A
+        // key that jumped to image zero would lose wherever the user had
+        // scrolled to, and one that started from a cell off the top of the
+        // screen would appear to do nothing but scroll.
+        //
+        // The first *visible* ordinal, not the window's start: the loaded
+        // window deliberately begins a quarter of a screen above the view, so
+        // its first cell is one the user cannot see.
+        let at = ctl.resume_at.get().min(total - 1);
+        place_cursor(window, ctl, coll, at, false);
+        return;
+    };
+
+    // Saturating in `isize`, so a `Home` expressed as minus the library's
+    // length does not wrap round to the end.
+    let next = (from as isize)
+        .saturating_add(delta as isize)
+        .clamp(0, total as isize - 1) as usize;
+    if next == from {
+        // Already at the end being pressed toward. Nothing to move, and
+        // reloading the window would be a visible jerk for no movement.
+        return;
+    }
+    place_cursor(window, ctl, coll, next, extend);
+}
+
+/// Put the cursor on one image, bringing the window with it.
+fn place_cursor(
+    window: &AppWindow,
+    ctl: &Rc<LibraryController>,
+    coll: &Rc<crate::collections_ui::CollectionsController>,
+    at: usize,
+    extend: bool,
+) {
+    // Bring the window to the cursor if it has walked out of it. Centred a
+    // quarter in, exactly as a scroll does it, so continuing in the same
+    // direction has loaded cells to move into rather than another reload on
+    // the very next press.
+    let loaded = window.get_library_cells().row_count();
+    let offset = *ctl.offset.borrow();
+    if at < offset || at >= offset + loaded {
+        let size = *ctl.window.borrow();
+        *ctl.offset.borrow_mut() = at.saturating_sub(size / 4);
+        load_window(window, ctl);
+    }
+
+    // Re-read: `load_window` clamps the offset against the library's end, so
+    // the window may not start where it was asked to.
+    let offset = *ctl.offset.borrow();
+    let ids = ctl.visible_ids();
+    let Some(row) = at.checked_sub(offset).filter(|r| *r < ids.len()) else {
+        // The window could not be brought to the cursor — an empty or
+        // shrinking library. Leaving the cursor where it was is better than
+        // pointing it at nothing.
+        return;
+    };
+
+    if !extend {
+        // An arrow key collapses the selection onto the cursor. A *click* on
+        // an already-selected cell deliberately leaves the selection alone —
+        // that exception exists so a multi-image drag can start from one of
+        // its members — and there is no drag behind a keystroke.
+        coll.clear_selection();
+    }
+
+    crate::collections_ui::select_row(window, coll, &ids, offset, row, false, extend);
+    window.set_library_cursor(at as i32);
+}
+
 /// Connect the grid's callbacks.
 pub fn wire<F>(
     window: &AppWindow,
@@ -2261,10 +2356,15 @@ pub fn wire<F>(
 ) where
     F: Fn(String) + 'static,
 {
+    // Shared rather than moved: a click and `Return` both open an image, and
+    // they are two callbacks.
+    let on_open_image = Rc::new(on_open_image);
+
     {
         let weak = window.as_weak();
         let ctl = ctl.clone();
         let coll_for_click = coll_ctl.clone();
+        let on_open_image = on_open_image.clone();
         window.on_library_cell_clicked(move |i| {
             // A ctrl- or shift-click is a selection gesture. Opening the image
             // too would throw the user out of the grid mid-selection.
@@ -2283,6 +2383,47 @@ pub fn wire<F>(
         });
     }
 
+    // --- the keyboard cursor (FR-CULL-4) -----------------------------------
+    //
+    // Walking the grid with the arrows, and opening with `Return`. Together
+    // with the judgement keys already bound in the grid, this is what makes a
+    // culling pass a keyboard job: move, rate, move, open the doubtful one,
+    // come back. A cull is thousands of decisions, and reaching for the mouse
+    // between each of them is the difference between an hour and an evening.
+    {
+        let weak = window.as_weak();
+        let ctl = ctl.clone();
+        let coll = coll_ctl.clone();
+        window.on_library_move_cursor(move |delta, extend| {
+            let Some(w) = weak.upgrade() else { return };
+            move_cursor(&w, &ctl, &coll, delta, extend);
+        });
+    }
+
+    {
+        let weak = window.as_weak();
+        let ctl = ctl.clone();
+        let coll = coll_ctl.clone();
+        let on_open = on_open_image.clone();
+        window.on_library_open_cursor(move || {
+            let Some(w) = weak.upgrade() else { return };
+            // The cursor is a library ordinal and `paths` is the loaded
+            // window, so the row is the difference. A cursor outside the
+            // window cannot happen — moving it loads the window around it —
+            // but a shrinking library could leave one behind, and opening the
+            // wrong photograph is worse than opening none.
+            let Some(cursor) = coll.cursor() else { return };
+            let offset = *ctl.offset.borrow();
+            let path = cursor
+                .checked_sub(offset)
+                .and_then(|row| ctl.paths.borrow().get(row).cloned());
+            if let Some(path) = path {
+                w.set_show_library(false);
+                on_open(path);
+            }
+        });
+    }
+
     // Ctrl+wheel or pinch over the grid resizes the cells.
     //
     // Geometric steps rather than fixed pixels: the same gesture should feel