mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 02:07:09 -06:00
bflatasticandClaude Opus 5.5
2bc6c66c94
Double-clicking a Scatter, Art or Pattern brush in the Brushes panel (or the panel menu's Brush Options...) now opens its options dialog, as Calligraphic and Bristle brushes already did. OK runs brush.options and every stroke painted with the brush redraws. - Scatter Brush Options: Name; Size (10-1000 %), Spacing (10-10000 %), Scatter (-1000-1000 %) and Rotation (-180-180 deg), each Fixed (the first value), Random (between the two values) or Pressure (the first value at the lightest pen pressure, the second at the heaviest); Rotation relative to Page or Path. Scatter brushes now keep these modes (`modes`); brushes saved before keep their look (Random where the two values differ). - Art Brush Options: Name; Width (1-1000 %); Scale Proportionately, Stretch to Fit Stroke Length or Stretch Between Guides with the guides' Start and End (% of the art length); the four Directions; Flip Along and Across. - Pattern Brush Options: Name; Scale (1-10000 %), Spacing (0-10000 %); the five tiles (Outer Corner, Side, Inner Corner, Start, End) drawn with their art or None; Flip Along and Across; Stretch to fit, Add space to fit or Approximate path. - All three: Colorization (None, Tints, Tints and Shades, Hue Shift with its Key Color picked from the art's colours, the most used one by default) and a live preview of a stroke painted with the edited brush. Brush definitions from files and commands are now kept within these ranges (Brush::sanitize, also for Calligraphic and Bristle values); unknown modes, directions, fits or colorization methods are refused. The brush.options and ui.brushOptions docs list the new params and fields. Tests: the brush model (modes, pressure, sanitizing, art colours), engine params reaching the brush and strokes redrawing, junk params in command_sweep, and headless dialog tests for each dialog. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
574 lines
28 KiB
Rust
574 lines
28 KiB
Rust
//! Brushes and symbols: commands, tools, rendering and persistence.
|
|
|
|
use serde_json::{Value, json};
|
|
use vectorcraft_doc::{Document, Node, NodeKind};
|
|
use vectorcraft_geom::Rect;
|
|
use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
|
|
|
|
use super::*;
|
|
|
|
fn session() -> Session {
|
|
let mut s = Session::new();
|
|
s.execute("file.new", &json!({"width": 400, "height": 300})).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 line(s: &mut Session) -> NodeId {
|
|
let r = s.execute("shape.line", &json!({"x1": 50, "y1": 100, "x2": 250, "y2": 100}));
|
|
match r {
|
|
Ok(v) if v["id"].is_u64() => NodeId(v["id"].as_u64().unwrap()),
|
|
_ => {
|
|
let r = s.execute("path.freehand", &json!({"points": [[50, 100], [150, 100], [250, 100]]})).unwrap();
|
|
NodeId(r["id"].as_u64().unwrap())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn node(s: &Session, id: NodeId) -> Node {
|
|
s.doc().unwrap().doc.node(id).cloned().unwrap()
|
|
}
|
|
|
|
fn brush_of(s: &Session, id: NodeId) -> Option<String> {
|
|
node(s, id).appearance.stroke().and_then(|st| st.brush.clone())
|
|
}
|
|
|
|
fn select(s: &mut Session, ids: &[NodeId]) {
|
|
let ids = ids.to_vec();
|
|
s.select(|_, sel| sel.set(ids)).unwrap();
|
|
}
|
|
|
|
fn close(a: Rect, b: Rect, tol: f64) -> bool {
|
|
(a.x0 - b.x0).abs() < tol && (a.y0 - b.y0).abs() < tol && (a.x1 - b.x1).abs() < tol && (a.y1 - b.y1).abs() < tol
|
|
}
|
|
|
|
fn bounds(s: &Session, id: NodeId) -> Rect {
|
|
node(s, id).geometric_bounds().unwrap()
|
|
}
|
|
|
|
// ---------- brushes ----------
|
|
|
|
#[test]
|
|
fn brush_list_has_the_default_library() {
|
|
let mut s = session();
|
|
let l = s.execute("brush.list", &json!({})).unwrap();
|
|
let names: Vec<&str> = l["brushes"].as_array().unwrap().iter().map(|b| b["name"].as_str().unwrap()).collect();
|
|
for n in ["3 pt. Round", "6 pt. Flat", "Charcoal", "Arrow", "Dots", "Chain", "Bristle Round"] {
|
|
assert!(names.contains(&n), "{n} in {names:?}");
|
|
}
|
|
let def = s.execute("brush.get", &json!({"name": "6 pt. Flat"})).unwrap();
|
|
assert_eq!(def["type"], "calligraphic");
|
|
assert_eq!(def["angle"], json!(45.0));
|
|
}
|
|
|
|
#[test]
|
|
fn apply_and_remove_brush_with_undo() {
|
|
let mut s = session();
|
|
let a = rect(&mut s, 10.0, 10.0, 50.0, 50.0);
|
|
s.execute("brush.apply", &json!({"name": "Charcoal"})).unwrap();
|
|
assert_eq!(brush_of(&s, a).as_deref(), Some("Charcoal"));
|
|
assert_eq!(s.execute("brush.list", &json!({})).unwrap()["current"], "Charcoal");
|
|
s.execute("brush.remove", &json!({})).unwrap();
|
|
assert_eq!(brush_of(&s, a), None);
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(brush_of(&s, a).as_deref(), Some("Charcoal"));
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(brush_of(&s, a), None);
|
|
assert!(s.execute("brush.apply", &json!({"name": "Nope"})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn apply_adds_a_stroke_when_missing_and_reaches_into_groups() {
|
|
let mut s = session();
|
|
let a = rect(&mut s, 10.0, 10.0, 50.0, 50.0);
|
|
let b = rect(&mut s, 80.0, 10.0, 50.0, 50.0);
|
|
s.execute("paint.setStroke", &json!({"color": null, "ids": [a.0]})).ok();
|
|
select(&mut s, &[a, b]);
|
|
s.execute("object.group", &json!({})).unwrap();
|
|
s.execute("brush.apply", &json!({"name": "Dots"})).unwrap();
|
|
assert_eq!(brush_of(&s, a).as_deref(), Some("Dots"));
|
|
assert_eq!(brush_of(&s, b).as_deref(), Some("Dots"));
|
|
assert!(!node(&s, a).appearance.stroke_paint().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn new_brushes_from_params_and_selection() {
|
|
let mut s = session();
|
|
let r = s.execute("brush.new", &json!({"type": "calligraphic", "name": "Nib", "params": {"angle": 20, "roundness": 30, "size": 8}})).unwrap();
|
|
assert_eq!(r["name"], "Nib");
|
|
assert_eq!(s.execute("brush.get", &json!({"name": "Nib"})).unwrap()["size"], json!(8.0));
|
|
// Art brushes need art.
|
|
s.select(|_, sel| sel.clear()).unwrap();
|
|
assert!(s.execute("brush.new", &json!({"type": "art"})).is_err());
|
|
let a = rect(&mut s, 0.0, 0.0, 40.0, 8.0);
|
|
let r = s.execute("brush.new", &json!({"type": "art", "name": "Bar"})).unwrap();
|
|
assert_eq!(r["name"], "Bar");
|
|
let r = s.execute("brush.new", &json!({"type": "pattern"})).unwrap();
|
|
assert_eq!(r["name"], "New Pattern Brush");
|
|
let def = s.execute("brush.get", &json!({"name": "New Pattern Brush"})).unwrap();
|
|
assert!(def["side"].is_object());
|
|
// The new art brush draws the rectangle along another path.
|
|
let l = line(&mut s);
|
|
s.execute("brush.apply", &json!({"name": "Bar", "ids": [l.0]})).unwrap();
|
|
let g = s.execute("object.expandBrush", &json!({"ids": [l.0]})).unwrap();
|
|
let gid = NodeId(g["ids"][0].as_u64().unwrap());
|
|
let b = bounds(&s, gid);
|
|
assert!((b.width() - 200.0).abs() < 0.5 && (b.height() - 8.0).abs() < 0.5, "{b:?}");
|
|
let _ = a;
|
|
// Undo removes the brush again; the library was not there before.
|
|
assert!(s.execute("brush.new", &json!({"type": "nope"})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn brush_options_rename_duplicate_and_delete_update_strokes() {
|
|
let mut s = session();
|
|
let a = rect(&mut s, 10.0, 10.0, 50.0, 50.0);
|
|
s.execute("brush.apply", &json!({"name": "3 pt. Round"})).unwrap();
|
|
s.execute("brush.options", &json!({"name": "3 pt. Round", "params": {"size": 5}, "newName": "5 pt. Round"})).unwrap();
|
|
assert_eq!(brush_of(&s, a).as_deref(), Some("5 pt. Round"));
|
|
assert_eq!(s.execute("brush.get", &json!({"name": "5 pt. Round"})).unwrap()["size"], json!(5.0));
|
|
assert_eq!(s.execute("brush.list", &json!({})).unwrap()["current"], "5 pt. Round");
|
|
let d = s.execute("brush.duplicate", &json!({"name": "5 pt. Round"})).unwrap();
|
|
assert_eq!(d["name"], "5 pt. Round copy");
|
|
s.execute("brush.delete", &json!({"name": "5 pt. Round"})).unwrap();
|
|
assert_eq!(brush_of(&s, a), None);
|
|
assert!(s.execute("brush.get", &json!({"name": "5 pt. Round"})).is_err());
|
|
assert!(s.execute("brush.delete", &json!({"name": "5 pt. Round"})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn expand_brush_replaces_path_with_art_group() {
|
|
let mut s = session();
|
|
let a = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
|
|
s.execute("brush.apply", &json!({"name": "10 pt. Oval"})).unwrap();
|
|
let r = s.execute("object.expandBrush", &json!({})).unwrap();
|
|
let g = NodeId(r["ids"][0].as_u64().unwrap());
|
|
assert!(s.doc().unwrap().doc.node(a).is_none());
|
|
let gn = node(&s, g);
|
|
assert!(matches!(gn.kind, NodeKind::Group { .. }));
|
|
// White fill kept + the black nib outline.
|
|
assert_eq!(gn.children().unwrap().len(), 2);
|
|
let b = bounds(&s, g);
|
|
assert!(b.width() > 104.0 && b.width() < 112.0, "{b:?}");
|
|
assert_eq!(s.doc().unwrap().selection.objects, vec![g]);
|
|
assert!(s.execute("object.expandBrush", &json!({})).is_err(), "nothing brushed left");
|
|
}
|
|
|
|
#[test]
|
|
fn brush_freehand_paints_with_a_brush_in_one_step() {
|
|
let mut s = session();
|
|
let n = s.doc().unwrap().history.undo.len();
|
|
s.begin_interaction("Paintbrush").unwrap();
|
|
s.preview("brush.freehand", &json!({"points": [[10, 10], [60, 40], [120, 10]], "style": "brush", "brush": "Charcoal"})).unwrap();
|
|
s.commit_interaction().unwrap();
|
|
assert_eq!(s.doc().unwrap().history.undo.len(), n + 1);
|
|
let id = s.doc().unwrap().selection.objects[0];
|
|
assert_eq!(brush_of(&s, id).as_deref(), Some("Charcoal"));
|
|
}
|
|
|
|
#[test]
|
|
fn paintbrush_tool_uses_the_current_brush() {
|
|
let mut s = session();
|
|
s.execute("brush.setCurrent", &json!({"name": "Arrow"})).unwrap();
|
|
let v = ViewInfo::default();
|
|
s.select_tool("paintbrush", v).unwrap();
|
|
for (k, x, y) in
|
|
[(PointerKind::Down, 10.0, 10.0), (PointerKind::Drag, 50.0, 30.0), (PointerKind::Drag, 90.0, 20.0), (PointerKind::Up, 130.0, 10.0)]
|
|
{
|
|
s.pointer(&PointerEvent::new(k, x, y), v).unwrap();
|
|
}
|
|
let id = s.doc().unwrap().selection.objects[0];
|
|
assert_eq!(brush_of(&s, id).as_deref(), Some("Arrow"));
|
|
// A tool option overrides the document's current brush.
|
|
s.set_tool_option("brush", &json!("Dots"));
|
|
for (k, x, y) in [(PointerKind::Down, 10.0, 110.0), (PointerKind::Drag, 50.0, 130.0), (PointerKind::Up, 130.0, 110.0)] {
|
|
s.pointer(&PointerEvent::new(k, x, y), v).unwrap();
|
|
}
|
|
let id = s.doc().unwrap().selection.objects[0];
|
|
assert_eq!(brush_of(&s, id).as_deref(), Some("Dots"));
|
|
assert!(s.execute("brush.setCurrent", &json!({"name": "Nope"})).is_err());
|
|
}
|
|
|
|
/// A Size: Pressure variant of "3 pt. Round" (3 ± 3 pt).
|
|
fn pressure_round(s: &mut Session) {
|
|
let params = json!({"variation": [0, 0, 3], "modes": ["fixed", "fixed", "pressure"]});
|
|
s.execute("brush.options", &json!({"name": "3 pt. Round", "params": params})).unwrap();
|
|
}
|
|
|
|
fn pressure_of(s: &Session, id: NodeId) -> Option<vectorcraft_doc::PressureProfile> {
|
|
node(s, id).appearance.stroke().and_then(|st| st.pressure.clone())
|
|
}
|
|
|
|
/// #852: the Paintbrush records the pen pressure on the stroke, the brush draws it, and it lasts
|
|
/// through saving and every export; a mouse stroke records none.
|
|
#[test]
|
|
fn paintbrush_records_pen_pressure_on_the_stroke() {
|
|
let mut s = session();
|
|
pressure_round(&mut s);
|
|
s.execute("brush.setCurrent", &json!({"name": "3 pt. Round"})).unwrap();
|
|
let v = ViewInfo::default();
|
|
s.select_tool("paintbrush", v).unwrap();
|
|
let strokes = |s: &mut Session, y: f64, pressure: [f32; 4]| {
|
|
let kinds = [PointerKind::Down, PointerKind::Drag, PointerKind::Drag, PointerKind::Up];
|
|
for ((k, x), p) in kinds.into_iter().zip([20.0, 120.0, 220.0, 320.0]).zip(pressure) {
|
|
s.pointer(&PointerEvent { pressure: p, ..PointerEvent::new(k, x, y) }, v).unwrap();
|
|
}
|
|
let id = s.doc().unwrap().selection.objects[0];
|
|
// Deselected, so the next stroke starts a path of its own.
|
|
select(s, &[]);
|
|
id
|
|
};
|
|
let pen = strokes(&mut s, 60.0, [0.0, 0.4, 0.8, 1.0]);
|
|
let p = pressure_of(&s, pen).expect("pressure recorded");
|
|
assert!(p.at(0.0) < 0.05 && p.at(1.0) > 0.95 && (p.at(0.5) - 0.6).abs() < 0.05, "{p:?}");
|
|
let mouse = strokes(&mut s, 200.0, [1.0; 4]);
|
|
assert_eq!(pressure_of(&s, mouse), None, "a mouse presses fully: nothing to record");
|
|
// Drawn: thin where the pen pressed lightly, 6 pt where it pressed fully.
|
|
let doc: Document = (*s.doc().unwrap().doc).clone();
|
|
let art = |d: &Document, id: NodeId| vectorcraft_brush::node_pieces(d, d.node(id).unwrap()).unwrap();
|
|
let heavy_end = vectorcraft_brush::pieces_bounds(&art(&doc, pen)).unwrap();
|
|
assert!((heavy_end.height() - 6.0).abs() < 0.3, "{heavy_end:?}");
|
|
let even = vectorcraft_brush::pieces_bounds(&art(&doc, mouse)).unwrap();
|
|
assert!((even.height() - 3.0).abs() < 0.1, "no pressure draws the size itself: {even:?}");
|
|
// Saved and reopened as it was.
|
|
let back = vectorcraft_format::load(&vectorcraft_format::save(&doc, false)).unwrap();
|
|
assert_eq!(back.node(pen).unwrap().appearance.stroke().unwrap().pressure, Some(p));
|
|
// SVG and PDF draw the brush through the same stroke code: without the pressure they differ.
|
|
let mut flat = doc.clone();
|
|
flat.node_mut(pen).unwrap().appearance.stroke_mut().unwrap().pressure = None;
|
|
assert_ne!(vectorcraft_svg::export(&doc, &Default::default()), vectorcraft_svg::export(&flat, &Default::default()));
|
|
let pdf = |d: &Document| {
|
|
vectorcraft_pdf::export(d, &vectorcraft_pdf::PdfOptions { created: Some(0), ..vectorcraft_pdf::PdfOptions::uncompressed() }).unwrap()
|
|
};
|
|
assert_ne!(pdf(&doc), pdf(&flat));
|
|
}
|
|
|
|
/// Continuing a pressure stroke keeps its pressure where it was and adds the new stroke's after it.
|
|
#[test]
|
|
fn continuing_a_stroke_joins_its_pressure() {
|
|
let mut s = session();
|
|
let r = s.execute("path.freehand", &json!({"points": [[0, 50, 0], [100, 50, 1]], "style": "brush"})).unwrap();
|
|
let id = NodeId(r["id"].as_u64().unwrap());
|
|
s.execute("path.freehand", &json!({"points": [[100, 50, 1], [200, 50, 0]], "style": "brush", "extend": {"id": id.0, "end": "end"}})).unwrap();
|
|
let p = pressure_of(&s, id).unwrap();
|
|
assert!(p.at(0.0) < 0.05 && (p.at(0.5) - 1.0).abs() < 0.05 && p.at(1.0) < 0.05, "{p:?}");
|
|
// Continued at its start: the new stroke comes first, running backwards from where it joined.
|
|
let r = s.execute("path.freehand", &json!({"points": [[0, 150], [100, 150]], "style": "brush"})).unwrap();
|
|
let id = NodeId(r["id"].as_u64().unwrap());
|
|
s.execute("path.freehand", &json!({"points": [[0, 150, 1], [-100, 150, 0]], "style": "brush", "extend": {"id": id.0, "end": "start"}})).unwrap();
|
|
let p = pressure_of(&s, id).unwrap();
|
|
assert!(p.at(0.0) < 0.05 && (p.at(0.5) - 1.0).abs() < 0.05, "{p:?}");
|
|
assert_eq!(p.at(1.0), vectorcraft_doc::PressureProfile::MID, "the old part had no pressure");
|
|
}
|
|
|
|
/// Pen pressure belongs to its path: new art, graphic styles and Brush Options' edits leave it.
|
|
#[test]
|
|
fn pressure_stays_with_its_own_path() {
|
|
let mut s = session();
|
|
s.execute("appearance.setNewArtBasic", &json!({"on": false})).unwrap();
|
|
let r = s.execute("brush.freehand", &json!({"points": [[0, 50, 0.2], [100, 50, 0.9]], "style": "brush", "brush": "3 pt. Round"})).unwrap();
|
|
let id = NodeId(r["id"].as_u64().unwrap());
|
|
assert!(pressure_of(&s, id).is_some());
|
|
select(&mut s, &[id]);
|
|
s.execute("graphicStyle.new", &json!({"name": "Inked"})).unwrap();
|
|
let style = s.doc().unwrap().doc.graphic_style("Inked").unwrap().appearance.clone();
|
|
assert!(style.stroke().is_some_and(|st| st.pressure.is_none()));
|
|
let other = rect(&mut s, 10.0, 100.0, 50.0, 50.0);
|
|
assert_eq!(pressure_of(&s, other), None, "new art takes the look, not the pressure");
|
|
pressure_round(&mut s);
|
|
assert!(pressure_of(&s, id).is_some(), "editing the brush keeps the strokes' pressure");
|
|
}
|
|
|
|
/// Brush Options sets the variation modes; bad modes are refused, never a panic.
|
|
#[test]
|
|
fn brush_options_set_variation_modes() {
|
|
let mut s = session();
|
|
pressure_round(&mut s);
|
|
let b = s.execute("brush.get", &json!({"name": "3 pt. Round"})).unwrap();
|
|
assert_eq!(b["modes"], json!(["fixed", "fixed", "pressure"]));
|
|
assert_eq!(b["variation"], json!([0.0, 0.0, 3.0]));
|
|
for bad in [json!({"modes": ["fixed", "fixed", "tilt"]}), json!({"modes": "pressure"}), json!({"variation": "x"}), json!({"modes": [1, 2, 3]})] {
|
|
assert!(s.execute("brush.options", &json!({"name": "3 pt. Round", "params": bad})).is_err(), "{bad}");
|
|
}
|
|
assert_eq!(s.execute("brush.get", &json!({"name": "3 pt. Round"})).unwrap(), b, "a refused edit changes nothing");
|
|
}
|
|
|
|
/// The bounds of the brush art `id`'s strokes draw.
|
|
fn brushed_bounds(s: &Session, id: NodeId) -> Rect {
|
|
let st = s.doc().unwrap();
|
|
let pieces = vectorcraft_brush::node_pieces(&st.doc, &node(s, id)).expect("brushed");
|
|
vectorcraft_brush::pieces_bounds(&pieces).expect("draws")
|
|
}
|
|
|
|
/// Scatter, Art and Pattern Brush Options: the params reach the brush and every stroke painted
|
|
/// with it redraws; values out of range are clamped, unknown choices refused.
|
|
#[test]
|
|
fn scatter_art_and_pattern_brush_options_update_strokes() {
|
|
let mut s = session();
|
|
// A rectangle as an art brush (straight edges: no flattening between sizes).
|
|
let r = rect(&mut s, 10.0, 200.0, 40.0, 8.0);
|
|
let bar = s.execute("brush.new", &json!({"type": "art", "name": "Bar", "ids": [r.0]})).unwrap()["name"].as_str().unwrap().to_string();
|
|
let id = line(&mut s);
|
|
select(&mut s, &[id]);
|
|
let edit = |s: &mut Session, name: &str, params: Value| -> f64 {
|
|
s.execute("brush.apply", &json!({ "name": name })).unwrap();
|
|
let before = brushed_bounds(s, id).height();
|
|
s.execute("brush.options", &json!({ "name": name, "params": params })).unwrap();
|
|
brushed_bounds(s, id).height() / before
|
|
};
|
|
// Art: Width 300 % draws the art three times as wide across the path.
|
|
let art = json!({"width": 300, "direction": "rightToLeft", "flip_across": true});
|
|
assert!((edit(&mut s, &bar, art) - 3.0).abs() < 1e-6);
|
|
s.execute("brush.options", &json!({"name": bar, "params": {"scale": {"mode": "betweenGuides", "start": 0.2, "end": 0.6}}})).unwrap();
|
|
let b = s.execute("brush.get", &json!({ "name": bar })).unwrap();
|
|
assert_eq!(
|
|
(&b["direction"], &b["flip_across"], &b["scale"]),
|
|
(&json!("rightToLeft"), &json!(true), &json!({"mode": "betweenGuides", "start": 0.2, "end": 0.6}))
|
|
);
|
|
// Pattern: Scale 200 % doubles the tiles.
|
|
assert!((edit(&mut s, "Stitches", json!({"scale": 200, "spacing": 50, "fit": "addSpace", "flip_along": true})) - 2.0).abs() < 0.05);
|
|
let b = s.execute("brush.get", &json!({"name": "Stitches"})).unwrap();
|
|
assert_eq!((&b["spacing"], &b["fit"]), (&json!(50.0), &json!("addSpace")));
|
|
// Scatter: a fixed Size of 200 % doubles the dots; the modes and Hue Shift are kept.
|
|
let key = json!({"model": "rgb", "r": 0.0, "g": 0.0, "b": 0.0});
|
|
let scatter = json!({"size": [200, 50], "modes": ["fixed", "fixed", "fixed", "random"], "rotation_relative_to_path": true, "colorization": {"method": "hueShift", "key": key}});
|
|
assert!((edit(&mut s, "Dots", scatter) - 2.0).abs() < 0.05);
|
|
let b = s.execute("brush.get", &json!({"name": "Dots"})).unwrap();
|
|
assert_eq!(
|
|
(&b["modes"], &b["colorization"]["method"], &b["colorization"]["key"]),
|
|
(&json!(["fixed", "fixed", "fixed", "random"]), &json!("hueShift"), &key)
|
|
);
|
|
// Out of range: clamped. Unknown choices: refused, nothing changes.
|
|
let junk = json!({"size": [1e308, -1e308], "spacing": [0, 1e308], "rotation": [720, -1e9], "scatter": [-1e308, 5]});
|
|
s.execute("brush.options", &json!({"name": "Dots", "params": junk})).unwrap();
|
|
let b = s.execute("brush.get", &json!({"name": "Dots"})).unwrap();
|
|
assert_eq!(
|
|
(&b["size"], &b["spacing"], &b["rotation"], &b["scatter"]),
|
|
(&json!([10000.0, 1.0]), &json!([1.0, 10000.0]), &json!([180.0, -180.0]), &json!([-1000.0, 5.0]))
|
|
);
|
|
assert!(brushed_bounds(&s, id).is_finite());
|
|
for (name, bad) in [
|
|
("Dots", json!({"modes": ["fixed", "tilt", "fixed", "fixed"]})),
|
|
("Dots", json!({"modes": ["fixed"]})),
|
|
("Dots", json!({"colorization": {"method": "sparkle"}})),
|
|
("Arrow", json!({"direction": "diagonal"})),
|
|
("Arrow", json!({"width": "wide"})),
|
|
("Chain", json!({"fit": "squeeze"})),
|
|
] {
|
|
let before = s.execute("brush.get", &json!({ "name": name })).unwrap();
|
|
assert!(s.execute("brush.options", &json!({ "name": name, "params": bad })).is_err(), "{bad}");
|
|
assert_eq!(s.execute("brush.get", &json!({ "name": name })).unwrap(), before);
|
|
}
|
|
s.execute("brush.options", &json!({"name": "Chain", "params": {"scale": 1e308, "spacing": -1e308}})).unwrap();
|
|
let b = s.execute("brush.get", &json!({"name": "Chain"})).unwrap();
|
|
assert_eq!((&b["scale"], &b["spacing"]), (&json!(10000.0), &json!(0.0)));
|
|
}
|
|
|
|
// ---------- symbols ----------
|
|
|
|
fn make_symbol(s: &mut Session) -> (NodeId, String, Rect) {
|
|
let a = rect(s, 100.0, 50.0, 80.0, 40.0);
|
|
let b = bounds(s, a);
|
|
let r = s.execute("symbol.new", &json!({"name": "Box"})).unwrap();
|
|
(NodeId(r["id"].as_u64().unwrap()), r["name"].as_str().unwrap().to_string(), b)
|
|
}
|
|
|
|
#[test]
|
|
fn new_symbol_replaces_selection_with_instance_of_same_bounds() {
|
|
let mut s = session();
|
|
let (inst, name, b) = make_symbol(&mut s);
|
|
assert_eq!(name, "Box");
|
|
let n = node(&s, inst);
|
|
assert!(matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Box"));
|
|
assert!(close(n.geometric_bounds().unwrap(), b, 1e-9), "{:?} vs {b:?}", n.geometric_bounds());
|
|
let d = &s.doc().unwrap().doc;
|
|
assert_eq!(d.symbols.len(), 1);
|
|
assert_eq!(d.layers[0].children().unwrap().len(), 1);
|
|
let l = s.execute("symbol.list", &json!({})).unwrap();
|
|
assert_eq!(l["symbols"][0]["instances"], 1);
|
|
assert_eq!(l["symbols"][0]["size"], json!([80.0, 40.0]));
|
|
// A second symbol gets a unique name.
|
|
rect(&mut s, 0.0, 0.0, 10.0, 10.0);
|
|
assert_eq!(s.execute("symbol.new", &json!({"name": "Box"})).unwrap()["name"], "Box 2");
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(s.doc().unwrap().doc.symbols.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn place_and_break_link_round_trip_geometry() {
|
|
let mut s = session();
|
|
let (_, name, _) = make_symbol(&mut s);
|
|
let r = s.execute("symbol.place", &json!({"name": name, "x": 300, "y": 200})).unwrap();
|
|
let p = NodeId(r["id"].as_u64().unwrap());
|
|
assert!(close(bounds(&s, p), Rect::new(260.0, 180.0, 340.0, 220.0), 1e-9), "{:?}", bounds(&s, p));
|
|
let r = s.execute("symbol.breakLink", &json!({"ids": [p.0]})).unwrap();
|
|
let art = NodeId(r["ids"][0].as_u64().unwrap());
|
|
let n = node(&s, art);
|
|
assert!(matches!(n.kind, NodeKind::Path { .. }));
|
|
assert!(close(n.geometric_bounds().unwrap(), Rect::new(260.0, 180.0, 340.0, 220.0), 1e-6));
|
|
assert_eq!(n.appearance.stroke_width(), 1.0, "strokes are not scaled by normalisation");
|
|
}
|
|
|
|
#[test]
|
|
fn edit_then_update_redefines_all_instances() {
|
|
let mut s = session();
|
|
let (inst, name, _) = make_symbol(&mut s);
|
|
let other = NodeId(s.execute("symbol.place", &json!({"x": 300, "y": 200})).unwrap()["id"].as_u64().unwrap());
|
|
select(&mut s, &[inst]);
|
|
let r = s.execute("symbol.edit", &json!({})).unwrap();
|
|
assert_eq!(r["name"], name);
|
|
let art = NodeId(r["ids"][0].as_u64().unwrap());
|
|
// Make the art twice as wide, then redefine.
|
|
s.execute("object.transform", &json!({"ids": [art.0], "matrix": [2, 0, 0, 1, -140, 0]})).ok();
|
|
let w = bounds(&s, art).width();
|
|
let r = s.execute("symbol.update", &json!({"name": name})).unwrap();
|
|
let new_inst = NodeId(r["id"].as_u64().unwrap());
|
|
assert!((bounds(&s, new_inst).width() - w).abs() < 1e-6);
|
|
assert!((bounds(&s, other).width() - w).abs() < 1e-6, "other instances pick up the new size");
|
|
assert!((bounds(&s, other).center().x - 300.0).abs() < 1e-6);
|
|
}
|
|
|
|
#[test]
|
|
fn delete_duplicate_and_replace_symbols() {
|
|
let mut s = session();
|
|
let (inst, name, _) = make_symbol(&mut s);
|
|
let d = s.execute("symbol.duplicate", &json!({"name": name})).unwrap();
|
|
assert_eq!(d["name"], "Box copy");
|
|
rect(&mut s, 0.0, 0.0, 20.0, 20.0);
|
|
s.execute("symbol.new", &json!({"name": "Small"})).unwrap();
|
|
select(&mut s, &[inst]);
|
|
s.execute("symbol.replace", &json!({"name": "Small"})).unwrap();
|
|
assert!(matches!(&node(&s, inst).kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Small"));
|
|
assert!(close(bounds(&s, inst), Rect::new(130.0, 60.0, 150.0, 80.0), 1e-6), "{:?}", bounds(&s, inst));
|
|
s.execute("symbol.delete", &json!({"name": "Small"})).unwrap();
|
|
let doc = &s.doc().unwrap().doc;
|
|
assert!(doc.symbols.iter().all(|x| x.name != "Small"));
|
|
assert!(doc.node(inst).is_none());
|
|
let mut plain = 0;
|
|
doc.walk(|n| plain += matches!(n.kind, NodeKind::Path { .. }) as i32);
|
|
assert_eq!(plain, 2, "both instances of Small were expanded");
|
|
assert!(s.execute("symbol.delete", &json!({"name": "Small"})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn sprayer_command_creates_a_symbol_set_and_alt_removes() {
|
|
let mut s = session();
|
|
make_symbol(&mut s);
|
|
s.select(|_, sel| sel.clear()).unwrap();
|
|
let pts: Vec<Value> = (0..20).map(|i| json!([20.0 + i as f64 * 15.0, 150.0])).collect();
|
|
let r = s.execute("symbol.spray", &json!({"points": pts, "radius": 10, "density": 8})).unwrap();
|
|
let set = NodeId(r["id"].as_u64().unwrap());
|
|
let n = r["count"].as_u64().unwrap() as usize;
|
|
assert!(n >= 3, "{n}");
|
|
let g = node(&s, set);
|
|
assert_eq!(g.name.as_deref(), Some("Symbol Set"));
|
|
assert_eq!(g.children().unwrap().len(), n);
|
|
// Spraying again with the set selected adds to it.
|
|
s.execute("symbol.spray", &json!({"points": [[200, 250]]})).unwrap();
|
|
assert_eq!(node(&s, set).children().unwrap().len(), n + 1);
|
|
let r = s.execute("symbol.spray", &json!({"points": [[200, 250]], "radius": 60, "alt": true})).unwrap();
|
|
assert!(r["count"].as_u64().unwrap() >= 1);
|
|
assert_eq!(node(&s, set).children().unwrap().len(), n + 1 - r["count"].as_u64().unwrap() as usize);
|
|
}
|
|
|
|
#[test]
|
|
fn symbolism_adjustments() {
|
|
let mut s = session();
|
|
let (inst, _, b) = make_symbol(&mut s);
|
|
let c = b.center();
|
|
let at = json!([[c.x, c.y]]);
|
|
s.execute("symbol.adjust", &json!({"tool": "size", "points": at, "radius": 50, "intensity": 10})).unwrap();
|
|
assert!(bounds(&s, inst).width() > b.width() + 1.0);
|
|
s.execute("symbol.adjust", &json!({"tool": "screen", "points": at, "intensity": 10})).unwrap();
|
|
assert!(node(&s, inst).opacity < 1.0);
|
|
s.execute("symbol.adjust", &json!({"tool": "stain", "points": at, "color": "#ff0000", "intensity": 10})).unwrap();
|
|
let f = node(&s, inst).appearance.fill().cloned().unwrap();
|
|
assert!(f.opacity > 0.0 && f.paint.color().unwrap().to_hex() == "#ff0000");
|
|
s.execute("symbol.adjust", &json!({"tool": "shift", "points": [[c.x, c.y], [c.x + 20.0, c.y]], "intensity": 10})).unwrap();
|
|
assert!(bounds(&s, inst).center().x > c.x + 5.0);
|
|
let before = bounds(&s, inst);
|
|
s.execute("symbol.adjust", &json!({"tool": "spin", "points": at, "intensity": 10})).unwrap();
|
|
assert!(!close(bounds(&s, inst), before, 1e-6), "spin rotates");
|
|
let far = s.execute("symbol.adjust", &json!({"tool": "size", "points": [[0, 290]], "radius": 5})).unwrap();
|
|
assert_eq!(far["count"], 0);
|
|
assert!(s.execute("symbol.adjust", &json!({"tool": "nope", "points": at})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn symbol_sprayer_tool_gesture_is_one_undo_step() {
|
|
let mut s = session();
|
|
make_symbol(&mut s);
|
|
s.select(|_, sel| sel.clear()).unwrap();
|
|
let n = s.doc().unwrap().history.undo.len();
|
|
let v = ViewInfo::default();
|
|
s.select_tool("symbolSprayer", v).unwrap();
|
|
let mut evs = vec![PointerEvent::new(PointerKind::Down, 50.0, 200.0)];
|
|
for i in 1..15 {
|
|
evs.push(PointerEvent::new(PointerKind::Drag, 50.0 + i as f64 * 20.0, 200.0));
|
|
}
|
|
evs.push(PointerEvent::new(PointerKind::Up, 350.0, 200.0).with_mods(Mods::default()));
|
|
for e in evs {
|
|
s.pointer(&e, v).unwrap();
|
|
}
|
|
assert_eq!(s.doc().unwrap().history.undo.len(), n + 1);
|
|
let set = s.doc().unwrap().selection.objects[0];
|
|
assert!(node(&s, set).children().unwrap().len() >= 3);
|
|
// The sizer tool grows the sprayed instances.
|
|
let first = node(&s, set).children().unwrap()[0].clone();
|
|
let c = first.geometric_bounds().unwrap().center();
|
|
s.select_tool("symbolSizer", v).unwrap();
|
|
s.pointer(&PointerEvent::new(PointerKind::Down, c.x, c.y), v).unwrap();
|
|
s.pointer(&PointerEvent::new(PointerKind::Up, c.x, c.y), v).unwrap();
|
|
let after = s.doc().unwrap().doc.node(first.id).unwrap().geometric_bounds().unwrap();
|
|
assert!(after.width() > first.geometric_bounds().unwrap().width());
|
|
}
|
|
|
|
// ---------- rendering & persistence ----------
|
|
|
|
#[test]
|
|
fn brushed_strokes_and_instances_render() {
|
|
let mut s = session();
|
|
make_symbol(&mut s);
|
|
let l = line(&mut s);
|
|
s.execute("brush.apply", &json!({"name": "Chain", "ids": [l.0]})).unwrap();
|
|
let doc = s.doc().unwrap().doc.clone();
|
|
let img = vectorcraft_render::Renderer::new().render_region(&doc, Rect::new(0.0, 0.0, 400.0, 300.0), 1.0, true);
|
|
let dark = |x: u32, y: u32| {
|
|
let p = img.pixel(x, y);
|
|
(p[0] as u32 + p[1] as u32 + p[2] as u32) < 300
|
|
};
|
|
// The instance's outline (the rectangle's black stroke) is drawn.
|
|
assert!((45..=55).any(|y| dark(100, y)), "instance stroke rendered");
|
|
// Chain links are thicker than the 1 pt stroke, with gaps.
|
|
let hits = (50..250).filter(|x| (95..=105).any(|y| dark(*x, y))).count();
|
|
assert!(hits > 100, "chain covers most of the line: {hits}");
|
|
}
|
|
|
|
#[test]
|
|
fn brushes_and_symbols_survive_vectorcraft_round_trip() {
|
|
let mut s = session();
|
|
make_symbol(&mut s);
|
|
s.execute("brush.new", &json!({"type": "calligraphic", "name": "Mine", "params": {"size": 7}})).unwrap();
|
|
let l = line(&mut s);
|
|
s.execute("brush.apply", &json!({"name": "Mine", "ids": [l.0]})).unwrap();
|
|
let doc = s.doc().unwrap().doc.clone();
|
|
let bytes = vectorcraft_format::save(&doc, false);
|
|
let back = vectorcraft_format::load(&bytes).unwrap();
|
|
assert_eq!(vectorcraft_brush::library(&back), vectorcraft_brush::library(&doc));
|
|
assert_eq!(vectorcraft_brush::find(&back, "Mine").map(|b| b.kind.type_id()), Some("calligraphic"));
|
|
assert_eq!(back.symbols, doc.symbols);
|
|
assert_eq!(back.unknown.get("symbolSizes"), doc.unknown.get("symbolSizes"));
|
|
let bl = back.node(l).unwrap();
|
|
assert_eq!(bl.appearance.stroke().unwrap().brush.as_deref(), Some("Mine"));
|
|
// A reloaded document places instances at the natural size.
|
|
let mut s2 = Session::new();
|
|
s2.add_document(back, None);
|
|
let r = s2.execute("symbol.place", &json!({"name": "Box", "x": 100, "y": 100})).unwrap();
|
|
let b = s2.doc().unwrap().doc.node(NodeId(r["id"].as_u64().unwrap())).unwrap().geometric_bounds().unwrap();
|
|
assert!(close(b, Rect::new(60.0, 80.0, 140.0, 120.0), 1e-9));
|
|
}
|