G11: preserve explicit strokes when erasing ordinary filled open paths

This commit is contained in:
yoriswind
2026-11-11 12:08:18 -08:00
parent 77b795c2c4
commit f6c48fd86b
6 changed files with 388 additions and 22 deletions
+96 -7
View File
@@ -3,9 +3,10 @@ use super::common::{
samples_param, sibling_with, size_pressure, target_paths, usize_opt,
};
use super::{
Anchor, AnchorKind, Beside, BezPath, BoolOp, Cap, EngineError, FillRule, Join, NodeId, ParamCurve, PathData, Point, Result, Session, SubPath,
Value, bad, eraser_area, eraser_tip, f64_or, fill_contains, id_param, json, number_or, po,
Anchor, AnchorKind, Appearance, Arc, Beside, BezPath, BoolOp, Cap, Document, EngineError, FillRule, Join, Node, NodeId, NodeKind, ParamCurve,
PathData, Point, Result, Session, SubPath, Value, bad, eraser_area, eraser_tip, f64_or, fill_contains, id_param, json, number_or, po,
};
use vectorcraft_doc::AppearanceItem;
/// Split a filled path into connected pieces (each outer contour with its holes).
pub(in super::super) fn components(pd: &PathData) -> Vec<PathData> {
@@ -304,9 +305,27 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
Some(bp) => fill_contains(bp, FillRule::NonZero, q),
None => dist_to_polyline(&round, squash * q) <= r,
};
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
let mut plan = vec![];
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach), true)? {
let closed = pd.is_closed();
let node = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
let painted_stroke = node
.appearance
.items
.iter()
.any(|item| matches!(item, AppearanceItem::Stroke(stroke) if stroke.visible && !stroke.paint.is_none() && stroke.width > 0.0));
if !closed && has_fill(node) && painted_stroke && !needs_legacy_eraser(&st.doc, id) {
let fill_changed = po::area(&po::boolean(&pd, rule, &region, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) > 1e-6;
let stroke = erase_outline(&pd, short / 2.0, &under);
if fill_changed || stroke.is_some() {
// Fill closes open contours implicitly; a stroke must keep only the original
// explicit segments. Keep every stroke subpath together so its paint is applied once.
let fill = po::boolean(&pd, rule, &region, FillRule::NonZero, BoolOp::Difference);
let stroke = stroke.map_or(pd, |pieces| PathData::new(pieces.into_iter().flat_map(|piece| piece.subpaths).collect()));
plan.push((id, ErasedPieces::Paint { fill, stroke, rule }));
}
continue;
}
let single = pd.subpaths.len() == 1;
let filled = !closed && st.doc.node(id).is_some_and(has_fill) && po::area(&pd, rule) > 0.0;
// Fill implicitly closes an open contour. Keep zero-area open lines
@@ -338,13 +357,72 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
}
}
if changed {
plan.push((id, pieces));
plan.push((id, ErasedPieces::Geometry(pieces)));
}
}
apply_plan(s, "Eraser", plan)
}
fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, Vec<PathData>)>) -> Result<Value> {
enum ErasedPieces {
Geometry(Vec<PathData>),
Paint { fill: PathData, stroke: PathData, rule: FillRule },
}
/// Splitting paint changes effect seeds, item indices and geometry contexts. Keep targets
/// with visible effects of their own or on an ancestor on the existing route. Clipping-source
/// subtrees also stay there: groups change their mask geometry and do not supply clip paint.
fn needs_legacy_eraser(d: &Document, id: NodeId) -> bool {
let Some(ancestry) = d.ancestry(id) else { return true };
let mut parent: Option<&Node> = None;
for id in ancestry {
let Some(node) = d.node(id) else { return true };
if parent.is_some_and(|p| p.clips() && p.children().and_then(|children| children.first()).is_some_and(|first| first.id == id)) {
return true;
}
if node.appearance.effects.iter().any(|effect| effect.visible)
|| node.appearance.items.iter().any(|item| item.effects().iter().any(|effect| effect.visible))
{
return true;
}
parent = Some(node);
}
false
}
/// Paint fill and explicit stroke geometry in the original stack order, with object-level
/// transparency, effects and metadata on one wrapper rather than on each painted part.
fn separate_eraser_paints(d: &mut Document, id: NodeId, fill: PathData, stroke: PathData, rule: FillRule) -> Result<Node> {
let mut root = d.node(id).cloned().ok_or(EngineError::NoNode(id))?;
// Pin before the two geometries get different bounds, so their gradients stay in place.
root.pin_gradients();
let mut runs: Vec<Vec<AppearanceItem>> = vec![];
for item in &root.appearance.items {
if let Some(run) = runs.last_mut().filter(|run| run.first().is_some_and(|first| first.is_fill() == item.is_fill())) {
run.push(item.clone());
} else {
runs.push(vec![item.clone()]);
}
}
let mut children = vec![];
for items in runs {
let is_fill = items.first().is_some_and(AppearanceItem::is_fill);
let path = if is_fill { &fill } else { &stroke };
if path.is_empty() {
continue;
}
let mut child = Node::path(d.alloc_id(), path.clone(), Appearance { items, ..Default::default() });
if let NodeKind::Path { rule: child_rule, .. } = &mut child.kind {
*child_rule = if is_fill { FillRule::NonZero } else { rule };
}
children.push(Arc::new(child));
}
root.kind = NodeKind::Group { children, clip: false };
root.appearance.items.clear();
root.appearance.contents_index = None;
Ok(root)
}
fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, ErasedPieces)>) -> Result<Value> {
if plan.is_empty() {
return Ok(json!({ "ids": [] }));
}
@@ -352,7 +430,18 @@ fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, Vec<PathData>)>)
let mut all = vec![];
let mut cut = Beside::replacing(d, &plan.iter().map(|(id, _)| *id).collect::<Vec<_>>());
for (id, pieces) in plan {
all.extend(replace_with_pieces(d, &mut cut, id, pieces)?);
match pieces {
ErasedPieces::Geometry(pieces) => all.extend(replace_with_pieces(d, &mut cut, id, pieces)?),
ErasedPieces::Paint { fill, stroke, rule } => {
let root = separate_eraser_paints(d, id, fill, stroke, rule)?;
if root.children().is_some_and(Vec::is_empty) {
cut.put(d, id, vec![])?;
} else {
cut.put(d, id, vec![root])?;
all.push(id);
}
}
}
}
cut.finish(d)?;
sel.set(all.iter().copied());
@@ -373,7 +462,7 @@ pub(super) fn erase_segments(s: &mut Session, p: &Value) -> Result<Value> {
for id in target_paths(&st.doc, &st.selection, poly_bounds(&pts, w)) {
let (pd, _) = path_of(&st.doc, id)?;
if let Some(pieces) = erase_outline(&pd, w / 2.0, &|q| dist_to_polyline(&pts, q) <= w / 2.0) {
plan.push((id, pieces));
plan.push((id, ErasedPieces::Geometry(pieces)));
}
}
apply_plan(s, "Path Eraser", plan)
+279 -2
View File
@@ -30,6 +30,24 @@ fn paths(s: &Session) -> Vec<PathData> {
paths
}
/// Geometric area of paths that own a visible fill, excluding stroke-only children.
/// This does not infer inherited paint from compound paths or containers.
fn own_filled_path_area(s: &Session) -> f64 {
let mut area = 0.0;
s.doc().unwrap().doc.walk(|node| {
if let NodeKind::Path { path, rule, .. } = &node.kind
&& node
.appearance
.items
.iter()
.any(|item| matches!(item, vectorcraft_doc::AppearanceItem::Fill(fill) if fill.visible && !fill.paint.is_none()))
{
area += vectorcraft_pathops::area(path, *rule);
}
});
area
}
/// #6582: an open contour fills its implicitly closed area. Erasing a strip removes only that
/// strip, just as for the closed rectangle, rather than changing its fill to diagonal chords.
#[test]
@@ -141,7 +159,7 @@ fn eraser_keeps_mixed_fill_and_zero_area_strokes_with_one_undo() {
assert!(pixel[0] > 200 && pixel[1] < 60 && pixel[2] < 60 && pixel[3] > 200, "retained red stroke at ({x},{y}): {pixel:?}");
}
if filled_open {
let area: f64 = remaining.iter().map(|path| vectorcraft_pathops::area(path, FillRule::NonZero)).sum();
let area = own_filled_path_area(&s);
assert!((area - 9000.0).abs() < 1.0, "retained fill area {area}");
for (x, y) in [(110, 125), (190, 125), (110, 175), (190, 175)] {
assert!(image.pixel(x, y)[3] > 240, "retained fill pixel ({x},{y})");
@@ -279,10 +297,12 @@ fn eraser_cuts_the_outline_when_even_odd_cancels_an_open_paths_fill() {
assert!(original.subpaths.first().unwrap().signed_area().abs() > 10000.0);
assert!(vectorcraft_pathops::area(original, FillRule::EvenOdd) < 1e-9, "Even-Odd cancels the two laps");
assert!((original.length() - 800.0).abs() < 1e-9);
assert_eq!(render_erased(&s).pixel(150, 125)[3], 0, "the cancelled interior is transparent before Eraser");
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
let length: f64 = paths(&s).iter().map(PathData::length).sum();
assert!((length - 760.0).abs() < 0.1, "both laps lose their crossed stroke portions: {length}");
assert_eq!(render_erased(&s).pixel(150, 125)[3], 0, "Eraser does not paint the cancelled interior outside its sweep");
}
/// Hidden fills retain open outlines, while a lower visible fill beneath None still paints.
@@ -363,14 +383,271 @@ fn eraser_even_odd_cancellation_survives_beside_a_filled_subpath() {
assert_eq!(before.pixel(150, 125)[3], 0, "the twice-traced open subpath cancels under Even-Odd");
assert_eq!(before.pixel(150, 175)[3], 0, "the cancelled lower run is empty before Eraser");
assert!(before.pixel(250, 125)[3] > 240, "the disjoint open rectangle fills");
assert_eq!(before.pixel(230, 125), [0, 0, 0, 255], "the second contour has fill but no explicit left stroke");
assert_eq!(before.pixel(229, 125), [0, 0, 0, 0], "there is no stroke outside its implicit closing edge");
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [290, 150]], "size": 10})).unwrap();
let after = render(&s);
assert_eq!(after.pixel(150, 175)[3], 0, "the cancelled interior stays empty below the sweep");
assert!(after.pixel(250, 125)[3] > 240, "the disjoint filled subpath survives");
assert_eq!(after.pixel(250, 150)[3], 0, "the swept band through the filled subpath is empty");
for (x, y) in [(100, 125), (200, 125), (230, 125), (280, 125)] {
for (x, y) in [(230, 125), (229, 125)] {
assert_eq!(after.pixel(x, y), before.pixel(x, y), "the implicit closing edge stays unstroked at ({x},{y})");
}
for (x, y) in [(100, 125), (200, 125), (280, 125)] {
let pixel = after.pixel(x, y);
assert!(pixel[0] > 200 && pixel[1] < 60 && pixel[2] < 60 && pixel[3] > 200, "open outline survivor ({x},{y}): {pixel:?}");
}
}
#[test]
fn eraser_preserves_the_missing_edge_of_a_filled_open_stroke() {
let mut failures = vec![];
for (opacity, expected_alpha) in [(100, 255u8), (50, 128u8)] {
for closed in [true, false] {
let (mut s, id) = painted_open_rectangle(closed);
s.execute("transparency.set", &json!({"ids": [id.0], "opacity": opacity})).unwrap();
s.execute("select.none", &json!({})).unwrap();
let mut check = |ok: bool, message: String| {
if !ok {
failures.push(format!("closed={closed} opacity={opacity}: {message}"));
}
};
let before = render_erased(&s);
for y in [125, 175] {
check(before.pixel(150, y)[3].abs_diff(expected_alpha) <= 1, format!("original fill at y={y}: {:?}", before.pixel(150, y)));
}
let before_left = before.pixel(99, 125);
if closed {
check(before_left[0] > before_left[1] && before_left[3] > 0, format!("closed control's explicit red left edge: {before_left:?}"));
} else {
check(before_left[3] == 0, format!("open source has no implicit left stroke: {before_left:?}"));
}
let before_overlap = before.pixel(199, 125);
check(before_overlap[3].abs_diff(expected_alpha) <= 1, format!("object opacity is applied once before Eraser: {before_overlap:?}"));
check(before_overlap[0] > before_overlap[1] && before_overlap[3] > 0, format!("visible fill and red stroke overlap: {before_overlap:?}"));
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
let after = render_erased(&s);
for y in [125, 175] {
check(
after.pixel(150, y) == before.pixel(150, y),
format!("retained fill at y={y}: before {:?}, after {:?}", before.pixel(150, y), after.pixel(150, y)),
);
}
check(after.pixel(150, 150)[3] == 0, format!("Eraser band is empty: {:?}", after.pixel(150, 150)));
let after_left = after.pixel(99, 125);
check(after_left == before_left, format!("left-edge stroke: before {before_left:?}, after {after_left:?}"));
let after_overlap = after.pixel(199, 125);
check(after_overlap == before_overlap, format!("unaffected fill/stroke overlap: before {before_overlap:?}, after {after_overlap:?}"));
check(after_overlap[0] > after_overlap[1] && after_overlap[3] > 0, format!("explicit right stroke remains visible: {after_overlap:?}"));
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}
fn render_erased(s: &Session) -> vectorcraft_render::Rendered {
vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default())
}
fn painted_open_rectangle(closed: bool) -> (Session, NodeId) {
let mut s = session();
let id = NodeId(
s.execute(
"path.create",
&json!({"closed": closed, "anchors": [
{"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200}
]}),
)
.unwrap()["id"]
.as_u64()
.unwrap(),
);
s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#ff0000"})).unwrap();
s.execute("stroke.set", &json!({"ids": [id.0], "weight": 2})).unwrap();
(s, id)
}
fn assert_eraser_history(s: &mut Session, before: &serde_json::Value, before_selection: &vectorcraft_doc::Selection) {
let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
let after_selection = s.doc().unwrap().selection.clone();
let after_pixels = render_erased(s).pixels;
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), *before, "one Undo restores the exact source");
assert_eq!(s.doc().unwrap().selection, *before_selection);
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after, "one Redo restores the exact erased document");
assert_eq!(s.doc().unwrap().selection, after_selection);
assert_eq!(render_erased(s).pixels, after_pixels, "Redo restores the rendered appearance");
}
#[test]
fn eraser_keeps_object_metadata_and_mask_once_around_separate_fill_and_stroke() {
let (mut s, id) = painted_open_rectangle(false);
let mask = NodeId(s.execute("shape.rectangle", &json!({"x": 80, "y": 80, "width": 140, "height": 140})).unwrap()["id"].as_u64().unwrap());
s.execute("paint.setFill", &json!({"ids": [mask.0], "color": "#ffffff"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [mask.0], "none": true})).unwrap();
s.execute("transparency.makeOpacityMask", &json!({"ids": [id.0, mask.0]})).unwrap();
s.execute(
"transparency.set",
&json!({"ids": [id.0], "opacity": 50, "blend": "multiply", "isolate": true, "knockout": "off", "knockoutShape": true}),
)
.unwrap();
s.execute("attributes.set", &json!({"ids": [id.0], "note": "Eraser source", "showCenter": true})).unwrap();
// A stored object axis is independent of this axis-aligned fixture's geometry.
s.edit("Fixture metadata", |doc, _| {
let n = doc.node_mut(id).unwrap();
n.name = Some("Filled open stroke".into());
n.bbox_angle = 17.0;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
let original = s.doc().unwrap().doc.node(id).unwrap().clone();
let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
let before_selection = s.doc().unwrap().selection.clone();
let before_history = s.doc().unwrap().history.undo.len();
let before_image = render_erased(&s);
assert!(before_image.pixel(150, 125)[3].abs_diff(128) <= 1);
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), before_history + 1);
let root = s.doc().unwrap().doc.node(id).unwrap();
let NodeKind::Group { children, clip: false } = &root.kind else { panic!("fill and stroke share one ordinary object wrapper") };
assert_eq!(
(&root.name, root.opacity, root.blend, root.isolate, root.knockout, root.knockout_shape, root.bbox_angle),
(&original.name, original.opacity, original.blend, original.isolate, original.knockout, original.knockout_shape, original.bbox_angle)
);
assert_eq!(root.extras(), original.extras(), "the mask and Attributes remain on the object");
assert!(!children.is_empty());
for child in children {
assert!(child.name.is_none() && child.has_default_transparency(), "paint lanes do not repeat object metadata or transparency");
assert_eq!(child.bbox_angle, 0.0);
assert_eq!(child.extras(), &vectorcraft_doc::NodeExtras::default());
}
let after = render_erased(&s);
for (x, y) in [(99, 125), (150, 125), (150, 175), (199, 125)] {
assert_eq!(after.pixel(x, y), before_image.pixel(x, y), "object appearance outside the sweep at ({x},{y})");
}
assert_eq!(after.pixel(150, 150)[3], 0);
assert_eraser_history(&mut s, &before, &before_selection);
}
#[test]
fn eraser_keeps_a_painted_clipping_source_on_the_legacy_path_route() {
let mut results = vec![];
for closed in [true, false] {
let mut s = session();
let art = NodeId(s.execute("shape.rectangle", &json!({"x": 90, "y": 90, "width": 60, "height": 120})).unwrap()["id"].as_u64().unwrap());
s.execute("paint.setFill", &json!({"ids": [art.0], "color": "#ff0000"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [art.0], "none": true})).unwrap();
let clip = NodeId(
s.execute(
"path.create",
&json!({"closed": closed, "anchors": [
{"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200}
]}),
)
.unwrap()["id"]
.as_u64()
.unwrap(),
);
let group = NodeId(s.execute("object.clippingMask.make", &json!({"ids": [art.0, clip.0]})).unwrap()["id"].as_u64().unwrap());
s.execute("paint.setFill", &json!({"ids": [clip.0], "color": "#0000ff"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [clip.0], "color": "#00ff00"})).unwrap();
s.execute("stroke.set", &json!({"ids": [clip.0], "weight": 2})).unwrap();
s.execute("select.set", &json!({"ids": [clip.0]})).unwrap();
let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
let before_selection = s.doc().unwrap().selection.clone();
let image = render_erased(&s);
assert_eq!(image.pixel(110, 125), [255, 0, 0, 255], "clipped art paints above the clipping fill");
assert_eq!(image.pixel(180, 125), [0, 0, 255, 255], "clipping fill paints behind the art");
assert_eq!(image.pixel(199, 125), [0, 255, 0, 255], "clipping stroke paints over the fill");
assert_eq!(image.pixel(90, 125)[3], 0, "art outside the clip is hidden");
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
let doc = &s.doc().unwrap().doc;
let NodeKind::Group { children, clip: true } = &doc.node(group).unwrap().kind else { panic!("the clipping group is retained") };
let source = children.first().unwrap();
assert_eq!(source.id, clip);
assert!(matches!(source.kind, NodeKind::Path { .. }), "the actual clipping source stays a path");
let paint = source.clip_paint();
assert!(paint.fill.is_some() && paint.stroke.is_some(), "the clipping source keeps its fill and stroke paint");
assert_eq!(render_erased(&s).pixel(150, 150)[3], 0, "the clipping region loses the sweep band");
// Legacy fill Booleans close both source contours. This deliberately pins that existing
// painted-clip behavior against the unchanged closed-source route, not the ordinary fix.
results.push(render_erased(&s).pixels);
assert_eraser_history(&mut s, &before, &before_selection);
}
assert_eq!(results[0], results[1], "open clipping sources retain the existing closed-fill Boolean behavior");
}
#[test]
fn eraser_separates_an_ordinary_open_stroke_inside_a_clipping_group() {
let (mut s, art) = painted_open_rectangle(false);
let clip = NodeId(s.execute("shape.rectangle", &json!({"x": 80, "y": 80, "width": 140, "height": 140})).unwrap()["id"].as_u64().unwrap());
s.execute("object.clippingMask.make", &json!({"ids": [art.0, clip.0]})).unwrap();
s.execute("select.set", &json!({"ids": [art.0]})).unwrap();
let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
let before_selection = s.doc().unwrap().selection.clone();
let original_clip = s.doc().unwrap().doc.node(clip).unwrap().clone();
let before_image = render_erased(&s);
assert_eq!(before_image.pixel(99, 125)[3], 0);
assert_eq!(before_image.pixel(150, 125), [0, 0, 0, 255]);
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
assert_eq!(s.doc().unwrap().doc.node(clip).unwrap(), &original_clip, "the actual clipping source is untouched");
let after = render_erased(&s);
for (x, y) in [(99, 125), (150, 125), (150, 175), (199, 125)] {
assert_eq!(after.pixel(x, y), before_image.pixel(x, y), "ordinary clipped art retains its appearance at ({x},{y})");
}
assert_eq!(after.pixel(150, 150)[3], 0);
assert_eraser_history(&mut s, &before, &before_selection);
}
#[test]
fn eraser_keeps_a_live_outline_strokes_original_appearance_context() {
let mut results = vec![];
for closed in [true, false] {
let (mut s, id) = painted_open_rectangle(closed);
s.execute("stroke.set", &json!({"ids": [id.0], "weight": 10})).unwrap();
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "path.outlineStroke", "item": null, "params": {}})).unwrap();
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
let original = s.doc().unwrap().doc.node(id).unwrap();
assert_eq!(original.appearance.stroke().unwrap().width, 10.0);
assert!(original.appearance.effects.iter().any(|effect| effect.visible && effect.id == "path.outlineStroke"));
let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
let before_selection = s.doc().unwrap().selection.clone();
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
let after = render_erased(&s);
assert!(after.pixels.as_chunks::<4>().0.iter().any(|pixel| pixel[3] > 0), "the live effect still paints");
results.push(after.pixels);
assert_eraser_history(&mut s, &before, &before_selection);
}
// The legacy fill Booleans produce identical closed survivors and retain the 10 pt context.
assert_eq!(results[0], results[1], "an open source with a live effect retains the closed legacy rendering");
}
#[test]
fn eraser_preserves_a_translucent_fill_above_the_stroke() {
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{AppearanceItem, FillLayer};
let (mut s, id) = painted_open_rectangle(false);
s.edit("Fixture top fill", |doc, _| {
let node = doc.node_mut(id).unwrap();
assert!(matches!(node.appearance.items.last(), Some(AppearanceItem::Stroke(_))));
let mut fill = FillLayer::new(Paint::solid(Color::WHITE));
fill.opacity = 0.5;
node.appearance.items.push(AppearanceItem::Fill(fill));
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
let before = render_erased(&s);
let near = |actual: [u8; 4], expected: [u8; 4]| actual.iter().zip(expected).all(|(a, e)| a.abs_diff(e) <= 1);
assert!(near(before.pixel(199, 125), [255, 128, 128, 255]), "half-opacity white covers red: {:?}", before.pixel(199, 125));
assert!(near(before.pixel(150, 125), [128, 128, 128, 255]), "half-opacity white covers black: {:?}", before.pixel(150, 125));
assert_eq!(before.pixel(99, 125), [0, 0, 0, 0]);
s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap();
let after = render_erased(&s);
for (x, y) in [(199, 125), (150, 125), (99, 125)] {
assert_eq!(after.pixel(x, y), before.pixel(x, y), "paint order and item opacity survive at ({x},{y})");
}
assert_eq!(after.pixel(150, 150)[3], 0, "the swept band is empty");
}
+3 -3
View File
@@ -4,7 +4,7 @@
## Feature submission evidence
> **Eraser fill update (2026-11-11):** filled open paths and compound holes use filled-area cutting (#6582); stroke-closure follow-up remains open; scores and estimates unchanged.
> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged.
**Feature evidence last updated:** 2026-11-03.
@@ -307,7 +307,7 @@ macOS cursor delivery (#2292) is narrowed to a native host adapter using the exi
## G11 Correctness bugs in core tools
- **Improved (#6582):** the Eraser subtracts its swept area from filled open contours, preserving fill outside the stroke. Open compound members keep their holes under either fill rule; zero-area open lines keep outline splitting. Original engine integration regressions check rendered pixels, retained geometry, mixed paths and history. Review follow-up: filled open paths with a visible stroke can gain a stroke on their implicit closing edge; separate fill/stroke geometry and clipping-source handling remain unresolved. A single twice-traced contour with canceled Even-Odd fill can also reveal fill after outline splitting. Scores and estimates unchanged.
- **Improved (#6582):** the Eraser subtracts its swept area from filled open contours, preserving fill outside the stroke. Open compound members keep their holes under either fill rule; zero-area open lines keep outline splitting. Ordinary filled open paths with visible strokes keep separate fill and explicit-stroke geometry in their original paint order, preserving missing closing edges, Even-Odd cancellation and object opacity. Thirteen engine integration regressions check rendered pixels, geometry, paint order, masks, mixed paths and history. Clipping-source subtrees and paths with visible appearance effects on themselves or an ancestor retain the existing route; its stroke-closure and canceled-fill limitations remain open pending the scope decision. Scores and estimates unchanged.
- **Export-only improvement (#6309):** 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. Broader G11 scope, scores and estimates unchanged.
@@ -861,7 +861,7 @@ trap, and the defaults (0.25 pt, 100%, 40%) are VectorCraft's own, the pages giv
| 2026-11-11 | minor | G5: built-in Energy Beams brush library (Laser Bolt, Plasma Arc, Charge Wave, Spark Trail); Missing trimmed; estimate 5–15 → 4–14 h; MCP Brush libraries list Energy Beams. |
| 2026-11-11 | minor | G5: built-in Skill Icons symbol library (Attack, Defend, Heal, Buff, Ult); Missing trimmed; estimate 6–16 → 5–15 h; MCP Symbol libraries list Skill Icons. |
| 2026-11-10 | minor | G6: MCP catalogue (#6460): headless lists `UI_COMMANDS` (`ui: true`), eight prompts, effect vs command ids, 33 tools, commands/reference; estimate unchanged. |
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; zero-area open lines retain outline splitting (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | G5: built-in Status Effects graphic style library (Poison Tint, Freeze Edge, Burn Aura, Stun Pulse, Stealth Fade, Shield Buff); Missing trimmed; estimate 7–17 → 6–16 h; MCP docs list UI Frames and Map Markers under Symbol libraries. |
| 2026-11-11 | minor | G5: built-in Inventory Icons symbol library (Sword, Shield, Potion, Key, Gem; no default 9-slice); Missing trimmed; estimate 8–18 → 7–17 h. |
| 2026-11-10 | minor | G4 type: Edit › Edit Custom Dictionary… adds, deletes and changes the custom dictionary's words, #4936; the Check Spelling dialog remains; scores and estimates unchanged. |
+3 -3
View File
@@ -4,7 +4,7 @@
>
> Vector Halftone preview update (2026-11-10): temporary dot selection marks are hidden, and the bounding box stays available (#6369).
>
> **Eraser fill update (2026-11-11):** filled open paths and compound holes use filled-area cutting (#6582); stroke-closure follow-up remains open; scores and estimates unchanged.
> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged.
>
> **Flyout update:** 2026-11-06 — resizable icon-strip flyouts and bottom-aligned panel footers (#5713); scores and estimates unchanged.
>
@@ -55,7 +55,7 @@ M7 type: Touch Type moves a right-to-left character along its line and up from i
| 2026-11-08 | minor | Character Styles panel: a double-click on a user style's row opens its Character Style Options (`ui.charStyleOptions`); the dialog keeps a fixed width and scrolls its sections in a shorter window, so OK and Cancel stay on screen. Tests `panels::text_styles::tests::double_clicking_a_character_style_row_opens_its_options` and `dialogs::char_style_options::tests::the_sections_scroll_in_a_window_shorter_than_the_general_list`. Scores and estimates unchanged. |
| 2026-11-08 | minor | #3380, deletion only: preserve gradient placement and exact surviving geometry; consume owned subpaths with a shared original-node snapshot; consolidate status/evidence and document command/helper contracts. Compound behavior and the existing M2 status entry are retained. Endpoint highlighting remains open; scores and estimates unchanged. |
| 2026-11-10 | minor | M13 / G6: MCP catalogue (#6460): headless lists UI commands, eight prompts, 33 tools, effect vs command ids; scores and estimates unchanged. |
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; zero-area open lines retain outline splitting (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. |
| 2026-11-07 | minor | #3380 (deletion only): independent surviving path objects; transformed appearance, stacking, selection, cubic handles and Undo/Redo covered by `delete_path_pieces`; compound semantics retained. Endpoint highlighting remains open; scores and estimates unchanged. |
| 2026-11-02 | minor | Selection QoL: saved marquee modes, screen drag direction with a 3 px dead zone, and translated mode/E feedback (#5313); VectorCraft addition, scores and estimates unchanged. |
| 2026-11-07 | minor | Indian-language hyphenation (#4947): eleven MIT-licensed pattern sets, with grapheme and shaping-cluster protection in both composers and existing paragraph limits. Assamese and Sanskrit are selectable; Sanskrit automatic patterns remain pending an allowlisted source. Scores and estimates unchanged. |
@@ -144,7 +144,7 @@ native wording review, layout checks and a web Devanagari font remain. [Notes](l
|---|---|---|---|
| M0 | Skeleton + vertical slice | ✅ done | — |
| M1 | Selection, transform, layers, MCP (common command tools, strict keys, session resources and version-aware result hints) | ✅ mostly done (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 its sweep on open paths and keeps compound holes (#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 its sweep on open paths and keeps compound holes and ordinary explicit strokes; clipping-source/live-effect follow-up remains open (#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 |
| M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Eyedropper styles highlighted text only (atomic transparency rejection); Eyedropper reads visible locked and outside-isolation sources (#1251); Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork (screen-bounded Edit chip list, #3416); 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 | 4–8 |
| M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | 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 | 3–6 (existing scope; Affinity export unestimated) |
| M5 | Performance | 🟡 background render + caches + MT done; `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 |
+4 -4
View File
@@ -4,7 +4,7 @@
>
> Vector Halftone preview update (2026-11-10): temporary dot selection marks are hidden, and the bounding box stays available (#6369).
>
> **Eraser fill update (2026-11-11):** filled open paths and compound holes use filled-area cutting (#6582); stroke-closure follow-up remains open; scores and estimates unchanged.
> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged.
>
> **Flyout update:** 2026-11-06 — resizable icon-strip flyouts and bottom-aligned panel footers (#5713); scores and estimates unchanged.
@@ -217,7 +217,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; 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; Eraser preserves filled open-path area outside its sweep, including compound holes and mixed stroked lines (#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; Eraser preserves ordinary filled open-path area and explicit strokes outside its sweep, including compound holes and mixed stroked lines; clipping-source/live-effect correction remains open (#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) |
| Colour, swatches, gradients, patterns, mesh, recolor | 7 | 92% | 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 |
| Strokes, brushes, width profiles | 5 | 88% | Shift-double-click adjoining adjustment is implemented; brush libraries are done (six generated libraries including Game Trails and Energy Beams, 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) |
@@ -945,7 +945,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
While a spiral is dragged out, Alt adds or removes whole winds of four segments and Ctrl/Cmd changes the decay. The spiral's inner end keeps the distance from the center it had on the first modified drag event, while the outer end follows the pointer. The [default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) (archived copy) list Alt-drag to add or subtract winds and Ctrl-drag to change the decay rate; [Draw spirals](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-spirals.html) defines four segments per full wind and Decay as the amount each wind decreases. An 80% spiral has 80% of its outer radius after four segments; newly drawn spirals with the same settings wind more broadly than in earlier VectorCraft builds. Rounding the fitted count to whole winds from the count on the first Alt-only drag event, the held inner radius, the ranges (2…1000 segments, 5…99.99 % decay), Ctrl/Cmd taking precedence when both are held, and the new values staying as Spiral tool options are our own rules. Switching back to Alt uses the current count as its new base while keeping the held inner end.
Escape while an arc, spiral or grid is dragged out cancels it and puts back the options its keys, Alt and Ctrl/Cmd changed (slope, open or closed, base axis, segments, decay, dividers and skews), so the next drag and the tool's options start from the values before the canceled drag; a drag that is let go keeps them, and an option set with `tool.setOption` during the drag stays. This is VectorCraft's own rule.
- **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
The Eraser cuts filled open contours as areas (#6582), retaining fill outside its sweep; cut filled pieces are closed as for closed input. Open compound members are cut together under their compound fill rule so holes stay empty. Zero-area open lines retain outline splitting, including lines alongside filled contours in one path. `crates/engine/tests/eraser_open_fill.rs` checks original open/closed shapes, retained/erased pixels, self-crossing fill, compound holes, mixed strokes and Undo/Redo. A confirmed review regression remains: closing filled open pieces can add a stroke on the original implicit closing edge; the stroke/clipping follow-up and single-contour canceled-fill limitation remain open. Scores and hours are unchanged.
The Eraser cuts filled open contours as areas (#6582), retaining fill outside its sweep. Open compound members are cut together under their compound fill rule so holes stay empty. Ordinary filled open paths keep closed fill geometry separate from their original explicit stroke segments, with the original paint order and object transparency on one wrapper. Canceled Even-Odd fill stays empty; zero-area open lines retain outline splitting. Thirteen tests in `crates/engine/tests/eraser_open_fill.rs` check open/closed shapes, retained/erased pixels, self-crossing fill, compound holes, missing stroke edges, object/item opacity, masks, mixed strokes and Undo/Redo. Painted clipping-source subtrees and paths with visible self/ancestor appearance effects deliberately retain the legacy route; that route can still add closing-edge strokes or reveal canceled fill. Their broader correction remains an open scope decision. Scores and hours are unchanged.
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.
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.
Alt-drag with the Knife cuts in a straight line, and Shift+Alt-drag cuts at 45° or 90°, as [Cut objects using the Knife and Scissors tools](https://web.archive.org/web/20260926095638/https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/cut-objects.html) and [Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) describe. Alt counts only when held at the press; the dashed line runs from the press point to the pointer, stays straight after Alt is let go, and release sends `path.knife` with those two points. Alt pressed after the press leaves the cut freehand. Shift+Alt keeps the endpoint at 45° steps from the horizontal and vertical, whatever the Constrain Angle.
@@ -1982,7 +1982,7 @@ Edit › Copy and Cut put the selected ruler guides on the clipboard, with the s
| 2026-11-11 | minor | Bundled content: built-in Energy Beams brush library (Laser Bolt, Plasma Arc, Charge Wave, Spark Trail); brush libraries evidence updated; ~44% → ~46%; more built-in brush libraries remain. |
| 2026-11-11 | minor | Bundled content: built-in Skill Icons symbol library (Attack, Defend, Heal, Buff, Ult); symbol libraries evidence updated; ~42% → ~44%; more built-in symbol libraries remain. |
| 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-11 | minor | Eraser: filled open contours and compound holes use area cutting; zero-area open lines retain outline splitting (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | Bundled content: built-in Status Effects graphic style library; style libraries evidence updated; ~40% → ~42%; MCP Symbol libraries list UI Frames and Map Markers; more built-in graphic-style libraries remain. |
| 2026-11-11 | minor | Bundled content: built-in Inventory Icons symbol library (Sword, Shield, Potion, Key, Gem); symbol libraries evidence updated; ~38% → ~40%; more built-in symbol libraries remain. |
| 2026-11-10 | minor | Type advanced: the Edit Custom Dictionary dialog, #4936; evidence added; the Check Spelling dialog remains; scores and hours unchanged. |
+3 -3
View File
@@ -4,7 +4,7 @@
>
> Vector Halftone preview update (2026-11-10): temporary dot selection marks are hidden, and the bounding box stays available (#6369).
>
> **Eraser fill update (2026-11-11):** filled open paths and compound holes use filled-area cutting (#6582); stroke-closure follow-up remains open; scores and estimates unchanged.
> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged.
>
> Numeric spinner update (2026-11-10): held mouse arrows repeat past the click timeout; scores and estimates unchanged (#6307).
@@ -160,7 +160,7 @@ tools, never checked side by side) isn't captured row by row.
| Anchor Point and Curvature tools' own cursors | done | the caret on the anchor it converts; the pen nib with a curve badge |
| Free Transform's Cmd/Ctrl side-shear cursor | done | two arrows passing along the side (ShearH, ShearV), instead of the resize arrow across it |
| Cursors of their own for Lasso, Magic Wand, the freehand tools, Shaper, Live Paint Bucket, 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 |
| Eraser: filled open paths and compound holes | partial | Area cutting preserves fill outside the swept region (#6582); zero-area open lines retain outline splitting. Original engine integration regressions cover rendered pixels, geometry, holes and mixed strokes. Stroke closure and canceled-fill follow-ups remain open; see G11 in [gaps.md](gaps.md#g11-correctness-bugs-in-core-tools). |
| Eraser: filled open paths and compound holes | partial | Area cutting preserves fill outside the swept region (#6582). Ordinary filled open paths preserve explicit strokes, paint order, opacity and canceled fill with separate fill/stroke geometry; zero-area open lines retain outline splitting. Thirteen engine integration tests cover rendered pixels, geometry, holes, masks, mixed strokes and history. Clipping-source/live-effect correction remains open; see G11 in [gaps.md](gaps.md#g11-correctness-bugs-in-core-tools). |
| Blob Brush and Eraser: the tip's outline at the pointer | done | before a press and while painting, the outline of the tip (its size, angle and roundness, at the zoom) follows the pointer, black on a white halo, round a small centre dot; `[` / `]` and Tool Options change it at once; precise cursors (Caps Lock) show only the crosshair; it goes when the pointer leaves the canvas, while Cmd/Ctrl lends a selection tool and while Alt lends the Blob Brush the Smooth tool (#4977); `crates/tools/src/draw2/gesture.rs` and its tests While the button is down a round Blob Brush shows the outline of the area it will add, rounded at both ends, not a line as wide as the brush that ends square (#4343). |
| Busy cursor during long operations | done | Background open, save and export show the system progress cursor (gap G1) |
| Each anchor snaps to Smart Guides and construction angles | done | `DrawSnap` |
@@ -514,7 +514,7 @@ separate. Scores and hours unchanged. [Behavior and command details](development
| Date | Change | Summary |
|---|---|---|
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; zero-area open lines retain outline splitting (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. |
| 2026-11-11 | minor | Outline view: a click on a path's outline selects it through an image or a gradient mesh in front, which Outline draws as a frame or mesh lines (#6437). |
| 2026-11-11 | minor | A middle-click on a document tab (or its ×) closes it as the × does; closing a document's last view with unsaved changes asks to save first (#6506). VectorCraft addition; scores and estimates unchanged. |
| 2026-11-03 | minor | A double-click on a ruler adds a guide at the pointer (#5239): a vertical one on the top ruler, a horizontal one on the left ruler; scores and estimates unchanged. |