From 13dfcdd142e9f630c60b91983d4472a07f807319 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Fri, 13 Nov 2026 10:42:33 -0800 Subject: [PATCH] Tools: commands return the error when a tool cannot be chosen tool.toggleTouchMode reported success with the old tool when the tool switch failed, and it had already stored the outgoing tool as the drawing tool to return to. It now returns the error, and the drawing tool changes only after the switch succeeds. tool.select, ui.cropImage and the Path Precision Tools' Corner Tool and Shared Edge Merge Tool commands also return the error instead of reporting success, and the two Path Precision commands no longer reveal the Anchor Inspector after a failed choice. A failed choice no longer stores the requested tool as its toolbar group's tool. Toolbar clicks, shortcuts and other UI paths still show the error in the status bar. Docs: docs/mcp.md, docs/target-app-parity.md and the command params text. --- crates/ui-egui/src/addons/pathtools/corner.rs | 2 +- .../src/addons/pathtools/shared_edge.rs | 2 +- crates/ui-egui/src/app.rs | 2 + crates/ui-egui/src/app/commands.rs | 42 ++++++++++---- crates/ui-egui/src/canvas/tests.rs | 58 +++++++++++++++++++ crates/ui-egui/src/lib.rs | 4 ++ crates/ui-egui/src/menus/run.rs | 12 +--- crates/ui-egui/src/menus/ui_commands.rs | 6 +- crates/ui-egui/src/touch.rs | 21 +++---- docs/mcp.md | 5 +- docs/target-app-parity.md | 1 + 11 files changed, 120 insertions(+), 35 deletions(-) diff --git a/crates/ui-egui/src/addons/pathtools/corner.rs b/crates/ui-egui/src/addons/pathtools/corner.rs index ace9be954c..58cc95882d 100644 --- a/crates/ui-egui/src/addons/pathtools/corner.rs +++ b/crates/ui-egui/src/addons/pathtools/corner.rs @@ -19,7 +19,7 @@ const FIELD_W: f32 = 96.0; /// Object › Plug-ins › Path Precision Tools › Corner Tool. pub fn open(app: &mut VectorcraftApp) -> Result { - app.select_tool(ID); + app.try_select_tool(ID)?; crate::panel_docking::reveal_panel(app, super::ID) } diff --git a/crates/ui-egui/src/addons/pathtools/shared_edge.rs b/crates/ui-egui/src/addons/pathtools/shared_edge.rs index d682aad776..57254e1aec 100644 --- a/crates/ui-egui/src/addons/pathtools/shared_edge.rs +++ b/crates/ui-egui/src/addons/pathtools/shared_edge.rs @@ -17,7 +17,7 @@ const LABEL_W: f32 = 80.0; /// Object › Plug-ins › Path Precision Tools › Shared Edge Merge Tool. pub fn open(app: &mut VectorcraftApp) -> Result { - app.select_tool(ID); + app.try_select_tool(ID)?; crate::panel_docking::reveal_panel(app, super::ID) } diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 8c8a153a94..186a7891ab 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -181,6 +181,8 @@ impl VectorcraftApp { host_iteration: 0, #[cfg(test)] now_override: None, + #[cfg(test)] + fail_next_tool_choice: None, tick_iteration: None, input_frames: vec![], shortcuts_frames: vec![], diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index 50c7b1be30..6000bb8a24 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -406,34 +406,54 @@ impl VectorcraftApp { } } - /// Select a tool (also used by the toolbar and shortcuts). + /// Select a tool (also used by the toolbar and shortcuts). A choice that fails shows its error + /// in the status bar. pub fn select_tool(&mut self, id: &str) { + if let Err(e) = self.try_select_tool(id) { + self.ui.status = e; + } + } + + /// Select a tool for a command ([`Self::select_tool`]): a choice that fails returns its error, + /// and the tool remembered for the toolbar group and for the Touch workspace's drawing mode + /// stays as it was. + pub(crate) fn try_select_tool(&mut self, id: &str) -> Result<(), String> { // The tip of a pen whose eraser end selected the Eraser doesn't undo this choice, and // neither does letting go of a held tool shortcut. self.pen_end.forget_tool(); self.held_tool.clear(); - self.activate_tool(id, true); + self.activate_tool(id, true)?; let now = self.session.tool_id(); if crate::touch::is_drawing_tool(now) { self.ui.touch_drawing_tool = Some(now.to_string()); } + Ok(()) } /// Go back to tool `id` after a tool that stood in for it (the pen's eraser end, [`stylus`]): - /// a perspective grid hidden meanwhile stays hidden. + /// a perspective grid hidden meanwhile stays hidden. A switch that fails shows its error in the + /// status bar. pub(crate) fn return_to_tool(&mut self, id: &str) { - self.activate_tool(id, false); + if let Err(e) = self.activate_tool(id, false) { + self.ui.status = e; + } } /// Make tool `id` active: chosen afresh (`fresh`, [`vectorcraft_engine::Session::select_tool`]), /// or back from a tool that stood in for it ([`vectorcraft_engine::Session::switch_tool`]). - fn activate_tool(&mut self, id: &str, fresh: bool) { + /// The toolbar group remembers `id` only when the switch succeeds. + fn activate_tool(&mut self, id: &str, fresh: bool) -> Result<(), String> { let v = self.view_info(); let before = self.session.tool_id(); - let switched = if fresh { self.session.select_tool(id, v) } else { self.session.switch_tool(id, v) }; - if let Err(e) = switched { - self.ui.status = e.to_string(); - } + #[cfg(test)] + let failed = self.fail_next_tool_choice.take(); + #[cfg(not(test))] + let failed: Option = None; + let switched = match failed { + Some(e) => Err(e), + None if fresh => self.session.select_tool(id, v).map_err(|e| e.to_string()), + None => self.session.switch_tool(id, v).map_err(|e| e.to_string()), + }; if before != self.session.tool_id() { // A control gesture cannot resume after another tool has owned the pointer. self.control_rotate_press = None; @@ -445,13 +465,15 @@ impl VectorcraftApp { { panels::artboards::select(self, panels::artboards::selected(self, n)); } + self.ui.flyout = None; + switched?; if let Some(g) = vectorcraft_tools::catalog::group_of(id) && let Some(slot) = self.ui.group_tool.get_mut(g) { *slot = id.to_string(); } toolbar::remember(self, id); - self.ui.flyout = None; + Ok(()) } /// Show a transient status message. diff --git a/crates/ui-egui/src/canvas/tests.rs b/crates/ui-egui/src/canvas/tests.rs index 6bf8a6fa97..38d3163ef3 100644 --- a/crates/ui-egui/src/canvas/tests.rs +++ b/crates/ui-egui/src/canvas/tests.rs @@ -1051,6 +1051,64 @@ fn switch_selection_and_drawing_modes_command() { } } +/// A Switch Selection and Drawing Modes whose tool choice fails returns the error, in both +/// directions: the tool stays, the drawing tool to return to stays, and no undo step is added. +#[test] +fn a_failed_mode_switch_returns_its_error() { + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap(); + app.session.execute("shape.rectangle", &json!({"x": 40, "y": 40, "width": 30, "height": 20})).unwrap(); + let undo = |app: &VectorcraftApp| app.session.active().unwrap().history.undo.len(); + let steps = undo(&app); + app.select_tool("rectangle"); + app.ui.touch_drawing_tool = Some("pen".into()); + app.fail_next_tool_choice = Some("no switch".into()); + let r = app.run(crate::touch::TOGGLE_MODE, json!({})); + assert!(r.as_ref().is_err_and(|e| e.contains("no switch")), "{r:?}"); + assert_eq!((app.session.tool_id(), app.ui.touch_drawing_tool.as_deref(), undo(&app)), ("rectangle", Some("pen"), steps), "drawing mode"); + app.select_tool("selection"); + app.fail_next_tool_choice = Some("no switch".into()); + let r = app.run(crate::touch::TOGGLE_MODE, json!({})); + assert!(r.as_ref().is_err_and(|e| e.contains("no switch")), "{r:?}"); + assert_eq!((app.session.tool_id(), app.ui.touch_drawing_tool.as_deref(), undo(&app)), ("selection", Some("pen"), steps), "selection mode"); + // The next switch works again. + assert_eq!(app.run(crate::touch::TOGGLE_MODE, json!({})).unwrap(), json!({"tool": "pen"})); + assert_eq!(undo(&app), steps); +} + +/// The commands that choose a tool (Select Tool, Crop Image, and the Path Precision Tools' Corner +/// Tool and Shared Edge Merge Tool) return the error when the choice fails, and the tool and the +/// toolbar group's tool stay as they were. +#[test] +fn tool_commands_return_a_failed_choice() { + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + let img = image::RgbaImage::from_pixel(20, 10, image::Rgba([200, 120, 40, 255])); + let mut png = vec![]; + img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap(); + let data = vectorcraft_format::base64_encode(&png); + app.run("file.place", json!({"name": "texture.png", "dataBase64": data, "link": false, "at": [150, 150]})).unwrap(); + app.select_tool("selection"); + let group = vectorcraft_tools::catalog::group_of("ellipse").unwrap(); + let commands = [ + ("tool.select", json!({"tool": "ellipse"})), + ("ui.cropImage", json!({})), + (crate::addons::pathtools::corner::COMMAND, json!({})), + (crate::addons::pathtools::shared_edge::COMMAND, json!({})), + ]; + for (command, params) in commands { + let slot = app.ui.group_tool[group].clone(); + app.fail_next_tool_choice = Some("no switch".into()); + let r = app.run(command, params.clone()); + assert!(r.as_ref().is_err_and(|e| e.contains("no switch")), "{command}: {r:?}"); + assert_eq!(app.session.tool_id(), "selection", "{command}"); + assert_eq!(app.ui.group_tool[group], slot, "{command}"); + app.run(command, params).unwrap(); + assert_ne!(app.session.tool_id(), "selection", "{command} works again"); + app.select_tool("selection"); + } +} + /// The Artboard tool's label holds the artboard's name (never translated); the tools' own /// labels are interface text. #[test] diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index c527991ed0..3019886391 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -339,6 +339,10 @@ pub struct VectorcraftApp { /// can be driven one simulated frame at a time (production always leaves this `None`). #[cfg(test)] pub(crate) now_override: Option, + /// An error the next tool choice returns before the engine sees it ([`Self::try_select_tool`]), + /// so tests can drive a failed switch (production has no such field). + #[cfg(test)] + pub(crate) fail_next_tool_choice: Option, /// The host iteration [`Self::tick`] ran in (`None`: never): once per iteration, never per pass. tick_iteration: Option, /// The context, viewport and frame whose UI-phase input was already taken in this host diff --git a/crates/ui-egui/src/menus/run.rs b/crates/ui-egui/src/menus/run.rs index efa4e95ac4..0d46481841 100644 --- a/crates/ui-egui/src/menus/run.rs +++ b/crates/ui-egui/src/menus/run.rs @@ -677,14 +677,11 @@ fn run_ui_part6(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option crate::chrome::step_document(app, true), "window.previousDocument" => crate::chrome::step_document(app, false), "tool.select" => match s("tool") { - Some(t) if vectorcraft_tools::tool_info(&t).is_some() => { - app.select_tool(&t); - Ok(json!({"tool": app.session.tool_id()})) - } + Some(t) if vectorcraft_tools::tool_info(&t).is_some() => app.try_select_tool(&t).map(|()| json!({"tool": app.session.tool_id()})), Some(t) => Err(format!("unknown tool `{t}`")), None => Err("missing `tool`".into()), }, - crate::touch::TOGGLE_MODE => Ok(crate::touch::toggle_mode(app)), + crate::touch::TOGGLE_MODE => crate::touch::toggle_mode(app), crate::addons::pathtools::corner::COMMAND => crate::addons::pathtools::corner::open(app), crate::addons::pathtools::shared_edge::COMMAND => crate::addons::pathtools::shared_edge::open(app), crate::addons::arrange::ZOOM => crate::addons::arrange::zoom(app), @@ -696,10 +693,7 @@ fn run_ui_part6(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option crate::dialogs::open_effect_dialog(app, p), "ui.recolorDialog" => crate::dialogs::recolor::open(app, p), "ui.cropImage" if !selected_image(app, |_| true) => Err("select an image".into()), - "ui.cropImage" => { - app.select_tool(vectorcraft_tools::cropimage::ID); - Ok(json!({"tool": app.session.tool_id()})) - } + "ui.cropImage" => app.try_select_tool(vectorcraft_tools::cropimage::ID).map(|()| json!({"tool": app.session.tool_id()})), "ui.paramDialog" => { let cmd = s("command").unwrap_or_default(); let mut fields = p.get("params").and_then(Value::as_object).cloned().unwrap_or_default(); diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rs index 5f6da1ca36..2d7b157706 100644 --- a/crates/ui-egui/src/menus/ui_commands.rs +++ b/crates/ui-egui/src/menus/ui_commands.rs @@ -771,7 +771,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[ "Cmd+Shift+F6", "{} make the open document before the current one in tab order the current one, as a click on its tab does (before the first document it goes to the last, and from the Home screen to the last); each view window.newWindow opened is a step of its own; returns {index}, with `view` for a document with more than one view", ), - ("tool.select", "Select Tool", "", "{tool: id} (see tools)"), + ("tool.select", "Select Tool", "", "{tool: id} (see tools) → {tool}; a tool that cannot be chosen returns the error"), ( "tool.setOption", "Tool Option", @@ -782,7 +782,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[ crate::touch::TOGGLE_MODE, "Switch Selection and Drawing Modes", "", - "{} from the Selection, Direct Selection, Group Selection, Magic Wand, Lasso or Perspective Selection tool, choose the drawing tool chosen last in this window (none yet: the Pencil tool); from any other tool, choose the Selection tool, remembering the tool left as the drawing tool unless it is the Hand, Rotate View, Zoom or Print Tiling tool → {tool}. A two-finger tap on the canvas runs it in the Touch workspace (Enable Touch Gestures on)", + "{} from the Selection, Direct Selection, Group Selection, Magic Wand, Lasso or Perspective Selection tool, choose the drawing tool chosen last in this window (none yet: the Pencil tool); from any other tool, choose the Selection tool, remembering the tool left as the drawing tool unless it is the Hand, Rotate View, Zoom or Print Tiling tool → {tool}; a tool that cannot be chosen returns the error and leaves the drawing tool as it was. A two-finger tap on the canvas runs it in the Touch workspace (Enable Touch Gestures on)", ), ( "effect.dialog", @@ -801,7 +801,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[ "ui.cropImage", "Crop Image", "", - "{} show a crop box on the selected image (tool `cropImage`): it starts on the part over the image's artboard; drag its handles or inside it, then Enter or the Control bar's Apply crops the image to it (object.cropImage {rect}), Escape or Cancel leaves it as it is, both back to the Selection tool. tool.setOption {key: \"rect\", value: [x, y, width, height]} sets the box", + "{} show a crop box on the selected image (tool `cropImage`): it starts on the part over the image's artboard; drag its handles or inside it, then Enter or the Control bar's Apply crops the image to it (object.cropImage {rect}), Escape or Cancel leaves it as it is, both back to the Selection tool. tool.setOption {key: \"rect\", value: [x, y, width, height]} sets the box. → {tool}; a tool that cannot be chosen returns the error", ), ("effect.applyLast", "Apply Last Effect", "Cmd+Shift+E", "{}"), ( diff --git a/crates/ui-egui/src/touch.rs b/crates/ui-egui/src/touch.rs index 7cd1a4ad76..48db775c31 100644 --- a/crates/ui-egui/src/touch.rs +++ b/crates/ui-egui/src/touch.rs @@ -153,19 +153,20 @@ pub(crate) fn is_drawing_tool(id: &str) -> bool { /// [`TOGGLE_MODE`]: from a tool of selection mode, choose the drawing tool chosen last (none yet: /// [`FIRST_DRAWING_TOOL`]); from any other tool, keep it as the drawing tool and choose the -/// Selection tool. → `{tool}`, the tool now active. -pub(crate) fn toggle_mode(app: &mut crate::VectorcraftApp) -> serde_json::Value { +/// Selection tool. → `{tool}`, the tool now active. A switch that fails returns its error and +/// leaves the drawing tool to return to as it was. +pub(crate) fn toggle_mode(app: &mut crate::VectorcraftApp) -> Result { let now = app.session.tool_id().to_string(); - let next = if selects(&now) { - app.ui.touch_drawing_tool.clone().unwrap_or_else(|| FIRST_DRAWING_TOOL.to_string()) + let (next, outgoing) = if selects(&now) { + (app.ui.touch_drawing_tool.clone().unwrap_or_else(|| FIRST_DRAWING_TOOL.to_string()), None) } else { - if is_drawing_tool(&now) { - app.ui.touch_drawing_tool = Some(now); - } - "selection".to_string() + ("selection".to_string(), is_drawing_tool(&now).then_some(now)) }; - app.select_tool(&next); - serde_json::json!({"tool": app.session.tool_id()}) + app.try_select_tool(&next)?; + if let Some(tool) = outgoing { + app.ui.touch_drawing_tool = Some(tool); + } + Ok(serde_json::json!({"tool": app.session.tool_id()})) } #[cfg(test)] diff --git a/docs/mcp.md b/docs/mcp.md index 6800d7d7e5..b7c0584968 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -5735,7 +5735,10 @@ desktop app) instead and undoes nothing ([the help page](https://helpx.adobe.com From the Selection, Direct Selection, Group Selection, Magic Wand, Lasso or Perspective Selection tool it chooses the drawing tool chosen last in the window, or the Pencil tool when none has been chosen yet; from any other tool it chooses the Selection tool, and the tool left becomes the drawing tool unless it is the Hand, Rotate View, Zoom or Print -Tiling tool. It returns `{tool}` and adds no undo step. Pencil as the first drawing tool and the list of selection tools +Tiling tool. It returns `{tool}` and adds no undo step. When the tool cannot be chosen it returns the error, the tool +and the drawing tool stay as they were, and it adds no undo step; `tool.select`, `ui.cropImage`, +`addon.pathtools.cornerTool` and `addon.pathtools.sharedEdgeTool` also return the error when their tool cannot be +chosen. Pencil as the first drawing tool and the list of selection tools are VectorCraft's own rules. A tap in Presentation Mode runs nothing. `gridlineEvery` (72 pt by default) and `gridSubdivisions` (8 by default) set the document grid that View › Show Grid diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index c50a45b639..0ba0a72c9b 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1188,6 +1188,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur A two-finger rotation on a Mac trackpad turns the view about the pointer once it reaches 5° (Preferences › General › Trackpad Gesture to Rotate View, on by default). On a touch screen a second finger cancels the tool press the first finger began, in the frame it lands or later: the Pencil's stroke or a Selection move is rolled back with no undo entry, and a finger that lands while another is down presses nothing, so a pinch or two-finger pan only zooms and pans (#4198; canvas test `a_second_finger_cancels_the_tool_gesture_the_first_began`). In the Touch workspace a two-finger tap switches between the Selection tool and the drawing tool chosen last (the Pencil tool when none has been chosen yet) and undoes nothing; outside Touch it still undoes, and a three-finger tap still redoes ([the help page](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/touch-workspace-in-illustrator.html); `tool.toggleTouchMode`; canvas test `two_finger_tap_in_touch_switches_selection_and_drawing_modes`). + When the tool cannot be chosen, `tool.toggleTouchMode` returns the error instead of `{tool}`, keeps the drawing tool it returns to, and adds no undo step; `tool.select`, `ui.cropImage` and the Path Precision Tools' Corner Tool and Shared Edge Merge Tool commands also return the error, and the toolbar group keeps its tool (canvas tests `a_failed_mode_switch_returns_its_error` and `tool_commands_return_a_failed_choice`). A tool press dropped by a second finger, a long touch or a canceled touch cancels the tool's drag as Escape does: the tool gets back the options it had when the press began (the Polygon tool's sides, set with ↑ and ↓) and they are not stored, a press held still opens no size dialog, a Selection or Artboard tool marquee selects nothing, and the Pen goes on drawing its path without the dropped anchor (canvas tests `a_canceled_touch_drops_the_drag_without_keeping_its_options` and `long_touch_drops_a_tool_press_without_committing_art`; engine tests in `tests::toolsettings`). The status bar navigator's field shows the active artboard's number and name, and its drop-down lists every artboard by number and name, as the Artboards panel does. Choosing an artboard in the list makes it the active artboard and fits it in the window (`view.goToArtboard`). The list opens on the active artboard's row and lays out only the rows in view and at most one more. - **Geometry and effects:**