mirror of
https://github.com/storytold/figcraft.git
synced 2026-10-28 12:26:52 -06:00
381 lines
21 KiB
Rust
381 lines
21 KiB
Rust
//! Drawing extras: text on a path (commands, resize, undo, SVG round trip) and pattern fills
|
|
//! (tiles render live from their source, copies keep their own source, exports).
|
|
|
|
use serde_json::{Value, json};
|
|
|
|
use crate::Session;
|
|
use crate::params::id_of;
|
|
use figcraft_color::PaintKind;
|
|
use figcraft_doc::{NodeId, NodeKind};
|
|
|
|
fn id(v: Value) -> NodeId {
|
|
id_of(&v["id"]).unwrap()
|
|
}
|
|
|
|
fn text_path(s: &Session, t: NodeId) -> Option<figcraft_doc::TextPath> {
|
|
match &s.doc().unwrap().node(t)?.kind {
|
|
NodeKind::Text(td) => td.path.as_deref().cloned(),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// The RGBA of `node` rendered at 1x, at (`x`, `y`) of its box.
|
|
fn pixel(s: &Session, node: NodeId, x: u32, y: u32) -> [u8; 4] {
|
|
let pix = figcraft_render::render_node(s.doc().unwrap(), node, 1.0).unwrap();
|
|
let i = ((y * pix.width() + x) * 4) as usize;
|
|
let d = pix.data();
|
|
[d[i], d[i + 1], d[i + 2], d[i + 3]]
|
|
}
|
|
|
|
#[test]
|
|
fn text_goes_onto_a_path_and_off_again() {
|
|
let mut s = Session::new();
|
|
let t = id(s.execute("text.create", &json!({"text": "Around", "x": 0, "y": 0})).unwrap());
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 C50 -50 150 -50 200 0", "x": 40, "y": 100})).unwrap());
|
|
// Without a path selected it says what's missing.
|
|
assert!(s.execute("text.onPath", &json!({"ids": [t]})).is_err());
|
|
let (vxf, vw) = s.doc().map(|d| d.node(v).map(|n| (n.transform, n.width))).unwrap().unwrap();
|
|
let r = s.execute("text.onPath", &json!({"ids": [t, v], "start": 0.25})).unwrap();
|
|
assert_eq!(id(r), t);
|
|
let doc = s.doc().unwrap();
|
|
assert!(doc.node(v).is_none(), "the path layer became the text's path");
|
|
let n = doc.node(t).unwrap();
|
|
assert_eq!((n.transform, n.width), (vxf, vw), "in the path's place");
|
|
assert_eq!(s.selection(), vec![t]);
|
|
let tp = text_path(&s, t).unwrap();
|
|
assert_eq!((tp.start, tp.flip), (0.25, false));
|
|
s.execute("text.pathOptions", &json!({"ids": [t], "flip": true, "start": 7})).unwrap();
|
|
let tp = text_path(&s, t).unwrap();
|
|
assert_eq!((tp.start, tp.flip), (1.0, true), "start clamps into 0..1");
|
|
// Resizing scales the path with the box.
|
|
let w = s.doc().unwrap().node(t).unwrap().width;
|
|
s.execute("transform.resize", &json!({"ids": [t], "width": w * 2.0})).unwrap();
|
|
let bb = figcraft_geom::Shape::bounding_box(&text_path(&s, t).unwrap().path());
|
|
assert!((bb.width() - w * 2.0).abs() < 1.0, "{bb:?}");
|
|
s.execute("text.removeFromPath", &json!({"ids": [t]})).unwrap();
|
|
assert!(text_path(&s, t).is_none());
|
|
for _ in 0..4 {
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
}
|
|
assert!(s.doc().unwrap().node(v).is_some() && text_path(&s, t).is_none(), "undo brings the path back");
|
|
}
|
|
|
|
/// A click (press and release) at (`x`, `y`) at 100%.
|
|
fn click(s: &mut Session, x: f64, y: f64) {
|
|
use crate::tools::{PointerEvent, PointerKind};
|
|
s.pointer(&PointerEvent::at(PointerKind::Down, x, y, 1.0)).unwrap();
|
|
s.pointer(&PointerEvent::at(PointerKind::Up, x, y, 1.0)).unwrap();
|
|
}
|
|
|
|
fn editing(s: &Session) -> Option<NodeId> {
|
|
s.ds().unwrap().text_edit.as_ref().map(|te| te.id)
|
|
}
|
|
|
|
#[test]
|
|
fn the_text_on_a_path_tool_types_new_text_onto_the_path_it_clicks() {
|
|
let mut s = Session::new();
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 L200 0", "x": 40, "y": 100, "props": {"fill": "#FF0000"}})).unwrap());
|
|
s.execute("effect.add", &json!({"ids": [v], "type": "dropShadow"})).unwrap();
|
|
let (vxf, vw, fills, effects) = {
|
|
let n = s.doc().unwrap().node(v).unwrap();
|
|
(n.transform, n.width, n.fills.clone(), n.effects.clone())
|
|
};
|
|
assert!(!fills.is_empty() && !effects.is_empty());
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
// Away from the path a click does nothing.
|
|
click(&mut s, 140.0, 160.0);
|
|
assert!(editing(&s).is_none() && s.doc().unwrap().node(v).is_some(), "only a path takes text");
|
|
// A quarter of the way along, a few pixels off the line.
|
|
click(&mut s, 90.0, 103.0);
|
|
let t = editing(&s).expect("typing starts on the path");
|
|
assert!(s.doc().unwrap().node(v).is_none(), "the path layer became the text's path");
|
|
crate::textedit::insert(&mut s, "Along").unwrap();
|
|
crate::textedit::end(&mut s).unwrap();
|
|
let doc = s.doc().unwrap();
|
|
let n = doc.node(t).unwrap();
|
|
assert_eq!((n.transform, n.width), (vxf, vw), "in the path's place");
|
|
assert_eq!(n.kind.text().map(|t| t.characters.as_str()), Some("Along"));
|
|
assert_eq!((&n.fills, &n.effects), (&fills, &effects), "the path's fill and effects carry over to the text");
|
|
let tp = text_path(&s, t).unwrap();
|
|
assert!((tp.start - 0.25).abs() < 0.01, "the text starts where the path was clicked: {}", tp.start);
|
|
assert_eq!(s.tool.tool, crate::tools::ToolId::Move, "back to Move after placing, as with the Text tool");
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
let doc = s.doc().unwrap();
|
|
assert!(doc.node(v).is_some() && doc.node(t).is_none(), "one undo step brings the path back");
|
|
}
|
|
|
|
#[test]
|
|
fn a_shape_in_front_whose_path_is_away_from_the_click_does_not_hide_the_path_behind() {
|
|
let mut s = Session::new();
|
|
let back = id(s.execute("vector.create", &json!({"path": "M0 0 L200 0", "x": 40, "y": 100})).unwrap());
|
|
// A filled square over the line: the click is inside it, 20 or more from its outline.
|
|
let front = id(s.execute("shape.rectangle", &json!({"x": 60, "y": 80, "width": 100, "height": 60})).unwrap());
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
click(&mut s, 90.0, 100.0);
|
|
assert!(editing(&s).is_some(), "typing starts on the path behind");
|
|
let doc = s.doc().unwrap();
|
|
assert!(doc.node(back).is_none() && doc.node(front).is_some(), "the clicked path took the text");
|
|
}
|
|
|
|
#[test]
|
|
fn a_path_scaled_more_one_way_is_reached_where_it_shows() {
|
|
let mut s = Session::new();
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 L100 100", "x": 0, "y": 0})).unwrap());
|
|
// Ten times wider than tall: on the page the line runs from (0, 0) to (1000, 100).
|
|
s.doc_mut().unwrap().get_mut(v).unwrap().transform = figcraft_geom::Affine::scale_non_uniform(10.0, 1.0);
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
// 5 below the line on the page, halfway along it.
|
|
click(&mut s, 500.0, 55.0);
|
|
let t = editing(&s).expect("typing starts on the path");
|
|
let tp = text_path(&s, t).unwrap();
|
|
assert!((tp.start - 0.5).abs() < 0.01, "{}", tp.start);
|
|
// A layer shown at a tenth of its size: its outline is still reached 5 screen pixels away.
|
|
let mut s = Session::new();
|
|
let r = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 1000, "height": 1000})).unwrap());
|
|
s.doc_mut().unwrap().get_mut(r).unwrap().transform = figcraft_geom::Affine::scale(0.1);
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
click(&mut s, 105.0, 50.0);
|
|
assert!(editing(&s).is_some() && s.doc().unwrap().node(r).is_none(), "typing starts on the small square's path");
|
|
}
|
|
|
|
#[test]
|
|
fn paths_a_mask_or_a_turned_clipping_frame_hides_take_no_text() {
|
|
let mut s = Session::new();
|
|
// A square masked by a circle in its top-left corner: its right edge doesn't show.
|
|
let m = id(s.execute("shape.ellipse", &json!({"x": 0, "y": 0, "width": 50, "height": 50})).unwrap());
|
|
let r = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap());
|
|
s.execute("object.mask", &json!({"ids": [m, r]})).unwrap();
|
|
// A clipping frame turned 45°, with a line outside it: inside the frame's bounding box, but clipped.
|
|
let f = id(s.execute("frame.create", &json!({"x": 300, "y": 0, "width": 100, "height": 100, "props": {"clip": true}})).unwrap());
|
|
let l = id(s.execute("vector.create", &json!({"path": "M0 0 L40 0", "x": -60, "y": 50, "parent": f})).unwrap());
|
|
s.execute("node.set", &json!({"id": f, "props": {"rotation": 45}})).unwrap();
|
|
let hidden = s.doc().unwrap().world_transform(l) * figcraft_geom::Point::new(20.0, 0.0);
|
|
let frame_box = s.doc().unwrap().world_bounds(f).unwrap();
|
|
assert!(frame_box.contains(hidden), "the line's middle is inside the frame's bounding box");
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
for (x, y) in [(100.0, 50.0), (hidden.x, hidden.y)] {
|
|
click(&mut s, x, y);
|
|
assert!(editing(&s).is_none(), "nothing shows at ({x}, {y})");
|
|
}
|
|
let doc = s.doc().unwrap();
|
|
assert!(doc.node(r).is_some() && doc.node(l).is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn text_on_a_stroke_only_path_gets_the_usual_fill() {
|
|
let mut s = Session::new();
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 C50 -50 150 -50 200 0", "x": 40, "y": 100, "props": {"fills": []}})).unwrap());
|
|
assert!(!s.doc().unwrap().node(v).unwrap().fills.iter().any(|f| f.visible), "a path with a stroke only");
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
click(&mut s, 40.0, 100.0);
|
|
let t = editing(&s).expect("typing starts on the path");
|
|
assert!(s.doc().unwrap().node(t).unwrap().fills.iter().any(|f| f.visible), "the text can be seen");
|
|
}
|
|
|
|
#[test]
|
|
fn text_on_a_path_left_empty_puts_the_path_back_without_an_undo_step() {
|
|
let mut s = Session::new();
|
|
let r = id(s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap());
|
|
let locked = id(s.execute("shape.rectangle", &json!({"x": 400, "y": 100, "width": 100, "height": 100, "props": {"locked": true}})).unwrap());
|
|
let before = (s.doc().unwrap().clone(), s.undo_labels(100).len());
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
click(&mut s, 400.0, 150.0);
|
|
assert!(editing(&s).is_none(), "a locked layer's path doesn't take text");
|
|
// Inside the square, away from its outline, nothing happens either.
|
|
click(&mut s, 150.0, 150.0);
|
|
assert!(editing(&s).is_none());
|
|
click(&mut s, 100.0, 150.0);
|
|
assert!(editing(&s).is_some() && s.doc().unwrap().node(r).is_none());
|
|
crate::textedit::end(&mut s).unwrap();
|
|
assert_eq!(*s.doc().unwrap(), before.0, "the square is back as it was");
|
|
assert_eq!(s.undo_labels(100).len(), before.1, "no undo step");
|
|
assert!(s.doc().unwrap().node(locked).is_some());
|
|
// A double-click on the path, then nothing typed: the same (with this tool and the Text tool).
|
|
use crate::tools::{PointerEvent, PointerKind, ToolId};
|
|
for tool in [ToolId::TextOnPath, ToolId::Text] {
|
|
s.set_tool(tool);
|
|
click(&mut s, 100.0, 150.0);
|
|
s.pointer(&PointerEvent::at(PointerKind::DoubleClick, 100.0, 150.0, 1.0)).unwrap();
|
|
assert!(editing(&s).is_some(), "{tool:?}");
|
|
crate::textedit::end(&mut s).unwrap();
|
|
assert_eq!(*s.doc().unwrap(), before.0, "{tool:?}: the file is back as it was");
|
|
assert_eq!(s.undo_labels(100).len(), before.1, "{tool:?}: no undo step");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn scaling_text_scales_its_path() {
|
|
let mut s = Session::new();
|
|
let t = id(s.execute("text.create", &json!({"text": "Around", "x": 0, "y": 0})).unwrap());
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 C50 -50 150 -50 200 0", "x": 40, "y": 100})).unwrap());
|
|
s.execute("text.onPath", &json!({"ids": [t, v]})).unwrap();
|
|
let w0 = figcraft_geom::Shape::bounding_box(&text_path(&s, t).unwrap().path()).width();
|
|
s.execute("transform.scale", &json!({"ids": [t], "factor": 2.0})).unwrap();
|
|
let w1 = figcraft_geom::Shape::bounding_box(&text_path(&s, t).unwrap().path()).width();
|
|
assert!((w1 - w0 * 2.0).abs() < 1.0, "path width {w0} -> {w1}");
|
|
}
|
|
|
|
#[test]
|
|
fn svg_text_paths_import_as_text_on_a_path() {
|
|
// SVG text is parsed with Inter standing in for every family (CI has no fonts).
|
|
if figcraft_text::find_face("Inter", "Regular").is_none() {
|
|
eprintln!("no Inter; skipping");
|
|
return;
|
|
}
|
|
let mut s = Session::new();
|
|
let svg = br##"<svg xmlns="http://www.w3.org/2000/svg" width="200" height="100"><path id="p" d="M10 80 Q100 0 190 80" fill="none"/><text font-size="12"><textPath href="#p" startOffset="50%" text-anchor="middle">Curved words</textPath></text></svg>"##;
|
|
let doc = s.doc_mut().unwrap();
|
|
let page = doc.current_page.unwrap();
|
|
figcraft_svg::import_svg(doc, svg, page, 0.0, 0.0, "curve").unwrap();
|
|
let texts: Vec<_> = s.doc().unwrap().nodes().filter_map(|n| n.kind.text().cloned()).collect();
|
|
let t = texts.iter().find(|t| t.characters == "Curved words").expect("a text layer");
|
|
let tp = t.path.as_ref().expect("on a path");
|
|
assert!((tp.start - 0.5).abs() < 0.01, "{}", tp.start);
|
|
assert_eq!(t.align_h, figcraft_doc::TextAlignH::Center);
|
|
}
|
|
|
|
/// A text layer with its own green fill bound to `ink` and a layer blur, and a curve; the
|
|
/// variables `ink` and `shadow` exist.
|
|
fn text_and_curve(s: &mut Session, path_props: Value) -> (NodeId, NodeId) {
|
|
let t = id(s.execute("text.create", &json!({"text": "Around", "x": 0, "y": 0})).unwrap());
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 C50 -50 150 -50 200 0", "x": 40, "y": 100, "props": path_props})).unwrap());
|
|
s.execute("variable.createCollection", &json!({"name": "Paint"})).unwrap();
|
|
for (name, value) in [("ink", "#00FF00"), ("shadow", "#FF000080")] {
|
|
s.execute("variable.create", &json!({"collection": "Paint", "name": name, "type": "color", "value": value})).unwrap();
|
|
}
|
|
s.execute("variable.bind", &json!({"ids": [t], "field": "fills/0/color", "variable": "ink"})).unwrap();
|
|
s.execute("effect.add", &json!({"ids": [t], "type": "layerBlur"})).unwrap();
|
|
(t, v)
|
|
}
|
|
|
|
#[test]
|
|
fn text_put_on_a_filled_path_takes_its_fill_and_effects() {
|
|
let mut s = Session::new();
|
|
let (t, v) = text_and_curve(&mut s, json!({"fill": "#FF0000"}));
|
|
let brand = s.execute("style.create", &json!({"type": "paint", "name": "Brand", "value": "#3366FF"})).unwrap()["id"].clone();
|
|
s.execute("style.apply", &json!({"ids": [v], "style": brand})).unwrap();
|
|
s.execute("effect.add", &json!({"ids": [v], "type": "dropShadow"})).unwrap();
|
|
s.execute("variable.bind", &json!({"ids": [v], "field": "effects/0/color", "variable": "shadow"})).unwrap();
|
|
let path = s.doc().unwrap().node(v).unwrap().clone();
|
|
let text = s.doc().unwrap().node(t).unwrap().clone();
|
|
assert!(path.styles.fill.is_some() && path.bound.contains_key("effects/0/color"));
|
|
s.execute("text.onPath", &json!({"ids": [t, v]})).unwrap();
|
|
let n = s.doc().unwrap().node(t).unwrap();
|
|
// "the vector object's fill and effects are automatically transferred to the text layer"
|
|
assert_eq!((&n.fills, &n.styles.fill), (&path.fills, &path.styles.fill), "the path's fill and its style");
|
|
assert_eq!((&n.effects, &n.styles.effect), (&path.effects, &path.styles.effect), "the path's effects");
|
|
assert_eq!(n.bound, path.bound, "the path's bindings replace the text's fill binding");
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
let n = s.doc().unwrap().node(t).unwrap();
|
|
assert_eq!((&n.fills, &n.styles.fill), (&text.fills, &text.styles.fill), "undo gives the text its own fill back");
|
|
assert_eq!((&n.effects, &n.styles.effect), (&text.effects, &text.styles.effect), "undo gives the text its own effects back");
|
|
assert_eq!(n.bound, text.bound, "undo gives the text its own fill binding back");
|
|
}
|
|
|
|
#[test]
|
|
fn text_put_on_a_stroke_only_path_keeps_its_own_fill_and_effects() {
|
|
let mut s = Session::new();
|
|
let (t, v) = text_and_curve(&mut s, json!({"fills": []}));
|
|
let text = s.doc().unwrap().node(t).unwrap().clone();
|
|
assert!(!text.fills.is_empty() && !text.effects.is_empty());
|
|
s.execute("text.onPath", &json!({"ids": [t, v]})).unwrap();
|
|
let n = s.doc().unwrap().node(t).unwrap();
|
|
assert_eq!((&n.fills, &n.effects, &n.bound), (&text.fills, &text.effects, &text.bound), "a path with no fill or effects to give");
|
|
}
|
|
|
|
#[test]
|
|
fn text_put_on_a_path_with_an_empty_effect_style_keeps_its_own_effects() {
|
|
let mut s = Session::new();
|
|
let (t, v) = text_and_curve(&mut s, json!({"fills": []}));
|
|
let none = s.execute("style.create", &json!({"type": "effect", "name": "None", "value": []})).unwrap()["id"].clone();
|
|
s.execute("style.apply", &json!({"ids": [v], "style": none})).unwrap();
|
|
let path = s.doc().unwrap().node(v).unwrap().clone();
|
|
assert!(path.effects.is_empty() && path.styles.effect.is_some());
|
|
let text = s.doc().unwrap().node(t).unwrap().clone();
|
|
s.execute("text.onPath", &json!({"ids": [t, v]})).unwrap();
|
|
let n = s.doc().unwrap().node(t).unwrap();
|
|
assert_eq!((&n.effects, &n.styles.effect), (&text.effects, &text.styles.effect), "a path whose effect style draws no effects");
|
|
}
|
|
|
|
#[test]
|
|
fn text_put_on_a_path_takes_a_fill_binding_made_through_fills() {
|
|
let mut s = Session::new();
|
|
let (t, v) = text_and_curve(&mut s, json!({"fill": "#FF0000"}));
|
|
s.execute("variable.bind", &json!({"ids": [v], "field": "fills", "variable": "shadow"})).unwrap();
|
|
s.execute("variable.bind", &json!({"ids": [t], "field": "fills", "variable": "ink"})).unwrap();
|
|
let path = s.doc().unwrap().node(v).unwrap().clone();
|
|
assert!(path.bound.contains_key("fills"));
|
|
s.execute("text.onPath", &json!({"ids": [t, v]})).unwrap();
|
|
let n = s.doc().unwrap().node(t).unwrap();
|
|
assert_eq!(n.bound, path.bound, "the path's `fills` binding replaces the text's");
|
|
assert_eq!(n.fills, path.fills);
|
|
}
|
|
|
|
#[test]
|
|
fn pattern_fills_tile_their_source_live() {
|
|
let mut s = Session::new();
|
|
let tile = id(s.execute("shape.rectangle", &json!({"x": 500, "y": 0, "width": 10, "height": 10})).unwrap());
|
|
s.execute("fill.set", &json!({"ids": [tile], "color": "#FF0000"})).unwrap();
|
|
let r = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap());
|
|
s.execute("fill.set", &json!({"ids": [r], "color": "#FFFFFF"})).unwrap();
|
|
s.execute("fill.add", &json!({"ids": [r]})).unwrap();
|
|
assert!(s.execute("fill.pattern", &json!({"ids": [r], "source": r})).is_err(), "not itself");
|
|
s.execute("fill.pattern", &json!({"ids": [r], "source": tile, "spacing": [10, 10]})).unwrap();
|
|
assert!(matches!(&s.doc().unwrap().node(r).unwrap().fills[1].kind, PaintKind::Pattern(p) if p.source == tile.0 && p.spacing == (10.0, 10.0)));
|
|
assert_eq!(pixel(&s, r, 5, 5), [255, 0, 0, 255]);
|
|
assert_eq!(pixel(&s, r, 15, 5), [255, 255, 255, 255], "the gap shows the fill below");
|
|
assert_eq!(pixel(&s, r, 45, 45), [255, 0, 0, 255]);
|
|
// Live: recolouring the source recolours the tiles.
|
|
s.execute("fill.set", &json!({"ids": [tile], "color": "#0000FF"})).unwrap();
|
|
assert_eq!(pixel(&s, r, 5, 5), [0, 0, 255, 255]);
|
|
// Half-shifted rows.
|
|
s.execute("fill.pattern", &json!({"ids": [r], "source": tile, "spacing": [10, 10], "tile": "horizontalHex"})).unwrap();
|
|
assert_eq!(pixel(&s, r, 15, 25), [0, 0, 255, 255]);
|
|
assert_eq!(pixel(&s, r, 5, 25), [255, 255, 255, 255]);
|
|
// A copy of the source together with the layer tiles the copied source.
|
|
s.execute("object.group", &json!({"ids": [tile, r]})).unwrap();
|
|
s.execute("edit.duplicate", &json!({})).unwrap();
|
|
let doc = s.doc().unwrap();
|
|
let sources: Vec<u64> = doc
|
|
.nodes()
|
|
.flat_map(|n| n.fills.iter())
|
|
.filter_map(|p| match &p.kind {
|
|
PaintKind::Pattern(pt) => Some(pt.source),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
assert_eq!(sources.len(), 2);
|
|
assert_ne!(sources[0], sources[1], "each copy tiles its own source");
|
|
// Exports: SVG as a <pattern> of vectors, PDF without failing.
|
|
let svg = figcraft_svg::export_svg(doc, &[r], &figcraft_svg::SvgOptions::default()).unwrap();
|
|
assert!(svg.contains("<pattern") && svg.contains("fill=\"url(#pattern"), "{svg}");
|
|
assert!(figcraft_pdf::export_nodes_pdf(doc, &[r]).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn a_pattern_of_itself_draws_nothing_instead_of_recursing() {
|
|
let mut s = Session::new();
|
|
let r = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 40, "height": 40})).unwrap());
|
|
// Hand-written (the command refuses this): the layer tiles itself.
|
|
s.execute("fill.set", &json!({"ids": [r], "paint": {"type": "pattern", "source": r.0, "scale": 0.25}})).unwrap();
|
|
let doc = s.doc().unwrap();
|
|
assert!(figcraft_render::render_node(doc, r, 1.0).is_some());
|
|
assert!(figcraft_svg::export_svg(doc, &[r], &figcraft_svg::SvgOptions::default()).is_some());
|
|
assert!(figcraft_pdf::export_nodes_pdf(doc, &[r]).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn the_text_on_a_path_tool_carries_a_fill_bound_through_fills() {
|
|
let mut s = Session::new();
|
|
let v = id(s.execute("vector.create", &json!({"path": "M0 0 L200 0", "x": 40, "y": 100, "props": {"fill": "#FF0000"}})).unwrap());
|
|
s.execute("variable.createCollection", &json!({"name": "Paint"})).unwrap();
|
|
s.execute("variable.create", &json!({"collection": "Paint", "name": "ink", "type": "color", "value": "#00FF00"})).unwrap();
|
|
s.execute("variable.bind", &json!({"ids": [v], "field": "fills", "variable": "ink"})).unwrap();
|
|
let bound = s.doc().unwrap().node(v).unwrap().bound.clone();
|
|
assert!(bound.contains_key("fills"));
|
|
s.set_tool(crate::tools::ToolId::TextOnPath);
|
|
click(&mut s, 90.0, 103.0);
|
|
let t = editing(&s).expect("typing starts on the path");
|
|
assert_eq!(s.doc().unwrap().node(t).unwrap().bound, bound, "the fill keeps following its variable");
|
|
}
|