2bc41aeb8602
previewbounds.rs
//! Use Preview Bounds: the Transform panel values, the bounding box, Align and Distribute measure
//! visual bounds (strokes, geometry and projected 3D effects included) when it is on.
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Document, Effect, Node, NodeId, NodeKind, Symbol};
use vectorcraft_geom::{Affine, Point, Rect, shapes};
use vectorcraft_tools::{Cursor, Mods, PointerEvent, PointerKind};
use crate::*;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
s
}
fn run(s: &mut Session, id: &str, p: Value) -> Value {
s.execute(id, &p).unwrap_or_else(|e| panic!("{id}: {e}"))
}
/// A rectangle with a `weight` pt stroke (0: no stroke).
fn rect(s: &mut Session, x: f64, w: f64, weight: f64) -> NodeId {
let id = NodeId(run(s, "shape.rectangle", json!({"x": x, "y": 100, "width": w, "height": 50}))["id"].as_u64().unwrap());
if weight > 0.0 {
run(s, "stroke.set", json!({"weight": weight}));
} else {
run(s, "paint.setStroke", json!({"none": true}));
}
id
}
fn geometric(s: &Session, id: NodeId) -> Rect {
s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap()
}
fn preview(s: &mut Session, on: bool) {
run(s, "prefs.set", json!({"key": "usePreviewBounds", "value": on}));
}
/// Two rectangles: one with a 10 pt stroke at x = 100, an unstroked one at x = 20; align left.
fn aligned_left(on: bool, p: Value) -> f64 {
let mut s = session();
let a = rect(&mut s, 100.0, 50.0, 10.0);
rect(&mut s, 20.0, 50.0, 0.0);
preview(&mut s, on);
run(&mut s, "select.all", json!({}));
let mut p = p;
p["horizontal"] = json!("left");
run(&mut s, "object.align", p);
geometric(&s, a).x0
}
#[test]
fn align_left_differs_by_half_the_stroke() {
assert_eq!(aligned_left(false, json!({})), 20.0);
// The 10 pt stroke's outer edge lines up with the other object: the path sits 5 pt in.
assert_eq!(aligned_left(true, json!({})), 25.0);
// `bounds` overrides the preference either way.
assert_eq!(aligned_left(true, json!({"bounds": "geometric"})), 20.0);
assert_eq!(aligned_left(false, json!({"bounds": "preview"})), 25.0);
let mut s = session();
rect(&mut s, 0.0, 10.0, 0.0);
assert!(s.execute("object.align", &json!({"horizontal": "left", "bounds": "visual"})).is_err());
}
#[test]
fn distribute_spacing_measures_preview_bounds() {
let mut s = session();
let a = rect(&mut s, 0.0, 50.0, 10.0);
let b = rect(&mut s, 200.0, 50.0, 10.0);
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
run(&mut s, "object.distributeSpacing", json!({"axis": "horizontal", "spacing": 0}));
// The strokes touch: the paths are a stroke weight apart.
assert_eq!(geometric(&s, b).x0 - geometric(&s, a).x1, 10.0);
}
/// A 100 pt square at (`x`, 100) without a stroke, with Offset Path 10.
fn offset_square(s: &mut Session, x: f64) -> NodeId {
let id = NodeId(run(s, "shape.rectangle", json!({"x": x, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
run(s, "paint.setStroke", json!({"none": true}));
run(s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 10}, "ids": [id.0], "item": null}));
id
}
/// Point type `text` (48 pt) at (`x`, 100) with Outline Object.
fn outlined_type(s: &mut Session, x: f64, text: &str) -> NodeId {
let id = NodeId(run(s, "text.create", json!({"x": x, "y": 100, "text": text, "size": 48}))["id"].as_u64().unwrap());
run(s, "effect.apply", json!({"effect": "path.outlineObject", "ids": [id.0], "item": null}));
id
}
/// The box of the glyph outlines that type `id` with Outline Object is drawn as.
fn glyphs(s: &Session, id: NodeId) -> Rect {
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
vectorcraft_render::effects::reshape(None, &n, None).unwrap().geometric_bounds().unwrap()
}
fn near(a: Rect, b: Rect, tolerance: f64) -> bool {
[(a.x0, b.x0), (a.y0, b.y0), (a.x1, b.x1), (a.y1, b.y1)].iter().all(|(x, y)| (x - y).abs() <= tolerance)
}
const PREVIEW_3D: [&str; 4] = ["threeD.extrude", "threeD.revolve", "threeD.inflate", "threeD.rotate"];
/// A live projected rectangle, with the effect on the object or its painted fill.
fn projected_rect(s: &mut Session, effect: &str, item: bool) -> NodeId {
let id = rect(s, 100.0, 80.0, 0.0);
run(s, "effect.apply", json!({"ids": [id.0], "effect": effect, "params": params_3d(effect), "item": if item { json!(0) } else { Value::Null }}));
id
}
/// Settings for `effect` that turn the art and give it depth.
fn params_3d(effect: &str) -> Value {
let mut params = json!({"rotationX": -20, "rotationY": 35, "rotationZ": 15, "perspectiveAngle": 0, "shade": false});
match effect {
"threeD.revolve" => {
params["segments"] = json!(8);
params["angle"] = json!(240);
params["offset"] = json!(12);
}
"threeD.extrude" => {
params["depth"] = json!(40);
params["bevel"] = json!("rounded");
}
"threeD.inflate" => params["depth"] = json!(20),
_ => {}
}
params
}
/// Measure the renderer's projected vector art, including any geometry effects left after 3D.
fn projected(s: &Session, id: NodeId) -> Rect {
let d = &s.doc().unwrap().doc;
let n = d.node(id).unwrap();
let art = vectorcraft_render::effects::revolve_art(n).or_else(|| vectorcraft_render::effects::solid_art(n)).unwrap();
vectorcraft_render::effects::preview::visual_bounds(&d.symbol_boxes(), &art).unwrap()
}
/// All four projected effects contribute at object and item scope; off and hidden keep source bounds.
#[test]
fn preview_3d_measures_the_projected_art_at_object_and_item_scope() {
for effect in PREVIEW_3D {
for item in [false, true] {
let mut s = session();
let id = projected_rect(&mut s, effect, item);
let expected = projected(&s, id);
let source = geometric(&s, id);
assert!(!near(expected, source, 1e-3), "the fixture must change its bounds: {effect}");
preview(&mut s, true);
assert!(near(s.transform_bounds(&[id]).unwrap(), expected, 1e-6), "{effect}, item={item}");
preview(&mut s, false);
assert_eq!(s.transform_bounds(&[id]), Some(source));
preview(&mut s, true);
run(&mut s, "effect.setParams", json!({"ids": [id.0], "index": 0, "item": if item { json!(0) } else { Value::Null }, "visible": false}));
assert_eq!(s.transform_bounds(&[id]), Some(source), "hidden {effect}, item={item}");
}
}
}
/// Align and spacing use projected edges, with one undo step and no repeat-alignment edit.
#[test]
fn preview_3d_align_and_spacing_measure_projected_edges() {
for effect in PREVIEW_3D {
let mut s = session();
let a = projected_rect(&mut s, effect, false);
let b = rect(&mut s, 20.0, 30.0, 0.0);
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
let before = s.doc().unwrap().doc.clone();
let history = s.doc().unwrap().history.undo.len();
run(&mut s, "object.align", json!({"horizontal": "left"}));
assert!((projected(&s, a).x0 - geometric(&s, b).x0).abs() < 1e-6, "{effect}");
assert_eq!(s.doc().unwrap().history.undo.len(), history + 1);
let aligned = s.doc().unwrap().doc.clone();
run(&mut s, "object.align", json!({"horizontal": "left"}));
assert_eq!(s.doc().unwrap().history.undo.len(), history + 1, "already aligned {effect}");
assert_eq!(s.doc().unwrap().doc, aligned);
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc().unwrap().doc, before);
run(&mut s, "edit.redo", json!({}));
assert_eq!(s.doc().unwrap().doc, aligned);
let mut s = session();
let a = projected_rect(&mut s, effect, false);
let b = rect(&mut s, 350.0, 30.0, 0.0);
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
let before = s.doc().unwrap().doc.clone();
run(&mut s, "object.distributeSpacing", json!({"axis": "horizontal", "spacing": 0}));
assert!((projected(&s, a).x1 - geometric(&s, b).x0).abs() < 1e-6, "{effect}");
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc().unwrap().doc, before);
}
}
/// A group's and a symbol's projected members are measured as art rather than flat source paths.
#[test]
fn preview_3d_measures_projected_group_and_symbol_members() {
for effect in PREVIEW_3D {
let mut source = session();
let source_id = projected_rect(&mut source, effect, false);
let expected = projected(&source, source_id);
let mut d = Document::new(600.0, 400.0);
let mut shape = source.doc().unwrap().doc.node(source_id).unwrap().clone();
shape.id = d.alloc_id();
let group = Node::group(d.alloc_id(), vec![Arc::new(shape.clone())]);
let group_id = group.id;
let layer = d.layers[0].id;
d.insert(Some(layer), 0, group).unwrap();
shape.id = d.alloc_id();
d.symbols.push(Symbol { dynamic: false, name: "3D / Bounds".into(), art: Arc::new(shape) });
let shift = Affine::translate((250.0, 0.0));
let instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "3D / Bounds".into(), xf: shift });
let instance_id = instance.id;
d.insert(Some(layer), 1, instance).unwrap();
let mut s = Session::new();
s.add_document(d, None);
preview(&mut s, true);
assert!(near(s.transform_bounds(&[group_id]).unwrap(), expected, 1e-6), "group {effect}");
assert!(near(s.transform_bounds(&[instance_id]).unwrap(), shift.transform_rect_bbox(expected), 1e-6), "symbol {effect}");
}
}
/// A symbol instance with a 3D effect of its own is measured by the art the renderer projects from its symbol.
#[test]
fn preview_3d_measures_an_instance_with_its_own_effect() {
for effect in PREVIEW_3D {
let mut d = Document::new(600.0, 400.0);
let square = Node::path(
d.alloc_id(),
shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 80.0)),
Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0),
);
d.symbols.push(Symbol { dynamic: false, name: "3D / Own".into(), art: Arc::new(square) });
let instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "3D / Own".into(), xf: Affine::translate((50.0, 40.0)) });
let (layer, id) = (d.layers[0].id, instance.id);
d.insert(Some(layer), 0, instance).unwrap();
let mut s = Session::new();
s.add_document(d, None);
run(&mut s, "effect.apply", json!({"ids": [id.0], "effect": effect, "params": params_3d(effect)}));
let d = &s.doc().unwrap().doc;
let n = d.node(id).unwrap();
let art = vectorcraft_render::effects::revolve_art_in(Some(d), n).or_else(|| vectorcraft_render::effects::solid_art_in(Some(d), n)).unwrap();
let expected = vectorcraft_render::effects::preview::visual_bounds(&d.symbol_boxes(), &art).unwrap();
let source = geometric(&s, id);
assert!(!near(expected, source, 1e-3), "the fixture must change its bounds: {effect}");
preview(&mut s, true);
assert!(near(s.transform_bounds(&[id]).unwrap(), expected, 1e-6), "{effect}");
}
}
/// Dynamic instance overrides are applied before deciding which painted 3D surfaces remain.
#[test]
fn preview_3d_dynamic_symbol_overrides_precede_projection() {
for effect in PREVIEW_3D {
let mut source = session();
let source_id = projected_rect(&mut source, effect, false);
let full = projected(&source, source_id);
let mut d = Document::new(600.0, 400.0);
let mut art = source.doc().unwrap().doc.node(source_id).unwrap().clone();
art.id = d.alloc_id();
d.symbols.push(Symbol { dynamic: true, name: "3D / Dynamic".into(), art: Arc::new(art) });
let mut instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "3D / Dynamic".into(), xf: Affine::IDENTITY });
instance
.extras_mut()
.symbol_overrides
.push(vectorcraft_doc::symbol_overrides::SymbolOverride { fill: Some(Paint::None), ..Default::default() });
let id = instance.id;
let changed = vectorcraft_doc::symbol_overrides::dynamic_art(&d.symbols[0].art, &instance);
let expected = vectorcraft_render::effects::preview::visual_bounds(&d.symbol_boxes(), &changed);
if effect == "threeD.extrude" {
assert!(expected.is_some(), "the Extrude fixture must retain its source bounds");
}
assert!(expected.is_none_or(|b| !near(b, full, 1e-3)), "the override must remove the projected surface: {effect}");
let layer = d.layers[0].id;
d.insert(Some(layer), 0, instance).unwrap();
let mut s = Session::new();
s.add_document(d, None);
preview(&mut s, true);
let actual = s.transform_bounds(&[id]);
assert!(
match (actual, expected) {
(Some(a), Some(b)) => near(a, b, 1e-6),
(None, None) => true,
_ => false,
},
"overridden {effect}: {actual:?}, expected {expected:?}"
);
run(&mut s, "symbol.instance.reset", json!({"ids": [id.0]}));
assert!(near(s.transform_bounds(&[id]).unwrap(), full, 1e-6), "reset {effect}");
}
}
/// Geometry after projection remains part of the measured stack at object and item scope.
#[test]
fn preview_3d_applies_geometry_after_the_projected_surface() {
for effect in PREVIEW_3D {
for item in [false, true] {
let mut s = session();
let id = projected_rect(&mut s, effect, item);
run(
&mut s,
"effect.apply",
json!({"ids": [id.0], "effect": "path.offsetPath", "params": {"offset": 5}, "item": if item { json!(0) } else { Value::Null }}),
);
let expected = projected(&s, id);
preview(&mut s, true);
assert!(near(s.transform_bounds(&[id]).unwrap(), expected, 1e-6), "{effect}, item={item}");
}
}
}
/// Typed width sizes the projected art and remains one undoable edit.
#[test]
fn preview_3d_set_bounds_sizes_the_projected_width() {
for effect in PREVIEW_3D {
let mut s = session();
let id = projected_rect(&mut s, effect, false);
let target = projected(&s, id).width() * 1.25;
preview(&mut s, true);
let before = s.doc().unwrap().doc.clone();
let history = s.doc().unwrap().history.undo.len();
run(&mut s, "object.setBounds", json!({"width": target, "reference": 0, "proportional": true, "strokes": false}));
assert!((projected(&s, id).width() - target).abs() < 1e-4, "{effect}: {:?}, target {target}", projected(&s, id));
assert_eq!(s.doc().unwrap().history.undo.len(), history + 1);
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc().unwrap().doc, before);
}
}
/// A rotated selection measures the projected surface in its own bounding-box frame.
#[test]
fn preview_3d_oriented_box_follows_projected_art() {
for effect in PREVIEW_3D {
let mut s = session();
let id = projected_rect(&mut s, effect, false);
run(&mut s, "object.rotate", json!({"angle": 30}));
let d = &s.doc().unwrap().doc;
let angle = d.bbox_angle(&[id]);
assert!(angle.abs() > 0.1);
let n = d.node(id).unwrap();
let art = vectorcraft_render::effects::revolve_art(n).or_else(|| vectorcraft_render::effects::solid_art(n)).unwrap();
let frame = vectorcraft_doc::OrientedBox { angle, rect: Rect::ZERO }.to_doc().inverse();
let expected = vectorcraft_render::effects::preview::bounds_in(&d.symbol_boxes(), &art, frame).unwrap();
preview(&mut s, true);
let measured = s.transform_box(&[id]).unwrap();
assert_eq!(measured.angle, angle);
assert!(near(measured.rect, expected, 1e-6), "{effect}: {measured:?} vs {expected:?}");
}
}
/// A click on a member of a layer with a 3D effect selects that member, with Use Preview Bounds on
/// or off, and the layer is still measured by its projected art.
#[test]
fn a_click_selects_the_member_of_a_layer_with_a_3d_effect() {
for effect in PREVIEW_3D {
for on in [false, true] {
let mut s = session();
let id = rect(&mut s, 100.0, 80.0, 0.0);
run(&mut s, "paint.setFill", json!({"color": "#0000ff"}));
let layer = s.doc().unwrap().doc.layers[0].id;
run(&mut s, "effect.apply", json!({"ids": [layer.0], "effect": effect, "params": params_3d(effect), "item": null}));
preview(&mut s, on);
run(&mut s, "select.none", json!({}));
let v = ViewInfo::default();
s.select_tool("selection", v).unwrap();
for k in [PointerKind::Down, PointerKind::Up] {
s.pointer(&PointerEvent::new(k, 140.0, 125.0), v).unwrap();
}
assert_eq!(s.active().unwrap().selection.objects, [id], "{effect}, preview={on}");
let d = &s.doc().unwrap().doc;
let art =
vectorcraft_render::effects::revolve_art(&d.layers[0]).or_else(|| vectorcraft_render::effects::solid_art(&d.layers[0])).unwrap();
let expected = vectorcraft_render::effects::preview::visual_bounds(&d.symbol_boxes(), &art).unwrap();
let measured = vectorcraft_render::effects::preview::bounds_of(d, &[layer], true).unwrap();
assert!(near(measured, expected, 1e-6), "{effect}: {measured:?} vs {expected:?}");
}
}
}
#[test]
fn a_square_with_offset_path_is_measured_by_the_offset_shape() {
let mut s = session();
let a = offset_square(&mut s, 100.0);
preview(&mut s, true);
assert!(near(s.transform_bounds(&[a]).unwrap(), Rect::new(90.0, 90.0, 210.0, 210.0), 1e-6), "{:?}", s.transform_bounds(&[a]));
// Align left with an unstroked rectangle at x 20: the offset shape's left edge lines up with it.
rect(&mut s, 20.0, 50.0, 0.0);
run(&mut s, "select.all", json!({}));
run(&mut s, "object.align", json!({"horizontal": "left"}));
assert!((geometric(&s, a).x0 - 30.0).abs() < 1e-6, "{:?}", geometric(&s, a));
// Distribute Spacing 0: the offset shapes touch, so the squares are 20 pt apart.
let mut s = session();
let (a, b) = (offset_square(&mut s, 0.0), offset_square(&mut s, 300.0));
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
run(&mut s, "object.distributeSpacing", json!({"axis": "horizontal", "spacing": 0}));
assert!((geometric(&s, b).x0 - geometric(&s, a).x1 - 20.0).abs() < 1e-6);
}
#[test]
fn a_stroke_with_offset_path_of_its_own_is_measured_where_it_paints() {
// A 100 pt square with a 10 pt stroke whose own Offset Path 10 moves it 10 pt out: the stroke
// paints from 15 pt outside the square to 5 pt outside it.
let mut s = session();
let id = NodeId(run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
run(&mut s, "stroke.set", json!({"weight": 10}));
let items = s.doc().unwrap().doc.node(id).unwrap().appearance.items.clone();
let stroke = items.iter().position(|i| matches!(i, vectorcraft_doc::AppearanceItem::Stroke(_))).unwrap();
run(&mut s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 10}, "ids": [id.0], "item": stroke}));
preview(&mut s, true);
assert!(near(s.transform_bounds(&[id]).unwrap(), Rect::new(85.0, 85.0, 215.0, 215.0), 1e-6), "{:?}", s.transform_bounds(&[id]));
}
#[test]
fn a_groups_own_stroke_with_offset_path_is_measured_where_it_paints() {
// A group of an unstroked 100 pt square, with a 10 pt stroke of its own whose Offset Path 10
// moves it 10 pt out: the stroke paints from 15 pt outside the square to 5 pt outside it.
let mut s = session();
run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}));
run(&mut s, "paint.setStroke", json!({"none": true}));
let g = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
run(&mut s, "appearance.addStroke", json!({"ids": [g.0]}));
run(&mut s, "paint.setStroke", json!({"ids": [g.0], "item": 0, "color": "#000000"}));
run(&mut s, "stroke.set", json!({"ids": [g.0], "item": 0, "weight": 10}));
run(&mut s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 10}, "ids": [g.0], "item": 0}));
preview(&mut s, true);
assert!(near(s.transform_bounds(&[g]).unwrap(), Rect::new(85.0, 85.0, 215.0, 215.0), 1e-6), "{:?}", s.transform_bounds(&[g]));
}
#[test]
fn a_groups_own_fill_is_measured_on_its_members_where_they_are() {
// A group with a fill of its own around a 100 pt square whose fill a Transform effect moves
// 100 pt right: the group's fill paints the square where it is, and the square's own fill
// paints 100 pt to the right of it.
let mut s = session();
let id = NodeId(run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
run(&mut s, "paint.setStroke", json!({"none": true}));
let items = s.doc().unwrap().doc.node(id).unwrap().appearance.items.clone();
let fill = items.iter().position(|i| i.is_fill()).unwrap();
run(&mut s, "effect.apply", json!({"effect": "distort.transform", "params": {"moveH": 100}, "ids": [id.0], "item": fill}));
let g = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
run(&mut s, "appearance.addFill", json!({"ids": [g.0]}));
run(&mut s, "paint.setFill", json!({"ids": [g.0], "item": 0, "color": "#000000"}));
preview(&mut s, true);
assert!(near(s.transform_bounds(&[g]).unwrap(), Rect::new(100.0, 100.0, 300.0, 200.0), 1e-6), "{:?}", s.transform_bounds(&[g]));
}
#[test]
fn a_clip_group_is_measured_where_its_clipping_paths_stroke_paints() {
// A 200 pt square clipped by a 100 pt square at (100, 100) with Offset Path 20. The clipped art
// is clipped by the square without the offset, so the group is measured by that square.
let mut s = session();
let content = NodeId(run(&mut s, "shape.rectangle", json!({"x": 50, "y": 50, "width": 200, "height": 200}))["id"].as_u64().unwrap());
let path = NodeId(run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
run(&mut s, "select.set", json!({"ids": [content.0, path.0]}));
let clip = NodeId(run(&mut s, "object.clippingMask.make", json!({}))["id"].as_u64().unwrap());
run(&mut s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 20}, "ids": [path.0], "item": null}));
preview(&mut s, true);
let square = Rect::new(100.0, 100.0, 200.0, 200.0);
assert!(near(s.transform_bounds(&[clip]).unwrap(), square, 1e-6), "{:?}", s.transform_bounds(&[clip]));
// A 4 pt stroke on the clipping path paints along the offset shape, over the clipped art, from
// 78 to 222.
run(&mut s, "paint.setStroke", json!({"ids": [path.0], "color": "#000000"}));
run(&mut s, "stroke.set", json!({"ids": [path.0], "weight": 4}));
let stroked = Rect::new(78.0, 78.0, 222.0, 222.0);
assert!(near(s.transform_bounds(&[clip]).unwrap(), stroked, 1e-6), "{:?}", s.transform_bounds(&[clip]));
// A fill of the clip group's own keeps that box.
run(&mut s, "appearance.addFill", json!({"ids": [clip.0]}));
run(&mut s, "paint.setFill", json!({"ids": [clip.0], "item": 0, "color": "#000000"}));
assert!(near(s.transform_bounds(&[clip]).unwrap(), stroked, 1e-6), "with a fill: {:?}", s.transform_bounds(&[clip]));
// Turned 30°, the box keeps that size.
run(&mut s, "select.set", json!({"ids": [clip.0]}));
run(&mut s, "object.rotate", json!({"angle": 30}));
let turned = s.transform_box(&[clip]).unwrap();
assert!(
(turned.angle - 30.0).abs() < 1e-9 && (turned.rect.width() - 144.0).abs() < 1e-6 && (turned.rect.height() - 144.0).abs() < 1e-6,
"{turned:?}"
);
// In a group, the clip group is measured the same way.
run(&mut s, "object.rotate", json!({"angle": -30}));
let group = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
assert!(near(s.transform_bounds(&[group]).unwrap(), stroked, 1e-6), "{:?}", s.transform_bounds(&[group]));
// Without Use Preview Bounds, the clipping path's geometry is measured.
preview(&mut s, false);
assert!(near(s.transform_bounds(&[clip]).unwrap(), square, 1e-6), "{:?}", s.transform_bounds(&[clip]));
}
#[test]
fn only_fills_and_strokes_that_paint_are_measured() {
let item = |s: &Session, id: NodeId, fill: bool| {
let items = s.doc().unwrap().doc.node(id).unwrap().appearance.items.clone();
items.iter().position(|i| i.is_fill() == fill).unwrap()
};
// A 100 pt square without a stroke whose fill a Transform effect moves 100 pt right is measured
// where the fill paints, not where the path is.
let mut s = session();
let id = NodeId(run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
run(&mut s, "paint.setStroke", json!({"none": true}));
let fill = item(&s, id, true);
run(&mut s, "effect.apply", json!({"effect": "distort.transform", "params": {"moveH": 100}, "ids": [id.0], "item": fill}));
preview(&mut s, true);
assert!(near(s.transform_bounds(&[id]).unwrap(), Rect::new(200.0, 100.0, 300.0, 200.0), 1e-6), "{:?}", s.transform_bounds(&[id]));
// A hidden 10 pt stroke with Offset Path 10 of its own adds nothing to the box of the square,
// which Offset Path 5 of the object's own takes 5 pt out.
let mut s = session();
let id = NodeId(run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
run(&mut s, "stroke.set", json!({"weight": 10}));
let stroke = item(&s, id, false);
run(&mut s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 10}, "ids": [id.0], "item": stroke}));
run(&mut s, "appearance.setItem", json!({"index": stroke, "visible": false, "ids": [id.0]}));
preview(&mut s, true);
assert!(near(s.transform_bounds(&[id]).unwrap(), Rect::new(100.0, 100.0, 200.0, 200.0), 1e-6), "{:?}", s.transform_bounds(&[id]));
run(&mut s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 5}, "ids": [id.0], "item": null}));
assert!(near(s.transform_bounds(&[id]).unwrap(), Rect::new(95.0, 95.0, 205.0, 205.0), 1e-6), "{:?}", s.transform_bounds(&[id]));
}
#[test]
fn type_with_outline_object_aligns_by_its_glyphs() {
// "ace" has no ascender or descender; "Tg" has a capital and a descender. Aligned top, their
// glyph tops line up; aligned bottom, the bottom of the g lines up with the bottom of "ace".
let edge = |vertical: &str| {
let mut s = session();
let a = outlined_type(&mut s, 20.0, "ace");
let b = outlined_type(&mut s, 200.0, "Tg");
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
run(&mut s, "object.align", json!({"vertical": vertical}));
let (a, b) = (glyphs(&s, a), glyphs(&s, b));
if vertical == "top" { (a.y0, b.y0) } else { (a.y1, b.y1) }
};
for vertical in ["top", "bottom"] {
let (a, b) = edge(vertical);
assert!((a - b).abs() < 1e-6, "{vertical}: {a} and {b}");
}
}
#[test]
fn type_with_outline_object_measures_as_its_outlines() {
let mut s = session();
let id = outlined_type(&mut s, 40.0, "Outline");
preview(&mut s, true);
let measured = s.transform_bounds(&[id]).unwrap();
assert!(near(measured, glyphs(&s, id), 1e-9), "{measured:?}");
// The type's Create Outlines copy has the same visual box.
run(&mut s, "select.set", json!({"ids": [id.0]}));
let outlines: Vec<NodeId> =
run(&mut s, "type.createOutlines", json!({}))["ids"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
let copy = s.doc().unwrap().doc.bounds_of(&outlines, true).unwrap();
assert!(near(measured, copy, 0.01), "{measured:?} {copy:?}");
}
#[test]
fn set_bounds_sizes_the_glyphs_of_type_with_outline_object() {
let mut s = session();
let id = outlined_type(&mut s, 40.0, "Outline");
preview(&mut s, true);
let before = glyphs(&s, id);
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.setBounds", json!({"width": 100, "reference": 0}));
let after = glyphs(&s, id);
assert!((after.width() - 100.0).abs() < 1e-6, "{after:?}");
assert!((after.x0 - before.x0).abs() < 1e-6 && (after.y0 - before.y0).abs() < 1e-6, "{before:?} {after:?}");
assert!(near(s.transform_bounds(&[id]).unwrap(), after, 1e-9));
}
#[test]
fn set_bounds_sizes_the_offset_shape_of_a_square_with_offset_path() {
// The offset shape is 120 pt wide. Set to 220 wide from its top-left corner, it is 220 wide and
// stays 120 high, with Scale Strokes & Effects off (the offset stays 10 pt) and on (the offset
// scales with the square).
for strokes in [false, true] {
let mut s = session();
let id = offset_square(&mut s, 100.0);
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.setBounds", json!({"width": 220, "reference": 0, "strokes": strokes}));
let v = s.transform_bounds(&[id]).unwrap();
assert!(near(v, Rect::new(90.0, 90.0, 310.0, 210.0), 1e-6), "strokes {strokes}: {v:?}");
}
// Set to 10 x 10, smaller than the 20 pt the offset adds, with Scale Strokes & Effects on: the
// offset shrinks with the square, and the offset shape is 10 x 10.
let mut s = session();
let id = offset_square(&mut s, 100.0);
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.setBounds", json!({"width": 10, "height": 10, "reference": 0, "strokes": true}));
let v = s.transform_bounds(&[id]).unwrap();
assert!(near(v, Rect::new(90.0, 90.0, 100.0, 100.0), 1e-6), "{v:?}");
}
#[test]
fn set_bounds_sizes_art_that_a_transform_effect_turns() {
// A 100 x 50 rectangle that a Transform effect turns 90° is drawn 50 wide and 100 high. Set to
// 100 x 100, it is drawn 100 x 100: its width stays 100 and its height doubles.
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 0.0);
run(&mut s, "effect.apply", json!({"effect": "distort.transform", "params": {"rotate": 90}, "ids": [id.0], "item": null}));
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.setBounds", json!({"width": 100, "height": 100}));
let v = s.transform_bounds(&[id]).unwrap();
assert!((v.width() - 100.0).abs() < 1e-6 && (v.height() - 100.0).abs() < 1e-6, "{v:?}");
let g = geometric(&s, id);
assert!((g.width() - 100.0).abs() < 1e-6 && (g.height() - 100.0).abs() < 1e-6, "{g:?}");
}
#[test]
fn a_symbol_instance_is_measured_with_the_geometry_effects_in_its_art() {
let mut s = session();
offset_square(&mut s, 100.0);
let id = NodeId(run(&mut s, "symbol.new", json!({"name": "Offset"}))["id"].as_u64().unwrap());
preview(&mut s, true);
let v = s.transform_bounds(&[id]).unwrap();
assert!(near(v, Rect::new(90.0, 90.0, 210.0, 210.0), 1e-6), "{v:?}");
}
#[test]
fn blends_envelopes_and_repeats_are_measured_with_the_geometry_effects_of_their_objects() {
// A grid repeat of a 100 pt square without a stroke, with Offset Path 10: each copy is drawn
// 10 pt out from its square.
let mut s = session();
let a = offset_square(&mut s, 100.0);
run(&mut s, "select.set", json!({"ids": [a.0]}));
let id = NodeId(run(&mut s, "object.repeat.grid", json!({}))["id"].as_u64().unwrap());
preview(&mut s, true);
let (g, v) = (geometric(&s, id), s.transform_bounds(&[id]).unwrap());
assert!(g.width() > 200.0 && near(v, g.inflate(10.0, 10.0), 1e-6), "{v:?} {g:?}");
// A blend between two such squares, 100 pt apart.
let mut s = session();
let (a, b) = (offset_square(&mut s, 0.0), offset_square(&mut s, 200.0));
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
let id = NodeId(run(&mut s, "object.blend.make", json!({"steps": 1}))["id"].as_u64().unwrap());
preview(&mut s, true);
let v = s.transform_bounds(&[id]).unwrap();
assert!(near(v, Rect::new(-10.0, 90.0, 310.0, 210.0), 1e-6), "{v:?}");
// An envelope around one, with a warp that leaves it as it is.
let mut s = session();
let a = offset_square(&mut s, 100.0);
run(&mut s, "select.set", json!({"ids": [a.0]}));
let id = NodeId(run(&mut s, "object.envelope.makeWithWarp", json!({"style": "arc", "bend": 0}))["id"].as_u64().unwrap());
preview(&mut s, true);
let v = s.transform_bounds(&[id]).unwrap();
assert!(near(v, Rect::new(90.0, 90.0, 210.0, 210.0), 1e-6), "{v:?}");
}
#[test]
fn an_object_has_the_art_of_at_most_4096_symbol_instances_drawn() {
// Symbol S0 is a filled 10 pt square with Offset Path 1, drawn from -1 to 11. Each of S1 to S12
// holds two instances of the symbol before it, the second 20 × 2^(k - 1) pt to the right, so an
// instance of S12 shows 4,096 squares in a row, 20 pt apart, through 8,191 instances. The art of
// the first 4,096 is drawn: the instance itself and the 4,095 in the left half. The squares in
// the right half are measured without the offset.
let mut d = Document::new(400.0, 400.0);
let mut filled = Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0);
filled.effects.push(Effect { id: "path.offsetPath".into(), params: json!({"offset": 1}), visible: true });
let square = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), filled);
d.symbols.push(Symbol { dynamic: false, name: "S0".into(), art: Arc::new(square) });
for k in 1..=12 {
let mut instance =
|dx: f64| Arc::new(Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: format!("S{}", k - 1), xf: Affine::translate((dx, 0.0)) }));
let pair = vec![instance(0.0), instance(20.0 * f64::from(1 << (k - 1)))];
let art = Node::group(d.alloc_id(), pair);
d.symbols.push(Symbol { dynamic: false, name: format!("S{k}"), art: Arc::new(art) });
}
let instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "S12".into(), xf: Affine::IDENTITY });
let (layer, id) = (d.layers[0].id, instance.id);
d.insert(Some(layer), 0, instance).unwrap();
let mut s = Session::new();
s.add_document(d, None);
preview(&mut s, true);
let v = s.transform_bounds(&[id]).unwrap();
assert!(near(v, Rect::new(-1.0, -1.0, 81910.0, 11.0), 1e-6), "{v:?}");
}
#[test]
fn a_turned_type_objects_box_follows_its_glyphs() {
let mut s = session();
let id = outlined_type(&mut s, 40.0, "Outline");
preview(&mut s, true);
let before = s.transform_box(&[id]).unwrap();
assert!(near(before.rect, glyphs(&s, id), 1e-9), "{before:?}");
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.rotate", json!({"angle": 30}));
let after = s.transform_box(&[id]).unwrap();
assert!((after.angle - 30.0).abs() < 1e-9, "{after:?}");
assert!(
(after.rect.width() - before.rect.width()).abs() < 1e-6 && (after.rect.height() - before.rect.height()).abs() < 1e-6,
"{before:?} {after:?}"
);
assert!(after.center().distance(before.center()) < 1e-6, "{before:?} {after:?}");
}
#[test]
fn objects_selected_whole_with_anchors_turn_about_the_box_of_their_offset_shape() {
// A square with Offset Path 10 (drawn from 90 to 210) selected whole with the top-left anchor
// of an unstroked square at (300, 100); a half turn about the center of the box around both.
let center_after = |on: bool| {
let mut s = session();
let a = offset_square(&mut s, 100.0);
let b = NodeId(run(&mut s, "shape.rectangle", json!({"x": 300, "y": 100, "width": 50, "height": 50}))["id"].as_u64().unwrap());
run(&mut s, "paint.setStroke", json!({"none": true}));
preview(&mut s, on);
run(&mut s, "select.set", json!({"ids": [a.0]}));
run(&mut s, "select.anchors", json!({"id": b.0, "anchors": [[0, 0]], "mode": "add"}));
run(&mut s, "object.rotate", json!({"angle": 180}));
geometric(&s, a).center()
};
// On, the box runs from (90, 90) to (300, 210); off, from (100, 100) to (300, 200).
assert!(center_after(true).distance(vectorcraft_geom::Point::new(240.0, 150.0)) < 1e-6, "{:?}", center_after(true));
assert!(center_after(false).distance(vectorcraft_geom::Point::new(250.0, 150.0)) < 1e-6, "{:?}", center_after(false));
}
#[test]
fn without_preview_bounds_geometry_effects_are_not_measured() {
let mut s = session();
let ids = [offset_square(&mut s, 100.0), outlined_type(&mut s, 40.0, "Outline")];
let d = &s.doc().unwrap().doc;
for id in ids {
assert_eq!(s.transform_bounds(&[id]), d.bounds_of(&[id], false));
assert_eq!(s.transform_box(&[id]), d.oriented_bounds(&[id], false));
}
}
#[test]
fn the_w_field_sets_the_visual_width() {
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 10.0);
preview(&mut s, true);
assert_eq!(s.transform_bounds(&[id]).unwrap().width(), 110.0);
// Strokes scale: the whole visual box doubles, from its left edge.
run(&mut s, "object.setBounds", json!({"width": 220, "reference": 0, "proportional": true, "strokes": true}));
let v = s.transform_bounds(&[id]).unwrap();
assert!((v.width() - 220.0).abs() < 1e-9 && (v.x0 - 95.0).abs() < 1e-9, "{v:?}");
assert!((geometric(&s, id).width() - 200.0).abs() < 1e-9);
run(&mut s, "edit.undo", json!({}));
// Strokes kept: the path takes the difference.
run(&mut s, "object.setBounds", json!({"width": 220, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&[id]).unwrap();
assert!((v.width() - 220.0).abs() < 1e-9 && (v.x0 - 95.0).abs() < 1e-9, "{v:?}");
assert!((geometric(&s, id).width() - 210.0).abs() < 1e-9);
// X places the visual box's reference point.
run(&mut s, "object.setBounds", json!({"x": 0, "reference": 0}));
assert!((s.transform_bounds(&[id]).unwrap().x0).abs() < 1e-9);
assert!((geometric(&s, id).x0 - 5.0).abs() < 1e-9);
}
#[test]
fn a_size_below_what_a_kept_stroke_adds_gives_the_path_no_width_or_height() {
// The 10 pt stroke adds 10 pt to the width and the height. With strokes kept, a width or height
// of 0 or more below 10 pt gives the path no width or height, and the visual box is the
// stroke's 10 pt: the path does not turn over. A size of 10 pt or more scales the path to it,
// and a negative size turns the path over.
let mut wrong = vec![];
for (key, size, path, visual) in [
("width", 5.0, 0.0, 10.0),
("width", 0.0, 0.0, 10.0),
("width", 10.0, 0.0, 10.0),
("width", 30.0, 20.0, 30.0),
("width", -10.0, 20.0, 30.0),
("height", 5.0, 0.0, 10.0),
("height", 0.0, 0.0, 10.0),
("height", 10.0, 0.0, 10.0),
("height", 30.0, 20.0, 30.0),
("height", -10.0, 20.0, 30.0),
] {
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 10.0);
preview(&mut s, true);
run(&mut s, "object.setBounds", json!({key: size, "reference": 0, "strokes": false}));
let (g, v) = (geometric(&s, id), s.transform_bounds(&[id]).unwrap());
let (g, v) = if key == "width" { (g.width(), v.width()) } else { (g.height(), v.height()) };
if (g - path).abs() > 1e-9 || (v - visual).abs() > 1e-9 {
wrong.push(format!("{key} {size}: path {g}, visual box {v}"));
}
}
assert!(wrong.is_empty(), "{wrong:?}");
}
#[test]
fn set_bounds_gives_one_path_sizes_out_of_proportion_when_strokes_scale() {
// The 100 × 50 rectangle with a 10 pt stroke: its visual box runs from (95, 95) to (205, 155).
// The stroke scales by the square root of the product of the two scales, so the width it adds
// depends on the height too. Set from the top-left corner, the visual box is 220 × 60, and
// 5 × 1000 with the path the same way round.
let mut wrong = vec![];
for (width, height) in [(220.0, 60.0), (5.0, 1000.0)] {
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 10.0);
preview(&mut s, true);
run(&mut s, "object.setBounds", json!({"width": width, "height": height, "reference": 0, "strokes": true}));
let v = s.transform_bounds(&[id]).unwrap();
let Some(vectorcraft_doc::LiveShape::Rectangle { xf, .. }) = s.doc().unwrap().doc.node(id).unwrap().live_shape() else {
panic!("the rectangle")
};
if !close(v, Rect::new(95.0, 95.0, 95.0 + width, 95.0 + height)) || xf.as_coeffs()[0] <= 0.0 {
wrong.push(format!("{width} × {height}: {v:?}, {xf:?}"));
}
}
assert!(wrong.is_empty(), "{wrong:?}");
}
fn close(a: Rect, b: Rect) -> bool {
[(a.x0, b.x0), (a.y0, b.y0), (a.x1, b.x1), (a.y1, b.y1)].iter().all(|(x, y)| (x - y).abs() < 1e-9)
}
/// Two rectangles 50 pt high at y 100, both selected with Use Preview Bounds on: one from x 0 to
/// 10 with a 2 pt stroke, which sets the left edge of the paths, and one from x 3 to 10 with a
/// 10 pt stroke, which sets every edge of the visual box, (-2, 95) to (15, 155).
fn thin_and_thick() -> (Session, [NodeId; 2]) {
let mut s = session();
let ids = [rect(&mut s, 0.0, 10.0, 2.0), rect(&mut s, 3.0, 7.0, 10.0)];
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [ids[0].0, ids[1].0]}));
assert!(close(s.transform_bounds(&ids).unwrap(), Rect::new(-2.0, 95.0, 15.0, 155.0)));
(s, ids)
}
#[test]
fn set_bounds_measures_the_margins_on_each_side_object_by_object() {
// Set to 37 wide from the left edge with strokes kept, the paths scale by 3.1, and the left edge
// of the visual box stays at -2.
let (mut s, ids) = thin_and_thick();
run(&mut s, "object.setBounds", json!({"width": 37, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&ids).unwrap();
assert!(close(v, Rect::new(-2.0, 95.0, 35.0, 155.0)), "{v:?}");
assert!(close(geometric(&s, ids[0]), Rect::new(-1.0, 100.0, 30.0, 150.0)), "{:?}", geometric(&s, ids[0]));
assert!(close(geometric(&s, ids[1]), Rect::new(8.3, 100.0, 30.0, 150.0)), "{:?}", geometric(&s, ids[1]));
}
#[test]
fn set_bounds_scales_both_ways_at_once_when_strokes_scale_and_the_sizes_are_out_of_proportion() {
// Each stroke scales by the square root of the product of the two scales, so the width it
// adds depends on the height too. The visual box is 40 × 100.
let (mut s, ids) = thin_and_thick();
run(&mut s, "object.setBounds", json!({"width": 40, "height": 100, "reference": 0, "strokes": true}));
let v = s.transform_bounds(&ids).unwrap();
assert!(close(v, Rect::new(-2.0, 95.0, 38.0, 195.0)), "{v:?}");
}
#[test]
fn set_bounds_measures_paths_turned_together_square_to_their_box() {
// Turned 30° together, the paths are measured square to their turned box: it is 37 wide, and
// its top-left corner stays where it was.
let (mut s, ids) = thin_and_thick();
run(&mut s, "object.rotate", json!({"angle": 30}));
let before = s.transform_box(&ids).unwrap();
run(&mut s, "object.setBounds", json!({"width": 37, "reference": 0, "strokes": false}));
let after = s.transform_box(&ids).unwrap();
assert!((after.angle - 30.0).abs() < 1e-9 && (after.rect.width() - 37.0).abs() < 1e-9, "{after:?}");
assert!((after.rect.height() - 60.0).abs() < 1e-9, "{after:?}");
assert!(after.reference_point(0).distance(before.reference_point(0)) < 1e-9, "{before:?} {after:?}");
}
#[test]
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. 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, 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();
run(&mut s, "object.setBounds", json!({"width": width, "reference": 0, "strokes": false}));
let (g, v) = (ids.map(|id| geometric(&s, id)), s.transform_bounds(&ids).unwrap());
if !close(g[0], paths[0]) || !close(g[1], paths[1]) || !close(v, visual) {
wrong.push(format!("width {width}: paths {g:?}, visual box {v:?}"));
}
}
assert!(wrong.is_empty(), "{wrong:?}");
}
#[test]
fn set_bounds_leaves_the_height_of_lines_with_no_height() {
// Horizontal lines at y 100 with square caps, from x 0 to 10 with a 2 pt stroke and from x 3 to
// 10 with a 10 pt stroke: the visual box is (-2, 95) to (15, 105). They have no height to
// scale, so the height stays 10; the width becomes 37 from the left edge.
let mut s = session();
let mut ids = vec![];
for (x, weight) in [(0.0, 2.0), (3.0, 10.0)] {
ids.push(NodeId(run(&mut s, "shape.line", json!({"x1": x, "y1": 100, "x2": 10, "y2": 100}))["id"].as_u64().unwrap()));
run(&mut s, "stroke.set", json!({"weight": weight, "cap": "square"}));
}
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [ids[0].0, ids[1].0]}));
assert!(close(s.transform_bounds(&ids).unwrap(), Rect::new(-2.0, 95.0, 15.0, 105.0)), "{:?}", s.transform_bounds(&ids));
run(&mut s, "object.setBounds", json!({"width": 37, "height": 30, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&ids).unwrap();
assert!(close(v, Rect::new(-2.0, 95.0, 35.0, 105.0)), "{v:?}");
assert!(close(geometric(&s, ids[1]), Rect::new(8.3, 100.0, 30.0, 100.0)), "{:?}", geometric(&s, ids[1]));
}
/// A line with a 2 pt stroke and butt caps, selected, with Use Preview Bounds on.
fn butt_line(s: &mut Session, from: (f64, f64), to: (f64, f64)) -> NodeId {
let id = NodeId(run(s, "shape.line", json!({"x1": from.0, "y1": from.1, "x2": to.0, "y2": to.1}))["id"].as_u64().unwrap());
run(s, "stroke.set", json!({"weight": 2, "cap": "butt"}));
preview(s, true);
run(s, "select.set", json!({"ids": [id.0]}));
id
}
#[test]
fn set_bounds_gives_a_butt_line_the_whole_height() {
// A butt cap ends at the anchor, so 10 mm (28.3465 pt) is the length of the line itself.
let mut s = session();
let id = butt_line(&mut s, (100.0, 100.0), (100.0, 140.0));
assert!(close(s.transform_bounds(&[id]).unwrap(), Rect::new(99.0, 100.0, 101.0, 140.0)), "{:?}", s.transform_bounds(&[id]));
run(&mut s, "object.setBounds", json!({"height": 28.3465, "reference": 0, "strokes": false}));
assert!(close(geometric(&s, id), Rect::new(100.0, 100.0, 100.0, 128.3465)), "{:?}", geometric(&s, id));
assert!(close(s.transform_bounds(&[id]).unwrap(), Rect::new(99.0, 100.0, 101.0, 128.3465)), "{:?}", s.transform_bounds(&[id]));
}
#[test]
fn set_bounds_gives_a_diagonal_butt_line_the_size_out_of_proportion() {
// The stroke's corners follow the line's slope, which a scale out of proportion changes.
let mut s = session();
let id = butt_line(&mut s, (100.0, 100.0), (130.0, 140.0));
let before = s.transform_bounds(&[id]).unwrap();
// The stroke's corners reach 0.8 pt across x and 0.6 pt across y at this 3-4-5 slope.
assert!(close(before, Rect::new(99.2, 99.4, 130.8, 140.6)), "{before:?}");
run(&mut s, "object.setBounds", json!({"height": 100, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&[id]).unwrap();
assert!((v.height() - 100.0).abs() < 1e-6, "{v:?}");
}
#[test]
fn set_bounds_gives_a_butt_path_with_slanted_corners_the_size_out_of_proportion() {
// Square ends, but the bevel join at the apex sets the top edge by the slanted segments'
// corners, which a scale out of proportion moves.
let mut s = session();
let anchors = json!([{"x": 100, "y": 150}, {"x": 100, "y": 140}, {"x": 110, "y": 100}, {"x": 120, "y": 140}, {"x": 120, "y": 150}]);
let id = NodeId(run(&mut s, "path.create", json!({"anchors": anchors}))["id"].as_u64().unwrap());
run(&mut s, "stroke.set", json!({"weight": 2, "cap": "butt", "join": "bevel"}));
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();
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();
butt_line(&mut s, (100.0, 100.0), (130.0, 140.0));
let id = NodeId(run(&mut s, "symbol.new", json!({"name": "Line"}))["id"].as_u64().unwrap());
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.setBounds", json!({"width": 20, "height": 100, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&[id]).unwrap();
assert!((v.width() - 20.0).abs() < 1e-6 && (v.height() - 100.0).abs() < 1e-6, "{v:?}");
}
#[test]
fn align_places_a_vertical_butt_line_by_its_end_points() {
// With Use Preview Bounds on, a butt line's ends line up with the top of a rectangle without
// a stroke.
let mut s = session();
rect(&mut s, 20.0, 50.0, 0.0);
let id = butt_line(&mut s, (200.0, 160.0), (200.0, 190.0));
run(&mut s, "select.all", json!({}));
run(&mut s, "object.align", json!({"vertical": "top"}));
assert!(close(geometric(&s, id), Rect::new(200.0, 100.0, 200.0, 130.0)), "{:?}", geometric(&s, id));
}
/// The rectangles of [`thin_and_thick`] in a group, the thick one in a group of its own inside it
/// when `nested`, selected with an unstroked rectangle from x 100 to 110 when `plain`. Returns the
/// selected objects.
fn grouped(nested: bool, plain: bool) -> (Session, Vec<NodeId>) {
let (mut s, [thin, thick]) = thin_and_thick();
let mut members = vec![thin.0, thick.0];
if nested {
run(&mut s, "select.set", json!({"ids": [thick.0]}));
members[1] = run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap();
}
run(&mut s, "select.set", json!({"ids": members}));
let mut ids = vec![NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap())];
if plain {
ids.push(rect(&mut s, 100.0, 10.0, 0.0));
}
run(&mut s, "select.set", json!({"ids": ids.iter().map(|id| id.0).collect::<Vec<_>>()}));
(s, ids)
}
#[test]
fn set_bounds_measures_the_members_of_groups_one_by_one() {
// With the unstroked rectangle, the visual box runs from (-2, 95) to (110, 155). Set to 224 wide
// from its left edge, it is 224 wide and its left edge stays at -2, with strokes kept or
// scaling, and with the thick rectangle in a group of its own. The group alone, (-2, 95) to
// (15, 155), set to 37 wide is 37 wide.
let mut wrong = vec![];
for (nested, plain, width, strokes) in
[(false, true, 224.0, false), (false, true, 224.0, true), (true, true, 224.0, false), (false, false, 37.0, false)]
{
let (mut s, ids) = grouped(nested, plain);
run(&mut s, "object.setBounds", json!({"width": width, "reference": 0, "strokes": strokes}));
let v = s.transform_bounds(&ids).unwrap();
if !close(v, Rect::new(-2.0, 95.0, width - 2.0, 155.0)) {
wrong.push(format!("nested {nested}, plain {plain}, strokes {strokes}: {v:?}"));
}
}
// The group with a 1 pt stroke of its own, which reaches 5 pt at its miter limit of 10, around
// each member: the visual box runs from (-7, 90) to (110, 160). Set to 224 wide from its left
// edge, it is 224 wide and its left edge stays at -7, with strokes kept or scaling.
for strokes in [false, true] {
let (mut s, _) = thin_and_thick();
let group = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
run(&mut s, "appearance.addStroke", json!({"ids": [group.0]}));
let ids = [group, rect(&mut s, 100.0, 10.0, 0.0)];
run(&mut s, "select.set", json!({"ids": [ids[0].0, ids[1].0]}));
assert!(close(s.transform_bounds(&ids).unwrap(), Rect::new(-7.0, 90.0, 110.0, 160.0)), "{:?}", s.transform_bounds(&ids));
run(&mut s, "object.setBounds", json!({"width": 224, "reference": 0, "strokes": strokes}));
let v = s.transform_bounds(&ids).unwrap();
if !close(v, Rect::new(-7.0, 90.0, 217.0, 160.0)) {
wrong.push(format!("the group with a stroke, strokes {strokes}: {v:?}"));
}
}
// A group of a rectangle from x 0 to 100 with a 2 pt stroke and one from x 40 to 60 with a 10 pt
// stroke: its visual box, (-1, 95) to (101, 155), set to 11 wide is 11 wide.
let mut s = session();
let ids = [rect(&mut s, 0.0, 100.0, 2.0), rect(&mut s, 40.0, 20.0, 10.0)];
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [ids[0].0, ids[1].0]}));
let group = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
run(&mut s, "object.setBounds", json!({"width": 11, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&[group]).unwrap();
if !close(v, Rect::new(-1.0, 95.0, 10.0, 155.0)) {
wrong.push(format!("the 0 to 100 and 40 to 60 group: {v:?}"));
}
assert!(wrong.is_empty(), "{wrong:?}");
}
#[test]
fn set_bounds_measures_clip_groups_and_groups_with_effects_as_one_object() {
// A clip group is measured by its clipping path, a rectangle from x 0 to 10, though its content
// with a 10 pt stroke reaches past it: with the unstroked rectangle from x 100 to 110, set to
// 224 wide from the left edge, the visual box runs from x 0 to 224.
let mut s = session();
let content = rect(&mut s, 3.0, 17.0, 10.0);
let path = rect(&mut s, 0.0, 10.0, 0.0);
run(&mut s, "select.set", json!({"ids": [content.0, path.0]}));
let clip = NodeId(run(&mut s, "object.clippingMask.make", json!({}))["id"].as_u64().unwrap());
let plain = rect(&mut s, 100.0, 10.0, 0.0);
preview(&mut s, true);
run(&mut s, "select.set", json!({"ids": [clip.0, plain.0]}));
run(&mut s, "object.setBounds", json!({"width": 224, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&[clip, plain]).unwrap();
assert!(close(v, Rect::new(0.0, 100.0, 224.0, 150.0)), "the clip group: {v:?}");
// A group with a drop shadow of its own is measured as one object, as before. Its 2 pt margin on
// the left is measured from the group's left edge, though the stroke of the thick rectangle at
// x 3 paints it, so the visual box is 223 wide and its left edge moves to -1.
let (mut s, ids) = grouped(false, true);
run(&mut s, "effect.apply", json!({"effect": "stylize.dropShadow", "ids": [ids[0].0]}));
run(&mut s, "select.set", json!({"ids": [ids[0].0, ids[1].0]}));
run(&mut s, "object.setBounds", json!({"width": 224, "reference": 0, "strokes": false}));
let v = s.transform_bounds(&ids).unwrap();
assert!(close(v, Rect::new(-1.0, 95.0, 222.0, 155.0)), "the group with a shadow: {v:?}");
}
#[test]
fn the_bounding_box_handles_sit_on_the_preview_bounds() {
// Drag from the visual right edge (10 pt outside the path) 100 pt to the right.
let drag = |on: bool| {
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 20.0);
preview(&mut s, on);
let v = ViewInfo::default();
s.select_tool("selection", v).unwrap();
for (k, x) in [(PointerKind::Down, 210.0), (PointerKind::Drag, 310.0), (PointerKind::Up, 310.0)] {
s.pointer(&PointerEvent::new(k, x, 125.0), v).unwrap();
}
geometric(&s, id)
};
assert!(drag(true).width() > 150.0, "a scale from the visual edge");
assert_eq!(drag(false).width(), 100.0, "off, the point is no handle");
}
#[test]
fn the_bounding_box_handles_sit_on_the_offset_shape() {
// Drag from the right edge of the offset shape (10 pt outside the square) 100 pt to the right.
let drag = |on: bool| {
let mut s = session();
let id = offset_square(&mut s, 100.0);
preview(&mut s, on);
let v = ViewInfo::default();
s.select_tool("selection", v).unwrap();
for (k, x) in [(PointerKind::Down, 210.0), (PointerKind::Drag, 310.0), (PointerKind::Up, 310.0)] {
s.pointer(&PointerEvent::new(k, x, 150.0), v).unwrap();
}
geometric(&s, id)
};
assert!(drag(true).width() > 150.0, "a scale from the edge of the offset shape");
assert_eq!(drag(false).width(), 100.0, "off, the point is no handle");
}
/// The box `id` is drawn in (strokes and geometry effects included) and its geometric box after a
/// Selection tool drag from `from` to `to` with `mods`, with Smart Guides off.
fn drag_box(s: &mut Session, id: NodeId, from: (f64, f64), to: (f64, f64), mods: Mods) -> (Rect, Rect) {
let v = ViewInfo { smart_guides: false, ..ViewInfo::default() };
s.select_tool("selection", v).unwrap();
for (k, (x, y)) in [(PointerKind::Down, from), (PointerKind::Drag, to), (PointerKind::Up, to)] {
s.pointer(&PointerEvent { mods, ..PointerEvent::new(k, x, y) }, v).unwrap();
}
let drawn = vectorcraft_render::effects::preview::bounds_of(&s.doc().unwrap().doc, &[id], true).unwrap();
(drawn, geometric(s, id))
}
/// Drags of `make`'s object with Use Preview Bounds on, and Scale Strokes & Effects off and on: from
/// the handle at the first point to the second point, with the modifiers, giving the visual box.
type HandleDrags = [((f64, f64), (f64, f64), Mods, Rect); 4];
fn assert_handle_drags(make: fn(&mut Session) -> NodeId, drags: HandleDrags) {
for strokes in [false, true] {
for (from, to, mods, want) in drags {
let mut s = session();
let id = make(&mut s);
preview(&mut s, true);
s.prefs.scale_strokes = strokes;
let (v, _) = drag_box(&mut s, id, from, to, mods);
assert!(near(v, want, 1e-6), "strokes {strokes}, {from:?} to {to:?}, {mods:?}: {v:?}");
}
}
}
const SHIFT: Mods = Mods { shift: true, alt: false, cmd: false, ctrl: false, space: false };
const ALT: Mods = Mods { shift: false, alt: true, cmd: false, ctrl: false, space: false };
#[test]
fn a_handle_drag_keeps_the_opposite_visual_edge_of_a_stroked_path() {
// A 100 x 50 rectangle at (100, 100) with a 20 pt stroke, drawn from (90, 90) to (210, 160): the
// opposite edge of the visual box stays and the dragged edge goes to the pointer, with Shift in
// proportion, with Alt about the center.
let make = |s: &mut Session| rect(s, 100.0, 100.0, 20.0);
assert_handle_drags(
make,
[
((210.0, 125.0), (310.0, 125.0), Mods::default(), Rect::new(90.0, 90.0, 310.0, 160.0)),
((210.0, 160.0), (260.0, 200.0), Mods::default(), Rect::new(90.0, 90.0, 260.0, 200.0)),
((210.0, 160.0), (330.0, 170.0), SHIFT, Rect::new(90.0, 90.0, 330.0, 230.0)),
((210.0, 125.0), (260.0, 125.0), ALT, Rect::new(40.0, 90.0, 260.0, 160.0)),
],
);
// Off, the handles sit on the path, and the path scales from its own opposite edge.
for strokes in [false, true] {
let mut s = session();
let id = make(&mut s);
s.prefs.scale_strokes = strokes;
let (_, g) = drag_box(&mut s, id, (200.0, 125.0), (300.0, 125.0), Mods::default());
assert_eq!(g, Rect::new(100.0, 100.0, 300.0, 150.0), "strokes {strokes}");
let (_, g) = drag_box(&mut s, id, (300.0, 150.0), (350.0, 200.0), Mods::default());
assert_eq!(g, Rect::new(100.0, 100.0, 350.0, 200.0), "strokes {strokes}");
}
}
#[test]
fn transform_again_repeats_the_transform_of_a_handle_drag_with_preview_bounds() {
// The drag takes the visual right edge of the stroked rectangle from 210 to 310, so the path,
// with its stroke kept, goes from 100..200 to 100..300: x becomes 2x - 100.
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 20.0);
preview(&mut s, true);
s.prefs.scale_strokes = false;
let (_, g) = drag_box(&mut s, id, (210.0, 125.0), (310.0, 125.0), Mods::default());
assert!(near(g, Rect::new(100.0, 100.0, 300.0, 150.0), 1e-6), "{g:?}");
run(&mut s, "object.transformAgain", json!({}));
assert!(near(geometric(&s, id), Rect::new(100.0, 100.0, 500.0, 150.0), 1e-6), "{:?}", geometric(&s, id));
}
#[test]
fn a_handle_drag_with_preview_bounds_scales_a_compound_paths_member_alone() {
// A ring: a 100 pt square at (100, 100) with a 20 pt square hole at (140, 140), the hole selected
// alone in the isolated compound path.
let mut s = session();
let square = |s: &mut Session, at: f64, size: f64| {
NodeId(run(s, "shape.rectangle", json!({"x": at, "y": at, "width": size, "height": size}))["id"].as_u64().unwrap())
};
let (outer, hole) = (square(&mut s, 100.0, 100.0), square(&mut s, 140.0, 20.0));
run(&mut s, "select.set", json!({"ids": [outer.0, hole.0]}));
let c = run(&mut s, "object.compoundPath.make", json!({}))["id"].as_u64().unwrap();
run(&mut s, "object.isolate", json!({"id": c}));
run(&mut s, "select.set", json!({"ids": [hole.0]}));
preview(&mut s, true);
let (b, around) = (s.transform_bounds(&[hole]).unwrap(), s.transform_bounds(&[outer]));
let (v, _) = drag_box(&mut s, hole, (b.x1, b.center().y), (b.x1 + 10.0, b.center().y), Mods::default());
assert_eq!(s.transform_bounds(&[outer]), around, "the square around the hole stays");
assert!(near(v, Rect::new(b.x0, b.y0, b.x1 + 10.0, b.y1), 1e-6), "the hole: {v:?} from {b:?}");
}
#[test]
fn a_handle_drag_with_preview_bounds_leaves_the_art_some_width() {
// Dragging the visual right edge of the rectangle with a kept 20 pt stroke (drawn from 90 to 210)
// to 95 asks for less width than the stroke adds: the path keeps 1e-4 of its width.
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 20.0);
preview(&mut s, true);
s.prefs.scale_strokes = false;
let (_, g) = drag_box(&mut s, id, (210.0, 125.0), (95.0, 125.0), Mods::default());
assert!((g.width() - 0.01).abs() < 1e-9, "{g:?}");
}
#[test]
fn a_handle_drag_keeps_the_opposite_edge_of_the_offset_shape() {
// A 100 pt square at (100, 100) with Offset Path 10, drawn from (90, 90) to (210, 210).
let make = |s: &mut Session| offset_square(s, 100.0);
assert_handle_drags(
make,
[
((210.0, 150.0), (310.0, 150.0), Mods::default(), Rect::new(90.0, 90.0, 310.0, 210.0)),
((210.0, 210.0), (260.0, 250.0), Mods::default(), Rect::new(90.0, 90.0, 260.0, 250.0)),
((210.0, 210.0), (330.0, 220.0), SHIFT, Rect::new(90.0, 90.0, 330.0, 330.0)),
((210.0, 150.0), (260.0, 150.0), ALT, Rect::new(40.0, 90.0, 260.0, 210.0)),
],
);
// Off, the handles sit on the square, and the square scales from its own opposite edge.
for strokes in [false, true] {
let mut s = session();
let id = make(&mut s);
s.prefs.scale_strokes = strokes;
let (_, g) = drag_box(&mut s, id, (200.0, 150.0), (300.0, 150.0), Mods::default());
assert_eq!(g, Rect::new(100.0, 100.0, 300.0, 200.0), "strokes {strokes}");
let (_, g) = drag_box(&mut s, id, (300.0, 200.0), (350.0, 250.0), Mods::default());
assert_eq!(g, Rect::new(100.0, 100.0, 350.0, 250.0), "strokes {strokes}");
}
}
#[test]
fn a_hover_checks_the_memo_as_often_however_many_objects_are_selected() {
let checks = |objects: u32| {
let mut s = session();
for i in 0..objects {
rect(&mut s, f64::from(i), 1.0, 0.0);
}
run(&mut s, "select.all", json!({}));
let v = ViewInfo::default();
s.select_tool("selection", v).unwrap();
// Off the art, so the hover walks every selected object and finds no anchor or center.
let hover = |s: &mut Session| {
s.pointer(&PointerEvent::new(PointerKind::Move, 350.0, 350.0), v).unwrap();
s.cursor(Point::new(350.0, 350.0), Mods::default(), v)
};
hover(&mut s);
let before = s.preview_memo.checks();
hover(&mut s);
s.preview_memo.checks() - before
};
let few = checks(3);
assert!(few > 0, "a hover asks the memo");
assert_eq!(checks(60), few, "a check compares the whole selection: one per object is quadratic");
}
#[test]
fn hovering_over_an_unchanged_document_measures_nothing_again() {
// A selected square with Offset Path 10, drawn from 90 to 210, with Use Preview Bounds and Smart
// Guides on: the bounding box and the center Smart Guides label are measured once.
let mut s = session();
let id = offset_square(&mut s, 100.0);
preview(&mut s, true);
let v = ViewInfo::default();
s.select_tool("selection", v).unwrap();
let hover = |s: &mut Session, x: f64| {
s.pointer(&PointerEvent::new(PointerKind::Move, x, 150.0), v).unwrap();
s.cursor(Point::new(x, 150.0), Mods::default(), v)
};
let xs = [210.0, 150.0, 151.0, 180.0, 250.0];
for x in xs {
hover(&mut s, x);
}
let measured = s.preview_memo.measurements();
assert!(measured > 0, "the first hover measures");
for x in xs {
hover(&mut s, x);
}
assert_eq!(s.preview_memo.measurements(), measured, "hovering again measures nothing");
assert_eq!(hover(&mut s, 210.0), Cursor::ResizeH, "the right edge of the offset shape");
assert_ne!(hover(&mut s, 230.0), Cursor::ResizeH);
// Offset Path 30 draws the square from 70 to 230: the box is measured again.
run(&mut s, "effect.setParams", json!({"index": 0, "params": {"offset": 30}, "ids": [id.0], "item": null}));
assert_eq!(hover(&mut s, 230.0), Cursor::ResizeH, "the right edge of the new offset shape");
let measured_again = s.preview_memo.measurements();
assert!(measured_again > measured);
// Moved 50 pt to the right, the square is drawn from 120 to 280.
run(&mut s, "object.move", json!({"dx": 50, "dy": 0}));
assert_eq!(hover(&mut s, 280.0), Cursor::ResizeH, "the right edge of the moved offset shape");
assert!(s.preview_memo.measurements() > measured_again);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.