Merge remote-tracking branch 'origin/main' into fix/6969-rasterize-gray

# Conflicts:
#	docs/target-app-parity.md
This commit is contained in:
Sven Lafebre
2026-11-12 23:55:52 +01:00
108 changed files with 3751 additions and 461 deletions
+36
View File
@@ -529,6 +529,42 @@ fn a_spread_gradient_expands_into_whole_bands_for_each_run() {
}
}
/// A gradient that repeats across a box in more runs than are written (700 runs of 0.2 pt) is not
/// expanded into its first runs and a flat last color: the fill stays a gradient, and the rest of
/// the object (its stroke) still expands. `object.expand.info` reports no gradient or fill to
/// expand, and Expand with only Fill on reports nothing to expand; the same gradient in 70 runs
/// (10 repeats) reports both.
#[test]
fn a_spread_gradient_with_more_runs_than_written_stays_a_gradient() {
let gradient = |repeats: u32| {
json!({"kind": "linear", "spread": "repeat", "repeats": repeats, "start": [30, 100], "end": [50, 100],
"stops": [{"offset": 0, "color": "#ffff00"}, {"offset": 1, "color": "#004080"}]})
};
for (repeats, expands) in [(10, true), (100, false)] {
let mut s = session();
gradient_rect(&mut s, Rect::new(30.0, 40.0, 170.0, 160.0), gradient(repeats), true);
let info = s.execute("object.expand.info", &json!({})).unwrap();
assert_eq!(
(info["gradient"].clone(), info["fill"].clone(), info["stroke"].clone()),
(json!(expands), json!(expands), json!(true)),
"{repeats}"
);
let only_fill = s.execute("object.expand", &json!({"object": false, "stroke": false}));
assert_eq!(only_fill.is_ok(), expands, "{repeats}: {only_fill:?}");
}
for to in [json!({"steps": 240}), json!({"gradient": "mesh"})] {
let mut s = session();
gradient_rect(&mut s, Rect::new(30.0, 40.0, 170.0, 160.0), gradient(100), true);
let before = render(&s);
run(&mut s, "object.expand", to.clone());
let after = render(&s);
assert!(mean_diff(&before, &after) < 2.0, "{to}: {}", mean_diff(&before, &after));
let mut gradients = 0;
s.doc().unwrap().doc.walk(|n| gradients += usize::from(matches!(n.appearance.fill_paint(), Paint::Gradient(_))));
assert_eq!(gradients, 1, "{to}");
}
}
#[test]
fn the_mesh_option_makes_a_mesh_that_paints_the_gradient() {
for gradient in [
+10 -1
View File
@@ -1102,6 +1102,13 @@ fn document_replies_leave_out_paths_outside_the_read_roots() {
s.execute("variable.define", &json!({"name": "Photo", "kind": "image"})).unwrap();
s.execute("dataset.new", &json!({"name": "Row", "values": {"Photo": pic}})).unwrap();
let image = r["ids"][0].as_u64().unwrap();
// A linked JavaScript file outside the read roots, and one given as a URL.
let script = away.file("menu.js");
write(&script, b"void 0;");
let url = "https://example.com/scripts/menu.js";
for file in [script.as_str(), url] {
s.execute("svgInteractivity.addFile", &json!({"file": file})).unwrap();
}
let poster = away.file("poster.vectorcraft");
save(&mut s, &poster);
// The folder Export for Screens wrote to, and a pattern of the linked image being edited: its
@@ -1124,11 +1131,13 @@ fn document_replies_leave_out_paths_outside_the_read_roots() {
assert!(model.contains(&format!("\"path\":\"{name}\"")), "{name}: {model}");
}
assert!(model.contains("{\"image\":\"photo.png\"}"), "{model}");
assert!(model.contains(&format!("\"svg_scripts\":[\"menu.js\",\"{url}\"]")), "{model}");
// The document keeps its links, and a caller whose read roots hold the files sees every path.
assert_eq!(placed(&s, id).link.path, src);
assert_eq!(s.doc().unwrap().doc.svg_scripts, [script.as_str(), url]);
for model in [ask(&mut s, &away.0, "document.json"), s.execute("document.json", &json!({})).unwrap()] {
let model = model.to_string();
for path in [&src, &pic, &out] {
for path in [&src, &pic, &out, &script] {
assert!(model.contains(&json!(path).to_string()), "{path}: {model}");
}
}
+21
View File
@@ -722,6 +722,27 @@ fn expanding_a_gradient_fill_keeps_each_piece_s_own_paint() {
}
}
/// `object.expand.info` measures each piece a painted effect returns: a piece whose repeating
/// gradient needs more runs across it than are written (1,000) reports no gradient to expand, as
/// Expand leaves it a gradient, and the same gradient in 10 runs reports one.
#[test]
fn expand_info_measures_the_gradient_on_each_painted_piece() {
for (end, expands) in [(120.0, true), (100.2, false)] {
let mut s = session();
let id = rect(&mut s, 10.0, "#ff0000");
let gradient = json!({"kind": "linear", "spread": "repeat", "repeats": 10, "start": [100, 50], "end": [end, 50]});
run(&mut s, "paint.setFill", json!({"ids": [id.0], "gradient": gradient}));
let out = json!({"objects": [{"path": square_at(100.0)}]}).to_string();
install_wat(&mut s, &tpl::returning(&painting("test.engine.expandruns", true), &out));
run(&mut s, "effect.apply", json!({"ids": [id.0], "effect": "plugin.test.engine.expandruns"}));
run(&mut s, "select.set", json!({"ids": [id.0]}));
let info = s.execute("object.expand.info", &json!({})).unwrap();
assert_eq!((info["gradient"].clone(), info["fill"].clone()), (json!(expands), json!(expands)), "{end}");
let only_fill = s.execute("object.expand", &json!({"object": false, "fill": true, "stroke": false}));
assert_eq!(only_fill.is_ok(), expands, "{end}: {only_fill:?}");
}
}
/// Object › Expand of a pattern fill works piece by piece: a piece that keeps the pattern has its
/// tiles expanded, and a piece with a paint of its own keeps that paint.
#[test]
+34 -3
View File
@@ -581,11 +581,13 @@ fn set_bounds_measures_paths_turned_together_square_to_their_box() {
fn a_size_below_what_the_kept_strokes_of_several_paths_add_gives_them_no_width() {
// With no width, the paths have a visual box 10 pt wide, the width of the thick stroke. A width
// of 0 or more below 10 gives both paths no width, and the left edge of the visual box stays at
// -2. A negative width turns the paths over, as it does one path.
// -2. With no width each path turns back at its top and bottom, where the miter join bevels,
// so the visual box runs from y 100 to 150. A negative width turns the paths over, as it does
// one path.
let mut wrong = vec![];
for (width, paths, visual) in [
(8.0, [Rect::new(3.0, 100.0, 3.0, 150.0); 2], Rect::new(-2.0, 95.0, 8.0, 155.0)),
(0.0, [Rect::new(3.0, 100.0, 3.0, 150.0); 2], Rect::new(-2.0, 95.0, 8.0, 155.0)),
(8.0, [Rect::new(3.0, 100.0, 3.0, 150.0); 2], Rect::new(-2.0, 100.0, 8.0, 150.0)),
(0.0, [Rect::new(3.0, 100.0, 3.0, 150.0); 2], Rect::new(-2.0, 100.0, 8.0, 150.0)),
(-37.0, [Rect::new(-44.0, 100.0, 0.0, 150.0), Rect::new(-44.0, 100.0, -13.2, 150.0)], Rect::new(-49.0, 95.0, 1.0, 155.0)),
] {
let (mut s, ids) = thin_and_thick();
@@ -666,6 +668,35 @@ fn set_bounds_gives_a_butt_path_with_slanted_corners_the_size_out_of_proportion(
assert!((v.width() - 60.0).abs() < 1e-6 && (v.height() - 20.0).abs() < 1e-6, "{v:?}");
}
#[test]
fn set_bounds_gives_a_closed_path_with_beveled_or_mitered_corners_the_size_out_of_proportion() {
// The bevel at the triangle's tip, the miter the limit bevels there and the miter spikes it
// keeps reach past the path by margins that follow the slanted segments' directions, which a
// scale out of proportion changes. The miter spikes of a stroke whose dashes have round or
// projecting caps reach past the path too.
let mut wrong = vec![];
for (join, limit, cap, dash) in [
("bevel", 10.0, "round", Value::Null),
("miter", 2.0, "round", Value::Null),
("miter", 10.0, "round", Value::Null),
("miter", 10.0, "round", json!([6, 3])),
("miter", 10.0, "projecting", json!([6, 3])),
] {
let mut s = session();
let anchors = json!([{"x": 100, "y": 150}, {"x": 110, "y": 100}, {"x": 120, "y": 150}]);
let id = NodeId(run(&mut s, "path.create", json!({"anchors": anchors, "closed": true}))["id"].as_u64().unwrap());
run(&mut s, "stroke.set", json!({"weight": 2, "cap": cap, "join": join, "miterLimit": limit, "dash": dash}));
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.setBounds", json!({"width": 60, "height": 20, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&[id]).unwrap();
if (v.width() - 60.0).abs() > 1e-6 || (v.height() - 20.0).abs() > 1e-6 {
wrong.push(format!("{join} {limit} {cap} {dash}: {v:?}"));
}
}
assert!(wrong.is_empty(), "{wrong:?}");
}
#[test]
fn set_bounds_gives_a_symbol_instance_of_a_diagonal_butt_line_the_size_out_of_proportion() {
let mut s = session();