From b7644d31f2f99dad4f22efa05f048979c8913f1d Mon Sep 17 00:00:00 2001 From: imachus <51533227+imachus@users.noreply.github.com> Date: Thu, 8 Oct 2026 23:54:22 +0900 Subject: [PATCH 01/22] Fix #433: open only file URLs handed to the app (macOS 27 turns an https URL into a path) `application:openURLs:` can pass URLs that aren't files, and on macOS 27 `to_file_path()` returns the path of an https URL ("/a.svg"), so it was queued as a document. Keep the file URLs (`isFileURL`) before converting; `opened_files_wait_for_the_ui` passes again on macOS 27. Co-Authored-By: Claude Opus 5.5 --- apps/vectorcraft/src/open_documents.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/apps/vectorcraft/src/open_documents.rs b/apps/vectorcraft/src/open_documents.rs index b949e9ca..67f409b0 100644 --- a/apps/vectorcraft/src/open_documents.rs +++ b/apps/vectorcraft/src/open_documents.rs @@ -78,7 +78,8 @@ fn add_open_urls_method() { /// Queue the files among `urls` and wake the UI. Never panics: it runs inside AppKit. extern "C-unwind" fn open_urls(_delegate: &AnyObject, _cmd: Sel, _app: &AnyObject, urls: &NSArray) { - let paths = urls.iter().filter_map(|u| u.to_file_path()).map(|p| p.to_string_lossy().into_owned()); + // Only file URLs: macOS 27 turns an https URL's path into a file path too (#433). + let paths = urls.iter().filter(|u| u.isFileURL()).filter_map(|u| u.to_file_path()).map(|p| p.to_string_lossy().into_owned()); PENDING.lock().unwrap_or_else(PoisonError::into_inner).extend(paths); if let Some(ctx) = UI.get() { ctx.request_repaint(); From e6a3b37bed52be984e363b345c296b657263b849 Mon Sep 17 00:00:00 2001 From: Fry Date: Thu, 8 Oct 2026 10:57:01 -0400 Subject: [PATCH 02/22] UI: right-click a ruler to swap the document units MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A right-click on either ruler (or the origin box) now opens a context menu listing the ten document units, the current one checked. Choosing one runs document.setUnits — the same one-undo-step change as Preferences ▸ Units ▸ General / Document Setup. The guide-drag interact on each ruler becomes click-and-drag so the same widget both drags out guides (left) and opens the unit menu (right); the origin box gets its own click interact. checked() reports the active unit so the menu shows the check-mark; the unit labels are already translated as the Units preference choices. Co-Authored-By: Claude Opus 4.8 (1M context) --- crates/ui-egui/src/canvas.rs | 14 +++++++++++-- crates/ui-egui/src/menus.rs | 19 ++++++++++++++++++ crates/ui-egui/src/tests_contextmenu.rs | 26 +++++++++++++++++++++++++ 3 files changed, 57 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index d377f4a3..3800b615 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -891,9 +891,14 @@ fn ruler_rects(full: egui::Rect) -> [egui::Rect; 3] { /// ruler, snapped as a moved guide is (with Shift to the ruler's ticks). Released anywhere else, /// it makes none. fn ruler_guides(app: &mut VectorcraftApp, ui: &Ui, full: egui::Rect, canvas: egui::Rect, xf: &Xf) { - let [top, left, _] = ruler_rects(full); + let [top, left, corner] = ruler_rects(full); + // Right-click on a ruler or the origin box: the document units, to swap between them as + // Preferences ▸ Units ▸ General does ([`crate::menus::ruler_menu_body`]). + let mut unit_clicked = None; for (r, vertical, id) in [(top, false, "ruler-top"), (left, true, "ruler-left")] { - let resp = ui.interact(r, egui::Id::new(id), Sense::drag()); + // Click-and-drag so the same widget drags out guides (left) and opens the unit menu (right). + let resp = ui.interact(r, egui::Id::new(id), Sense::click_and_drag()); + resp.context_menu(|ui| crate::menus::ruler_menu_body(app, ui, &mut unit_clicked)); let kind = if resp.drag_stopped() { PointerKind::Up } else if resp.dragged() { @@ -912,6 +917,11 @@ fn ruler_guides(app: &mut VectorcraftApp, ui: &Ui, full: egui::Rect, canvas: egu app.status(e.to_string()); } } + let corner = ui.interact(corner, egui::Id::new("ruler-corner"), Sense::click()); + corner.context_menu(|ui| crate::menus::ruler_menu_body(app, ui, &mut unit_clicked)); + if let Some((id, p)) = unit_clicked { + crate::menus::invoke(app, &id, p); + } } fn rulers(ui: &Ui, full: egui::Rect, xf: &Xf, hover: Option, unit: Unit, t: &Tokens) { diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index f409d949..e5953ab7 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -1388,6 +1388,10 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option { let cmyk = app.session.active().is_some_and(|d| d.doc.color_mode == vectorcraft_engine::doc::ColorMode::Cmyk); p.get("mode").and_then(Value::as_str) == Some(if cmyk { "cmyk" } else { "rgb" }) } + // The ruler context menu lists the document units, the current one checked. + "document.setUnits" => { + p.get("units").and_then(Value::as_str).and_then(vectorcraft_engine::doc::Unit::named) == Some(app.session.general_unit()) + } _ => return None, }) } @@ -2559,6 +2563,21 @@ pub fn context_menu_body(app: &VectorcraftApp, ui: &mut egui::Ui, clicked: &mut }); } +/// The document units a right-click on a ruler offers: each runs `document.setUnits`, exactly as +/// Preferences ▸ Units ▸ General does, with the current one checked ([`checked`]). +pub fn ruler_unit_items() -> Vec { + vectorcraft_engine::doc::Unit::ALL.iter().map(|u| cp(u.label(), "document.setUnits", json!({ "units": u.label() }))).collect() +} + +/// The ruler context menu's popup (right-click a ruler or the origin box); the unit clicked goes in +/// `clicked`, for [`invoke`]. +pub fn ruler_menu_body(app: &VectorcraftApp, ui: &mut egui::Ui, clicked: &mut Option<(String, Value)>) { + widgets::menu_scroll(ui, |ui| { + ui.set_min_width(160.0); + render_items(app, ui, &ruler_unit_items(), true, clicked); + }); +} + /// Render the menu bar. /// The in-window menu bar. Returns where its titles end (x): the bar itself takes the full width. pub fn menu_bar(app: &mut VectorcraftApp, ui: &mut egui::Ui) -> f32 { diff --git a/crates/ui-egui/src/tests_contextmenu.rs b/crates/ui-egui/src/tests_contextmenu.rs index 893583f5..7cc7dc1c 100644 --- a/crates/ui-egui/src/tests_contextmenu.rs +++ b/crates/ui-egui/src/tests_contextmenu.rs @@ -110,6 +110,32 @@ fn right_click_on_empty_canvas_offers_the_view_and_a_dismissing_click_does_nothi assert_eq!(app.session.active().unwrap().doc.art_bounds(), None); } +/// #: right-clicking a ruler offers the document units, the current one checked, and choosing one +/// swaps them — the same effect as Preferences ▸ Units ▸ General (`document.setUnits`). +#[test] +fn right_clicking_a_ruler_swaps_the_document_units() { + use vectorcraft_doc::Unit; + let mut app = app(); + app.ui.view.rulers = true; + let ctx = egui::Context::default(); + frame(&mut app, &ctx, vec![]); + assert_eq!(app.session.general_unit(), Unit::Points, "a new document starts in the prefs unit"); + // Right-click on the top ruler (the band along the top, past the origin box). + let texts = click(&mut app, &ctx, pos2(400.0, 8.0), PointerButton::Secondary); + for label in ["Points", "Picas", "Inches", "Millimeters", "Feet & Inches", "Pixels"] { + assert!(has(&texts, label), "{label} in {texts:?}"); + } + assert!(texts.iter().any(|(t, _)| t == "✓ Points"), "the current unit is checked: {texts:?}"); + // Choosing a unit runs document.setUnits and closes the menu. + let mm = texts.iter().find(|(t, _)| t.trim_start_matches(['✓', ' ']) == "Millimeters").map(|(_, r)| r.center()).expect("Millimeters"); + let texts = click(&mut app, &ctx, mm, PointerButton::Primary); + assert_eq!(app.session.general_unit(), Unit::Millimeters, "the ruler's unit changed"); + assert!(!has(&texts, "Inches"), "the menu closed"); + // The left ruler offers the same menu, now checking the new unit. + let texts = click(&mut app, &ctx, pos2(8.0, 300.0), PointerButton::Secondary); + assert!(texts.iter().any(|(t, _)| t == "✓ Millimeters"), "the left ruler reflects the current unit: {texts:?}"); +} + fn labels(items: &[Item]) -> Vec<&'static str> { items .iter() From fba610284cc7a9d125e76202ae18cd2a90777c5e Mon Sep 17 00:00:00 2001 From: imachus <51533227+imachus@users.noreply.github.com> Date: Fri, 9 Oct 2026 00:08:03 +0900 Subject: [PATCH 03/22] Type (#432): new type in a Japanese interface starts top-to-top with em box centre alignment MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit As decided in #432 (option 2): while the interface is in Japanese, new type starts with em box top-to-top leading and em box centre character alignment; other languages keep the Roman baseline, so Latin area type doesn't move. - The UI tells the engine the language it is drawn in each frame (`Session::ui_language`); without a UI, an explicit `interfaceLanguage` preference counts (`Session::japanese_interface`). - `text.create` and `text.createInPath` (the Type tools' clicks and drags) apply it, and take `leadingModel` / `charAlign` to choose; the values used are journaled, so a replay does the same in any language. - `paraStyle.new` / `charStyle.new` made from nothing (no `attrs`, no text selected) carry them. - Imported text (PDF, SVG, DXF…) keeps the Roman baseline. Saved documents keep what they say. - docs/mcp.md (New type in a Japanese interface) and the ROADMAP note it. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 2 +- crates/engine/src/cmd/create.rs | 37 +++++++++++++++- crates/engine/src/cmd/textedit.rs | 3 +- crates/engine/src/cmd/textstyles.rs | 29 ++++++++++++- crates/engine/src/cmd/typecmd.rs | 67 +++++++++++++++++++++++++++++ crates/engine/src/lib.rs | 11 +++++ crates/ui-egui/src/i18n/tests.rs | 18 ++++++++ crates/ui-egui/src/lib.rs | 7 ++- docs/mcp.md | 13 ++++++ 9 files changed, 182 insertions(+), 5 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 3a7ec9da..7fac486c 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -136,7 +136,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected. With anchors selected, the Control bar and the Properties panel also convert them to corner or smooth (`path.convertAnchors`), connect end points (Join) and cut the path at them (`path.cutAtAnchors`, also on the task bar and the context menu): a closed path opens there and an open one becomes one path per piece, each cut leaving one of its two coincident anchors selected so a drag pulls the path apart. - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups; several loose objects are grouped first, in one undo step), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters). - **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. The Selection tool shows the type widget beside selected type's bounding box (hollow on point type, filled on area type); double-clicking it converts between them (Type › Convert To Area Type / Convert To Point Type), keeping the text and its styles in place. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text. Font Size and Leading are combo boxes in the Character and Properties panels (Font Size in the Control bar too, beside the Character link, font family and style): type, step with ↑/↓ or the spinner, scrub the label, or pick a preset (6–72 pt, shown in the type unit; Leading also Auto), each pick one undo step; Kerning and Tracking list -100…200; a size, leading, kerning or tracking the selected text doesn't share shows blank (#458). -- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish also translates status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines. +- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish also translates status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline (new type in a Japanese interface starts top to top, with em box centre character alignment, #432); Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines. - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `` and PDF soft masks. - **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets; with an image selected the Control bar and the Properties panel show Image Trace, whose arrow traces with any preset, Mask (`object.maskImage`: a clipping path on the image's outline, selected so its handles crop), Crop Image and Embed or Unembed in place of Fill and Stroke; with an Image Trace object selected, its Preset (choosing another traces again), the Image Trace panel and Expand, plus Release in Properties; the View modes are not done), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror). - **Paint and appearance (M3):** diff --git a/crates/engine/src/cmd/create.rs b/crates/engine/src/cmd/create.rs index 0c2b4042..ab72da2a 100644 --- a/crates/engine/src/cmd/create.rs +++ b/crates/engine/src/cmd/create.rs @@ -50,7 +50,7 @@ pub fn specs() -> Vec { "Create Text", [], None, - "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}, placeholder?: bool (fill it with placeholder text instead, as the Type tools do with prefs placeholderText)} → {id}", + "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}, placeholder?: bool (fill it with placeholder text instead, as the Type tools do with prefs placeholderText), leadingModel?: \"romanBaseline\"|\"emBoxTop\", charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\" (default: emBoxTop and emBoxCenter while the interface is in Japanese, else romanBaseline)} → {id}", has_doc, text_create ), @@ -409,6 +409,7 @@ fn text_create(s: &mut Session, p: &Value) -> Result { let mut t = TextObject::point(Point::new(x, y), text, new_type_style(s, p)); t.vertical = p.get("vertical").and_then(Value::as_bool).unwrap_or(false); t.para = new_type_para(); + new_type_alignment(s, p, "text.create", &mut t)?; if let Some(a) = p.get("area") { let w = f64_or(a, "width", 200.0); let h = f64_or(a, "height", 100.0); @@ -435,6 +436,40 @@ pub(crate) fn new_type_para() -> vectorcraft_doc::ParaStyle { } } +/// The leading model and character alignment new type starts with (`t`'s paragraph and runs): +/// `leadingModel` and `charAlign` from `p`, else em box top to top and em box centre while the +/// interface is in Japanese (#432), else the Roman baseline for both. Noted in the journal, so a +/// replay sets the same whatever the interface. +pub(crate) fn new_type_alignment(s: &mut Session, p: &Value, cmd: &str, t: &mut TextObject) -> Result<()> { + use vectorcraft_doc::{CharAlign, LeadingModel}; + let japanese = s.japanese_interface(); + let leading = match p.get("leadingModel").filter(|v| !v.is_null()) { + Some(v) => match v.as_str() { + Some("romanBaseline") => LeadingModel::RomanBaseline, + Some("emBoxTop") => LeadingModel::EmBoxTop, + _ => return Err(bad(cmd, "`leadingModel` must be \"romanBaseline\" or \"emBoxTop\"")), + }, + None => { + let l = if japanese { LeadingModel::EmBoxTop } else { LeadingModel::RomanBaseline }; + s.note_journal("leadingModel", json!(l)); + l + } + }; + let align = match super::textedit::char_align_param(p, cmd)? { + Some(a) => a, + None => { + let a = if japanese { CharAlign::EmBoxCenter } else { CharAlign::RomanBaseline }; + s.note_journal("charAlign", json!(a)); + a + } + }; + t.para.leading_model = leading; + for r in &mut t.runs { + r.style.char_align = align; + } + Ok(()) +} + /// The character style new type gets: `size`, `font`, `style` and `color` from `p`, else the /// defaults, filled with the current fill unless that is None or white (black then). pub(crate) fn new_type_style(s: &Session, p: &Value) -> CharStyle { diff --git a/crates/engine/src/cmd/textedit.rs b/crates/engine/src/cmd/textedit.rs index 6bc50072..9ae8d384 100644 --- a/crates/engine/src/cmd/textedit.rs +++ b/crates/engine/src/cmd/textedit.rs @@ -45,7 +45,7 @@ pub fn specs() -> Vec { "Area / Path Type", [], None, - "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?, placeholder?: bool (placeholder text instead, as text.create)} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}", + "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?, placeholder?: bool (placeholder text instead, as text.create), leadingModel?, charAlign? (as text.create)} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}", has_doc, create_in_path ), @@ -471,6 +471,7 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result { cached_bounds: None, cached_baselines: Vec::new(), }; + super::create::new_type_alignment(s, p, C, &mut t)?; if bool_or(p, "placeholder", false) { super::typemenu::fill_with_placeholder(&mut t); } else { diff --git a/crates/engine/src/cmd/textstyles.rs b/crates/engine/src/cmd/textstyles.rs index f11204a8..f8e58db8 100644 --- a/crates/engine/src/cmd/textstyles.rs +++ b/crates/engine/src/cmd/textstyles.rs @@ -261,6 +261,26 @@ fn attrs_param(p: &Value, kind: Kind, verb: &str) -> Result Map { + if !s.japanese_interface() { + return Map::new(); + } + let (set, default) = match kind { + Kind::Char => { + let st = CharStyle { char_align: vectorcraft_doc::CharAlign::EmBoxCenter, ..CharStyle::default() }; + (to_attrs(&st), to_attrs(&CharStyle::default())) + } + Kind::Para => { + let st = ParaStyle { leading_model: vectorcraft_doc::LeadingModel::EmBoxTop, ..ParaStyle::default() }; + (to_attrs(&st), to_attrs(&ParaStyle::default())) + } + }; + set.into_iter().filter(|(k, v)| default.get(k) != Some(v)).collect() +} + // ---------- commands ---------- fn list(s: &mut Session, kind: Kind) -> Result { @@ -275,7 +295,14 @@ fn new(s: &mut Session, p: &Value, kind: Kind) -> Result { let c = kind.cmd("new"); let attrs = match attrs_param(p, kind, "new")? { Some(a) => a, - None => selection_attrs(s, p, kind)?.unwrap_or_default(), + None => match selection_attrs(s, p, kind)? { + Some(a) => a, + None => { + let a = new_style_attrs(s, kind); + s.note_journal("attrs", Value::Object(a.clone())); + a + } + }, }; let d = &s.doc()?.doc; let base = if kind == Kind::Char { "Character Style" } else { "Paragraph Style" }; diff --git a/crates/engine/src/cmd/typecmd.rs b/crates/engine/src/cmd/typecmd.rs index 4cd3b4e8..7c830ff7 100644 --- a/crates/engine/src/cmd/typecmd.rs +++ b/crates/engine/src/cmd/typecmd.rs @@ -444,6 +444,73 @@ mod area_tests { assert_eq!(old.burasagari, Burasagari::None); } + /// #432: while the interface is in Japanese, new type (text.create, text.createInPath) starts + /// with em box top-to-top leading and em box centre alignment, and new styles made from nothing + /// carry them; params override; the values are journaled; imported text keeps the Roman + /// baseline. + #[test] + fn new_type_takes_the_japanese_defaults_while_the_interface_is_japanese() { + use vectorcraft_doc::{CharAlign, LeadingModel}; + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap(); + let made = |s: &mut Session, cmd: &str, p: Value| -> (LeadingModel, CharAlign) { + let id = s.execute(cmd, &p).unwrap()["id"].as_u64().unwrap(); + match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind { + NodeKind::Text(t) => (t.para.leading_model, t.runs[0].style.char_align), + _ => panic!("text"), + } + }; + let roman = (LeadingModel::RomanBaseline, CharAlign::RomanBaseline); + let japanese = (LeadingModel::EmBoxTop, CharAlign::EmBoxCenter); + let point = json!({"x": 10, "y": 50, "text": "雅楽"}); + assert!(!s.japanese_interface()); + assert_eq!(made(&mut s, "text.create", point.clone()), roman, "headless, `auto`: the Roman defaults"); + s.ui_language = Some("ja".into()); + assert_eq!(made(&mut s, "text.create", point.clone()), japanese); + assert_eq!(made(&mut s, "text.create", json!({"x": 10, "y": 90, "text": "笙", "area": {"width": 100, "height": 50}})), japanese); + // Journaled: a replay in another language does the same. + let (_, logged) = s.journal.last().unwrap().clone(); + assert_eq!((logged["leadingModel"].as_str(), logged["charAlign"].as_str()), (Some("emBoxTop"), Some("emBoxCenter"))); + // Params override. + assert_eq!( + made(&mut s, "text.create", json!({"x": 10, "y": 120, "text": "a", "leadingModel": "romanBaseline", "charAlign": "romanBaseline"})), + roman + ); + assert!(s.execute("text.create", &json!({"x": 0, "y": 0, "text": "a", "leadingModel": "middle"})).is_err()); + // Area type in a path. + let path = s.execute("shape.rectangle", &json!({"x": 200, "y": 200, "width": 100, "height": 80})).unwrap()["id"].clone(); + assert_eq!(made(&mut s, "text.createInPath", json!({"path": path, "mode": "area", "text": "篳篥"})), japanese); + // A preference set to Japanese counts without a UI; another language doesn't. + s.ui_language = None; + s.prefs.interface_language = "ja".into(); + assert_eq!(made(&mut s, "text.create", point.clone()), japanese); + s.ui_language = Some("en".into()); + assert_eq!(made(&mut s, "text.create", point.clone()), roman); + // New styles made from nothing. + s.execute("select.set", &json!({"ids": []})).unwrap(); + s.ui_language = Some("ja".into()); + let style = |s: &mut Session, kind: &str| { + let name = s.execute(&format!("{kind}.new"), &json!({})).unwrap()["name"].as_str().unwrap().to_string(); + let list = s.execute(&format!("{kind}.list"), &json!({})).unwrap(); + list["styles"].as_array().unwrap().iter().find(|st| st["name"] == name.as_str()).unwrap()["attrs"].clone() + }; + assert_eq!(style(&mut s, "paraStyle"), json!({"leading_model": "emBoxTop"})); + assert_eq!(style(&mut s, "charStyle"), json!({"charAlign": "emBoxCenter"})); + s.ui_language = Some("en".into()); + assert_eq!(style(&mut s, "paraStyle"), json!({})); + // Imported text keeps the Roman baseline. + s.ui_language = Some("ja".into()); + let svg = r#"雅楽"#; + s.execute("document.open", &json!({"name": "t.svg", "dataBase64": vectorcraft_format::base64_encode(svg.as_bytes())})).unwrap(); + let mut found = vec![]; + s.doc().unwrap().doc.walk(|n| { + if let NodeKind::Text(t) = &n.kind { + found.push((t.para.leading_model, t.runs[0].style.char_align)); + } + }); + assert_eq!(found, [roman]); + } + #[test] fn leading_model_is_set_per_paragraph_and_saved_only_when_top_to_top() { use vectorcraft_doc::LeadingModel; diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 453b9b1d..5e549773 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -754,6 +754,10 @@ pub struct Session { pub style_libraries: cmd::stylelib::Libraries, /// URLs recently given in the Attributes panel (`attributes.set {url}`), newest first; not saved. pub recent_urls: Vec, + /// The language the UI is drawn in (a language code, never `auto`), set by the UI each frame; + /// `None` without one (headless), where an explicit `interfaceLanguage` preference counts. + /// Japanese gives new type the Japanese defaults ([`Session::japanese_interface`]). + pub ui_language: Option, /// Parameters the running top-level command resolved from the preferences or the clock, added /// to its journal entry so a replay does the same ([`Session::note_journal`]). journal_note: serde_json::Map, @@ -814,6 +818,7 @@ impl Session { freeform_point: None, style_libraries: Default::default(), recent_urls: vec![], + ui_language: None, journal_note: Default::default(), note_depth: 1, batch_stash: None, @@ -983,6 +988,12 @@ impl Session { Ok(r) } + /// Is the interface in Japanese? Then new type starts with em box top-to-top leading and em + /// box centre character alignment (#432). + pub fn japanese_interface(&self) -> bool { + self.ui_language.as_deref().unwrap_or(&self.prefs.interface_language).eq_ignore_ascii_case("ja") + } + /// Record `key: value` in the running top-level command's journal entry (or its interaction's /// preview, or its step in a batch) unless its params give `key`: a value it resolved from the /// preferences or the clock. diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs index 0184b4d2..1cee8751 100644 --- a/crates/ui-egui/src/i18n/tests.rs +++ b/crates/ui-egui/src/i18n/tests.rs @@ -167,6 +167,24 @@ fn partial_catalogs_only_translate_strings_the_ui_shows() { } } +/// The engine learns the language the UI is drawn in each frame: new type takes the Japanese +/// defaults while it is Japanese (#432). +#[test] +fn the_engine_follows_the_interface_language() { + let mut app = crate::VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default()); + let ctx = egui::Context::default(); + let frame = |app: &mut crate::VectorcraftApp| { + ctx.run_ui(egui::RawInput::default(), |ui| app.logic(ui.ctx())).textures_delta.clear(); + }; + frame(&mut app); + assert_eq!(app.session.ui_language.as_deref(), Some("en"), "tests resolve `auto` to English"); + assert!(!app.session.japanese_interface()); + app.session.prefs.interface_language = "ja".into(); + frame(&mut app); + assert_eq!(app.session.ui_language.as_deref(), Some("ja")); + assert!(app.session.japanese_interface()); +} + /// VectorCraft › Language (`app.language`) sets the `interfaceLanguage` preference, which is what /// persists; the checked item follows the preference, and a bad code is an error, not a change. #[test] diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 9e66a128..55225ba1 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -725,7 +725,12 @@ impl VectorcraftApp { } fn logic_frame(&mut self, ctx: &egui::Context) { - i18n::set_current(self.ui_language()); + let lang = self.ui_language(); + i18n::set_current(lang); + // The engine gives new type the Japanese defaults while the UI is in Japanese. + if self.session.ui_language.as_deref() != Some(lang.code()) { + self.session.ui_language = Some(lang.code().to_string()); + } self.adopt_context(ctx); if !self.styled { theme::install_fonts(ctx); diff --git a/docs/mcp.md b/docs/mcp.md index 4eac72a7..6d3455f2 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -2161,6 +2161,19 @@ undo step. {"name":"run_command","arguments":{"command":"text.setFormat","params":{"burasagari":"forced"}}} ``` +## New type in a Japanese interface + +While the interface is in Japanese (VectorCraft › Language, or `auto` on a Japanese system), new type starts with em +box top-to-top leading (`leadingModel: "emBoxTop"`) and em box centre character alignment (`charAlign: "emBoxCenter"`); +in other languages it starts on the Roman baseline (#432). This covers the Type tools, +`text.create` and `text.createInPath`, which also take `leadingModel` and `charAlign` to choose, and `paraStyle.new` / +`charStyle.new` made with no `attrs` and no text selected. The values used are kept in the journal, so a replay sets the +same in any language. Saved documents keep what they say, and imported text (PDF, SVG, DXF…) keeps the Roman baseline. + +```json +{"name":"run_command","arguments":{"command":"text.create","params":{"x":40,"y":60,"text":"雅楽","leadingModel":"emBoxTop","charAlign":"emBoxCenter"}}} +``` + ## Moving and flipping type on a path Type on a path flows between a start and an end bracket, stored as fractions of its path's length. From b5759662c1f353b98346bd91a8b749e5da7af54e Mon Sep 17 00:00:00 2001 From: David Panusch Date: Thu, 8 Oct 2026 17:38:18 +0200 Subject: [PATCH 04/22] Control bar: Transform link opens the Transform panel; reference point locator redrawn The Control bar's underlined Transform link opens the Transform panel as a popover under it (reference point, X/Y/W/H, Rotate and Shear with their icons and angle presets, flips, shape properties, Scale Corners, Scale Strokes & Effects), as the Stroke link does the Stroke panel. X/Y/W/H stay inline while the bar has room. The reference point locator is now nine squares with the outer eight joined around the box; the old outline was inset off the squares' centres. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 1 + crates/ui-egui/src/chrome.rs | 11 ++++++++-- crates/ui-egui/src/i18n/es.tsv | 1 + crates/ui-egui/src/i18n/ja.tsv | 1 + crates/ui-egui/src/i18n/pt-br.tsv | 1 + crates/ui-egui/src/i18n/zh-hans.tsv | 1 + crates/ui-egui/src/i18n/zh-hant.tsv | 1 + crates/ui-egui/src/panels/transform.rs | 17 +++++++++++++++- crates/ui-egui/src/tests_paintchips.rs | 28 ++++++++++++++++++++++++++ crates/ui-egui/src/widgets.rs | 21 +++++++++++-------- 10 files changed, 72 insertions(+), 11 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 3a7ec9da..3222b463 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -111,6 +111,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - Dialogs move by dragging their heading (the band down from the top edge, as a title bar), stay on screen and keep where they were moved for the session; the form dialogs' choices are dropdowns (Offset Path's Joins, Average's and Shear's and Reflect's axis), and Offset Path lists Offset, Joins, Miter Limit and previews (#423). - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels, the Control bar and dialogs (preferences too) step with Up/Down, or with the mouse wheel over the focused field (#485: a notch a step; the panel under it then stays put, and an unfocused field leaves the wheel to scrolling) (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once. - Scrubby labels (#400, beyond Illustrator, as in Photoshop): dragging a numeric field's label left or right (the ↔ cursor shows over it) steps the value one unit every 2 points (Shift: ten, Ctrl/Cmd: a tenth; counts stay whole), in the field's unit and within its limits, applied live as the art follows; the whole drag is one undo step and Escape puts the value back. A click on the label focuses the field; the text box itself never scrubs, and a field with no label doesn't. Text labels before a field (Transform, Properties, Control bar, Stroke, Transparency, form rows in dialogs) and the Character and Paragraph panels' icons act as labels. Preferences › General › Scrub Numeric Fields by Dragging (on by default) turns it off. + - The Control bar's underlined Transform link opens the Transform panel in a popover under it (reference point, X/Y/W/H, Rotate and Shear with their icons and angle presets, flips, shape properties, Scale Corners and Scale Strokes & Effects), as its Stroke link does the Stroke panel; X/Y/W/H also show inline while the bar has room. The reference point locator is nine squares, the outer eight joined around the box. - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields. - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected). - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one. diff --git a/crates/ui-egui/src/chrome.rs b/crates/ui-egui/src/chrome.rs index 45e28b34..20da2920 100644 --- a/crates/ui-egui/src/chrome.rs +++ b/crates/ui-egui/src/chrome.rs @@ -146,6 +146,9 @@ pub fn anchor_buttons(app: &mut VectorcraftApp, ui: &mut Ui) { } } +/// The room the Control bar's inline X/Y/W/H fields need; with less, only the Transform link shows. +const INLINE_TRANSFORM_WIDTH: f32 = 440.0; + /// The Control bar (Window → Control), context-sensitive like Illustrator's. pub fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) { let t = Tokens::get(ui.ctx()); @@ -252,9 +255,13 @@ pub fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) { } } ui.separator(); - // Transform fields. + // The Transform link opens the whole Transform panel (reference point, rotate, + // shear, options) in a popover; X/Y/W/H follow inline while the bar has room. + crate::panels::transform::link(app, ui); // The bounding box, rotated with rotated objects: its centre and its own sides. - if let Some(b) = app.selection_box() { + if let Some(b) = app.selection_box() + && ui.available_width() >= INLINE_TRANSFORM_WIDTH + { let c = b.center(); let link = app.session.prefs.constrain_proportions; for (k, lbl, v) in [("x", "X:", c.x), ("y", "Y:", c.y), ("width", "W:", b.rect.width()), ("height", "H:", b.rect.height())] { diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv index 1237ffff..3af7719a 100644 --- a/crates/ui-egui/src/i18n/es.tsv +++ b/crates/ui-egui/src/i18n/es.tsv @@ -2546,6 +2546,7 @@ Character: Carácter: Character options Opciones de carácter Stroke options Opciones de trazo + Transform options Opciones de transformación Stroke Weight Grosor de trazo Stroke: Trazo: Stroke: click for swatches, Shift-click for the color mixer Trazo: clic para muestras, Shift+clic para el mezclador de colores diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv index c3ecb5fd..1e8fc1bc 100644 --- a/crates/ui-egui/src/i18n/ja.tsv +++ b/crates/ui-egui/src/i18n/ja.tsv @@ -2352,6 +2352,7 @@ Character: 文字: Character options 文字オプション Stroke options 線オプション + Transform options 変形オプション Stroke: 線: Style スタイル Style Name: スタイル名: diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv index 0e47c699..596c41c3 100644 --- a/crates/ui-egui/src/i18n/pt-br.tsv +++ b/crates/ui-egui/src/i18n/pt-br.tsv @@ -2248,6 +2248,7 @@ Character: Caractere: Character options Opções de caractere Stroke options Opções de traçado + Transform options Opções de transformação Stroke: Traçado: Style Estilo Style Name: Nome do Estilo: diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv index 8c01b809..d1db2ad3 100644 --- a/crates/ui-egui/src/i18n/zh-hans.tsv +++ b/crates/ui-egui/src/i18n/zh-hans.tsv @@ -2484,6 +2484,7 @@ Character: 字符： Character options 字符选项 Stroke options 描边选项 + Transform options 变换选项 Stroke Weight 描边粗细 Stroke: 描边： Stroke: click for swatches, Shift-click for the color mixer 描边：单击开启色板，按住 Shift 单击开启混色器 diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv index 05467689..ea04b060 100644 --- a/crates/ui-egui/src/i18n/zh-hant.tsv +++ b/crates/ui-egui/src/i18n/zh-hant.tsv @@ -2566,6 +2566,7 @@ Character: 字元： Character options 字元選項 Stroke options 筆畫選項 + Transform options 變形選項 Stroke Weight 筆畫寬度 Stroke: 筆畫： Stroke: click for swatches, Shift-click for the color mixer 筆畫：按一下開啟色票，按住 Shift 按一下開啟混色器 diff --git a/crates/ui-egui/src/panels/transform.rs b/crates/ui-egui/src/panels/transform.rs index 003f5440..038b8560 100644 --- a/crates/ui-egui/src/panels/transform.rs +++ b/crates/ui-egui/src/panels/transform.rs @@ -13,6 +13,8 @@ use crate::widgets::{self, menu_item}; use crate::{VectorcraftApp, icons}; pub const ANGLE_PRESETS: [f64; 9] = [-180.0, -135.0, -90.0, -45.0, 0.0, 45.0, 90.0, 135.0, 180.0]; +/// The shear angle's presets: steep enough to be useful, short of the degenerate ±90°. +pub const SHEAR_PRESETS: [f64; 9] = [-60.0, -45.0, -30.0, -15.0, 0.0, 15.0, 30.0, 45.0, 60.0]; /// Proportional size: the other dimension when one changes with the link on. pub fn constrained(w: f64, h: f64, new_w: Option, new_h: Option) -> (f64, f64) { @@ -151,8 +153,10 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { ui.add_space(4.0); let icon = icons::icon(ui, "dc-shear", 16.0, t.icon).on_hover_text(tl!("Shear")); crate::scrub::note_label(ui, icon.rect); - if let Some(a) = widgets::plain_field(ui, "xfp-shear", 0.0, "°", 1, 56.0) + // Shear is relative: the field rests at 0° and a new value shears by it. + if let Some(a) = widgets::spin_plain(ui, "xfp-shear", 0.0, "°", 2, 96.0, 15.0, -89.0, &SHEAR_PRESETS) && a != 0.0 + && a.abs() < 90.0 { app.run("object.shear", json!({"angle": a, "axis": "horizontal", "origin": origin})).ok(); } @@ -209,6 +213,17 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { } } +/// The Control bar's underlined "Transform" link: a click toggles the Transform panel in a +/// popover under it, as the Stroke link does with the Stroke panel. +pub fn link(app: &mut VectorcraftApp, ui: &mut Ui) { + let t = Tokens::get(ui.ctx()); + let resp = ui.link(egui::RichText::new(tl!("Transform")).size(12.0).color(t.text).underline()).on_hover_text(tl!("Transform options")); + widgets::popover(&resp, resp.clicked(), |ui| { + ui.set_width(300.0); + show(app, ui); + }); +} + /// The link between W and H (Transform panel, Properties panel, Control bar): one toggle, the /// `constrainProportions` preference, which the size fields pass on as `proportional`. pub fn constrain_link(app: &mut VectorcraftApp, ui: &mut Ui) { diff --git a/crates/ui-egui/src/tests_paintchips.rs b/crates/ui-egui/src/tests_paintchips.rs index bcd15529..4ce5cf5b 100644 --- a/crates/ui-egui/src/tests_paintchips.rs +++ b/crates/ui-egui/src/tests_paintchips.rs @@ -242,3 +242,31 @@ fn the_window_menu_panel_keys() { app.ui.shortcut_overrides.clear(); shortcut_editor::sync(&app.ui); } + +/// Where `shapes` paint the text `s`. +fn text_rect(shapes: &[Shape], s: &str) -> Option { + shapes.iter().find_map(|sh| match sh { + Shape::Text(t) if t.galley.text() == s => Some(t.visual_bounding_rect()), + Shape::Vec(v) => text_rect(v, s), + _ => None, + }) +} + +#[test] +fn the_transform_link_opens_the_transform_panel() { + let mut app = app(); + app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap(); + let ctx = context(); + frame(&mut app, &ctx, vec![], Modifiers::NONE, control_bar); + let shapes = frame(&mut app, &ctx, vec![], Modifiers::NONE, control_bar); + let link = text_rect(&shapes, "Transform").expect("the Control bar shows the Transform link"); + assert!(text_rect(&shapes, "Scale Corners").is_none()); + click(&mut app, &ctx, link.center(), Modifiers::NONE, control_bar); + let shapes = frame(&mut app, &ctx, vec![], Modifiers::NONE, control_bar); + for s in ["Scale Corners", "Scale Strokes & Effects", "0°"] { + assert!(text_rect(&shapes, s).is_some(), "the popover shows {s}"); + } + // A click outside closes it. + click(&mut app, &ctx, Pos2::new(1300.0, 900.0), Modifiers::NONE, control_bar); + assert!(text_rect(&frame(&mut app, &ctx, vec![], Modifiers::NONE, control_bar), "Scale Corners").is_none()); +} diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs index 8c007656..a666281d 100644 --- a/crates/ui-egui/src/widgets.rs +++ b/crates/ui-egui/src/widgets.rs @@ -806,18 +806,23 @@ pub fn opacity_blend( edit } -/// The 3×3 reference point locator. Returns a new index when clicked. +/// The 3×3 reference point locator: nine squares, the eight outer ones joined by a line around +/// the box (the centre one stands alone), the current one filled. Returns a new index when clicked. pub fn reference_point(ui: &mut Ui, current: usize) -> Option { let t = Tokens::get(ui.ctx()); - let size = 22.0; + // 5 pt squares with 4 pt gaps; the origin is snapped to whole points so the 1 pt lines through + // the squares' centres stay crisp. + let (sq, step) = (5.0, 9.0); + let size = 2.0 * step + sq; let (rect, _) = ui.allocate_exact_size(Vec2::splat(size), Sense::hover()); + let o = rect.min.round(); + let centre = |i: usize| o + Vec2::new(sq / 2.0 + (i % 3) as f32 * step, sq / 2.0 + (i / 3) as f32 * step); + let line = Stroke::new(1.0, t.text_dim); + ui.painter().rect_stroke(Rect::from_two_pos(centre(0), centre(8)), 0.0, line, StrokeKind::Middle); let mut out = None; - let step = size / 2.0 - 2.5; - ui.painter().rect_stroke(rect.shrink(4.5), 0.0, Stroke::new(1.0, t.text_dim), StrokeKind::Middle); for i in 0..9 { - let c = Pos2::new(rect.left() + 3.0 + (i % 3) as f32 * step + 1.5, rect.top() + 3.0 + (i / 3) as f32 * step + 1.5); - let r = Rect::from_center_size(c, Vec2::splat(5.0)); - let resp = ui.interact(r.expand(1.5), ui.id().with(("refpt", i)), Sense::click()); + let r = Rect::from_center_size(centre(i), Vec2::splat(sq)); + let resp = ui.interact(r.expand(2.0), ui.id().with(("refpt", i)), Sense::click()); if resp.clicked() { out = Some(i); } @@ -825,7 +830,7 @@ pub fn reference_point(ui: &mut Ui, current: usize) -> Option { ui.painter().rect_filled(r, 0.0, t.text); } else { ui.painter().rect_filled(r, 0.0, t.panel); - ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.text_dim), StrokeKind::Inside); + ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, if resp.hovered() { t.text } else { t.text_dim }), StrokeKind::Inside); } } out From 7c7ae5562519f4eea91b8ecdeac976b93350d89e Mon Sep 17 00:00:00 2001 From: callmeBalloch Date: Thu, 8 Oct 2026 14:01:08 +0000 Subject: [PATCH 05/22] i18n: Italian interface (it) Adds an Italian catalog (crates/ui-egui/src/i18n/it.tsv, 3,549 rows in es.tsv's order) covering every menu string, every tl! literal, the plurals and every status/error message, at the same scope as Spanish. Standard Italian in sentence case, written clean-room from the meaning of the English labels; the product, workspace, perspective preset and language names stay in English as in es and ja. Registered as "Italiano" with the one/other plural rule and complete_menus; every it-* locale resolves to it. Tests: it joins KEEPS_MENU_NAMES and COMPLETE_MESSAGES, italian_reads_as_italian checks vocabulary and plurals, tags_map_to_languages the locale tags, and the bundled-font glyph test covers Italian accents and guillemets. README, ROADMAP and docs/development.md list the language. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011iayep93edeimiAE8oSfaT --- README.md | 2 +- ROADMAP.md | 4 +- crates/ui-egui/src/i18n/it.tsv | 3575 ++++++++++++++++++++++++++++++ crates/ui-egui/src/i18n/mod.rs | 12 +- crates/ui-egui/src/i18n/tests.rs | 44 +- docs/development.md | 7 +- 6 files changed, 3630 insertions(+), 14 deletions(-) create mode 100644 crates/ui-egui/src/i18n/it.tsv diff --git a/README.md b/README.md index e79c9aca..1f87e190 100644 --- a/README.md +++ b/README.md @@ -194,7 +194,7 @@ milestones, and honest time-to-parity estimates. "a power user can't tell the difference". Everyday vector illustration is close to usable: drawing and path tools, Pathfinder and Shape Builder, paint, gradients, appearance and transparency, type with styles, threading and Hebrew/Arabic bidirectional layout, and files (SVG, PDF and PDF-compatible `.ai` with PDF/X, EPS, DXF, EMF/WMF, raster formats and PSD, Print, Package). The interface -speaks English, Japanese, Traditional and Simplified Chinese and Spanish (and Czech and Brazilian Portuguese in the menus). +speaks English, Japanese, Traditional and Simplified Chinese, Spanish and Italian (and Czech and Brazilian Portuguese in the menus). The scores are self-assessed, so the [honest assessment](ROADMAP.md#honest-assessment-2026-10-05) explains how far to trust them. diff --git a/ROADMAP.md b/ROADMAP.md index d6434cac..a03970f8 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -101,7 +101,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - Tool flyouts tear off: dragging or clicking the tear-off bar on a flyout's right side (or releasing the long press over it) floats its group as a strip of tool buttons, moved by the same bar and put back in the toolbar by the × at its top (`window.floatTools`). While a group floats, the presses that would open its flyout raise the strip instead. Floating strips are kept with the preferences and in user workspaces. Not done: turning a strip vertical, docking it. - Panels undock (#495): a dock tab, a panel icon or a popped-out panel's title dragged out of the dock floats that panel inside the window, and the strip right of the dock's tabs floats the whole tabbed group. A floating group moves by its title bar, a tab dragged out of it floats on its own, and dropped on another group's title bar or tabs it stacks with that group; dropped on the dock, which lights up under the pointer, its panels go back where they live (the tabbed group or the icon column), as its × and the panel menus' Float Panel / Dock Panel do (`window.panel.float`, `window.panel.dock`). The Tools panel floats by its title bar and docks again on the window's left edge. Floating panels and the Tools panel's position are kept with the preferences and in user workspaces, and clamped into a smaller window. Not done: panels in separate OS windows, docking a panel into a dock group it doesn't belong to, reordering tabs by dragging, collapsing a floating group to icons, resizing floating panels. - The dock's double arrow collapses Properties, Layers and Libraries to icons at the top of the icon column, popping out like the other icon panels, and expands them again (`window.collapseDock`, kept with the preferences and in saved workspaces). The icon column's own arrow (expanding the icon panels into a full column) is not done. - - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese and Spanish ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows, Linux and the web (the browser's languages, or `?lang=`), a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins). + - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese, Spanish and Italian ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows, Linux and the web (the browser's languages, or `?lang=`), a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins). - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool. - macOS: Finder opens every format File › Open reads with VectorCraft (double-click, Open With, a drop on the Dock icon, `open -a`), at launch or while it runs; the release and `cargo xtask bundle` apps share one `Info.plist` that declares those document types, owning only VectorCraft's own formats. The DMG opens on a designed Finder window, VectorCraft.app beside the `Applications` link over a background with the app icon (#493). - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, Remove Anchor Points when anchors are selected, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas. @@ -137,7 +137,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected. With anchors selected, the Control bar and the Properties panel also convert them to corner or smooth (`path.convertAnchors`), connect end points (Join) and cut the path at them (`path.cutAtAnchors`, also on the task bar and the context menu): a closed path opens there and an open one becomes one path per piece, each cut leaving one of its two coincident anchors selected so a drag pulls the path apart. - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups; several loose objects are grouped first, in one undo step), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters). - **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. The Selection tool shows the type widget beside selected type's bounding box (hollow on point type, filled on area type); double-clicking it converts between them (Type › Convert To Area Type / Convert To Point Type), keeping the text and its styles in place. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text. Font Size and Leading are combo boxes in the Character and Properties panels (Font Size in the Control bar too, beside the Character link, font family and style): type, step with ↑/↓ or the spinner, scrub the label, or pick a preset (6–72 pt, shown in the type unit; Leading also Auto), each pick one undo step; Kerning and Tracking list -100…200; a size, leading, kerning or tracking the selected text doesn't share shows blank (#458). -- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish also translates status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines. +- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese, Spanish (neutral international Spanish, for every `es-*` locale) and Italian (every `it-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish and Italian also translate status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech, Spanish and Italian ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines. - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `` and PDF soft masks. - **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets; with an image selected the Control bar and the Properties panel show Image Trace, whose arrow traces with any preset, Mask (`object.maskImage`: a clipping path on the image's outline, selected so its handles crop), Crop Image and Embed or Unembed in place of Fill and Stroke; with an Image Trace object selected, its Preset (choosing another traces again), the Image Trace panel and Expand, plus Release in Properties; the View modes are not done), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror). - **Paint and appearance (M3):** diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv new file mode 100644 index 00000000..b3c9d5a4 --- /dev/null +++ b/crates/ui-egui/src/i18n/it.tsv @@ -0,0 +1,3575 @@ +# Italian (it) catalog. Same format as zh-hant.tsv: context source translation +# (empty context = a plain UI string; `@id` = a command id; `@plural` = "one|other" forms). +# +# Clean-room: written from the meaning of VectorCraft's English labels in standard Italian, using the +# feature names Italian users of vector illustration software know (Tavola da disegno, Campioni, Traccia, +# Riempimento, Tracciato, Punto di ancoraggio, Penna, Selezione diretta, Elaborazione tracciati, Motivo, +# Preset). No other application's Italian localisation was copied. Labels use sentence case (only the +# first word capitalised); commands use the imperative (Apri, Salva, Mostra) and sentences address the +# user as "tu". Shortcut keys keep their key-cap names (Shift, Alt, Ctrl, Esc). +# +# Coverage: the whole interface — every menu string and every `tl!` literal (`complete_menus`, +# tested). Left in English on purpose (`MENU_KEEP_AS_IS` in the tests): the product name, language +# names, OpenType, the built-in workspace names and the bracketed perspective grid preset names. +# Status and error messages too (`@msg` rows at the end, `COMPLETE_MESSAGES` in the tests). +# A native speaker's review is welcome: keep the placeholders ({name}), the trailing "…" and the +# leading/trailing spaces of fragments exactly as they are. + + — missing — mancante + to search every command per cercare qualsiasi comando + (closest) (il più simile) + + Add Scale + Aggiungi scala + 0.2 (quality) to 100 (speed) da 0,2 (qualità) a 100 (velocità) + 1 Color Job… Lavoro a 1 colore… + 1 {unit} on the artboard stands for {real} {unit} in the scene. 1 {unit} sulla tavola da disegno corrisponde a {real} {unit} nella scena. + 2 Color Job… Lavoro a 2 colori… + 3 Color Job… Lavoro a 3 colori… + 30° Angles Angoli di 30° + 3D and Materials 3D e materiali + 3D Ribbon Nastro 3D + 45° Angles Angoli di 45° + 60° Angles Angoli di 60° + 90° & 45° & 30° Angles Angoli di 90°, 45° e 30° + 90° & 45° Angles Angoli di 90° e 45° + 90° Angles Angoli di 90° + < 1 sec < 1 s + + [Default] is protected: New… starts an editable copy. [Predefinito] è protetto: Nuovo… crea una copia modificabile. + [Unnamed] [Senza nome] + A File… Un file… + A lower value follows the stroke closely; a higher one gives fewer points and smoother curves. Un valore più basso segue fedelmente il tratto; uno più alto produce meno punti e curve più morbide. + A new preset starting from the selected one Un nuovo preset basato su quello selezionato + A saved copy of the selected preset Una copia salvata del preset selezionato + About VectorCraft Informazioni su VectorCraft + above sopra + Absolute Position Posizione assoluta + Accurate Preciso + Abutting Adiacente + Action {n} Azione {n} + Actions Azioni + Activate Document Attiva documento + Active Perspective Plane Piano prospettico attivo + Actual Size Dimensioni effettive + Add Aggiungi + Add Anchor (Pen) Aggiungi ancoraggio (Penna) + Add Anchor Point Aggiungi punto di ancoraggio + Add Anchor Point Tool Strumento Aggiungi punto di ancoraggio + Add Anchor Points Aggiungi punti di ancoraggio + Add Effect Aggiungi effetto + Add Freeform Line Aggiungi linea libera + Add Freeform Point Aggiungi punto libero + Add Guide Aggiungi guida + Add Mesh Line Aggiungi linea trama + Add New Aggiungi nuovo + Add New Effect Aggiungi nuovo effetto + Add New Fill Aggiungi nuovo riempimento + Add New Stroke Aggiungi nuova traccia + Add Selected Artwork (Alt: as one asset) Aggiungi grafica selezionata (Alt: come risorsa unica) + Add Selected Artwork as Multiple Assets Aggiungi grafica selezionata come più risorse + Add Selected Artwork as One Asset Aggiungi grafica selezionata come risorsa unica + Add Spine Point Aggiungi punto alla dorsale + Add Swatches Aggiungi campioni + Add to Graphic Styles Aggiungi agli stili grafici + Add to Profiles Aggiungi ai profili + Add to Profiles… Aggiungi ai profili… + Add to Selection Aggiungi alla selezione + Add to Swatches Aggiungi ai campioni + Add Used Colors Aggiungi colori usati + Additional Plug-ins Folder Cartella plug-in aggiuntivi + Adjust Adjoining Width Points Regola punti di larghezza adiacenti + Adjust Color Balance… Regola bilanciamento colore… + Adjust Colors Regola colori + Adjust Options: Opzioni di regolazione: + Advanced Avanzate + Advanced Options Opzioni avanzate + Align Allinea + Align center Allinea al centro + Align left Allinea a sinistra + Align Objects: Allinea oggetti: + Align On: Allinea su: + Align right Allinea a destra + Align Stroke to Center Allinea traccia al centro + Align Stroke to Inside Allinea traccia all'interno + Align Stroke to Outside Allinea traccia all'esterno + Align Stroke: Allinea traccia: + Align to Artboard Allinea alla tavola da disegno + Align to Glyph Bounds Allinea ai limiti del glifo + Align to Key Object Allinea all'oggetto chiave + Align to Page Allinea alla pagina + Align to Path Allinea al tracciato + Align to Selection Allinea alla selezione + Align To: Allinea a: + Align: Allinea: + Alignment Guides Guide di allineamento + Alignment: Allineamento: + All Tutto + All Artwork Above Tutta la grafica soprastante + All Caps Tutto maiuscolo + All Categories Tutte le categorie + All colours are within the CMYK gamut Tutti i colori rientrano nella gamma CMYK + All on Active Artboard Tutto nella tavola da disegno attiva + All on Same Layers Tutto sugli stessi livelli + All printer's marks Tutti i segni di stampa + All Scripts Tutti i sistemi di scrittura + All Text Objects Tutti gli oggetti di testo + All the art Tutta la grafica + All Tools Tutti gli strumenti + Alt Alt + Alt: Alt: + Alter Paths for Appearance Modifica tracciati in base all'aspetto + Amount Quantità + Amount: Quantità: + Anchor Point Punto di ancoraggio + Anchor Point Tool Strumento Punto di ancoraggio + Anchor Points Punti di ancoraggio + Anchor Points, Handle, and Bounding Box Display Visualizzazione di punti di ancoraggio, maniglie e riquadro di delimitazione + Anchor/Path Labels Etichette ancoraggio/tracciato + Anchors: Ancoraggi: + Angle Angolo + Angle: Angolo: + Angles Angoli + Animated Zoom Zoom animato + Anti-alias Anti-aliasing + Anti-Alias Anti-aliasing + Anti-alias Rasters Anti-aliasing per immagini raster + Anti-aliased Artwork Grafica con anti-aliasing + Anti-aliasing: Anti-aliasing: + Any Kind Qualsiasi tipo + Appearance Aspetto + Appearance Attribute Attributo aspetto + Appearance Item Elemento aspetto + Appearance of Black Aspetto del nero + Appearance Panel Pannello Aspetto + Appearance panel Pannello Aspetto + Applies when the linked file is relinked or updated. Si applica quando il file collegato viene ricollegato o aggiornato. + Applies the next time VectorCraft starts. Si applica al prossimo avvio di VectorCraft. + Apply Brush Applica pennello + Apply Character Style Applica stile carattere + Apply Effect Applica effetto + Apply Graphic Style Applica stile grafico + Apply Last Color Applica ultimo colore + Apply Last Effect Applica ultimo effetto + Apply Last Gradient Applica ultima sfumatura + Apply Paragraph Style Applica stile paragrafo + Apply SVG Filter… Applica filtro SVG… + Apply to All Applica a tutti + Apply to All ({count} more missing) Applica a tutti (ne mancano altri {count}) + Arc Arco + Arc Lower… Arco inferiore… + Arc Tool Strumento Arco + Arc Upper… Arco superiore… + Arch… Arcata… + Arc… Arco… + Area / Path Type Testo in area / su tracciato + Area Graph Tool Strumento Grafico ad area + Area Text Objects Oggetti testo in area + Area Type Options Opzioni testo in area + Area Type Options… Opzioni testo in area… + Area Type Tool Strumento Testo in area + Around Object Attorno all'oggetto + Arrange Disponi + Arrange: Bring to Front Disponi: Porta in primo piano + Arrowheads: Punte di freccia: + Art Grafica + Art using a deleted global swatch keeps its colour. La grafica che usa un campione globale eliminato mantiene il suo colore. + Artboard Options Opzioni tavola da disegno + Artboard Options: edit with the Artboard tool Opzioni tavola da disegno: modifica con lo strumento Tavola da disegno + Artboard Options… Opzioni tavola da disegno… + Artboard Tool Strumento Tavola da disegno + Artboard {number} Tavola da disegno {number} + Artboard: Tavola da disegno: + Artboards Tavole da disegno + ArtCraft Website Sito web di ArtCraft + ArtCraft website Sito web di ArtCraft + Artwork Colors Colori della grafica + As Multiple Assets Come più risorse + As Single Asset Come risorsa unica + Ascender Ascendente + Ask When Modified Chiedi se modificato + Aspect Ratio Proporzioni + Asset Export Esportazione risorse + Asset Export Settings Impostazioni esportazione risorse + Assets Risorse + Assign Assegna + Assign Profile… Assegna profilo… + Assign: Assegna: + Attach to Active Plane Associa al piano attivo + Attributes Attributi + Author Title: Qualifica dell'autore: + Author: Autore: + Auto Auto + Automatic Automatico + Auto Size New Area Type Dimensionamento automatico del nuovo testo in area + Auto Spell Check Controllo ortografico automatico + Auto-Collapse Iconic Panels Comprimi automaticamente i pannelli a icona + Auto-Rotate (turn the paper to each artboard) Rotazione automatica (orienta la carta in base a ogni tavola da disegno) + Automatic flatness Planarità automatica + Automatically Automaticamente + Automatically Save Recovery Data Salva automaticamente i dati di recupero + Average Media + Average… Media… + Axis: Asse: + Background Color: Colore di sfondo: + Background Contents Contenuto sfondo + Background Contents: Contenuto sfondo: + Background: Sfondo: + Backspace Backspace + Bar Graph Tool Strumento Grafico a barre + Baseline Linea di base + Baseline Shift Spostamento linea di base + Basic Latin Latino di base + Batch Elaborazione batch + Begin Recording Avvia registrazione + Bend: Curvatura: + Bevel Join Unione smussata + Bitmap Bitmap + Black Nero + Black and White Bianco e nero + Black and White Logo Logo in bianco e nero + BLANK DOCUMENT PRESETS PRESET DI DOCUMENTI VUOTI + Bleed Abbondanza + Bleed: Abbondanza: + Bleeds Abbondanze + Blend Fusione + Blend Front to Back Fusione da davanti a dietro + Blend Horizontally Fusione orizzontale + Blend Info Informazioni fusione + Blend Options Opzioni fusione + Blend Options… Opzioni fusione… + Blend Tool Strumento Fusione + Blend Vertically Fusione verticale + Blending Mode Metodo di fusione + Blends and Transparency Fusioni e trasparenza + Bloat Tool Strumento Gonfia + Blob Brush Pennello tondo + Blob Brush Tool Strumento Pennello tondo + Blue Blu + Blur Sfocatura + Bottom In basso + Bottom in Front Inferiore davanti + Bottom: In basso: + Bounds Limiti + Bounds (Fill Proportionally) Limiti (riempi proporzionalmente) + Bounds (Fit Proportionally) Limiti (adatta proporzionalmente) + Break Link to Graphic Style Interrompi collegamento allo stile grafico + Break Link to Symbol Interrompi collegamento al simbolo + Brick by Column Mattoni per colonna + Brick by Row Mattoni per riga + Brick Offset: Sfalsamento mattoni: + Brightness Luminosità + Brightness/Contrast… Luminosità/contrasto… + Brights Brillanti + Bring Forward Porta avanti + Bring to Front Porta in primo piano + Bristle Setole + Bristle Brush Strokes Pennellate a setole + Browser Browser + Brush Affects: Il pennello influisce su: + Brush Definition Definizione pennello + Brush Libraries Librerie pennelli + Brush Libraries (on the roadmap) Librerie pennelli (in programma) + Brush Options… Opzioni pennello… + Brush Strokes Pennellate + Brushes Pennelli + Built-in Libraries Librerie integrate + Built-in presets are read-only: New… starts an editable copy. I preset integrati sono di sola lettura: Nuovo… crea una copia modificabile. + Built-in presets don't change: New makes a copy you can edit. I preset integrati non cambiano: Nuovo crea una copia che puoi modificare. + Built-in presets don't change: New… starts an editable copy. I preset integrati non cambiano: Nuovo… crea una copia modificabile. + Bulge… Rigonfiamento… + Bullet Punto elenco + Butt Cap Estremità tronca + Byte Order: Ordine dei byte: + Calligraphic Calligrafico + Can't print these settings: see the Summary Impossibile stampare con queste impostazioni: vedi il Riepilogo + Cancel Annulla + Cancel Key Object Annulla oggetto chiave + Canvas Color Colore area di disegno + Cap Estremità + Cap: Estremità: + Cascade A cascata + Center Centro + Center Artwork Centra grafica + Center on Artboard Centra nella tavola da disegno + Center-Justified Tab Tabulazione centrata + Centimeters Centimetri + Change Cambia + Change All Cambia tutto + Change Case Maiuscole/minuscole + Change Screen Mode (F) Cambia modalità schermo (F) + Change to Global Rulers Passa a righelli globali + Change to Right-to-Left Layout Passa al layout da destra a sinistra + Changed since the last Refresh. Modificato dall'ultimo aggiornamento. + Changes allowed: Modifiche consentite: + Changes made since it was last saved will be lost. Le modifiche apportate dall'ultimo salvataggio andranno perse. + Changing these settings changes how raster effects look when exported, flattened or expanded. Modificare queste impostazioni cambia l'aspetto degli effetti raster quando vengono esportati, appiattiti o espansi. + Channel Canale + Character Carattere + Character Alignment Allineamento caratteri + Character / Paragraph Carattere / Paragrafo + Character Rotation Rotazione caratteri + Character Set: Set di caratteri: + Character Style Stile carattere + Character Style Options Opzioni stile carattere + Character Styles Stili carattere + Check Links Verifica collegamenti + Check Spelling… Controlla ortografia… + Choose a folder Scegli una cartella + Choose… Scegli… + Circle Cerchio + Classic Defaults Valori predefiniti classici + Clean Up… Pulisci… + Clear Cancella + Clear All Tabs Cancella tutte le tabulazioni + Clear Appearance Cancella aspetto + Clear Guides Cancella guide + Clear Overrides Cancella sostituzioni + Clear Recent Files Cancella file recenti + Click Clic + Click an anchor point Fai clic su un punto di ancoraggio + Click or drag Fai clic o trascina + Click the art with the Gradient tool to add or select points. Fai clic sulla grafica con lo strumento Sfumatura per aggiungere o selezionare punti. + Click the first point Fai clic sul primo punto + Click the ramp or a type button to apply a gradient. Fai clic sulla barra della sfumatura o su un pulsante di tipo per applicare una sfumatura. + Click to add a tab stop, drag to move it, drag it off the ruler to delete it Fai clic per aggiungere una tabulazione, trascinala per spostarla, trascinala fuori dal righello per eliminarla + Click to choose a swatch, Shift-click to mix a colour Fai clic per scegliere un campione, Shift+clic per mescolare un colore + Click to edit the mask; Alt-click to view only the mask; Shift-click to disable or enable it Fai clic per modificare la maschera; Alt+clic per visualizzare solo la maschera; Shift+clic per disattivarla o attivarla + Click to place each file at 100%, or drag to size it; arrow keys switch files, Esc skips one. Fai clic per inserire ogni file al 100% o trascina per dimensionarlo; i tasti freccia cambiano file, Esc ne salta uno. + Click to select, double-click to edit Fai clic per selezionare, doppio clic per modificare + Click to toggle visibility Fai clic per mostrare o nascondere + Click to zoom in, Alt-click to zoom out, drag to pan, double-click to fit Fai clic per ingrandire, Alt+clic per ridurre, trascina per spostare la vista, doppio clic per adattare + Client-side (.html) Lato client (.html) + Clip Ritaglio + Clip Complex Regions Ritaglia aree complesse + Clip to Art Ritaglia alla grafica + Clip to Artboard Ritaglia alla tavola da disegno + Clip to Bounding Box Ritaglia al riquadro di delimitazione + Clipboard as PDF Appunti come PDF + Clipboard as PNG Appunti come PNG + Clipboard as SVG Appunti come SVG + Clipboard as Text Appunti come testo + Clipboard Formats Formati degli appunti + Clipboard Handling Gestione degli appunti + Clipping Mask Maschera di ritaglio + Clipping Masks Maschere di ritaglio + Close Chiudi + Close All Chiudi tutto + Close Library Chiudi libreria + Close Path Chiudi tracciato + Close paths when ends are within: Chiudi i tracciati quando le estremità distano meno di: + Cmd Cmd + CMYK CMYK + CMYK Color Colore CMYK + CMYK colours print with their own values; off, they go through the colour settings too. I colori CMYK vengono stampati con i propri valori; se disattivato, passano anche per le impostazioni colore. + Collapse Panels to Icons Comprimi pannelli in icone + Collapse to Icons Comprimi in icone + Collate Fascicola + Collect for Export Raccogli per l'esportazione + Collect in New Layer Raccogli in un nuovo livello + Collect Links in a Separate Folder Raccogli i collegamenti in una cartella separata + Color Colore + Color (,) Colore (,) + Color Adjustments Regolazioni colore + Color bars Barre colore + Color blindness – Deuteranopia-type Daltonismo – tipo deuteranopia + Color blindness – Protanopia-type Daltonismo – tipo protanopia + Color Burn Brucia colore + Color conversion: Conversione colore: + Color Dodge Scherma colore + Color Group Gruppo colori + Color Group: Gruppo colori: + Color Group: {name} Gruppo colori: {name} + Color Guide Guida colori + Color Guide Options Opzioni guida colori + Color Guide Options… Opzioni guida colori… + Color images Immagini a colori + Color Library Libreria colori + Color Library… Libreria colori… + Color Management Gestione del colore + Color Mixer (Shift-click the chip) Miscelatore colori (Shift+clic sul riquadro colore) + Color Mode Metodo colore + Color Mode: Metodo colore: + Color Model: Modello colore: + Color Models Modelli colore + Color Picker Selettore colore + Color Picker… Selettore colore… + Color Reduction: Riduzione colori: + Color Settings Impostazioni colore + Color Settings… Impostazioni colore… + Color Space Spazio colore + Color Swatches Campioni colore + Color Table Tabella colori + Color Table ({n} color) Tabella colori ({n} colore) + Color Table ({n} colors) Tabella colori ({n} colori) + Color Theme Tema colore + Color Themes Temi colore + Color Type: Tipo di colore: + Color: Colore: + Colorize Colora + Colors Colori + Colors: Colori: + Column Graph Tool Strumento Grafico a colonne + Columns: Colonne: + Column… Colonna… + Combine Slices Combina sezioni + Coming soon — tracked in the parity plan Prossimamente — previsto nel piano di parità + Command Click to Select Objects Behind Cmd+clic per selezionare gli oggetti retrostanti + Command Dialog Finestra dei comandi + Community Comunità + Compatibility: Compatibilità: + Compatible Gradient and Gradient Mesh Printing Stampa compatibile di sfumature e trame sfumatura + Complement Complementare + Complexity: Complessità: + Composite colours are converted to it; separations separate with it when it is a CMYK profile. I colori compositi vengono convertiti in questo profilo; le separazioni lo usano quando è un profilo CMYK. + Compound Path Tracciato composto + Compress (RLE) Comprimi (RLE) + Compress text and line art Comprimi testo e grafica al tratto + Compression Compressione + Compression › Color › Above Ppi Compressione › Colore › Oltre ppi + Compression: Compressione: + Condition identifier: Identificativo condizione: + Conflict {n} of {count} Conflitto {n} di {count} + Connect Selected End Points Collega i punti finali selezionati + Consolidate All Windows Consolida tutte le finestre + Constrain Angle Vincola angolo + Constrain Width and Height Proportions Vincola proporzioni di larghezza e altezza + Construction Guides Guide di costruzione + Contextual Alternates Alternative contestuali + Contextual Task Bar Barra attività contestuale + Pin Bar Position Fissa posizione barra + Reset Bar Position Ripristina posizione barra + Contrast Contrasto + Control Controllo + Convert Converti + Convert All Spot Colors to Process Converti tutti i colori spot in quadricromia + Convert All Strokes to Outlines Converti tutte le tracce in contorni + Convert All Text to Outlines Converti tutto il testo in contorni + Convert Anchor Point Converti punto di ancoraggio + Convert Anchor Points Converti punti di ancoraggio + Convert Color Converti colore + Convert Document Color Mode Converti metodo colore documento + Convert Process to Global Converti quadricromia in globale + Convert Selected Anchor Points to Corner Converti i punti di ancoraggio selezionati in punti d'angolo + Convert Selected Anchor Points to Smooth Converti i punti di ancoraggio selezionati in punti curvi + Convert text to outlines Converti il testo in contorni + Convert To Area Type Converti in testo in area + Convert to Artboards Converti in tavole da disegno + Convert to CMYK Converti in CMYK + Convert to Grayscale Converti in scala di grigi + Convert To Outlines Converti in contorni + Convert To Point Type Converti in testo per punti + Convert to RGB Converti in RGB + Convert to Shape Converti in forma + Convert to sRGB Converti in sRGB + Convert: Converti: + Copied the CSS of {rules} object(s) CSS copiato da {rules} oggetto/i + Copies: Copie: + Copy Copia + Copy (make a transformed copy) Copia (crea una copia trasformata) + Copy All Objects Copia tutti gli oggetti + Copy All Styles Copia tutti gli stili + Copy Color Value (Hex) Copia valore colore (hex) + Copy Fonts Used in the Document Copia i font usati nel documento + Copy Links Copia collegamenti + Copy Selected Style Copia stile selezionato + Copy Width Point Copia punto di larghezza + Copyright Copyright + Copyright Info URL: URL informazioni copyright: + Copyright Notice: Nota sul copyright: + Copyright Status: Stato copyright: + Copyright Symbol Simbolo di copyright + Corner Radius Raggio angolo + Corner Radius: Raggio angolo: + Corner: Angolo: + Corners Angoli + Chamfer Smusso + Corners… Angoli… + Cut Path Taglia tracciato + Descender Discendente + Flip Capovolgi + Inverted Round Arrotondato invertito + Radius: Raggio: + Round Arrotondato + Couldn't copy to the system clipboard: {e} Impossibile copiare negli appunti di sistema: {e} + Couldn't paste from the clipboard: {e} Impossibile incollare dagli appunti: {e} + Couldn't save recovery data: {e} Impossibile salvare i dati di recupero: {e} + Couldn't {} {name}: {e} Impossibile {} {name}: {e} + Create Crea + Create Clipping Mask Crea maschera di ritaglio + Create Document Crea documento + Create from Guides Crea da guide + Create from Selection Crea dalla selezione + Create From: Crea da: + Create Gradient Mesh… Crea trama sfumatura… + Create Graph Crea grafico + Create New Layer Crea nuovo livello + Create New Sublayer Crea nuovo sottolivello + Create New Swatch… Crea nuovo campione… + Create New {kind} Style Crea nuovo stile {kind} + Create Object Mosaic… Crea mosaico di oggetti… + Create Outlines Crea contorni + Create Path Crea tracciato + Create PDF layers from top-level layers Crea livelli PDF dai livelli principali + Create PDF-Compatible File Crea file compatibile PDF + Create Report Crea rapporto + Create Slice Crea sezione + Create Sub-folders Crea sottocartelle + Create Text Crea testo + Create Trim Marks Crea segni di taglio + Created Creato + Created: Creato: + Crop Ritaglia + Crop Image Ritaglia immagine + Mask Maschera + Crop Marks Segni di ritaglio + Crop To Ritaglia in base a + Crystallize Tool Strumento Cristallizza + CSS Properties Proprietà CSS + Ctrl Ctrl + Currency & Symbols Valute e simboli + Current Brush Pennello corrente + Current Colors ({total}) Colori correnti ({total}) + Current Symbol Simbolo corrente + Curvature Curvatura + Curvature Tool Strumento Curvatura + Curves… Curve… + Custom Personalizzato + Customize… Personalizza… + Cut Taglia + Cut Path at Selected Anchor Points Taglia tracciato nei punti di ancoraggio selezionati + Cyan Ciano + Dark Scuro + Darken Scurisci + dash trattino + Dash Pattern Schema del tratteggio + Dashed Tratteggiato + Dashed Line Linea tratteggiata + Data Recovery Recupero dati + Data… Dati… + Dates Date + Decimal-Justified Tab Tabulazione allineata ai decimali + Decimal: Decimale: + Decorative Decorativo + Default Predefinito + Default Actions Azioni predefinite + Default Figure Cifre predefinite + Default Fill and Stroke Riempimento e traccia predefiniti + Default Fill and Stroke (D) Riempimento e traccia predefiniti (D) + Default Language Lingua predefinita + Default Printer Stampante predefinita + Default Swatches Campioni predefiniti + Define Grid… Definisci griglia… + Define Perspective Grid Definisci griglia prospettica + Define Perspective Grid… Definisci griglia prospettica… + Delete Elimina + Delete All Elimina tutto + Delete Anchor Point Elimina punto di ancoraggio + Delete Anchor Point Tool Strumento Elimina punto di ancoraggio + Delete Anchor Points Elimina punti di ancoraggio + Delete Artboard Elimina tavola da disegno + Delete Artboards Elimina tavole da disegno + Delete Brush Elimina pennello + Delete Character Style Elimina stile carattere + Delete Empty Artboards Elimina tavole da disegno vuote + Delete Freeform Point Elimina punto libero + Delete Graphic Style Elimina stile grafico + Delete Graphic Style (Alt-click: without asking) Elimina stile grafico (Alt+clic: senza conferma) + Delete Layer Elimina livello + Delete Mesh Point Elimina punto trama + Delete Paragraph Style Elimina stile paragrafo + Delete Pattern Elimina motivo + Delete PDF Preset Elimina preset PDF + Delete Perspective Grid Preset Elimina preset griglia prospettica + Delete Point Elimina punto + Delete Preset Elimina preset + Delete Print Preset Elimina preset di stampa + Delete Profile Elimina profilo + Delete Save for Web Preset Elimina preset di Salva per il web + Delete Selected Item Elimina elemento selezionato + Delete Selection Elimina selezione + Delete Slices Elimina sezioni + Delete Spine Point Elimina punto della dorsale + Delete Stop Elimina cursore colore + Delete Swatch Elimina campione + Delete Symbol Elimina simbolo + Delete Tab Elimina tabulazione + Delete the graphic style “{name}”? Eliminare lo stile grafico “{name}”? + Delete Theme Elimina tema + Delete theme Elimina tema + Delete these {count} swatches and groups? Eliminare questi {count} campioni e gruppi? + Delete these {n} graphic styles? Eliminare questi {n} stili grafici? + Delete this saved preset Elimina questo preset salvato + Delete this {n} graphic style? Eliminare {n} stile grafico? + Delete Transparency Flattener Preset Elimina preset di appiattimento trasparenza + Delete Width Point Elimina punto di larghezza + Delete Workspace Elimina area di lavoro + Delete {kind} Style Elimina stile {kind} + Delete “{name}”? Eliminare “{name}”? + Depth: Profondità: + Description Descrizione + Description: Descrizione: + Deselect Deseleziona + Design… Design… + Destination: Destinazione: + Detail: Dettaglio: + Devices Dispositivi + Dialog Finestra di dialogo + Diamond Rombo + Difference Differenza + Differences from {preset}: Differenze rispetto a {preset}: + Dim Copies to: Attenua copie al: + Dim Images to: Attenua immagini al: + Dimensions Dimensioni + Direct Selection Tool Strumento Selezione diretta + Direction Handles Maniglie di direzione + Disable Auto Add/Delete Disattiva aggiunta/eliminazione automatica + Disable Opacity Mask Disattiva maschera di opacità + Discard Scarta + Discard Empty Type Scarta testo vuoto + Discard Recovered Documents Scarta documenti recuperati + Discard White Overprint in Output Scarta sovrastampa del bianco nell'output + Discarded {} recovered document(s) Documenti recuperati scartati: {} + Discord Discord + Discretionary Hyphen Trattino facoltativo + Discretionary Ligatures Legature facoltative + Display All Blacks Accurately Visualizza tutti i neri con precisione + Display All Blacks as Rich Black Visualizza tutti i neri come nero ricco + Display Bitmaps as Anti-aliased Images in Pixel Preview Visualizza bitmap come immagini con antialiasing nell'anteprima pixel + Display Options Opzioni di visualizzazione + Display Print Size at 100% Zoom Visualizza dimensioni di stampa con zoom al 100% + Distort & Transform Distorci e trasforma + Distort Appearance Distorci aspetto + Distort Linear Gradients Distorci sfumature lineari + Distort Pattern Fills Distorci riempimenti con motivo + Distortion Distorsione + Distribute Distribuisci + Distribute Objects: Distribuisci oggetti: + Distribute Spacing Distribuisci spaziatura + Distribute Spacing: Distribuisci spaziatura: + Dither: Dithering: + Divide Dividi + Divide Horizontally Into Dividi orizzontalmente in + Divide Objects Below Dividi oggetti sottostanti + Divide Slices Dividi sezioni + Divide Slices… Dividi sezioni… + Divide Vertically Into Dividi verticalmente in + Do Not Move Non spostare + Do you want to save the changes you made to “{name}”? Vuoi salvare le modifiche apportate a “{name}”? + Document Documento + Document Color Mode Metodo colore documento + Document Info Informazioni documento + Document Ink Options Opzioni inchiostro documento + Document JSON JSON del documento + Document open password Password di apertura del documento + Document profile Profilo documento + Document Raster Effects Settings Impostazioni effetti raster documento + Document Raster Effects Settings Dialog Finestra di dialogo Impostazioni effetti raster documento + Document Raster Effects Settings… Impostazioni effetti raster documento… + Document Setup Imposta documento + Document Setup… Impostazione documento… + Document Swatches Campioni del documento + Document Title: Titolo del documento: + Documents you create appear here. I documenti che crei vengono visualizzati qui. + Don't Save Non salvare + Don't Show Center Non mostrare centro + Done Fine + Dots Punti + Double Click To Isolate Fai doppio clic per isolare + Double Left Quotation Marks Virgolette doppie di apertura + Double Quotes: Virgolette doppie: + Double Right Quotation Marks Virgolette doppie di chiusura + Double-click Fai doppio clic + Double-click to edit the characters' paint Fai doppio clic per modificare il colore dei caratteri + Double-click to insert Fai doppio clic per inserire + Double-click to rename Fai doppio clic per rinominare + Double-click to target the contents Fai doppio clic per impostare il contenuto come destinazione + Download Scarica + Download: Download: + Downloaded {what} Download completato: {what} + Downloaded {} file(s) File scaricati: {} + Drag Trascina + Drag a handle Trascina una maniglia + Drag art here, or select it and click +. Hold Alt for one asset of several objects. Trascina qui la grafica oppure selezionala e fai clic su +. Tieni premuto Alt per creare una sola risorsa da più oggetti. + Drag onto art to apply this appearance Trascina sulla grafica per applicare questo aspetto + Drag the art to move it on the paper Trascina la grafica per spostarla sul foglio + Draw Disegna + Draw Behind Disegna dietro + Draw in Perspective Disegna in prospettiva + Draw Inside Disegna all'interno + Draw Normal Disegna normalmente + Draw: Disegna: + Drawing Mode Modalità di disegno + Drop Shadow Ombra esterna + Drop Shadow… Ombra esterna… + Duotone Gradients Sfumature bicromatiche + Duplicate Duplica + Duplicate and Offset 10 pt Duplica e sposta di 10 pt + Duplicate Artboard Duplica tavola da disegno + Copy Artboard Copia tavola da disegno + Cut Artboard Taglia tavola da disegno + Duplicate Artboards Duplica tavole da disegno + Duplicate Brush Duplica pennello + Duplicate Character Style Duplica stile carattere + Duplicate Effect Duplica effetto + Duplicate Graphic Style Duplica stile grafico + Duplicate Item Duplica elemento + Duplicate Layer Duplica livello + Duplicate Paragraph Style Duplica stile paragrafo + Duplicate Selected Item Duplica elemento selezionato + Duplicate Selection Duplica selezione + Duplicate Slice Duplica sezione + Duplicate Swatch Duplica campione + Duplicate Symbol Duplica simbolo + Duplicate {kind} Style Duplica stile {kind} + Dutch Olandese + DXF Import Options Opzioni di importazione DXF + DXF Info Informazioni DXF + DXF Options Opzioni DXF + DXF Options Dialog Finestra di dialogo Opzioni DXF + e.g. 1-3, 5 es. 1-3, 5 + Each page prints as one image, at the document's raster effects resolution. Ogni pagina viene stampata come un'unica immagine, alla risoluzione degli effetti raster del documento. + Earth Tones Toni della terra + East Asian Type Testo dell'Asia orientale + Edit Modifica + Edit Artboards Modifica tavole + Edit Clipping Path Modifica tracciato di ritaglio + Edit Color Group Modifica gruppo colori + Edit Colors Modifica colori + Edit Contents Modifica contenuto + Edit Custom Dictionary… Modifica dizionario personalizzato… + Edit Envelope Modifica involucro + Edit Freeform Point Modifica punto libero + Edit Gradient Modifica sfumatura + Edit Opacity Mask Modifica maschera di opacità + Edit or Apply Color Group Modifica o applica gruppo colori + Edit or Apply Color Group… Modifica o applica gruppo colori… + Edit or Apply Colors Modifica o applica colori + Edit Original Modifica originale + Edit Pattern Modifica motivo + Edit PDF Preset Modifica preset PDF + Edit Print Preset Modifica preset di stampa + Edit selected paths within: Modifica i tracciati selezionati entro: + Edit Selection Modifica selezione + Edit Selection… Modifica selezione… + Edit Symbol Modifica simbolo + Edit Text Modifica testo + Edit the applied effect, or add another one? Modificare l'effetto applicato o aggiungerne un altro? + Edit the selected point's colour in the Color panel Modifica il colore del punto selezionato nel pannello Colore + Edit the stop Modifica il cursore colore + Edit Theme Modifica tema + Edit theme Modifica tema + Edit Toolbar Modifica barra degli strumenti + Edit Views Modifica viste + Edit Views… Modifica viste… + Edit… Modifica… + Effect Effetto + Effect Options Opzioni effetto + Effective PPI PPI effettivi + Effects Effetti + Effect… Effetto… + Ellipse Ellisse + Ellipse Tool Strumento Ellisse + Ellipse… Ellisse… + Ellipsis Puntini di sospensione + Em Box Bottom/Left Riquadro em in basso/a sinistra + Em Box Center Riquadro em al centro + Em Box Top/Right Riquadro em in alto/a destra + Em Dash Lineetta + Em Space Spazio em + Embed Incorpora + Embed Fonts (for other applications) Incorpora font (per altre applicazioni) + Embed Fonts (Glyphs Used) Incorpora font (glifi utilizzati) + Embed ICC Profile Incorpora profilo ICC + Embed ICC Profiles Incorpora profili ICC + Embed Image Incorpora immagine + Embed Image(s) Incorpora immagini + Embed page thumbnails Incorpora miniature delle pagine + Embedded Incorporato + Embedded Image Immagine incorporata + Embedded {n} image(s) Immagini incorporate: {n} + Embedded {n} image(s); {missing} missing: relink them first Immagini incorporate: {n}; mancanti: {missing} (ricollegale prima) + Emulsion: Emulsione: + En Dash Trattino medio + En Space Spazio en + Enable Background Export Attiva esportazione in background + Enable Background Save Attiva salvataggio in background + Enable Contextual Task Bar Attiva barra attività contestuale + Enable copying of text, images and other content Consenti la copia di testo, immagini e altri contenuti + Enable in-menu font previews Attiva anteprima dei font nei menu + Enable Missing Glyph Protection Attiva protezione glifi mancanti + Enable Opacity Mask Attiva maschera di opacità + Enable plaintext metadata Attiva metadati in testo semplice + Enable Rubber Band for Attiva elastico per + Enable text access for screen readers Consenti l'accesso al testo per le utilità di lettura dello schermo + Enable Touch Gestures Attiva gesti touch + Enable Touch Workspace Attiva area di lavoro touch + Encoding Codifica + Encoding: Codifica: + Encryption: {name} (set by Compatibility) Crittografia: {name} (impostata da Compatibilità) + End arrowhead Punta di freccia finale + English English + English: UK Inglese: Regno Unito + English: USA Inglese: Stati Uniti + Enter Invio + Enter Isolation Mode Entra in modalità isolamento + Entire Font Font intero + Envelope Distort Distorsione involucro + Envelope Info Informazioni involucro + Envelope Mesh Trama involucro + Envelope Options Opzioni involucro + Envelope Options… Opzioni involucro… + EPS Options Opzioni EPS + EPS Options Dialog Finestra di dialogo Opzioni EPS + Eraser Gomma + Eraser Tool Strumento Gomma + Error Errore + Esc Esc + Every (minutes) Ogni (minuti) + Every option is at its default. Tutte le opzioni hanno il valore predefinito. + Every option matches {base}. Tutte le opzioni corrispondono a {base}. + Every-line Composer Composizione su tutte le righe + Exact dash lengths Lunghezze esatte dei trattini + Exceptions (comma separated) Eccezioni (separate da virgole) + Exclude Escludi + Exclusion Esclusione + Exit Isolation Mode Esci dalla modalità isolamento + Expand Espandi + Expand Appearance Espandi aspetto + Expand applies to compound shapes (Alt-click a shape mode) — on the roadmap Espandi si applica alle forme composte (Alt+clic su un metodo forma) — in programma + Expand Brush Strokes Espandi tracce pennello + Expand Compound Shape Espandi forma composta + Expand Gradient Mesh Espandi trama sfumatura + Expand Gradient To Espandi sfumatura in + Expand Layers Panel Rows Espandi righe del pannello Livelli + Expand Options Opzioni di espansione + Expand Panels Espandi pannelli + Expand Repeat Espandi ripetizione + Expand Shape Espandi forma + Expand: Espandi: + Expand… Espandi… + Export Esporta + Export All… Esporta tutto… + Export and Clipboard Transparency Flattener Settings Impostazioni di appiattimento trasparenza per esportazione e Appunti + Export Artboard Esporta tavola da disegno + Export As Esporta come + Export As PNG… Esporta come PNG… + Export As SVG… Esporta come SVG… + Export Asset Esporta risorsa + Export Assets Esporta risorse + Export As… Esporta come… + Export CSS Esporta CSS + Export CSS… Esporta CSS… + Export Document Esporta documento + Export DXF Esporta DXF + Export EPS Esporta EPS + Export for Screens Esporta per schermi + Export for Screens Settings Impostazioni Esporta per schermi + Export for Screens… Esporta per schermi… + Export Keyboard Shortcuts… Esporta scelte rapide da tastiera… + Export Option Opzione di esportazione + Export PDF Esporta PDF + Export PDF Presets Esporta preset PDF + Export Perspective Grid Presets Esporta preset griglia prospettica + Export Print Presets Esporta preset di stampa + Export Selected Art Only Esporta solo la grafica selezionata + Export Selected CSS… Esporta CSS selezionato… + Export Selection… Esporta selezione… + Export Settings Impostazioni di esportazione + Export the selected assets (else all of them) Esporta le risorse selezionate (o tutte, se non ne è selezionata nessuna) + Export to: Esporta in: + Export Transparency Flattener Presets Esporta preset di appiattimento trasparenza + Export {count} Selected Esporta selezione ({count}) + Export: Esporta: + Exported {count} file(s) to {folder} File esportati in {folder}: {count} + Exported {path} Esportazione completata: {path} + Exported {what} Esportazione completata: {what} + Exported {what} with {} note(s): {first} Esportazione di {what} completata con note ({}): {first} + Exporting {} Esportazione di {} in corso + Export… Esporta… + Extrude & Bevel… Estrusione e smusso… + Eyedropper Contagocce + Eyedropper Applies: Il contagocce applica: + Eyedropper Options Opzioni contagocce + Eyedropper Picks Up: Il contagocce preleva: + Eyedropper Tool Strumento Contagocce + Eyedropper: click the art to sample the stop's colour Contagocce: fai clic sulla grafica per campionare il colore del cursore + Favorites Preferiti + Feather… Sfuma bordi… + Feet Piedi + Feet & Inches Piedi e pollici + Fewer Elements Meno elementi + Fidelity: Fedeltà: + Figure Space Spazio cifra + Figure: Cifre: + File File + File Dimensions Dimensioni file + File Format: Formato file: + File Formats Formati file + File Handling Gestione file + File Info Informazioni file + File Info Dialog Finestra di dialogo Informazioni file + File Info… Informazioni file… + File Name: Nome file: + File › Place… brings in an image, linked or embedded. File › Inserisci… importa un'immagine, collegata o incorporata. + Files File + Files of a PDF standard can't be password-protected. I file conformi a uno standard PDF non possono essere protetti da password. + Files of this standard tag their colours with ICC profiles. I file conformi a questo standard contrassegnano i colori con profili ICC. + Fill Riempimento + Fill & Stroke Riempimento e traccia + Fill (X), double-click for the Color Picker Riempimento (X), fai doppio clic per il selettore colore + Fill and Stroke Riempimento e traccia + Fill new strokes Riempi nuove tracce + Fill Color Colore riempimento + Fill New Type Objects With Placeholder Text Riempi i nuovi oggetti di testo con testo segnaposto + Fill Rule Regola di riempimento + Fill with Placeholder Text Riempi con testo segnaposto + Fill: Riempimento: + Fill: click for swatches, Shift-click for the color mixer Riempimento: fai clic per i campioni, Shift+clic per il miscelatore colori + Find Trova + Find and Replace… Trova e sostituisci… + Find Font Trova font + Find Font… Trova font… + Find Next Trova successivo + Find Objects Trova oggetti + First Page Prima pagina + First-line Left Indent Rientro sinistro prima riga + Fisheye… Occhio di pesce… + Fish… Pesce… + Fit All Adatta tutto + Fit All in Window Adatta tutto alla finestra + Fit Artboard in Window Adatta tavola da disegno alla finestra + Fit dashes to corners and ends Adatta i trattini ad angoli ed estremità + Fit Headline Adatta titolo + Decrease Font Size Riduci dimensione font + Increase Font Size Aumenta dimensione font + Spacing Spaziatura + Step Type Dimensione testo a incrementi + Fit in View Adatta alla vista + Fit in Window Adatta alla finestra + Fit on Screen Adatta allo schermo + Fit to Artwork Bounds Adatta ai limiti della grafica + Fit to Selected Art Adatta alla grafica selezionata + Flag… Bandiera… + Flare Riflesso + Flare Tool Strumento Riflesso + Flare Tool Options Opzioni strumento Riflesso + Flat Image Immagine appiattita + Flatness: Planarità: + Flatten Artwork Appiattisci grafica + Flatten Transparency Appiattisci trasparenza + Flatten Transparency… Appiattisci trasparenza… + Flattener preset: Preset di appiattimento: + Flattener presets Preset di appiattimento + Flattener Preview Anteprima appiattimento + Flip Across Capovolgi trasversalmente + Flip Along Capovolgi longitudinalmente + Flip Along Horizontal Axis Capovolgi sull'asse orizzontale + Flip Along Vertical Axis Capovolgi sull'asse verticale + Flip Horizontal Capovolgi orizzontalmente + Flip Row Order Inverti ordine delle righe + Flip Vertical Capovolgi verticalmente + Float in Window Rendi mobile nella finestra + Focal Fill Riempimento attivo + Focal Stroke Traccia attiva + Folder Cartella + Folder Name: Nome cartella: + Font Font + Font Family Famiglia di font + Font Family & Style Famiglia e stile font + Font Family, Style & Size Famiglia, stile e dimensione font + Font List Elenco font + Font Preview Size Dimensione anteprima font + Font Size Dimensione font + Font: Font: + Fonts Font + Fonts in Document Font nel documento + Fonts in Document: {count} Font nel documento: {count} + Fonts whose licence doesn't allow embedding are not copied. I font la cui licenza non consente l'incorporamento non vengono copiati. + Forced Line Break Interruzione di riga forzata + Format Formato + Format Options Opzioni formato + Format Settings Impostazioni formato + Format: Formato: + Formats: Formati: + Fractional Widths Larghezze frazionarie + Fractions Frazioni + Free Libero + Free Distort Distorsione libera + Free Distort… Distorsione libera… + Free Transform Tool Strumento Trasformazione libera + Freeform Gradient Sfumatura a forma libera + French Francese + Frequencies and angles are the output device's to apply. Frequenze e angoli vengono applicati dal dispositivo di output. + Frequency Frequenza + Full Document Documento completo + Full Screen Mode Modalità schermo intero + Full Screen Mode with Menu Bar Modalità schermo intero con barra dei menu + Gamma Gamma + Gamut Check Controllo gamut + Gamut Warning Avviso gamut + gap spazio + Gap Options… Opzioni spazi vuoti… + Gaussian Blur… Sfocatura gaussiana… + General Generale + General › Placement › X Generale › Posizionamento › X + General › Thumbnails Generale › Miniature + Generate CSS Genera CSS + Generate CSS: the whole document's CSS while nothing is selected Genera CSS: il CSS dell'intero documento se non è selezionato nulla + German Tedesco + Get Preferences Ottieni preferenze + Get Text Range Ottieni intervallo di testo + Global Globale + Global Brush Dimensions Dimensioni pennello globali + Global Process Color Colore quadricromia globale + Global Process Color, CMYK Colore quadricromia globale, CMYK + glyph {id} glifo {id} + Glyphs Glifi + Go to Artboard Vai alla tavola da disegno + Go To Link Vai al collegamento + GPL palettes keep solid colours only, as RGB. Le palette GPL conservano solo i colori pieni, in RGB. + GPU Performance Prestazioni GPU + Gradient Sfumatura + Gradient (.) Sfumatura (.) + Gradient across stroke Sfumatura trasversale alla traccia + Gradient along stroke Sfumatura lungo la traccia + Gradient and Mesh Resolution: Risoluzione sfumature e trame: + Gradient Fill: click to apply, drag onto art Riempimento sfumatura: fai clic per applicare, trascina sulla grafica + Gradient Finishes Finiture sfumatura + Gradient Mesh Trama sfumatura + Gradient swatches Campioni sfumatura + Gradient Tool Strumento Sfumatura + Gradient Vector Vettore sfumatura + Gradient within stroke Sfumatura all'interno della traccia + Gradients Sfumature + Graph Grafico + Graph Data Dati grafico + Graph Type Tipo di grafico + Graphic Style Stile grafico + Graphic Style Libraries Librerie stili grafici + Graphic Style Libraries Menu Menu Librerie stili grafici + Graphic Style Library Libreria stili grafici + Graphic Style Options Opzioni stile grafico + Graphic Style Options… Opzioni stile grafico… + Graphic Styles Stili grafici + Graphic Styles Options Opzioni stili grafici + Graphics Grafica + Graphics Processor Processore grafico + Graphics: {adapter} Scheda grafica: {adapter} + Gravity Gravità + Grays Grigi + Grays and Neutrals Grigi e neutri + Grayscale Scala di grigi + Grayscale images Immagini in scala di grigi + Greek & Cyrillic Greco e cirillico + Green Verde + Grid Griglia + Grid Color & Opacity Colore e opacità griglia + Grid Colors: Colori griglia: + Grid Size: Dimensione griglia: + Gridline every Linea griglia ogni + Gridline every: Linea griglia ogni: + Grids In Back Griglie dietro + Group Raggruppa + Group Selection Tool Strumento Selezione gruppo + Guides Guide + Guides & Grid Guide e griglia + H Spacing: Spaziatura orizzontale: + H: A: + Hair Space Spazio sottilissimo + Hand Tool Strumento Mano + Hand-Drawn Disegnato a mano + Handles Maniglie + Hard Light Luce intensa + Harmony Rules: Regole di armonia: + Harmony Sets Gruppi di armonia + Height Altezza + Height: Altezza: + Help Aiuto + Help › Search Commands… Aiuto › Cerca comandi… + Hex by Column Esagono per colonna + Hex by Row Esagono per riga + Hide Nascondi + Hide Artboards Nascondi tavole da disegno + Hide Bounding Box Nascondi riquadro di delimitazione + Hide Code Nascondi codice + Hide Bar Nascondi barra + More Options Altre opzioni + Show Properties Panel Mostra pannello Proprietà + Hide Corner Widget Nascondi widget angolo + Hide Corner Widget for angles greater than Nascondi widget angolo per angoli maggiori di + Hide Edges Nascondi bordi + Hide Gradient Annotator Nascondi annotatore sfumatura + Hide Grid Nascondi griglia + Hide Guides Nascondi guide + Hide Hidden Characters Nascondi caratteri nascosti + Hide Note Nascondi nota + Hide Options Nascondi opzioni + Hide Others Nascondi altri + Hide Print Tiling Nascondi affiancamento di stampa + Hide Rulers Nascondi righelli + Hide Slices Nascondi sezioni + Hide Text Threads Nascondi concatenamenti testo + Hide Thumbnail Nascondi miniatura + Hide Thumbnails Nascondi miniature + Hide Transparency Grid Nascondi griglia trasparenza + High Alta + High (300 ppi) Alta (300 ppi) + High Performance (discrete) Prestazioni elevate (dedicata) + Highlight Alternate Glyphs Evidenzia glifi alternativi + Highlight anchors on mouse over Evidenzia ancoraggi al passaggio del mouse + Highlight Rows Evidenzia righe + Highlight Substituted Fonts Evidenzia font sostituiti + Highlight Substituted Glyphs Evidenzia glifi sostituiti + History Cronologia + History Options… Opzioni cronologia… + History States Stati cronologia + Hollow Vuoto + Home Home + Horizon Height: Altezza orizzonte: + Horizontal Orizzontale + Horizontal % % orizzontale + Horizontal Align Center Allinea centri orizzontalmente + Horizontal Align Left Allinea a sinistra orizzontalmente + Horizontal Align Right Allinea a destra orizzontalmente + Horizontal Distribute Center Distribuisci orizzontalmente i centri + Horizontal Distribute Left Distribuisci orizzontalmente i bordi sinistri + Horizontal Distribute Right Distribuisci orizzontalmente i bordi destri + Horizontal Distribute Space Distribuisci spazio orizzontalmente + Horizontal Grid: Griglia orizzontale: + Horizontal Plane Piano orizzontale + Horizontal Scale % % scala orizzontale + Horizontal: Orizzontale: + How colours outside the press's gamut are separated. Modalità di separazione dei colori fuori dalla gamma della macchina da stampa. + Hue Tonalità + Hue/Saturation… Tonalità/saturazione… + Hyphenate Sillaba + Hyphenation Sillabazione + Hyphenation… Sillabazione… + ICC Profile Profilo ICC + Identify Objects By Identifica oggetti per + Ignore Ignora + Ignore Artboards (all the art as one page) Ignora tavole da disegno (tutta la grafica come una sola pagina) + Ignore White Ignora bianco + Image Immagine + Image Info Informazioni immagine + Image Map: Mappa immagine: + Image Size Dimensione immagine + Image Trace Ricalco immagine + Image Tracing Oggetto ricalco immagine + Tracing Presets Preset di ricalco + Image Trace Presets Preset ricalco immagine + Image: Immagine: + Images: Immagini: + Import Keyboard Shortcuts… Importa scelte rapide da tastiera… + Import PDF Importa PDF + Import PDF Presets Importa preset PDF + Import Perspective Grid Presets Importa preset griglia prospettica + Import Print Presets Importa preset di stampa + Import Transparency Flattener Presets Importa preset appiattimento trasparenza + Imported {what}: {} Importazione di {what} completata: {} + Import… Importa… + In Tangent Handles Maniglie tangente in entrata + In the selected objects Negli oggetti selezionati + Inches Pollici + Include Blacks with CMY: Includi neri con CMY: + Include Bleed Includi abbondanza + Include Cmy Blacks Includi neri CMY + Include CMYK PostScript in RGB Files Includi PostScript CMYK nei file RGB + Include Document Thumbnails Includi miniature documento + Include Hidden Layers Includi livelli nascosti + Include Linked Files Includi file collegati + Include Metadata Includi metadati + Include non-printing layers Includi livelli non stampabili + Include SVG Code Includi codice SVG + Include Swatches for Tints Includi campioni per tinte + Inflate… Gonfia… + Info Info + Ink Inchiostro + Inner Glow… Bagliore interno… + Input Black Nero di input + Input White Bianco di input + Insert Break Character Inserisci carattere di interruzione + Insert Character Inserisci carattere + Insert Special Character Inserisci carattere speciale + Insert Whitespace Character Inserisci carattere spazio + Inspect Document Ispeziona documento + Inspect Object Ispeziona oggetto + Install Plug-in Installa plug-in + Install Plug-in… Installa plug-in… + Installed plug-in {} Plug-in {} installato + Intensity: Intensità: + Intent: Intento: + Interlaced Interlacciato + Internal CSS CSS interno + Internet Standard RGB (sRGB) RGB standard Internet (sRGB) + Intersect Intersezione + Inverse Inversa + Invert Inverti + Invert Colors Inverti colori + Invert Mask Inverti maschera + Isolate Isola + Isolate Blending Isola fusione + Isolate Group Isola gruppo + Italian Italiano + Japanese Giapponese + Join Unisci + Join Our Discord Unisciti al nostro Discord + Join our Discord Unisciti al nostro Discord + Join the ArtCraft community on Discord (discord.gg/artcraft) Unisciti alla comunità di ArtCraft su Discord (discord.gg/artcraft) + Join the lines of each paragraph Unisci le righe di ogni paragrafo + Join Tool Strumento Unisci + Justification… Giustificazione… + Justify all lines Giustifica tutte le righe + Justify with last line aligned center Giustifica con l'ultima riga centrata + Justify with last line aligned left Giustifica con l'ultima riga allineata a sinistra + Justify with last line aligned right Giustifica con l'ultima riga allineata a destra + Keep a link to an image file instead of only embedding it Mantieni un collegamento al file immagine invece di incorporarlo soltanto + Keep both sides the same width Mantieni la stessa larghezza su entrambi i lati + Keep Formatting Mantieni formattazione + Keep Original Mantieni originale + Keep Plain Text Mantieni solo testo + Keep the pasted color as a new swatch with a numbered name. Mantieni il colore incollato come nuovo campione con un nome numerato. + Keep this row's colors (exclude) Mantieni i colori di questa riga (escludi) + Keep: Mantieni: + Kerning (0 = Auto) Crenatura (0 = auto) + Keyboard Increment Incremento da tastiera + Keyboard Shortcut Conflicts Conflitti tra scelte rapide da tastiera + Keyboard Shortcut Set Set di scelte rapide da tastiera + Keyboard Shortcuts… Scelte rapide da tastiera… + Keywords: Parole chiave: + Knife Coltello + Knockout Group Gruppo con foratura + Lab Lab + Lab Spot Colors: Colori spot Lab: + Lab Values Valori Lab + Landscape Orizzontale + Interface Language Lingua interfaccia + Language Lingua + Language Options Opzioni lingua + Language: Lingua: + Large Grande + Large List View Vista elenco grande + Large Tabs Schede grandi + Large Thumbnail View Vista miniature grandi + Large Thumbnails Miniature grandi + Lasso Tool Strumento Lazo + Last Effect: {name} Ultimo effetto: {name} + Last Effect: {} Ultimo effetto: {} + Last Effect… Ultimo effetto… + Last Page Ultima pagina + Latin Latino + Latin Extended Latino esteso + Latin-1 Supplement Supplemento Latino-1 + Layer Livello + Layer Names Nomi livelli + Layer Options Opzioni livello + Layer Options… Opzioni livello… + Layers Livelli + Layers Panel Options Opzioni pannello Livelli + Layout: Layout: + Leader: Carattere di riempimento: + Leading Interlinea + Left Sinistra + Left Grid: Griglia sinistra: + Left in Front Sinistra davanti + Left Indent Rientro sinistro + Left Plane Piano sinistro + Left-Justified Tab Tabulazione a sinistra + Left-to-Right Paragraph Direction Direzione paragrafo da sinistra a destra + Left: Sinistra: + Legacy Macintosh RGB (Gamma 1.8) RGB Macintosh tradizionale (gamma 1.8) + Legacy vector clipboard Appunti vettoriali tradizionali + Legacy vector clipboard (no transparency) Appunti vettoriali tradizionali (senza trasparenza) + Less Meno + Letter Lettera + Levels… Livelli tonali… + Libraries Librerie + Ligatures are off while the text is tracked. Le legature sono disattivate quando al testo è applicata una spaziatura caratteri. + Light Chiaro + Light Blue Azzurro + Lighten Schiarisci + Lightness Luminosità + Limit Color Guide to Library Limita guida colori alla libreria + Limit colors to swatch library Limita colori alla libreria campioni + Limit colors to swatch library: {name} Limita colori alla libreria campioni: {name} + Limit to Library: Limita alla libreria: + Limit: Limite: + Line Linea + Line Art and Text Resolution: Risoluzione grafica al tratto e testo: + Line Breaks Interruzioni di riga + Line Color Colore linea + Line Cut Taglio linea + Line Cut Tool Strumento Taglio linea + Line Endings: Fine riga: + Line Graph Tool Strumento Grafico a linee + Line Segment Segmento linea + Line Segment Tool Strumento Segmento linea + Line Segment Tool Options Opzioni strumento Segmento linea + Line-end Punctuation Half Width Punteggiatura di fine riga a mezza larghezza + Linear Gradient Sfumatura lineare + Lines Linee + Lines: clicks add points joined by a line Linee: ogni clic aggiunge punti uniti da una linea + Link Collega + Link harmony colors Collega colori armonia + Link Info Informazioni collegamento + Link Opacity Mask Collega maschera di opacità + Link start and end arrowhead scales Collega scale delle punte di freccia iniziale e finale + Link the mask Collega la maschera + Linked Collegato + Linked File File collegato + Linked File Not Found File collegato non trovato + Links Collegamenti + Liquify Fluidifica + List Graphic Styles Elenca stili grafici + List Keyboard Shortcuts Elenca scelte rapide da tastiera + List Patterns Elenca motivi + List Plug-ins Elenca plug-in + List Preferences Elenca preferenze + List Slices Elenca sezioni + List View Vista elenco + List Workspaces Elenca aree di lavoro + Live Paint Pittura dinamica + Live Paint Bucket Secchiello pittura dinamica + Live Paint Bucket (Stroke) Secchiello pittura dinamica (traccia) + Live Paint Info Informazioni pittura dinamica + Live Paint Selection Tool Strumento Selezione pittura dinamica + Live Shape Properties Proprietà forma dinamica + Load Color Profile… Carica profilo colore… + Load Image into Clipboard Carica immagine negli appunti + Load Metafile into Clipboard Carica metafile negli appunti + Load PDF into Clipboard Carica PDF negli appunti + Load Place Cursor Carica cursore di inserimento + Load Profile… Carica profilo… + Load SVG into Clipboard Carica SVG negli appunti + Load Text into Clipboard Carica testo negli appunti + Local Libraries Librerie locali + Locate Object Individua oggetto + Location Posizione + Location: Posizione: + Lock Blocca + Lock (⌘2) Blocca (⌘2) + Lock Grid Blocca griglia + Lock Guides Blocca guide + Lock Others Blocca altri + Lock Slices Blocca sezioni + Lock Station Point Blocca punto di osservazione + Lossless (lossy WebP isn't available yet) Senza perdita (WebP con perdita non è ancora disponibile) + Lossy: Con perdita: + Low Bassa + lowercase minuscole + Luminosity Luminanza + LZW Compression Compressione LZW + Mac Mac + Magenta Magenta + Magic Wand Bacchetta magica + Magic Wand Options Opzioni bacchetta magica + Magic Wand Settings Impostazioni bacchetta magica + Magic Wand Tool Strumento Bacchetta magica + Maintain Envelope Shape Mantieni forma involucro + Make Crea + Make a theme on Create and save it. Crea un tema nella scheda Crea e salvalo. + Make all bleed settings the same Usa lo stesso valore per tutte le abbondanze + Make and Expand Crea ed espandi + Make and Expand… Crea ed espandi… + Make Clipping Mask Crea maschera di ritaglio + Make Compound Shape Crea forma composta + Make Envelope Crea involucro + Make Guides Crea guide + Make Mask Crea maschera + Make Opacity Mask Crea maschera di opacità + Make Pixel Perfect Allinea ai pixel + Make the bleed values differ Usa valori di abbondanza diversi + Make with Mesh… Crea con trama… + Make with Top Object Crea con oggetto superiore + Make with Warp… Crea con alterazione… + Make/Release Clipping Mask Crea/rilascia maschera di ritaglio + Make… Crea… + Manage Workspaces Gestisci aree di lavoro + Manage Workspaces… Gestisci aree di lavoro… + Manually Manualmente + Mark as trapped Contrassegna come sottoposto a trapping + Mark Older Files as [Converted] When Opened Contrassegna i file meno recenti come [Convertito] all'apertura + Marker… Indicatore… + Marks Segni + Marks and Bleed Segni e abbondanza + Marks and Bleeds Segni e abbondanze + Match User Interface Brightness Adatta alla luminosità dell'interfaccia utente + Materials… Materiali… + Matte Colore alone + Matte: Colore alone: + Maximize Massimizza + Maximum Massima + Maximum Editability Massima modificabilità + Measure Tool Strumento Misura + Measurement Labels Etichette di misura + Media Supporto + Medium Media + Medium (150 ppi) Media (150 ppi) + Medium Dark Scuro medio + Medium Light Chiaro medio + Medium Thumbnail View Vista miniature medie + Medium Thumbnails Miniature medie + Menu Dialog Finestra di dialogo menu + Merge Fondi + Merge colors into one row Unisci colori in una riga + Merge Graphic Styles Unisci stili grafici + Merge Graphic Styles… Unisci stili grafici… + Merge Layers Unisci livelli + Merge Selected Unisci selezionati + Merge Swatches Unisci campioni + Mesh Tool Strumento Trama + Message: Messaggio: + Metadata: Metadati: + Metallic Gradients Sfumature metalliche + Meters Metri + Method: Metodo: + Millimeters Millimetri + Minify Minifica + Minimal Minimale + Minimize Riduci a icona + Minus Back Meno dietro + Minus Front Meno davanti + Mirror Specchia + Mirror & Cut Specchia e taglia + Mirror & Cut Tool Strumento Specchia e taglia + Missing Mancante + Missing: {path} Mancante: {path} + Miter Join Unione ad angolo vivo + Miter Limit Limite angolo vivo + Miter Limit: Limite angolo vivo: + Mixed Appearances Aspetti misti + Mixed Objects Oggetti misti + Mode: Modalità: + Model Modello + Modified Modificato + Modified since it was read: {path} Modificato dopo la lettura: {path} + Modified: Modificato: + Modify Modifica + Mojikumi Mojikumi + Mojikumi Set Set mojikumi + Monitor RGB RGB monitor + Mono Mono + Monochrome images Immagini monocromatiche + Monospaced Monospaziato + More Altro + More Pathfinder options Altre opzioni di Elaborazione tracciati + More Settings Altre impostazioni + Move Sposta + Move All Objects Sposta tutti gli oggetti + Move Anchors Sposta ancoraggi + Move Appearance Sposta aspetto + Move Artboard Sposta tavola da disegno + Move Artboard Up/Down Sposta tavola da disegno su/giù + Move Direction Handle Sposta maniglia di direzione + Move Down Sposta giù + Move Effect Sposta effetto + Move Envelope Mesh Point Sposta punto trama involucro + Move Graphic Style Sposta stile grafico + Move Guide Sposta guida + Move in Perspective Sposta in prospettiva + Move Locked and Hidden Artwork with Artboard Sposta grafica bloccata e nascosta con la tavola da disegno + Move Mesh Point Sposta punto trama + Move Plane Sposta piano + Move Plane to Match Object Sposta piano in base all'oggetto + Move Rows Sposta righe + Move Slices Sposta sezioni + Move Spine Point Sposta punto dorsale + Move Swatch Sposta campione + Move Up Sposta su + Move… Sposta… + Multiply Moltiplica + My Themes I miei temi + N pt per N pt per + N slices …, evenly spaced N sezioni …, spaziate uniformemente + Name Nome + Name 40% Nome 40% + Name* @ 66.67 % (RGB/Preview) Nome* @ 66,67 % (RGB/Anteprima) + Name* @ 66.67% (RGB/Preview) Nome* @ 66,67% (RGB/Anteprima) + Name: Nome: + Navigate Naviga + Navigator Navigatore + Needs the desktop app Richiede l'app desktop + Neutral Gradients Sfumature neutre + New Nuovo + New Art Appearance Aspetto nuova grafica + New Art Brush from Selection Nuovo pennello artistico dalla selezione + New Art Has Basic Appearance La nuova grafica ha aspetto di base + New Artboard Nuova tavola da disegno + New Bristle Brush Nuovo pennello a setole + New Brush… Nuovo pennello… + New Calligraphic Brush Nuovo pennello calligrafico + New Character Style Nuovo stile carattere + New Color Group Nuovo gruppo colori + New Color Group… Nuovo gruppo colori… + New Document Presets Preset nuovo documento + New file Nuovo file + New from Template Nuovo da modello + New from Template… Nuovo da modello… + New Graphic Style Nuovo stile grafico + New Graphic Style (Alt-click to name it) Nuovo stile grafico (Alt+clic per assegnare un nome) + New Graphic Style… Nuovo stile grafico… + New Layer Options… Opzioni nuovo livello… + New Layer… Nuovo livello… + New Opacity Masks Are Clipping Le nuove maschere di opacità ritagliano + New Opacity Masks Are Inverted Le nuove maschere di opacità sono invertite + New Paragraph Style Nuovo stile paragrafo + New Pattern Brush from Selection Nuovo pennello motivo dalla selezione + New PDF Preset Nuovo preset PDF + New Print Preset Nuovo preset di stampa + New Scatter Brush from Selection Nuovo pennello a dispersione dalla selezione + New Sublayer… Nuovo sottolivello… + New Swatch Nuovo campione + New Swatch… Nuovo campione… + New Symbol Nuovo simbolo + New Symbol… Nuovo simbolo… + New theme from the current color Nuovo tema dal colore corrente + New View Nuova vista + New View… Nuova vista… + New Window Nuova finestra + New Workspace Nuova area di lavoro + New Workspace… Nuova area di lavoro… + New {kind} Style… Nuovo stile {kind}… + New… Nuovo… + Next Successivo + Next Library Libreria successiva + Next Object Above Oggetto successivo sopra + Next Object Below Oggetto successivo sotto + Next Page Pagina successiva + Next page Pagina successiva + No actions. Press ● to record. Nessuna azione. Premi ● per registrare. + No assets Nessuna risorsa + No assets yet. Collect art with Object › Collect for Export, or drag it into the Asset Export panel. Ancora nessuna risorsa. Raccogli la grafica con Oggetto › Raccogli per l'esportazione oppure trascinala nel pannello Esportazione risorse. + No Break Nessuna interruzione + No brushes Nessun pennello + No colors to recolor (preserved colors are left out). Nessun colore da ricolorare (i colori conservati sono esclusi). + No CSS Nessun CSS + No document Nessun documento + No Document Nessun documento + No document open Nessun documento aperto + No document open. Nessun documento aperto. + No filter plug-ins installed Nessun plug-in filtro installato + No fonts are available. Nessun font disponibile. + No gradient swatches Nessun campione sfumatura + No graphic styles Nessuno stile grafico + No images Nessuna immagine + No matches. Nessuna corrispondenza. + No matching fonts Nessun font corrispondente + No options Nessuna opzione + No printer settings to open here Nessuna impostazione stampante da aprire qui + No saved themes Nessun tema salvato + No saved views (View → New View…) Nessuna vista salvata (Visualizza → Nuova vista…) + No Selection Nessuna selezione + No selection Nessuna selezione + No symbols in this document Nessun simbolo in questo documento + No text selected Nessun testo selezionato + No Thumbnails Nessuna miniatura + Noise Disturbo + Nonbreaking Hyphen Trattino indivisibile + Nonbreaking Space Spazio indivisibile + None Nessuno + None (/) Nessuno (/) + None (keep transparency) Nessuno (mantieni trasparenza) + None. Nessuno. + Normal Normale + Normal Screen Mode Modalità schermo normale + Note: Nota: + Nothing matches the Show filter. Nessun elemento corrisponde al filtro Mostra. + Nothing to print Niente da stampare + Nudge Sposta leggermente + Nudge in Perspective Sposta leggermente in prospettiva + Number of Artboards: Numero di tavole da disegno: + Number of Colors: Numero di colori: + Number of Recent Files to Display Numero di file recenti da visualizzare + Number of Recent Fonts Numero di font recenti + Numbers Without Units Are Points I numeri senza unità sono punti + Object Oggetto + Object Highlighting Evidenziazione oggetti + Object IDs: ID oggetto: + Object Name Nome oggetto + Object Properties Proprietà oggetto + Object Selection by Path Only Selezione oggetti solo tramite tracciato + Objects Oggetti + Objects using them keep their look but are no longer linked. Gli oggetti che li usano mantengono il loro aspetto ma non sono più collegati. + of characters used dei caratteri usati + of {count} di {count} + Off Disattivato + Offset Path Sposta tracciato + Offset Path… Sposta tracciato… + Offset X Spostamento X + Offset: Spostamento: + OK OK + On Attivato + On Copy Durante la copia + On Paste Durante l'incollamento + On Screen Su schermo + One file per artboard: -.{ext} Un file per tavola da disegno: -.{ext} + One page per artboard. Una pagina per tavola da disegno. + One Point Un punto + One Point Perspective Prospettiva a un punto + One Point Perspective Preset 1 Preset prospettiva a un punto 1 + One Point Perspective Preset 2 Preset prospettiva a un punto 2 + One Point Perspective Preset 3 Preset prospettiva a un punto 3 + One Point Perspective Preset 4 Preset prospettiva a un punto 4 + One Point Perspective Preset 5 Preset prospettiva a un punto 5 + Only Web Colors Solo colori web + Opacity Opacità + Opacity & Mask Define Knockout Shape Opacità e maschera definiscono la forma di foratura + Opacity Mask Maschera di opacità + Opacity Mask Info Informazioni maschera di opacità + Opacity Mask Options Opzioni maschera di opacità + Opacity: Opacità: + Opacity: 50% Multiply Opacità: 50% Moltiplica + Opacity: Default Opacità: predefinita + Opacity: {value} Opacità: {value} + Opaque Opaco + Open Apri + Open a document to edit its patterns. Apri un documento per modificarne i motivi. + Open a document to navigate it. Apri un documento per navigare al suo interno. + Open a document to preview its flattening. Apri un documento per vedere l'anteprima dell'appiattimento. + Open a document to preview its pages Apri un documento per vedere l'anteprima delle pagine + Open a document to see its artboards. Apri un documento per vederne le tavole da disegno. + Open a document to see its graphic styles. Apri un documento per vederne gli stili grafici. + Open a document to see its history. Apri un documento per vederne la cronologia. + Open a document to see its swatches. Apri un documento per vederne i campioni. + Open Document Apri documento + Open Documents As Tabs Apri documenti come schede + Open Graphic Style Library Apri libreria stili grafici + Open Location after Export Apri posizione dopo l'esportazione + Open password: Password di apertura: + Open Paths Tracciati aperti + Open Recent File 1 Apri file recente 1 + Open Recent File 10 Apri file recente 10 + Open Recent File 11 Apri file recente 11 + Open Recent File 12 Apri file recente 12 + Open Recent File 13 Apri file recente 13 + Open Recent File 14 Apri file recente 14 + Open Recent File 15 Apri file recente 15 + Open Recent File 16 Apri file recente 16 + Open Recent File 17 Apri file recente 17 + Open Recent File 18 Apri file recente 18 + Open Recent File 19 Apri file recente 19 + Open Recent File 2 Apri file recente 2 + Open Recent File 20 Apri file recente 20 + Open Recent File 21 Apri file recente 21 + Open Recent File 22 Apri file recente 22 + Open Recent File 23 Apri file recente 23 + Open Recent File 24 Apri file recente 24 + Open Recent File 25 Apri file recente 25 + Open Recent File 26 Apri file recente 26 + Open Recent File 27 Apri file recente 27 + Open Recent File 28 Apri file recente 28 + Open Recent File 29 Apri file recente 29 + Open Recent File 3 Apri file recente 3 + Open Recent File 30 Apri file recente 30 + Open Recent File 4 Apri file recente 4 + Open Recent File 5 Apri file recente 5 + Open Recent File 6 Apri file recente 6 + Open Recent File 7 Apri file recente 7 + Open Recent File 8 Apri file recente 8 + Open Recent File 9 Apri file recente 9 + Open Recent Files Apri file recenti + Open Swatch Library Apri libreria campioni + Open the URL in the web browser Apri l'URL nel browser web + Opened with {} note(s): {} Aperto con note ({}): {} + Open… Apri… + Optical Margin Alignment Allineamento ottico dei margini + Optimize for fast web view Ottimizza per visualizzazione web veloce + Optimized Ottimizzato + Options Opzioni + Options for Selection… Opzioni per la selezione… + Options: Opzioni: + Options… Opzioni… + or more spaces with a tab o più spazi con una tabulazione + Order: Ordine: + Ordinals Ordinali + Orientation Orientamento + Orientation: Orientamento: + Original Originale + Original: click to restore Originale: fai clic per ripristinare + Other Altro + Other Layers Altri livelli + Other Libraries Altre librerie + Other Library… Altra libreria… + Other Script… Altro script… + Out of Gamut Warning Avviso fuori gamma + Out of Web Color Warning Avviso colore non web + Out Tangent Handles Maniglie tangente in uscita + Outer Glow… Bagliore esterno… + Outline Contorno + Outline Others Altri in contorno + Outline Stroke Contorna traccia + Outline Text Contorna testo + Outlines and Rules Contorni e filetti + Output Output + Output All Blacks Accurately Riproduci tutti i neri con precisione + Output All Blacks as Rich Black Riproduci tutti i neri come nero ricco + Output Black Nero di output + Output condition: Condizione di output: + Output Intent Intento di output + Output intent profile: Profilo intento di output: + Output White Bianco di output + Output › Mode Output › Modalità + Output: Output: + Overlap: Sovrapposizione: + Overlapping Sovrapposti + Overlay Sovrapponi + Overprint Sovrastampa + Overprint and Transparency Flattener Sovrastampa e appiattimento trasparenza + Overprint and Transparency Flattener Options Opzioni sovrastampa e appiattimento trasparenza + Overprint Black… Sovrastampa nero… + Overprint Fill Sovrastampa riempimento + Overprint Preview Anteprima sovrastampa + Overprint Preview (separations) Anteprima sovrastampa (separazioni) + Overprint Stroke Sovrastampa traccia + Overprint: Sovrastampa: + Overprints: Sovrastampe: + Override Character Color Sostituisci colore carattere + Package Crea pacchetto + Package collects a saved document with its linked files and fonts. Il comando Crea pacchetto raccoglie un documento salvato insieme ai file collegati e ai font. + Package created Pacchetto creato + Packaged {n} file(s) in {folder}{note} Pacchetto creato con {n} file in {folder}{note} + Packaged {n} file(s){note} Pacchetto creato con {n} file{note} + Package… Crea pacchetto… + Page Pagina + Page information Informazioni pagina + Page Isolated Blending Fusione isolata pagina + Page Knockout Group Gruppo foratura pagina + Pages Pagine + Paintbrush Pennello + Paintbrush Tool Strumento Pennello + Panel menu Menu del pannello + Panel Options… Opzioni pannello… + Panels Pannelli + Paragraph Paragrafo + Paragraph Style Stile paragrafo + Paragraph Style Options Opzioni stile paragrafo + Paragraph Styles Stili paragrafo + Paragraph Symbol Segno di paragrafo + Part of ArtCraft. MIT OR Apache-2.0. Fonts: Source Sans 3, Inter, JetBrains Mono (OFL). Icons: Lucide (ISC) + VectorCraft. Parte di ArtCraft. MIT OR Apache-2.0. Font: Source Sans 3, Inter, JetBrains Mono (OFL). Icone: Lucide (ISC) + VectorCraft. + Password Password + Paste Incolla + Paste in Back Incolla dietro + Paste in Front Incolla davanti + Paste in Place Incolla nella stessa posizione + Paste Offset Spostamento all'incollamento + Paste on All Artboards Incolla su tutte le tavole da disegno + Paste Remembers Layers Incolla nei livelli originali + Paste without Formatting Incolla senza formattazione + Pasted Incollato + Pastels Colori pastello + Path Tracciato + Path Eraser Gomma tracciato + Path Eraser Tool Strumento Gomma tracciato + Pathfinder Elaborazione tracciati + Pathfinder Options… Opzioni elaborazione tracciati… + Pathfinders: Elaborazioni tracciati: + Paths Tracciati + Paths: {paths} Anchors: {anchors} Colors: {colors} Tracciati: {paths} Ancoraggi: {anchors} Colori: {colors} + Pattern Motivo + Pattern Editing Modifica motivo + Pattern Options Opzioni motivo + Pattern options are available in pattern editing mode. Le opzioni motivo sono disponibili in modalità di modifica motivo. + PDF PDF + PDF 1.3 files have no transparency: the preset flattens it. I file PDF 1.3 non supportano la trasparenza: il preset la appiattisce. + PDF Info Informazioni PDF + PDF Preset Preset PDF + PDF Preset: Preset PDF: + PDF Presets Preset PDF + PDF Presets… Preset PDF… + PDF Settings Impostazioni PDF + PDF/A files carry their own output intent. I file PDF/A includono il proprio intento di output. + PDF/X-1a files are CMYK: every colour is converted to the destination (blank: the output intent's CMYK profile), untagged. I file PDF/X-1a sono CMYK: ogni colore viene convertito nella destinazione (se vuota: il profilo CMYK dell'intento di output), senza tag. + Pen Tool Strumento Penna + Pencil Matita + Pencil Tool Strumento Matita + per slice per sezione + Percent: Percentuale: + Perceptual Scales Scale percettive + Performance Prestazioni + Performance & Storage Prestazioni e archiviazione + Permissions Autorizzazioni + Permissions password: Password autorizzazioni: + Perspective Prospettiva + Perspective Grid Griglia prospettica + Perspective Grid Options Opzioni griglia prospettica + Perspective Grid Preset Preset griglia prospettica + Perspective Grid Presets Preset griglia prospettica + Perspective grid presets Preset griglia prospettica + Perspective Grid Presets… Preset griglia prospettica… + Perspective Grid Settings Impostazioni griglia prospettica + Perspective Grid Tool Strumento Griglia prospettica + Perspective Plane Options… Opzioni piano prospettico… + Perspective Selection Tool Strumento Selezione prospettica + Phone 390×844 Telefono 390×844 + Picas Pica + Pie Graph Tool Strumento Grafico a torta + Pixel Preview Anteprima pixel + Pixels Pixel + Place Inserisci + Place DXF Inserisci DXF + Place onto a new locked, dimmed template layer below the current layer Inserisci in un nuovo livello modello bloccato e attenuato sotto il livello corrente + Place PDF Inserisci PDF + Place Symbol Instance Inserisci istanza simbolo + Place the pages with the placement again Inserisci di nuovo le pagine con lo stesso posizionamento + Placed File Info Informazioni file inserito + Placement Options Opzioni di posizionamento + Placement Options… Opzioni di posizionamento… + Placement: Posizionamento: + Place… Inserisci… + Plates Lastre + Platform: Piattaforma: + Play Current Selection Esegui selezione corrente + Plug-in Info Informazioni plug-in + Plug-ins Plug-in + Plug-in… Plug-in… + Point Sample Campionamento puntuale + Point Text Objects Oggetti testo per punti + Points Punti + Points: clicks add free points Punti: ogni clic aggiunge punti liberi + Polar Grid Griglia polare + Polar Grid Tool Strumento Griglia polare + Polygon Poligono + Polygon Properties: Proprietà poligono: + Polygon Tool Strumento Poligono + Portrait Verticale + Power Saving (integrated) Risparmio energetico (integrata) + Portuguese Portoghese + Position Posizione + Postcard Cartolina + PostScript: PostScript: + PPI PPI + Preferences Preferenze + Preferences… Preferenze… + Prefix: Prefisso: + Presentation Attributes Attributi di presentazione + Presentation Mode Modalità presentazione + Preserve Alpha Transparency Mantieni trasparenza alfa + Preserve Appearance and Overprints Mantieni aspetto e sovrastampe + Preserve CMYK Numbers Mantieni valori CMYK + Preserve Editing Capabilities Mantieni possibilità di modifica + Preserve editing capabilities Mantieni possibilità di modifica + Preserve Lightness Mantieni luminosità + Preserve Overprints and Spot Colors Mantieni sovrastampe e colori spot + Preserve Paths Mantieni tracciati + Preserve Shape Using: Mantieni forma con: + Preserve Spot Colors Mantieni colori spot + Preserve Text Appearance Mantieni aspetto del testo + Preserve Text Editability Mantieni modificabilità del testo + Preserve: Mantieni: + PRESET DETAILS DETTAGLI PRESET + Preset Name Nome preset + Preset name: Nome preset: + Preset {} Preset {} + Preset: Preset: + Presets you save with the Save Preset button appear here. I preset salvati con il pulsante Salva preset vengono visualizzati qui. + Presets: Preset: + Press Premi + Preview Anteprima + Preview All Layers Anteprima di tutti i livelli + Preview in Browser Anteprima nel browser + Preview in Browser needs the desktop app (the web downloads files instead) Anteprima nel browser richiede l'app desktop (la versione web scarica invece i file) + Preview Mode Modalità anteprima + Preview the document as it is now Visualizza l'anteprima del documento nello stato attuale + Previous Precedente + Previous Library Libreria precedente + Previous Page Pagina precedente + Previous page Pagina precedente + Primary Principale + Print Stampa + Print as Bitmap Stampa come bitmap + Print Layers: Stampa livelli: + Print Preset Preset di stampa + Print Preset: Preset di stampa: + Print Presets Preset di stampa + Print presets Preset di stampa + Print Presets… Preset di stampa… + Print Preview Anteprima di stampa + Print Setup Impostazione di stampa + Print Tiling Affiancamento di stampa + Print Tiling Pages Pagine affiancamento di stampa + Print Tiling Tool Strumento Affiancamento di stampa + Printer Stampante + Printer mark type: Tipo di segni di stampa: + Printer profile: Profilo stampante: + Printer Setup… Impostazione stampante… + Printer: Stampante: + Printers Stampanti + Printing / Exporting Stampa / Esportazione + Printing allowed: Stampa consentita: + Print… Stampa… + Process Color Colore quadricromia + Profile inclusion: Inclusione profilo: + Profile: Profilo: + Progressive Progressivo + Projecting Cap Estremità sporgente + Proof Colors Colori di prova + Proof Setup Impostazione prova + Properties Proprietà + Proportional Oldstyle Proporzionale vecchio stile + Pucker & Bloat… Contrai e gonfia… + Pucker Tool Strumento Contrai + Punctuation Punteggiatura + Punctuation Space Spazio di punteggiatura + Puppet Warp Alterazione marionetta + Puppet Warp Pins Perni alterazione marionetta + Puppet Warp Tool Strumento Alterazione marionetta + Quality {quality} Qualità {quality} + Quality: Qualità: + Quarter Space Quarto di spazio + Quick Actions Azioni rapide + Quickly start a new file Inizia rapidamente un nuovo file + Quit VectorCraft Esci da VectorCraft + Radar Graph Tool Strumento Grafico radar + Radial Radiale + Radial Glows Bagliori radiali + Radial Gradient Sfumatura radiale + Radius 1 Raggio 1 + Radius 2 Raggio 2 + Radius1 Raggio1 + Radius2 Raggio2 + Rainbow Arcobaleno + Random Casuale + Randomize Colors Colori casuali + Randomly change color order Cambia casualmente l'ordine dei colori + Randomly change saturation and brightness Cambia casualmente saturazione e luminosità + Range: Intervallo: + Raster Effects Effetti raster + Raster File Format: Formato file raster: + Raster Sample Size: Dimensione campione raster: + Raster/Vector Balance: Bilanciamento raster/vettoriale: + Rasterize Rasterizza + Rasterize Unsupported Art Rasterizza grafica non supportata + Rasterize… Rasterizza… + Rasters Raster + Rating: Valutazione: + Real World: Mondo reale: + Real-time Drawing and Editing Disegno e modifica in tempo reale + Rearrange All Artboards (on the roadmap) Ridisponi tutte le tavole da disegno (in programma) + Rearrange All Artboards… Ridisponi tutte le tavole da disegno… + Recall Selection Richiama selezione + RECENT RECENTI + Recent Recenti + Recent Colors Colori recenti + Recent File File recente + Recent Files File recenti + Recent Font Font recente + Recent Font 1 Font recente 1 + Recent Font 10 Font recente 10 + Recent Font 11 Font recente 11 + Recent Font 12 Font recente 12 + Recent Font 13 Font recente 13 + Recent Font 14 Font recente 14 + Recent Font 15 Font recente 15 + Recent Font 2 Font recente 2 + Recent Font 3 Font recente 3 + Recent Font 4 Font recente 4 + Recent Font 5 Font recente 5 + Recent Font 6 Font recente 6 + Recent Font 7 Font recente 7 + Recent Font 8 Font recente 8 + Recent Font 9 Font recente 9 + Recent Fonts Font recenti + Recent URLs URL recenti + Recolor Ricolora + Recolor Artwork Ricolora grafica + Recolor Artwork… Ricolora grafica… + Recolor this row Ricolora questa riga + Recolor with Preset Ricolora con preset + Recover Documents Recupera documenti + Recovery Data Dati di recupero + Rectangle Rettangolo + Rectangle Cut Taglio rettangolare + Rectangle Cut Tool Strumento Taglio rettangolare + Rectangle Properties: Proprietà rettangolo: + Rectangle Tool Strumento Rettangolo + Rectangle: Sunshine Rettangolo: Sole + Rectangle… Rettangolo… + Rectangular Grid Griglia rettangolare + Rectangular Grid Tool Strumento Griglia rettangolare + Red Rosso + Redefine Character Style Ridefinisci stile carattere + Redefine Graphic Style Ridefinisci stile grafico + Redefine Graphic Style “{name}” Ridefinisci stile grafico “{name}” + Redefine Paragraph Style Ridefinisci stile paragrafo + Redefine Symbol Ridefinisci simbolo + Redefine {kind} Style Ridefinisci stile {kind} + Redo Ripeti + Redo {name} Ripeti {name} + Redo {} Ripeti {} + Reduce Colors Riduci colori + Reduce to Basic Appearance Riduci ad aspetto di base + Reduction: Riduzione: + Reference Point Punto di riferimento + Reflect Rifletti + Reflect Horizontal Rifletti orizzontalmente + Reflect Tool Strumento Rifletti + Reflect X Rifletti X + Reflect Y Rifletti Y + Reflect… Rifletti… + Refresh Aggiorna + Refresh Font List Aggiorna elenco font + Registered Trademark Symbol Simbolo di marchio registrato + Registration marks Segni di registro + Registry name: Nome registro: + Regular Regular + Release Rilascia + Release Compound Shape Rilascia forma composta + Release Guides Rilascia guide + Release Opacity Mask Rilascia maschera di opacità + Release Selection Rilascia selezione + Release to Layers (Build) Rilascia su livelli (accumulo) + Release to Layers (Sequence) Rilascia su livelli (sequenza) + Release with Perspective Rilascia con prospettiva + Relink Ricollega + Relink Linked Files to the Document Ricollega i file collegati al documento + Relink to Folder… Ricollega a cartella… + Relinked {n} image(s) Immagini ricollegate: {n} + Relinked {n} image(s); not in that folder: {} Immagini ricollegate: {n}; non presenti in quella cartella: {} + Relinked {} image(s) Immagini ricollegate: {} + Relink… Ricollega… + Reload Plug-ins Ricarica plug-in + Remove Rimuovi + Remove Anchor Points Rimuovi punti di ancoraggio + Remove Asset Rimuovi risorsa + Remove blank lines between paragraphs Rimuovi righe vuote tra i paragrafi + Remove Brush Stroke Rimuovi traccia pennello + Remove Effect Rimuovi effetto + Remove Guide Rimuovi guida + Remove Item Rimuovi elemento + Remove Plug-in Rimuovi plug-in + Remove Selected Assets Rimuovi risorse selezionate + Remove Threading Rimuovi concatenamento + Remove “{keyword}” Rimuovi “{keyword}” + Rename Rinomina + Rename Asset Rinomina risorsa + Rename Character Style Rinomina stile carattere + Rename Graphic Style Rinomina stile grafico + Rename Paragraph Style Rinomina stile paragrafo + Rename Workspace Rinomina area di lavoro + Render Threads (-1 = Automatic) Thread di rendering (-1 = automatico) + Rendering intent: Intento di rendering: + Reorder Riordina + Reorder Appearance Item Riordina elemento aspetto + Repeat Ripetizione + Repeat Options Opzioni di ripetizione + Repeat Pathfinder Ripeti Elaborazione tracciati + Repeat Tab Ripeti tabulazione + Repeat {name} Ripeti {name} + Replace Sostituisci + Replace Font Sostituisci font + Replace it with another file, or ignore it: its images keep showing the preview saved with the document. Sostituiscilo con un altro file oppure ignoralo: le sue immagini continueranno a mostrare l'anteprima salvata con il documento. + Replace Spine Sostituisci dorsale + Replace Symbol Sostituisci simbolo + Replace With Font Sostituisci con font + Replaces the saved preset of that name. Sostituisce il preset salvato con quel nome. + Replace… Sostituisci… + Require a password to open the document Richiedi una password per aprire il documento + Reselect Riseleziona + Reset Reimposta + Reset Bounding Box Reimposta riquadro di delimitazione + Reset Envelope Mesh Reimposta trama involucro + Reset Envelope Shape Reimposta forma involucro + Reset Essentials Reimposta Essentials + Reset Keyboard Shortcuts Reimposta scelte rapide da tastiera + Reset OpenType Features Reimposta funzioni OpenType + Reset Panel Reimposta pannello + Reset Preferences Reimposta preferenze + Reset Profiles Reimposta profili + Reset Rotate View Reimposta rotazione vista + Reset the rows to the artwork's colors Reimposta le righe sui colori della grafica + Reset to Default Reimposta valori predefiniti + Reset to White, Black Reimposta su bianco, nero + Reset with Mesh Reimposta con trama + Reset with Mesh… Reimposta con trama… + Reset with Warp Reimposta con alterazione + Reset with Warp… Reimposta con alterazione… + Reset {name} Reimposta {name} + Reset {} Reimposta {} + Reshape Rimodella + Reshape Segment Rimodella segmento + Reshape Tool Strumento Rimodella + Reshape Type Area Rimodella area di testo + Resolution: Risoluzione: + Responsive Adattivo + Restore Ripristina + Restore every preference to its default (applied on OK) Ripristina tutte le preferenze ai valori predefiniti (applicato con OK) + Restore Recovered Documents Ripristina documenti recuperati + Restored documents open unsaved: save them to keep them. I documenti ripristinati si aprono senza essere salvati: salvali per conservarli. + Restored {} recovered document(s): save them to keep them Documenti recuperati ripristinati: {}. Salvali per conservarli + Restrict printing, editing and other tasks Limita la stampa, la modifica e altre operazioni + Reverse Front to Back Inverti davanti/dietro + Reverse Gradient Inverti sfumatura + Reverse Order Inverti ordine + Reverse Path Direction Inverti direzione tracciato + Reverse Path Direction Off Inverti direzione tracciato disattivato + Reverse Path Direction On Inverti direzione tracciato attivato + Reverse Spine Inverti dorsale + Revert Ripristina + Revert to the saved version of “{name}”? Ripristinare la versione salvata di “{name}”? + Revolve… Rivoluzione… + RGB Color Colore RGB + Right Destra + Right Grid: Griglia destra: + Right in Front Destra davanti + Right Indent Rientro destro + Right Plane Piano destro + Right-Justified Tab Tabulazione allineata a destra + Right-to-Left Paragraph Direction Direzione paragrafo da destra a sinistra + Right: Destra: + Rise… Ascesa… + Roman Baseline Linea di base romana + Roman Hanging Punctuation Punteggiatura sporgente romana + Rotate Ruota + Rotate 90° CW Ruota di 90° in senso orario + Rotate Tool Strumento Ruota + Rotate View Tool Strumento Ruota vista + Rotate… Ruota… + Rotation Rotazione + Roughen… Irruvidisci… + Round Cap Estremità arrotondata + Round Corners… Arrotonda angoli… + Round Join Unione arrotondata + Rounded Arrotondato + Rounded Rectangle Rettangolo arrotondato + Rounded Rectangle Tool Strumento Rettangolo arrotondato + Rounded Rectangle… Rettangolo arrotondato… + Row Size: Dimensione riga: + Rows: Righe: + Rule: Regola: + Rulers Righelli + Rulers & Grids Righelli e griglie + Run Plug-in Esegui plug-in + Same Uguale + Same As Source Uguale all'origine + Sample Color Campiona colore + Sans Serif / Gothic Sans serif / Gotico + Saturate Satura + Saturate… Satura… + Saturation Saturazione + Save Salva + Save a Copy Salva una copia + Save a Copy… Salva una copia… + Save As Salva con nome + Save as PDF… Salva come PDF… + Save as preset: Salva come preset: + Save as Template Salva come modello + Save as Template… Salva come modello… + Save As… Salva con nome… + Save changes to {name} Salva le modifiche a {name} + Save color group to Swatch panel Salva il gruppo colori nel pannello Campioni + Save Colors as Swatches Salva colori come campioni + Save Document Salva documento + Save Document Info… Salva informazioni documento… + Save each artboard to a separate file Salva ogni tavola da disegno in un file separato + Save for Office Documents Salva per documenti Office + Save for Office Documents… Salva per documenti Office… + Save for Web Salva per il web + Save for Web (Legacy)… Salva per il web (versione precedente)… + Save for Web Presets Preset di Salva per il web + Save for Web Preview Anteprima di Salva per il web + Save for Web Settings Impostazioni di Salva per il web + Save Graphic Style Library Salva libreria stili grafici + Save Graphic Style Library… Salva libreria stili grafici… + Save Grid as Preset Salva griglia come preset + Save Grid as Preset… Salva griglia come preset… + Save PDF Salva PDF + Save PDF Dialog Finestra di dialogo Salva PDF + Save PDF Preset Salva preset PDF + Save Perspective Grid Preset Salva preset griglia prospettica + Save Preset Salva preset + Save Preset… Salva preset… + Save Print Preset Salva preset di stampa + Save Recovery Data Salva dati di recupero + Save Save for Web Preset Salva preset di Salva per il web + Save selected colors as swatches Salva i colori selezionati come campioni + Save Selection… Salva selezione… + Save Swatch Library Salva libreria campioni + Save Swatch Library… Salva libreria campioni… + Save the current layout under this name Salva il layout corrente con questo nome + Save the document first? Salvare prima il documento? + Save the selected preset to a file Salva il preset selezionato in un file + Save the settings as a preset Salva le impostazioni come preset + Save Theme Salva tema + Save theme to My Themes Salva il tema in I miei temi + Save these settings as a preset Salva queste impostazioni come preset + Save these settings as a print preset Salva queste impostazioni come preset di stampa + Save to Swatches Salva nei campioni + Save To: Salva in: + Save Transparency Flattener Preset Salva preset di appiattimento trasparenza + Save Transparency Flattener Preset… Salva preset di appiattimento trasparenza… + SAVED SALVATI + Saved Salvato + Saved recovery data for {title} Dati di recupero salvati per {title} + Saved Selection 1 Selezione salvata 1 + Saved Selection 10 Selezione salvata 10 + Saved Selection 11 Selezione salvata 11 + Saved Selection 12 Selezione salvata 12 + Saved Selection 13 Selezione salvata 13 + Saved Selection 14 Selezione salvata 14 + Saved Selection 15 Selezione salvata 15 + Saved Selection 16 Selezione salvata 16 + Saved Selection 17 Selezione salvata 17 + Saved Selection 18 Selezione salvata 18 + Saved Selection 19 Selezione salvata 19 + Saved Selection 2 Selezione salvata 2 + Saved Selection 20 Selezione salvata 20 + Saved Selection 21 Selezione salvata 21 + Saved Selection 22 Selezione salvata 22 + Saved Selection 23 Selezione salvata 23 + Saved Selection 24 Selezione salvata 24 + Saved Selection 25 Selezione salvata 25 + Saved Selection 3 Selezione salvata 3 + Saved Selection 4 Selezione salvata 4 + Saved Selection 5 Selezione salvata 5 + Saved Selection 6 Selezione salvata 6 + Saved Selection 7 Selezione salvata 7 + Saved Selection 8 Selezione salvata 8 + Saved Selection 9 Selezione salvata 9 + Saved Selections Selezioni salvate + Saved to User Defined: {} Salvato in Definito dall'utente: {} + Saved View 1 Vista salvata 1 + Saved View 10 Vista salvata 10 + Saved View 2 Vista salvata 2 + Saved View 3 Vista salvata 3 + Saved View 4 Vista salvata 4 + Saved View 5 Vista salvata 5 + Saved View 6 Vista salvata 6 + Saved View 7 Vista salvata 7 + Saved View 8 Vista salvata 8 + Saved View 9 Vista salvata 9 + Saved Views Viste salvate + Saved {n} files beside {path} {n} file salvati accanto a {path} + Saved {path} {path} salvato + Saved {path} with {} note(s): {first} {path} salvato (note: {}): {first} + Saves the current bars, toolbar and panel layout. Salva la disposizione corrente di barre, barra degli strumenti e pannelli. + Save… Salva… + Saving Salvataggio + Saving Poster.vectorcraft Salvataggio di Poster.vectorcraft + Saving recovery data for {} Salvataggio dei dati di recupero per {} + Saving {} Salvataggio di {} + Scale Scala + Scale Corners Scala angoli + Scale Cursor Proportional to UI Scala il cursore in proporzione all'interfaccia + Scale Lineweights Scala spessori linea + Scale Strokes & Effects Scala tracce ed effetti + Scale to Fit Artboard Scala per adattare alla tavola da disegno + Scale Tool Strumento Scala + Scale: Scala: + Scale… Scala… + Scaling Ridimensionamento + Scaling: Ridimensionamento: + Scallop Tool Strumento Smerla + Scans: Scansioni: + Scatter Dispersione + Scatter Graph Tool Strumento Grafico a dispersione + Scissors Tool Strumento Forbici + Scratch Disks Dischi di memoria virtuale + Screen Schermo + Screen (72 ppi) Schermo (72 ppi) + Screen Mode Modalità schermo + Screens Schermi + Scribble… Scarabocchio… + Script / Brush Corsivo / Pennello + Scripts Script + Search Cerca + Search All Cerca ovunque + Search commands and tools Cerca comandi e strumenti + Search commands and tools… Cerca comandi e strumenti… + Search Commands… Cerca comandi… + Secondary Secondario + Section Symbol Simbolo di sezione + Security Sicurezza + Select Selezione + Select a text object Seleziona un oggetto di testo + Select a text object to edit its character attributes. Seleziona un oggetto di testo per modificarne gli attributi di carattere. + Select a text object to edit its paragraph attributes. Seleziona un oggetto di testo per modificarne gli attributi di paragrafo. + Select a text object to set its tab stops. Seleziona un oggetto di testo per impostarne le tabulazioni. + Select All Seleziona tutto + Select All Art on Layer Seleziona tutta la grafica sul livello + Select All Assets Seleziona tutte le risorse + Select All Instances Seleziona tutte le istanze + Select All Pins Seleziona tutti i perni + Select All Unused Seleziona tutti gli elementi non usati + Select an image to see its Link Info. Seleziona un'immagine per vederne le informazioni sul collegamento. + Select an image to trace Seleziona un'immagine da ricalcare + Select Anchors Seleziona punti di ancoraggio + Select Appearance Item Seleziona elemento aspetto + Select Art Seleziona grafica + Select art and choose Object › Pattern › Make. Seleziona la grafica e scegli Oggetto › Motivo › Crea. + Select art and click New Symbol to make one. Seleziona la grafica e fai clic su Nuovo simbolo per crearne uno. + Select art and use New Brush to make one. Seleziona la grafica e usa Nuovo pennello per crearne uno. + Select Freeform Point Seleziona punto libero + Select Gradient Stop Seleziona cursore colore + Select Guides Seleziona guide + Select Objects Seleziona oggetti + Select objects to see their CSS, or Generate CSS for the whole document. Seleziona gli oggetti per vederne il CSS oppure usa Genera CSS per l'intero documento. + Select Same Tint % Seleziona stessa % tinta + Select Slices Seleziona sezioni + Select styled art and click New Graphic Style. Seleziona la grafica con stile e fai clic su Nuovo stile grafico. + Select text Seleziona il testo + Select Text by Font Seleziona testo per font + Select text or click into text with the Type tool to insert glyphs Seleziona il testo o fai clic nel testo con lo strumento Testo per inserire glifi + Select text to set its OpenType features. Seleziona il testo per impostarne le funzioni OpenType. + Select the art (and, on top of it, the mask object) Seleziona la grafica (e, sopra di essa, l'oggetto maschera) + Select Tool Seleziona strumento + Select: Seleziona: + Selected Artwork Grafica selezionata + Selected Styles Only Solo stili selezionati + Selected Swatches Campioni selezionati + Selected Swatches Only Solo campioni selezionati + Selection Selezione + Selection & Anchor Display Visualizzazione selezione e punti di ancoraggio + Selection Only Solo selezione + Selection Tool Strumento Selezione + Send Backward Porta indietro + Send to Back Porta in fondo + Send to Current Layer Sposta sul livello corrente + Sentence case Maiuscola a inizio frase + Separate colors into rows Separa i colori in righe + Separate several keywords with commas. Separa più parole chiave con virgole. + Separations list the document's inks here: one page per ink that prints. Qui le separazioni elencano gli inchiostri del documento: una pagina per ogni inchiostro stampato. + Separations Preview Anteprima separazioni + Serialize Document Serializza documento + Serif / Mincho Serif / Mincho + Server-side (.map) Lato server (.map) + Set 1 Set 1 + Set Anchors Imposta punti di ancoraggio + Set base color Imposta colore di base + Set base color to the current color Imposta il colore corrente come colore di base + Set Bounds Imposta limiti + Set Current Layer Imposta livello corrente + Set Key Object Imposta oggetto chiave + Set Keyboard Shortcut Imposta scelta rapida da tastiera + Set Mesh Point Color Imposta colore punto trama + Set Preference Imposta preferenza + Set Slice Rectangle Imposta rettangolo sezione + Set Tab Stops Imposta tabulazioni + Set Text Imposta testo + Set the selected color to the current color Imposta il colore selezionato sul colore corrente + Set Zoom Imposta zoom + Settings… Impostazioni… + Setup… Configurazione… + Shadows and Glows Ombre e bagliori + Shape Forma + Shape Builder Generatore forme + Shape Builder Regions Aree del Generatore forme + Shape Builder Tool Strumento Generatore forme + Shape Effects Effetti forma + Shape Modes: Metodi forma: + Shape Properties: Proprietà forma: + Shaper Tool Strumento Sagomatore + Shapes Forme + Shear Inclina + Shear Tool Strumento Inclina + Shear… Inclina… + Shell Lower… Conchiglia inferiore… + Shell Upper… Conchiglia superiore… + Shift Shift + Shift to Color… Sposta verso colore… + Shifts the tints of global and spot colors; other colors stay. Sposta le tinte dei colori globali e spot; gli altri colori restano invariati. + Show Mostra + Show Active Plane Widget Mostra widget piano attivo + Show All Mostra tutto + Show All Hidden Attributes Mostra tutti gli attributi nascosti + Show All Layers Mostra tutti i livelli + Show All Plates Mostra tutte le lastre + Show all plates Mostra tutte le lastre + Show All Swatches Mostra tutti i campioni + Show and print from the Lab definition; PDF files carry it as the ink's alternate color. Mostra e stampa in base alla definizione Lab; i file PDF la includono come colore alternativo dell'inchiostro. + Show and separate through the working CMYK space, as in older documents. Mostra e separa tramite lo spazio CMYK di lavoro, come nei documenti meno recenti. + Show Artboards Mostra tavole da disegno + Show Bounding Box Mostra riquadro di delimitazione + Show Brush Size Mostra dimensione pennello + Show Center Mostra centro + Show Code Mostra codice + Show Color Groups Mostra gruppi colori + Show Color Swatches Mostra campioni colore + Show Corner Widget Mostra widget angolo + Show East Asian Options Mostra opzioni Asia orientale + Show Edges Mostra bordi + Show Embedded Mostra incorporati + Show Find Field Mostra campo di ricerca + Show Font Names in English Mostra nomi dei font in inglese + Show Gradient Annotator Mostra annotatore sfumatura + Show Gradient Swatches Mostra campioni sfumatura + Show Grid Mostra griglia + Show Grid (⌘') Mostra griglia (⌘') + Show Guides Mostra guide + Show handles when multiple anchors are selected Mostra le maniglie quando sono selezionati più punti di ancoraggio + Show Hidden Characters Mostra caratteri nascosti + Show Images in Outline Mode Mostra immagini in modalità Contorno + Show in Folder Mostra nella cartella + Show Indic Options Mostra opzioni per lingue indiane + Show Layers Only Mostra solo livelli + Show Link Info Mostra informazioni collegamento + Show List View Mostra vista elenco + Show Mesh Mostra trama + Show Missing Mostra mancanti + Show Modified Mostra modificati + Show Note Mostra nota + Show Options Mostra opzioni + Show Package Mostra pacchetto + Show Panel Mostra pannello + Show Pattern Swatches Mostra campioni motivo + Show Perspective Grid Mostra griglia prospettica + Show Pixel Grid (Above 600% Zoom) Mostra griglia pixel (zoom oltre il 600%) + Show Print Tiling Mostra affiancamento di stampa + Show Rulers Mostra righelli + Show Rulers (⌘R) Mostra righelli (⌘R) + Show Slice Numbers Mostra numeri sezioni + Show Slices Mostra sezioni + Show Swatch Bounds Mostra limiti campione + Show Swatch Kinds Mostra tipi di campione + Show Text Threads Mostra concatenamenti testo + Show The Home Screen When No Documents Are Open Mostra la schermata iniziale quando non ci sono documenti aperti + Show Thumbnail Mostra miniatura + Show Thumbnail View Mostra vista miniature + Show Thumbnails Mostra miniature + Show Tile Edge Mostra bordo tassello + Show Tints/Shades Mostra tinte/toni scuri + Show Tool Tips Mostra descrizioni comandi + Show Transparency Grid Mostra griglia trasparenza + Show Video Rulers Mostra righelli video + Show Vivid/Muted Mostra vivaci/tenui + Show Warm/Cool Mostra caldi/freddi + Show {kind} Brushes Mostra pennelli di tipo {kind} + Show/hide plate (Alt-click: only this plate) Mostra/nascondi lastra (Alt+clic: solo questa lastra) + Show: Mostra: + Shown with the optimised preview. Mostrato con l'anteprima ottimizzata. + Side 1: Lato 1: + Side 2: Lato 2: + Sides: Lati: + Simplify Semplifica + Simplify: Semplifica: + Simplify… Semplifica… + Simulate Colored Paper Simula carta colorata + Simulate Paper Simula carta + Double Column Colonna doppia + Single Left Quotation Mark Virgoletta singola di apertura + Single Quotes: Virgolette singole: + Single Right Quotation Mark Virgoletta singola di chiusura + Single-line Composer Composizione su riga singola + Sixth Space Spazio di un sesto + Size Dimensione + Size Tile to Art Adatta tassello alla grafica + Size/Leading Dimensione/interlinea + Size: Dimensione: + Size: {size} Tracking: {tracking} Dimensione: {size} Spaziatura caratteri: {tracking} + Skew Inclinazione + Skin Tone Ramps Scale di tonalità della pelle + Skip Blank Artboards Salta tavole da disegno vuote + Sky Gradients Sfumature cielo + Slice Sezione + Slice Options Opzioni sezione + Slice Options… Opzioni sezione… + Slice Selection Tool Strumento Selezione sezione + Slice Tool Strumento Sezione + Slice Type: Tipo sezione: + Slices Sezioni + slices across, evenly spaced sezioni una accanto all'altra, spaziate in modo uniforme + slices down, evenly spaced sezioni una sotto l'altra, spaziate in modo uniforme + Slices: Sezioni: + Small Piccola + Small Caps Maiuscoletto + Small Caps (on the roadmap) Maiuscoletto (in programma) + Small Caps: Maiuscoletto: + Small List View Vista elenco piccola + Small Thumbnail View Vista miniature piccole + Small Thumbnails Miniature piccole + Smaller ↔ Larger Più piccolo ↔ Più grande + Smart Guides Guide sensibili + Smart Guides (View → Smart Guides) Guide sensibili (Visualizza → Guide sensibili) + Smart Guides (⌘U) Guide sensibili (⌘U) + Smart Punctuation… Punteggiatura intelligente… + Smooth Smussa + Smooth Color Colore graduale + Smooth Tool Strumento Smussa + Snap Curves To Lines Aggancia curve a linee + Snap Options Opzioni di aggancio + Snap to Glyph Aggancia a glifo + Snap to Grid Aggancia alla griglia + Snap to Pixel Aggancia ai pixel + Snap to Point Aggancia al punto + Snapping Tolerance Tolleranza di aggancio + Social Square Post 1080×1080 Post quadrato per social 1080×1080 + Soft Light Luce soffusa + Solid Pieno + Sort by Kind Ordina per tipo + Sort by Name Ordina per nome + Sort by Status Ordina per stato + Source code on GitHub Codice sorgente su GitHub + Source Sans 3 Source Sans 3 + Space After Paragraph Spazio dopo il paragrafo + Space Before Paragraph Spazio prima del paragrafo + Spaces Spazi + Spacing Guides Guide di spaziatura + Spacing: Spaziatura: + Spanish Spagnolo + Specified Distance Distanza specificata + Specified Steps Passaggi specificati + Specify: Specifica: + Spectrum Gradients Sfumature spettro + Spelling Ortografia + Spiral Spirale + Spiral Tool Strumento Spirale + Split Freeform Line Dividi linea libera + Split Into Grid Dividi in griglia + Split Into Grid… Dividi in griglia… + Split Path Dividi tracciato + spot spot + Spot Color Colore spot + Spot Colors Colori spot + Spot Colors… Colori spot… + Spread: Estensione: + Square Quadrato + Squeeze… Compressione… + Stacked Bar Graph Tool Strumento Grafico a barre sovrapposte + Stacked Column Graph Tool Strumento Grafico a colonne sovrapposte + Stair Step A gradini + Standard Ligatures Legature standard + Standard Vertical Roman Alignment Allineamento verticale romano standard + Standard: Standard: + Star Stella + Star Tool Strumento Stella + Start arrowhead Punta di freccia iniziale + Start Global Edit Avvia modifica globale + Status Stato + Steps: Passaggi: + Stop Editing Opacity Mask Interrompi modifica maschera di opacità + Stop editing the opacity mask Interrompi la modifica della maschera di opacità + Stop Playing/Recording Interrompi riproduzione/registrazione + Stray Points Punti isolati + Strikethrough Barrato + Stroke Traccia + Stroke (X), double-click for the Color Picker Traccia (X), fai doppio clic per il selettore colore + Stroke Color Colore traccia + Stroke Options Opzioni traccia + Character: Carattere: + Character options Opzioni carattere + Stroke options Opzioni traccia + Stroke Weight Spessore traccia + Stroke: Traccia: + Stroke: click for swatches, Shift-click for the color mixer Traccia: fai clic per i campioni, Shift+clic per il miscelatore colori + Style Stile + Style Attributes Attributi di stile + Style Attributes (Entity References) Attributi di stile (riferimenti a entità) + Style Name: Nome stile: + Style: Stile: + Styling: Stili: + Stylize Stilizzazione + Subdivisions Suddivisioni + Subscript Pedice + Subscript (on the roadmap) Pedice (in programma) + Subscript: Pedice: + Subset fonts below: Crea sottoinsiemi di font al di sotto di: + Subtract Sottrai + Suffix Suffisso + Summary Riepilogo + Superscript Apice + Superscript (on the roadmap) Apice (in programma) + Superscript: Apice: + SVG Filters Filtri SVG + SVG Interactivity Interattività SVG + SVG Options Opzioni SVG + SVG Profile: Profilo SVG: + Swap Fill and Stroke Inverti riempimento e traccia + Swap Fill and Stroke (Shift+X) Inverti riempimento e traccia (Shift+X) + Swap start and end arrowheads Inverti punte di freccia iniziale e finale + Swap the selected object for the file, keeping its place and transform Sostituisci l'oggetto selezionato con il file, mantenendone posizione e trasformazione + Swash Ornamentale + Swatch Conflict Conflitto campioni + Swatch Conflicts Conflitti campioni + Swatch Libraries Librerie campioni + Swatch Libraries Menu Menu Librerie campioni + Swatch Library Libreria campioni + Swatch Name: Nome campione: + Swatch Options Opzioni campione + Swatch Options… Opzioni campione… + Swatch Tiles Riquadri campioni + Swatches Campioni + Switch workspace Cambia area di lavoro + Symbol Instance Istanza di simbolo + Symbol Libraries Librerie simboli + Symbol Libraries (on the roadmap) Librerie simboli (in programma) + Symbol Screener Tool Strumento Trasparenza simboli + Symbol Scruncher Tool Strumento Addensamento simboli + Symbol Shifter Tool Strumento Spostamento simboli + Symbol Sizer Tool Strumento Ridimensionamento simboli + Symbol Spinner Tool Strumento Rotazione simboli + Symbol Sprayer Spruzzo simboli + Symbol Sprayer Tool Strumento Spruzzo simboli + Symbol Stainer Tool Strumento Colorazione simboli + Symbol Styler Tool Strumento Stile simboli + Symbolism Tool Strumento Simbolismo + Symbols Simboli + System Layout Layout di sistema + Tab Tabulazione + Tab Stops Tabulazioni + Tabs Tabulazioni + Tabular Lining Tabulari allineati + Tabular Oldstyle Tabulari stile antico + Target Destinazione + Target Contents Contenuto destinazione + Target: Destinazione: + Tate-chu-yoko Tate-chu-yoko + Temperature Temperatura + Temperature/Tint… Temperatura/tinta… + Template Modello + Templates Modelli + Templates Folder Cartella modelli + Templates… Modelli… + Text Displayed in Cell: Testo visualizzato nella cella: + Text Export Options Opzioni di esportazione testo + Text Fill Color Colore riempimento testo + Text Import Options Opzioni di importazione testo + Text Stroke Color Colore traccia testo + Text Wrap Testo attorno + Text Wrap Options Opzioni testo attorno + Text Wrap Options… Opzioni testo attorno… + The bounds of the visible art. I limiti della grafica visibile. + The cell shows the type object's text as HTML. La cella mostra il testo dell'oggetto testo come HTML. + The document has no colour swatches. Il documento non ha campioni di colore. + The edge of the paper the printer can't reach: the art goes inside it, and the preview shows it dashed. Il bordo del foglio che la stampante non riesce a raggiungere: la grafica resta al suo interno e l'anteprima lo mostra tratteggiato. + The page as it prints La pagina come viene stampata + the preset il preset + The Print Tiling tool placed the pages. Lo strumento Affiancamento di stampa ha posizionato le pagine. + The selected objects have no CSS of their own (see below). Gli oggetti selezionati non hanno CSS propri (vedi sotto). + The system's settings of this printer Le impostazioni di sistema di questa stampante + Thin Space Spazio sottile + Third Space Spazio da un terzo + Third Vanishing Point: Terzo punto di fuga: + This document already has a swatch named “{name}” with another color. Questo documento ha già un campione denominato “{name}” con un altro colore. + This library is empty. Questa libreria è vuota. + This panel is on the roadmap (see the parity plan). Questo pannello è in programma (vedi il piano di parità). + Threaded Text Testo concatenato + Threads Concatenamenti + Three Point Tre punti + Three Point Perspective Prospettiva a tre punti + Three Point Perspective Preset 1 Preset prospettiva a tre punti 1 + Three Point Perspective Preset 2 Preset prospettiva a tre punti 2 + Three Point Perspective Preset 3 Preset prospettiva a tre punti 3 + Three Point Perspective Preset 4 Preset prospettiva a tre punti 4 + Three Point Perspective Preset 5 Preset prospettiva a tre punti 5 + Threshold Soglia + Thumbnail View Vista miniature + Thumbnails: Miniature: + Tile Affianca + Tile Edge Color Colore bordo tassello + Tile Edge Color… Colore bordo tassello… + Tile Full Pages Affianca pagine intere + Tile Range: Intervallo riquadri: + Tile Type: Tipo di tassello: + tile {number} riquadro {number} + Tiles are numbered across, then down; leave the range empty for every tile. I riquadri sono numerati da sinistra a destra, poi dall'alto in basso; lascia vuoto l'intervallo per stamparli tutti. + Tint Tinta + Tip extends past the end point La punta si estende oltre il punto finale + Tip on the end point Punta sul punto finale + Title Case Iniziali maiuscole + to a + Toggle Fill/Stroke Focus Alterna attivazione riempimento/traccia + Toggle Selection Alterna selezione + Toggle single/double column Alterna colonna singola/doppia + Tolerance Tolleranza + Tolerance: Tolleranza: + Tool Option Opzione strumento + Tool Options… Opzioni strumento… + Toolbar: Advanced / Basic Barra degli strumenti: avanzata / di base + Toolbar: Single/Double Column Barra degli strumenti: colonna singola/doppia + Toolbars Barre degli strumenti + Tools Strumenti + Top In alto + Top in Front Superiore davanti + Top: In alto: + Total Width: Larghezza totale: + Touch Type Tool Strumento Ritocco testo + Trace Ricalca + Trace the image with the Default preset Ricalca l'immagine con il preset Predefinito + Tracking Spaziatura caratteri + Trademark Symbol Simbolo di marchio + Transform Trasforma + Transform Again Ripeti trasformazione + Transform Both Trasforma entrambi + Transform Each Trasforma singolarmente + Transform Each… Trasforma singolarmente… + Transform in Perspective Trasforma in prospettiva + Transform Object Only Trasforma solo oggetto + Transform Panel Pannello Trasforma + Transform Pattern Only Trasforma solo motivo + Transform Pattern Tiles Trasforma tasselli motivo + Transform Patterns Trasforma motivi + Transform Tools Strumenti di trasformazione + Transforms Trasformazioni + Transform… Trasforma… + Transparency Trasparenza + Transparency Flattener Presets Preset di appiattimento trasparenza + Transparency Flattener Presets… Preset di appiattimento trasparenza… + Transparency Grid Griglia trasparenza + Transparency Info Informazioni trasparenza + Transparency is flattened with the preset. Type is written as outlines; gradients as bands of colour. La trasparenza viene appiattita con il preset. Il testo viene scritto come contorni; le sfumature come bande di colore. + Transparency is flattened with the preset. Type is written as outlines; gradients stay smooth. La trasparenza viene appiattita con il preset. Il testo viene scritto come contorni; le sfumature restano continue. + Transparency Options Opzioni trasparenza + Transparent Trasparente + Transparent (Default) Trasparente (predefinito) + Transparent Background Sfondo trasparente + Transverse (the page a quarter turn on the paper) Trasversale (la pagina ruotata di un quarto di giro sul foglio) + Trap… Trapping… + Trim Rifila + Trim mark weight: Spessore segni di taglio: + Trim marks Segni di taglio + Trim View Vista rifilata + True colour needs version 2004 or later: the nearest of 256 colours is written. Il colore reale richiede la versione 2004 o successiva: viene scritto il più vicino tra 256 colori. + Turn off Data Recovery for complex documents Disattiva il recupero dati per i documenti complessi + Tweak… Ritocca… + Twirl Rate: Velocità vortice: + Twirl Tool Strumento Vortice + Twist… Torci… + Two Point Due punti + Two Point Perspective Prospettiva a due punti + Two Point Perspective Preset 1 Preset prospettiva a due punti 1 + Two Point Perspective Preset 2 Preset prospettiva a due punti 2 + Two Point Perspective Preset 3 Preset prospettiva a due punti 3 + Two Point Perspective Preset 4 Preset prospettiva a due punti 4 + Two Point Perspective Preset 5 Preset prospettiva a due punti 5 + Type Testo + Type becomes outlines, and strokes a CAD line can't draw become filled shapes. Il testo diventa contorni e le tracce che una linea CAD non può disegnare diventano forme riempite. + Type Object Selection by Path Only Selezione oggetti testo solo tramite tracciato + Type on a Path Testo su tracciato + Type on a Path Options Opzioni testo su tracciato + Type on a Path Options… Opzioni testo su tracciato… + Type on a Path Tool Strumento Testo su tracciato + Type Orientation Orientamento testo + Type stays text, and every stroke is a line with its lineweight and dashes. Il testo resta testo e ogni traccia diventa una linea con il suo spessore e i suoi tratteggi. + Type Tool Strumento Testo + Type: Tipo: + Type… Tipo… + UI Brightness Luminosità interfaccia + UI Scaling Scala interfaccia + Underline Sottolineato + Undo Annulla + Undo {name} Annulla {name} + Undo {} Annulla {} + Unembed Rimuovi incorporamento + Unembedded to {} Incorporamento rimosso, salvato in {} + Unembed… Rimuovi incorporamento… + Ungroup Separa + Ungroup Color Group Separa gruppo colori + Unicode Unicode + Unicode (UTF-16) Unicode (UTF-16) + Unicode (UTF-8) Unicode (UTF-8) + Uniform Uniforme + Unique Unico + Unite Unione + Unite and Simplify Unisci e semplifica + Units Unità + Units: Unità: + Units: {units} Unità: {units} + Unlink harmony colors Scollega colori armonia + Unlink Opacity Mask Scollega maschera di opacità + Unlink the mask Scollega la maschera + Unlock Sblocca + Unlock All Sblocca tutto + Unlock All Layers Sblocca tutti i livelli + Unlock Grid Sblocca griglia + Unlock Guides Sblocca guide + Unnamed Objects Oggetti senza nome + Unprintable margin: Margine non stampabile: + Unshift Annulla spostamento + Untitled Senza titolo + Update Link Aggiorna collegamento + Update Links Aggiorna collegamenti + Update Modified Links Aggiorna collegamenti modificati + Updated {} image(s) Immagini aggiornate: {} + UPPERCASE MAIUSCOLO + URL: URL: + Use Usa + Use Artboards Usa tavole da disegno + Use Black Point Compensation Usa compensazione punto nero + Use Compression Usa compressione + Use document bleed settings Usa impostazioni abbondanza del documento + Use Even-Odd Fill Rule Usa regola di riempimento pari-dispari + Use Japanese Crop Marks Usa segni di ritaglio giapponesi + Use Low Resolution Proxy for Linked EPS Usa proxy a bassa risoluzione per EPS collegati + Use Non-Zero Winding Fill Rule Usa regola di riempimento diversa da zero + Use Precise Cursors Usa cursori di precisione + Use Pressure Pen Usa penna a pressione + Use Preview Bounds Usa limiti anteprima + Use Registration Point for Symbol Usa punto di registrazione per il simbolo + Use Square for Previews Usa quadrato per le anteprime + Use Text for Previews Usa testo per le anteprime + Use the document's swatch: pasted colors take its color. Usa il campione del documento: i colori incollati ne assumono il colore. + Use the Selected Text's Font Usa il font del testo selezionato + Use Typographer's Quotes Usa virgolette tipografiche + User Defined Definito dall'utente + User Defined Libraries Librerie definite dall'utente + User Graphic Style Library 1 Libreria stili grafici utente 1 + User Graphic Style Library 10 Libreria stili grafici utente 10 + User Graphic Style Library 2 Libreria stili grafici utente 2 + User Graphic Style Library 3 Libreria stili grafici utente 3 + User Graphic Style Library 4 Libreria stili grafici utente 4 + User Graphic Style Library 5 Libreria stili grafici utente 5 + User Graphic Style Library 6 Libreria stili grafici utente 6 + User Graphic Style Library 7 Libreria stili grafici utente 7 + User Graphic Style Library 8 Libreria stili grafici utente 8 + User Graphic Style Library 9 Libreria stili grafici utente 9 + User Interface Interfaccia utente + User Library Libreria utente + User Preset Preset utente + User Swatch Library 1 Libreria campioni utente 1 + User Swatch Library 10 Libreria campioni utente 10 + User Swatch Library 2 Libreria campioni utente 2 + User Swatch Library 3 Libreria campioni utente 3 + User Swatch Library 4 Libreria campioni utente 4 + User Swatch Library 5 Libreria campioni utente 5 + User Swatch Library 6 Libreria campioni utente 6 + User Swatch Library 7 Libreria campioni utente 7 + User Swatch Library 8 Libreria campioni utente 8 + User Swatch Library 9 Libreria campioni utente 9 + V Spacing: Spaziatura verticale: + V: V: + Variable Width Profile Profilo larghezza variabile + Variables Variabili + Variation: Variazione: + Vector Effects Effetti vettoriali + Vector Halftone Retino vettoriale + Vector Halftone… Retino vettoriale… + Vector illustration — fast, open, scriptable. Illustrazione vettoriale — veloce, aperta, programmabile. + VectorCraft didn't quit normally last time. These documents had unsaved changes: VectorCraft non si è chiuso correttamente l'ultima volta. Questi documenti avevano modifiche non salvate: + VectorCraft Help… Aiuto di VectorCraft… + VectorCraft on getartcraft.com VectorCraft su getartcraft.com + VectorCraft on GitHub VectorCraft su GitHub + Vectors Vettori + Version {version} — open-source vector illustration in pure Rust. Versione {version} — illustrazione vettoriale open source in puro Rust. + Version: Versione: + Vertical Verticale + Vertical % % verticale + Vertical Align Bottom Allinea verticalmente in basso + Vertical Align Center Allinea verticalmente al centro + Vertical Align Top Allinea verticalmente in alto + Vertical Area Type Tool Strumento Testo in area verticale + Vertical Distribute Bottom Distribuisci verticalmente i bordi inferiori + Vertical Distribute Center Distribuisci verticalmente i centri + Vertical Distribute Space Distribuisci spazio verticalmente + Vertical Distribute Top Distribuisci verticalmente i bordi superiori + Vertical Scale % % scala verticale + Vertical Type on a Path Tool Strumento Testo verticale su tracciato + Vertical Type Tool Strumento Testo verticale + Vertical: Verticale: + Very High Molto alta + View Visualizza + View Artboard Only Visualizza solo tavola da disegno + View Opacity Mask Visualizza maschera di opacità + View PDF after saving Visualizza PDF dopo il salvataggio + View {n} Vista {n} + Viewing Angle: Angolo di visualizzazione: + Viewing Distance: Distanza di visualizzazione: + W: L: + Warnings Avvisi + Warp Altera + Warp Options Opzioni alterazione + Warp Tool Strumento Altera + Wave… Onda… + Web 1920×1080 Web 1920×1080 + Web Safe 216 216 sicuri per il Web + Web Safe RGB RGB sicuro per il Web + Web Shift Passa a colori Web + Web Snap: Aggancio ai colori Web: + Weight Spessore + Weight: Spessore: + Welcome to VectorCraft Ti diamo il benvenuto in VectorCraft + When pasting text Quando incolli testo + White Bianco + Widget Position: Posizione widget: + Width Larghezza + Width and Height Larghezza e altezza + Width Point Punto di larghezza + Width Point Edit Modifica punto di larghezza + Width Point Edit… Modifica punto di larghezza… + Width Profile Profilo larghezza + Width Profiles Profili larghezza + Width Tool Strumento Larghezza + Width: Larghezza: + Window Finestra + Windows Windows + Working CMYK CMYK di lavoro + Working CMYK (don't tag) CMYK di lavoro (senza tag) + Workspace Area di lavoro + Workspace {i} Area di lavoro {i} + Wrinkle Tool Strumento Grinza + Write Layers Scrivi livelli + XML ID ID XML + Yards Iarde + Yellow Giallo + Your browser downloads the files (several as one .zip). Il browser scarica i file (se sono più di uno, in un unico .zip). + Your changes will be lost if you don't save them. Se non le salvi, le modifiche andranno perse. + Zig Zag… Zig-zag… + Zoom In Ingrandisci + Zoom Out Riduci + Zoom to Selection Zoom sulla selezione + Zoom Tool Strumento Zoom + Zoom with Mouse Wheel Zoom con la rotellina del mouse + Scrub Numeric Fields by Dragging Regola i campi numerici trascinando + {count} file(s) in {folder}{note}. Show the package folder? {count} file in {folder}{note}. Vuoi mostrare la cartella del pacchetto? + {count} linked file(s) not found File collegati non trovati: {count} + {count} linked image(s) changed since this document was saved. Show the new versions? Immagini collegate modificate dopo il salvataggio di questo documento: {count}. Vuoi mostrare le nuove versioni? + {count} more rules: Export writes every one. Altre {count} regole: Esporta le scrive tutte. + {count} unnamed objects left out: name them, or turn on Unnamed Objects in the panel menu. {count} oggetti senza nome esclusi: assegna loro un nome o attiva Oggetti senza nome nel menu del pannello. + {effect} is already applied L'effetto {effect} è già applicato + {format} Options Opzioni {format} + {kind} Gradient Sfumatura {kind} + {kind} Style Options… Opzioni stile {kind}… + {kind}, {model} {kind}, {model} + {name} (spot) {name} (spot) + {pages} in all, {count} per copy {pages} in totale, {count} per copia + {page} of {count} {page} di {count} + {percent}% opacity {percent}% di opacità + {secs} sec {secs} s + {shortcut} with the tool sizes the brush {shortcut} con lo strumento ridimensiona il pennello + {title} (selection) {title} (selezione) + {tool} Options Opzioni {tool} + {tool} Tool Options Opzioni strumento {tool} + {warning}: click to correct to the closest color ({hex}) {warning}: fai clic per correggere con il colore più vicino ({hex}) + “{file}” is protected by a password. “{file}” è protetto da password. + ● Recording ● Registrazione in corso +@plural {n} item|{n} items {n} elemento|{n} elementi +@plural Color Table ({n} color)|Color Table ({n} colors) Tabella colori ({n} colore)|Tabella colori ({n} colori) +@plural Delete this {n} graphic style?|Delete these {n} graphic styles? Eliminare {n} stile grafico?|Eliminare questi {n} stili grafici? +@plural {n} Layer|{n} Layers {n} livello|{n} livelli +@plural {n} Object|{n} Objects {n} oggetto|{n} oggetti +@plural {n} area highlighted|{n} areas highlighted {n} area evidenziata|{n} aree evidenziate +@plural {n} color|{n} colors {n} colore|{n} colori +@plural {n} fill|{n} fills {n} riempimento|{n} riempimenti +@plural {n} glyph|{n} glyphs {n} glifo|{n} glifi +@plural {n} object highlighted|{n} objects highlighted {n} oggetto evidenziato|{n} oggetti evidenziati +@plural {n} star|{n} stars {n} stella|{n} stelle +@plural {n} step|{n} steps {n} passaggio|{n} passaggi +@plural {n} stroke|{n} strokes {n} traccia|{n} tracce + the object to select | sull'oggetto per selezionarlo | + to select multiple objects | per selezionare più oggetti | + the object to duplicate l'oggetto per duplicarlo + an anchor or path segment to select it | su un punto di ancoraggio o un segmento di tracciato per selezionarlo | + to move | per spostare | + to add per aggiungere + to add a corner point | per aggiungere un punto d'angolo | + to add a smooth point | per aggiungere un punto curvo | + to close | per chiudere | + to finish per terminare + to add smooth points | per aggiungere punti curvi | + to toggle corner | per alternare punto d'angolo e punto curvo | + to create point type | per creare testo per punti | + to create area type | per creare testo in area | + to exit editing per uscire dalla modifica + to draw | per disegnare | + to constrain proportions | per vincolare le proporzioni | + from center | dal centro | + for exact size per dimensioni esatte + to set the reference point | per impostare il punto di riferimento | + to transform | per trasformare | + for exact values per valori esatti + to pan the view per spostare la vista + to zoom in | per ingrandire | + to zoom out | per ridurre | + to zoom into an area per ingrandire un'area + an object to copy its attributes | su un oggetto per copiarne gli attributi | + to apply the selection's to it | per applicargli quelli della selezione | + to sample a color per campionare un colore + across a selected object to set the gradient direction su un oggetto selezionato per impostare la direzione della sfumatura + to select an artboard | per selezionare una tavola da disegno | + on the canvas to create one sull'area di disegno per crearne una + a stroke to add a width point | su una traccia per aggiungere un punto di larghezza | + to change one side | per modificare un solo lato | + to select more points | per selezionare altri punti | + a point to edit it | su un punto per modificarlo | + to remove points per rimuovere punti + the art to add a pin | sulla grafica per aggiungere un perno | + to select more pins | per selezionare altri perni | + a pin to warp | un perno per alterare | + near a selected pin to rotate | vicino a un perno selezionato per ruotare | + to remove pins per rimuovere perni + across paths to push them along | sui tracciati per spingerli | + to size the brush ( per ridimensionare il pennello ( + keeps its proportions) mantiene le proporzioni) + over paths, and hold still to keep going | sui tracciati e tieni fermo il puntatore per continuare | + over paths to roughen their outlines | sui tracciati per renderne irregolari i contorni | + to move in perspective | per spostare in prospettiva | + to copy | per copiare | + while dragging to move perpendicular to the plane | durante il trascinamento per spostare perpendicolarmente al piano | + to scale in perspective per scalare in prospettiva + an object, then another to blend them | su un oggetto, poi su un altro per fonderli | + to blend from it | per creare una fusione a partire da esso | + to set spacing and orientation per impostare spaziatura e orientamento + : : + Isolate Selected Group Isola gruppo selezionato + Release Clipping Mask Rilascia maschera di ritaglio + Make Compound Path Crea tracciato composto + Release Compound Path Rilascia tracciato composto + — substituted by {style} — sostituito con {style} + — {n} characters from another font — {n} caratteri da un altro font + [Normal Character Style] [Stile carattere normale] + [Normal Paragraph Style] [Stile paragrafo normale] + +# Leading model (Paragraph panel menu, East Asian options). + Top-to-Top Leading Interlinea da sommità a sommità + Bottom-to-Bottom Leading Interlinea da base a base + Burasagari Burasagari + Force Forza + +# About › Contributors / Models (credits.rs) + About Informazioni + Contributors Collaboratori + Models Modelli + Username Nome utente + Display name Nome visualizzato + Real name Nome reale + Sort Ordina + Reverse the order Inverti l'ordine + Grab bag Alla rinfusa + Table Tabella + Name (A–Z) Nome (A–Z) + Merged PRs PR unite + Commits Commit + Lines added Righe aggiunte + Lines deleted Righe eliminate + Line delta Differenza righe + Binary assets added Risorse binarie aggiunte + Binary assets removed Risorse binarie rimosse + First commit Primo commit + Last commit Ultimo commit + First Primo + Last Ultimo + {people} contributors · {commits} commits {people} collaboratori · {commits} commit + No contributor data was built into this copy. Questa copia non include dati sui collaboratori. + No model credits were built into this copy. Questa copia non include riconoscimenti dei modelli. + Company Azienda + Version Versione + % of all commits % di tutti i commit + Lines +/− Righe +/− + Joins Giunzioni + Miter Angolo vivo + Bevel Smussato + Offset Spostamento + Axis Asse +axis Horizontal Orizzontale +axis Vertical Verticale +axis Both Entrambi + Drag to move Trascina per spostare + Drag to float as a toolbar Trascina per rendere mobile come barra degli strumenti + Put back in the toolbar Riporta nella barra degli strumenti + Float Tool Group Rendi mobile gruppo strumenti + +# Status and error messages (`@msg`), translated where the status bar shows them; the message itself +# stays English for agents and tests. `{_1}`, `{_2}` … stand for the `{}` of the format string, in order +# (`complete_languages_translate_every_message` lists any that are missing). Command ids, parameter +# names and values in backticks or code (`colorModel rgb`, `document.export`) stay as they are. +@msg `to` must be "corner" or "smooth" `to` deve essere "corner" o "smooth" +@msg BMP files are RGB or grayscale: colorModel rgb or gray I file BMP sono RGB o in scala di grigi: colorModel rgb o gray +@msg Blend colors: select at least three objects with filled colours Fondi colori: seleziona almeno tre oggetti con riempimento colore +@msg Combine Slices: the slices have no bounds Combina sezioni: le sezioni non hanno limiti +@msg Convert to Artboards: selection has no area Converti in tavole da disegno: la selezione non ha area +@msg Convert to Shape: no rectangles or ellipses selected Converti in forma: nessun rettangolo o ellisse selezionato +@msg Copied the CSS of {rules} object(s) Copiato il CSS di {rules} oggetto/i +@msg Corners edits a live rectangle Angoli modifica un rettangolo dinamico +@msg Couldn't copy to the system clipboard: {e} Impossibile copiare negli appunti di sistema: {e} +@msg Couldn't open {name}: {e} Impossibile aprire {name}: {e} +@msg Couldn't place {name}: the document it was dropped on was closed Impossibile inserire {name}: il documento su cui è stato rilasciato è stato chiuso +@msg Couldn't read {name}: {e} Impossibile leggere {name}: {e} +@msg Couldn't save recovery data: {e} Impossibile salvare i dati di recupero: {e} +@msg Create Outlines: select text objects Crea contorni: seleziona oggetti di testo +@msg Create from Guides: the document has no artboard Crea da guide: il documento non ha una tavola da disegno +@msg Create from Guides: the guides make more than {MAX_PIECES} slices Crea da guide: le guide generano più di {MAX_PIECES} sezioni +@msg Create from Selection: the selection has no area Crea da selezione: la selezione non ha area +@msg Data Recovery has nowhere to keep copies: set Preferences → File Handling → Data Recovery → Folder (recoveryFolder) Il recupero dati non ha dove conservare le copie: imposta Preferenze → Gestione file → Recupero dati → Cartella (recoveryFolder) +@msg direct-select anchor points to cut at (not the end points of open paths) seleziona con Selezione diretta i punti di ancoraggio in cui tagliare (non i punti finali dei tracciati aperti) +@msg Divide Objects Below: select a path Dividi oggetti sottostanti: seleziona un tracciato +@msg Divide Objects Below: select exactly one path Dividi oggetti sottostanti: seleziona esattamente un tracciato +@msg Downloaded {_1} file(s) File scaricati: {_1} +@msg Downloaded {what} Scaricato {what} +@msg Expand Appearance: the selection has a basic appearance Espandi aspetto: la selezione ha un aspetto di base +@msg Expand: no brush strokes selected Espandi: nessuna traccia di pennello selezionata +@msg Expand: no gradient fills Espandi: nessun riempimento con sfumatura +@msg Expand: nothing to expand Espandi: niente da espandere +@msg Exported {count} file(s) to {folder} File esportati in {folder}: {count} +@msg Exported {path} Esportato {path} +@msg Flatten Transparency: select objects to flatten Appiattisci trasparenza: seleziona gli oggetti da appiattire +@msg Flatten Transparency: {e} Appiattisci trasparenza: {e} +@msg Image Trace: the traced image is missing Ricalco immagine: manca l'immagine ricalcata +@msg Imported {what}: {_1} Importato {what}: {_1} +@msg Installed plug-in {_1} Plug-in installato: {_1} +@msg Internal error: {msg} (please report this bug) Errore interno: {msg} (segnala questo bug) +@msg Live Paint Merge: select a Live Paint group and the paths to add Fondi pittura dinamica: seleziona un gruppo di pittura dinamica e i tracciati da aggiungere +@msg Live Paint: select paths or compound paths Pittura dinamica: seleziona tracciati o tracciati composti +@msg Live Paint: these paths are too degenerate to paint Pittura dinamica: questi tracciati sono troppo degeneri per essere dipinti +@msg Make Guides: select paths Crea guide: seleziona tracciati +@msg No saved selections (Select → Save Selection…) Nessuna selezione salvata (Selezione → Salva selezione…) +@msg No saved views (View → New View…) Nessuna vista salvata (Visualizza → Nuova vista…) +@msg Offset Path: select paths Sposta tracciato: seleziona tracciati +@msg Opened with {_1} note(s): {_2} Aperto con {_1} nota/e: {_2} +@msg Opened {url} Aperto {url} +@msg Outline Stroke: no stroked paths selected Contorna traccia: nessun tracciato con traccia selezionato +@msg PDF settings are not an object Le impostazioni PDF non sono un oggetto +@msg PDF writer error: {0} Errore del generatore PDF: {0} +@msg Packaged {n} file(s) in {folder}{note} Pacchetto creato con {n} file in {folder}{note} +@msg Packaged {n} file(s){note} Pacchetto creato con {n} file{note} +@msg Preview in Browser needs the desktop app (the web downloads files instead) Anteprima nel browser richiede l'app desktop (sul web i file vengono invece scaricati) +@msg Release Guides: no guides Rilascia guide: nessuna guida +@msg Release: no layer to put the rectangle in Rilascia: nessun livello in cui inserire il rettangolo +@msg Replace Spine: select a blend and a path Sostituisci dorsale: seleziona una fusione e un tracciato +@msg select paths or anchor points seleziona tracciati o punti di ancoraggio +@msg SVG parse error: {0} Errore di analisi SVG: {0} +@msg Save for Web: the image is empty Salva per il web: l'immagine è vuota +@msg Save writes {_1}, not {_2}: use document.export for other formats Salva scrive {_1}, non {_2}: usa document.export per gli altri formati +@msg Saved recovery data for {title} Dati di recupero salvati per {title} +@msg Saved to User Defined: {_1} Salvato in Definito dall'utente: {_1} +@msg Saved {path} Salvato {path} +@msg Select text or click into text with the Type tool to insert glyphs Seleziona del testo o fai clic nel testo con lo strumento Testo per inserire glifi +@msg Shape Builder: no region under the pointer Generatore forme: nessuna regione sotto il puntatore +@msg Shape Builder: select paths or compound paths Generatore forme: seleziona tracciati o tracciati composti +@msg Show All Hidden Attributes: nothing is hidden Mostra tutti gli attributi nascosti: non c'è nulla di nascosto +@msg Split Into Grid: select paths large enough for the grid Dividi in griglia: seleziona tracciati abbastanza grandi per la griglia +@msg Targa files are RGB: colorModel rgb I file Targa sono RGB: colorModel rgb +@msg Text Wrap: select a wrap object Testo attorno: seleziona un oggetto di avvolgimento +@msg `aspect` must be a number (%) `aspect` deve essere un numero (%) +@msg `at` must be [x, y] `at` deve essere [x, y] +@msg `color` must be a colour `color` deve essere un colore +@msg `command` must be a command whose menu item opens a dialog (see ui.menuDialog) `command` deve essere un comando la cui voce di menu apre una finestra di dialogo (vedi ui.menuDialog) +@msg `freeform.points` must be an array `freeform.points` deve essere un array +@msg `gradient` must be an object `gradient` deve essere un oggetto +@msg `library` is a library id or name (see {list}) `library` è l'id o il nome di una libreria (vedi {list}) +@msg `mode` applies to freeform gradients `mode` si applica alle sfumature a forma libera +@msg `sampleSize` must be 1, 3 or 5 `sampleSize` deve essere 1, 3 o 5 +@msg `stops` must be an array `stops` deve essere un array +@msg `svg` must be an object of SVG options (see document.formats) `svg` deve essere un oggetto di opzioni SVG (vedi document.formats) +@msg `{_1}` is no save command `{_1}` non è un comando di salvataggio +@msg `{area}` is no recovery area name `{area}` non è il nome di un'area di recupero +@msg `{color}` is not a colour (#rrggbb or a preset name) `{color}` non è un colore (#rrggbb o il nome di un preset) +@msg `{id}` has no envelope dialog `{id}` non ha una finestra di dialogo per l'involucro +@msg `{keep}` is not a side of this axis `{keep}` non è un lato di questo asse +@msg `{key}` must be `auto` or a language code such as `en` or `zh-hant` `{key}` deve essere `auto` o un codice lingua come `en` o `zh-hant` +@msg `{key}` must be a #rrggbb colour `{key}` deve essere un colore #rrggbb +@msg `{key}` must be a number `{key}` deve essere un numero +@msg `{key}` must be a string `{key}` deve essere una stringa +@msg `{key}` must be a whole number `{key}` deve essere un numero intero +@msg `{key}` must be a whole number between {min} and {max} (got {x}) `{key}` deve essere un numero intero tra {min} e {max} (ricevuto {x}) +@msg `{key}` must be between {min} and {max} (got {x}) `{key}` deve essere compreso tra {min} e {max} (ricevuto {x}) +@msg `{key}` must be one of {_1} `{key}` deve essere uno dei seguenti: {_1} +@msg `{key}` must be true or false `{key}` deve essere true o false +@msg `{k}` must be [x, y] `{k}` deve essere [x, y] +@msg `{name}` has no options `{name}` non ha opzioni +@msg `{name}` is a built-in workspace; choose another name `{name}` è un'area di lavoro integrata; scegli un altro nome +@msg `{name}` is a process colour: tints apply to global and spot colours `{name}` è un colore quadricromia: le tinte si applicano ai colori globali e spot +@msg `{name}` is no recovery entry name `{name}` non è il nome di una voce di recupero +@msg `{name}` isn't a colour swatch `{name}` non è un campione di colore +@msg `{path}` must be a bool or an object of bools `{path}` deve essere un booleano o un oggetto di booleani +@msg `{s}` is not a colour (#rrggbb or a preset name) `{s}` non è un colore (#rrggbb o il nome di un preset) +@msg `{tool}` isn't a Liquify tool `{tool}` non è uno strumento Fluidifica +@msg `{tool}` isn't a freehand tool `{tool}` non è uno strumento a mano libera +@msg `{to}` is not an available name `{to}` non è un nome disponibile +@msg a PostScript error ({name} in `{op}`) un errore PostScript ({name} in `{op}`) +@msg a PostScript error ({name} in `{op}`), in {procs} un errore PostScript ({name} in `{op}`), in {procs} +@msg a PostScript error ({name} in `{op}`: {at}) un errore PostScript ({name} in `{op}`: {at}) +@msg a PostScript error ({name} in `{op}`: {at}), in {procs} un errore PostScript ({name} in `{op}`: {at}), in {procs} +@msg a PostScript error ({name}) un errore PostScript ({name}) +@msg a bitmap is empty una bitmap è vuota +@msg a bitmap is too large to read una bitmap è troppo grande per essere letta +@msg a colour index is 0 to {_1}, not {n} un indice di colore va da 0 a {_1}, non {n} +@msg a colour is an index, #rrggbb or a preset name, not {v} un colore è un indice, #rrggbb o il nome di un preset, non {v} +@msg a document needs at least one artboard un documento richiede almeno una tavola da disegno +@msg a document needs at least one layer un documento richiede almeno un livello +@msg a freeform gradient keeps at least one point una sfumatura a forma libera mantiene almeno un punto +@msg a gradient needs at least two stops una sfumatura richiede almeno due cursori colore +@msg a graphic style named `{to}` already exists esiste già uno stile grafico denominato `{to}` +@msg a page is missing manca una pagina +@msg a page out of range una pagina fuori intervallo +@msg a page tree kid isn't a reference un elemento figlio dell'albero delle pagine non è un riferimento +@msg a page tree node has no kids un nodo dell'albero delle pagine non ha elementi figli +@msg a page's placement is not finite la posizione di una pagina non è finita +@msg a preset named `{_1}` exists esiste già un preset denominato `{_1}` +@msg a slice size must be a positive number of points la dimensione di una sezione deve essere un numero positivo di punti +@msg a stream runs past the end uno stream prosegue oltre la fine +@msg a stream's length is wrong la lunghezza di uno stream è errata +@msg a stream's length isn't a number la lunghezza di uno stream non è un numero +@msg add a format to export aggiungi un formato di esportazione +@msg already editing a pattern è già in corso la modifica di un motivo +@msg an object can't be read impossibile leggere un oggetto +@msg an object in perspective would leave the edited grid un oggetto in prospettiva uscirebbe dalla griglia modificata +@msg antiAlias `{id}`: none, art or type antiAlias `{id}`: none, art o type +@msg artboard {0} does not exist la tavola da disegno {0} non esiste +@msg at this scale the drawing is {w} × {h} pt, more than the canvas holds: choose a smaller scale or fit it to the artboard a questa scala il disegno misura {w} × {h} pt, più di quanto possa contenere l'area di disegno: scegli una scala più piccola o adattalo alla tavola da disegno +@msg background {other}: transparent, white, black or a colour such as "#ff8800" sfondo {other}: transparent, white, black o un colore come "#ff8800" +@msg bad color {v} colore non valido {v} +@msg bad colour `{hex}` (#rrggbb) colore non valido `{hex}` (#rrggbb) +@msg bad page tree albero delle pagine non valido +@msg bad shortcut scelta rapida non valida +@msg bad stream length lunghezza dello stream non valida +@msg bad trailer trailer non valido +@msg balance must be between 0 and 100 il bilanciamento deve essere compreso tra 0 e 100 +@msg batch step {_1} (`{id}`) failed: {e} il passaggio {_1} del batch (`{id}`) non è riuscito: {e} +@msg brightness must be dark|mediumDark|mediumLight|light la luminosità deve essere dark|mediumDark|mediumLight|light +@msg can't encode the document: {0} impossibile codificare il documento: {0} +@msg can't parse shortcut `{c}` impossibile interpretare la scelta rapida `{c}` +@msg can't parse shortcut `{s}` for `{k}` impossibile interpretare la scelta rapida `{s}` per `{k}` +@msg can't save version {0}: VectorCraft writes versions {MIN_VERSION} to {VERSION} impossibile salvare la versione {0}: VectorCraft scrive le versioni da {MIN_VERSION} a {VERSION} +@msg can't write .{ext} images impossibile scrivere immagini .{ext} +@msg cannot distort a zero-size bounding box impossibile distorcere un riquadro di delimitazione di dimensione zero +@msg cannot read PDF: {0} impossibile leggere il PDF: {0} +@msg cannot split an open path at its end point impossibile dividere un tracciato aperto nel suo punto finale +@msg check an asset to export spunta una risorsa da esportare +@msg choice must be "merge" or "add", not `{choice}` choice deve essere "merge" o "add", non `{choice}` +@msg choose a direction to divide in scegli una direzione in cui dividere +@msg choose a folder to export to scegli una cartella in cui esportare +@msg choose a location for the package scegli una posizione per il pacchetto +@msg clipboard is empty gli appunti sono vuoti +@msg colorTable.{what}: `{h}` is not a colour such as "#ff8800" colorTable.{what}: `{h}` non è un colore come "#ff8800" +@msg colorTable.{what}: at most {MAX_TABLE} colours colorTable.{what}: al massimo {MAX_TABLE} colori +@msg command `{0}` is not available right now: {1} il comando `{0}` non è disponibile in questo momento: {1} +@msg compound paths can only contain paths i tracciati composti possono contenere solo tracciati +@msg compressed (RLE) bitmaps can't be read yet le bitmap compresse (RLE) non possono ancora essere lette +@msg damaged danneggiato +@msg decimals must be {_1}–{_2} (got {_3}) i decimali devono essere {_1}–{_2} (ricevuto {_3}) +@msg divide into 1 to {MAX_PIECES} slices dividi in un numero di sezioni da 1 a {MAX_PIECES} +@msg effect {k} is `{_1}`, not `{id}` l'effetto {k} è `{_1}`, non `{id}` +@msg empty brush stroke traccia di pennello vuota +@msg empty cutter oggetto di taglio vuoto +@msg empty path tracciato vuoto +@msg file version {0} is newer than this VectorCraft supports ({VERSION}) la versione del file {0} è più recente di quelle supportate da questo VectorCraft ({VERSION}) +@msg freeform point {i} needs `at` [x, y] and a valid `color` il punto a forma libera {i} richiede `at` [x, y] e un `color` valido +@msg give both `start` and `end` [x, y] (or neither) specifica sia `start` sia `end` [x, y] (o nessuno dei due) +@msg give corners 0–3 specifica angoli da 0 a 3 +@msg give the path `id` and the width point `index` specifica l'`id` del tracciato e l'`index` del punto di larghezza +@msg guides are locked le guide sono bloccate +@msg image '{key}' has no pixels and was left out l'immagine '{key}' non ha pixel ed è stata omessa +@msg image data `{_1}` is missing mancano i dati immagine `{_1}` +@msg image would be too large; lower the resolution l'immagine sarebbe troppo grande; riduci la risoluzione +@msg index must be a number or first, previous, next or last index deve essere un numero oppure first, previous, next o last +@msg index must be a number or first, previous, next or last, not `{other}` index deve essere un numero oppure first, previous, next o last, non `{other}` +@msg installing from a path is not available on the web; pass the module as `dataBase64` l'installazione da un percorso non è disponibile sul web; passa il modulo come `dataBase64` +@msg internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug) errore interno in `{cmd}`: {msg} (il documento è rimasto com'era; segnala questo bug) +@msg internal error: {msg} (please report this bug) errore interno: {msg} (segnala questo bug) +@msg invalid PDF setting: {0} impostazione PDF non valida: {0} +@msg invalid image data for `{0}` dati immagine non validi per `{0}` +@msg invalid parameters for `{cmd}`: {msg} parametri non validi per `{cmd}`: {msg} +@msg is not an image VectorCraft reads non è un'immagine che VectorCraft sa leggere +@msg it uses `{at}`, which VectorCraft's PostScript reader doesn't know usa `{at}`, che il lettore PostScript di VectorCraft non conosce +@msg it uses `{at}`, which VectorCraft's PostScript reader doesn't know, in {procs} usa `{at}`, che il lettore PostScript di VectorCraft non conosce, in {procs} +@msg its Windows metafile preview was opened instead, which may simplify the art è stata aperta invece la sua anteprima metafile di Windows, che potrebbe semplificare la grafica +@msg its preview was placed instead, at screen resolution è stata inserita invece la sua anteprima, a risoluzione dello schermo +@msg join needs open paths per unire servono tracciati aperti +@msg lang must be one of {_1} lang deve essere uno dei seguenti: {_1} +@msg layers can't be wrap objects i livelli non possono essere oggetti di avvolgimento +@msg missing `folder` manca `folder` +@msg missing `id` (see plugin.list) manca `id` (vedi plugin.list) +@msg missing `name` manca `name` +@msg missing `tool` manca `tool` +@msg missing index manca index +@msg multiple windows land with M11.5 le finestre multiple arriveranno con M11.5 +@msg name the file assegna un nome al file +@msg no CSS to copy: select objects with CSS of their own nessun CSS da copiare: seleziona oggetti con un CSS proprio +@msg no Live Paint edge near that point nessun bordo di pittura dinamica vicino a quel punto +@msg no Live Paint face at that point nessuna faccia di pittura dinamica in quel punto +@msg no PNG encoder nessun codificatore PNG +@msg no active document nessun documento attivo +@msg no active perspective plane nessun piano prospettico attivo +@msg no anchor points selected nessun punto di ancoraggio selezionato +@msg no app to open files here nessuna app per aprire file qui +@msg no artboard nessuna tavola da disegno +@msg no artboard {i} (0-based; the document has {_1}) nessuna tavola da disegno {i} (a partire da 0; il documento ne ha {_1}) +@msg no artboard {i} (0-based; the document has {count}) nessuna tavola da disegno {i} (a partire da 0; il documento ne ha {count}) +@msg no artboards named nessuna tavola da disegno indicata +@msg no artwork nessuna grafica +@msg no blend options nessuna opzione di fusione +@msg no bounds nessun limite +@msg no brush named `{name}` nessun pennello denominato `{name}` +@msg no catalog nessun catalogo +@msg no changes since the last save nessuna modifica dall'ultimo salvataggio +@msg no clock to keep a heartbeat by nessun orologio con cui mantenere il segnale di attività +@msg no colour group `{g}` nessun gruppo colori `{g}` +@msg no cross-reference table nessuna tabella dei riferimenti incrociati +@msg no current layer nessun livello corrente +@msg no data nessun dato +@msg no dialog open nessuna finestra di dialogo aperta +@msg no document nessun documento +@msg no document open nessun documento aperto +@msg no effect applied yet nessun effetto ancora applicato +@msg no effect at index {k} nessun effetto all'indice {k} +@msg no end record nessun record finale +@msg no file manager here nessun gestore file disponibile qui +@msg no file reader nessun modulo di lettura file +@msg no file system here nessun file system disponibile qui +@msg no file writer nessun modulo di scrittura file +@msg no files to place nessun file da inserire +@msg no format to export to nessun formato di esportazione +@msg no free recovery area nessuna area di recupero libera +@msg no gradient stop or freeform point is selected nessun cursore colore o punto a forma libera selezionato +@msg no graphic style `{name}` nessuno stile grafico `{name}` +@msg no graphic style `{n}` nessuno stile grafico `{n}` +@msg no interaction in progress nessuna interazione in corso +@msg no key object nessun oggetto chiave +@msg no library `{key}` (see {list}) nessuna libreria `{key}` (vedi {list}) +@msg no native format nessun formato nativo +@msg no pages nessuna pagina +@msg no pattern `{name}` nessun motivo `{name}` +@msg no perspective grid preset named `{name}` nessun preset di griglia prospettica denominato `{name}` +@msg no plug-in {0} is installed nessun plug-in {0} installato +@msg no plug-in {id} is installed nessun plug-in {id} installato +@msg no point {i} (the gradient has {_1}) nessun punto {i} (la sfumatura ne ha {_1}) +@msg no preset editor nessun editor di preset +@msg no previous transform nessuna trasformazione precedente +@msg no print preset named `{base}` nessun preset di stampa denominato `{base}` +@msg no print preset named `{name}` nessun preset di stampa denominato `{name}` +@msg no print service nessun servizio di stampa +@msg no revert command nessun comando Ripristina +@msg no saved PDF preset named `{name}` (built-in presets are read-only: start a new one from them) nessun preset PDF salvato denominato `{name}` (i preset integrati sono di sola lettura: creane uno nuovo a partire da essi) +@msg no saved presets nessun preset salvato +@msg no saved print preset named `{name}` ({DEFAULT_PRESET} is protected: start a new one from it) nessun preset di stampa salvato denominato `{name}` ({DEFAULT_PRESET} è protetto: creane uno nuovo a partire da esso) +@msg no saved profiles nessun profilo salvato +@msg no saved selections nessuna selezione salvata +@msg no saved themes nessun tema salvato +@msg no segment {segment} on line {line} nessun segmento {segment} alla riga {line} +@msg no selected slice in the image: select slices, or save all of them nessuna sezione selezionata nell'immagine: seleziona delle sezioni o salvale tutte +@msg no selection bounds nessun limite della selezione +@msg no slice selected nessuna sezione selezionata +@msg no such action azione inesistente +@msg no such anchor punto di ancoraggio inesistente +@msg no such artboard tavola da disegno inesistente +@msg no such document documento inesistente +@msg no such layer or object livello o oggetto inesistente +@msg no such object {0} oggetto {0} inesistente +@msg no such perspective grid preset preset di griglia prospettica inesistente +@msg no such recent file file recente inesistente +@msg no such recent font font recente inesistente +@msg no such saved selection selezione salvata inesistente +@msg no such segment segmento inesistente +@msg no such subpath sottotracciato inesistente +@msg no such user library libreria utente inesistente +@msg no such view vista inesistente +@msg no such width point punto di larghezza inesistente +@msg no swatch `{name}` nessun campione `{name}` +@msg no swatch library `{l}` (see swatch.library.list) nessuna libreria campioni `{l}` (vedi swatch.library.list) +@msg no symbol instances selected nessuna istanza di simbolo selezionata +@msg no target object has an opacity mask: select one or give `id` nessun oggetto di destinazione ha una maschera di opacità: selezionane uno o specifica `id` +@msg no threaded text selected nessun testo concatenato selezionato +@msg no user workspace `{from}` nessuna area di lavoro utente `{from}` +@msg node {_1} is not text il nodo {_1} non è testo +@msg not a DXF drawing non è un disegno DXF +@msg not a VectorCraft file: {0} non è un file VectorCraft: {0} +@msg not a VectorCraft shortcut set (missing `overrides`) non è un set di scelte rapide VectorCraft (manca `overrides`) +@msg not a graphic style library (format `{_1}`) non è una libreria di stili grafici (formato `{_1}`) +@msg not a stored central record non è un record centrale archiviato +@msg not a valid plug-in module: {0} non è un modulo plug-in valido: {0} +@msg not an EMF or WMF file non è un file EMF o WMF +@msg not found non trovato +@msg not in pattern editing mode non sei in modalità modifica motivo +@msg nothing encoded nessun dato codificato +@msg nothing selected nessuna selezione +@msg nothing to align niente da allineare +@msg nothing to distort niente da distorcere +@msg nothing to export: the document has no visible art (or turn on Use Artboards) niente da esportare: il documento non ha grafica visibile (oppure attiva Usa tavole da disegno) +@msg nothing to preview niente da visualizzare in anteprima +@msg nothing to print niente da stampare +@msg nothing to redo niente da ripetere +@msg nothing to save: the document has no visible art niente da salvare: il documento non ha grafica visibile +@msg nothing to undo niente da annullare +@msg nothing to warp niente da alterare +@msg nothing to wrap niente da avvolgere +@msg object {0} cannot have children l'oggetto {0} non può avere elementi figli +@msg object {id} is not a path l'oggetto {id} non è un tracciato +@msg page size {w} × {h} dimensioni pagina {w} × {h} +@msg page {0} does not exist (the PDF has {1}) la pagina {0} non esiste (il PDF ne ha {1}) +@msg paste unavailable impossibile incollare +@msg path is already closed il tracciato è già chiuso +@msg paths contain invalid coordinates i tracciati contengono coordinate non valide +@msg paths: give at least one file paths: specifica almeno un file +@msg pattern missing motivo mancante +@msg patterns nested too deeply are filled with mid-grey i motivi annidati troppo in profondità vengono riempiti di grigio medio +@msg percent must be above 0 and at most 6400, not {p} la percentuale deve essere maggiore di 0 e al massimo 6400, non {p} +@msg pick a colour, gradient or pattern to save as a swatch scegli un colore, una sfumatura o un motivo da salvare come campione +@msg plane must be left, right or ground plane deve essere left, right o ground +@msg plug-in ABI: {0} ABI del plug-in: {0} +@msg plug-in exceeded its {0} limite superato dal plug-in: {0} +@msg plug-in failed: {0} plug-in non riuscito: {0} +@msg plug-in manifest: {0} manifest del plug-in: {0} +@msg plug-in output: {0} output del plug-in: {0} +@msg plug-in parameters: {0} parametri del plug-in: {0} +@msg plug-in trapped: {0} il plug-in si è interrotto con un errore: {0} +@msg print settings are not an object le impostazioni di stampa non sono un oggetto +@msg printing isn't available here la stampa non è disponibile qui +@msg range `{s}` is empty l'intervallo `{s}` è vuoto +@msg range `{s}`: `{part}` names no number intervallo `{s}`: `{part}` non indica alcun numero +@msg range `{s}`: `{part}` runs backwards intervallo `{s}`: `{part}` è in ordine inverso +@msg range `{s}`: `{t}` is not a number from 1 to {count} intervallo `{s}`: `{t}` non è un numero da 1 a {count} +@msg recovery copy `{file}`: {e} copia di recupero `{file}`: {e} +@msg resolutions must be between 1 and 2400 ppi le risoluzioni devono essere comprese tra 1 e 2400 ppi +@msg result would exceed the canvas (coordinates out of range) il risultato supererebbe l'area di disegno (coordinate fuori intervallo) +@msg scale must be a number from {_1} to {_2}, not {_3} la scala deve essere un numero da {_1} a {_2}, non {_3} +@msg scale must be a number from {_1} to {_2}, not {s} la scala deve essere un numero da {_1} a {_2}, non {s} +@msg select (or target) objects whose appearance isn't basic seleziona (o imposta come destinazione) oggetti con un aspetto non di base +@msg select a Live Paint group seleziona un gruppo di pittura dinamica +@msg select a blend seleziona una fusione +@msg select a clip group seleziona un gruppo di ritaglio +@msg select a gradient mesh seleziona una trama sfumatura +@msg select a linked image: an embedded one has no file seleziona un'immagine collegata: un'immagine incorporata non ha un file +@msg select a repeat seleziona una ripetizione +@msg select a stroke with a variable width seleziona una traccia con larghezza variabile +@msg select a symbol instance seleziona un'istanza di simbolo +@msg select an Image Trace object seleziona un oggetto di ricalco immagine +@msg select an envelope seleziona un involucro +@msg select an image seleziona un'immagine +@msg select an object in perspective seleziona un oggetto in prospettiva +@msg select artwork (or a colour group) to recolor seleziona la grafica (o un gruppo colori) da ricolorare +@msg select at least two objects seleziona almeno due oggetti +@msg select objects, not layers seleziona oggetti, non livelli +@msg select one live rectangle, or give its `id` seleziona un rettangolo dinamico o specifica il suo `id` +@msg select paths to join seleziona i tracciati da unire +@msg select the art to repeat seleziona la grafica da ripetere +@msg select the artwork to warp seleziona la grafica da alterare +@msg select the objects to transform in perspective seleziona gli oggetti da trasformare in prospettiva +@msg select two or more graphic styles to merge seleziona due o più stili grafici da unire +@msg select type in perspective seleziona del testo in prospettiva +@msg selection has no bounds la selezione non ha limiti +@msg shadings of an unknown type were left out le ombreggiature di tipo sconosciuto sono state omesse +@msg shadings of more than 4096 patches or triangles were left out le ombreggiature con più di 4096 patch o triangoli sono state omesse +@msg shadings whose functions are of an unknown type are filled with their middle colour le ombreggiature con funzioni di tipo sconosciuto vengono riempite con il loro colore intermedio +@msg shortcut for `{k}` must be a string la scelta rapida per `{k}` deve essere una stringa +@msg stop {i} needs `offset` il cursore colore {i} richiede `offset` +@msg stop {i} needs a valid `color` il cursore colore {i} richiede un `color` valido +@msg stop {i}: `{k}` must be a number cursore colore {i}: `{k}` deve essere un numero +@msg the EMF header is damaged l'intestazione EMF è danneggiata +@msg the PDF has no pages il PDF non ha pagine +@msg the PDF is no longer loaded il PDF non è più caricato +@msg the PDF is password-protected: give its password il PDF è protetto da password: specifica la password +@msg the PDF password is wrong la password del PDF è errata +@msg the Save PDF dialog didn't open la finestra di dialogo Salva PDF non si è aperta +@msg the WMF header is damaged l'intestazione WMF è danneggiata +@msg the art could not be sampled impossibile campionare la grafica +@msg the art has no bounds la grafica non ha limiti +@msg the art is too light for any dots la grafica è troppo chiara per generare punti +@msg the artboard to fit must be a positive size up to {_1} pt la tavola da disegno da adattare deve avere una dimensione positiva fino a {_1} pt +@msg the background worker stopped il processo in background si è interrotto +@msg the compressed file unpacks to more than {_1} MB il file compresso, una volta decompresso, supera {_1} MB +@msg the document has never been saved il documento non è mai stato salvato +@msg the document has no artboard il documento non ha una tavola da disegno +@msg the document has no artboards il documento non ha tavole da disegno +@msg the document has no patterns il documento non ha motivi +@msg the document has no slices il documento non ha sezioni +@msg the document has no symbols il documento non ha simboli +@msg the drawing has no layout `{_1}` (it has {_2}) il disegno non ha il layout `{_1}` (ha {_2}) +@msg the drawing is no longer loaded il disegno non è più caricato +@msg the drawing is too large to open il disegno è troppo grande per essere aperto +@msg the export region is empty l'area di esportazione è vuota +@msg the export region is not finite l'area di esportazione non è finita +@msg the export returned unreadable data l'esportazione ha restituito dati illeggibili +@msg the export wrote no file l'esportazione non ha scritto alcun file +@msg the file holds only a placeholder page, not its art (it was saved without PDF compatibility): save it again with PDF compatibility on, or as PDF or SVG il file contiene solo una pagina segnaposto, non la sua grafica (è stato salvato senza compatibilità PDF): salvalo di nuovo con la compatibilità PDF attivata, oppure come PDF o SVG +@msg the file was read up to an error ({why}): what follows it was left out il file è stato letto fino a un errore ({why}): la parte successiva è stata omessa +@msg the file's preview header points outside the file l'intestazione di anteprima del file punta all'esterno del file +@msg the image's pixels don't match its size i pixel dell'immagine non corrispondono alle sue dimensioni +@msg the layer has no objects to clip by il livello non ha oggetti con cui ritagliare +@msg the layer or group is locked il livello o il gruppo è bloccato +@msg the layer to flatten into is hidden il livello in cui appiattire è nascosto +@msg the object already has an opacity mask l'oggetto ha già una maschera di opacità +@msg the object has no geometry l'oggetto non ha geometria +@msg the object has no opacity mask l'oggetto non ha una maschera di opacità +@msg the object has no stroke l'oggetto non ha traccia +@msg the object is beyond the plane's horizon l'oggetto è oltre l'orizzonte del piano +@msg the object isn't in perspective l'oggetto non è in prospettiva +@msg the object isn't on a perspective plane l'oggetto non si trova su un piano prospettico +@msg the object would cross the horizon of the perspective plane l'oggetto attraverserebbe l'orizzonte del piano prospettico +@msg the objects would leave the grid gli oggetti uscirebbero dalla griglia +@msg the package came back damaged il pacchetto è tornato danneggiato +@msg the pointer is beyond the plane's horizon il puntatore è oltre l'orizzonte del piano +@msg the preview image is empty l'immagine di anteprima è vuota +@msg the print job has no data il lavoro di stampa non contiene dati +@msg the scale is not a usable number la scala non è un numero utilizzabile +@msg the selected stroke's profile is already listed as {_1} il profilo della traccia selezionata è già elencato come {_1} +@msg the selection has no URL (or they differ) la selezione non ha un URL (oppure gli URL sono diversi) +@msg the selection isn't in perspective la selezione non è in prospettiva +@msg the stroke has no weight la traccia non ha spessore +@msg the thumbnail image is malformed l'immagine miniatura non è formata correttamente +@msg the top object must be a path, compound path or text object to use as a clipping mask l'oggetto superiore deve essere un tracciato, un tracciato composto o un oggetto di testo da usare come maschera di ritaglio +@msg the {tool} tool has no options lo strumento {tool} non ha opzioni +@msg there are no objects to release non ci sono oggetti da rilasciare +@msg there are no printer settings to open here non ci sono impostazioni della stampante da aprire qui +@msg this PostScript file can't be read ({_1}): save it as PDF or SVG in the app that made it impossibile leggere questo file PostScript ({_1}): salvalo come PDF o SVG nell'app che lo ha creato +@msg this file's PostScript couldn't be read ({why}): {what} impossibile leggere il PostScript di questo file ({why}): {what} +@msg this format holds one artboard: export several as PDF or with document.exportForScreens questo formato contiene una sola tavola da disegno: esportane più di una come PDF o con document.exportForScreens +@msg this is a DWG drawing, which can't be read: save it from the CAD app as an ASCII DXF and open that questo è un disegno DWG, che non può essere letto: salvalo dall'app CAD come DXF ASCII e apri quel file +@msg this is a PostScript file (an .ai saved in an older format or without PDF compatibility, or an EPS file), which can't be opened yet: save it as PDF, PDF-compatible .ai or SVG questo è un file PostScript (un .ai salvato in un formato precedente o senza compatibilità PDF, oppure un file EPS), che non può ancora essere aperto: salvalo come PDF, .ai compatibile con PDF o SVG +@msg this is not a PostScript file questo non è un file PostScript +@msg tool shortcuts must be a single key (optionally with Shift) le scelte rapide degli strumenti devono essere un singolo tasto (eventualmente con Shift) +@msg truncated troncato +@msg unknown command `{0}` comando sconosciuto `{0}` +@msg unknown effect `{id}` effetto sconosciuto `{id}` +@msg unknown format formato sconosciuto +@msg unknown format `{f}` (Save writes {_1}) formato sconosciuto `{f}` (Salva scrive {_1}) +@msg unknown freeform mode `{m}` (points, lines) modalità a forma libera sconosciuta `{m}` (points, lines) +@msg unknown gradient kind `{k}` (linear, radial, freeform) tipo di sfumatura sconosciuto `{k}` (linear, radial, freeform) +@msg unknown highlight `{h}` evidenziazione sconosciuta `{h}` +@msg unknown option `{path}.{k}` opzione sconosciuta `{path}.{k}` +@msg unknown overprints `{o}` (preserve, simulate or discard) valore di sovrastampa sconosciuto `{o}` (preserve, simulate o discard) +@msg unknown panel `{raw}` pannello sconosciuto `{raw}` +@msg unknown preference `{key}` preferenza sconosciuta `{key}` +@msg unknown preset (one of {_1}) preset sconosciuto (uno dei seguenti: {_1}) +@msg unknown preset `{name}` (high, medium, low or a saved one: see flattener.presets.list) preset sconosciuto `{name}` (high, medium, low o uno salvato: vedi flattener.presets.list) +@msg unknown preset `{name}` (see flattener.presets.list) preset sconosciuto `{name}` (vedi flattener.presets.list) +@msg unknown preset `{name}` (see webExport.presets.list) preset sconosciuto `{name}` (vedi webExport.presets.list) +@msg unknown side `{other}` (left|right|top|bottom) lato sconosciuto `{other}` (left|right|top|bottom) +@msg unknown tool `{tool}` strumento sconosciuto `{tool}` +@msg unknown tool `{t}` strumento sconosciuto `{t}` +@msg unknown tool or command `{key}` strumento o comando sconosciuto `{key}` +@msg unknown workspace (one of {_1}) area di lavoro sconosciuta (una delle seguenti: {_1}) +@msg unsupported: {0} non supportato: {0} +@msg version {0} files can't be compressed: only version {COMPRESSED_SINCE} and later open compressed files i file della versione {0} non possono essere compressi: solo la versione {COMPRESSED_SINCE} e successive aprono file compressi +@msg width and height are at least 1 pixel larghezza e altezza sono di almeno 1 pixel +@msg workspace name can't be empty il nome dell'area di lavoro non può essere vuoto +@msg {C}: no effect at index {from} {C}: nessun effetto all'indice {from} +@msg {_1} failed: {e} errore in {_1}: {e} +@msg {_1} files can be opened but not written (see document.formats) i file {_1} possono essere aperti ma non scritti (vedi document.formats) +@msg {_1} font families available {_1} famiglie di font disponibili +@msg {_1} is a live effect (Effect › Plug-ins) {_1} è un effetto dinamico (Effetto › Plug-in) +@msg {_1} is already used by {_2} {_1} è già usato da {_2} +@msg {_1} linked file(s) can't be read here: their previews show file collegati non leggibili qui: {_1}; vengono mostrate le loro anteprime +@msg {_1} linked image(s) changed on disk: Update Links shows the new versions immagini collegate modificate su disco: {_1}; Aggiorna collegamenti mostra le nuove versioni +@msg {_1}: not saved, so not closed {_1}: non salvato, quindi non chiuso +@msg {bpp}-bit bitmaps can't be read impossibile leggere bitmap a {bpp} bit +@msg {command} didn't create an object {command} non ha creato alcun oggetto +@msg {label} produced an empty result {label} ha prodotto un risultato vuoto +@msg {label}: lost track of a shape's style {label}: lo stile di una forma è andato perso +@msg {label}: select paths {label}: seleziona tracciati +@msg {label}: select paths, compound paths, groups or text {label}: seleziona tracciati, tracciati composti, gruppi o testo +@msg {label}… {label}… +@msg {name}: CRC mismatch {name}: CRC non corrispondente +@msg {name}: no local header {name}: nessuna intestazione locale +@msg {name}: no such recovery entry {name}: voce di recupero inesistente +@msg {path} can't be found: relink it first impossibile trovare {path}: ricollegalo prima +@msg {path}: no file system here (pass dataBase64 to open; omit the path to get dataBase64) {path}: nessun file system disponibile qui (passa dataBase64 per aprire; ometti il percorso per ottenere dataBase64) +@msg {path}: {e} {path}: {e} +@msg {status} ({e}) {status} ({e}) +@msg Couldn't place {name}: {e} Impossibile inserire {name}: {e} +@msg Couldn't paste from the clipboard: {e} Impossibile incollare dagli appunti: {e} +@msg Saved {path} with {_1} note(s): {first} Salvato {path} con {_1} nota/e: {first} +@msg Exported {what} with {_1} note(s): {first} Esportato {what} con {_1} nota/e: {first} +@msg Exported {what} Esportato {what} +@msg Saved {n} files beside {path} Salvati {n} file accanto a {path} +@msg Saving Salvataggio +@msg Saving {_1} Salvataggio di {_1} +@msg Exporting {_1} Esportazione di {_1} +@msg Saving recovery data for {_1} Salvataggio dei dati di recupero per {_1} +@msg Discarded {_1} recovered document(s) Documenti recuperati scartati: {_1} +@msg Restored {_1} recovered document(s): save them to keep them Documenti recuperati ripristinati: {_1}. Salvali per conservarli +@msg Embedded {n} image(s); {missing} missing: relink them first Immagini incorporate: {n}; mancanti: {missing} (ricollegale prima) +@msg Embedded {n} image(s) Immagini incorporate: {n} +@msg Relinked {_1} image(s) Immagini ricollegate: {_1} +@msg Relinked {n} image(s) Immagini ricollegate: {n} +@msg Relinked {n} image(s); not in that folder: {_1} Immagini ricollegate: {n}; non presenti in quella cartella: {_1} +@msg Updated {_1} image(s) Immagini aggiornate: {_1} +@msg Unembedded to {_1} Incorporamento rimosso, salvato in {_1} +@msg Reset {_1} Reimpostato {_1} +@msg Sent to {_1} Inviato a {_1} +@msg {_1} files {_1} file +@msg The graphics were lost and have been restarted Il contesto grafico è stato perso ed è stato riavviato +@msg Loading VectorCraft… Caricamento di VectorCraft… +@msg VectorCraft failed to start: {e} Impossibile avviare VectorCraft: {e} +@msg A browser with WebGPU or WebGL2 is required. È necessario un browser con WebGPU o WebGL2. +@msg The graphics were lost and couldn't be restarted. Il contesto grafico è stato perso e non è stato possibile riavviarlo. +@msg Your unsaved changes are kept in this browser: reload the page to get them back. Le modifiche non salvate sono conservate in questo browser: ricarica la pagina per recuperarle. +@msg Reload the page to go on (changes not saved yet may be lost). Ricarica la pagina per continuare (le modifiche non ancora salvate potrebbero andare perse). +@msg tool (a tool id) is required tool (un id di strumento) è obbligatorio +@msg {tool} isn't in a toolbar group of several tools {tool} non fa parte di un gruppo di più strumenti nella barra degli strumenti diff --git a/crates/ui-egui/src/i18n/mod.rs b/crates/ui-egui/src/i18n/mod.rs index 3ab62826..7f896d18 100644 --- a/crates/ui-egui/src/i18n/mod.rs +++ b/crates/ui-egui/src/i18n/mod.rs @@ -64,7 +64,7 @@ fn plural_czech(n: u64) -> usize { } /// The registry. English first: it is the fallback and the source language. -pub static LANGUAGES: [LangInfo; 7] = [ +pub static LANGUAGES: [LangInfo; 8] = [ LangInfo { code: "en", name: "English", source: "", plural: plural_one_other, complete_menus: false, catalog: OnceLock::new() }, // Japanese: the whole interface (every menu string and `tl!` literal), keeping the product, // workspace and perspective preset names in English (`MENU_KEEP_AS_IS`). @@ -81,6 +81,16 @@ pub static LANGUAGES: [LangInfo; 7] = [ complete_menus: true, catalog: OnceLock::new(), }, + // Italian: the whole interface and the status and error messages, keeping the same names in + // English as Spanish; every `it-*` locale (`it-IT`, `it-CH`, `it-SM` …) resolves here. + LangInfo { + code: "it", + name: "Italiano", + source: include_str!("it.tsv"), + plural: plural_one_other, + complete_menus: true, + catalog: OnceLock::new(), + }, // Brazilian Portuguese: every menu label (`menu_catalogs_translate_every_menu_label`), every // `tl!` literal and the plural messages; left English on purpose are the `MENU_KEEP_AS_IS` // strings (product name, language names, workspace names, perspective grid presets). diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs index 0184b4d2..a5b8b7bc 100644 --- a/crates/ui-egui/src/i18n/tests.rs +++ b/crates/ui-egui/src/i18n/tests.rs @@ -15,6 +15,10 @@ fn tags_map_to_languages() { for tag in ["es", "es_ES.UTF-8", "es-MX", "es_AR", "es-419", "es-US"] { assert_eq!(lang_from_tag(tag), Lang::from_code("es"), "{tag}"); } + // Italian: Italy, Switzerland and San Marino share the one catalog. + for tag in ["it", "it_IT.UTF-8", "it-CH", "it_SM"] { + assert_eq!(lang_from_tag(tag), Lang::from_code("it"), "{tag}"); + } // Traditional Chinese: by region, by script, and with a region after the script. assert_eq!(lang_from_tag("zh_TW.UTF-8"), Some(ZH())); assert_eq!(lang_from_tag("zh-TW"), Some(ZH())); @@ -391,9 +395,9 @@ fn cs() -> Lang { } /// Languages whose catalogs leave [`MENU_KEEP_AS_IS`] in English. -const KEEPS_MENU_NAMES: [&str; 4] = ["cs", "es", "ja", "pt-br"]; +const KEEPS_MENU_NAMES: [&str; 5] = ["cs", "es", "it", "ja", "pt-br"]; -/// Menu labels the menu-complete catalogs (Czech, Spanish, Japanese, Brazilian Portuguese) show as they are: the product name, a format name, the built-in workspace +/// Menu labels the menu-complete catalogs (Czech, Spanish, Italian, Japanese, Brazilian Portuguese) show as they are: the product name, a format name, the built-in workspace /// names and the perspective grid presets (names, shown untranslated wherever else they appear). /// Each language's own name in the Language menu is left alone too. const MENU_KEEP_AS_IS: &[&str] = &[ @@ -483,7 +487,7 @@ fn toggled_labels() -> Vec { labels } -/// Czech, Spanish, Japanese and Brazilian Portuguese cover every menu label, the Show/Hide pairs +/// Czech, Spanish, Italian, Japanese and Brazilian Portuguese cover every menu label, the Show/Hide pairs /// and the canvas context menu included (panels and dialogs not yet). #[test] fn menu_catalogs_translate_every_menu_label() { @@ -514,12 +518,17 @@ fn menu_catalogs_translate_every_menu_label() { assert_eq!(tr(Lang::from_code("ja").expect("ja"), "File"), "ファイル"); assert_eq!(tr(Lang::from_code("pt-br").expect("pt-br"), "File"), "Arquivo"); assert_eq!(tr(es(), "File"), "Archivo"); + assert_eq!(tr(it(), "Edit"), "Modifica"); } fn es() -> Lang { Lang::from_code("es").expect("es registered") } +fn it() -> Lang { + Lang::from_code("it").expect("it registered") +} + /// Spanish uses the vector-illustration vocabulary its users know, has two plural forms like /// English, and reads the same in the menus and in the panels. #[test] @@ -541,6 +550,26 @@ fn spanish_reads_as_spanish() { assert_eq!(trn(es(), 3, "{n} Layer", "{n} Layers"), "3 capas"); } +/// Italian uses the vector-illustration vocabulary its users know, has two plural forms like +/// English (zero takes the plural), and reads the same in the menus and in the panels. +#[test] +fn italian_reads_as_italian() { + for (en, want) in [ + ("Artboard Tool", "Strumento Tavola da disegno"), + ("Swatches", "Campioni"), + ("Pathfinder", "Elaborazione tracciati"), + ("Stroke", "Traccia"), + ("Fill", "Riempimento"), + ("Direct Selection Tool", "Strumento Selezione diretta"), + ("Save As…", "Salva con nome…"), + ("Undo", "Annulla"), + ] { + assert_eq!(tr(it(), en), want); + } + assert_eq!(trn(it(), 1, "{n} Layer", "{n} Layers"), "1 livello"); + assert_eq!(trn(it(), 0, "{n} Layer", "{n} Layers"), "0 livelli"); + assert_eq!(trn(it(), 3, "{n} Layer", "{n} Layers"), "3 livelli"); +} /// Catalogs written with spaces between words keep a fragment's leading and trailing spaces: the /// hint bar and a few labels are joined from pieces (" to finish", "Press "). #[test] @@ -559,11 +588,11 @@ fn czech_plurals_have_three_forms() { assert_eq!(forms, [2, 0, 1, 1, 2, 2, 2]); } -/// Czech and Spanish letters (and the punctuation their text uses) come from each family's own first font, not +/// Czech, Spanish and Italian letters (and the punctuation their text uses) come from each family's own first font, not /// from a fallback further down the stack. (`has_glyph` can't tell: it counts characters of the /// face that draws missing glyphs, the first one, as missing.) #[test] -fn czech_and_spanish_glyphs_are_available_without_system_fonts() { +fn czech_spanish_and_italian_glyphs_are_available_without_system_fonts() { let ctx = egui::Context::default(); crate::theme::install_fonts(&ctx); let mut output = ctx.run_ui(egui::RawInput::default(), |_| {}); @@ -574,7 +603,8 @@ fn czech_and_spanish_glyphs_are_available_without_system_fonts() { let first = first.unwrap(); let mut font = fonts.fonts.font(&family); let chars = font.characters(); - for ch in "áčďéěíňóřšťúůýžÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ„“‚‘…–ñÑüÜ¿¡”".chars() { + for ch in "áčďéěíňóřšťúůýžÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ„“‚‘…–ñÑüÜ¿¡”àèìòùÀÈÌÒÙ«»’".chars() + { assert!(chars.get(&ch).is_some_and(|fonts| fonts.contains(&first)), "{first} ({family:?}) has no {ch}"); } } @@ -651,7 +681,7 @@ fn complete_languages_translate_every_message() { } /// Languages whose catalogs cover every status and error message. -const COMPLETE_MESSAGES: &[&str] = &["es"]; +const COMPLETE_MESSAGES: &[&str] = &["es", "it"]; /// Crates whose error and status messages reach the status bar. const MESSAGE_CRATES: &[&str] = &["ui-egui", "engine", "doc", "format", "svg", "pdf", "eps", "text", "plugins", "metafile", "cad"]; diff --git a/docs/development.md b/docs/development.md index 5f9487af..aa441142 100644 --- a/docs/development.md +++ b/docs/development.md @@ -124,7 +124,8 @@ Languages shipped: English (`en`, the source), Traditional Chinese (`zh-hant`, c in Taiwan; `zh-TW`, `zh-HK`, `zh-MO` and `zh-Hant-*` locales all resolve to it), Simplified Chinese (`zh-hans`, complete, in the vocabulary used in mainland China; `zh-CN`, `zh-SG`, `zh-Hans-*` and a bare `zh` resolve to it, so the two scripts never mix), Japanese (`ja`, complete), Spanish (`es`, complete, in neutral -international Spanish; every `es-*` locale such as `es-ES`, `es-MX`, `es-AR` or `es-419` resolves to it), Czech (`cs`, every menu label) and Brazilian Portuguese +international Spanish; every `es-*` locale such as `es-ES`, `es-MX`, `es-AR` or `es-419` resolves to it), Italian (`it`, +complete; `it-IT`, `it-CH` and every other `it-*` locale resolve to it), Czech (`cs`, every menu label) and Brazilian Portuguese (`pt-br`, every menu label and every `tl!` literal). Untranslated text falls back to English until its rows are added. - `tl!("…")` translates a literal into the language the UI is drawn in; `i18n::t(s)` is the same for a @@ -152,10 +153,10 @@ international Spanish; every `es-*` locale such as `es-ES`, `es-MX`, `es-AR` or control channel, MCP and tests read them) and are translated only where the status bar draws them (`i18n::msg`). `@msg` catalog rows hold a whole message or a template such as `Couldn't open {name}: {e}`; `{_1}`, `{_2}` … stand for the format string's `{}`, and the values in the - placeholders are translated in turn (the reason after `: {e}` is often a message too). Spanish covers every + placeholders are translated in turn (the reason after `: {e}` is often a message too). Spanish and Italian cover every message literal the test scan finds (`complete_languages_translate_every_message`, languages listed in `COMPLETE_MESSAGES`): a new `Err("…")`, `Other(…)`, `#[error(…)]` or `status(…)` message needs an `es.tsv` - row (`VECTORCRAFT_I18N_DUMP_MESSAGES=messages.txt cargo test -p vectorcraft-ui-egui + and an `it.tsv` row (`VECTORCRAFT_I18N_DUMP_MESSAGES=messages.txt cargo test -p vectorcraft-ui-egui complete_languages_translate_every_message` lists them all). Other languages show messages in English until they add `@msg` rows. - Not translated on purpose: names that are user data (layers, swatches, fonts, documents), the tab From 4ba8a021079cee7876a57b443e5b164a41ec873c Mon Sep 17 00:00:00 2001 From: callmeBalloch Date: Thu, 8 Oct 2026 14:14:35 +0000 Subject: [PATCH 06/22] Contributors: add callmeBalloch (Riccardo Balloch) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011iayep93edeimiAE8oSfaT --- contributors/people.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/contributors/people.toml b/contributors/people.toml index 89c6db20..ac861d43 100644 --- a/contributors/people.toml +++ b/contributors/people.toml @@ -21,3 +21,7 @@ real_name = "Brandon Thomas" display_name = "Brandon Thomas" sync_github_name = false + +[people.callmeBalloch] +real_name = "Riccardo Balloch" +sync_github_name = false From 7c5799aec63b1e45e3b5c72c4cda23e4b9b0d41b Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 21:31:28 +0700 Subject: [PATCH 07/22] i18n: Italian rows for strings added since the PR's base, consistency and fit fixes (review of #515) - Italian rows for the strings main gained after the PR's base: the floating panels of #513 (Float Panel, Dock Panel, the drag hints, two window.float messages) and the GPU fallback status message of #519, so the completeness tests pass on current main. - File > Document Setup... reads "Imposta documento..." like the dialog title and the Properties button, instead of "Impostazione documento...". - The Properties panel's quick action "Arrange: Bring to Front" reads "Porta in primo piano": "Disponi: Porta in primo piano" was clipped at both ends of its fixed-width button. - OpenType figure style "Proportional Oldstyle" reads "Proporzionali stile antico", matching "Tabulari stile antico". - Blank line between the Italian test and the next item; ROADMAP's "Last updated" lists the Italian interface (#514). Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 2 +- crates/ui-egui/src/i18n/it.tsv | 15 ++++++++++++--- crates/ui-egui/src/i18n/tests.rs | 1 + 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index a03970f8..4e8d8350 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv index b3c9d5a4..65ab696f 100644 --- a/crates/ui-egui/src/i18n/it.tsv +++ b/crates/ui-egui/src/i18n/it.tsv @@ -168,7 +168,7 @@ Area Type Tool Strumento Testo in area Around Object Attorno all'oggetto Arrange Disponi - Arrange: Bring to Front Disponi: Porta in primo piano + Arrange: Bring to Front Porta in primo piano Arrowheads: Punte di freccia: Art Grafica Art using a deleted global swatch keeps its colour. La grafica che usa un campione globale eliminato mantiene il suo colore. @@ -665,7 +665,7 @@ Document Raster Effects Settings Dialog Finestra di dialogo Impostazioni effetti raster documento Document Raster Effects Settings… Impostazioni effetti raster documento… Document Setup Imposta documento - Document Setup… Impostazione documento… + Document Setup… Imposta documento… Document Swatches Campioni del documento Document Title: Titolo del documento: Documents you create appear here. I documenti che crei vengono visualizzati qui. @@ -1904,7 +1904,7 @@ Proof Colors Colori di prova Proof Setup Impostazione prova Properties Proprietà - Proportional Oldstyle Proporzionale vecchio stile + Proportional Oldstyle Proporzionali stile antico Pucker & Bloat… Contrai e gonfia… Pucker Tool Strumento Contrai Punctuation Punteggiatura @@ -3053,6 +3053,12 @@ axis Both Entrambi Drag to move Trascina per spostare Drag to float as a toolbar Trascina per rendere mobile come barra degli strumenti Put back in the toolbar Riporta nella barra degli strumenti + Float Panel Rendi mobile pannello + Dock Panel Ancora pannello + Drag to float the panel group Trascina per rendere mobile il gruppo di pannelli + Put back in the dock Riporta nell'area dei pannelli + Drag to float the toolbar Trascina per rendere mobile la barra degli strumenti + Drag to the window's left edge to dock Trascina sul bordo sinistro della finestra per ancorare Float Tool Group Rendi mobile gruppo strumenti # Status and error messages (`@msg`), translated where the status bar shows them; the message itself @@ -3565,6 +3571,7 @@ axis Both Entrambi @msg Sent to {_1} Inviato a {_1} @msg {_1} files {_1} file @msg The graphics were lost and have been restarted Il contesto grafico è stato perso ed è stato riavviato +@msg The graphics processor tried first couldn't show the window, so VectorCraft started again on {summary} Il processore grafico provato per primo non è riuscito a mostrare la finestra, quindi VectorCraft è stato riavviato con {summary} @msg Loading VectorCraft… Caricamento di VectorCraft… @msg VectorCraft failed to start: {e} Impossibile avviare VectorCraft: {e} @msg A browser with WebGPU or WebGL2 is required. È necessario un browser con WebGPU o WebGL2. @@ -3573,3 +3580,5 @@ axis Both Entrambi @msg Reload the page to go on (changes not saved yet may be lost). Ricarica la pagina per continuare (le modifiche non ancora salvate potrebbero andare perse). @msg tool (a tool id) is required tool (un id di strumento) è obbligatorio @msg {tool} isn't in a toolbar group of several tools {tool} non fa parte di un gruppo di più strumenti nella barra degli strumenti +@msg onto must name a panel floating in another group onto deve indicare un pannello mobile in un altro gruppo +@msg x and y must both be numbers x e y devono essere entrambi numeri diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs index a5b8b7bc..13964493 100644 --- a/crates/ui-egui/src/i18n/tests.rs +++ b/crates/ui-egui/src/i18n/tests.rs @@ -570,6 +570,7 @@ fn italian_reads_as_italian() { assert_eq!(trn(it(), 0, "{n} Layer", "{n} Layers"), "0 livelli"); assert_eq!(trn(it(), 3, "{n} Layer", "{n} Layers"), "3 livelli"); } + /// Catalogs written with spaces between words keep a fragment's leading and trailing spaces: the /// hint bar and a few labels are joined from pieces (" to finish", "Press "). #[test] From 1d14f337dbb1c32875e481bbec00c641355702c4 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 22:51:40 +0700 Subject: [PATCH 08/22] Fix #511: Live Corners on any path's corners (stars, polygons, pen paths) Corner widgets only ever showed on live rectangles: CornerWidgets::of bailed out unless the selection's live shape was LiveShape::Rectangle, and object.setLiveShape only edited rectangle radii. A star is a plain path, so it had no widgets with either selection tool. - geom::corners: the corners of any path (anchors without handles between two straight sides) and the path with them cut round, inverted round or chamfered, each corner a circle tangent to both sides, its radius no larger than takes the cut halfway along its shorter side. Rectangles now cut their corners with it (bit-identical anchors and layout). - doc::corners::LiveCorners/set_corners: one model for a live rectangle's, a live polygon's (new radii/kinds) and any other path's corners (new LiveShape::Path keeping the uncut outline, plain again once nothing is cut); radii scale with transforms (Scale Corners) and stay circular. - object.setLiveShape takes anchor indices for `corners` on any path; polygons keep a shared radius as their sides change. - Widgets: Direct Selection on any path, Selection on live rectangles and polygons; placed on each corner's bisector, the drag follows it, the red limit outline marks corners at their own limit; the angle preference and View > Hide Corner Widget apply. Corners dialog and the Properties and Transform panels' Corner Radius (now on polygons too) work on them. - Tests for the star, the polygon and a pen path in geom, doc, tools, engine and ui-egui; docs and ROADMAP. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 8 +- crates/doc/src/corners.rs | 271 +++++++++++++++ crates/doc/src/lib.rs | 2 + crates/doc/src/node.rs | 175 ++++++---- crates/engine/src/cmd/create.rs | 3 +- crates/engine/src/cmd/object.rs | 77 ++-- crates/engine/src/tests_livecorners.rs | 135 ++++++- crates/geom/src/corners.rs | 283 +++++++++++++++ crates/geom/src/lib.rs | 1 + crates/geom/src/shapes.rs | 59 +--- crates/svg/src/css.rs | 4 +- crates/tools/src/corners.rs | 444 ++++++++++++++++-------- crates/tools/src/direct.rs | 8 +- crates/tools/src/lib.rs | 2 +- crates/tools/src/select.rs | 8 +- crates/ui-egui/src/canvas.rs | 32 +- crates/ui-egui/src/dialogs/corners.rs | 63 ++-- crates/ui-egui/src/i18n/es.tsv | 6 +- crates/ui-egui/src/menus.rs | 2 +- crates/ui-egui/src/panels/mod.rs | 23 +- crates/ui-egui/src/panels/properties.rs | 16 +- crates/ui-egui/src/panels/transform.rs | 13 +- docs/control-protocol.md | 6 +- docs/mcp.md | 33 +- 24 files changed, 1281 insertions(+), 393 deletions(-) create mode 100644 crates/doc/src/corners.rs create mode 100644 crates/geom/src/corners.rs diff --git a/ROADMAP.md b/ROADMAP.md index d6434cac..78ccf623 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), Live Corners on stars, polygons and pen paths (#511); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -121,7 +121,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes). - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag). - - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442). + - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442). Live Corners work on any path's corners too, as on a rectangle's (#511): a star's, a live polygon's (which also shows them to the Selection tool, has a Corner Radius field in the Properties and Transform panels and keeps its radius as its sides change) and a pen path's, wherever two straight sides meet at an anchor. Direct Selection shows the widgets of every corner, or of the corners holding selected anchors; each corner is a circle tangent to both sides, drawn no larger than takes its cut halfway along its shorter side; a path keeps its uncut outline so its corners stay editable, and the same command, dialog, angle preference and View › Hide Corner Widget apply. - **Pen:** Alt pressed in the middle of dragging out an anchor splits its handles and keeps the curve already shaped into it (only the outgoing handle follows the pointer); Space held while dragging out an anchor moves it, handles and all. A press on the first anchor of the path being drawn closes it whatever the drag then does: the drag shapes the closing curve (symmetric handles, Alt breaks them) and the release closes the path wherever it ends (#501). Clicking the last anchor of the path being drawn retracts its outgoing handle (convert cursor), and dragging from it pulls out a new one on its own. Auto Add/Delete: over a selected path, a click on a segment adds an anchor and a click on an anchor deletes it (add and delete cursors); Shift held, or Preferences › General › Disable Auto Add/Delete, starts a new path instead. Alt held over a handle end or an anchor of a selected path (the one being drawn too) works as the Anchor Point tool, with its convert cursor: dragging a handle moves it alone, clicking a smooth anchor makes it a corner, dragging an anchor pulls out new symmetric handles, dragging a segment reshapes it; drawing then goes on. Cmd (Ctrl) held drags with the selection tool chosen last, Direct Selection until one is (handles, anchors and segments of the path being drawn or another), and the Pen then goes on drawing its path while that stays selected; the pointer shows that tool's while Cmd is held. The same holds for agents (`pointer_gesture` with `mods.cmd`), as the borrowing now lives in the engine (#494). - **Path editing (#494):** the handles shown are the handles that drag: Direct Selection drags those of a path selected as a whole (as the Pen leaves it), the Anchor Point tool and Pen+Alt no longer grab handles that Show handles when multiple anchors are selected hides, a handle shorter than the tolerance leaves its anchor to be picked, and the anchor tools pick within Selection & Anchor Display › Tolerance. A dragged segment keeps a smooth anchor at either end smooth. With Direct Selection, the Pen, the Curvature and the anchor tools, a path selected as a whole shows all its anchors selected, and the Control bar and the Properties panel offer Convert (corner, smooth) for them too; Remove and Cut wait for anchors direct-selected (#504). A handle drag gathers its snap targets once per drag (it took 21 ms per pointer move on a 20,000-path document, now 1 ms; `vectorcraft-cli perf` measures handle and segment drags on a 5,000-anchor path). - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type. @@ -167,7 +167,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist |---|---|---|---| | M0 | Skeleton + vertical slice | ✅ done | — | | M1 | Selection, transform, layers, MCP | ✅ mostly done (transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending) | 4–6 | -| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed; Shaper, the remaining Pen modifier nuances) | 15–20 | +| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper, the remaining Pen modifier nuances) | 15–20 | | M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork; gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool, Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries. Left: freeform and mixed spot/process gradients export as stops or process colours to SVG/PDF; confirm the Scale Strokes & Effects default | 4–8 | | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 | | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 | @@ -199,7 +199,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale) | Area | Weight | Done | Missing (main items) | One agent (h) | |---|---:|---:|---|---:| | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances (the rotated persistent bounding box is done) | 4–6 | -| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, the freehand Tool Options' Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection and brush angle/roundness, Touch Type, Live Corners on plain paths and polygons (and Relative rounding) | 10–15 | +| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, the freehand Tool Options' Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection and brush angle/roundness, Touch Type, Live Corners on corners between curved sides (and Relative rounding) | 10–15 | | Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection, options (Tool Options dialog, clicking a stroke in merge mode) and Shift-drag marquee | 3–6 | | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 | | Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 12–20 | diff --git a/crates/doc/src/corners.rs b/crates/doc/src/corners.rs new file mode 100644 index 00000000..a618ee1b --- /dev/null +++ b/crates/doc/src/corners.rs @@ -0,0 +1,271 @@ +//! Live Corners on any path: the corners of its uncut outline (a live rectangle's or polygon's, a +//! live path's, or a plain path's own), each one's radius and kind, and the anchors of the path as +//! drawn that belong to each. [`set_corners`] edits them. + +use std::borrow::Cow; +use std::collections::BTreeSet; + +use vectorcraft_geom::corners::{Corner, cut_corners, path_corners}; +use vectorcraft_geom::shapes::{self, CornerKind}; +use vectorcraft_geom::{Affine, PathData, Rect}; + +use crate::node::{LiveShape, Node, NodeKind}; +use crate::selection::AnchorRef; + +/// The Live Corners of a path. +#[derive(Clone, Debug)] +pub struct LiveCorners<'a> { + /// The path with its corners uncut, in the corners' own space: a live rectangle's (its size + /// and radii in document units, see [`LiveShape::folded`]), else the document's. + pub base: Cow<'a, PathData>, + /// Maps `base` into the document. + pub xf: Affine, + /// The corners that can be cut, in anchor order ([`path_corners`] of `base`). + pub corners: Vec, + radii: Vec, + kinds: Vec, + /// For each anchor of the path as drawn (per subpath), the anchor of `base` it comes from. + sources: Vec>, +} + +impl<'a> LiveCorners<'a> { + /// The Live Corners of `path` and its live shape; `None` for shapes without corners (ellipses, + /// lines). + pub fn new(path: &'a PathData, live: Option<&'a LiveShape>) -> Option { + let (base, xf, radii, kinds) = match live { + None => (Cow::Borrowed(path), Affine::IDENTITY, vec![], vec![]), + Some(l @ LiveShape::Rectangle { .. }) => { + let LiveShape::Rectangle { w, h, radii, kinds, xf } = l.folded() else { return None }; + (Cow::Owned(shapes::rectangle(Rect::new(0.0, 0.0, w, h))), xf, radii.to_vec(), kinds.to_vec()) + } + Some(l @ LiveShape::Polygon { radii, kinds, .. }) => (Cow::Owned(l.polygon_outline()), Affine::IDENTITY, radii.clone(), kinds.clone()), + Some(LiveShape::Path { base, radii, kinds }) => (Cow::Borrowed(base), Affine::IDENTITY, radii.clone(), kinds.clone()), + Some(LiveShape::Ellipse { .. } | LiveShape::Line { .. }) => return None, + }; + let sources = if radii.iter().any(|r| *r > 0.0) { + cut_corners(&base, &radii, &kinds).1 + } else { + let mut first = 0; + base.subpaths + .iter() + .map(|sp| { + first += sp.anchors.len(); + (first - sp.anchors.len()..first).collect() + }) + .collect() + }; + Some(Self { corners: path_corners(&base), base, xf, radii, kinds, sources }) + } + + /// The Live Corners of a path object. + pub fn of(node: &'a Node) -> Option { + let NodeKind::Path { path, live, .. } = &node.kind else { return None }; + Self::new(path, live.as_ref()) + } + + /// The corner at anchor `index` of `base`. + pub fn corner(&self, index: usize) -> Option<&Corner> { + self.corners.binary_search_by_key(&index, |c| c.index).ok().and_then(|i| self.corners.get(i)) + } + + /// The radius corner `index` is set to, in document units (drawn no larger than fits). + pub fn radius(&self, index: usize) -> f64 { + self.radii.get(index).copied().unwrap_or(0.0) + } + + /// The kind corner `index` is cut with. + pub fn kind(&self, index: usize) -> CornerKind { + self.kinds.get(index).copied().unwrap_or_default() + } + + /// Every corner. + pub fn all(&self) -> BTreeSet { + self.corners.iter().map(|c| c.index).collect() + } + + /// The corners holding one of `anchors` (of the path as drawn). + pub fn corners_of(&self, anchors: &BTreeSet) -> BTreeSet { + anchors.iter().filter_map(|(si, ai)| self.sources.get(*si)?.get(*ai).copied()).filter(|k| self.corner(*k).is_some()).collect() + } + + /// The corners Live Corners edit for a selection: those holding a selected anchor when the + /// path is partly selected (Direct Selection), else every corner. + pub fn picked(&self, partial: Option<&BTreeSet>) -> BTreeSet { + let picked = partial.map(|a| self.corners_of(a)).unwrap_or_default(); + if picked.is_empty() { self.all() } else { picked } + } + + /// The anchors of the path as drawn that belong to `corners` (to keep them selected as the + /// path changes). + pub fn anchors_of(&self, corners: &BTreeSet) -> BTreeSet { + let mut out = BTreeSet::new(); + for (si, from) in self.sources.iter().enumerate() { + out.extend(from.iter().enumerate().filter(|(_, k)| corners.contains(k)).map(|(ai, _)| (si, ai))); + } + out + } + + /// For each anchor of the path as drawn (per subpath), the anchor of `base` it comes from. + pub fn sources(&self) -> &[Vec] { + &self.sources + } + + /// The radius (document units) and kind `corners` share (each `None` when they differ, or + /// for no corners). + pub fn style(&self, corners: &BTreeSet) -> (Option, Option) { + fn shared(mut it: impl Iterator, same: impl Fn(T, T) -> bool) -> Option { + let first = it.next()?; + it.all(|x| same(x, first)).then_some(first) + } + let radius = shared(corners.iter().map(|k| self.radius(*k)), |a, b| (a - b).abs() < 1e-9); + (radius, shared(corners.iter().map(|k| self.kind(*k)), |a, b| a == b)) + } +} + +/// Set `radius` (document units; negative: 0) and/or `kind` on the `corners` (anchor indices of +/// the uncut outline, see [`LiveCorners`]) of a path and its live shape, then cut the path again. +/// A path that isn't a live shape keeps its uncut outline as a [`LiveShape::Path`], which is a +/// plain path again once no corner is cut. Ellipses and lines have no corners: they stay as they +/// are. +pub fn set_corners(path: &mut PathData, live: &mut Option, corners: &BTreeSet, radius: Option, kind: Option) { + fn edit(radii: &mut [f64], kinds: &mut [CornerKind], corners: &BTreeSet, radius: Option, kind: Option) { + for k in corners { + if let (Some(r), Some(slot)) = (radius, radii.get_mut(*k)) { + *slot = r.max(0.0); + } + if let (Some(kind), Some(slot)) = (kind, kinds.get_mut(*k)) { + *slot = kind; + } + } + } + /// One radius and kind per corner of an outline of `n` anchors while editing; none saved + /// when all are sharp or round. + fn edit_vec( + n: usize, + radii: &mut Vec, + kinds: &mut Vec, + corners: &BTreeSet, + radius: Option, + kind: Option, + ) { + radii.resize(n, 0.0); + kinds.resize(n, CornerKind::Round); + edit(radii, kinds, corners, radius, kind); + if radii.iter().all(|r| *r <= 0.0) { + radii.clear(); + } + if kinds.iter().all(|k| *k == CornerKind::Round) { + kinds.clear(); + } + } + let l = live.get_or_insert_with(|| LiveShape::Path { base: path.clone(), radii: vec![], kinds: vec![] }); + // Radii are document lengths and corners circular, also on a rectangle from a file that kept + // an uneven scale in its transform (#442). + l.fold_scale(); + match l { + LiveShape::Rectangle { radii, kinds, .. } => edit(radii, kinds, corners, radius, kind), + LiveShape::Polygon { sides, radii, kinds, .. } => edit_vec(*sides as usize, radii, kinds, corners, radius, kind), + LiveShape::Path { base, radii, kinds } => edit_vec(base.anchor_count(), radii, kinds, corners, radius, kind), + LiveShape::Ellipse { .. } | LiveShape::Line { .. } => return, + } + match live { + Some(LiveShape::Path { base, radii, kinds }) if radii.is_empty() && kinds.is_empty() => { + *path = std::mem::take(base); + *live = None; + } + Some(l) => *path = l.to_path(), + None => {} + } +} + +#[cfg(test)] +mod tests { + use super::*; + use vectorcraft_geom::{Point, SubPath}; + + fn set(v: &[usize]) -> BTreeSet { + v.iter().copied().collect() + } + + fn anchors(v: &[usize]) -> BTreeSet { + v.iter().map(|ai| (0, *ai)).collect() + } + + #[test] + fn rectangle_corners_map_to_their_anchors() { + let l = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0, 10.0, 0.0, 0.0], kinds: Default::default(), xf: Affine::IDENTITY }; + let path = l.to_path(); + let c = LiveCorners::new(&path, Some(&l)).unwrap(); + // Anchors: top-left, the top-right corner's two, bottom-right, bottom-left. + assert_eq!(c.sources(), [vec![0, 1, 1, 2, 3]]); + assert_eq!(path.anchor_count(), 5); + assert_eq!(c.corners_of(&anchors(&[2, 4])), set(&[1, 3])); + assert!(c.corners_of(&anchors(&[9])).is_empty(), "out of range"); + assert_eq!(c.anchors_of(&set(&[1, 3])), anchors(&[1, 2, 4])); + // Partly selected: the corners of the selected anchors; wholly (or no anchor): all four. + assert_eq!(c.picked(Some(&anchors(&[0]))), set(&[0])); + assert_eq!(c.picked(None), set(&[0, 1, 2, 3])); + assert_eq!(c.picked(Some(&anchors(&[]))), set(&[0, 1, 2, 3])); + assert_eq!(c.style(&set(&[1])), (Some(10.0), Some(CornerKind::Round))); + assert_eq!(c.style(&set(&[0, 1])), (None, Some(CornerKind::Round))); + assert_eq!(c.style(&set(&[0, 2, 3])), (Some(0.0), Some(CornerKind::Round))); + let e = LiveShape::Ellipse { w: 1.0, h: 1.0, pie: (0.0, 360.0), xf: Affine::IDENTITY }; + assert!(LiveCorners::new(&e.to_path(), Some(&e)).is_none()); + } + + /// #511: a plain path (a star) rounds its corners and keeps them editable; with none cut it + /// is plain again. + #[test] + fn a_plain_path_keeps_its_cut_corners_live() { + let star = shapes::star(Point::new(100.0, 100.0), 50.0, 25.0, 5, 0.0); + let (mut path, mut live) = (star.clone(), None); + set_corners(&mut path, &mut live, &set(&[0, 2]), Some(5.0), None); + let Some(LiveShape::Path { base, radii, kinds }) = &live else { panic!("live corners: {live:?}") }; + assert_eq!((base, radii.len(), kinds.len()), (&star, 10, 0)); + assert_eq!(path.anchor_count(), 12, "two corners cut"); + let c = LiveCorners::new(&path, live.as_ref()).unwrap(); + assert_eq!(c.style(&set(&[0, 2])), (Some(5.0), Some(CornerKind::Round))); + assert_eq!(c.corners_of(&anchors(&[0, 11])), set(&[0]), "the first corner's cut ends the path"); + // Kinds alone keep it live; squaring every corner makes it the plain star again. + set_corners(&mut path, &mut live, &set(&[0, 2]), Some(0.0), Some(CornerKind::Chamfer)); + assert!(matches!(&live, Some(LiveShape::Path { radii, .. }) if radii.is_empty())); + set_corners(&mut path, &mut live, &set(&[0, 2]), None, Some(CornerKind::Round)); + assert_eq!((path, live), (star, None)); + } + + /// A polygon's corners are cut in the document and survive a change of sides when shared. + #[test] + fn polygon_corners_follow_their_sides() { + let mut l = LiveShape::Polygon { radius: 50.0, sides: 6, xf: Affine::translate((100.0, 100.0)), radii: vec![], kinds: vec![] }; + let (mut path, mut live) = (l.to_path(), Some(l.clone())); + set_corners(&mut path, &mut live, &set(&[0, 1, 2, 3, 4, 5]), Some(8.0), None); + assert_eq!(path.anchor_count(), 12); + l = live.clone().unwrap(); + l.set_sides(8); + assert!(matches!(&l, LiveShape::Polygon { radii, .. } if *radii == vec![8.0; 8])); + assert_eq!(l.to_path().anchor_count(), 16); + // Mixed radii: the new corners are sharp. + set_corners(&mut path, &mut live, &set(&[1]), Some(3.0), None); + let mut l = live.unwrap(); + l.set_sides(7); + assert!(matches!(&l, LiveShape::Polygon { radii, .. } if *radii == [8.0, 3.0, 8.0, 8.0, 8.0, 8.0, 0.0])); + // An uneven scale keeps the cuts circular: the radius scales by the mean scale. + let mut p = l.clone(); + assert!(p.transform(Affine::scale_non_uniform(4.0, 1.0))); + assert!(matches!(&p, LiveShape::Polygon { radii, .. } if (radii[0] - 16.0).abs() < 1e-9)); + assert!(!p.transform(Affine::translate((5.0, 0.0))), "a move needs no new cuts"); + } + + #[test] + fn open_paths_and_curves_keep_their_ends_and_smooth_anchors() { + let pen = PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 80.0)], false)); + let c = LiveCorners::new(&pen, None).unwrap(); + assert_eq!(c.all(), set(&[1])); + assert_eq!(c.picked(Some(&anchors(&[0]))), set(&[1]), "an end is no corner: every corner"); + let (mut path, mut live) = (pen.clone(), None); + set_corners(&mut path, &mut live, &c.all(), Some(10.0), None); + assert_eq!(path.anchor_count(), 4); + assert_eq!(path.subpaths[0].anchors[0].p, Point::new(0.0, 0.0)); + assert_eq!(path.subpaths[0].anchors[3].p, Point::new(100.0, 80.0)); + } +} diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs index a357cd07..a9fb74da 100644 --- a/crates/doc/src/lib.rs +++ b/crates/doc/src/lib.rs @@ -10,6 +10,7 @@ pub mod assets; pub mod blend; pub mod clipnest; pub mod cmyk; +pub mod corners; pub mod graph; pub mod hit; pub mod inks; @@ -58,6 +59,7 @@ pub use appearance::{ StrokeLayer, WidthProfile, }; pub use assets::ExportAsset; +pub use corners::LiveCorners; pub use graph::{GraphKind, GraphSpec}; pub use hit::{Hit, HitKind}; pub use links::{LinkInfo, PlacementOptions}; diff --git a/crates/doc/src/node.rs b/crates/doc/src/node.rs index a51102d1..845f6f2e 100644 --- a/crates/doc/src/node.rs +++ b/crates/doc/src/node.rs @@ -1,17 +1,16 @@ //! Document nodes. -use std::collections::BTreeSet; use std::sync::Arc; use serde::{Deserialize, Serialize}; use vectorcraft_color::BlendMode; +use vectorcraft_geom::corners::cut_corners; use vectorcraft_geom::shapes::{self, CornerKind}; use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect}; use crate::appearance::Appearance; use crate::live::{BlendSpec, EnvelopeKind, GradientMesh, Outliner}; use crate::pattern::RepeatSpec; -use crate::selection::AnchorRef; use crate::text::TextObject; /// Stable per-document object id. Never reused. @@ -104,11 +103,30 @@ pub enum LiveShape { radius: f64, sides: u32, xf: Affine, + /// Corner radii in document units, by vertex from the first one clockwise (none: sharp). + #[serde(default, skip_serializing_if = "Vec::is_empty")] + radii: Vec, + /// Corner kinds, in the same order (none: round). + #[serde(default, skip_serializing_if = "all_round")] + kinds: Vec, }, Line { a: Point, b: Point, }, + /// Any other path whose corners Live Corners cut (a star, a pen path): it keeps its uncut + /// outline so the corners stay editable. Without a cut corner it is a plain path again. + Path { + /// The path with its corners uncut, in the document. + base: PathData, + /// Corner radii in document units, by anchor index of `base` (counting every subpath's + /// anchors in order; missing: sharp). + #[serde(default, skip_serializing_if = "Vec::is_empty")] + radii: Vec, + /// Corner kinds, in the same order (missing: round). + #[serde(default, skip_serializing_if = "all_round")] + kinds: Vec, + }, } impl LiveShape { @@ -119,6 +137,7 @@ impl LiveShape { LiveShape::Ellipse { .. } => "Ellipse", LiveShape::Polygon { .. } => "Polygon", LiveShape::Line { .. } => "Line", + LiveShape::Path { .. } => "Path", } } /// Regenerate the path. @@ -128,10 +147,33 @@ impl LiveShape { shapes::rectangle_with_corners(Rect::new(0.0, 0.0, *w, *h), *radii, *kinds).transformed(*xf) } LiveShape::Ellipse { w, h, xf, .. } => shapes::ellipse(Rect::new(0.0, 0.0, *w, *h)).transformed(*xf), - LiveShape::Polygon { radius, sides, xf } => shapes::polygon(Point::ZERO, *radius, *sides, 0.0).transformed(*xf), + LiveShape::Polygon { radii, kinds, .. } => cut_corners(&self.polygon_outline(), radii, kinds).0, LiveShape::Line { a, b } => shapes::line(*a, *b), + LiveShape::Path { base, radii, kinds } => cut_corners(base, radii, kinds).0, } } + /// A polygon's outline with its corners uncut, in the document (empty for other shapes). + pub fn polygon_outline(&self) -> PathData { + match self { + LiveShape::Polygon { radius, sides, xf, .. } => shapes::polygon(Point::ZERO, *radius, *sides, 0.0).transformed(*xf), + _ => PathData::default(), + } + } + /// Give a polygon `n` sides (3–1000). Its corners keep the radius and kind they shared; else + /// the corners past the old last one are sharp. + pub fn set_sides(&mut self, n: u64) { + let LiveShape::Polygon { sides, radii, kinds, .. } = self else { return }; + *sides = n.clamp(3, 1000) as u32; + fn spread(v: &mut Vec, n: usize) { + match v.first().copied() { + Some(x) if v.iter().all(|y| *y == x) => *v = vec![x; n], + Some(_) => v.resize(n, T::default()), + None => {} + } + } + spread(radii, *sides as usize); + spread(kinds, *sides as usize); + } /// Apply `a` to the shape. True when the shape is no longer `a` applied to the old path, so /// the caller must regenerate the path with [`LiveShape::to_path`]. /// @@ -140,19 +182,27 @@ impl LiveShape { /// only the rotation, reflection and position. The radii scale by the mean scale (the square /// root of the determinant), which [`LiveShape::keep_corners`] undoes for Scale Corners off. /// A shear can't keep circular corners: `xf` takes it, as do moves (so files saved with a - /// scale in `xf` keep their exact geometry until they're next transformed). + /// scale in `xf` keep their exact geometry until they're next transformed). A polygon's or a + /// path's corner radii are document lengths: they scale by the mean scale and the corners are + /// cut again, circular whatever `a` does. pub fn transform(&mut self, a: Affine) -> bool { match self { LiveShape::Rectangle { xf, .. } => { *xf = a * *xf; - let [a0, a1, a2, a3, _, _] = a.as_coeffs(); - let moves_only = (a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12; - !moves_only && self.fold_scale() + !moves_only(a) && self.fold_scale() } - LiveShape::Ellipse { xf, .. } | LiveShape::Polygon { xf, .. } => { + LiveShape::Ellipse { xf, .. } => { *xf = a * *xf; false } + LiveShape::Polygon { xf, radii, .. } => { + *xf = a * *xf; + scale_radii(radii, a) + } + LiveShape::Path { base, radii, .. } => { + base.transform(a); + scale_radii(radii, a) + } LiveShape::Line { a: p, b } => { *p = a * *p; *b = a * *b; @@ -192,52 +242,16 @@ impl LiveShape { /// Divide live corner radii by `k`, the mean scale of a transform just applied, so the corners /// keep their size (Scale Corners off). False when nothing changed. pub fn keep_corners(&mut self, k: f64) -> bool { - match self { - LiveShape::Rectangle { radii, .. } if radii.iter().any(|r| *r > 0.0) && k > 1e-12 => { - radii.iter_mut().for_each(|r| *r /= k); - true - } - _ => false, + let radii: &mut [f64] = match self { + LiveShape::Rectangle { radii, .. } => radii, + LiveShape::Polygon { radii, .. } | LiveShape::Path { radii, .. } => radii, + LiveShape::Ellipse { .. } | LiveShape::Line { .. } => return false, + }; + if !radii.iter().any(|r| *r > 0.0) || k <= 1e-12 { + return false; } - } - /// The corner (radii order) of each anchor of a rectangle's path; empty for other shapes. - pub fn anchor_corners(&self) -> Vec { - match self { - LiveShape::Rectangle { w, h, radii, .. } => shapes::rectangle_anchor_corners(Rect::new(0.0, 0.0, *w, *h), *radii), - _ => vec![], - } - } - /// The corners of a rectangle that hold one of `anchors` (of its only subpath). - pub fn corners_of(&self, anchors: &BTreeSet) -> [bool; 4] { - let map = self.anchor_corners(); - let mut out = [false; 4]; - for k in anchors.iter().filter(|(si, _)| *si == 0).filter_map(|(_, ai)| map.get(*ai)) { - if let Some(c) = out.get_mut(*k) { - *c = true; - } - } - out - } - /// The corners Live Corners edit for a selection: those holding a selected anchor when the - /// shape is partly selected (Direct Selection), else all four. - pub fn picked_corners(&self, partial: Option<&BTreeSet>) -> [bool; 4] { - let picked = partial.map_or([true; 4], |a| self.corners_of(a)); - if picked.contains(&true) { picked } else { [true; 4] } - } - /// The anchors of a rectangle's `corners` (to keep them selected as its path changes). - pub fn corner_anchors(&self, corners: [bool; 4]) -> BTreeSet { - self.anchor_corners().into_iter().enumerate().filter(|(_, k)| corners.get(*k) == Some(&true)).map(|(ai, _)| (0, ai)).collect() - } - /// The radius (in document units, see [`LiveShape::folded`]) and kind the `corners` of a - /// rectangle share (each `None` when they differ). - pub fn corner_style(&self, corners: [bool; 4]) -> (Option, Option) { - let LiveShape::Rectangle { radii, kinds, .. } = self.folded() else { return (None, None) }; - fn shared(v: [T; 4], corners: [bool; 4], same: impl Fn(T, T) -> bool) -> Option { - let mut it = v.into_iter().zip(corners).filter(|(_, on)| *on).map(|(x, _)| x); - let first = it.next()?; - it.all(|x| same(x, first)).then_some(first) - } - (shared(radii, corners, |a, b| (a - b).abs() < 1e-9), shared(kinds, corners, |a, b| a == b)) + radii.iter_mut().for_each(|r| *r /= k); + true } /// Rotation angle of the live shape in degrees (shown in the Properties panel). pub fn angle_deg(&self) -> f64 { @@ -247,14 +261,33 @@ impl LiveShape { c[1].atan2(c[0]).to_degrees() } LiveShape::Line { a, b } => (b.y - a.y).atan2(b.x - a.x).to_degrees(), + LiveShape::Path { .. } => 0.0, } } } -fn all_round(kinds: &[CornerKind; 4]) -> bool { +fn all_round(kinds: &[CornerKind]) -> bool { kinds.iter().all(|k| *k == CornerKind::Round) } +/// Whether `a` only moves (no rotation, scale, shear or reflection). +fn moves_only(a: Affine) -> bool { + let [a0, a1, a2, a3, _, _] = a.as_coeffs(); + (a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12 +} + +/// Scale corner radii in document units by the mean scale of `a`, applied to their path. True +/// when the path must be cut again: some corner is cut and `a` does more than move it (an +/// uneven scale would otherwise make the cuts elliptical). +fn scale_radii(radii: &mut [f64], a: Affine) -> bool { + if moves_only(a) || !radii.iter().any(|r| *r > 0.0) { + return false; + } + let k = a.determinant().abs().sqrt(); + radii.iter_mut().for_each(|r| *r *= k); + true +} + /// What a transform scales besides geometry, by its mean scale (the square root of its /// determinant). `Scaling::default()` (and `false`) scales nothing else; `true` scales stroke /// weights and dashes only. Transforms the user asks for take theirs from Scale Strokes & Effects @@ -1214,7 +1247,7 @@ impl Node { /// Shapes drawn with the shape tools (live rectangles, ellipses and polygons) show their centre. pub fn shows_center_by_default(&self) -> bool { - matches!(&self.kind, NodeKind::Path { live: Some(l), .. } if !matches!(l, LiveShape::Line { .. })) + matches!(&self.kind, NodeKind::Path { live: Some(l), .. } if !matches!(l, LiveShape::Line { .. } | LiveShape::Path { .. })) } /// Change this object's attributes with `f`; all-default attributes are dropped. @@ -1276,23 +1309,9 @@ mod tests { } #[test] - fn rectangle_corners_map_to_their_anchors() { + fn corner_kinds_save_only_when_some_corner_isnt_round() { let mut l = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0, 10.0, 0.0, 0.0], kinds: Default::default(), xf: Affine::IDENTITY }; - // Anchors: top-left, the top-right corner's two, bottom-right, bottom-left. - assert_eq!(l.anchor_corners(), [0, 1, 1, 2, 3]); - assert_eq!(l.to_path().anchor_count(), 5); - let set = |v: &[usize]| v.iter().map(|ai| (0, *ai)).collect::>(); - assert_eq!(l.corners_of(&set(&[2, 4])), [false, true, false, true]); - assert_eq!(l.corners_of(&set(&[9])), [false; 4], "out of range"); - assert_eq!(l.corner_anchors([false, true, false, true]), set(&[1, 2, 4])); - // Partly selected: the corners of the selected anchors; wholly (or no anchor): all four. - assert_eq!(l.picked_corners(Some(&set(&[0]))), [true, false, false, false]); - assert_eq!(l.picked_corners(None), [true; 4]); - assert_eq!(l.picked_corners(Some(&set(&[]))), [true; 4]); - assert_eq!(l.corner_style([false, true, false, false]), (Some(10.0), Some(CornerKind::Round))); - assert_eq!(l.corner_style([true, true, false, false]), (None, Some(CornerKind::Round))); - assert_eq!(l.corner_style([true, false, true, true]), (Some(0.0), Some(CornerKind::Round))); - // Corner kinds save only when some corner isn't round, and older files read as round. + // Older files read as round. let json = serde_json::to_value(&l).unwrap(); assert!(json.get("kinds").is_none(), "{json}"); assert_eq!(serde_json::from_value::(json).unwrap(), l); @@ -1302,7 +1321,16 @@ mod tests { let json = serde_json::to_value(&l).unwrap(); assert_eq!(json["kinds"], serde_json::json!(["round", "chamfer", "round", "round"])); assert_eq!(serde_json::from_value::(json).unwrap(), l); - assert!(LiveShape::Ellipse { w: 1.0, h: 1.0, pie: (0.0, 360.0), xf: Affine::IDENTITY }.anchor_corners().is_empty()); + // Polygons saved before Live Corners cut theirs read as sharp; a live path round-trips. + let p: LiveShape = + serde_json::from_value(serde_json::json!({"shape": "polygon", "radius": 10.0, "sides": 5, "xf": [1, 0, 0, 1, 0, 0]})).unwrap(); + assert_eq!(p, LiveShape::Polygon { radius: 10.0, sides: 5, xf: Affine::IDENTITY, radii: vec![], kinds: vec![] }); + let star = shapes::star(Point::new(0.0, 0.0), 20.0, 10.0, 5, 0.0); + let path = LiveShape::Path { base: star, radii: vec![2.0; 10], kinds: vec![] }; + let json = serde_json::to_value(&path).unwrap(); + assert_eq!((json["shape"].as_str(), json.get("kinds")), (Some("path"), None)); + assert_eq!(serde_json::from_value::(json).unwrap(), path); + assert_eq!(path.label(), "Path"); } /// A node holding a live rectangle (`w` × `h`, all radii `r`, placed by `xf`) and its path. @@ -1427,7 +1455,8 @@ mod tests { assert!(near_xf(*xf, Affine::translate((5.0, 5.0)))); let (a, b) = (folded.to_path().bounds().unwrap(), live.to_path().bounds().unwrap()); assert!(near(a.x0, b.x0) && near(a.y0, b.y0) && near(a.x1, b.x1) && near(a.y1, b.y1), "same place and size: {a:?} {b:?}"); - assert_eq!(live.corner_style([true; 4]).0, Some(40.0), "the radius in document units"); + let corners = crate::LiveCorners::of(&n).unwrap(); + assert_eq!(corners.style(&corners.all()).0, Some(40.0), "the radius in document units"); // Nothing to fold: a moved, rotated or reflected rectangle and a sheared one stay as they are. let place = Affine::translate((5.0, 5.0)) * Affine::rotate(0.5) * Affine::scale_non_uniform(-1.0, 1.0); let shear = Affine::new([1.0, 0.0, 0.5, 1.0, 0.0, 0.0]); diff --git a/crates/engine/src/cmd/create.rs b/crates/engine/src/cmd/create.rs index 0c2b4042..21e0978e 100644 --- a/crates/engine/src/cmd/create.rs +++ b/crates/engine/src/cmd/create.rs @@ -188,7 +188,8 @@ fn polygon(s: &mut Session, p: &Value) -> Result { let r = f64_req(p, "radius", "shape.polygon")?.abs(); let sides = p.get("sides").and_then(Value::as_u64).unwrap_or(6).clamp(3, 1000) as u32; let rot = f64_or(p, "rotation", 0.0); - let live = LiveShape::Polygon { radius: r, sides, xf: Affine::translate(c.to_vec2()) * Affine::rotate(rot.to_radians()) }; + let xf = Affine::translate(c.to_vec2()) * Affine::rotate(rot.to_radians()); + let live = LiveShape::Polygon { radius: r, sides, xf, radii: vec![], kinds: vec![] }; add_art(s, "Polygon", path_kind(live.to_path(), Some(live)), None) } diff --git a/crates/engine/src/cmd/object.rs b/crates/engine/src/cmd/object.rs index b5c85344..91784cc4 100644 --- a/crates/engine/src/cmd/object.rs +++ b/crates/engine/src/cmd/object.rs @@ -1,11 +1,13 @@ //! Object menu: transforms, arrange, group, lock/hide, compound paths, clipping masks, isolation, //! align & distribute, object properties. +use std::collections::BTreeSet; use std::sync::Arc; use serde_json::{Value, json}; use vectorcraft_color::{BlendMode, Paint}; -use vectorcraft_doc::{Appearance, Document, Knockout, Node, NodeId, NodeKind, OrientedBox, Scaling}; +use vectorcraft_doc::corners::set_corners; +use vectorcraft_doc::{Appearance, Document, Knockout, LiveCorners, LiveShape, Node, NodeId, NodeKind, OrientedBox, Scaling}; use vectorcraft_geom::shapes::CornerKind; use vectorcraft_geom::{Affine, FillRule, Point, Rect, Vec2}; @@ -194,7 +196,7 @@ pub fn specs() -> Vec { "Live Shape Properties", [], None, - "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [0..3…], sides?: n} (Live Corners: radius and kind set a rectangle's corners: `corners` (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), else the corners with a Direct-Selected anchor, else all four; sides: a polygon's)", + "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [i…], sides?: n} (Live Corners on any path: radius and kind set its corners (anchors without handles between two straight sides): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared)", has_selection, set_live_shape ), @@ -1006,21 +1008,12 @@ fn expand_shape(s: &mut Session, _: &Value) -> Result { ok() } -/// The `corners` of `object.setLiveShape`: a mask of corner indices 0–3. -fn corners_param(p: &Value) -> Result> { +/// The `corners` of `object.setLiveShape`: anchor indices of a path's uncut outline. +fn corners_param(p: &Value) -> Result>> { let Some(v) = p.get("corners").filter(|v| !v.is_null()) else { return Ok(None) }; - let err = || { - bad( - "object.setLiveShape", - format!("`corners` must list corner indices 0–3 (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), not {v}"), - ) - }; - let mut mask = [false; 4]; - for k in v.as_array().ok_or_else(err)? { - let slot = k.as_u64().and_then(|k| mask.get_mut(usize::try_from(k).ok()?)).ok_or_else(err)?; - *slot = true; - } - Ok(Some(mask)) + let err = || bad("object.setLiveShape", format!("`corners` must list anchor indices (0, 1, 2…), not {v}")); + let list = v.as_array().ok_or_else(err)?; + list.iter().map(|k| k.as_u64().and_then(|k| usize::try_from(k).ok()).ok_or_else(err)).collect::>().map(Some) } fn set_live_shape(s: &mut Session, p: &Value) -> Result { @@ -1035,39 +1028,37 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result { }) .transpose()?; let radius = p.get("radius").and_then(Value::as_f64); + let sides = p.get("sides").and_then(Value::as_u64); s.edit("Live Shape", |d, sel| { for id in &ids { - let Some(NodeKind::Path { path, live: Some(live), .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue }; - // Radii are document lengths and corners circular, also on a rectangle from a file - // that kept an uneven scale in its transform (#442). - live.fold_scale(); - let partial = sel.anchors.get_mut(id); - let picked = corners.unwrap_or_else(|| live.picked_corners(partial.as_deref())); - let (layout, selected) = (live.anchor_corners(), partial.as_deref().map(|a| live.corners_of(a))); - match live { - vectorcraft_doc::LiveShape::Rectangle { radii, kinds, .. } => { - for ((_, r), k) in picked.iter().zip(radii.iter_mut()).zip(kinds.iter_mut()).filter(|((on, _), _)| **on) { - if let Some(radius) = radius { - *r = radius.max(0.0); - } - if let Some(kind) = kind { - *k = kind; - } - } - } - vectorcraft_doc::LiveShape::Polygon { sides, .. } => { - if let Some(n) = p.get("sides").and_then(Value::as_u64) { - *sides = n.clamp(3, 1000) as u32; - } - } - _ => {} + let Some(NodeKind::Path { path, live, .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue }; + if let (Some(l @ LiveShape::Polygon { .. }), Some(n)) = (live.as_mut(), sides) { + l.set_sides(n); + *path = l.to_path(); } - *path = live.to_path(); + if radius.is_none() && kind.is_none() { + continue; + } + let partial = sel.anchors.get_mut(id); + // The corners to edit, the Direct-Selected ones and the anchor layout before the edit. + let Some(c) = LiveCorners::new(path, live.as_ref()) else { continue }; + let picked = match &corners { + Some(k) if k.last().is_some_and(|k| *k >= c.base.anchor_count()) => { + let n = c.base.anchor_count(); + let past: Vec<_> = k.range(n..).collect(); + return Err(bad("object.setLiveShape", format!("object {id} has anchors 0–{} for `corners`, not {past:?}", n.saturating_sub(1)))); + } + Some(k) => k.clone(), + None => c.picked(partial.as_deref()), + }; + let (selected, layout) = (partial.as_deref().map(|a| c.corners_of(a)), c.sources().to_vec()); + set_corners(path, live, &picked, radius, kind); // Direct-Selected corners stay selected as they gain or lose anchors. if let (Some(anchors), Some(selected)) = (partial, selected) - && live.anchor_corners() != layout + && let Some(c) = LiveCorners::new(path, live.as_ref()) + && c.sources() != layout { - *anchors = live.corner_anchors(selected); + *anchors = c.anchors_of(&selected); } } Ok(()) diff --git a/crates/engine/src/tests_livecorners.rs b/crates/engine/src/tests_livecorners.rs index f0a0ff4a..8988e3c9 100644 --- a/crates/engine/src/tests_livecorners.rs +++ b/crates/engine/src/tests_livecorners.rs @@ -1,10 +1,11 @@ -//! Live Corners on live rectangles: `object.setLiveShape` rounds the given corners, the -//! Direct-Selected ones or all four, sets corner kinds, and keeps selected corners selected. +//! Live Corners: `object.setLiveShape` rounds the given corners of a live rectangle, the +//! Direct-Selected ones or all four, sets corner kinds, and keeps selected corners selected; and +//! does the same on any path's corners: a star, a live polygon, a pen path (#511). use std::collections::BTreeSet; use serde_json::{Value, json}; -use vectorcraft_doc::{AnchorRef, LiveShape, NodeKind}; +use vectorcraft_doc::{AnchorRef, LiveCorners, LiveShape, NodeKind}; use vectorcraft_geom::Affine; use vectorcraft_geom::shapes::CornerKind; @@ -150,3 +151,131 @@ fn corners_of_a_non_square_rectangle_are_alike_circles() { run(&mut s, json!({"radius": 8})); assert_spans(&s, id, [8.0; 4]); } + +/// A selected five-pointed star at (200, 200) of radii 60 and 30: a plain path. +fn star(s: &mut Session) -> NodeId { + NodeId(s.execute("shape.star", &json!({"cx": 200, "cy": 200, "radius1": 60, "radius2": 30})).unwrap()["id"].as_u64().unwrap()) +} + +fn node_path(s: &Session, id: NodeId) -> (vectorcraft_geom::PathData, Option) { + let NodeKind::Path { path, live, .. } = &s.doc().unwrap().doc.node(id).unwrap().kind else { panic!("not a path") }; + (path.clone(), live.clone()) +} + +/// The radius and kind every corner of `id` shares, and how many corners it has. +fn style(s: &Session, id: NodeId) -> (Option, Option, usize) { + let c = LiveCorners::of(s.doc().unwrap().doc.node(id).unwrap()).unwrap(); + let (r, k) = c.style(&c.all()); + (r, k, c.corners.len()) +} + +/// The radius set on each of the first `N` corners of `id`. +fn radii(s: &Session, id: NodeId) -> [f64; N] { + let c = LiveCorners::of(s.doc().unwrap().doc.node(id).unwrap()).unwrap(); + std::array::from_fn(|k| c.radius(k)) +} + +/// #511: a star (a plain path) rounds all ten corners as one step, keeps them editable (a new +/// radius cuts the outline again rather than the cut path), and is the plain star again at 0. +#[test] +fn a_star_rounds_its_corners_and_keeps_them_live() { + let (mut s, _) = session(); + let id = star(&mut s); + let (sharp, _) = node_path(&s, id); + assert_eq!(style(&s, id), (Some(0.0), Some(CornerKind::Round), 10)); + let undo = s.doc().unwrap().history.undo.len(); + run(&mut s, json!({"radius": 4})); + assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1); + let (path, live) = node_path(&s, id); + assert_eq!(path.anchor_count(), 20); + assert!(matches!(&live, Some(LiveShape::Path { base, .. }) if *base == sharp), "{live:?}"); + assert_eq!(style(&s, id), (Some(4.0), Some(CornerKind::Round), 10)); + assert_eq!(s.doc().unwrap().doc.node(id).unwrap().kind_label(), "Path"); + run(&mut s, json!({"radius": 6, "kind": "chamfer"})); + assert_eq!((node_path(&s, id).0.anchor_count(), style(&s, id)), (20, (Some(6.0), Some(CornerKind::Chamfer), 10))); + run(&mut s, json!({"radius": 0, "kind": "round"})); + assert_eq!(node_path(&s, id), (sharp, None)); + s.execute("edit.undo", &json!({})).unwrap(); + assert_eq!(style(&s, id).0, Some(6.0)); +} + +/// Each corner stops at its own limit: its cut reaches halfway along its shorter side, so a +/// star's neighbouring corners meet without overlapping. +#[test] +fn star_corners_stop_at_their_own_limit() { + let (mut s, _) = session(); + let id = star(&mut s); + run(&mut s, json!({"radius": 1000})); + let (path, live) = node_path(&s, id); + let Some(LiveShape::Path { base, .. }) = live else { panic!("live corners") }; + // Every cut ends at the middle of a side: each side's two cuts meet there. + let sp = &base.subpaths[0]; + for (i, a) in sp.anchors.iter().enumerate() { + let mid = a.p.midpoint(sp.anchors[(i + 1) % 10].p); + assert!(path.anchors().any(|(_, _, b)| b.p.distance(mid) < 1e-9), "a cut ends at {mid:?}"); + } + assert_eq!(style(&s, id).0, Some(1000.0), "the radius set is kept; it draws as large as fits"); +} + +/// #511: Direct Selection picks one of the star's anchors: that corner alone rounds, and both of +/// its new anchors stay selected. +#[test] +fn a_direct_selected_star_anchor_rounds_its_corner_alone() { + let (mut s, _) = session(); + let id = star(&mut s); + s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0]], "mode": "set"})).unwrap(); + run(&mut s, json!({"radius": 5})); + assert_eq!(node_path(&s, id).0.anchor_count(), 11); + // The top tip's cut ends the path and starts it. + assert_eq!(selected_anchors(&s, id), Some(anchors(&[0, 10]))); + assert_eq!(radii::<2>(&s, id), [5.0, 0.0]); + // Explicit corners, as MCP and the widgets give them. + run(&mut s, json!({"id": id.0, "corners": [1, 3], "radius": 2})); + assert_eq!(radii::<4>(&s, id), [5.0, 2.0, 0.0, 2.0]); + // Past the outline's last anchor is an error, and nothing changes. + assert!(s.execute("object.setLiveShape", &json!({"id": id.0, "corners": [10], "radius": 1})).is_err()); + assert_eq!(node_path(&s, id).0.anchor_count(), 13); +} + +/// A live polygon stays live with cut corners, which keep their radius as its sides change and +/// stay circular when it is scaled unevenly (the radius scales by the mean scale). +#[test] +fn a_polygon_keeps_its_corners_through_sides_and_scales() { + let (mut s, _) = session(); + let id = NodeId(s.execute("shape.polygon", &json!({"cx": 200, "cy": 200, "radius": 80, "sides": 6})).unwrap()["id"].as_u64().unwrap()); + run(&mut s, json!({"radius": 10})); + let (path, live) = node_path(&s, id); + assert_eq!(path.anchor_count(), 12); + assert!(matches!(live, Some(LiveShape::Polygon { sides: 6, .. }))); + run(&mut s, json!({"sides": 8})); + assert_eq!((node_path(&s, id).0.anchor_count(), style(&s, id)), (16, (Some(10.0), Some(CornerKind::Round), 8))); + s.execute("object.scale", &json!({"sx": 400, "sy": 100, "corners": true})).unwrap(); + assert!(matches!(node_path(&s, id).1, Some(LiveShape::Polygon { .. }))); + assert!((style(&s, id).0.unwrap() - 20.0).abs() < 1e-9); + // Every cut is a circle of that radius: its ends are as far from its centre. + let path = node_path(&s, id).0; + let c = LiveCorners::of(s.doc().unwrap().doc.node(id).unwrap()).unwrap(); + for k in &c.corners { + let centre = k.on_bisector(20.0 / k.sin()); + let ends = path.anchors().filter(|(_, _, a)| (a.p.distance(centre) - 20.0).abs() < 1e-6).count(); + assert_eq!(ends, 2, "corner {} is circular", k.index); + } +} + +/// #511: a pen path's corners round; its ends don't. An ellipse has no corners to round. +#[test] +fn a_pen_path_rounds_its_corners_but_not_its_ends() { + let (mut s, _) = session(); + let pen = json!({"anchors": [{"x": 10, "y": 200}, {"x": 110, "y": 100}, {"x": 210, "y": 200}, {"x": 310, "y": 100}]}); + let id = NodeId(s.execute("path.create", &pen).unwrap()["id"].as_u64().unwrap()); + s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); + run(&mut s, json!({"radius": 8})); + let path = node_path(&s, id).0; + assert_eq!(path.anchor_count(), 6); + let sp = &path.subpaths[0]; + assert_eq!((sp.anchors[0].p.x, sp.anchors[5].p.x), (10.0, 310.0), "the ends stay"); + let e = NodeId(s.execute("shape.ellipse", &json!({"x": 0, "y": 0, "width": 50, "height": 30})).unwrap()["id"].as_u64().unwrap()); + let before = node_path(&s, e); + run(&mut s, json!({"id": e.0, "radius": 8})); + assert_eq!(node_path(&s, e), before); +} diff --git a/crates/geom/src/corners.rs b/crates/geom/src/corners.rs new file mode 100644 index 00000000..f4e10dcc --- /dev/null +++ b/crates/geom/src/corners.rs @@ -0,0 +1,283 @@ +//! Live Corners on any path: the anchors where two straight sides meet at an angle, and the path +//! with those corners cut round, inverted round or chamfered. Rectangles cut theirs the same way. + +use kurbo::{Point, Vec2}; + +use crate::path::{Anchor, AnchorKind, PathData, SubPath}; +use crate::shapes::{CornerKind, KAPPA}; + +/// Lengths and radii at or below this are none at all. +const EPS: f64 = 1e-9; +/// Sides closer than this to straight on (or folded back), as the sine of their angle, make no corner. +const MIN_SINE: f64 = 1e-6; + +/// A corner Live Corners can cut: an anchor without handles between two straight sides that +/// meet at an angle. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Corner { + /// The anchor's index in its path, counting the anchors of every subpath in order. + pub index: usize, + /// Where the sides meet. + pub at: Point, + /// Unit directions along the sides: towards the previous anchor, then towards the next one. + pub u: Vec2, + pub v: Vec2, + /// The sides' lengths, in the same order. + pub lu: f64, + pub lv: f64, +} + +impl Corner { + /// The corner of anchor `i` of `sp`, whose index in the path is `index`; `None` when the + /// anchor is an end of an open subpath, has handles or is smooth, when a side curves or has + /// no length, or when the sides run straight on. + fn of(sp: &SubPath, i: usize, index: usize) -> Option { + let n = sp.anchors.len(); + let (prev, next) = if sp.closed { ((i + n).checked_sub(1)? % n, (i + 1) % n) } else { (i.checked_sub(1)?, i + 1) }; + let (a, prev, next) = (sp.anchors.get(i)?, sp.anchors.get(prev)?, sp.anchors.get(next)?); + if a.kind == AnchorKind::Smooth || a.has_in() || a.has_out() || prev.has_out() || next.has_in() { + return None; + } + let (du, dv) = (prev.p - a.p, next.p - a.p); + let (lu, lv) = (du.hypot(), dv.hypot()); + if !(lu > EPS && lv > EPS && lu.is_finite() && lv.is_finite()) { + return None; + } + let c = Self { index, at: a.p, u: du / lu, v: dv / lv, lu, lv }; + (c.sin() > MIN_SINE).then_some(c) + } + + /// The cosine of the angle between the sides. + pub fn cos(&self) -> f64 { + self.u.dot(self.v) + } + + /// The sine of the angle between the sides. + pub fn sin(&self) -> f64 { + self.u.cross(self.v).abs() + } + + /// The angle between the sides, in degrees (90 at a rectangle's corners). + pub fn angle_deg(&self) -> f64 { + self.sin().atan2(self.cos()).to_degrees() + } + + /// How far from the corner a round cut of radius `r` meets each side: r / tan(angle / 2). + pub fn setback(&self, r: f64) -> f64 { + r * (1.0 + self.cos()) / self.sin() + } + + /// The largest radius the corner draws: its cut then reaches halfway along the shorter side, + /// so neighbouring corners at their largest meet without overlapping (half the shorter side + /// at a rectangle's corners). + pub fn max_radius(&self) -> f64 { + self.lu.min(self.lv) / 2.0 * self.sin() / (1.0 + self.cos()) + } + + /// The radius the corner is drawn with: `radius`, no larger than [`Corner::max_radius`], 0 when + /// negative or not a number. + pub fn fitted(&self, radius: f64) -> f64 { + radius.max(0.0).min(self.max_radius()) + } + + /// The point `k` along the bisector, measured in (u + v): the centre of a round cut of radius + /// `r` is at `k = r / sin`. + pub fn on_bisector(&self, k: f64) -> Point { + self.at + (self.u + self.v) * k + } + + /// How much the radius grows when the centre of the round cut moves by `d`: `d`'s part along + /// the bisector, in radius units. + pub fn radius_change(&self, d: Vec2) -> f64 { + d.dot(self.u + self.v) * self.sin() / (2.0 + 2.0 * self.cos()) + } + + /// The two anchors replacing the corner when cut with `radius` (> 0, fitted): where the cut + /// meets the arriving side, then the leaving one. + fn cut(&self, radius: f64, kind: CornerKind) -> [Anchor; 2] { + let t = self.setback(radius); + let (start, end) = (self.at + self.u * t, self.at + self.v * t); + let (h_out, h_in) = match kind { + // An arc of `radius` tangent to both sides, turning by 180° less the angle. + CornerKind::Round => { + let h = radius * arc_handle(-self.cos()); + (start - self.u * h, end - self.v * h) + } + // An arc centred on the corner through both ends, spanning the angle. + CornerKind::InvertedRound => { + let h = t * arc_handle(self.cos()); + (start + square_to(self.u, self.v) * h, end + square_to(self.v, self.u) * h) + } + CornerKind::Chamfer => (start, end), + }; + [Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner }, Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner }] + } +} + +/// The unit direction square to unit `a`, on `b`'s side. +fn square_to(a: Vec2, b: Vec2) -> Vec2 { + let w = b - a * a.dot(b); + w / w.hypot() +} + +/// The handle length, per unit of radius, of a cubic drawing a circular arc that spans an angle +/// whose cosine is `cos`: 4/3 · tan(angle / 4) ([`KAPPA`] for a quarter circle). +fn arc_handle(cos: f64) -> f64 { + if cos.abs() < 1e-12 { + return KAPPA; + } + let (sin_half, cos_half) = (((1.0 - cos) / 2.0).max(0.0).sqrt(), ((1.0 + cos) / 2.0).max(0.0).sqrt()); + 4.0 / 3.0 * sin_half / (1.0 + cos_half) +} + +/// The corners of `path` Live Corners can cut, in anchor order. +pub fn path_corners(path: &PathData) -> Vec { + let mut out = vec![]; + let mut first = 0; + for sp in &path.subpaths { + out.extend((0..sp.anchors.len()).filter_map(|i| Corner::of(sp, i, first + i))); + first += sp.anchors.len(); + } + out +} + +/// `path` with each of its corners ([`path_corners`]) cut by the radius in `radii` and the kind in +/// `kinds` at its anchor index (missing: 0 and round), each radius no larger than fits +/// ([`Corner::fitted`]). A cut corner becomes two anchors; a closed subpath whose first corner +/// is cut starts where that cut ends, so the cut closes it. Also returns, per subpath, the +/// anchor index in `path` each anchor comes from. +pub fn cut_corners(path: &PathData, radii: &[f64], kinds: &[CornerKind]) -> (PathData, Vec>) { + let corners = path_corners(path); + let mut corners = corners.iter().peekable(); + let (mut subpaths, mut sources) = (Vec::with_capacity(path.subpaths.len()), Vec::with_capacity(path.subpaths.len())); + let mut first = 0; + for sp in &path.subpaths { + let (mut anchors, mut from) = (Vec::with_capacity(sp.anchors.len()), Vec::with_capacity(sp.anchors.len())); + let mut closing = None; + for (i, a) in sp.anchors.iter().enumerate() { + let index = first + i; + let corner = corners.next_if(|c| c.index == index); + let radius = corner.map_or(0.0, |c| c.fitted(radii.get(index).copied().unwrap_or(0.0))); + match corner { + Some(c) if radius > EPS => { + let [start, end] = c.cut(radius, kinds.get(index).copied().unwrap_or_default()); + if i == 0 && sp.closed { + closing = Some(start); + } else { + anchors.push(start); + from.push(index); + } + anchors.push(end); + from.push(index); + } + _ => { + anchors.push(*a); + from.push(index); + } + } + } + if let Some(a) = closing { + anchors.push(a); + from.push(first); + } + first += sp.anchors.len(); + subpaths.push(SubPath::new(anchors, sp.closed)); + sources.push(from); + } + (PathData::new(subpaths), sources) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::shapes; + use kurbo::Rect; + + fn near(a: Point, b: Point) -> bool { + a.distance(b) < 1e-9 + } + + /// A five-pointed star's tips are acute corners, its inner corners obtuse: all ten cut, each + /// a circle of the radius tangent to both sides. + #[test] + fn a_star_has_ten_corners_cut_as_circles() { + let star = shapes::star(Point::new(100.0, 100.0), 50.0, 25.0, 5, 0.0); + let corners = path_corners(&star); + assert_eq!(corners.len(), 10); + let angles: Vec<_> = corners.iter().map(|c| c.angle_deg()).collect(); + assert!(angles.iter().step_by(2).all(|a| *a < 90.0), "tips are acute: {angles:?}"); + assert!(angles.iter().skip(1).step_by(2).all(|a| *a > 90.0), "inner corners are obtuse: {angles:?}"); + let (cut, from) = cut_corners(&star, &[4.0; 10], &[]); + assert_eq!(cut.anchor_count(), 20); + assert_eq!(from, [vec![0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 0]]); + for c in &corners { + // Both ends of the cut lie `setback` along the sides, as far from the arc's centre as + // the radius, and that centre is `radius` from either side. + let t = c.setback(4.0); + let o = c.on_bisector(4.0 / c.sin()); + for p in [c.at + c.u * t, c.at + c.v * t] { + assert!((p.distance(o) - 4.0).abs() < 1e-9); + assert!(cut.anchors().any(|(_, _, a)| near(a.p, p)), "{p:?} is an anchor"); + } + } + } + + #[test] + fn radii_stop_at_half_the_shorter_side_per_corner() { + let tri = PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(0.0, 40.0)], true)); + let corners = path_corners(&tri); + assert_eq!(corners.len(), 3); + for c in &corners { + let max = c.max_radius(); + assert!((c.setback(max) - c.lu.min(c.lv) / 2.0).abs() < 1e-9); + assert_eq!(c.fitted(1e6), max); + assert_eq!(c.fitted(-3.0), 0.0); + assert_eq!(c.fitted(f64::NAN), 0.0); + } + // The right angle at (0, 0) takes up to 20, half its shorter side. + assert!((corners[0].max_radius() - 20.0).abs() < 1e-9); + } + + #[test] + fn ends_curves_smooth_and_straight_anchors_are_no_corners() { + // An open zig-zag: its ends aren't corners, nor is the anchor its sides run straight on through. + let open = PathData::single(SubPath::polyline( + &[Point::new(0.0, 0.0), Point::new(50.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 50.0), Point::new(150.0, 80.0)], + false, + )); + assert_eq!(path_corners(&open).iter().map(|c| c.index).collect::>(), [2, 3]); + // A curve on either side, or handles on the anchor, leave it alone. + let mut sp = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)], true); + sp.anchors[1].h_out = Point::new(110.0, 10.0); + let p = PathData::single(sp); + assert_eq!(path_corners(&p).iter().map(|c| c.index).collect::>(), [0, 3]); + assert!(path_corners(&shapes::ellipse(Rect::new(0.0, 0.0, 10.0, 10.0))).is_empty()); + // A second subpath counts on from the first one's anchors. + let two = PathData::new(vec![ + SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(0.0, 10.0)], true), + SubPath::polyline(&[Point::new(50.0, 0.0), Point::new(60.0, 0.0), Point::new(50.0, 10.0)], true), + ]); + let (cut, from) = cut_corners(&two, &[0.0, 0.0, 0.0, 1.0], &[]); + assert_eq!(from, [vec![0, 1, 2], vec![3, 4, 5, 3]]); + assert_eq!(cut.anchor_count(), 7); + } + + /// Inverted round and chamfer cuts end where the round one does, at any angle. + #[test] + fn kinds_share_their_ends() { + let star = shapes::star(Point::new(0.0, 0.0), 50.0, 25.0, 5, 0.0); + let ends = |k: CornerKind| -> Vec { cut_corners(&star, &[3.0; 10], &[k; 10]).0.anchors().map(|(_, _, a)| a.p).collect() }; + let round = ends(CornerKind::Round); + assert_eq!(ends(CornerKind::InvertedRound), round); + assert_eq!(ends(CornerKind::Chamfer), round); + // The inverted arc stays on the circle about the corner. + let c = path_corners(&star)[0]; + let [s, e] = c.cut(3.0, CornerKind::InvertedRound); + let bez = kurbo::CubicBez::new(s.p, s.h_out, e.h_in, e.p); + let r = c.setback(3.0); + for t in [0.25, 0.5, 0.75] { + use kurbo::ParamCurve; + assert!((bez.eval(t).distance(c.at) - r).abs() < r * 1e-3); + } + } +} diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs index 8e1ab9db..84162c2a 100644 --- a/crates/geom/src/lib.rs +++ b/crates/geom/src/lib.rs @@ -9,6 +9,7 @@ pub mod arc; pub mod bez; +pub mod corners; pub mod hit; pub mod path; pub mod projective; diff --git a/crates/geom/src/shapes.rs b/crates/geom/src/shapes.rs index 16e9fab1..756923cd 100644 --- a/crates/geom/src/shapes.rs +++ b/crates/geom/src/shapes.rs @@ -62,52 +62,10 @@ pub fn fitted_corner_radius(w: f64, h: f64, radius: f64) -> f64 { /// Rectangle whose corners (top-left, top-right, bottom-right, bottom-left, y down) each have /// their own radius and kind, every radius clamped to half the shorter side. A corner without a /// radius is one anchor, the others two (where the cut meets each side). Clockwise from the -/// top-left corner, its anchor on the top side first. +/// top-left corner, its anchor on the top side first. Cut as any path's corners are +/// ([`crate::corners::cut_corners`]). pub fn rectangle_with_corners(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> PathData { - PathData::single(SubPath::new(corner_anchors(r, radii, kinds).into_iter().map(|(_, a)| a).collect(), true)) -} - -/// The corner (index into `radii`) of each anchor of [`rectangle_with_corners`]. -pub fn rectangle_anchor_corners(r: Rect, radii: [f64; 4]) -> Vec { - corner_anchors(r, radii, [CornerKind::Round; 4]).into_iter().map(|(k, _)| k).collect() -} - -/// The anchors of [`rectangle_with_corners`], each with its corner. -fn corner_anchors(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> Vec<(usize, Anchor)> { - let r = r.abs(); - // Each corner, with the directions of the side arriving at it and of the side leaving it. - let corners = [ - (Point::new(r.x0, r.y0), Vec2::new(0.0, -1.0), Vec2::new(1.0, 0.0)), - (Point::new(r.x1, r.y0), Vec2::new(1.0, 0.0), Vec2::new(0.0, 1.0)), - (Point::new(r.x1, r.y1), Vec2::new(0.0, 1.0), Vec2::new(-1.0, 0.0)), - (Point::new(r.x0, r.y1), Vec2::new(-1.0, 0.0), Vec2::new(0.0, -1.0)), - ]; - let mut out = Vec::with_capacity(8); - let mut top_left_start = None; - for (k, ((c, din, dout), (rad, kind))) in corners.into_iter().zip(radii.into_iter().zip(kinds)).enumerate() { - let rad = fitted_corner_radius(r.width(), r.height(), rad); - if rad <= 1e-9 { - out.push((k, Anchor::corner(c))); - continue; - } - // The cut runs from `start` on the arriving side to `end` on the leaving one. - let (start, end, h) = (c - din * rad, c + dout * rad, rad * KAPPA); - let (h_out, h_in) = match kind { - CornerKind::Round => (start + din * h, end - dout * h), - CornerKind::InvertedRound => (start + dout * h, end - din * h), - CornerKind::Chamfer => (start, end), - }; - let start = Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner }; - let end = Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner }; - if k == 0 { - top_left_start = Some(start); - } else { - out.push((k, start)); - } - out.push((k, end)); - } - out.extend(top_left_start.map(|a| (0, a))); - out + crate::corners::cut_corners(&rectangle(r), &radii, &kinds).0 } /// Ellipse inscribed in `r` with 4 smooth anchors (left, top, right, bottom). @@ -244,6 +202,11 @@ pub fn polar_grid(r: Rect, concentric: u32, radial: u32) -> Vec { mod tests { use super::*; + /// The corner (index into `radii`) of each anchor of [`rectangle_with_corners`]. + fn corner_sources(r: Rect, radii: [f64; 4]) -> Vec { + crate::corners::cut_corners(&rectangle(r), &radii, &[]).1.concat() + } + #[test] fn rect_is_4_corners_clockwise() { let p = rectangle(Rect::new(0.0, 0.0, 100.0, 50.0)); @@ -293,7 +256,7 @@ mod tests { a((x0, y0 + rad), (x0, y0 + rad), (x0, y0 + rad - k)), ]; assert_eq!(rounded_rectangle(r, rad).subpaths[0].anchors, want); - assert_eq!(rectangle_anchor_corners(r, [rad; 4]), [0, 1, 1, 2, 2, 3, 3, 0]); + assert_eq!(corner_sources(r, [rad; 4]), [0, 1, 1, 2, 2, 3, 3, 0]); assert_eq!(rounded_rectangle(r, 0.0), rectangle(r)); } @@ -305,11 +268,11 @@ mod tests { let p = rectangle_with_corners(r, radii, [CornerKind::Round; 4]); let pts: Vec = p.subpaths[0].anchors.iter().map(|a| a.p).collect(); assert_eq!(pts, [Point::new(0.0, 0.0), Point::new(90.0, 0.0), Point::new(100.0, 10.0), Point::new(100.0, 60.0), Point::new(0.0, 60.0)]); - assert_eq!(rectangle_anchor_corners(r, radii), [0, 1, 1, 2, 3]); + assert_eq!(corner_sources(r, radii), [0, 1, 1, 2, 3]); let quarter = PI * 25.0; assert!((p.subpaths[0].area() - (6000.0 - 100.0 + quarter)).abs() < 0.1, "a quarter circle off one corner"); // The top-left corner rounded: its top-side anchor first, its left-side one last. - assert_eq!(rectangle_anchor_corners(r, [10.0, 0.0, 0.0, 200.0]), [0, 1, 2, 3, 3, 0]); + assert_eq!(corner_sources(r, [10.0, 0.0, 0.0, 200.0]), [0, 1, 2, 3, 3, 0]); // Inverted round cuts a quarter circle out; a chamfer cuts a triangle. let inverted = rectangle_with_corners(r, radii, [CornerKind::InvertedRound; 4]); assert!((inverted.subpaths[0].area() - (6000.0 - quarter)).abs() < 0.1); diff --git a/crates/svg/src/css.rs b/crates/svg/src/css.rs index 3fab8ddc..ee7c3247 100644 --- a/crates/svg/src/css.rs +++ b/crates/svg/src/css.rs @@ -621,7 +621,9 @@ fn corners(path: &PathData, live: Option<&LiveShape>) -> Option { let sweep = (pie.1 - pie.0).abs(); (sweep < 1e-6 || (sweep - 360.0).abs() < 1e-6).then_some(Corners::Ellipse) } - Some(LiveShape::Rectangle { .. } | LiveShape::Ellipse { .. } | LiveShape::Polygon { .. } | LiveShape::Line { .. }) => None, + Some( + LiveShape::Rectangle { .. } | LiveShape::Ellipse { .. } | LiveShape::Polygon { .. } | LiveShape::Line { .. } | LiveShape::Path { .. }, + ) => None, None => is_upright_rectangle(path).then_some(Corners::Square), } } diff --git a/crates/tools/src/corners.rs b/crates/tools/src/corners.rs index 1141782c..eb738baa 100644 --- a/crates/tools/src/corners.rs +++ b/crates/tools/src/corners.rs @@ -1,187 +1,231 @@ -//! Live Corners: the widgets inside the corners of a selected live rectangle. Dragging one rounds -//! (or sharpens) the corners whose widgets show together: all four when the whole shape is -//! selected, those with a selected anchor when Direct Selection picked some. Alt-clicking a widget -//! cycles their corner kind (round, inverted round, chamfer); double-clicking one opens the -//! Corners dialog. The Selection and Direct Selection tools share this, and the canvas draws the -//! widgets from the same geometry. +//! Live Corners: the widgets inside the corners of a selected path. The Selection tool shows them +//! on a live rectangle or polygon, Direct Selection on any path (a star, a pen path) at each corner +//! anchor: one without handles between two straight sides. Dragging one rounds (or sharpens) the +//! corners whose widgets show together: every corner when the whole path is selected, those with a +//! selected anchor when Direct Selection picked some. Alt-clicking a widget cycles their corner +//! kind (round, inverted round, chamfer); double-clicking one opens the Corners dialog. The +//! Selection and Direct Selection tools share this, and the canvas draws the widgets from the same +//! geometry. use serde_json::{Map, Value, json}; -use vectorcraft_doc::{Document, LiveShape, NodeId, NodeKind, Selection}; -use vectorcraft_geom::shapes::{self, CornerKind}; -use vectorcraft_geom::{Affine, BezPath, Point, Rect, Vec2}; +use vectorcraft_doc::{Document, LiveCorners, LiveShape, NodeId, NodeKind, Selection}; +use vectorcraft_geom::corners::{Corner, cut_corners}; +use vectorcraft_geom::shapes::CornerKind; +use vectorcraft_geom::{Affine, BezPath, PathData, Point, Vec2}; use crate::{Action, Overlay, PointerEvent, ToolContext}; /// The dialog a double-click on a corner widget opens: `{id, corners}`. pub const DIALOG: &str = "corners"; -/// Widgets sit at least this far inside their corner (screen px), further in once the radius is. +/// Widgets sit at least this far inside their corner along each side of a right angle (screen px; +/// √2 times it along the bisector, at any angle), further in once the radius is. const MIN_INSET_PX: f64 = 10.0; -/// Shapes whose shorter side is smaller than this on screen (px) hide their widgets. +/// Corners with a side shorter than this on screen (px) hide their widgets. const MIN_SIDE_PX: f64 = 3.0 * MIN_INSET_PX; -/// Corners in radii order (top-left, top-right, bottom-right, bottom-left): position as factors -/// of (w, h) and the inward diagonal. -const CORNERS: [((f64, f64), (f64, f64)); 4] = - [((0.0, 0.0), (1.0, 1.0)), ((1.0, 0.0), (-1.0, 1.0)), ((1.0, 1.0), (-1.0, -1.0)), ((0.0, 1.0), (1.0, -1.0))]; -/// The corner widgets of a selection that is exactly one editable live rectangle. +/// One corner's widget. #[derive(Clone, Copy, Debug, PartialEq)] +struct Widget { + /// The corner, in the corners' own space. + corner: Corner, + /// The radius it is set to (document units) and its kind. + radius: f64, + kind: CornerKind, + /// The angle between its sides in the document, in degrees. + angle: f64, + /// The widget's centre in the document. + at: Point, +} + +/// The corner widgets of a selection that is exactly one editable path with corners. +#[derive(Clone, Debug, PartialEq)] pub struct CornerWidgets { pub id: NodeId, - w: f64, - h: f64, - radii: [f64; 4], - kinds: [CornerKind; 4], + /// Maps the corners' space into the document (a live rectangle's own; else none). xf: Affine, - /// Widget centres in document coordinates, in radii order. - pub points: [Point; 4], - /// The corners whose widgets show (and which a drag edits). - pub shown: [bool; 4], + /// The widgets that show (and which a drag edits), in anchor order. + widgets: Vec, + /// Every corner of the path shows its widget. + all: bool, } impl CornerWidgets { - /// The widgets at `zoom` (screen px per document point), if the selection has them. - pub fn of(doc: &Document, selection: &Selection, zoom: f64) -> Option { + /// The widgets at `zoom` (screen px per document point), if the selection has them: on any + /// path with Direct Selection (`any_path`), on live rectangles and polygons with Selection. + pub fn of(doc: &Document, selection: &Selection, zoom: f64, any_path: bool) -> Option { let [id] = selection.objects[..] else { return None }; if !doc.is_editable(id) { return None; } - let Some(NodeKind::Path { live: Some(live), .. }) = doc.node(id).map(|n| &n.kind) else { return None }; - // In document units, as `object.setLiveShape` edits them. - let LiveShape::Rectangle { w, h, radii, kinds, xf } = live.folded() else { return None }; - // Screen pixels per shape unit along each side (the shape may be scaled or skewed). - let c = xf.as_coeffs(); - let (px, py) = (Vec2::new(c[0], c[1]).hypot() * zoom, Vec2::new(c[2], c[3]).hypot() * zoom); - if xf.determinant().abs() < 1e-12 || (w * px).min(h * py) < MIN_SIDE_PX { + let NodeKind::Path { path, live, .. } = &doc.node(id)?.kind else { return None }; + if !any_path && !matches!(live, Some(LiveShape::Rectangle { .. } | LiveShape::Polygon { .. })) { return None; } - // Each widget sits on its corner's diagonal, at the centre of the arc as drawn. - let points = std::array::from_fn(|k| { - let ((fx, fy), (sx, sy)) = CORNERS[k]; - let r = shapes::fitted_corner_radius(w, h, radii[k]); - let ix = r.max(MIN_INSET_PX / px).min(w / 2.0); - let iy = r.max(MIN_INSET_PX / py).min(h / 2.0); - xf * Point::new(fx * w + sx * ix, fy * h + sy * iy) - }); - Some(Self { id, w, h, radii, kinds, xf, points, shown: live.picked_corners(selection.partial(id)) }) + let lc = LiveCorners::new(path, live.as_ref())?; + let det = lc.xf.determinant().abs(); + if det < 1e-12 { + return None; + } + // Screen pixels per unit of the corners' space (a rectangle's may be skewed). + let scale = zoom * det.sqrt(); + let picked = lc.picked(selection.partial(id)); + let widgets: Vec<_> = lc + .corners + .iter() + .filter(|c| picked.contains(&c.index) && c.lu.min(c.lv) * scale >= MIN_SIDE_PX) + .map(|c| { + // On the bisector at the centre of the arc as drawn, at least the minimum inset + // in and at most half the shorter side. + let radius = lc.radius(c.index); + let k = (c.fitted(radius) / c.sin()).max(MIN_INSET_PX / (scale * (1.0 + c.cos()).sqrt())).min(c.lu.min(c.lv) / 2.0); + Widget { corner: *c, radius, kind: lc.kind(c.index), angle: angle_in(lc.xf, c), at: lc.xf * c.on_bisector(k) } + }) + .collect(); + let all = widgets.len() == lc.corners.len(); + (!widgets.is_empty()).then_some(Self { id, xf: lc.xf, widgets, all }) } /// Selection & Anchor Display → Hide Corner Widget for angles greater than: the widgets of - /// corners wider than `max` degrees (a skewed rectangle's obtuse ones) hide; none if all do. + /// corners wider than `max` degrees (in the document) hide; none if all do. pub fn within_angle(mut self, max: f64) -> Option { - // The angle between the shape's sides where they meet at the top-left corner; the - // top-right and bottom-left corners are its supplement. - let c = self.xf.as_coeffs(); - let (u, v) = (Vec2::new(c[0], c[1]), Vec2::new(c[2], c[3])); - let a = u.cross(v).abs().atan2(u.dot(v)).to_degrees(); - for (k, shown) in self.shown.iter_mut().enumerate() { - let angle = if k % 2 == 0 { a } else { 180.0 - a }; - *shown &= angle <= max + 1e-9; - } - self.shown.contains(&true).then_some(self) + let n = self.widgets.len(); + self.widgets.retain(|w| w.angle <= max + 1e-9); + self.all &= self.widgets.len() == n; + (!self.widgets.is_empty()).then_some(self) } - /// The widgets the active tool can drag (View → Show Corner Widget on). - pub fn for_tool(cx: &ToolContext) -> Option { - if !cx.corner_widgets { + /// The widgets on show: [`Self::of`] with View → Show Corner Widget `on`, less those wider + /// than `max_angle` ([`Self::within_angle`]). + pub fn showing(doc: &Document, selection: &Selection, zoom: f64, any_path: bool, on: bool, max_angle: f64) -> Option { + if !on { return None; } - Self::of(cx.doc, cx.selection, cx.zoom)?.within_angle(cx.corner_widget_max_angle) + Self::of(doc, selection, zoom, any_path)?.within_angle(max_angle) + } + + /// The widgets the active tool can drag (Direct Selection: `any_path`). + pub fn for_tool(cx: &ToolContext, any_path: bool) -> Option { + Self::showing(cx.doc, cx.selection, cx.zoom, any_path, cx.corner_widgets, cx.corner_widget_max_angle) } /// The centres of the widgets that show. pub fn visible(&self) -> impl Iterator + '_ { - self.points.iter().zip(self.shown).filter(|(_, on)| *on).map(|(p, _)| *p) + self.widgets.iter().map(|w| w.at) } - /// The indices of the shown corners. - fn shown_indices(&self) -> Value { - (0..4).filter(|k| self.shown[*k]).collect() + /// The corners whose widgets show: anchor indices of the path's uncut outline. + pub fn corners(&self) -> Vec { + self.widgets.iter().map(|w| w.corner.index).collect() } - /// Index of the shown widget nearest to `p` within `tol` (document units). - pub fn hit(&self, p: Point, tol: f64) -> Option { - let d = |k: &usize| self.points[*k].distance(p); - (0..4).filter(|k| self.shown[*k] && d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b))) + /// The widget nearest to `p` within `tol` (document units). + fn hit(&self, p: Point, tol: f64) -> Option { + let d = |k: &usize| self.widgets.get(*k).map_or(f64::INFINITY, |w| w.at.distance(p)); + (0..self.widgets.len()).filter(|k| d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b))) } - /// `object.setLiveShape` params setting `key` on the shown corners (all four unless some are - /// hidden, which `corners` then leaves out). + /// `object.setLiveShape` params setting `key` on the shown corners (every corner unless some + /// are hidden, which `corners` then leaves out). fn command(&self, key: &str, value: Value) -> Value { let mut p = Map::new(); p.insert("id".into(), json!(self.id.0)); p.insert(key.into(), value); - if self.shown != [true; 4] { - p.insert("corners".into(), self.shown_indices()); + if !self.all { + p.insert("corners".into(), json!(self.corners())); } Value::Object(p) } } -/// Is `p` over a corner widget the active tool would drag? -pub fn over_widget(cx: &ToolContext, p: Point) -> bool { - CornerWidgets::for_tool(cx).and_then(|w| w.hit(p, cx.tol(5.0))).is_some() +/// The angle between corner `c`'s sides once `xf` maps them into the document, in degrees. +fn angle_in(xf: Affine, c: &Corner) -> f64 { + let [a, b, cc, d, _, _] = xf.as_coeffs(); + let map = |v: Vec2| Vec2::new(a * v.x + cc * v.y, b * v.x + d * v.y); + let (u, v) = (map(c.u), map(c.v)); + u.cross(v).abs().atan2(u.dot(v)).to_degrees() +} + +/// Is `p` over a corner widget the active tool would drag (Direct Selection: `any_path`)? +pub fn over_widget(cx: &ToolContext, p: Point, any_path: bool) -> bool { + CornerWidgets::for_tool(cx, any_path).and_then(|w| w.hit(p, cx.tol(5.0))).is_some() } /// A double-click on a corner widget opens the Corners dialog for the shown corners. -pub fn double_click(cx: &ToolContext, p: Point) -> Option { - let w = CornerWidgets::for_tool(cx)?; +pub fn double_click(cx: &ToolContext, p: Point, any_path: bool) -> Option { + let w = CornerWidgets::for_tool(cx, any_path)?; w.hit(p, cx.tol(5.0))?; - Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.shown_indices() }))) + Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.corners() }))) } -/// Dragging a corner widget: the radius follows the pointer along the corner's diagonal. An +/// Dragging a corner widget: the radius follows the pointer along the corner's bisector. An /// Alt-click (no drag) cycles the corner kind instead. -#[derive(Clone, Copy, Debug)] +#[derive(Clone, Debug)] pub struct CornerDrag { widgets: CornerWidgets, - corner: usize, + /// The dragged widget (index into the shown ones). + widget: usize, + /// The path's uncut outline with its corners' radii and kinds (to outline the corners at + /// their largest). + base: PathData, + radii: Vec, + kinds: Vec, start: Point, began: bool, alt: bool, radius: f64, - /// The pointer went past fully round: the corners are at their largest radius. + /// The pointer went past fully round: the dragged corner is at its largest radius. at_limit: bool, at: Point, } impl CornerDrag { - /// Start a drag when the press `ev` is on a widget of the selection. - pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option { - let (widgets, p) = (CornerWidgets::for_tool(cx)?, ev.pos); - let corner = widgets.hit(p, cx.tol(5.0))?; - Some(Self { widgets, corner, start: p, began: false, alt: ev.mods.alt, radius: widgets.radii[corner], at_limit: false, at: p }) + /// Start a drag when the press `ev` is on a widget of the selection (Direct Selection: + /// `any_path`). + pub fn hit(cx: &ToolContext, ev: &PointerEvent, any_path: bool) -> Option { + let (widgets, p) = (CornerWidgets::for_tool(cx, any_path)?, ev.pos); + let widget = widgets.hit(p, cx.tol(5.0))?; + let radius = widgets.widgets.get(widget)?.radius; + let lc = cx.doc.node(widgets.id).and_then(LiveCorners::of)?; + let n = lc.base.anchor_count(); + let (radii, kinds) = ((0..n).map(|k| lc.radius(k)).collect(), (0..n).map(|k| lc.kind(k)).collect()); + let base = lc.base.into_owned(); + Some(Self { widgets, widget, base, radii, kinds, start: p, began: false, alt: ev.mods.alt, radius, at_limit: false, at: p }) } /// The start radius (as drawn: no larger than fits) plus the pointer's travel along the - /// corner's inward diagonal (in the shape's own units), from square to fully round; and - /// whether the travel reached fully round (the limit every corner shares). + /// corner's bisector (in the corners' own units), from square to fully round; and whether the + /// travel reached fully round. fn radius_at(&self, p: Point) -> (f64, bool) { - let w = &self.widgets; - let inv = w.xf.inverse(); - let d = inv * p - inv * self.start; - let (_, (sx, sy)) = CORNERS[self.corner]; - let max = shapes::max_corner_radius(w.w, w.h); - let r = shapes::fitted_corner_radius(w.w, w.h, w.radii[self.corner]) + (d.x * sx + d.y * sy) / 2.0; + let Some(w) = self.widgets.widgets.get(self.widget) else { return (self.radius, self.at_limit) }; + let inv = self.widgets.xf.inverse(); + let max = w.corner.max_radius(); + let r = w.corner.fitted(w.radius) + w.corner.radius_change(inv * p - inv * self.start); (r.min(max).max(0.0), max > 0.0 && r >= max) } - /// The edited corners' cuts at the dragged radius, in document coordinates. - fn edited_corners(&self) -> BezPath { - let w = &self.widgets; - let rect = Rect::new(0.0, 0.0, w.w, w.h); - let radii = std::array::from_fn(|k| if w.shown[k] { self.radius } else { w.radii[k] }); - let corner_of = shapes::rectangle_anchor_corners(rect, radii); - let path = shapes::rectangle_with_corners(rect, radii, w.kinds).transformed(w.xf); + /// The cuts of the edited corners that are at their largest radius, in document coordinates. + fn corners_at_limit(&self) -> BezPath { + let shown = &self.widgets.widgets; + let mut radii = self.radii.clone(); + for w in shown { + if let Some(r) = radii.get_mut(w.corner.index) { + *r = self.radius; + } + } + let full = |k: &usize| shown.iter().any(|w| w.corner.index == *k && self.radius >= w.corner.max_radius() - 1e-9); + let (path, sources) = cut_corners(&self.base, &radii, &self.kinds); let mut out = BezPath::new(); - let Some(sp) = path.subpaths.first() else { return out }; - // A corner's cut is the segment between its two anchors (the last one, for the top-left). - for i in 0..sp.segment_count() { - let (a, b) = (corner_of.get(i), corner_of.get(i + 1).or(corner_of.first())); - if a == b && a.is_some_and(|k| w.shown.get(*k) == Some(&true)) { - let c = sp.segment(i); - out.move_to(c.p0); - out.curve_to(c.p1, c.p2, c.p3); + for (sp, from) in path.transformed(self.widgets.xf).subpaths.iter().zip(&sources) { + // A corner's cut is the segment between its two anchors (the last one, for a closed + // subpath's first corner). + for i in 0..sp.segment_count() { + let (a, b) = (from.get(i), from.get(i + 1).or(from.first())); + if a == b && a.is_some_and(full) { + let c = sp.segment(i); + out.move_to(c.p0); + out.curve_to(c.p1, c.p2, c.p3); + } } } out @@ -205,22 +249,21 @@ impl CornerDrag { pub fn finish(self) -> Vec { if self.began { vec![Action::Commit] - } else if self.alt { - let kind = self.widgets.kinds[self.corner].next(); - vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(kind)))] + } else if let Some(w) = self.widgets.widgets.get(self.widget).filter(|_| self.alt) { + vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(w.kind.next())))] } else { vec![] } } - /// The radius readout next to the pointer; at the largest radius, the edited corners in red. + /// The radius readout next to the pointer; at the largest radius, the corners there in red. pub fn overlays(&self, cx: &ToolContext) -> Vec { if !self.began { return vec![]; } let mut out = vec![Overlay::Measure { p: self.at, text: format!("Radius: {}", cx.len(self.radius)) }]; if self.at_limit { - out.push(Overlay::Path { path: self.edited_corners(), color: crate::builder::HIGHLIGHT_RED, width: 2.0, dashed: false }); + out.push(Overlay::Path { path: self.corners_at_limit(), color: crate::builder::HIGHLIGHT_RED, width: 2.0, dashed: false }); } out } @@ -240,24 +283,38 @@ mod tests { /// A live `w` × `h` rectangle with corner radius `r`. fn live_shape(w: f64, h: f64, r: f64, xf: Affine) -> (Document, NodeId) { + let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf }; + doc_with(live.to_path(), Some(live)) + } + + /// A document holding one path with its live shape. + fn doc_with(path: PathData, live: Option) -> (Document, NodeId) { let mut d = Document::new(500.0, 500.0); let l = d.layers[0].id; let id = d.alloc_id(); - let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf }; - let mut n = Node::path(id, live.to_path(), Appearance::default_art()); + let mut n = Node::path(id, path, Appearance::default_art()); if let NodeKind::Path { live: slot, .. } = &mut n.kind { - *slot = Some(live); + *slot = live; } d.insert(Some(l), 0, n).unwrap(); (d, id) } + /// A five-pointed star at (200, 200) of radii 60 and 30 (#511): a plain path. + fn star() -> (Document, NodeId) { + doc_with(vectorcraft_geom::shapes::star(Point::new(200.0, 200.0), 60.0, 30.0, 5, 0.0), None) + } + fn selected(id: NodeId) -> Selection { let mut s = Selection::default(); s.add(id); s } + fn pts(w: &CornerWidgets) -> Vec { + w.visible().collect() + } + fn radius(a: &Action) -> f64 { let Action::Preview(c, v) = a else { panic!("not a preview: {a:?}") }; assert_eq!(c, "object.setLiveShape"); @@ -267,17 +324,19 @@ mod tests { #[test] fn widgets_sit_inside_each_corner() { let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0))); - let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap(); - assert_eq!(w.points, [Point::new(110.0, 110.0), Point::new(190.0, 110.0), Point::new(190.0, 190.0), Point::new(110.0, 190.0)]); + let w = CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap(); + assert_eq!(pts(&w), [Point::new(110.0, 110.0), Point::new(190.0, 110.0), Point::new(190.0, 190.0), Point::new(110.0, 190.0)]); // A larger radius moves them to the arc centres; zooming in keeps a 10 px minimum. let (d, id) = live_rect(20.0, Affine::translate((100.0, 100.0))); - assert_eq!(CornerWidgets::of(&d, &selected(id), 1.0).unwrap().points[0], Point::new(120.0, 120.0)); - assert_eq!(CornerWidgets::of(&d, &selected(id), 4.0).unwrap().points[2], Point::new(180.0, 180.0)); - // Hidden when the shape is tiny on screen, for plain paths and without a single selection. - assert!(CornerWidgets::of(&d, &selected(id), 0.2).is_none()); + assert_eq!(pts(&CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap())[0], Point::new(120.0, 120.0)); + assert_eq!(pts(&CornerWidgets::of(&d, &selected(id), 4.0, false).unwrap())[2], Point::new(180.0, 180.0)); + // Hidden when the shape is tiny on screen and without a single selection; a plain path + // shows them with Direct Selection only. + assert!(CornerWidgets::of(&d, &selected(id), 0.2, true).is_none()); let (d, id) = doc_with_rect(); - assert!(CornerWidgets::of(&d, &selected(id), 1.0).is_none()); - assert!(CornerWidgets::of(&d, &Selection::default(), 1.0).is_none()); + assert!(CornerWidgets::of(&d, &selected(id), 1.0, false).is_none()); + assert_eq!(pts(&CornerWidgets::of(&d, &selected(id), 1.0, true).unwrap())[0], Point::new(110.0, 110.0)); + assert!(CornerWidgets::of(&d, &Selection::default(), 1.0, true).is_none()); } #[test] @@ -307,9 +366,9 @@ mod tests { fn widgets_of_a_non_square_rectangle_follow_the_drawn_corners() { let (d, id) = live_shape(200.0, 80.0, 60.0, Affine::translate((100.0, 100.0))); let s = selected(id); - let w = CornerWidgets::of(&d, &s, 1.0).unwrap(); + let w = CornerWidgets::of(&d, &s, 1.0, false).unwrap(); let centres = [Point::new(140.0, 140.0), Point::new(260.0, 140.0), Point::new(260.0, 140.0), Point::new(140.0, 140.0)]; - assert_eq!(w.points, centres); + assert_eq!(pts(&w), centres); let p = paint(); let cx = cx(&d, &s, &p); let red = |t: &dyn crate::Tool| { @@ -339,8 +398,8 @@ mod tests { // 50 × 80 with 10 pt corners stretched 4 × 1: drawn 200 × 80, a mean radius of 20. let (d, id) = live_shape(50.0, 80.0, 10.0, Affine::translate((100.0, 100.0)) * Affine::scale_non_uniform(4.0, 1.0)); let s = selected(id); - let w = CornerWidgets::of(&d, &s, 1.0).unwrap(); - assert_eq!(w.points[0], Point::new(120.0, 120.0)); + let w = CornerWidgets::of(&d, &s, 1.0, false).unwrap(); + assert_eq!(pts(&w)[0], Point::new(120.0, 120.0)); let p = paint(); let cx = cx(&d, &s, &p); let mut t = crate::create("directSelection"); @@ -357,8 +416,8 @@ mod tests { let s = selected(id); let p = paint(); let cx = cx(&d, &s, &p); - let w = CornerWidgets::of(&d, &s, 1.0).unwrap(); - assert!(w.points[0].distance(Point::new(190.0, 110.0)) < 1e-9); + let w = CornerWidgets::of(&d, &s, 1.0, false).unwrap(); + assert!(pts(&w)[0].distance(Point::new(190.0, 110.0)) < 1e-9); let mut t = crate::create("directSelection"); t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 190.0, 110.0)); let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 180.0, 120.0)); @@ -377,10 +436,10 @@ mod tests { s.anchors.insert(id, [(0, 2)].into()); let p = paint(); let cx = cx(&d, &s, &p); - let w = CornerWidgets::of(&d, &s, 1.0).unwrap(); - assert_eq!(w.shown, [false, false, true, false]); - assert_eq!(w.visible().collect::>(), [Point::new(190.0, 190.0)]); - assert!(!over_widget(&cx, Point::new(110.0, 110.0)), "the other corners hide theirs"); + let w = CornerWidgets::of(&d, &s, 1.0, true).unwrap(); + assert_eq!(w.corners(), [2]); + assert_eq!(pts(&w), [Point::new(190.0, 190.0)]); + assert!(!over_widget(&cx, Point::new(110.0, 110.0), true), "the other corners hide theirs"); let mut t = crate::create("directSelection"); assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 190.0, 191.0)).is_empty()); let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 175.0, 176.0)); @@ -423,20 +482,20 @@ mod tests { #[test] fn corners_wider_than_the_preference_hide_their_widgets() { let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0))); - let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap(); - assert_eq!(w.within_angle(177.0).map(|w| w.shown), Some([true; 4])); - assert_eq!(w.within_angle(90.0).map(|w| w.shown), Some([true; 4])); + let w = CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap(); + assert_eq!(w.clone().within_angle(177.0).map(|w| w.corners()), Some(vec![0, 1, 2, 3])); + assert_eq!(w.clone().within_angle(90.0).map(|w| w.corners()), Some(vec![0, 1, 2, 3])); assert!(w.within_angle(89.0).is_none()); // Sheared by 30°: 60° at the top-left and bottom-right corners, 120° at the others. let shear = Affine::translate((100.0, 100.0)) * Affine::new([1.0, 0.0, 30f64.to_radians().tan(), 1.0, 0.0, 0.0]); let (d, id) = live_rect(0.0, shear); - let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap(); - assert_eq!(w.within_angle(100.0).map(|w| w.shown), Some([true, false, true, false])); + let w = CornerWidgets::of(&d, &selected(id), 1.0, false).unwrap(); + assert_eq!(w.clone().within_angle(100.0).map(|w| w.corners()), Some(vec![0, 2])); let s = selected(id); let p = paint(); let c = ToolContext { corner_widget_max_angle: 100.0, ..cx(&d, &s, &p) }; - assert!(over_widget(&c, w.points[0])); - assert!(!over_widget(&c, w.points[1]), "the 120° corner's widget is hidden"); + assert!(over_widget(&c, pts(&w)[0], false)); + assert!(!over_widget(&c, pts(&w)[1], false), "the 120° corner's widget is hidden"); } #[test] @@ -445,14 +504,113 @@ mod tests { let s = selected(id); let p = paint(); let mut c = cx(&d, &s, &p); - assert!(over_widget(&c, Point::new(110.0, 110.0))); - assert!(!over_widget(&c, Point::new(150.0, 150.0))); + assert!(over_widget(&c, Point::new(110.0, 110.0), false)); + assert!(!over_widget(&c, Point::new(150.0, 150.0), false)); c.corner_widgets = false; - assert!(!over_widget(&c, Point::new(110.0, 110.0))); + assert!(!over_widget(&c, Point::new(110.0, 110.0), true)); // With the widgets hidden, a drag from the same spot moves the object. let mut t = crate::create("selection"); t.pointer(&c, &PointerEvent::new(PointerKind::Down, 110.0, 110.0)); let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 130.0, 110.0)); assert_eq!(a[0], Action::Begin("Move".into())); } + + /// #511: Direct Selection shows a widget in each of a star's ten corners (the Selection tool + /// none: a star isn't a live shape); dragging a tip's inward rounds them all as one step. + #[test] + fn a_star_shows_widgets_in_every_corner_with_direct_selection() { + let (d, id) = star(); + let s = selected(id); + let p = paint(); + let cx = cx(&d, &s, &p); + assert!(CornerWidgets::for_tool(&cx, false).is_none()); + let w = CornerWidgets::for_tool(&cx, true).expect("widgets on a plain path"); + assert_eq!(w.corners(), (0..10).collect::>()); + // The top tip's widget sits 10 √2 px down its bisector. + let tip = pts(&w)[0]; + assert!(tip.distance(Point::new(200.0, 140.0 + 10.0 * 2f64.sqrt())) < 1e-9, "{tip:?}"); + let mut t = crate::create("directSelection"); + assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tip.x, tip.y)).is_empty()); + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, tip.x, tip.y + 10.0)); + assert_eq!(a[0], Action::Begin("Corner Radius".into())); + // The widget follows the arc's centre: r / sin(angle / 2) along the bisector. + let c = vectorcraft_geom::corners::path_corners(&star_path(&d, id))[0]; + let want = 10.0 * (c.angle_deg() / 2.0).to_radians().sin(); + assert!((radius(&a[1]) - want).abs() < 1e-9, "{a:?} want {want}"); + assert!(matches!(&a[1], Action::Preview(_, v) if v["id"] == id.0 && v.get("corners").is_none()), "every corner: {a:?}"); + // The Selection tool drags the star instead. + let mut t = crate::create("selection"); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tip.x, tip.y)); + assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, tip.x, tip.y + 10.0))[0], Action::Begin("Move".into())); + } + + fn star_path(d: &Document, id: NodeId) -> PathData { + let Some(NodeKind::Path { path, .. }) = d.node(id).map(|n| &n.kind) else { panic!("not a path") }; + path.clone() + } + + /// #511: a Direct-Selected anchor of the star shows its corner's widget alone, and the + /// preference hides the star's wide inner corners (about 125°) below their angle. + #[test] + fn star_corners_follow_the_anchors_and_the_angle_preference() { + let (d, id) = star(); + let mut s = selected(id); + s.anchors.insert(id, [(0, 3)].into()); + let p = paint(); + let c = cx(&d, &s, &p); + let w = CornerWidgets::for_tool(&c, true).unwrap(); + assert_eq!(w.corners(), [3]); + let mut t = crate::create("directSelection"); + let at = pts(&w)[0]; + t.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y)); + let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, at.x + 20.0, at.y + 20.0)); + assert!(matches!(&a[1], Action::Preview(_, v) if v["corners"] == json!([3])), "{a:?}"); + // Corners wider than 90° hide: the five tips keep theirs. + let whole = selected(id); + let c = ToolContext { corner_widget_max_angle: 90.0, ..cx(&d, &whole, &p) }; + let w = CornerWidgets::for_tool(&c, true).unwrap(); + assert_eq!(w.corners(), [0, 2, 4, 6, 8]); + assert_eq!(w.command("radius", json!(4.0))["corners"], json!([0, 2, 4, 6, 8])); + } + + /// A live polygon shows its widgets to the Selection tool too; past every corner's limit the + /// cuts outline in red. + #[test] + fn a_live_polygon_rounds_with_either_tool() { + let live = LiveShape::Polygon { radius: 80.0, sides: 6, xf: Affine::translate((200.0, 200.0)), radii: vec![], kinds: vec![] }; + let (d, id) = doc_with(live.to_path(), Some(live)); + let s = selected(id); + let p = paint(); + let cx = cx(&d, &s, &p); + for any_path in [false, true] { + assert_eq!(CornerWidgets::for_tool(&cx, any_path).unwrap().corners().len(), 6); + } + let tip = pts(&CornerWidgets::for_tool(&cx, false).unwrap())[0]; + let mut t = crate::create("selection"); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tip.x, tip.y)); + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 200.0, 300.0)); + // A hexagon's 120° corners stop where their cuts meet: 40 · tan 60°. + assert!((radius(&a[1]) - 40.0 * 3f64.sqrt()).abs() < 1e-9, "{a:?}"); + let red = t + .overlays(&cx) + .into_iter() + .any(|o| matches!(o, Overlay::Path { color, path, .. } if color == crate::builder::HIGHLIGHT_RED && path.elements().len() == 12)); + assert!(red, "six arcs at the limit"); + } + + /// A pen path's middle corner shows a widget; its ends and curved corners don't. + #[test] + fn a_pen_path_shows_widgets_on_its_corners_only() { + let mut sp = vectorcraft_geom::SubPath::polyline( + &[Point::new(100.0, 100.0), Point::new(300.0, 100.0), Point::new(300.0, 300.0), Point::new(100.0, 300.0)], + false, + ); + sp.anchors[2].h_out = Point::new(250.0, 350.0); + let (d, id) = doc_with(PathData::single(sp), None); + let s = selected(id); + let p = paint(); + let w = CornerWidgets::for_tool(&cx(&d, &s, &p), true).unwrap(); + assert_eq!(w.corners(), [1]); + assert_eq!(pts(&w), [Point::new(290.0, 110.0)]); + } } diff --git a/crates/tools/src/direct.rs b/crates/tools/src/direct.rs index f7dfc6e0..b5c8426a 100644 --- a/crates/tools/src/direct.rs +++ b/crates/tools/src/direct.rs @@ -6,7 +6,7 @@ //! steps), drag a direction handle to //! reshape (Shift keeps it at 45° steps round its anchor, Alt moves it alone; smart guides snap //! it), marquee to select anchors (Shift-drag toggles them: the selected ones inside are -//! deselected, the others selected), drag a live rectangle's corner widget to round its corners +//! deselected, the others selected), drag a corner widget of any path (a star, a pen path) to round its corners //! (the selected ones when anchors are selected; Alt-click cycles their kind, double-click opens //! the Corners dialog). //! Group Selection: click selects the leaf; each further click on it adds the next enclosing group; @@ -317,13 +317,13 @@ impl Tool for DirectSelectionTool { vec![Action::Exec("select.set".into(), json!({"ids": [target.0]}))] } } - (PointerKind::DoubleClick, _) if !self.group => corners::double_click(cx, p).into_iter().collect(), + (PointerKind::DoubleClick, _) if !self.group => corners::double_click(cx, p, true).into_iter().collect(), (PointerKind::Move, State::Idle) => { self.hover = if self.group || !cx.highlight_anchors { None } else { hovered_anchor(cx, p) }; vec![] } (PointerKind::Down, _) => { - if let Some(c) = CornerDrag::hit(cx, ev) { + if let Some(c) = CornerDrag::hit(cx, ev, true) { self.state = State::Corner(c); return vec![]; } @@ -597,7 +597,7 @@ impl Tool for DirectSelectionTool { } } fn cursor(&self, cx: &ToolContext, p: Point, _m: Mods) -> Cursor { - if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p)) { + if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p, true)) { return Cursor::CornerRadius; } if !self.group && (matches!(self.state, State::Bracket(_)) || over_bracket(cx, p)) { diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs index b143e8a4..a7dea741 100644 --- a/crates/tools/src/lib.rs +++ b/crates/tools/src/lib.rs @@ -234,7 +234,7 @@ pub struct ToolContext<'a> { /// points (a transform's reference point) land on anchors and ruler guides within /// [`Self::snap_tolerance`]. pub snap_to_point: bool, - /// View → Show Corner Widget: live rectangles show draggable Live Corners widgets. + /// View → Show Corner Widget: paths show draggable Live Corners widgets in their corners. pub corner_widgets: bool, /// Which paint proxy is in front (true = Fill): the one the Gradient tool edits. pub fill_active: bool, diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rs index 1742cf49..32f035b4 100644 --- a/crates/tools/src/select.rs +++ b/crates/tools/src/select.rs @@ -2,7 +2,7 @@ //! the selected ones are deselected, the others selected), move (Alt copies, Shift constrains; Smart //! Guides, or with them off View › Snap to Point, snap it), //! bounding-box scale (Shift proportional, Alt from centre) and rotate (outside corners, Shift 45°), -//! drag a live rectangle's corner widget to round its corners (Alt-click cycles their kind, +//! drag a live rectangle's or polygon's corner widget to round its corners (Alt-click cycles their kind, //! double-click opens the Corners dialog), double-click to enter isolation mode (Double Click To //! Isolate), Cmd/Ctrl-click to select the object behind (Command Click to Select Objects Behind), //! click or drag a ruler guide ([`crate::rulerguide`]), drag the brackets of type on a path @@ -169,7 +169,7 @@ impl Tool for SelectionTool { match (ev.kind, self.state.clone()) { (PointerKind::DoubleClick, _) => { self.state = State::Idle; - if let Some(a) = corners::double_click(cx, p).or_else(|| typewidget::double_click(cx, p)) { + if let Some(a) = corners::double_click(cx, p, false).or_else(|| typewidget::double_click(cx, p)) { return vec![a]; } if crate::rulerguide::guide_at(cx, p).is_some() { @@ -191,7 +191,7 @@ impl Tool for SelectionTool { (PointerKind::Down, _) => { // 1. Live Corners widgets and type on a path's brackets, then the bounding-box // handles of the current selection. - if let Some(c) = CornerDrag::hit(cx, ev) { + if let Some(c) = CornerDrag::hit(cx, ev, false) { self.state = State::Corner(c); return vec![]; } @@ -381,7 +381,7 @@ impl Tool for SelectionTool { if self.guide.busy() { return self.guide.cursor(cx, p).unwrap_or_default(); } - if over_widget(cx, p) { + if over_widget(cx, p, false) { return Cursor::CornerRadius; } if over_bracket(cx, p) { diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index 83e2559d..d4b17f4c 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -1419,11 +1419,16 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) { anchor_square(p, xf.to_screen(a.p), color, false, anchor(direct)); } } - // Live Corners widgets (Selection / Direct Selection on a single live rectangle). + // Live Corners widgets (Selection on a live rectangle or polygon, Direct Selection on any path). if matches!(tool, "selection" | "directSelection") - && app.ui.view.corner_widgets - && let Some(w) = vectorcraft_tools::corners::CornerWidgets::of(&st.doc, &st.selection, xf.zoom) - .and_then(|w| w.within_angle(app.session.prefs.hide_corner_widget_above)) + && let Some(w) = vectorcraft_tools::corners::CornerWidgets::showing( + &st.doc, + &st.selection, + xf.zoom, + tool == "directSelection", + app.ui.view.corner_widgets, + app.session.prefs.hide_corner_widget_above, + ) { let color = c32(st.doc.layer_color(w.id)); for sp in w.visible().map(|q| xf.to_screen(q)) { @@ -2249,6 +2254,25 @@ mod tests { assert_eq!(widgets(&mut app), 0); } + /// #511: a star shows a widget in each of its ten corners with Direct Selection (none with + /// the Selection tool: it isn't a live shape); View → Hide Corner Widget hides them. + #[test] + fn a_star_shows_corner_widgets_with_direct_selection() { + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap(); + app.session.execute("shape.star", &json!({"cx": 200, "cy": 150, "radius1": 80, "radius2": 40})).unwrap(); + let ctx = egui::Context::default(); + let widgets = |app: &mut VectorcraftApp| { + shapes(app, &ctx).iter().filter(|s| matches!(s, Shape::Circle(c) if c.radius == 3.0 && c.fill == Color32::WHITE)).count() + }; + app.select_tool("selection"); + assert_eq!(widgets(&mut app), 0); + app.select_tool("directSelection"); + assert_eq!(widgets(&mut app), 10); + app.run("view.cornerWidget", json!({})).unwrap(); + assert_eq!(widgets(&mut app), 0); + } + /// The type widget beside selected type's bounding box: hollow (white) on point type, filled /// in the layer colour on area type. #[test] diff --git a/crates/ui-egui/src/dialogs/corners.rs b/crates/ui-egui/src/dialogs/corners.rs index d4d30577..14cf1da6 100644 --- a/crates/ui-egui/src/dialogs/corners.rs +++ b/crates/ui-egui/src/dialogs/corners.rs @@ -1,13 +1,16 @@ //! Corners: double-clicking a Live Corners widget (or `ui.corners`) sets the corner kind and -//! radius of a live rectangle's corners: those whose widgets show (the Direct-Selected ones, else -//! all four). OK runs `object.setLiveShape` for them, one undo step. +//! radius of a path's corners: those whose widgets show (the Direct-Selected ones, else every +//! corner). OK runs `object.setLiveShape` for them, one undo step. //! -//! Fields: `id`, `corners` (indices 0–3: top-left, top-right, bottom-right, bottom-left), `kind` -//! ("round", "invertedRound" or "chamfer") and `radius` (pt). While the corners differ in kind -//! or radius, that field is absent and OK leaves it as it is. +//! Fields: `id`, `corners` (anchor indices of the path with its corners uncut: a rectangle's 0–3 +//! from the top-left clockwise), `kind` ("round", "invertedRound" or "chamfer") and `radius` +//! (pt). While the corners differ in kind or radius, that field is absent and OK leaves it as it +//! is. + +use std::collections::BTreeSet; use serde_json::{Value, json}; -use vectorcraft_engine::doc::{NodeId, NodeKind}; +use vectorcraft_engine::doc::{LiveCorners, NodeId}; use vectorcraft_geom::shapes::CornerKind; use super::swatch_options::{grid, label}; @@ -20,7 +23,7 @@ pub const KIND: &str = vectorcraft_tools::corners::DIALOG; pub(super) const SPEC: DialogSpec = DialogSpec { heading: |_| tl!("Corners").into(), body, confirm, min_width: 280.0, ..DialogSpec::FORM }; -/// Open Corners for `{id?, corners?}`: the live rectangle `id` (default: the selected one) and its +/// Open Corners for `{id?, corners?}`: the path `id` (default: the selected one) and its /// `corners` (default: the selected corners), filled in with their kind and radius. pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result { let st = app.session.active().ok_or("no document")?; @@ -28,22 +31,21 @@ pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result { Some(id) => NodeId(id), None => match st.selection.objects[..] { [id] => id, - _ => return Err("select one live rectangle, or give its `id`".into()), + _ => return Err("select one path, or give its `id`".into()), }, }; - let Some(NodeKind::Path { live: Some(live @ vectorcraft_engine::doc::LiveShape::Rectangle { .. }), .. }) = st.doc.node(id).map(|n| &n.kind) - else { - return Err("Corners edits a live rectangle".into()); + let Some(live) = st.doc.node(id).and_then(LiveCorners::of) else { + return Err("Corners edits the corners of a path".into()); }; - let corners = match p.get("corners").and_then(Value::as_array) { - Some(a) => std::array::from_fn(|k| a.iter().any(|v| v.as_u64() == Some(k as u64))), - None => live.picked_corners(st.selection.partial(id)), + let corners: BTreeSet = match p.get("corners").and_then(Value::as_array) { + Some(a) => a.iter().filter_map(Value::as_u64).filter_map(|k| usize::try_from(k).ok()).filter(|k| live.corner(*k).is_some()).collect(), + None => live.picked(st.selection.partial(id)), }; - if !corners.contains(&true) { - return Err("give corners 0–3".into()); + if corners.is_empty() { + return Err("give corners of the path: anchors between two straight sides".into()); } - let (radius, kind) = live.corner_style(corners); - let mut fields = json!({"id": id.0, "corners": (0..4).filter(|k| corners[*k]).collect::>()}); + let (radius, kind) = live.style(&corners); + let mut fields = json!({"id": id.0, "corners": corners}); if let Some(k) = kind { fields["kind"] = json!(k); } @@ -94,7 +96,7 @@ fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result { mod tests { use super::*; use vectorcraft_engine::Session; - use vectorcraft_engine::doc::LiveShape; + use vectorcraft_engine::doc::{LiveShape, NodeKind}; use vectorcraft_tools::corners::CornerWidgets; use vectorcraft_tools::{PointerEvent, PointerKind}; @@ -121,7 +123,7 @@ mod tests { /// The radius the Properties panel's Corner Radius field shows. fn panel_radius(app: &VectorcraftApp, id: u64) -> Option { let n = app.session.active().unwrap().doc.node(NodeId(id)).unwrap().clone(); - crate::panels::corner_radius(app, &n, &live(app, id)) + crate::panels::corner_radius(app, &n) } fn shown(app: &mut VectorcraftApp) -> Vec { @@ -151,7 +153,7 @@ mod tests { app.select_tool("directSelection"); let view = app.view_info(); let st = app.session.active().unwrap(); - let at: Vec<_> = CornerWidgets::of(&st.doc, &st.selection, view.zoom).unwrap().visible().collect(); + let at: Vec<_> = CornerWidgets::of(&st.doc, &st.selection, view.zoom, true).unwrap().visible().collect(); assert_eq!(at.len(), 1); crate::canvas::dispatch(&mut app, &PointerEvent::new(PointerKind::DoubleClick, at[0].x, at[0].y), view); let d = app.ui.dialog.clone().expect("Corners opened"); @@ -192,8 +194,25 @@ mod tests { app.ui.dialog.as_mut().unwrap().fields.insert("radius".into(), json!("3 pt")); super::super::confirm(&mut app).unwrap(); assert_eq!(corners(&app, id), ([3.0; 4], before.1)); - // Only live rectangles, and only real corners. + // Only paths, and only real corners. assert!(app.run("ui.corners", json!({"id": 9999})).is_err()); assert!(app.run("ui.corners", json!({"corners": [7]})).is_err()); + let e = app.run("shape.ellipse", json!({"x": 0, "y": 0, "width": 50, "height": 30})).unwrap()["id"].as_u64().unwrap(); + assert!(app.run("ui.corners", json!({"id": e})).is_err()); + } + + /// #511: a star's corners open in Corners too; OK rounds them. + #[test] + fn corners_edits_a_star() { + let (mut app, _) = app(); + let id = app.run("shape.star", json!({"cx": 200, "cy": 200, "radius1": 60, "radius2": 30})).unwrap()["id"].as_u64().unwrap(); + app.run("ui.corners", json!({})).unwrap(); + let d = app.ui.dialog.as_mut().unwrap(); + assert_eq!((d.fields.get("corners"), d.f64("radius", -1.0)), (Some(&json!((0..10).collect::>())), 0.0)); + d.fields.insert("radius".into(), json!(5)); + super::super::confirm(&mut app).unwrap(); + let n = app.session.active().unwrap().doc.node(NodeId(id)).unwrap().clone(); + assert!(matches!(&n.kind, NodeKind::Path { live: Some(LiveShape::Path { .. }), .. })); + assert_eq!(crate::panels::corner_radius(&app, &n), Some(5.0)); } } diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv index 6de71837..369a09fe 100644 --- a/crates/ui-egui/src/i18n/es.tsv +++ b/crates/ui-egui/src/i18n/es.tsv @@ -3072,7 +3072,7 @@ axis Both Ambos @msg Convert to Artboards: selection has no area Convertir en mesas de trabajo: la selección no tiene área @msg Convert to Shape: no rectangles or ellipses selected Convertir en forma: no hay rectángulos ni elipses seleccionados @msg Copied the CSS of {rules} object(s) Se copió el CSS de {rules} objeto(s) -@msg Corners edits a live rectangle Esquinas edita un rectángulo interactivo +@msg Corners edits the corners of a path Esquinas edita las esquinas de un trazado @msg Couldn't copy to the system clipboard: {e} No se pudo copiar al portapapeles del sistema: {e} @msg Couldn't open {name}: {e} No se pudo abrir {name}: {e} @msg Couldn't place {name}: the document it was dropped on was closed No se pudo colocar {name}: se cerró el documento en el que se soltó @@ -3238,7 +3238,7 @@ axis Both Ambos @msg file version {0} is newer than this VectorCraft supports ({VERSION}) la versión de archivo {0} es más reciente de lo que admite este VectorCraft ({VERSION}) @msg freeform point {i} needs `at` [x, y] and a valid `color` el punto de forma libre {i} necesita `at` [x, y] y un `color` válido @msg give both `start` and `end` [x, y] (or neither) indica `start` y `end` [x, y] (o ninguno de los dos) -@msg give corners 0–3 indica esquinas de 0 a 3 +@msg give corners of the path: anchors between two straight sides indica esquinas del trazado: puntos de ancla entre dos lados rectos @msg give the path `id` and the width point `index` indica el `id` del trazado y el `index` del punto de anchura @msg guides are locked las guías están bloqueadas @msg image '{key}' has no pixels and was left out la imagen '{key}' no tiene píxeles y se omitió @@ -3422,7 +3422,7 @@ axis Both Ambos @msg select artwork (or a colour group) to recolor selecciona la ilustración (o un grupo de colores) que quieres volver a colorear @msg select at least two objects selecciona al menos dos objetos @msg select objects, not layers selecciona objetos, no capas -@msg select one live rectangle, or give its `id` selecciona un rectángulo interactivo o indica su `id` +@msg select one path, or give its `id` selecciona un trazado o indica su `id` @msg select paths to join selecciona los trazados que quieres unir @msg select the art to repeat selecciona la ilustración que quieres repetir @msg select the artwork to warp selecciona la ilustración que quieres deformar diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index 683e72d1..f3ca744c 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -485,7 +485,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[ "ui.corners", "Corners…", "", - "{id?, corners?: [0..3…]} open Corners for live rectangle `id` (default: the selected one) and its corners (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; default: the Direct-Selected corners, else all four) (dialog `corners`: kind (round|invertedRound|chamfer), radius (pt); double-clicking a corner widget opens it too): OK runs object.setLiveShape", + "{id?, corners?: [i…]} open Corners for path `id` (default: the selected one) and its corners (anchor indices of the path with its corners uncut, as object.setLiveShape takes them: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; default: the Direct-Selected corners, else every corner) (dialog `corners`: kind (round|invertedRound|chamfer), radius (pt); double-clicking a corner widget opens it too): OK runs object.setLiveShape", ), ( "ui.colorGuideLimit", diff --git a/crates/ui-egui/src/panels/mod.rs b/crates/ui-egui/src/panels/mod.rs index a6c13939..6c7fa771 100644 --- a/crates/ui-egui/src/panels/mod.rs +++ b/crates/ui-egui/src/panels/mod.rs @@ -45,7 +45,7 @@ pub mod transparency; use egui::{Rect, Sense, Ui, vec2}; use serde_json::{Value, json}; use vectorcraft_color::{BlendMode, Color, Paint}; -use vectorcraft_doc::{LiveShape, Node, StrokeLayer}; +use vectorcraft_doc::{LiveCorners, Node, StrokeLayer}; use vectorcraft_engine::inspect::StrokeMixed; use crate::theme::Tokens; @@ -57,11 +57,24 @@ pub fn first_selected(app: &VectorcraftApp) -> Option { first_node(app).cloned() } -/// The radius the Live Corners of live rectangle `n` show in the panels: that of the corners the -/// panels set (the Direct-Selected ones, else all four), blank when they differ. -pub(crate) fn corner_radius(app: &VectorcraftApp, n: &Node, live: &LiveShape) -> Option { +/// The radius the Live Corners of path `n` show in the panels: that of the corners the panels set +/// (the Direct-Selected ones, else every corner), blank when they differ. +pub(crate) fn corner_radius(app: &VectorcraftApp, n: &Node) -> Option { let partial = app.session.active().and_then(|d| d.selection.partial(n.id)); - live.corner_style(live.picked_corners(partial)).0 + let corners = LiveCorners::of(n)?; + corners.style(&corners.picked(partial)).0 +} + +/// The Corner Radius field of a live rectangle's or polygon's properties: [`corner_radius`], +/// which a new value sets on those corners. +pub(crate) fn corner_radius_row(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, id: &str) { + let units = app.session.general_unit(); + ui.horizontal(|ui| { + dim_label(ui, tl!("Corner Radius:")); + if let Some(r) = crate::widgets::num_field(ui, id, corner_radius(app, n), units, 80.0) { + app.run("object.setLiveShape", json!({"radius": r})).ok(); + } + }); } /// Number of selected objects. diff --git a/crates/ui-egui/src/panels/properties.rs b/crates/ui-egui/src/panels/properties.rs index 49f07c5d..158e3317 100644 --- a/crates/ui-egui/src/panels/properties.rs +++ b/crates/ui-egui/src/panels/properties.rs @@ -2,9 +2,9 @@ use egui::Ui; use serde_json::json; -use vectorcraft_doc::{NodeKind, Unit}; +use vectorcraft_doc::{LiveShape, NodeKind, Unit}; -use super::{corner_radius, first_selected, pstate, set_pstate}; +use super::{corner_radius_row, first_selected, pstate, set_pstate}; use crate::theme::Tokens; use crate::widgets::{self, dim_label, divider, section_header}; use crate::{VectorcraftApp, icons}; @@ -93,7 +93,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { divider(ui); section_header(ui, tl!("Quick Actions")); let is_group = matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Group { .. })); - let is_live = matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Path { live: Some(_), .. })); + let is_live = matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Path { live: Some(l), .. }) if !matches!(l, LiveShape::Path { .. })); let mut actions: Vec<(&str, &str)> = vec![]; if n_sel > 1 { actions.push((tl!("Group"), "object.group")); @@ -335,14 +335,7 @@ pub fn transform_section(app: &mut VectorcraftApp, ui: &mut Ui) { && let NodeKind::Path { live: Some(live), .. } = &n.kind { match live { - vectorcraft_doc::LiveShape::Rectangle { .. } => { - ui.horizontal(|ui| { - dim_label(ui, tl!("Corner Radius:")); - if let Some(r) = widgets::num_field(ui, "radius", corner_radius(app, &n, live), units, 80.0) { - app.run("object.setLiveShape", json!({"radius": r})).ok(); - } - }); - } + vectorcraft_doc::LiveShape::Rectangle { .. } => corner_radius_row(app, ui, &n, "radius"), vectorcraft_doc::LiveShape::Polygon { sides, .. } => { ui.horizontal(|ui| { dim_label(ui, tl!("Sides:")); @@ -350,6 +343,7 @@ pub fn transform_section(app: &mut VectorcraftApp, ui: &mut Ui) { app.run("object.setLiveShape", json!({"sides": s as u32})).ok(); } }); + corner_radius_row(app, ui, &n, "radius"); } _ => {} } diff --git a/crates/ui-egui/src/panels/transform.rs b/crates/ui-egui/src/panels/transform.rs index 003f5440..a4dd33f2 100644 --- a/crates/ui-egui/src/panels/transform.rs +++ b/crates/ui-egui/src/panels/transform.rs @@ -7,7 +7,7 @@ use serde_json::json; use vectorcraft_doc::NodeKind; use vectorcraft_geom::Rect; -use super::{corner_radius, first_selected, pstate, set_pstate}; +use super::{corner_radius_row, first_selected, pstate, set_pstate}; use crate::theme::Tokens; use crate::widgets::{self, menu_item}; use crate::{VectorcraftApp, icons}; @@ -166,20 +166,16 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { app.run("object.reflect", json!({"axis": "horizontal", "origin": origin})).ok(); } }); - // Live shape properties. + // Live shape properties (a path with live corners is no shape). if let Some(n) = first_selected(app) && let NodeKind::Path { live: Some(live), .. } = &n.kind + && !matches!(live, vectorcraft_doc::LiveShape::Path { .. }) { widgets::divider(ui); match live { vectorcraft_doc::LiveShape::Rectangle { .. } => { widgets::subheader(ui, tl!("Rectangle Properties:")); - ui.horizontal(|ui| { - widgets::dim_label(ui, tl!("Corner Radius:")); - if let Some(r) = widgets::num_field(ui, "xfp-radius", corner_radius(app, &n, live), units, 80.0) { - app.run("object.setLiveShape", json!({"radius": r})).ok(); - } - }); + corner_radius_row(app, ui, &n, "xfp-radius"); } vectorcraft_doc::LiveShape::Polygon { sides, .. } => { widgets::subheader(ui, tl!("Polygon Properties:")); @@ -189,6 +185,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { app.run("object.setLiveShape", json!({"sides": s.clamp(3.0, 20.0) as u32})).ok(); } }); + corner_radius_row(app, ui, &n, "xfp-radius"); } _ => { widgets::subheader(ui, tl!("Shape Properties:")); diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 3844c82f..3df16f00 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -291,9 +291,9 @@ Width Point Edit: double-clicking a width point with the Width tool, or `ui.widt value: true}` then confirm (the Delete button) removes the point with `stroke.widthPoint.remove`. Corners: double-clicking a Live Corners widget with the Selection or Direct Selection tool, or `ui.corners {id?, -corners?}`, opens the `corners` dialog for a live rectangle's corners (the Direct-Selected ones, else all four; fields -`id`, `corners`: indices 0–3 clockwise from the top-left, `kind`: round, invertedRound or chamfer, `radius` in points; -`kind` or `radius` is absent while the corners differ). `ui.dialog.confirm` runs `object.setLiveShape` with them. +corners?}`, opens the `corners` dialog for a path's corners (the Direct-Selected ones, else every corner; fields `id`, +`corners`: anchor indices of the path with its corners uncut, a rectangle's 0–3 clockwise from the top-left, `kind`: +round, invertedRound or chamfer, `radius` in points; `kind` or `radius` is absent while the corners differ). `ui.dialog.confirm` runs `object.setLiveShape` with them. Perspective plane options: double-clicking a plane widget of the perspective grid, or `ui.perspectivePlane {plane}`, opens the `perspectivePlane` dialog (fields `plane`: left, right or ground; `location`: points along the plane's diff --git a/docs/mcp.md b/docs/mcp.md index e681bcb1..d7df68c1 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -1135,21 +1135,32 @@ size. The journal entry of a scaling command records the `strokes` and `corners` ## Live Corners -`object.setLiveShape {id?, ids?, radius?, kind?, corners?}` sets the corners of live rectangles (one undo step): -`radius` (pt) and `kind` (`round`, `invertedRound` or `chamfer`) go to the `corners` given (0 top-left, 1 top-right, -2 bottom-right, 3 bottom-left), else to the corners holding a Direct-Selected anchor (`select.anchors`), else to all -four. Each corner keeps its own radius and kind (the shape's `live` in queries has `radii` and, when a corner isn't -round, `kinds`); a corner with no radius is one anchor, a cut one two, and Direct-Selected corners stay selected as -that changes. Every corner is a circular arc, whatever the rectangle's proportions: a radius past half the shorter -side draws at half of it (the same limit for every corner), and a rectangle from a file that kept an uneven scale in its -transform (elliptical corners) gets circular ones in document units when its corners are next set. With the Selection or -Direct Selection tool, dragging a corner widget rounds the corners whose widgets show (all four, or the Direct-Selected -ones), outlining them in red once they reach that limit; Alt-clicking one cycles their kind and double-clicking one -opens Corners (`ui.corners {id?, corners?}`, dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`). +`object.setLiveShape {id?, ids?, radius?, kind?, corners?}` sets the corners of any path (one undo step): a live +rectangle's or polygon's, a star's, a pen path's. A corner is an anchor without handles between two straight sides +(not an open path's ends, not a smooth anchor, not one the sides run straight on through). `radius` (pt) and `kind` +(`round`, `invertedRound` or `chamfer`) go to the `corners` given, else to the corners holding a Direct-Selected +anchor (`select.anchors`), else to every corner. `corners` are anchor indices of the path with its corners uncut, +counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a +polygon's from its first vertex clockwise; a star's from its first tip; an index past the last anchor is an error. +Each corner keeps its own radius and kind (the shape's `live` in queries has `radii` and, when a corner isn't round, +`kinds`); a corner with no radius is one anchor, a cut one two, and Direct-Selected corners stay selected as that +changes. A path that isn't a live shape keeps its uncut outline (`live` `{"shape": "path", "base", "radii"}`) so its +corners stay editable, and is a plain path again once no corner is cut; a polygon stays a live polygon, its corners +keeping the radius they shared when `sides` changes. Every corner is a circular arc tangent to both sides: a radius +draws no larger than takes the cut halfway along the corner's shorter side (half the shorter side of a rectangle, the +same limit for its four corners), the corners stay circular through uneven scales (the radius scales by the mean scale, +or keeps its size with Scale Corners off), and a rectangle from a file that kept an uneven scale in its transform +(elliptical corners) gets circular ones in document units when its corners are next set. Dragging a corner widget +rounds the corners whose widgets show (every corner, or the Direct-Selected ones), outlining in red those that reach +their limit; the Selection tool shows the widgets of live rectangles and polygons, the Direct Selection tool those of +any path. Alt-clicking one cycles their kind and double-clicking one opens Corners (`ui.corners {id?, corners?}`, +dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`). ```json {"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[1],"radius":16}}} {"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[0,3],"radius":8,"kind":"chamfer"}}} +{"name":"run_command","arguments":{"command":"shape.star","params":{"cx":200,"cy":200,"radius1":60,"radius2":30}}} +{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"radius":5}}} ``` ## Use Preview Bounds From 4eac7b505fc9329f62af406b041f4f61dda2813d Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 21:48:42 +0700 Subject: [PATCH 09/22] Fix #506: drawing tools snap to Smart Guides as the Selection tool does Every drawing tool now asks one snapper (guides::DrawSnap) for the points it places: the Pen's and Curvature tool's anchors, the Pencil's ends, the shape tools' start and dragged corner or radius (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star, Line Segment, Arc, Spiral, the grids), the Type tool's click and frame and a new artboard's corners. Points land on other objects' anchors, centres and paths ("anchor", "center", "path") or line up with their anchors, edges and centres ("align"); hovering shows it before the press, the Pen's guides end its rubber band, and the Pen lands on the path being drawn too. Shift keeps a point to its 45-degree step (from Constrain Angle) or a box's diagonal and slides it along that way into line with a target. Preferences > Smart Guides > Construction Guides and Angles now act: a drawn point near a guide through the point it leaves from lands on it. Before, the Pen snapped only its press and showed nothing, and the shape tools re-gathered targets on every drag step from the document showing their own preview, so the dragged corner stuck to where the last step left it. Performance: targets are gathered once per document state (keyed on the document's uid and revision, now in ToolContext), from the art in the window, and sorted, so the anchors, centres and lines near the pointer are found by bisection. Leaving objects out of the targets no longer looks up each node's ancestry (quadratic in the document's size): one pruned walk does it, which also speeds up the Selection tool's moves and resizes. The direction handles' HandleSnap (#494) is now a DrawSnap holding its own targets (Targets::for_handle) for the drag: one cache, one lookup. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 12 +- crates/engine/src/lib.rs | 4 +- crates/engine/src/tests_smartguides.rs | 109 +++++ crates/engine/src/tooling.rs | 6 + crates/mcp/src/tests.rs | 27 ++ crates/tools/src/draw2/curvature.rs | 55 ++- crates/tools/src/draw2/family.rs | 72 ++- crates/tools/src/draw2/gesture.rs | 64 ++- crates/tools/src/guides.rs | 590 ++++++++++++++++++++++--- crates/tools/src/lib.rs | 10 + crates/tools/src/pen.rs | 76 +++- crates/tools/src/shape.rs | 92 +++- crates/tools/src/text.rs | 36 +- crates/tools/src/text_tests.rs | 21 + crates/tools/src/xform/artboard.rs | 19 +- docs/mcp.md | 30 +- 16 files changed, 1061 insertions(+), 162 deletions(-) create mode 100644 crates/engine/src/tests_smartguides.rs diff --git a/ROADMAP.md b/ROADMAP.md index 4e8d8350..8874ff92 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), the drawing tools snapping to Smart Guides as the Selection tool does, with Construction Guides (#506); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -107,7 +107,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, Remove Anchor Points when anchors are selected, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas. - Save / Don't Save / Cancel before closing or quitting with unsaved documents (tabs, Close, Close All, Quit, window close). - Four brightness themes, persistent preferences. - - Preferences that act (#394, in part): Show Tool Tips, Double Click To Isolate, Zoom with Mouse Wheel (the wheel zooms about the pointer, Shift-wheel scrolls up and down, Cmd/Ctrl-wheel sideways; Alt/Option-wheel and a trackpad pinch zoom about the pointer either way), Use Precise Cursors; Selection & Anchor Display › Tolerance (objects, anchors and handles), Object Selection by Path Only, Command Click to Select Objects Behind (cycling down the stack), Zoom to Selection, anchor Size, Highlight anchors on mouse over; Type › Number of Recent Fonts (up to 15); Guides & Grid › guide and grid Color and Style (lines or dots) and Grids In Back. Then Snap to Point (its distance, for moves, drawn points and reference points), Move Locked and Hidden Artwork with Artboard, Enable Rubber Band for the Pen and Curvature tools, Handles style, Show handles when multiple anchors are selected, Hide Corner Widget for angles greater than; General › Transform Pattern Tiles (the transforms' and dialogs' Transform Patterns) and Select Same Tint %; Type › Size/Leading, Tracking and Baseline Shift increments (`type.step`, Cmd+Shift+. and Cmd+Shift+, for the size, the Type tool's Alt+arrows), Enable Missing Glyph Protection and Fill New Type Objects With Placeholder Text. Then Smart Guides › Color, Alignment Guides, Anchor/Path Labels, Measurement Labels, Transform Tools, Object Highlighting (with Smart Guides on) and Snapping Tolerance (4 px by default, for every smart guide snap). Then Type › Type Object Selection by Path Only (type is picked on the baseline of any of its lines, area type's frame or the path of type on a path, no longer anywhere in its bounds; the Type tools and the Eyedropper still take a click among the characters). Then General › Anti-aliased Artwork (off, the canvas draws the art with hard edges). Then Guides & Grid › Show Pixel Grid (Above 600% Zoom), a line at every document pixel over the art in Pixel Preview, turning with a rotated view as the document grid now does too. Then General › Show The Home Screen When No Documents Are Open (off, closing the last document leaves an empty window; the Home button still opens the screen). Then Units › Numbers Without Units Are Points (on by default: a number typed with no unit into a field in picas is read in points, a typed unit still wins; dimmed unless a unit is Picas). Then User Interface › Auto-Collapse Iconic Panels (off by default: on, a click away from a panel popped out of the icon column puts it away). They reach agents too (`prefs.set`, then `pointer_gesture` or `press_key`; `ui.wheel` on the control channel). About 32 stored options still do nothing yet (the rest of #394: Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, Construction and Spacing Guides, performance, devices…). + - Preferences that act (#394, in part): Show Tool Tips, Double Click To Isolate, Zoom with Mouse Wheel (the wheel zooms about the pointer, Shift-wheel scrolls up and down, Cmd/Ctrl-wheel sideways; Alt/Option-wheel and a trackpad pinch zoom about the pointer either way), Use Precise Cursors; Selection & Anchor Display › Tolerance (objects, anchors and handles), Object Selection by Path Only, Command Click to Select Objects Behind (cycling down the stack), Zoom to Selection, anchor Size, Highlight anchors on mouse over; Type › Number of Recent Fonts (up to 15); Guides & Grid › guide and grid Color and Style (lines or dots) and Grids In Back. Then Snap to Point (its distance, for moves, drawn points and reference points), Move Locked and Hidden Artwork with Artboard, Enable Rubber Band for the Pen and Curvature tools, Handles style, Show handles when multiple anchors are selected, Hide Corner Widget for angles greater than; General › Transform Pattern Tiles (the transforms' and dialogs' Transform Patterns) and Select Same Tint %; Type › Size/Leading, Tracking and Baseline Shift increments (`type.step`, Cmd+Shift+. and Cmd+Shift+, for the size, the Type tool's Alt+arrows), Enable Missing Glyph Protection and Fill New Type Objects With Placeholder Text. Then Smart Guides › Color, Alignment Guides, Anchor/Path Labels, Measurement Labels, Transform Tools, Object Highlighting (with Smart Guides on) and Snapping Tolerance (4 px by default, for every smart guide snap), then Construction Guides and their Angles (#506: a drawn point near a line at one of those angles through the point it leaves from lands on it). Then Type › Type Object Selection by Path Only (type is picked on the baseline of any of its lines, area type's frame or the path of type on a path, no longer anywhere in its bounds; the Type tools and the Eyedropper still take a click among the characters). Then General › Anti-aliased Artwork (off, the canvas draws the art with hard edges). Then Guides & Grid › Show Pixel Grid (Above 600% Zoom), a line at every document pixel over the art in Pixel Preview, turning with a rotated view as the document grid now does too. Then General › Show The Home Screen When No Documents Are Open (off, closing the last document leaves an empty window; the Home button still opens the screen). Then Units › Numbers Without Units Are Points (on by default: a number typed with no unit into a field in picas is read in points, a typed unit still wins; dimmed unless a unit is Picas). Then User Interface › Auto-Collapse Iconic Panels (off by default: on, a click away from a panel popped out of the icon column puts it away). They reach agents too (`prefs.set`, then `pointer_gesture` or `press_key`; `ui.wheel` on the control channel). About 30 stored options still do nothing yet (the rest of #394: Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, Spacing Guides, performance, devices…). - Dialogs move by dragging their heading (the band down from the top edge, as a title bar), stay on screen and keep where they were moved for the session; the form dialogs' choices are dropdowns (Offset Path's Joins, Average's and Shear's and Reflect's axis), and Offset Path lists Offset, Joins, Miter Limit and previews (#423). - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels, the Control bar and dialogs (preferences too) step with Up/Down, or with the mouse wheel over the focused field (#485: a notch a step; the panel under it then stays put, and an unfocused field leaves the wheel to scrolling) (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once. - Scrubby labels (#400, beyond Illustrator, as in Photoshop): dragging a numeric field's label left or right (the ↔ cursor shows over it) steps the value one unit every 2 points (Shift: ten, Ctrl/Cmd: a tenth; counts stay whole), in the field's unit and within its limits, applied live as the art follows; the whole drag is one undo step and Escape puts the value back. A click on the label focuses the field; the text box itself never scrubs, and a field with no label doesn't. Text labels before a field (Transform, Properties, Control bar, Stroke, Transparency, form rows in dialogs) and the Character and Paragraph panels' icons act as labels. Preferences › General › Scrub Numeric Fields by Dragging (on by default) turns it off. @@ -117,7 +117,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Tools:** - **Selection:** Selection, Direct/Group Selection, Magic Wand, Lasso. A Shift-drag marquee toggles what it reaches: objects with the Selection tool, anchors with Direct and Group Selection (#483); the Lasso adds with Shift and subtracts with Alt. Dragging a path segment with Direct Selection bends it when it's curved (its anchors stay) and moves its two anchors when it's straight, one undo step; the fill, Shift or Alt still pick the whole path (Alt-drag copies it). - **Saved selections:** Select ▸ Save Selection… asks for a name and keeps the selection in the document (saved with the file, undoable, up to 25); each one is listed at the bottom of the Select menu and a click selects its objects again; Edit Selection… lists them to rename or delete, applied together on OK. A file's saved selections are capped and checked against its objects when it opens. Not yet: Update Selection and the Layers panel's saved-selection menu. - - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join. Direction handles dragged with Direct Selection or the Anchor Point tool snap to smart guides, and Shift keeps them at 45° steps from their anchor. + - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join. Direction handles dragged with Direct Selection or the Anchor Point tool snap to smart guides, and Shift keeps them at 45° steps from their anchor. Every point a drawing tool places snaps to Smart Guides through one snapper (#506): the Pen's and Curvature tool's anchors, the Pencil's ends, the shape tools' start and dragged corner or radius (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star, Line Segment, Arc, Spiral, the grids), the Type tool's click and frame, a new artboard's corners. - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes). - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag). @@ -131,7 +131,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, onto the Swatches panel a pattern swatch and onto the Brushes panel an Art brush; a symbol dragged onto the canvas places an instance where it is dropped, and a brush dragged onto a path is applied to it. - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options, and the Pencil, Paintbrush, Smooth, Blob Brush and Eraser tools their Tool Options (Fidelity, fill, the tolerances, the brush size). - **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies) and a dimmed copy of the row under the pointer (dropped on the trash rows are deleted, on New Layer duplicated, as in Illustrator), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets, each with a chip of its colour, or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting. -- **Drawing aids:** Smart Guides and snapping (moving, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles with the Selection or Free Transform tool, Shift and Alt too: the dragged corner or side lands on the other objects' anchors and centres ("anchor", "center") or lines up with their edges and centres (a line and "align"); the Rotate, Scale, Shear and Reflect tools drag from the anchor they grab and snap the pointer the same way, so a corner dragged onto another object's anchor scales exactly onto it, #482; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (#451: they snap as moved guides do, Shift to the ruler's ticks; with the Artboard tool they are artboard guides, which run across their artboard only and move, copy and delete with it, `guide.add {artboard}`) that the Selection, Direct Selection and Group Selection tools then pick and drag (#414: the selected guides highlight and move together, Alt copies them, Shift snaps the dragged one to the ticks, otherwise it snaps to pixels, the grid or the edges, centres (so the sides' midpoints) and anchors of the art and the artboards, or with Smart Guides off Snap to Point pulls it onto anchors; the arrow keys nudge them, Delete deletes them, dragging one back onto its ruler deletes it, Lock Guides and Hide Guides leave them alone; `guide.list`, `guide.select`, `guide.move` and `guide.remove` reach agents), and Draw Normal / Behind / Inside modes. +- **Drawing aids:** Smart Guides and snapping (moving, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles with the Selection or Free Transform tool, Shift and Alt too: the dragged corner or side lands on the other objects' anchors and centres ("anchor", "center") or lines up with their edges and centres (a line and "align"); the Rotate, Scale, Shear and Reflect tools drag from the anchor they grab and snap the pointer the same way, so a corner dragged onto another object's anchor scales exactly onto it, #482; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H; drawn points, #506: hovering shows where the press goes, the point lands on the other objects' anchors, centres and paths ("anchor", "center", "path") or lines up with their anchors, edges and centres ("align"), the Pen's on the path being drawn too, near a construction guide through the anchor before it on that guide (Preferences › Smart Guides › Construction Guides and Angles), and with Shift kept to its 45° step or a square's diagonal it slides along that way into line; the targets are gathered once per document state, from the art in the window, and the anchors, centres and lines near the pointer are found by bisection, so hovering never rescans the document), guides dragged out of the rulers (#451: they snap as moved guides do, Shift to the ruler's ticks; with the Artboard tool they are artboard guides, which run across their artboard only and move, copy and delete with it, `guide.add {artboard}`) that the Selection, Direct Selection and Group Selection tools then pick and drag (#414: the selected guides highlight and move together, Alt copies them, Shift snaps the dragged one to the ticks, otherwise it snaps to pixels, the grid or the edges, centres (so the sides' midpoints) and anchors of the art and the artboards, or with Smart Guides off Snap to Point pulls it onto anchors; the arrow keys nudge them, Delete deletes them, dragging one back onto its ruler deletes it, Lock Guides and Hide Guides leave them alone; `guide.list`, `guide.select`, `guide.move` and `guide.remove` reach agents), and Draw Normal / Behind / Inside modes. - **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard. The Artboards panel highlights that active artboard: clicking a row makes it active (the Artboard tool's too, while it is chosen) as does clicking an artboard with the Artboard tool, double-clicking its number also fits it in the window and double-clicking its name renames it. Duplicate Artboards, or a row dragged onto New Artboard, copies the artboard with its art (#446). Escape leaves Presentation Mode, F from it goes back to Normal Screen Mode, and the screen mode isn't saved with the preferences: the app always starts in Normal Screen Mode with its menus and panels (#472). - **Geometry and effects:** - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected. With anchors selected, the Control bar and the Properties panel also convert them to corner or smooth (`path.convertAnchors`), connect end points (Join) and cut the path at them (`path.cutAtAnchors`, also on the task bar and the context menu): a closed path opens there and an open one becomes one path per piece, each cut leaving one of its two coincident anchors selected so a drag pulls the path apart. @@ -213,12 +213,12 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale) | Image Trace, graphs, image tools | 3 | 70% | graph Design/Column/Marker, Create Object Mosaic, Crop Image polish (an on-canvas crop box), Image Trace View modes (Outlines, Source Image) (Vector Halftone is done) | 6–10 | | Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard presets/rearrange polish (Document Setup, New Document and the rest of the Layers panel are done) | 4–7 | | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 | -| Guides, grids, smart guides, snapping, rulers | 3 | 82% | global/video rulers, smart-guide preference depth, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click), ruler guides as Layers rows with their own lock and hide (#451: Lock Guides locks them all; Make Guides paths are Layers rows already) (dragging existing guides is done, #414; new guides snapping to side midpoints and artboards, and artboard guides, #451) | 3–5 | +| Guides, grids, smart guides, snapping, rulers | 3 | 84% | global/video rulers, Spacing Guides, Smart Guides' angle and distance readouts while drawing, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click), ruler guides as Layers rows with their own lock and hide (#451: Lock Guides locks them all; Make Guides paths are Layers rows already) (dragging existing guides is done, #414; new guides snapping to side midpoints and artboards, and artboard guides, #451; the drawing tools snapping, with Construction Guides, #506) | 2–4 | | File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, EPS checked against more real files (Illustrator 2026 and Inkscape files open as vectors; CorelDRAW, Affinity, LibreOffice, matplotlib and Ghostscript output checked with synthetic programs only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 | | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 | | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 | | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 | -| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, floating panels outside the app window and docked into any group, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done), about 32 Preferences options stored but not yet acted on (#394: Construction and Spacing Guides, Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, performance, devices…) | 14–22 | +| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, floating panels outside the app window and docked into any group, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done), about 30 Preferences options stored but not yet acted on (#394: Spacing Guides, Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, performance, devices…) | 14–22 | | Libraries, Links, Package | 2 | 50% | a local Libraries panel (no cloud by design); Links and Package are done | 5–8 | | **Feature parity** | **103** | **~75%** | | **~210–330** | | Interaction-fidelity pass (side by side with Illustrator: every tool modifier, cursor, dialog, Properties context) | | | | 60–90 | diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index beac971a..71751937 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -634,7 +634,7 @@ impl Default for Prefs { object_highlighting: true, transform_tools_guides: true, construction_guides: true, - construction_angles: s("90° & 45° Angles"), + construction_angles: s(vectorcraft_tools::guides::DEFAULT_CONSTRUCTION_ANGLES), anchor_path_labels: true, measurement_labels: true, spacing_guides: true, @@ -1477,6 +1477,8 @@ mod tests_scalestrokes; #[cfg(test)] mod tests_slices; #[cfg(test)] +mod tests_smartguides; +#[cfg(test)] mod tests_strokegeom; #[cfg(test)] mod tests_strokegradient; diff --git a/crates/engine/src/tests_smartguides.rs b/crates/engine/src/tests_smartguides.rs new file mode 100644 index 00000000..b06b33be --- /dev/null +++ b/crates/engine/src/tests_smartguides.rs @@ -0,0 +1,109 @@ +//! Smart Guides for the drawing tools, driven through the session (#506): where the Rectangle +//! tool's corners and the Pen's anchors land, and the guides they show. + +use serde_json::json; +use vectorcraft_doc::NodeId; +use vectorcraft_geom::{Point, Rect}; +use vectorcraft_tools::{Mods, Overlay, PointerEvent, PointerKind}; + +use super::*; +use crate::tooling::ViewInfo; + +/// An 800 × 600 document with a 100 × 100 square at (100, 100), nothing selected. +fn session() -> Session { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap(); + s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap(); + s.execute("select.none", &json!({})).unwrap(); + s +} + +fn pointer(s: &mut Session, kind: PointerKind, x: f64, y: f64) { + s.pointer(&PointerEvent::new(kind, x, y), ViewInfo::default()).unwrap(); +} + +fn labels(s: &mut Session) -> Vec<(String, Point)> { + s.overlays(ViewInfo::default()).into_iter().filter_map(|o| if let Overlay::Label { text, p, .. } = o { Some((text, p)) } else { None }).collect() +} + +/// The bounds of the object the last gesture made (it is selected). +fn made(s: &Session) -> Rect { + let d = s.doc().unwrap(); + let id: NodeId = d.selection.objects[0]; + d.doc.node(id).unwrap().geometric_bounds().unwrap() +} + +#[test] +fn a_rectangle_corner_lands_on_another_objects_anchor() { + let mut s = session(); + s.select_tool("rectangle", ViewInfo::default()).unwrap(); + // Hovering near the square's corner already says where the press goes. + pointer(&mut s, PointerKind::Move, 302.0, 297.0); + pointer(&mut s, PointerKind::Move, 202.0, 203.0); + assert_eq!(labels(&mut s), [("anchor".to_string(), Point::new(200.0, 200.0))]); + pointer(&mut s, PointerKind::Down, 302.0, 297.0); + pointer(&mut s, PointerKind::Drag, 250.0, 250.0); + pointer(&mut s, PointerKind::Drag, 202.0, 203.0); + assert_eq!(labels(&mut s), [("anchor".to_string(), Point::new(200.0, 200.0))]); + let measure = s.overlays(ViewInfo::default()).into_iter().find_map(|o| if let Overlay::Measure { text, .. } = o { Some(text) } else { None }); + assert!(measure.as_deref().is_some_and(|t| t.starts_with("W: 102") && t.contains("H: 100")), "{measure:?}"); + pointer(&mut s, PointerKind::Up, 202.0, 203.0); + // The start lined up with the artboard's centre (y = 300), the corner on the anchor. + assert_eq!(made(&s), Rect::new(200.0, 200.0, 302.0, 300.0)); +} + +/// The corner being dragged never snaps to the rectangle's own preview: dragged slowly, it follows +/// the pointer instead of sticking where the last step left it. +#[test] +fn a_rectangle_does_not_snap_to_itself_while_drawn() { + let mut s = session(); + s.select_tool("rectangle", ViewInfo::default()).unwrap(); + pointer(&mut s, PointerKind::Down, 320.0, 420.0); + for x in 370..=380 { + pointer(&mut s, PointerKind::Drag, f64::from(x), 470.0 + f64::from(x - 370)); + } + pointer(&mut s, PointerKind::Up, 380.0, 480.0); + assert_eq!(made(&s), Rect::new(320.0, 420.0, 380.0, 480.0)); +} + +#[test] +fn a_pen_anchor_lines_up_with_another_objects_centre() { + let mut s = session(); + s.select_tool("pen", ViewInfo::default()).unwrap(); + pointer(&mut s, PointerKind::Down, 300.0, 420.0); + pointer(&mut s, PointerKind::Up, 300.0, 420.0); + // Hovering: in line with the square's centre (150, 150), the guide running from it. + pointer(&mut s, PointerKind::Move, 151.5, 431.0); + let ov = s.overlays(ViewInfo::default()); + assert!(ov.iter().any(|o| matches!(o, Overlay::Line { a, b, .. } if *a == Point::new(150.0, 150.0) && *b == Point::new(150.0, 431.0))), "{ov:?}"); + assert_eq!(labels(&mut s), [("align".to_string(), Point::new(150.0, 431.0))]); + pointer(&mut s, PointerKind::Down, 151.5, 431.0); + pointer(&mut s, PointerKind::Up, 151.5, 431.0); + // Shift: along the 45° step from it, slid into line with the square's left side (x = 100). + s.pointer(&PointerEvent::new(PointerKind::Down, 103.0, 386.0).with_mods(Mods { shift: true, ..Mods::default() }), ViewInfo::default()).unwrap(); + pointer(&mut s, PointerKind::Up, 103.0, 386.0); + let d = s.doc().unwrap(); + let path = d.doc.node(d.selection.objects[0]).unwrap().path_data().unwrap(); + let pts: Vec = path.subpaths[0].anchors.iter().map(|a| a.p).collect(); + assert_eq!(pts[..2], [Point::new(300.0, 420.0), Point::new(150.0, 431.0)]); + assert!((pts[2] - Point::new(100.0, 381.0)).hypot() < 1e-9, "{pts:?}"); +} + +/// Preferences › Smart Guides › Construction Guides: on (the default), a Pen anchor near the +/// 45° guide through the last one lands on it; off, it stays where it was clicked. +#[test] +fn construction_guides_follow_the_preference() { + for on in [true, false] { + let mut s = session(); + s.execute("prefs.set", &json!({"key": "constructionGuides", "value": on})).unwrap(); + s.select_tool("pen", ViewInfo::default()).unwrap(); + pointer(&mut s, PointerKind::Down, 500.0, 500.0); + pointer(&mut s, PointerKind::Up, 500.0, 500.0); + pointer(&mut s, PointerKind::Down, 561.0, 438.0); + pointer(&mut s, PointerKind::Up, 561.0, 438.0); + let d = s.doc().unwrap(); + let last = d.doc.node(d.selection.objects[0]).unwrap().path_data().unwrap().subpaths[0].anchors[1].p; + let want = if on { Point::new(561.5, 438.5) } else { Point::new(561.0, 438.0) }; + assert!((last - want).hypot() < 1e-9, "{on}: {last:?}"); + } +} diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rs index e093a28f..bd624689 100644 --- a/crates/engine/src/tooling.rs +++ b/crates/engine/src/tooling.rs @@ -178,6 +178,7 @@ impl Session { let (unit, stroke_unit) = (self.general_unit(), self.stroke_unit()); let cx = ToolContext { doc: &st.doc, + revision: (st.uid, st.revision), selection: &st.selection, zoom: view.zoom, isolation: st.isolation, @@ -222,6 +223,11 @@ impl Session { measurement_labels: self.prefs.measurement_labels, transform_tools_guides: self.prefs.transform_tools_guides, snapping_tolerance: self.prefs.snapping_tolerance, + construction_angles: if self.prefs.construction_guides { + vectorcraft_tools::guides::construction_angles(&self.prefs.construction_angles) + } else { + &[] + }, screen: view.screen, plane_widget: self.prefs.perspective_widget.show.then_some(self.prefs.perspective_widget.position), }; diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs index 58e43789..463ad198 100644 --- a/crates/mcp/src/tests.rs +++ b/crates/mcp/src/tests.rs @@ -588,3 +588,30 @@ fn type_preferences_apply_to_agents() { assert_eq!(r["isError"], false, "{r}"); assert_eq!(style(&mut s, 6), (size + 4.0, tracking + 50.0)); } + +/// The drawing tools snap to Smart Guides over MCP as with the mouse (#506): a Rectangle drawn +/// from near another object's corner starts on it, and a Pen anchor placed beside that object's +/// centre lines up with it. +#[test] +fn drawing_gestures_snap_to_smart_guides() { + let mut s = server(); + let r = call(&mut s, 1, "run_command", json!({"command": "file.new", "params": {"width": 800, "height": 600}})); + assert_eq!(r["isError"], false, "{r}"); + let r = call(&mut s, 2, "draw_shape", json!({"shape": "rectangle", "x": 100, "y": 100, "width": 100, "height": 100})); + assert_eq!(r["isError"], false, "{r}"); + let bounds = |s: &mut Server, n: u64, events: Value, tool: &str| { + let r = call(s, n, "pointer_gesture", json!({"tool": tool, "events": events})); + assert_eq!(r["isError"], false, "{r}"); + let id = serde_json::from_str::(&text_of(&r)).unwrap()["selection"][0].clone(); + let doc: Value = serde_json::from_str(&text_of(&call(s, n + 1, "inspect_document", json!({})))).unwrap(); + let made = doc["layers"][0]["children"].as_array().unwrap().iter().find(|c| c["id"] == id).expect("drawn").clone(); + let b = &made["bounds"]; + [&b["x"], &b["y"], &b["width"], &b["height"]].map(|v| v.as_f64().unwrap()) + }; + let events = json!([{"kind": "move", "x": 202, "y": 203}, {"kind": "down", "x": 202, "y": 203}, {"kind": "drag", "x": 330, "y": 341}, {"kind": "up", "x": 330, "y": 341}]); + assert_eq!(bounds(&mut s, 3, events, "rectangle"), [200.0, 200.0, 130.0, 141.0]); + let r = call(&mut s, 5, "run_command", json!({"command": "select.none", "params": {}})); + assert_eq!(r["isError"], false, "{r}"); + let events = json!([{"kind": "down", "x": 300, "y": 420}, {"kind": "up", "x": 300, "y": 420}, {"kind": "move", "x": 151.5, "y": 431}, {"kind": "down", "x": 151.5, "y": 431}, {"kind": "up", "x": 151.5, "y": 431}]); + assert_eq!(bounds(&mut s, 6, events, "pen"), [150.0, 420.0, 150.0, 11.0]); +} diff --git a/crates/tools/src/draw2/curvature.rs b/crates/tools/src/draw2/curvature.rs index 00704558..47085ff9 100644 --- a/crates/tools/src/draw2/curvature.rs +++ b/crates/tools/src/draw2/curvature.rs @@ -3,13 +3,15 @@ //! Each click adds a point and the path curves smoothly through all points. Alt-click or //! double-click a point toggles it between smooth and corner; drag a point to move it; click the //! first point to close; Backspace/Delete removes the last touched point; Esc/Enter ends the path. -//! A rubber band shows the curve to the cursor (Enable Rubber Band for Curvature Tool). +//! A rubber band shows the curve to the cursor (Enable Rubber Band for Curvature Tool). Each point +//! placed or dragged snaps to Smart Guides ([`DrawSnap`]), as the Pen's anchors do. use serde_json::{Value, json}; -use vectorcraft_doc::NodeId; +use vectorcraft_doc::{NodeId, Selection}; use vectorcraft_geom::Point; use super::{FEEDBACK, catmull_rom}; +use crate::guides::{DrawSnap, Leave, Targets}; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; #[derive(Default)] @@ -22,6 +24,7 @@ pub struct CurvatureTool { /// Last touched point (Backspace removes it). current: Option, hover: Option, + snap: DrawSnap, } impl CurvatureTool { @@ -55,6 +58,12 @@ impl CurvatureTool { self.id = None; self.drag = None; self.current = None; + self.snap.clear(); + } + + /// The segment to the next point leaves the last one. + fn leave(&self, cx: &ToolContext) -> Option { + self.pts.last().map(|(p, _)| Leave::segment(cx, *p, false)) } } @@ -73,11 +82,12 @@ impl Tool for CurvatureTool { } match ev.kind { PointerKind::Move => { - self.hover = Some(p); + let from = active.and_then(|_| self.leave(cx)); + self.hover = Some(self.snap.hover(cx, p, active.as_slice(), from.as_ref())); vec![] } PointerKind::Down => { - if active.is_some() { + if let Some(id) = active { if let Some(i) = self.hit_point(cx, p) { self.current = Some(i); if ev.mods.alt { @@ -88,10 +98,15 @@ impl Tool for CurvatureTool { self.closed = true; return vec![Action::Exec("path.curvature".into(), self.params())]; } + // The point dragged and the curve through it move: the rest pull. + let sel = Selection { objects: vec![id], anchors: [(id, [(0, i)].into())].into(), ..Selection::default() }; + self.snap.hold(cx, || Targets::for_anchor_drag(cx.doc, &sel)); self.drag = Some((i, p, false)); return vec![]; } if !self.closed { + let from = self.leave(cx); + let p = self.snap.press(cx, p, &[id], from.as_ref()); self.pts.push((p, ev.mods.alt)); self.current = Some(self.pts.len() - 1); return vec![Action::Exec("path.curvature".into(), self.params())]; @@ -99,6 +114,7 @@ impl Tool for CurvatureTool { } // Start a new path. self.reset(); + let p = self.snap.press(cx, p, &[], None); self.pts.push((p, false)); self.current = Some(0); vec![Action::Exec("path.curvature".into(), self.params()), Action::Notify("created".into())] @@ -113,16 +129,20 @@ impl Tool for CurvatureTool { out.push(Action::Begin("Curvature".into())); self.drag = Some((i, start, true)); } + let p = self.snap.drag(cx, p, None); if let Some(pt) = self.pts.get_mut(i) { pt.0 = p; } out.push(Action::Preview("path.curvature".into(), self.params())); out } - PointerKind::Up => match self.drag.take() { - Some((_, _, true)) => vec![Action::Commit], - _ => vec![], - }, + PointerKind::Up => { + self.snap.clear(); + match self.drag.take() { + Some((_, _, true)) => vec![Action::Commit], + _ => vec![], + } + } PointerKind::DoubleClick => { if active.is_none() { return vec![]; @@ -163,10 +183,10 @@ impl Tool for CurvatureTool { if dragging { vec![Action::Commit] } else { vec![] } } fn overlays(&self, cx: &ToolContext) -> Vec { + let mut o = self.snap.guides().to_vec(); if self.active(cx).is_none() { - return vec![]; + return o; } - let mut o = vec![]; if cx.curvature_rubber_band && !self.closed && self.drag.is_none() @@ -217,4 +237,19 @@ mod tests { let a = t.pointer(&cx2, &PointerEvent::new(PointerKind::Down, 400.0, 400.0)); assert!(matches!(&a[0], Action::Exec(_, v) if v["id"] == id.0 && v["points"].as_array().unwrap().len() == 5)); } + + /// Points snap to Smart Guides (#506): the first lands on another object's anchor and says so. + #[test] + fn points_snap_to_smart_guides() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = cx(&d, &s, &p); + let mut t = CurvatureTool::default(); + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 202.0, 99.0)); + assert!(matches!(&a[0], Action::Exec(_, v) if v["points"][0]["x"] == 200.0 && v["points"][0]["y"] == 100.0), "{a:?}"); + assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "anchor"))); + t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 202.0, 99.0)); + assert!(t.overlays(&cx).is_empty()); + } } diff --git a/crates/tools/src/draw2/family.rs b/crates/tools/src/draw2/family.rs index 36ee103d..5118fa93 100644 --- a/crates/tools/src/draw2/family.rs +++ b/crates/tools/src/draw2/family.rs @@ -1,13 +1,16 @@ //! Line Segment family drag tools: Arc, Spiral, Rectangular Grid and Polar Grid. //! //! Drag draws (Shift = equal axes / square, Alt = from the centre for arc and grids, Space held -//! moves the shape being drawn); a click without dragging asks the UI for the options dialog. +//! moves the shape being drawn); a click without dragging asks the UI for the options dialog. The +//! start point and the dragged corner snap to Smart Guides ([`DrawSnap`]), hovering too. //! While dragging, ↑/↓ change the spiral's segments, the grid rows or the concentric dividers; ←/→ //! change grid columns / radial dividers. use serde_json::{Value, json}; -use vectorcraft_geom::{Point, Rect, Vec2}; +use vectorcraft_geom::Point; +use crate::guides::{DrawSnap, Leave, square}; +use crate::shape::drag_rect; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; pub struct FamilyTool { @@ -24,6 +27,7 @@ pub struct FamilyTool { pub rows: u32, /// Columns / radial dividers. pub columns: u32, + snap: DrawSnap, } impl FamilyTool { @@ -46,6 +50,7 @@ impl FamilyTool { clockwise: true, rows: 5, columns: 5, + snap: DrawSnap::default(), } } @@ -58,13 +63,10 @@ impl FamilyTool { } } - fn rect(start: Point, p: Point, m: Mods) -> Rect { - let mut d = p - start; - if m.shift { - let s = d.x.abs().max(d.y.abs()); - d = Vec2::new(s * d.x.signum(), s * d.y.signum()); - } - if m.alt { Rect::from_points(start - d, start + d) } else { Rect::from_points(start, start + d) } + /// How the dragged point keeps to the start: a spiral's radius goes anywhere, the arc's and + /// the grids' corner keeps to a diagonal with Shift. + fn leave(&self, start: Point, m: Mods) -> Option { + (self.id != "spiral").then(|| Leave::diagonal(start, m.shift)) } /// The command for a drag from `start` to `p`. @@ -78,25 +80,21 @@ impl FamilyTool { ) } "rectangularGrid" => { - let r = Self::rect(start, p, m); + let r = drag_rect(start, p, m); ( "shape.rectangularGrid".into(), json!({"x": r.x0, "y": r.y0, "width": r.width(), "height": r.height(), "rows": self.rows, "columns": self.columns}), ) } "polarGrid" => { - let r = Self::rect(start, p, m); + let r = drag_rect(start, p, m); ( "shape.polarGrid".into(), json!({"x": r.x0, "y": r.y0, "width": r.width(), "height": r.height(), "concentric": self.rows, "radial": self.columns}), ) } _ => { - let mut d = p - start; - if m.shift { - let s = d.x.abs().max(d.y.abs()); - d = Vec2::new(s * d.x.signum(), s * d.y.signum()); - } + let d = if m.shift { square(p - start) } else { p - start }; let (a, b) = if m.alt { (start - d, start + d) } else { (start, start + d) }; ("shape.arc".into(), json!({"x1": a.x, "y1": a.y, "x2": b.x, "y2": b.y, "closed": self.closed})) } @@ -113,8 +111,12 @@ impl Tool for FamilyTool { } fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec { match ev.kind { + PointerKind::Move => { + self.snap.hover(cx, ev.pos, &[], None); + vec![] + } PointerKind::Down => { - let (p, _) = crate::guides::snap_draw(cx, ev.pos, &[]); + let p = self.snap.press(cx, ev.pos, &[], None); self.start = Some(p); self.last = p; self.began = false; @@ -122,6 +124,8 @@ impl Tool for FamilyTool { } PointerKind::Drag => { let Some(mut s) = self.start else { return vec![] }; + let pos = self.snap.drag(cx, ev.pos, self.leave(s, ev.mods).as_ref()); + let ev = &PointerEvent { pos, ..*ev }; crate::shape::space_moves(&mut s, &mut self.last, ev, self.began); self.start = Some(s); self.mods = ev.mods; @@ -139,6 +143,7 @@ impl Tool for FamilyTool { } PointerKind::Up => { let Some(s) = self.start.take() else { return vec![] }; + self.snap.clear(); if std::mem::take(&mut self.began) { vec![Action::Commit] } else { vec![Action::Dialog(self.id.into(), json!({"x": s.x, "y": s.y}))] } } _ => vec![], @@ -179,19 +184,21 @@ impl Tool for FamilyTool { } else if key == ToolKey::Escape { self.start = None; self.began = false; + self.snap.clear(); vec![Action::Cancel] } else { vec![] } } fn overlays(&self, cx: &ToolContext) -> Vec { - match self.start { - Some(s) if self.began && cx.measurement_labels => { - let d = self.last - s; - vec![Overlay::Measure { p: self.last, text: cx.size_label(d.x.abs(), d.y.abs()) }] - } - _ => vec![], + let mut o = self.snap.guides().to_vec(); + if let Some(s) = self.start.filter(|_| self.began && cx.measurement_labels) { + // The size as drawn (from the centre with Alt, square with Shift). + let r = drag_rect(s, self.last, self.mods); + let (w, h) = if self.id == "spiral" { ((self.last - s).x.abs(), (self.last - s).y.abs()) } else { (r.width(), r.height()) }; + o.push(Overlay::Measure { p: self.last, text: cx.size_label(w, h) }); } + o } fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor { Cursor::Crosshair @@ -267,4 +274,23 @@ mod tests { assert_eq!(c, "shape.arc"); assert_eq!(v, json!({"x1": 0.0, "y1": 0.0, "x2": 10.0, "y2": 10.0, "closed": false})); } + + /// The start and the dragged corner snap to Smart Guides (#506), Shift sliding the corner of + /// a square grid along its diagonal into line. + #[test] + fn corners_snap_to_smart_guides() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = cx(&d, &s, &p); + let mut t = FamilyTool::new("rectangularGrid"); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 202.0, 99.0)); + let shift = Mods { shift: true, ..Mods::default() }; + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 255.0, 147.0).with_mods(shift)); + assert!( + matches!(&a[..], [Action::Begin(_), Action::Preview(_, v)] if v["x"] == 200.0 && v["y"] == 100.0 && v["width"] == 50.0 && v["height"] == 50.0), + "{a:?}" + ); + assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "align"))); + } } diff --git a/crates/tools/src/draw2/gesture.rs b/crates/tools/src/draw2/gesture.rs index 7df2dd9b..429a1d4c 100644 --- a/crates/tools/src/draw2/gesture.rs +++ b/crates/tools/src/draw2/gesture.rs @@ -3,14 +3,17 @@ //! //! Pencil and Paintbrush preview the fitted path live (`path.freehand` re-applied on the snapshot) //! and commit on release; Alt on release (or ending near the start) closes the path, and starting -//! near an end of a selected open path continues it. The other tools collect the drag polyline -//! (shown as an overlay) and run one command on release. +//! near an end of a selected open path continues it. The Pencil's new path starts and ends on +//! Smart Guides ([`DrawSnap`]: an anchor, a path, in line with the art), hovering too; the points +//! between follow the hand. The other tools collect the drag polyline (shown as an overlay) and run +//! one command on release. use serde_json::{Value, json}; use vectorcraft_doc::NodeId; use vectorcraft_geom::Point; use super::{FEEDBACK, points_json, polyline}; +use crate::guides::DrawSnap; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; pub struct GestureTool { @@ -30,6 +33,8 @@ pub struct GestureTool { pub edit_within: f64, /// "Close paths when ends are within N pixels". pub close_within: f64, + /// Smart Guides for the Pencil's ends. + snap: DrawSnap, } impl GestureTool { @@ -56,9 +61,15 @@ impl GestureTool { fill: false, edit_within: 12.0, close_within: 15.0, + snap: DrawSnap::default(), } } + /// Do the ends of its strokes snap (the Pencil)? + fn snaps(&self) -> bool { + self.id == "pencil" + } + fn draws_path(&self) -> bool { matches!(self.id, "pencil" | "paintbrush") } @@ -147,17 +158,27 @@ impl Tool for GestureTool { fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec { let p = ev.pos; match ev.kind { + PointerKind::Move if self.snaps() => { + self.snap.hover(cx, p, &[], None); + vec![] + } PointerKind::Down => { - self.points = vec![p]; self.active = true; self.began = false; self.extend = if self.draws_path() { self.find_extend(cx, p) } else { None }; + // A path continued starts at its end; a new one where it snaps. + let start = if self.snaps() && self.extend.is_none() { self.snap.press(cx, p, &[], None) } else { p }; + self.points = vec![start]; vec![] } PointerKind::Drag => { if !self.active { return vec![]; } + if self.snaps() { + // Where the stroke would end: shown, taken on release. + self.snap.drag(cx, p, None); + } if self.points.last().is_some_and(|l| l.distance(p) < cx.tol(1.0)) { return vec![]; } @@ -177,8 +198,16 @@ impl Tool for GestureTool { if !self.active { return vec![]; } + let end = if self.snaps() { self.snap.drag(cx, p, None) } else { p }; + self.snap.clear(); if self.points.last().is_some_and(|l| l.distance(p) >= cx.tol(1.0)) { - self.points.push(p); + self.points.push(end); + } else if self.snaps() + && self.points.len() > 1 + && let Some(last) = self.points.last_mut() + { + // The last step was where the button went up: it moves where that snaps. + *last = end; } let out = self.finish(cx, ev.mods); self.active = false; @@ -194,6 +223,7 @@ impl Tool for GestureTool { match key { ToolKey::Escape if self.active => { let began = self.began; + self.snap.clear(); self.active = false; self.began = false; self.points.clear(); @@ -212,21 +242,24 @@ impl Tool for GestureTool { } fn deactivate(&mut self, _cx: &ToolContext) -> Vec { let began = self.began; + self.snap.clear(); self.active = false; self.began = false; self.points.clear(); if began { vec![Action::Commit] } else { vec![] } } fn overlays(&self, cx: &ToolContext) -> Vec { + let mut o = self.snap.guides().to_vec(); if !self.active || self.points.len() < 2 || self.began { - return vec![]; + return o; } let width = match self.id { "blobBrush" | "eraser" => (self.size * cx.zoom) as f32, _ => 1.0, }; let color = if self.id == "eraser" { [0x80, 0x80, 0x80] } else { FEEDBACK }; - vec![Overlay::Path { path: polyline(&self.points), color, width, dashed: self.id == "knife" }] + o.push(Overlay::Path { path: polyline(&self.points), color, width, dashed: self.id == "knife" }); + o } fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor { Cursor::Crosshair @@ -269,6 +302,25 @@ mod tests { v } + /// The Pencil's new path starts and ends on Smart Guides (#506), the points between where + /// the hand went. + #[test] + fn pencil_ends_snap_to_smart_guides() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = cx(&d, &s, &p); + let mut t = GestureTool::new("pencil"); + let acts = drag(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0), (250.0, 320.0), (198.0, 203.0)], Mods::default()); + let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") }; + assert_eq!(v["points"], json!([[100.0, 100.0], [151.0, 300.0], [250.0, 320.0], [200.0, 200.0]])); + // The Paintbrush follows the hand all the way. + let mut t = GestureTool::new("paintbrush"); + let acts = drag(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0)], Mods::default()); + let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") }; + assert_eq!(v["points"][0], json!([102.0, 98.0])); + } + #[test] fn pencil_previews_and_commits() { let (d, _) = doc_with_rect(); diff --git a/crates/tools/src/guides.rs b/crates/tools/src/guides.rs index 778eccb7..d6f1e7ef 100644 --- a/crates/tools/src/guides.rs +++ b/crates/tools/src/guides.rs @@ -1,15 +1,23 @@ -//! Smart Guides: snapping to anchors, path segments (for dragged anchors), object bounds -//! (edges/centres), artboards, with the magenta construction lines and labels Illustrator users -//! expect. Preferences › Smart Guides sets their colour, which of them show ([`GuideStyle`]) and -//! how near a target pulls (`ToolContext::snapping_tolerance`). +//! Smart Guides: snapping to anchors, path segments (for dragged anchors and drawn points), object +//! bounds (edges/centres), artboards, with the magenta construction lines and labels Illustrator +//! users expect. Preferences › Smart Guides sets their colour, which of them show ([`GuideStyle`]), +//! how near a target pulls (`ToolContext::snapping_tolerance`) and the angles of the construction +//! guides drawn points land on (`ToolContext::construction_angles`). +//! +//! The drawing tools (Pen, Curvature, Pencil, the shape tools, Type, Artboard) all snap the points +//! they place through one [`DrawSnap`]: their targets are gathered once per document state, sorted, +//! and each pointer move looks up the few near the pointer by bisection. + +use std::collections::HashSet; +use std::sync::Arc; use vectorcraft_doc::hit::{HitOptions, hit_test}; -use vectorcraft_doc::{Document, NodeId, NodeKind, OrientedBox, Selection}; +use vectorcraft_doc::{Document, Node, NodeId, NodeKind, OrientedBox, Selection}; use vectorcraft_geom::kurbo::ParamCurveNearest; -use vectorcraft_geom::{Affine, Line, ParamCurve, PathSeg, Point, Rect, SubPath, Vec2}; +use vectorcraft_geom::{Affine, Line, ParamCurve, PathSeg, Point, Rect, SubPath, Vec2, constrain_angle_from}; use crate::bbox::Handle; -use crate::{Overlay, ToolContext}; +use crate::{Overlay, ScreenFrame, ToolContext}; pub const MAGENTA: [u8; 3] = [0xff, 0x3d, 0xfc]; @@ -102,9 +110,93 @@ impl Ruler { /// How many anchors, and how many segments, the targets gather at most. const BUDGET: usize = 20_000; +/// What [`Targets::collect_inner`] gathers from each path besides its anchors and bounds. +#[derive(Clone, Copy, PartialEq)] +enum Gather { + /// Nothing more: a moved or resized selection lines up with bounds. + Bounds, + /// Its segments, which a dragged anchor lands on. + Segments, + /// Its segments, and its anchors as lines too: a drawn point lines up with them. + Drawing, +} + +/// The entries of `sorted` (ascending by `key`) whose key is within `tol` of `v`, found by +/// bisection. +fn within(sorted: &[T], key: impl Fn(&T) -> f64, v: f64, tol: f64) -> &[T] { + let lo = sorted.partition_point(|e| key(e) < v - tol); + let hi = sorted.partition_point(|e| key(e) <= v + tol); + sorted.get(lo..hi).unwrap_or_default() +} + +/// Visit `nodes` and everything inside them, but the nodes in `skip` and everything inside those: +/// one pass, however many are skipped. +fn walk_but<'a>(nodes: &'a [Arc], skip: &HashSet, f: &mut impl FnMut(&'a Node)) { + for n in nodes.iter().filter(|n| !skip.contains(&n.id)) { + f(n); + if let Some(ch) = n.children() { + walk_but(ch, skip, f); + } + } +} + +/// The lines of `lines` (sorted by where they run) within `tol` of `v`. +fn lines_near(lines: &[(f64, Point, Kind)], v: f64, tol: f64) -> &[(f64, Point, Kind)] { + within(lines, |l| l.0, v, tol) +} + impl Targets { pub fn collect(doc: &Document, exclude: &[NodeId], visible: Option) -> Self { - Self::collect_inner(doc, exclude, None, visible, false) + Self::collect_inner(doc, exclude, None, visible, Gather::Bounds) + } + + /// Targets for a drawn point: the art in `visible` (all of it for None) but `exclude`, its + /// anchors, centres, edges and path segments, its anchors in line too. The anchors and + /// segments of `exclude` (the path being drawn, whose bounds grow with it) stay targets. + pub fn for_drawing(doc: &Document, exclude: &[NodeId], visible: Option) -> Self { + let mut t = Self::collect_inner(doc, exclude, None, visible, Gather::Drawing); + t.push_paths(doc, exclude, true); + t.index() + } + + /// Targets for a dragged direction handle of path `id`: the other art, and the anchors of `id` + /// (its bounds and the segments through the handle move with it, so they would chase it). + pub fn for_handle(doc: &Document, id: NodeId) -> Self { + let mut t = Self::collect_inner(doc, &[id], None, None, Gather::Bounds); + t.push_paths(doc, &[id], false); + t.index() + } + + /// The anchors of the paths `ids` as targets, on them and in line, and their segments too + /// when `segments`: at most [`BUDGET`] of each. + fn push_paths(&mut self, doc: &Document, ids: &[NodeId], segments: bool) { + let (mut anchors, mut segment_budget) = (BUDGET, if segments { BUDGET } else { 0 }); + for path in ids.iter().filter_map(|id| doc.node(*id)?.path_data()) { + for sp in &path.subpaths { + for a in sp.anchors.iter().take(anchors) { + self.push_anchor(a.p); + anchors -= 1; + } + self.push_segments(sp, |_| false, &mut segment_budget); + } + } + } + + /// Sort the targets so that [`within`] finds those near a point by bisection: the anchors + /// and centres by x, the lines by where they run. Every constructor ends with it (the sort + /// is stable: of targets alike, the first gathered still wins). + fn index(mut self) -> Self { + self.points.sort_by(|a, b| a.0.x.total_cmp(&b.0.x)); + self.xs.sort_by(|a, b| a.0.total_cmp(&b.0)); + self.ys.sort_by(|a, b| a.0.total_cmp(&b.0)); + self + } + + /// Anchor `a` as a target: a point lands on it and lines up with it. + fn push_anchor(&mut self, a: Point) { + self.points.push((a, Kind::Anchor)); + self.xs.push((a.x, a, Kind::Anchor)); + self.ys.push((a.y, a, Kind::Anchor)); } /// The same targets drawing their guides as the Smart Guides preferences in `cx` ask @@ -127,29 +219,27 @@ impl Targets { /// Targets for dragging artboard `index`: everything except that artboard and `exclude` (the /// art that moves along with it). pub fn for_artboard(doc: &Document, index: usize, exclude: &[NodeId]) -> Self { - Self::collect_inner(doc, exclude, Some(index), None, false) + Self::collect_inner(doc, exclude, Some(index), None, Gather::Bounds) } /// Targets for dragging the direct-selected anchors of `sel` (and its objects selected as a /// whole): the other art, its path segments too, and the anchors and segments that stay put on /// the paths being reshaped (their bounds move along, so they are no targets). pub fn for_anchor_drag(doc: &Document, sel: &Selection) -> Self { - let mut t = Self::collect_inner(doc, &sel.objects, None, None, true); + let mut t = Self::collect_inner(doc, &sel.objects, None, None, Gather::Segments); let (mut anchors, mut segments) = (BUDGET, BUDGET); for (id, set) in &sel.anchors { let Some(path) = doc.node(*id).and_then(|n| n.path_data()) else { continue }; for (si, sp) in path.subpaths.iter().enumerate() { let moving = |ai: usize| set.contains(&(si, ai)); for a in sp.anchors.iter().enumerate().filter(|(ai, _)| !moving(*ai)).map(|(_, a)| a.p).take(anchors) { - t.points.push((a, Kind::Anchor)); - t.xs.push((a.x, a, Kind::Anchor)); - t.ys.push((a.y, a, Kind::Anchor)); + t.push_anchor(a); anchors -= 1; } t.push_segments(sp, moving, &mut segments); } } - t + t.index() } /// The segments of `sp` that stay put while the anchors `moving` accepts move, as targets, at @@ -171,9 +261,8 @@ impl Targets { } } - fn collect_inner(doc: &Document, exclude: &[NodeId], skip_artboard: Option, visible: Option, segments: bool) -> Self { + fn collect_inner(doc: &Document, exclude: &[NodeId], skip_artboard: Option, visible: Option, gather: Gather) -> Self { let mut t = Targets::default(); - let excluded = |id: NodeId| exclude.iter().any(|e| doc.ancestry(id).is_some_and(|a| a.contains(e))); let add_rect = |t: &mut Targets, r: Rect, kind: Kind| { let c = r.center(); for p in [Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)] { @@ -194,8 +283,8 @@ impl Targets { } } let (mut budget, mut segment_budget) = (BUDGET, BUDGET); - doc.walk(|n| { - if budget == 0 || n.is_container() || !n.visible || excluded(n.id) { + walk_but(&doc.layers, &exclude.iter().copied().collect(), &mut |n| { + if budget == 0 || n.is_container() || !n.visible { return; } let Some(b) = n.geometric_bounds() else { return }; @@ -207,10 +296,14 @@ impl Targets { } if let NodeKind::Path { path, .. } = &n.kind { for (_, _, a) in path.anchors() { - t.points.push((a.p, Kind::Anchor)); + if gather == Gather::Drawing { + t.push_anchor(a.p); + } else { + t.points.push((a.p, Kind::Anchor)); + } budget = budget.saturating_sub(1); } - if segments { + if gather != Gather::Bounds { for sp in &path.subpaths { t.push_segments(sp, |_| false, &mut segment_budget); } @@ -218,7 +311,7 @@ impl Targets { } add_rect(&mut t, b, Kind::Edge); }); - t + t.index() } /// Only these targets' anchors pull (View → Snap to Point). @@ -265,25 +358,55 @@ impl Targets { t.points.push((b.center(), Kind::Center)); }); } - t + t.index() } /// Snap a single point: onto the nearest anchor or centre, else onto the nearest segment, else /// into line with targets. Returns the snapped point and guide overlays. pub fn snap_point(&self, p: Point, tol: f64) -> (Point, Vec) { + self.snap_from(p, None, tol) + } + + /// Snap a drawn point `p` as [`Self::snap_point`] does, and when it leaves `from` (the anchor + /// before it, a shape's start): with Shift held it keeps to its angles round it, sliding along + /// that way into line with the nearest target; else, before lining up, it lands on a + /// construction guide through it, where a target's line crosses the guide if one does nearby. + pub fn snap_from(&self, p: Point, from: Option<&Leave>, tol: f64) -> (Point, Vec) { + if let Some(f) = from + && let Some(q) = f.constrained(p) + { + return match self.slide(f.at, q - f.at, q, tol, true) { + Some((q, target)) => (q, self.lined_up(q, target)), + None => (q, vec![]), + }; + } if let Some((q, k)) = self.nearest_point(p, tol) { return (q, self.label(q, k.label()).into_iter().collect()); } if let Some(q) = self.on_segment(p, tol) { return (q, self.label(q, Kind::Edge.label()).into_iter().collect()); } + if let Some(f) = from + && let Some((dir, q)) = f.construction(p, tol) + { + let construction = |q: Point| Overlay::Line { a: f.at, b: q, color: self.style.color, dashed: false }; + return match self.slide(f.at, dir, q, tol, false) { + Some((q, target)) => (q, std::iter::once(construction(q)).chain(self.lined_up(q, target)).collect()), + None => (q, vec![construction(q)]), + }; + } let mut out = p; let mut ov = vec![]; // The targets' lines along one axis and the ruler guides running past `p`, the nearest // within reach of `v`. let nearest = |lines: &[(f64, Point, Kind)], vertical: bool, v: f64| { let rulers = self.rulers.iter().filter(|r| r.vertical == vertical).filter_map(|r| r.line_at(p, tol)); - lines.iter().copied().chain(rulers).filter(|(t, ..)| (t - v).abs() <= tol).min_by(|a, b| (a.0 - v).abs().total_cmp(&(b.0 - v).abs())) + lines_near(lines, v, tol) + .iter() + .copied() + .chain(rulers) + .filter(|(t, ..)| (t - v).abs() <= tol) + .min_by(|a, b| (a.0 - v).abs().total_cmp(&(b.0 - v).abs())) }; let mut aligned = false; if let Some((x, from, _)) = nearest(&self.xs, true, p.x) { @@ -304,7 +427,47 @@ impl Targets { /// The anchor or centre nearest `p`, within `tol`. fn nearest_point(&self, p: Point, tol: f64) -> Option<(Point, Kind)> { - self.points.iter().copied().filter(|(q, _)| q.distance(p) <= tol).min_by(|a, b| a.0.distance(p).total_cmp(&b.0.distance(p))) + within(&self.points, |q| q.0.x, p.x, tol) + .iter() + .copied() + .filter(|(q, _)| q.distance(p) <= tol) + .min_by(|a, b| a.0.distance(p).total_cmp(&b.0.distance(p))) + } + + /// Slide `q`, on the line through `at` along `dir` (beyond `at` only, for a `ray`), to where + /// the nearest target line crosses it, at most twice `tol` away: where it lands and the + /// target's own point (where its line starts). + fn slide(&self, at: Point, dir: Vec2, q: Point, tol: f64, ray: bool) -> Option<(Point, Point)> { + if !dir.hypot2().is_finite() || dir.hypot2() <= 1e-18 { + return None; + } + let reach = 2.0 * tol; + let mut best: Option<(f64, Point, Point)> = None; + for (vertical, lines, d, a, v) in [(true, &self.xs, dir.x, at.x, q.x), (false, &self.ys, dir.y, at.y, q.y)] { + if d.abs() <= 1e-9 { + continue; + } + // A line that far across the way crosses it at least that far along. + for (t, from, _) in lines_near(lines, v, reach) { + let s = (t - a) / d; + // Exactly on the line, whatever the rounding along the way. + let hit = if vertical { Point::new(*t, at.y + dir.y * s) } else { Point::new(at.x + dir.x * s, *t) }; + let moved = hit.distance(q); + if moved <= reach && (!ray || s > 0.0) && best.is_none_or(|b| moved < b.0) { + best = Some((moved, hit, *from)); + } + } + } + best.map(|(_, hit, from)| (hit, from)) + } + + /// The guides of a point `q` slid into line with the target at `from`: the line from it and + /// "align", or the target's own label when `q` sits right on it. + fn lined_up(&self, q: Point, from: Point) -> Vec { + if let Some((on, k)) = self.nearest_point(q, 1e-9) { + return self.label(on, k.label()).into_iter().collect(); + } + self.line(from, q).into_iter().chain(self.label(q, "align")).collect() } /// The nearest point within `tol` of `p` on a target segment. @@ -323,7 +486,7 @@ impl Targets { pub fn snap_guide(&self, vertical: bool, v: f64, tol: f64) -> (f64, Vec) { let along = |q: &Point| if vertical { q.x } else { q.y }; let lines = if vertical { &self.xs } else { &self.ys }; - let best = lines + let best = lines_near(lines, v, tol) .iter() .map(|(t, from, k)| (*t, *from, *k)) .chain(self.points.iter().map(|(q, k)| (along(q), *q, *k))) @@ -370,7 +533,7 @@ impl Targets { rects .iter() .flat_map(|r| along(r).into_iter().map(move |v| (v, *r))) - .flat_map(|(v, r)| targets.iter().map(move |(t, from, _)| (t - v, *from, v, r))) + .flat_map(|(v, r)| lines_near(targets, v, tol).iter().map(move |(t, from, _)| (t - v, *from, v, r))) .filter(|(d, ..)| d.abs() <= tol) .min_by(|a, b| a.0.abs().total_cmp(&b.0.abs())) }; @@ -410,7 +573,11 @@ impl Targets { // A scale that collapses or flips the box is no snap. let valid = |n: f64, s: f64| n.is_finite() && n * s > 0.0; let nearest = |v: f64, ts: &[(f64, Point, Kind)]| -> Hit { - ts.iter().map(|(t, from, _)| (*t, *from)).filter(|(t, _)| (t - v).abs() <= tol).min_by(|p, q| (p.0 - v).abs().total_cmp(&(q.0 - v).abs())) + lines_near(ts, v, tol) + .iter() + .map(|(t, from, _)| (*t, *from)) + .filter(|(t, _)| (t - v).abs() <= tol) + .min_by(|p, q| (p.0 - v).abs().total_cmp(&(q.0 - v).abs())) }; let (mut nx, mut ny) = (sx, sy); let mut snap: Snap = (None, None, None); @@ -540,24 +707,225 @@ impl PointSnap { /// Where `p` goes, and the guides showing why. pub fn snap(&self, cx: &ToolContext, p: Point) -> (Point, Vec) { + self.snap_from(cx, p, None) + } + + /// Where a drawn point `p` leaving `from` goes ([`Targets::snap_from`]), and the guides + /// showing why. Pixels and the grid round it before Shift turns it onto its angle. + pub fn snap_from(&self, cx: &ToolContext, p: Point, from: Option<&Leave>) -> (Point, Vec) { + let keep = |q: Point| from.and_then(|f| f.constrained(q)).unwrap_or(q); if cx.snap_to_pixel { - return (Point::new(p.x.round(), p.y.round()), vec![]); + return (keep(Point::new(p.x.round(), p.y.round())), vec![]); } if cx.snap_to_grid { - return (vectorcraft_geom::snap::snap_point_to_grid(p, cx.grid_step()), vec![]); + return (keep(vectorcraft_geom::snap::snap_point_to_grid(p, cx.grid_step())), vec![]); } match &self.targets { - Some((t, tol)) => t.snap_point(p, cx.tol(*tol)), - None => (p, vec![]), + Some((t, tol)) => t.snap_from(p, from, cx.tol(*tol)), + None => (keep(p), vec![]), } } } -/// Snapping for a dragged direction handle: Shift keeps it at 45° steps round its anchor, else it -/// snaps as a drawn point does. The targets are gathered on the first move that needs them and -/// kept for the rest of the drag (gathering them takes as long as the document is big). +/// The Construction Guides angle set new preferences start with. +pub const DEFAULT_CONSTRUCTION_ANGLES: &str = "90° & 45° Angles"; + +/// The angles (degrees) of the construction guides of a Smart Guides › Angles set: "90°" gives the +/// horizontal and the vertical, "45°" the diagonals, "60°" and "30°" their multiples between those. +pub fn construction_angles(set: &str) -> &'static [f64] { + match set { + "30° Angles" => &[30.0, 60.0, 120.0, 150.0], + "45° Angles" => &[45.0, 135.0], + "60° Angles" => &[60.0, 120.0], + "90° Angles" => &[0.0, 90.0], + "90° & 45° & 30° Angles" => &[0.0, 30.0, 45.0, 60.0, 90.0, 120.0, 135.0, 150.0], + _ => &[0.0, 45.0, 90.0, 135.0], + } +} + +/// How Shift keeps a drawn point to the point it leaves from. +#[derive(Clone, Copy, Debug, PartialEq)] +enum Keep { + /// At steps of `step` degrees counted from `base` (a segment). + Angle { step: f64, base: f64 }, + /// On a diagonal, as far along as the pointer's farther axis (a square's corner). + Square, +} + +/// The point a drawn point leaves from (the anchor before it, a shape's start) and how it keeps +/// to it: with Shift held at fixed angles round it, and onto the construction guides through it +/// (Smart Guides › Construction Guides). +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Leave { + pub at: Point, + /// Shift held: how the point keeps to `at`. + shift: Option, + /// The angles of the construction guides through `at` (none with them off). + angles: &'static [f64], +} + +impl Leave { + /// A segment from `at` (Pen, Curvature, Line Segment): Shift keeps it at 45° steps from + /// General › Constrain Angle; with Smart Guides on it lands on the construction guides. + pub fn segment(cx: &ToolContext, at: Point, shift: bool) -> Self { + Self { + at, + shift: shift.then_some(Keep::Angle { step: 45.0, base: cx.constrain_angle }), + angles: if cx.smart_guides { cx.construction_angles } else { &[] }, + } + } + + /// A box dragged from its corner or centre `at` (Rectangle, Ellipse, Arc, the grids, + /// Artboard): Shift keeps the dragged corner on a diagonal, the box a square. + pub fn diagonal(at: Point, shift: bool) -> Self { + Self { at, shift: shift.then_some(Keep::Square), angles: &[] } + } + + /// Where Shift puts `p`: none without it. + fn constrained(&self, p: Point) -> Option { + let v = p - self.at; + Some(match self.shift? { + Keep::Angle { step, base } => self.at + constrain_angle_from(v, step, base), + Keep::Square => self.at + square(v), + }) + } + + /// The construction guide through `at` nearest `p`, within `tol` of it (and `p` farther than + /// that from `at`, where every guide meets): its direction and where `p` lands on it. + fn construction(&self, p: Point, tol: f64) -> Option<(Vec2, Point)> { + let v = p - self.at; + if v.hypot() <= tol { + return None; + } + self.angles + .iter() + // Counter-clockwise as seen on the y-down page. + .map(|a| Vec2::new(a.to_radians().cos(), -a.to_radians().sin())) + .map(|d| (d, self.at + d * v.dot(d))) + .map(|(d, q)| (d, q, q.distance(p))) + .filter(|(.., dist)| *dist <= tol) + .min_by(|a, b| a.2.total_cmp(&b.2)) + .map(|(d, q, _)| (d, q)) + } +} + +/// `d` made square: as long on both axes as on its longer one, each keeping its sign. +pub fn square(d: Vec2) -> Vec2 { + let s = d.x.abs().max(d.y.abs()); + Vec2::new(s * d.x.signum(), s * d.y.signum()) +} + +/// Smart Guides for the points a drawing tool places: the Pen's and Curvature tool's anchors, +/// the Pencil's ends, the shape tools' start and dragged corner, the Type tool's click and the +/// Artboard tool's new artboard. Each such tool keeps one and asks it for every point, hovering +/// too, so they all snap alike, and shows its [`Self::guides`]. +/// +/// The targets ([`Targets::for_drawing`], the art in the window) are gathered once per document +/// state: hovering gathers them again only after the document, the selection, what is left out, +/// the window or the snapping options changed; a press always gathers them afresh, and the drag +/// it starts keeps them, the document then showing the drag's own previews. #[derive(Default)] -pub struct HandleSnap(Option); +pub struct DrawSnap { + /// The targets, and what they were gathered for (none: for one drag only). + targets: Option<(Option, PointSnap)>, + guides: Vec, +} + +/// What a [`DrawSnap`]'s targets were gathered for: the document state, the art left out, the +/// window and every option [`PointSnap::new`] reads. +#[derive(PartialEq)] +struct SnapKey { + revision: (u64, u64), + exclude: Vec, + screen: Option, + view: [bool; 5], + style: GuideStyle, + tolerances: [f64; 2], +} + +impl SnapKey { + fn of(cx: &ToolContext, exclude: &[NodeId]) -> Self { + Self { + revision: cx.revision, + exclude: exclude.to_vec(), + screen: cx.screen, + view: [cx.smart_guides, cx.snap_to_point, cx.snap_to_pixel, cx.snap_to_grid, cx.guides], + style: GuideStyle::of(cx), + tolerances: [cx.snapping_tolerance, cx.snap_tolerance], + } + } +} + +/// The part of the document the window shows (none headless: all of it). +fn visible(cx: &ToolContext) -> Option { + let s = cx.screen?; + let (w, h) = s.size; + Some(Rect::from_points(s.at(0.0, 0.0), s.at(w, h)).union_pt(s.at(w, 0.0)).union_pt(s.at(0.0, h))) +} + +impl DrawSnap { + /// Snap the pointer hovering at `p` (the art but `exclude` as targets, the anchors of + /// `exclude` still pulling), reusing the targets while nothing they depend on changed. + pub fn hover(&mut self, cx: &ToolContext, p: Point, exclude: &[NodeId], from: Option<&Leave>) -> Point { + let key = SnapKey::of(cx, exclude); + if self.targets.as_ref().is_none_or(|(k, _)| k.as_ref() != Some(&key)) { + self.gather(cx, key); + } + self.snap(cx, p, from) + } + + /// Snap the point pressed at `p`, the targets gathered afresh: the drag that follows keeps + /// them ([`Self::drag`]). + pub fn press(&mut self, cx: &ToolContext, p: Point, exclude: &[NodeId], from: Option<&Leave>) -> Point { + self.gather(cx, SnapKey::of(cx, exclude)); + self.snap(cx, p, from) + } + + /// Gather `targets` other than the art for the drag a press starts (a point being dragged + /// leaves itself out); the next hover gathers its own again. + pub fn hold(&mut self, cx: &ToolContext, targets: impl FnOnce() -> Targets) { + self.targets = Some((None, PointSnap::new(cx, targets))); + self.guides.clear(); + } + + /// Snap `p`, dragged since the press, with the targets the press gathered. + pub fn drag(&mut self, cx: &ToolContext, p: Point, from: Option<&Leave>) -> Point { + if self.targets.is_none() { + self.gather(cx, SnapKey::of(cx, &[])); + } + self.snap(cx, p, from) + } + + /// The guides of the last snap. + pub fn guides(&self) -> &[Overlay] { + &self.guides + } + + /// Hide the guides (the gesture ended). + pub fn clear(&mut self) { + self.guides.clear(); + } + + fn gather(&mut self, cx: &ToolContext, key: SnapKey) { + let snap = PointSnap::new(cx, || Targets::for_drawing(cx.doc, &key.exclude, visible(cx))); + self.targets = Some((Some(key), snap)); + } + + fn snap(&mut self, cx: &ToolContext, p: Point, from: Option<&Leave>) -> Point { + let (q, guides) = match &self.targets { + Some((_, t)) => t.snap_from(cx, p, from), + None => (p, vec![]), + }; + self.guides = guides; + q + } +} + +/// Snapping for a dragged direction handle: Shift keeps it at 45° steps round its anchor, else it +/// snaps as a drawn point does ([`DrawSnap`]). The targets ([`Targets::for_handle`]) are gathered +/// on the first move that needs them and kept for the rest of the drag. +#[derive(Default)] +pub struct HandleSnap(DrawSnap); impl HandleSnap { /// Where the handle of anchor `ai` of subpath `si` of path `id` goes with the pointer at `p`, @@ -565,22 +933,13 @@ impl HandleSnap { pub fn snap(&mut self, cx: &ToolContext, (id, si, ai): (NodeId, usize, usize), p: Point, shift: bool) -> (Point, Vec) { let path = cx.doc.node(id).and_then(|n| n.path_data()); if shift && let Some(a) = path.and_then(|pd| pd.subpaths.get(si)?.anchors.get(ai)) { - return (a.p + vectorcraft_geom::constrain_angle_from(p - a.p, 45.0, cx.constrain_angle), vec![]); + return (a.p + constrain_angle_from(p - a.p, 45.0, cx.constrain_angle), vec![]); } - let snap = self.0.get_or_insert_with(|| { - PointSnap::new(cx, || { - // The path's bounds move with the handle, so they would chase it: its anchors - // (which stay put) are the targets instead, the handle lining up with them too. - let mut t = Targets::collect(cx.doc, &[id], None); - for (_, _, a) in path.into_iter().flat_map(|pd| pd.anchors()).take(20_000) { - t.points.push((a.p, Kind::Anchor)); - t.xs.push((a.p.x, a.p, Kind::Anchor)); - t.ys.push((a.p.y, a.p, Kind::Anchor)); - } - t - }) - }); - snap.snap(cx, p) + if self.0.targets.is_none() { + self.0.hold(cx, || Targets::for_handle(cx.doc, id)); + } + let q = self.0.drag(cx, p, None); + (q, self.0.guides().to_vec()) } } @@ -758,9 +1117,138 @@ mod tests { s.anchors.insert(id, [(0, 0)].into_iter().collect()); let t = Targets::for_anchor_drag(&d, &s); let anchors: Vec = t.points.iter().filter(|(_, k)| *k == Kind::Anchor).map(|(p, _)| *p).collect(); - assert_eq!(anchors, [Point::new(200.0, 100.0), Point::new(200.0, 200.0), Point::new(100.0, 200.0)]); + assert_eq!(anchors, [Point::new(100.0, 200.0), Point::new(200.0, 100.0), Point::new(200.0, 200.0)], "by x"); assert_eq!(t.segments.len(), 2); assert!(!t.points.iter().any(|(p, k)| *k == Kind::Center && *p == Point::new(150.0, 150.0)), "the rect's centre moves"); assert_eq!(t.snap_point(Point::new(101.0, 99.0), 4.0).0, Point::new(100.0, 100.0), "in line with its neighbours, not on itself"); } + + fn labels(ov: &[Overlay]) -> Vec<&str> { + ov.iter().filter_map(|o| if let Overlay::Label { text, .. } = o { Some(text.as_str()) } else { None }).collect() + } + + fn lines(ov: &[Overlay]) -> Vec<(Point, Point)> { + ov.iter().filter_map(|o| if let Overlay::Line { a, b, .. } = o { Some((*a, *b)) } else { None }).collect() + } + + /// A drawn point (#506): on another object's anchors, in line with them too (not only with its + /// bounds), onto its paths; Shift slides it along its 45° step into line; near a construction + /// guide through the point it leaves from it lands on the guide, where a target's line crosses + /// it if one does nearby. + #[test] + fn drawn_points_land_on_anchors_paths_alignments_and_construction_guides() { + let (d, _) = doc_with_rect(); + let (s, p) = (Selection::default(), paint()); + let c = cx(&d, &s, &p); + let t = Targets::for_drawing(&d, &[], None).styled(&c); + // The rect is 100..200: its corner, a point on its side, and in line with an anchor. + let (q, ov) = t.snap_from(Point::new(202.0, 198.0), None, 4.0); + assert_eq!((q, labels(&ov)), (Point::new(200.0, 200.0), vec!["anchor"])); + let (q, ov) = t.snap_from(Point::new(202.0, 160.0), None, 4.0); + assert_eq!((q, labels(&ov)), (Point::new(200.0, 160.0), vec!["path"])); + let (q, ov) = t.snap_from(Point::new(330.0, 102.0), None, 4.0); + assert_eq!((q, labels(&ov)), (Point::new(330.0, 100.0), vec!["align"])); + // Shift from (300, 300): the pointer at 2° keeps to 0°, then slides onto x = 200. + let shift = Leave::segment(&c, Point::new(300.0, 300.0), true); + let (q, ov) = t.snap_from(Point::new(203.0, 303.0), Some(&shift), 4.0); + assert!((q - Point::new(200.0, 300.0)).hypot() < 1e-9, "{q:?}"); + assert_eq!(labels(&ov), ["align"]); + assert_eq!(lines(&ov).len(), 1, "{ov:?}"); + // Nothing in reach: on its angle, as far as the pointer. + let (q, ov) = t.snap_from(Point::new(300.0, 380.0), Some(&shift), 4.0); + assert_eq!((q, ov.len()), (Point::new(300.0, 380.0), 0)); + // Construction guides through (300, 320): onto the 135° one… + let from = Leave::segment(&c, Point::new(300.0, 320.0), false); + let (q, ov) = t.snap_from(Point::new(352.0, 373.0), Some(&from), 4.0); + assert!((q - Point::new(352.5, 372.5)).hypot() < 1e-9, "{q:?}"); + assert_eq!(lines(&ov), vec![(Point::new(300.0, 320.0), q)]); + // …where x = 200 crosses it. + let (q, ov) = t.snap_from(Point::new(203.0, 222.5), Some(&from), 4.0); + assert!((q - Point::new(200.0, 220.0)).hypot() < 1e-9, "{q:?}"); + assert_eq!((lines(&ov).len(), labels(&ov)), (2, vec!["align"])); + // Construction Guides off (or Smart Guides off): in line, not on a guide. + let off = ToolContext { construction_angles: &[], ..cx(&d, &s, &p) }; + let (q, _) = t.snap_from(Point::new(352.0, 373.0), Some(&Leave::segment(&off, Point::new(300.0, 320.0), false)), 4.0); + assert_eq!(q, Point::new(352.0, 373.0)); + // A box's corner keeps to a diagonal with Shift, the farther axis giving its size. + let (q, _) = t.snap_from(Point::new(340.0, 310.0), Some(&Leave::diagonal(Point::new(300.0, 300.0), true)), 4.0); + assert_eq!(q, Point::new(340.0, 340.0)); + } + + /// The angle sets of Preferences › Smart Guides › Construction Guides. + #[test] + fn construction_angle_sets() { + assert_eq!(construction_angles(DEFAULT_CONSTRUCTION_ANGLES), [0.0, 45.0, 90.0, 135.0]); + assert_eq!(construction_angles("90° Angles"), [0.0, 90.0]); + assert_eq!(construction_angles("30° Angles"), [30.0, 60.0, 120.0, 150.0]); + assert_eq!(construction_angles("90° & 45° & 30° Angles").len(), 8); + assert_eq!(construction_angles("nonsense"), construction_angles(DEFAULT_CONSTRUCTION_ANGLES)); + } + + /// The sorted targets find by bisection just what a scan of all of them finds, whatever + /// gathered them. + #[test] + fn bisection_finds_what_a_scan_finds() { + use vectorcraft_doc::{Appearance, Node}; + let (mut d, id) = doc_with_rect(); + let l = d.layers[0].id; + for i in 0..60 { + let (x, y) = ((i * 37 % 450) as f64, (i * 53 % 430) as f64); + let tri = vectorcraft_geom::PathData::single(SubPath::polyline( + &[Point::new(x, y), Point::new(x + 13.0, y + 3.0), Point::new(x + 5.0, y + 17.0)], + true, + )); + let n = d.alloc_id(); + d.insert(Some(l), 1, Node::path(n, tri, Appearance::default_art())).unwrap(); + } + let mut s = Selection::default(); + s.set([id]); + s.anchors.insert(id, [(0, 1)].into_iter().collect()); + for t in [Targets::collect(&d, &[], None), Targets::for_drawing(&d, &[id], None), Targets::for_anchor_drag(&d, &s)] { + for q in (0..40).flat_map(|i| (0..40).map(move |j| Point::new(i as f64 * 12.7, j as f64 * 11.3))) { + let scan = t.points.iter().copied().filter(|(a, _)| a.distance(q) <= 6.0).min_by(|a, b| a.0.distance(q).total_cmp(&b.0.distance(q))); + assert_eq!(t.nearest_point(q, 6.0).map(|h| h.0.distance(q)), scan.map(|h| h.0.distance(q)), "{q:?}"); + for (lines, v) in [(&t.xs, q.x), (&t.ys, q.y)] { + let mut near: Vec = lines_near(lines, v, 6.0).iter().map(|l| l.0).collect(); + let mut all: Vec = lines.iter().map(|l| l.0).filter(|w| (w - v).abs() <= 6.0).collect(); + near.sort_by(f64::total_cmp); + all.sort_by(f64::total_cmp); + assert_eq!(near, all); + } + } + } + } + + /// A drawing tool's snapper reuses its targets while hovering over the same document state, and + /// gathers them again when it changes, and on every press. + #[test] + fn draw_snap_gathers_once_per_document_state() { + let (d, _) = doc_with_rect(); + let empty = vectorcraft_doc::Document::new(500.0, 500.0); + let (s, p) = (Selection::default(), paint()); + let at = Point::new(202.0, 198.0); + let mut snap = DrawSnap::default(); + let c = ToolContext { revision: (1, 1), ..cx(&d, &s, &p) }; + assert_eq!(snap.hover(&c, at, &[], None), Point::new(200.0, 200.0)); + assert_eq!(labels(snap.guides()), ["anchor"]); + // The same revision: the targets are the ones gathered (the document isn't read again). + let c = ToolContext { revision: (1, 1), ..cx(&empty, &s, &p) }; + assert_eq!(snap.hover(&c, at, &[], None), Point::new(200.0, 200.0)); + // A new revision, or a press, reads it. + let c = ToolContext { revision: (1, 2), ..cx(&empty, &s, &p) }; + assert_eq!(snap.hover(&c, at, &[], None), at); + assert!(snap.guides().is_empty()); + let c = ToolContext { revision: (1, 2), ..cx(&d, &s, &p) }; + assert_eq!(snap.press(&c, at, &[], None), Point::new(200.0, 200.0)); + // The drag keeps what the press gathered, though the document now shows its preview. + let c = ToolContext { revision: (1, 3), ..cx(&empty, &s, &p) }; + assert_eq!(snap.drag(&c, at, None), Point::new(200.0, 200.0)); + snap.clear(); + assert!(snap.guides().is_empty()); + // Snap to Grid wins over Smart Guides, Shift still keeping the angle. + let c = ToolContext { snap_to_grid: true, ..cx(&d, &s, &p) }; + let from = Leave::segment(&c, Point::ZERO, true); + let q = snap.press(&c, Point::new(31.0, 2.0), &[], Some(&from)); + assert!((q.y - 0.0).abs() < 1e-9, "{q:?}"); + } } diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs index b143e8a4..32ef1c20 100644 --- a/crates/tools/src/lib.rs +++ b/crates/tools/src/lib.rs @@ -216,6 +216,10 @@ impl ScreenFrame { /// Read-only context a tool sees. pub struct ToolContext<'a> { pub doc: &'a Document, + /// Which open document `doc` is (its process-unique id) and its revision, which moves with + /// every change of the document or the selection: what a tool keeps between pointer events + /// for the document as it is (the snap targets of hovering) is keyed on it. + pub revision: (u64, u64), pub selection: &'a Selection, /// Screen pixels per document point. pub zoom: f64, @@ -319,6 +323,10 @@ pub struct ToolContext<'a> { /// Smart Guides → Snapping Tolerance (screen pixels): how near a smart guide target pulls the /// pointer, a dragged edge or a drawn point. pub snapping_tolerance: f64, + /// Smart Guides → Construction Guides: the angles (degrees, counter-clockwise from the x axis + /// as seen on the page) of the lines through the point a drawn point leaves from, onto which a + /// point near one lands ([`guides::construction_angles`]); none with the option off. + pub construction_angles: &'static [f64], /// The document window (none headless): screen-fixed widgets sit in it. pub screen: Option, /// Where the Plane Switching Widget sits (Perspective Grid Options); None while it's hidden. @@ -631,6 +639,7 @@ pub(crate) mod testutil { pub fn cx<'a>(d: &'a Document, s: &'a Selection, p: &'a PaintDefaults) -> ToolContext<'a> { ToolContext { doc: d, + revision: (0, 0), selection: s, zoom: 1.0, isolation: None, @@ -675,6 +684,7 @@ pub(crate) mod testutil { measurement_labels: true, transform_tools_guides: true, snapping_tolerance: 4.0, + construction_angles: guides::construction_angles(guides::DEFAULT_CONSTRUCTION_ANGLES), screen: None, plane_widget: Some(Default::default()), } diff --git a/crates/tools/src/pen.rs b/crates/tools/src/pen.rs index 1a6327a4..b69537dc 100644 --- a/crates/tools/src/pen.rs +++ b/crates/tools/src/pen.rs @@ -16,6 +16,10 @@ //! segment of a selected path adds an anchor there and a click on one of its anchors deletes it //! (Shift held or General → Disable Auto Add/Delete starts a new path instead). On a selected //! blend's spine a click adds a point (on a point no key object sits on: deletes it). +//! Each anchor placed snaps to Smart Guides ([`DrawSnap`]): onto the anchors, centres and paths of +//! the other art and of the path being drawn, into line with them, onto the construction guides +//! through the last anchor; with Shift held it slides along its 45° step into line. Hovering shows +//! where the next one would go. use serde_json::json; use vectorcraft_doc::{NodeId, NodeKind}; @@ -23,6 +27,7 @@ use vectorcraft_geom::{BezPath, Point}; use crate::direct::hit_handle; use crate::draw2::AnchorTool; +use crate::guides::{DrawSnap, Leave}; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; #[derive(Default)] @@ -43,6 +48,8 @@ pub struct PenTool { handle: Option<(NodeId, usize, usize, Point)>, /// The Anchor Point tool, while an Alt gesture on a selected path's handle or anchor lasts. convert: Option, + /// Smart Guides for the anchors placed (and the pointer hovering). + snap: DrawSnap, } /// An anchor being placed, as the press decided: where it is, the path it goes on (none: the @@ -116,8 +123,6 @@ impl Tool for PenTool { self.drag.is_some() || self.handle.is_some() || self.convert.is_some() } fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec { - let exclude: Vec = if self.drawing { cx.selection.objects.clone() } else { vec![] }; - let (mut p, _) = if matches!(ev.kind, PointerKind::Down) { crate::guides::snap_draw(cx, ev.pos, &exclude) } else { (ev.pos, vec![]) }; let tol = cx.tol(5.0); // The path a press began is the selected one by the next event. if self.drawing && self.path.is_none() { @@ -127,6 +132,14 @@ impl Tool for PenTool { if self.drawing && active.is_none() && ev.kind == PointerKind::Down { self.stop(); } + // The path being drawn moves its bounds as it grows: only its anchors and segments pull. + let drawn = active.map(|a| a.0); + let from = active.map(|(_, _, last, _)| Leave::segment(cx, last, ev.mods.shift)); + let p = match ev.kind { + PointerKind::Move => self.snap.hover(cx, ev.pos, drawn.as_slice(), from.as_ref()), + PointerKind::Down => self.snap.press(cx, ev.pos, drawn.as_slice(), from.as_ref()), + _ => ev.pos, + }; match ev.kind { PointerKind::Move => { self.hover = Some(p); @@ -135,9 +148,6 @@ impl Tool for PenTool { PointerKind::Down => { self.last = ev.pos; if let Some((id, first, last, _)) = active { - if ev.mods.shift { - p = last + vectorcraft_geom::constrain_angle(p - last, 45.0); - } let end = last_anchor(cx, id); // A one-anchor path doesn't close on itself: its anchor is the last one too. if p.distance(first) <= tol && end.is_some_and(|(_, ai)| ai > 0) { @@ -230,6 +240,7 @@ impl Tool for PenTool { )] } PointerKind::Up => { + self.snap.clear(); if let Some(mut t) = self.convert.take() { return t.pointer(cx, ev); } @@ -251,6 +262,7 @@ impl Tool for PenTool { self.stop(); self.drag = None; self.handle = None; + self.snap.clear(); // An Alt gesture under way ends as it stands. self.convert.take().map(|mut t| t.deactivate(cx)).unwrap_or_default() } @@ -259,25 +271,30 @@ impl Tool for PenTool { } fn deactivate(&mut self, cx: &ToolContext) -> Vec { self.stop(); + self.snap.clear(); self.convert.take().map(|mut t| t.deactivate(cx)).unwrap_or_default() } fn overlays(&self, cx: &ToolContext) -> Vec { if let Some(t) = &self.convert { return t.overlays(cx); } - if !cx.pen_rubber_band || self.drag.is_some() || self.handle.is_some() { - return vec![]; + let mut o = vec![]; + if cx.pen_rubber_band + && self.drag.is_none() + && self.handle.is_none() + && let (Some((id, _, last, out)), Some(h)) = (self.active(cx), self.hover) + { + let mut bp = BezPath::new(); + bp.move_to(last); + if out.distance(last) > 1e-9 { + bp.quad_to(out, h); + } else { + bp.line_to(h); + } + o.push(Overlay::Path { path: bp, color: cx.doc.layer_color(id), width: 1.0, dashed: false }); } - let (Some((id, _, last, out)), Some(h)) = (self.active(cx), self.hover) else { return vec![] }; - let mut bp = BezPath::new(); - bp.move_to(last); - if out.distance(last) > 1e-9 { - bp.quad_to(out, h); - } else { - bp.line_to(h); - } - let c = cx.doc.layer_color(id); - vec![Overlay::Path { path: bp, color: c, width: 1.0, dashed: false }] + o.extend_from_slice(self.snap.guides()); + o } fn cursor(&self, cx: &ToolContext, p: Point, m: Mods) -> Cursor { let tol = cx.tol(5.0); @@ -614,6 +631,31 @@ mod tests { assert!(matches!(&a[..], [Action::Begin(_), Action::Preview(c, _)] if c == "path.create"), "{a:?}"); } + /// Each anchor snaps to Smart Guides (#506): hovering shows where it goes (the rubber band ends + /// there), in line with another object's centre; Shift slides it along its 45° step into line. + #[test] + fn anchors_snap_to_smart_guides() { + let (d, id, s) = drawing(vectorcraft_geom::SubPath::polyline(&[Point::new(10.0, 300.0), Point::new(60.0, 300.0)], false)); + let p = paint(); + let cx = cx(&d, &s, &p); + let mut t = PenTool { drawing: true, ..PenTool::default() }; + t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 152.0, 318.0)); + let o = t.overlays(&cx); + assert!(o.iter().any(|o| matches!(o, Overlay::Label { text, p, .. } if text == "align" && *p == Point::new(150.0, 318.0))), "{o:?}"); + assert!(o.iter().any( + |o| matches!(o, Overlay::Path { path, .. } if path.elements().last().and_then(|e| e.end_point()) == Some(Point::new(150.0, 318.0))) + )); + let a = click(&mut t, &cx, 152.0, 318.0, Mods::default()); + assert_eq!(a[1], Action::Preview("path.appendAnchor".into(), json!({"id": id.0, "x": 150.0, "y": 318.0}))); + let shift = Mods { shift: true, ..Mods::default() }; + let a = click(&mut t, &cx, 152.0, 310.0, shift); + assert_eq!(a[1], Action::Preview("path.appendAnchor".into(), json!({"id": id.0, "x": 150.0, "y": 300.0}))); + // The first anchor of a new path lands on the rect's corner. + let mut t = PenTool::default(); + let a = click(&mut t, &cx, 102.0, 99.0, Mods::default()); + assert_eq!(a[1], Action::Preview("path.create".into(), json!({"anchors": [{"x": 100.0, "y": 100.0}]}))); + } + #[test] fn alt_over_a_shown_handle_or_an_anchor_converts() { // The middle anchor is smooth: handles at (150, 100) and (250, 100) round (200, 100). diff --git a/crates/tools/src/shape.rs b/crates/tools/src/shape.rs index f465a7d9..e316e9d3 100644 --- a/crates/tools/src/shape.rs +++ b/crates/tools/src/shape.rs @@ -2,11 +2,13 @@ //! //! Drag draws (Shift constrains to square/circle/45°, Alt draws from the centre, Space held moves //! the shape being drawn); a click without a drag asks the UI for the size dialog (like -//! Illustrator). ↑/↓ during a polygon/star drag change the side/point count. +//! Illustrator). ↑/↓ during a polygon/star drag change the side/point count. The start point and +//! the dragged corner snap to Smart Guides ([`DrawSnap`]), hovering before the press too. use serde_json::{Value, json}; use vectorcraft_geom::{Point, Rect}; +use crate::guides::{DrawSnap, Leave, square}; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; pub struct ShapeTool { @@ -20,7 +22,7 @@ pub struct ShapeTool { pub corner_radius: f64, /// Star inner radius as a fraction of the outer radius. pub star_ratio: f64, - guides: Vec, + snap: DrawSnap, } impl ShapeTool { @@ -43,7 +45,7 @@ impl ShapeTool { points: 5, corner_radius: 12.0, star_ratio: 0.5, - guides: vec![], + snap: DrawSnap::default(), } } @@ -58,7 +60,18 @@ impl ShapeTool { } } - /// The command for the current drag. + /// How the dragged point keeps to the start: a polygon's or star's radius goes anywhere, a + /// line is a segment (Shift: 45° steps), the rest are boxes (Shift: a square). + fn leave(&self, cx: &ToolContext, start: Point, m: Mods) -> Option { + match self.id { + "polygon" | "star" => None, + "lineSegment" => Some(Leave::segment(cx, start, m.shift)), + _ => Some(Leave::diagonal(start, m.shift)), + } + } + + /// The command for a drag from `start` to `p` (snapped: a line's end already keeps Shift's + /// angle). pub fn command(&self, start: Point, p: Point, m: Mods) -> (String, Value) { match self.id { "polygon" | "star" => { @@ -76,7 +89,6 @@ impl ShapeTool { } "lineSegment" => { let (a, b) = if m.alt { (start - (p - start), p) } else { (start, p) }; - let b = if m.shift { a + vectorcraft_geom::constrain_angle(b - a, 45.0) } else { b }; ("shape.line".into(), json!({ "x1": a.x, "y1": a.y, "x2": b.x, "y2": b.y })) } _ => { @@ -104,11 +116,7 @@ pub(crate) fn space_moves(start: &mut Point, last: &mut Point, ev: &PointerEvent /// The rectangle a drag from `start` to `p` draws: Shift makes it a square, Alt draws it from its /// centre. pub(crate) fn drag_rect(start: Point, p: Point, m: Mods) -> Rect { - let mut d = p - start; - if m.shift { - let s = d.x.abs().max(d.y.abs()); - d = vectorcraft_geom::Vec2::new(s * d.x.signum(), s * d.y.signum()); - } + let d = if m.shift { square(p - start) } else { p - start }; if m.alt { Rect::from_points(start - d, start + d) } else { Rect::from_points(start, start + d) } } @@ -121,8 +129,12 @@ impl Tool for ShapeTool { } fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec { match ev.kind { + PointerKind::Move => { + self.snap.hover(cx, ev.pos, &[], None); + vec![] + } PointerKind::Down => { - let (p, _) = crate::guides::snap_draw(cx, ev.pos, &[]); + let p = self.snap.press(cx, ev.pos, &[], None); self.start = Some(p); self.last = ev.pos; self.began = false; @@ -130,8 +142,7 @@ impl Tool for ShapeTool { } PointerKind::Drag => { let Some(mut s) = self.start else { return vec![] }; - let (pos, g) = crate::guides::snap_draw(cx, ev.pos, &[]); - self.guides = g; + let pos = self.snap.drag(cx, ev.pos, self.leave(cx, s, ev.mods).as_ref()); let ev = &PointerEvent { pos, ..*ev }; space_moves(&mut s, &mut self.last, ev, self.began); self.start = Some(s); @@ -150,7 +161,7 @@ impl Tool for ShapeTool { } PointerKind::Up => { let Some(s) = self.start.take() else { return vec![] }; - self.guides.clear(); + self.snap.clear(); if self.began { self.began = false; vec![Action::Commit] @@ -196,23 +207,26 @@ impl Tool for ShapeTool { } else if key == ToolKey::Escape { self.start = None; self.began = false; + self.snap.clear(); vec![Action::Cancel] } else { vec![] } } fn overlays(&self, cx: &ToolContext) -> Vec { - match self.start { - Some(s) if self.began => { - let d = self.last - s; - let mut o = self.guides.clone(); - if cx.measurement_labels { - o.push(Overlay::Measure { p: self.last, text: cx.size_label(d.x.abs(), d.y.abs()) }); + let mut o = self.snap.guides().to_vec(); + if let Some(s) = self.start.filter(|_| self.began && cx.measurement_labels) { + // A box's size as drawn (from its centre with Alt, square with Shift). + let (w, h) = match self.id { + "polygon" | "star" | "lineSegment" => ((self.last - s).x.abs(), (self.last - s).y.abs()), + _ => { + let r = drag_rect(s, self.last, self.mods); + (r.width(), r.height()) } - o - } - _ => vec![], + }; + o.push(Overlay::Measure { p: self.last, text: cx.size_label(w, h) }); } + o } fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor { Cursor::Crosshair @@ -310,4 +324,36 @@ mod tests { let a = t.key(&cx, ToolKey::Up, Mods::default()); assert!(matches!(&a[0], Action::Preview(_, v) if v["sides"] == 7)); } + + /// The start and the dragged corner land on another object's anchors (#506), hovering shows + /// it before the press, and the measurement label gives the size drawn. + #[test] + fn corners_snap_to_smart_guides() { + let (d, _) = doc_with_rect(); + let s = Selection::default(); + let p = paint(); + let cx = cx(&d, &s, &p); + let mut t = ShapeTool::new("rectangle"); + let anchor = |o: &[Overlay], at: Point| o.iter().any(|o| matches!(o, Overlay::Label { text, p, .. } if text == "anchor" && *p == at)); + t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 98.0, 102.0)); + assert!(anchor(&t.overlays(&cx), Point::new(100.0, 100.0))); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 98.0, 102.0)); + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 198.0, 202.0)); + assert_eq!(a[1], Action::Preview("shape.rectangle".into(), json!({"x": 100.0, "y": 100.0, "width": 100.0, "height": 100.0}))); + let o = t.overlays(&cx); + assert!(anchor(&o, Point::new(200.0, 200.0)), "{o:?}"); + assert!(o.iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &cx.size_label(100.0, 100.0)))); + // Alt draws from the centre: the label gives the whole size. + let alt = Mods { alt: true, ..Mods::default() }; + t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 198.0, 202.0).with_mods(alt)); + assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &cx.size_label(200.0, 200.0)))); + t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 198.0, 202.0)); + assert!(t.overlays(&cx).is_empty()); + // A line with Shift keeps to 45° steps, sliding into line with the rect's right side. + let mut t = ShapeTool::new("lineSegment"); + t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 300.0, 300.0)); + let shift = Mods { shift: true, ..Mods::default() }; + let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 203.0, 302.0).with_mods(shift)); + assert!(matches!(&a[..], [_, Action::Preview(_, v)] if v["x2"] == 200.0 && (v["y2"].as_f64().unwrap() - 300.0).abs() < 1e-9), "{a:?}"); + } } diff --git a/crates/tools/src/text.rs b/crates/tools/src/text.rs index 9f2ae1d9..3c6ebd69 100644 --- a/crates/tools/src/text.rs +++ b/crates/tools/src/text.rs @@ -3,7 +3,8 @@ //! Type: click places point type, drag draws an area-type frame, clicking into existing text //! places the caret. Area Type / Type on a Path: click a path to turn it into a text frame or a //! baseline (`text.createInPath`). Point type placed by a click and left empty is discarded when -//! editing ends (`text.discardEmpty`); frames keep their shape. +//! editing ends (`text.discardEmpty`); frames keep their shape. Where new type goes (the click, the +//! frame's corners) snaps to Smart Guides ([`DrawSnap`]), hovering too. //! //! While editing: caret movement by character / word (Cmd or Alt) / line (Up/Down) / line ends //! (Home/End; Cmd = whole text), Shift extends the selection, drag selects, double-click selects a @@ -27,6 +28,7 @@ use vectorcraft_doc::{NodeId, NodeKind, TextKind, TextObject, TextRun}; use vectorcraft_geom::{BezPath, Point, Rect, Shape}; use vectorcraft_text::{FontDb, TextLayout, edit}; +use crate::guides::DrawSnap; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; /// Which of the Type tools this is. @@ -68,8 +70,12 @@ pub struct TypeTool { goal_x: Option, typing: Option, preedit: Option, - press: Option, + /// Where the button went down, and where new type goes from there (snapped to Smart Guides). + press: Option<(Point, Point)>, + /// The other corner of an area dragged out (snapped). drag: Option, + /// Smart Guides for where new type goes. + snap: DrawSnap, /// The press landed in the edited text: dragging selects. selecting: bool, /// Click counting for double/triple click (position of the last click, count). @@ -252,7 +258,8 @@ impl TypeTool { Some(out) } - fn on_up(&mut self, cx: &ToolContext, start: Point) -> Vec { + /// The button released after a press at `start` (new type goes at `at`). + fn on_up(&mut self, cx: &ToolContext, start: Point, at: Point) -> Vec { // Click into existing text: place the caret. if let Some(out) = self.edit_at(cx, start) { return out; @@ -272,10 +279,10 @@ impl TypeTool { return out; } } - let area = drag.map(|d| Rect::from_points(start, d)).filter(|r| r.width() > cx.tol(6.0) && r.height() > cx.tol(6.0)); + let area = drag.map(|d| Rect::from_points(at, d)).filter(|r| r.width() > cx.tol(6.0) && r.height() > cx.tol(6.0)); let mut params = match area { Some(r) => json!({"x": r.x0, "y": r.y0, "text": "", "area": {"width": r.width(), "height": r.height()}}), - None => json!({"x": start.x, "y": start.y, "text": ""}), + None => json!({"x": at.x, "y": at.y, "text": ""}), }; params["vertical"] = json!(self.vertical); params["placeholder"] = json!(cx.placeholder_text); @@ -386,7 +393,7 @@ impl Tool for TypeTool { self.selecting = true; return out; } - self.press = Some(ev.pos); + self.press = Some((ev.pos, self.snap.press(cx, ev.pos, self.editing.as_slice(), None))); self.drag = None; vec![] } @@ -398,7 +405,7 @@ impl Tool for TypeTool { self.clicks = (None, 0); } } else if self.press.is_some() { - self.drag = Some(ev.pos); + self.drag = Some(self.snap.drag(cx, ev.pos, None)); } vec![] } @@ -407,8 +414,9 @@ impl Tool for TypeTool { self.selecting = false; return vec![]; } - let Some(start) = self.press.take() else { return vec![] }; - self.on_up(cx, start) + self.snap.clear(); + let Some((start, at)) = self.press.take() else { return vec![] }; + self.on_up(cx, start, at) } PointerKind::DoubleClick => { if self.editing.is_some() && self.hit_edited(cx, ev.pos).is_some() { @@ -417,7 +425,11 @@ impl Tool for TypeTool { } vec![] } - PointerKind::Move => vec![], + PointerKind::Move => { + // The type being edited is no target: its guides would only point at itself. + self.snap.hover(cx, ev.pos, self.editing.as_slice(), None); + vec![] + } } } fn text_input(&mut self, cx: &ToolContext, s: &str) -> Vec { @@ -700,8 +712,8 @@ impl Tool for TypeTool { } } fn overlays(&self, cx: &ToolContext) -> Vec { - let mut o = vec![]; - if let (Some(s), Some(d)) = (self.press, self.drag) { + let mut o = self.snap.guides().to_vec(); + if let (Some((_, s)), Some(d)) = (self.press, self.drag) { o.push(Overlay::Marquee(Rect::from_points(s, d))); } // Overflow markers on selected text. diff --git a/crates/tools/src/text_tests.rs b/crates/tools/src/text_tests.rs index 5ddce3df..8ac03794 100644 --- a/crates/tools/src/text_tests.rs +++ b/crates/tools/src/text_tests.rs @@ -335,3 +335,24 @@ fn hebrew_typing_and_visual_arrows_keep_logical_text() { let NodeKind::Text(t) = &d.node(id).unwrap().kind else { panic!() }; assert_eq!(t.plain_text(), "שלום"); } + +/// Where new type goes snaps to Smart Guides (#506): a click beside a rect lines up with its +/// centre, and hovering shows it first; an area's corners land on its anchors. +#[test] +fn new_type_snaps_to_smart_guides() { + let (d, _) = crate::testutil::doc_with_rect(); + let (sel, p) = (Selection::default(), paint()); + let c = cx(&d, &sel, &p); + let mut tool = TypeTool::new("type"); + tool.pointer(&c, &PointerEvent::new(PointerKind::Move, 151.0, 330.0)); + assert!(tool.overlays(&c).iter().any(|o| matches!(o, Overlay::Label { text, p, .. } if text == "align" && *p == Point::new(150.0, 330.0)))); + tool.pointer(&c, &PointerEvent::new(PointerKind::Down, 151.0, 330.0)); + let acts = tool.pointer(&c, &PointerEvent::new(PointerKind::Up, 151.0, 330.0)); + assert!(acts.iter().any(|a| matches!(a, Action::Exec(cmd, v) if cmd == "text.create" && v["x"] == 150.0 && v["y"] == 330.0)), "{acts:?}"); + let mut tool = TypeTool::new("type"); + tool.pointer(&c, &PointerEvent::new(PointerKind::Down, 102.0, 98.0)); + tool.pointer(&c, &PointerEvent::new(PointerKind::Drag, 199.0, 202.0)); + let acts = tool.pointer(&c, &PointerEvent::new(PointerKind::Up, 199.0, 202.0)); + let area = json!({"width": 100.0, "height": 100.0}); + assert!(acts.iter().any(|a| matches!(a, Action::Exec(cmd, v) if cmd == "text.create" && v["x"] == 100.0 && v["area"] == area)), "{acts:?}"); +} diff --git a/crates/tools/src/xform/artboard.rs b/crates/tools/src/xform/artboard.rs index f72a9245..97d7df09 100644 --- a/crates/tools/src/xform/artboard.rs +++ b/crates/tools/src/xform/artboard.rs @@ -8,14 +8,14 @@ //! the Selection tool. Moving and resizing snap like drawing //! does: to whole pixels, to the grid, or with Smart Guides to other artboards, their bleed and //! objects (never to the dragged artboard or the art moving with it); the artboard's own bleed edges -//! snap too. +//! snap too. A new artboard's corners snap as drawn points do ([`DrawSnap`]). use serde_json::{Value, json}; use vectorcraft_geom::{Point, Rect, Vec2}; use super::{BLUE, polygon, rect_corners}; use crate::bbox::{Handle, hit_handle, move_delta, scale_for_drag}; -use crate::guides::Targets; +use crate::guides::{DrawSnap, Leave, Targets}; use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey}; #[derive(Clone, Copy, Debug)] @@ -57,11 +57,13 @@ pub struct ArtboardTool { copy_targets: Option, /// Smart Guides shown while dragging. guides: Vec, + /// Smart Guides for the corners of a new artboard. + draw: DrawSnap, } impl Default for ArtboardTool { fn default() -> Self { - Self { active: 0, move_art: true, drag: None, preview: None, targets: None, copy_targets: None, guides: vec![] } + Self { active: 0, move_art: true, drag: None, preview: None, targets: None, copy_targets: None, guides: vec![], draw: DrawSnap::default() } } } @@ -134,6 +136,7 @@ impl ArtboardTool { self.targets = None; self.copy_targets = None; self.guides.clear(); + self.draw.clear(); } } @@ -171,7 +174,7 @@ impl Tool for ArtboardTool { self.active = i; self.drag = Some(Drag::Move { index: i, start: p, rect: a.rect, began: false, copy: false }); } else { - let (p, _) = crate::guides::snap_draw(cx, p, &[]); + let p = self.draw.press(cx, p, &[], None); self.drag = Some(Drag::Create { start: p, cur: p }); } vec![] @@ -213,12 +216,7 @@ impl Tool for ArtboardTool { out } (PointerKind::Drag, Some(Drag::Create { start, .. })) => { - let (mut cur, _) = crate::guides::snap_draw(cx, p, &[]); - if m.shift { - let d = cur - start; - let s = d.x.abs().max(d.y.abs()); - cur = start + Vec2::new(s.copysign(d.x), s.copysign(d.y)); - } + let cur = self.draw.drag(cx, p, Some(&Leave::diagonal(start, m.shift))); self.drag = Some(Drag::Create { start, cur }); vec![] } @@ -289,6 +287,7 @@ impl Tool for ArtboardTool { fn overlays(&self, cx: &ToolContext) -> Vec { let mut o = vec![]; if let Some(Drag::Create { start, cur }) = self.drag { + o.extend_from_slice(self.draw.guides()); let r = Rect::from_points(start, cur); o.push(Overlay::Marquee(r)); if cx.measurement_labels { diff --git a/docs/mcp.md b/docs/mcp.md index e681bcb1..f067ddb7 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -1215,8 +1215,8 @@ off, an empty window, and the Home button or `app.home` still shows the screen) default: on, a click away from a panel popped out of the icon column puts it away). The Smart Guides preferences (Preferences › Smart Guides) apply to `pointer_gesture` with Smart Guides on (the -default view) and to the mouse; they change what the tools show and how far a target pulls, never where a snapped -point lands: +default view) and to the mouse; they change what the tools show and how far a target pulls, and only Construction +Guides change where a snapped point lands: - `smartGuideColor` (`#ff3dfc` by default): the colour of the smart guides' lines and labels. - `alignmentGuides` (on by default): off, no line is drawn along the edge or centre the art lines up with; the art @@ -1231,6 +1231,11 @@ point lands: - `snappingTolerance` (0–40 px, 4 by default): how near an anchor, edge, centre or artboard edge pulls a drawn point, a dragged selection, a bounding-box handle, a ruler guide or an artboard. With Smart Guides off, Snap to Point uses `snapToPointTolerance` instead. +- `constructionGuides` (on by default) and `constructionAngles` (`90° & 45° Angles` by default; also `90° Angles`, + `45° Angles`, `60° Angles`, `30° Angles`, `90° & 45° & 30° Angles`): a point drawn near a line at one of those + angles through the point it leaves from (the Pen's or Curvature tool's last anchor, a line's start) lands on that + line, where a target's alignment line crosses it if one does nearby. "90°" gives the horizontal and the vertical, + "45°" the diagonals, "60°" and "30°" the multiples of those angles in between. Off, the point only lines up. With Smart Guides on, a bounding-box handle dragged with the Selection or Free Transform tool (`mods.shift` proportional, `mods.alt` from the centre) lands on another object's anchor or centre (labelled "anchor" or @@ -1242,7 +1247,26 @@ snap the pointer as drawing tools do, so dragging a corner onto another object's {"name":"pointer_gesture","arguments":{"tool":"scale","events":[{"kind":"down","x":100,"y":100},{"kind":"up","x":100,"y":100},{"kind":"down","x":199,"y":198},{"kind":"drag","x":302,"y":262},{"kind":"up","x":302,"y":262}]}} ``` -Not read yet: Construction Guides and their Angles, and Spacing Guides (the tools draw neither). +Every point a drawing tool places snaps the same way, through one snapper (#506): the Pen's and Curvature tool's +anchors, the Pencil's first and last point, the shape tools' start and dragged corner or radius (`rectangle`, +`roundedRectangle`, `ellipse`, `polygon`, `star`, `lineSegment`, `arc`, `spiral`, `rectangularGrid`, `polarGrid`), the +Type tool's click and frame, and a new artboard's corners. The point lands on another object's anchor, centre or +path ("anchor", "center", "path"), else lines up with the anchors, edges and centres of the art and the artboards (a +line from the target and "align"); the Pen's lands on the path being drawn too, so a click on its first anchor closes +it exactly. With `mods.shift` the point keeps to its 45° step from the anchor before it (from `constrainAngle`; a box +dragged keeps its corner on a diagonal) and slides along that way into line with the nearest target. A `move` event +before the press shows where it would go, as hovering does with the mouse. The targets are the art in the window (all +of it headless), gathered once per document state; the shape being drawn is never one of them: + +```json +{"name":"pointer_gesture","arguments":{"tool":"rectangle","events":[{"kind":"down","x":202,"y":203},{"kind":"drag","x":330,"y":341},{"kind":"up","x":330,"y":341}]}} +{"name":"pointer_gesture","arguments":{"tool":"pen","events":[{"kind":"down","x":300,"y":420},{"kind":"up","x":300,"y":420},{"kind":"down","x":151.5,"y":431},{"kind":"up","x":151.5,"y":431}]}} +``` + +With a 100 × 100 square at (100, 100), the first starts the rectangle on its corner (200, 200); the second puts the +Pen's second anchor at (150, 431), in line with the square's centre. + +Not read yet: Spacing Guides (the tools draw none). ## Type preferences From eb255ef37957460b6f760f747ca0f82a0c520d0e Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 23:43:48 +0700 Subject: [PATCH 10/22] EPS tests: interpreter programs written from the PostScript Language Reference MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two EPS import tests become programs written from the PostScript Language Reference (3rd ed.), with their own names and structure, covering the interpreter features the importer relies on: - `level_2_and_3_probes_read_as_vectors`: a resource category made from Generic, resources defined and found in it (§3.9), local and global VM (`currentglobal`, `setglobal`, `gcheck`, §3.7.2), `internaldict` probed through `stopped`, a halftone dictionary set and restored, `cachestatus`, `rootfont` and `currentcolorrendering`, drawing with its own procedures. - `executable_strings_and_integer_keys`: shading dictionaries closed by an executable string (`(>>) cvx`, or a Level 1 builder with `counttomark`), procedures kept under integer keys run with `load` through `stopped`, `cvx`/`cvlit`/`xcheck` on strings. Each was mutation-checked: making any of findresource, defineresource, currentglobal, setglobal, gcheck, internaldict, sethalftone, currenthalftone, currentcolorrendering, cachestatus, rootfont, stopped, cvx, load, counttomark, cvlit or xcheck unknown fails a test, and so do strings that `cvx` leaves literal, `load` refusing integer keys and `gcheck` answering true. The ROADMAP's EPS paragraph, file-formats row and last-updated line state the PostScript features the reader supports; the legacy `.ai` comments in the import module and the interpreter cite that format's published specification (PRONOM fmt/423) for the `%AI` header comments and `u`/`U` group operators the reader keys on. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 6 +- crates/engine/tests/import_fuzz.rs | 5 +- crates/eps/src/import/interp.rs | 6 +- crates/eps/src/import/mod.rs | 11 +- crates/eps/src/import/tests_generators.rs | 177 +++++++-------------- crates/eps/src/import/tests_illustrator.rs | 3 + 6 files changed, 78 insertions(+), 130 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 4e8d8350..9e298c30 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -155,7 +155,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Files (M4):** - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465). - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396; a top-level group with a clip path, such as a clipped Inkscape layer, opens as a layer with a clipping mask, its name kept: #420); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers, on pages of up to 64 million operators, art whose layer can't be told going to a hidden, non-printing layer rather than showing or printing: #419; strokes kept live, a fill and a stroke of one outline as one object; a type object's stroke written as each glyph's outline stroked back on the type, so it stays one editable object; lines wrapped in a frame (each wrapped line ending in a space, one left edge, leading and font) back as one area type object, left aligned or justified with its paragraph spacing, where laying it out breaks the lines where the file does; glyphs set apart by gaps wider than a space (a barcode's digit groups) keeping their places; layers stacked as the pages mark them even when one first paints on a later page, art ending a layer's marked content or a clip closing in a later layer kept in its own layer, and layers with no art kept empty: #508; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320). - - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors. It also runs what other generators write (Discord feedback, #466, #469): Illustrator 2026's procsets (`gcheck`, `rootfont`, `currentcolorrendering`: every Illustrator 2026 EPS fell back to its preview before), cairo/Inkscape (`status`/`flushfile`, images with a mask, `ImageType 3`, reusable streams), matplotlib's Type 3 fonts, Illustrator 8 EPS (stock art's usual format: executable strings such as its gradients' `ed`, `load` by integer keys, #474), Ghostscript's `//name` immediate names, `pdfmark`, `token`, `execform` and user paths. Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). + - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read. Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398); on Linux the Paste menu checks the clipboard off the UI thread, so an X11 owner that never answers can't freeze the window (#510); screenshots and other copied pictures paste as embedded images at the view centre everywhere, the web included (#457). - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped. - **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software), and if the window fails on one while starting up it starts again without it instead of crashing; Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Liquify tools' Use Pressure Pen on Windows, while winit 0.30 reports none on macOS or Linux and egui none on the web. On Linux, see `docs/development.md` for pens under Wayland. @@ -214,7 +214,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale) | Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard presets/rearrange polish (Document Setup, New Document and the rest of the Layers panel are done) | 4–7 | | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 | | Guides, grids, smart guides, snapping, rulers | 3 | 82% | global/video rulers, smart-guide preference depth, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click), ruler guides as Layers rows with their own lock and hide (#451: Lock Guides locks them all; Make Guides paths are Layers rows already) (dragging existing guides is done, #414; new guides snapping to side midpoints and artboards, and artboard guides, #451) | 3–5 | -| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, EPS checked against more real files (Illustrator 2026 and Inkscape files open as vectors; CorelDRAW, Affinity, LibreOffice, matplotlib and Ghostscript output checked with synthetic programs only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 | +| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, EPS checked against more real files users send (Inkscape files open as vectors; other generators' constructs are tested with programs written from the PostScript Language Reference only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 | | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 | | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 | | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 | diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs index ec93b755..aa2f8c7f 100644 --- a/crates/engine/tests/import_fuzz.rs +++ b/crates/engine/tests/import_fuzz.rs @@ -878,7 +878,8 @@ proptest! { } /// Hostile PostScript programs: operators in any order with any operands, opened and placed; - /// as Illustrator's too, its groups (`u` … `U`) unbalanced, deep and among clips. + /// as files in the legacy Illustrator format too (the creator line is what turns on its + /// documented `u` … `U` groups), the groups unbalanced, deep and among clips. #[test] fn eps_hostile_programs_never_panic(tokens in prop::collection::vec(arb_ps_token(), 0..60), illustrator in any::()) { let head = if illustrator { "%%Creator: Adobe Illustrator(R) 8.0\n%%EndComments\n/u {} def /U {} def" } else { "%%EndComments" }; @@ -952,7 +953,7 @@ fn arb_ps_token() -> impl Strategy { "/T3 << /FontType 3 /FontMatrix [0.1 0 0 0.1 0 0] /FontBBox [0 0 9 9] /Encoding [/a /b] /BuildChar { pop pop 9 0 setcharwidth 0 0 5 5 rectfill } >> definefont setfont", "/T4 << /FontType 3 /FontMatrix [1 0 0 1 0 0] /BuildGlyph { pop pop (x) show } /Encoding [/a] >> definefont setfont", "glyphshow", "xshow", "xyshow", "awidthshow", "kshow", "/a", "[1 2 3]", - // Executable strings and integer keys (Illustrator 8's procsets). + // Executable strings and keys other than names (PLRM 3rd ed., `cvx`, `load`). "(>>) cvx", "(1 2 add) cvx exec", "(x) cvx dup exec", "0 load", "1 { } def", "(mark) cvx cvlit" ]) .prop_map(str::to_string), diff --git a/crates/eps/src/import/interp.rs b/crates/eps/src/import/interp.rs index 99ac5cb9..1a1d8005 100644 --- a/crates/eps/src/import/interp.rs +++ b/crates/eps/src/import/interp.rs @@ -56,8 +56,8 @@ pub(crate) struct Interp<'a> { pub g: GState, pub saved: Vec, pub out: Out, - /// The program is an Illustrator file's: its `u` … `U` (written at the top level, whatever - /// its prolog defines them as) are groups. + /// The program is in the legacy Illustrator format: its group operators `u` … `U` (at the top + /// level, whatever its prolog defines them as) are groups (see the module docs of `import`). pub illustrator: bool, } @@ -157,7 +157,7 @@ impl<'a> Interp<'a> { loop { let Some(o) = self.lex.next()? else { return Ok(()) }; let o = self.scanned(o, self.lex.immediate)?; - // An Illustrator group begins before its `u` runs (`Some(true)`) and ends after its `U` + // A group begins before its `u` runs (`Some(true)`) and ends after its `U` // has (`Some(false)`). let group = match &o { Obj::Exec(name) if self.illustrator => match &**name { diff --git a/crates/eps/src/import/mod.rs b/crates/eps/src/import/mod.rs index 5aa2b2e0..bf03d95c 100644 --- a/crates/eps/src/import/mod.rs +++ b/crates/eps/src/import/mod.rs @@ -11,9 +11,11 @@ //! - `text`: fonts by name and type as point type; Type 3 fonts' glyphs drawn by their procedures. //! - `preview`: the previews a file carries, for when its PostScript can't be read. //! -//! Clipped art comes in as clipping groups. In an Illustrator file (Illustrator 3–8, written with -//! the prolog that defines its operators), the groups it writes (`u` … `U`, nested) come in as -//! groups. +//! Clipped art comes in as clipping groups. In a file in the legacy Illustrator format (versions +//! 3–8, with the prolog that defines its operators), the group operators `u` … `U` (nested) come in +//! as groups. The format's published specification documents its header comments (`%AI…`, +//! `%%Creator`) and these operators: Adobe Illustrator File Format Specification, version 7.0 +//! (1998), listed by PRONOM at https://www.nationalarchives.gov.uk/PRONOM/fmt/423. //! //! The page is the file's `%%BoundingBox` (`%%HiResBoundingBox` when it has one), the first page //! of a PostScript file without one. A file whose program can't be read (an operator the @@ -73,7 +75,8 @@ struct Dsc { /// `llx lly urx ury` in PostScript's default space. bbox: Option<[f64; 4]>, pages: Option, - /// Written by Illustrator (or in its format): `%AI…` comments, or Illustrator the creator. + /// In the legacy Illustrator format: its header has `%AI…` comments or names the app as the + /// creator (see the module docs for the specification). illustrator: bool, } diff --git a/crates/eps/src/import/tests_generators.rs b/crates/eps/src/import/tests_generators.rs index 343fd14c..6bc08d5e 100644 --- a/crates/eps/src/import/tests_generators.rs +++ b/crates/eps/src/import/tests_generators.rs @@ -592,105 +592,52 @@ showpage"##; assert!(near(bounds(&meshes[1]), Rect::new(150.0, 90.0, 190.0, 140.0)), "{:?}", bounds(&meshes[1])); } -/// Illustrator's EPS (CS and later, through 2026): procsets that define helpers with -/// `bdf`/`ndf`/`ddf`, probe the level and version (`{version cvr} stopped`), switch VM with -/// `currentglobal`/`setglobal`, save and restore the whole graphics state through -/// `currentcolorrendering`, `rootfont`, the colour transfers, half-tone and flatness, set up -/// categories and keep fonts by VM (`gcheck`), while the art is drawn with procedures of their own. +/// A procset written as the PostScript Language Reference (3rd ed.) describes the Level 2 and 3 +/// facilities programs probe before drawing: a resource category made from `Generic` and +/// resources defined and found in it (§3.9), local and global VM (`currentglobal`, `setglobal`, +/// `gcheck`, §3.7.2), `internaldict` (§8.2), a halftone dictionary (§7.4), the font cache +/// (`cachestatus`), `rootfont` and the colour rendering dictionary (§7.1), each guarded or +/// probed through `stopped` (§3.10), saving the state they change and drawing with procedures of +/// their own. #[test] -fn illustrator_procsets_read_as_vectors() { +fn level_2_and_3_probes_read_as_vectors() { let program = r##"%%BeginProlog -%%BeginResource: procset Adobe_AGM_Utils 1.0 0 -systemdict /setpacking known { currentpacking true setpacking } if -userdict /Adobe_AGM_Utils 75 dict dup begin put -/bdf { bind def } bind def -/nd { null def } bdf -/xdf { exch def } bdf -/ddf { put } bdf -/xddf { 3 -1 roll put } bdf -/ndf { exch dup where { pop pop pop } { xdf } ifelse } def -/gx { get exec } bdf -/ps_level /languagelevel where { pop systemdict /languagelevel gx } { 1 } ifelse def -/level2 ps_level 2 ge def -/level3 ps_level 3 ge def -/ps_version { version cvr } stopped { -1 } if def -/set_gvm { currentglobal exch setglobal } bdf -/reset_gvm { setglobal } bdf -/makereadonlyarray { /packedarray where { pop packedarray } { array astore readonly } ifelse } bdf -/GSTATE 22 dict def -/get_gstate { - GSTATE begin - /clr_spc currentcolorspace def - mark currentcolor counttomark array astore /clr_comps xdf pop - /fnt rootfont def - /lw currentlinewidth def /lc currentlinecap def /lj currentlinejoin def /ml currentmiterlimit def - currentdash /dsh_o xdf /dsh_a xdf - /sa currentstrokeadjust def - /crd currentcolorrendering def - /op currentoverprint def - /bg currentblackgeneration cvlit def - /ucr currentundercolorremoval cvlit def - currentcolortransfer cvlit /gy_x xdf cvlit /b_x xdf cvlit /g_x xdf cvlit /r_x xdf - /ht currenthalftone def - /flt currentflat def - end -} def -/set_gstate { - GSTATE begin - clr_spc setcolorspace clr_comps aload pop setcolor - fnt setfont lw setlinewidth lc setlinecap lj setlinejoin ml setmiterlimit dsh_a dsh_o setdash - sa setstrokeadjust crd setcolorrendering op setoverprint - bg cvx setblackgeneration ucr cvx setundercolorremoval - r_x cvx g_x cvx b_x cvx gy_x cvx setcolortransfer - ht /HalftoneType get dup 9 eq exch 100 eq or { ht sethalftone } if - flt setflat - end -} def -/ct_tst { 1183615869 internaldict pop } stopped pop -currentdict readonly pop +/ExampleKit 40 dict def ExampleKit begin +/defp { bind def } bind def +% A category of our own, implemented by a copy of Generic's dictionary (§3.9.2). +/Generic /Category findresource dup length dict copy /ExampleShapes exch /Category defineresource pop +/Card << /W 80 /H 50 >> /ExampleShapes defineresource pop +% VM: a dictionary made in global VM, then the VM mode put back. +/wasglobal currentglobal def true setglobal /Shared 4 dict def wasglobal setglobal +/vm Shared gcheck { (global) } { (local) } ifelse def +% Probes that fail on some interpreters, inside stopped. +/hasinternal { 1183615869 internaldict } stopped { false } { pop true } ifelse def +/screen << /HalftoneType 1 /Frequency 85 /Angle 15 /SpotFunction { 180 mul cos exch 180 mul cos add 2 div } >> def +/oldscreen currenthalftone def +/rendering currentcolorrendering def +/cache [ cachestatus ] def +/frame { /h exch def /w exch def moveto w 0 rlineto 0 h rlineto w neg 0 rlineto closepath } defp end -systemdict /setpacking known { setpacking } if -%%EndResource -%%BeginResource: procset Adobe_AGM_Core 2.0 0 -userdict /Adobe_AGM_Core 200 dict dup begin put -/AGMCORE_str256 256 string def -/AGMCORE_deviceDPI 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt def -/AGMCORE_distilling /product where { pop systemdict /setdistillerparams known product (Adobe PostScript Parser) ne and } { false } ifelse def -/AGMCORE_producing_seps currentpagedevice /Separations 2 copy known { get } { pop pop false } ifelse def -/AGMCORE_page_size currentpagedevice /PageSize get def -/Generic /Category findresource dup length dict copy /Category defineresource pop -/AGMCORE_mo { moveto } def /AGMCORE_li { lineto } def /AGMCORE_cv { curveto } def /AGMCORE_cp { closepath } def -/AGMCORE_rgb { setrgbcolor } def /AGMCORE_cmyk { setcmykcolor } def -/doc_setup { Adobe_AGM_Utils begin get_gstate end } def -/page_setup { Adobe_AGM_Utils begin set_gstate end } def -end -%%EndResource -%%BeginResource: procset Adobe_CoolType_Core 2.31 0 -userdict /CT_Core 20 dict dup begin put -/GVMFonts 10 dict def /LVMFonts 10 dict def -/VMDictPut { dup gcheck { GVMFonts } { LVMFonts } ifelse 3 1 roll put } bind def -/copyfont { currentglobal exch dup gcheck setglobal dup length dict copy exch setglobal } bind def -end -%%EndResource %%EndProlog %%BeginSetup -Adobe_AGM_Core /doc_setup get exec -CT_Core begin /Body /Helvetica findfont copyfont VMDictPut end +ExampleKit begin +screen sethalftone +/Helvetica 12 selectfont +/face rootfont /FontName get def %%EndSetup %%Page: 1 1 -%%BeginPageSetup -Adobe_AGM_Core /page_setup get exec -%%EndPageSetup -Adobe_AGM_Core begin -/mo { AGMCORE_mo } def /li { AGMCORE_li } def /cv { AGMCORE_cv } def /cp { AGMCORE_cp } def -0 0.94 0.94 0.12 AGMCORE_cmyk -10 140 mo 90 140 li 90 90 li 10 90 li cp fill -0.2 0.4 0.8 AGMCORE_rgb -100 20 mo 150 80 180 0 190 60 cv 2 setlinewidth stroke -0 setgray CT_Core /LVMFonts get /Body get 12 scalefont setfont 10 30 moveto (Art) show +gsave +0 0.94 0.94 0.12 setcmykcolor +10 90 /Card /ExampleShapes findresource dup /W get exch /H get frame fill +0.2 0.4 0.8 setrgbcolor 2 setlinewidth 100 20 moveto 150 80 180 0 190 60 curveto stroke +grestore +% Each probe answered as the reference says: draw only when it did. +vm length 5 eq hasinternal and rendering type /dicttype eq and cache length 7 eq and face /Helvetica eq and +{ 0 setgray 10 30 moveto (Art) show } if +oldscreen sethalftone end showpage"##; - let r = open("Adobe Illustrator(R) 30.0", program); + let r = open("Example Generator 1.0", program); let d = &r.document; let rect = all(d).into_iter().find(|n| fill(n).and_then(Paint::color) == Some(Color::cmyk(0.0, 0.94, 0.94, 0.12))).unwrap(); assert!(near(bounds(&rect), Rect::new(10.0, 10.0, 90.0, 60.0)), "{:?}", bounds(&rect)); @@ -950,44 +897,38 @@ fn hostile_patterns_glyphs_and_shadings_end() { assert_eq!(objects(&r.document).len(), 1); } -/// Illustrator 8 EPS (what stock art often comes as, #474): its gradient procset builds shading -/// dictionaries with `bd` … `ed`, where `ed` is an executable string (`(>>) cvx`, or a Level 1 -/// dictionary builder), and its `discard` runs procedures it `load`s by integer keys. +/// Executable strings and keys other than names (#474): `cvx` makes a string executable, and +/// running it runs its text (PLRM 3rd ed. §3.3.1, `cvx`, `exec`); `load` takes any key (§8.2). +/// A program closes its shading dictionaries with an executable string (`>>` at Level 2 and up, +/// else a dictionary built with `counttomark`), and runs procedures it keeps under integer keys +/// through `stopped`. #[test] -fn illustrator_8_gradients_and_executable_strings() { +fn executable_strings_and_integer_keys() { let program = r##"%%BeginProlog -userdict /AGM_Gradient 20 dict dup begin put -/AGM_Gradient_private 201 dict def -/initialize { - AGM_Gradient begin AGM_Gradient_private begin - /bd systemdict /mark get def - /ed /languagelevel where { pop languagelevel 2 ge } { false } ifelse - { (>>) } { (counttomark 2 idiv dup dict begin {def} repeat pop currentdict end) } ifelse cvx def - /ed1 (counttomark 2 idiv dup dict begin {def} repeat pop currentdict end) cvx def - end end -} def -userdict /discardDict 4 dict dup begin put -0 { 0 1 0 setrgbcolor } def -2 { 0 0 1 setrgbcolor } def +/ShadeKit 12 dict def ShadeKit begin +% A Level 1 way to make a dictionary of the pairs above a mark. +/pairs (counttomark 2 idiv dict begin { counttomark 0 eq { exit } if def } loop pop currentdict end) cvx def +/close /languagelevel where { pop languagelevel 2 ge } { false } ifelse { (>>) } { (pairs) } ifelse cvx def +/open /mark load def +/actions 3 dict def actions begin 0 { 0 1 0 setrgbcolor } def 1 { 1 0 0 setrgbcolor } def end +/act { actions 1 index known { actions begin load end stopped pop } { pop } ifelse } bind def end -/gt38? false def -/discard { discardDict begin /endString exch def gt38? { 2 add } if load stopped pop end } bind def %%EndProlog -initialize -AGM_Gradient begin AGM_Gradient_private begin -bd /ShadingType 3 /ColorSpace /DeviceRGB - /Function bd /FunctionType 2 /Domain [0 1] /C0 [1 1 0] /C1 [0 0.5 0] /N 1 ed - /Extend [true true] /Coords [50 50 0 50 50 40] ed +ShadeKit begin +open /ShadingType 3 /ColorSpace /DeviceRGB + /Function open /FunctionType 2 /Domain [0 1] /C0 [1 1 0] /C1 [0 0.5 0] /N 1 close + /Extend [true true] /Coords [50 50 0 50 50 40] close gsave 10 10 80 80 rectclip shfill grestore -bd /Width 3 ed1 /Width get 3 eq { 0 (%AI5_EndPalette) discard 10 10 20 20 rectfill } if -end end +mark /Width 3 pairs /Width get 3 eq { 0 act 10 10 20 20 rectfill } if +2 act +end (x) cvx xcheck (x) cvx cvlit xcheck not and { 50 50 10 10 rectfill } if showpage"##; - let r = open("Adobe Illustrator(R) 8.0", program); + let r = open("Example Generator 1.0", program); let d = &r.document; let Some(Paint::Gradient(g)) = all(d).into_iter().find_map(|n| fill(&n).cloned()) else { panic!("no gradient") }; assert_eq!(g.gradient.kind, vectorcraft_color::GradientKind::Radial); - // `discard` ran the procedure under key 0 (green), not the one under 2. + // `act` ran the procedure under key 0 (green); there is none under key 2. assert!(all(d).iter().any(|n| fill(n).and_then(Paint::color) == Some(Color::rgb(0.0, 1.0, 0.0)))); assert_eq!(objects(d).len(), 3); } diff --git a/crates/eps/src/import/tests_illustrator.rs b/crates/eps/src/import/tests_illustrator.rs index d22fddb1..a3124af1 100644 --- a/crates/eps/src/import/tests_illustrator.rs +++ b/crates/eps/src/import/tests_illustrator.rs @@ -20,6 +20,9 @@ fn ai(header: &str, ugroup: &str, body: &str) -> Vec { .into_bytes() } +/// A legacy Illustrator format header: the reader takes `u` … `U` as groups only in files whose +/// header says they are in that format (`%AI…` comments or the creator, which the format's +/// published specification documents; see the `import` module docs). const AI8: &str = "%%Creator: Adobe Illustrator(R) 8.0\n%AI5_FileFormat 4.0\n"; /// A triangle filled at `x`. From 1d265951df1c067d122142c11cbbf26e71281673 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 23:43:49 +0700 Subject: [PATCH 11/22] Fix #498: EPS images with several data sources read them in turn MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit An image can take one data source per colour component (MultipleDataSources, or `colorimage` with multi true). The PostScript Language Reference (3rd ed., §4.10 "Images" and `image`/`colorimage` in chapter 8) has the operator read the sources in turn, the same amount from each. The reader drained each source on its own instead: when the sources are procedures reading one file a row at a time, the first plane took the rows of every component and the image came out in sheared horizontal bands, as in #498. - Data sources are read in turn by one reader, `read_sources`: a procedure once a round, a file or string a row a round, until each plane is full or its source ends. Single sources, procedure filters and masked images use it too; a string source resumes where it left off. - Tests (`tests_images.rs`, programs written from the reference): procedures reading one file in the dictionary and `colorimage` operand forms (fails without the fix), separate string sources, rows padded to a byte at 1, 2, 4, 12 and 16 bits with an odd width (one and several sources), Flate PNG predictors with every row filter at an odd width. The import fuzz vocabulary has several sources reading one file and sources of uneven lengths. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 4 +- crates/engine/tests/import_fuzz.rs | 4 + crates/eps/src/import/data.rs | 72 +++++++----- crates/eps/src/import/mod.rs | 2 + crates/eps/src/import/tests_generators.rs | 2 +- crates/eps/src/import/tests_images.rs | 130 ++++++++++++++++++++++ 6 files changed, 182 insertions(+), 32 deletions(-) create mode 100644 crates/eps/src/import/tests_images.rs diff --git a/ROADMAP.md b/ROADMAP.md index 9e298c30..9d7eccea 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -155,7 +155,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Files (M4):** - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465). - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396; a top-level group with a clip path, such as a clipped Inkscape layer, opens as a layer with a clipping mask, its name kept: #420); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers, on pages of up to 64 million operators, art whose layer can't be told going to a hidden, non-printing layer rather than showing or printing: #419; strokes kept live, a fill and a stroke of one outline as one object; a type object's stroke written as each glyph's outline stroked back on the type, so it stays one editable object; lines wrapped in a frame (each wrapped line ending in a space, one left edge, leading and font) back as one area type object, left aligned or justified with its paragraph spacing, where laying it out breaks the lines where the file does; glyphs set apart by gaps wider than a space (a barcode's digit groups) keeping their places; layers stacked as the pages mark them even when one first paints on a later page, art ending a layer's marked content or a clip closing in a later layer kept in its own layer, and layers with no art kept empty: #508; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320). - - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read. Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). + - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398); on Linux the Paste menu checks the clipboard off the UI thread, so an X11 owner that never answers can't freeze the window (#510); screenshots and other copied pictures paste as embedded images at the view centre everywhere, the web included (#457). - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped. - **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software), and if the window fails on one while starting up it starts again without it instead of crashing; Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Liquify tools' Use Pressure Pen on Windows, while winit 0.30 reports none on macOS or Linux and egui none on the web. On Linux, see `docs/development.md` for pens under Wayland. diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs index aa2f8c7f..3cd971d1 100644 --- a/crates/engine/tests/import_fuzz.rs +++ b/crates/engine/tests/import_fuzz.rs @@ -953,6 +953,10 @@ fn arb_ps_token() -> impl Strategy { "/T3 << /FontType 3 /FontMatrix [0.1 0 0 0.1 0 0] /FontBBox [0 0 9 9] /Encoding [/a /b] /BuildChar { pop pop 9 0 setcharwidth 0 0 5 5 rectfill } >> definefont setfont", "/T4 << /FontType 3 /FontMatrix [1 0 0 1 0 0] /BuildGlyph { pop pop (x) show } /Encoding [/a] >> definefont setfont", "glyphshow", "xshow", "xyshow", "awidthshow", "kshow", "/a", "[1 2 3]", + // Several data sources reading one file in turn, and sources of uneven lengths. + "/f currentfile /ASCIIHexDecode filter def", "{f 3 string readstring pop}", "{f 0 string readstring pop}", "true 3 colorimage", + "3 2 8 [3 0 0 2 0 0] {f 5 string readstring pop} {(ab)} {f 1 string readstring pop} true 3 colorimage", + "<< /ImageType 1 /Width 3 /Height 2 /BitsPerComponent 4 /Decode [0 1 0 1 0 1 0 1] /ImageMatrix [3 0 0 2 0 0] /MultipleDataSources true /DataSource [(a) (bc) {f 2 string readstring pop} (d)] >>", // Executable strings and keys other than names (PLRM 3rd ed., `cvx`, `load`). "(>>) cvx", "(1 2 add) cvx exec", "(x) cvx dup exec", "0 load", "1 { } def", "(mark) cvx cvlit" ]) diff --git a/crates/eps/src/import/data.rs b/crates/eps/src/import/data.rs index 4a8d56d0..c91e658d 100644 --- a/crates/eps/src/import/data.rs +++ b/crates/eps/src/import/data.rs @@ -635,33 +635,51 @@ impl Interp<'_> { /// The bytes a data procedure gives, called until it gives an empty string or `n` bytes. fn gather(&mut self, p: &Obj, n: usize) -> Res> { - let mut out = vec![]; - while out.len() < n { - self.call(p.clone())?; - let s = self.pop_str()?; - let s = s.borrow(); - if s.is_empty() { - break; - } - self.alloc(s.len())?; - out.extend_from_slice(&s); - } - out.truncate(n); - Ok(out) + Ok(self.read_sources(&[Source::Proc(p.clone())], n, n)?.pop().unwrap_or_default()) } /// `n` bytes of image data from `src` (zeros past its end). fn source_bytes(&mut self, src: &Source, n: usize) -> Res> { - let mut v = match src { - Source::File(f) => self.read(f, n)?, - Source::Str(s) if !s.is_empty() => s.iter().copied().cycle().take(n).collect(), - Source::Str(_) => vec![], - Source::Proc(p) => self.gather(p, n)?, - }; + let mut v = self.read_sources(std::slice::from_ref(src), n, n)?.pop().unwrap_or_default(); v.resize(n, 0); Ok(v) } + /// Up to `n` bytes from each of `sources`, read in turn as an image reads several data sources + /// (PLRM 3rd ed., §4.10 "Images" and `image`/`colorimage` in chapter 8: the sources are read + /// in turn, the same amount from each): each procedure called once a round (its string, + /// whatever its length), each file and string giving `step` bytes a round, until each has + /// given `n` bytes or ended. Procedures that read one file get their own rows that way. + fn read_sources(&mut self, sources: &[Source], n: usize, step: usize) -> Res>> { + let mut out: Vec> = vec![vec![]; sources.len()]; + let mut ended = vec![false; sources.len()]; + while out.iter().zip(&ended).any(|(o, e)| o.len() < n && !e) { + for ((src, o), e) in sources.iter().zip(out.iter_mut()).zip(ended.iter_mut()) { + if *e || o.len() >= n { + continue; + } + let want = step.min(n - o.len()); + let chunk = match src { + Source::File(f) => self.read(f, want)?, + // A string gives its bytes over and over. + Source::Str(s) => { + let at = o.len() % s.len().max(1); + s.get(at..).unwrap_or_default().iter().chain(s.iter().cycle()).take(want).copied().collect() + } + Source::Proc(p) => { + self.call(p.clone())?; + let s = self.pop_str()?.to_vec(); + self.alloc(s.len())?; + s + } + }; + *e = chunk.is_empty(); + o.extend_from_slice(chunk.get(..chunk.len().min(n - o.len())).unwrap_or_default()); + } + } + Ok(out) + } + /// `eexec`: an encrypted font program follows. It is skipped (type is drawn in the app's /// fonts, by name): the font dictionary it would complete is defined as it is. fn eexec(&mut self) -> Res { @@ -849,16 +867,12 @@ impl Interp<'_> { let multi = s.sources.len() > 1; let row_bits = if multi { s.w * bpc } else { s.w * n * bpc }; let row = row_bits.div_ceil(8); - let planes: Vec> = if multi { - let mut v = vec![]; - for src in &s.sources { - v.push(self.source_bytes(src, row * s.h)?); - } - v - } else { - let src = s.sources.first().ok_or(PsError::Ps("undefined", "DataSource".into()))?; - vec![self.source_bytes(src, row * s.h)?] - }; + // Several sources are read in turn, a row at a time each (zeros past their ends). + let sources = if multi { &s.sources[..] } else { s.sources.get(..1).ok_or(PsError::Ps("undefined", "DataSource".into()))? }; + let mut planes = self.read_sources(sources, row * s.h, if multi { row } else { row * s.h })?; + for p in &mut planes { + p.resize(row * s.h, 0); + } let max = ((1u32 << bpc.min(16)) - 1) as f64; let sample = |plane: &[u8], y: usize, i: usize| -> u32 { let bit = y * row * 8 + i * bpc; diff --git a/crates/eps/src/import/mod.rs b/crates/eps/src/import/mod.rs index bf03d95c..dbcc84ca 100644 --- a/crates/eps/src/import/mod.rs +++ b/crates/eps/src/import/mod.rs @@ -41,6 +41,8 @@ mod tests_fontnames; mod tests_generators; #[cfg(test)] mod tests_illustrator; +#[cfg(test)] +mod tests_images; use std::sync::Arc; diff --git a/crates/eps/src/import/tests_generators.rs b/crates/eps/src/import/tests_generators.rs index 6bc08d5e..4f4e6521 100644 --- a/crates/eps/src/import/tests_generators.rs +++ b/crates/eps/src/import/tests_generators.rs @@ -42,7 +42,7 @@ fn a85_flate(data: &[u8]) -> String { } /// Pixel `(x, y)` (straight RGBA) of the first image in `d`. -fn pixel(d: &Document, x: u32, y: u32) -> [u8; 4] { +pub(super) fn pixel(d: &Document, x: u32, y: u32) -> [u8; 4] { let im = all(d) .into_iter() .find_map(|n| match &n.kind { diff --git a/crates/eps/src/import/tests_images.rs b/crates/eps/src/import/tests_images.rs new file mode 100644 index 00000000..641cd1ac --- /dev/null +++ b/crates/eps/src/import/tests_images.rs @@ -0,0 +1,130 @@ +//! Image data read as the PostScript Language Reference (3rd ed.) defines it: several data sources +//! read in turn (§4.10 "Images", `image` and `colorimage` in chapter 8), rows padded to a whole +//! byte at every bit depth and odd widths (§4.10), and Flate predictors undone row by row (§3.13, +//! `FlateDecode` parameters) (#498). + +use super::tests::read; +use super::tests_generators::pixel; + +/// Each pixel of the first image, row by row. +fn pixels(r: &crate::Imported, w: u32, h: u32) -> Vec<[u8; 4]> { + assert!(!r.preview && r.warnings.is_empty(), "{:?}", r.warnings); + (0..h).flat_map(|y| (0..w).map(move |x| (x, y))).map(|(x, y)| pixel(&r.document, x, y)).collect() +} + +/// A CMYK image whose four data sources are procedures reading one file, a row of one ink each: +/// the image operator calls them in turn, so each gets its own rows. Read one after the other, +/// the cyan source took the first four rows of all four inks and the image came out in +/// horizontal bands (#498). +#[test] +fn procedures_reading_one_file_are_read_in_turn() { + // 3 × 2 pixels; rows: C M Y K of row 0, then of row 1. + let rows = ["ff0000", "00ff00", "000000", "000000", "000000", "000000", "ffff00", "0000ff"]; + let r = read(&format!( + "/DeviceCMYK setcolorspace 30 20 scale /f currentfile /ASCIIHexDecode filter def \ + << /ImageType 1 /Width 3 /Height 2 /BitsPerComponent 8 /Decode [0 1 0 1 0 1 0 1] /ImageMatrix [3 0 0 -2 0 2] \ + /MultipleDataSources true /DataSource [ {{f 3 string readstring pop}} {{f 3 string readstring pop}} \ + {{f 3 string readstring pop}} {{f 3 string readstring pop}} ] >> image\n{}>", + rows.concat() + )); + let cyan = [0, 174, 239, 255]; + let magenta = [236, 0, 140, 255]; + let yellow = [255, 242, 0, 255]; + let black = [35, 31, 32, 255]; + let white = [255, 255, 255, 255]; + let px = pixels(&r, 3, 2); + let near = |a: [u8; 4], b: [u8; 4]| a.iter().zip(b).all(|(x, y)| x.abs_diff(y) <= 40); + let want = [cyan, magenta, white, yellow, yellow, black]; + assert!(px.iter().zip(want).all(|(a, b)| near(*a, b)), "{px:?}"); + + // The operand form: `{r} {g} {b} true 3 colorimage`, procedures reading one file. + let r = read( + "30 20 scale /f currentfile /ASCIIHexDecode filter def \ + 3 2 8 [3 0 0 -2 0 2] {f 3 string readstring pop} {f 3 string readstring pop} {f 3 string readstring pop} true 3 colorimage\n\ + ff0000 00ff00 0000ff 102030 405060 708090>", + ); + assert_eq!(pixels(&r, 3, 2), [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [16, 64, 112, 255], [32, 80, 128, 255], [48, 96, 144, 255]]); +} + +/// Separate strings and files as the sources: each is read for its own plane, whatever the row. +#[test] +fn separate_sources_keep_their_planes() { + let r = read("30 20 scale 3 2 8 [3 0 0 -2 0 2] <00ff00405060> <0000ff708090> true 3 colorimage"); + assert_eq!(pixels(&r, 3, 2), [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [16, 64, 112, 255], [32, 80, 128, 255], [48, 96, 144, 255]]); +} + +/// Rows of an odd width at 1, 2, 4, 12 and 16 bits a sample start at a byte (their last byte +/// padded), in one source and in several. +#[test] +fn rows_of_every_depth_start_at_a_byte() { + // 3 pixels a row, two rows: 0, max, mid / max, 0, 0 (grey), each row padded. + let cases = [ + (1, "a0 80"), // 101(00000) 100(00000) + (2, "cc c0"), // 11 00 11 (00), 11 00 00 (00) + (4, "f0 80 f0 00"), // f 0 8 (0), f 0 0 (0) + (12, "fff0008000 fff0000000"), // fff 000 800 (0), fff 000 000 (0) + (16, "ffff00008000 ffff00000000"), + ]; + for (bpc, data) in cases { + let data = data.replace(' ', ""); + let r = read(&format!("30 20 scale 3 2 {bpc} [3 0 0 -2 0 2] <{data}> image")); + let px: Vec = pixels(&r, 3, 2).iter().map(|p| p[0]).collect(); + let want: &[u8] = match bpc { + 1 => &[255, 0, 255, 255, 0, 0], + 2 => &[255, 0, 255, 255, 0, 0], + 4 => &[255, 0, 136, 255, 0, 0], + 12 => &[255, 0, 128, 255, 0, 0], + _ => &[255, 0, 128, 255, 0, 0], + }; + assert_eq!(px, want, "{bpc} bits"); + } + // Several 4-bit sources, odd width: each plane's rows padded on their own. + let r = read("30 20 scale 3 2 4 [3 0 0 -2 0 2] <0f00f000> <00f00ff0> true 3 colorimage"); + let (on, off) = (255, 0); + let want = [[on, off, off], [off, on, off], [on, off, on], [off, on, off], [off, off, on], [on, off, on]]; + assert_eq!(pixels(&r, 3, 2), want.map(|[r, g, b]| [r, g, b, 255])); +} + +/// A PNG-predicted Flate image of an odd width: every row filter (None, Sub, Up, Average, Paeth) +/// undone on its own row. +#[test] +fn predicted_rows_of_an_odd_width() { + // 3 RGB pixels a row, five rows; each row predicted with its own filter. + let raw: Vec<[u8; 9]> = (0..5u8).map(|y| std::array::from_fn(|i| (i as u8).wrapping_mul(29).wrapping_add(y.wrapping_mul(53)))).collect(); + let mut encoded = vec![]; + let mut prev = [0u8; 9]; + for (kind, row) in raw.iter().enumerate() { + encoded.push(kind as u8); + for i in 0..9 { + let a = if i >= 3 { row[i - 3] } else { 0 }; + let b = prev[i]; + let c = if i >= 3 { prev[i - 3] } else { 0 }; + let pred = match kind { + 1 => a, + 2 => b, + 3 => ((u16::from(a) + u16::from(b)) / 2) as u8, + 4 => { + let p = i16::from(a) + i16::from(b) - i16::from(c); + let (pa, pb, pc) = ((p - i16::from(a)).abs(), (p - i16::from(b)).abs(), (p - i16::from(c)).abs()); + if pa <= pb && pa <= pc { + a + } else if pb <= pc { + b + } else { + c + } + } + _ => 0, + }; + encoded.push(row[i].wrapping_sub(pred)); + } + prev = *row; + } + let r = read(&format!( + "/DeviceRGB setcolorspace 30 50 scale << /ImageType 1 /Width 3 /Height 5 /BitsPerComponent 8 /Decode [0 1 0 1 0 1] /ImageMatrix [3 0 0 -5 0 5] \ + /DataSource currentfile /ASCII85Decode filter << /Predictor 15 /Colors 3 /Columns 3 >> /FlateDecode filter >> image\n{}", + crate::ps::ascii85(&crate::ps::deflate(&encoded)) + )); + let want: Vec<[u8; 4]> = raw.iter().flat_map(|row| (0..3).map(move |x| [row[3 * x], row[3 * x + 1], row[3 * x + 2], 255])).collect(); + assert_eq!(pixels(&r, 3, 5), want); +} From b43b15a6e839b9ebb5732ad598863ded0141afa2 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 23:43:51 +0700 Subject: [PATCH 12/22] Part of #505: restore puts dictionaries back as they were at the save MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The PostScript Language Reference (3rd ed., §3.7.3 "Save and Restore") has `restore` reset composite objects in local VM to their values at the `save`. The reader only restored the graphics state, so dictionary entries changed between `save` and `restore` stayed changed: a program that counts its open saves in a dictionary and refuses to go past a depth stopped after that many saves in sequence, and the file fell back to its preview. EPS files with many images, each drawn between `save` and `restore`, are a likely case of #505; its reporter hasn't sent a file, so this is part of it. - While a `save` is open, `def`, `store`, `put`, `undef` and dictionary `copy` keep each entry's old value in a journal (counted against the memory budget); `restore` undoes it, newest change first, down to its save. A save restored already, itself or through an outer one, is no longer valid (`invalidrestore`, §3.7.3). - `cachestatus` reports a device's cache sizes (chapter 8) instead of zeros: its last value, the most bytes one cached glyph may take, is what programs divide by. - Tests (programs written from the reference): 100 saves counted in a dictionary under a depth limit, each dictionary change undone, saves restored twice, `cachestatus`'s glyph limit. Mutation-checked: without the journal or with a zero `cachestatus` the test fails. The import fuzz vocabulary has saves and restores around dictionary changes. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 4 +- crates/engine/tests/import_fuzz.rs | 2 + crates/eps/src/import/interp.rs | 85 +++++++++++++++++------ crates/eps/src/import/tests_generators.rs | 27 +++++++ 4 files changed, 96 insertions(+), 22 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 9d7eccea..1e477316 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -155,7 +155,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Files (M4):** - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465). - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396; a top-level group with a clip path, such as a clipped Inkscape layer, opens as a layer with a clipping mask, its name kept: #420); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers, on pages of up to 64 million operators, art whose layer can't be told going to a hidden, non-printing layer rather than showing or printing: #419; strokes kept live, a fill and a stroke of one outline as one object; a type object's stroke written as each glyph's outline stroked back on the type, so it stays one editable object; lines wrapped in a frame (each wrapped line ending in a space, one left edge, leading and font) back as one area type object, left aligned or justified with its paragraph spacing, where laying it out breaks the lines where the file does; glyphs set apart by gaps wider than a space (a barcode's digit groups) keeping their places; layers stacked as the pages mark them even when one first paints on a later page, art ending a layer's marked content or a clip closing in a later layer kept in its own layer, and layers with no art kept empty: #508; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320). - - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). + - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). `restore` puts dictionaries back as they were at the `save`, so programs that count their saves in a dictionary read to their end (part of #505). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398); on Linux the Paste menu checks the clipboard off the UI thread, so an X11 owner that never answers can't freeze the window (#510); screenshots and other copied pictures paste as embedded images at the view centre everywhere, the web included (#457). - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped. - **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software), and if the window fails on one while starting up it starts again without it instead of crashing; Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Liquify tools' Use Pressure Pen on Windows, while winit 0.30 reports none on macOS or Linux and egui none on the web. On Linux, see `docs/development.md` for pens under Wayland. diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs index 3cd971d1..83450a86 100644 --- a/crates/engine/tests/import_fuzz.rs +++ b/crates/engine/tests/import_fuzz.rs @@ -957,6 +957,8 @@ fn arb_ps_token() -> impl Strategy { "/f currentfile /ASCIIHexDecode filter def", "{f 3 string readstring pop}", "{f 0 string readstring pop}", "true 3 colorimage", "3 2 8 [3 0 0 2 0 0] {f 5 string readstring pop} {(ab)} {f 1 string readstring pop} true 3 colorimage", "<< /ImageType 1 /Width 3 /Height 2 /BitsPerComponent 4 /Decode [0 1 0 1 0 1 0 1] /ImageMatrix [3 0 0 2 0 0] /MultipleDataSources true /DataSource [(a) (bc) {f 2 string readstring pop} (d)] >>", + // Local VM restored: dictionary changes undone, saves restored twice. + "/a 1 def save /a 2 def", "restore", "save dup restore", "1 dict save exch /k 1 put", "cachestatus", "/n 0 def save /n n 1 add store", // Executable strings and keys other than names (PLRM 3rd ed., `cvx`, `load`). "(>>) cvx", "(1 2 add) cvx exec", "(x) cvx dup exec", "0 load", "1 { } def", "(mark) cvx cvlit" ]) diff --git a/crates/eps/src/import/interp.rs b/crates/eps/src/import/interp.rs index 1a1d8005..6104d1b5 100644 --- a/crates/eps/src/import/interp.rs +++ b/crates/eps/src/import/interp.rs @@ -49,6 +49,12 @@ pub(crate) struct Interp<'a> { /// Bytes asked for so far (see [`MAX_MEMORY`]). allocated: usize, seed: u32, + /// The `save`s not restored yet, oldest first. + saves: Vec, + /// What dictionary entries were before they changed since the oldest `save` (dictionary, + /// key, old value): `restore` puts them back, as restoring local VM does (PLRM 3rd ed., + /// §3.7.3 "Save and Restore": composite objects get the values they had at the `save`). + journal: Vec<(DictRef, Key, Option)>, /// Where the error that is unwinding was raised (see [`Fault`]). pub fault: Option, /// The width a Type 3 glyph procedure gave (`setcachedevice`, `setcharwidth`). @@ -72,6 +78,13 @@ pub(crate) struct Fault { /// Most procedure names a [`Fault`] keeps. const FAULT_PROCS: usize = 3; +/// Where a `save` was made: the graphics states saved and the journal's length then. +#[derive(Clone, Copy, Debug)] +struct SaveMark { + gstates: usize, + journal: usize, +} + fn new_dict() -> DictRef { Rc::new(RefCell::new(Dict::new())) } @@ -143,6 +156,8 @@ impl<'a> Interp<'a> { ops: 0, allocated: 0, seed: 1, + saves: vec![], + journal: vec![], fault: None, glyph_width: None, g, @@ -190,6 +205,7 @@ impl<'a> Interp<'a> { } self.dicts.clear(); self.stack.clear(); + self.journal.clear(); } // ---------- the operand stack ---------- @@ -879,7 +895,7 @@ impl<'a> Interp<'a> { } Obj::Dict(d) => { let key = k.key().ok_or(PsError::Ps("typecheck", String::new()))?; - insert(&d, key, v)?; + self.insert(&d, key, Some(v))?; true } _ => return ps_err("typecheck", ""), @@ -968,7 +984,7 @@ impl<'a> Interp<'a> { let v = self.pop()?; let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", String::new()))?; let d = self.dicts.last().cloned().ok_or(PsError::Ps("dictstackunderflow", String::new()))?; - insert(&d, k, v)?; + self.insert(&d, k, Some(v))?; } Load => { let k = self.pop()?; @@ -981,7 +997,7 @@ impl<'a> Interp<'a> { let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", String::new()))?; let d = self.dicts.iter().rev().find(|d| d.borrow().contains_key(&k)).or(self.dicts.last()).cloned(); let d = d.ok_or(PsError::Ps("dictstackunderflow", String::new()))?; - insert(&d, k, v)?; + self.insert(&d, k, Some(v))?; } Known => { let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", String::new()))?; @@ -1001,7 +1017,8 @@ impl<'a> Interp<'a> { } Undef => { let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", String::new()))?; - self.pop_dict()?.borrow_mut().remove(&k); + let d = self.pop_dict()?; + self.insert(&d, k, None)?; } CurrentDict => { let d = self.dicts.last().cloned().ok_or(PsError::Ps("dictstackunderflow", String::new()))?; @@ -1034,11 +1051,24 @@ impl<'a> Interp<'a> { } Save => { self.gsave()?; - self.push(Obj::Save(self.saved.len()))?; + self.push(Obj::Save(self.saves.len()))?; + self.saves.push(SaveMark { gstates: self.saved.len(), journal: self.journal.len() }); } Restore => { - let Obj::Save(level) = self.pop()? else { return ps_err("typecheck", "") }; - while self.saved.len() >= level && !self.saved.is_empty() { + let Obj::Save(i) = self.pop()? else { return ps_err("typecheck", "") }; + // A save restored already (or through an outer one) is no longer valid: §3.7.3, + // `invalidrestore`. + let mark = self.saves.get(i).copied().ok_or(PsError::Ps("invalidrestore", String::new()))?; + self.saves.truncate(i); + // The dictionaries as they were at the save, newest change undone first. + for (d, k, old) in self.journal.drain(mark.journal..).rev() { + let mut d = d.borrow_mut(); + match old { + Some(v) => d.insert(k, v), + None => d.remove(&k), + }; + } + while self.saved.len() >= mark.gstates && !self.saved.is_empty() { self.grestore(); } } @@ -1083,9 +1113,12 @@ impl<'a> Interp<'a> { self.push(Obj::Int(1 << 20))?; } } + // An empty font cache of a device's sizes, in `cachestatus`'s order (PLRM 3rd ed., + // chapter 8): bytes used and most, fonts used and most, glyphs used and most, and the + // most bytes one cached glyph may take (positive on a real device: programs divide by it). CacheStatus => { - for _ in 0..7 { - self.push(Obj::Int(0))?; + for v in [0, 1 << 20, 0, 1000, 0, 10_000, 25_000] { + self.push(Obj::Int(v))?; } } StartJob => { @@ -1143,7 +1176,9 @@ impl<'a> Interp<'a> { } Obj::Dict(d) => { let from = self.pop_dict()?.borrow().clone(); - d.borrow_mut().extend(from); + for (k, v) in from { + self.insert(&d, k, Some(v))?; + } self.push(Obj::Dict(d))?; } _ => return ps_err("typecheck", "copy"), @@ -1219,6 +1254,26 @@ impl<'a> Interp<'a> { } } + /// Put `v` under `k` in `d` (`None`: remove it), within [`MAX_ALLOC`] entries; while a `save` + /// is open the old value is kept for `restore`. + fn insert(&mut self, d: &DictRef, k: Key, v: Option) -> Res { + let old = { + let mut dm = d.borrow_mut(); + if v.is_some() && dm.len() >= MAX_ALLOC && !dm.contains_key(&k) { + return Err(PsError::Limit("a dictionary grew too large")); + } + match v { + Some(v) => dm.insert(k.clone(), v), + None => dm.remove(&k), + } + }; + if !self.saves.is_empty() { + self.alloc(2 * std::mem::size_of::())?; + self.journal.push((d.clone(), k, old)); + } + Ok(()) + } + // ---------- resources ---------- /// The resources of `category`. @@ -1293,16 +1348,6 @@ impl<'a> Interp<'a> { } } -/// Put `v` under `k` in `d`, within [`MAX_ALLOC`] entries. -fn insert(d: &DictRef, k: Key, v: Obj) -> Res { - let mut d = d.borrow_mut(); - if d.len() >= MAX_ALLOC && !d.contains_key(&k) { - return Err(PsError::Limit("a dictionary grew too large")); - } - d.insert(k, v); - Ok(()) -} - /// An array or string index. fn index(k: &Obj) -> Res { match *k { diff --git a/crates/eps/src/import/tests_generators.rs b/crates/eps/src/import/tests_generators.rs index 4f4e6521..e5ad7c4d 100644 --- a/crates/eps/src/import/tests_generators.rs +++ b/crates/eps/src/import/tests_generators.rs @@ -932,3 +932,30 @@ showpage"##; assert!(all(d).iter().any(|n| fill(n).and_then(Paint::color) == Some(Color::rgb(0.0, 1.0, 0.0)))); assert_eq!(objects(d).len(), 3); } + +/// `restore` puts local VM back as it was at the `save` (PLRM 3rd ed., §3.7.3 "Save and +/// Restore"): dictionaries get back the entries they had, whatever changed them. A program that +/// keeps a count of the saves it has open in a dictionary, and refuses to go past a depth, reads +/// to its end only if each `restore` puts the count back (part of #505: files with many images, +/// each drawn between `save` and `restore`). +#[test] +fn restore_puts_dictionaries_back() { + let r = read( + "/Depth 2 dict def Depth /open 0 put \ + /enter { save Depth /open get 1 add dup 8 gt { rangecheck } if Depth exch /open exch put } def \ + 1 1 100 { pop enter 0 0 1 1 rectfill restore } for Depth /open get 0 eq { 10 10 5 5 rectfill } if", + ); + clean(&r); + assert_eq!(objects(&r.document).len(), 101); + // `def`, `store`, `put`, `undef` and dictionary `copy` are undone, newest first. + super::tests::check( + "/a 1 def /d 2 dict def d /k 1 put save /a 2 def /b 3 def d /k 2 put d /k undef 1 dict dup /z 9 put d copy pop \ + /a 4 store restore a 1 eq /b where not and d /k get 1 eq and d /z known not and", + ); + // A save restored (itself, or through an outer one) is no longer valid: `invalidrestore`. + super::tests::check("save dup restore { restore } stopped"); + super::tests::check("save save exch restore { restore } stopped"); + // `cachestatus` gives a device's cache sizes; its last, the most bytes one cached glyph may + // take, is positive (chapter 8), and programs divide by it. + super::tests::check("cachestatus 7 1 roll 6 { pop } repeat 0 gt"); +} From ab65474044ff9f1caf04e74f3550c642c97298c0 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Thu, 8 Oct 2026 20:24:41 +0700 Subject: [PATCH 13/22] macOS: the menus live in the system menu bar, settings in the VectorCraft menu MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On macOS the menus are in the system menu bar, laid out as a Mac app's (Illustrator on the Mac as the reference), and the app settings sit in the VectorCraft menu: About, Settings ▸ (one item per Preferences page, General… ⌘K), Language ▸, Appearance ▸ (UI brightness), Services, Hide VectorCraft ⌃⌘H (⌘H stays View › Hide Edges), Hide Others ⌥⌘H, Show All and Quit ⌘Q (the app's own quit, so unsaved documents are asked about); they leave Edit and Help. Window gets Minimize ⌃⌘M, Zoom and Bring All to Front; Help is the system's Help menu. Windows, Linux and the web keep the in-window menu bar unchanged; --in-window-menus or VECTORCRAFT_IN_WINDOW_MENUS keeps it on macOS too, and so does a menu bar AppKit refuses to build. One menu model: the in-window menus and the native bar draw the same rows (menus::entry), and the platform-free native_menu module lays them out, decides when to update (a cheap state hash; labels, enabled and checked in place, a rebuild only when the structure changes) and hands key equivalents back to egui as the key presses they were, so shortcuts, user overrides and focused text fields behave as in the window and nothing fires twice. The muda backend (pinned =0.21.1, macOS only, no unsafe) is apps/vectorcraft/src/mac_menu.rs, mirroring PhotoCraft's. ui.inspect reports nativeMenuBar. Translations for the new labels in ja, es, zh-hans, zh-hant, cs and pt-br. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 7 +- ROADMAP.md | 5 +- apps/vectorcraft/Cargo.toml | 6 +- apps/vectorcraft/src/mac_menu.rs | 367 ++++++++++++ apps/vectorcraft/src/main.rs | 39 +- apps/vectorcraft/src/native_menu.rs | 183 ------ crates/ui-egui/src/chrome.rs | 3 +- crates/ui-egui/src/control.rs | 2 + .../src/dialogs/perspective_presets.rs | 5 - .../ui-egui/src/dialogs/tests_perspective.rs | 6 +- crates/ui-egui/src/i18n/cs.tsv | 21 + crates/ui-egui/src/i18n/es.tsv | 7 + crates/ui-egui/src/i18n/it.tsv | 7 + crates/ui-egui/src/i18n/ja.tsv | 8 + crates/ui-egui/src/i18n/pt-br.tsv | 8 + crates/ui-egui/src/i18n/tests.rs | 3 + crates/ui-egui/src/i18n/zh-hans.tsv | 6 + crates/ui-egui/src/i18n/zh-hant.tsv | 7 + crates/ui-egui/src/lib.rs | 25 +- crates/ui-egui/src/menus.rs | 250 +++++---- crates/ui-egui/src/native_menu.rs | 528 ++++++++++++++++++ crates/ui-egui/src/shortcuts.rs | 28 +- crates/ui-egui/src/tests_nativemenu.rs | 422 ++++++++++++++ crates/ui-egui/src/tests_save.rs | 2 +- docs/control-protocol.md | 2 +- docs/development.md | 10 + 26 files changed, 1608 insertions(+), 349 deletions(-) create mode 100644 apps/vectorcraft/src/mac_menu.rs delete mode 100644 apps/vectorcraft/src/native_menu.rs create mode 100644 crates/ui-egui/src/native_menu.rs create mode 100644 crates/ui-egui/src/tests_nativemenu.rs diff --git a/Cargo.lock b/Cargo.lock index 427c3dcc..f7a94e40 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2283,9 +2283,9 @@ dependencies = [ [[package]] name = "muda" -version = "0.21.0" +version = "0.21.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6744ab645ebe79f9c428455c7cb9dfa4275fa3b50a25408e08f927da8dc618c" +checksum = "9a7b000cca0783af26837fe2ebd9ddf1c42279463c085b97622ee1d2f444b89e" dependencies = [ "crossbeam-channel", "dpi", @@ -2294,7 +2294,6 @@ dependencies = [ "objc2-app-kit 0.3.2", "objc2-core-foundation", "objc2-foundation 0.3.2", - "once_cell", "png 0.18.1", "thiserror 2.0.21", "windows-sys 0.61.2", @@ -2777,7 +2776,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] diff --git a/ROADMAP.md b/ROADMAP.md index 1e477316..5cc39bf4 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -42,7 +42,7 @@ since 2026-10-01. | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing | | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine | | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA | -| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) | +| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) | | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel | | **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) | @@ -103,6 +103,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - The dock's double arrow collapses Properties, Layers and Libraries to icons at the top of the icon column, popping out like the other icon panels, and expands them again (`window.collapseDock`, kept with the preferences and in saved workspaces). The icon column's own arrow (expanding the icon panels into a full column) is not done. - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese, Spanish and Italian ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows, Linux and the web (the browser's languages, or `?lang=`), a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins). - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool. + - The macOS menu bar is built from the in-window menus (one model, `native_menu`) and laid out as a Mac app's: the VectorCraft menu holds About, Settings ▸ (each Preferences page, General… ⌘K), Language ▸, Appearance ▸ (UI brightness), Services, Hide VectorCraft ⌃⌘H (⌘H stays Hide Edges), Hide Others, Show All and Quit; Window gains Minimize ⌃⌘M, Zoom and Bring All to Front, and Help the system's search field. Its key equivalents go back to egui as key presses, so user shortcuts, focused text fields and the Type tool's input method behave as in the window, and nothing fires twice; enabled, check marks and labels update in place. `--in-window-menus` or `VECTORCRAFT_IN_WINDOW_MENUS=1` keeps the menus in the window; `ui.inspect` reports `nativeMenuBar`. - macOS: Finder opens every format File › Open reads with VectorCraft (double-click, Open With, a drop on the Dock icon, `open -a`), at launch or while it runs; the release and `cargo xtask bundle` apps share one `Info.plist` that declares those document types, owning only VectorCraft's own formats. The DMG opens on a designed Finder window, VectorCraft.app beside the `Applications` link over a background with the app icon (#493). - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, Remove Anchor Points when anchors are selected, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas. - Save / Don't Save / Cancel before closing or quitting with unsaved documents (tabs, Close, Close All, Quit, window close). diff --git a/apps/vectorcraft/Cargo.toml b/apps/vectorcraft/Cargo.toml index b48e5c2b..0ec3881e 100644 --- a/apps/vectorcraft/Cargo.toml +++ b/apps/vectorcraft/Cargo.toml @@ -37,9 +37,11 @@ winit = { version = "0.30", default-features = false } clipboard-win = { workspace = true } [target.'cfg(target_os = "macos")'.dependencies] -muda = { version = "0.21", default-features = false } +# The macOS menu bar (src/mac_menu.rs): Tauri's menu crate, AppKit menus behind a safe API (no GTK +# with default features off). Pinned exactly: review the diff before bumping. +muda = { version = "=0.21.1", default-features = false } objc2 = "0.6" -objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSApplication", "NSPasteboard", "NSResponder", "NSTextInputContext"] } +objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSApplication", "NSEvent", "NSPasteboard", "NSResponder", "NSTextInputContext"] } # Files opened from Finder and the Dock (src/open_documents.rs) and pasted bitmaps (src/clipboard.rs); both already come with winit, muda and rfd. objc2-foundation = { version = "0.3", default-features = false, features = ["std", "block2", "NSArray", "NSData", "NSNotification", "NSOperation", "NSString", "NSURL"] } block2 = "0.6" diff --git a/apps/vectorcraft/src/mac_menu.rs b/apps/vectorcraft/src/mac_menu.rs new file mode 100644 index 00000000..0c8325dc --- /dev/null +++ b/apps/vectorcraft/src/mac_menu.rs @@ -0,0 +1,367 @@ +//! The macOS menu bar, through muda (Tauri's menu crate: AppKit menus behind a safe API, no GTK +//! with default features off). The menus, their Mac layout and how their keys reach VectorCraft +//! are in `vectorcraft_ui_egui::native_menu`; this file only builds and updates the `NSMenu`s. +//! +//! - Item ids are the items' places (`vc12`, depth first): one command can run from several items +//! (each language of VectorCraft › Language is `app.language` with its own code). +//! - A structure change (a recent file added, the language or a shortcut changed) rebuilds the +//! menu; labels, enabled and checked are updated in place. +//! - A chosen item is a click or a key equivalent: AppKit's current event says which. A key +//! equivalent goes back to egui as the key press that was made (the event's modifiers, not the +//! item's: AppKit may match ⌘R to a ⇧⌘R item), so VectorCraft's key rules still apply. +//! - Hide and Hide Others are items of ours calling `NSApplication`: AppKit's own always take ⌘H +//! (View › Hide Edges) and ⌥⌘H. + +use std::sync::mpsc::{Receiver, channel}; + +use egui::{Key, KeyboardShortcut}; +use muda::accelerator::{Accelerator, Code, Modifiers}; +use muda::{CheckMenuItem, Menu, MenuEvent, MenuItem, PredefinedMenuItem, Submenu}; +use objc2::MainThreadMarker; +use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSEventType}; +use vectorcraft_ui_egui::VectorcraftApp; +use vectorcraft_ui_egui::native_menu::{self, Backend, Event, MenuBar, MenuRole, Node, Standard}; + +enum Handle { + Plain(MenuItem), + Check(CheckMenuItem), +} + +/// One native item, in the order of [`MenuBar::items`]. +struct Entry { + handle: Handle, + item: native_menu::Item, + /// Its shortcut, when it is a key equivalent. + chord: Option, +} + +/// How an item was chosen, read from AppKit's current event while it calls the handler. +struct Chosen { + id: String, + /// A key press (not a mouse click), and the modifiers held: ⌘, ⌃, ⌥, ⇧. + key: bool, + mods: [bool; 4], +} + +pub struct MacMenu { + menu: Option, + entries: Vec, + rx: Receiver, + structure: u64, +} + +impl MacMenu { + fn new(ctx: &egui::Context) -> MacMenu { + let (tx, rx) = channel(); + let repaint = ctx.clone(); + MenuEvent::set_event_handler(Some(move |e: MenuEvent| { + // AppKit calls this on the main thread, from the event that chose the item: a key + // equivalent is a key-down, a click a mouse-up (or ↩ inside the open menu). + let event = MainThreadMarker::new().and_then(|mtm| NSApplication::sharedApplication(mtm).currentEvent()); + let key = event.as_ref().is_some_and(|ev| ev.r#type() == NSEventType::KeyDown); + let flags = event.as_ref().map_or(NSEventModifierFlags::empty(), |ev| ev.modifierFlags()); + let mods = [NSEventModifierFlags::Command, NSEventModifierFlags::Control, NSEventModifierFlags::Option, NSEventModifierFlags::Shift] + .map(|m| flags.contains(m)); + // The receiver only goes away with the app. + let _ = tx.send(Chosen { id: e.id.0, key, mods }); + // Wake egui, so the item runs now rather than on the next mouse move. + repaint.request_repaint(); + })); + MacMenu { menu: None, entries: Vec::new(), rx, structure: 0 } + } + + /// Build the menus of `bar` and make them the app's, in place of the ones before. + fn build(&mut self, bar: &MenuBar) -> muda::Result<()> { + let mut entries = Vec::new(); + let menu = Menu::new(); + let mut special = Vec::new(); + for m in &bar.menus { + let sub = Submenu::new(escape(&m.title), true); + append(&sub, &m.children, &mut entries)?; + menu.append(&sub)?; + if matches!(m.role, MenuRole::Window | MenuRole::Help) { + special.push((m.role, sub)); + } + } + if let Some(old) = self.menu.take() { + old.remove_for_nsapp(); + } + menu.init_for_nsapp(); + // Only once the menu is the app's: muda looks the submenus up in the installed main menu. + for (role, sub) in special { + match role { + MenuRole::Window => sub.set_as_windows_menu_for_nsapp(), + _ => sub.set_as_help_menu_for_nsapp(), + } + } + self.menu = Some(menu); + self.entries = entries; + self.structure = native_menu::structure_key(bar); + Ok(()) + } +} + +fn append(sub: &Submenu, nodes: &[Node], entries: &mut Vec) -> muda::Result<()> { + for n in nodes { + match n { + Node::Separator => sub.append(&PredefinedMenuItem::separator())?, + Node::Header(label) => sub.append(&MenuItem::new(escape(label), false, None))?, + Node::Submenu { label, children } => { + let s = Submenu::new(escape(label), !children.is_empty()); + append(&s, children, entries)?; + sub.append(&s)?; + } + Node::Standard(item) => { + let text = Some(vectorcraft_ui_egui::i18n::t(item.label())); + let p = match item { + Standard::Services => PredefinedMenuItem::services(text), + Standard::ShowAll => PredefinedMenuItem::show_all(text), + Standard::Zoom => PredefinedMenuItem::maximize(text), + Standard::BringAllToFront => PredefinedMenuItem::bring_all_to_front(text), + }; + sub.append(&p)?; + } + Node::Item(it) => { + let id = format!("vc{}", entries.len()); + let chord = it.shortcut.and_then(vectorcraft_ui_egui::shortcuts::parse).filter(native_menu::native_ok); + let accel = chord.as_ref().and_then(accelerator); + let handle = match it.checked { + Some(c) => { + let h = CheckMenuItem::with_id(id, escape(&it.label), it.enabled, c, accel); + sub.append(&h)?; + Handle::Check(h) + } + None => { + let h = MenuItem::with_id(id, escape(&it.label), it.enabled, accel); + sub.append(&h)?; + Handle::Plain(h) + } + }; + entries.push(Entry { handle, item: it.clone(), chord }); + } + } + } + Ok(()) +} + +impl Backend for MacMenu { + fn sync(&mut self, bar: &MenuBar) { + let items = bar.items(); + if self.menu.is_none() || native_menu::structure_key(bar) != self.structure || items.len() != self.entries.len() { + if let Err(e) = self.build(bar) { + // The menus as they were stay up (a failed build changed nothing). + log::warn!("couldn't rebuild the macOS menu bar: {e}"); + } + return; + } + for (e, it) in self.entries.iter_mut().zip(items) { + if e.item.label != it.label { + let text = escape(&it.label); + match &e.handle { + Handle::Plain(h) => h.set_text(text), + Handle::Check(h) => h.set_text(text), + } + } + if e.item.enabled != it.enabled { + match &e.handle { + Handle::Plain(h) => h.set_enabled(it.enabled), + Handle::Check(h) => h.set_enabled(it.enabled), + } + } + // Compare with AppKit's own state: muda toggles a check item when it's clicked. + if let (Handle::Check(h), Some(c)) = (&e.handle, it.checked) + && h.is_checked() != c + { + h.set_checked(c); + } + if e.item != *it { + e.item = it.clone(); + } + } + } + + fn drain(&mut self) -> Vec { + let mut out = Vec::new(); + while let Ok(chosen) = self.rx.try_recv() { + // Ids that aren't ours are AppKit's own items (Services, Zoom…), already handled. + let Some(e) = chosen.id.strip_prefix("vc").and_then(|n| n.parse::().ok()).and_then(|i| self.entries.get(i)) else { continue }; + if let Some(command @ (native_menu::HIDE | native_menu::HIDE_OTHERS)) = e.item.command { + if let Some(mtm) = MainThreadMarker::new() { + let app = NSApplication::sharedApplication(mtm); + if command == native_menu::HIDE { app.hide(None) } else { app.hideOtherApplications(None) } + } + continue; + } + // A key-down chose it: its key equivalent, unless it was ↩ or Space inside the open + // menu (no ⌘ or ⌃ while the item's shortcut has one). The key is the item's (AppKit + // matched on it); the modifiers are the ones held. + let [cmd, ctrl, alt, shift] = chosen.mods; + let key = e + .chord + .filter(|c| { + chosen.key && e.item.command != Some(native_menu::MINIMIZE) && (cmd || ctrl || !(c.modifiers.command || c.modifiers.ctrl)) + }) + .map(|c| KeyboardShortcut::new(egui::Modifiers { alt, ctrl, shift, mac_cmd: cmd, command: cmd }, c.logical_key)); + out.push(match key { + Some(k) => Event::Key(k), + None => Event::Click(e.item.clone()), + }); + } + out + } +} + +/// Install the menu bar (in eframe's creator closure, so winit's default menu doesn't stay up). +/// `None` keeps the menus in the window: AppKit refused them (logged), never a crash. +pub fn install(ctx: &egui::Context, app: &VectorcraftApp) -> Option { + vectorcraft_ui_egui::i18n::set_current(app.ui_language()); + let bar = native_menu::layout(app).bar; + let built = vectorcraft_engine::guard::catch_panic(|| { + let mut menu = MacMenu::new(ctx); + menu.build(&bar).map(|()| menu) + }); + match built { + Ok(Ok(menu)) => Some(native_menu::NativeMenu::new(Box::new(menu))), + Ok(Err(e)) => { + log::warn!("couldn't install the macOS menu bar ({e}); the menus stay in the window"); + None + } + Err(e) => { + log::warn!("couldn't install the macOS menu bar ({e}); the menus stay in the window"); + None + } + } +} + +/// `&` marks a mnemonic in muda labels: "Fill & Stroke" keeps its ampersand. +fn escape(s: &str) -> String { + s.replace('&', "&&") +} + +/// A key equivalent for AppKit. `Cmd` is ⌘ (`META`) and `Ctrl` is ⌃: never folded together. +fn accelerator(c: &KeyboardShortcut) -> Option { + let m = c.modifiers; + let mut mods = Modifiers::empty(); + for (on, flag) in [(m.command || m.mac_cmd, Modifiers::META), (m.ctrl, Modifiers::CONTROL), (m.alt, Modifiers::ALT), (m.shift, Modifiers::SHIFT)] + { + if on { + mods |= flag; + } + } + Some(Accelerator::new(mods, code(c.logical_key)?)) +} + +/// The key code AppKit matches for an egui key. +fn code(key: Key) -> Option { + Some(match key { + Key::A => Code::KeyA, + Key::B => Code::KeyB, + Key::C => Code::KeyC, + Key::D => Code::KeyD, + Key::E => Code::KeyE, + Key::F => Code::KeyF, + Key::G => Code::KeyG, + Key::H => Code::KeyH, + Key::I => Code::KeyI, + Key::J => Code::KeyJ, + Key::K => Code::KeyK, + Key::L => Code::KeyL, + Key::M => Code::KeyM, + Key::N => Code::KeyN, + Key::O => Code::KeyO, + Key::P => Code::KeyP, + Key::Q => Code::KeyQ, + Key::R => Code::KeyR, + Key::S => Code::KeyS, + Key::T => Code::KeyT, + Key::U => Code::KeyU, + Key::V => Code::KeyV, + Key::W => Code::KeyW, + Key::X => Code::KeyX, + Key::Y => Code::KeyY, + Key::Z => Code::KeyZ, + Key::Num0 => Code::Digit0, + Key::Num1 => Code::Digit1, + Key::Num2 => Code::Digit2, + Key::Num3 => Code::Digit3, + Key::Num4 => Code::Digit4, + Key::Num5 => Code::Digit5, + Key::Num6 => Code::Digit6, + Key::Num7 => Code::Digit7, + Key::Num8 => Code::Digit8, + Key::Num9 => Code::Digit9, + Key::F1 => Code::F1, + Key::F2 => Code::F2, + Key::F3 => Code::F3, + Key::F4 => Code::F4, + Key::F5 => Code::F5, + Key::F6 => Code::F6, + Key::F7 => Code::F7, + Key::F8 => Code::F8, + Key::F9 => Code::F9, + Key::F10 => Code::F10, + Key::F11 => Code::F11, + Key::F12 => Code::F12, + Key::F13 => Code::F13, + Key::F14 => Code::F14, + Key::F15 => Code::F15, + Key::F16 => Code::F16, + Key::F17 => Code::F17, + Key::F18 => Code::F18, + Key::F19 => Code::F19, + Key::F20 => Code::F20, + Key::F21 => Code::F21, + Key::F22 => Code::F22, + Key::F23 => Code::F23, + Key::F24 => Code::F24, + Key::OpenBracket => Code::BracketLeft, + Key::CloseBracket => Code::BracketRight, + Key::Backslash => Code::Backslash, + Key::Slash => Code::Slash, + // `+` is Shift+`=` on the keyboards AppKit matches by key: Zoom In shows ⌘=. + Key::Equals | Key::Plus => Code::Equal, + Key::Minus => Code::Minus, + Key::Quote => Code::Quote, + Key::Semicolon => Code::Semicolon, + Key::Comma => Code::Comma, + Key::Period => Code::Period, + Key::Backtick => Code::Backquote, + Key::Backspace => Code::Backspace, + Key::Delete => Code::Delete, + Key::Enter => Code::Enter, + Key::Tab => Code::Tab, + Key::Space => Code::Space, + Key::Escape => Code::Escape, + Key::ArrowLeft => Code::ArrowLeft, + Key::ArrowRight => Code::ArrowRight, + Key::ArrowUp => Code::ArrowUp, + Key::ArrowDown => Code::ArrowDown, + _ => return None, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Every shortcut the Mac menu shows as a key equivalent has one AppKit can match. + #[test] + fn every_menu_shortcut_maps_to_a_key_equivalent() { + let app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default()); + let bar = native_menu::layout(&app).bar; + let mut native = 0; + for it in bar.items() { + let Some(c) = it.shortcut.and_then(vectorcraft_ui_egui::shortcuts::parse).filter(native_menu::native_ok) else { continue }; + assert!(accelerator(&c).is_some(), "{:?} ({:?}) has no key equivalent", it.shortcut, it.command); + native += 1; + } + assert!(native > 70, "{native} key equivalents"); + } + + #[test] + fn control_and_command_stay_distinct() { + let parse = |s| vectorcraft_ui_egui::shortcuts::parse(s).and_then(|c| accelerator(&c)); + assert_ne!(parse("Cmd+M"), parse("Ctrl+Cmd+M")); + assert!(parse("Cmd+M").is_some()); + } +} diff --git a/apps/vectorcraft/src/main.rs b/apps/vectorcraft/src/main.rs index 64fc2049..8a5537a7 100644 --- a/apps/vectorcraft/src/main.rs +++ b/apps/vectorcraft/src/main.rs @@ -1,6 +1,9 @@ //! VectorCraft desktop app. //! -//! Usage: `vectorcraft [--control ] [files…]` +//! Usage: `vectorcraft [--control ] [--in-window-menus] [files…]` +//! +//! `--in-window-menus` (or `VECTORCRAFT_IN_WINDOW_MENUS=1`) keeps the menus inside the window on +//! macOS instead of the macOS menu bar (`mac_menu`). //! //! `--control ` (or `VECTORCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server: //! `{"id":1,"method":"ui.inspect","params":{}}` → `{"id":1,"ok":true,"result":…}`. @@ -20,7 +23,7 @@ mod control_server; mod gpu; mod logging; #[cfg(target_os = "macos")] -mod native_menu; +mod mac_menu; #[cfg(target_os = "macos")] mod open_documents; mod printing; @@ -37,8 +40,6 @@ struct App { graphics_loss: GraphicsLoss, /// The graphics device was lost and the unsaved changes are kept for Data Recovery. graphics_lost: bool, - #[cfg(target_os = "macos")] - menu: Option, } impl eframe::App for App { @@ -59,15 +60,7 @@ impl eframe::App for App { return; } #[cfg(target_os = "macos")] - { - if self.menu.is_none() && std::env::var_os("VECTORCRAFT_NO_NATIVE_MENU").is_none() { - self.menu = Some(native_menu::NativeMenu::install(&mut self.app)); - } - if let Some(m) = &mut self.menu { - m.poll(&mut self.app, ctx); - } - open_files(&mut self.app, open_documents::take()); - } + open_files(&mut self.app, open_documents::take()); self.app.logic(ctx); window::track(ctx, &mut self.app.ui.window); if self.app.ui.status == "quit" { @@ -319,10 +312,12 @@ fn main() -> std::process::ExitCode { vectorcraft_ui_egui::i18n::detect_system_lang_in_background(); let mut control_port: Option = std::env::var("VECTORCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok()); let mut files = Vec::new(); + let mut in_window_menus = std::env::var_os("VECTORCRAFT_IN_WINDOW_MENUS").is_some_and(|v| !v.is_empty() && v != "0"); let mut args = std::env::args().skip(1); while let Some(a) = args.next() { match a.as_str() { "--control" => control_port = args.next().and_then(|p| p.parse().ok()), + "--in-window-menus" => in_window_menus = true, "--version" => { println!("vectorcraft {}", env!("CARGO_PKG_VERSION")); return std::process::ExitCode::SUCCESS; @@ -434,15 +429,17 @@ fn main() -> std::process::ExitCode { app = app.with_control(rx); } #[cfg(target_os = "macos")] - open_documents::set_ui(&cc.egui_ctx); + { + open_documents::set_ui(&cc.egui_ctx); + // The macOS menu bar, installed now so winit's default menu doesn't stay up. + if !in_window_menus { + app.services.native_menu = mac_menu::install(&cc.egui_ctx, &app); + } + } + #[cfg(not(target_os = "macos"))] + let _ = in_window_menus; open_files(&mut app, files); - Ok(Box::new(App { - app, - graphics_loss, - graphics_lost: false, - #[cfg(target_os = "macos")] - menu: None, - })) + Ok(Box::new(App { app, graphics_loss, graphics_lost: false })) }), ) }); diff --git a/apps/vectorcraft/src/native_menu.rs b/apps/vectorcraft/src/native_menu.rs deleted file mode 100644 index ba8ca16c..00000000 --- a/apps/vectorcraft/src/native_menu.rs +++ /dev/null @@ -1,183 +0,0 @@ -//! macOS: VectorCraft's menu tree as the native system menu bar (like Illustrator on the Mac). -//! Items dispatch through the same command path as the in-window menus; enablement, check marks -//! and dynamic labels ("Undo Move") are refreshed a few times per second, and the menu is rebuilt -//! when saved views or recent files come and go. - -use std::collections::HashMap; -use std::str::FromStr; - -use muda::accelerator::Accelerator; -use muda::{CheckMenuItem, Menu, MenuEvent, MenuItem, PredefinedMenuItem, Submenu}; -use serde_json::Value; -use vectorcraft_ui_egui::VectorcraftApp; -use vectorcraft_ui_egui::i18n::{self, Lang, t}; -use vectorcraft_ui_egui::menus::{self, Item}; - -enum Handle { - Plain(MenuItem), - Check(CheckMenuItem), -} - -pub struct NativeMenu { - _menu: Menu, - items: HashMap, - last_refresh: f64, - /// Shortcut-override / workspace-list generation the menu was built for. - generation: u64, - /// Saved views and recent files listed (empty slots are left out, so a change rebuilds). - slots: usize, - /// Plug-in registry revision the Plug-ins submenus were built for. - plugins: u64, - /// The language the labels were built in (a change rebuilds the menu). - language: Lang, -} - -/// Accelerator for a shortcut like "Cmd+Shift+]" (modifier-less shortcuts stay in the app so they -/// don't steal keys from text fields; a focused field still gets Cmd+A/X/C/V, see [`NativeMenu::poll`]). -fn accel(sc: &str) -> Option { - if !(sc.contains("Cmd") || sc.contains("Ctrl") || sc.contains("Alt") || sc.starts_with('F')) { - return None; - } - Accelerator::from_str(&sc.replace("Cmd", "CMD").replace("Alt", "ALT").replace("Shift", "SHIFT").replace("Ctrl", "CTRL")).ok() -} - -impl NativeMenu { - pub fn install(app: &mut VectorcraftApp) -> Self { - // Accelerators come from `shortcut_of`, which honours the user's overrides. - vectorcraft_ui_egui::shortcut_editor::sync(&app.ui); - let generation = vectorcraft_ui_egui::shortcut_editor::GENERATION.load(std::sync::atomic::Ordering::Relaxed); - let menu = Menu::new(); - let mut items = HashMap::new(); - let mut counter = 0usize; - for (title, entries) in menus::menu_tree() { - let sub = Submenu::new(t(title), true); - build(app, &sub, &entries, &mut items, &mut counter); - let _ = menu.append(&sub); - } - menu.init_for_nsapp(); - app.native_menu = true; - app.native_shortcuts = items - .values() - .filter(|(_, p, _, c)| (p.is_null() || p.as_object().is_some_and(|o| o.is_empty())) && menus::shortcut_of(c).and_then(accel).is_some()) - .map(|(_, _, _, c)| c.clone()) - .collect(); - Self { - _menu: menu, - items, - last_refresh: 0.0, - generation, - slots: menus::listed_slots(app), - plugins: menus::plugin_revision(), - language: i18n::current(), - } - } - - /// Dispatch chosen items (a focused text field takes Select All and the clipboard) and refresh - /// state. - pub fn poll(&mut self, app: &mut VectorcraftApp, ctx: &egui::Context) { - while let Ok(ev) = MenuEvent::receiver().try_recv() { - if let Some((cmd, params, _, _)) = self.items.get(ev.id.as_ref()) { - let p = if params.is_null() { serde_json::json!({}) } else { params.clone() }; - menus::invoke_from_system_menu(app, ctx, cmd, p); - } - } - let now = vectorcraft_ui_egui::now_ms(); - if now - self.last_refresh < 250.0 { - return; - } - self.last_refresh = now; - // Shortcuts edited, workspaces added, saved views, recent files, plug-ins or the UI language - // changed: rebuild so accelerators, lists and labels are current. - if vectorcraft_ui_egui::shortcut_editor::GENERATION.load(std::sync::atomic::Ordering::Relaxed) != self.generation - || menus::listed_slots(app) != self.slots - || menus::plugin_revision() != self.plugins - || i18n::current() != self.language - { - *self = NativeMenu::install(app); - return; - } - for (run, rp, h, cmd) in self.items.values() { - let null = Value::Null; - let params = if run == cmd { rp } else { &null }; - let en = menus::enabled(app, cmd); - match h { - Handle::Plain(i) => { - i.set_enabled(en); - if matches!( - cmd.as_str(), - "edit.undo" - | "edit.redo" - | "view.outline" - | "view.rulers" - | "view.guides" - | "view.grid" - | "view.edges" - | "view.artboards" - | "view.boundingBox" - | "view.transparencyGrid" - | "window.workspace.reset" - ) || cmd.starts_with("file.openRecent") - || cmd.starts_with("type.recentFont") - || cmd.starts_with("view.goto") - || matches!( - cmd.as_str(), - "view.cornerWidget" | "view.textThreads" | "view.gradientAnnotator" | "effect.last" | "type.hiddenCharacters" - ) - { - i.set_text(menus::display_label(app, cmd, "")); - } - } - Handle::Check(c) => { - c.set_enabled(en); - c.set_checked(menus::checked(app, cmd, params).unwrap_or(false)); - } - } - } - } -} - -fn build( - app: &VectorcraftApp, - parent: &Submenu, - entries: &[Item], - items: &mut HashMap, - counter: &mut usize, -) { - for e in entries { - match e { - Item::Sep => { - let _ = parent.append(&PredefinedMenuItem::separator()); - } - Item::Header(h) => { - let _ = parent.append(&MenuItem::new(t(h), false, None)); - } - Item::Todo(label, sc) => { - let _ = parent.append(&MenuItem::new(t(label), false, accel(sc))); - } - Item::Sub(label, children) => { - let sub = Submenu::new(t(label), true); - build(app, &sub, children, items, counter); - let _ = parent.append(&sub); - } - // Unused saved-view and recent-file slots are left out, as in the in-window menus. - Item::Cmd(_, cmd, _) if menus::hidden_slot(app, cmd) => {} - Item::Cmd(label, cmd, params) => { - *counter += 1; - let id = format!("dc{counter}"); - let sc = if params.is_null() { menus::shortcut_of(cmd).and_then(accel) } else { None }; - let handle = if menus::checked(app, cmd, params).is_some() { - let c = CheckMenuItem::with_id(id.clone(), menus::display_label(app, cmd, label), true, false, sc); - let _ = parent.append(&c); - Handle::Check(c) - } else { - let i = MenuItem::with_id(id.clone(), menus::display_label(app, cmd, label), true, sc); - let _ = parent.append(&i); - Handle::Plain(i) - }; - let (run, run_params) = menus::click_target(label, cmd, params); - let _ = &run_params; - items.insert(id, (run, run_params, handle, cmd.to_string())); - } - } - } -} diff --git a/crates/ui-egui/src/chrome.rs b/crates/ui-egui/src/chrome.rs index 14a96d82..3418ba32 100644 --- a/crates/ui-egui/src/chrome.rs +++ b/crates/ui-egui/src/chrome.rs @@ -34,7 +34,8 @@ pub fn app_bar(app: &mut VectorcraftApp, ui: &mut Ui) { app.run("app.home", json!({})).ok(); } ui.add_space(2.0); - let menus_end = if app.native_menu { + // With the macOS menu bar the menus are at the top of the screen instead. + let menus_end = if app.services.native_menu.is_some() { let full = ui.max_rect(); ui.painter().text(full.center(), egui::Align2::CENTER_CENTER, "VectorCraft", egui::FontId::proportional(13.5), t.text); ui.cursor().min.x diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 534da568..43977320 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -91,6 +91,8 @@ pub fn inspect(app: &VectorcraftApp, ctx: &egui::Context) -> Value { "activeDocument": app.session.active_index(), "perf": {"frameMs": app.perf.frame_ms, "renderMs": app.perf.render_ms, "fps": app.perf.fps}, "graphicsAdapter": app.graphics_adapter, + // The menus are in the macOS menu bar rather than the window. + "nativeMenuBar": app.services.native_menu.is_some(), // Saves and exports still being written in the background (Background Save / Export). "background": app.background.jobs.iter().map(|j| j.label.as_str()).collect::>(), }) diff --git a/crates/ui-egui/src/dialogs/perspective_presets.rs b/crates/ui-egui/src/dialogs/perspective_presets.rs index c720a036..be4d2109 100644 --- a/crates/ui-egui/src/dialogs/perspective_presets.rs +++ b/crates/ui-egui/src/dialogs/perspective_presets.rs @@ -209,11 +209,6 @@ pub fn slot_preset(app: &VectorcraftApp, id: &str) -> Option { app.session.prefs.perspective_presets.iter().filter(|p| p.kind == kind).nth(n.checked_sub(1)?).map(|p| p.name.clone()) } -/// How many saved presets the slots list (the native menu is rebuilt when this changes). -pub fn listed_slots(app: &VectorcraftApp) -> usize { - (1..=3u8).map(|k| app.session.prefs.perspective_presets.iter().filter(|p| p.kind == k).count().min(SLOTS)).sum() -} - /// View → Perspective Grid → One/Two/Three Point Perspective (`kind` 1–3): the built-in views of /// the type, then the saved presets' slots (`slots`, the type's ids). pub fn menu(kind: u8, slots: [&'static str; SLOTS]) -> Vec { diff --git a/crates/ui-egui/src/dialogs/tests_perspective.rs b/crates/ui-egui/src/dialogs/tests_perspective.rs index ee933229..c88f7961 100644 --- a/crates/ui-egui/src/dialogs/tests_perspective.rs +++ b/crates/ui-egui/src/dialogs/tests_perspective.rs @@ -141,7 +141,11 @@ fn the_presets_manager_creates_edits_and_deletes_presets() { assert_eq!(app.session.prefs.perspective_presets[0].opacity, 90.0); // Its type's menu lists it in a slot, which applies it. assert_eq!(crate::menus::dynamic_label(&app, "ui.perspectiveUserPreset3.1", ""), "Gorge"); - assert!(crate::menus::hidden_slot(&app, "ui.perspectiveUserPreset3.2") && crate::menus::hidden_slot(&app, "ui.perspectiveUserPreset2.1")); + assert!( + ["ui.perspectiveUserPreset3.2", "ui.perspectiveUserPreset2.1"] + .iter() + .all(|id| crate::menus::shown_state(&app, id, &serde_json::Value::Null).is_none()) + ); app.run("ui.perspectiveUserPreset3.1", json!({})).unwrap(); assert_eq!(grid(&app).name, "Gorge"); // Delete selects the one above it. diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv index b8b572f8..c5004e61 100644 --- a/crates/ui-egui/src/i18n/cs.tsv +++ b/crates/ui-egui/src/i18n/cs.tsv @@ -614,3 +614,24 @@ Float Panel Plovoucí panel Dock Panel Ukotvit panel Float Tool Group Plovoucí skupina nástrojů + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services Služby + Hide VectorCraft Skrýt VectorCraft + Hide Others Skrýt ostatní + Minimize Minimalizovat + Zoom Zvětšit + Bring All to Front Převést vše do popředí + Settings Nastavení + General Obecné + Selection & Anchor Display Výběr a zobrazení kotevních bodů + Units Jednotky + Guides & Grid Vodítka a mřížka + Hyphenation Dělení slov + Performance & Storage Výkon a úložiště + User Interface Uživatelské rozhraní + Performance Výkon + File Handling Práce se soubory + Clipboard Handling Práce se schránkou + Appearance of Black Vzhled černé + Devices Zařízení diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv index 6de71837..cce9d938 100644 --- a/crates/ui-egui/src/i18n/es.tsv +++ b/crates/ui-egui/src/i18n/es.tsv @@ -3582,3 +3582,10 @@ axis Both Ambos @msg {tool} isn't in a toolbar group of several tools {tool} no está en un grupo de la barra de herramientas con varias herramientas @msg onto must name a panel floating in another group onto debe nombrar un panel que flote en otro grupo @msg x and y must both be numbers x e y deben ser números + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services Servicios + Hide VectorCraft Ocultar VectorCraft + Zoom Zoom + Bring All to Front Traer todo al frente + Settings Ajustes diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv index 65ab696f..707cc338 100644 --- a/crates/ui-egui/src/i18n/it.tsv +++ b/crates/ui-egui/src/i18n/it.tsv @@ -3582,3 +3582,10 @@ axis Both Entrambi @msg {tool} isn't in a toolbar group of several tools {tool} non fa parte di un gruppo di più strumenti nella barra degli strumenti @msg onto must name a panel floating in another group onto deve indicare un pannello mobile in un altro gruppo @msg x and y must both be numbers x e y devono essere entrambi numeri + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services Servizi + Hide VectorCraft Nascondi VectorCraft + Zoom Zoom + Bring All to Front Porta tutto in primo piano + Settings Impostazioni diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv index c3ecb5fd..9926f829 100644 --- a/crates/ui-egui/src/i18n/ja.tsv +++ b/crates/ui-egui/src/i18n/ja.tsv @@ -3048,3 +3048,11 @@ axis Both 両方 Drag to float the toolbar ドラッグしてツールバーをフローティング Drag to the window's left edge to dock ウィンドウの左端までドラッグしてドッキング Float Tool Group ツールグループをフローティング + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services サービス + Hide VectorCraft VectorCraft を隠す + Zoom 拡大/縮小 + Bring All to Front すべてを手前に移動 + Settings 環境設定 +theme Appearance 外観 diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv index 0e47c699..c3d4779e 100644 --- a/crates/ui-egui/src/i18n/pt-br.tsv +++ b/crates/ui-egui/src/i18n/pt-br.tsv @@ -2636,3 +2636,11 @@ Float Panel Flutuar Painel Dock Panel Encaixar Painel Float Tool Group Flutuar Grupo de Ferramentas + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services Serviços + Hide VectorCraft Ocultar o VectorCraft + Hide Others Ocultar Outros + Zoom Zoom + Bring All to Front Trazer Todas para a Frente + Settings Configurações diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs index 13964493..a6008cef 100644 --- a/crates/ui-egui/src/i18n/tests.rs +++ b/crates/ui-egui/src/i18n/tests.rs @@ -503,6 +503,9 @@ fn menu_catalogs_translate_every_menu_label() { let mut all: Vec = labels.iter().filter(|l| interface(l)).map(|(l, ..)| l.to_string()).collect(); all.extend(toggled_labels()); all.extend(crate::menus::CONTEXT_LABELS.iter().map(|l| l.to_string())); + // The macOS menu bar's own labels, and its Settings submenu's Preferences pages. + all.extend(crate::native_menu::MAC_LABELS.iter().map(|l| l.to_string())); + all.extend(vectorcraft_engine::cmd::prefscmds::PREF_CATEGORIES.iter().map(|l| l.to_string())); all.sort(); all.dedup(); for code in KEEPS_MENU_NAMES { diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv index 8c01b809..8850423f 100644 --- a/crates/ui-egui/src/i18n/zh-hans.tsv +++ b/crates/ui-egui/src/i18n/zh-hans.tsv @@ -3305,3 +3305,9 @@ axis Both 两者 Drag to float the toolbar 拖动以浮动工具栏 Drag to the window's left edge to dock 拖到窗口左边缘以停放 Float Tool Group 浮动工具组 + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services 服务 + Hide VectorCraft 隐藏 VectorCraft + Bring All to Front 前置全部窗口 + Settings 设置 diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv index 05467689..77f49c7d 100644 --- a/crates/ui-egui/src/i18n/zh-hant.tsv +++ b/crates/ui-egui/src/i18n/zh-hant.tsv @@ -3079,3 +3079,10 @@ axis Both 兩者 Drag to float the toolbar 拖曳以浮動工具列 Drag to the window's left edge to dock 拖曳到視窗左側邊緣以停駐 Float Tool Group 浮動工具組 + +# The macOS menu bar (native_menu): the app and Window menus' system items, Settings pages. + Services 服務 + Hide VectorCraft 隱藏 VectorCraft + Zoom 縮放 + Bring All to Front 將全部移至最前 + Settings 設定 diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 8cf17d93..e2b8c0cd 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -33,6 +33,7 @@ pub mod icon_data; pub mod icons; pub mod io; pub mod menus; +pub mod native_menu; pub mod palette; pub mod panels; pub mod place; @@ -78,6 +79,8 @@ mod tests_home; #[cfg(test)] mod tests_labels; #[cfg(test)] +mod tests_nativemenu; +#[cfg(test)] mod tests_nativeoptions; #[cfg(test)] mod tests_numfields; @@ -228,6 +231,8 @@ pub struct Services { /// File → Print: the system's printers and print queue (desktop), the browser's print dialog /// (web). Without it Print saves the job as a PDF. pub print: Option>, + /// The macOS menu bar, when the desktop app installed one: the in-window menus are hidden then. + pub native_menu: Option, } /// Cached canvas raster. @@ -288,12 +293,11 @@ pub struct VectorcraftApp { pub perf: Perf, /// macOS: draw our own title strip under the traffic lights. pub integrated_titlebar: bool, - /// The host installed a native menu bar (macOS): don't draw in-window menus. - pub native_menu: bool, /// Last applied effect (Effect → Apply Last Effect). pub last_effect: Option<(String, serde_json::Value)>, - /// Commands whose shortcuts the native menu handles (skip them in egui to avoid double firing). - pub native_shortcuts: std::collections::HashSet, + /// Commands run through [`Self::run`] so far: the native menu bar reads its rows again when it + /// moves ([`native_menu::sync`]). + run_count: u64, control_rx: Option>, /// (token, path, reply, deadline ms): a window that isn't presented never delivers its frame. pending_screenshots: Vec<(u64, Option, Sender, f64)>, @@ -389,9 +393,8 @@ impl VectorcraftApp { }, perf: Perf::default(), integrated_titlebar: false, - native_menu: false, last_effect: None, - native_shortcuts: Default::default(), + run_count: 0, clipboard_out: None, clipboard_published: None, clipboard_in: None, @@ -477,6 +480,7 @@ impl VectorcraftApp { /// Run a UI or engine command by id. The single entry point for every frontend path. pub fn run(&mut self, id: &str, params: Value) -> Result { + self.run_count = self.run_count.wrapping_add(1); if let Some(r) = menus::run_ui_command(self, id, ¶ms) { return r; } @@ -793,6 +797,7 @@ impl VectorcraftApp { ctx.copy_text(t); } self.drain_inbox(); + native_menu::run(self, ctx); if self.fonts_ready { shortcuts::handle(self, ctx); } @@ -838,6 +843,13 @@ impl VectorcraftApp { /// modifiers egui holds (`i.modifiers`), so a synthetic key, button or wheel turn holds its own /// for the frames it spans (a drag's moves included); the keyboard's come back after. pub fn raw_input_hook(&mut self, raw: &mut egui::RawInput) { + // The native menu's key equivalents become the input their keys make, ahead of what came + // after them (see `native_menu`). + let keys = self.services.native_menu.as_mut().map(native_menu::NativeMenu::take_keys).unwrap_or_default(); + if !keys.is_empty() { + let events: Vec = keys.into_iter().flat_map(|k| native_menu::key_events(k, || self.system_clipboard_text())).collect(); + raw.events.splice(0..0, events); + } for e in &raw.events { match e { egui::Event::ModifiersChanged(m) => self.host_modifiers = *m, @@ -936,6 +948,7 @@ impl VectorcraftApp { } self.ui_fonts.frame(&ctx); scrub::end_frame(self, &ctx); + native_menu::sync(self, &ctx); self.perf.frame_ms = now_ms() - t0; let _ = json!(null); } diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index 683e72d1..eb35c581 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -1353,14 +1353,20 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option { }); } let v = &app.ui.view; + // An item that can be on or off is `Some` whatever the document and selection (off with none): + // the macOS menu bar can't change an item's kind without rebuilding. + let selected_text = |onpath: bool| { + let st = app.session.active()?; + st.selection.objects.iter().find_map(|id| match st.doc.node(*id).map(|n| &n.kind) { + Some(vectorcraft_engine::doc::NodeKind::Text(t)) if !onpath || matches!(t.kind, vectorcraft_engine::doc::TextKind::OnPath { .. }) => { + Some(t) + } + _ => None, + }) + }; Some(match id { "type.orientation.vertical" | "type.orientation.horizontal" => { - let st = app.session.active()?; - let t = st.selection.objects.iter().find_map(|id| match st.doc.node(*id).map(|n| &n.kind) { - Some(vectorcraft_engine::doc::NodeKind::Text(t)) => Some(t), - _ => None, - })?; - t.vertical == (id == "type.orientation.vertical") + selected_text(false).is_some_and(|t| t.vertical == (id == "type.orientation.vertical")) } "view.outline" => v.outline, "view.pixelPreview" => v.pixel_preview, @@ -1368,12 +1374,7 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option { "view.snapToPixel" => v.snap_to_pixel, // Type on a Path effect of the selected path type. "type.pathOptions" if p.get("effect").is_some() => { - let st = app.session.active()?; - let t = st.selection.objects.iter().find_map(|id| match st.doc.node(*id).map(|n| &n.kind) { - Some(vectorcraft_engine::doc::NodeKind::Text(t)) if matches!(t.kind, vectorcraft_engine::doc::TextKind::OnPath { .. }) => Some(t), - _ => None, - })?; - p.get("effect").and_then(Value::as_str) == Some(t.path_effect.id()) + selected_text(true).is_some_and(|t| p.get("effect").and_then(Value::as_str) == Some(t.path_effect.id())) } "view.smartGuides" => v.smart_guides, "view.grid" => v.grid, @@ -1407,8 +1408,8 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option { "view.proofColors" => vectorcraft_render::proof::view().proof_colors, "view.overprintPreview" => vectorcraft_render::proof::view().overprint, "view.proofSetup" => p.get("target").and_then(Value::as_str) == Some(vectorcraft_render::proof::view().setup.target.id().as_str()), - "perspective.grid.snap" => perspective_grid(app)?.snap, - "perspective.grid.lockStation" => perspective_grid(app)?.lock_station, + "perspective.grid.snap" => perspective_grid(app).is_some_and(|g| g.snap), + "perspective.grid.lockStation" => perspective_grid(app).is_some_and(|g| g.lock_station), "file.documentColorMode" | "object.convertDocumentColorMode" => { let cmyk = app.session.active().is_some_and(|d| d.doc.color_mode == vectorcraft_engine::doc::ColorMode::Cmyk); p.get("mode").and_then(Value::as_str) == Some(if cmyk { "cmyk" } else { "rgb" }) @@ -1611,28 +1612,81 @@ fn recent_slot<'a>(app: &'a VectorcraftApp, id: &str) -> Option<&'a String> { io::recent_files(app).get(n.checked_sub(1)?) } -/// A menu slot hidden while it is empty ([`hidden_when_disabled`]) rather than shown disabled (the -/// native menu leaves it out). -pub fn hidden_slot(app: &VectorcraftApp, id: &str) -> bool { - hidden_when_disabled(id) && !enabled(app, id) +/// How the menus show item `id` (params `p`) now: (enabled, checked: `Some` for an item that is on +/// or off), or `None` while they leave it out: an empty slot ([`hidden_when_disabled`]) or an item +/// another stands in for ([`swapped_out`]). +pub fn shown_state(app: &VectorcraftApp, id: &str, p: &Value) -> Option<(bool, Option)> { + let en = enabled(app, id); + if (!en && hidden_when_disabled(id)) || swapped_out(app, id) { + return None; + } + Some((en, checked(app, id, p))) } -/// How many saved-view, recent-file and User Defined library slots are listed: a menu that can't -/// hide items (the native one) is rebuilt when this changes. -pub fn listed_slots(app: &VectorcraftApp) -> usize { - use vectorcraft_engine::cmd::{stylelib, swatchlib}; - let user = |libs: Vec| libs.iter().filter(|l| l.category == "user").count().min(10); - let views = app.session.active().map_or(0, |d| d.doc.views.len().min(10)); - views - + app.session.active().map_or(0, |d| d.doc.saved_selections.len().min(SAVED_SELECTION_IDS.len())) - + io::recent_files(app).len().min(RECENT_IDS.len()) - + user(swatchlib::libraries(&app.session)) - + user(stylelib::libraries(&app.session)) - + crate::dialogs::perspective_presets::listed_slots(app) +/// One row of a menu as it shows now. The in-window menus draw these and the macOS menu bar +/// ([`crate::native_menu`]) is built from them, so the two can't drift. +pub enum Entry<'a> { + Sep, + /// A section header (a disabled label), in the UI language. + Header(&'static str), + /// A submenu: its label in the UI language, and its items. + Sub(&'static str, &'a [Item]), + Item(Row<'a>), +} + +/// A menu item as it shows now ([`entry`]). +pub struct Row<'a> { + /// The command and its params; `None` for an item not implemented yet (always disabled). + pub command: Option<(&'static str, &'a Value)>, + /// The tree's own English label, which [`click_target`] reads. + pub source: &'static str, + /// The label in the UI language, as it reads now (Undo *Move*, Show/Hide…, a recent file). + pub label: std::borrow::Cow<'static, str>, + /// The shortcut as the registry writes it (`Cmd+Shift+Z`), the user's overrides applied. + pub shortcut: Option<&'static str>, + pub enabled: bool, + /// `Some` for an item that is on or off. + pub checked: Option, +} + +impl Row<'_> { + /// What choosing it runs ([`click_target`]); `None` for an item not implemented yet. + pub fn target(&self) -> Option<(String, Value)> { + self.command.map(|(id, p)| click_target(self.source, id, p)) + } +} + +/// Item `it` as the menus show it now, or `None` while they leave it out ([`shown_state`]). +pub fn entry<'a>(app: &VectorcraftApp, it: &'a Item) -> Option> { + use crate::i18n::t; + Some(match it { + Item::Sep => Entry::Sep, + Item::Header(h) => Entry::Header(t(h)), + Item::Sub(label, children) => Entry::Sub(t(label), children), + Item::Todo(label, sc) => Entry::Item(Row { + command: None, + source: label, + label: t(label).into(), + shortcut: Some(*sc).filter(|s| !s.is_empty()), + enabled: false, + checked: None, + }), + Item::Cmd(label, id, p) => { + let (enabled, checked) = shown_state(app, id, p)?; + Entry::Item(Row { + command: Some((id, p)), + source: label, + label: display_label(app, id, label).into(), + shortcut: item_shortcut(id, p), + enabled, + checked, + }) + } + }) } /// Changes whenever a plug-in is installed or removed: Object › Plug-ins and Effect › Plug-ins -/// list them, so a menu built once (the native one) is rebuilt. +/// list them (the command palette's cache follows it). pub fn plugin_revision() -> u64 { vectorcraft_plugins::registry::revision() } @@ -2657,66 +2711,64 @@ fn menu_body(app: &VectorcraftApp, ui: &mut egui::Ui, items: &[Item], clicked: & /// room for one). fn render_items(app: &VectorcraftApp, ui: &mut egui::Ui, items: &[Item], checks: bool, clicked: &mut Option<(String, Value)>) { let t = Tokens::get(ui.ctx()); - for it in items { - match it { - Item::Sep => { + for e in items.iter().filter_map(|it| entry(app, it)) { + match e { + Entry::Sep => { ui.separator(); } - Item::Header(h) => { - ui.label(egui::RichText::new(tl!(h)).size(11.0).color(t.text_dim)); + Entry::Header(h) => { + ui.label(egui::RichText::new(h).size(11.0).color(t.text_dim)); } - Item::Sub(label, children) => { - ui.menu_button(tl!(label), |ui| { + Entry::Sub(label, children) => { + ui.menu_button(label, |ui| { widgets::menu_scroll(ui, |ui| { ui.set_min_width(200.0); render_items(app, ui, children, checks, clicked); }); }); } - Item::Todo(label, sc) => { - ui.add_enabled_ui(false, |ui| { - ui.add(egui::Button::new(tl!(label)).shortcut_text(pretty_shortcut(sc))); - }) - .response - .on_disabled_hover_text(tl!("Coming soon — tracked in the parity plan")); - } - Item::Cmd(label, id, p) => { - let en = enabled(app, id); - // Unused saved-view and recent-file slots are hidden (only the real ones are listed). - if (!en && hidden_when_disabled(id)) || swapped_out(app, id) { - continue; - } - let label = display_label(app, id, label); - let sc = item_shortcut(id, p).map(pretty_shortcut).unwrap_or_default(); - let chk = checks.then(|| checked(app, id, p)).flatten(); - let text = match chk { - Some(true) => format!("✓ {label}"), - Some(false) => format!(" {label}"), - None => label, - }; - // Type → Font: each family's sample after its name (Enable in-menu font previews). - let sampled = p.get("font").and_then(Value::as_str).filter(|_| *id == "text.setStyle" && app.session.prefs.font_preview); - let r = match sampled { - Some(family) => { - let slot = ui.id().with(("font-sample", family)); - let button = egui::Button::new(text).right_text(egui::Atom::custom(slot, crate::font_menu::MENU_SAMPLE_SIZE)); - let out = ui.add_enabled_ui(en, |ui| button.atom_ui(ui)).inner; - if let Some(rect) = out.rect(slot) { - crate::font_menu::menu_item_sample(ui, rect, family); - } - out.response - } - None => ui.add_enabled(en, egui::Button::new(text).shortcut_text(sc)), - }; - if r.clicked() { - *clicked = Some(click_target(label_of(it), id, p)); - ui.close(); - } - } + Entry::Item(row) => render_row(app, ui, &row, checks, clicked), } } } +/// One menu item: its label (with a check mark, or the room for one, under `checks`), its shortcut, +/// and Type › Font's samples. +fn render_row(app: &VectorcraftApp, ui: &mut egui::Ui, row: &Row, checks: bool, clicked: &mut Option<(String, Value)>) { + let sc = row.shortcut.map(pretty_shortcut).unwrap_or_default(); + let Some((id, p)) = row.command else { + ui.add_enabled_ui(false, |ui| { + ui.add(egui::Button::new(row.label.as_ref()).shortcut_text(sc)); + }) + .response + .on_disabled_hover_text(tl!("Coming soon — tracked in the parity plan")); + return; + }; + let text = match row.checked.filter(|_| checks) { + Some(true) => format!("✓ {}", row.label), + Some(false) => format!(" {}", row.label), + None => row.label.to_string(), + }; + // Type → Font: each family's sample after its name (Enable in-menu font previews). + let sampled = p.get("font").and_then(Value::as_str).filter(|_| id == "text.setStyle" && app.session.prefs.font_preview); + let r = match sampled { + Some(family) => { + let slot = ui.id().with(("font-sample", family)); + let button = egui::Button::new(text).right_text(egui::Atom::custom(slot, crate::font_menu::MENU_SAMPLE_SIZE)); + let out = ui.add_enabled_ui(row.enabled, |ui| button.atom_ui(ui)).inner; + if let Some(rect) = out.rect(slot) { + crate::font_menu::menu_item_sample(ui, rect, family); + } + out.response + } + None => ui.add_enabled(row.enabled, egui::Button::new(text).shortcut_text(sc)), + }; + if r.clicked() { + *clicked = row.target(); + ui.close(); + } +} + /// What the Home screen remembers when it opens (`app.home`): the active document and the /// document count. When either changes, the Home screen gives way to the document. pub(crate) fn home_key(app: &VectorcraftApp) -> (Option, usize) { @@ -2730,13 +2782,6 @@ pub(crate) fn home_showing(app: &VectorcraftApp) -> bool { app.ui.home.is_some() || (app.session.active().is_none() && app.session.prefs.show_home_screen) } -fn label_of(it: &Item) -> &'static str { - match it { - Item::Cmd(l, _, _) => l, - _ => "", - } -} - /// What a menu click runs: items whose label ends with "…" and that carry default params open a /// generic parameter dialog (fields = the defaults) instead of running immediately. pub fn click_target(label: &str, id: &str, p: &Value) -> (String, Value) { @@ -2790,10 +2835,10 @@ fn field_event(app: &mut VectorcraftApp, id: &str) -> Option { }) } -/// Invoke an item of the system menu bar (macOS), chosen by a click or by its key equivalent: the -/// system takes those keys before the window sees them. While a text field has the keyboard, -/// Select All, Cut, Copy and Paste act on the field's text, as their keys do in the window; -/// everything else (and those commands with no field focused) goes to [`invoke`]. +/// Invoke an item clicked in the system menu bar (macOS; its key equivalents come back to egui as +/// key presses, see [`crate::native_menu`]). While a text field has the keyboard, Select All, Cut, +/// Copy and Paste act on the field's text, as their keys do; everything else (and those commands +/// with no field focused) goes to [`invoke`]. pub fn invoke_from_system_menu(app: &mut VectorcraftApp, ctx: &egui::Context, id: &str, p: Value) { if ctx.text_edit_focused() && let Some(e) = field_event(app, id) @@ -3000,15 +3045,17 @@ pub fn context_entries(app: &VectorcraftApp) -> Vec { fn flatten(app: &VectorcraftApp, path: Vec, items: &[Item], out: &mut Vec) { for it in items { match it { - Item::Cmd(_, id, _) if (hidden_when_disabled(id) && !enabled(app, id)) || swapped_out(app, id) => {} - Item::Cmd(l, id, p) => out.push(MenuEntry { - path: path.clone(), - label: dynamic_label(app, id, l), - command: Some(id.to_string()), - params: p.clone(), - enabled: enabled(app, id), - shortcut: item_shortcut(id, p).or_else(|| shortcut_of(id)).unwrap_or("").to_string(), - }), + Item::Cmd(l, id, p) => { + let Some((enabled, _)) = shown_state(app, id, p) else { continue }; + out.push(MenuEntry { + path: path.clone(), + label: dynamic_label(app, id, l), + command: Some(id.to_string()), + params: p.clone(), + enabled, + shortcut: item_shortcut(id, p).or_else(|| shortcut_of(id)).unwrap_or("").to_string(), + }) + } Item::Todo(l, sc) => out.push(MenuEntry { path: path.clone(), label: l.to_string(), @@ -3285,6 +3332,7 @@ pub fn menu_strings() -> std::collections::BTreeSet { out.insert(title.to_string()); walk(&items, title, &mut out); } + out.extend(crate::native_menu::MAC_LABELS.iter().map(|s| s.to_string())); out.extend(DYNAMIC_LABELS.iter().map(|s| s.to_string())); out.extend(CONTEXT_LABELS.iter().map(|s| s.to_string())); out.extend(UI_COMMANDS.iter().map(|c| c.1.to_string())); @@ -3549,11 +3597,11 @@ mod tests { let r = app.run("select.recall2", json!({})).unwrap(); assert!(r["count"].as_u64().unwrap() >= 1); assert_eq!(app.session.active().unwrap().selection.len(), 2); - // The native menu is rebuilt when the number of slots changes. - let listed = listed_slots(&app); + // A deleted selection's slot leaves the menus. app.run("select.editSaved", json!({"name": "Ellipse", "delete": true})).unwrap(); - assert_eq!(listed_slots(&app), listed - 1); assert!(!enabled(&app, "select.recall2")); + assert!(shown_state(&app, "select.recall2", &Value::Null).is_none()); + assert!(shown_state(&app, "select.recall1", &Value::Null).is_some()); } #[test] diff --git a/crates/ui-egui/src/native_menu.rs b/crates/ui-egui/src/native_menu.rs new file mode 100644 index 00000000..2701dc02 --- /dev/null +++ b/crates/ui-egui/src/native_menu.rs @@ -0,0 +1,528 @@ +//! The macOS menu bar: the menus of the in-window bar ([`crate::menus::menu_tree`], each item as +//! [`crate::menus::entry`] shows it), laid out the way a Mac app's are and handed to a platform +//! [`Backend`] (the desktop app's, through muda). +//! +//! Pure and platform-free, so it is tested everywhere and builds for the web; only the backend +//! touches AppKit. What the layout does ([`mac_layout`], Illustrator on the Mac as the reference): +//! - an **app menu** named VectorCraft: About; Settings, a submenu with one item per Preferences +//! page (General… ⌘K first); Language; Appearance (the UI brightness); Services; Hide VectorCraft +//! ⌃⌘H (⌘H stays View › Hide Edges), Hide Others ⌥⌘H, Show All; and Quit ⌘Q, still the app's own +//! `app.quit`, so documents with unsaved changes are asked about. These leave the other menus +//! (Edit › Preferences…, Help › About), and Join Our Discord stays under Help only; +//! - **Window** gets Minimize ⌃⌘M, Zoom and Bring All to Front, and **Help** the system's search +//! field; +//! - a system key already bound to a command keeps the command's: the system item goes without. +//! +//! **Keys stay with egui.** AppKit runs a menu's key equivalents before the window sees the key, +//! which would skip VectorCraft's key rules (a focused text field takes ⌘A, ⌘C, ⌘V and ⌘Z; dialogs +//! and the Type tool's input method have the keyboard). So the backend reports a key equivalent as +//! [`Event::Key`], and [`key_events`] feeds it to egui as the key press it was (the clipboard +//! events egui's window integration makes of ⌘X, ⌘C and ⌘V): the shortcut runs through +//! [`crate::shortcuts::handle`] exactly as without a native menu, user overrides included. A click +//! is [`Event::Click`] and runs like an in-window menu click. +//! +//! **Updates are cheap.** The rows are read again only when something they show may have changed +//! ([`sync`]); labels, enabled and checked are then updated in place, and the menus are rebuilt +//! only when their structure changes ([`structure_key`]: a recent file added, the language or a +//! shortcut changed). + +use std::hash::{DefaultHasher, Hash, Hasher}; + +use egui::{Key, KeyboardShortcut}; +use serde_json::{Value, json}; + +use crate::VectorcraftApp; +use crate::i18n::{Lang, tr, tr_ctx}; +use crate::menus::{self, Entry}; + +pub const APP_NAME: &str = "VectorCraft"; +/// Hide VectorCraft: an item of ours (AppKit's always takes ⌘H, which is View › Hide Edges). +pub const HIDE: &str = "app.hide"; +/// Hide Others: an item of ours, so a command bound to ⌥⌘H keeps it. +pub const HIDE_OTHERS: &str = "app.hideOthers"; +/// Minimize: an item of ours with ⌃⌘M (AppKit's always takes ⌘M). +pub const MINIMIZE: &str = "window.minimize"; + +/// The labels the Mac layout adds to the menus (translated like every menu string: +/// [`crate::menus::menu_strings`]). +pub const MAC_LABELS: &[&str] = + &["Settings", "Appearance", "Services", "Hide VectorCraft", "Hide Others", "Show All", "Minimize", "Zoom", "Bring All to Front"]; + +#[derive(Clone, Debug, Default, PartialEq)] +pub struct MenuBar { + pub menus: Vec, +} + +#[derive(Clone, Debug, PartialEq)] +pub struct Menu { + /// In the UI language (the app menu is the app's name). + pub title: String, + pub role: MenuRole, + pub children: Vec, +} + +/// What a top-level menu is for: macOS treats the app, Window and Help menus specially. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)] +pub enum MenuRole { + #[default] + Normal, + App, + Window, + Help, +} + +#[derive(Clone, Debug, PartialEq)] +pub enum Node { + Item(Item), + Separator, + /// A section header (a disabled label). + Header(String), + Submenu { + label: String, + children: Vec, + }, + /// An item AppKit provides and runs itself. + Standard(Standard), +} + +#[derive(Clone, Debug, PartialEq)] +pub struct Item { + /// The command id, one of [`HIDE`], [`HIDE_OTHERS`], [`MINIMIZE`], or `None` for an item not + /// implemented yet. + pub command: Option<&'static str>, + pub params: Value, + /// The menu tree's English label ([`crate::menus::click_target`] reads it). + pub source: &'static str, + /// In the UI language, as it reads now. + pub label: String, + /// As the registry writes it (`Cmd+Shift+Z`): `Cmd` is ⌘ and `Ctrl` the Control key. + pub shortcut: Option<&'static str>, + pub enabled: bool, + /// `Some` for an item that is on or off. + pub checked: Option, +} + +/// Items AppKit provides and runs: none has a key equivalent, so none can take a command's. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum Standard { + Services, + ShowAll, + Zoom, + BringAllToFront, +} + +impl Standard { + /// The English label ([`MAC_LABELS`]). + pub fn label(self) -> &'static str { + match self { + Standard::Services => "Services", + Standard::ShowAll => "Show All", + Standard::Zoom => "Zoom", + Standard::BringAllToFront => "Bring All to Front", + } + } +} + +impl Item { + /// An item of the layout's own (Hide, Minimize…): always enabled, `shortcut` unless a command + /// has it. + fn system(command: &'static str, source: &'static str, shortcut: Option<&'static str>, lang: Lang) -> Item { + Item { command: Some(command), params: Value::Null, source, label: tr(lang, source).into(), shortcut, enabled: true, checked: None } + } +} + +impl MenuBar { + /// Every item, depth first. + pub fn items(&self) -> Vec<&Item> { + fn walk<'a>(nodes: &'a [Node], out: &mut Vec<&'a Item>) { + for n in nodes { + match n { + Node::Item(it) => out.push(it), + Node::Submenu { children, .. } => walk(children, out), + Node::Separator | Node::Header(_) | Node::Standard(_) => {} + } + } + } + let mut out = Vec::new(); + for m in &self.menus { + walk(&m.children, &mut out); + } + out + } + + pub fn menu(&self, role: MenuRole) -> Option<&Menu> { + self.menus.iter().find(|m| m.role == role) + } +} + +/// The menus as the in-window bar shows them now, as a tree: `tree`'s items through +/// [`crate::menus::entry`] (labels in the UI language, live state, empty slots left out). +pub fn from_tree(app: &VectorcraftApp, tree: &[(&'static str, Vec)]) -> MenuBar { + fn level(app: &VectorcraftApp, items: &[menus::Item]) -> Vec { + let nodes = items + .iter() + .filter_map(|it| menus::entry(app, it)) + .map(|e| match e { + Entry::Sep => Node::Separator, + Entry::Header(h) => Node::Header(h.to_string()), + Entry::Sub(label, children) => Node::Submenu { label: label.to_string(), children: level(app, children) }, + Entry::Item(row) => Node::Item(Item { + command: row.command.map(|(id, _)| id), + params: row.command.map_or(Value::Null, |(_, p)| p.clone()), + source: row.source, + label: row.label.into_owned(), + shortcut: row.shortcut, + enabled: row.enabled, + checked: row.checked, + }), + }) + .collect(); + tidy(nodes) + } + let menus = tree + .iter() + .enumerate() + .map(|(i, (title, items))| { + // The first menu is the in-window bar's application menu. + let role = match *title { + _ if i == 0 => MenuRole::App, + "Window" => MenuRole::Window, + "Help" => MenuRole::Help, + _ => MenuRole::Normal, + }; + Menu { title: crate::i18n::t(title).to_string(), role, children: level(app, items) } + }) + .collect(); + MenuBar { menus } +} + +/// Drop separators at the start or end of a level and collapse runs of them, at every depth. +fn tidy(nodes: Vec) -> Vec { + let mut out: Vec = Vec::with_capacity(nodes.len()); + for n in nodes { + let n = match n { + Node::Submenu { label, children } => Node::Submenu { label, children: tidy(children) }, + other => other, + }; + if matches!(n, Node::Separator) && matches!(out.last(), None | Some(Node::Separator)) { + continue; + } + out.push(n); + } + while matches!(out.last(), Some(Node::Separator)) { + out.pop(); + } + out +} + +/// A hash of everything a native menu can only change by rebuilding: menus, items (command, +/// params, kind: plain or check, shortcut), submenu and header labels. Item labels, enabled and +/// checked are updated in place. +pub fn structure_key(bar: &MenuBar) -> u64 { + fn walk(nodes: &[Node], h: &mut DefaultHasher) { + for n in nodes { + match n { + Node::Item(it) => ('i', it.command, it.params.to_string(), it.checked.is_some(), it.shortcut).hash(h), + Node::Separator => '-'.hash(h), + Node::Header(label) => ('h', label).hash(h), + Node::Submenu { label, children } => { + ('[', label).hash(h); + walk(children, h); + ']'.hash(h); + } + Node::Standard(s) => ('s', s).hash(h), + } + } + } + let mut h = DefaultHasher::new(); + for m in &bar.menus { + (&m.title, m.role).hash(&mut h); + walk(&m.children, &mut h); + } + h.finish() +} + +// ----------------------------------------------------------------------------- shortcuts + +/// Does a shortcut make a key equivalent in the native menu? Only with ⌘ or ⌃, or a function key: +/// bare keys and ⌥/⇧ chords are typing (⌥ types accented letters), which AppKit would otherwise +/// take from a text field. +pub fn native_ok(sc: &KeyboardShortcut) -> bool { + sc.modifiers.command || sc.modifiers.mac_cmd || sc.modifiers.ctrl || is_function_key(sc.logical_key) +} + +pub fn is_function_key(key: Key) -> bool { + key.name().strip_prefix('F').and_then(|n| n.parse::().ok()).is_some_and(|n| (1..=24).contains(&n)) +} + +/// The input egui's window integration would have made of a press of `sc` (key and modifiers +/// held): the key press and its release, but for ⌘X, ⌘C and ⌘V the Cut, Copy and Paste events +/// (Paste with the clipboard's text, from `paste_text`). A paste's release is left to the window's +/// own key-up: one without a press or a Paste event is how a paste of a picture or a PDF is told +/// apart ([`crate::shortcuts`]). +pub fn key_events(sc: KeyboardShortcut, paste_text: impl FnOnce() -> Option) -> Vec { + let key = |pressed| egui::Event::Key { key: sc.logical_key, physical_key: None, pressed, repeat: false, modifiers: sc.modifiers }; + if sc.modifiers.command { + match sc.logical_key { + Key::X => return vec![egui::Event::Cut, key(false)], + Key::C => return vec![egui::Event::Copy, key(false)], + Key::V => return paste_text().map(|t| t.replace("\r\n", "\n")).filter(|t| !t.is_empty()).map(egui::Event::Paste).into_iter().collect(), + _ => {} + } + } + vec![key(true), key(false)] +} + +// ----------------------------------------------------------------------------- macOS layout + +/// A system key equivalent VectorCraft already uses for a command. +#[derive(Clone, Debug, PartialEq)] +pub struct Clash { + pub shortcut: &'static str, + /// What macOS uses it for. + pub system: &'static str, + /// The command bound to it. + pub command: &'static str, +} + +pub struct Layout { + pub bar: MenuBar, + /// System keys left to commands (logged once). + pub clashes: Vec, +} + +/// The Mac menu bar of `bar` (the in-window menus, [`from_tree`]): see the module docs. +pub fn mac_layout(bar: &MenuBar, lang: Lang) -> Layout { + let mut bar = bar.clone(); + let mut clashes = Vec::new(); + let bound = crate::shortcuts::all_shortcuts(); + // A system item's key, unless a command has it. + let mut key = |sc: &'static str, system: &'static str| { + let chord = crate::shortcuts::parse(sc)?; + match bound.iter().find(|(b, ..)| *b == chord) { + Some((_, command, _)) => { + clashes.push(Clash { shortcut: sc, system, command }); + None + } + None => Some(sc), + } + }; + let hide = Item::system(HIDE, "Hide VectorCraft", key("Ctrl+Cmd+H", "Hide"), lang); + let hide_others = Item::system(HIDE_OTHERS, "Hide Others", key("Cmd+Alt+H", "Hide Others"), lang); + let minimize = Item::system(MINIMIZE, "Minimize", key("Ctrl+Cmd+M", "Minimize"), lang); + + // What the application menu takes from the others (every copy: About is in Help too, Settings + // in Edit as Preferences…). + let about = take_items(&mut bar, "help.about").into_iter().next(); + let settings = take_items(&mut bar, "edit.preferences").into_iter().next(); + let quit = take_items(&mut bar, "app.quit").into_iter().next(); + let language = take_submenu(&mut bar, "app.language"); + let appearance = take_submenu(&mut bar, "window.brightness"); + // Its other items (Join Our Discord) stay where the in-window bar also has them: Help. + bar.menus.retain(|m| m.role != MenuRole::App); + + let mut app = Vec::new(); + app.extend(about.map(Node::Item)); + app.push(Node::Separator); + app.extend(settings.map(|s| Node::Submenu { label: tr(lang, "Settings").into(), children: settings_pages(&s, lang) })); + app.extend(language); + app.extend(appearance.map(|n| match n { + // The theme, as Mac apps call it. + Node::Submenu { children, .. } => Node::Submenu { label: tr_ctx(lang, "theme", "Appearance").into(), children }, + other => other, + })); + app.extend([Node::Separator, Node::Standard(Standard::Services), Node::Separator]); + app.extend([Node::Item(hide), Node::Item(hide_others), Node::Standard(Standard::ShowAll), Node::Separator]); + app.extend(quit.map(Node::Item)); + bar.menus.insert(0, Menu { title: APP_NAME.into(), role: MenuRole::App, children: app }); + + if let Some(window) = bar.menus.iter_mut().find(|m| m.role == MenuRole::Window) { + let mut children = vec![Node::Item(minimize), Node::Standard(Standard::Zoom), Node::Separator]; + children.append(&mut window.children); + children.extend([Node::Separator, Node::Standard(Standard::BringAllToFront)]); + window.children = children; + } + for m in &mut bar.menus { + m.children = tidy(std::mem::take(&mut m.children)); + } + // A menu the moves emptied goes away (Help stays: it has the search field). + bar.menus.retain(|m| !m.children.is_empty() || m.role == MenuRole::Help); + Layout { bar, clashes } +} + +/// Settings ▸: one item per page of the Preferences dialog (its own list), each opening it there; +/// the first (General…) has Preferences' shortcut (⌘K), as in Illustrator. +fn settings_pages(preferences: &Item, lang: Lang) -> Vec { + vectorcraft_engine::cmd::prefscmds::PREF_CATEGORIES + .iter() + .enumerate() + .map(|(i, page)| { + Node::Item(Item { + command: preferences.command, + params: json!({ "category": page }), + // The page's name, not a "…" label: it runs, rather than asking for its params. + source: page, + label: format!("{}…", tr(lang, page)), + shortcut: preferences.shortcut.filter(|_| i == 0), + enabled: preferences.enabled, + checked: None, + }) + }) + .collect() +} + +/// Remove every item running `command`, at any depth; returns them in order. +fn take_items(bar: &mut MenuBar, command: &str) -> Vec { + fn walk(nodes: &mut Vec, command: &str, out: &mut Vec) { + let mut kept = Vec::with_capacity(nodes.len()); + for n in std::mem::take(nodes) { + match n { + Node::Item(it) if it.command == Some(command) => out.push(it), + Node::Submenu { label, mut children } => { + walk(&mut children, command, out); + kept.push(Node::Submenu { label, children }); + } + other => kept.push(other), + } + } + *nodes = kept; + } + let mut out = Vec::new(); + for m in &mut bar.menus { + walk(&mut m.children, command, &mut out); + } + out +} + +/// Remove the first submenu that lists `command`, and any other item running it. +fn take_submenu(bar: &mut MenuBar, command: &str) -> Option { + fn find(nodes: &mut Vec, command: &str) -> Option { + let lists = |n: &Node| matches!(n, Node::Submenu { children, .. } if children.iter().any(|c| matches!(c, Node::Item(it) if it.command == Some(command)))); + if let Some(i) = nodes.iter().position(lists) { + return Some(nodes.remove(i)); + } + nodes.iter_mut().find_map(|n| match n { + Node::Submenu { children, .. } => find(children, command), + _ => None, + }) + } + let sub = bar.menus.iter_mut().find_map(|m| find(&mut m.children, command)); + take_items(bar, command); + sub +} + +/// VectorCraft's menus as a Mac menu bar, as they show now. +pub fn layout(app: &VectorcraftApp) -> Layout { + mac_layout(&from_tree(app, &menus::menu_tree()), crate::i18n::current()) +} + +// ----------------------------------------------------------------------------- the app's side + +/// What the native menu reports. +#[derive(Clone, Debug, PartialEq)] +pub enum Event { + /// An item chosen with the mouse (or the keyboard inside an open menu). + Click(Item), + /// A key equivalent pressed: the item's key with the modifiers held, to be handled as the key + /// press it was. + Key(KeyboardShortcut), +} + +/// A platform's native menu bar (the desktop app implements it for macOS with muda). +pub trait Backend { + /// Bring the menu in step with `bar`: update labels, enabled and checked in place, or rebuild + /// when its structure changed. + fn sync(&mut self, bar: &MenuBar); + /// What was chosen since the last call. Items the platform runs itself (Services, Zoom, Hide…) + /// are handled there and not reported. + fn drain(&mut self) -> Vec; +} + +/// The native menu bar, while VectorCraft uses one (the in-window menus are hidden then). +pub struct NativeMenu { + backend: Box, + /// Hash of the state the menus were last read in ([`state_hash`]). + state: Option, + clicks: Vec, + /// Something was chosen (AppKit may have toggled a check mark itself): read the menus again. + dirty: bool, + logged: bool, +} + +impl NativeMenu { + pub fn new(backend: Box) -> NativeMenu { + NativeMenu { backend, state: None, clicks: Vec::new(), dirty: true, logged: false } + } + + /// The key equivalents pressed since the last frame, for [`key_events`]; clicks wait for + /// [`run`]. + pub fn take_keys(&mut self) -> Vec { + let mut keys = Vec::new(); + for e in self.backend.drain() { + match e { + Event::Key(k) => keys.push(k), + Event::Click(it) => self.clicks.push(it), + } + self.dirty = true; + } + keys + } +} + +/// Run the items clicked in the native menu since the last frame, like in-window menu clicks. +pub fn run(app: &mut VectorcraftApp, ctx: &egui::Context) { + let Some(menu) = app.services.native_menu.as_mut() else { return }; + for it in std::mem::take(&mut menu.clicks) { + match it.command { + Some(MINIMIZE) => ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(true)), + Some(command) => { + let (id, p) = menus::click_target(it.source, command, &it.params); + menus::invoke_from_system_menu(app, ctx, &id, p); + } + None => {} + } + } +} + +/// Bring the native menu up to date when anything it shows may have changed: a command ran, the +/// document, its history or selection changed, the user clicked or pressed a key. Reading the rows +/// asks every command whether it is enabled, so frames that only animate or scroll skip it. +pub fn sync(app: &mut VectorcraftApp, ctx: &egui::Context) { + let Some(menu) = app.services.native_menu.as_ref() else { return }; + let input = ctx + .input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Key { pressed: true, .. } | egui::Event::PointerButton { pressed: false, .. }))); + let state = state_hash(app, input.then_some(app.frame)); + if menu.state == Some(state) && !menu.dirty { + return; + } + let layout = layout(app); + let Some(menu) = app.services.native_menu.as_mut() else { return }; + if !menu.logged { + for c in &layout.clashes { + log::info!("menu: {} is {} on macOS and {} in VectorCraft, which keeps it", c.shortcut, c.system, c.command); + } + menu.logged = true; + } + menu.backend.sync(&layout.bar); + menu.state = Some(state); + menu.dirty = false; +} + +/// What the menus' rows depend on, cheaply (no allocation): commands run, the active document, +/// its revision (edits, selection and view changes), history and clipboard, the language, +/// shortcuts and plug-ins. `input` forces a change on frames with a click or a key press, which +/// covers what the hash doesn't list (panels shown, a tool picked). +fn state_hash(app: &VectorcraftApp, input: Option) -> u64 { + let mut h = DefaultHasher::new(); + input.hash(&mut h); + app.run_count.hash(&mut h); + let s = &app.session; + (s.journal.len(), s.active_index(), s.clipboard.is_empty(), s.tool_composing()).hash(&mut h); + if let Some(d) = s.active() { + (d.uid, d.revision, d.history.undo.len(), d.history.redo.len(), d.transparency_grid, d.print_tiling).hash(&mut h); + } + (app.system_paste, app.last_effect.is_some(), app.ui.recent_files.len(), app.ui.recent_files.first(), app.recent_fonts().len()).hash(&mut h); + (crate::i18n::current().code(), menus::plugin_revision()).hash(&mut h); + crate::shortcut_editor::GENERATION.load(std::sync::atomic::Ordering::Relaxed).hash(&mut h); + h.finish() +} diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs index 9b59f454..a409e226 100644 --- a/crates/ui-egui/src/shortcuts.rs +++ b/crates/ui-egui/src/shortcuts.rs @@ -82,10 +82,9 @@ pub(crate) fn all_shortcuts() -> Vec<(KeyboardShortcut, &'static str, serde_json /// Consume a press of `sc`. A `=` chord also takes [`Key::Plus`], which is how `+` arrives from /// the numpad and from layouts where it has its own key (Shift+`=` arrives as either; extra Shift -/// is ignored). `native`: the system menu already handles the chord as written, so only that -/// alias is left to match here. -pub(crate) fn consume(i: &mut egui::InputState, sc: &KeyboardShortcut, native: bool) -> bool { - (!native && i.consume_shortcut(sc)) +/// is ignored). +pub(crate) fn consume(i: &mut egui::InputState, sc: &KeyboardShortcut) -> bool { + i.consume_shortcut(sc) || (sc.logical_key == Key::Equals && i.consume_key(sc.modifiers, Key::Plus)) || (sc.modifiers.shift && shifted(sc.logical_key).is_some_and(|k| i.consume_key(sc.modifiers, k))) } @@ -281,14 +280,13 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) { // Editing keys with modifiers and the clipboard (Cmd+A is Select All's, below: the text). crate::panels::character::route_type_input(app, ctx); // Enter was already delivered above as ToolKey::Enter (newline). - let fire = all_shortcuts().into_iter().filter(|(sc, ..)| sc.modifiers.command).find(|(sc, ..)| ctx.input_mut(|i| consume(i, sc, false))); + let fire = all_shortcuts().into_iter().filter(|(sc, ..)| sc.modifiers.command).find(|(sc, ..)| ctx.input_mut(|i| consume(i, sc))); if let Some((_, id, p)) = fire { crate::menus::invoke(app, id, p); } return; } - // Clipboard keys arrive as events, not key presses (except where the native menu has them); - // the chord held says which paste. + // Clipboard keys arrive as events, not key presses; the chord held says which paste. let mut clip = vec![]; ctx.input_mut(|i| { let held = i.modifiers; @@ -299,17 +297,13 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) { egui::Event::Paste(t) => (paste_command(held), Some(t.clone())), _ => return true, }; - if app.native_shortcuts.contains(id) { - return true; - } clip.push((id, text)); false }) }); - // Only the system clipboard service reads what isn't text (the native menu has its own Paste). + // Only the system clipboard service reads what isn't text. if let Some(id) = textless_paste.map(paste_command) && app.services.system_clipboard.is_some() - && !app.native_shortcuts.contains(id) { clip.push((id, None)); } @@ -389,8 +383,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) { if plain && (sc.logical_key.name().len() == 1 || matches!(sc.logical_key, Key::Slash | Key::Comma | Key::Period)) { continue; } - let native = app.native_shortcuts.contains(id); - if ctx.input_mut(|i| consume(i, &sc, native)) { + if ctx.input_mut(|i| consume(i, &sc)) { fire = Some((id, p)); break; } @@ -669,13 +662,6 @@ mod tests { let before = zoom(&mut app); frame(&mut app, vec![press(Key::Minus, Modifiers::COMMAND)]); assert!(zoom(&mut app) < before, "Cmd+- zooms out"); - // The system menu handles `Cmd+=` itself; the `+` key is still matched here. - app.native_shortcuts.insert("view.zoomIn".into()); - let before = zoom(&mut app); - frame(&mut app, vec![press(Key::Equals, Modifiers::COMMAND)]); - assert_eq!(zoom(&mut app), before, "left to the system menu"); - frame(&mut app, vec![press(Key::Plus, Modifiers::COMMAND)]); - assert!(zoom(&mut app) > before); } #[test] diff --git a/crates/ui-egui/src/tests_nativemenu.rs b/crates/ui-egui/src/tests_nativemenu.rs new file mode 100644 index 00000000..9ffe2814 --- /dev/null +++ b/crates/ui-egui/src/tests_nativemenu.rs @@ -0,0 +1,422 @@ +//! The macOS menu bar's model ([`crate::native_menu`]), tested on every platform with a fake +//! backend: the Mac layout of the in-window menus, the keys it hands back to egui, the clicks it +//! runs and when it reads the menus again. + +use std::cell::RefCell; +use std::collections::HashMap; +use std::rc::Rc; + +use egui::{Event, Key, KeyboardShortcut, Modifiers, PointerButton, Pos2, Rect, vec2}; +use serde_json::{Value, json}; +use vectorcraft_engine::Session; +use vectorcraft_engine::cmd::prefscmds::PREF_CATEGORIES; + +use crate::i18n::Lang; +use crate::native_menu::{self, Backend, MenuBar, MenuRole, NativeMenu, Node, Standard}; +use crate::{VectorcraftApp, menus}; + +fn app(doc: bool) -> VectorcraftApp { + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + if doc { + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("shape.rectangle", json!({"x": 20, "y": 20, "width": 37, "height": 40})).unwrap(); + } + app +} + +fn bar(app: &VectorcraftApp) -> MenuBar { + native_menu::mac_layout(&native_menu::from_tree(app, &menus::menu_tree()), Lang::EN).bar +} + +/// A level's nodes as short names: an item's command (`---` a separator, `[label]` a submenu, +/// `` an AppKit item). +fn ids(nodes: &[Node]) -> Vec { + nodes + .iter() + .map(|n| match n { + Node::Item(it) => it.command.unwrap_or("").to_string(), + Node::Separator => "---".into(), + Node::Header(h) => format!("#{h}"), + Node::Submenu { label, .. } => format!("[{label}]"), + Node::Standard(s) => format!("<{s:?}>"), + }) + .collect() +} + +fn menu<'a>(bar: &'a MenuBar, title: &str) -> &'a [Node] { + &bar.menus.iter().find(|m| m.title == title).unwrap_or_else(|| panic!("no {title} menu")).children +} + +fn submenu<'a>(nodes: &'a [Node], name: &str) -> &'a [Node] { + nodes + .iter() + .find_map(|n| match n { + Node::Submenu { label, children } if label == name => Some(children.as_slice()), + _ => None, + }) + .unwrap_or_else(|| panic!("no {name} submenu in {:?}", ids(nodes))) +} + +fn items(nodes: &[Node]) -> Vec<&native_menu::Item> { + nodes.iter().filter_map(|n| if let Node::Item(it) = n { Some(it) } else { None }).collect() +} + +fn find<'a>(bar: &'a MenuBar, command: &str) -> &'a native_menu::Item { + bar.items().into_iter().find(|it| it.command == Some(command)).unwrap_or_else(|| panic!("no {command} item")) +} + +#[test] +fn vectorcraft_gets_a_mac_app_menu() { + let bar = bar(&app(true)); + let titles: Vec<&str> = bar.menus.iter().map(|m| m.title.as_str()).collect(); + assert_eq!(titles, ["VectorCraft", "File", "Edit", "Object", "Type", "Select", "Effect", "View", "Window", "Help"]); + let app_menu = &bar.menus[0]; + assert_eq!(app_menu.role, MenuRole::App); + assert_eq!( + ids(&app_menu.children), + [ + "help.about", + "---", + "[Settings]", + "[Language]", + "[Appearance]", + "---", + "", + "---", + native_menu::HIDE, + native_menu::HIDE_OTHERS, + "", + "---", + "app.quit" + ] + ); + let shown = |command: &str| { + let it = find(&bar, command); + (it.label.as_str(), it.shortcut) + }; + assert_eq!(shown("help.about"), ("About VectorCraft", None)); + assert_eq!(shown("app.quit"), ("Quit VectorCraft", Some("Cmd+Q")), "Quit is the app's own, so unsaved documents are asked about"); + // ⌘H stays View › Hide Edges (Illustrator's); Hide takes ⌃⌘H. + assert_eq!(shown(native_menu::HIDE), ("Hide VectorCraft", Some("Ctrl+Cmd+H"))); + assert_eq!(shown(native_menu::HIDE_OTHERS), ("Hide Others", Some("Cmd+Alt+H"))); + assert_eq!(find(&bar, "view.edges").shortcut, Some("Cmd+H")); + assert_eq!(bar.menu(MenuRole::Help).map(|m| m.title.as_str()), Some("Help")); +} + +/// Settings ▸ lists the Preferences dialog's own pages, General… with ⌘K, and each opens the +/// dialog on its page. +#[test] +fn settings_lists_every_preferences_page() { + let mut app = app(true); + let bar = bar(&app); + let pages = items(submenu(&bar.menus[0].children, "Settings")); + assert_eq!(pages.len(), PREF_CATEGORIES.len()); + assert_eq!((pages[0].label.as_str(), pages[0].shortcut), ("General…", Some("Cmd+K"))); + assert!(pages[1..].iter().all(|it| it.shortcut.is_none())); + for (it, page) in pages.iter().zip(PREF_CATEGORIES) { + assert_eq!((it.command, &it.params, it.label.clone()), (Some("edit.preferences"), &json!({"category": page}), format!("{page}…"))); + } + let units = pages.iter().find(|it| it.source == "Units").unwrap(); + let (id, p) = menus::click_target(units.source, units.command.unwrap(), &units.params); + assert_eq!(id, "edit.preferences", "a page opens the dialog, not a parameter form"); + menus::invoke(&mut app, &id, p); + let dialog = app.ui.dialog.as_ref().expect("Preferences open"); + assert_eq!((dialog.kind.as_str(), dialog.fields.get("__category")), ("preferences", Some(&json!("Units")))); +} + +/// Language ▸: Automatic, then each language in its own name (in any UI language), the +/// preference checked; Appearance ▸: the UI brightness choices, the current one checked. +#[test] +fn language_and_appearance_are_in_the_app_menu() { + let mut app = app(false); + app.session.prefs.interface_language = "ja".into(); + let bar = bar(&app); + let app_menu = &bar.menus[0].children; + assert_eq!(ids(submenu(app_menu, "Language"))[..2], ["app.language", "---"], "Automatic, then the languages"); + let langs: Vec<(String, Option)> = items(submenu(app_menu, "Language")).iter().map(|it| (it.label.clone(), it.checked)).collect(); + let mut want = vec![("Automatic".to_string(), Some(false))]; + want.extend(Lang::all().map(|l| (l.name().to_string(), Some(l.code() == "ja")))); + assert_eq!(langs, want); + // In every UI language the languages keep their own names. + for ui in Lang::all() { + for l in Lang::all() { + assert_eq!(crate::i18n::tr_id(ui, "app.language", l.name()), l.name(), "{} in {}", l.name(), ui.code()); + } + } + let appearance: Vec<(&'static str, Option)> = items(submenu(app_menu, "Appearance")).iter().map(|it| (it.source, it.checked)).collect(); + assert_eq!(appearance.len(), crate::theme::Brightness::ALL.len()); + assert_eq!(appearance.iter().filter(|(_, c)| *c == Some(true)).count(), 1, "{appearance:?}"); + assert!(appearance.iter().all(|(_, c)| c.is_some())); + assert_eq!(crate::i18n::tr_ctx(Lang::from_code("ja").unwrap(), "theme", "Appearance"), "外観", "the theme, not the Appearance panel"); +} + +/// Everything the in-window bar lists is in the Mac menu bar, once: what moved to the app menu +/// (About, Settings, Quit, Language, UI Brightness) leaves its other places, and Join Our Discord +/// stays under Help. +#[test] +fn every_in_window_item_is_in_the_mac_menu_bar_once() { + let app = app(true); + let count = |bar: &MenuBar| { + let mut n: HashMap<(String, String), usize> = HashMap::new(); + for it in bar.items() { + if let Some(c) = it.command { + // Settings ▸ opens Preferences on each page: one item per page instead of one. + let params = if c == "edit.preferences" { String::new() } else { it.params.to_string() }; + *n.entry((c.to_string(), params)).or_default() += 1; + } + } + n + }; + let in_window = native_menu::from_tree(&app, &menus::menu_tree()); + let mac = bar(&app); + let (a, b) = (count(&in_window), count(&mac)); + // The in-window application menu's commands, its submenus' included. + let moved: Vec<&str> = MenuBar { menus: vec![in_window.menus[0].clone()] }.items().iter().filter_map(|it| it.command).collect(); + for (key, n) in &a { + let m = b.get(key).copied().unwrap_or(0); + let want = match key.0.as_str() { + "edit.preferences" => PREF_CATEGORIES.len(), + c if moved.contains(&c) => 1, + _ => *n, + }; + assert_eq!(m, want, "{key:?} is listed {m} times on the Mac, {n} in the window"); + } + let system = [native_menu::HIDE, native_menu::HIDE_OTHERS, native_menu::MINIMIZE]; + for key in b.keys() { + assert!(a.contains_key(key) || system.contains(&key.0.as_str()), "{key:?} isn't an in-window item"); + } + let help = ids(menu(&mac, "Help")); + assert!(help.contains(&"help.discord".to_string()) && !help.contains(&"help.about".to_string()), "{help:?}"); + let edit = ids(menu(&mac, "Edit")); + assert!(!edit.contains(&"edit.preferences".to_string()) && edit.contains(&"edit.keyboardShortcuts".to_string()), "{edit:?}"); + assert!(ids(menu(&mac, "Window")).contains(&"[Workspace]".to_string())); +} + +#[test] +fn the_window_menu_has_the_system_items() { + let bar = bar(&app(true)); + let window = ids(&bar.menu(MenuRole::Window).unwrap().children); + assert_eq!(window[..3], [native_menu::MINIMIZE.to_string(), "".into(), "---".into()]); + assert_eq!(window[window.len() - 2..], ["---".to_string(), "".into()]); + assert_eq!(window[3], "window.newWindow", "then VectorCraft's own items"); + assert_eq!(find(&bar, native_menu::MINIMIZE).shortcut, Some("Ctrl+Cmd+M")); + assert!(!window.iter().any(|i| i == "window.brightness"), "the theme is only in the app menu"); + assert_eq!(Standard::Zoom.label(), "Zoom"); +} + +/// A system key a command already has stays the command's: the system item goes without. The +/// user's shortcuts show in the menus. +#[test] +fn a_command_keeps_a_system_key_it_is_bound_to() { + let mut app = app(true); + app.ui.shortcut_overrides.insert("view.grid".into(), "Ctrl+Cmd+H".into()); + crate::shortcut_editor::sync(&app.ui); + let layout = native_menu::mac_layout(&native_menu::from_tree(&app, &menus::menu_tree()), Lang::EN); + app.ui.shortcut_overrides.clear(); + crate::shortcut_editor::sync(&app.ui); + assert_eq!(find(&layout.bar, native_menu::HIDE).shortcut, None); + assert_eq!(find(&layout.bar, "view.grid").shortcut, Some("Ctrl+Cmd+H"), "the user's override shows in the menu"); + assert_eq!(layout.clashes.iter().map(|c| (c.shortcut, c.command)).collect::>(), [("Ctrl+Cmd+H", "view.grid")]); +} + +/// A native menu can't turn a plain item into a check item in place: opening a document or +/// selecting must not change the menus' structure, or every change rebuilds them. +#[test] +fn documents_and_selections_change_state_not_structure() { + let empty = native_menu::structure_key(&bar(&app(false))); + let mut a = app(true); + assert_eq!(native_menu::structure_key(&bar(&a)), empty, "a document with a selected rectangle"); + a.run("select.none", json!({})).unwrap(); + a.run("text.create", json!({"x": 50, "y": 50, "text": "Hi"})).unwrap(); + assert!(!a.session.active().unwrap().selection.objects.is_empty()); + assert_eq!(native_menu::structure_key(&bar(&a)), empty, "type selected"); + // A recent file is a new item: the menus are rebuilt. + crate::io::note_recent(&mut a, "/art/a.svg"); + assert_ne!(native_menu::structure_key(&bar(&a)), empty); +} + +#[test] +fn key_equivalents_are_command_and_function_keys_only() { + let ok = |s| crate::shortcuts::parse(s).is_some_and(|k| native_menu::native_ok(&k)); + assert!(ok("Cmd+B") && ok("F7") && ok("Ctrl+Cmd+M") && ok("Shift+F7")); + assert!(!ok("B") && !ok("Alt+F") && !ok("Shift+X")); +} + +/// What a key equivalent becomes: the press and release egui's window integration sends, or for +/// ⌘X, ⌘C and ⌘V its clipboard events (a paste's release comes from the window). +#[test] +fn key_equivalents_become_the_input_their_keys_make() { + let cmd = |key| KeyboardShortcut::new(Modifiers::COMMAND, key); + let key = |key, pressed| Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::COMMAND }; + assert_eq!(native_menu::key_events(cmd(Key::A), || None), [key(Key::A, true), key(Key::A, false)]); + assert_eq!(native_menu::key_events(cmd(Key::C), || None), [Event::Copy, key(Key::C, false)]); + assert_eq!(native_menu::key_events(cmd(Key::X), || None), [Event::Cut, key(Key::X, false)]); + assert_eq!(native_menu::key_events(cmd(Key::V), || Some("a\r\nb".into())), [Event::Paste("a\nb".into())]); + assert_eq!(native_menu::key_events(cmd(Key::V), || None), [], "a picture: the release tells the paste"); +} + +/// The fake backend: the menus the app synced, and events to report. +#[derive(Clone, Default)] +struct Fake(Rc, Vec)>>); + +impl Backend for Fake { + fn sync(&mut self, bar: &MenuBar) { + self.0.borrow_mut().0.push(bar.clone()); + } + fn drain(&mut self) -> Vec { + std::mem::take(&mut self.0.borrow_mut().1) + } +} + +impl Fake { + fn synced(&self) -> usize { + self.0.borrow().0.len() + } + fn last(&self) -> MenuBar { + self.0.borrow().0.last().cloned().unwrap() + } + fn report(&self, e: native_menu::Event) { + self.0.borrow_mut().1.push(e); + } +} + +/// The app with the fake native menu (or none), driven a whole frame at a time like the desktop +/// app. +struct Mac { + app: VectorcraftApp, + fake: Fake, + ctx: egui::Context, + time: f64, +} + +impl Mac { + fn new(native: bool) -> Self { + let mut app = app(true); + let fake = Fake::default(); + if native { + app.services.native_menu = Some(NativeMenu::new(Box::new(fake.clone()))); + } + let mut m = Mac { app, fake, ctx: egui::Context::default(), time: 0.0 }; + for _ in 0..3 { + m.frame(vec![]); + } + m + } + + fn frame(&mut self, events: Vec) -> egui::FullOutput { + self.time += 0.1; + let mut raw = egui::RawInput { + events, + time: Some(self.time), + screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 850.0))), + ..Default::default() + }; + self.app.raw_input_hook(&mut raw); + let app = &mut self.app; + let mut out = self.ctx.run_ui(raw, |ui| { + app.logic(ui.ctx()); + app.ui(ui); + }); + out.textures_delta.clear(); + out + } + + /// AppKit chose an item by its key equivalent `sc` (⌘ held). + fn key_equivalent(&mut self, sc: &str) -> egui::FullOutput { + let mut k = crate::shortcuts::parse(sc).unwrap(); + k.modifiers.mac_cmd = k.modifiers.command; + self.fake.report(native_menu::Event::Key(k)); + self.frame(vec![]) + } + + fn selected(&self) -> usize { + self.app.session.active().unwrap().selection.objects.len() + } +} + +/// A key equivalent runs through the app's own key handling, once: ⌘A selects every object, ⌘Z +/// undoes one step; and frames where nothing changed don't read the menus again. +#[test] +fn key_equivalents_run_through_the_normal_shortcut_path_once() { + let mut m = Mac::new(true); + m.app.run("shape.rectangle", json!({"x": 200, "y": 150, "width": 20, "height": 20})).unwrap(); + m.app.run("select.none", json!({})).unwrap(); + m.frame(vec![]); + m.key_equivalent("Cmd+A"); + assert_eq!(m.selected(), 2, "⌘A selected every object"); + let undo = |m: &Mac| m.app.session.active().unwrap().history.undo.len(); + let before = undo(&m); + m.key_equivalent("Cmd+Z"); + assert_eq!(undo(&m), before - 1, "⌘Z undid one step"); + let synced = m.fake.synced(); + assert!(synced >= 1, "the menus were built"); + m.frame(vec![]); + m.frame(vec![]); + assert_eq!(m.fake.synced(), synced, "nothing changed: the menus weren't read again"); + assert_eq!(crate::control::inspect(&m.app, &m.ctx)["nativeMenuBar"], json!(true)); +} + +/// A click runs its command like an in-window click, and the menus follow: View › Show Rulers +/// reads Hide Rulers afterwards; the app menu's Appearance items run with their params. +#[test] +fn clicks_run_their_command_and_the_menus_follow() { + let mut m = Mac::new(true); + let rulers = find(&m.fake.last(), "view.rulers").clone(); + let before = m.app.ui.view.rulers; + m.fake.report(native_menu::Event::Click(rulers.clone())); + m.frame(vec![]); + assert_eq!(m.app.ui.view.rulers, !before); + assert_ne!(find(&m.fake.last(), "view.rulers").label, rulers.label, "the label flipped"); + let other = m.fake.last().items().into_iter().find(|it| it.command == Some("window.brightness") && it.checked == Some(false)).cloned().unwrap(); + m.fake.report(native_menu::Event::Click(other.clone())); + m.frame(vec![]); + assert_eq!(Some(m.app.ui.brightness.id()), other.params.get("brightness").and_then(Value::as_str)); + let now = m.fake.last().items().into_iter().find(|it| it.params == other.params).cloned().unwrap(); + assert_eq!(now.checked, Some(true), "the checkmark moved"); +} + +/// With a text field focused, the menu's ⌘A and ⌘C act on the field, as the keys do without the +/// native menu. +#[test] +fn a_focused_field_keeps_select_all_and_copy() { + let mut m = Mac::new(true); + let (id, rect) = m + .ctx + .viewport(|vp| vp.prev_pass.widgets.layers().flat_map(|(_, w)| w.iter()).map(|w| (w.id, w.rect)).collect::>()) + .into_iter() + .find(|&(id, _)| m.ctx.data(|d| d.get_temp::(id)).is_some_and(|t| t == "37 pt") && egui::TextEdit::load_state(&m.ctx, id).is_some()) + .expect("the W field"); + let click = |pressed| Event::PointerButton { pos: rect.center(), button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }; + m.frame(vec![Event::PointerMoved(rect.center()), click(true)]); + m.frame(vec![click(false)]); + m.frame(vec![Event::Key { key: Key::End, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }]); + assert!(m.ctx.text_edit_focused()); + m.key_equivalent("Cmd+A"); + let r = egui::TextEdit::load_state(&m.ctx, id).and_then(|s| s.cursor.char_range()).unwrap(); + let (a, b): (usize, usize) = (r.primary.index.into(), r.secondary.index.into()); + assert_eq!((a.min(b), a.max(b)), (0, 5), "⌘A selected the field's text"); + assert_eq!(m.selected(), 1, "not the art"); + let out = m.key_equivalent("Cmd+C"); + let copied: Vec<_> = + out.platform_output.commands.iter().filter_map(|c| if let egui::OutputCommand::CopyText(t) = c { Some(t.as_str()) } else { None }).collect(); + assert_eq!(copied, ["37 pt"]); + assert!(m.app.session.clipboard.is_empty(), "no art copied"); +} + +/// With the macOS menu bar the app bar draws no menu titles: each shows once fewer. +#[test] +fn the_app_bar_hides_its_menus_with_the_mac_menu_bar() { + let texts = |native: bool| { + let mut m = Mac::new(native); + let out = m.frame(vec![]); + out.shapes + .iter() + .filter_map(|s| if let egui::Shape::Text(t) = &s.shape { Some(t.galley.text().to_string()) } else { None }) + .collect::>() + }; + let (in_window, native) = (texts(false), texts(true)); + for (title, _) in menus::menu_tree().iter().skip(1) { + let n = |t: &[String]| t.iter().filter(|s| s == title).count(); + assert_eq!(n(&native) + 1, n(&in_window), "{title}"); + } +} diff --git a/crates/ui-egui/src/tests_save.rs b/crates/ui-egui/src/tests_save.rs index 39826283..30b0398e 100644 --- a/crates/ui-egui/src/tests_save.rs +++ b/crates/ui-egui/src/tests_save.rs @@ -107,7 +107,7 @@ fn recent_files_show_as_many_as_the_preference_keeps() { assert!(menus::enabled(&app, "file.openRecent30")); app.session.prefs.recent_files_count = 0; assert_eq!((io::recent_files(&app).len(), listed(&app)), (0, 0), "0 hides the list"); - assert_eq!(menus::listed_slots(&app), 0, "the native menu rebuilds without them"); + assert!(menus::shown_state(&app, "file.openRecent1", &json!(null)).is_none(), "the slots leave the menus"); assert!(app.run("file.openRecent1", json!({})).is_err()); app.session.prefs.recent_files_count = 5; assert_eq!(io::recent_files(&app)[0], "/art/34.svg", "hiding them didn't forget them"); diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 3844c82f..3a2e27f1 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -18,7 +18,7 @@ so only enable it while you use it. Transport: `apps/vectorcraft/src/control_ser | `engine.execute` | `{command, params}` | run any engine or UI command (see `engine.commands`) | | `engine.commands` | | every command with label, shortcut, params doc, enablement | | `document.inspect` | `{depth?, childLimit?}` | layer tree, selection, history, paint defaults; the options slice the layer tree as `document.node {summary: true}` does | -| `ui.inspect` | | tool, UI state, `screenMode` (0 normal, 1 full screen with menu bar, 2 full screen, 3 Presentation Mode), `taskBar` (`pinned`, and `rect` `[x, y, w, h]` while the Contextual Task Bar shows), view, canvas rect, window size, perf, background saves and exports still running | +| `ui.inspect` | | tool, UI state, `screenMode` (0 normal, 1 full screen with menu bar, 2 full screen, 3 Presentation Mode), `taskBar` (`pinned`, and `rect` `[x, y, w, h]` while the Contextual Task Bar shows), view, canvas rect, window size, perf, background saves and exports still running, `nativeMenuBar` (true when the menus are in the macOS menu bar rather than the window; `ui.menu.list` lists the in-window menus either way) | | `ui.menu.list` / `ui.menu.invoke` | `{command, params}` | the full menu tree / invoke an item | | `ui.contextMenu.list` | | the canvas context menu for the current selection, flattened like `ui.menu.list` (`path` holds its submenus). `ui.click {x, y, button: "right"}` on the canvas opens it, after selecting the object there unless it is already selected | | `ui.tool.select` / `ui.tool.list` | `{tool}` | | diff --git a/docs/development.md b/docs/development.md index aa441142..ae28520f 100644 --- a/docs/development.md +++ b/docs/development.md @@ -62,6 +62,7 @@ By default VectorCraft's own crates log at `info` and everything else at `warn`. | Variable | Effect | |---|---| | `VECTORCRAFT_CONTROL_PORT` | Same as `--control ` | +| `VECTORCRAFT_IN_WINDOW_MENUS` | Any value but empty or `0`: same as `--in-window-menus` (see [macOS: the menu bar](#macos-the-menu-bar)) | | `VECTORCRAFT_NO_PREFS` | No preferences read or written, no default Data Recovery folder and no log file (agents' test runs) | | `WGPU_POWER_PREF` | Graphics adapter: `low`, `high` or `none` (see [Desktop graphics processor](#desktop-graphics-processor)) | | `WGPU_ADAPTER_NAME` | Graphics adapter by (part of) its name, any case (see [Desktop graphics processor](#desktop-graphics-processor)) | @@ -69,6 +70,15 @@ By default VectorCraft's own crates log at `info` and everything else at `warn`. | `VECTORCRAFT_GPU_SKIP` | Set by the app when it starts again without a graphics adapter that failed (see [Desktop graphics processor](#desktop-graphics-processor)) | | `RUST_LOG` | Log levels for standard error and the log file (see [Logs](#logs)) | +## macOS: the menu bar + +On macOS the menus live in the system menu bar, not in the window's app bar (which keeps the brand mark, Home, the search box and the workspace switcher next to the traffic lights). `--in-window-menus` or `VECTORCRAFT_IN_WINDOW_MENUS=1` keeps them in the window, as on Windows, Linux and the web; so does a menu bar AppKit refuses to build (logged). `ui.inspect` says which with `nativeMenuBar`. + +- **One menu model.** `crates/ui-egui/src/native_menu.rs` (platform-free, tested on every platform) builds the menu bar from the in-window menus (`menus::menu_tree`, each item through `menus::entry`, which the in-window menus draw too) and lays it out the Mac way: the VectorCraft menu holds About, Settings ▸ (one item per Preferences page, General… ⌘K), Language ▸, Appearance ▸ (UI brightness), Services, Hide VectorCraft ⌃⌘H (⌘H stays View › Hide Edges), Hide Others ⌥⌘H, Show All and Quit ⌘Q (the app's own `app.quit`, so unsaved documents are asked about); those leave Edit and Help. Window starts with Minimize ⌃⌘M and Zoom and ends with Bring All to Front, and Help is the system's Help menu (its search field). A system key a command (or a user's shortcut) already has stays the command's, and the log says so. +- **The native side** is `apps/vectorcraft/src/mac_menu.rs`: muda (`=0.21.1`, default features off, macOS only, no `unsafe`) builds the `NSMenu`s. Labels, enabled and checked are updated in place when anything they show may have changed (a command ran, the document, its history or selection changed, a click or a key press); a change of structure (a recent file, the language, a shortcut) rebuilds the menus. +- **Keys stay with egui.** AppKit runs a menu's key equivalents before the window sees the key, so the item's key goes back to egui as the key press it was (⌘X/⌘C/⌘V as egui's Cut/Copy/Paste events), through `raw_input_hook`: `shortcuts::handle` runs it once, user shortcuts apply, and a focused text field keeps ⌘A, ⌘C, ⌘V and ⌘Z. A click runs the item like an in-window click. Bare keys and ⌥/⇧ chords are never key equivalents (they type). +- Built and clippy-checked for `aarch64-apple-darwin` and `x86_64-apple-darwin` from any host: `cargo clippy -p vectorcraft --target aarch64-apple-darwin --all-targets -- -D warnings`. + ## Linux: Wayland and X11 The window runs natively on Wayland (eframe's `wayland` feature) and on X11. On machines with two GPUs it renders on the one the desktop runs on unless Preferences say otherwise; see [Desktop graphics processor](#desktop-graphics-processor) (#502). The system clipboard (`apps/vectorcraft/src/clipboard.rs`) is arboard with its `wayland-data-control` feature: From c21f78328637d13cfd511a2ec174123914bdc218 Mon Sep 17 00:00:00 2001 From: Michael Gieson Date: Thu, 8 Oct 2026 12:57:16 -0400 Subject: [PATCH 14/22] Clippy: use as_chunks for constant-size chunks (Rust 1.98) Rust 1.98's clippy adds `chunks_exact_to_as_chunks`, which `-D warnings` turns into an error, so `cargo xtask ci` fails on main with the current stable toolchain. The EPS stencil-mask loop and the cursor rasterizer (and two cursor tests) now use `as_chunks`, which yields fixed-size arrays; like `chunks_exact`, it skips an incomplete last chunk, so nothing changes in behaviour. Co-Authored-By: Claude Opus 5.5 (1M context) --- crates/eps/src/import/data.rs | 2 +- crates/ui-egui/src/cursors.rs | 7 +++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/crates/eps/src/import/data.rs b/crates/eps/src/import/data.rs index 4a8d56d0..677e134f 100644 --- a/crates/eps/src/import/data.rs +++ b/crates/eps/src/import/data.rs @@ -743,7 +743,7 @@ impl Interp<'_> { let Some(mut img) = self.decode_image(image)? else { return Ok(None) }; let Some(m) = self.decode_image(stencil)? else { return Ok(Some(img)) }; let (w, h, mw, mh) = (img.w as usize, img.h as usize, m.w as usize, m.h as usize); - for (i, px) in img.rgba.chunks_exact_mut(4).enumerate() { + for (i, px) in img.rgba.as_chunks_mut::<4>().0.iter_mut().enumerate() { let (x, y) = (i % w, i / w); // The mask's pixel over this one (in 64 bits: rows times rows overflow 32). let at = (y as u64 * mh as u64 / h.max(1) as u64) * mw as u64 + x as u64 * mw as u64 / w.max(1) as u64; diff --git a/crates/ui-egui/src/cursors.rs b/crates/ui-egui/src/cursors.rs index e5c2e4aa..333c22ff 100644 --- a/crates/ui-egui/src/cursors.rs +++ b/crates/ui-egui/src/cursors.rs @@ -348,8 +348,7 @@ fn rasterize(c: Cursor, ppp: f32) -> Option { let (w, h) = (size.x as usize, size.y as usize); let mut px = vec![[0.0; 4]; w * h]; let corner = |v: &Vertex| (v.pos.to_vec2() * ppp - min, v.color); - for tri in mesh.indices.chunks_exact(3) { - let &[i, j, k] = tri else { continue }; + for &[i, j, k] in mesh.indices.as_chunks::<3>().0 { if let (Some(a), Some(b), Some(c)) = (mesh.vertices.get(i as usize), mesh.vertices.get(j as usize), mesh.vertices.get(k as usize)) { fill_triangle(&mut px, w, [corner(a), corner(b), corner(c)]); } @@ -463,7 +462,7 @@ mod tests { assert_eq!(img.rgba.len(), w * h * 4, "{c:?}"); assert!(img.hotspot[0] < img.size[0] && img.hotspot[1] < img.size[1], "{c:?} at {ppp}: {img:?}"); assert!(w as f32 <= 50.0 * ppp && h as f32 <= 50.0 * ppp, "{c:?} at {ppp}: {img:?}"); - assert!(img.rgba.chunks_exact(4).any(|p| p[3] == 255), "{c:?}: nothing opaque"); + assert!(img.rgba.as_chunks::<4>().0.iter().any(|p| p[3] == 255), "{c:?}: nothing opaque"); } } for c in [Cursor::Hand, Cursor::HandGrab, Cursor::ZoomIn, Cursor::ZoomOut, Cursor::NotAllowed] { @@ -482,7 +481,7 @@ mod tests { assert!(pixel(&img, hx, hy)[3] > 0, "{:?}", pixel(&img, hx, hy)); let body = pixel(&img, hx + 2, hy + 8); assert!(body[3] == 255 && body[..3].iter().all(|&c| c < 40), "{body:?}"); - assert!(img.rgba.chunks_exact(4).any(|p| p[3] == 255 && p[..3].iter().all(|&c| c > 215)), "no white halo"); + assert!(img.rgba.as_chunks::<4>().0.iter().any(|p| p[3] == 255 && p[..3].iter().all(|&c| c > 215)), "no white halo"); // Nothing left of or above the tip but the halo. assert!((0..img.size[1] as usize).all(|y| pixel(&img, 0, y)[..3].iter().all(|&c| c > 100) || pixel(&img, 0, y)[3] < 128)); // At twice the pixels per point, twice the pixels. From d9544d8f87f76c06f40abc69ce05973e3ec708e4 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 00:39:45 +0700 Subject: [PATCH 15/22] UI: the ruler unit menu in the ROADMAP; its test names the PR Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 4 ++-- crates/ui-egui/src/tests_contextmenu.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 5cc39bf4..17f0e781 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request), the rulers' unit menu (#528); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -132,7 +132,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, onto the Swatches panel a pattern swatch and onto the Brushes panel an Art brush; a symbol dragged onto the canvas places an instance where it is dropped, and a brush dragged onto a path is applied to it. - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options, and the Pencil, Paintbrush, Smooth, Blob Brush and Eraser tools their Tool Options (Fidelity, fill, the tolerances, the brush size). - **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies) and a dimmed copy of the row under the pointer (dropped on the trash rows are deleted, on New Layer duplicated, as in Illustrator), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets, each with a chip of its colour, or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting. -- **Drawing aids:** Smart Guides and snapping (moving, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles with the Selection or Free Transform tool, Shift and Alt too: the dragged corner or side lands on the other objects' anchors and centres ("anchor", "center") or lines up with their edges and centres (a line and "align"); the Rotate, Scale, Shear and Reflect tools drag from the anchor they grab and snap the pointer the same way, so a corner dragged onto another object's anchor scales exactly onto it, #482; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (#451: they snap as moved guides do, Shift to the ruler's ticks; with the Artboard tool they are artboard guides, which run across their artboard only and move, copy and delete with it, `guide.add {artboard}`) that the Selection, Direct Selection and Group Selection tools then pick and drag (#414: the selected guides highlight and move together, Alt copies them, Shift snaps the dragged one to the ticks, otherwise it snaps to pixels, the grid or the edges, centres (so the sides' midpoints) and anchors of the art and the artboards, or with Smart Guides off Snap to Point pulls it onto anchors; the arrow keys nudge them, Delete deletes them, dragging one back onto its ruler deletes it, Lock Guides and Hide Guides leave them alone; `guide.list`, `guide.select`, `guide.move` and `guide.remove` reach agents), and Draw Normal / Behind / Inside modes. +- **Drawing aids:** Smart Guides and snapping (moving, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles with the Selection or Free Transform tool, Shift and Alt too: the dragged corner or side lands on the other objects' anchors and centres ("anchor", "center") or lines up with their edges and centres (a line and "align"); the Rotate, Scale, Shear and Reflect tools drag from the anchor they grab and snap the pointer the same way, so a corner dragged onto another object's anchor scales exactly onto it, #482; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (#451: they snap as moved guides do, Shift to the ruler's ticks; with the Artboard tool they are artboard guides, which run across their artboard only and move, copy and delete with it, `guide.add {artboard}`) that the Selection, Direct Selection and Group Selection tools then pick and drag (#414: the selected guides highlight and move together, Alt copies them, Shift snaps the dragged one to the ticks, otherwise it snaps to pixels, the grid or the edges, centres (so the sides' midpoints) and anchors of the art and the artboards, or with Smart Guides off Snap to Point pulls it onto anchors; the arrow keys nudge them, Delete deletes them, dragging one back onto its ruler deletes it, Lock Guides and Hide Guides leave them alone; `guide.list`, `guide.select`, `guide.move` and `guide.remove` reach agents), a right-click on either ruler or the origin box to pick the document's units (the current one checked; `document.setUnits`, one undo step, #528), and Draw Normal / Behind / Inside modes. - **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard. The Artboards panel highlights that active artboard: clicking a row makes it active (the Artboard tool's too, while it is chosen) as does clicking an artboard with the Artboard tool, double-clicking its number also fits it in the window and double-clicking its name renames it. Duplicate Artboards, or a row dragged onto New Artboard, copies the artboard with its art (#446). Escape leaves Presentation Mode, F from it goes back to Normal Screen Mode, and the screen mode isn't saved with the preferences: the app always starts in Normal Screen Mode with its menus and panels (#472). - **Geometry and effects:** - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected. With anchors selected, the Control bar and the Properties panel also convert them to corner or smooth (`path.convertAnchors`), connect end points (Join) and cut the path at them (`path.cutAtAnchors`, also on the task bar and the context menu): a closed path opens there and an open one becomes one path per piece, each cut leaving one of its two coincident anchors selected so a drag pulls the path apart. diff --git a/crates/ui-egui/src/tests_contextmenu.rs b/crates/ui-egui/src/tests_contextmenu.rs index 7cc7dc1c..1890666c 100644 --- a/crates/ui-egui/src/tests_contextmenu.rs +++ b/crates/ui-egui/src/tests_contextmenu.rs @@ -110,7 +110,7 @@ fn right_click_on_empty_canvas_offers_the_view_and_a_dismissing_click_does_nothi assert_eq!(app.session.active().unwrap().doc.art_bounds(), None); } -/// #: right-clicking a ruler offers the document units, the current one checked, and choosing one +/// #528: right-clicking a ruler offers the document units, the current one checked, and choosing one /// swaps them — the same effect as Preferences ▸ Units ▸ General (`document.setUnits`). #[test] fn right_clicking_a_ruler_swaps_the_document_units() { From 6efe9df3e862e6bbbdff8c789a88bbb6f13bf49b Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 00:28:49 +0700 Subject: [PATCH 16/22] Type (#432): the language test keeps its frames in English The drawing language is process-wide, so a Japanese frame translated the tests running beside it (Appearance, Attributes, menus). The test now checks that each frame hands the engine its language without leaving English. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/i18n/tests.rs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs index f594026e..06c976b3 100644 --- a/crates/ui-egui/src/i18n/tests.rs +++ b/crates/ui-egui/src/i18n/tests.rs @@ -172,7 +172,8 @@ fn partial_catalogs_only_translate_strings_the_ui_shows() { } /// The engine learns the language the UI is drawn in each frame: new type takes the Japanese -/// defaults while it is Japanese (#432). +/// defaults while it is Japanese (#432). The frames stay in English: the drawing language is +/// process-wide, and a Japanese frame would translate the tests running beside this one. #[test] fn the_engine_follows_the_interface_language() { let mut app = crate::VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default()); @@ -183,10 +184,14 @@ fn the_engine_follows_the_interface_language() { frame(&mut app); assert_eq!(app.session.ui_language.as_deref(), Some("en"), "tests resolve `auto` to English"); assert!(!app.session.japanese_interface()); - app.session.prefs.interface_language = "ja".into(); - frame(&mut app); - assert_eq!(app.session.ui_language.as_deref(), Some("ja")); + // Each frame hands the engine the language it draws in, whatever the engine had. + app.session.ui_language = Some("ja".into()); assert!(app.session.japanese_interface()); + frame(&mut app); + assert_eq!(app.session.ui_language.as_deref(), Some("en")); + // The language a frame would draw in follows the preference. + app.session.prefs.interface_language = "ja".into(); + assert_eq!(app.ui_language().code(), "ja"); } /// VectorCraft › Language (`app.language`) sets the `interfaceLanguage` preference, which is what From 01c9be7d35313ff827d9c782ab9a85d70d757ff0 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 00:28:50 +0700 Subject: [PATCH 17/22] Part of #511: Italian rows for the Live Corners messages on any path Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/i18n/it.tsv | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv index 707cc338..83d19caf 100644 --- a/crates/ui-egui/src/i18n/it.tsv +++ b/crates/ui-egui/src/i18n/it.tsv @@ -3072,7 +3072,7 @@ axis Both Entrambi @msg Convert to Artboards: selection has no area Converti in tavole da disegno: la selezione non ha area @msg Convert to Shape: no rectangles or ellipses selected Converti in forma: nessun rettangolo o ellisse selezionato @msg Copied the CSS of {rules} object(s) Copiato il CSS di {rules} oggetto/i -@msg Corners edits a live rectangle Angoli modifica un rettangolo dinamico +@msg Corners edits the corners of a path Angoli modifica gli angoli di un tracciato @msg Couldn't copy to the system clipboard: {e} Impossibile copiare negli appunti di sistema: {e} @msg Couldn't open {name}: {e} Impossibile aprire {name}: {e} @msg Couldn't place {name}: the document it was dropped on was closed Impossibile inserire {name}: il documento su cui è stato rilasciato è stato chiuso @@ -3238,7 +3238,7 @@ axis Both Entrambi @msg file version {0} is newer than this VectorCraft supports ({VERSION}) la versione del file {0} è più recente di quelle supportate da questo VectorCraft ({VERSION}) @msg freeform point {i} needs `at` [x, y] and a valid `color` il punto a forma libera {i} richiede `at` [x, y] e un `color` valido @msg give both `start` and `end` [x, y] (or neither) specifica sia `start` sia `end` [x, y] (o nessuno dei due) -@msg give corners 0–3 specifica angoli da 0 a 3 +@msg give corners of the path: anchors between two straight sides specifica angoli del tracciato: punti di ancoraggio tra due lati diritti @msg give the path `id` and the width point `index` specifica l'`id` del tracciato e l'`index` del punto di larghezza @msg guides are locked le guide sono bloccate @msg image '{key}' has no pixels and was left out l'immagine '{key}' non ha pixel ed è stata omessa @@ -3422,7 +3422,7 @@ axis Both Entrambi @msg select artwork (or a colour group) to recolor seleziona la grafica (o un gruppo colori) da ricolorare @msg select at least two objects seleziona almeno due oggetti @msg select objects, not layers seleziona oggetti, non livelli -@msg select one live rectangle, or give its `id` seleziona un rettangolo dinamico o specifica il suo `id` +@msg select one path, or give its `id` seleziona un tracciato o specifica il suo `id` @msg select paths to join seleziona i tracciati da unire @msg select the art to repeat seleziona la grafica da ripetere @msg select the artwork to warp seleziona la grafica da alterare From 8e753d746e5151cfd71e202b72be3287fd2bac85 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 00:51:02 +0700 Subject: [PATCH 18/22] Part of #516: the in-window menus' Select All, Cut, Copy and Paste act on a focused field The clipboard keys already went to a focused text field, but on Windows, Linux and the web the press that opens a menu takes the keyboard from the field, so Edit > Copy (and Cut, Paste, Select > All) acted on the art. The menu bar now keeps the field that had the keyboard, and its selection, while the menus are open; those four commands go to it as the events their keys send, the frame after the click that chose them, and give it the keyboard back. Everything else, and those commands with no field, run as before. The macOS menu bar shares the same helpers. Tests: Copy, Cut and Paste events in the W field and the Color panel's hex field edit the text, never the art; Select > All, Edit > Copy and Edit > Paste clicked in the in-window menus act on the field. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 4 +- crates/ui-egui/src/menus.rs | 74 +++++++++++++++------- crates/ui-egui/src/tests_selectall.rs | 91 +++++++++++++++++++++++++++ 3 files changed, 144 insertions(+), 25 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 5cc39bf4..fce0396d 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-09 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request), the in-window menus' Select All, Cut, Copy and Paste acting on the text field they were opened from (#516); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -113,7 +113,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels, the Control bar and dialogs (preferences too) step with Up/Down, or with the mouse wheel over the focused field (#485: a notch a step; the panel under it then stays put, and an unfocused field leaves the wheel to scrolling) (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once. - Scrubby labels (#400, beyond Illustrator, as in Photoshop): dragging a numeric field's label left or right (the ↔ cursor shows over it) steps the value one unit every 2 points (Shift: ten, Ctrl/Cmd: a tenth; counts stay whole), in the field's unit and within its limits, applied live as the art follows; the whole drag is one undo step and Escape puts the value back. A click on the label focuses the field; the text box itself never scrubs, and a field with no label doesn't. Text labels before a field (Transform, Properties, Control bar, Stroke, Transparency, form rows in dialogs) and the Character and Paragraph panels' icons act as labels. Preferences › General › Scrub Numeric Fields by Dragging (on by default) turns it off. - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields. - - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected). + - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too, and elsewhere the in-window menus' do: the field that had the keyboard when the menu opened gets them, with its selection, and the keyboard back (#516). Not yet: Select All across threaded frames (one frame's text is selected). - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one. - **Tools:** - **Selection:** Selection, Direct/Group Selection, Magic Wand, Lasso. A Shift-drag marquee toggles what it reaches: objects with the Selection tool, anchors with Direct and Group Selection (#483); the Lasso adds with Shift and subtracts with Alt. Dragging a path segment with Direct Selection bends it when it's curved (its anchors stay) and moves its two anchors when it's straight, one undo step; the fill, Shift or Alt still pick the whole path (Alt-drag copies it). diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index eb35c581..c9d6572c 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -2642,9 +2642,24 @@ pub fn context_menu_body(app: &VectorcraftApp, ui: &mut egui::Ui, clicked: &mut /// The in-window menu bar. Returns where its titles end (x): the bar itself takes the full width. pub fn menu_bar(app: &mut VectorcraftApp, ui: &mut egui::Ui) -> f32 { let t = Tokens::get(ui.ctx()); + let ctx = ui.ctx().clone(); + // The press that opens a menu takes the keyboard from a focused text field: the field and its + // selection are kept while the menus are open, so their Select All, Cut, Copy and Paste act on + // its text (#516), the frame after the click that chose them (that click takes the keyboard + // from it again). + type Field = (egui::Id, egui::text_edit::TextEditState); + let (field_key, chosen_key) = (egui::Id::new("menu-bar-field"), egui::Id::new("menu-bar-field-event")); + if let Some(((field, state), e)) = ctx.data(|d| d.get_temp::<(Field, egui::Event)>(chosen_key)) { + ctx.data_mut(|d| d.remove::<(Field, egui::Event)>(chosen_key)); + state.store(&ctx, field); + to_field(&ctx, field, e); + } + if let Some(field) = focused_text_field(&ctx).and_then(|id| Some((id, egui::TextEdit::load_state(&ctx, id)?))) { + ctx.data_mut(|d| d.insert_temp::(field_key, field)); + } let mut clicked: Option<(String, Value)> = None; let tree = menu_tree(); - let end = egui::MenuBar::new() + let (end, open) = egui::MenuBar::new() .ui(ui, |ui| { let mut titles = Vec::with_capacity(tree.len()); for (i, (title, items)) in tree.iter().enumerate() { @@ -2655,12 +2670,21 @@ pub fn menu_bar(app: &mut VectorcraftApp, ui: &mut egui::Ui) -> f32 { }; titles.push(ui.menu_button(text, |ui| menu_body(app, ui, items, &mut clicked)).response); } - switch_on_hover(ui.ctx(), &titles); - ui.cursor().min.x + (ui.cursor().min.x, switch_on_hover(ui.ctx(), &titles)) }) .inner; + let field = ctx.data(|d| d.get_temp::(field_key)); + if !open && focused_text_field(&ctx).is_none() { + ctx.data_mut(|d| d.remove::(field_key)); + } if let Some((id, p)) = clicked { - invoke(app, &id, p); + match field.and_then(|f| Some((f, field_event(app, &id)?))) { + Some(chosen) => { + ctx.data_mut(|d| d.insert_temp(chosen_key, chosen)); + ctx.request_repaint(); + } + None => invoke(app, &id, p), + } } end } @@ -2673,29 +2697,25 @@ fn pointer_reaches_title(ctx: &egui::Context, title: &egui::Response, p: egui::P } /// Like a native menu bar: while one top-level menu is open, moving the pointer onto another -/// title opens that menu instead (egui alone needs a click on each title). -fn switch_on_hover(ctx: &egui::Context, titles: &[egui::Response]) { +/// title opens that menu instead (egui alone needs a click on each title). Returns whether a menu +/// is open. +fn switch_on_hover(ctx: &egui::Context, titles: &[egui::Response]) -> bool { let ids: Vec = titles.iter().map(egui::Popup::default_response_id).collect(); let Some(open) = ids.iter().position(|id| egui::Popup::is_id_open(ctx, *id)) else { - return; + return false; }; // `Response::hovered` is false while a menu's popup is open, so hit-test the titles here. - let Some(p) = ctx.pointer_hover_pos() else { - return; - }; // Only a moving pointer switches: one resting on a title leaves the open menu alone. - if ctx.input(|i| i.pointer.delta() == egui::Vec2::ZERO) { - return; - } - let Some(i) = titles.iter().position(|title| pointer_reaches_title(ctx, title, p)) else { - return; - }; - if i != open + let moving = ctx.input(|i| i.pointer.delta() != egui::Vec2::ZERO); + if let Some(p) = ctx.pointer_hover_pos().filter(|_| moving) + && let Some(i) = titles.iter().position(|title| pointer_reaches_title(ctx, title, p)) + && i != open && let Some(id) = ids.get(i) { egui::Popup::open_id(ctx, *id); ctx.request_repaint(); } + true } /// A top-level menu's popup: as wide as its widest item (label plus shortcut), at least 230 pt; @@ -2840,13 +2860,21 @@ fn field_event(app: &mut VectorcraftApp, id: &str) -> Option { /// Copy and Paste act on the field's text, as their keys do; everything else (and those commands /// with no field focused) goes to [`invoke`]. pub fn invoke_from_system_menu(app: &mut VectorcraftApp, ctx: &egui::Context, id: &str, p: Value) { - if ctx.text_edit_focused() - && let Some(e) = field_event(app, id) - { - ctx.input_mut(|i| i.events.push(e)); - return; + match focused_text_field(ctx).and_then(|f| Some((f, field_event(app, id)?))) { + Some((field, e)) => to_field(ctx, field, e), + None => invoke(app, id, p), } - invoke(app, id, p); +} + +/// The text field that has the keyboard, if any. +fn focused_text_field(ctx: &egui::Context) -> Option { + ctx.memory(|m| m.focused()).filter(|&id| egui::TextEdit::load_state(ctx, id).is_some()) +} + +/// Give text field `field` the keyboard (back) and event `e`, a [`field_event`], this frame. +fn to_field(ctx: &egui::Context, field: egui::Id, e: egui::Event) { + ctx.memory_mut(|m| m.request_focus(field)); + ctx.input_mut(|i| i.events.push(e)); } /// Invoke a menu/command id with UI side effects (dialogs for "…" commands that need input). diff --git a/crates/ui-egui/src/tests_selectall.rs b/crates/ui-egui/src/tests_selectall.rs index 8ddb93cf..51629a2f 100644 --- a/crates/ui-egui/src/tests_selectall.rs +++ b/crates/ui-egui/src/tests_selectall.rs @@ -171,3 +171,94 @@ fn cmd_a_on_the_canvas_selects_all_objects() { a.menu("select.all"); assert_eq!(a.selected(), 2, "so does the menu's Select All"); } + +/// The copied texts of a frame's output. +fn copied(out: &egui::FullOutput) -> Vec { + out.platform_output.commands.iter().filter_map(|c| if let egui::OutputCommand::CopyText(t) = c { Some(t.clone()) } else { None }).collect() +} + +/// #516: Ctrl/Cmd+C, X and V in a focused field (the window's own clipboard keys, which egui sends +/// as Copy, Cut and Paste events) edit the field's text, never the art. +#[test] +fn the_clipboard_keys_in_a_focused_field_edit_its_text() { + let mut a = App::new(); + a.app.run("window.panel", json!({"panel": "color"})).unwrap(); + for _ in 0..3 { + a.frame(vec![]); + } + for text in ["37 pt", "FFFFFF"] { + let (id, rect) = a.field(text); + a.frame(vec![Event::PointerMoved(rect.center()), click(rect.center(), true)]); + a.frame(vec![click(rect.center(), false)]); + a.frame(vec![press(Key::A, Modifiers::COMMAND)]); + assert!(a.ctx.memory(|m| m.has_focus(id)), "{text}: the field has the keyboard"); + let out = a.frame(vec![Event::Copy]); + assert_eq!(copied(&out), [text], "Copy copies the field's text"); + assert!(a.app.session.clipboard.is_empty(), "{text}: no art copied"); + let out = a.frame(vec![Event::Cut]); + assert_eq!(copied(&out), [text], "Cut cuts the field's text"); + a.frame(vec![Event::Paste("12".into())]); + assert_eq!(a.ctx.data(|d| d.get_temp::(id)).as_deref(), Some("12"), "Paste pastes into the field"); + assert_eq!(a.selected(), 1, "{text}: the art stays"); + a.frame(vec![press(Key::Escape, Modifiers::NONE)]); + } +} + +/// The centre of the text `label` painted last (in the topmost layer) in a frame's output; with +/// `title`, the first one painted (the menu bar's). +fn text_at(out: &egui::FullOutput, label: &str, title: bool) -> Pos2 { + let mut shapes: Box> = if title { Box::new(out.shapes.iter()) } else { Box::new(out.shapes.iter().rev()) }; + shapes + .find_map(|s| match &s.shape { + egui::Shape::Text(t) if t.galley.text().trim() == label => Some(Rect::from_min_size(t.pos, t.galley.size()).center()), + _ => None, + }) + .unwrap_or_else(|| panic!("no {label:?} painted")) +} + +/// A click on `at` → the frame after it. +fn click_at(a: &mut App, at: Pos2) -> egui::FullOutput { + a.frame(vec![Event::PointerMoved(at), click(at, true)]); + a.frame(vec![click(at, false)]); + a.frame(vec![]) +} + +/// The in-window menus' Select › All, Edit › Copy and Edit › Paste act on the text field that had the keyboard +/// when the menu was opened (the click on the menu took it), and give it the keyboard back. +#[test] +fn the_in_window_edit_menu_acts_on_the_field_it_was_opened_from() { + let mut a = App::new(); + // Text on the system clipboard. + a.app.services.clipboard_read = Some(Box::new(|| Some("42 pt".into()))); + let (id, rect) = a.field("37 pt"); + a.frame(vec![Event::PointerMoved(rect.center()), click(rect.center(), true)]); + a.frame(vec![click(rect.center(), false)]); + let out = a.frame(vec![press(Key::End, Modifiers::NONE)]); + let (edit, select) = (text_at(&out, "Edit", true), text_at(&out, "Select", true)); + let menu = |a: &mut App, title: Pos2, item: &str| { + let out = click_at(a, title); + assert!(!a.ctx.text_edit_focused(), "the menu took the keyboard"); + click_at(a, text_at(&out, item, false)) + }; + menu(&mut a, select, "All"); + assert!(a.ctx.memory(|m| m.has_focus(id)), "the field has the keyboard back"); + assert_eq!(a.field_selection(id), Some((0, 5)), "Select All selected the field's text"); + assert_eq!(a.selected(), 1, "not the art"); + a.frame(vec![press(Key::End, Modifiers::NONE)]); + a.frame(vec![press(Key::A, Modifiers::COMMAND)]); + a.frame(vec![]); + let out = menu(&mut a, edit, "Copy"); + assert_eq!(copied(&out), ["37 pt"], "Copy copied the field's text"); + assert!(a.app.session.clipboard.is_empty(), "no art copied"); + // Art on the app's clipboard (Paste is enabled): the field still takes the text. + a.app.run("edit.copy", json!({})).unwrap(); + a.frame(vec![press(Key::A, Modifiers::COMMAND)]); + menu(&mut a, edit, "Paste"); + assert_eq!(a.ctx.data(|d| d.get_temp::(id)).as_deref(), Some("42 pt"), "Paste pasted into the field"); + assert_eq!(a.selected(), 1, "nothing pasted on the canvas"); + // With no field focused, the menu's Select All selects the art. + a.frame(vec![press(Key::Escape, Modifiers::NONE)]); + a.frame(vec![]); + menu(&mut a, select, "All"); + assert_eq!(a.selected(), 2); +} From ac043129c83c590ba114b62b7d8391c112123508 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 00:56:49 +0700 Subject: [PATCH 19/22] Fix #545: Windows renders through DX12 before Vulkan Windows lists each GPU under both backends, and Vulkan came first. On an Intel GPU its driver made the whole window flicker black while the pointer moved; the same machine was fine with WGPU_BACKEND=dx12 or gl. adapter_order now ranks a GPU's DX12 adapter before its Vulkan one, after the power preference, so the GPU chosen doesn't change, only how it is driven. Vulkan stays the fallback (a failed DX12 start restarts on it) and WGPU_BACKEND=vulkan still picks it. Elsewhere there is no DX12 adapter, so nothing changes. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 6 +++--- apps/vectorcraft/src/gpu.rs | 37 ++++++++++++++++++++++++++++--------- docs/development.md | 2 +- 3 files changed, 32 insertions(+), 13 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index ddd8e201..e22bb1f0 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request), the rulers' unit menu (#528), Live Corners on stars, polygons and pen paths (#511), the drawing tools snapping to Smart Guides as the Selection tool does, with Construction Guides (#506); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request), the rulers' unit menu (#528), Live Corners on stars, polygons and pen paths (#511), the drawing tools snapping to Smart Guides as the Selection tool does, with Construction Guides (#506), Windows rendering through DX12 before Vulkan (#545); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -42,7 +42,7 @@ since 2026-10-01. | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing | | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine | | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA | -| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) | +| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Windows renders through DX12 before Vulkan (#545: Vulkan flickered black on an Intel GPU, DX12 and OpenGL didn't; verified by unit tests and the reporter's runs with `WGPU_BACKEND`), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) | | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel | | **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) | @@ -159,7 +159,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). `restore` puts dictionaries back as they were at the `save`, so programs that count their saves in a dictionary read to their end (part of #505). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398); on Linux the Paste menu checks the clipboard off the UI thread, so an X11 owner that never answers can't freeze the window (#510); screenshots and other copied pictures paste as embedded images at the view centre everywhere, the web included (#457). - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped. -- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software), and if the window fails on one while starting up it starts again without it instead of crashing; Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Liquify tools' Use Pressure Pen on Windows, while winit 0.30 reports none on macOS or Linux and egui none on the web. On Linux, see `docs/development.md` for pens under Wayland. +- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software, and on Windows a GPU's DX12 adapter before its Vulkan one: Intel's Vulkan driver made the whole window flicker black, #545), and if the window fails on one while starting up it starts again without it instead of crashing; Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Liquify tools' Use Pressure Pen on Windows, while winit 0.30 reports none on macOS or Linux and egui none on the web. On Linux, see `docs/development.md` for pens under Wayland. - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`). ## Milestones and estimates diff --git a/apps/vectorcraft/src/gpu.rs b/apps/vectorcraft/src/gpu.rs index b195d5ec..ba504a34 100644 --- a/apps/vectorcraft/src/gpu.rs +++ b/apps/vectorcraft/src/gpu.rs @@ -4,9 +4,9 @@ //! The canvas is rasterized on the CPU; the GPU only composites it and draws the UI, so any //! adapter that can present to the window will do. [`adapter_order`] ranks the adapters: those that //! can't present to the window's surface never, then the one `WGPU_ADAPTER_NAME` names, hardware -//! before software, the native backends (Vulkan, Metal, DX12) before OpenGL, and the power -//! preference ([`power_preference`]) among the rest. eframe is handed [`selector`], which takes -//! the first of that order. +//! before software, the native backends (Vulkan, Metal, DX12) before OpenGL, the power preference +//! ([`power_preference`]) among the rest, and a GPU's DX12 adapter before its Vulkan one (#545). +//! eframe is handed [`selector`], which takes the first of that order. //! //! An adapter can report that it presents to the window and still fail once it does: on a hybrid //! Linux desktop under Wayland, the compositor runs on one GPU and may refuse the frame buffers @@ -89,15 +89,17 @@ fn key(backend: Backend, vendor: u32, device: u32) -> String { /// The order to try `candidates` in (their indices): only those that present to the window and /// aren't in `skip`; the one whose name contains `named` (any case) first; hardware before -/// software; native backends before OpenGL; then by `power`, keeping the system's order among -/// equals (all of it for [`PowerPreference::None`]). +/// software; native backends before OpenGL; then by `power`; then DX12 before Vulkan, keeping the +/// system's order among equals (all of it for [`PowerPreference::None`]). Windows lists each GPU +/// under both, and Intel's Vulkan driver made the whole window flicker black where DX12 and OpenGL +/// didn't (#545); elsewhere there is no DX12 adapter, so the order is unchanged. pub fn adapter_order(candidates: &[Candidate], power: PowerPreference, named: Option<&str>, skip: &[String]) -> Vec { let named = named.map(str::to_lowercase).filter(|n| !n.is_empty()); let mut order: Vec<(usize, &Candidate)> = candidates.iter().enumerate().filter(|(_, c)| c.presents && !skip.contains(&c.key)).collect(); // Stable, so equals keep the system's order. order.sort_by_key(|(_, c)| { let unnamed = named.as_ref().is_some_and(|n| !c.name.to_lowercase().contains(n)); - (unnamed, c.device_type == DeviceType::Cpu, c.backend == Backend::Gl, power_rank(c.device_type, power)) + (unnamed, c.device_type == DeviceType::Cpu, c.backend == Backend::Gl, power_rank(c.device_type, power), c.backend == Backend::Vulkan) }); order.into_iter().map(|(i, _)| i).collect() } @@ -361,7 +363,7 @@ mod tests { } /// A Windows machine lists every GPU twice (Vulkan and DX12): power saving still takes the - /// integrated GPU first, as wgpu's own choice did (#306). + /// integrated GPU first, as wgpu's own choice did (#306), each GPU through DX12 first (#545). #[test] fn hybrid_laptop_on_windows_renders_on_the_integrated_gpu_with_power_saving() { let c = vec![ @@ -372,8 +374,25 @@ mod tests { gpu("Microsoft Basic Render Driver", Backend::Dx12, DeviceType::Cpu), ]; let order = adapter_order(&c, PowerPreference::LowPower, None, &[]); - assert_eq!(order, [1, 3, 0, 2, 4]); - assert_eq!(adapter_order(&c, PowerPreference::HighPerformance, None, &[]), [0, 2, 1, 3, 4]); + assert_eq!(order, [3, 1, 2, 0, 4]); + assert_eq!(adapter_order(&c, PowerPreference::HighPerformance, None, &[]), [2, 0, 3, 1, 4]); + } + + /// The machine of #545: one Intel GPU, whose Vulkan driver made the window flicker black. + /// DX12 comes first whatever the preference; Vulkan stays a fallback, and `WGPU_ADAPTER_NAME` + /// or a restart leaving DX12 out still reach it. + #[test] + fn a_windows_gpu_renders_through_dx12_before_vulkan() { + let c = vec![ + gpu("Intel(R) Graphics", Backend::Vulkan, DeviceType::IntegratedGpu), + gpu("Intel(R) Graphics", Backend::Dx12, DeviceType::IntegratedGpu), + gpu("Microsoft Basic Render Driver", Backend::Dx12, DeviceType::Cpu), + gpu("Intel(R) Graphics", Backend::Gl, DeviceType::Other), + ]; + for power in [PowerPreference::LowPower, PowerPreference::HighPerformance, PowerPreference::None] { + assert_eq!(adapter_order(&c, power, None, &[]), [1, 0, 3, 2], "{power:?}"); + } + assert_eq!(adapter_order(&c, PowerPreference::LowPower, None, &[c[1].key.clone()]), [0, 3, 2], "DX12 failed: Vulkan next"); } #[test] diff --git a/docs/development.md b/docs/development.md index ae28520f..54aa028e 100644 --- a/docs/development.md +++ b/docs/development.md @@ -38,7 +38,7 @@ How the web shell (`apps/vectorcraft-web/src/web.rs`) differs from desktop: The canvas is rasterized on the CPU (`vectorcraft-render`, vello_cpu); the GPU (wgpu, through eframe) only composites the canvas texture and draws the UI, so any GPU that can show the window will do. The desktop app picks the window's adapter itself (`apps/vectorcraft/src/gpu.rs`, eframe's `native_adapter_selector`) and logs every adapter it found and the one it uses. -- **Order:** adapters that report they can't present to the window are never tried; then the one `WGPU_ADAPTER_NAME` names; hardware before software (llvmpipe, WARP); the native backends (Vulkan, Metal, DX12) before OpenGL; then the power preference, keeping the system's order among equals. +- **Order:** adapters that report they can't present to the window are never tried; then the one `WGPU_ADAPTER_NAME` names; hardware before software (llvmpipe, WARP); the native backends (Vulkan, Metal, DX12) before OpenGL; then the power preference; then, on Windows, where each GPU is listed under both, a GPU's DX12 adapter before its Vulkan one (Intel's Vulkan driver made the whole window flicker black, #545), keeping the system's order among equals. `WGPU_BACKEND=vulkan` still picks Vulkan. - **Preferences › Performance › Graphics Processor** (`gpuPreference`): `automatic` (the default), `lowPower` (Power Saving, the integrated GPU) or `highPerformance` (the discrete GPU). The adapter is chosen when the window opens, so a change applies after a restart. - **Automatic on Windows and macOS** is power saving: the system shows frames from any GPU, and presenting frames rendered on a discrete GPU through the integrated one made the window flicker on some hybrid laptops (#306). - **Automatic on Linux and the BSDs** keeps the system's order: Mesa's Vulkan device-select layer puts the GPU the desktop runs on first (the integrated one on hybrid laptops; `DRI_PRIME` and `MESA_VK_DEVICE_SELECT` steer it). A Wayland compositor may not accept frames from another GPU: on a desktop whose compositor ran on an NVIDIA GPU, rendering on the Ryzen's integrated GPU made KWin end the window's connection ("importing the supplied dmabufs failed") and 0.5.0 crashed at startup (#502). From f8004250fbdec948bfd97b312c00400cdae2887e Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 01:01:02 +0700 Subject: [PATCH 20/22] =?UTF-8?q?Fix=20#543:=20Object=20=E2=80=BA=20Image?= =?UTF-8?q?=20Trace=20=E2=80=BA=20Make=20traces=20with=20the=20Default=20p?= =?UTF-8?q?reset?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Make… and Make and Expand… opened the generic parameter form, whose preset was a text box holding a preset's name (Black and White Logo, 6 Colors), so the other presets looked missing. As in Illustrator, Make and Make and Expand now trace at once with the Default preset, as the Control bar's Image Trace button does; the button's arrow and the Image Trace panel's Preset list choose among the 12 presets. The catalogs drop the two "…" labels; Czech gets Make and Expand. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 4 ++-- crates/ui-egui/src/i18n/cs.tsv | 3 +-- crates/ui-egui/src/i18n/es.tsv | 2 -- crates/ui-egui/src/i18n/it.tsv | 2 -- crates/ui-egui/src/i18n/ja.tsv | 2 -- crates/ui-egui/src/i18n/pt-br.tsv | 2 -- crates/ui-egui/src/i18n/zh-hans.tsv | 2 -- crates/ui-egui/src/i18n/zh-hant.tsv | 2 -- crates/ui-egui/src/menus.rs | 20 ++++++++++++++++++-- 9 files changed, 21 insertions(+), 18 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index ddd8e201..ea102dcc 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands. -_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request), the rulers' unit menu (#528), Live Corners on stars, polygons and pen paths (#511), the drawing tools snapping to Smart Guides as the Selection tool does, with Construction Guides (#506); see [Honest assessment](#honest-assessment-2026-10-05))._ +_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG window (#493), panels, panel groups and the Tools panel undocking into floating panels that move, stack and dock again (#495), the 0.5.0 startup crash on dual-GPU Linux desktops under Wayland fixed: the desktop's own GPU by default and a restart on the next GPU when one can't show the window (#502), path editing while drawing: Cmd/Ctrl with the Pen borrowing Direct Selection and drawing on afterwards, Pen+Alt reshaping segments, handles of a whole selected path dragging, and handle drags no longer re-gathering snap targets every move (#494), the Control bar's and Properties panel's Convert buttons for a path selected as a whole with Direct Selection, the Pen and the anchor tools (#504), the Pen closing a path dragged out of its first anchor every time, without flicker (#501), the Paste menu checking the system clipboard on a background thread on Linux so an X11 clipboard owner that never answers no longer freezes the window (#510), PDF/`.ai` import keeping a type object's outline stroke on the type, wrapped lines as area type, barcode digits in place and layers in the file's stacking order (#508), the Italian interface (#514), EPS images with several data sources read in turn (#498), `restore` undoing dictionary changes in EPS import (part of #505), the macOS menu bar laid out as a Mac app's (the VectorCraft menu with Settings, Language and Appearance, the system's Hide, Services and Window items; owner's request), Object › Image Trace › Make tracing with the Default preset instead of asking for a preset's name (#543), the rulers' unit menu (#528), Live Corners on stars, polygons and pen paths (#511), the drawing tools snapping to Smart Guides as the Selection tool does, with Construction Guides (#506); see [Honest assessment](#honest-assessment-2026-10-05))._ ## Where we are @@ -140,7 +140,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist - **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. The Selection tool shows the type widget beside selected type's bounding box (hollow on point type, filled on area type); double-clicking it converts between them (Type › Convert To Area Type / Convert To Point Type), keeping the text and its styles in place. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text. Font Size and Leading are combo boxes in the Character and Properties panels (Font Size in the Control bar too, beside the Character link, font family and style): type, step with ↑/↓ or the spinner, scrub the label, or pick a preset (6–72 pt, shown in the type unit; Leading also Auto), each pick one undo step; Kerning and Tracking list -100…200; a size, leading, kerning or tracking the selected text doesn't share shows blank (#458). - **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese, Spanish (neutral international Spanish, for every `es-*` locale) and Italian (every `it-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish and Italian also translate status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech, Spanish and Italian ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline (new type in a Japanese interface starts top to top, with em box centre character alignment, #432); Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines. - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `` and PDF soft masks. -- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets; with an image selected the Control bar and the Properties panel show Image Trace, whose arrow traces with any preset, Mask (`object.maskImage`: a clipping path on the image's outline, selected so its handles crop), Crop Image and Embed or Unembed in place of Fill and Stroke; with an Image Trace object selected, its Preset (choosing another traces again), the Image Trace panel and Expand, plus Release in Properties; the View modes are not done), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror). +- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets; Object › Image Trace › Make and Make and Expand trace at once with the Default preset, #543; with an image selected the Control bar and the Properties panel show Image Trace, whose arrow traces with any preset, Mask (`object.maskImage`: a clipping path on the image's outline, selected so its handles crop), Crop Image and Embed or Unembed in place of Fill and Stroke; with an Image Trace object selected, its Preset (choosing another traces again), the Image Trace panel and Expand, plus Release in Properties; the View modes are not done), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror). - **Paint and appearance (M3):** - **Swatches:** names follow the colour model and are unique; Swatch Options (process/spot, Global, Gray/RGB/HSB/CMYK/Web, live preview); editing a global or spot swatch recolours every linked fill, stroke and text run in one undo step; multi-select and delete with confirmation; New Swatch and New Color Group dialogs (a group from the selected artwork's colours); swatches in colour groups convert, separate and count like any other. The Swatches panel selects ranges and whole groups, has a find field, and drags swatches to reorder, regroup or paint art; Add Used Colors, Select All Unused, Merge, Ungroup and Sort by Kind; a CMYK document keeps applied colours in CMYK. Swatch libraries: nine generated colour libraries and five gradient libraries in a library panel, saved and loaded as `.vcswatches`, `.gpl` or CSS. Tints of global and spot colours ("Name 40%") stay linked and separate as a percentage of their plate. Spot colours can be defined in Lab (Spot Colors options). A built-in [Registration] swatch prints on every plate. - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers (the Properties panel has the Control bar's Fill and Stroke chips, Stroke link and weight spinner, with nothing selected too), panels have Illustrator's Window menu keys (Align Shift+F7, Transform Shift+F8, Pathfinder Cmd+Shift+F9, Layers F7, Character Cmd+T…; every panel can be given one in Edit › Keyboard Shortcuts), and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB greys separate into four-colour greys and a rich black as Illustrator does, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`). diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv index c5004e61..c44ada02 100644 --- a/crates/ui-egui/src/i18n/cs.tsv +++ b/crates/ui-egui/src/i18n/cs.tsv @@ -143,6 +143,7 @@ Make Pixel Perfect Zarovnat na obrazové body Slice Řez Make Vytvořit + Make and Expand Vytvořit a rozložit Release Uvolnit Create from Guides Vytvořit z vodítek Create from Selection Vytvořit z výběru @@ -199,8 +200,6 @@ Merge Sloučit Gap Options… Možnosti mezer… Image Trace Vektorizace obrazu - Make… Vytvořit… - Make and Expand… Vytvořit a rozložit… Text Wrap Obtékání textu Text Wrap Options… Možnosti obtékání textu… Clipping Mask Ořezová maska diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv index 11affb70..07b02a7d 100644 --- a/crates/ui-egui/src/i18n/es.tsv +++ b/crates/ui-egui/src/i18n/es.tsv @@ -1369,7 +1369,6 @@ Make a theme on Create and save it. Crea un tema en Crear y guárdalo. Make all bleed settings the same Usar el mismo valor en todos los sangrados Make and Expand Crear y expandir - Make and Expand… Crear y expandir… Make Clipping Mask Crear máscara de recorte Make Compound Shape Crear forma compuesta Make Envelope Crear envolvente @@ -1382,7 +1381,6 @@ Make with Top Object Crear con objeto superior Make with Warp… Crear con deformación… Make/Release Clipping Mask Crear/soltar máscara de recorte - Make… Crear… Manage Workspaces Administrar espacios de trabajo Manage Workspaces… Administrar espacios de trabajo… Manually Manualmente diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv index 83d19caf..4c7b92c0 100644 --- a/crates/ui-egui/src/i18n/it.tsv +++ b/crates/ui-egui/src/i18n/it.tsv @@ -1369,7 +1369,6 @@ Make a theme on Create and save it. Crea un tema nella scheda Crea e salvalo. Make all bleed settings the same Usa lo stesso valore per tutte le abbondanze Make and Expand Crea ed espandi - Make and Expand… Crea ed espandi… Make Clipping Mask Crea maschera di ritaglio Make Compound Shape Crea forma composta Make Envelope Crea involucro @@ -1382,7 +1381,6 @@ Make with Top Object Crea con oggetto superiore Make with Warp… Crea con alterazione… Make/Release Clipping Mask Crea/rilascia maschera di ritaglio - Make… Crea… Manage Workspaces Gestisci aree di lavoro Manage Workspaces… Gestisci aree di lavoro… Manually Manualmente diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv index 9926f829..0ee0115d 100644 --- a/crates/ui-egui/src/i18n/ja.tsv +++ b/crates/ui-egui/src/i18n/ja.tsv @@ -233,8 +233,6 @@ Image Trace 画像トレース Image Tracing 画像トレースオブジェクト Tracing Presets トレースプリセット - Make… 作成… - Make and Expand… 作成して拡張… Text Wrap テキストの回り込み Text Wrap Options… テキストの回り込みオプション… Clipping Mask クリッピングマスク diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv index c3d4779e..70680a78 100644 --- a/crates/ui-egui/src/i18n/pt-br.tsv +++ b/crates/ui-egui/src/i18n/pt-br.tsv @@ -1242,13 +1242,11 @@ Make a theme on Create and save it. Crie um tema em Criar e salve-o. Make all bleed settings the same Tornar todas as configurações de sangria iguais Make and Expand Criar e Expandir - Make and Expand… Criar e Expandir… Make the bleed values differ Fazer os valores de sangria diferirem Make with Mesh… Criar com Malha… Make with Top Object Criar com Objeto Superior Make with Warp… Criar com Distorção… Make/Release Clipping Mask Criar/Liberar Máscara de Recorte - Make… Criar… Manage Workspaces Gerenciar Espaços de Trabalho Manage Workspaces… Gerenciar Espaços de Trabalho… Manually Manualmente diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv index 8850423f..6686a58c 100644 --- a/crates/ui-egui/src/i18n/zh-hans.tsv +++ b/crates/ui-egui/src/i18n/zh-hans.tsv @@ -1351,7 +1351,6 @@ Make a theme on Create and save it. 在“创建”中制作主题并存储。 Make all bleed settings the same 使所有出血设置相同 Make and Expand 创建并扩展 - Make and Expand… 制作并展开… Make Clipping Mask 制作剪切蒙版 Make Compound Shape 创建复合形状 Make Envelope 制作封套 @@ -1364,7 +1363,6 @@ Make with Top Object 用顶层对象创建 Make with Warp… 用变形创建… Make/Release Clipping Mask 创建/释放剪切蒙版 - Make… 制作… Manage Workspaces 管理工作区 Manage Workspaces… 管理工作区… Manually 手动 diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv index 77f49c7d..f26ec228 100644 --- a/crates/ui-egui/src/i18n/zh-hant.tsv +++ b/crates/ui-egui/src/i18n/zh-hant.tsv @@ -1387,7 +1387,6 @@ Make a theme on Create and save it. 按一下「建立」即可製作主題並儲存。 Make all bleed settings the same 將所有出血設定設為相同 Make and Expand 製作並展開 - Make and Expand… 製作並展開… Make Clipping Mask 製作剪裁遮色片 Make Compound Shape 製作複合形狀 Make Envelope 製作封套 @@ -1400,7 +1399,6 @@ Make with Top Object 以最上層物件製作 Make with Warp… 以彎曲製作… Make/Release Clipping Mask 製作／釋放剪裁遮色片 - Make… 製作… Manage Workspaces 管理工作區 Manage Workspaces… 管理工作區… Manually 手動 diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index f9f0d1ac..817dc964 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -2157,8 +2157,11 @@ pub fn menu_tree() -> Vec<(&'static str, Vec)> { sub( "Image Trace", vec![ - cp("Make…", "imageTrace.make", json!({"preset": "Black and White Logo"})), - cp("Make and Expand…", "imageTrace.makeAndExpand", json!({"preset": "6 Colors"})), + // Traced at once with the Default preset, as the Control bar's Image Trace + // button does; other presets come from its arrow or the Image Trace panel + // (#543: the "…" form asked for a preset's name in a text box). + cp("Make", "imageTrace.make", json!({"preset": "Default"})), + cp("Make and Expand", "imageTrace.makeAndExpand", json!({"preset": "Default"})), c("Release", "imageTrace.release"), c("Expand", "imageTrace.expand"), ], @@ -3752,6 +3755,19 @@ mod tests { assert_eq!(pretty_shortcut(""), ""); } + /// #543: Object › Image Trace › Make and Make and Expand trace with the Default preset at once, + /// with no form asking for a preset's name. + #[test] + fn image_trace_make_traces_with_the_default_preset() { + let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default()); + app.run("file.new", json!({})).unwrap(); + for cmd in ["imageTrace.make", "imageTrace.makeAndExpand"] { + let e = menu_entries(&app).into_iter().find(|e| e.command.as_deref() == Some(cmd)).unwrap(); + assert_eq!(e.path, ["Object", "Image Trace"]); + assert_eq!(click_target(&e.label, cmd, &e.params), (cmd.to_string(), json!({"preset": "Default"})), "{}", e.label); + } + } + #[test] fn expand_appearance_is_an_object_menu_item_only() { let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default()); From 0e6a47e72d61885eef8bcbdc3e04e0a798845c85 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 01:03:03 +0700 Subject: [PATCH 21/22] Control bar: Italian for the Transform link's tooltip Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/i18n/it.tsv | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv index 83d19caf..017f7645 100644 --- a/crates/ui-egui/src/i18n/it.tsv +++ b/crates/ui-egui/src/i18n/it.tsv @@ -2546,6 +2546,7 @@ Character: Carattere: Character options Opzioni carattere Stroke options Opzioni traccia + Transform options Opzioni di trasformazione Stroke Weight Spessore traccia Stroke: Traccia: Stroke: click for swatches, Shift-click for the color mixer Traccia: fai clic per i campioni, Shift+clic per il miscelatore colori From c3279f1bcf21e24f39f35c9f4047681ed9991073 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Fri, 9 Oct 2026 01:16:08 +0700 Subject: [PATCH 22/22] Release: VectorCraft v0.7.0 For users, since 0.6.0: - Linux: no more startup crash on desktops whose compositor runs on another GPU (#502, #551); the window renders on the desktop's GPU and retries the next one instead of crashing. - Windows: rendering through DirectX 12 first, fixing the black flicker on Intel GPUs (#545). - Italian interface (#514). - macOS: the menus live in the system menu bar. - Panels, panel groups and the Tools panel undock into floating panels (#495). - Live Corners on any path's corners: stars, polygons, pen paths (#511). - Drawing tools snap to Smart Guides as the Selection tool does (#506). - Pen: Cmd/Ctrl edits the path being drawn, Alt reshapes segments, drags out of the first anchor always close (#494, #501); Convert buttons for whole paths (#504). - Right-click a ruler to change the document's units; the Control bar's Transform link opens the Transform panel. - Object > Image Trace > Make traces with the Default preset (#543). - Edit menu Select All, Cut, Copy and Paste act on a focused field (#516). - Japanese UI: new type starts top-to-top with em box centre alignment (#432). - PDF/.ai import keeps type strokes, wrapped lines and layer order (#508); EPS import fixes (#498, #505). - macOS 27: only file URLs are opened (#433); Linux: the Paste menu no longer freezes on an unresponsive clipboard owner (#510). Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 50 +++++++++++++++++++++++++------------------------- Cargo.toml | 2 +- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f7a94e40..e73ad92c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4296,7 +4296,7 @@ dependencies = [ [[package]] name = "vectorcraft" -version = "0.6.0" +version = "0.7.0" dependencies = [ "arboard", "block2 0.6.2", @@ -4320,7 +4320,7 @@ dependencies = [ [[package]] name = "vectorcraft-brush" -version = "0.6.0" +version = "0.7.0" dependencies = [ "kurbo 0.13.1", "serde", @@ -4332,7 +4332,7 @@ dependencies = [ [[package]] name = "vectorcraft-cad" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "kurbo 0.13.1", @@ -4348,7 +4348,7 @@ dependencies = [ [[package]] name = "vectorcraft-cli" -version = "0.6.0" +version = "0.7.0" dependencies = [ "serde_json", "vectorcraft-color", @@ -4364,7 +4364,7 @@ dependencies = [ [[package]] name = "vectorcraft-color" -version = "0.6.0" +version = "0.7.0" dependencies = [ "kurbo 0.13.1", "moxcms", @@ -4376,7 +4376,7 @@ dependencies = [ [[package]] name = "vectorcraft-doc" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "jpeg-encoder", @@ -4393,7 +4393,7 @@ dependencies = [ [[package]] name = "vectorcraft-effects" -version = "0.6.0" +version = "0.7.0" dependencies = [ "kurbo 0.13.1", "serde_json", @@ -4407,7 +4407,7 @@ dependencies = [ [[package]] name = "vectorcraft-engine" -version = "0.6.0" +version = "0.7.0" dependencies = [ "flate2", "image", @@ -4439,7 +4439,7 @@ dependencies = [ [[package]] name = "vectorcraft-eps" -version = "0.6.0" +version = "0.7.0" dependencies = [ "flate2", "image", @@ -4457,7 +4457,7 @@ dependencies = [ [[package]] name = "vectorcraft-format" -version = "0.6.0" +version = "0.7.0" dependencies = [ "flate2", "proptest", @@ -4471,7 +4471,7 @@ dependencies = [ [[package]] name = "vectorcraft-geom" -version = "0.6.0" +version = "0.7.0" dependencies = [ "kurbo 0.13.1", "proptest", @@ -4483,7 +4483,7 @@ dependencies = [ [[package]] name = "vectorcraft-mcp" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "log", @@ -4502,7 +4502,7 @@ dependencies = [ [[package]] name = "vectorcraft-metafile" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "kurbo 0.13.1", @@ -4516,7 +4516,7 @@ dependencies = [ [[package]] name = "vectorcraft-pathops" -version = "0.6.0" +version = "0.7.0" dependencies = [ "kurbo 0.13.1", "linesweeper", @@ -4528,7 +4528,7 @@ dependencies = [ [[package]] name = "vectorcraft-pdf" -version = "0.6.0" +version = "0.7.0" dependencies = [ "aes", "flate2", @@ -4557,7 +4557,7 @@ dependencies = [ [[package]] name = "vectorcraft-plugins" -version = "0.6.0" +version = "0.7.0" dependencies = [ "serde", "serde_json", @@ -4571,7 +4571,7 @@ dependencies = [ [[package]] name = "vectorcraft-render" -version = "0.6.0" +version = "0.7.0" dependencies = [ "flate2", "gif", @@ -4596,7 +4596,7 @@ dependencies = [ [[package]] name = "vectorcraft-svg" -version = "0.6.0" +version = "0.7.0" dependencies = [ "flate2", "image", @@ -4620,7 +4620,7 @@ dependencies = [ [[package]] name = "vectorcraft-testkit" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "kurbo 0.13.1", @@ -4637,7 +4637,7 @@ dependencies = [ [[package]] name = "vectorcraft-text" -version = "0.6.0" +version = "0.7.0" dependencies = [ "harfrust 0.13.3", "kurbo 0.13.1", @@ -4655,7 +4655,7 @@ dependencies = [ [[package]] name = "vectorcraft-tools" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "kurbo 0.13.1", @@ -4670,7 +4670,7 @@ dependencies = [ [[package]] name = "vectorcraft-trace" -version = "0.6.0" +version = "0.7.0" dependencies = [ "image", "kurbo 0.13.1", @@ -4683,7 +4683,7 @@ dependencies = [ [[package]] name = "vectorcraft-ui-egui" -version = "0.6.0" +version = "0.7.0" dependencies = [ "egui", "egui_extras", @@ -4712,7 +4712,7 @@ dependencies = [ [[package]] name = "vectorcraft-web" -version = "0.6.0" +version = "0.7.0" dependencies = [ "eframe", "egui", @@ -5815,7 +5815,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee" [[package]] name = "xtask" -version = "0.6.0" +version = "0.7.0" dependencies = [ "serde_json", ] diff --git a/Cargo.toml b/Cargo.toml index 687ce5db..5912e9d9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"] default-members = ["crates/*", "apps/vectorcraft", "apps/vectorcraft-cli", "xtask"] [workspace.package] -version = "0.6.0" +version = "0.7.0" edition = "2024" license = "MIT OR Apache-2.0" rust-version = "1.95"