@tryinget/pi-activity-strip 0.8.0 → 0.10.0

package/native/panel/src/card_view.rs

@@ -16,6 +16,7 @@ const AK_CHIP_SLOTS: usize = 1;
 
 pub struct CardView {
     pub root: gtk::Button,
+    pub motion: gtk::EventControllerMotion,
     phase: gtk::Label,
     repo: gtk::Label,
     state: gtk::Label,
@@ -154,7 +155,7 @@ impl CardView {
         motion.connect_leave(move |_| {
             let _ = tx.send(AppMsg::Hover(card_id.clone(), false));
         });
-        root.add_controller(motion);
+        root.add_controller(motion.clone());
 
         let focus = gtk::EventControllerFocus::new();
         let card_id = id.to_owned();
@@ -193,6 +194,7 @@ impl CardView {
 
         Self {
             root,
+            motion,
             phase,
             repo,
             state,
@@ -216,7 +218,14 @@ impl CardView {
         }
     }
 
-    pub fn update(&self, card: &Card, focused: bool, duplicate_label: bool, now_ms: i64) {
+    pub fn update(
+        &self,
+        card: &Card,
+        focused: bool,
+        duplicate_label: bool,
+        now_ms: i64,
+        key_hint: Option<&str>,
+    ) {
         let hidden_tab = card.hidden_tab();
         self.repo.set_text(&display_repo(card, duplicate_label));
         self.phase.set_text(text_or(&card.phase, "Idle"));
@@ -301,7 +310,7 @@ impl CardView {
         };
         let ak_note = ak_accessible_note(&card.ak_tasks);
         let window_note = window_note(card);
-        self.root.set_tooltip_text(Some(&format!(
+        let mut tooltip = format!(
             "{} {} ({}{}{}){}",
             if hidden_tab { "Present" } else { "Focus" },
             text_or(&card.repo_label, "Pi session"),
@@ -309,7 +318,13 @@ impl CardView {
             window_note,
             if hidden_tab { ", hidden tab" } else { "" },
             ak_note
-        )));
+        );
+        // The first rung of the keyboard hints: every card names the shortcut.
+        if let Some(hint) = key_hint {
+            tooltip.push('\n');
+            tooltip.push_str(hint);
+        }
+        self.root.set_tooltip_text(Some(&tooltip));
         let accessible_label = format!(
             "{}{}, {}, {}{}",
             text_or(&card.repo_label, "Pi session"),

package/native/panel/src/directory_view.rs

@@ -0,0 +1,471 @@
+use crate::app::AppMsg;
+use crate::protocol::WindowEntry;
+use relm4::Sender;
+use relm4::gtk;
+use relm4::gtk::prelude::*;
+use std::cell::RefCell;
+
+/// Enough digits for any Niri window id; a longer number is a typo, not a window.
+const MAX_WINDOW_DIGITS: usize = 9;
+/// A search is a few letters of a project name, never a sentence.
+const MAX_QUERY_CHARS: usize = 32;
+
+/// What Enter does with the typed query.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum JumpChoice {
+    /// A number: exactly that Niri window, listed or not.
+    Window(i64),
+    /// A name: the first listed match, opened like clicking its row.
+    Card(String),
+}
+
+/// The brand block's window list: every agent window on every workspace, as its card's first line
+/// and its Niri window number. The typed query narrows it by name or number; Enter goes to the
+/// typed window number, or to the first match of a name.
+pub struct DirectoryView {
+    pub root: gtk::Box,
+    status: gtk::Label,
+    rows: gtk::Box,
+    // Every material field (including the activation target), but not current styling.
+    rendered_rows: RefCell<Vec<WindowEntry>>,
+    sender: Sender<AppMsg>,
+}
+
+impl DirectoryView {
+    pub fn new(sender: &Sender<AppMsg>) -> Self {
+        let root = gtk::Box::new(gtk::Orientation::Vertical, 6);
+        root.add_css_class("directory");
+        root.set_visible(false);
+        root.set_vexpand(true);
+        root.set_margin_top(8);
+
+        let status = gtk::Label::new(None);
+        status.add_css_class("jump-line");
+        status.set_halign(gtk::Align::Fill);
+        status.set_xalign(0.0);
+
+        let rows = gtk::Box::new(gtk::Orientation::Vertical, 1);
+        let scroller = gtk::ScrolledWindow::new();
+        scroller.add_css_class("directory-scroller");
+        scroller.set_policy(gtk::PolicyType::Never, gtk::PolicyType::Automatic);
+        // Fill the brand column's height; rows beyond it scroll (wheel or touchpad, no bar).
+        scroller.set_vexpand(true);
+        scroller.set_child(Some(&rows));
+
+        root.append(&status);
+        root.append(&scroller);
+        Self {
+            root,
+            status,
+            rows,
+            rendered_rows: RefCell::new(Vec::new()),
+            sender: sender.clone(),
+        }
+    }
+
+    pub fn set_visible(&self, visible: bool) {
+        self.root.set_visible(visible);
+    }
+
+    /// Strong references let GTK tests distinguish retained rows from replacement widgets.
+    #[cfg(test)]
+    pub(crate) fn row_widgets(&self) -> Vec<gtk::Widget> {
+        let mut rows = Vec::new();
+        let mut child = self.rows.first_child();
+        while let Some(row) = child {
+            child = row.next_sibling();
+            rows.push(row);
+        }
+        rows
+    }
+
+    /// Retain rows when their material data and order match; update focus/choice styling in
+    /// place. Clicking a row activates its card, including hidden tabs. The row Enter opens is
+    /// marked, so a typed name always shows where it leads.
+    pub fn render(
+        &self,
+        windows: &[WindowEntry],
+        query: &str,
+        can_type: bool,
+        allow_unlisted: bool,
+        hotkey: Option<&str>,
+    ) {
+        let shown = filter_entries(windows, query);
+        let key: Vec<WindowEntry> = shown
+            .iter()
+            .map(|entry| {
+                let mut key = (**entry).clone();
+                key.current = false;
+                key
+            })
+            .collect();
+        // Empty states have different messages; rebuild them rather than caching a label.
+        let reuse = !shown.is_empty() && *self.rendered_rows.borrow() == key;
+        if !reuse {
+            while let Some(child) = self.rows.first_child() {
+                self.rows.remove(&child);
+            }
+        }
+        let mut retained = self.rows.first_child();
+        let choice = jump_choice(windows, query, allow_unlisted);
+        // Alphabetical from the controller, so workspace headings would repeat; each row names
+        // its workspace instead.
+        for entry in &shown {
+            let chosen = match &choice {
+                Some(JumpChoice::Window(id)) => entry.window_id == *id,
+                Some(JumpChoice::Card(card_id)) => &entry.card_id == card_id,
+                None => false,
+            };
+            if reuse {
+                let row = retained.take().expect("cached directory row exists");
+                retained = row.next_sibling();
+                for (class, enabled) in [("current", entry.current), ("chosen", chosen)] {
+                    if enabled {
+                        row.add_css_class(class);
+                    } else {
+                        row.remove_css_class(class);
+                    }
+                }
+            } else {
+                self.rows.append(&self.row(entry, chosen));
+            }
+        }
+        *self.rendered_rows.borrow_mut() = key;
+        if shown.is_empty() {
+            let empty = gtk::Label::new(Some(if windows.is_empty() {
+                "No agent windows"
+            } else {
+                "No listed window matches"
+            }));
+            empty.add_css_class("directory-empty");
+            empty.set_xalign(0.0);
+            self.rows.append(&empty);
+        }
+        self.status.set_text(&status_text(
+            windows,
+            query,
+            can_type,
+            allow_unlisted,
+            hotkey,
+        ));
+    }
+
+    /// The typing hint alone, leaving the rows (and any click in progress on them) untouched.
+    pub fn set_prompt(
+        &self,
+        windows: &[WindowEntry],
+        query: &str,
+        can_type: bool,
+        allow_unlisted: bool,
+        hotkey: Option<&str>,
+    ) {
+        self.status.set_text(&status_text(
+            windows,
+            query,
+            can_type,
+            allow_unlisted,
+            hotkey,
+        ));
+    }
+
+    /// A transient message after a jump or activation, until the next keystroke re-renders.
+    pub fn set_status(&self, message: &str) {
+        self.status.set_text(message);
+    }
+
+    fn row(&self, entry: &WindowEntry, chosen: bool) -> gtk::Button {
+        let row = gtk::Button::new();
+        row.add_css_class("directory-row");
+        if entry.current {
+            row.add_css_class("current");
+        }
+        if chosen {
+            row.add_css_class("chosen");
+        }
+        let line = gtk::Box::new(gtk::Orientation::Horizontal, 8);
+        let label = gtk::Label::new(Some(&format!(
+            "{}{}",
+            if entry.hidden_tab { "⧉ " } else { "" },
+            entry.label
+        )));
+        label.add_css_class("directory-label");
+        label.set_xalign(0.0);
+        label.set_hexpand(true);
+        label.set_ellipsize(relm4::gtk::pango::EllipsizeMode::End);
+        label.set_max_width_chars(1);
+        let workspace = gtk::Label::new(Some(&workspace_tag(entry)));
+        workspace.add_css_class("directory-workspace");
+        let id = gtk::Label::new(Some(&format!("#{}", entry.window_id)));
+        id.add_css_class("directory-id");
+        line.append(&label);
+        line.append(&workspace);
+        line.append(&id);
+        row.set_child(Some(&line));
+        row.set_tooltip_text(Some(&format!(
+            "{} — window #{}, {}{}",
+            entry.label,
+            entry.window_id,
+            workspace_title(entry),
+            if entry.hidden_tab { ", hidden tab" } else { "" }
+        )));
+        let tx = self.sender.clone();
+        let card_id = entry.card_id.clone();
+        row.connect_clicked(move |_| {
+            let _ = tx.send(AppMsg::DirectoryActivate(card_id.clone()));
+        });
+        row
+    }
+}
+
+/// Entries whose project name contains the query (ignoring case) or whose window number starts
+/// with it; all of them when nothing is typed.
+pub fn filter_entries<'a>(windows: &'a [WindowEntry], query: &str) -> Vec<&'a WindowEntry> {
+    let needle = query.to_lowercase();
+    windows
+        .iter()
+        .filter(|entry| {
+            entry.window_id.to_string().starts_with(&needle)
+                || entry.label.to_lowercase().contains(&needle)
+        })
+        .collect()
+}
+
+fn is_window_number(query: &str) -> bool {
+    !query.is_empty() && query.chars().all(|character| character.is_ascii_digit())
+}
+
+/// What Enter does. Digits go to the listed window with exactly that number; failing that, to a
+/// project whose name contains them (`0844` finds `pi-0844-…`); failing that, when
+/// `allow_unlisted`, to exactly that number, listed or not, never a guessed completion. Anything
+/// else goes to the first project whose name contains it. Nothing typed, or nothing matching,
+/// does nothing. Typing held only by hover passes `allow_unlisted = false`, so a digit typed at a
+/// terminal prompt cannot reach an arbitrary window.
+pub fn jump_choice(
+    windows: &[WindowEntry],
+    query: &str,
+    allow_unlisted: bool,
+) -> Option<JumpChoice> {
+    if query.is_empty() {
+        return None;
+    }
+    let needle = query.to_lowercase();
+    let named = || {
+        windows
+            .iter()
+            .find(|entry| entry.label.to_lowercase().contains(&needle))
+            .map(|entry| JumpChoice::Card(entry.card_id.clone()))
+    };
+    if !is_window_number(query) {
+        return named();
+    }
+    let number = (query.len() <= MAX_WINDOW_DIGITS)
+        .then(|| query.parse::<i64>().ok())
+        .flatten();
+    if let Some(id) = number
+        && windows.iter().any(|entry| entry.window_id == id)
+    {
+        return Some(JumpChoice::Window(id));
+    }
+    named().or(number.filter(|_| allow_unlisted).map(JumpChoice::Window))
+}
+
+/// Append a typed character: letters and digits, and the `-`, `_` and `.` of project names.
+pub fn push_query_char(query: &mut String, character: char) -> bool {
+    if !is_query_char(character) || query.chars().count() >= MAX_QUERY_CHARS {
+        return false;
+    }
+    query.push(character);
+    true
+}
+
+pub fn is_query_char(character: char) -> bool {
+    character.is_alphanumeric() || matches!(character, '-' | '_' | '.')
+}
+
+/// The short workspace marker on each row: the number the operator sees in Niri.
+fn workspace_tag(entry: &WindowEntry) -> String {
+    entry
+        .workspace_idx
+        .map(|idx| format!("ws{idx}"))
+        .unwrap_or_default()
+}
+
+/// The workspace in full, for the row's tooltip: its number and any name.
+fn workspace_title(entry: &WindowEntry) -> String {
+    let number = entry
+        .workspace_idx
+        .map(|idx| format!("workspace {idx}"))
+        .unwrap_or_else(|| "workspace".to_owned());
+    match entry
+        .workspace_name
+        .as_deref()
+        .filter(|name| !name.is_empty())
+    {
+        Some(name) => format!("{number} · {name}"),
+        None => number,
+    }
+}
+
+fn status_text(
+    windows: &[WindowEntry],
+    query: &str,
+    can_type: bool,
+    allow_unlisted: bool,
+    hotkey: Option<&str>,
+) -> String {
+    if !can_type {
+        // The keyboard was handed back (hover timeout); a click or the shortcut takes it again.
+        return crate::hints::pointer_prompt(hotkey);
+    }
+    match jump_choice(windows, query, allow_unlisted) {
+        _ if query.is_empty() => "Type a name or number · ⏎ go".to_owned(),
+        Some(JumpChoice::Window(_)) => format!("#{query}▏ ⏎ jump · ⌫ edit"),
+        Some(JumpChoice::Card(card_id)) => {
+            let label = windows
+                .iter()
+                .find(|entry| entry.card_id == card_id)
+                .map(|entry| entry.label.as_str())
+                .unwrap_or("match");
+            format!("{query}▏ ⏎ {label}")
+        }
+        None => format!("{query}▏ no match"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn jump_choice_open(windows: &[WindowEntry], query: &str) -> Option<JumpChoice> {
+        jump_choice(windows, query, true)
+    }
+
+    fn entry(label: &str, window_id: i64, workspace_idx: i64) -> WindowEntry {
+        WindowEntry {
+            card_id: format!("card-{window_id}"),
+            label: label.into(),
+            window_id,
+            workspace_id: Some(workspace_idx + 100),
+            workspace_idx: Some(workspace_idx),
+            workspace_name: None,
+            hidden_tab: false,
+            current: false,
+        }
+    }
+
+    #[test]
+    fn the_status_line_says_what_enter_will_do() {
+        let windows = vec![entry("pi-extensions", 432, 2)];
+        assert_eq!(
+            status_text(&windows, "", false, true, None),
+            "Click, then type a name or number"
+        );
+        assert_eq!(
+            status_text(&windows, "", false, true, Some("Super+Shift+A")),
+            "Click or Super+Shift+A to type"
+        );
+        assert_eq!(
+            status_text(&windows, "", true, true, None),
+            "Type a name or number · ⏎ go"
+        );
+        assert!(status_text(&windows, "43", true, true, None).starts_with("#43"));
+        assert_eq!(
+            status_text(&windows, "ext", true, true, None),
+            "ext▏ ⏎ pi-extensions"
+        );
+        assert_eq!(
+            status_text(&windows, "zzz", true, true, None),
+            "zzz▏ no match"
+        );
+    }
+
+    #[test]
+    fn the_query_matches_names_anywhere_and_numbers_from_the_start() {
+        let windows = vec![
+            entry("pi-extensions", 43, 2),
+            entry("dep-diet", 432, 2),
+            entry("Text-Tools", 344, 3),
+        ];
+        let labels = |query: &str| -> Vec<String> {
+            filter_entries(&windows, query)
+                .iter()
+                .map(|entry| entry.label.clone())
+                .collect()
+        };
+        assert_eq!(labels("").len(), 3);
+        assert_eq!(
+            labels("ext"),
+            ["pi-extensions", "Text-Tools"],
+            "any case, anywhere"
+        );
+        assert_eq!(labels("43"), ["pi-extensions", "dep-diet"]);
+        assert_eq!(labels("432"), ["dep-diet"]);
+        assert!(labels("9").is_empty());
+    }
+
+    #[test]
+    fn enter_goes_to_the_typed_number_or_the_first_named_match() {
+        let windows = vec![entry("dep-diet", 432, 2), entry("pi-extensions", 43, 2)];
+        assert_eq!(
+            jump_choice_open(&windows, "43"),
+            Some(JumpChoice::Window(43))
+        );
+        assert_eq!(
+            jump_choice_open(&windows, "007"),
+            Some(JumpChoice::Window(7)),
+            "a number need not be listed"
+        );
+        assert_eq!(jump_choice_open(&windows, "1234567890"), None);
+        assert_eq!(
+            jump_choice_open(&windows, "d"),
+            Some(JumpChoice::Card("card-432".into())),
+            "the first listed match"
+        );
+        assert_eq!(jump_choice_open(&windows, "nothing"), None);
+        let numbered = vec![entry("pi-0844-qualification", 12, 2), entry("x", 844, 2)];
+        assert_eq!(
+            jump_choice_open(&numbered, "844"),
+            Some(JumpChoice::Window(844)),
+            "a listed window number wins"
+        );
+        assert_eq!(
+            jump_choice_open(&numbered[..1], "0844"),
+            Some(JumpChoice::Card("card-12".into())),
+            "digits inside a name, with no such window listed, go to that project"
+        );
+        assert_eq!(jump_choice_open(&windows, ""), None);
+        assert_eq!(
+            jump_choice(&windows, "1", false),
+            None,
+            "held only by hover, an unlisted number goes nowhere"
+        );
+        assert_eq!(
+            jump_choice(&windows, "43", false),
+            Some(JumpChoice::Window(43)),
+            "a listed number still jumps"
+        );
+    }
+
+    #[test]
+    fn the_query_takes_name_characters_up_to_a_bound() {
+        let mut query = String::new();
+        assert!(push_query_char(&mut query, 'e'));
+        assert!(push_query_char(&mut query, '-'));
+        assert!(push_query_char(&mut query, '4'));
+        assert!(!push_query_char(&mut query, ' '));
+        assert!(!push_query_char(&mut query, '/'));
+        for _ in 0..50 {
+            push_query_char(&mut query, 'x');
+        }
+        assert_eq!(query.chars().count(), MAX_QUERY_CHARS);
+    }
+
+    #[test]
+    fn each_row_names_its_workspace() {
+        let mut named = entry("a", 1, 3);
+        named.workspace_name = Some("claude-recovery".into());
+        assert_eq!(workspace_tag(&named), "ws3");
+        assert_eq!(workspace_title(&named), "workspace 3 · claude-recovery");
+        assert_eq!(workspace_title(&entry("a", 1, 2)), "workspace 2");
+    }
+}

package/native/panel/src/hints.rs

@@ -0,0 +1,65 @@
+//! Progressive keyboard hints. The ribbon teaches its shortcut in three steps, each shown only
+//! once the operator is already doing the step before it: every tooltip names the shortcut, the
+//! list's status line says what the keyboard would do right now, and keyboard mode itself shows
+//! the whole key map where the folder path normally is.
+
+/// The whole key map, for the brand tooltip and the docs.
+pub const KEY_MAP: &str =
+    "←/→ move · Shift+←/→ reorder · Enter open\nType a name or window # to jump · Esc leaves";
+
+/// Brand lines while keyboard mode is on: the key map replaces the folder path.
+pub const KEYBOARD_EYEBROW: &str = "⌨ KEYBOARD MODE";
+pub const KEYBOARD_META: &str = "←→ move · ⏎ open · Esc";
+
+/// One line under each card's tooltip: the shortcut that reaches the ribbon without the mouse.
+pub fn card_hint(hotkey: Option<&str>) -> Option<String> {
+    hotkey.map(|key| format!("{key} drives the strip from the keyboard"))
+}
+
+/// The brand tooltip: where you are, then how to get here without the mouse.
+pub fn brand_tooltip(cwd: Option<&str>, hotkey: Option<&str>) -> String {
+    let keys = match hotkey {
+        Some(key) => format!("{key} — keyboard mode\n{KEY_MAP}"),
+        None => format!("Keyboard mode\n{KEY_MAP}"),
+    };
+    match cwd.filter(|cwd| !cwd.is_empty()) {
+        Some(cwd) => format!("{cwd}\n\n{keys}"),
+        None => keys,
+    }
+}
+
+/// The list's prompt before it may type: the two ways to hand it the keyboard.
+pub fn pointer_prompt(hotkey: Option<&str>) -> String {
+    match hotkey {
+        Some(key) => format!("Click or {key} to type"),
+        None => "Click, then type a name or number".to_owned(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_level_names_the_bound_shortcut_and_none_invents_one() {
+        assert_eq!(card_hint(None), None);
+        assert!(
+            card_hint(Some("Super+Shift+A"))
+                .unwrap()
+                .starts_with("Super+Shift+A")
+        );
+        assert!(pointer_prompt(Some("Super+Shift+A")).contains("Super+Shift+A"));
+        assert_eq!(pointer_prompt(None), "Click, then type a name or number");
+        let tooltip = brand_tooltip(Some("/home/me/repo"), Some("Super+Shift+A"));
+        assert!(tooltip.starts_with("/home/me/repo\n\nSuper+Shift+A"));
+        assert!(tooltip.contains("Esc leaves"));
+        assert!(brand_tooltip(Some(""), None).starts_with("Keyboard mode"));
+    }
+
+    #[test]
+    fn the_keyboard_mode_lines_fit_the_brand_column() {
+        // BRAND_WIDTH is 196 px; the meta font fits about 26 characters before ellipsizing.
+        assert!(KEYBOARD_META.chars().count() <= 26);
+        assert!(KEYBOARD_EYEBROW.chars().count() <= 26);
+    }
+}

package/native/panel/src/hover-lifecycle-fixtures.json

@@ -0,0 +1,30 @@
+[
+  {
+    "name": "capture releases and late focus cannot revive",
+    "steps": [["grant", true], ["capture", true], ["release", false], ["capture", false]]
+  },
+  {
+    "name": "release before GTK acquisition is final",
+    "steps": [["grant", true], ["release", false], ["capture", false]]
+  },
+  {
+    "name": "old permission cannot transfer to a newer request",
+    "steps": [
+      ["grant", true],
+      ["capture", true],
+      ["release", false],
+      ["grant", true],
+      ["stale-permission", true],
+      ["capture", true],
+      ["release", false]
+    ]
+  },
+  {
+    "name": "source revocation defeats later acquisition",
+    "steps": [["grant", true], ["capture", true], ["source-revoked", false], ["capture", false]]
+  },
+  {
+    "name": "duplicate acquisition preserves one request",
+    "steps": [["grant", true], ["capture", true], ["capture", true], ["release", false]]
+  }
+]