@tryinget/pi-activity-strip 0.8.0 → 0.9.0

package/native/panel/src/app.rs

@@ -1,13 +1,19 @@
 use crate::card_view::CardView;
-use crate::protocol::{Card, ViewMessage, demo_view, emit, emit_error, emit_ready};
+use crate::directory_view::{
+    DirectoryView, JumpChoice, is_query_char, jump_choice, push_query_char,
+};
+use crate::protocol::{Card, ViewMessage, WindowEntry, demo_view, emit, emit_error, emit_ready};
 use crate::runtime::{apply_theme, duplicate_labels, install_css, now_ms, start_input_reader};
 use gtk4_layer_shell::{Edge, KeyboardMode, Layer, LayerShell};
 use relm4::gtk;
+use relm4::gtk::gdk;
 use relm4::gtk::glib;
 use relm4::gtk::prelude::*;
 use relm4::{Component, ComponentParts, ComponentSender};
 use serde_json::json;
+use std::cell::Cell;
 use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
 use std::time::Duration;
 
 const COMPACT_HEIGHT: i32 = 84;
@@ -17,6 +23,13 @@ const OUTER_MARGIN: i32 = 8;
 const EXPANDED_HEIGHT: i32 = 276;
 const ORDER_REFRESH_MS: i64 = 15_000;
 const BRAND_WIDTH: i32 = 196;
+/// Grace before a hovered-away window list closes, so crossing the brand's own padding does not
+/// close and reopen it.
+const DIRECTORY_CLOSE_MS: u64 = 200;
+/// Hovering the ribbon takes the keyboard so a window number can be typed at once. Without a digit
+/// within this time it is handed back, so a pointer resting on the ribbon cannot keep swallowing
+/// what is typed into the window below; a click on the ribbon still takes it again.
+const HOVER_GRAB_MS: u64 = 3_000;
 
 pub struct AppInit {
     pub demo: bool,
@@ -37,6 +50,77 @@ pub struct App {
     next_order_refresh_at: i64,
     collapse_generation: u64,
     interactive: bool,
+    directory: DirectoryView,
+    windows: Vec<WindowEntry>,
+    directory_open: bool,
+    directory_hovered: bool,
+    /// The pointer is over the brand column: it expands the ribbon like a card does, showing the
+    /// list at full height.
+    brand_hovered: bool,
+    /// Counts brand hover changes, so a leave only collapses if the pointer did not come back
+    /// (or land on a card) within the collapse grace.
+    brand_generation: u64,
+    directory_generation: u64,
+    /// Opened by hovering the brand, so leaving it closes the list; a list opened by a typed
+    /// digit in keyboard mode stays open until it jumps or is dismissed.
+    directory_opened_by_hover: bool,
+    /// Counts list openings, so a jump or activation result only acts on the list that asked.
+    directory_session: u64,
+    pending_request: Option<PendingRequest>,
+    /// The list changed the keyboard mode and must set it back when it closes.
+    directory_owns_keyboard: bool,
+    /// The keyboard was taken on hover and is still held. Released when the pointer leaves, and
+    /// after HOVER_GRAB_MS without a key while nothing is typed.
+    hover_grab: bool,
+    /// Counts grab timers, so only the latest one (re-armed on every key) can release the grab.
+    grab_generation: u64,
+    /// Whether the ribbon has keyboard focus right now: after a click on the list, or in
+    /// keyboard mode. Hovering alone never takes the keyboard from the window being typed into.
+    window_active: bool,
+    query: String,
+    /// Read by the window's key controller: which keys belong to the window list right now.
+    key_capture: Rc<Cell<KeyCapture>>,
+    /// Read by the key controller: the keyboard is held only because of hover, so any key that is
+    /// not part of a search means the typing was meant for the window below.
+    hover_guard: Rc<Cell<bool>>,
+}
+
+/// Keys the window list takes before any card sees them.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum KeyCapture {
+    None,
+    /// Keyboard mode on the cards: a typed name or number character opens the list; Enter and
+    /// Escape stay with the cards.
+    Digits,
+    /// The list is open with nothing typed: digits, Backspace and Escape are its own; Enter still
+    /// reaches the focused card.
+    List,
+    /// The list is open with digits typed: Enter jumps.
+    ListTyped,
+}
+
+/// What the open list asked the controller for, so only that answer acts on it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PendingRequest {
+    session: u64,
+    target: RequestTarget,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum RequestTarget {
+    Card(String),
+    Window(i64),
+}
+
+#[derive(Debug)]
+pub enum DirectoryKey {
+    /// A letter, digit, `-`, `_` or `.` of a name or window number.
+    Char(char),
+    Backspace,
+    Enter,
+    Escape,
+    /// A key that cannot be part of a search, pressed while only hover holds the keyboard.
+    Interrupt,
 }
 
 #[derive(Debug)]
@@ -52,9 +136,17 @@ pub enum AppMsg {
     FocusStrip,
     Collapse,
     CollapseIf(u64),
-    WindowInactive,
+    WindowActive(bool),
     ParentGone,
     InputError(String),
+    DirectoryHover(bool),
+    BrandHover(bool),
+    BrandSettle(u64),
+    DirectoryCloseIf(u64),
+    DirectoryGrabExpired(u64),
+    DirectoryKey(DirectoryKey),
+    DirectoryActivate(String),
+    JumpResult(i64, bool, String),
 }
 
 #[relm4::component(pub)]
@@ -85,6 +177,9 @@ impl Component for App {
                     add_css_class: "brand",
                     set_orientation: gtk::Orientation::Vertical,
                     set_width_request: BRAND_WIDTH,
+                    // Set explicitly so the window list's expanding rows cannot widen the brand
+                    // and push the cards aside.
+                    set_hexpand: false,
                     set_valign: gtk::Align::Center,
 
                     #[name = "eyebrow"]
@@ -168,11 +263,12 @@ impl Component for App {
 
         let tx = sender.input_sender().clone();
         root.connect_is_active_notify(move |window| {
-            if !window.is_active() {
-                let _ = tx.send(AppMsg::WindowInactive);
-            }
+            let _ = tx.send(AppMsg::WindowActive(window.is_active()));
         });
 
+        let directory = DirectoryView::new(sender.input_sender());
+        let key_capture = Rc::new(Cell::new(KeyCapture::None));
+        let hover_guard = Rc::new(Cell::new(false));
         let model = App {
             cards: HashMap::new(),
             data: HashMap::new(),
@@ -187,9 +283,67 @@ impl Component for App {
             next_order_refresh_at: 0,
             collapse_generation: 0,
             interactive: !init.click_through,
+            directory,
+            windows: Vec::new(),
+            directory_open: false,
+            directory_hovered: false,
+            brand_hovered: false,
+            brand_generation: 0,
+            directory_generation: 0,
+            directory_opened_by_hover: false,
+            directory_session: 0,
+            pending_request: None,
+            directory_owns_keyboard: false,
+            hover_grab: false,
+            grab_generation: 0,
+            window_active: false,
+            query: String::new(),
+            key_capture: Rc::clone(&key_capture),
+            hover_guard: Rc::clone(&hover_guard),
         };
         let widgets = view_output!();
         widgets.body.set_can_target(!init.click_through);
+        widgets.brand.append(&model.directory.root);
+
+        // Hovering anywhere on the ribbon opens the window list in the brand column.
+        let hover = gtk::EventControllerMotion::new();
+        let tx = sender.input_sender().clone();
+        hover.connect_enter(move |_, _, _| {
+            let _ = tx.send(AppMsg::DirectoryHover(true));
+        });
+        let tx = sender.input_sender().clone();
+        hover.connect_leave(move |_| {
+            let _ = tx.send(AppMsg::DirectoryHover(false));
+        });
+        widgets.body.add_controller(hover);
+
+        let brand_hover = gtk::EventControllerMotion::new();
+        let tx = sender.input_sender().clone();
+        brand_hover.connect_enter(move |_, _, _| {
+            let _ = tx.send(AppMsg::BrandHover(true));
+        });
+        let tx = sender.input_sender().clone();
+        brand_hover.connect_leave(move |_| {
+            let _ = tx.send(AppMsg::BrandHover(false));
+        });
+        widgets.brand.add_controller(brand_hover);
+
+        // Captured before any card sees it, and only while the list (or keyboard mode) is live:
+        // see `directory_key` for which keys belong to the list in which state.
+        let keys = gtk::EventControllerKey::new();
+        keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+        let tx = sender.input_sender().clone();
+        keys.connect_key_pressed(move |_, key, _, modifiers| {
+            let chord = is_chord(modifiers);
+            let message = match directory_key(key_capture.get(), key, chord) {
+                Some(message) => message,
+                None if hover_guard.get() && !is_modifier_key(key) => DirectoryKey::Interrupt,
+                None => return glib::Propagation::Proceed,
+            };
+            let _ = tx.send(AppMsg::DirectoryKey(message));
+            glib::Propagation::Stop
+        });
+        widgets.root.add_controller(keys);
 
         let tick_tx = sender.input_sender().clone();
         glib::timeout_add_seconds_local(1, move || {
@@ -218,8 +372,14 @@ impl Component for App {
             AppMsg::Theme(definitions) => apply_theme(&definitions),
             AppMsg::Tick => {
                 if now_ms() >= self.next_order_refresh_at {
+                    let focused_at = self.focused_position();
                     self.regroup();
                     self.reorder_widgets(&widgets.cards_box);
+                    // Only when regrouping moved the focused card: a row the operator scrolled
+                    // by hand stays where they left it.
+                    if self.focused_position() != focused_at {
+                        self.scroll_focused_into_view(widgets);
+                    }
                     self.next_order_refresh_at = now_ms() + ORDER_REFRESH_MS;
                 }
                 self.refresh_cards();
@@ -248,25 +408,37 @@ impl Component for App {
             }
             AppMsg::Activate(id) => {
                 emit(json!({ "protocol": 1, "type": "activate", "cardId": id }));
+                // Focus is moving to that card's window, so the ribbon must hold nothing: not
+                // keyboard mode, and not the hover grab that clicking inside the ribbon implies.
                 if self.keyboard_active {
-                    self.end_engagement();
-                    root.set_keyboard_mode(KeyboardMode::None);
-                    self.apply_expansion(widgets, root, None);
+                    self.leave_keyboard_mode(widgets, root);
+                } else {
+                    self.close_directory(widgets, root);
                 }
             }
             AppMsg::ActivationResult(id, ok, message) => {
                 if let Some(card) = self.cards.get(&id) {
                     card.set_activation(ok, &message);
                 }
+                if self.take_own_request(&RequestTarget::Card(id)) {
+                    if ok {
+                        self.finish_directory_jump(widgets, root);
+                    } else {
+                        self.directory.set_status(&message);
+                    }
+                }
             }
             AppMsg::FocusStrip => {
                 if self.visible && self.interactive {
                     if self.keyboard_active {
-                        self.end_engagement();
-                        root.set_keyboard_mode(KeyboardMode::None);
-                        self.apply_expansion(widgets, root, None);
+                        self.leave_keyboard_mode(widgets, root);
                     } else {
                         self.keyboard_active = true;
+                        // Keyboard mode now holds the keyboard, whoever opened the list, and no
+                        // hover timeout may hand it back.
+                        self.directory_owns_keyboard = false;
+                        self.hover_grab = false;
+                        self.sync_key_capture();
                         self.hovered.clear();
                         self.keyboard_focused = self.order.first().cloned();
                         root.set_keyboard_mode(KeyboardMode::Exclusive);
@@ -282,32 +454,203 @@ impl Component for App {
                                 json!({ "protocol": 1, "type": "keyboard-active", "active": true }),
                             );
                         } else {
-                            self.end_engagement();
-                            root.set_keyboard_mode(KeyboardMode::None);
-                            self.apply_expansion(widgets, root, None);
+                            self.leave_keyboard_mode(widgets, root);
                         }
                     }
                 }
             }
-            AppMsg::Collapse | AppMsg::WindowInactive => {
-                self.end_engagement();
-                root.set_keyboard_mode(KeyboardMode::None);
-                self.apply_expansion(widgets, root, None);
+            AppMsg::Collapse => {
+                self.leave_keyboard_mode(widgets, root);
+            }
+            AppMsg::WindowActive(active) => {
+                self.window_active = active;
+                if active {
+                    // Only the hint changes. Rebuilding the rows here would replace the very row
+                    // whose click just handed over the keyboard, and swallow that click.
+                    self.refresh_directory_status();
+                } else if self.keyboard_active {
+                    // Keyboard mode lost the keyboard to another window: leave it entirely.
+                    self.leave_keyboard_mode(widgets, root);
+                } else if !self.directory_hovered {
+                    // A click elsewhere dismisses a clicked-into list. Hover expansion of cards is
+                    // pointer business and is left alone.
+                    self.close_directory(widgets, root);
+                } else {
+                    // Still hovered but no longer typing (the hover grab ran out): say so.
+                    self.refresh_directory_status();
+                }
+            }
+            AppMsg::BrandHover(entered) => {
+                self.brand_hovered = entered;
+                self.brand_generation += 1;
+                // Every card opens (entered) or falls back to the hovered one (left) at once.
+                self.refresh_cards();
+                if entered {
+                    self.resize(root);
+                    self.sync_directory_layout(widgets);
+                } else {
+                    // Collapse only after the same grace as a card, so crossing from the brand to
+                    // a card does not flicker the ribbon down and up again.
+                    self.reconcile_engagement(widgets, root, &sender);
+                    let generation = self.brand_generation;
+                    let tx = sender.input_sender().clone();
+                    glib::timeout_add_local_once(Duration::from_millis(120), move || {
+                        let _ = tx.send(AppMsg::BrandSettle(generation));
+                    });
+                }
+            }
+            AppMsg::BrandSettle(generation) => {
+                if generation == self.brand_generation {
+                    self.resize(root);
+                    self.sync_directory_layout(widgets);
+                }
             }
             AppMsg::CollapseIf(generation) => {
                 if generation == self.collapse_generation
                     && self.hovered.is_empty()
+                    && !self.brand_hovered
                     && (!self.keyboard_active || self.keyboard_focused.is_none())
                 {
                     self.apply_expansion(widgets, root, None);
                 }
             }
             AppMsg::InputError(message) => emit_error(message),
+            AppMsg::DirectoryHover(entered) => {
+                self.directory_hovered = entered;
+                self.directory_generation += 1;
+                if entered {
+                    self.open_directory(widgets, root, true);
+                    // Also on re-entry within the close grace: the grab and its timer start over.
+                    if self.take_hover_grab(root) {
+                        self.arm_grab_timer(&sender);
+                    }
+                } else {
+                    // Hovering is the only reason the ribbon holds the keyboard: leaving returns it.
+                    self.release_hover_grab(root);
+                    let generation = self.directory_generation;
+                    let tx = sender.input_sender().clone();
+                    glib::timeout_add_local_once(
+                        Duration::from_millis(DIRECTORY_CLOSE_MS),
+                        move || {
+                            let _ = tx.send(AppMsg::DirectoryCloseIf(generation));
+                        },
+                    );
+                }
+            }
+            AppMsg::DirectoryGrabExpired(generation) => {
+                if generation == self.grab_generation && self.query.is_empty() {
+                    self.release_hover_grab(root);
+                }
+            }
+            AppMsg::DirectoryCloseIf(generation) => {
+                if generation == self.directory_generation
+                    && !self.directory_hovered
+                    && self.directory_opened_by_hover
+                {
+                    self.close_directory(widgets, root);
+                }
+            }
+            AppMsg::DirectoryKey(key) => {
+                // Every key keeps a hover grab alive for another HOVER_GRAB_MS; the grab is only
+                // released idle and empty, never mid-number.
+                if self.hover_grab {
+                    self.arm_grab_timer(&sender);
+                }
+                self.handle_directory_key(widgets, root, key);
+            }
+            AppMsg::DirectoryActivate(card_id) => {
+                self.pending_request = Some(PendingRequest {
+                    session: self.directory_session,
+                    target: RequestTarget::Card(card_id.clone()),
+                });
+                self.directory.set_status("Opening…");
+                emit(json!({ "protocol": 1, "type": "activate", "cardId": card_id }));
+            }
+            AppMsg::JumpResult(window_id, ok, message) => {
+                if self.take_own_request(&RequestTarget::Window(window_id)) {
+                    if ok {
+                        // The jumped-to window must get the keyboard back at once.
+                        self.finish_directory_jump(widgets, root);
+                    } else {
+                        self.directory.set_status(&message);
+                    }
+                }
+            }
             AppMsg::ParentGone => root.close(),
         }
     }
 }
 
+/// The scroll offset that shows the span `start..end` with the least movement: unchanged when it
+/// is already fully visible, otherwise just far enough to bring its nearer edge into view.
+fn scroll_to_show(value: f64, page: f64, start: f64, end: f64) -> f64 {
+    if start < value {
+        start
+    } else if end > value + page {
+        (end - page).min(start)
+    } else {
+        value
+    }
+}
+
+/// Whether a result for `target` answers the request the list opened as `session` is waiting on.
+fn answers_request(pending: Option<&PendingRequest>, session: u64, target: &RequestTarget) -> bool {
+    pending.is_some_and(|request| request.session == session && &request.target == target)
+}
+
+/// Ctrl, Alt, Super or Meta held: a shortcut, not typing. Shift is typing (capital letters).
+fn is_chord(modifiers: gdk::ModifierType) -> bool {
+    modifiers.intersects(
+        gdk::ModifierType::CONTROL_MASK
+            | gdk::ModifierType::ALT_MASK
+            | gdk::ModifierType::SUPER_MASK
+            | gdk::ModifierType::META_MASK,
+    )
+}
+
+/// A modifier pressed on its own, on the way to a capital letter or a chord: neither search input
+/// nor a sign that the typing is meant elsewhere.
+fn is_modifier_key(key: gdk::Key) -> bool {
+    matches!(
+        key,
+        gdk::Key::Shift_L
+            | gdk::Key::Shift_R
+            | gdk::Key::Control_L
+            | gdk::Key::Control_R
+            | gdk::Key::Alt_L
+            | gdk::Key::Alt_R
+            | gdk::Key::Super_L
+            | gdk::Key::Super_R
+            | gdk::Key::Meta_L
+            | gdk::Key::Meta_R
+            | gdk::Key::ISO_Level3_Shift
+            | gdk::Key::Caps_Lock
+    )
+}
+
+/// The window-list key a press means under the current capture, if it belongs to the list at all.
+fn directory_key(capture: KeyCapture, key: gdk::Key, chord: bool) -> Option<DirectoryKey> {
+    // Ctrl, Alt and Super combinations are shortcuts, never search characters.
+    if chord {
+        return None;
+    }
+    let typed = key
+        .to_unicode()
+        .filter(|character| is_query_char(*character));
+    match capture {
+        KeyCapture::None => None,
+        KeyCapture::Digits => typed.map(DirectoryKey::Char),
+        KeyCapture::List | KeyCapture::ListTyped => match key {
+            gdk::Key::BackSpace => Some(DirectoryKey::Backspace),
+            gdk::Key::Return | gdk::Key::KP_Enter if capture == KeyCapture::ListTyped => {
+                Some(DirectoryKey::Enter)
+            }
+            gdk::Key::Escape => Some(DirectoryKey::Escape),
+            _ => typed.map(DirectoryKey::Char),
+        },
+    }
+}
+
 fn navigation_target(index: usize, direction: i32, len: usize) -> Option<usize> {
     if len == 0 {
         return None;
@@ -389,6 +732,7 @@ impl App {
         self.hovered.clear();
         self.keyboard_focused = None;
         self.keyboard_active = false;
+        self.sync_key_capture();
         self.collapse_generation += 1;
         if was_keyboard_active {
             emit(json!({ "protocol": 1, "type": "keyboard-active", "active": false }));
@@ -406,7 +750,12 @@ impl App {
             return;
         }
         self.revision = view.revision;
+        let focus_moved = self.focused_card_id != view.focused_card_id;
         self.focused_card_id = view.focused_card_id;
+        if self.windows != view.windows {
+            self.windows = view.windows;
+            self.render_directory();
+        }
         let incoming_order: Vec<_> = view
             .sessions
             .iter()
@@ -450,9 +799,7 @@ impl App {
             if focus_grabbed {
                 self.reconcile_engagement(widgets, root, sender);
             } else {
-                self.end_engagement();
-                root.set_keyboard_mode(KeyboardMode::None);
-                self.apply_expansion(widgets, root, None);
+                self.leave_keyboard_mode(widgets, root);
             }
         }
         if open_card_removed {
@@ -461,6 +808,9 @@ impl App {
         self.reorder_widgets(&widgets.cards_box);
         self.refresh_cards();
         self.update_brand(widgets);
+        if focus_moved {
+            self.scroll_focused_into_view(widgets);
+        }
 
         let should_show = view.visible && !self.data.is_empty();
         if should_show != self.visible {
@@ -469,9 +819,7 @@ impl App {
                 root.set_exclusive_zone(COMPACT_HEIGHT);
                 root.present();
             } else {
-                self.end_engagement();
-                root.set_keyboard_mode(KeyboardMode::None);
-                self.apply_expansion(widgets, root, None);
+                self.leave_keyboard_mode(widgets, root);
                 root.set_exclusive_zone(-1);
                 root.set_visible(false);
             }
@@ -505,6 +853,8 @@ impl App {
     fn refresh_cards(&self) {
         let duplicates = duplicate_labels(self.data.values());
         let now = now_ms();
+        // Hovering the brand column is an overview: every card shows its details at once.
+        let all_open = self.brand_hovered && self.expanded();
         for (id, view) in &self.cards {
             if let Some(card) = self.data.get(id) {
                 view.update(
@@ -513,7 +863,7 @@ impl App {
                     duplicates.contains(&card.repo_label),
                     now,
                 );
-                view.set_expanded(self.open_card_id.as_deref() == Some(id));
+                view.set_expanded(all_open || self.open_card_id.as_deref() == Some(id));
             }
         }
     }
@@ -610,7 +960,7 @@ impl App {
 
     fn apply_expansion(
         &mut self,
-        _widgets: &mut AppWidgets,
+        widgets: &mut AppWidgets,
         root: &gtk::Window,
         card_id: Option<String>,
     ) {
@@ -618,7 +968,72 @@ impl App {
             return;
         }
         self.open_card_id = card_id;
-        let expanded = self.open_card_id.is_some();
+        self.refresh_cards();
+        self.resize(root);
+        self.sync_directory_layout(widgets);
+    }
+
+    /// Scroll the card row so the focused window's card is fully in view, as Niri focus moves
+    /// between windows. Runs once layout has placed the card, so its position in the row is known.
+    fn scroll_focused_into_view(&self, widgets: &AppWidgets) {
+        let Some(card) = self
+            .focused_card_id
+            .as_ref()
+            .and_then(|id| self.cards.get(id))
+        else {
+            return;
+        };
+        let row = widgets.cards_box.clone();
+        let scroller = widgets.scroller.clone();
+        // Measured on the second frame after the change: the first one lays the row out, so the
+        // card's position is final, and a panel that is not shown yet simply waits until it is.
+        let frames = Cell::new(0u8);
+        card.root.add_tick_callback(move |card, _clock| {
+            frames.set(frames.get() + 1);
+            if frames.get() < 2 {
+                return glib::ControlFlow::Continue;
+            }
+            if let Some(origin) = card.compute_point(&row, &gtk::graphene::Point::new(0.0, 0.0)) {
+                let start = f64::from(origin.x());
+                let end = start + f64::from(card.width());
+                let adjustment = scroller.hadjustment();
+                adjustment.set_value(scroll_to_show(
+                    adjustment.value(),
+                    adjustment.page_size(),
+                    start,
+                    end,
+                ));
+            }
+            glib::ControlFlow::Break
+        });
+    }
+
+    fn focused_position(&self) -> Option<usize> {
+        let id = self.focused_card_id.as_ref()?;
+        self.order.iter().position(|candidate| candidate == id)
+    }
+
+    /// The ribbon is tall while a card is open (hovered or in keyboard mode), while the pointer is
+    /// on the brand column with the list open, or while a typed number needs the list shown.
+    fn expanded(&self) -> bool {
+        self.open_card_id.is_some()
+            || (self.directory_open && (self.brand_hovered || !self.query.is_empty()))
+    }
+
+    /// The list fills the brand column, top to bottom, whenever the ribbon is expanded; compact,
+    /// it is hidden.
+    fn sync_directory_layout(&self, widgets: &AppWidgets) {
+        let shown = self.directory_open && self.expanded();
+        self.directory.set_visible(shown);
+        widgets.brand.set_valign(if shown {
+            gtk::Align::Fill
+        } else {
+            gtk::Align::Center
+        });
+    }
+
+    fn resize(&self, root: &gtk::Window) {
+        let expanded = self.expanded();
         root.set_default_size(
             1,
             if expanded {
@@ -628,19 +1043,249 @@ impl App {
             },
         );
         root.set_exclusive_zone(COMPACT_HEIGHT);
-        self.refresh_cards();
         emit(
             json!({ "protocol": 1, "type": "expanded", "expanded": expanded, "cardId": self.open_card_id }),
         );
     }
+
+    fn sync_key_capture(&self) {
+        self.hover_guard
+            .set(self.directory_open && self.hover_grab && !self.keyboard_active);
+        self.key_capture
+            .set(if self.directory_open && !self.query.is_empty() {
+                KeyCapture::ListTyped
+            } else if self.directory_open {
+                KeyCapture::List
+            } else if self.keyboard_active {
+                KeyCapture::Digits
+            } else {
+                KeyCapture::None
+            });
+    }
+
+    fn handle_directory_key(
+        &mut self,
+        widgets: &mut AppWidgets,
+        root: &gtk::Window,
+        key: DirectoryKey,
+    ) {
+        match key {
+            DirectoryKey::Char(digit) => {
+                self.open_directory(widgets, root, false);
+                if push_query_char(&mut self.query, digit) {
+                    self.render_directory();
+                    self.sync_key_capture();
+                    self.resize(root);
+                    self.sync_directory_layout(widgets);
+                }
+            }
+            DirectoryKey::Backspace => {
+                self.query.pop();
+                self.render_directory();
+                self.sync_key_capture();
+                self.resize(root);
+                self.sync_directory_layout(widgets);
+            }
+            DirectoryKey::Enter => {
+                match jump_choice(&self.windows, &self.query, self.allow_unlisted()) {
+                    Some(JumpChoice::Window(window_id)) => {
+                        self.pending_request = Some(PendingRequest {
+                            session: self.directory_session,
+                            target: RequestTarget::Window(window_id),
+                        });
+                        self.directory
+                            .set_status(&format!("Jumping to #{window_id}…"));
+                        emit(json!({ "protocol": 1, "type": "jump", "windowId": window_id }));
+                    }
+                    Some(JumpChoice::Card(card_id)) => {
+                        self.pending_request = Some(PendingRequest {
+                            session: self.directory_session,
+                            target: RequestTarget::Card(card_id.clone()),
+                        });
+                        self.directory.set_status("Opening…");
+                        emit(json!({ "protocol": 1, "type": "activate", "cardId": card_id }));
+                    }
+                    // Enter leading nowhere while only hover holds the keyboard: the typing was meant
+                    // for the window below, so hand the keyboard back.
+                    None if self.hover_guard.get() => self.cancel_hover_search(widgets, root),
+                    None => {}
+                }
+            }
+            DirectoryKey::Escape => self.dismiss_directory(widgets, root),
+            DirectoryKey::Interrupt => self.cancel_hover_search(widgets, root),
+        }
+    }
+
+    /// Whether a result answers exactly what the open list asked for. Anything else (a card's own
+    /// activation, an earlier jump) leaves the pending request in place.
+    fn take_own_request(&mut self, target: &RequestTarget) -> bool {
+        if self.directory_open
+            && answers_request(
+                self.pending_request.as_ref(),
+                self.directory_session,
+                target,
+            )
+        {
+            self.pending_request = None;
+            true
+        } else {
+            false
+        }
+    }
+
+    fn refresh_directory_status(&self) {
+        if self.directory_open {
+            self.directory.set_prompt(
+                &self.windows,
+                &self.query,
+                self.window_active || self.keyboard_active,
+                self.allow_unlisted(),
+            );
+        }
+    }
+
+    fn render_directory(&self) {
+        if self.directory_open {
+            self.directory.render(
+                &self.windows,
+                &self.query,
+                self.window_active || self.keyboard_active,
+                self.allow_unlisted(),
+            );
+        }
+    }
+
+    /// Take the keyboard for a hover-opened list, so a number can be typed at once. Clears the
+    /// window's focus widget first: Enter with nothing typed must not press a card or row that
+    /// kept focus from an earlier keyboard mode or click.
+    fn take_hover_grab(&mut self, root: &gtk::Window) -> bool {
+        if !self.directory_open || !self.directory_opened_by_hover || self.keyboard_active {
+            return false;
+        }
+        if !self.hover_grab {
+            GtkWindowExt::set_focus(root, None::<&gtk::Widget>);
+            root.set_keyboard_mode(KeyboardMode::Exclusive);
+            self.hover_grab = true;
+            self.directory_owns_keyboard = true;
+            self.sync_key_capture();
+        }
+        true
+    }
+
+    /// Typing held only by hover turned out to be meant for the window below: drop it, hand the
+    /// keyboard back and close the list, so keys still in flight find nothing to type into. The
+    /// list reopens when the pointer re-enters the ribbon.
+    fn cancel_hover_search(&mut self, widgets: &mut AppWidgets, root: &gtk::Window) {
+        self.query.clear();
+        self.release_hover_grab(root);
+        self.dismiss_directory(widgets, root);
+    }
+
+    /// Unlisted window numbers are reachable only when the keyboard was given on purpose (a
+    /// click or keyboard mode), not merely held by hover.
+    fn allow_unlisted(&self) -> bool {
+        !(self.hover_grab && !self.keyboard_active)
+    }
+
+    fn release_hover_grab(&mut self, root: &gtk::Window) {
+        if self.hover_grab {
+            self.hover_grab = false;
+            self.grab_generation += 1;
+            if !self.keyboard_active {
+                root.set_keyboard_mode(KeyboardMode::OnDemand);
+            }
+            self.sync_key_capture();
+            self.refresh_directory_status();
+        }
+    }
+
+    fn arm_grab_timer(&mut self, sender: &ComponentSender<Self>) {
+        self.grab_generation += 1;
+        let generation = self.grab_generation;
+        let tx = sender.input_sender().clone();
+        glib::timeout_add_local_once(Duration::from_millis(HOVER_GRAB_MS), move || {
+            let _ = tx.send(AppMsg::DirectoryGrabExpired(generation));
+        });
+    }
+
+    fn open_directory(&mut self, widgets: &AppWidgets, root: &gtk::Window, by_hover: bool) {
+        if self.directory_open || !self.visible || !self.interactive {
+            return;
+        }
+        self.directory_open = true;
+        self.directory_opened_by_hover = by_hover;
+        self.directory_session += 1;
+        self.query.clear();
+        // On-demand until a hover grab (take_hover_grab) upgrades it; a click can always take the
+        // keyboard. Keyboard mode already holds it.
+        if !self.keyboard_active {
+            root.set_keyboard_mode(KeyboardMode::OnDemand);
+            self.directory_owns_keyboard = true;
+        }
+        self.render_directory();
+        self.sync_key_capture();
+        self.resize(root);
+        self.sync_directory_layout(widgets);
+    }
+
+    /// After the list moved focus somewhere, nothing on the ribbon may keep the keyboard: the list
+    /// closes, and keyboard mode ends exactly as activating a card ends it.
+    fn finish_directory_jump(&mut self, widgets: &mut AppWidgets, root: &gtk::Window) {
+        if self.keyboard_active {
+            self.leave_keyboard_mode(widgets, root);
+        } else {
+            self.dismiss_directory(widgets, root);
+        }
+    }
+
+    /// Close the list and let the ribbon fall back to compact unless a card is still under the
+    /// pointer: the card kept open while the pointer crossed to the list has done its job.
+    fn dismiss_directory(&mut self, widgets: &mut AppWidgets, root: &gtk::Window) {
+        self.close_directory(widgets, root);
+        if self.hovered.is_empty() && !self.keyboard_active {
+            self.apply_expansion(widgets, root, None);
+        }
+    }
+
+    /// The one way out of keyboard mode. The list closes with it: once the ribbon gives up the
+    /// keyboard nothing could type into or dismiss a list left open.
+    fn leave_keyboard_mode(&mut self, widgets: &mut AppWidgets, root: &gtk::Window) {
+        self.close_directory(widgets, root);
+        self.end_engagement();
+        root.set_keyboard_mode(KeyboardMode::None);
+        self.apply_expansion(widgets, root, None);
+    }
+
+    fn close_directory(&mut self, widgets: &AppWidgets, root: &gtk::Window) {
+        if !self.directory_open {
+            return;
+        }
+        self.directory_open = false;
+        self.directory_opened_by_hover = false;
+        self.hover_grab = false;
+        self.pending_request = None;
+        self.query.clear();
+        if self.directory_owns_keyboard {
+            self.directory_owns_keyboard = false;
+            if !self.keyboard_active {
+                root.set_keyboard_mode(KeyboardMode::None);
+            }
+        }
+        self.sync_key_capture();
+        self.resize(root);
+        self.sync_directory_layout(widgets);
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::{
-        BrandCounts, brand_text, engaged_card_id, move_order_item, navigation_target, short_path,
+        BrandCounts, DirectoryKey, KeyCapture, PendingRequest, RequestTarget, answers_request,
+        brand_text, directory_key, engaged_card_id, move_order_item, navigation_target,
+        scroll_to_show, short_path,
     };
     use crate::protocol::Card;
+    use relm4::gtk::gdk;
     use std::collections::HashSet;
 
     fn counts() -> BrandCounts {
@@ -650,6 +1295,112 @@ mod tests {
         }
     }
 
+    #[test]
+    fn the_focused_card_scrolls_into_view_with_the_least_movement() {
+        // Row viewport 0..1000.
+        assert_eq!(
+            scroll_to_show(0.0, 1000.0, 200.0, 440.0),
+            0.0,
+            "already visible"
+        );
+        assert_eq!(
+            scroll_to_show(0.0, 1000.0, 1500.0, 1740.0),
+            740.0,
+            "right of view"
+        );
+        assert_eq!(
+            scroll_to_show(800.0, 1000.0, 300.0, 540.0),
+            300.0,
+            "left of view"
+        );
+        assert_eq!(
+            scroll_to_show(0.0, 200.0, 500.0, 740.0),
+            500.0,
+            "wider than the view: its start wins"
+        );
+    }
+
+    #[test]
+    fn only_the_answer_to_what_the_open_list_asked_acts_on_it() {
+        let pending = PendingRequest {
+            session: 3,
+            target: RequestTarget::Window(43),
+        };
+        assert!(answers_request(
+            Some(&pending),
+            3,
+            &RequestTarget::Window(43)
+        ));
+        assert!(
+            !answers_request(Some(&pending), 3, &RequestTarget::Window(44)),
+            "an earlier jump to another number"
+        );
+        assert!(
+            !answers_request(Some(&pending), 3, &RequestTarget::Card("card-a".into())),
+            "a card's own activation"
+        );
+        assert!(
+            !answers_request(Some(&pending), 4, &RequestTarget::Window(43)),
+            "a list opened again since"
+        );
+        assert!(!answers_request(None, 3, &RequestTarget::Window(43)));
+    }
+
+    #[test]
+    fn only_ctrl_alt_super_make_a_chord_and_bare_modifiers_are_not_typing() {
+        assert!(super::is_chord(gdk::ModifierType::CONTROL_MASK));
+        assert!(super::is_chord(gdk::ModifierType::SUPER_MASK));
+        assert!(
+            !super::is_chord(gdk::ModifierType::SHIFT_MASK),
+            "Shift types capitals"
+        );
+        assert!(super::is_modifier_key(gdk::Key::Shift_L));
+        assert!(!super::is_modifier_key(gdk::Key::space));
+    }
+
+    #[test]
+    fn the_window_list_takes_keys_only_while_they_belong_to_it() {
+        let key = |capture, key| format!("{:?}", directory_key(capture, key, false));
+        assert_eq!(
+            format!("{:?}", directory_key(KeyCapture::List, gdk::Key::c, true)),
+            "None",
+            "Ctrl+C is a shortcut, not a search for c"
+        );
+        assert_eq!(key(KeyCapture::None, gdk::Key::_4), "None");
+        // Keyboard mode on the cards: a digit opens the list, Enter and Escape stay with the cards.
+        assert_eq!(key(KeyCapture::Digits, gdk::Key::_4), "Some(Char('4'))");
+        assert_eq!(
+            key(KeyCapture::Digits, gdk::Key::e),
+            "Some(Char('e'))",
+            "a letter starts a name search"
+        );
+        assert_eq!(key(KeyCapture::Digits, gdk::Key::Return), "None");
+        assert_eq!(key(KeyCapture::Digits, gdk::Key::Escape), "None");
+        assert_eq!(key(KeyCapture::List, gdk::Key::KP_7), "Some(Char('7'))");
+        assert_eq!(key(KeyCapture::List, gdk::Key::minus), "Some(Char('-'))");
+        assert_eq!(
+            key(KeyCapture::List, gdk::Key::space),
+            "None",
+            "space is never taken"
+        );
+        assert_eq!(
+            key(KeyCapture::List, gdk::Key::Return),
+            "None",
+            "with nothing typed, Enter still reaches the focused card"
+        );
+        assert_eq!(key(KeyCapture::ListTyped, gdk::Key::Return), "Some(Enter)");
+        assert_eq!(
+            key(KeyCapture::List, gdk::Key::BackSpace),
+            "Some(Backspace)"
+        );
+        assert_eq!(key(KeyCapture::List, gdk::Key::Escape), "Some(Escape)");
+        assert_eq!(key(KeyCapture::None, gdk::Key::a), "None");
+        assert!(matches!(
+            directory_key(KeyCapture::ListTyped, gdk::Key::KP_Enter, false),
+            Some(DirectoryKey::Enter)
+        ));
+    }
+
     #[test]
     fn brand_names_the_focused_windows_project_and_folder() {
         let card: Card = serde_json::from_value(serde_json::json!({