Skip to content

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.rs
index 000000000,b266623f3..1a78bae57
mode 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(&params) {
+ 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(&params) {
+ 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(&params) && 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(&params) && 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, &params) {
+ 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, &params) {
+ 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, &params)? {
+ return Ok(Value::Null);
+ }
+ // New 3D Primitive without parameters opens its dialog.
+ if crate::panels::primitive_dialog::route(app, id, &params)? {
+ 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, &params)? {
+ 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, &params)? {
+ 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, &params) {
+ 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, &params),
+ "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(&params) => crate::panels::dialogs::open_new_comp(app),
+ "app.compSettings" | "comp.settings" if no_params(&params) => crate::panels::dialogs::open_comp_settings(app)?,
+ "app.compSettings" | "comp.settings" if only_comp(&params).is_some() => {
+ crate::panels::dialogs::open_comp_settings_for(app, only_comp(&params).ok_or("missing `comp`")?)?
+ }
+ "app.solidSettings" | "layer.newSolid" if no_params(&params) => crate::panels::dialogs::open_new_solid(app)?,
+ "keys.velocity" if no_params(&params) => crate::panels::key_dialogs::open_velocity(app)?,
+ "keys.interpolation" if no_params(&params) => crate::panels::key_dialogs::open_interpolation(app)?,
+ "layer.timeStretch" if no_params(&params) => 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, &params) {
+ return r;
+ }
+ if id == "layer.precompose" && params.get("name").is_none() {
+ crate::panels::precomp::open(app, &params)?;
+ return Ok(json!({"dialog": id}));
+ }
+ if crate::panels::dialogs::open_form(app, id, &params) {
+ 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, &params);
+ 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, &params);
+ }
+ 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.rs
index 000000000,7e3dfcec2..5c9a385c4
mode 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.rs
index 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, ui
ui.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| {