LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M16.1: native macOS menu bar + in-window menus from the command registry
Brandon Thomas673e1bf6cbb2
diff --git a/Cargo.lock b/Cargo.lockindex 01e13890f..f22c48fa9 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -853,6 +853,15 @@ dependencies = ["cfg-if",]+[[package]]+name = "crossbeam-channel"+version = "0.5.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1"+dependencies = [+ "crossbeam-utils",+]+[[package]]name = "crossbeam-deque"version = "0.8.8"@@ -1927,6 +1936,16 @@ dependencies = ["tracing",]+[[package]]+name = "keyboard-types"+version = "0.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0fbe853b403ae61a04233030ae8a79d94975281ed9770a1f9e246732b534b28d"+dependencies = [+ "bitflags 2.13.2",+ "serde",+]+[[package]]name = "khronos-egl"version = "6.0.0"@@ -2011,6 +2030,7 @@ dependencies = ["lightcraft-raster","lightcraft-ui-egui","log",+ "muda","rfd","serde_json",]@@ -2392,6 +2412,25 @@ dependencies = ["pxfm",]+[[package]]+name = "muda"+version = "0.21.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6744ab645ebe79f9c428455c7cb9dfa4275fa3b50a25408e08f927da8dc618c"+dependencies = [+ "crossbeam-channel",+ "dpi",+ "keyboard-types",+ "objc2 0.6.4",+ "objc2-app-kit 0.3.2",+ "objc2-core-foundation",+ "objc2-foundation 0.3.2",+ "once_cell",+ "png",+ "thiserror 2.0.21",+ "windows-sys 0.61.2",+]+[[package]]name = "naga"version = "30.0.1"diff --git a/Cargo.toml b/Cargo.tomlindex 76abfa4c5..9e2bb1353 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -68,6 +68,7 @@ egui_extras = { version = "0.36", default-features = false }eframe = { version = "0.36", default-features = false }egui_kittest = "0.36"rfd = "0.17"+muda = { version = "0.21", default-features = false } # native menu bar (macOS: objc2/AppKit, pure Rust; no GTK)web-time = "1"# web (apps/lightcraft-web)diff --git a/apps/lightcraft/Cargo.toml b/apps/lightcraft/Cargo.tomlindex 96d7e8ab5..21de0243a 100644--- a/apps/lightcraft/Cargo.toml+++ b/apps/lightcraft/Cargo.toml@@ -21,3 +21,6 @@ log = { workspace = true }[target.'cfg(not(target_arch = "wasm32"))'.dependencies]rfd = { workspace = true }++[target.'cfg(target_os = "macos")'.dependencies]+muda = { workspace = true }diff --git a/apps/lightcraft/src/main.rs b/apps/lightcraft/src/main.rsindex baac940f1..7200568ee 100644--- a/apps/lightcraft/src/main.rs+++ b/apps/lightcraft/src/main.rs@@ -13,14 +13,20 @@//! See `lightcraft_ui_egui::control` for the methods.mod control_server;+#[cfg(target_os = "macos")]+mod native_menu;use lightcraft_engine::Session;use lightcraft_ui_egui::{LightcraftApp, Services, UiState};-struct App(LightcraftApp);+struct App(LightcraftApp, #[cfg(target_os = "macos")] Option<native_menu::NativeMenu>);impl eframe::App for App {fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {+ #[cfg(target_os = "macos")]+ if let Some(m) = self.1.as_mut() {+ m.update(&mut self.0, ctx);+ }self.0.logic(ctx);}fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {@@ -221,7 +227,15 @@ fn main() -> eframe::Result {let _ = app.run("library.import", serde_json::json!({"paths": files}));app.ui.view = lightcraft_ui_egui::state::ViewMode::PhotoGrid;}- Ok(Box::new(App(app)))+ // native menu bar generated from the command registry (macOS; elsewhere the menus are+ // drawn in the window's top bar). LIGHTCRAFT_NO_NATIVE_MENU=1 keeps the in-window menus.+ #[cfg(target_os = "macos")]+ let menu = (std::env::var_os("LIGHTCRAFT_NO_NATIVE_MENU").is_none()).then(|| native_menu::NativeMenu::install(&mut app, &cc.egui_ctx));+ Ok(Box::new(App(+ app,+ #[cfg(target_os = "macos")]+ menu,+ )))}),)}diff --git a/apps/lightcraft/src/native_menu.rs b/apps/lightcraft/src/native_menu.rsnew file mode 100644index 000000000..cfb1bd4e0--- /dev/null+++ b/apps/lightcraft/src/native_menu.rs@@ -0,0 +1,389 @@+//! The native macOS menu bar (via `muda`, pure Rust over AppKit), generated from the same model as+//! the in-window menus ([`lightcraft_ui_egui::menubar`]): the registry's menu paths, shortcuts,+//! enabled and checked state, and live labels ("Undo Exposure").+//!+//! Key handling: a native key equivalent consumes the key press before egui sees it, so+//! - shortcuts installed natively are listed in `LightcraftApp::native_shortcuts` and skipped by+//! the egui shortcut handler (nothing fires twice);+//! - while a text field has keyboard focus, accelerators without ⌘ (`G`, `1`, `Delete`…) and the+//! text-editing ones (⌘A/⌘C/⌘V/⌘X/⌘Z) are removed, so typing and text editing work; they come+//! back when the field loses focus.++use std::collections::{HashMap, HashSet};+use std::sync::mpsc::{Receiver, channel};++use lightcraft_ui_egui::LightcraftApp;+use lightcraft_ui_egui::menubar::{MenuNode, menu_bar};+use muda::accelerator::{Accelerator, Code, Modifiers};+use muda::{CheckMenuItem, Menu, MenuEvent, MenuItem, PredefinedMenuItem, Submenu};+use serde_json::Value;++const QUIT: &str = "app.quit";+/// Shortcuts text fields need while they have focus.+const TEXT_EDIT: &[&str] = &["Cmd+A", "Cmd+C", "Cmd+V", "Cmd+X", "Cmd+Z", "Cmd+Shift+Z"];++enum Handle {+ Plain(MenuItem),+ Check(CheckMenuItem),+}++struct Item {+ handle: Handle,+ cmd: String,+ params: Value,+ shortcut: Option<String>,+ accel: Option<Accelerator>,+ label: String,+ enabled: bool,+ checked: Option<bool>,+}++pub struct NativeMenu {+ menu: Menu,+ items: HashMap<String, Item>,+ rx: Receiver<String>,+ /// Structure of the installed menu (ids, kinds, submenu names); a change rebuilds it.+ structure: String,+ text_focus: bool,+}++/// `Cmd+Shift+Z` → a muda accelerator (`None` for keys we leave to egui, e.g. Escape).+fn accelerator(sc: &str) -> Option<Accelerator> {+ let mut mods = Modifiers::empty();+ let mut key = None;+ for part in sc.split('+') {+ match part {+ "Cmd" => mods |= Modifiers::META,+ "Shift" => mods |= Modifiers::SHIFT,+ "Alt" => mods |= Modifiers::ALT,+ "Ctrl" => mods |= Modifiers::CONTROL,+ k => key = Some(k),+ }+ }+ let code = match key? {+ k if k.len() == 1 && k.as_bytes()[0].is_ascii_alphabetic() => {+ const LETTERS: [Code; 26] = [+ Code::KeyA,+ Code::KeyB,+ Code::KeyC,+ Code::KeyD,+ Code::KeyE,+ Code::KeyF,+ Code::KeyG,+ Code::KeyH,+ Code::KeyI,+ Code::KeyJ,+ Code::KeyK,+ Code::KeyL,+ Code::KeyM,+ Code::KeyN,+ Code::KeyO,+ Code::KeyP,+ Code::KeyQ,+ Code::KeyR,+ Code::KeyS,+ Code::KeyT,+ Code::KeyU,+ Code::KeyV,+ Code::KeyW,+ Code::KeyX,+ Code::KeyY,+ Code::KeyZ,+ ];+ LETTERS[(k.as_bytes()[0].to_ascii_uppercase() - b'A') as usize]+ }+ k if k.len() == 1 && k.as_bytes()[0].is_ascii_digit() => {+ const DIGITS: [Code; 10] = [+ Code::Digit0,+ Code::Digit1,+ Code::Digit2,+ Code::Digit3,+ Code::Digit4,+ Code::Digit5,+ Code::Digit6,+ Code::Digit7,+ Code::Digit8,+ Code::Digit9,+ ];+ DIGITS[(k.as_bytes()[0] - b'0') as usize]+ }+ "[" => Code::BracketLeft,+ "]" => Code::BracketRight,+ "\\" => Code::Backslash,+ "/" => Code::Slash,+ "=" => Code::Equal,+ "-" => Code::Minus,+ "'" => Code::Quote,+ "Delete" => Code::Backspace,+ _ => return None,+ };+ Some(Accelerator::new(mods, code))+}++/// Accelerators that must step aside while a text field has focus.+fn yields_to_text(sc: &str) -> bool {+ !sc.contains("Cmd") && !sc.contains("Ctrl") || TEXT_EDIT.contains(&sc)+}++/// `&` marks a mnemonic in muda labels.+fn label_text(s: &str) -> String {+ s.replace('&', "&&")+}++fn structure_of(bar: &[(String, Vec<MenuNode>)]) -> String {+ fn walk(n: &[MenuNode], out: &mut String) {+ for x in n {+ match x {+ MenuNode::Item { id, params, checked, shortcut, .. } => {+ out.push_str(&MenuNode::key(id, params));+ out.push(if checked.is_some() { 'c' } else { 'i' });+ out.push_str(shortcut.as_deref().unwrap_or(""));+ }+ MenuNode::Separator => out.push('-'),+ MenuNode::Submenu { label, children } => {+ out.push('[');+ out.push_str(label);+ walk(children, out);+ out.push(']');+ }+ }+ out.push(';');+ }+ }+ let mut s = String::new();+ for (t, items) in bar {+ s.push_str(t);+ walk(items, &mut s);+ }+ s+}++impl NativeMenu {+ /// Build the menu bar and install it as the application menu (main thread, after launch).+ pub fn install(app: &mut LightcraftApp, ctx: &egui::Context) -> NativeMenu {+ let (tx, rx) = channel::<String>();+ let repaint = ctx.clone();+ MenuEvent::set_event_handler(Some(move |e: MenuEvent| {+ let _ = tx.send(e.id.0);+ repaint.request_repaint();+ }));+ let mut m = NativeMenu { menu: Menu::new(), items: HashMap::new(), rx, structure: String::new(), text_focus: false };+ m.rebuild(app);+ app.native_menu = true;+ m+ }++ fn rebuild(&mut self, app: &mut LightcraftApp) {+ let bar = menu_bar(app);+ self.structure = structure_of(&bar);+ self.menu = Menu::new();+ self.items.clear();++ // the application menu+ let app_menu = Submenu::new("LightCraft", true);+ let about = MenuItem::with_id("app.about", "About LightCraft", true, None);+ let quit = MenuItem::with_id(QUIT, "Quit LightCraft", true, accelerator("Cmd+Q"));+ let _ = app_menu.append_items(&[+ &about,+ &PredefinedMenuItem::separator(),+ &PredefinedMenuItem::services(None),+ &PredefinedMenuItem::separator(),+ &PredefinedMenuItem::hide(Some("Hide LightCraft")),+ &PredefinedMenuItem::hide_others(None),+ &PredefinedMenuItem::show_all(None),+ &PredefinedMenuItem::separator(),+ &quit,+ ]);+ let _ = self.menu.append(&app_menu);++ for (title, nodes) in &bar {+ let sub = Submenu::new(title, true);+ if title == "Window" {+ let _ = sub.append_items(&[+ &PredefinedMenuItem::minimize(None),+ &PredefinedMenuItem::maximize(Some("Zoom")),+ &PredefinedMenuItem::separator(),+ ]);+ }+ // About lives in the app menu on macOS+ let nodes: Vec<MenuNode> = nodes.iter().filter(|n| !matches!(n, MenuNode::Item { id, .. } if id == "app.about")).cloned().collect();+ self.append_nodes(&sub, &nodes);+ if title == "Window" {+ let _ = sub.append_items(&[&PredefinedMenuItem::separator(), &PredefinedMenuItem::bring_all_to_front(None)]);+ sub.set_as_windows_menu_for_nsapp();+ }+ if title == "Help" {+ sub.set_as_help_menu_for_nsapp();+ }+ let _ = self.menu.append(&sub);+ }+ self.menu.init_for_nsapp();+ self.text_focus = false;+ self.publish_shortcuts(app);+ }++ fn append_nodes(&mut self, sub: &Submenu, nodes: &[MenuNode]) {+ for n in nodes {+ match n {+ MenuNode::Separator => {+ let _ = sub.append(&PredefinedMenuItem::separator());+ }+ MenuNode::Submenu { label, children } => {+ let s = Submenu::new(label_text(label), true);+ self.append_nodes(&s, children);+ let _ = sub.append(&s);+ }+ MenuNode::Item { id, params, label, shortcut, enabled, checked } => {+ let key = MenuNode::key(id, params);+ if self.items.contains_key(&key) {+ continue; // muda ids must be unique+ }+ let accel = shortcut.as_deref().and_then(accelerator);+ let handle = match checked {+ Some(c) => {+ let it = CheckMenuItem::with_id(key.clone(), label_text(label), *enabled, *c, accel);+ let _ = sub.append(&it);+ Handle::Check(it)+ }+ None => {+ let it = MenuItem::with_id(key.clone(), label_text(label), *enabled, accel);+ let _ = sub.append(&it);+ Handle::Plain(it)+ }+ };+ self.items.insert(+ key,+ Item {+ handle,+ cmd: id.clone(),+ params: params.clone(),+ shortcut: shortcut.clone(),+ accel,+ label: label.clone(),+ enabled: *enabled,+ checked: *checked,+ },+ );+ }+ }+ }+ }++ /// Tell the egui shortcut handler which shortcuts the menu bar currently owns.+ fn publish_shortcuts(&self, app: &mut LightcraftApp) {+ app.native_shortcuts = self+ .items+ .values()+ .filter(|i| i.accel.is_some())+ .filter_map(|i| i.shortcut.clone())+ .filter(|sc| !(self.text_focus && yields_to_text(sc)))+ .collect::<HashSet<_>>();+ }++ /// Per frame: run chosen items, then sync labels / enabled / checked and the text-focus+ /// accelerators with the app state.+ pub fn update(&mut self, app: &mut LightcraftApp, ctx: &egui::Context) {+ while let Ok(key) = self.rx.try_recv() {+ if key == QUIT {+ ctx.send_viewport_cmd(egui::ViewportCommand::Close);+ continue;+ }+ if key == "app.about" {+ let _ = app.run("app.about", serde_json::json!({}));+ continue;+ }+ if let Some(it) = self.items.get(&key) {+ let (cmd, params) = (it.cmd.clone(), it.params.clone());+ let _ = lightcraft_ui_egui::menubar::run_item(app, &cmd, params);+ }+ }+ let bar = menu_bar(app);+ if structure_of(&bar) != self.structure {+ self.rebuild(app);+ return;+ }+ fn walk(nodes: &[MenuNode], items: &mut HashMap<String, Item>) {+ for n in nodes {+ match n {+ MenuNode::Submenu { children, .. } => walk(children, items),+ MenuNode::Item { id, params, label, enabled, checked, .. } => {+ let Some(it) = items.get_mut(&MenuNode::key(id, params)) else { continue };+ if it.label != *label {+ match &it.handle {+ Handle::Plain(h) => h.set_text(label_text(label)),+ Handle::Check(h) => h.set_text(label_text(label)),+ }+ it.label = label.clone();+ }+ if it.enabled != *enabled {+ match &it.handle {+ Handle::Plain(h) => h.set_enabled(*enabled),+ Handle::Check(h) => h.set_enabled(*enabled),+ }+ it.enabled = *enabled;+ }+ if let (Handle::Check(h), Some(c)) = (&it.handle, checked) {+ // also resyncs after AppKit toggled it on click+ if h.is_checked() != *c {+ h.set_checked(*c);+ }+ it.checked = Some(*c);+ }+ }+ MenuNode::Separator => {}+ }+ }+ }+ walk(&bar.iter().flat_map(|(_, v)| v.clone()).collect::<Vec<_>>(), &mut self.items);++ let focus = ctx.egui_wants_keyboard_input();+ if focus != self.text_focus {+ self.text_focus = focus;+ for it in self.items.values() {+ let Some(sc) = it.shortcut.as_deref() else { continue };+ if it.accel.is_none() || !yields_to_text(sc) {+ continue;+ }+ let accel = if focus { None } else { it.accel };+ let _ = match &it.handle {+ Handle::Plain(h) => h.set_accelerator(accel),+ Handle::Check(h) => h.set_accelerator(accel),+ };+ }+ self.publish_shortcuts(app);+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn shortcuts_map_to_accelerators() {+ assert_eq!(accelerator("Cmd+Shift+Z"), Some(Accelerator::new(Modifiers::META | Modifiers::SHIFT, Code::KeyZ)));+ assert_eq!(accelerator("G"), Some(Accelerator::new(Modifiers::empty(), Code::KeyG)));+ assert_eq!(accelerator("Cmd+'"), Some(Accelerator::new(Modifiers::META, Code::Quote)));+ assert_eq!(accelerator("Escape"), None);+ assert!(yields_to_text("G") && yields_to_text("Delete") && yields_to_text("Cmd+V"));+ assert!(!yields_to_text("Cmd+Shift+E"));+ // every registry shortcut that a menu shows maps (or is deliberately left to egui)+ let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), Default::default());+ fn all(n: &[MenuNode], out: &mut Vec<String>) {+ for x in n {+ match x {+ MenuNode::Item { shortcut: Some(s), .. } => out.push(s.clone()),+ MenuNode::Submenu { children, .. } => all(children, out),+ _ => {}+ }+ }+ }+ let mut scs = Vec::new();+ for (_, v) in menu_bar(&app) {+ all(&v, &mut scs);+ }+ for sc in scs {+ assert!(accelerator(&sc).is_some(), "{sc}");+ }+ }+}diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex 8d6cbfaec..27451dafa 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -132,6 +132,9 @@ pub fn handle(app: &mut LightcraftApp, ctx: &egui::Context, req: &ControlRequest}"engine.commands" => ok(all_commands(app)),"ui.menu.list" => ok(serde_json::to_value(crate::menus::menu_entries(app)).unwrap_or_default()),+ "ui.menu.tree" => {+ ok(Value::Array(crate::menubar::menu_bar(app).into_iter().map(|(title, items)| json!({"label": title, "children": items})).collect()))+ }"ui.inspect" => ok(inspect(app, ctx)),"ui.widgets" => {let filter = s("filter").unwrap_or("");diff --git a/crates/ui-egui/src/headless.rs b/crates/ui-egui/src/headless.rsindex 9def09301..96aa5a3bb 100644--- a/crates/ui-egui/src/headless.rs+++ b/crates/ui-egui/src/headless.rs@@ -335,6 +335,8 @@ mod tests {h.request("ui.set", json!({"view": "survey"}), t);h.request("ui.key", json!({"key": "escape"}), t);assert_eq!(h.app.ui.view, crate::state::ViewMode::Detail);+ // let in-flight renders finish: worker threads must not outlive the test process' TLS+ h.settle(Duration::from_secs(20));}#[test]diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex a03099674..3a525716b 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -8,6 +8,7 @@pub mod control;pub mod headless;pub mod icons;+pub mod menubar;pub mod menus;pub mod panels;pub mod render;@@ -59,8 +60,11 @@ pub struct LightcraftApp {pub perf: Perf,/// macOS: the host draws the traffic lights over our top bar.pub integrated_titlebar: bool,- /// The host installed a native menu bar.+ /// The host installed a native menu bar (no in-window menus then).pub native_menu: bool,+ /// Shortcuts the native menu bar currently handles (`Cmd+Z`, `G`…): the egui shortcut handler+ /// leaves them alone so nothing fires twice.+ pub native_shortcuts: std::collections::HashSet<String>,/// The host is [`headless::Headless`] (it answers viewport screenshot commands itself).pub headless_host: bool,control_rx: Option<Receiver<ControlRequest>>,@@ -92,6 +96,7 @@ impl LightcraftApp {perf: Perf::default(),integrated_titlebar: false,native_menu: false,+ native_shortcuts: Default::default(),headless_host: false,control_rx: None,pending_screenshots: vec![],diff --git a/crates/ui-egui/src/menubar.rs b/crates/ui-egui/src/menubar.rsnew file mode 100644index 000000000..0e74e2da9--- /dev/null+++ b/crates/ui-egui/src/menubar.rs@@ -0,0 +1,576 @@+//! The menu bar model: File, Edit, View, Photo, Window, Help, generated from the command registry+//! (engine commands with menu paths + [`crate::menus::UI_COMMANDS`]) with live labels, shortcuts,+//! enabled and checked state.+//!+//! One model drives every menu surface: the native macOS menu bar (built by the desktop host), the+//! in-window menu bar (web, Windows, Linux — [`show_in_window`]) and the control channel+//! (`ui.menu.tree`). Items are a command id plus parameters, run through [`run_item`] so they+//! behave exactly like their keyboard shortcuts.++use serde::Serialize;+use serde_json::{Value, json};++use crate::LightcraftApp;+use crate::menus::MenuEntry;+use crate::state::{RightPanel, ViewMode};++#[derive(Clone, Debug, PartialEq, Serialize)]+#[serde(tag = "kind", rename_all = "camelCase")]+pub enum MenuNode {+ Item {+ id: String,+ #[serde(skip_serializing_if = "Value::is_null")]+ params: Value,+ label: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ shortcut: Option<String>,+ enabled: bool,+ /// `Some` for toggles and radio-style choices.+ #[serde(skip_serializing_if = "Option::is_none")]+ checked: Option<bool>,+ },+ Separator,+ Submenu {+ label: String,+ children: Vec<MenuNode>,+ },+}++impl MenuNode {+ /// `id|params` — a stable key for one item (native menu ids).+ pub fn key(id: &str, params: &Value) -> String {+ if params.is_null() { id.to_string() } else { format!("{id}|{params}") }+ }+}++/// Top-level menus in order (the macOS app menu is added by the host).+pub const MENUS: &[&str] = &["File", "Edit", "View", "Photo", "Window", "Help"];++/// Order and grouping per menu: command ids, `---` separators and `@Submenu` placeholders.+/// Entries with a menu path that aren't listed are appended at the end of their menu.+const LAYOUT: &[(&str, &[&str])] = &[+ (+ "File",+ &[+ "file.addPhotos",+ "---",+ "dialog.newAlbum",+ "dialog.newFolder",+ "dialog.newSmartAlbum",+ "---",+ "file.importPresets",+ "file.exportPresets",+ "---",+ "dialog.export",+ "---",+ "library.toggleAutoWriteXmp",+ "---",+ ],+ ),+ (+ "Edit",+ &["edit.undo", "edit.redo", "---", "develop.copy", "dialog.copySettings", "develop.paste", "---", "library.selectAll", "library.selectNone"],+ ),+ (+ "View",+ &[+ "view.photoGrid",+ "view.squareGrid",+ "view.detail",+ "view.compare",+ "view.survey",+ "---",+ "view.leftPanel",+ "view.filmstrip",+ "view.histogram",+ "---",+ "view.showOriginal",+ "view.beforeAfter",+ "view.beforeAfterSplit",+ "---",+ "view.zoomIn",+ "view.zoomOut",+ "view.zoomToggle",+ "view.zoomFit",+ "view.zoom100",+ "---",+ "view.clipping",+ "view.maskOverlay",+ "view.cropOverlay",+ "---",+ "@Sort",+ "@Stacks",+ "view.filterBar",+ "library.clearFilter",+ "---",+ "compare.swap",+ "compare.makeSelect",+ ],+ ),+ (+ "Photo",+ &[+ "@Add to Album",+ "---",+ "@Set Rating",+ "@Set Flag",+ "@Set Color Label",+ "view.autoAdvance",+ "---",+ "photo.rotateLeft",+ "photo.rotateRight",+ "photo.flipHorizontal",+ "photo.flipVertical",+ "---",+ "version.create",+ "photo.virtualCopy",+ "@Stack",+ "---",+ "develop.auto",+ "develop.treatment",+ "develop.reset",+ "dialog.createPreset",+ "---",+ "photo.saveMetadataToFile",+ "photo.readMetadataFromFile",+ "---",+ "photo.delete",+ ],+ ),+ (+ "Window",+ &[+ "panel.edit",+ "panel.crop",+ "panel.remove",+ "panel.masking",+ "panel.redeye",+ "---",+ "panel.presets",+ "panel.versions",+ "panel.activity",+ "panel.info",+ "panel.keywords",+ "---",+ "@Edit Sections",+ "@Tools",+ ],+ ),+ ("Help", &["app.shortcuts", "---", "app.about"]),+];++/// Registry entries that are reached another way (parameterized commands are expanded into+/// submenus below; others duplicate a dialog command).+const HIDDEN: &[&str] = &[+ "photo.rate",+ "photo.flag",+ "photo.pick",+ "photo.reject",+ "photo.unflag",+ "photo.label",+ "library.sort",+ "album.addPhotos",+ "album.create",+ "library.import",+ "preset.create",+];++fn item(id: &str, params: Value, label: impl Into<String>, shortcut: Option<&str>, enabled: bool, checked: Option<bool>) -> MenuNode {+ MenuNode::Item { id: id.into(), params, label: label.into(), shortcut: shortcut.map(str::to_string), enabled, checked }+}++/// Checked state of toggles and radio items.+pub fn checked(app: &LightcraftApp, id: &str) -> Option<bool> {+ let u = &app.ui;+ let panel = |p: RightPanel| Some(u.right == p);+ match id {+ "view.photoGrid" => Some(u.view == ViewMode::PhotoGrid),+ "view.squareGrid" => Some(u.view == ViewMode::SquareGrid),+ "view.detail" => Some(u.view == ViewMode::Detail),+ "view.compare" => Some(u.view == ViewMode::Compare),+ "view.survey" => Some(u.view == ViewMode::Survey),+ "view.leftPanel" => Some(u.left_panel),+ "view.filmstrip" => Some(u.filmstrip),+ "view.histogram" => Some(u.histogram),+ "view.clipping" => Some(u.show_clipping),+ "view.maskOverlay" => Some(u.mask_overlay),+ "view.showOriginal" => Some(u.before_after == crate::state::BeforeAfter::Original),+ "view.beforeAfter" => Some(u.before_after == crate::state::BeforeAfter::SideBySide),+ "view.beforeAfterSplit" => Some(u.before_after == crate::state::BeforeAfter::Split),+ "view.autoAdvance" => Some(u.auto_advance),+ "panel.edit" => panel(RightPanel::Edit),+ "panel.crop" => panel(RightPanel::Crop),+ "panel.remove" => panel(RightPanel::Remove),+ "panel.masking" => panel(RightPanel::Masking),+ "panel.redeye" => panel(RightPanel::RedEye),+ "panel.versions" => panel(RightPanel::Versions),+ "panel.activity" => panel(RightPanel::Activity),+ "panel.info" => panel(RightPanel::Info),+ "panel.keywords" => panel(RightPanel::Keywords),+ "panel.presets" => Some(u.presets),+ "library.toggleAutoWriteXmp" => Some(app.session.xmp.auto_write),+ _ => None,+ }+}++/// Labels that follow the state ("Undo Exposure", "Delete 3 Photos").+fn live_label(app: &LightcraftApp, id: &str, label: &str) -> String {+ let n = app.session.selection.ids.len();+ match id {+ "edit.undo" => app.session.undo.last().map(|e| format!("Undo {}", e.label)).unwrap_or_else(|| "Undo".into()),+ "edit.redo" => app.session.redo.last().map(|e| format!("Redo {}", e.label)).unwrap_or_else(|| "Redo".into()),+ "photo.delete" if n > 1 => format!("Delete {n} Photos"),+ "photo.virtualCopy" if n > 1 => format!("Create {n} Virtual Copies"),+ _ => label.to_string(),+ }+}++/// The parameterized submenus.+fn expanded(app: &LightcraftApp, name: &str) -> Option<Vec<MenuNode>> {+ let active = app.session.active().and_then(|id| app.session.catalog.photo(id).cloned());+ let has = active.is_some();+ Some(match name {+ "Set Rating" => (0..=5u8)+ .map(|r| {+ let label = if r == 0 { "None".to_string() } else { "★".repeat(r as usize) };+ let sc = ["0", "1", "2", "3", "4", "5"][r as usize];+ item("photo.rate", json!({"rating": r}), label, Some(sc), has, Some(active.as_ref().is_some_and(|p| p.rating == r)))+ })+ .collect(),+ "Set Flag" => [+ ("pick", "Pick", "P", lightcraft_catalog::Flag::Pick),+ ("reject", "Reject", "X", lightcraft_catalog::Flag::Reject),+ ("none", "Unflagged", "U", lightcraft_catalog::Flag::None),+ ]+ .into_iter()+ .map(|(f, label, sc, flag)| {+ item("photo.flag", json!({"flag": f}), label, Some(sc), has, Some(active.as_ref().is_some_and(|p| p.flag == flag)))+ })+ .collect(),+ "Set Color Label" => {+ let mut v: Vec<MenuNode> = lightcraft_catalog::ColorLabel::ALL+ .iter()+ .zip([Some("6"), Some("7"), Some("8"), Some("9"), None])+ .map(|(l, sc)| {+ let name = format!("{l:?}");+ item(+ "photo.label",+ json!({"label": name.to_lowercase()}),+ name,+ sc,+ has,+ Some(active.as_ref().is_some_and(|p| p.label == Some(*l))),+ )+ })+ .collect();+ v.push(MenuNode::Separator);+ v.push(item("photo.label", json!({"label": "none"}), "None", None, has, Some(active.as_ref().is_some_and(|p| p.label.is_none()))));+ v+ }+ "Sort" => {+ use lightcraft_catalog::SortKey::*;+ let cur = app.session.sort;+ let mut v: Vec<MenuNode> = [+ ("Capture Date", CaptureDate, "captureDate"),+ ("Import Date", ImportDate, "importDate"),+ ("Modified Date", EditDate, "editDate"),+ ("File Name", FileName, "fileName"),+ ("Rating", Rating, "rating"),+ ("File Size", FileSize, "fileSize"),+ ]+ .into_iter()+ .map(|(label, key, k)| item("library.sort", json!({"key": k}), label, None, true, Some(cur.key == key)))+ .collect();+ v.push(MenuNode::Separator);+ v.push(item("library.sort", json!({"ascending": true}), "Ascending", None, true, Some(cur.ascending)));+ v.push(item("library.sort", json!({"ascending": false}), "Descending", None, true, Some(!cur.ascending)));+ v+ }+ "Add to Album" => {+ let sel = !app.session.selection.ids.is_empty() || has;+ let mut albums: Vec<_> = app.session.catalog.albums().filter(|a| !a.folder && !a.is_smart()).map(|a| (a.name.clone(), a.id.0)).collect();+ albums.sort_by_key(|(n, _)| n.to_lowercase());+ let mut v: Vec<MenuNode> =+ albums.into_iter().map(|(name, id)| item("album.addPhotos", json!({"id": id}), name, None, sel, None)).collect();+ if !v.is_empty() {+ v.push(MenuNode::Separator);+ }+ v.push(item("dialog.newAlbum", Value::Null, "New Album…", None, true, None));+ v+ }+ _ => return None,+ })+}++fn node(app: &LightcraftApp, e: &MenuEntry) -> MenuNode {+ item(&e.id, Value::Null, live_label(app, &e.id, &e.label), e.shortcut.as_deref(), e.enabled, checked(app, &e.id))+}++/// Drop leading, trailing and doubled separators (also inside submenus) and empty submenus.+fn tidy(v: Vec<MenuNode>) -> Vec<MenuNode> {+ let mut out: Vec<MenuNode> = Vec::with_capacity(v.len());+ for n in v {+ let n = match n {+ MenuNode::Submenu { label, children } => {+ let children = tidy(children);+ if children.is_empty() {+ continue;+ }+ MenuNode::Submenu { label, children }+ }+ n => n,+ };+ if n == MenuNode::Separator && out.last().is_none_or(|l| *l == MenuNode::Separator) {+ continue;+ }+ out.push(n);+ }+ while out.last() == Some(&MenuNode::Separator) {+ out.pop();+ }+ out+}++/// The whole menu bar: (title, items) per menu in [`MENUS`] order.+pub fn menu_bar(app: &LightcraftApp) -> Vec<(String, Vec<MenuNode>)> {+ let entries: Vec<MenuEntry> = crate::menus::menu_entries(app).into_iter().filter(|e| !HIDDEN.contains(&e.id.as_str())).collect();+ let mut used = vec![false; entries.len()];+ let mut bar = Vec::new();+ for title in MENUS {+ let layout = LAYOUT.iter().find(|(t, _)| t == title).map(|(_, l)| *l).unwrap_or(&[]);+ let mut items = Vec::new();+ let sub = |name: &str, used: &mut [bool]| -> Vec<MenuNode> {+ let mut children = expanded(app, name).unwrap_or_default();+ let mut dialogs = Vec::new();+ for (i, e) in entries.iter().enumerate() {+ if !used[i] && e.menu.len() == 2 && e.menu[0] == *title && e.menu[1] == name {+ used[i] = true;+ // commands that open a dialog go last, after a separator+ if e.label.ends_with('…') { dialogs.push(node(app, e)) } else { children.push(node(app, e)) }+ }+ }+ if !dialogs.is_empty() {+ children.push(MenuNode::Separator);+ children.extend(dialogs);+ }+ children+ };+ for slot in layout {+ if *slot == "---" {+ items.push(MenuNode::Separator);+ } else if let Some(name) = slot.strip_prefix('@') {+ let children = sub(name, &mut used);+ items.push(MenuNode::Submenu { label: name.to_string(), children });+ } else if let Some(i) = entries.iter().position(|e| e.id == *slot && e.menu.first().map(String::as_str) == Some(title)) {+ used[i] = true;+ items.push(node(app, &entries[i]));+ }+ }+ // everything else that names this menu+ items.push(MenuNode::Separator);+ let mut extra_subs: Vec<String> = Vec::new();+ for (i, e) in entries.iter().enumerate() {+ if used[i] || e.menu.first().map(String::as_str) != Some(title) {+ continue;+ }+ if e.menu.len() == 1 {+ used[i] = true;+ items.push(node(app, e));+ } else if !extra_subs.contains(&e.menu[1]) {+ extra_subs.push(e.menu[1].clone());+ }+ }+ for name in extra_subs {+ let children = sub(&name, &mut used);+ items.push(MenuNode::Submenu { label: name, children });+ }+ bar.push((title.to_string(), tidy(items)));+ }+ bar+}++/// Run a menu item. Rating, flag and label items behave like their keys (the active photo only in+/// Compare/Survey; Auto Advance moves on).+pub fn run_item(app: &mut LightcraftApp, id: &str, params: Value) -> Result<Value, String> {+ let mut params = if params.is_null() { json!({}) } else { params };+ let culling_cmd = matches!(id, "photo.rate" | "photo.flag" | "photo.label" | "photo.pick" | "photo.reject" | "photo.unflag");+ if culling_cmd {+ crate::panels::compare::target_active(app, &mut params);+ }+ let r = app.run(id, params);+ if culling_cmd && r.is_ok() && app.ui.auto_advance {+ crate::panels::compare::advance(app);+ }+ r+}++/// Human-readable shortcut text for menus: `Cmd+Shift+Z` → `⌘⇧Z` on macOS, `Ctrl+Shift+Z` elsewhere.+pub fn shortcut_text(sc: &str, mac: bool) -> String {+ if mac {+ let mut mods = String::new();+ let mut key = "";+ for part in sc.split('+') {+ match part {+ "Ctrl" => mods.push('⌃'),+ "Alt" => mods.push('⌥'),+ "Shift" => mods.push('⇧'),+ "Cmd" => mods.push('⌘'),+ k => key = k,+ }+ }+ let key = match key {+ "Delete" => "⌫",+ "Escape" => "⎋",+ "Left" => "←",+ "Right" => "→",+ k => k,+ };+ format!("{mods}{key}")+ } else {+ sc.replace("Cmd", "Ctrl")+ }+}++/// Width of the in-window menu bar's titles.+pub fn bar_width(ui: &egui::Ui) -> f32 {+ let t = crate::theme::Tokens::get(ui.ctx());+ MENUS.iter().map(|m| ui.painter().layout_no_wrap(m.to_string(), t.font(13.0), t.text).size().x + 16.0).sum::<f32>()+ + ui.spacing().item_spacing.x * MENUS.len() as f32+}++/// The in-window menu bar (hosts without a native one): one dropdown per menu, or a single+/// "Menu" button when the space is too narrow. Returns the width used.+pub fn show_in_window(app: &mut LightcraftApp, ui: &mut egui::Ui, max_width: f32) -> f32 {+ let t = crate::theme::Tokens::get(ui.ctx());+ let bar = menu_bar(app);+ let font = t.font(13.0);+ let widths: Vec<f32> = bar.iter().map(|(title, _)| ui.painter().layout_no_wrap(title.clone(), font.clone(), t.text).size().x + 16.0).collect();+ let total: f32 = widths.iter().sum();+ let mut clicked: Option<(String, Value)> = None;+ let start = ui.cursor().left();+ let mac = ui.ctx().os() == egui::os::OperatingSystem::Mac;+ if total <= max_width {+ for (title, items) in &bar {+ let r = ui.add(egui::Button::new(egui::RichText::new(title).font(font.clone()).color(t.text_label)).frame(false));+ crate::widgets::register(ui.ctx(), format!("menu:{title}"), r.rect);+ egui::Popup::menu(&r).show(|ui| nodes_ui(ui, items, mac, &mut clicked));+ }+ } else {+ let r = ui.add(egui::Button::new(egui::RichText::new("Menu").font(font.clone()).color(t.text_label)).frame(false));+ crate::widgets::register(ui.ctx(), "menu:all", r.rect);+ egui::Popup::menu(&r).show(|ui| {+ for (title, items) in &bar {+ ui.menu_button(title, |ui| nodes_ui(ui, items, mac, &mut clicked));+ }+ });+ }+ if let Some((id, params)) = clicked {+ let _ = run_item(app, &id, params);+ }+ ui.cursor().left() - start+}++fn nodes_ui(ui: &mut egui::Ui, nodes: &[MenuNode], mac: bool, clicked: &mut Option<(String, Value)>) {+ ui.set_min_width(220.0);+ for n in nodes {+ match n {+ MenuNode::Separator => {+ ui.separator();+ }+ MenuNode::Submenu { label, children } => {+ ui.menu_button(format!(" {label}"), |ui| nodes_ui(ui, children, mac, clicked));+ }+ MenuNode::Item { id, params, label, shortcut, enabled, checked } => {+ // a gutter for check marks, like native menus+ let mut b = egui::Button::new(format!(" {label}"));+ if let Some(sc) = shortcut {+ b = b.shortcut_text(shortcut_text(sc, mac));+ }+ let r = ui.add_enabled(*enabled, b);+ if *checked == Some(true) {+ let t = crate::theme::Tokens::get(ui.ctx());+ let c = egui::Rect::from_center_size(egui::pos2(r.rect.left() + 11.0, r.rect.center().y), egui::vec2(13.0, 13.0));+ crate::icons::paint(ui.painter(), c, crate::icons::Icon::Check, if *enabled { t.text } else { t.text_disabled });+ }+ if r.clicked() {+ *clicked = Some((id.clone(), params.clone()));+ ui.close();+ }+ }+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn app() -> LightcraftApp {+ LightcraftApp::new(lightcraft_engine::Session::with_demo(), Default::default())+ }++ fn find<'a>(nodes: &'a [MenuNode], id: &str) -> Option<&'a MenuNode> {+ nodes.iter().find_map(|n| match n {+ MenuNode::Item { id: i, .. } if i == id => Some(n),+ MenuNode::Submenu { children, .. } => find(children, id),+ _ => None,+ })+ }++ #[test]+ fn bar_follows_the_registry_and_state() {+ let mut app = app();+ let bar = menu_bar(&app);+ let titles: Vec<&str> = bar.iter().map(|(t, _)| t.as_str()).collect();+ assert_eq!(titles, MENUS);+ let all: Vec<MenuNode> = bar.iter().flat_map(|(_, v)| v.clone()).collect();+ // every engine command with a menu path is reachable (parameterized ones via submenus)+ for c in lightcraft_engine::command_specs().iter().filter(|c| !c.menu.is_empty() && !HIDDEN.contains(&c.id)) {+ assert!(find(&all, c.id).is_some(), "{} missing from the menu bar", c.id);+ }+ for id in ["photo.rate", "photo.flag", "photo.label", "library.sort", "album.addPhotos", "view.compare", "stack.group", "photo.virtualCopy"] {+ assert!(find(&all, id).is_some(), "{id}");+ }+ // no doubled or dangling separators+ fn check(v: &[MenuNode]) {+ assert_ne!(v.first(), Some(&MenuNode::Separator));+ assert_ne!(v.last(), Some(&MenuNode::Separator));+ for w in v.windows(2) {+ assert!(!(w[0] == MenuNode::Separator && w[1] == MenuNode::Separator));+ }+ for n in v {+ if let MenuNode::Submenu { children, .. } = n {+ check(children);+ }+ }+ }+ bar.iter().for_each(|(_, v)| check(v));+ // live state: undo label, enabled, checked+ let Some(MenuNode::Item { enabled, .. }) = find(&all, "edit.undo") else { panic!() };+ assert!(!enabled);+ run_item(&mut app, "photo.rate", json!({"rating": 3})).unwrap();+ let bar = menu_bar(&app);+ let all: Vec<MenuNode> = bar.iter().flat_map(|(_, v)| v.clone()).collect();+ let Some(MenuNode::Item { label, enabled, .. }) = find(&all, "edit.undo") else { panic!() };+ assert_eq!((label.as_str(), *enabled), ("Undo Set Rating", true));+ let rated: Vec<_> = all+ .iter()+ .filter_map(|n| match n {+ MenuNode::Submenu { label, children } if label == "Set Rating" => Some(children.clone()),+ _ => None,+ })+ .flatten()+ .filter(|n| matches!(n, MenuNode::Item { checked: Some(true), .. }))+ .collect();+ assert!(matches!(&rated[..], [MenuNode::Item { params, .. }] if params["rating"] == 3));+ let Some(MenuNode::Item { checked, .. }) = find(&all, "view.filmstrip") else { panic!() };+ assert_eq!(*checked, Some(app.ui.filmstrip));+ }++ #[test]+ fn shortcut_text_per_platform() {+ assert_eq!(shortcut_text("Cmd+Shift+Z", true), "⌘⇧Z");+ assert_eq!(shortcut_text("Cmd+Shift+Z", false), "Ctrl+Shift+Z");+ assert_eq!(shortcut_text("Delete", true), "⌫");+ }+}diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rsindex 35785e703..a43c98858 100644--- a/crates/ui-egui/src/menus.rs+++ b/crates/ui-egui/src/menus.rs@@ -33,39 +33,40 @@ pub const UI_COMMANDS: &[UiCommand] = &[("view.histogram", "Histogram", Some("Cmd+Shift+H"), "View"),("view.maskOverlay", "Show Mask Overlay", Some("O"), "View"),("view.cropOverlay", "Cycle Crop Overlay", Some("Shift+O"), "View"),- ("view.back", "Back to Grid", Some("Escape"), "View"),+ ("view.back", "Back to Grid", Some("Escape"), ""),("view.filterBar", "Filter", None, "View"),- ("panel.edit", "Edit", Some("E"), "View"),- ("panel.crop", "Crop & Rotate", Some("C"), "View"),- ("panel.remove", "Remove", Some("H"), "View"),- ("panel.masking", "Masking", Some("M"), "View"),- ("panel.redeye", "Red Eye", None, "View"),- ("panel.presets", "Presets", Some("Shift+P"), "View"),- ("panel.info", "Info", Some("I"), "View"),- ("panel.keywords", "Keywords", Some("K"), "View"),- ("panel.versions", "Versions", Some("Shift+V"), "View"),- ("panel.activity", "History", Some("Shift+Y"), "View"),- ("panel.close", "Close Panel", None, "View"),- ("section.light", "Light", Some("Cmd+Alt+1"), "View"),- ("section.color", "Color", Some("Cmd+Alt+2"), "View"),- ("section.effects", "Effects", Some("Cmd+Alt+3"), "View"),- ("section.detail", "Detail", Some("Cmd+Alt+4"), "View"),- ("section.optics", "Optics", Some("Cmd+Alt+5"), "View"),- ("tool.brush", "Brush", Some("B"), "View"),- ("tool.linear", "Linear Gradient", Some("L"), "View"),- ("tool.radial", "Radial Gradient", Some("R"), "View"),- ("tool.wbPicker", "White Balance Selector", Some("W"), "View"),- ("tool.none", "No Tool", None, "View"),+ ("panel.edit", "Edit", Some("E"), "Window"),+ ("panel.crop", "Crop & Rotate", Some("C"), "Window"),+ ("panel.remove", "Remove", Some("H"), "Window"),+ ("panel.masking", "Masking", Some("M"), "Window"),+ ("panel.redeye", "Red Eye", None, "Window"),+ ("panel.presets", "Presets", Some("Shift+P"), "Window"),+ ("panel.info", "Info", Some("I"), "Window"),+ ("panel.keywords", "Keywords", Some("K"), "Window"),+ ("panel.versions", "Versions", Some("Shift+V"), "Window"),+ ("panel.activity", "History", None, "Window"),+ ("panel.close", "Close Panel", None, ""),+ ("section.light", "Light", Some("Cmd+Alt+1"), "Window>Edit Sections"),+ ("section.color", "Color", Some("Cmd+Alt+2"), "Window>Edit Sections"),+ ("section.effects", "Effects", Some("Cmd+Alt+3"), "Window>Edit Sections"),+ ("section.detail", "Detail", Some("Cmd+Alt+4"), "Window>Edit Sections"),+ ("section.optics", "Optics", Some("Cmd+Alt+5"), "Window>Edit Sections"),+ ("tool.brush", "Brush", Some("B"), "Window>Tools"),+ ("tool.linear", "Linear Gradient", Some("L"), "Window>Tools"),+ ("tool.radial", "Radial Gradient", Some("R"), "Window>Tools"),+ ("tool.wbPicker", "White Balance Selector", Some("W"), "Window>Tools"),+ ("tool.none", "No Tool", None, ""),("dialog.newAlbum", "New Album…", Some("Cmd+N"), "File"),+ ("dialog.newFolder", "New Folder…", None, "File"),("dialog.newSmartAlbum", "New Smart Album from Filter…", Some("Cmd+Alt+N"), "File"),("dialog.createPreset", "Create Preset…", Some("Cmd+Shift+P"), "Photo"),("dialog.autoStack", "Auto-Stack by Capture Time…", None, "Photo>Stack"),- ("dialog.copySettings", "Choose Edit Settings to Copy…", Some("Cmd+Shift+C"), "Photo"),+ ("dialog.copySettings", "Choose Edit Settings to Copy…", Some("Cmd+Shift+C"), "Edit"),("dialog.export", "Export…", Some("Cmd+Shift+E"), "File"),("file.addPhotos", "Add Photos…", Some("Cmd+Shift+I"), "File"),("file.importPresets", "Import Presets…", None, "File"),("file.exportPresets", "Export Presets…", None, "File"),- ("app.about", "About LightCraft", None, "LightCraft"),+ ("app.about", "About LightCraft", None, "Help"),("app.shortcuts", "Keyboard Shortcuts", Some("Cmd+/"), "Help"),("app.export", "Export Now", None, ""),];@@ -295,6 +296,10 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Reapp.ui.dialog = Some(Dialog::NewSmartAlbum { name: p.get("name").and_then(Value::as_str).unwrap_or("").into() });Ok(Value::Null)}+ "dialog.newFolder" => {+ app.ui.dialog = Some(Dialog::NewAlbum { name: p.get("name").and_then(Value::as_str).unwrap_or("").into(), folder: true });+ Ok(Value::Null)+ }"dialog.createPreset" => {app.ui.dialog = Some(Dialog::CreatePreset { name: String::new(), group: "User Presets".into() });Ok(Value::Null)diff --git a/crates/ui-egui/src/panels/topbar.rs b/crates/ui-egui/src/panels/topbar.rsindex 7429a05d5..979f91282 100644--- a/crates/ui-egui/src/panels/topbar.rs+++ b/crates/ui-egui/src/panels/topbar.rs@@ -16,6 +16,13 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {.frame(egui::Frame::NONE.fill(t.chrome).inner_margin(egui::Margin { left, right: 12, top: 0, bottom: 0 })).show(ui, |ui| {let full = ui.max_rect();+ let mut sw = 640.0f32.min(full.width() - 460.0).max(200.0);+ if !app.native_menu {+ // leave room for the in-window menus left of the (centred) search field+ let menus_right = full.left() + 140.0 + crate::menubar::bar_width(ui) + 24.0;+ sw = sw.min(2.0 * (full.center().x - menus_right)).max(200.0);+ }+ let search_left = full.center().x - sw / 2.0;ui.horizontal_centered(|ui| {ui.spacing_mut().item_spacing.x = 4.0;if icon_button(ui, "sidebar", Icon::Sidebar, vec2(30.0, 30.0), app.ui.left_panel, true, "Show/hide My Photos panel").clicked() {@@ -26,9 +33,14 @@ pub fn show(app: &mut LightcraftApp, ui: &mut egui::Ui) {let _ = app.run("view.back", json!({}));}icon_button(ui, "forward", Icon::Forward, vec2(30.0, 30.0), false, false, "Forward");+ if !app.native_menu {+ // no native menu bar (web, Windows, Linux): menus in the top bar+ ui.add_space(10.0);+ let room = search_left - ui.cursor().left() - 16.0;+ crate::menubar::show_in_window(app, ui, room);+ }});// search field (centred on the window)- let sw = 640.0f32.min(full.width() - 460.0).max(200.0);let sr = Rect::from_center_size(pos2(full.center().x, full.center().y), vec2(sw, 28.0));let id = egui::Id::new("search-field");let focused = ui.memory(|m| m.has_focus(id));diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rsindex a3487c3b3..cce9defde 100644--- a/crates/ui-egui/src/shortcuts.rs+++ b/crates/ui-egui/src/shortcuts.rs@@ -51,16 +51,18 @@ pub fn handle(app: &mut LightcraftApp, ctx: &egui::Context) {return;}let mut fire: Vec<String> = Vec::new();+ // shortcuts the native menu bar handles (it consumes those key presses itself)+ let native = |sc: &str| app.native_shortcuts.contains(sc);ctx.input(|i| {for (id, _, sc, _) in crate::menus::UI_COMMANDS {- if let Some((m, k)) = sc.and_then(parse)+ if let Some((m, k)) = sc.filter(|s| !native(s)).and_then(parse)&& matches(i, m, k){fire.push(id.to_string());}}for c in lightcraft_engine::command_specs() {- if let Some((m, k)) = c.shortcut.and_then(parse)+ if let Some((m, k)) = c.shortcut.filter(|s| !native(s)).and_then(parse)&& matches(i, m, k){fire.push(c.id.to_string());@@ -68,15 +70,15 @@ pub fn handle(app: &mut LightcraftApp, ctx: &egui::Context) {}// rating 0-5, colour labels 6-9 (with Shift: and advance)for (n, key) in [Key::Num0, Key::Num1, Key::Num2, Key::Num3, Key::Num4, Key::Num5].iter().enumerate() {- if matches(i, Modifiers::NONE, *key) {+ if matches(i, Modifiers::NONE, *key) && !native(&n.to_string()) {fire.push(format!("rate:{n}:0"));}if matches(i, Modifiers::SHIFT, *key) {fire.push(format!("rate:{n}:1"));}}- for (label, key) in [("red", Key::Num6), ("yellow", Key::Num7), ("green", Key::Num8), ("blue", Key::Num9)] {- if matches(i, Modifiers::NONE, key) {+ for (label, key, sc) in [("red", Key::Num6, "6"), ("yellow", Key::Num7, "7"), ("green", Key::Num8, "8"), ("blue", Key::Num9, "9")] {+ if matches(i, Modifiers::NONE, key) && !native(sc) {fire.push(format!("label:{label}"));}}diff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex c3cb81035..71d5ee05c 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -19,7 +19,8 @@ mode ([mcp.md](mcp.md)) is a thin layer over this channel. Implementation:|---|---|---|| `engine.execute` (alias `ui.menu.invoke`) | `{command, params?}` | Run any engine or UI command (see `engine.commands`) || `engine.commands` | — | Engine + UI commands: id, label, menu, shortcut, params doc, enabled |-| `ui.menu.list` | — | Menu entries |+| `ui.menu.list` | — | Menu entries (flat: id, label, menu path, shortcut, enabled) |+| `ui.menu.tree` | — | The menu bar as shown (File … Help): items `{id, params?, label, shortcut?, enabled, checked?}`, separators, submenus — the model behind the native macOS menu bar and the in-window menus || `ui.inspect` | — | UI state, window, canvas/image rects, active photo, selection, perf, status || `ui.widgets` | `{filter?}` | On-screen widgets `{id, rect: [x, y, w, h]}` (screen points) || `ui.clickWidget` / `ui.dragWidget` | `{id, count?, fx?, fy?}` / `{id, toX?, toY?, dx?, dy?, steps?}` | Real egui input on a widget |