mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-16 03:51:16 +00:00
With span: "selection", paint.setStroke placed the gradient on the union of each target's topmost stroke box, also when `item` named a lower stroke, including an aligned row of a graph design's art. With a 40 pt lower stroke under a 1 pt topmost one, the gradient reached 0.5 pt past the objects instead of 20 pt. Each target's box is now that of the row it edits.
175 lines
7.7 KiB
Rust
175 lines
7.7 KiB
Rust
//! `paint.setFill` / `paint.setStroke` `span: "selection"`: one gradient placed on the union of
|
||
//! the targets' bounds, so the ramp runs across them (#2127).
|
||
|
||
use serde_json::{Value, json};
|
||
use vectorcraft_color::{GradientPaint, Paint};
|
||
use vectorcraft_geom::{Affine, Point};
|
||
|
||
use crate::*;
|
||
|
||
fn session() -> Session {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 400, "height": 200})).unwrap();
|
||
s
|
||
}
|
||
|
||
fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64) -> NodeId {
|
||
let r = s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap();
|
||
NodeId(r["id"].as_u64().unwrap())
|
||
}
|
||
|
||
fn fill_gradient(s: &Session, id: NodeId) -> GradientPaint {
|
||
match s.doc().unwrap().doc.node(id).unwrap().appearance.fill_paint() {
|
||
Paint::Gradient(g) => *g,
|
||
p => panic!("expected a gradient fill, got {p:?}"),
|
||
}
|
||
}
|
||
|
||
fn stroke_gradient(s: &Session, id: NodeId) -> GradientPaint {
|
||
match &s.doc().unwrap().doc.node(id).unwrap().appearance.stroke().unwrap().paint {
|
||
Paint::Gradient(g) => (**g).clone(),
|
||
p => panic!("expected a gradient stroke, got {p:?}"),
|
||
}
|
||
}
|
||
|
||
fn near(a: Point, b: Point) -> bool {
|
||
(a - b).hypot() < 1e-6
|
||
}
|
||
|
||
fn black_to_white() -> Value {
|
||
json!({"kind": "linear", "stops": [{"offset": 0, "color": "#000000"}, {"offset": 1, "color": "#ffffff"}]})
|
||
}
|
||
|
||
/// The red channel of the rendered document at (x, y).
|
||
fn red_at(s: &Session, x: u32, y: u32) -> u8 {
|
||
let doc = s.doc().unwrap().doc.clone();
|
||
let img = vectorcraft_render::Renderer::new().render(&doc, 400, 200, Affine::IDENTITY, &Default::default());
|
||
img.pixel(x, y)[0]
|
||
}
|
||
|
||
#[test]
|
||
fn a_linear_gradient_spans_the_union_of_the_targets() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 50.0, 100.0, 100.0);
|
||
let b = rect(&mut s, 100.0, 0.0, 100.0, 200.0);
|
||
let c = rect(&mut s, 300.0, 50.0, 100.0, 100.0);
|
||
s.execute("paint.setFill", &json!({"ids": [a.0, b.0, c.0], "gradient": black_to_white(), "span": "selection"})).unwrap();
|
||
// One vector for all three, across the union 0..400 × 0..200 at angle 0.
|
||
for id in [a, b, c] {
|
||
let g = fill_gradient(&s, id);
|
||
let geom = g.geom.expect("placed in document coordinates");
|
||
assert!(near(geom.start, Point::new(0.0, 100.0)) && near(geom.end, Point::new(400.0, 100.0)), "{id:?}: {geom:?}");
|
||
}
|
||
// The ramp runs on across the objects: dark on the left one, light on the right one, and the
|
||
// edge the first two share is the same colour on both sides.
|
||
let (left, right) = (red_at(&s, 5, 100), red_at(&s, 395, 100));
|
||
assert!(left < 20 && right > 235, "{left} {right}");
|
||
let (edge_a, edge_b) = (i32::from(red_at(&s, 98, 100)), i32::from(red_at(&s, 102, 100)));
|
||
assert!((edge_a - edge_b).abs() <= 4 && (50..80).contains(&edge_a), "{edge_a} {edge_b}");
|
||
}
|
||
|
||
#[test]
|
||
fn without_span_each_object_fits_its_own_box() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 50.0, 100.0, 100.0);
|
||
let b = rect(&mut s, 100.0, 50.0, 100.0, 100.0);
|
||
for span in [json!(null), json!("object")] {
|
||
let mut p = json!({"ids": [a.0, b.0], "gradient": black_to_white()});
|
||
if !span.is_null() {
|
||
p["span"] = span;
|
||
}
|
||
s.execute("paint.setFill", &p).unwrap();
|
||
assert_eq!(fill_gradient(&s, a).geom, None);
|
||
// Each ramp starts dark again on its own object.
|
||
assert!(red_at(&s, 102, 100) < 20, "{p}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn the_selection_is_the_default_target_and_angle_and_radial_are_kept() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
|
||
let b = rect(&mut s, 200.0, 100.0, 100.0, 100.0);
|
||
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
|
||
let mut g = black_to_white();
|
||
g["angle"] = json!(-90);
|
||
s.execute("paint.setFill", &json!({"gradient": g, "span": "selection"})).unwrap();
|
||
// Vertical, top to bottom, over the union 0..300 × 0..200.
|
||
let geom = fill_gradient(&s, b).geom.unwrap();
|
||
assert!(near(geom.start, Point::new(150.0, 0.0)) && near(geom.end, Point::new(150.0, 200.0)), "{geom:?}");
|
||
assert_eq!(fill_gradient(&s, a).geom, Some(geom));
|
||
// Radial: centred on the union, radius half its larger side, aspect kept.
|
||
s.execute("paint.setFill", &json!({"gradient": {"kind": "radial", "aspect": 50, "stops": black_to_white()["stops"]}, "span": "selection"}))
|
||
.unwrap();
|
||
let geom = fill_gradient(&s, a).geom.unwrap();
|
||
assert!(near(geom.start, Point::new(150.0, 100.0)), "{geom:?}");
|
||
assert!(((geom.end - geom.start).hypot() - 150.0).abs() < 1e-6, "{geom:?}");
|
||
assert!((geom.aspect - 0.5).abs() < 1e-9, "{geom:?}");
|
||
assert_eq!(fill_gradient(&s, b).geom, Some(geom));
|
||
}
|
||
|
||
#[test]
|
||
fn strokes_span_the_targets_too() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 50.0, 100.0, 100.0);
|
||
let b = rect(&mut s, 300.0, 50.0, 100.0, 100.0);
|
||
s.execute("paint.setStroke", &json!({"ids": [a.0, b.0], "gradient": black_to_white(), "span": "selection"})).unwrap();
|
||
let (ga, gb) = (stroke_gradient(&s, a).geom.unwrap(), stroke_gradient(&s, b).geom.unwrap());
|
||
assert_eq!(ga, gb);
|
||
assert!(ga.start.x < 0.0 && ga.end.x > 400.0, "the stroke's box, half its weight out: {ga:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_lower_stroke_row_spans_the_box_that_row_paints() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 50.0, 100.0, 100.0);
|
||
let b = rect(&mut s, 300.0, 50.0, 100.0, 100.0);
|
||
// [Fill, Stroke 40 pt, Stroke 1 pt] on both.
|
||
s.execute("appearance.addStroke", &json!({"ids": [a.0, b.0]})).unwrap();
|
||
s.execute("stroke.set", &json!({"ids": [a.0, b.0], "item": 1, "weight": 40})).unwrap();
|
||
for aligned in [false, true] {
|
||
s.execute("paint.setStroke", &json!({"ids": [a.0, b.0], "item": 1, "aligned": aligned, "gradient": black_to_white(), "span": "selection"}))
|
||
.unwrap();
|
||
for id in [a, b] {
|
||
let Paint::Gradient(g) = &s.doc().unwrap().doc.node(id).unwrap().appearance.stroke_at(Some(1)).unwrap().paint else {
|
||
panic!("expected a gradient on stroke row 1")
|
||
};
|
||
// The 40 pt row reaches 20 pt past the union 0..400, not the 1 pt topmost stroke's 0.5 pt.
|
||
let geom = g.geom.expect("placed in document coordinates");
|
||
assert!(near(geom.start, Point::new(-20.0, 100.0)) && near(geom.end, Point::new(420.0, 100.0)), "aligned {aligned}, {id:?}: {geom:?}");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn the_new_art_default_stays_unplaced() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
|
||
s.execute("paint.setFill", &json!({"ids": [a.0], "gradient": black_to_white(), "span": "selection"})).unwrap();
|
||
s.execute("select.set", &json!({"ids": []})).unwrap();
|
||
let n = rect(&mut s, 200.0, 0.0, 50.0, 50.0);
|
||
assert_eq!(fill_gradient(&s, n).geom, None, "the next object fits the gradient to itself");
|
||
}
|
||
|
||
#[test]
|
||
fn bad_spans_are_refused_and_change_nothing() {
|
||
let mut s = session();
|
||
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
|
||
let b = rect(&mut s, 200.0, 0.0, 100.0, 100.0);
|
||
let before = s.doc().unwrap().doc.clone();
|
||
let mut with_vector = black_to_white();
|
||
with_vector["start"] = json!([0, 0]);
|
||
with_vector["end"] = json!([10, 0]);
|
||
for bad in [
|
||
json!({"ids": [a.0, b.0], "gradient": black_to_white(), "span": "page"}),
|
||
json!({"ids": [a.0, b.0], "gradient": black_to_white(), "span": true}),
|
||
json!({"ids": [a.0, b.0], "color": "#ff0000", "span": "selection"}),
|
||
json!({"ids": [a.0, b.0], "gradient": {"kind": "freeform"}, "span": "selection"}),
|
||
json!({"ids": [a.0, b.0], "gradient": with_vector, "span": "selection"}),
|
||
] {
|
||
let e = s.execute("paint.setFill", &bad).unwrap_err().to_string();
|
||
assert!(e.contains("span"), "{bad}: {e}");
|
||
assert_eq!(s.doc().unwrap().doc, before, "{bad}");
|
||
}
|
||
}
|