From b4876c27ec1cba957cf2f5a9be5dea886af6f6a0 Mon Sep 17 00:00:00 2001 From: yoriswind Date: Mon, 16 Nov 2026 20:14:25 -0800 Subject: [PATCH 1/2] #8284: restore Brush Options canvas color sampling --- crates/ui-egui/src/app/commands.rs | 1 + crates/ui-egui/src/canvas/input.rs | 4 + crates/ui-egui/src/dialogs.rs | 7 +- .../ui-egui/src/dialogs/brush_art_options.rs | 137 +++++- crates/ui-egui/src/dialogs/modal.rs | 40 +- crates/ui-egui/src/state.rs | 11 + .../tests/brush_keycolor_modal_repro.rs | 395 ++++++++++++++++++ docs/roadmap.md | 5 +- docs/target-app-parity.md | 6 +- docs/ui-parity.md | 4 +- 10 files changed, 593 insertions(+), 17 deletions(-) create mode 100644 crates/ui-egui/tests/brush_keycolor_modal_repro.rs diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index 8cf742e499..ab4a4292a7 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -418,6 +418,7 @@ impl VectorcraftApp { /// and the tool remembered for the toolbar group and for the Touch workspace's drawing mode /// stays as it was. pub(crate) fn try_select_tool(&mut self, id: &str) -> Result<(), String> { + crate::dialogs::cancel_brush_key_color(self, false); // The tip of a pen whose eraser end selected the Eraser doesn't undo this choice, and // neither does letting go of a held tool shortcut. self.pen_end.forget_tool(); diff --git a/crates/ui-egui/src/canvas/input.rs b/crates/ui-egui/src/canvas/input.rs index d811ad3bac..20f48d865b 100644 --- a/crates/ui-egui/src/canvas/input.rs +++ b/crates/ui-egui/src/canvas/input.rs @@ -13,8 +13,12 @@ use super::{Color32, Drag, Mods, Point, PointerEvent, PointerKind, Pos2, Shape, /// Dispatch canvas pointer, keyboard and drop events through the active document view. pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) { // A modal dialog takes the canvas's presses, finger taps, long touches and view navigation, from the frame it opens. + let cancelled = crate::dialogs::refresh_brush_key_color(app); let modal = crate::panel_docking::modal_open(app, ui.ctx()); let (pointer, m, space, hover) = wheel_view(app, ui, resp, rect, modal); + if (cancelled && pointer.primary_pressed()) || crate::dialogs::brush_key_color_input(app, ui, resp, rect) { + return; + } let v = *app.view().unwrap_or(&View::default()); let xf = Xf::at(rect, &v, app.canvas_ui_zoom); // A lifted pen or finger takes the pointer away in the frame it lifts (egui's `PointerGone`), diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index dc8c6f09a8..5058aba18d 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -17,6 +17,7 @@ pub mod action_stop; pub mod artboard_options; pub mod blend_options; mod brush_art_options; +pub(crate) use brush_art_options::{brush_key_color_canvas, brush_key_color_input, cancel_brush_key_color, refresh_brush_key_color}; pub mod brush_delete; pub mod brush_options; pub mod brush_replace_art; @@ -681,6 +682,7 @@ pub(crate) fn field_set(app: &mut VectorcraftApp, field: &str, old: Option<&Valu /// Close the open dialog as Cancel does, rolling back a live preview and showing the dialog it was /// opened over (`ui.dialog.cancel`). pub fn cancel(app: &mut VectorcraftApp) { + cancel_brush_key_color(app, true); missing_fonts::requeue_replaced(app); // More Settings' pop-up and Save Preset end on their own; New Document stays. if app.ui.dialog.as_mut().is_some_and(new_document::close_popup) { @@ -741,6 +743,7 @@ pub(crate) fn reset(app: &mut VectorcraftApp) -> DialogResult { /// Apply the open dialog (OK). pub fn confirm(app: &mut VectorcraftApp) -> DialogResult { + cancel_brush_key_color(app, true); missing_fonts::requeue_replaced(app); let Some(d) = app.ui.dialog.clone() else { return Err("no dialog open".into()) }; // A file dialog it shows off the UI thread confirms the dialog as it is again. @@ -780,6 +783,7 @@ pub(crate) fn opened_by_panel(app: &mut VectorcraftApp) { /// Draws the active dialog and handles shared initial focus, keyboard shortcuts and actions. /// Inline actions and footer buttons use the same confirmation and preview rollback paths. pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) { + refresh_brush_key_color(app); crate::shortcuts::hold_back_keys(app, ctx); about::show(app, ctx); settle(app); @@ -837,7 +841,8 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) { let initial = if revolves { egui::vec2((ctx.content_rect().width() / 2.0 - 226.0).max(0.0), -40.0) } else { egui::vec2(0.0, -40.0) }; let id = egui::Id::unique(("dialog", d.kind.as_str())); let id = if revolves { id.with("revolve") } else { id }; - modal::show_at(ctx, &heading, id, initial, MARGIN, |ui| { + let canvas_pick = brush_key_color_canvas(app, ctx); + modal::show_at(ctx, &heading, id, initial, MARGIN, canvas_pick, |ui| { // Never wider than the window (a large UI scale in a small window): the text wraps. let room = (ctx.content_rect().width() - 2.0 * (f32::from(MARGIN) + EDGE_GAP)).max(EDGE_GAP); ui.set_min_width(spec.min_width.min(room)); diff --git a/crates/ui-egui/src/dialogs/brush_art_options.rs b/crates/ui-egui/src/dialogs/brush_art_options.rs index 8bc0e66a2e..8519ab60c9 100644 --- a/crates/ui-egui/src/dialogs/brush_art_options.rs +++ b/crates/ui-egui/src/dialogs/brush_art_options.rs @@ -719,12 +719,130 @@ fn tile_doc(art: &Node, w: f64, h: f64) -> Option { Some(doc) } +/// The private dialog marker survives with its draft, never in the brush definition. +const KEY_COLOR_DOC: &str = "__keyColorDoc"; + +fn key_color_owner_valid(app: &VectorcraftApp) -> bool { + let Some(pick) = app.ui.brush_key_color_pick.as_ref() else { return false }; + app.session.active().is_some_and(|doc| doc.uid == pick.doc) + && app.ui.dialog.as_ref().is_some_and(|dialog| { + dialog.kind == super::brush_options::KIND + && dialog.str("colorization") == "hueShift" + && dialog.fields.get(KEY_COLOR_DOC).and_then(Value::as_u64) == Some(pick.doc) + }) +} + +fn key_color_pick_active(app: &VectorcraftApp) -> bool { + key_color_owner_valid(app) && app.session.tool_id() == "eyedropper" && app.session.tool_options()["brushKeyColor"] == true +} + +/// Only the owned Brush Options pick opens an input aperture; other modal owners still block it. +pub(crate) fn brush_key_color_canvas(app: &VectorcraftApp, ctx: &egui::Context) -> Option { + (key_color_pick_active(app) + && !app.ui.about + && !app.ui.palette_open + && !app.file_dialog_open() + && !crate::updates_ui::blocks_input(app) + && !egui::Popup::is_any_open(ctx)) + .then_some(app.canvas_rect) + .flatten() +} + +/// Clear only the transient mode owned by this dialog, including a parked eyedropper. +pub(crate) fn cancel_brush_key_color(app: &mut VectorcraftApp, restore: bool) { + let Some(pick) = app.ui.brush_key_color_pick.take() else { return }; + let options = Map::from_iter([("brushKeyColor".into(), json!(false)), ("stop".into(), Value::Null)]); + app.session.set_tool_options(Some("eyedropper"), &options); + if restore && app.session.tool_id() == "eyedropper" { + app.return_to_tool(&pick.back); + } +} + +/// Refresh before real canvas input and dialog layout, so a stale press cannot reach another tool. +pub(crate) fn refresh_brush_key_color(app: &mut VectorcraftApp) -> bool { + if app.ui.brush_key_color_pick.is_none() || key_color_pick_active(app) { + return false; + } + let restore = !key_color_owner_valid(app) && app.session.tool_id() == "eyedropper"; + cancel_brush_key_color(app, restore); + true +} + +/// A foreground color click owns its physical Down/Up; the restored tool receives neither. +pub(crate) fn brush_key_color_input(app: &mut VectorcraftApp, ui: &egui::Ui, response: &egui::Response, rect: egui::Rect) -> bool { + if app.ui.brush_key_color_pick.is_none() { + return false; + } + let (pointer, focused, lost) = ui.input(|input| { + let up = input + .events + .iter() + .position(|event| matches!(event, egui::Event::PointerButton { button: egui::PointerButton::Primary, pressed: false, .. })); + let gone = input.events.iter().position(|event| matches!(event, egui::Event::PointerGone)); + let lost = gone.is_some_and(|gone| up.is_none_or(|up| gone < up)) + || input.events.iter().any(|event| matches!(event, egui::Event::Touch { phase: egui::TouchPhase::Cancel, .. })) + || input.multi_touch().is_some() + || response.long_touched(); + (input.pointer.clone(), input.focused, lost) + }); + let pending = app.ui.brush_key_color_pick.as_ref().is_some_and(|pick| pick.press.is_some()); + if pending && (!focused || lost || (!pointer.primary_down() && !pointer.primary_released())) { + cancel_brush_key_color(app, true); + return true; + } + if brush_key_color_canvas(app, ui.ctx()).is_none() { + if let Some(pick) = app.ui.brush_key_color_pick.as_mut() { + pick.press = None; + } + return false; + } + if !focused { + return true; + } + if pointer.primary_pressed() + && response.hovered() + && let Some(point) = pointer.interact_pos().filter(|point| rect.contains(*point) && ui.clip_rect().contains(*point)) + { + let xf = crate::canvas::Xf::at(rect, app.view().unwrap_or(&crate::View::default()), app.canvas_ui_zoom); + if let Some(pick) = app.ui.brush_key_color_pick.as_mut() { + pick.press = Some(xf.to_doc(point)); + } + } + if pointer.button_released(egui::PointerButton::Primary) + && let Some(point) = app.ui.brush_key_color_pick.as_mut().and_then(|pick| pick.press.take()) + { + // The existing tool returns a deferred SwitchTool request. Release Eye before applying + // that request, so a held color click cannot start or finish a stroke in the prior tool. + let view = app.view_info(); + let down = vectorcraft_tools::PointerEvent::new(vectorcraft_tools::PointerKind::Down, point.x, point.y); + let up = vectorcraft_tools::PointerEvent::new(vectorcraft_tools::PointerKind::Up, point.x, point.y); + let sampled = app.session.pointer(&down, view); + let released = app.session.pointer(&up, view); + crate::canvas::apply_requests(app, sampled); + crate::canvas::apply_requests(app, released); + } + true +} + /// Key Color eyedropper: sample the next click on the art into this dialog's `keyColor`. -fn key_color_eyedropper(app: &mut VectorcraftApp) { - let back = app.session.tool_id(); - app.select_tool("eyedropper"); +fn key_color_eyedropper(app: &mut VectorcraftApp, dialog: &mut Dialog) { + if app.ui.brush_key_color_pick.is_some() { + cancel_brush_key_color(app, true); + return; + } + let Some(doc) = app.session.active().map(|doc| doc.uid) else { return }; + if dialog.fields.get(KEY_COLOR_DOC).and_then(Value::as_u64).is_some_and(|owner| owner != doc) { + return; + } + let back = app.session.tool_id().to_string(); + if let Err(error) = app.try_select_tool("eyedropper") { + app.status(error); + return; + } app.session.set_tool_option("brushKeyColor", &json!(true)); app.session.set_tool_option("stop", &json!(back)); + dialog.fields.insert(KEY_COLOR_DOC.into(), json!(doc)); + app.ui.brush_key_color_pick = Some(crate::state::BrushKeyColorPick { doc, back, press: None }); } fn colorization_body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) { @@ -762,7 +880,7 @@ fn colorization_body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog } } if widgets::icon_button(ui, "pipette", tl!("Eyedropper: click the art to sample the key color"), false, 22.0).clicked() { - key_color_eyedropper(app); + key_color_eyedropper(app, d); } }); }); @@ -770,6 +888,17 @@ fn colorization_body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog /// Apply a sampled colour to the open Brush Options dialog (`brushKeyColor` tool request). pub(super) fn apply_key_color_sample(app: &mut VectorcraftApp, color: &Value) { + let marked = app.ui.dialog.as_ref().is_some_and(|dialog| dialog.fields.contains_key(KEY_COLOR_DOC)); + if app.ui.brush_key_color_pick.is_some() { + if !key_color_owner_valid(app) { + cancel_brush_key_color(app, false); + return; + } + cancel_brush_key_color(app, false); + } else if marked { + // A reply cannot change the draft after its owned pick was cancelled or replaced. + return; + } let Some(d) = app.ui.dialog.as_mut().filter(|d| d.kind == super::brush_options::KIND) else { return }; if d.str("colorization") != "hueShift" { return; diff --git a/crates/ui-egui/src/dialogs/modal.rs b/crates/ui-egui/src/dialogs/modal.rs index f72383068e..8e151ccf6d 100644 --- a/crates/ui-egui/src/dialogs/modal.rs +++ b/crates/ui-egui/src/dialogs/modal.rs @@ -13,18 +13,44 @@ use crate::theme::{self, Tokens}; /// screen's centre until it is moved, with `margin` inside its frame. `add` draws the contents and /// should start with [`heading`] (or [`drag_band`]) so the window can be moved. pub(crate) fn show(ctx: &egui::Context, title: &str, id: Id, nudge: f32, margin: i8, add: impl FnOnce(&mut egui::Ui) -> R) -> Option { - show_at(ctx, title, id, egui::vec2(0.0, nudge), margin, add) + show_at(ctx, title, id, egui::vec2(0.0, nudge), margin, None, add) } /// A modal that starts at a chosen offset, then keeps the user's dragged position. -pub(crate) fn show_at(ctx: &egui::Context, title: &str, id: Id, initial: Vec2, margin: i8, add: impl FnOnce(&mut egui::Ui) -> R) -> Option { +pub(crate) fn show_at( + ctx: &egui::Context, + title: &str, + id: Id, + initial: Vec2, + margin: i8, + canvas_pick: Option, + add: impl FnOnce(&mut egui::Ui) -> R, +) -> Option { let t = Tokens::get(ctx); let dim = backdrop(); - egui::Area::new(dim.id).order(dim.order).fixed_pos(egui::Pos2::ZERO).show(ctx, |ui| { - // Modal, but the canvas isn't dimmed so previews stay readable (as in the reference app). - // Not focusable (`Sense::click()` is): Tab goes through the dialog's controls, not the backdrop. - ui.allocate_rect(ctx.content_rect(), egui::Sense::CLICK); - }); + if let Some(canvas) = canvas_pick { + let screen = ctx.content_rect(); + let canvas = canvas.intersect(screen); + // Separate areas keep their hit rectangles outside the canvas. One area around a hole + // would still cover the canvas with its enclosing rectangle. + let regions = [ + Rect::from_min_max(screen.min, egui::pos2(screen.right(), canvas.top())), + Rect::from_min_max(egui::pos2(screen.left(), canvas.top()), egui::pos2(canvas.left(), canvas.bottom())), + Rect::from_min_max(egui::pos2(canvas.right(), canvas.top()), egui::pos2(screen.right(), canvas.bottom())), + Rect::from_min_max(egui::pos2(screen.left(), canvas.bottom()), screen.max), + ]; + for (index, region) in regions.into_iter().enumerate().filter(|(_, region)| region.width() > 0.0 && region.height() > 0.0) { + egui::Area::new(dim.id.with(index)).order(dim.order).fixed_pos(region.min).show(ctx, |ui| { + ui.allocate_rect(region, egui::Sense::CLICK); + }); + } + } else { + egui::Area::new(dim.id).order(dim.order).fixed_pos(egui::Pos2::ZERO).show(ctx, |ui| { + // Modal, but the canvas isn't dimmed so previews stay readable (as in the reference app). + // Not focusable (`Sense::click()` is): Tab goes through the dialog's controls, not the backdrop. + ui.allocate_rect(ctx.content_rect(), egui::Sense::CLICK); + }); + } let shown = egui::Window::new(title) .id(id) .order(egui::Order::Foreground) diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs index d3698aaeef..19e8393261 100644 --- a/crates/ui-egui/src/state.rs +++ b/crates/ui-egui/src/state.rs @@ -6,6 +6,14 @@ use vectorcraft_geom::Point; use crate::theme::Brightness; +/// A Brush Options Key Color click, owned by its dialog and document until release or cancel. +#[derive(Clone, Debug)] +pub struct BrushKeyColorPick { + pub doc: u64, + pub back: String, + pub press: Option, +} + /// Per-document view (camera). #[derive(Clone, Copy, Debug, Serialize, Deserialize)] pub struct View { @@ -563,6 +571,8 @@ pub struct UiState { pub tab_hid: Option, pub view: ViewFlags, pub dialog: Option, + #[serde(skip)] + pub brush_key_color_pick: Option, /// Messages to show in a dialog once the open one is closed (`dialogs::confirm::tell`), in /// the order they came. #[serde(skip)] @@ -1194,6 +1204,7 @@ impl Default for UiState { tab_hid: None, view: ViewFlags::default(), dialog: None, + brush_key_color_pick: None, told: vec![], answering_control: false, flyout: None, diff --git a/crates/ui-egui/tests/brush_keycolor_modal_repro.rs b/crates/ui-egui/tests/brush_keycolor_modal_repro.rs new file mode 100644 index 0000000000..edcfb02d37 --- /dev/null +++ b/crates/ui-egui/tests/brush_keycolor_modal_repro.rs @@ -0,0 +1,395 @@ +//! Regression coverage for Brush Options Key Color sampling through the real modal canvas route. +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +use egui::{Event, Modifiers, PointerButton, Pos2, RawInput, Rect, vec2}; +use serde_json::json; +use vectorcraft_color::{Color, Paint}; +use vectorcraft_engine::Session; +use vectorcraft_geom::Point; +use vectorcraft_tools::{PointerEvent, PointerKind}; +use vectorcraft_ui_egui::{VectorcraftApp, canvas}; + +const BRUSH: &str = "Original key-color fixture"; +const PICK_KEY: &str = "Eyedropper: click the art to sample the key color"; + +fn frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec) -> egui::FullOutput { + let mut raw = RawInput { events, focused: true, screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1100.0))), ..Default::default() }; + app.raw_input_hook(ctx, &mut raw); + ctx.run_ui(raw, |ui| { + app.tick(ui.ctx()); + app.ui(ui); + }) +} + +fn settle(app: &mut VectorcraftApp, ctx: &egui::Context) { + for _ in 0..4 { + frame(app, ctx, vec![]).textures_delta.clear(); + } +} + +fn click_at(app: &mut VectorcraftApp, ctx: &egui::Context, at: Pos2, modifiers: Modifiers) { + let press = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers }; + frame(app, ctx, vec![Event::ModifiersChanged(modifiers), Event::PointerMoved(at)]).textures_delta.clear(); + frame(app, ctx, vec![press(true)]).textures_delta.clear(); + frame(app, ctx, vec![press(false)]).textures_delta.clear(); + frame(app, ctx, vec![Event::ModifiersChanged(Modifiers::NONE)]).textures_delta.clear(); +} + +fn click_control(app: &mut VectorcraftApp, ctx: &egui::Context, label: &str) { + let mut bounds = None; + for _ in 0..3 { + let mut output = frame(app, ctx, vec![]); + if let Some(update) = &output.platform_output.accesskit_update { + bounds = update.nodes.iter().find(|(_, node)| node.label() == Some(label)).and_then(|(_, node)| node.bounds()); + } + output.textures_delta.clear(); + if bounds.is_some() { + break; + } + } + let bounds = bounds.unwrap_or_else(|| panic!("missing actual Brush Options control: {label}")); + let at = egui::pos2(((bounds.x0 + bounds.x1) * 0.5) as f32, ((bounds.y0 + bounds.y1) * 0.5) as f32); + click_at(app, ctx, at, Modifiers::NONE); + settle(app, ctx); +} + +fn key_color(app: &VectorcraftApp) -> Color { + let dialog = app.ui.dialog.as_ref().expect("Brush Options remains open"); + assert_eq!(dialog.kind, "brushOptions"); + assert_eq!(dialog.fields.get("colorization"), Some(&json!("hueShift"))); + vectorcraft_engine::cmd::color_value(dialog.fields.get("keyColor").expect("Key Color field")).unwrap() +} + +fn open_options(app: &mut VectorcraftApp, ctx: &egui::Context) { + app.run("ui.brushOptions", json!({"name": BRUSH})).unwrap(); + settle(app, ctx); + assert_eq!(key_color(app), Color::BLACK, "the original brush has a black key, distinct from the blue canvas sample"); +} + +#[test] +fn key_color_sampling_reaches_the_canvas_while_brush_options_stays_open() { + vectorcraft_ui_egui::i18n::set_current(vectorcraft_ui_egui::i18n::Lang::EN); + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("paint.setFill", json!({"color": "#000000"})).unwrap(); + let art = app.run("shape.rectangle", json!({"x": 300, "y": 30, "width": 20, "height": 12})).unwrap()["id"].clone(); + app.run( + "brush.new", + json!({"type": "art", "name": BRUSH, "ids": [art], "params": {"colorization": {"method": "hueShift", "key": Color::BLACK}}}), + ) + .unwrap(); + app.run("paint.setFill", json!({"color": "#336699"})).unwrap(); + app.run("shape.rectangle", json!({"x": 20, "y": 120, "width": 80, "height": 60})).unwrap(); + app.run("select.none", json!({})).unwrap(); + app.ui.task_bar = false; + app.ui.view.rulers = false; + app.canvas.worker_started = true; + let ctx = egui::Context::default(); + ctx.enable_accesskit(); + for _ in 0..8 { + frame(&mut app, &ctx, vec![]).textures_delta.clear(); + } + let view = app.view_mut().unwrap(); + view.zoom = 3.0; + view.center = Point::new(200.0, 150.0); + view.rotation = 0.0; + settle(&mut app, &ctx); + let point = Point::new(60.0, 150.0); + let at = canvas::Xf::at(app.canvas_rect.unwrap(), app.view().unwrap(), ctx.zoom_factor()).to_screen(point); + assert!(app.canvas_rect.unwrap().contains(at)); + + // Positive control: this exact coordinate is colored art and the ordinary real UI route hits it. + let control_document = app.session.active().unwrap().doc.clone(); + app.run("paint.setFill", json!({"color": "#e020c0"})).unwrap(); + app.select_tool("eyedropper"); + click_at(&mut app, &ctx, at, Modifiers::SHIFT); + let expected_key = match &app.session.paint.fill { + Paint::Solid { color, .. } => *color, + _ => panic!("ordinary Eye sampled a solid color"), + }; + assert_eq!(expected_key.to_hex(), "#336699", "ordinary real UI Eyedropper hits the sample point"); + assert_eq!(app.session.active().unwrap().doc, control_document); + assert!(app.session.active().unwrap().selection.objects.is_empty()); + app.run("paint.setFill", json!({"color": "#e020c0"})).unwrap(); + app.select_tool("paintbrush"); + let state = app.session.active().unwrap(); + let (document, selection, revision) = (state.doc.clone(), state.selection.clone(), state.revision); + let history = (state.history.undo.len(), state.history.redo.len()); + let paint = app.session.paint.clone(); + let unchanged = |app: &VectorcraftApp| { + let state = app.session.active().unwrap(); + assert_eq!(state.doc, document); + assert_eq!(state.selection, selection); + assert_eq!(state.revision, revision); + assert_eq!((state.history.undo.len(), state.history.redo.len()), history); + assert_eq!(app.session.paint, paint); + }; + + // Separate callback control, not the failure witness: the existing tool-to-dialog route works. + open_options(&mut app, &ctx); + click_control(&mut app, &ctx, PICK_KEY); + assert_eq!(app.session.tool_id(), "eyedropper"); + assert_eq!(app.session.tool_options()["brushKeyColor"], true); + let view = app.view_info(); + canvas::dispatch(&mut app, &PointerEvent::new(PointerKind::Down, point.x, point.y), view); + settle(&mut app, &ctx); + assert_eq!(key_color(&app), expected_key, "the callback can update this hue-shift dialog"); + assert_eq!(app.session.tool_id(), "paintbrush"); + unchanged(&app); + click_control(&mut app, &ctx, "Cancel"); + assert!(app.ui.dialog.is_none()); + unchanged(&app); + + // Reopen from the unchanged brush so the real canvas witness starts with the original black key. + open_options(&mut app, &ctx); + click_control(&mut app, &ctx, PICK_KEY); + assert_eq!(app.session.tool_id(), "eyedropper"); + assert_eq!(app.session.tool_options()["brushKeyColor"], true); + assert_eq!(app.session.tool_options()["stop"], "paintbrush"); + let fields = app.ui.dialog.as_ref().unwrap().fields.clone(); + let modal = ctx.memory(|memory| memory.area_rect(egui::Id::unique(("dialog", "brushOptions")))).expect("the real Brush Options window bounds"); + let now = canvas::Xf::at(app.canvas_rect.unwrap(), app.view().unwrap(), ctx.zoom_factor()).to_screen(point); + assert!(now.distance(at) < 0.1, "the control and witness use the same canvas coordinate"); + assert!(!modal.contains(at), "sample visible art outside the dialog body, not a covered control"); + unchanged(&app); + click_at(&mut app, &ctx, at, Modifiers::NONE); + settle(&mut app, &ctx); + unchanged(&app); + let actual_key = key_color(&app); + assert_eq!(actual_key, expected_key, "the armed Key Color eyedropper must receive the real canvas click through the retained dialog"); + let mut expected_fields = fields; + expected_fields.insert("keyColor".into(), serde_json::to_value(expected_key).unwrap()); + assert_eq!(app.ui.dialog.as_ref().unwrap().fields, expected_fields, "only the dialog Key Color changes"); + assert_eq!(app.session.tool_id(), "paintbrush"); + assert_eq!(app.session.tool_options_of("eyedropper")["brushKeyColor"], false); +} + +// Additional controls are appended; the independently reproduced witness above is unchanged. +fn modal_fixture() -> (VectorcraftApp, egui::Context, Pos2) { + vectorcraft_ui_egui::i18n::set_current(vectorcraft_ui_egui::i18n::Lang::EN); + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("paint.setFill", json!({"color": "#000000"})).unwrap(); + let art = app.run("shape.rectangle", json!({"x": 300, "y": 30, "width": 20, "height": 12})).unwrap()["id"].clone(); + app.run( + "brush.new", + json!({"type": "art", "name": BRUSH, "ids": [art], "params": {"colorization": {"method": "hueShift", "key": Color::BLACK}}}), + ) + .unwrap(); + app.run("paint.setFill", json!({"color": "#336699"})).unwrap(); + app.run("shape.rectangle", json!({"x": 20, "y": 120, "width": 80, "height": 60})).unwrap(); + app.run("select.none", json!({})).unwrap(); + app.ui.task_bar = false; + app.ui.view.rulers = false; + app.canvas.worker_started = true; + let ctx = egui::Context::default(); + ctx.enable_accesskit(); + for _ in 0..8 { + frame(&mut app, &ctx, vec![]).textures_delta.clear(); + } + let view = app.view_mut().unwrap(); + view.zoom = 3.0; + view.center = Point::new(200.0, 150.0); + view.rotation = 0.0; + settle(&mut app, &ctx); + let at = canvas::Xf::at(app.canvas_rect.unwrap(), app.view().unwrap(), ctx.zoom_factor()).to_screen(Point::new(60.0, 150.0)); + app.run("paint.setFill", json!({"color": "#e020c0"})).unwrap(); + app.select_tool("paintbrush"); + open_options(&mut app, &ctx); + let modal = ctx.memory(|memory| memory.area_rect(egui::Id::unique(("dialog", "brushOptions")))).unwrap(); + assert!(app.canvas_rect.unwrap().contains(at) && !modal.contains(at)); + (app, ctx, at) +} + +fn document_defaults(app: &VectorcraftApp) -> (serde_json::Value, vectorcraft_tools::PaintDefaults) { + let state = app.session.active().unwrap(); + ( + json!({"document": state.doc, "selection": state.selection, "revision": state.revision, + "undo": state.history.undo.len(), "redo": state.history.redo.len()}), + app.session.paint.clone(), + ) +} + +fn escape(app: &mut VectorcraftApp, ctx: &egui::Context) { + for pressed in [true, false] { + frame( + app, + ctx, + vec![ + Event::ModifiersChanged(Modifiers::NONE), + Event::Key { key: egui::Key::Escape, physical_key: Some(egui::Key::Escape), pressed, repeat: false, modifiers: Modifiers::NONE }, + ], + ) + .textures_delta + .clear(); + } + settle(app, ctx); +} + +fn sample_press(app: &mut VectorcraftApp, ctx: &egui::Context, at: Pos2, modifiers: Modifiers) { + frame(app, ctx, vec![Event::ModifiersChanged(modifiers), Event::PointerMoved(at)]).textures_delta.clear(); + frame(app, ctx, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers }]).textures_delta.clear(); +} + +#[test] +fn unarmed_brush_and_other_modal_keep_blocking_canvas_input() { + for other_modal in [false, true] { + let (mut app, ctx, at) = modal_fixture(); + if other_modal { + click_control(&mut app, &ctx, "Cancel"); + app.run("ui.newBrush", json!({})).unwrap(); + settle(&mut app, &ctx); + } + app.select_tool("eyedropper"); + let before = document_defaults(&app); + click_at(&mut app, &ctx, at, Modifiers::SHIFT); + settle(&mut app, &ctx); + assert_eq!(document_defaults(&app), before, "an unarmed modal must still block the same canvas point"); + if !other_modal { + assert_eq!(key_color(&app), Color::BLACK); + } + click_control(&mut app, &ctx, "Cancel"); + assert!(app.ui.dialog.is_none()); + click_at(&mut app, &ctx, at, Modifiers::SHIFT); + match &app.session.paint.fill { + Paint::Solid { color, .. } => assert_eq!(color.to_hex(), "#336699", "the same point works after the modal closes"), + _ => panic!("ordinary Eye returns a solid color"), + } + } +} + +#[test] +fn key_color_reentry_escape_cancel_and_tool_choice_restore_only_the_owned_pick() { + let (mut app, ctx, _) = modal_fixture(); + let before = document_defaults(&app); + click_control(&mut app, &ctx, PICK_KEY); + assert_eq!(app.session.tool_options()["stop"], "paintbrush"); + click_control(&mut app, &ctx, PICK_KEY); + assert_eq!(app.session.tool_id(), "paintbrush", "reentry must not capture Eye as its own return tool"); + assert_eq!(key_color(&app), Color::BLACK); + click_control(&mut app, &ctx, PICK_KEY); + escape(&mut app, &ctx); + assert_eq!(app.session.tool_id(), "paintbrush"); + assert_eq!(key_color(&app), Color::BLACK, "the first Escape ends sampling and keeps the draft"); + escape(&mut app, &ctx); + assert!(app.ui.dialog.is_none(), "the second Escape closes Brush Options"); + open_options(&mut app, &ctx); + click_control(&mut app, &ctx, PICK_KEY); + click_control(&mut app, &ctx, "Cancel"); + assert_eq!(app.session.tool_id(), "paintbrush"); + assert!(app.ui.dialog.is_none()); + open_options(&mut app, &ctx); + click_control(&mut app, &ctx, PICK_KEY); + app.select_tool("rectangle"); + settle(&mut app, &ctx); + assert_eq!(app.session.tool_id(), "rectangle", "an explicit choice wins over automatic restoration"); + assert_eq!(key_color(&app), Color::BLACK); + assert_eq!(document_defaults(&app), before); +} + +#[test] +fn key_color_release_samples_once_without_lending_or_sending_up_to_paintbrush() { + let (mut app, ctx, at) = modal_fixture(); + click_control(&mut app, &ctx, PICK_KEY); + let before = document_defaults(&app); + let inputs = app.session.input_count(); + let modifiers = Modifiers { ctrl: true, command: true, ..Modifiers::NONE }; + sample_press(&mut app, &ctx, at, modifiers); + assert_eq!(app.session.tool_id(), "eyedropper", "Cmd/Ctrl must not lend Selection in this foreground pick"); + assert_eq!(app.session.input_count(), inputs, "the physical Down is retained until its release"); + assert_eq!(key_color(&app), Color::BLACK); + frame(&mut app, &ctx, vec![Event::PointerMoved(at + vec2(2.0, 0.0))]).textures_delta.clear(); + assert_eq!(app.session.input_count(), inputs, "holding/moving the pick must not start a stroke"); + frame(&mut app, &ctx, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers }]).textures_delta.clear(); + assert_eq!(app.session.input_count(), inputs + 2, "only the existing Eye Down and Eye Up reach Session"); + assert_eq!(app.session.tool_id(), "paintbrush"); + assert!(!app.session.pointer_held()); + assert!(!app.session.in_interaction()); + assert_eq!(key_color(&app).to_hex(), "#336699"); + assert_eq!(document_defaults(&app), before); +} + +#[test] +fn key_color_lost_press_or_replaced_target_cannot_commit_on_a_later_up() { + for exit in ["focus", "pointerGone", "dialog", "document"] { + let (mut app, ctx, at) = modal_fixture(); + click_control(&mut app, &ctx, PICK_KEY); + sample_press(&mut app, &ctx, at, Modifiers::NONE); + assert_eq!(key_color(&app), Color::BLACK); + match exit { + "focus" => { + let mut raw = + RawInput { focused: false, screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1100.0))), ..Default::default() }; + app.raw_input_hook(&ctx, &mut raw); + ctx.run_ui(raw, |ui| { + app.tick(ui.ctx()); + app.ui(ui); + }) + .textures_delta + .clear(); + } + "pointerGone" => { + frame(&mut app, &ctx, vec![Event::PointerGone]).textures_delta.clear(); + } + "dialog" => { + app.run("ui.brushOptions", json!({"name": BRUSH})).unwrap(); + } + "document" => { + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + } + _ => panic!("unexpected test exit: {exit}"), + } + settle(&mut app, &ctx); + assert_eq!(app.session.tool_id(), "paintbrush", "{exit}: invalidated picks restore the original tool"); + let before = document_defaults(&app); + let fields = app.ui.dialog.as_ref().map(|dialog| dialog.fields.clone()); + frame( + &mut app, + &ctx, + vec![ + Event::PointerMoved(at), + Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }, + ], + ) + .textures_delta + .clear(); + settle(&mut app, &ctx); + assert_eq!(document_defaults(&app), before, "{exit}: an unrelated Up cannot commit a ghost sample or stroke"); + assert_eq!(app.ui.dialog.as_ref().map(|dialog| dialog.fields.clone()), fields, "{exit}: no late callback changes the draft"); + } +} + +#[test] +fn key_color_ok_saves_the_sampled_brush_key_and_reopened_cancel_preserves_it() { + let (mut app, ctx, at) = modal_fixture(); + let before = document_defaults(&app); + let selection = app.session.active().unwrap().selection.clone(); + let undo = app.session.active().unwrap().history.undo.len(); + click_control(&mut app, &ctx, PICK_KEY); + click_at(&mut app, &ctx, at, Modifiers::NONE); + settle(&mut app, &ctx); + assert_eq!(key_color(&app).to_hex(), "#336699"); + assert_eq!(app.session.tool_id(), "paintbrush"); + assert_eq!(document_defaults(&app), before, "sampling changes only the dialog draft before OK"); + + click_control(&mut app, &ctx, "OK"); + assert!(app.ui.dialog.is_none(), "the actual OK button commits and closes Brush Options"); + let state = app.session.active().unwrap(); + assert_eq!(state.selection, selection); + assert_eq!(state.history.undo.len(), undo + 1, "saving the changed brush definition is one Brush Options edit"); + assert!(state.history.redo.is_empty()); + assert_eq!(app.session.paint, before.1, "OK does not change the default paints"); + + // Open from the saved brush, rather than the black-key fixture helper. + app.run("ui.brushOptions", json!({"name": BRUSH})).unwrap(); + settle(&mut app, &ctx); + assert_eq!(key_color(&app).to_hex(), "#336699", "reopening reads the sampled key saved by OK"); + let saved = document_defaults(&app); + click_control(&mut app, &ctx, "Cancel"); + assert!(app.ui.dialog.is_none()); + assert_eq!(document_defaults(&app), saved, "Cancel leaves the stored definition, history and default paints intact"); + app.run("ui.brushOptions", json!({"name": BRUSH})).unwrap(); + settle(&mut app, &ctx); + assert_eq!(key_color(&app).to_hex(), "#336699", "Cancel preserves the stored sampled key"); + assert_eq!(document_defaults(&app), saved); +} diff --git a/docs/roadmap.md b/docs/roadmap.md index e10e3adae2..551c283022 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -1,6 +1,6 @@ # Roadmap: milestones and what's next -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-16 · **Change:** minor (Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: M7: Check Spelling modal dialog (Edit › Spelling › Check Spelling…), #4936; spell check complete; previously: PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, a glyph stroked otherwise than the run it joins coming in as a run of its own, #7741; M10/G5: Neon & Glow built-in graphic style library (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor); previously: Tech Circuit brush library, G5; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: M10/G5: Energy Beams brush library; MCP docs list Energy Beams; previously minor: M10/G5: Skill Icons symbol library; MCP docs list Skill Icons; previously minor: M10/G5: Status Effects graphic style library; MCP docs catch-up for symbol libraries; previously minor: M10/G5: Inventory Icons built-in symbol library; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: M10/G5: Game HUD graphic style library; previously minor: resizable icon-strip flyouts and bottom-aligned panel footers, #5713; previously minor: M10/G5: Map Markers built-in symbol library; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: G2: Effect Gallery thumbnails and in-dialog preview are in; Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: EPS import: embedded fonts (composite, Type 42, CID-keyed, Type 1, CFF FontSet) draw their glyphs; spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; M4/M7: `.ai`/EPS type keeps its tab stops, and right-aligned lines with tabs lay out as the file's page, #6147; M4/M7: `.ai`/EPS type from the text document lays its lines out closer to the file's page, within limits, #6137; numeric fields step on wheel hover without taking keyboard focus, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Selection QoL: marquee modes and visible feedback, #5313; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; Indian-language hyphenation review and license allowlist, #4947; Hindi catalog and contributor loanword preferences; full wording review in progress; Effect dialogs: a colour swatch beside a hex colour opens the Color Picker, #5365; shape tools move the selection from its centre point and turn it from the zone outside a box corner, #5477; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x) +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-17 · **Change:** minor (Brush Options Key Color: restore canvas input for the existing one-shot pick, then resume the retained draft and previous tool (#8284; six full-app input regressions passed); scores and estimates unchanged; previously: Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: M7: Check Spelling modal dialog (Edit › Spelling › Check Spelling…), #4936; spell check complete; previously: PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, a glyph stroked otherwise than the run it joins coming in as a run of its own, #7741; M10/G5: Neon & Glow built-in graphic style library (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor); previously: Tech Circuit brush library, G5; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: M10/G5: Energy Beams brush library; MCP docs list Energy Beams; previously minor: M10/G5: Skill Icons symbol library; MCP docs list Skill Icons; previously minor: M10/G5: Status Effects graphic style library; MCP docs catch-up for symbol libraries; previously minor: M10/G5: Inventory Icons built-in symbol library; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: M10/G5: Game HUD graphic style library; previously minor: resizable icon-strip flyouts and bottom-aligned panel footers, #5713; previously minor: M10/G5: Map Markers built-in symbol library; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: G2: Effect Gallery thumbnails and in-dialog preview are in; Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: EPS import: embedded fonts (composite, Type 42, CID-keyed, Type 1, CFF FontSet) draw their glyphs; spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; M4/M7: `.ai`/EPS type keeps its tab stops, and right-aligned lines with tabs lay out as the file's page, #6147; M4/M7: `.ai`/EPS type from the text document lays its lines out closer to the file's page, within limits, #6137; numeric fields step on wheel hover without taking keyboard focus, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Selection QoL: marquee modes and visible feedback, #5313; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; Indian-language hyphenation review and license allowlist, #4947; Hindi catalog and contributor loanword preferences; full wording review in progress; Effect dialogs: a colour swatch beside a hex colour opens the Color Picker, #5365; shape tools move the selection from its centre point and turn it from the zone outside a box corner, #5477; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x) > > Oversized artboard import update (2026-11-12): Explicit editing-data import retains a single artboard beyond a capped 14,400 pt PDF page (#6865). > @@ -166,7 +166,7 @@ Gujarati interface follow-up (2026-11-14): the catalog and zero/one plural rule | M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | Spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, the custom dictionary and Ignore All commands, Auto Spell Check with its right-click suggestions, Ignore All and Add to Dictionary, Spelling › Auto Spell Check in the context menu of type, the Edit Custom Dictionary dialog, and the modal Check Spelling dialog (Edit › Spelling › Check Spelling…, `Cmd+I`, `ui.checkSpelling`, #4936); Right-aligned area type sets the text after a line's last tab against the right edge, the text before it at its stops (#6147); A line a soft return ends is justified as a wrapped line is (#6137); Indian-language pattern hyphenation preserves syllables in both composers (#4947); 🟡 Hanging punctuation keeps its published amounts under Glyph Scaling, and Standard burasagari counts a hung line start as room; Fullwidth `!` / `?` keep an upright fallback in vertical type; Hyphenation… and Justification… per paragraph (#2310, #2755), Auto Leading also driving the Character panel's Leading, the Alt+↑/↓ leading nudge and Fill with Placeholder Text; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs (feature-valued alternates and unencoded glyphs applied in one Undo step while keeping Arabic joining, #5514), OpenType panel (including font-defined Stylistic Sets), Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, show recently applied families first (#3515), filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; paint-only Arabic harakat keep joining with GDEF-mark ownership and Insert Kashidas tatweels on the base letter's paint (`tests::harakat`); tab leaders, vertical type pending | 45–60 | | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Anchor Point spine conversion/handle editing and selection priority (#2544), with #2425 Shift reshape preserved; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 | | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder, Color Adjustments and Document Raster Effects Settings; PDF export warns when the pixel cap lowers raster-effect resolution; Artistic › Colored Pencil, Cutout, Dry Brush, Film Grain, Fresco, Neon Glow, Paint Daubs, Palette Knife, Poster Edges, Rough Pastels, Smudge Stick, Sponge, Underpainting and Watercolor and Sketch › Halftone Pattern, Bas Relief, Charcoal, Conté Crayon, Photocopy, Stamp, Torn Edges and Water Paper done (57/57 Photoshop filters); Revolve with automatic smooth vector shading, default-on circular caps and continuous rims, Extrude & Bevel, Inflate and Rotate with one to ten colored directional lights and four original lighting presets; SVG Filters, remaining raster effects and 3D materials and shadows pending | 81–130 | -| M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG ``/PDF export) and live Repeat (radial/grid/mirror) done; interactive selected mirror axis implemented (focused and native checks passed; full CI blocked by an unrelated text test); symbol libraries done (Window › Symbol Libraries, six generated libraries (Basic Shapes, UI Frames, Map Markers, Inventory Icons, Skill Icons, Weather Icons), User Defined, Other Library…, Save Symbols); brush libraries done (Window › Brush Libraries, ten generated libraries including Tech Circuit, Ink and Wash, Bristle Brushes and Dry Media, User Defined, Other Library…, Save Brushes); symbol editing shows draggable 9-slice guides (#5280), with guides outside the artwork still unsupported; brushes/symbols in progress | 23–37 | +| M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG ``/PDF export) and live Repeat (radial/grid/mirror) done; interactive selected mirror axis implemented (focused and native checks passed; full CI blocked by an unrelated text test); symbol libraries done (Window › Symbol Libraries, six generated libraries (Basic Shapes, UI Frames, Map Markers, Inventory Icons, Skill Icons, Weather Icons), User Defined, Other Library…, Save Symbols); brush libraries done (Window › Brush Libraries, ten generated libraries including Tech Circuit, Ink and Wash, Bristle Brushes and Dry Media, User Defined, Other Library…, Save Brushes); symbol editing shows draggable 9-slice guides (#5280), with guides outside the artwork still unsupported; Brush Options Key Color resumes its draft after one canvas sample (#8284; six full-app input regressions passed); brushes/symbols in progress | 23–37 | | M11 | Artboards & views (selected-set deletion shared by Artboards menu, trash and Properties, retaining artboard 1 when all are selected; Artboard deletion keys keep the first of an all-selected set and protect artwork; history prunes invalid indices while preserving valid multiselection (history tests and full workspace CI pass); click-to-fit objects with the Artboard tool (#1227), artboard escape routing and document setup modal handoff done; artboard panel/tool with Move Artwork for X/Y fields and Artboard Options, Trim View, middle-button pan, print tiling and the status bar's artboard navigator with synchronized Artboard tool selection done; Window › Arrange › Tile and Consolidate All Windows done; multiple windows, presentation polish) (cached canvas reprojection preserves scale during resize, rotation and DPI changes; regression-tested and contributor-confirmed 2026-10-19; estimates unchanged) (cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission; regression-tested; estimates unchanged); status-bar pointer coordinates follow the active ruler origin and General units | 🟡; Artboard Options shares existing presets and orientation controls and can fit artwork without moving it; artwork fitting includes all drawn document art across artboards and off-board; artwork bounds are cached by active document and revision, and selection uses the shared bounds cache across artboards | 15–25 | | M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (junction-returning pieces retain their positioned boundaries; a simpler contour walk with identical output; an edge's sub-pixel shift is the same from either side; notches read only their own piece; collapsed loops keep few segments; large images trace with a warning; Auto Color keeps rare distinct colours; quick presets trace at once and the Image Trace button opens the adjustment controls; Properties reopens them; tiny fitted contours retain islands and holes; Create Strokes: exact crop EDT, Guo–Hall thinning and maximal-disc graph simplification; 15 presets, the 14 documented ones each with an enhanced version; Ignore Color, Shapes, Auto Grouping and Gradients options; measured in `image-trace-quality.md`; closed outlines retain their interior after straightening; the Flat Logo mode places edges to a fraction of a pixel, restores sharp corners, snaps lines and circles, and refuses gradients; live trace result bounds and selection highlights exclude the retained bitmap except in source-image views), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, group-selected series colours persist through regenerate/save/open) done; Graph Design and Marker designs, Transpose and Switch x/y, `\|` label line breaks, the pie options, drop shadows, the legend across the top, overlapping widths, First Row/Column in Front, filled lines, kept label formatting and the Graph Data worksheet done; graph Column designs pending; Vector Halftone Preview keeps the selection box without drawing dot selection marks (#6369); Live Paint Bucket fills faces crossed in one drag (#6373) | 6–10 | | M13 | Automation (Actions ✅ record/playback, persisted; variables, scripting, batch) | 🟡 MCP `add_text` exposes existing vertical point, area and path type; `script.run` and File › Scripts › Other Script… run JavaScript files, and Window › Script Console shows their output; the script document model and batch work remain | 18–27 | @@ -212,6 +212,7 @@ not take the artwork yet. Overflow-menu drag remains separate. Scores and hours | Date | Change | Summary | |---|---|---| +| 2026-11-17 | minor | Brush Options Key Color (#8284): restore canvas input for its existing eyedropper, then resume the retained draft and previous tool; OK/Cancel and Escape remain separate actions. Six full-app input regressions passed; scores and estimates unchanged. | | 2026-11-16 | minor | Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged. | | 2026-11-16 | minor | Color panel: the spectrum fills the vertical space of a resized panel, with options shown or hidden (#8005). Compact auto-fit flyouts and embedded mixers keep their existing size. Evidence: panels::color::tests::the_spectrum_grows_with_the_color_panel. Scores and estimates unchanged. | | 2026-11-15 | minor | PDF import: stroked type (text rendering modes 1, 2, 5 and 6, and glyphs under `ActualText`) keeps the line cap, line join and miter limit of the graphics state it is stroked with, as paths do, instead of butt caps, miter joins and a miter limit of 10; a glyph filled and then stroked otherwise than the run its fill joined comes in as a run of its own, so the glyphs before it keep their stroke (#7741; `imported_stroked_type_keeps_the_files_cap_join_and_miter_limit` in `crates/pdf/src/tests/textstroke.rs`). Scores and estimates unchanged. | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index a4992647b2..853b894655 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1,6 +1,6 @@ # Parity with Adobe Illustrator -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-16 · **Change:** minor (Properties panel: the Character section shows the font of the Type tool's selection, not the first run's (#8189); scores and estimates unchanged; previously: Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: Paragraph composers (#4935): the Paragraph panel menu and paragraph styles offer four composers, the Middle Eastern & South Asian Single-line and Every-line (how all type is set, and the default) and a Standard Single-line and Every-line that set Indic, Arabic and Hebrew type glyph by glyph as the font maps it, for legacy fonts that keep a script on Latin character codes; PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, a glyph stroked otherwise than the run it joins coming in as a run of its own, #7741; G5: Neon & Glow joins built-in graphic style libraries (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor); scores and estimates unchanged; previously: Pencil ignores Smart Guides and Snap to Point and shows no Smart Guides, #7252; previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; previously: G5: Weather Icons joins built-in symbol libraries (Sun, Moon, Cloud, Rain, Thunder, Snow); scores and estimates unchanged; previously: a closed Pencil stroke closes with a straight segment; previously: Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; previously: 3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scores and estimates unchanged); previously minor: G5: Energy Beams brush library; bundled content ~44% → ~46%; previously minor: G5: Skill Icons symbol library; bundled content ~42% → ~44%; previously minor: `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art (#6570; scores and estimates unchanged); previously minor: ruler double-click adds a guide at the pointer, #5239; G5: Status Effects graphic style library; bundled content ~40% → ~42%; MCP symbol libraries list UI Frames and Map Markers; previously minor: G5: Inventory Icons built-in symbol library; bundled content ~38% → ~40%; previously minor: `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke (#3179; scores and estimates unchanged); previously minor: `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid where VectorCraft's warp doesn't draw as their drawn art (#3179; scores and estimates unchanged); G5: Game Trails brush library; bundled content ~36% → ~38%; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page (#3179; scores and estimates unchanged); G5: Game HUD graphic style library; bundled content ~34% → ~36%; previously minor: Line Arrow arrowhead (#5421; scores and estimates unchanged); G5: Map Markers built-in symbol library; bundled content ~32% → ~34%; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Canvas: a 3D effect changed on type or a group redraws where its solid was; Fit to Artwork Bounds and per-artboard SVG export build each solid once for all artboards; previously minor: Effect Gallery: a thumbnail for each filter and a preview area inside the dialog, on an original drawing; Raster effects 52% → 55%, hours 1–2 → none; headline numbers unchanged; Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; G5: UI Frames built-in symbol library with default 9-slice; bundled content ~32%; previously minor: G5: dynamic symbol part on-canvas opacity/blend/gradient/pattern; strokes remaining no longer lists Overlap/auto corners; symbols ~88%; previously minor: interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; previously minor: harakat paint fallback clarified; previously minor: current Guides feature-area rows consolidated using existing ruler evidence; scores and estimates unchanged; previously minor: Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; previously minor: G5 docs: Art brush Overlap and Pattern brush auto corners removed from strokes remaining; symbols remaining lists dynamic on-canvas beyond solid and guides outside the art; previously minor: custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: EPS import: embedded fonts (composite, Type 42, CID-keyed, Type 1, CFF FontSet) draw their glyphs; spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; `.ai`/EPS type keeps its tab stops, and right-aligned lines with tabs lay out as the file's page, #6147; `.ai`/EPS type from the text document lays its lines out closer to the file's page, within limits, #6137; `.ai` and EPS import: older Art brush objects read; numeric fields step on wheel hover without taking keyboard focus, and a panel wheel turn cannot seed a canvas zoom glide, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Tools stays beside the canvas with left-side panels; new gradients follow document color mode; Selection QoL: marquee modes and visible feedback, #5313; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; the canvas keeps selection outlines and anchors between frames; Indian-language hyphenation review and license allowlist, #4947; Stroke gradients: an arrowhead aligned to the tip is painted to the corners of its base, #5964; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Hindi catalog and contributor loanword preferences; full wording review in progress; Properties in Edit Artboards: a Transform section with the reference point above the Artboards section, #5219; the Control bar's Stroke: and Opacity: links scrub their fields, #4088; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window, #4155; Control bar Paragraph section with type selected, #5372; translating unchanged type reuses its glyph and character-stroke outlines; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026; Units › East Asian Type acts, with Q and Ha units; scores unchanged) +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-17 · **Change:** minor (Brush Options Key Color: restore canvas input for the existing one-shot pick, then resume the retained draft and previous tool (#8284; six full-app input regressions passed); scores and estimates unchanged; previously: Properties panel: the Character section shows the font of the Type tool's selection, not the first run's (#8189); scores and estimates unchanged; previously: Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: Paragraph composers (#4935): the Paragraph panel menu and paragraph styles offer four composers, the Middle Eastern & South Asian Single-line and Every-line (how all type is set, and the default) and a Standard Single-line and Every-line that set Indic, Arabic and Hebrew type glyph by glyph as the font maps it, for legacy fonts that keep a script on Latin character codes; PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, a glyph stroked otherwise than the run it joins coming in as a run of its own, #7741; G5: Neon & Glow joins built-in graphic style libraries (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor); scores and estimates unchanged; previously: Pencil ignores Smart Guides and Snap to Point and shows no Smart Guides, #7252; previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; previously: G5: Weather Icons joins built-in symbol libraries (Sun, Moon, Cloud, Rain, Thunder, Snow); scores and estimates unchanged; previously: a closed Pencil stroke closes with a straight segment; previously: Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; previously: 3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scores and estimates unchanged); previously minor: G5: Energy Beams brush library; bundled content ~44% → ~46%; previously minor: G5: Skill Icons symbol library; bundled content ~42% → ~44%; previously minor: `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art (#6570; scores and estimates unchanged); previously minor: ruler double-click adds a guide at the pointer, #5239; G5: Status Effects graphic style library; bundled content ~40% → ~42%; MCP symbol libraries list UI Frames and Map Markers; previously minor: G5: Inventory Icons built-in symbol library; bundled content ~38% → ~40%; previously minor: `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke (#3179; scores and estimates unchanged); previously minor: `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid where VectorCraft's warp doesn't draw as their drawn art (#3179; scores and estimates unchanged); G5: Game Trails brush library; bundled content ~36% → ~38%; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page (#3179; scores and estimates unchanged); G5: Game HUD graphic style library; bundled content ~34% → ~36%; previously minor: Line Arrow arrowhead (#5421; scores and estimates unchanged); G5: Map Markers built-in symbol library; bundled content ~32% → ~34%; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Canvas: a 3D effect changed on type or a group redraws where its solid was; Fit to Artwork Bounds and per-artboard SVG export build each solid once for all artboards; previously minor: Effect Gallery: a thumbnail for each filter and a preview area inside the dialog, on an original drawing; Raster effects 52% → 55%, hours 1–2 → none; headline numbers unchanged; Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; G5: UI Frames built-in symbol library with default 9-slice; bundled content ~32%; previously minor: G5: dynamic symbol part on-canvas opacity/blend/gradient/pattern; strokes remaining no longer lists Overlap/auto corners; symbols ~88%; previously minor: interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; previously minor: harakat paint fallback clarified; previously minor: current Guides feature-area rows consolidated using existing ruler evidence; scores and estimates unchanged; previously minor: Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; previously minor: G5 docs: Art brush Overlap and Pattern brush auto corners removed from strokes remaining; symbols remaining lists dynamic on-canvas beyond solid and guides outside the art; previously minor: custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: EPS import: embedded fonts (composite, Type 42, CID-keyed, Type 1, CFF FontSet) draw their glyphs; spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; `.ai`/EPS type keeps its tab stops, and right-aligned lines with tabs lay out as the file's page, #6147; `.ai`/EPS type from the text document lays its lines out closer to the file's page, within limits, #6137; `.ai` and EPS import: older Art brush objects read; numeric fields step on wheel hover without taking keyboard focus, and a panel wheel turn cannot seed a canvas zoom glide, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Tools stays beside the canvas with left-side panels; new gradients follow document color mode; Selection QoL: marquee modes and visible feedback, #5313; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; the canvas keeps selection outlines and anchors between frames; Indian-language hyphenation review and license allowlist, #4947; Stroke gradients: an arrowhead aligned to the tip is painted to the corners of its base, #5964; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Hindi catalog and contributor loanword preferences; full wording review in progress; Properties in Edit Artboards: a Transform section with the reference point above the Artboards section, #5219; the Control bar's Stroke: and Opacity: links scrub their fields, #4088; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window, #4155; Control bar Paragraph section with type selected, #5372; translating unchanged type reuses its glyph and character-stroke outlines; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026; Units › East Asian Type acts, with Q and Ha units; scores unchanged) > > Tech Circuit update (2026-11-14): three original procedural brushes; ten built-in brush libraries (G5). > @@ -251,7 +251,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de | Drawing tools (Pen, Curvature, Pencil, shapes, Shaper) | 7 | 85% | Shaper construction widget, Pencil/Pen nuances, Blob Brush options, Touch Type, Dimension tool; see [ui-parity.md](ui-parity.md) | 8–13 | estimated; Curvature point display regression-tested (#1236, in part); Polygon/Star exact-size count persistence regression-covered; Live Corners' Relative rounding done (#3091), score unchanged; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123), score and hours unchanged; the Pen, Smart Pen and Curvature tool show the measurement readout with the rubber band off (#7043), score, gaps and hours unchanged | | Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 80% | Shape Builder on the reporter's file (#937: art past 4,096 segments is cut by lines again; unconfirmed on the file itself); gap detection shares Live Paint’s finder, with a 72 pt custom cap and the existing options; Live Paint Gap Options | 4–8 | estimated; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog (lowered from 86%: open issues); compound attributes regression-tested (#1197); single-result source names survive SVG export/import (#1293), with [SVG ID semantics](https://www.w3.org/TR/SVG2/struct.html#IDAttribute) and original-shape tests; Simplify component selection and preview regression-tested (#1272); Simplify of a Direct Selection part of a path regression-tested (`tests/simplify_part.rs`); Divide open-cutting-path geometry and appearance regression-tested (#1307); the Shape Builder's edge-source grid is bounded in memory and files a segment once per cell (`planar.rs` test `rect_index_holds_a_bounded_number_of_references`); live compound shapes (Make, Alt-click, member Shape Modes, Release, Expand, saved and exported) regression-tested (#4522); Live Paint Bucket face drags, including narrow faces and one Undo, regression-tested (#6373) | | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 92% | Picker Lab entry, picker libraries and Assign-row menus complete the deferred #4028 UI paths (#8031); scores and estimates unchanged; Eyedropper copies effective character dimensions across text transforms (#6404); 30.0's gradient additions are done (dither, perceptual blending, presets); freeform gradients in SVG/PDF, mixed spot/process gradients in SVG, PDF gradients mixing a spot color with RGB or Lab stops, and dithered spot gradient fills and Perceptual spot gradients with RGB or Lab stops other than white or more than 4,096 stops on their curve, which PDF export writes as images in process colors| 4–7 | estimated; Recolor model selection is available through the engine and MCP (#2520), and the dialog's color sliders (HSB, RGB, CMYK, Lab, Tint for a spot color) edit the selected row's new color in its mode, and the Edit tab's Global Adjust sliders (Saturation, Brightness, Temperature, Luminosity, -100% to 100%) change every recolored color at once (lowered from 96%: target moved); unpainted zero-width stroke restoration fixed (#1253), score and hours unchanged; Eyedropper source reads regression-tested (#1251); screen-bounded Recolor Edit chip list (#3416), score and hours unchanged; a point on a gradient mesh's outline locates on its edge on every side (#7006: `mesh_locate_takes_a_point_on_any_side_of_the_outline`, `mesh_add_line_exactly_on_the_edge_needs_no_tolerance`), score and hours unchanged; Color panel spectrum grows with the resized panel (#8005) | -| Strokes, brushes, width profiles | 5 | 88% | Shift-double-click adjoining adjustment is implemented; brush libraries are done (ten generated libraries including Tech Circuit, Ink and Wash, Bristle Brushes, Game Trails, Energy Beams and Dry Media, User Defined, Other Library…, Save Brushes); Art brush Overlap and Pattern brush auto corners are done; remaining: pen pressure on macOS, Stylus Wheel, more built-in brush libraries, tilt, bearing and rotation for Art, Pattern and Bristle brushes and on native Wayland and the web | 8–15 | estimated; width-point creation and adjoining adjustment regression-tested; dialog layout reviewed; evidence below; finite-arithmetic follow-up regressions and full CI passed (evidence below) | +| Strokes, brushes, width profiles | 5 | 88% | Shift-double-click adjoining adjustment is implemented; brush libraries are done (ten generated libraries including Tech Circuit, Ink and Wash, Bristle Brushes, Game Trails, Energy Beams and Dry Media, User Defined, Other Library…, Save Brushes); Art brush Overlap and Pattern brush auto corners are done; remaining: pen pressure on macOS, Stylus Wheel, more built-in brush libraries, tilt, bearing and rotation for Art, Pattern and Bristle brushes and on native Wayland and the web | 8–15 | estimated; width-point creation and adjoining adjustment regression-tested; dialog layout reviewed; evidence below; finite-arithmetic follow-up regressions and full CI passed (evidence below); Brush Options Key Color canvas-pick restoration (#8284): six full-app input regressions passed, score and hours unchanged | | Appearance, transparency, graphic styles, masks | 5 | 97% | raster effect reach in preview bounds | 1–2 | estimated; Transform typing, sliders, preview, and undo are covered in `crates/ui-egui/src/panels/tests_appearance.rs` | | 3D and Materials (and Turntable) | 4 | ~25% | live Revolve with automatic smooth vector shading and default-on continuous circular caps, Extrude & Bevel (twist, taper, caps, five bevel shapes), Inflate and Rotate with Position presets (colored Inflate uses smooth membrane lighting; white-light Inflate retains its existing shading; Extrude & Bevel and Rotate retain planar shading; one to ten colored lights, shared neutral ambient, painter visibility); materials, light presets, shadows, ray tracing, the rest of 3D Classic (Map Art), Turntable views, textures, map art and shading in 3D export | 30–55 | estimated (Extrude & Bevel, Inflate and Rotate added 2026-10-12); every 3D seam has round joins (2026-11-12, [three-d.md](three-d.md#seams)), score, gaps and hours unchanged | | Type core | 9 | 80% | Auto-leading style resets are implemented; Hyphenation… and Justification… options are done (#2310, #2755), and a paragraph's Auto Leading also sets the Character panel's Leading, the Alt+↑/↓ leading nudge and Fill with Placeholder Text; remaining: Optical Margin Alignment, Middle Eastern features beyond bidi layout (the Middle Eastern & South Asian and Standard composers are done per paragraph, #4935; `.ai`/EPS/PDF files carry no composer), optional group font-size preservation; transformed character controls fixed (#1034), see [type-parity.md](type-parity.md) | 14–19 | estimated; eleven-language pattern hyphenation in both composers, with grapheme and shaping-cluster protection (#4947, `hyphen::tests` and `layout::wrapping_tests`); Sanskrit patterns pending an allowlisted source; recent-font groups in font pickers (#3515); full-name font matches regression-tested (#1258); mixed paragraph alignment indication implemented; headless regressions, full integration CI and visual review pass; localized legacy family-name fallback with loaded/catalog regressions (#2208); Fractional Widths per type object regression-tested; color emoji fonts with bitmap glyphs (`sbix`, `CBDT`) draw and export; threading ports: every selected area type and type on a path shows its in and out ports (empty, arrow, red "+"), and the Selection tool threads from either, the in port into a frame before it, and a double-click on a threaded port breaks the thread there (`threads::tests::break_splits_the_thread_and_the_story_flows_into_the_first_part`, `select::tests::a_double_click_on_a_threaded_port_breaks_the_thread`, `canvas::tests::a_double_click_on_a_threaded_out_port_breaks_the_thread`) (#2572; `select::tests::a_click_on_the_in_port_threads_into_a_frame_before_it`, `text::tests::selected_type_shows_its_ports_in_each_state`, `threads::tests::add_before_threads_the_story_from_the_new_frame_into_the_clicked_one`, live screenshot); the Glyphs panel highlights and scrolls to the character selected with the Type tool (#4908, `panels::glyphs` tests); the OpenType panel lists only `ss01`–`ss20` sets present in the selected font and uses its custom names when supplied; Type-range desktop Copy publishes styled art and keeps font family, size and color on canvas Paste after editing (#5636); paint-only Arabic harakat keep joining with conditional GDEF-mark ownership and Insert Kashidas base-letter paint (`tests::harakat`) | @@ -1763,6 +1763,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur - **Freeform gradient colors in their own model:** Object ▸ Expand and Object ▸ Create Gradient Mesh (`object.mesh.create`) mix a freeform gradient's points in the color model they share: points of C50 M20 Y0 K10 give mesh points of C50 M20 Y0 K10, and RGB points keep their values in a working RGB space other than sRGB. The canvas, the gradient chips and the SVG, PDF, EPS and EMF writers mix the points in that model too. PDF and EPS write a gradient whose points are all CMYK, or all Gray in a CMYK file, as a CMYK image, which PDF's Output settings convert as they convert any CMYK image. Points in different models mix in display RGB (on the canvas in a CMYK document that shows transparency, as the inks of each point), and a CMYK document stores the result of Expand as CMYK through the color settings. Points colored along CMYK stops (`paint.editGradient {stops}`, or a CMYK gradient switched to freeform) are CMYK, and so are a point `paint.freeform.splitLine` adds between CMYK points and a point `paint.freeform.addPoint` adds without `color` to CMYK points. Public reference: [Gradients](https://web.archive.org/web/20250714042311/https://helpx.adobe.com/illustrator/using/gradients.html) and [Meshes](https://web.archive.org/web/20250812201019/https://helpx.adobe.com/illustrator/using/meshes.html), which do not state how colors in different models mix; the rule is VectorCraft's own. - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units (its weight presets are round values in that unit: `0.25 mm`, `0.0625 in`, `1 px`, #426; fields show four decimals in mm, cm and inches, three in points), shows mixed values blank and opens from the Control bar. A width profile library, thirty-one more arrowheads (among them Line Arrow: two arms of the head's weight (stroke weight × arrowhead scale, at least 0.25 pt: the line's weight at 100 % for lines of 0.25 pt or more) at right angles, cut square, #5421), and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance. A width profile's sides run as a smooth C1 curve between the width points (a monotone cubic Hermite, Fritsch–Carlson, with the one-sided three-point PCHIP slope at the profile's ends and flat either side of a step), sampled adaptively along the path (two samples per profile segment, refined where the width bends, and leaning on dense path flattening) so straight runs draw it too; added samples offset along the source curve's exact tangent, not the flattened chord, so high zoom follows the true width; the sampled edges are fitted with G1 cubics within a tenth of the flattening tolerance (0.001 pt at the default 0.01 pt) rather than one cubic per flatten step, so exports stay close to a uniform stroke's path data; a point reshapes the curve as far as its neighbours' neighbours (their slopes depend on it), and coincident points still step. - **Brushes (part of #852):** double-clicking a brush in the Brushes panel (or the panel menu's Brush Options…) opens Calligraphic Brush Options (Name; Angle, Roundness and Size, each Fixed, Random, Pressure, Tilt, Bearing or Rotation with its Variation; live previews of the nib and of a light–heavy–light stroke) or Bristle Brush Options (Shape and the bristle sliders); OK edits the brush and every stroke painted with it. The Paintbrush records the pen pressure along each stroke (kept with the path, saved, and joined when a stroke continues a path); a Calligraphic value on Pressure goes from value − variation at the lightest pressure to value + variation at the heaviest, on the canvas and in SVG, PDF and the other exports. Brushes saved before keep their look. Scatter Brush Options (Size, Spacing, Scatter and Rotation, each Fixed, Random between two values, Pressure from the first at the lightest pressure to the second at the heaviest, Tilt, Bearing or Rotation; Rotation relative to Page or Path), Art Brush Options (Width, Scale Proportionately, Stretch to Fit Stroke Length or Stretch Between Guides with the guides' start and end, the four Directions, Flip Along and Across, Overlap) and Pattern Brush Options (Scale, Spacing, the five tiles shown, Flip Along and Across, Stretch to fit, Add space to fit or Approximate path) each have Colorization (None, Tints, Tints and Shades, Hue Shift with its Key Color picked from the art's colours) and a live stroke preview; values from files and commands are clamped to their ranges. Art Brush Options › Overlap places art on each run between sharp corners so folds do not overlap (`ArtBrush.overlap`; `art_brush_overlap_splits_at_corners`). Still to come: Stylus Wheel, pen pressure on macOS where the windowing layer reports none, and tilt, bearing and rotation for Pattern and Bristle brushes and on native Wayland and the web. + Brush Options › Key Color temporarily yields the dialog to one canvas click, then resumes the same options draft and the tool that started the pick (#8284). Sampling changes only the draft: OK applies the brush options and Cancel discards them. Escape ends the pick without sampling; a later Escape still cancels Brush Options. Six full-app input regressions in `crates/ui-egui/tests/brush_keycolor_modal_repro.rs` cover the actual pick, OK/reopen/Cancel, Escape, reentry, held clicks, stale releases and ordinary modal blocking. Scores and estimates unchanged. Under Tints and Tints and Shades, art in black ink alone goes by its ink amount, and a process or gray stroke color's tints and shades stay in that color's model; these are VectorCraft's own rules. Scale Proportionately art is scaled across by the stroke weight and the Width, as Stretch to Fit Stroke Length and Stretch Between Guides art is, on top of the scale the path length gives it, so a 3 pt stroke draws the art three times as wide as a 1 pt stroke. The [Brushes](https://web.archive.org/web/20241230205225/https://helpx.adobe.com/illustrator/using/brushes.html) page says Scale Proportionately keeps the art's proportions and does not say how the stroke weight applies; that rule is VectorCraft's own. Evidence: `tests::art_brush_proportional_grows_with_weight` (vectorcraft-brush). Type in a scatter brush's art takes the brush's colorization as its paths do: Tints, Tints and Shades and Hue Shift recolor the characters' solid fills and strokes in each copy the brush draws, and Brush Options' Key Color list, whose first color is Hue Shift's default key, counts the characters' fills and their strokes wider than 0. The Brushes page says that a scatter, art or pattern brush takes its colors from the current stroke color and the brush's colorization method () and does not mention type there; recoloring the characters' paints like the art's fills and strokes is VectorCraft's own rule. The Symbol Stainer mixes the characters' strokes of type toward the stain as it mixes their fills. Evidence: `tests::scatter_colorization_recolors_type`, `tests::art_colors_list_the_most_used_first`, `tests::stain_mixes_type_strokes_too` (vectorcraft-brush). @@ -2754,6 +2755,7 @@ Edit › Copy and Cut put the selected ruler guides on the clipboard, with the s | Date | Change | Summary | |---|---|---| +| 2026-11-17 | minor | Brush Options Key Color (#8284): restore canvas input for its existing eyedropper, then resume the retained draft and previous tool; OK/Cancel and Escape remain separate actions. Six full-app input regressions passed; scores and estimates unchanged. | | 2026-11-16 | minor | Properties panel: while the Type tool edits text, the Character section shows the font family and style and the Variable Font button of the first selected character (or of the character before the caret), not those of the text object's first run (#8189). Evidence: `panels::properties::tests::character_section_shows_the_type_tool_selections_style`. Scores and estimates unchanged. | | 2026-11-16 | minor | Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged. | | 2026-11-16 | minor | Color panel: the spectrum fills the vertical space of a resized panel, with options shown or hidden (#8005). Compact auto-fit flyouts and embedded mixers keep their existing size. Evidence: panels::color::tests::the_spectrum_grows_with_the_color_panel. Scores and estimates unchanged. | diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 550da7c469..ab4463ad96 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI and interaction parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-16 · **Change:** minor (Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Remove Background in the Contextual Task Bar, Properties › Quick Actions and the Control bar; previously minor: Ruler origin: the corner drag snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Outline view: images and gradient meshes are picked on what Outline draws, so a click inside them reaches the path behind, #6437; previously minor: a middle-click on a document tab closes it, #6506; previously minor: Blob Brush: a round tip's preview is the outline of the area it adds, round at both ends, as the stroke it commits (#4343); scores and estimates unchanged; previously:; ruler double-click adds a guide at the pointer, #5239; G5: Inventory Icons built-in symbol library (four built-ins); previously minor: files that record no units open in Preferences › Units › General, #5820; previously minor: interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; numeric fields step on wheel hover without taking keyboard focus, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Selection QoL: marquee modes and visible feedback, #5313; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Layers: Rename (`ui.rename`) opens the name field of the selected layer, group or object, #5324; Properties in Edit Artboards: Transform section above the Artboards section, #5219; scrubby labels: the Control bar's Stroke: and Opacity: links and the Properties panel's Stroke link scrub their fields, #4088; Properties: Quick Actions has Repeat Options for one selected repeat, #5181; Direct Selection: Shift-click picks several blend spine points, which drag together, #5285; Direct Selection: Cmd/Ctrl held lends the Selection tool and shows its bounding box, #3901; Join tool trims two crossing open paths and joins them at the crossing, #5844; Control bar: Paragraph: link and Align left/center/right while type is selected, #5372; shape tools: a press on the selection's centre point moves it and one in the rotate zone outside a box corner turns it, #5477; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; Units › East Asian Type acts, with Q and Ha units; scores unchanged) +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-17 · **Change:** minor (Brush Options Key Color: restore canvas input for the existing one-shot pick, then resume the retained draft and previous tool (#8284; six full-app input regressions passed); scores and estimates unchanged; previously: Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Remove Background in the Contextual Task Bar, Properties › Quick Actions and the Control bar; previously minor: Ruler origin: the corner drag snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Outline view: images and gradient meshes are picked on what Outline draws, so a click inside them reaches the path behind, #6437; previously minor: a middle-click on a document tab closes it, #6506; previously minor: Blob Brush: a round tip's preview is the outline of the area it adds, round at both ends, as the stroke it commits (#4343); scores and estimates unchanged; previously:; ruler double-click adds a guide at the pointer, #5239; G5: Inventory Icons built-in symbol library (four built-ins); previously minor: files that record no units open in Preferences › Units › General, #5820; previously minor: interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; numeric fields step on wheel hover without taking keyboard focus, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Selection QoL: marquee modes and visible feedback, #5313; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Layers: Rename (`ui.rename`) opens the name field of the selected layer, group or object, #5324; Properties in Edit Artboards: Transform section above the Artboards section, #5219; scrubby labels: the Control bar's Stroke: and Opacity: links and the Properties panel's Stroke link scrub their fields, #4088; Properties: Quick Actions has Repeat Options for one selected repeat, #5181; Direct Selection: Shift-click picks several blend spine points, which drag together, #5285; Direct Selection: Cmd/Ctrl held lends the Selection tool and shows its bounding box, #3901; Join tool trims two crossing open paths and joins them at the crossing, #5844; Control bar: Paragraph: link and Align left/center/right while type is selected, #5372; shape tools: a press on the selection's centre point moves it and one in the rotate zone outside a box corner turns it, #5477; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; Units › East Asian Type acts, with Q and Ha units; scores unchanged) > > Tech Circuit update (2026-11-14): three original procedural brushes; ten built-in brush libraries (G5). > @@ -385,6 +385,7 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po | Interaction | Status | Evidence | |---|---|---| +| Brush Options › Key Color eyedropper yields to one canvas click, then resumes the same draft and previous tool | done | #8284; the pick changes the dialog draft without painting or editing the document. OK applies the brush options; Cancel discards them. Escape ends the pick without sampling before a later Escape cancels the dialog. Six full-app input regressions in `crates/ui-egui/tests/brush_keycolor_modal_repro.rs` cover the actual pick, OK/reopen/Cancel, Escape, reentry, held clicks, stale releases and ordinary modal blocking. | | Ordinary Save refused by filesystem permissions/read-only storage offers Save As | focused UI regressions passed; native acceptance pending | #6146; `io::tests_read_only_save`; same name/format suggested; unchanged format keeps options, changed format opens its Save options; Documents folder, UID-bound continuation; cancellation and automation isolation | | Selection artwork drag hovers a visible document tab to activate it, then drops editable artwork on its canvas | done | `tests_document_drag`, `edit.dropSelection`, lossless resource and one-step Undo regressions; a release over another document's tiled pane copies it there too (`canvas::panes` tests), and so does a release over a floating window drawn inside the main window (`doc_windows` tests); overflow-menu drag and floating OS windows remain separate | | A document tab dragged along the tab strip moves its document; a line marks where it goes, the current document and every document's view stay as they were, and a drag off the strip still floats it | done | #5663, [public source](https://helpx.adobe.com/illustrator/using/customizing-workspace.html); `document.move`; `tests::tab_reorder`, `chrome::tests` (drop index with floating and view tabs), `engine` `tests::document_move` | @@ -561,6 +562,7 @@ before release (#6373). [Paint faces and edges](https://helpx.adobe.com/illustra | Date | Change | Summary | |---|---|---| +| 2026-11-17 | minor | Brush Options Key Color (#8284): restore canvas input for its existing eyedropper, then resume the retained draft and previous tool; OK/Cancel and Escape remain separate actions. Six full-app input regressions passed; scores and estimates unchanged. | | 2026-11-16 | minor | Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged. | | 2026-11-16 | minor | Recolor Artwork › Assign: native Lab entry in the Color Picker, swatch libraries access in the picker, and row context menu options (Pick from Swatches, Limit to Library) (#4028). Scores and estimates unchanged. | | 2026-11-16 | minor | Color panel: the spectrum fills the vertical space of a resized panel, with options shown or hidden (#8005). Compact auto-fit flyouts and embedded mixers keep their existing size. Evidence: panels::color::tests::the_spectrum_grows_with_the_color_panel. Scores and estimates unchanged. | From 6476b041442291c32deb99f8c41d5afb8f4d3ed2 Mon Sep 17 00:00:00 2001 From: yoriswind Date: Tue, 17 Nov 2026 02:34:58 -0800 Subject: [PATCH 2/2] #8284: restore the Key Color initiator after a rejected tool change --- crates/ui-egui/src/app/commands.rs | 8 +- crates/ui-egui/src/dialogs/tests.rs | 118 ++++++++++++++++++++++++++++ 2 files changed, 125 insertions(+), 1 deletion(-) diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index 79ec296fc2..76f793567c 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -424,12 +424,18 @@ impl VectorcraftApp { /// and the tool remembered for the toolbar group and for the Touch workspace's drawing mode /// stays as it was. pub(crate) fn try_select_tool(&mut self, id: &str) -> Result<(), String> { + let back = self.ui.brush_key_color_pick.as_ref().map(|pick| pick.back.clone()); crate::dialogs::cancel_brush_key_color(self, false); // The tip of a pen whose eraser end selected the Eraser doesn't undo this choice, and // neither does letting go of a held tool shortcut. self.pen_end.forget_tool(); self.held_tool.clear(); - self.activate_tool(id, true)?; + if let Err(error) = self.activate_tool(id, true) { + if let Some(back) = back.filter(|_| self.session.tool_id() == "eyedropper") { + self.return_to_tool(&back); + } + return Err(error); + } let now = self.session.tool_id(); if crate::touch::is_drawing_tool(now) { self.ui.touch_drawing_tool = Some(now.to_string()); diff --git a/crates/ui-egui/src/dialogs/tests.rs b/crates/ui-egui/src/dialogs/tests.rs index 08968d5e93..f2199e6700 100644 --- a/crates/ui-egui/src/dialogs/tests.rs +++ b/crates/ui-egui/src/dialogs/tests.rs @@ -3654,3 +3654,121 @@ fn color_halftones_max_radius_stays_in_pixels_whatever_the_units() { assert!(shows, "{typed} shows as {shown}, not in centimetres"); } } + +/// A real Key Color pick returns to its initiating tool when choosing its replacement fails. +#[test] +fn a_failed_tool_choice_restores_the_brush_key_color_initiator() { + use egui::{Event, Modifiers, PointerButton, Pos2, RawInput, Rect, vec2}; + + fn full_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec) -> egui::FullOutput { + let mut raw = + RawInput { events, focused: true, screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1100.0))), ..Default::default() }; + app.raw_input_hook(ctx, &mut raw); + let mut output = ctx.run_ui(raw, |ui| { + app.tick(ui.ctx()); + app.ui(ui); + }); + output.textures_delta.clear(); + output + } + + fn arm(app: &mut VectorcraftApp, ctx: &egui::Context) { + for _ in 0..4 { + let _ = full_frame(app, ctx, vec![]); + } + let mut bounds = None; + for _ in 0..8 { + let output = full_frame(app, ctx, vec![]); + bounds = output.platform_output.accesskit_update.as_ref().and_then(|update| { + update + .nodes + .iter() + .find(|(_, node)| node.label() == Some("Eyedropper: click the art to sample the key color")) + .and_then(|(_, node)| node.bounds()) + }); + if bounds.is_some() { + break; + } + } + let bounds = bounds.expect("the real Brush Options pipette button"); + let at = egui::pos2(((bounds.x0 + bounds.x1) * 0.5) as f32, ((bounds.y0 + bounds.y1) * 0.5) as f32); + let _ = full_frame(app, ctx, vec![Event::ModifiersChanged(Modifiers::NONE), Event::PointerMoved(at)]); + for pressed in [true, false] { + let _ = full_frame(app, ctx, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }]); + } + assert_eq!(app.session.tool_id(), "eyedropper"); + let pick = app.ui.brush_key_color_pick.as_ref().expect("the button owns a live pick"); + assert_eq!(pick.back, "paintbrush"); + assert_eq!(pick.doc, app.session.active().unwrap().uid); + assert!(pick.press.is_none()); + assert_eq!(app.session.tool_options()["brushKeyColor"], true); + assert_eq!(app.session.tool_options()["stop"], "paintbrush"); + } + + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("paint.setFill", json!({"color": "#000000"})).unwrap(); + let art = app.run("shape.rectangle", json!({"x": 300, "y": 30, "width": 20, "height": 12})).unwrap()["id"].clone(); + let brush = "Failed tool choice fixture"; + app.run( + "brush.new", + json!({"type": "art", "name": brush, "ids": [art], + "params": {"colorization": {"method": "hueShift", "key": vectorcraft_color::Color::BLACK}}}), + ) + .unwrap(); + app.run("select.none", json!({})).unwrap(); + app.select_tool("paintbrush"); + app.ui.task_bar = false; + app.ui.view.rulers = false; + app.canvas.worker_started = true; + app.session.prefs.interface_language = "en".into(); + crate::i18n::set_current(crate::i18n::Lang::EN); + let ctx = egui::Context::default(); + ctx.enable_accesskit(); + app.run("ui.brushOptions", json!({"name": brush})).unwrap(); + arm(&mut app, &ctx); + let unchanged = |app: &VectorcraftApp| { + let state = app.session.active().unwrap(); + ( + json!({"uid": state.uid, "doc": state.doc, "selection": state.selection, "revision": state.revision, + "undo": state.history.undo.len(), "redo": state.history.redo.len()}), + app.session.paint.clone(), + ) + }; + let before = unchanged(&app); + let draft = app.ui.dialog.as_ref().unwrap().fields.clone(); + let group_tools = app.ui.group_tool.clone(); + let drawing_tool = app.ui.touch_drawing_tool.clone(); + + // The existing failure hook exercises a valid replacement, not an unknown tool id. + app.fail_next_tool_choice = Some("key-color replacement failed".into()); + assert_eq!(app.try_select_tool("rectangle"), Err(String::from("key-color replacement failed"))); + assert!(app.fail_next_tool_choice.is_none()); + assert!(app.ui.brush_key_color_pick.is_none()); + assert_eq!(app.session.tool_options_of("eyedropper")["brushKeyColor"], false); + assert!(app.session.tool_options_of("eyedropper")["stop"].is_null()); + assert_eq!(app.ui.dialog.as_ref().unwrap().fields, draft); + assert_eq!(app.ui.group_tool, group_tools); + assert_eq!(app.ui.touch_drawing_tool, drawing_tool); + assert_eq!(unchanged(&app), before); + // Before the repair, all cleanup checks above pass, but the session stays on Eyedropper. + assert_eq!(app.session.tool_id(), "paintbrush", "a failed replacement must restore the pick's initiating tool"); + + cancel(&mut app); + assert!(app.ui.dialog.is_none()); + assert_eq!(app.session.tool_id(), "paintbrush", "Cancel cannot return an already consumed pick twice"); + assert_eq!(unchanged(&app), before); + app.run("ui.brushOptions", json!({"name": brush})).unwrap(); + arm(&mut app, &ctx); + app.try_select_tool("rectangle").unwrap(); + assert_eq!(app.session.tool_id(), "rectangle", "a successful replacement stays selected"); + assert!(app.ui.brush_key_color_pick.is_none()); + assert_eq!(app.session.tool_options_of("eyedropper")["brushKeyColor"], false); + assert!(app.session.tool_options_of("eyedropper")["stop"].is_null()); + assert_eq!(app.ui.dialog.as_ref().unwrap().fields, draft); + assert_eq!(unchanged(&app), before); + cancel(&mut app); + assert!(app.ui.dialog.is_none()); + assert_eq!(app.session.tool_id(), "rectangle", "Cancel must preserve the successful replacement"); + assert_eq!(unchanged(&app), before); +}