use super::spans::Spans; use super::transform::{TRANSFORM_SWITCHES, about, apply_transform, scaling_options, transforms_objects}; use super::{ Affine, Document, EngineError, NodeId, OrientedBox, Point, Rect, Result, Scaling, Session, Value, bool_or, check_numbers, check_switches, effects, f64_or, json, selected_roots_to_transform, }; pub(super) fn set_bounds(s: &mut Session, p: &Value) -> Result { match bounds_transform(s, p, selected_roots_to_transform(s)?, 0.0, true)? { Bounds::Anchors(ids, b) => set_anchor_bounds(s, p, ids, b), Bounds::Objects(ids, xf) => apply_transform(s, "Transform", ids, xf, p, false), } } /// What `object.setBounds` does with its values ([`bounds_transform`]). enum Bounds { /// With anchors selected with Direct Selection: the objects and the box of the anchors that /// [`set_anchor_bounds`] moves or scales. Anchors(Vec, Rect), /// The objects and the transform that gives them the values. Objects(Vec, Affine), } /// A previewed `object.setBounds` that transforms objects runs as `object.transform` with the /// transform [`bounds_transform`] finds for it, so the interaction commits that transform (Transform /// Again repeats it, and the journal holds it). A bounding-box handle drag with Use Preview Bounds /// previews `object.setBounds`. The objects are those `object.transform` transforms (a path of a /// compound path selected on its own is one), and the art keeps at least 1e-4 of its width and /// height, as with [`vectorcraft_tools::bbox::scale_for_drag`]. `None` with anchors selected with /// Direct Selection and when the values are not valid. pub(crate) fn bounds_rewrite(s: &Session, cmd: &str, params: &Value) -> Option<(String, Value)> { if cmd != "object.setBounds" { return None; } let Ok(Bounds::Objects(_, xf)) = bounds_transform(s, params, selected_roots_to_transform(s).ok()?, 1e-4, true) else { return None }; let mut p = params.as_object().cloned().unwrap_or_default(); for k in ["x", "y", "width", "height", "reference", "proportional"] { p.remove(k); } p.insert("matrix".into(), json!(xf.as_coeffs())); Some(("object.transform".to_string(), Value::Object(p))) } /// The transform that gives object `id` on its own the place and size `p` asks for, as /// `object.setBounds` measures them (Use Preview Bounds, `strokes`, `reference`, `proportional`), /// whatever anchors are direct-selected. The art keeps at least 1e-4 of its width and height. pub(crate) fn object_bounds_transform(s: &Session, p: &Value, id: NodeId) -> Result { match bounds_transform(s, p, vec![id], 1e-4, false)? { Bounds::Objects(_, xf) => Ok(xf), Bounds::Anchors(..) => Err(EngineError::Other("no bounds".into())), } } /// How `object.setBounds` with params `p` changes the objects `ids`. A scale that would leave the /// art with a width or height below `least` of the one it has keeps `least` of it. With `anchors`, /// direct-selected anchors are what changes ([`Bounds::Anchors`]). fn bounds_transform(s: &Session, p: &Value, ids: Vec, least: f64, anchors: bool) -> Result { check_numbers(p, &["x", "y", "width", "height", "reference"], "object.setBounds")?; let refi = reference_index(p)?; let st = s.doc()?; check_switches(p, &TRANSFORM_SWITCHES, "object.setBounds")?; check_switches(p, &["proportional"], "object.setBounds")?; let how = s.bounds_measure(); if anchors && transforms_objects(p) && !bool_or(p, "copy", false) && let Some(b) = effects::preview::anchor_bounds_with(&st.selection, &st.doc, how) { return Ok(Bounds::Anchors(ids, b)); } let d = &s.doc()?.doc; // Sizes are measured square to the bounding box, which a rotation turns with the objects: // the math below runs in its frame. With Measure Type by Glyph Bounds, point type is measured // by its glyphs' ink, which a transform of the type moves and scales with it. let geometric = effects::preview::Measure { preview: false, ..how }; let frame = effects::preview::oriented_bounds_with(d, &ids, geometric).ok_or_else(|| EngineError::Other("no bounds".into()))?; let g = frame.rect; let symbols = d.symbol_boxes(); let by_glyphs = how.glyphs && ids.iter().filter_map(|id| d.node(*id)).any(|n| effects::preview::by_glyphs(&symbols, n, how)); // With Use Preview Bounds the values measure the visual box as drawn, whose margins around the // geometric box (left, top, right, bottom) scale with the strokes or stay. The margins of // `vs`, the visual box without the strokes in symbols' art, scale; those strokes keep their // weight when an instance scales, so the rest of the margins stay. Type measured by its glyphs // is measured as drawn after each scale tried instead (below). let (v, vs) = if s.prefs.use_preview_bounds { let v = effects::preview::oriented_bounds_with(d, &ids, how).map_or(g, |b| b.rect); (v, if by_glyphs { v } else { scaling_box(d, &ids, &frame).unwrap_or(g) }) } else { (g, g) }; let margins = |b: Rect| [g.x0 - b.x0, g.y0 - b.y0, b.x1 - g.x1, b.y1 - g.y1]; let (m, all) = (margins(vs), margins(v)); let fixed = [all[0] - m[0], all[1] - m[1], all[2] - m[2], all[3] - m[3]]; let rp = vectorcraft_geom::reference_point(v, refi); let (w, h) = wanted_size(p, v); // The geometric scale that gives the visual size: margins grow by the strokes' scale `f`. It is // exact for proportional scales of one path; [`Spans::refit`] checks it, and solves for the // scales where it misses. let strokes = bool_or(p, "strokes", s.prefs.scale_strokes); let ratio = |size: f64, geo: f64, margin: f64| if geo > 1e-9 { (size - margin) / geo } else { 1.0 }; let f = |sx: f64, sy: f64| if strokes { (sx * sy).abs().sqrt() } else { 1.0 }; // The strokes' scale `f0`: the size left after the margins in symbols' art, which stay, over // `vs`, whose margins scale. let (lx, ly) = (ratio(w - fixed[0] - fixed[2], vs.width(), 0.0), ratio(h - fixed[1] - fixed[3], vs.height(), 0.0)); let f0 = f(if g.width() > 1e-9 { lx } else { 1.0 }, if g.height() > 1e-9 { ly } else { 1.0 }); // When a size of 0 or more is smaller than the margins and some of them stay, the geometry // gets no width or height: the visual box is then as small as it can be. The margins in // symbols' art stay, and so does every margin when strokes do not scale. let fit = |size: f64, geo: f64, scaling: f64, kept: f64| { let s = ratio(size, geo, scaling * f0 + kept); let stays = if strokes { kept } else { scaling + kept }; if s < 0.0 && size >= 0.0 && stays > 0.0 { 0.0 } else { s } }; let sx = fit(w, g.width(), m[0] + m[2], fixed[0] + fixed[2]); let sy = fit(h, g.height(), m[1] + m[3], fixed[1] + fixed[3]); let scale = about(rp, Affine::scale_non_uniform(sx, sy)); // Move the new visual box's reference point to x, y (default: where it was): the geometric // box's reference point moves with the art, the margin from it to `vs`'s by `f`, and the // margin from that one to the visual box's stays. let gp = vectorcraft_geom::reference_point(g, refi); let sp = vectorcraft_geom::reference_point(vs, refi); let new_rp = scale * gp + (sp - gp) * f(sx, sy) + (rp - sp); // x, y place the reference point on the page. let page = frame.to_doc() * rp; // When every value given is the current one, the transform is the identity. Computing it can // leave a rounding error in it on a rotated object or with Use Preview Bounds. let current = |k: &str, now: f64| p.get(k).and_then(Value::as_f64).is_none_or(|x| x == now); if current("x", page.x) && current("y", page.y) && current("width", v.width()) && current("height", v.height()) { return Ok(Bounds::Objects(ids, Affine::IDENTITY)); } let to = frame.to_local(Point::new(f64_or(p, "x", page.x), f64_or(p, "y", page.y))); // The scales and the point above can miss the size or the reference point when the margins of // the objects differ, the members of groups and the objects in symbols' art included, and with // strokes that scale, when the sizes are out of proportion. The objects are then measured one // by one ([`Spans::measure`]), and the scales solved for. Objects with geometry effects, // objects with a stroke that stops at the corners of a segment at a slant (butt caps, bevel and // miter joins), whose margins change with the segment's direction, and type measured by its // glyphs, are measured as drawn after each scale tried instead ([`refit_drawn`]). let to_local = frame.to_doc().inverse(); let drawn = || { by_glyphs || ids .iter() .filter_map(|id| d.node(*id)) .any(|n| effects::preview::draws_geometry(&symbols, n) || n.has_slanted_stroke_corners(&symbols, to_local)) }; // Without Use Preview Bounds the box has no margins (`v`, `vs` and `g` are one box, glyph ink // included), so the scales above are exact and nothing is refitted. let solved = if !(s.prefs.use_preview_bounds && w >= 0.0 && h >= 0.0) { None } else if transforms_objects(p) && !bool_or(p, "typeAreas", false) && drawn() { let options = scaling_options(s, p); let measure = |sx: f64, sy: f64| { let xf = frame.conjugate(about(rp, Affine::scale_non_uniform(sx, sy))); let sc = if Scaling::factor(xf).is_some() { options } else { Scaling::default() }; ids.iter().filter_map(|id| d.node(*id)).fold(None, |acc, n| { let mut n = n.clone(); n.transform(xf, sc); vectorcraft_geom::union_opt(acc, effects::preview::bounds_in_with(&symbols, &n, to_local, how)) }) }; // The scales above keep the effects' reach as a margin that stays, and give 0 for a size // smaller than that reach. Strokes and effects that scale shrink the reach with the art, so // the search then starts from the size wanted over the size as drawn. let seed = |s: f64, size: f64, now: f64| if s <= 0.0 && size > 0.0 && now > 1e-9 { size / now } else { s }; refit_drawn(measure, refi, [w, h], (seed(sx, w, v.width()), seed(sy, h, v.height())), [g.width() > 1e-9, g.height() > 1e-9]) } else { Spans::measure(d, &ids, &frame, strokes).refit(rp, refi, [w, h], (sx, sy, new_rp)) }; let (sx, sy, new_rp) = solved.unwrap_or((sx, sy, new_rp)); // A scale below `least` of art with a width (height) keeps `least`, and the reference point // moves with the scales as above. let keep = |s: f64, geo: f64| if geo > 1e-9 && (0.0..least).contains(&s) { least } else { s }; let (kx, ky) = (keep(sx, g.width()), keep(sy, g.height())); let scale = about(rp, Affine::scale_non_uniform(kx, ky)); let new_rp = if (kx, ky) == (sx, sy) { new_rp } else { scale * gp + (sp - gp) * f(kx, ky) + (rp - sp) }; let xf = frame.conjugate(Affine::translate(to - new_rp) * scale); Ok(Bounds::Objects(ids, xf)) } /// The scales along x and y that give the box `measure` returns for them the size `size`, and point /// `refi` of that box: the point that goes to the reference point's place. The search starts at /// `start`. Each step measures how the width and the height change with each scale that `free` /// marks true, by measuring again with that scale moved by 1e-4 of it (at least 1e-6), and moves /// those scales by the least-squares solution of that linear change, never below 0. The width can /// change with the y scale and the height with the x scale (a geometry effect can turn the art). A /// scale that `free` marks false stays as it is. The search stops when both sizes are within 1e-9 /// of the sizes wanted (of the largest of 1 and those sizes), when no scale moves, when `measure` /// finds no box, or after 16 steps, and returns the scales that came nearest. `None` when `measure` /// finds no box for `start`. fn refit_drawn( measure: impl Fn(f64, f64) -> Option, refi: usize, size: [f64; 2], start: (f64, f64), free: [bool; 2], ) -> Option<(f64, f64, Point)> { let [w, h] = size; let tolerance = 1e-9 * w.max(h).max(1.0); let miss = |b: Rect| (b.width() - w).abs() + (b.height() - h).abs(); let (mut sx, mut sy) = start; let mut b = measure(sx, sy)?; let mut best = (sx, sy, b); for _ in 0..16 { let f = [b.width() - w, b.height() - h]; if f[0].abs() <= tolerance && f[1].abs() <= tolerance { break; } // How the width and the height change with the x scale (`a`) and the y scale (`c`). let change = |x: bool| -> Option<[f64; 2]> { let (on, s) = if x { (free[0], sx) } else { (free[1], sy) }; if !on { return Some([0.0, 0.0]); } let ds = (s.abs() * 1e-4).max(1e-6); let m = if x { measure(sx + ds, sy) } else { measure(sx, sy + ds) }?; Some([(m.width() - b.width()) / ds, (m.height() - b.height()) / ds]) }; let (Some(a), Some(c)) = (change(true), change(false)) else { break }; let dot = |u: [f64; 2], v: [f64; 2]| u[0] * v[0] + u[1] * v[1]; let (aa, ac, cc, af, cf) = (dot(a, a), dot(a, c), dot(c, c), dot(a, f), dot(c, f)); let det = aa * cc - ac * ac; let (dx, dy) = if det > 1e-12 * aa * cc && det > 0.0 { ((ac * cf - cc * af) / det, (ac * af - aa * cf) / det) } else if aa >= cc && aa > 0.0 { (-af / aa, 0.0) } else if cc > 0.0 { (0.0, -cf / cc) } else { break; }; let (nx, ny) = ((sx + dx).max(0.0), (sy + dy).max(0.0)); if !(nx.is_finite() && ny.is_finite()) || (nx == sx && ny == sy) { break; } let Some(next) = measure(nx, ny) else { break }; (sx, sy, b) = (nx, ny, next); if miss(b) < miss(best.2) { best = (sx, sy, b); } } let (sx, sy, b) = best; Some((sx, sy, vectorcraft_geom::reference_point(b, refi))) } /// The `width` and `height` `object.setBounds` asks for a box now `b`: the one not given stays, or /// with `proportional` follows the one given. fn wanted_size(p: &Value, b: Rect) -> (f64, f64) { let mut w = f64_or(p, "width", b.width()); let mut h = f64_or(p, "height", b.height()); if bool_or(p, "proportional", false) { if p.get("width").is_some() && b.width() > 0.0 { h = b.height() * w / b.width(); } else if p.get("height").is_some() && b.height() > 0.0 { w = b.width() * h / b.height(); } } (w, h) } /// `object.setBounds` with anchors selected with Direct Selection (#1824): the values are those of /// `b`, the box around the anchors (and the objects selected whole) square to the page, and only /// the anchors, their handles with them, and those objects move or scale. fn set_anchor_bounds(s: &mut Session, p: &Value, ids: Vec, b: Rect) -> Result { let refi = reference_index(p)?; let rp = vectorcraft_geom::reference_point(b, refi); let (w, h) = wanted_size(p, b); // A single anchor, or anchors in a line, have no size to scale on that side. let ratio = |size: f64, now: f64| if now > 1e-9 { size / now } else { 1.0 }; let scale = about(rp, Affine::scale_non_uniform(ratio(w, b.width()), ratio(h, b.height()))); let to = Point::new(f64_or(p, "x", rp.x), f64_or(p, "y", rp.y)); apply_transform(s, "Transform", ids, Affine::translate(to - rp) * scale, p, true) } fn reference_index(p: &Value) -> Result { let reference = crate::cmd::number_or(p, "reference", 4.0, "object.setBounds")?; if !reference.is_finite() || reference < 0.0 || reference.fract() != 0.0 { return Err(crate::cmd::bad("object.setBounds", "`reference` must be a whole number")); } Ok(reference.min(8.0) as usize) } /// The visual box of `ids` square to `frame`, as [`Document::oriented_bounds`] measures it, with /// symbol instances measured without the strokes in their art /// ([`vectorcraft_doc::SymbolBoxes::without_art_strokes`]). fn scaling_box(d: &Document, ids: &[NodeId], frame: &OrientedBox) -> Option { let symbols = d.symbol_boxes().without_art_strokes(); let to_local = frame.to_doc().inverse(); ids.iter().filter_map(|id| d.node(*id)).fold(None, |acc, n| { let b = if frame.angle == 0.0 { n.visual_bounds_with(&symbols) } else { n.bounds_in(&symbols, to_local, true) }; vectorcraft_geom::union_opt(acc, b) }) }