mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 12:38:18 +00:00
Merge pull request #6713 from yoriswind/codex/6470-scissors-shared-snap
Fix #6470: use shared drawing snaps for Scissors
This commit is contained in:
@@ -0,0 +1,156 @@
|
||||
//! Scissors receives the view's Smart Guides setting and keeps the split endpoint selected.
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
|
||||
use serde_json::json;
|
||||
use vectorcraft_doc::NodeId;
|
||||
use vectorcraft_engine::{Session, ViewInfo};
|
||||
use vectorcraft_geom::{Affine, PathData, Point};
|
||||
use vectorcraft_tools::{Overlay, PointerEvent, PointerKind};
|
||||
|
||||
fn path(session: &Session, id: NodeId) -> PathData {
|
||||
session.doc().unwrap().doc.node(id).unwrap().path_data().unwrap().clone()
|
||||
}
|
||||
|
||||
/// Pixel Preview disables Smart Guides at the Session boundary, rather than asking the tool to
|
||||
/// interpret that view option. A selected rectangle wins the cut over the crossing line above it.
|
||||
#[test]
|
||||
fn scissors_snap_follows_pixel_preview_and_restores_the_cut_selection() {
|
||||
let mut observed = Vec::new();
|
||||
for pixel_preview in [false, true] {
|
||||
let mut session = Session::new();
|
||||
session.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
|
||||
let rectangle =
|
||||
NodeId(session.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap());
|
||||
let crossing = NodeId(session.execute("shape.line", &json!({"x1": 145, "y1": 90, "x2": 165, "y2": 130})).unwrap()["id"].as_u64().unwrap());
|
||||
session.execute("select.set", &json!({"ids": [rectangle.0]})).unwrap();
|
||||
let view = ViewInfo { pixel_preview, ..ViewInfo::default() };
|
||||
session.select_tool("scissors", view).unwrap();
|
||||
let original = path(&session, rectangle);
|
||||
let line = path(&session, crossing);
|
||||
let selection_before = session.doc().unwrap().selection.clone();
|
||||
let undo_before = session.doc().unwrap().history.undo.len();
|
||||
assert!(original.is_closed());
|
||||
|
||||
session.pointer(&PointerEvent::new(PointerKind::Move, 152.0, 101.5), view).unwrap();
|
||||
let intersection = session.overlays(view).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "intersect"));
|
||||
for kind in [PointerKind::Down, PointerKind::Up] {
|
||||
session.pointer(&PointerEvent::new(kind, 152.0, 101.5), view).unwrap();
|
||||
}
|
||||
|
||||
let opened = path(&session, rectangle);
|
||||
assert_eq!(opened.subpaths.len(), 1);
|
||||
assert!(!opened.is_closed());
|
||||
let anchors = &opened.subpaths[0].anchors;
|
||||
assert_eq!(anchors.len(), 6);
|
||||
let cut = anchors.first().unwrap().p;
|
||||
assert_eq!(anchors.last().unwrap().p, cut, "the cut ends coincide");
|
||||
let selected = &session.doc().unwrap().selection;
|
||||
assert_eq!(selected.objects, [rectangle]);
|
||||
assert_eq!(selected.anchors.len(), 1);
|
||||
assert_eq!(selected.partial(rectangle).unwrap().iter().copied().collect::<Vec<_>>(), [(0, 0)]);
|
||||
assert!(selected.segments.is_empty(), "one cut endpoint, not a segment, is selected");
|
||||
let selection_after = selected.clone();
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before + 1);
|
||||
|
||||
session.execute("edit.undo", &json!({})).unwrap();
|
||||
assert_eq!(path(&session, rectangle), original);
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().selection, selection_before);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before);
|
||||
session.execute("edit.redo", &json!({})).unwrap();
|
||||
assert_eq!(path(&session, rectangle), opened);
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().selection, selection_after);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before + 1);
|
||||
observed.push((pixel_preview, cut, intersection));
|
||||
}
|
||||
|
||||
// Observe both producer rows before checking the original failure: without Scissors snapping,
|
||||
// Smart Guides on cuts at (152, 100), rather than the intersection at (150, 100).
|
||||
for (pixel_preview, cut, intersection) in observed {
|
||||
let expected = Point::new(if pixel_preview { 152.0 } else { 150.0 }, 100.0);
|
||||
assert!(cut.distance(expected) < 1e-6, "Pixel Preview {pixel_preview}: cut {cut:?}, expected {expected:?}");
|
||||
assert_eq!(intersection, !pixel_preview, "Pixel Preview {pixel_preview}: intersection feedback");
|
||||
}
|
||||
}
|
||||
|
||||
/// A command that ends an actual drag must settle its deferred move before Scissors reads the
|
||||
/// document. Real-time drawing is the control: both routes cut the same moved geometry.
|
||||
#[test]
|
||||
fn scissors_cuts_after_a_command_settles_a_deferred_move() {
|
||||
for real_time_drawing in [true, false] {
|
||||
let mut session = Session::new();
|
||||
session.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
|
||||
let rectangle =
|
||||
NodeId(session.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap());
|
||||
let crossing = NodeId(session.execute("shape.line", &json!({"x1": 185, "y1": 110, "x2": 205, "y2": 150})).unwrap()["id"].as_u64().unwrap());
|
||||
session.execute("select.set", &json!({"ids": [rectangle.0]})).unwrap();
|
||||
session.execute("prefs.set", &json!({"key": "realTimeDrawing", "value": real_time_drawing})).unwrap();
|
||||
let drag_view = ViewInfo { smart_guides: false, snap_to_point: false, snap_to_grid: false, snap_to_pixel: false, ..ViewInfo::default() };
|
||||
session.select_tool("selection", drag_view).unwrap();
|
||||
let original = path(&session, rectangle);
|
||||
let moved = original.transformed(Affine::translate((40.0, 20.0)));
|
||||
let line = path(&session, crossing);
|
||||
let undo_before = session.doc().unwrap().history.undo.len();
|
||||
|
||||
session.pointer(&PointerEvent::new(PointerKind::Down, 150.0, 150.0), drag_view).unwrap();
|
||||
session.pointer(&PointerEvent::new(PointerKind::Drag, 190.0, 170.0), drag_view).unwrap();
|
||||
assert!(session.in_interaction(), "the pointer drag is still held");
|
||||
if real_time_drawing {
|
||||
assert_eq!(path(&session, rectangle), moved);
|
||||
assert!(!session.interaction_unapplied(), "the real-time preview is already applied");
|
||||
} else {
|
||||
assert_eq!(path(&session, rectangle), original, "the non-real-time drag has not changed the stored geometry yet");
|
||||
assert!(session.interaction_unapplied(), "an actual Selection move is pending");
|
||||
let state = session.doc().unwrap();
|
||||
let (command, params) = state.interaction.as_ref().unwrap().preview.as_ref().unwrap();
|
||||
assert_eq!(command, "object.transform");
|
||||
let matrix: Vec<f64> = params["matrix"].as_array().unwrap().iter().map(|value| value.as_f64().unwrap()).collect();
|
||||
assert_eq!(matrix, [1.0, 0.0, 0.0, 1.0, 40.0, 20.0], "the pending move keeps its exact translation");
|
||||
}
|
||||
// command.batch settles the interaction before its steps; selecting the same object
|
||||
// changes no geometry and adds no separate undo step.
|
||||
session
|
||||
.execute(
|
||||
"command.batch",
|
||||
&json!({
|
||||
"label": "Keep selection", "commands": [{"command": "select.set", "params": {"ids": [rectangle.0]}}]
|
||||
}),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(!session.in_interaction());
|
||||
assert_eq!(path(&session, rectangle), moved, "the command keeps the pending move: real-time={real_time_drawing}");
|
||||
assert!(path(&session, rectangle).is_closed());
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before + 1);
|
||||
|
||||
// Finish the physical gesture before changing tools. Releasing after the command has
|
||||
// settled it must neither repeat the transform nor discard its committed geometry.
|
||||
session.pointer(&PointerEvent::new(PointerKind::Up, 190.0, 170.0), drag_view).unwrap();
|
||||
assert!(!session.in_interaction());
|
||||
assert_eq!(path(&session, rectangle), moved, "release keeps exactly one move");
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before + 1);
|
||||
|
||||
let cut_view = ViewInfo::default();
|
||||
session.select_tool("scissors", cut_view).unwrap();
|
||||
session.pointer(&PointerEvent::new(PointerKind::Move, 192.0, 121.5), cut_view).unwrap();
|
||||
for kind in [PointerKind::Down, PointerKind::Up] {
|
||||
session.pointer(&PointerEvent::new(kind, 192.0, 121.5), cut_view).unwrap();
|
||||
}
|
||||
let opened = path(&session, rectangle);
|
||||
assert!(!opened.is_closed());
|
||||
let anchors = &opened.subpaths[0].anchors;
|
||||
let cut = anchors.first().unwrap().p;
|
||||
assert!(cut.distance(Point::new(190.0, 120.0)) < 1e-6, "the current moved path snaps to its intersection");
|
||||
assert_eq!(anchors.last().unwrap().p, cut);
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before + 2);
|
||||
session.execute("edit.undo", &json!({})).unwrap();
|
||||
assert_eq!(path(&session, rectangle), moved, "undoing the cut retains the earlier settled move");
|
||||
assert_eq!(path(&session, crossing), line);
|
||||
assert_eq!(session.doc().unwrap().selection.objects, [rectangle]);
|
||||
assert_eq!(session.doc().unwrap().history.undo.len(), undo_before + 1);
|
||||
}
|
||||
}
|
||||
@@ -11,7 +11,8 @@
|
||||
//! still held: at 45° steps from where it was). Space held during a convert- or handle-drag moves
|
||||
//! the anchor, handles and all, as while drawing with the Pen. Blend spine points and handles
|
||||
//! follow the same conversions (#2544).
|
||||
//! Scissors: click a path to split it there (Alt = add, as the Add Anchor Point tool does).
|
||||
//! Scissors: hover and click snap as the Pen does; click a path to split it there (Alt = add,
|
||||
//! as the Add Anchor Point tool does).
|
||||
|
||||
use serde_json::json;
|
||||
use vectorcraft_doc::NodeId;
|
||||
@@ -19,8 +20,8 @@ use vectorcraft_geom::Point;
|
||||
|
||||
use super::{hit_anchor, hit_segment, insert_anchor, remove_anchor};
|
||||
use crate::direct::hit_handle;
|
||||
use crate::guides::HandleSnap;
|
||||
use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
|
||||
use crate::guides::{DrawSnap, HandleSnap};
|
||||
use crate::{Action, Cursor, Mods, Overlay, PixelOp, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
|
||||
use vectorcraft_geom::constrain_angle_from;
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
@@ -94,12 +95,25 @@ enum SpaceResume {
|
||||
SpineHandle { id: NodeId, ai: usize, out: bool },
|
||||
}
|
||||
|
||||
/// The cursor reuses the last hover's point, with DrawSnap checking its target inputs. The
|
||||
/// Scissors-only inputs also bind the resolved point to the current cut eligibility.
|
||||
struct ScissorsHover {
|
||||
raw: Point,
|
||||
snapped: Point,
|
||||
zoom: f64,
|
||||
isolation: Option<NodeId>,
|
||||
selection_tolerance: f64,
|
||||
}
|
||||
|
||||
pub struct AnchorTool {
|
||||
id: &'static str,
|
||||
state: State,
|
||||
/// Smart guides of the handle being dragged, and what it snaps to.
|
||||
guides: Vec<Overlay>,
|
||||
snap: HandleSnap,
|
||||
/// Scissors uses the drawing tools' targets; Anchor Point keeps its own handle snap above.
|
||||
scissors_snap: DrawSnap,
|
||||
scissors_hover: Option<ScissorsHover>,
|
||||
/// Move offset while Shift-dragging an anchor or spine point (pointer, delta).
|
||||
measure: Option<(Point, f64, f64)>,
|
||||
/// While Space is held during a convert/handle drag, the shape gesture to return to.
|
||||
@@ -117,7 +131,85 @@ impl AnchorTool {
|
||||
"scissors" => "scissors",
|
||||
_ => "addAnchor",
|
||||
};
|
||||
Self { id, state: State::Idle, guides: vec![], snap: HandleSnap::default(), measure: None, space_resume: None, lent: false }
|
||||
Self {
|
||||
id,
|
||||
state: State::Idle,
|
||||
guides: vec![],
|
||||
snap: HandleSnap::default(),
|
||||
scissors_snap: DrawSnap::default(),
|
||||
scissors_hover: None,
|
||||
measure: None,
|
||||
space_resume: None,
|
||||
lent: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn clear_scissors_snap(&mut self) {
|
||||
self.scissors_snap.clear();
|
||||
self.scissors_hover = None;
|
||||
}
|
||||
|
||||
fn current_scissors_hover(&self, cx: &ToolContext) -> Option<&ScissorsHover> {
|
||||
self.scissors_hover.as_ref().filter(|h| {
|
||||
h.zoom == cx.zoom
|
||||
&& h.isolation == cx.isolation
|
||||
&& h.selection_tolerance == cx.selection_tolerance
|
||||
&& self.scissors_snap.is_current(cx, &[])
|
||||
})
|
||||
}
|
||||
|
||||
/// Keep a shared art snap unless it prevents a cut the raw pointer could make. Outside art
|
||||
/// still supplies alignment and intersection guides; pixel and grid snapping keep precedence.
|
||||
fn resolve_scissors_snap(&mut self, cx: &ToolContext, raw: Point, snapped: Point) -> Point {
|
||||
let eligible = |p| hit_anchor(cx, p, 0.0).is_some() || hit_segment(cx, p, cx.pick_tol()).is_some();
|
||||
let fallback = (cx.smart_guides || cx.snap_to_point)
|
||||
&& !cx.snaps_to_pixel(PixelOp::Drawing)
|
||||
&& !cx.snap_to_grid
|
||||
&& snapped != raw
|
||||
&& !eligible(snapped)
|
||||
&& eligible(raw);
|
||||
let snapped = if fallback {
|
||||
self.scissors_snap.clear();
|
||||
raw
|
||||
} else {
|
||||
snapped
|
||||
};
|
||||
self.scissors_hover =
|
||||
Some(ScissorsHover { raw, snapped, zoom: cx.zoom, isolation: cx.isolation, selection_tolerance: cx.selection_tolerance });
|
||||
snapped
|
||||
}
|
||||
|
||||
/// Prefer a path actually at the snapped point before a nearby selected path. The small
|
||||
/// tolerance covers curve-meeting roundoff. Pixel, grid and alignment points can lie off all
|
||||
/// paths; there the ordinary full pick radius keeps the existing selected-path priority.
|
||||
fn scissors_segment(cx: &ToolContext, p: Point) -> Option<(NodeId, usize, usize, f64)> {
|
||||
let tol = cx.pick_tol();
|
||||
if cx.smart_guides || cx.snap_to_point || cx.snaps_to_pixel(PixelOp::Drawing) || cx.snap_to_grid {
|
||||
super::segment_in(cx, super::candidate_paths(cx), p, tol.min(1e-6)).or_else(|| hit_segment(cx, p, tol))
|
||||
} else {
|
||||
hit_segment(cx, p, tol)
|
||||
}
|
||||
}
|
||||
|
||||
fn scissors_press(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
|
||||
let p = ev.pos;
|
||||
if ev.mods.alt {
|
||||
return Self::add(cx, p);
|
||||
}
|
||||
let snapped = self.scissors_snap.press(cx, p, &[], None);
|
||||
let p = self.resolve_scissors_snap(cx, p, snapped);
|
||||
let point = cx.point_tol();
|
||||
// A path snap must not be pulled to a nearby anchor by the larger pick radius.
|
||||
// Shared anchor targets and the path's anchors use the same stored coordinates.
|
||||
let snapping = cx.smart_guides || cx.snap_to_point || cx.snaps_to_pixel(PixelOp::Drawing) || cx.snap_to_grid;
|
||||
let anchor_tol = if snapping { 0.0 } else { point };
|
||||
if let Some((id, si, ai)) = hit_anchor(cx, p, anchor_tol) {
|
||||
return vec![Action::Exec("path.split".into(), json!({"id": id.0, "subpath": si, "anchor": ai}))];
|
||||
}
|
||||
match Self::scissors_segment(cx, p) {
|
||||
Some((id, si, seg, t)) => vec![Action::Exec("path.split".into(), json!({"id": id.0, "subpath": si, "segment": seg, "t": t}))],
|
||||
None => vec![],
|
||||
}
|
||||
}
|
||||
|
||||
/// The Anchor Point tool as the Pen lends it with Alt held: an Alt-drag on a handle moves only
|
||||
@@ -317,7 +409,10 @@ impl Tool for AnchorTool {
|
||||
/// handle, a segment, a blend spine's point, handle or segment) cancels it: what it moved goes
|
||||
/// back and the release does nothing. Escape after a press that has not moved yet drops the
|
||||
/// press, so its release converts nothing.
|
||||
fn key(&mut self, _cx: &ToolContext, key: ToolKey, _mods: Mods) -> Vec<Action> {
|
||||
fn key(&mut self, _cx: &ToolContext, key: ToolKey, mods: Mods) -> Vec<Action> {
|
||||
if self.id == "scissors" && (key == ToolKey::Escape || mods.alt) {
|
||||
self.clear_scissors_snap();
|
||||
}
|
||||
if key != ToolKey::Escape || matches!(self.state, State::Idle) {
|
||||
return vec![];
|
||||
}
|
||||
@@ -339,8 +434,9 @@ impl Tool for AnchorTool {
|
||||
}
|
||||
fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
|
||||
let p = ev.pos;
|
||||
// Anchors and handle ends are picked from a little further than segments.
|
||||
let (tol, point) = (cx.pick_tol(), cx.point_tol());
|
||||
if self.id == "scissors" && ev.mods.alt {
|
||||
self.clear_scissors_snap();
|
||||
}
|
||||
match (self.id, ev.kind) {
|
||||
("addAnchor", PointerKind::Down) => {
|
||||
if ev.mods.alt {
|
||||
@@ -356,18 +452,18 @@ impl Tool for AnchorTool {
|
||||
Self::delete(cx, p)
|
||||
}
|
||||
}
|
||||
("scissors", PointerKind::Down) => {
|
||||
if ev.mods.alt {
|
||||
return Self::add(cx, p);
|
||||
}
|
||||
if let Some((id, si, ai)) = hit_anchor(cx, p, point) {
|
||||
return vec![Action::Exec("path.split".into(), json!({"id": id.0, "subpath": si, "anchor": ai}))];
|
||||
}
|
||||
match hit_segment(cx, p, tol) {
|
||||
Some((id, si, seg, t)) => vec![Action::Exec("path.split".into(), json!({"id": id.0, "subpath": si, "segment": seg, "t": t}))],
|
||||
None => vec![],
|
||||
("scissors", PointerKind::Move) => {
|
||||
if !ev.mods.alt {
|
||||
let snapped = self.scissors_snap.hover(cx, p, &[], None);
|
||||
self.resolve_scissors_snap(cx, p, snapped);
|
||||
}
|
||||
vec![]
|
||||
}
|
||||
("scissors", PointerKind::Up) => {
|
||||
self.clear_scissors_snap();
|
||||
vec![]
|
||||
}
|
||||
("scissors", PointerKind::Down) => self.scissors_press(cx, ev),
|
||||
("anchorPoint", PointerKind::Down) => {
|
||||
self.space_resume = None;
|
||||
self.state = Self::press_target(cx, p);
|
||||
@@ -572,7 +668,14 @@ impl Tool for AnchorTool {
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
fn hover_ended(&mut self, _cx: &ToolContext) {
|
||||
self.clear_scissors_snap();
|
||||
}
|
||||
fn wants_rehover(&self) -> bool {
|
||||
self.id == "scissors" && self.scissors_hover.is_some()
|
||||
}
|
||||
fn deactivate(&mut self, _cx: &ToolContext) -> Vec<Action> {
|
||||
self.clear_scissors_snap();
|
||||
self.measure = None;
|
||||
let st = std::mem::replace(&mut self.state, State::Idle);
|
||||
match st {
|
||||
@@ -591,6 +694,9 @@ impl Tool for AnchorTool {
|
||||
if matches!(self.state, State::Handle { .. }) {
|
||||
out.extend(self.guides.iter().cloned());
|
||||
}
|
||||
if self.id == "scissors" && self.current_scissors_hover(cx).is_some() {
|
||||
out.extend_from_slice(self.scissors_snap.guides());
|
||||
}
|
||||
if cx.measurement_labels
|
||||
&& let Some((p, dx, dy)) = self.measure
|
||||
{
|
||||
@@ -606,11 +712,8 @@ impl Tool for AnchorTool {
|
||||
"deleteAnchor" => Cursor::PenAdd,
|
||||
"scissors" if m.alt => Cursor::PenAdd,
|
||||
"scissors" => {
|
||||
if hit_segment(cx, p, cx.pick_tol()).is_some() {
|
||||
Cursor::Scissors
|
||||
} else {
|
||||
Cursor::ScissorsNotAllowed
|
||||
}
|
||||
let p = self.current_scissors_hover(cx).filter(|h| h.raw == p).map_or(p, |h| h.snapped);
|
||||
if hit_segment(cx, p, cx.pick_tol()).is_some() { Cursor::Scissors } else { Cursor::ScissorsNotAllowed }
|
||||
}
|
||||
_ => match self.state {
|
||||
State::Reshape { .. } => Cursor::ReshapeSegment,
|
||||
|
||||
@@ -301,6 +301,317 @@ fn scissors_splits_at_segment() {
|
||||
);
|
||||
}
|
||||
|
||||
fn scissors_crossing() -> (vectorcraft_doc::Document, NodeId, Selection) {
|
||||
let (mut d, rect) = doc_with_rect();
|
||||
let line = d.alloc_id();
|
||||
d.insert(
|
||||
Some(d.layers[0].id),
|
||||
1,
|
||||
vectorcraft_doc::Node::path(
|
||||
line,
|
||||
vectorcraft_geom::shapes::line(Point::new(145.0, 90.0), Point::new(165.0, 130.0)),
|
||||
vectorcraft_doc::Appearance::default_art(),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
// The selected rectangle is the cut target even though the crossing line is above it.
|
||||
let mut selected = Selection::default();
|
||||
selected.set([rect]);
|
||||
(d, rect, selected)
|
||||
}
|
||||
|
||||
fn scissors_cut_at(d: &vectorcraft_doc::Document, id: NodeId, actions: &[Action]) -> Point {
|
||||
let [Action::Exec(command, args)] = actions else { panic!("expected one split: {actions:?}") };
|
||||
assert_eq!(command, "path.split");
|
||||
assert_eq!(args["id"], id.0);
|
||||
let si = args["subpath"].as_u64().unwrap() as usize;
|
||||
let sp = &d.node(id).unwrap().path_data().unwrap().subpaths[si];
|
||||
if let Some(anchor) = args["anchor"].as_u64() {
|
||||
sp.anchors[anchor as usize].p
|
||||
} else {
|
||||
// A straight segment still has cubic parameters: check geometry, not a linear t.
|
||||
sp.segment(args["segment"].as_u64().unwrap() as usize).eval(args["t"].as_f64().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
fn scissors_labels(tool: &AnchorTool, cx: &ToolContext) -> Vec<(String, Point)> {
|
||||
tool.overlays(cx).into_iter().filter_map(|o| if let Overlay::Label { text, p, .. } = o { Some((text, p)) } else { None }).collect()
|
||||
}
|
||||
|
||||
/// #6470: the hover and the cut use the drawing tools' intersection, with their existing pixel,
|
||||
/// grid and Smart Guides/Snap to Point precedence. Turning Smart Guides off restores the raw cut.
|
||||
#[test]
|
||||
fn scissors_snaps_intersections_with_the_drawing_options() {
|
||||
let (mut d, rect, selected) = scissors_crossing();
|
||||
d.grid = vectorcraft_doc::GridPrefs { spacing: 20.0, subdivisions: 1 };
|
||||
let paint = paint();
|
||||
for (smart, point, pixel, grid, x, label) in [
|
||||
(true, true, false, false, 150.0, Some("intersect")),
|
||||
(false, false, false, false, 152.0, None),
|
||||
(false, true, false, false, 152.0, None),
|
||||
(true, true, true, false, 152.0, None),
|
||||
(true, true, false, true, 160.0, None),
|
||||
] {
|
||||
let c = ToolContext { smart_guides: smart, snap_to_point: point, snap_to_pixel: pixel, snap_to_grid: grid, ..cx(&d, &selected, &paint) };
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
assert!(tool.pointer(&c, &PointerEvent::new(PointerKind::Move, 152.0, 101.5)).is_empty());
|
||||
let hovered = scissors_labels(&tool, &c);
|
||||
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, 152.0, 101.5));
|
||||
let cut = scissors_cut_at(&d, rect, &actions);
|
||||
assert!(cut.distance(Point::new(x, 100.0)) < 1e-6, "smart={smart}, point={point}, pixel={pixel}, grid={grid}: {cut:?}");
|
||||
assert_eq!(hovered, label.map(|s| (s.to_string(), Point::new(x, 100.0))).into_iter().collect::<Vec<_>>());
|
||||
assert!(tool.pointer(&c, &PointerEvent::new(PointerKind::Up, 152.0, 101.5)).is_empty());
|
||||
assert!(tool.overlays(&c).is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
/// Snapping chooses the path it names, rather than a selected path merely within pick tolerance.
|
||||
/// With every snap off, the existing selected-path priority still applies to the raw pointer.
|
||||
#[test]
|
||||
fn scissors_snapped_path_beats_nearby_selected_path() {
|
||||
let (mut d, rect) = doc_with_rect();
|
||||
let line = d.alloc_id();
|
||||
d.insert(
|
||||
Some(d.layers[0].id),
|
||||
1,
|
||||
vectorcraft_doc::Node::path(
|
||||
line,
|
||||
vectorcraft_geom::shapes::line(Point::new(120.0, 102.0), Point::new(240.0, 102.0)),
|
||||
vectorcraft_doc::Appearance::default_art(),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
let mut selected = Selection::default();
|
||||
selected.set([rect]);
|
||||
let paint = paint();
|
||||
for (smart, point, at, owner, target) in [
|
||||
(false, false, (150.0, 101.6), rect, (150.0, 100.0)),
|
||||
(true, true, (150.0, 101.6), line, (150.0, 102.0)),
|
||||
(false, true, (150.0, 101.6), rect, (150.0, 100.0)),
|
||||
(false, true, (150.0, 102.0), line, (150.0, 102.0)),
|
||||
] {
|
||||
let (at, target) = (Point::from(at), Point::from(target));
|
||||
let c = ToolContext { smart_guides: smart, snap_to_point: point, snap_to_pixel: false, snap_to_grid: false, ..cx(&d, &selected, &paint) };
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
let labels = scissors_labels(&tool, &c);
|
||||
if smart {
|
||||
assert_eq!(labels.len(), 1, "{labels:?}");
|
||||
assert_eq!(labels[0].0, "path");
|
||||
assert!(labels[0].1.distance(Point::new(150.0, 102.0)) < 1e-6, "{labels:?}");
|
||||
} else {
|
||||
assert!(labels.is_empty(), "{labels:?}");
|
||||
}
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
|
||||
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
|
||||
assert!(scissors_cut_at(&d, owner, &actions).distance(target) < 1e-6, "smart={smart}, point={point}: {actions:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Outside art can give an isolated path useful guides, but an unusable art snap must not turn a
|
||||
/// valid raw cut into a miss. Pixel/grid precedence still forbids falling back to the raw point.
|
||||
#[test]
|
||||
fn scissors_keeps_valid_isolated_cuts_when_outside_art_snaps() {
|
||||
let (mut d, rect) = doc_with_rect();
|
||||
let outside = d.alloc_id();
|
||||
d.insert(
|
||||
Some(d.layers[0].id),
|
||||
1,
|
||||
vectorcraft_doc::Node::path(
|
||||
outside,
|
||||
vectorcraft_geom::shapes::line(Point::new(150.0, 103.5), Point::new(350.0, 350.0)),
|
||||
vectorcraft_doc::Appearance::default_art(),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
let mut selected = Selection::default();
|
||||
selected.set([rect]);
|
||||
let paint = paint();
|
||||
let at = Point::new(150.0, 100.0);
|
||||
for snapping in [false, true] {
|
||||
let c = ToolContext {
|
||||
isolation: Some(rect),
|
||||
smart_guides: snapping,
|
||||
snap_to_point: snapping,
|
||||
snap_to_pixel: false,
|
||||
snap_to_grid: false,
|
||||
..cx(&d, &selected, &paint)
|
||||
};
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
let labels = scissors_labels(&tool, &c);
|
||||
let cursor = tool.cursor(&c, at, Mods::default());
|
||||
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
|
||||
assert!(scissors_cut_at(&d, rect, &actions).distance(at) < 1e-6, "snapping={snapping}: {actions:?}");
|
||||
assert_eq!(cursor, Cursor::Scissors, "snapping={snapping}");
|
||||
assert!(labels.is_empty(), "rejected outside snap must not guide the raw cut: {labels:?}");
|
||||
assert!(scissors_labels(&tool, &c).is_empty(), "the press also discards its rejected guide");
|
||||
}
|
||||
|
||||
// The same isolation may still use an outside path's intersection on the eligible rectangle.
|
||||
let (d, rect, selected) = scissors_crossing();
|
||||
let c = ToolContext { isolation: Some(rect), ..cx(&d, &selected, &paint) };
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
let at = Point::new(152.0, 101.5);
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
let labels = scissors_labels(&tool, &c);
|
||||
assert_eq!(labels.len(), 1, "{labels:?}");
|
||||
assert_eq!(labels[0].0, "intersect");
|
||||
assert!(labels[0].1.distance(Point::new(150.0, 100.0)) < 1e-6, "{labels:?}");
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
|
||||
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
|
||||
assert!(scissors_cut_at(&d, rect, &actions).distance(Point::new(150.0, 100.0)) < 1e-6, "{actions:?}");
|
||||
|
||||
// A grid snap away from the path remains a miss even though the raw point is cuttable.
|
||||
let (mut d, rect) = doc_with_rect();
|
||||
d.node_mut(rect).unwrap().transform(vectorcraft_geom::Affine::translate((0.0, 3.5)), true);
|
||||
d.grid = vectorcraft_doc::GridPrefs { spacing: 20.0, subdivisions: 1 };
|
||||
let mut selected = Selection::default();
|
||||
selected.set([rect]);
|
||||
let c = ToolContext { isolation: Some(rect), snap_to_grid: true, ..cx(&d, &selected, &paint) };
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
let at = Point::new(150.0, 103.5);
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
assert!(tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y)).is_empty());
|
||||
assert!(scissors_labels(&tool, &c).is_empty());
|
||||
}
|
||||
|
||||
/// Path and alignment labels use the same targets as the Pen. A configured snap reach beyond the
|
||||
/// anchor's pick radius proves that snapping chooses the anchor rather than a nearby segment.
|
||||
#[test]
|
||||
fn scissors_shows_paths_alignment_and_configured_anchor_snaps() {
|
||||
let (d, rect) = doc_with_rect();
|
||||
let (selected, paint) = (Selection::default(), paint());
|
||||
for (at, smart, point, reach, label, target, cuts) in [
|
||||
((170.0, 201.0), true, true, 4.0, Some("path"), (170.0, 200.0), true),
|
||||
((151.5, 431.0), true, true, 4.0, Some("align"), (150.0, 431.0), false),
|
||||
((201.0, 105.5), true, true, 8.0, Some("anchor"), (200.0, 100.0), true),
|
||||
((201.0, 105.5), true, true, 4.0, Some("path"), (200.0, 105.5), true),
|
||||
// Snap to Point keeps the anchor target without Smart Guides labels.
|
||||
((201.0, 105.5), false, true, 8.0, None, (200.0, 100.0), true),
|
||||
// Outside Smart Guides' reach, but inside the legacy 4.5 px anchor pick radius.
|
||||
((200.0, 104.25), true, true, 4.0, Some("path"), (200.0, 104.25), true),
|
||||
((200.0, 104.25), false, false, 4.0, None, (200.0, 100.0), true),
|
||||
] {
|
||||
let c =
|
||||
ToolContext { smart_guides: smart, snap_to_point: point, snapping_tolerance: reach, snap_tolerance: reach, ..cx(&d, &selected, &paint) };
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.0, at.1));
|
||||
let target = Point::from(target);
|
||||
let labels = scissors_labels(&tool, &c);
|
||||
if let Some(label) = label {
|
||||
assert_eq!(labels.len(), 1, "at={at:?}, smart={smart}, point={point}, reach={reach}, want={label}: {labels:?}");
|
||||
assert_eq!(labels[0].0, label);
|
||||
assert!(labels[0].1.distance(target) < 1e-6, "{labels:?}");
|
||||
} else {
|
||||
assert!(labels.is_empty(), "{labels:?}");
|
||||
}
|
||||
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.0, at.1));
|
||||
if cuts {
|
||||
assert!(scissors_cut_at(&d, rect, &actions).distance(target) < 1e-6, "{actions:?}");
|
||||
if target == Point::new(200.0, 100.0) {
|
||||
assert!(matches!(&actions[..], [Action::Exec(_, v)] if v["anchor"] == 1));
|
||||
}
|
||||
} else {
|
||||
assert!(actions.is_empty(), "a guide away from every path must not cut: {actions:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A cached snap is for the same raw position, document state and drawing options only. A press
|
||||
/// gathers fresh targets, even when a previous hover's document state is reused by a caller.
|
||||
#[test]
|
||||
fn scissors_cursor_and_press_use_current_snaps() {
|
||||
let (d, rect) = doc_with_rect();
|
||||
let (selected, paint) = (Selection::default(), paint());
|
||||
let mut c = cx(&d, &selected, &paint);
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
let at = Point::new(204.0, 140.0);
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
|
||||
assert_eq!(tool.cursor(&c, Point::new(204.0, 160.0), Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
assert!(!tool.overlays(&c).is_empty());
|
||||
// These interaction inputs can change without a document revision. The old hover must not
|
||||
// keep moving the cursor onto the path or showing guides until another pointer move.
|
||||
c.selection_tolerance = 1.0;
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
assert!(tool.overlays(&c).is_empty());
|
||||
c.selection_tolerance = 3.0;
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
|
||||
assert!(!tool.overlays(&c).is_empty());
|
||||
c.isolation = Some(rect);
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
assert!(tool.overlays(&c).is_empty());
|
||||
c.isolation = None;
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
|
||||
assert!(!tool.overlays(&c).is_empty());
|
||||
c.smart_guides = false;
|
||||
c.snap_to_point = false;
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
assert!(tool.overlays(&c).is_empty());
|
||||
c.smart_guides = true;
|
||||
c.snap_to_point = true;
|
||||
c.zoom = 2.0;
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
c.zoom = 1.0;
|
||||
c.revision.1 += 1;
|
||||
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
|
||||
|
||||
let (crossing, _, selected) = scissors_crossing();
|
||||
let before = cx(&crossing, &selected, &paint);
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
tool.pointer(&before, &PointerEvent::new(PointerKind::Move, 152.0, 101.5));
|
||||
let after = cx(&d, &selected, &paint);
|
||||
let actions = tool.pointer(&after, &PointerEvent::new(PointerKind::Down, 152.0, 101.5));
|
||||
assert!(scissors_cut_at(&d, rect, &actions).distance(Point::new(152.0, 100.0)) < 1e-6, "{actions:?}");
|
||||
}
|
||||
|
||||
/// Ending the hover, release, Escape (including a dropped touch) and switching tools drop both the
|
||||
/// guides and the cursor's snap. Alt lends the raw Add Anchor Point tool, with no Scissors guide.
|
||||
#[test]
|
||||
fn scissors_clears_its_snap_when_the_interaction_ends_or_alt_takes_over() {
|
||||
let (d, _) = doc_with_rect();
|
||||
let (selected, paint) = (Selection::default(), paint());
|
||||
let c = cx(&d, &selected, &paint);
|
||||
for ending in 0..7 {
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, 204.0, 140.0));
|
||||
assert!(!tool.overlays(&c).is_empty());
|
||||
match ending {
|
||||
0 => {
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Up, 204.0, 140.0));
|
||||
}
|
||||
1 => {
|
||||
tool.key(&c, ToolKey::Escape, Mods::default());
|
||||
}
|
||||
2 => {
|
||||
tool.drop_press(&c);
|
||||
}
|
||||
3 => {
|
||||
tool.deactivate(&c);
|
||||
}
|
||||
4 => tool.hover_ended(&c),
|
||||
_ => {
|
||||
let alt = Mods { alt: true, ..Mods::default() };
|
||||
let kind = if ending == 5 { PointerKind::Move } else { PointerKind::Down };
|
||||
let event = PointerEvent::new(kind, 170.0, 201.0);
|
||||
let mut add = AnchorTool::new("addAnchor");
|
||||
let actions = tool.pointer(&c, &event.with_mods(alt));
|
||||
assert_eq!(actions, add.pointer(&c, &event));
|
||||
if kind == PointerKind::Down {
|
||||
assert!(matches!(&actions[..], [Action::Exec(command, _)] if command == "path.insertAnchor"));
|
||||
}
|
||||
assert_eq!(tool.cursor(&c, event.pos, alt), Cursor::PenAdd);
|
||||
}
|
||||
}
|
||||
assert!(tool.overlays(&c).is_empty(), "ending {ending}");
|
||||
assert_eq!(tool.cursor(&c, Point::new(204.0, 140.0), Mods::default()), Cursor::ScissorsNotAllowed, "ending {ending}");
|
||||
}
|
||||
}
|
||||
|
||||
/// With Alt held the Scissors tool acts as the Add Anchor Point tool: a click sends what the Add
|
||||
/// Anchor Point tool's click sends (an anchor inserted on a segment, nothing away from every path)
|
||||
/// and never splits, and the cursor is the Add Anchor Point tool's everywhere. Without Alt it cuts
|
||||
@@ -611,6 +922,49 @@ fn anchor_point_shift_drag_honors_measurement_labels() {
|
||||
assert!(!t.overlays(&off).iter().any(|o| matches!(o, Overlay::Measure { .. })));
|
||||
}
|
||||
|
||||
/// Disabled Drawing pixel snapping must behave like the same effective art-snap mode.
|
||||
/// Drawing enabled is the ordinary pixel-priority control at this integer cut point.
|
||||
#[test]
|
||||
fn scissors_drawing_pixel_option_keeps_valid_isolated_cuts() {
|
||||
let (mut d, rect) = doc_with_rect();
|
||||
let outside = d.alloc_id();
|
||||
d.insert(
|
||||
Some(d.layers[0].id),
|
||||
1,
|
||||
vectorcraft_doc::Node::path(
|
||||
outside,
|
||||
vectorcraft_geom::shapes::line(Point::new(150.0, 103.5), Point::new(350.0, 350.0)),
|
||||
vectorcraft_doc::Appearance::default_art(),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
let mut selected = Selection::default();
|
||||
selected.set([rect]);
|
||||
let paint = paint();
|
||||
let at = Point::new(150.0, 100.0);
|
||||
for drawing in [true, false] {
|
||||
let c = ToolContext {
|
||||
isolation: Some(rect),
|
||||
smart_guides: true,
|
||||
snap_to_point: true,
|
||||
snap_to_pixel: true,
|
||||
pixel_snap: crate::PixelSnap { drawing, ..Default::default() },
|
||||
snap_to_grid: false,
|
||||
..cx(&d, &selected, &paint)
|
||||
};
|
||||
let mut tool = AnchorTool::new("scissors");
|
||||
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
|
||||
let labels = scissors_labels(&tool, &c);
|
||||
let cursor = tool.cursor(&c, at, Mods::default());
|
||||
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
|
||||
assert!(!actions.is_empty(), "drawing={drawing}: expected a valid isolated cut");
|
||||
assert!(scissors_cut_at(&d, rect, &actions).distance(at) < 1e-6, "drawing={drawing}: {actions:?}");
|
||||
assert_eq!(cursor, Cursor::Scissors, "drawing={drawing}");
|
||||
assert!(labels.is_empty(), "rejected outside snap must not guide the raw cut: {labels:?}");
|
||||
assert!(scissors_labels(&tool, &c).is_empty(), "the press also discards its rejected guide");
|
||||
}
|
||||
}
|
||||
|
||||
/// Alt held while dragging a handle links it with the opposite handle (`link`), making the
|
||||
/// anchor smooth; without Alt the handle moves on its own. Shift with Alt keeps the 45° steps, an
|
||||
/// Alt-click still retracts the handle, and Escape cancels the linking drag. The Pen, lending the
|
||||
|
||||
@@ -384,6 +384,12 @@ pub(super) fn visible(cx: &ToolContext) -> Option<Rect> {
|
||||
}
|
||||
|
||||
impl DrawSnap {
|
||||
/// Whether the last hover or press still has the current targets, without gathering the art
|
||||
/// again. A caller caching the snapped point can use this before reusing it for a cursor.
|
||||
pub(crate) fn is_current(&self, cx: &ToolContext, exclude: &[NodeId]) -> bool {
|
||||
self.targets.as_ref().is_some_and(|(key, _)| key.as_ref() == Some(&SnapKey::of(cx, exclude)))
|
||||
}
|
||||
|
||||
/// Snap the pointer hovering at `p` (the art but `exclude` as targets, the anchors of
|
||||
/// `exclude` still pulling), reusing the targets while nothing they depend on changed.
|
||||
pub fn hover(&mut self, cx: &ToolContext, p: Point, exclude: &[NodeId], from: Option<&Leave>) -> Point {
|
||||
|
||||
File diff suppressed because one or more lines are too long
+4
-1
@@ -16,6 +16,8 @@
|
||||
>
|
||||
> Numeric spinner update (2026-11-10): held mouse arrows repeat past the click timeout; scores and estimates unchanged (#6307).
|
||||
|
||||
> Scissors snapping update (2026-11-11): with Alt released, hover and cuts use the Pen's path, alignment, intersection and anchor snaps (#6470). Scores and estimates unchanged.
|
||||
|
||||
> **PDF import status (2026-11-14, #6957):** Outlined Indic glyphs retain their full stroke properties; translucent glyphs stay separate, and a soft mask attaches to each glyph separately. Scores and estimates unchanged.
|
||||
|
||||
> Blend redraw update (#5179): renderer bounds include spine-placed keys and steps; both focused CPU regressions pass. Scores and estimates unchanged.
|
||||
@@ -168,7 +170,7 @@ Gujarati interface follow-up (2026-11-14): the catalog and zero/one plural rule
|
||||
|---|---|---|---|
|
||||
| M0 | Skeleton + vertical slice | ✅ done | — |
|
||||
| M1 | Selection, transform, layers, MCP (common command tools, strict keys, session resources and version-aware result hints) | ✅ mostly done (path and compound-path interior selection follows enabled fill rows (#6625); a marquee leaves locked or hidden guide paths out inside groups, as clicks do (#8538); hidden-fill and no-fill stroke cap/join CPU regressions passed; document-tab artwork drag with lossless resource transfer and one target Undo; malformed MCP app replies discard the connection without replay, #1761; bounded control socket waits and connection-slot recovery, #1726; bounded synthetic control input, #1709; no-op anchor Align keeps Undo, Redo and saved state (#1180 follow-up); transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending; the Transform fields take one Tab each, the W/H link after them) | 4–6 |
|
||||
| M2 | Drawing tools + smart guides | ✅ mostly done (Eraser preserves fill outside fixed and varied tip sweeps and Alt-drag marquees on fill-only open paths and keeps their compound holes; clipping masks retain surviving contours or empty geometry in the same node; ordinary Group/Layer paints and evaluated gradient placements are preserved when the stored paint reproduces their appearance; hidden Rasterize and Along/Across stroke rows do not block visible gradients; replacement-art effects, plug-ins/Rasterize, along/across-stroke gradients and placements that cannot be reproduced keep their existing fitting; stroked open paths retain main behavior (#6582); #3380 deletion creates independent selected path pieces and keeps bounds-fitted gradients in place; endpoint highlighting remains open; Polygon/Star exact-size count persistence, with repeated-drag, tool-switch and Cancel regression coverage; Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending); a shape just drawn moves by its centre point and turns from the zone outside a corner with its tool still active (#5477); Tangent and straight-segment perpendicular snapping use saved Smart Guides Geometric Guides preferences and Control bar quick access (#2537), including the existing Snap to Glyph and Alignment Guides toggles (#6164); no View submenu; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123) | 12–18 |
|
||||
| M2 | Drawing tools + smart guides | ✅ mostly done (Eraser preserves fill outside fixed and varied tip sweeps and Alt-drag marquees on fill-only open paths and keeps their compound holes; clipping masks retain surviving contours or empty geometry in the same node; ordinary Group/Layer paints and evaluated gradient placements are preserved when the stored paint reproduces their appearance; hidden Rasterize and Along/Across stroke rows do not block visible gradients; replacement-art effects, plug-ins/Rasterize, along/across-stroke gradients and placements that cannot be reproduced keep their existing fitting; stroked open paths retain main behavior (#6582); #3380 deletion creates independent selected path pieces and keeps bounds-fitted gradients in place; endpoint highlighting remains open; Polygon/Star exact-size count persistence, with repeated-drag, tool-switch and Cancel regression coverage; Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending); a shape just drawn moves by its centre point and turns from the zone outside a corner with its tool still active (#5477); Tangent and straight-segment perpendicular snapping use saved Smart Guides Geometric Guides preferences and Control bar quick access (#2537), including the existing Snap to Glyph and Alignment Guides toggles (#6164); no View submenu; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123); Scissors hover and cuts use the Pen's path/align/intersect/anchor snaps, with Alt Add Anchor and cut endpoint selection retained (#6470) | 12–18 |
|
||||
| M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Eyedropper copies transformed character dimensions (#6404) and styles highlighted text only (atomic transparency rejection); Eyedropper reads visible locked and outside-isolation sources (#1251); Color Picker, Color panel (its spectrum grows with a resized panel, #8005), Color Guide, Color Themes, Edit Colors and Recolor Artwork (screen-bounded Edit chip list, #3416; native Lab entry and swatch libraries in the picker, Assign-row menus, #8031/#4028); gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; visible strokes when paint is added to inherited None/zero-width art (#1253); stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool (Shift-double-click enables adjoining adjustment in Width Point Edit; finite-arithmetic follow-up regressions and full CI passed ([Validation evidence](target-app-parity.md#evidence-what-ships-today-by-area))), Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries; CSS library export preserves fractional linear and radial gradient stop positions. Left: freeform gradients in SVG/PDF, mixed spot/process gradients in SVG and PDF gradients mixing a spot color with RGB or Lab stops export as stops or process colors; PDF export writes dithered gradient fills with spot stops, and Perceptual spot gradients with RGB or Lab stops other than white or more than 4,096 stops on their curve, as images in process colors; confirm the Scale Strokes & Effects default; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls; Library panels' lists (swatch, Color Book, brush, symbol and graphic style libraries) fill a taller panel above its footer (#2992; scores and estimates unchanged); Graphic Styles list fills a taller panel above its footer (#2992; scores and estimates unchanged); Swatches list fills a taller panel above its footer (#1638; `the_list_fills_a_tall_panel_above_its_footer`; scores and estimates unchanged); | 4–8 |
|
||||
| M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | `.ai` and EPS import: clipping paths grouped in a compound path are its subpaths (#8128; estimates unchanged); Production Preflight checks fonts, overflow, links and image resolution with clickable findings and automatic rechecking (VectorCraft addition; estimates unchanged); PDF import: a glyph filled only after a glyph filled and stroked comes in filled only, not stroked (#8300; estimates unchanged); PDF import: type filled and stroked by one text-showing operator comes in as one filled and stroked type object (#8015; not for type filled and stroked at less than full opacity, which still comes in as a filled object and a stroked one, as the file composites them; estimates unchanged); PDF import: type filled and stroked by a `TJ` whose kerning starts a new line part way through comes in filled and stroked, a type object for each part, also where it draws a glyph again where it drew one, in an `ActualText` span too, where it stays one replacement type object on the first glyph's line and in its style; a `TJ` over more than 65 lines (the 64 its fill pass finished, kept back, and the open one) stays a filled object and a stroked one for each part (#8543; estimates unchanged); PDF import: stroked type keeps the file's line cap, line join and miter limit (#7741; estimates unchanged); Rename artboards in Export for Screens (#7275); Explicit editing-data import keeps oversized capped-page artboards (#6865; estimates unchanged); Save refusal continuation (#6146): ordinary Save offers Save As; unchanged format keeps options, changed format opens its Save options; cancellation/automation isolation; focused UI regressions passed, native acceptance pending; PDF authored ActualText preserved once in editable import (#6165; first-glyph line/style, bounded input; estimates unchanged); PDF export keeps harakat and zero-advance Noto Arabic dot glyphs in one compatible batch per layout line, with per-glyph vertical offsets (#6309). `crates/pdf/src/tests/realtext.rs` (`mark_text_*`) checks decoded cluster mappings, mixed Arabic/Latin/digits, contour placement against outline export, vertical columns, differing path rotations and PDF/X-1a/3/4. Editable-text import preserves authored ActualText separately (#6165), with cross-line/style layout limits; separately styled or differently rotated clusters and external viewer search/copy remain outside this export-only evidence. `.ai`/EPS type from the text document keeps its paragraphs' tab stops (#6147); `.ai`/EPS type from the text document keeps auto leading per line, its hyphenation options, and may show more of the last lines the file sets in an area frame of its own, when growing the frame by its lines' deepest descent plus 0.05 pt shows them (#6137); ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), shared guarded PDF writer and windowed reader ([pdf-backend.md](pdf-backend.md)), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out (EPS legacy mesh corners, vector opacity masks and raster page comparison verified; closed SPLINE flags round-trip and circular paths export as native CIRCLE/ARC, #1299), EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, TIFF in Export for Screens and Asset Export, clipboard flavours, File Info; AF.1–AF.4 add Affinity import (native layers, artboards, vectors, text and images from Affinity 1–3 files; the embedded preview only as a warned fallback; AF.4 expands current `.af` fixtures and every-board round-trip validation); EPS Save and Save As keep an opened EPS as EPS with its page frame and complete editable VectorCraft document (2026-10-26; G9 import fidelity unchanged). Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, Affinity export, polish; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; PDF import: glyphs inside a marked-content span with an empty `ActualText` come in as outlines in their fill and stroke, adding no text (#6971; scores and estimates unchanged); | 3–6 (existing scope; Affinity export unestimated) |
|
||||
| M5 | Performance | 🟡 background render + caches + MT done; text thread overlays index repeated selection lookups, keeping the first lookup and singleton selections direct (#6543); `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); opaque solid-fill knockout paths draw once in hard-edge/supersampled raster export, with analytical-AA compositing unchanged; file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); Craquelure/Mosaic Tiles/Stained Glass distance searches optimized with pixel-invariance checks and the `texture_drag_perf` probe (#1257); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
|
||||
@@ -259,6 +261,7 @@ not take the artwork yet. Overflow-menu drag remains separate. Scores and hours
|
||||
| 2026-11-11 | minor | M5/G15: text thread overlay membership indexing, focused output controls and matched component timings (#6543); scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | Eraser: fixed and varied tips and the Alt-drag marquee cut fill-only open contours and compound holes as areas; stroked open paths retain main behavior (#6582). Scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | #6625: path and compound-path interior hits follow enabled non-None fill rows, including lower fills beneath a top None row; hidden-only interiors miss; zero-opacity fills remain selectable. Scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | M2: Scissors hover and cuts share Pen-style path/align/intersect/anchor snapping (#6470); existing Alt and cut endpoint selection retained. Scores and estimates unchanged. |
|
||||
| 2026-11-10 | minor | M10/G5: Status Effects built-in graphic style library; MCP docs catch-up for UI Frames and Map Markers; estimates unchanged |
|
||||
| 2026-11-10 | minor | M10/G5: Inventory Icons built-in symbol library (Sword, Shield, Potion, Key, Gem); estimates unchanged |
|
||||
| 2026-11-10 | minor | M7: the Edit Custom Dictionary dialog (#4936); the Check Spelling dialog remains; scores and estimates unchanged. |
|
||||
|
||||
@@ -20,6 +20,8 @@
|
||||
>
|
||||
> **Flyout update:** 2026-11-06 — resizable icon-strip flyouts and bottom-aligned panel footers (#5713); scores and estimates unchanged.
|
||||
|
||||
> Scissors snapping update (2026-11-11): with Alt released, hover and cuts use the Pen's path, alignment, intersection and anchor snaps (#6470). Scores and estimates unchanged.
|
||||
|
||||
> **PDF import status (2026-11-14, #6957):** Outlined Indic glyphs retain their full stroke properties; translucent glyphs stay separate, and a soft mask attaches to each glyph separately. Scores and estimates unchanged.
|
||||
|
||||
> Blend redraw update (#5179): renderer bounds include spine-placed keys and steps; both focused CPU regressions pass. Scores and estimates unchanged.
|
||||
@@ -269,7 +271,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
|
||||
| Area | Weight | Done | Main gaps | One agent (h) | Kind |
|
||||
|---|---:|---:|---|---:|---|
|
||||
| Selection, transform & align tools | 6 | 85% | Direct Selection segment click/Delete corrected (#1278); deletion splits an ordinary contour into selected sibling objects with bounds-fitted gradients kept in place (#3380, deletion only; `crates/engine/tests/it/delete_path_pieces.rs`); open-path anchor Delete keeps gaps; Select › Start Global Edit finds the paths, compound paths and symbol instances of the selected object's shape (Appearance, Size and artboard options) and gives an edit of one to all of them in proportion, as one undo step (#3521), and on a group the groups like it, an edit inside one reaching the same object in the others (#4939), and a Shift-click on a highlighted match leaves it out; the Align panel menu's Align to Glyph Bounds › Point Text and Area Text measure type by its glyphs' ink for Align and Distribute (#4231); remaining: Free Transform/Scale/Reflect along a rotated box, Global Edit of rotated copies, transform nuances (no-op anchor Align history regression-tested, #1180 follow-up) | 4–6 | estimated; fill-stack selection regression-tested (`crates/engine/tests/path_fill_hits.rs`, #6625); cap/join follow-up CPU regressions passed; Global Edit regression-tested (`crates/engine/src/tests/globaledit.rs`; Quick Action, menu label and Escape in `panels::properties::tests::start_global_edit_quick_action_and_escape`) |
|
||||
| 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; Eraser preserves fill-only open-path area outside fixed and varied tip sweeps and Alt-drag marquees, including compound holes; clipping masks keep their remaining contours and empty-mask role; ordinary Group/Layer paints and evaluated gradient placements are preserved when the stored paint reproduces their appearance; replacement-art effects, plug-ins/Rasterize, along/across-stroke gradients and placements that cannot be reproduced keep their existing fitting; stroked open paths retain main behavior and result structure (#6582; `crates/engine/tests/eraser_open_fill.rs`), score and hours unchanged |
|
||||
| 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; Scissors shares the Pen's path/align/intersect/anchor snaps (#6470), source and headless regressions below; Eraser preserves fill-only open-path area outside fixed and varied tip sweeps and Alt-drag marquees, including compound holes; clipping masks keep their remaining contours and empty-mask role; ordinary Group/Layer paints and evaluated gradient placements are preserved when the stored paint reproduces their appearance; replacement-art effects, plug-ins/Rasterize, along/across-stroke gradients and placements that cannot be reproduced keep their existing fitting; stroked open paths retain main behavior and result structure (#6582; `crates/engine/tests/eraser_open_fill.rs`), score 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 (twelve generated libraries including Tech Circuit, Arrows, Pressure Sensitive, 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) |
|
||||
@@ -1365,6 +1367,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
In the Ellipse dialog, a click on the word Height copies the Width value into the Height field, so OK draws a circle of that width, as [the help page](https://web.archive.org/web/20210601162814/https://helpx.adobe.com/pdf/illustrator_reference.pdf#page=140) describes for drawing ellipses. The Rectangle and Rounded Rectangle dialogs keep plain labels. VectorCraft's own rules: the word Height is a button that Space or Enter also presses, and that Enter does not press OK (nor does Enter on the Constrain Width and Height Proportions button); with the link on, the link stays on and keeps the circle when a side is typed next; a Width that is empty or not a distance, including one the field refuses as the click leaves it, leaves Height as it is; Cancel discards the copy. Evidence: `dialogs::shapes::tests::{clicking_height_in_the_ellipse_dialog_copies_width_into_height, the_ellipse_height_button_copies_width_from_the_keyboard_and_keeps_the_link_round, enter_on_the_link_button_turns_the_link_on_without_pressing_ok, only_the_ellipse_dialog_has_the_height_button, copying_width_takes_only_a_width_that_reads}`.
|
||||
- **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
|
||||
The Eraser cuts fill-only open contours as areas (#6582), retaining fill outside its sweep or Alt-drag marquee. An eligible appearance has a visible non-None fill and no visible non-None stroke of positive width. Fill-only open compound members are cut together under their compound fill rule so holes stay empty. Cut pieces keep the existing path/compound representation and whole appearance. Bounds-fitted gradients on ordinary paths, compounds, groups and layers keep their original evaluated placement when it can be reproduced in the stored paint. Effects that draw replacement artwork, effect plug-ins, Rasterize, gradients along or across a stroke, and flattened placements or placements that cannot reproduce the original appearance keep their existing fitted behavior. Hidden Rasterize rows and hidden strokes with gradients along or across their paths do not block preserving a visible gradient. Already placed gradients and live-effect settings are retained; changes to a live effect's geometry can still move its paint. Path or Compound clipping masks keep every surviving contour in the same mask node; full erasure leaves an empty mask without promoting clipped contents. The mask identity, fill rule, appearance and parent child order are retained. Path Eraser uses the same preservation of the clipping role. Filled-and-stroked open paths retain the outline-splitting behavior from main. `crates/engine/tests/eraser_open_fill.rs` covers fixed and varied tips on fill-only open/closed geometry and raster output, compound holes and self-crossing fill, plus a painted-stroke outline control and clipping-mask split, empty-mask and Path Eraser cases. The same public target includes container-own paint and evaluated-placement regression cases. This deliberately scoped fix does not claim to repair filled-and-stroked open-path fill behavior. Scores and hours are unchanged.
|
||||
With Alt released, Scissors hover and cuts snap as the Pen does: onto paths and anchors, into alignment and onto intersections (#6470). The hover guides and cut use the same snapped point; the cursor follows the current hover target. The existing Smart Guides, Snap to Point, Snap to Pixel and Snap to Grid options keep their precedence. Pixel Preview turns off Smart Guides through the tool view context; Snap to Point keeps its existing rules. Alt Add Anchor and the cut's endpoint selection below are unchanged. Source: `crates/tools/src/draw2/anchor.rs`. Headless regressions: `scissors_snaps_intersections_with_the_drawing_options`, `scissors_shows_paths_alignment_and_configured_anchor_snaps`, `scissors_cursor_and_press_use_current_snaps` and `scissors_clears_its_snap_when_the_interaction_ends_or_alt_takes_over` in `crates/tools/src/draw2/anchor/tests.rs` and `crates/engine/tests/scissors_snap.rs`.
|
||||
A Scissors cut (`path.split`) leaves one of the two new end points selected and the rest of the path unselected, as [Cut paths](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/split-paths.html) and the "Split a path" section of the [CS3 user guide](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf) describe: the two end points lie on top of each other, and a Direct Selection drag from them moves the selected one with its handles and no other anchor. A closed path cut once stays one open path.
|
||||
The paths a Scissors cut (`path.split`) or Cut Path at Selected Anchor Points (`path.cutAtAnchors`) makes keep the source path's fill and stroke settings, and every stroke's alignment becomes Center in the same undo step, as [the help page](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/split-paths.html) describes. Resetting hidden stroke rows too, centering the strokes of a path's other subpaths and of the compound path a cut member belongs to are VectorCraft's own rules (`scissors_cut_paths_have_their_strokes_centered`, `cut_at_anchors_paths_have_their_strokes_centered`).
|
||||
While Alt is held, the Scissors tool works as the Add Anchor Point tool ([Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)): a click on a segment adds an anchor point without cutting (`path.insertAnchor`), and the pointer shows the Add Anchor Point cursor. When Alt is let go, a click cuts again.
|
||||
@@ -3064,6 +3067,7 @@ Edit › Copy and Cut put the selected ruler guides on the clipboard, with the s
|
||||
| 2026-11-11 | minor | Guides and snapping: a Shift move slides the selection along its line onto a ruler guide by its edges and centre, as a move without Shift does (#4312); a guide a nearly parallel line only reaches a long way off pulls nothing. Score and hours unchanged (estimated). |
|
||||
| 2026-11-11 | minor | M5/G15: text thread overlay membership indexing, focused output controls and matched component timings (#6543); scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | #6625: path and compound-path interior hits follow enabled non-None fill rows, including lower fills beneath a top None row; hidden-only interiors miss; zero-opacity fills remain selectable. Scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | Drawing tools: Scissors hover and cuts share the Pen's snapping (#6470), with current view options, Alt Add Anchor and endpoint selection retained; source and headless regressions listed. Scores and hours unchanged (estimated). |
|
||||
| 2026-11-10 | minor | Automation: MCP tool count 33; headless `command_list` lists `UI_COMMANDS` (`ui: true`); eight prompts; effect-id vs command-id clarified (#6460); scores and hours unchanged. |
|
||||
| 2026-11-10 | minor | Type advanced: the Edit Custom Dictionary dialog, #4936; evidence added; the Check Spelling dialog remains; scores and hours unchanged. |
|
||||
| 2026-11-10 | minor | File formats: in a `.ai` or EPS opened from its editing data, an envelope of type opens live where it draws as its drawn art and the layers with it draw as the page (the envelope weighed as the art it draws); elsewhere, and where a text or visibility variable binds its type, it keeps its drawn art, with a note (#3179); evidence updated; scores and hours unchanged. |
|
||||
|
||||
@@ -16,6 +16,8 @@
|
||||
|
||||
> **Flyout update:** 2026-11-06 — resizable icon-strip flyouts and bottom-aligned panel footers (#5713); scores and estimates unchanged.
|
||||
|
||||
> Scissors snapping update (2026-11-11): with Alt released, hover and cuts use the Pen's path, alignment, intersection and anchor snaps (#6470). Scores and estimates unchanged.
|
||||
|
||||
## Feature submission evidence
|
||||
|
||||
Numeric fields step on wheel hover without taking keyboard focus (#5949). Arrow keys still require focus; modifiers, units, limits, mixed values and existing rounding stay in the shared stepping path. Headless regressions in `tests/numfields.rs` cover hovered unfocused fields, focused fields, trackpad accumulation and panel scroll exclusion. Scores and estimates unchanged.
|
||||
@@ -182,6 +184,7 @@ tools, never checked side by side) isn't captured row by row.
|
||||
| Pen cursors (new path ×, continue /, close o, add +, delete −, convert ^) | done | the nib is a fountain-pen nib, tip on the hotspot, with the slit widening into the breather hole and the heel clipped square to its axis; bitmap tests at 1× and 2× pin the nib and the new-path asterisk, and in-app screenshots compare the Pen with Direct Selection |
|
||||
| Node-editing cursors: Direct Selection's white arrow with a hollow or filled square over an anchor (path unselected or selected); the Reshape Segment cursor over a curved segment (Direct Selection, Anchor Point, the Pen with Alt); the Anchor Point caret for the Pen with Alt; Group Selection's plus (also Direct Selection with Alt); a filled arrow while dragging that turns hollow on a snap; a double arrowhead for an Alt-drag copy | partial | as the public manual describes them, drawn in code; no cue over handles (none documented) |
|
||||
| Anchor Point and Curvature tools' own cursors | done | the caret on the anchor it converts; the pen nib with a curve badge |
|
||||
| Scissors hover and cuts use the Pen's path, alignment, intersection and anchor snapping (#6470) | implemented | Existing Smart Guides, Snap to Point, pixel and grid options apply; Pixel Preview turns off Smart Guides. Alt still adds an anchor without cutting, and a cut still leaves one new endpoint selected. Headless regressions: `crates/tools/src/draw2/anchor/tests.rs` and `crates/engine/tests/scissors_snap.rs`. |
|
||||
| Free Transform's Cmd/Ctrl side-shear cursor | done | two arrows passing along the side (ShearH, ShearV), instead of the resize arrow across it |
|
||||
| Live Paint Bucket cursors | partial | a filled bucket over a face a click fills, a brush over an edge it paints, an empty bucket where it paints nothing, following Paint Fills, Paint Strokes and Shift; the Eyedropper with Alt; the crosshair with Use Precise Cursors. No cursor swatch preview |
|
||||
| Cursors of their own for Lasso, Magic Wand, the freehand tools, Shaper, Measure, Print Tiling, the symbolism tools, vertical type, Scissors (over a segment and away), Mesh and Puppet Warp | partial | each tool returns its own cursor and Use Precise Cursors turns them into the crosshair; until they're drawn they borrow the crosshair, the I-beam, the Pen's add cursor or not-allowed |
|
||||
@@ -620,6 +623,7 @@ before release (#6373). [Paint faces and edges](https://helpx.adobe.com/illustra
|
||||
| 2026-11-11 | minor | Files that record no units (PDF, EPS or `.ai` without ruler units, raster images, metafiles, Affinity files, importer plug-ins) open and revert in Preferences › Units › General instead of points; native, SVG and DXF files and `.ai`/EPS ruler units are kept (#5820). Scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | Blob Brush: while painting, the preview of a round tip is the outline of the area the stroke adds, round at both ends, as the stroke it commits (#4343). Scores unchanged (estimated). |
|
||||
| 2026-11-11 | minor | #6625: path and compound-path interior hits follow enabled non-None fill rows, including lower fills beneath a top None row; hidden-only interiors miss; zero-opacity fills remain selectable. Scores and estimates unchanged. |
|
||||
| 2026-11-11 | minor | Scissors hover and cuts share Pen-style path/align/intersect/anchor snapping (#6470), retaining view options, Alt Add Anchor and cut endpoint selection; headless tool and Session regressions referenced. Scores and estimates unchanged. |
|
||||
| 2026-11-10 | minor | Symbol libraries: Inventory Icons joins Basic Shapes, UI Frames and Map Markers as a fourth built-in library (Sword, Shield, Potion, Key, Gem; no default 9-slice). |
|
||||
| 2026-11-10 | minor | Held numeric spinner arrows keep stepping past the click timeout and stop on release (#6307). Scores and estimates unchanged. |
|
||||
| 2026-11-10 | minor | Vector Halftone Preview leaves the dots unobscured and keeps the selection box (#6369). Scores and estimates unchanged. |
|
||||
|
||||
Reference in New Issue
Block a user