mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 02:07:09 -06:00
dotCooCoo
a5ea3a8002
With Use Preview Bounds on, a bounding-box handle drag scaled the art by the ratio of the visual box, so margins that stay (a stroke with Scale Strokes & Effects off, an Offset Path reach) or scale by another factor moved the opposite visible edge: dragging the right edge of a square with Offset Path 10 from 210 to 310 left its left edge at 98.33 instead of 90. The Selection tool now previews object.setBounds with the dragged visual size and the opposite handle (with Alt, the center) as the reference point, so the scale is solved from the geometric box and the margins the visual box adds, for strokes with Scale Strokes & Effects on or off and for geometry effects. Shift and Alt drags follow the same rule; a drag that flips the box, and one with anchors selected, still scale by the matrix. A previewed object.setBounds runs as object.transform with the transform it finds, so Transform Again repeats the drag and the journal holds that transform. The drag transforms a path of a compound path selected on its own, as object.transform does, and leaves the art at least 1e-4 of its width and height.
918 lines
48 KiB
Rust
918 lines
48 KiB
Rust
//! Use Preview Bounds: the Transform panel values, the bounding box, Align and Distribute measure
|
||
//! visual bounds (strokes and geometry 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 super::*;
|
||
|
||
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(&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)
|
||
}
|
||
|
||
#[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 { 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 { 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. A negative width turns the paths over, as it does one path.
|
||
let mut wrong = vec![];
|
||
for (width, paths, visual) in [
|
||
(8.0, [Rect::new(3.0, 100.0, 3.0, 150.0); 2], Rect::new(-2.0, 95.0, 8.0, 155.0)),
|
||
(0.0, [Rect::new(3.0, 100.0, 3.0, 150.0); 2], Rect::new(-2.0, 95.0, 8.0, 155.0)),
|
||
(-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]));
|
||
}
|
||
|
||
/// 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 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);
|
||
}
|