EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Merge upstream/main into feat-gap25-a11y-audit
vangel76107d595c1c18
diff --cc crates/ui-egui/src/menus/invoke.rsindex 000000000,b266623f3..1a78bae57mode 000000,100644..100644--- a/crates/ui-egui/src/menus/invoke.rs+++ b/crates/ui-egui/src/menus/invoke.rs@@@ -1,0 -1,692 +1,695 @@@+ use super::frontend::{file_dialog, frontend, run_engine};+ use super::shortcuts::system_paste_id;+ use super::*;++ pub fn panel_command_id(p: PanelKind) -> String {+ format!("window.panel.{}", p.id())+ }++ /// The reveal shortcuts (P, S, R, T, A, E, M, F, L…). `add` (Shift+key) adds the property to+ /// (or removes it from) those already revealed instead of replacing them.+ pub fn reveal(app: &mut EffectcraftApp, kind: &str, now: f64, add: bool) {+ // The double-press shortcuts: the same key again within 0.6 s reveals its second set (LL+ // Waveform, TT Mask Opacity, MM all mask properties, EE Expressions, RR Time Remap, AA+ // Material Options, PP paint / Roto Brush / Puppet, SS selected properties, FF missing+ // effects). A single M shows Mask Path.+ let double = |k: &str| -> Option<&'static str> {+ Some(match k {+ "levels" => "waveform",+ "opacity" => "maskOpacity",+ "masks" => "masks",+ "effects" => "expressions",+ "rotation" => "timeRemap",+ "anchor" => "material",+ "position" => "paint",+ "scale" => "selected",+ "feather" => "missingEffects",+ _ => return None,+ })+ };+ let pressed = kind;+ // (With Shift a second press removes the property again instead.)+ let again = !add && matches!(app.last_reveal.take(), Some((k, t)) if k == pressed && now - t < 0.6);+ app.last_reveal = Some((if again { String::new() } else { pressed.to_string() }, now));+ let kind = match (again, double(pressed)) {+ (true, Some(d)) => {+ // The second press replaces what the first one revealed.+ let first = if pressed == "masks" { "maskPath" } else { pressed };+ app.ui.timeline.reveal.retain(|k| k != first);+ d+ }+ _ if pressed == "masks" => "maskPath",+ _ => pressed,+ };+ let targets = reveal_targets(app);+ let tl = &mut app.ui.timeline;+ let present = tl.reveal.iter().any(|k| k == kind);+ let mut kinds = tl.reveal.clone();+ if add {+ if present {+ kinds.retain(|k| k != kind);+ } else {+ kinds.retain(|k| k != "props" || !tl.reveal_props.is_empty());+ kinds.push(kind.to_string());+ }+ } else if present && kinds.len() == 1 {+ kinds.clear();+ } else {+ kinds = vec![kind.to_string()];+ }+ tl.apply_reveal(&targets, kinds.clone());+ crate::panels::timeline::open_revealed(app, &targets, &kinds);+ }++ /// Show Time Remap on the layers of a `layer.enableTimeRemap` (`layers` by id, else the+ /// selected ones) that have it now.+ fn reveal_time_remap(app: &mut EffectcraftApp, params: &Value) {+ let asked: Vec<u64> = match params.get("layers").and_then(Value::as_array) {+ Some(a) => a.iter().filter_map(Value::as_u64).collect(),+ None => app.session.state.selected_layers.iter().map(|l| l.0).collect(),+ };+ let Some(comp) = app.session.active_comp() else { return };+ let layers: Vec<u64> = comp.layers.iter().filter(|l| asked.contains(&l.id.0) && l.props.get("timeRemap").is_some()).map(|l| l.id.0).collect();+ if !layers.is_empty() {+ app.ui.timeline.apply_reveal(&layers, vec!["timeRemap".into()]);+ }+ }++ /// After Alt+Shift+P (A, S, R, T) the Timeline shows the property on each layer it keyed, as in+ /// After Effects: added to what a reveal shortcut shows, else with the layer's Transform twirled+ /// open, else alone like P.+ fn reveal_keyed(app: &mut EffectcraftApp, keyed: &Value, kind: &str) {+ let layers: std::collections::BTreeSet<u64> = keyed.as_array().into_iter().flatten().filter_map(|k| k.get("layer").and_then(Value::as_u64)).collect();+ let Some(comp) = app.session.active_comp() else { return };+ let tl = &mut app.ui.timeline;+ for id in layers {+ let shown = tl.layer_reveal.get(&id).filter(|k| !k.is_empty()).cloned();+ match shown {+ Some(mut kinds) => {+ if !kinds.iter().any(|k| k == kind) {+ kinds.push(kind.to_string());+ tl.layer_reveal.insert(id, kinds);+ }+ }+ None if tl.open_layers.contains(&id) => {+ if let Some(tr) = comp.layer(effectcraft_engine::project::LayerId(id)).and_then(|l| l.transform()) {+ tl.open_groups.insert(tr.uid);+ }+ }+ None => {+ tl.open_layers.insert(id);+ tl.layer_reveal.insert(id, vec![kind.to_string()]);+ }+ }+ }+ }++ /// The layers a reveal shortcut acts on: the selected ones, else every layer of the active comp.+ fn reveal_targets(app: &EffectcraftApp) -> Vec<u64> {+ if app.session.state.selected_layers.is_empty() {+ app.session.active_comp().map(|c| c.layers.iter().map(|l| l.id.0).collect()).unwrap_or_default()+ } else {+ app.session.state.selected_layers.iter().map(|l| l.0).collect()+ }+ }++ /// The arrow keys nudge the selected layers 1 pixel at the viewer's magnification (`up`,+ /// `down`, `left`, `right`), 10 with Shift (`up10`…), as After Effects does, so zoomed in-/// they move by fractions of a comp pixel. From any panel except Project (which owns the++/// they move by fractions of a comp pixel. From any panel except Project, Effects & Presets and Render Queue (which own the+ /// arrow keys for its own keyboard navigation, #961); not while typing, with a dialog or+ /// menu open. With mask points selected the arrows move the points instead (#1288).+ fn nudge(app: &mut EffectcraftApp, ctx: &egui::Context, dir: &str) -> Result<Value, String> {+ let (side, n) = match dir.strip_suffix("10") {+ Some(side) => (side, 10.0),+ None => (dir, 1.0),+ };+ let (x, y) = match side {+ "up" => (0.0, -n),+ "down" => (0.0, n),+ "left" => (-n, 0.0),+ "right" => (n, 0.0),+ _ => return Err(format!("unknown nudge `{dir}`")),+ };+ let st = &app.session.state;- if app.ui.focused == PanelKind::Project || (st.selected_layers.is_empty() && st.selected_vertices.is_empty()) || st.text_edit.is_some() {++ if matches!(app.ui.focused, PanelKind::Project | PanelKind::EffectsPresets | PanelKind::RenderQueue)++ || (st.selected_layers.is_empty() && st.selected_vertices.is_empty())++ || st.text_edit.is_some()++ {+ return Ok(Value::Null);+ }+ // Screen pixels per comp pixel.+ let zoom = (app.ui.viewer.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx)) * ctx.pixels_per_point()) as f64;+ let k = if zoom.is_finite() && zoom > 1e-6 { 1.0 / zoom } else { 1.0 };+ if let Some(layer) = st.selected_vertices.first().map(|v| v.layer) {+ let d = vertex_delta(app, layer, [x * k, y * k]);+ return run_engine(app, ctx, "mask.moveVertices", json!({"delta": d}));+ }+ run_engine(app, ctx, "layer.nudge", json!({"x": x * k, "y": y * k}))+ }++ /// A comp-space step `d` in the layer space of `layer`, where mask points live. Like a drag of+ /// the points in the viewer, every selected point takes the first one's layer space.+ fn vertex_delta(app: &EffectcraftApp, layer: effectcraft_engine::project::LayerId, d: [f64; 2]) -> [f64; 2] {+ use effectcraft_engine::geom::vec2;+ let s = &app.session;+ let (Some(cid), Some(comp)) = (s.active_comp_id(), s.active_comp()) else { return d };+ let Some(l) = comp.layer(layer) else { return d };+ let ectx = effectcraft_engine::render::EvalCtx { project: &s.project, comp_id: cid, comp, time: s.time(), expr: s.expr.as_deref(), footage: None };+ let (l2c, _) = crate::panels::viewer::l2c(&ectx, l);+ l2c.inverse().map_or(d, |inv| {+ let v = inv.apply_vec(vec2(d[0], d[1]));+ [v.x, v.y]+ })+ }++ fn no_params(p: &Value) -> bool {+ p.as_object().is_none_or(|m| m.is_empty())+ }++ /// `{"comp": id}` and nothing else: Composition Settings opens on that comp instead of+ /// applying no settings to it.+ fn only_comp(p: &Value) -> Option<effectcraft_engine::project::ItemId> {+ let m = p.as_object().filter(|m| m.len() == 1)?;+ m.get("comp")?.as_u64().map(effectcraft_engine::project::ItemId)+ }++ /// Execute a UI or engine command by id.+ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result<Value, String> {+ if matches!(id, "effects.copyPresetsFolderPath" | "mediaBrowser.copySourcePath") {+ return frontend(app, ctx, id, params);+ }+ // Layer ▸ New ▸ Text (menu, shortcut, context menus) puts an insertion point in the centre of+ // the comp, as After Effects does, so typing goes into Source Text rather than running+ // shortcuts (#866). `engine.execute` keeps the headless default.+ if id == "layer.newText" && no_params(¶ms) {+ return run_engine(app, ctx, id, json!({"text": "", "edit": true}));+ }+ // A new folder (File ▸ New, its shortcut, the Project panel's button and context menu) opens+ // with its name ready to type, as in After Effects (#1658). The command selects it.+ // `engine.execute` keeps the headless default.+ if id == "project.newFolder" && no_params(¶ms) {+ let r = run_engine(app, ctx, id, params);+ if r.is_ok() {+ app.show_panel(PanelKind::Project);+ crate::panels::project::begin_rename(app, ctx);+ }+ return r;+ }+ // The Project-panel focus redirects apply only while no text edit is open: creating a text+ // layer leaves focus on Project while the insertion point lives in the comp, so during an+ // edit these commands address the text context — redirected, Deselect All would clear a+ // project selection the user is not looking at and silently swallow the edit's own end.+ if no_params(¶ms) && app.ui.focused == PanelKind::Project && app.session.state.text_edit.is_none() {+ match id {+ "edit.duplicate" => return run_engine(app, ctx, "project.duplicate", json!({})),+ "edit.selectAll" => {+ let items: Vec<u64> = crate::panels::project::visible_rows(app)+ .into_iter()+ .filter(|(id, _)| app.ui.project_search.is_empty() || app.session.project.item(*id).is_some_and(|it| !it.is_folder()))+ .map(|(id, _)| id.0)+ .collect();+ return run_engine(app, ctx, "project.select", json!({"items":items}));+ }+ "edit.deselectAll" => return run_engine(app, ctx, "project.select", json!({"items":[]})),+ "edit.cut" | "edit.copy" | "edit.paste" | "edit.copyWithPropertyLinks" | "edit.copyWithRelativePropertyLinks" | "edit.copyExpressionOnly" => {+ return Err("Project clipboard actions are not supported yet".into());+ }+ _ => {}+ }+ }+ // Edit ▸ Paste with SVG markup on the system clipboard pastes it as a shape layer (After+ // Effects 26.3). Copying in the app replaces the system clipboard with a note naming what+ // was copied, so SVG there was copied after anything copied in the app.+ if id == "edit.paste" && no_params(¶ms) && app.session.state.text_edit.is_none() {+ let text = ctx.data_mut(|d| d.remove_temp::<String>(system_paste_id())).or_else(|| app.hooks.clipboard_text.as_ref().and_then(|f| f()));+ if let Some(svg) = text.filter(|t| effectcraft_engine::vector::is_svg_text(t)) {+ return run_engine(app, ctx, "edit.pasteSvg", json!({"svg": svg}));+ }+ }+ // Clear follows panel focus, including the Edit menu and keyboard shortcut.+ if id == "edit.clear" && params.as_object().is_some_and(|p| p.is_empty()) && app.ui.focused == PanelKind::Project {+ // Through `invoke`, so deleting items that compositions use still asks first (M3.16).+ return invoke(app, ctx, "project.delete", json!({}));+ }+ if id == "edit.clear" && params.as_object().is_some_and(|p| p.is_empty()) && app.ui.focused == PanelKind::RenderQueue {+ let selected = ctx.data(|d| d.get_temp::<(Vec<u64>, Option<u64>)>(egui::Id::unique("rq-ui"))).and_then(|(_, id)| id);+ return match selected {+ Some(item) => run_engine(app, ctx, "renderQueue.remove", json!({"item": item})),+ None => Err("select a Render Queue item first".into()),+ };+ }+ // Shift+Delete deletes the Project panel's selection without asking; it does nothing in the+ // other panels.+ if id == "project.deleteWithoutConfirmation" {+ if app.ui.focused != PanelKind::Project {+ return Ok(Value::Null);+ }+ return crate::panels::delete_items::delete_confirmed(app, ctx, json!({}));+ }+ let now = app.now();+ // Closing a modified project asks to save it first; the command runs once answered.+ if crate::panels::unsaved::guard(app, id, ¶ms) {+ return Ok(json!({"dialog": "unsavedChanges"}));+ }+ // Deleting Project items that compositions use asks first, as in After Effects.+ if crate::panels::delete_items::guard(app, id, ¶ms) {+ return Ok(json!({"dialog": "deleteItems"}));+ }+ // J / K and Select All Keyframes act on what the Timeline shows (its revealed properties).+ if matches!(id, "time.nextKey" | "time.previousKey" | "keys.selectAll")+ && ["visible", "layers", "layer", "prop"].iter().all(|k| params.get(*k).is_none())+ && let Some(c) = app.session.active_comp_arc()+ {+ let mut p = if params.is_object() { params.clone() } else { json!({}) };+ p["visible"] = json!(crate::panels::timeline::visible_props(app, &c));+ return run_engine(app, ctx, id, p);+ }+ // New Camera/Light and Camera/Light Settings without parameters open their dialogs.+ if crate::panels::dialogs_3d::route(app, id, ¶ms)? {+ return Ok(Value::Null);+ }+ // New 3D Primitive without parameters opens its dialog.+ if crate::panels::primitive_dialog::route(app, id, ¶ms)? {+ return Ok(Value::Null);+ }+ // Layer Settings on a solid, adjustment layer or null opens its settings dialog.+ if crate::panels::dialogs::route_layer_settings(app, id, ¶ms)? {+ return Ok(Value::Null);+ }+ // Layer ▸ Layer Styles ▸ <style> from the menu adds the style and opens the dialog on it.+ if crate::panels::layer_styles_dialog::route(app, id, ¶ms)? {+ return Ok(Value::Null);+ }+ // Shared docking: `window.dockAction`, craft-ui's `window.panel.*` commands, `ui.dock`,+ // `ui.dock.reset` and `window.panelWindow`.+ if let Some(result) = crate::dock_ui::route(app, ctx, id, ¶ms) {+ return result;+ }+ // Legacy per-panel / per-workspace ids (`window.panel.Project`, `window.workspace.default`).+ if let Some(rest) = id.strip_prefix("window.panel.") {+ return frontend(app, ctx, "window.panel", json!({"panel": rest}));+ }+ if let Some(ws) = id.strip_prefix("window.workspace.") {+ if ws == "reset" {+ return frontend(app, ctx, "window.resetWorkspace", json!({}));+ }+ return frontend(app, ctx, "window.workspace", json!({"name": ws}));+ }+ if let Some(t) = id.strip_prefix("tool.") {+ // C cycles through the camera tools.+ if t == "camera" {+ let tools = [Tool::Orbit, Tool::PanCamera, Tool::Dolly];+ let next = match tools.iter().position(|x| *x == app.ui.tool) {+ Some(i) => tools[(i + 1) % tools.len()],+ None => Tool::Orbit,+ };+ app.ui.tool = next;+ return Ok(json!({"tool": next}));+ }+ // Slot shortcuts cycle through the slot's tools.+ let slot = match t {+ "shape" => Some(8),+ "pen" => Some(9),+ "type" => Some(10),+ "brush" => Some(11),+ "rotoBrush" => Some(14),+ "puppet" => Some(15),+ _ => None,+ };+ if let Some(si) = slot {+ let tools: Vec<Tool> = match si {+ 11 => vec![Tool::Brush, Tool::Clone, Tool::Eraser],+ _ => crate::state::Tool::SLOTS[si].to_vec(),+ };+ let cur = tools.iter().position(|x| *x == app.ui.tool);+ let next = match cur {+ Some(i) => tools[(i + 1) % tools.len()],+ None => app.ui.slot_tools.get(si).copied().filter(|x| tools.contains(x)).unwrap_or(tools[0]),+ };+ app.ui.tool = next;+ if si < app.ui.slot_tools.len() && si != 11 {+ app.ui.slot_tools[si] = next;+ }+ return Ok(json!({"tool": next}));+ }+ let tool = Tool::from_name(t).ok_or_else(|| format!("unknown tool `{t}`"))?;+ app.ui.tool = tool;+ return Ok(json!({"tool": tool}));+ }+ if let Some(dir) = id.strip_prefix("viewer.nudge.") {+ return nudge(app, ctx, dir);+ }+ if let Some(k) = id.strip_prefix("timeline.reveal.") {+ if k == "animated" {+ return run_engine(app, ctx, "anim.reveal", json!({"kind": "keyframes"}));+ }+ reveal(app, k, now, false);+ return Ok(Value::Null);+ }+ if let Some(k) = id.strip_prefix("timeline.keyAt.") {+ let r = run_engine(app, ctx, "keys.toggleTransform", json!({"prop": k}))?;+ reveal_keyed(app, &r, k);+ return Ok(r);+ }+ if let Some(k) = id.strip_prefix("timeline.revealAdd.") {+ reveal(app, k, now, true);+ return Ok(json!({"revealed": app.ui.timeline.reveal}));+ }+ // U reveals keyframed properties; UU (pressed twice quickly) all modified properties; U+ // again later hides them.+ if id == "anim.reveal" && params.get("kind").and_then(Value::as_str) == Some("keyframes") {+ let last = app.last_reveal.take();+ app.last_reveal = Some(("keyframes".into(), now));+ match last {+ Some((k, t)) if k == "keyframes" && now - t < 0.6 => {+ return run_engine(app, ctx, "anim.reveal", json!({"kind": "modified"}));+ }+ Some((k, _)) if k == "keyframes" && app.ui.timeline.reveal == ["props"] => {+ let targets = reveal_targets(app);+ app.ui.timeline.apply_reveal(&targets, vec![]);+ return Ok(json!({"revealed": 0}));+ }+ _ => {}+ }+ }+ // A UI-only command (not in the engine's menus), so `frontend` gets it from here.+ if id == "window.maximizeApp" {+ return frontend(app, ctx, id, params);+ }+ // Docking: {panel, anchor, zone: center|left|right|top|bottom}, {panel, rect?}, {panel?}.+ if let Some(op) = id.strip_prefix("window.").filter(|o| matches!(*o, "maximizePanel" | "dockPanel" | "floatPanel" | "closePanel")) {+ let panel_of = |k: &str| params.get(k).and_then(Value::as_str).map(|s| PanelKind::from_name(s).ok_or(format!("unknown panel `{s}`")));+ match op {+ "maximizePanel" => {+ let p = match panel_of("panel") {+ Some(p) => p?,+ None => app.panel_at(ctx.pointer_hover_pos()),+ };+ app.toggle_maximize(p);+ return Ok(json!({"maximized": app.ui.maximized}));+ }+ "closePanel" => {+ let p = panel_of("panel").ok_or("closePanel: need `panel`")??;+ if app.ui.dock.is_open(p) {+ app.apply_dock(craft_ui::docking::Action::Close { panel: p })?;+ }+ return Ok(Value::Null);+ }+ "floatPanel" => {+ let p = panel_of("panel").ok_or("floatPanel: need `panel`")??;+ let r = match params.get("rect") {+ Some(value) => serde_json::from_value::<[f32; 4]>(value.clone()).map_err(|_| "rect must contain four finite numbers")?,+ None => crate::dock_ui::default_float_rect(ctx.content_rect()),+ };+ app.apply_dock(craft_ui::docking::Action::Float { panel: p, rect: r }).map_err(|e| format!("can't undock {}: {e}", p.title()))?;+ return Ok(Value::Null);+ }+ _ => {+ // craft-ui's `window.panel.dock`: zones center/tab, left/right/top/bottom (a split+ // beside the anchor), above/below; without an anchor a side zone docks along that+ // edge of the whole workspace.+ let p = panel_of("panel").ok_or("dockPanel: need `panel`")??;+ let mut command = json!({"command": "window.panel.dock", "panel": p});+ if let Some(anchor) = panel_of("anchor") {+ command["anchor"] = json!(anchor?);+ command["zone"] = json!("center");+ }+ if let Some(zone) = params.get("zone") {+ let zone = zone.as_str().ok_or("zone: center|tab|left|right|top|bottom|above|below")?.to_ascii_lowercase();+ if command.get("anchor").is_some() || zone != "center" {+ command["zone"] = json!(zone);+ }+ }+ if let Some(before) = panel_of("before") {+ command["before"] = json!(before?);+ }+ let command: craft_ui::docking::DockCommand<PanelKind> =+ serde_json::from_value(command).map_err(|e| format!("dockPanel: zone: center|tab|left|right|top|bottom|above|below ({e})"))?;+ app.run_dock_command(ctx, command).map_err(|e| format!("can't dock {}: {e}", p.title()))?;+ app.show_panel(p);+ return Ok(Value::Null);+ }+ }+ }+ if id == "markers.dialog" {+ // The Composition/Layer Marker dialog (double-click a marker): {layer?, index}.+ let index = params.get("index").and_then(Value::as_u64).ok_or("markers.dialog: need `index`")? as usize;+ let layer = params.get("layer").and_then(Value::as_u64);+ crate::panels::markers_ui::open_dialog(app, crate::panels::markers_ui::MarkerRef { layer, index })?;+ return Ok(json!({"dialog": id}));+ }++ if id == "view.theme.toggle" {+ app.cycle_appearance(ctx);+ return Ok(json!({"appearanceMode": app.session.prefs.appearance.appearance_mode}));+ }+ if let Some(th) = id.strip_prefix("view.theme.") {+ let k = crate::theme::ThemeKind::from_name(th).ok_or("unknown theme")?;+ app.set_theme(ctx, k);+ return Ok(Value::Null);+ }+ let timing = |app: &mut EffectcraftApp, op: &str| app.session.execute("layer.timing", json!({"op": op})).map_err(|e| e.to_string());+ match id {+ "playback.ramPreview" => {+ app.toggle_play_with(now, effectcraft_engine::preview::PreviewShortcut::Numpad0);+ return Ok(json!({"playing": app.playback.playing}));+ }+ "playback.preview.shiftSpacebar" | "playback.preview.shiftNumpad0" | "playback.preview.altNumpad0" => {+ let sc = effectcraft_engine::preview::PreviewShortcut::parse(id.trim_start_matches("playback.preview.")).ok_or("unknown preview shortcut")?;+ app.toggle_play_with(now, sc);+ return Ok(json!({"playing": app.playback.playing}));+ }+ "playback.stop" => {+ app.stop();+ return Ok(Value::Null);+ }+ // The focused Layer panel has its own magnification; otherwise the Composition viewer.+ "view.fit" if app.ui.focused == PanelKind::Layer => {+ app.ui.layer_zoom = None;+ app.ui.layer_pan = [0.0, 0.0];+ return Ok(Value::Null);+ }+ "view.fit" => {+ app.ui.viewer.zoom = None;+ app.ui.viewer.fit_up_to_100 = false;+ app.ui.viewer.pan = [0.0, 0.0];+ return Ok(Value::Null);+ }+ "timeline.scrollToTime" => app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Time),+ "timeline.scrollToLayer" => app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Layer),+ "timeline.parentColumn" => {+ let on = !crate::panels::timeline::column_visible(&app.ui.timeline, "parent");+ crate::panels::timeline::set_column(&mut app.ui.timeline, "parent", on)?;+ return Ok(json!({"parent": on}));+ }+ "view.fitUpTo100" => {+ app.ui.viewer.zoom = None;+ app.ui.viewer.fit_up_to_100 = true;+ app.ui.viewer.pan = [0.0, 0.0];+ return Ok(Value::Null);+ }+ // Shift+, / Shift+.: the previous / next open composition (the viewer's tabs).+ "view.nextItem" | "view.previousItem" => {+ let open = app.session.state.open_comps.clone();+ let Some(i) = app.session.state.active_comp.and_then(|c| open.iter().position(|o| *o == c)) else { return Ok(Value::Null) };+ let step = if id == "view.nextItem" { 1 } else { open.len().saturating_sub(1) };+ let Some(next) = open.get((i + step) % open.len().max(1)).copied().filter(|n| Some(*n) != app.session.state.active_comp) else {+ return Ok(Value::Null);+ };+ return run_engine(app, ctx, "comp.open", json!({"comp": next.0}));+ }+ // \\: between the Composition viewer and the Timeline.+ "window.toggleCompTimeline" => {+ let to = if app.ui.focused == PanelKind::Timeline { crate::panels::viewers::active_panel(app) } else { PanelKind::Timeline };+ app.show_panel(to);+ return Ok(json!({"focused": to.id()}));+ }+ // Alt+Shift+, / Alt+Shift+.: the previous / next tab of the focused panel's group.+ "window.nextPanel" | "window.previousPanel" => {+ let focused = app.ui.focused;+ let group = app.ui.dock.group_of(focused);+ let Some(i) = group.iter().position(|p| *p == focused) else { return Ok(Value::Null) };+ let step = if id == "window.nextPanel" { 1 } else { group.len().saturating_sub(1) };+ if let Some(next) = group.get((i + step) % group.len().max(1)).copied() {+ app.show_panel(next);+ }+ return Ok(json!({"focused": app.ui.focused.id()}));+ }+ // Ctrl+Shift+W: with a viewer or the Timeline active, every open composition closes;+ // any other panel closes itself.+ "window.closeAll" => {+ let focused = app.ui.focused;+ if matches!(focused, PanelKind::Composition | PanelKind::Timeline | PanelKind::Viewer(_)) {+ for c in app.session.state.open_comps.clone() {+ run_engine(app, ctx, "comp.close", json!({"comp": c.0}))?;+ }+ } else {+ app.close_panel(focused);+ }+ return Ok(Value::Null);+ }+ "view.actualSize" if app.ui.focused == PanelKind::Layer => {+ app.ui.layer_zoom = Some(1.0 / ctx.pixels_per_point());+ app.ui.layer_pan = [0.0, 0.0];+ return Ok(Value::Null);+ }+ "view.actualSize" => {+ app.ui.viewer.zoom = Some(1.0 / ctx.pixels_per_point());+ app.ui.viewer.pan = [0.0, 0.0];+ return Ok(Value::Null);+ }+ "view.safeMargins" => app.ui.viewer.safe_margins = !app.ui.viewer.safe_margins,+ "view.transparencyGrid" => app.ui.viewer.transparency_grid = !app.ui.viewer.transparency_grid,+ "view.fastPreviews" => {+ // With a mode: Fast Previews ▸ Off / Adaptive Resolution / Draft / Fast Draft /+ // Wireframe; without: toggle Draft quality (Settings ▸ Previews).+ if params.get("mode").is_some() {+ return run_engine(app, ctx, "view.fastPreviewMode", params);+ }+ let on = !app.ui.viewer.fast_preview;+ app.set_pref("previews.fastPreviews", json!(on))?;+ app.ui.viewer.fast_preview = on;+ }+ "timeline.zoomIn" | "timeline.zoomOut" => {+ let k = if id == "timeline.zoomIn" { crate::panels::timeline::ZOOM_STEP } else { 1.0 / crate::panels::timeline::ZOOM_STEP };+ crate::panels::timeline::zoom(app, ctx, k);+ return Ok(Value::Null);+ }+ "timeline.zoomFit" => crate::panels::timeline::toggle_fit_zoom(app, ctx),+ "timeline.zoomFrameToggle" => crate::panels::timeline::toggle_frame_zoom(app, ctx),+ "timeline.column" => {+ let col = params.get("column").and_then(Value::as_str).ok_or("timeline.column: need `column`")?;+ let on = params.get("visible").and_then(Value::as_bool).unwrap_or(!crate::panels::timeline::column_visible(&app.ui.timeline, col));+ crate::panels::timeline::set_column(&mut app.ui.timeline, col, on)?;+ let shown: Vec<&str> =+ crate::panels::timeline::COLUMNS.iter().map(|c| c.0).filter(|c| crate::panels::timeline::column_visible(&app.ui.timeline, c)).collect();+ return Ok(json!({"columns": shown}));+ }+ "timeline.sourceName" => {+ let tl = &mut app.ui.timeline;+ tl.source_name = params.get("value").and_then(Value::as_bool).unwrap_or(!tl.source_name);+ return Ok(json!({"sourceName": tl.source_name}));+ }+ "flowchart.options" | "flowchart.graph" => return crate::panels::flowchart::command(app, id, ¶ms),+ "timeline.search" => {+ app.ui.timeline.search = params.get("query").and_then(Value::as_str).unwrap_or_default().to_string();+ app.show_panel(PanelKind::Timeline);+ }+ "timeline.graphEditor" => app.ui.timeline.graph_editor = !app.ui.timeline.graph_editor,+ "timeline.switchesModes" => app.ui.timeline.show_modes = !app.ui.timeline.show_modes,+ "timeline.collapseAll" => {+ app.ui.timeline.open_layers.clear();+ app.ui.timeline.open_groups.clear();+ app.ui.timeline.reveal.clear();+ app.ui.timeline.layer_reveal.clear();+ }+ // Ctrl+`: twirl the selected layers open (all closed ones) or closed (all open). From a+ // reveal shortcut's view it opens their full property trees.+ "timeline.twirlSelected" => {+ let sel: Vec<u64> = app.session.state.selected_layers.iter().map(|l| l.0).collect();+ let tl = &mut app.ui.timeline;+ let revealing = sel.iter().any(|l| tl.layer_reveal.contains_key(l));+ tl.reveal.clear();+ for l in &sel {+ tl.layer_reveal.remove(l);+ }+ if !revealing && sel.iter().all(|l| tl.open_layers.contains(l)) {+ for l in &sel {+ tl.open_layers.remove(l);+ }+ } else {+ tl.open_layers.extend(sel);+ }+ }+ "timeline.workAreaBegin" => return app.session.execute("comp.workArea", json!({"set": "begin"})).map_err(|e| e.to_string()),+ "timeline.workAreaEnd" => return app.session.execute("comp.workArea", json!({"set": "end"})).map_err(|e| e.to_string()),+ "timeline.moveInToTime" => return timing(app, "moveInToTime"),+ "timeline.moveOutToTime" => return timing(app, "moveOutToTime"),+ "timeline.trimInToTime" => return timing(app, "trimInToTime"),+ "timeline.trimOutToTime" => return timing(app, "trimOutToTime"),+ "app.home" => app.ui.start_screen = !app.ui.start_screen,+ "app.newComp" | "comp.new" if no_params(¶ms) => crate::panels::dialogs::open_new_comp(app),+ "app.compSettings" | "comp.settings" if no_params(¶ms) => crate::panels::dialogs::open_comp_settings(app)?,+ "app.compSettings" | "comp.settings" if only_comp(¶ms).is_some() => {+ crate::panels::dialogs::open_comp_settings_for(app, only_comp(¶ms).ok_or("missing `comp`")?)?+ }+ "app.solidSettings" | "layer.newSolid" if no_params(¶ms) => crate::panels::dialogs::open_new_solid(app)?,+ "keys.velocity" if no_params(¶ms) => crate::panels::key_dialogs::open_velocity(app)?,+ "keys.interpolation" if no_params(¶ms) => crate::panels::key_dialogs::open_interpolation(app)?,+ "layer.timeStretch" if no_params(¶ms) => crate::panels::key_dialogs::open_time_stretch(app)?,+ _ => {+ if id == "renderQueue.render" && params.get("wait").is_none() {+ // The UI renders in the background; the panel shows progress.+ let mut p = params.clone();+ if let Some(m) = p.as_object_mut() {+ m.insert("wait".into(), json!(false));+ } else {+ p = json!({"wait": false});+ }+ app.show_panel(PanelKind::RenderQueue);+ return app.session.execute(id, p).map_err(|e| e.to_string());+ }+ if id == "renderQueue.add" {+ let r = app.session.execute(id, params).map_err(|e| e.to_string());+ match &r {+ Ok(_) => app.show_panel(PanelKind::RenderQueue),+ Err(e) => app.ui.status = e.clone(),+ }+ return r;+ }+ if let Some(r) = file_dialog(app, id, ¶ms) {+ return r;+ }+ if id == "layer.precompose" && params.get("name").is_none() {+ crate::panels::precomp::open(app, ¶ms)?;+ return Ok(json!({"dialog": id}));+ }+ if crate::panels::dialogs::open_form(app, id, ¶ms) {+ return Ok(json!({"dialog": id}));+ }+ if id == "renderQueue.render" && params.get("wait").is_none() {+ // The UI renders in the background; the panel shows progress.+ let mut p = params.clone();+ if let Some(m) = p.as_object_mut() {+ m.insert("wait".into(), json!(false));+ } else {+ p = json!({"wait": false});+ }+ app.show_panel(PanelKind::RenderQueue);+ return app.session.execute(id, p).map_err(|e| e.to_string());+ }+ if id == "renderQueue.add" {+ let r = app.session.execute(id, params).map_err(|e| e.to_string());+ match &r {+ Ok(_) => app.show_panel(PanelKind::RenderQueue),+ Err(e) => app.ui.status = e.clone(),+ }+ return r;+ }+ // An effect added to a layer (Effect menu, Last Effect, dropped on a layer) brings+ // up Effect Controls on that layer, as in After Effects.+ if matches!(id, "effect.apply" | "effect.applyLast") {+ let r = run_engine(app, ctx, id, params.clone());+ if let Ok(applied) = &r {+ crate::panels::effect_controls::reveal_applied(app, ¶ms);+ crate::panels::effect_controls::choose_files_after_apply(app, applied);+ }+ return r;+ }+ // Enabling time remapping twirls its layers open on Time Remap and its two keys.+ if id == "layer.enableTimeRemap" {+ let r = run_engine(app, ctx, id, params.clone());+ if r.as_ref().is_ok_and(|on| on.as_bool() == Some(true)) {+ reveal_time_remap(app, ¶ms);+ }+ return r;+ }+ if id == "layer.rename" && params.get("name").is_none() {+ crate::panels::timeline::begin_rename(app, ctx);+ return Ok(Value::Null);+ }+ return run_engine(app, ctx, id, params);+ }+ }+ Ok(Value::Null)+ }diff --cc crates/ui-egui/src/menus/shortcuts.rsindex 000000000,7e3dfcec2..5c9a385c4mode 000000,100644..100644--- a/crates/ui-egui/src/menus/shortcuts.rs+++ b/crates/ui-egui/src/menus/shortcuts.rs@@@ -1,0 -1,397 +1,399 @@@+ use super::frontend::run_engine;+ use super::invoke::invoke;+ use super::*;++ /// Shortcut text in this OS's notation (`⇧⌘K` on macOS, `Ctrl+Shift+K` elsewhere).+ pub fn shortcut_text(s: &str) -> String {+ if cfg!(target_os = "macos") {+ let mut out = String::new();+ let parts: Vec<&str> = match s.strip_suffix("++") {+ Some(head) => vec![head, "+"],+ None => s.split('+').collect(),+ };+ let (mods, key) = parts.split_at(parts.len().saturating_sub(1));+ for m in mods {+ out.push_str(match *m {+ "Ctrl" => "⌃",+ "Alt" => "⌥",+ "Shift" => "⇧",+ "Cmd" => "⌘",+ x => x,+ });+ }+ out.push_str(match key.first().copied().unwrap_or("") {+ "Space" => "Space",+ "Escape" => "Esc",+ "Home" => "↖",+ k => k,+ });+ out+ } else {+ s.replace("Cmd", "Ctrl")+ }+ }++ /// Parse "Cmd+Shift+K" into modifiers + key.+ pub fn parse_shortcut(s: &str) -> Option<(egui::Modifiers, egui::Key)> {+ let mut m = egui::Modifiers::NONE;+ let mut key = None;+ // The plus key itself is written `+` or `Cmd++`.+ let (head, plus) = match s.strip_suffix("++") {+ Some(h) => (h, true),+ None if s == "+" => ("", true),+ None => (s, false),+ };+ let mut parts: Vec<&str> = if head.is_empty() { vec![] } else { head.split('+').collect() };+ if plus {+ parts.push("+");+ }+ for p in parts {+ match p {+ "Cmd" => {+ m.command = true;+ m.mac_cmd = cfg!(target_os = "macos");+ if !cfg!(target_os = "macos") {+ m.ctrl = true;+ }+ }+ "Physical" => {}+ "Shift" => m.shift = true,+ "Alt" => m.alt = true,+ "Ctrl" => m.ctrl = true,+ k => {+ key = match k {+ ";" => Some(egui::Key::Semicolon),+ "'" => Some(egui::Key::Quote),+ "," => Some(egui::Key::Comma),+ "." => Some(egui::Key::Period),+ "/" => Some(egui::Key::Slash),+ "\\" => Some(egui::Key::Backslash),+ "=" => Some(egui::Key::Equals),+ "-" => Some(egui::Key::Minus),+ "`" => Some(egui::Key::Backtick),+ "[" => Some(egui::Key::OpenBracket),+ "]" => Some(egui::Key::CloseBracket),+ "Num0" => Some(egui::Key::Num0),+ "Num*" => None,+ _ => egui::Key::from_name(k),+ }+ }+ }+ }+ key.map(|k| (m, k))+ }++ /// The key some keyboards report for a shifted punctuation key (`Shift+=` arrives as `+`).+ fn shifted_alias(k: egui::Key) -> Option<egui::Key> {+ use egui::Key::*;+ Some(match k {+ Equals => Plus,+ Semicolon => Colon,+ OpenBracket => OpenCurlyBracket,+ CloseBracket => CloseCurlyBracket,+ Slash => Questionmark,+ Backslash => Pipe,+ _ => return None,+ })+ }++ /// A key binding: modifiers, key, command id and bound params.+ pub type Binding = (egui::Modifiers, egui::Key, String, Value);++ /// All bindings of the active keyboard shortcut preset, most modifiers first.+ pub fn bindings(session: &effectcraft_engine::Session) -> Vec<Binding> {+ let mut v: Vec<Binding> = Vec::new();+ for (sc, b) in session.shortcuts().bindings() {+ if sc.starts_with("Physical+") {+ continue;+ }+ // Off macOS `Cmd` is Ctrl, so a custom Ctrl+Cmd shortcut would+ // steal the plain Cmd one: such macOS-only shortcuts aren't bound there.+ if !cfg!(target_os = "macos") && sc.split('+').any(|p| p == "Ctrl") && sc.split('+').any(|p| p == "Cmd") {+ continue;+ }+ if let Some((m, k)) = parse_shortcut(sc) {+ if m.shift+ && let Some(alias) = shifted_alias(k)+ {+ v.push((m, alias, b.command.clone(), b.params.clone()));+ }+ v.push((m, k, b.command.clone(), b.params.clone()));+ }+ }+ v.sort_by_key(|(m, ..)| std::cmp::Reverse(m.command as u8 + m.shift as u8 + m.alt as u8 + m.ctrl as u8));+ v+ }++ fn mods_match(want: egui::Modifiers, got: egui::Modifiers) -> bool {+ want.command == got.command && want.shift == got.shift && want.alt == got.alt && (want.ctrl == got.ctrl || got.command && cfg!(not(target_os = "macos")))+ }++ /// Whether the `key`+`mods` chord is the current binding of `command` in the active preset+ /// (so callers that must match a shortcut themselves — like the viewer's text editor, which+ /// holds the keyboard while the shortcut dispatcher is skipped — follow rebinds).+ /// `Physical+`-only bindings never match here, exactly as for the app-wide dispatcher.+ pub fn chord_matches(session: &effectcraft_engine::Session, command: &str, key: egui::Key, mods: egui::Modifiers) -> bool {+ bindings(session).into_iter().any(|(m, k, id, _)| id == command && k == key && mods_match(m, mods))+ }++ /// Whether a Deselect All chord matched by [`chord_matches`] may run while a text editor holds+ /// the keyboard. Chords carrying Cmd/Ctrl/Alt are command chords (the editor treats them as+ /// such for undo and the rest), and function keys never type, so those forward from the editor;+ /// a chord that could instead produce a character — a bare or Shift-only letter, digit or+ /// punctuation key, as from a pathological bare-letter rebinding — stays with the editor so+ /// typing keeps working, the same invariant the app-wide dispatcher honors by skipping+ /// focused text fields.+ pub fn forwardable_during_text_edit(mods: egui::Modifiers, key: egui::Key) -> bool {+ mods.command || mods.ctrl || mods.alt || (egui::Key::F1..=egui::Key::F35).contains(&key)+ }++ /// Set (egui temp data) from a plain Spacebar press until its release while a tap would still+ /// run the Spacebar shortcut.+ /// The system clipboard's text of this frame's paste event, for the Edit ▸ Paste it runs.+ pub(super) fn system_paste_id() -> egui::Id {+ egui::Id::unique("menus-system-paste")+ }++ /// The temp-data id of the flag set by a plain Space press and taken on its release, so a tap+ /// runs the Space shortcut while holding Space stays the Hand tool.+ fn space_tap_id() -> egui::Id {+ egui::Id::unique("spacebar-tap")+ }++ /// The modifiers held when this frame's input began: the state the last pass ended with, if it+ /// ran this (egui keeps only the state after the frame's events). Records this pass's state.+ pub(super) fn modifiers_at_start(ctx: &egui::Context) -> Option<egui::Modifiers> {+ let id = egui::Id::unique("shortcut-modifiers");+ let pass = ctx.cumulative_pass_nr();+ let now = ctx.input(|i| i.modifiers);+ ctx.data_mut(|d| {+ let last = d.get_temp::<(u64, egui::Modifiers, Option<egui::Modifiers>)>(id);+ if let Some((p, _, start)) = last+ && p == pass+ {+ return start;+ }+ let start = last.and_then(|(p, m, _)| (p.checked_add(1) == Some(pass)).then_some(m));+ d.insert_temp(id, (pass, now, start));+ start+ })+ }++ /// Only Shift held (Shift+Delete, not Ctrl/Alt+Shift+Delete).+ fn only_shift(m: egui::Modifiers) -> bool {+ m.shift && !m.alt && !m.ctrl && !m.command && !m.mac_cmd+ }++ /// Dispatch keyboard shortcuts (skipped while typing in a text field).+ pub fn handle_shortcuts(app: &mut EffectcraftApp, ctx: &egui::Context) {+ handle_shortcuts_impl(app, ctx, false);+ }++ /// Tab can acquire widget focus while the current frame is drawn. Dispatch its application+ /// binding only afterward, and only when no widget owned focus before or after layout.+ pub fn handle_tab_shortcut(app: &mut EffectcraftApp, ctx: &egui::Context) {+ if ctx.input(|i| i.key_pressed(egui::Key::Tab)) {+ handle_shortcuts_impl(app, ctx, true);+ }+ }++ fn handle_shortcuts_impl(app: &mut EffectcraftApp, ctx: &egui::Context, tab_only: bool) {+ let start = modifiers_at_start(ctx);+ // Dialog cancellation owns Escape even when a text field has keyboard focus.+ if !tab_only && app.dialog.is_some() && ctx.input(|i| i.key_pressed(egui::Key::Escape)) {+ // A popup or colour picker takes Escape first (the picker goes back to its original colour).+ if crate::panels::shortcut_editor::recording(app)+ || crate::panels::shortcut_editor::confirming(app)+ || egui::Popup::is_any_open(ctx)+ || crate::color_picker::open_recently(ctx)+ {+ return;+ }+ ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape));+ if app.dialog == Some(crate::Dialog::LayerStyles) {+ crate::panels::layer_styles_dialog::finish(app, false);+ } else if app.dialog == Some(crate::Dialog::Info) {+ crate::panels::forms::close_info(app);+ } else {+ if app.dialog == Some(crate::Dialog::Settings)+ && let Some(p) = app.dialog_state.prefs_snapshot.take()+ {+ app.session.prefs = p;+ app.session.prefs_changed();+ }+ if app.dialog == Some(crate::Dialog::UnsavedChanges) {+ app.dialog_state.unsaved.command = None;+ }+ app.dialog = None;+ }+ return;+ }+ // A mouse button down while Spacebar is held belongs to the Hand tool: its release won't+ // preview.+ if ctx.input(|i| i.pointer.any_down()) || ctx.egui_wants_keyboard_input() {+ ctx.data_mut(|d| d.remove::<bool>(space_tap_id()));+ }+ // While a menu or popup list is open, keys go to it, not to the app (Space must not start a+ // preview behind the menu, #279).+ if ctx.egui_wants_keyboard_input() || crate::widgets::any_menu_open(ctx) {+ return;+ }+ // Text editing in the viewer takes the clipboard events itself.+ let clipboard = app.session.state.text_edit.is_none();+ let project = app.ui.focused == PanelKind::Project;+ // The paste event's text: Edit ▸ Paste pastes SVG markup as a shape layer.+ let pasted =+ if clipboard { ctx.input(|i| i.events.iter().rev().find_map(|e| if let egui::Event::Paste(t) = e { Some(t.clone()) } else { None })) } else { None };+ let mut events: Vec<(egui::Key, egui::Modifiers, bool, Option<egui::Key>)> = ctx.input(|i| {+ // The windowing layer turns Ctrl+C / Ctrl+X / Ctrl+V into clipboard events instead of+ // key presses: map them back to the keys (with the modifiers held) so Edit ▸ Copy, Cut,+ // Paste and their variants (Ctrl+Alt+C…) run. Clipboard events carry no modifiers and+ // `i.modifiers` is the state after all of the frame's events, so each is read with the+ // modifiers where it is in the stream: walk the events from the frame's starting state.+ // `None` when that isn't known.+ let changed = i.events.iter().any(|e| matches!(e, egui::Event::ModifiersChanged(_) | egui::Event::WindowFocused(false)));+ let mut at = if changed { start } else { Some(i.modifiers) };+ let held = |at: Option<egui::Modifiers>| at.filter(|m| m.command).unwrap_or(egui::Modifiers::COMMAND);+ let mut out = Vec::new();+ for e in &i.events {+ match e {+ egui::Event::ModifiersChanged(m) => at = Some(*m),+ // egui forgets the modifiers held when the window loses focus.+ egui::Event::WindowFocused(false) => at = Some(egui::Modifiers::NONE),+ egui::Event::Key { key, physical_key, pressed: true, modifiers, repeat, .. }+ if !*repeat+ || matches!(+ key,+ egui::Key::PageUp | egui::Key::PageDown | egui::Key::ArrowLeft | egui::Key::ArrowRight | egui::Key::ArrowUp | egui::Key::ArrowDown+ ) =>+ {+ out.push((*key, *modifiers, true, *physical_key));+ }+ egui::Event::Key { key: egui::Key::Space, pressed: false, .. } => out.push((egui::Key::Space, egui::Modifiers::NONE, false, None)),+ egui::Event::Copy if clipboard => out.push((egui::Key::C, held(at), true, None)),+ // On Windows, Shift+Delete is the old Cut key and arrives as Cut too. The Project+ // panel has no clipboard: there a Cut with only Shift held is Shift+Delete (Delete+ // Project Items Without Confirmation). Never when the modifiers aren't known.+ egui::Event::Cut if clipboard && project && at.is_some_and(only_shift) => {+ out.push((egui::Key::Delete, egui::Modifiers::SHIFT, true, None));+ }+ egui::Event::Cut if clipboard => out.push((egui::Key::X, held(at), true, None)),+ egui::Event::Paste(_) if clipboard => out.push((egui::Key::V, held(at), true, None)),+ _ => {}+ }+ }+ out+ });+ events.retain(|(key, _, _, _)| (*key == egui::Key::Tab) == tab_only);+ // Numpad * (or `*` typed with Shift+8): Add Marker (#275). egui has no key for it, so it+ // comes as text.+ if !tab_only && clipboard && app.dialog.is_none() && ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Text(t) if t == "*"))) {+ let bound = app.session.shortcuts().bindings().into_iter().find(|(k, _)| *k == "Num*").map(|(_, b)| (b.command.clone(), b.params.clone()));+ // As in After Effects, it marks the selected layers; only with none selected does it add+ // a composition marker (#976).+ let bound = bound.map(|(id, params)| {+ if id == "comp.addMarker" && !app.session.state.selected_layers.is_empty() { ("layer.addMarker".to_owned(), params) } else { (id, params) }+ });+ if let Some((id, params)) = bound+ && let Err(e) = invoke(app, ctx, &id, if params.is_null() { json!({}) } else { params })+ {+ app.ui.status = e;+ }+ }+ if events.is_empty() {+ return;+ }+ let binds = bindings(&app.session);+ for (key, mods, pressed, physical_key) in events {+ // Plain Spacebar runs its shortcut (Play Current Preview) on the release: held, it is+ // the Hand tool (After Effects), and a drag with it must not start or stop playback.+ if key == egui::Key::Space && (!pressed || !mods.any()) {+ if pressed {+ if app.dialog.is_none() {+ ctx.data_mut(|d| d.insert_temp(space_tap_id(), true));+ }+ continue;+ }+ if !ctx.data_mut(|d| d.remove_temp::<bool>(space_tap_id())).unwrap_or(false) {+ continue;+ }+ }+ // Escape closes dialogs.+ if key == egui::Key::Escape && app.dialog.is_some() {+ // Escape while recording a shortcut cancels the recording, not the editor; so does+ // Escape in its Delete Preset prompt.+ if crate::panels::shortcut_editor::recording(app) || crate::panels::shortcut_editor::confirming(app) {+ continue;+ }+ if app.dialog == Some(crate::Dialog::Info) {+ crate::panels::forms::close_info(app);+ continue;+ }+ // Escape in Settings is Cancel: restore the settings from when it opened.+ if app.dialog == Some(crate::Dialog::Settings)+ && let Some(p) = app.dialog_state.prefs_snapshot.take()+ {+ app.session.prefs = p;+ app.session.prefs_changed();+ }+ app.dialog = None;+ continue;+ }+ if app.dialog.is_some() {+ continue;+ }+ // Enter in the Project panel renames the selected item (handled by the panel).- if key == egui::Key::Enter && !mods.any() && app.ui.focused == PanelKind::Project {++ // In Effects & Presets and the Render Queue Enter applies or opens the row (handled by the++ // panel), not the layer rename.++ if key == egui::Key::Enter && !mods.any() && matches!(app.ui.focused, PanelKind::Project | PanelKind::EffectsPresets | PanelKind::RenderQueue) {+ continue;+ }+ // The Project panel has its own selection; a previously selected Timeline layer+ // must not be deleted while the Project panel has focus.+ if matches!(key, egui::Key::Delete | egui::Key::Backspace) && !mods.any() {+ if matches!(app.ui.focused, PanelKind::Composition | PanelKind::Viewer(_)) && !app.session.state.camera_points.is_empty() {+ if let Err(e) = run_engine(app, ctx, "camera.deletePoints", json!({})) {+ app.ui.status = e;+ }+ ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, key));+ continue;+ }+ // The queue panel consumes the event after its selection state is drawn.+ if app.ui.focused == PanelKind::RenderQueue {+ continue;+ }+ let _ = invoke(app, ctx, "edit.clear", json!({}));+ continue;+ }+ // Explicit physical bindings distinguish keys that a layout reports with the same+ // logical name (for example AZERTY's minus and right parenthesis).+ let physical = physical_key.and_then(|key| {+ app.session.shortcuts().bindings().into_iter().find_map(|(sc, b)| {+ let (m, k) = parse_shortcut(sc.strip_prefix("Physical+")?)?;+ (k == key && mods_match(m, mods)).then(|| (b.command.clone(), b.params.clone()))+ })+ });+ if let Some((id, params)) = physical {+ if let Err(e) = invoke(app, ctx, &id, if params.is_null() { json!({}) } else { params }) {+ app.ui.status = e;+ }+ continue;+ }+ if let Some((_, _, id, params)) = binds.iter().filter(|(m, k, ..)| *k == key && mods_match(*m, mods)).min_by_key(|(_, _, id, params)| {+ // The focused panel wins over an application command sharing its chord.+ let key = effectcraft_engine::shortcuts::binding_key(id, params);+ app.session.shortcuts().find(&key).is_none_or(|b| b.scope != app.ui.focused.id())+ }) {+ let (id, params) = (id.clone(), if params.is_null() { json!({}) } else { params.clone() });+ if id == "edit.paste"+ && let Some(t) = &pasted+ {+ ctx.data_mut(|d| d.insert_temp(system_paste_id(), t.clone()));+ }+ if let Err(e) = invoke(app, ctx, &id, params) {+ app.ui.status = e;+ }+ ctx.data_mut(|d| d.remove_temp::<String>(system_paste_id()));+ }+ }+ }diff --cc crates/ui-egui/src/panels/settings.rsindex 4c7340a30,c285011fe..6a860d42a--- a/crates/ui-egui/src/panels/settings.rs+++ b/crates/ui-egui/src/panels/settings.rs@@@ -79,8 -78,7 +79,8 @@@ fn page_ui(app: &mut EffectcraftApp, uiui.horizontal(|ui| {ui.add_sized(vec2(label_w, 18.0), egui::Label::new(tr("Default Output:")));let shown = if sel.is_empty() { tr("System Default").to_string() } else { sel.clone() };+ let shown_name = shown.clone();- let r = egui::ComboBox::from_id_salt(("settings", key)).selected_text(shown).width(260.0).show_ui(ui, |ui| {+ let r = craft_ui::ComboBox::from_id_salt(("settings", key)).selected_text(shown).width(260.0).show_ui(ui, |ui| {if ui.selectable_label(sel.is_empty(), tr("System Default")).clicked() {acts.push(Act::Set(key.into(), json!("")));}@@@ -162,8 -157,7 +162,8 @@@Kind::Choice(opts) => {let curv = v.as_str().map_or_else(|| v.to_string(), str::to_string);let shown = opts.iter().find(|o| o.1 == curv).map(|o| o.0).unwrap_or(curv.as_str()).to_string();+ value_text = tr(&shown).to_string();- egui::ComboBox::from_id_salt(("settings", key))+ craft_ui::ComboBox::from_id_salt(("settings", key)).selected_text(tr(&shown)).width(220.0).show_ui(ui, |ui| {