diff --git a/crates/keymap/src/keymap.rs b/crates/keymap/src/keymap.rs index a5fcfd577..7bcb8f0d9 100644 --- a/crates/keymap/src/keymap.rs +++ b/crates/keymap/src/keymap.rs @@ -423,15 +423,47 @@ impl Keymap { ScopeKind::Panel => Active::panel(name[0]), ScopeKind::Context => Active { panel: None, contexts: &name, typing: false }, }; - match self.lookup(&trigger.chord, false, &active) { - Lookup::None => false, - Lookup::Run(c) => self.find(&c) == Some(i), - Lookup::Cycle(cycle) => cycle.iter().any(|c| self.find(c) == Some(i)), - } + self.press_runs(&trigger.chord, &active, i) }; single().filter(|(_, scope)| scope == home).chain(single().filter(|(_, scope)| scope != home)).find(runs).map(|(trigger, _)| trigger.chord) } + /// Whether a single press of `chord` with `active` focus runs catalog entry `i`, alone or in a cycle: what + /// [`lookup`](Self::lookup) answers, decided on catalog positions without building the answer's commands. + /// [`shown_chord`](Self::shown_chord) asks it for each binding of every command a frame shows. + fn press_runs(&self, chord: &Chord, active: &Active, i: usize) -> bool { + let want = Trigger { chord: chord.effective(self.platform), double: false }; + let held = active.typing && !self.typing.fires(&want.chord, self.platform); + let Some(holders) = self.by_trigger.get(&want) else { return false }; + // Each command's nearest rank, as `lookup_nested` ranks them: `holders` is in catalog order, so a command's + // bindings are consecutive. + let ranked = || { + let mut out: Vec<(usize, u8)> = Vec::new(); + for &(j, k) in holders { + let Some(r) = self.at(j, k).and_then(|(_, s)| self.scopes.rank_nested(s, active, &[])) else { continue }; + if held && r != 0 { + continue; + } + match out.last_mut() { + Some((last, best)) if *last == j => *best = (*best).min(r), + _ => out.push((j, r)), + } + } + out + }; + let ranks = ranked(); + let Some(best) = ranks.iter().map(|(_, r)| *r).min() else { return false }; + let mut winners = ranks.iter().filter(|(_, r)| *r == best).map(|(j, _)| *j); + let Some(first) = winners.next() else { return false }; + let rest: Vec = winners.collect(); + if rest.is_empty() || !rest.iter().all(|j| self.same_group(first, *j)) { + // One winner, or several of different groups: the first runs. + return first == i; + } + // A cycle of the winners. + first == i || rest.contains(&i) + } + /// The command that holds `chord` for a surface that takes the key whatever has focus (a system menu item): the /// command a single press runs with no panel focused (a cycle's first), else the first command in catalog order /// that binds it in a panel or context scope. @@ -604,7 +636,13 @@ impl Keymap { } fn find(&self, command: &CommandRef) -> Option { - self.index.get(&command.key()).copied() + // A command without parameters is keyed by its id (`CommandRef::key`): look it up without building the key. + // Menu rows, tooltips and buttons ask for their chords on every frame. + match &command.params { + serde_json::Value::Null => self.index.get(command.id.as_str()).copied(), + serde_json::Value::Object(params) if params.is_empty() => self.index.get(command.id.as_str()).copied(), + _ => self.index.get(&command.key()).copied(), + } } fn resolve_key(&self, key: &str) -> Option { diff --git a/crates/keymap/tests/keymap.rs b/crates/keymap/tests/keymap.rs index c4843eb1a..22b1b7cb5 100644 --- a/crates/keymap/tests/keymap.rs +++ b/crates/keymap/tests/keymap.rs @@ -195,3 +195,27 @@ fn the_alt_variant_follows_the_commands_key_and_yields_to_a_bound_alt_chord() { let km = Keymap::new(vec![app("layer.new.layer", &["F2"])], Scopes::new(), Platform::Mac); assert!(hit(&km, &alt(Key::F2, false, false)).is_none(), "a command that did not opt in has no Alt variant"); } + +/// Tools that share a chord: within one group a press cycles through them, so each shows the chord; across groups the +/// first in catalog order runs, so only it shows the chord. `shown_chord` decides on catalog positions (#15493) and +/// must answer as the lookup does. +#[test] +fn tools_sharing_a_chord_show_it_as_the_lookup_runs_them() { + use craft_keymap::CommandKind; + let tool = |id: &str, group: &str, keys: &[&str]| app(id, keys).with_kind(CommandKind::Tool { group: Some(group.into()) }); + let catalog = vec![ + tool("tool.marquee", "select", &["M"]), + tool("tool.ellipse", "select", &["M"]), + tool("tool.move", "move", &["V"]), + tool("tool.artboard", "board", &["V"]), + ]; + let km = Keymap::new(catalog, scopes(), Platform::Mac); + assert_eq!(press(&km, "M", &Active::NONE), Lookup::Cycle(vec![cmd("tool.marquee"), cmd("tool.ellipse")])); + assert_eq!(km.shown_chord(&cmd("tool.marquee")), Some(chord("M")), "a cycle runs its first tool"); + assert_eq!(km.shown_chord(&cmd("tool.ellipse")), Some(chord("M")), "and its other tools"); + assert_eq!(press(&km, "V", &Active::NONE), run("tool.move")); + assert_eq!(km.shown_chord(&cmd("tool.move")), Some(chord("V")), "of two groups the first runs"); + assert_eq!(km.shown_chord(&cmd("tool.artboard")), None, "the other group's tool never runs on V"); + // A command with empty parameters is the same command. + assert_eq!(km.shown_chord(&CommandRef::with_params("tool.move", serde_json::json!({}))), Some(chord("V"))); +} diff --git a/crates/menu/src/bar.rs b/crates/menu/src/bar.rs index ed436e6e1..9cd2119c0 100644 --- a/crates/menu/src/bar.rs +++ b/crates/menu/src/bar.rs @@ -134,10 +134,12 @@ impl<'a> MenuBarUi<'a> { let titles: Vec> = self.bar.menus.iter().zip(labels).map(|(menu, label)| MenuTitle::new(label, move |ui| shared.show(ui, &menu.children))).collect(); let help = self.help_search.then(|| self.bar.menus.iter().position(|menu| menu.role == MenuRole::Help)).flatten(); - let entries = if help.is_some() { entries_of(self.bar, self.english) } else { Vec::new() }; + // Collecting the search's commands walks every row of every menu: the bar does it only while Help is open. + let (bar_model, english) = (self.bar, self.english); + let entries = move || entries_of(bar_model, english); let mut bar = Bar::new(env.words::().label.clone(), titles).keyboard(self.keyboard.unwrap_or(self.target != Target::Mac)); if let Some(menu) = help { - bar = bar.help(MenuHelp::new(menu, &entries)); + bar = bar.help(MenuHelp::built(menu, &entries)); } MenuBarOutput { titles: bar.show(ui).titles } } diff --git a/crates/ui-widgets/src/menu/bar.rs b/crates/ui-widgets/src/menu/bar.rs index 8ef968644..26000173b 100644 --- a/crates/ui-widgets/src/menu/bar.rs +++ b/crates/ui-widgets/src/menu/bar.rs @@ -173,17 +173,50 @@ impl<'a> MenuTitle<'a> { } /// The Help menu's search: the index of the menu that starts with the field, and the commands it searches. -#[derive(Clone, Copy, Debug)] +#[derive(Clone, Copy)] #[non_exhaustive] pub struct MenuHelp<'a> { menu: usize, - entries: &'a [HelpEntry], + entries: HelpEntries<'a>, +} + +/// Where the help search's commands come from: a list the caller built, or a builder the bar runs only while the +/// Help menu is open. +#[derive(Clone, Copy)] +enum HelpEntries<'a> { + Listed(&'a [HelpEntry]), + Built(&'a dyn Fn() -> Vec), +} + +impl std::fmt::Debug for MenuHelp<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let entries = match self.entries { + HelpEntries::Listed(entries) => format!("{} listed", entries.len()), + HelpEntries::Built(_) => "built when opened".to_string(), + }; + f.debug_struct("MenuHelp").field("menu", &self.menu).field("entries", &entries).finish() + } } impl<'a> MenuHelp<'a> { /// A search field at the top of the menu `menu` (its position among the titles) over `entries`. pub fn new(menu: usize, entries: &'a [HelpEntry]) -> Self { - MenuHelp { menu, entries } + MenuHelp { menu, entries: HelpEntries::Listed(entries) } + } + + /// A search field at the top of the menu `menu` over the commands `entries` builds. The bar runs it only in a pass + /// that shows the Help menu, so an app whose command list is costly to collect (every row of its menus) pays + /// nothing while the menu is closed. + pub fn built(menu: usize, entries: &'a dyn Fn() -> Vec) -> Self { + MenuHelp { menu, entries: HelpEntries::Built(entries) } + } + + /// The commands, built now for a builder. + fn entries(&self) -> std::borrow::Cow<'a, [HelpEntry]> { + match self.entries { + HelpEntries::Listed(entries) => std::borrow::Cow::Borrowed(entries), + HelpEntries::Built(build) => std::borrow::Cow::Owned(build()), + } } } @@ -524,9 +557,10 @@ impl Component for MenuBar<'_> { let folder = cx.env.folder(); let texts = self.texts(&cx.env); let help = self.help; - let help_rows = help - .filter(|help| opened == Some(Open::Title(help.menu))) - .map(|help| Self::help_texts(help.entries, &cx.env, cx.env.words::().path_separator.as_str())); + // Only a pass that shows the Help menu needs its commands; a builder runs here and nowhere else. + let help_entries = help.filter(|help| opened == Some(Open::Title(help.menu))).map(|help| help.entries()); + let help_rows = + help_entries.as_deref().map(|entries| Self::help_texts(entries, &cx.env, cx.env.words::().path_separator.as_str())); // The search starts empty each time the Help menu opens. let mut query = if help_rows.is_some() { cx.memory::().clone() } else { Query::default() }; let mut stepped = None; @@ -542,7 +576,9 @@ impl Component for MenuBar<'_> { Menu::inline(Label::from(name.clone())) .show(ui, |ui, menu| match slot { Open::Title(at) => { - if let (Some(help), Some(rows)) = (help.filter(|help| help.menu == *at), help_rows.as_ref()) { + if let (Some(_), Some(rows), Some(entries)) = + (help.filter(|help| help.menu == *at), help_rows.as_ref(), help_entries.as_deref()) + { // The field sits in a padded frame: its edge lines up with the row labels and it keeps clear of the first row. // The field drives the menu: Up, Down, Home and End move its active row and Enter runs // it, or the first enabled match, while typing stays in the field. @@ -574,14 +610,14 @@ impl Component for MenuBar<'_> { let listed: Vec = search_order(&folder, &query.0, &refs) .into_iter() .filter(|at| { - let command = help.entries[*at].command(); + let command = entries[*at].command(); let fresh = !seen.contains(&command); seen.push(command); fresh }) .collect(); for at in &listed { - let entry = &help.entries[*at]; + let entry = &entries[*at]; let row = MenuItem::command(entry.command().clone()).label(entry.label().clone()); if entry.path().is_empty() { row.show(ui) diff --git a/crates/ui-widgets/tests/it/menu/bar.rs b/crates/ui-widgets/tests/it/menu/bar.rs index be86bf637..aba100d4a 100644 --- a/crates/ui-widgets/tests/it/menu/bar.rs +++ b/crates/ui-widgets/tests/it/menu/bar.rs @@ -146,3 +146,50 @@ fn a_pointer_move_over_menu_rows_lights_the_row_under_it_in_that_frame() { } } } + +/// A help search over built entries builds them only in a pass that shows the Help menu: a bar whose menus stay closed +/// never runs the builder, an open File menu doesn't either, and the open Help menu searches what it built. +#[trial] +fn built_help_entries_are_collected_only_while_the_help_menu_shows() { + use std::cell::Cell; + use std::rc::Rc; + let builds = Rc::new(Cell::new(0u32)); + let counted = builds.clone(); + let mut fixture = Fixture::new(move |ui| { + let titles = vec![ + MenuTitle::new("&File", |ui| { + MenuItem::new("&New").show(ui); + }), + MenuTitle::new("&Help", |ui| { + MenuItem::new("&About").show(ui); + }), + ]; + let counted = counted.clone(); + let build = move || { + counted.set(counted.get() + 1); + entries() + }; + MenuBar::new("Main menu", titles).help(MenuHelp::built(1, &build)).show(ui); + }); + fixture.settle(); + fixture.settle(); + assert_eq!(builds.get(), 0, "closed menus build nothing"); + + let file = fixture.by_label("File").expect("the File title"); + fixture.click(&file); + fixture.settle(); + assert!(fixture.by_label("New").is_some(), "File is open"); + assert_eq!(builds.get(), 0, "another open menu builds nothing"); + fixture.key(Key::Escape, Modifiers::NONE); + fixture.settle(); + + let help = fixture.by_label("Help").expect("the Help title"); + fixture.click(&help); + fixture.settle(); + assert!(builds.get() > 0, "the open Help menu builds its entries"); + let search = fixture.by_label("Search menus").expect("the search field"); + fixture.click(&search); + fixture.type_text("duplic"); + fixture.settle(); + assert!(fixture.by_label("Copy").is_some(), "the search finds a built entry by its English label"); +}