Merge main into feat/control-bar-shape-widgets

This commit is contained in:
dotCooCoo committed 2026-11-18 14:13:10 -08:00
commit cf4dd8b375
296 files changed
+33760 -1458

No files matched your search

Generated
+1
View File
@@ -6644,6 +6644,7 @@ dependencies = [
"webbrowser",
"windows",
"winit",
"winreg",
"winresource",
"winsafe",
"wl-clipboard-rs",
+1
View File
@@ -157,6 +157,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 2026-11-18: Common Tangents also takes a point (a path of one anchor) and a convex closed path: the lines from the point that touch the path, and the line from the point to the path's center if asked; a point on the outline gets the one tangent there, and a point inside gets none, with a message (#7846). A VectorCraft addition: headline numbers unchanged.
- 2026-11-15: With Smart Guides and Snap to Tangent on, a Line Segment drag pressed on one convex curved path and dragged near another lands on a common tangent of the two: both ends move to where the line touches the paths, each labeled "tangent" (#7845). A VectorCraft addition: headline numbers unchanged.
- 2026-11-15: Smooth Bridge joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): two selected circles become one closed outline joined by two concave arcs that touch both circles, so every anchor is smooth; the arcs' radius is a percentage of the smaller circle's radius (1 to 1000%, 100% by default), and Keep Originals adds the outline above the circles instead of replacing them. A dialog with Preview, one undo step (`addon.pathtools.bridge`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-18: Smooth Bridge also joins three or more circles: every two whose outlines are within Reach (10 pt by default) are joined, the bridges that connect become one shape each, and a circle bridged to no other stays as it is (at most 2000 circles); with Constant Gap the arcs' radius is the smaller circle's radius plus a gap (#8030). A VectorCraft addition: headline numbers unchanged.
- 2026-11-03: Text Tweaker, the first tool of the Type Tools add-on (Object › Plug-ins › Type Tools): one character attribute (size, baseline shift, rotation, horizontal or vertical scale, tracking, leading or stroke weight) goes letter by letter from a start value to an end value along a straight ramp, an ease, a bow, a spike or at random with a seed, set as the Character panel sets it, while the text stays live; a dialog with Preview, one undo step (`addon.type.textTweaker`, #4924). A VectorCraft addition: headline numbers unchanged.
- 2026-11-01: Group Overlapping Objects joins the Arrange Tools add-on (Object › Plug-ins › Arrange Tools): the selected objects whose visual bounds overlap or touch, chains included, go into one group each, within their own layer or group, at the stacking place of their frontmost member; objects that overlap nothing stay as they are. One undo step, a sweep along x so thousands of loose pieces group quickly (at most 20000 objects). A VectorCraft addition: headline numbers unchanged.
- 2026-10-31: Export for Screens works as the reference app's dialog: Artboards and Assets tabs with a grid or list of thumbnails, Clear Selection and Prefix, Create Sub-folders by Scale or Format (on by default), Export PDFs As Single File (the chosen artboards as one PDF's pages, `pdfs: "single"`) or Multiple Files, iOS and Android rows, format presets in a ☰ menu, and a count of the files the export writes (#4895). About 55 community PRs and fixes landed the same day: Find Font, Replace Font, Outline Stroke and Expand leave hidden and locked art alone (with a warning); DXF export writes LINE and ELLIPSE entities and outlines only the strokes a CAD line can't draw; Blob Brush Angle and Roundness; Shift-constrained Perspective Selection; Grid Repeat Options Preview; a gradient mesh from a file budgeted at about a million quads; width-profile strokes keep their shape zoomed out; `.ai`/EPS import fidelity (area type, envelopes, transparency in dictionaries, character styles); PDF import finds hyphenated and CMap-suffixed font names; Windows renders follow the process's core affinity; Enter or Escape in a floating panel's field no longer reaches the canvas (#4803); Properties shows Blend Options for any selected blend (#4817); Artwork Cleanup finds doubled type (#4835) and joins stacked lines into one object (Join Point Text, #4826). Headline numbers unchanged.
+3
View File
@@ -40,6 +40,9 @@ craft-print = { workspace = true }
[target.'cfg(windows)'.dependencies]
craft-update = { workspace = true }
clipboard-win = { workspace = true }
# Reads a print queue's Standard TCP/IP RAW port for the direct-PDF transport (src/direct_pdf.rs).
# MIT, already in the build through the update client.
winreg = "0.55"
# Which GPU drives which display (EnumDisplayDevices, src/gpu.rs), so the window is drawn on the
# GPU that shows it: drawing on a GPU without a monitor reset the display driver. Safe wrappers over
# Win32 (MIT); the `user` feature is User32.dll only. Only the wgpu renderer chooses an adapter.
+5
View File
@@ -3,6 +3,8 @@
use std::process::Command;
use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
mod direct_pdf;
pub struct SystemPrint;
impl PrintService for SystemPrint {
fn printers(&mut self) -> Vec<Printer> {
@@ -43,6 +45,9 @@ mod system {
craft_print::printers().into_iter().map(|p| Printer { name: p.name, default: p.default }).collect()
}
pub fn print(job: &PrintJob) -> Result<String, String> {
if job.direct_pdf {
return super::direct_pdf::print(job);
}
// Copies, layout, marks and colour management are already in the PDF. Preserve its
// physical sheet size and the queue's duplex default without printing copies twice.
let settings = craft_print::Job { printer: job.printer.map(str::to_string), title: job.title.into(), ..Default::default() };
+127
View File
@@ -0,0 +1,127 @@
//! Send the print-ready PDF to the printer's own PDF interpreter over its RAW TCP port.
//!
//! This is the opt-in escape hatch for large-format PCL drivers that rewrite a custom page
//! (the HP DesignJet Z5200ps V4 driver emits a square PCL page for a 1067 x 480 mm sheet). The
//! PDF already carries the paper size, so the printer's interpreter prints it as laid out.
#[cfg(windows)]
mod imp {
use std::io::Write;
use std::net::{Shutdown, TcpStream, ToSocketAddrs};
use std::time::Duration;
use vectorcraft_ui_egui::print::PrintJob;
use winreg::RegKey;
use winreg::enums::{HKEY_LOCAL_MACHINE, KEY_READ};
/// Submit one composed PDF to the selected printer's Standard TCP/IP RAW port.
pub fn print(job: &PrintJob) -> Result<String, String> {
let printer = job
.printer
.map(str::to_string)
.or_else(|| craft_print::printers().into_iter().find(|p| p.default).map(|p| p.name))
.ok_or("direct PDF needs a selected printer")?;
let (host, port) = tcp_port(&printer)?;
send(&host, port, &pjl(job.title, job.pdf))?;
Ok(format!(" (direct PDF to {host}:{port})"))
}
/// The `HostName` and port of a printer port registered as a Standard TCP/IP RAW port.
fn tcp_port(printer: &str) -> Result<(String, u16), String> {
let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
let printer_key = hklm
.open_subkey_with_flags(format!(r"SYSTEM\CurrentControlSet\Control\Print\Printers\{printer}"), KEY_READ)
.map_err(|e| format!("direct PDF: cannot read the printer settings for {printer}: {e}"))?;
let port_name: String = printer_key.get_value("Port").map_err(|e| format!("direct PDF: {printer} has no port: {e}"))?;
let port_key = hklm
.open_subkey_with_flags(format!(r"SYSTEM\CurrentControlSet\Control\Print\Monitors\Standard TCP/IP Port\Ports\{port_name}"), KEY_READ)
.map_err(|e| format!("direct PDF: {printer} does not use a Standard TCP/IP port ({port_name}): {e}"))?;
let protocol: u32 = port_key.get_value("Protocol").unwrap_or(1);
if protocol != 1 {
return Err(format!("direct PDF: {printer}'s port ({port_name}) is not a RAW TCP/IP port"));
}
let host = port_key
.get_value::<String, _>("HostName")
.ok()
.filter(|h| !h.trim().is_empty())
.or_else(|| port_key.get_value::<String, _>("IPAddress").ok().filter(|h| !h.trim().is_empty()))
.ok_or_else(|| format!("direct PDF: {printer}'s port ({port_name}) has no host address"))?;
let number = port_key.get_value::<u32, _>("PortNumber").unwrap_or(9100);
let port = u16::try_from(number).map_err(|_| format!("direct PDF: invalid port number {number}"))?;
Ok((host.trim().to_string(), port))
}
/// Frame the PDF for the printer's PJL interpreter.
fn pjl(title: &str, pdf: &[u8]) -> Vec<u8> {
let mut name: String = title.chars().map(|c| if (c.is_ascii_graphic() || c == ' ') && c != '"' { c } else { '_' }).take(80).collect();
if name.is_empty() {
name.push_str("VectorCraft");
}
let mut out = Vec::with_capacity(pdf.len() + 96);
out.extend_from_slice(b"\x1b%-12345X@PJL JOB NAME=\"");
out.extend_from_slice(name.as_bytes());
out.extend_from_slice(b"\"\r\n@PJL ENTER LANGUAGE=PDF\r\n");
out.extend_from_slice(pdf);
out.extend_from_slice(b"\r\n\x1b%-12345X@PJL EOJ\r\n");
out
}
/// Stream `data` to the first reachable address of `host:port`.
fn send(host: &str, port: u16, data: &[u8]) -> Result<(), String> {
let addrs = (host, port).to_socket_addrs().map_err(|e| format!("direct PDF: cannot resolve {host}: {e}"))?;
let mut last = None;
for addr in addrs {
match TcpStream::connect_timeout(&addr, Duration::from_secs(10)) {
Ok(mut stream) => {
stream.set_write_timeout(Some(Duration::from_secs(120))).map_err(|e| format!("direct PDF: {e}"))?;
stream.write_all(data).map_err(|e| format!("direct PDF: writing to {host}:{port} failed: {e}"))?;
stream.shutdown(Shutdown::Write).map_err(|e| format!("direct PDF: finishing {host}:{port} failed: {e}"))?;
return Ok(());
}
Err(e) => last = Some(e),
}
}
Err(match last {
Some(e) => format!("direct PDF: cannot connect to {host}:{port}: {e}"),
None => format!("direct PDF: {host}:{port} has no addresses"),
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Read;
use std::net::TcpListener;
#[test]
fn the_pjl_frames_the_pdf() {
let out = pjl("witch hat\"", b"%PDF-1.7");
let text = String::from_utf8_lossy(&out);
assert!(text.starts_with("\u{1b}%-12345X@PJL JOB NAME=\"witch hat_\"\r\n@PJL ENTER LANGUAGE=PDF\r\n"));
assert!(text.contains("%PDF-1.7"));
assert!(text.ends_with("\r\n\u{1b}%-12345X@PJL EOJ\r\n"));
}
#[test]
fn the_pdf_reaches_a_listening_port() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let t = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut got = Vec::new();
stream.read_to_end(&mut got).unwrap();
got
});
send("127.0.0.1", port, b"%PDF-1.7 test").unwrap();
assert_eq!(t.join().unwrap(), b"%PDF-1.7 test");
}
}
}
#[cfg(windows)]
pub use imp::print;
#[cfg(not(windows))]
pub fn print(_: &vectorcraft_ui_egui::print::PrintJob) -> Result<String, String> {
Err("direct PDF printing is only available on Windows".into())
}
+440
View File
@@ -0,0 +1,440 @@
//! Flare objects: the settings a flare group was drawn with (the Flare tool, `shape.flare`). Its
//! children are ordinary paths for every renderer and exporter; the settings let it be drawn again.
use serde::{Deserialize, Serialize};
use serde_json::Value;
use vectorcraft_color::{BlendMode, Color, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
use vectorcraft_geom::{Affine, BezPath, PathData, Point, Rect, Vec2, shapes};
use crate::Appearance;
use crate::node::{Node, NodeId, NodeKind};
/// The seed of the sizes a flare's rays and rings take when its settings give none.
pub const DEFAULT_SEED: u64 = 0x2545_f491_4f6c_dd1d;
/// One part of a flare: its name, outline, fill and opacity.
pub type Part = (&'static str, PathData, Paint, f32);
/// The number `key` of the settings `v`, or `default`.
fn number(v: &Value, key: &str, default: f64) -> f64 {
v.get(key).and_then(Value::as_f64).unwrap_or(default)
}
/// The parts of a flare with the settings `v` (`shape.flare`'s params, each one given): a bright
/// center, a halo ring, rays of varying length and rings along the path to the end point.
pub fn parts(v: &Value) -> Vec<Part> {
let c = Point::new(number(v, "cx", 0.0), number(v, "cy", 0.0));
let end = Point::new(number(v, "x2", c.x), number(v, "y2", c.y));
let pct = |k: &str| (number(v, k, 0.0) / 100.0).clamp(0.0, 10.0);
let r = (number(v, "diameter", 100.0) / 2.0).max(0.5);
let opacity = pct("opacity").min(1.0) as f32;
let brightness = pct("brightness").min(1.0) as f32;
let growth = pct("growth");
let fuzz = pct("fuzziness").min(1.0);
let rays = v.get("rays").and_then(Value::as_u64).unwrap_or(0).min(50) as usize;
let longest = pct("longest");
let ray_fuzz = pct("rayFuzziness").min(1.0);
let ray_turn = number(v, "rotation", 0.0).to_radians();
let rings = v.get("rings").and_then(Value::as_u64).unwrap_or(0).min(50) as usize;
let largest = pct("largest");
// Deterministic pseudo-random sizes (same parameters → same flare). `ringSeed` places the rings
// along the path from a sequence of its own; their count and sizes and the other parts stay.
// Xorshift64. Both streams start from a nonzero state.
let random = |mut state: u64| {
move || {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
(state >> 11) as f64 / (1u64 << 53) as f64
}
};
let mut rnd = random(v.get("seed").and_then(Value::as_u64).unwrap_or(DEFAULT_SEED) | 1);
// Each `ringSeed` below 2^53 (what a JSON number holds exactly) gets a state of its own.
let mut ring_at = v.get("ringSeed").and_then(Value::as_u64).filter(|r| *r < 1 << 53).map(|r| {
// SplitMix64 initializes the ring-position stream.
let mut z = r.wrapping_add(0x9e37_79b9_7f4a_7c15);
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
random(z ^ (z >> 31))
});
let stop = |offset: f32, opacity: f32| GradientStop { opacity, ..GradientStop::new(offset, Color::WHITE) };
let radial = |centre: Point, radius: f64, stops: Vec<GradientStop>| {
let mut g = GradientPaint::new(Gradient::new(GradientKind::Radial, stops));
g.geom = Some(GradientGeom { start: centre, end: centre + Vec2::new(radius, 0.0), aspect: 1.0, focal: None });
Paint::Gradient(Box::new(g))
};
let circle = |centre: Point, radius: f64| shapes::ellipse(Rect::from_center_size(centre, (radius * 2.0, radius * 2.0)));
let mut parts: Vec<Part> = vec![];
// Halo: a soft ring just outside the centre.
let halo_r = r * (1.0 + growth) * 1.6;
let inner = (1.0 - fuzz as f32 * 0.6).clamp(0.05, 0.95);
parts.push(("Halo", circle(c, halo_r), radial(c, halo_r, vec![stop(0.0, 0.0), stop(inner * 0.75, 0.0), stop(inner, 0.5), stop(1.0, 0.0)]), 1.0));
// Rays: thin spikes of random length (Longest = % of the centre radius), fading outwards.
// `rotation` turns them clockwise about the center.
if rays > 0 {
let mut bp = BezPath::new();
let mut reach: f64 = 0.0;
for i in 0..rays {
let a = std::f64::consts::TAU * (i as f64 + rnd() * 0.6) / rays as f64 + ray_turn;
let len = r * longest * (1.0 - ray_fuzz * 0.75 * rnd()).max(0.1);
reach = reach.max(len);
let w = r * 0.035;
let dir = Vec2::new(a.cos(), a.sin());
let n = Vec2::new(-dir.y, dir.x) * w;
bp.move_to(c + n);
bp.line_to(c + dir * len);
bp.line_to(c - n);
bp.line_to(c - dir * (w * 4.0));
bp.close_path();
}
parts.push(("Rays", PathData::from_bezpath(&bp), radial(c, reach, vec![stop(0.0, 0.9), stop(0.25, 0.35), stop(1.0, 0.0)]), 1.0));
}
// Centre: bright core fading to transparent.
parts.push(("Center", circle(c, r), radial(c, r, vec![stop(0.0, 1.0), stop(0.25 + brightness * 0.5, 0.6), stop(1.0, 0.0)]), opacity));
// Rings along the path to the end point (Largest = % of the average ring size).
for _ in 0..rings {
let t = rnd();
let t = ring_at.as_mut().map_or(t, |next| next());
let at = c + (end - c) * t;
let rr = (r * largest * (0.25 + rnd() * 0.75)).max(0.5);
let solid = rnd() < 0.5;
let stops = if solid {
vec![stop(0.0, 0.25), stop(0.8, 0.2), stop(1.0, 0.0)]
} else {
vec![stop(0.0, 0.0), stop(0.7, 0.05), stop(0.92, 0.35), stop(1.0, 0.0)]
};
parts.push(("Ring", circle(at, rr), radial(at, rr, stops), 1.0));
}
parts
}
/// Part `part` of a flare as the object `id`, transformed by `xf` (the transform its flare has had
/// since it was drawn), with the pixel-aligned property when `aligned`.
pub fn part_node(id: NodeId, part: Part, xf: Affine, aligned: bool) -> Node {
let (name, pd, paint, op) = part;
let mut n = Node::path(id, pd, Appearance::basic(paint, Paint::None, 0.0));
n.name = Some(name.into());
n.blend = BlendMode::Screen;
n.opacity = op;
if aligned {
n.extras_mut().pixel_aligned = true;
}
if xf != Affine::IDENTITY {
n.transform(xf, false);
}
n
}
/// The ellipse of a radial gradient's placement `geom` as the symmetric matrix `[xx, xy, yy]` that
/// maps it to the unit circle's: the same for every end point and aspect that give that ellipse
/// (transforms applied one by one and all at once can put the end on different axes of it).
fn ellipse(geom: &GradientGeom) -> [f64; 3] {
let u = geom.end - geom.start;
let w = Vec2::new(-u.y, u.x) * geom.aspect;
[u.x * u.x + w.x * w.x, u.x * u.y + w.x * w.y, u.y * u.y + w.y * w.y]
}
/// The ellipse `[xx, xy, yy]` ([`ellipse`]) as its size, the length of its longer half-axis, and
/// its shape: the ratio of its shorter axis to its longer one, then the cosine and sine of twice
/// the longer axis's angle, each times one minus that ratio (0 for a circle). Each number is a
/// length or a ratio of lengths, never a squared length that a tiny flare or a narrow gradient
/// makes smaller than the tolerance.
fn ellipse_size_and_shape(geom: &GradientGeom) -> (f64, [f64; 3]) {
let [xx, xy, yy] = ellipse(geom);
let half_diff = (xx - yy) / 2.0;
let d = half_diff.hypot(xy);
let longer = (xx + yy) / 2.0 + d;
if longer.is_nan() || longer <= 0.0 {
return (0.0, [0.0; 3]);
}
// The product of the half-axes is the area factor of the map from the unit circle, `u` across
// `w` as [`ellipse`] builds them: a sum of squares times the aspect, without the cancellation
// of `xx * yy - xy * xy` for a narrow ellipse.
let u = geom.end - geom.start;
let w = Vec2::new(-u.y, u.x) * geom.aspect;
let ratio = ((u.x * w.y - u.y * w.x).abs() / longer).min(1.0);
let (cos, sin) = if d > 0.0 { (half_diff / d, xy / d) } else { (0.0, 0.0) };
(longer.sqrt(), [ratio, (1.0 - ratio) * cos, (1.0 - ratio) * sin])
}
/// `n` as JSON without what depends on how its transforms were applied: its id, the angle of its
/// bounding box, and which axis of a gradient's ellipse its end point is on (the ellipse stays: its
/// size in the placement, and its shape beside the placement, out of reach of a pixel-aligned
/// part's snap allowance, which is a length).
fn comparable(n: &Node) -> Value {
fn strip(v: &mut Value) {
match v {
Value::Object(m) => {
for key in ["id", "bbox_angle"] {
m.remove(key);
}
if let Some(geom) = m.get_mut("geom")
&& let Ok(g) = serde_json::from_value::<GradientGeom>(geom.clone())
&& let Value::Object(geom) = geom
{
let (size, shape) = ellipse_size_and_shape(&g);
geom.remove("end");
geom.remove("aspect");
geom.insert("ellipse".into(), serde_json::json!(size));
m.insert("ellipseShape".into(), serde_json::json!(shape));
}
m.values_mut().for_each(strip);
}
Value::Array(a) => a.iter_mut().for_each(strip),
_ => {}
}
}
let mut v = serde_json::to_value(n).unwrap_or(Value::Null);
strip(&mut v);
v
}
/// How close, relative to its size, a number in an outline or a gradient's placement must be to the
/// one its transforms give: a few thousandths of a point near the edge of the canvas.
const GEOMETRY_TOL: f64 = 1e-9;
/// Whether `a` and `b` are the same JSON, with each number within `tol` relative to its size; each
/// number in an outline (`path`) or a gradient's placement (`geom`) is within [`GEOMETRY_TOL`]
/// relative to its size (or `tol`, when smaller), and `snap` points as well.
fn close(a: &Value, b: &Value, tol: f64, snap: f64, geometry: bool) -> bool {
match (a, b) {
(Value::Number(x), Value::Number(y)) => match (x.as_f64(), y.as_f64()) {
(Some(x), Some(y)) => {
let (snap, tol) = if geometry { (snap, tol.min(GEOMETRY_TOL)) } else { (0.0, tol) };
(x - y).abs() <= snap + tol * (1.0 + x.abs().max(y.abs()))
}
_ => x == y,
},
(Value::Array(x), Value::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(x, y)| close(x, y, tol, snap, geometry)),
(Value::Object(x), Value::Object(y)) => {
x.len() == y.len()
&& x.iter().all(|(k, v)| {
// A gradient's shape is ratios: compared as closely as geometry, without the snap.
let snap = if k == "ellipseShape" { 0.0 } else { snap };
y.get(k).is_some_and(|w| close(v, w, tol, snap, geometry || k == "path" || k == "geom" || k == "ellipseShape"))
})
}
_ => a == b,
}
}
/// Whether `a` and `b` are the same JSON, with each number within `tol` relative to its size.
pub fn json_close(a: &Value, b: &Value, tol: f64) -> bool {
close(a, b, tol, 0.0, false)
}
/// How far a pixel-aligned object's points may be from where its transforms put them: snapping to
/// the pixel grid moves each by up to a pixel.
const PIXEL_SNAP: f64 = 1.0;
/// The settings of a flare group ([`crate::NodeExtras::flare`]).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FlareSpec {
/// `shape.flare`'s params the flare was drawn with, each one given: the center (`cx`, `cy`) and
/// the rings' end point (`x2`, `y2`) are in the coordinates it was drawn in.
pub params: serde_json::Value,
/// The transform its art has had since it was drawn (moves, scales, rotations, reflections and
/// shears).
#[serde(default = "identity", skip_serializing_if = "is_identity")]
pub transform: Affine,
}
fn identity() -> Affine {
Affine::IDENTITY
}
fn is_identity(a: &Affine) -> bool {
*a == Affine::IDENTITY
}
impl FlareSpec {
/// The settings of a flare drawn with `params`, not transformed since.
pub fn new(params: serde_json::Value) -> Self {
Self { params, transform: Affine::IDENTITY }
}
/// The point `key_x`, `key_y` of the params, where it is in the document now.
fn point(&self, key_x: &str, key_y: &str) -> Option<Point> {
let x = self.params.get(key_x)?.as_f64()?;
let y = self.params.get(key_y)?.as_f64()?;
Some(self.transform * Point::new(x, y)).filter(|p| p.x.is_finite() && p.y.is_finite())
}
/// The flare's center, where it is in the document now.
pub fn center(&self) -> Option<Point> {
self.point("cx", "cy")
}
/// The rings' end point, where it is in the document now.
pub fn end(&self) -> Option<Point> {
self.point("x2", "y2")
}
/// Its art transformed by `a`.
pub fn transform(&mut self, a: Affine) {
self.transform = a * self.transform;
}
/// Whether `group`'s parts are still the ones these settings draw, in place: none was edited,
/// distorted, removed or added, and the transform can be undone. The parts are compared where
/// they are in the document, at any scale.
pub fn draws(&self, group: &Node) -> bool {
let NodeKind::Group { children, .. } = &group.kind else { return false };
if !self.transform.is_finite() || self.transform.determinant() == 0.0 || !self.transform.inverse().is_finite() {
return false;
}
let expected = parts(&self.params);
expected.len() == children.len()
&& expected.into_iter().zip(children).all(|(part, child)| {
let aligned = child.extras().pixel_aligned;
let snap = if aligned { PIXEL_SNAP } else { 0.0 };
close(&comparable(&part_node(child.id, part, self.transform, aligned)), &comparable(child), 1e-6, snap, false)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
/// A flare's center and end point follow its art through a transform, and a save and reload
/// keeps its settings.
#[test]
fn a_flare_keeps_its_settings_through_a_transform_and_a_save() {
let mut g = Node::group(NodeId(1), vec![std::sync::Arc::new(Node::path(NodeId(2), PathData::default(), Default::default()))]);
g.extras_mut().flare = Some(Box::new(FlareSpec::new(json!({ "cx": 10.0, "cy": 20.0, "x2": 110.0, "y2": 20.0, "seed": 7 }))));
g.transform(Affine::translate((5.0, 0.0)) * Affine::rotate(std::f64::consts::FRAC_PI_2), false);
let spec = g.extras().flare.as_deref().cloned().unwrap_or_else(|| panic!("no flare"));
let c = spec.center().unwrap_or_else(|| panic!("no center"));
let e = spec.end().unwrap_or_else(|| panic!("no end"));
assert!((c.x - -15.0).abs() < 1e-9 && (c.y - 10.0).abs() < 1e-9, "{c:?}");
assert!((e.x - -15.0).abs() < 1e-9 && (e.y - 110.0).abs() < 1e-9, "{e:?}");
let text = serde_json::to_string(&g).unwrap_or_else(|e| panic!("{e}"));
let back: Node = serde_json::from_str(&text).unwrap_or_else(|e| panic!("{e}"));
assert_eq!(back.extras().flare.as_deref(), Some(&spec));
// A flare that was not transformed writes no transform.
let plain = FlareSpec::new(json!({ "cx": 1.0 }));
assert_eq!(serde_json::to_value(&plain).unwrap_or_default(), json!({ "params": { "cx": 1.0 } }));
}
/// A flare group draws its settings until a part's gradient, opacity or outline is edited; a
/// pixel-aligned part may sit up to a pixel from where its transforms put it, but only in its
/// outline and its gradient's placement.
#[test]
fn a_flare_with_an_edited_part_no_longer_draws_its_settings() {
let v = json!({ "cx": 50.0, "cy": 50.0, "x2": 250.0, "y2": 50.0, "rays": 5, "rings": 2, "seed": 9, "diameter": 40.0,
"opacity": 50.0, "brightness": 30.0, "growth": 20.0, "fuzziness": 50.0, "longest": 300.0, "rayFuzziness": 100.0,
"rotation": 0.0, "largest": 50.0 });
let flare = |aligned: bool| {
let xf = Affine::rotate(0.3) * Affine::scale_non_uniform(1.5, 0.75);
let children = parts(&v).into_iter().enumerate().map(|(i, p)| std::sync::Arc::new(part_node(NodeId(10 + i as u64), p, xf, aligned)));
let mut g = Node::group(NodeId(1), children.collect());
g.extras_mut().flare = Some(Box::new(FlareSpec { params: v.clone(), transform: xf }));
g
};
let spec = |g: &Node| g.extras().flare.as_deref().cloned().unwrap_or_else(|| panic!("no flare"));
let edit = |g: &mut Node, f: &dyn Fn(&mut Node)| {
let NodeKind::Group { children, .. } = &mut g.kind else { panic!("not a group") };
// The center, drawn at half opacity.
f(std::sync::Arc::make_mut(&mut children[2]));
};
for aligned in [false, true] {
let g = flare(aligned);
assert!(spec(&g).draws(&g), "aligned {aligned}");
let mut moved = g.clone();
edit(&mut moved, &|n| n.transform(Affine::translate((0.4, 0.0)), false));
assert_eq!(spec(&moved).draws(&moved), aligned, "a fraction of a pixel, aligned {aligned}");
let mut faded = g.clone();
edit(&mut faded, &|n| n.opacity *= 0.8);
assert!(!spec(&faded).draws(&faded), "opacity, aligned {aligned}");
let mut shifted = g.clone();
edit(&mut shifted, &|n| {
if let Some(crate::AppearanceItem::Fill(fill)) = n.appearance.items.first_mut()
&& let Paint::Gradient(gp) = &mut fill.paint
&& let Some(geom) = &mut gp.geom
{
geom.start.x += 20.0;
}
});
assert!(!spec(&shifted).draws(&shifted), "gradient placement, aligned {aligned}");
let mut squashed = g.clone();
edit(&mut squashed, &|n| {
if let Some(crate::AppearanceItem::Fill(fill)) = n.appearance.items.first_mut()
&& let Paint::Gradient(gp) = &mut fill.paint
&& let Some(geom) = &mut gp.geom
{
geom.aspect *= 0.5;
}
});
assert!(!spec(&squashed).draws(&squashed), "gradient shape, aligned {aligned}");
}
}
/// An ellipse's size and shape are the same whichever axis its end point is on, and a narrow
/// gradient made narrower, or turned, changes its shape by more than [`GEOMETRY_TOL`].
#[test]
fn an_ellipse_shape_tells_narrow_gradients_apart() {
let geom = |end: (f64, f64), aspect: f64| GradientGeom { start: Point::new(1.0, 2.0), end: Point::new(end.0, end.1), aspect, focal: None };
let of = ellipse_size_and_shape;
let (size, shape) = of(&geom((11.0, 2.0), 0.5));
// The same ellipse with its end point on the other axis.
let (size2, shape2) = of(&geom((1.0, 7.0), 2.0));
assert!((size - size2).abs() < 1e-12 && shape.iter().zip(shape2).all(|(a, b)| (a - b).abs() < 1e-12), "{shape:?} {shape2:?}");
// A very narrow ellipse, given both ways, keeps its shape to within the tolerance.
let (thin, thin2) = (of(&geom((11.0, 2.0), 1e-8)).1, of(&geom((1.0, 2.0 + 1e-7), 1e8)).1);
assert!(thin.iter().zip(thin2).all(|(a, b)| (a - b).abs() < GEOMETRY_TOL), "{thin:?} {thin2:?}");
let narrow = of(&geom((11.0, 2.0), 1e-4)).1;
for other in [of(&geom((11.0, 2.0), 5e-5)).1, of(&geom((1.0, 12.0), 1e-4)).1] {
assert!(narrow.iter().zip(other).any(|(a, b)| (a - b).abs() > 1e3 * GEOMETRY_TOL), "{narrow:?} {other:?}");
}
assert_eq!(of(&geom((1.0, 2.0), 1.0)), (0.0, [0.0; 3]));
}
/// A flare scaled far down, in one direction or in all, anywhere on the canvas, still draws its
/// settings, and a part's gradient whose shape was edited is still told apart; a flattened flare
/// does not draw its settings.
#[test]
fn a_flare_scaled_far_down_still_draws_its_settings() {
let v = json!({ "cx": 50.0, "cy": 50.0, "x2": 250.0, "y2": 50.0, "rays": 5, "rings": 2, "seed": 9, "diameter": 40.0 });
let flare_aligned = |xf: Affine, aligned: bool| {
let children = parts(&v).into_iter().enumerate().map(|(i, p)| std::sync::Arc::new(part_node(NodeId(10 + i as u64), p, xf, aligned)));
let mut g = Node::group(NodeId(1), children.collect());
g.extras_mut().flare = Some(Box::new(FlareSpec { params: v.clone(), transform: xf }));
g
};
let flare = |xf: Affine| flare_aligned(xf, false);
// The center's gradient placement, to edit.
let center_geom = |g: &mut Node, f: &dyn Fn(&mut GradientGeom)| {
let NodeKind::Group { children, .. } = &mut g.kind else { panic!("not a group") };
if let Some(crate::AppearanceItem::Fill(fill)) = std::sync::Arc::make_mut(&mut children[2]).appearance.items.first_mut()
&& let Paint::Gradient(gp) = &mut fill.paint
&& let Some(geom) = &mut gp.geom
{
f(geom);
} else {
panic!("the center has no gradient fill");
}
};
let draws = |g: &Node| g.extras().flare.as_deref().is_some_and(|spec| spec.draws(g));
assert!(draws(&flare(Affine::scale(1e-7))), "scaled to 0.00001%");
assert!(draws(&flare(Affine::rotate(0.3) * Affine::scale_non_uniform(1.0, 1e-10))), "shrunk far on one axis");
assert!(draws(&flare(Affine::translate((crate::MAX_COORD - 1000.0, 0.0)) * Affine::scale(0.5))), "near the edge of the canvas");
assert!(draws(&flare(Affine::translate((1000.0, 0.0)) * Affine::scale(1e-5))), "scaled to 0.001% and moved away");
assert!(!draws(&flare(Affine::scale_non_uniform(1.0, 0.0))), "flattened");
// At that size a part whose gradient's shape was edited no longer draws the settings.
let mut squashed = flare(Affine::scale(1e-6));
assert!(draws(&squashed), "scaled to 0.0001%");
center_geom(&mut squashed, &|geom| geom.aspect *= 0.5);
assert!(!draws(&squashed), "gradient shape at 0.0001%");
// A pixel-aligned part may sit up to a pixel off, but its gradient's shape may not change,
// even when the ellipse keeps its size.
let mut reshaped = flare_aligned(Affine::IDENTITY, true);
assert!(draws(&reshaped), "aligned");
center_geom(&mut reshaped, &|geom| {
let a = geom.aspect;
geom.aspect = a * 0.5;
geom.end = geom.start + (geom.end - geom.start) * ((1.0 + a * a) / (1.0 + a * a / 4.0)).sqrt();
});
assert!(!draws(&reshaped), "gradient shape of the same size, aligned");
}
}
+2 -1
View File
@@ -17,6 +17,7 @@ pub mod corners;
pub mod decode;
pub mod depth;
pub mod dimension;
pub mod flare;
pub mod graph;
mod halftone_radii;
pub mod hit;
@@ -170,7 +171,7 @@ use limits::MAX_NEXT_ID;
pub use limits::{DocError, FORMAT_VERSION, MAX_COORD};
pub use records::{ImageBlob, MaskEdit, NewArtIds, SavedSelection, SavedView, SvgFilter, Symbol, SymbolEdit};
pub use stored_art::{StoredPlace, StoredRoot};
pub use units::{ColorMode, Unit, decimal_point, finite_in_every_unit, parse_number};
pub use units::{ColorMode, Unit, arithmetic_signs, decimal_point, finite_in_every_unit, parse_number};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Document {
+1
View File
@@ -271,6 +271,7 @@ fn node_bytes(n: &Node, other: Option<&Node>, counted: &mut HashSet<usize>) -> u
.as_deref()
.map_or(0, |m| ALLOC + size_of::<crate::color_mask::ColorMask>() + m.key.capacity() + m.from.capacity() + m.colors.capacity() * 3);
b += e.trace.as_ref().map_or(0, |t| ALLOC + size_of::<Value>() + json_bytes(t));
b += e.flare.as_ref().map_or(0, |f| ALLOC + size_of::<crate::flare::FlareSpec>() + json_bytes(&f.params));
b += e.intertwine.as_deref().map_or(0, |a| ALLOC + size_of::<PathData>() + path_bytes(a));
if e.intertwine_tiers.capacity() > 0 {
b += ALLOC + e.intertwine_tiers.capacity() * size_of::<PathData>() + e.intertwine_tiers.iter().map(path_bytes).sum::<usize>();
+4
View File
@@ -41,6 +41,9 @@ pub struct NodeExtras {
/// Dimension object: the live measurement it draws; its ordinary group children hold its
/// exportable appearance (Object › Dimensions, the Dimension tool).
pub dimension: Option<Box<crate::dimension::Dimension>>,
/// Flare object: the settings its group was drawn with (the Flare tool); its ordinary group
/// children hold its art.
pub flare: Option<Box<crate::flare::FlareSpec>>,
/// Object › Intertwine: as a member of an Intertwine group, the area (document coordinates,
/// filled non-zero) where this object is drawn over the group's other members.
pub intertwine: Option<Box<PathData>>,
@@ -100,6 +103,7 @@ pub(super) static NO_EXTRAS: NodeExtras = NodeExtras {
slice: None,
perspective: None,
dimension: None,
flare: None,
intertwine: None,
intertwine_tiers: Vec::new(),
live_paint_gaps: None,
+6
View File
@@ -520,6 +520,12 @@ impl Node {
{
dimension.transform(a);
}
// So does a flare's center and end point.
if let Some(e) = self.extras_if_any()
&& let Some(flare) = &mut e.flare
{
flare.transform(a);
}
// The path the objects are attached to, before it is transformed.
let on_path_before = self.on_path_data().cloned();
if !self.is_layer() {
+5
View File
@@ -45,6 +45,7 @@ impl Serialize for Node {
is_default(&self.bbox_angle),
e.perspective.is_none(),
e.dimension.is_none(),
e.flare.is_none(),
e.intertwine.is_none(),
e.intertwine_tiers.is_empty(),
e.live_paint_gaps.is_none(),
@@ -91,6 +92,7 @@ impl Serialize for Node {
field!("bbox_angle", &self.bbox_angle);
field!("perspective", &e.perspective);
field!("dimension", &e.dimension);
field!("flare", &e.flare);
field!("intertwine", &e.intertwine);
field!("intertwine_tiers", &e.intertwine_tiers);
field!("live_paint_gaps", &e.live_paint_gaps);
@@ -228,6 +230,8 @@ pub(super) struct NodeWire {
#[serde(default)]
dimension: Option<Box<crate::dimension::Dimension>>,
#[serde(default)]
flare: Option<Box<crate::flare::FlareSpec>>,
#[serde(default)]
intertwine: Option<Box<PathData>>,
#[serde(default, deserialize_with = "counted_list")]
intertwine_tiers: Vec<PathData>,
@@ -271,6 +275,7 @@ impl From<NodeWire> for Node {
slice: w.slice,
perspective: w.perspective,
dimension: w.dimension,
flare: w.flare,
intertwine: w.intertwine,
intertwine_tiers: w.intertwine_tiers,
live_paint_gaps: w.live_paint_gaps,
+49 -1
View File
@@ -94,11 +94,59 @@ fn a_very_long_expression_reads_as_nothing() {
}
}
/// `x`, `X` and `×` multiply as `*` does (#8435), units and percentages included; a lowercase `x`
/// right after a `p` stays the `px` unit.
#[test]
fn x_is_a_multiplication_sign() {
let (mm, cm) = (72.0 / 25.4, 72.0 / 2.54);
for (u, s, want) in [
(Unit::Points, "10x2", 20.0),
(Unit::Points, "10 x 2", 20.0),
(Unit::Points, "10X2", 20.0),
(Unit::Points, "10×2", 20.0),
(Unit::Points, "10x-2", -20.0),
(Unit::Points, "10/2x5", 25.0),
(Unit::Points, "1+2x3", 7.0),
(Unit::Millimeters, "2x3 mm", 6.0 * mm),
(Unit::Points, "2x3mm", 6.0 * mm),
(Unit::Points, "3mm x 2", 6.0 * mm),
(Unit::Centimeters, "3cmx50%", 1.5 * cm),
(Unit::Points, "2p x 2", 48.0),
(Unit::Points, "10px", 10.0),
(Unit::Points, "2px x 3", 6.0),
(Unit::Points, "2pxx3", 6.0),
(Unit::Millimeters, "4x3 px", 12.0),
// Only a lowercase x after a p is the px suffix.
(Unit::Points, "2pX3", 72.0),
(Unit::Points, "2p×3", 72.0),
// Text that used to be refused now reads as a product.
(Unit::Points, "8.5x11 in", 93.5 * 72.0),
(Unit::Points, "0x10", 0.0),
] {
let got = u.parse(s).unwrap_or_else(|| panic!("{u:?} can't read `{s}`"));
assert!((got - want).abs() < 1e-9, "{u:?}: `{s}` → {got}, want {want}");
}
for s in ["x", "x2", "5x", "5 x x 2", "xx", "2px3"] {
assert_eq!(Unit::Points.parse(s), None, "{s}");
}
assert_eq!(crate::parse_number("45x2"), Some(90.0));
assert_eq!(crate::parse_number(" 45 X 2 "), Some(90.0));
assert_eq!(crate::parse_number("45×2"), Some(90.0));
assert_eq!(crate::parse_number("90x-1"), Some(-90.0));
assert_eq!(crate::parse_number("x"), None);
// Each sign counts toward the 128-sign limit as a `*` would.
assert_eq!(Unit::Points.parse(&format!("1{}", "x1".repeat(128))), Some(1.0));
assert_eq!(Unit::Points.parse(&format!("1{}", "x1".repeat(129))), None);
assert_eq!(crate::parse_number(&format!("1{}", "×1".repeat(129))), None);
assert_eq!(crate::arithmetic_signs("1+2x3X4×5*6/7-8"), 7);
assert_eq!(crate::arithmetic_signs("2px x 3"), 1);
}
proptest! {
/// Field text made of digits, operators, `%`, spaces and unit letters reads as a finite value
/// or as nothing and does not panic.
#[test]
fn arithmetic_text_reads_as_a_finite_value_or_nothing(s in "[0-9.+*/% ptxinmcfyd-]{0,24}") {
fn arithmetic_text_reads_as_a_finite_value_or_nothing(s in "[0-9.+*/% ptxXinmcfyd×-]{0,24}") {
for u in Unit::ALL {
if let Some(v) = u.parse(&s) {
prop_assert!(v.is_finite(), "{u:?}: `{s}` → {v}");
+51 -5
View File
@@ -157,12 +157,17 @@ impl Unit {
/// that share of everything before it (`50pt+25%` is 62.5 pt, `100pt+20pt-50%` is 60 pt). A
/// percentage on its own (`50%`) reads as nothing.
///
/// Text with more than 128 `+ - * /` signs reads as nothing.
/// `x`, `X` and `×` multiply as `*` does (`10x2` is 20, `2x3 mm` is 6 mm), except a lowercase
/// `x` right after a `p`, which is the `px` suffix (`2px x 3` is 6 px, and `2px3` reads as
/// nothing; write `2p x 3` for picas). `X` and `×` after a `p` multiply (`2pX3` is 6 picas).
///
/// Text with more than 128 `+ - * /` signs ([`arithmetic_signs`], a multiplication sign counted
/// as `*`) reads as nothing.
pub fn parse(self, s: &str) -> Option<f64> {
if s.chars().filter(|c| matches!(c, '+' | '-' | '*' | '/')).count() > MAX_MEASURE_OPERATORS {
if arithmetic_signs(s) > MAX_MEASURE_OPERATORS {
return None;
}
parse_measure(s, self).filter(|v| v.is_finite())
parse_measure(&times_as_asterisks(s), self).filter(|v| v.is_finite())
}
/// The value naming this unit in the Units preferences (`points`, `millimeters`,
/// `feetInches`).
@@ -215,6 +220,46 @@ impl Unit {
/// The most `+ - * /` signs [`Unit::parse`] reads in one text.
const MAX_MEASURE_OPERATORS: usize = 128;
/// The number of `+ - * /` signs in `s`, each multiplication sign typed as `x`, `X` or `×`
/// ([`Unit::parse`]) counted as a `*`.
pub fn arithmetic_signs(s: &str) -> usize {
let mut prev = None;
s.chars()
.filter(|&c| {
let sign = matches!(c, '+' | '-' | '*' | '/') || is_times(c, prev);
prev = Some(c);
sign
})
.count()
}
/// Is `c`, after `prev`, a multiplication sign typed as `x`, `X` or `×`? A lowercase `x` right
/// after a `p` is the `px` suffix (`2px x 3`), also where a number follows it (`2px3`).
fn is_times(c: char, prev: Option<char>) -> bool {
matches!(c, 'X' | '×') || (c == 'x' && prev != Some('p'))
}
/// `s` with each multiplication sign ([`is_times`]) written as `*` (`10 x 2` is `10 * 2`); text
/// without one is not copied.
fn times_as_asterisks(s: &str) -> std::borrow::Cow<'_, str> {
let mut prev = None;
let any = s.chars().any(|c| {
let times = is_times(c, prev);
prev = Some(c);
times
});
if !any {
return s.into();
}
let mut out = String::with_capacity(s.len());
let mut prev = None;
for c in s.chars() {
out.push(if is_times(c, prev) { '*' } else { c });
prev = Some(c);
}
out.into()
}
fn parse_measure(s: &str, default: Unit) -> Option<f64> {
let s = s.trim();
// Simple arithmetic on the right (Illustrator fields accept "10+5", "100/2", "3in*2").
@@ -348,9 +393,10 @@ pub fn finite_in_every_unit(pt: f64) -> bool {
}
/// A unitless field value (percent, degrees, counts) with the same `+ - * /` arithmetic as
/// [`Unit::parse`] (`45*2`, `100/3`); text other than digits, `.` and operators reads as nothing.
/// [`Unit::parse`] (`45*2`, `45x2`, `100/3`); text other than digits, `.` and operators reads as
/// nothing.
pub fn parse_number(s: &str) -> Option<f64> {
if !s.chars().all(|c| c.is_ascii_digit() || " .+-*/".contains(c)) {
if !s.chars().all(|c| c.is_ascii_digit() || " .+-*/xX×".contains(c)) {
return None;
}
// A leading `+` is a sign (`+5`), as a plain number read it.
+12 -1
View File
@@ -32,6 +32,7 @@ pub mod expand;
pub(crate) mod fileinfo;
pub mod fileio;
pub mod findfiles;
pub mod flare;
pub mod flatten;
pub mod fontfiles;
mod fonts;
@@ -101,9 +102,11 @@ pub(crate) mod tabs;
mod textedit;
pub use textedit::effective_kerning;
mod retype;
pub mod textstyles;
pub(crate) mod textwrap;
pub(crate) mod threads;
pub mod toast;
pub(crate) mod typecmd;
mod typemenu;
mod variablecmds;
@@ -321,6 +324,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(pathops::specs());
v.extend(compoundshape::specs());
v.extend(typecmd::specs());
v.extend(retype::specs());
v.extend(menucmds::specs());
v.extend(live::specs());
v.extend(colorcmds::specs());
@@ -333,6 +337,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(compositefonts::specs());
v.extend(fontfiles::specs());
v.extend(help::specs());
v.extend(toast::specs());
v.extend(threads::specs());
v.extend(textwrap::specs());
v.extend(graph::specs());
@@ -875,10 +880,14 @@ pub use xform::{AppearanceAttrs, EyedropperAttrs, EyedropperOptions, FillAttrs,
/// The shape modes of the selected compound-shape members (the Pathfinder panel lights theirs).
pub use compoundshape::selected_member_modes;
/// Make Compound Shape's warning when a member is an open path that encloses no area.
pub use compoundshape::OPEN_PATHS_ADD_NO_AREA;
/// Pathfinder Options (`Prefs::pathfinder`).
pub use pathops::{PATHFINDER_PRECISION_RANGE, PathfinderOptions};
/// The Attributes panel's state ([`Session::attributes_info`]).
/// The Attributes panel's state ([`Session::attributes_info`]) and how many recent URLs it keeps.
pub use attributes::RECENT_URLS;
pub use overprint::AttributesInfo;
/// Object → Flatten Transparency settings (`object.flattenTransparency`).
@@ -902,6 +911,8 @@ pub(crate) use buildcmds::TracePresetChanges;
/// The shapes a group selected alone gives the Pathfinder panel.
pub use pathops::shape_count;
/// The tile counts Create Object Mosaic would use (the dialog's Use Ratio button sets them).
pub use menucmds::mosaic_counts;
/// The Shape Mode commands' warning when a selected open path encloses no area.
pub use pathops::SHAPE_MODE_OPEN_PATH_NO_AREA;
+110 -41
View File
@@ -1,5 +1,6 @@
//! Smooth Bridge: two selected circles joined into one outline by two concave arcs that touch both
//! circles, replacing the circles or added above them.
//! circles, or three or more each joined the same way to the others within reach and united where
//! the bridges connect, replacing the circles or added above them.
use serde_json::{Value, json};
use vectorcraft_doc::{NodeId, NodeKind};
@@ -20,6 +21,12 @@ const LABEL: &str = "Smooth Bridge";
/// The arcs' radius as a percentage of the smaller circle's radius: by default, and the range.
const RADIUS: f64 = 100.0;
const RADII: (f64, f64) = (1.0, 1000.0);
/// The gap (pt) added to the smaller circle's radius to give the arcs' radius: the range.
const GAPS: (f64, f64) = (0.0, 1000.0);
/// How far apart (pt) the outlines of two of three or more circles may be for a bridge between
/// them: by default, and the range.
const REACH: f64 = 10.0;
const REACHES: (f64, f64) = (0.0, 10000.0);
pub(super) fn specs() -> Vec<CommandSpec> {
vec![cmd!(
@@ -27,16 +34,33 @@ pub(super) fn specs() -> Vec<CommandSpec> {
"Smooth Bridge",
["Object", "Plug-ins", "Path Precision Tools"],
None,
"{radius?: % 1..1000 (100; the radius of the bridge's two arcs as a percentage of the smaller circle's radius: larger makes a wider, gentler bridge), keepOriginals?: bool (false: the outline replaces the two circles, painted as the upper one; true: it goes directly above the upper one and the circles stay), ids?: [id, id] (default: the selection)} join two circles (paths whose outline is a circle, not hidden or locked) into one closed outline: around each circle on its side away from the other, and along two concave arcs, one on each side, that touch both circles so the outline runs on smoothly into them. Overlapping and touching circles are joined too; one circle inside the other, or circles too far apart for the radius (the arcs would not reach both, or would cross), is an error, which suggests a larger radius when one up to 1000% would bridge them. One undo step; the outline is selected → {id}",
"{radius?: % 1..1000 (100; the radius of each bridge's two arcs as a percentage of the smaller circle's radius: larger makes a wider, gentler bridge), gap?: pt 0..1000 (instead of radius: the arcs' radius is the smaller circle's radius plus this gap, so each arc stays this gap away from a circle of the smaller circle's size about the arc's center; for equal circles this gap apart that is where a third circle this gap from both sits, as in a triangular grid, so the channels around an empty place in such a grid are one width; giving both is an error), reach?: pt 0..10000 (10; with three or more circles: how far apart two circles' outlines may be for a bridge between them, overlapping ones included; two circles are bridged at any distance), keepOriginals?: bool (false: each outline replaces its circles, painted as the topmost of them; true: it goes directly above that circle and the circles stay), ids?: [id] (default: the selection)} join circles (paths whose outline is a circle, not hidden or locked) into metaball (aka meatball) shapes. Two circles become one closed outline: around each circle on its side away from the other, and along two concave arcs, one on each side, that touch both circles so the outline runs on smoothly into them. With three or more, every two circles within reach are bridged the same way, and the bridges that connect are united into one shape each (holes smaller than 1% of the smallest circle's area are filled); a pair within reach but too far apart for the radius gets no bridge, and so does one whose neck would be thinner than the precision its shape is united at, and a circle bridged to no other is left as it is. Overlapping and touching circles are joined too. One circle inside another (among three or more, any such pair within reach) is an error; so are two circles too far apart for the radius (the arcs would not reach both, or would cross), or three or more with no pair the arcs can join, which suggests a larger radius or gap when the largest one would bridge them; so are no two circles within reach, more than 2000 circles and more than 8000 bridges. One undo step; the outlines (and the circles left as they are) are selected → {ids, alone}, with {id} too for two circles",
has_selection,
bridge
)]
}
fn bridge(s: &mut Session, p: &Value) -> Result<Value> {
let percent = given(p, "radius", Some(RADII), C)?.unwrap_or(RADIUS);
let percent = given(p, "radius", Some(RADII), C)?;
let gap = given(p, "gap", Some(GAPS), C)?;
let reach = given(p, "reach", Some(REACHES), C)?.unwrap_or(REACH);
if percent.is_some() && gap.is_some() {
// As the parameter check words it (`EXCLUSIVE_KEYS`), for a caller that skips that check.
let (key, other) = ("radius", "gap");
return Err(bad(C, format!("give `{key}` or `{other}`, not both")));
}
let arc = match gap {
Some(gap) => pt::ArcRadius::Gap(gap),
None => pt::ArcRadius::Share(percent.unwrap_or(RADIUS) / 100.0),
};
let keep = switch_or(p, "keepOriginals", false, C)?;
let roots = checked_ids_or_selection(s, p, C)?;
let mut roots = checked_ids_or_selection(s, p, C)?;
// An id given twice is one circle.
roots.sort_unstable();
roots.dedup();
if roots.len() > pt::MAX_BRIDGED_CIRCLES {
return Err(bad(C, "select at most 2000 circles to bridge"));
}
let circles: Vec<(NodeId, pt::Circle)> = {
let d = &s.doc()?.doc;
let editable = d.editable();
@@ -48,48 +72,93 @@ fn bridge(s: &mut Session, p: &Value) -> Result<Value> {
})
.collect()
};
let ([(below, a), (above, b)], 2) = (circles.as_slice(), roots.len()) else {
return Err(bad(C, "select two circles to bridge"));
};
let (below, above) = (*below, *above);
let at = |percent: f64| pt::smooth_bridge(*a, *b, a.radius.min(b.radius) * percent / 100.0);
let outline = match at(percent) {
Ok(sp) => PathData::single(sp),
Err(pt::BridgeError::Inside) => return Err(bad(C, "one circle is inside the other")),
// A larger radius bridges circles a smaller one cannot, so only suggest one that is allowed.
Err(pt::BridgeError::TooFar) if at(RADII.1).is_ok() => {
return Err(bad(C, "the circles are too far apart for this radius: raise the radius"));
if circles.len() != roots.len() || circles.len() < 2 {
return Err(bad(C, "select two or more circles to bridge"));
}
let only: Vec<pt::Circle> = circles.iter().map(|(_, c)| *c).collect();
// Each shape: the circles it joins, in paint order, and its outline.
let (shapes, alone): (Vec<(Vec<NodeId>, PathData)>, Vec<NodeId>) = match only.as_slice() {
[a, b] => match pt::smooth_bridge(*a, *b, arc.between(*a, *b)) {
Ok(sp) => (vec![(roots_of(&circles, &[0, 1]), PathData::single(sp))], vec![]),
Err(e) => return Err(refusal(e, arc, |largest| pt::smooth_bridge(*a, *b, largest.between(*a, *b)).is_ok())),
},
_ => {
let made = pt::bridge_many(&only, arc, reach).map_err(|e| match e {
pt::ManyError::TooManyCircles => bad(C, "select at most 2000 circles to bridge"),
pt::ManyError::TooManyBridges => bad(C, "that makes too many bridges (at most 8000): lower the reach"),
pt::ManyError::NoneInReach => bad(C, "no two circles are within reach: raise the reach"),
pt::ManyError::TooComplex => bad(C, "the bridged circles are too complex to unite"),
// Under the many-circle rules: a pair the largest radius or gap bridges on its own
// can still have a neck too thin to unite among the others.
pt::ManyError::Pair(_, _, e) => refusal(e, arc, |largest| pt::bridges_any(&only, largest, reach)),
pt::ManyError::Bad => bad(C, "select two or more circles to bridge"),
})?;
let shapes = made.joined.into_iter().map(|j| (roots_of(&circles, &j.members), j.outline)).collect();
(shapes, roots_of(&circles, &made.alone))
}
Err(pt::BridgeError::TooFar) => return Err(bad(C, "the circles are too far apart for this radius")),
Err(pt::BridgeError::Bad) => return Err(bad(C, "select two circles to bridge")),
};
let id = s.edit(LABEL, |d, sel| {
let id = if keep {
// A copy of the upper circle (its appearance) with the outline as its path, right above
// it; the circles stay as they are, live shapes included.
// Fresh ids throughout, its opacity mask's art included.
let upper = d.node(above).cloned().ok_or(EngineError::NoNode(above))?;
let mut n = d.reid(&upper);
if let NodeKind::Path { path, live, .. } = &mut n.kind {
*path = outline;
*live = None;
let made = s.edit(LABEL, |d, sel| {
let mut made = Vec::with_capacity(shapes.len());
if keep {
// A copy of each shape's topmost circle (its appearance) with the outline as its path,
// right above it; the circles stay as they are, live shapes included. Fresh ids
// throughout, an opacity mask's art included.
let tops: Vec<NodeId> = shapes.iter().filter_map(|(members, _)| members.last().copied()).collect();
let mut beside = Beside::above(d, &tops);
for ((_, outline), top) in shapes.into_iter().zip(tops) {
let upper = d.node(top).cloned().ok_or(EngineError::NoNode(top))?;
let mut n = d.reid(&upper);
if let NodeKind::Path { path, live, .. } = &mut n.kind {
*path = outline;
*live = None;
}
made.push(n.id);
beside.put(d, top, vec![n])?;
}
let id = n.id;
let mut beside = Beside::above(d, &[above]);
beside.put(d, above, vec![n])?;
beside.finish(d)?;
id
} else {
// The upper circle becomes the outline (a plain path now) and the lower one goes.
if let Some(NodeKind::Path { path, live, .. }) = d.node_mut(above).map(|n| &mut n.kind) {
*path = outline;
*live = None;
// Each shape's topmost circle becomes its outline (a plain path now) and the others go.
let mut gone = vec![];
for (members, outline) in shapes {
let Some((&top, rest)) = members.split_last() else { continue };
if let Some(NodeKind::Path { path, live, .. }) = d.node_mut(top).map(|n| &mut n.kind) {
*path = outline;
*live = None;
}
made.push(top);
gone.extend_from_slice(rest);
}
remove_each(d, &[below])?;
above
};
sel.set([id]);
Ok(id)
remove_each(d, &gone)?;
}
sel.set(made.iter().chain(&alone).copied());
Ok(made)
})?;
Ok(json!({ "id": id.0 }))
let mut out = json!({ "ids": made.iter().map(|id| id.0).collect::<Vec<_>>(), "alone": alone.iter().map(|id| id.0).collect::<Vec<_>>() });
if let ([id], 2) = (made.as_slice(), only.len()) {
out["id"] = json!(id.0);
}
Ok(out)
}
/// The ids of `circles` at indices `at`, in paint order (the circles are listed in paint order).
fn roots_of(circles: &[(NodeId, pt::Circle)], at: &[usize]) -> Vec<NodeId> {
at.iter().filter_map(|&i| circles.get(i)).map(|(id, _)| *id).collect()
}
/// The error for circles that arcs of `arc` can't bridge. A larger radius or gap bridges circles a
/// smaller one cannot, so it suggests one only when `bridges` says the largest allowed would.
fn refusal(e: pt::BridgeError, arc: pt::ArcRadius, bridges: impl FnOnce(pt::ArcRadius) -> bool) -> EngineError {
let largest = match arc {
pt::ArcRadius::Share(_) => pt::ArcRadius::Share(RADII.1 / 100.0),
pt::ArcRadius::Gap(_) => pt::ArcRadius::Gap(GAPS.1),
};
let would = e == pt::BridgeError::TooFar && bridges(largest);
match (e, arc, would) {
(pt::BridgeError::Inside, ..) => bad(C, "one circle is inside the other"),
(pt::BridgeError::TooFar, pt::ArcRadius::Share(_), true) => bad(C, "the circles are too far apart for this radius: raise the radius"),
(pt::BridgeError::TooFar, pt::ArcRadius::Share(_), false) => bad(C, "the circles are too far apart for this radius"),
(pt::BridgeError::TooFar, pt::ArcRadius::Gap(_), true) => bad(C, "the circles are too far apart for this gap: raise the gap"),
(pt::BridgeError::TooFar, pt::ArcRadius::Gap(_), false) => bad(C, "the circles are too far apart for this gap"),
(pt::BridgeError::Bad, ..) => bad(C, "select two or more circles to bridge"),
}
}
@@ -1,5 +1,5 @@
//! Smooth Bridge: the outline in place of the circles or above them, one undo step, the radius,
//! and what it refuses.
//! Smooth Bridge: the outline in place of the circles or above them, one undo step, the radius or
//! gap, many circles joined to their neighbors within reach, and what it refuses.
use serde_json::{Value, json};
use vectorcraft_doc::{NodeId, NodeKind};
@@ -46,6 +46,8 @@ fn two_circles_become_one_outline_in_the_upper_ones_place() {
let steps = s.doc().unwrap().history.undo.len();
let r = s.execute(BRIDGE, &json!({})).unwrap();
assert_eq!(r["id"], json!(b.0));
assert_eq!(r["ids"], json!([b.0]), "the same result fields as for more circles");
assert_eq!(r["alone"], json!([]));
assert_eq!(top_level(&s), [b]);
let d = &s.doc().unwrap().doc;
let NodeKind::Path { path, live, .. } = &d.node(b).unwrap().kind else { panic!("a path") };
@@ -158,9 +160,11 @@ fn far_apart_nested_and_other_objects_are_refused() {
assert!(e.ends_with("the circles are too far apart for this radius"), "{e}");
}
assert!(err(&mut s, json!({"ids": [a.0, inner.0]})).contains("one circle is inside the other"));
for ids in [json!([a.0, square.0]), json!([a.0, oval.0]), json!([a.0]), json!([a.0, far.0, inner.0])] {
assert!(err(&mut s, json!({ "ids": ids })).contains("select two circles to bridge"), "{ids}");
for ids in [json!([a.0, square.0]), json!([a.0, oval.0]), json!([a.0]), json!([a.0, far.0, square.0])] {
assert!(err(&mut s, json!({ "ids": ids })).contains("select two or more circles to bridge"), "{ids}");
}
// Three circles: each two within reach are bridged, and one inside another is refused there too.
assert!(err(&mut s, json!({"ids": [a.0, far.0, inner.0]})).contains("one circle is inside the other"));
assert!(err(&mut s, json!({"ids": [a.0, far.0], "radius": 0.5})).contains("`radius` must be from 1 to 1000"));
assert!(err(&mut s, json!({"ids": [a.0, far.0], "radius": 1001})).contains("`radius`"));
assert!(err(&mut s, json!({"ids": [a.0, far.0], "radius": "big"})).contains("`radius` must be a number"));
@@ -169,6 +173,174 @@ fn far_apart_nested_and_other_objects_are_refused() {
assert_eq!(s.doc().unwrap().history.undo.len(), steps, "nothing changed, no undo step");
}
/// A 3 × 3 grid of circles of radius 10, 4 apart (centers 24 apart), in rows from (100, 100).
fn grid(s: &mut Session) -> Vec<NodeId> {
(0..9).map(|k| circle(s, 100.0 + 24.0 * (k % 3) as f64, 100.0 + 24.0 * (k / 3) as f64, 10.0)).collect()
}
fn ids(v: &Value) -> Vec<NodeId> {
v.as_array().unwrap().iter().map(|i| NodeId(i.as_u64().unwrap())).collect()
}
fn path(s: &Session, id: NodeId) -> vectorcraft_geom::PathData {
s.doc().unwrap().doc.node(id).unwrap().path_data().unwrap().clone()
}
#[test]
fn a_grid_of_circles_joins_each_to_its_neighbors_in_one_shape() {
let mut s = session();
let g = grid(&mut s);
select(&mut s, &g);
let steps = s.doc().unwrap().history.undo.len();
// Reach 5: the side neighbors (4 apart) are bridged, the diagonal ones (about 13.9 apart) not.
let r = s.execute(BRIDGE, &json!({"gap": 4, "reach": 5})).unwrap();
assert_eq!(ids(&r["ids"]), [g[8]], "one shape, in the topmost circle's place");
assert_eq!(ids(&r["alone"]), []);
assert_eq!(top_level(&s), [g[8]]);
assert_eq!(s.doc().unwrap().selection.objects.to_vec(), [g[8]]);
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "one undo step");
// Its outline and a hole in each square of four circles, which no diagonal bridge fills.
let outline = path(&s, g[8]);
assert_eq!(outline.subpaths.len(), 5, "{}", outline.subpaths.len());
let inside = |p: &vectorcraft_geom::PathData, x: f64, y: f64| p.to_bezpath().winding(vectorcraft_geom::kurbo::Point::new(x, y)) != 0;
assert!(inside(&outline, 112.0, 100.0) && inside(&outline, 100.0, 112.0) && !inside(&outline, 112.0, 112.0));
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(top_level(&s), g);
// Reach 15 takes in the diagonal neighbors, whose bridges fill the middle of each square.
select(&mut s, &g);
s.execute(BRIDGE, &json!({"gap": 4, "reach": 15})).unwrap();
let outline = path(&s, g[8]);
assert_eq!(outline.subpaths.len(), 1);
assert!(inside(&outline, 112.0, 112.0));
}
#[test]
fn a_circle_with_no_neighbor_in_reach_stays_as_it_is() {
let mut s = session();
let g = grid(&mut s);
let far = circle(&mut s, 300.0, 250.0, 10.0);
let pair = [circle(&mut s, 300.0, 40.0, 8.0), circle(&mut s, 320.0, 40.0, 8.0)];
let mut all = g.clone();
all.extend([far, pair[0], pair[1]]);
let r = s.execute(BRIDGE, &json!({"ids": all.iter().map(|i| i.0).collect::<Vec<_>>(), "reach": 5})).unwrap();
assert_eq!(ids(&r["ids"]), [g[8], pair[1]]);
assert_eq!(ids(&r["alone"]), [far]);
assert_eq!(top_level(&s), [g[8], far, pair[1]]);
assert!(matches!(&s.doc().unwrap().doc.node(far).unwrap().kind, NodeKind::Path { live: Some(_), .. }), "untouched");
let mut selected = s.doc().unwrap().selection.objects.to_vec();
selected.sort();
let mut want = vec![g[8], pair[1], far];
want.sort();
assert_eq!(selected, want, "the shapes and the circle left alone");
}
#[test]
fn keep_originals_adds_each_shape_above_its_topmost_circle() {
let mut s = session();
let row: Vec<NodeId> = (0..3).map(|i| circle(&mut s, 100.0 + 25.0 * i as f64, 100.0, 10.0)).collect();
let other = [circle(&mut s, 100.0, 200.0, 10.0), circle(&mut s, 122.0, 200.0, 10.0)];
s.execute("paint.setFill", &json!({"ids": [row[2].0], "color": "#00ff00"})).unwrap();
let all: Vec<u64> = row.iter().chain(&other).map(|i| i.0).collect();
let r = s.execute(BRIDGE, &json!({"ids": all, "keepOriginals": true})).unwrap();
let made = ids(&r["ids"]);
assert_eq!(made.len(), 2);
assert_eq!(top_level(&s), [row[0], row[1], row[2], made[0], other[0], other[1], made[1]]);
let d = &s.doc().unwrap().doc;
assert_eq!(d.node(made[0]).unwrap().appearance, d.node(row[2]).unwrap().appearance, "painted as the topmost circle");
let b = d.node(made[0]).unwrap().path_data().unwrap().bounds().unwrap();
assert!((b.x0 - 90.0).abs() < 1e-2 && (b.x1 - 160.0).abs() < 1e-2, "{b:?}");
}
#[test]
fn the_gap_form_gives_arcs_the_smaller_radius_plus_the_gap() {
let area_with = |p: Value| {
let mut s = session();
let a = circle(&mut s, 100.0, 100.0, 10.0);
let b = circle(&mut s, 124.0, 100.0, 10.0);
let mut p = p;
p["ids"] = json!([a.0, b.0]);
let id = NodeId(s.execute(BRIDGE, &p).unwrap()["id"].as_u64().unwrap());
area(&s, id)
};
// Radius 10 plus a gap of 4 is 140% of 10.
let (gap, percent) = (area_with(json!({"gap": 4})), area_with(json!({"radius": 140})));
assert!((gap - percent).abs() < 1e-9, "{gap} {percent}");
assert!(area_with(json!({"gap": 0})) < gap && gap < area_with(json!({"gap": 20})));
}
#[test]
fn many_circle_and_gap_refusals() {
let mut s = session();
let a = circle(&mut s, 50.0, 100.0, 10.0);
let b = circle(&mut s, 250.0, 100.0, 10.0);
let c = circle(&mut s, 330.0, 100.0, 10.0);
let far = circle(&mut s, 380.0, 100.0, 10.0);
let before = top_level(&s);
let steps = s.doc().unwrap().history.undo.len();
assert!(err(&mut s, json!({"ids": [a.0, b.0], "radius": 100, "gap": 4})).contains("give `radius` or `gap`, not both"));
// Centers 200 apart: a gap of 0 does not bridge them, the largest (1000 pt) does. With centers
// 330 apart even that one closes the neck: it stays open only below 2 × √(10² + 2 × 10 × 1010)
// ≈ 285.
assert!(err(&mut s, json!({"ids": [a.0, b.0], "gap": 0})).ends_with("too far apart for this gap: raise the gap"));
assert!(err(&mut s, json!({"ids": [a.0, far.0], "gap": 0})).ends_with("the circles are too far apart for this gap"));
assert!(err(&mut s, json!({"ids": [a.0, b.0, c.0], "reach": 5})).contains("no two circles are within reach: raise the reach"));
// b and c are 60 apart: within a reach of 100, but too far for the default radius.
assert!(err(&mut s, json!({"ids": [a.0, b.0, c.0], "reach": 100})).ends_with("too far apart for this radius: raise the radius"));
assert!(err(&mut s, json!({"ids": [a.0, b.0, c.0], "reach": -1})).contains("`reach` must be from 0 to 10000"));
assert!(err(&mut s, json!({"ids": [a.0, b.0], "gap": 1001})).contains("`gap` must be from 0 to 1000"));
assert_eq!(top_level(&s), before);
assert_eq!(s.doc().unwrap().history.undo.len(), steps, "nothing changed, no undo step");
}
#[test]
fn a_larger_radius_is_suggested_only_when_it_bridges_among_the_other_circles() {
let mut s = session();
// Centers 91.65 apart: the largest radius (1000%, 100 pt) bridges these two on their own, but
// with a neck about 0.0007 pt wide, too thin to unite among three or more circles.
let a = circle(&mut s, 20.0, 100.0, 10.0);
let b = circle(&mut s, 111.65, 100.0, 10.0);
let far = circle(&mut s, 380.0, 100.0, 10.0);
assert!(s.execute(BRIDGE, &json!({"ids": [a.0, b.0], "radius": 1000})).is_ok());
s.execute("edit.undo", &json!({})).unwrap();
assert!(err(&mut s, json!({"ids": [a.0, b.0]})).ends_with("too far apart for this radius: raise the radius"));
for radius in [100, 1000] {
let e = err(&mut s, json!({"ids": [a.0, b.0, far.0], "radius": radius, "reach": 100}));
assert!(e.ends_with("the circles are too far apart for this radius"), "{e}");
}
}
#[test]
fn too_many_circles_or_bridges_are_refused() {
let mut s = session();
// 130 overlapping circles in a row: 8,385 pairs within reach.
let row: Vec<u64> = (0..130).map(|i| circle(&mut s, 20.0 + i as f64 * 0.2, 100.0, 10.0).0).collect();
assert!(err(&mut s, json!({ "ids": row })).contains("that makes too many bridges (at most 8000): lower the reach"));
let many: Vec<u64> = (0..2001).map(|i| circle(&mut s, 20.0 + (i % 50) as f64 * 7.0, 150.0 + (i / 50) as f64 * 3.0, 1.0).0).collect();
assert!(err(&mut s, json!({ "ids": many })).contains("select at most 2000 circles to bridge"));
}
#[test]
fn an_id_given_twice_is_one_circle() {
let mut s = session();
let a = circle(&mut s, 100.0, 100.0, 20.0);
let b = circle(&mut s, 150.0, 100.0, 20.0);
let r = s.execute(BRIDGE, &json!({"ids": [a.0, a.0, b.0]})).unwrap();
assert_eq!(r["id"], json!(b.0), "two circles, bridged");
assert_eq!(top_level(&s), [b]);
}
#[test]
fn small_circles_at_the_default_reach_bridge_the_pairs_the_arcs_can_join() {
let mut s = session();
// Radius 3: arcs of 3 pt (100%) join a and b (2 apart) but close before reaching c (6 from b,
// within the default reach of 10).
let (a, b, c) = (circle(&mut s, 100.0, 100.0, 3.0), circle(&mut s, 108.0, 100.0, 3.0), circle(&mut s, 120.0, 100.0, 3.0));
let r = s.execute(BRIDGE, &json!({"ids": [a.0, b.0, c.0]})).unwrap();
assert_eq!(ids(&r["ids"]), [b]);
assert_eq!(ids(&r["alone"]), [c]);
assert_eq!(top_level(&s), [b, c]);
}
#[test]
fn locked_and_hidden_circles_are_not_bridged() {
let mut s = session();
@@ -176,9 +348,9 @@ fn locked_and_hidden_circles_are_not_bridged() {
let b = circle(&mut s, 150.0, 100.0, 20.0);
select(&mut s, &[b]);
s.execute("object.lock", &json!({})).unwrap();
assert!(err(&mut s, json!({"ids": [a.0, b.0]})).contains("select two circles to bridge"));
assert!(err(&mut s, json!({"ids": [a.0, b.0]})).contains("select two or more circles to bridge"));
s.execute("object.unlockAll", &json!({})).unwrap();
select(&mut s, &[a]);
s.execute("object.hide", &json!({})).unwrap();
assert!(err(&mut s, json!({"ids": [a.0, b.0]})).contains("select two circles to bridge"));
assert!(err(&mut s, json!({"ids": [a.0, b.0]})).contains("select two or more circles to bridge"));
}
+6 -6
View File
@@ -10,7 +10,7 @@
mod tests;
use serde_json::{Value, json};
use vectorcraft_doc::{OrientedBox, Unit, decimal_point, finite_in_every_unit};
use vectorcraft_doc::{OrientedBox, Unit, arithmetic_signs, decimal_point, finite_in_every_unit};
use vectorcraft_render::effects;
use super::super::{CommandSpec, always, bad, cmd, has_selection};
@@ -22,8 +22,8 @@ const SELECTION_SIZE: &str = "addon.units.selectionSize";
const SHOWN_CHARS: usize = 64;
/// The longest `value` or `unit` text `addon.units.convert` reads, in bytes.
const MAX_TEXT_LEN: usize = 1024;
/// The most `+ - * /` signs `addon.units.convert` reads in one `value`: [`Unit::parse`] takes one
/// level of recursion per sign.
/// The most `+ - * /` signs `addon.units.convert` reads in one `value`, a multiplication sign
/// counted as a `*`: [`Unit::parse`] takes one level of recursion per sign.
const MAX_OPERATORS: usize = 128;
pub fn specs() -> Vec<CommandSpec> {
@@ -33,7 +33,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Convert Units",
[],
None,
"{value: a length (a number, or text as a number field reads it, with a unit suffix and + - * / arithmetic: \"10mm\", \"1in/2\", \"2p6\", \"3cm*50%\"; a decimal comma reads as a point: \"0,5 mm\"; at most 1024 bytes and 128 operators), unit?: the unit of a number without a suffix (a unit's name, suffix or key: points, picas, inches, millimeters, centimeters, pixels, feetInches, meters, yards, feet, q, ha; default: points)} the length in every unit of Preferences › Units › East Asian Type, written as the number fields write it (rounded to 3 decimals in pt, px, picas, Q and Ha and to 4 in the others; pixels are points). Nothing in the document changes → {points, units: [{unit (its key), label, number (no suffix), text (with the suffix)}]}",
"{value: a length (a number, or text as a number field reads it, with a unit suffix and + - * / arithmetic, x, X or × multiplying as * does: \"10mm\", \"1in/2\", \"2p6\", \"3cm*50%\", \"2x3 mm\"; a decimal comma reads as a point: \"0,5 mm\"; at most 1024 bytes and 128 operators, each multiplication sign counted), unit?: the unit of a number without a suffix (a unit's name, suffix or key: points, picas, inches, millimeters, centimeters, pixels, feetInches, meters, yards, feet, q, ha; default: points)} the length in every unit of Preferences › Units › East Asian Type, written as the number fields write it (rounded to 3 decimals in pt, px, picas, Q and Ha and to 4 in the others; pixels are points). Nothing in the document changes → {points, units: [{unit (its key), label, number (no suffix), text (with the suffix)}]}",
always,
convert
),
@@ -88,9 +88,9 @@ fn convert(_: &mut Session, p: &Value) -> Result<Value> {
}
/// Is `s` short enough to read: at most [`MAX_TEXT_LEN`] bytes and [`MAX_OPERATORS`] `+ - * /`
/// signs?
/// signs, a multiplication sign typed as `x`, `X` or `×` counted as a `*` ([`arithmetic_signs`])?
fn readable(s: &str) -> bool {
s.len() <= MAX_TEXT_LEN && s.chars().filter(|c| matches!(c, '+' | '-' | '*' | '/')).count() <= MAX_OPERATORS
s.len() <= MAX_TEXT_LEN && arithmetic_signs(s) <= MAX_OPERATORS
}
/// `v` as an error message shows it: text cut at [`SHOWN_CHARS`] characters with "…", as JSON,
@@ -76,6 +76,12 @@ fn values_read_as_number_fields_read_them() {
assert!(near(pt(&mut s, json!({"value": "1,500+2", "unit": "mm"})), 3.5 * 72.0 / 25.4));
// A sum of 128 signs still reads.
assert!(near(pt(&mut s, json!({"value": format!("1{}", "+1".repeat(128))})), 129.0));
// x, X and × multiply as * does, and each counts toward the 128 signs.
assert!(near(pt(&mut s, json!({"value": "2x3 mm"})), 6.0 * 72.0 / 25.4));
assert!(near(pt(&mut s, json!({"value": "10X2"})), 20.0));
assert!(near(pt(&mut s, json!({"value": "0,5×4 in"})), 144.0));
assert!(near(pt(&mut s, json!({"value": format!("1{}", "x1".repeat(128))})), 1.0));
assert!(s.execute("addon.units.convert", &json!({"value": format!("1{}", "x1".repeat(129))})).is_err());
}
#[test]
+4 -3
View File
@@ -12,8 +12,9 @@ use super::overprint::{AttributesInfo, apply_overprint, edit_counted, overprint_
use super::path::paths_in;
use super::{CommandSpec, NodeId, Result, Session, bad, cmd, has_doc, str_param, targets};
/// How many URLs the Attributes panel's recent list keeps.
const RECENT_URLS: usize = 10;
/// How many URLs the Attributes panel's recent list keeps: the most its Panel Options lets the
/// URL menu list.
pub const RECENT_URLS: usize = 30;
pub fn specs() -> Vec<CommandSpec> {
vec![
@@ -22,7 +23,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Attributes",
[],
None,
"{overprintFill?: bool, overprintStroke?: bool (aimed as object.setOverprint's fill and stroke, item? too), showCenter?: bool (the canvas shows the selected object's centre point), imageMap?: \"none\"|\"rectangle\"|\"polygon\", url?: string (\"\" removes it; SVG, PDF and .ai export link the object), note?: string, ids?|id?, item?: appearance item index|null, target?: \"object\"|\"contents\"} set the Attributes panel's values on ids or the selection, as one undo step; a URL given joins the recent URLs (attributes.info) → {changed: objects}",
"{overprintFill?: bool, overprintStroke?: bool (aimed as object.setOverprint's fill and stroke, item? too), showCenter?: bool (the canvas shows the selected object's centre point), imageMap?: \"none\"|\"rectangle\"|\"polygon\", url?: string (\"\" removes it; SVG, PDF and .ai export link the object), note?: string, ids?|id?, item?: appearance item index|null, target?: \"object\"|\"contents\"} set the Attributes panel's values on ids or the selection, as one undo step; a URL given joins the recent URLs (attributes.info, newest first, at most 30) → {changed: objects}",
has_doc,
set
),
+51 -1
View File
@@ -12,7 +12,8 @@ use std::sync::{Arc, LazyLock};
use serde_json::{Value, json};
use vectorcraft_brush::{
self as brush, ArtBrush, Bristle, BristleShape, Brush, BrushKind, Calligraphic, Colorization, PatternBrush, PatternFit, Scatter, Variation,
self as brush, ArtBrush, ArtScale, Bristle, BristleShape, Brush, BrushKind, Calligraphic, Colorization, PatternBrush, PatternFit, Scatter,
Variation,
};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, Document, FillLayer, Node, NodeId, NodeKind, PatternDef, Symbol};
@@ -180,6 +181,7 @@ pub const BUILTIN: &[BuiltinBrushLibrary] = &[
BuiltinBrushLibrary { id: "energy-beams", name: "Energy Beams", make: energy_beams },
BuiltinBrushLibrary { id: "dry-media", name: "Dry Media", make: dry_media },
BuiltinBrushLibrary { id: "tech-circuit", name: "Tech Circuit", make: tech_circuit },
BuiltinBrushLibrary { id: "arrows", name: "Arrows", make: arrows },
];
/// Built-in library `id`, made once.
@@ -233,6 +235,54 @@ fn art(name: &str, art: Node, colorization: Colorization) -> Brush {
Brush { name: name.into(), kind: BrushKind::Art(ArtBrush { art, colorization, ..Default::default() }) }
}
/// An Arrows brush whose art stretches only between `start` and `end` (fractions of its length).
fn arrow_art(name: &str, art: Node, start: f64, end: f64) -> Brush {
Brush {
name: name.into(),
kind: BrushKind::Art(ArtBrush {
art,
scale: ArtScale::BetweenGuides { start, end },
colorization: Colorization::Tints,
..Default::default()
}),
}
}
/// Arrows: original art brushes whose stems stretch while their heads keep their proportions.
fn arrows() -> BrushLibrary {
let shaft = || black(shapes::rectangle(Rect::new(0.0, -1.0, 82.0, 1.0)));
let head = || black(polygon(&[(76.0, -7.0), (100.0, 0.0), (76.0, 7.0), (82.0, 0.0)]));
let solid = group(vec![shaft(), head()]);
let outline = group(vec![shaft(), black(polygon(&[(76.0, -7.0), (100.0, 0.0), (76.0, 7.0), (78.0, 4.0), (91.0, 0.0), (78.0, -4.0)]))]);
let double = group(vec![
black(shapes::rectangle(Rect::new(18.0, -1.0, 82.0, 1.0))),
head(),
black(polygon(&[(24.0, -7.0), (0.0, 0.0), (24.0, 7.0), (18.0, 0.0)])),
]);
let chevrons = group(vec![shaft(), head(), black(polygon(&[(53.0, -5.0), (66.0, 0.0), (53.0, 5.0), (56.0, 0.0)]))]);
let dashed = group(
(0..5)
.map(|i| {
let x = f64::from(i) * 16.0;
black(shapes::rectangle(Rect::new(x, -1.0, x + 10.0, 1.0)))
})
.chain(std::iter::once(head()))
.collect(),
);
built(
"Arrows",
Document::new(100.0, 100.0),
vec![
arrow_art("Solid Arrow", solid, 0.0, 0.76),
arrow_art("Open Arrow", outline, 0.0, 0.76),
arrow_art("Double Arrow", double, 0.24, 0.76),
// The second chevron starts at 53 pt, so only the shaft before it stretches.
arrow_art("Chevron Arrow", chevrons, 0.0, 0.53),
arrow_art("Dashed Arrow", dashed, 0.0, 0.76),
],
)
}
/// Art Ribbons: art brushes, 100 pt long, drawn here; Striped Ribbon is filled with the library's
/// own pattern, Pinstripes.
fn art_ribbons() -> BrushLibrary {
+1 -1
View File
@@ -38,7 +38,7 @@ mod shape_builder;
mod trace;
pub use live_paint::live_paint_gaps;
pub(crate) use live_paint::{isolated_live_paint, merge_drawn_in_isolation};
pub(crate) use live_paint::{LivePaintMove, check_part_name, clear_part_name, isolated_live_paints, merge_drawn_in_isolation};
use live_paint::{lp_expand, lp_fill, lp_gap_options, lp_info, lp_make, lp_merge, lp_release, lp_stroke_edge};
use shape_builder::{sb_merge, sb_regions};
pub(crate) use trace::TracePresetChanges;
+241 -12
View File
@@ -1,8 +1,8 @@
use super::{
Appearance, AppearanceItem, Arc, Beside, Document, EDGE_NAME, EngineError, FACE_NAME, GapOptions, GapSize, LIVE_PAINT_NAME, Node, NodeId,
PathData, Point, Rect, Result, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite, fit_to_old_edge, ids_json,
is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids, source_nodes, source_shapes,
switch_or,
PathData, Point, Rect, Result, SOURCES_NAME, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite,
fit_to_old_edge, ids_json, is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids,
source_nodes, source_shapes, switch_or,
};
/// `options` as stored on a Live Paint group: none for the defaults.
@@ -74,6 +74,44 @@ fn set_parts(g: &mut Node, mut parts: Vec<Arc<Node>>, gone: &[NodeId]) {
}
}
/// Whether a path named `name` directly in a Live Paint group is one of its faces or edges: the
/// name is [`FACE_NAME`] or [`EDGE_NAME`].
fn part_name(name: Option<&str>) -> bool {
matches!(name, Some(FACE_NAME | EDGE_NAME))
}
/// Whether `n` is a path whose parent `parent` is a Live Paint group.
fn path_in_live_paint(d: &Document, parent: Option<NodeId>, n: &Node) -> bool {
n.path_data().is_some() && parent.and_then(|p| d.node(p)).is_some_and(is_live_paint)
}
/// Clear the name of `n`, put directly in `parent`, when it is a path named like a face or an edge
/// ([`part_name`]) and `parent` is a Live Paint group, so that the group's other children
/// ([`others_in`]) keep it when its faces and edges are made again. Paste uses it.
pub(crate) fn clear_part_name(d: &Document, parent: Option<NodeId>, n: &mut Node) {
if part_name(n.name.as_deref()) && path_in_live_paint(d, parent, n) {
n.name = None;
}
}
/// Refuse naming rows `ids` `name` when it is the name of a face or an edge ([`part_name`]) and one
/// of them is a path directly in a Live Paint group that is not named `name` already. Checked
/// before anything changes.
pub(crate) fn check_part_name(d: &Document, ids: &[NodeId], name: &str) -> Result<()> {
if !part_name(Some(name)) {
return Ok(());
}
for id in ids {
if let Some(n) = d.node(*id)
&& n.name.as_deref() != Some(name)
&& path_in_live_paint(d, d.parent_of(*id), n)
{
return Err(EngineError::Other("`Face` and `Edge` name the faces and edges of a Live Paint group: give the path another name".into()));
}
}
Ok(())
}
/// Select `ids` alone, without an undo step, when they are not selected that way already.
fn select_only(s: &mut Session, ids: &[NodeId]) -> Result<()> {
let st = s.doc()?;
@@ -149,11 +187,16 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
.ok_or_else(|| EngineError::Other("Live Paint Merge: select a Live Paint group and the paths to add".into()))?;
check_live_paint_takes(d, roots)?;
let old = d.node(target).cloned().ok_or(EngineError::NoNode(target))?;
// The rows that join are children of the group already when Merge runs after a drag, and a joining
// path named like a face or an edge is not one of the group's parts.
let mut old_parts = old.clone();
if let Some(ch) = old_parts.children_mut() {
ch.retain(|c| !roots.contains(&c.id));
}
// Paint to carry over: (point inside face, paint) for faces that draw; edges are matched to the
// old edges below.
let keep_faces: Vec<(Point, Carried)> =
b::faces(&old).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
let old_parts = old.clone();
b::faces(&old_parts).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
let mut sources = source_nodes(&old);
// The objects drawn in the other Live Paint groups besides their parts stay in the merged group.
let mut others = vec![];
@@ -227,19 +270,22 @@ pub(super) fn lp_merge(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
}
/// The Live Paint group whose drawn art is added when isolation mode leaves `isolated`: the innermost
/// Live Paint group that is `isolated` or holds it, such as a group drawn in an isolated Live Paint
/// group and then isolated itself. None when `isolated` is not in a Live Paint group.
pub(crate) fn isolated_live_paint(d: &Document, isolated: NodeId) -> Option<NodeId> {
d.ancestry(isolated)?.into_iter().rev().find(|id| d.node(*id).is_some_and(is_live_paint))
/// The Live Paint groups whose drawn art can be added when isolation mode leaves `isolated`, innermost
/// first: every Live Paint group that is `isolated` or holds it, such as a group drawn in an isolated
/// Live Paint group and then isolated itself, and the group it was drawn in. Empty when `isolated` is
/// not in a Live Paint group.
pub(crate) fn isolated_live_paints(d: &Document, isolated: NodeId) -> Vec<NodeId> {
d.ancestry(isolated).unwrap_or_default().into_iter().rev().filter(|id| d.node(*id).is_some_and(is_live_paint)).collect()
}
/// The children of Live Paint group `g` besides its parts ([`others_in`]) that Live Paint takes
/// ([`b::live_paint_takes`]) and that are shown and unlocked with everything in them, back to
/// front: the paths drawn in it in isolation mode.
/// front: the paths drawn in it in isolation mode. A Live Paint group's sources group, which is
/// always hidden, does not count.
fn drawn_in(g: &Node) -> Vec<NodeId> {
fn open(n: &Node) -> bool {
n.visible && !n.locked && n.children().is_none_or(|ch| ch.iter().all(|c| open(c)))
let src = b::sources(n).filter(|_| is_live_paint(n)).map(|s| s.id);
n.visible && !n.locked && n.children().is_none_or(|ch| ch.iter().filter(|c| Some(c.id) != src).all(|c| open(c)))
}
others_in(g).filter(|c| open(c) && b::live_paint_takes(c)).map(|c| c.id).collect()
}
@@ -259,6 +305,189 @@ pub(crate) fn merge_drawn_in_isolation(s: &mut Session, g: NodeId) -> Result<boo
Ok(true)
}
/// Where a row sits for Live Paint: among the paths of a Live Paint group (in its sources group,
/// at any depth), directly in a Live Paint group, or neither.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Spot {
Source(NodeId),
In(NodeId),
Outside,
}
/// The [`Spot`] of a row whose parent is `parent` (None: the top level).
fn spot_in(d: &Document, parent: Option<NodeId>) -> Spot {
let Some(p) = parent else { return Spot::Outside };
for x in d.ancestry(p).unwrap_or_default().into_iter().rev() {
let n = d.node(x);
if n.is_some_and(is_live_paint) {
return if x == p { Spot::In(x) } else { Spot::Outside };
}
if let Some(g) = d.parent_of(x)
&& d.node(g).filter(|n| is_live_paint(n)).and_then(b::sources).is_some_and(|s| s.id == x)
{
return Spot::Source(g);
}
}
Spot::Outside
}
/// The Live Paint groups that hold Live Paint group `g` among their paths (in their sources group,
/// at any depth), innermost first.
fn enclosing_live_paints(d: &Document, g: NodeId) -> Vec<NodeId> {
let mut out = vec![];
let mut at = g;
while let Spot::Source(o) = spot_in(d, d.parent_of(at)) {
if out.contains(&o) {
break;
}
out.push(o);
at = o;
}
out
}
/// What moving rows in the Layers panel (`layer.move`, `node.move`) does to Live Paint groups.
/// Rows that go into a Live Paint group from elsewhere are added to it as `livePaint.merge` adds
/// paths. Rows that go into or leave a group's paths (its sources group) change those paths, and
/// the group's faces and edges are made again from them, keeping the paint of the faces and edges
/// that stay, and so are those of every Live Paint group that holds a changed group among its
/// paths. Rows moved within one group's paths, or among a group's own children, change no faces.
pub(crate) struct LivePaintMove {
/// The Live Paint group the rows go into, and for each row whether it joins the group's paths.
join: Option<(NodeId, Vec<bool>)>,
/// The Live Paint group the rows go among the children of, with its sources group as it is
/// before the move.
keep_sources: Option<(NodeId, NodeId)>,
/// The Live Paint groups whose paths change.
rebuild: Vec<NodeId>,
}
impl LivePaintMove {
/// Plan moving `rows` (with `copy`, copies of them) into `parent`, before anything changes.
/// Refuses rows Live Paint can't take ([`b::live_paint_takes`]) that would go among a group's
/// paths, with the message Make and Merge give.
pub(crate) fn plan(d: &Document, rows: &[NodeId], parent: Option<NodeId>, copy: bool) -> Result<Self> {
let to = spot_in(d, parent);
let from: Vec<Spot> = rows.iter().map(|r| if copy { Spot::Outside } else { spot_in(d, d.parent_of(*r)) }).collect();
let mut rebuild = vec![];
for f in &from {
if let Spot::Source(g) = *f
&& *f != to
&& !rebuild.contains(&g)
{
rebuild.push(g);
}
}
if let Spot::Source(g) = to
&& from.iter().any(|f| *f != to)
&& !rebuild.contains(&g)
{
rebuild.push(g);
}
let entering: Vec<NodeId> = rows.iter().zip(&from).filter(|(_, f)| **f != to).map(|(r, _)| *r).collect();
let join = match to {
Spot::In(g) if !entering.is_empty() => Some((g, from.iter().map(|f| *f != to).collect())),
_ => None,
};
if to != Spot::Outside {
check_live_paint_takes(d, &entering)?;
}
let keep_sources = match to {
Spot::In(g) => d.node(g).and_then(b::sources).map(|s| (g, s.id)),
_ => None,
};
Ok(Self { join, keep_sources, rebuild })
}
/// Whether rows join a Live Paint group, which makes the move a "Merge Live Paint" step.
pub(crate) fn joins(&self) -> bool {
self.join.is_some()
}
/// After the rows were moved, now `moved` (in the order [`LivePaintMove::plan`] took them),
/// make the faces and edges of the groups whose paths changed again, and add the rows that
/// joined a group to it. → `moved` with the joined rows replaced by their group, once, and
/// without the faces and edges that were made again.
pub(crate) fn finish(self, d: &mut Document, sel: &mut Selection, moved: &[NodeId]) -> Result<Vec<NodeId>> {
// A moved object named like the sources group may now sit before it, where a lookup by name
// finds the object first. The group's own sources group goes back in front.
if let Some((g, src)) = self.keep_sources {
let ch = d.children_mut(Some(g))?;
if let Some(at) = ch.iter().position(|c| c.id == src)
&& ch[..at].iter().any(|c| c.name.as_deref() == Some(SOURCES_NAME))
{
let s = ch.remove(at);
ch.insert(0, s);
}
}
if self.join.is_none() && self.rebuild.is_empty() {
return Ok(moved.to_vec());
}
// The group the rows join is made again by the merge below, from its paths as they are now
// and with the paint of its faces and edges as they were before the move.
let join_group = self.join.as_ref().map(|(g, _)| *g);
// A Live Paint group among another group's paths gives that group its faces and edges, so
// the groups holding a changed group among their paths are made again too, innermost first.
let mut groups: Vec<NodeId> = vec![];
for g in self.rebuild.iter().copied().chain(join_group) {
for x in std::iter::once(g).chain(enclosing_live_paints(d, g)) {
if !groups.contains(&x) {
groups.push(x);
}
}
}
groups.sort_by_cached_key(|g| std::cmp::Reverse(d.ancestry(*g).map_or(0, |a| a.len())));
let joined: Vec<NodeId> = match &self.join {
Some((_, mask)) => moved.iter().zip(mask).filter(|(_, j)| **j).map(|(r, _)| *r).collect(),
None => vec![],
};
for g in groups {
if Some(g) == join_group {
let roots: Vec<NodeId> = std::iter::once(g).chain(joined.iter().copied()).collect();
merge_live(d, sel, &roots)?;
} else if d.node(g).is_some() {
rebuild_paths(d, g)?;
}
}
let Some((g, mask)) = self.join else { return Ok(moved.iter().copied().filter(|r| d.node(*r).is_some()).collect()) };
// `moved` holds each row once, so only the group can come twice. Faces and edges of the
// group moved along with the joining rows were made again, so they are left out.
let mut out = vec![];
let mut listed = false;
for (r, j) in moved.iter().zip(&mask) {
if *j {
if !listed {
out.push(g);
listed = true;
}
} else if d.node(*r).is_some() {
out.push(*r);
}
}
Ok(out)
}
}
/// Make Live Paint group `g`'s faces and edges again from the paths its sources group holds now,
/// with its Gap Options, carrying over the paint of the faces and edges that stay. With no path
/// left, the group keeps its sources group and its other children, and has no faces or edges.
fn rebuild_paths(d: &mut Document, g: NodeId) -> Result<()> {
let old = d.node(g).cloned().ok_or(EngineError::NoNode(g))?;
let sources = source_nodes(&old);
let mut n = old.clone();
if source_shapes(&sources).0.is_empty() {
let src = b::sources(&old).cloned().ok_or(EngineError::NoNode(g))?;
set_parts(&mut n, vec![src], &[]);
} else {
let (children, _, _) = build_children(d, sources, old.gap_options().max_gap())?;
set_parts(&mut n, children, &[]);
repaint_from(&mut n, &old);
}
let mut changed = Beside::replacing(d, &[g]);
changed.put(d, g, vec![n])?;
changed.finish(d)
}
fn live_targets(s: &Session, p: &Value) -> Result<Vec<NodeId>> {
let d = &s.doc()?.doc;
let ids = root_ids(s, p)?;
+46 -2
View File
@@ -8,6 +8,8 @@ use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind, ShapeMode};
use vectorcraft_geom::{FillRule, PathData, SubPath};
use vectorcraft_pathops as po;
use vectorcraft_render::effects;
use super::edit::{roots_of, selected_roots};
@@ -16,6 +18,10 @@ use super::{CommandSpec, EngineError, Result, Session, bad, cmd, has_multi};
const MODE_NAMES: [&str; 4] = ["add", "subtract", "intersect", "exclude"];
/// Make Compound Shape's warning, which the status bar shows, when a member holds a line or another
/// open path that encloses no area once closed, and so contributes no area to the shape.
pub const OPEN_PATHS_ADD_NO_AREA: &str = "a line or other open path that encloses no area contributes no area to the compound shape; to include it, apply Object › Path › Outline Stroke to it first";
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
@@ -23,7 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Make Compound Shape",
["Window", "Pathfinder"],
None,
"{ids?: [id…] (selected first; default: the selection), mode?: \"add\"|\"subtract\"|\"intersect\"|\"exclude\" (default add; Alt-clicking a Shape Mode button gives its mode)} the two or more selected objects (paths, compound paths, groups, compound shapes, type, blends, envelopes) become the members of one compound shape, each with the shape mode, in their stacking order where the frontmost was: it draws as the area they make from the backmost up (open paths closed; a blend as its steps, an envelope as its distorted art, an object with a warp or other geometry effect as it draws), painted with the appearance and transparency of the topmost member in Add, Intersect or Exclude mode (with every member in Subtract, the backmost), and the members stay editable (Direct Selection, Layers panel, isolation mode) → {id}",
"{ids?: [id…] (selected first; default: the selection), mode?: \"add\"|\"subtract\"|\"intersect\"|\"exclude\" (default add; Alt-clicking a Shape Mode button gives its mode)} the two or more selected objects (paths, compound paths, groups, compound shapes, type, blends, envelopes) become the members of one compound shape, each with the shape mode, in their stacking order where the frontmost was: it draws as the area they make from the backmost up (open paths closed; a blend as its steps, an envelope as its distorted art, an object with a warp or other geometry effect as it draws), painted with the appearance and transparency of the topmost member in Add, Intersect or Exclude mode (with every member in Subtract, the backmost), and the members stay editable (Direct Selection, Layers panel, isolation mode) → {id, warning?: when a member is or holds a line or another open path that encloses no area once closed, and so contributes no area}",
has_multi,
make
),
@@ -157,6 +163,7 @@ fn make(s: &mut Session, p: &Value) -> Result<Value> {
// all have `mode`, the topmost, or the backmost when they all subtract.
let order: Vec<&Node> = if mode == ShapeMode::Subtract { members } else { members.into_iter().rev().collect() };
let hook = |c: &Node| effects::outline_object(Some(d), c);
let no_area = order.iter().any(|n| adds_no_area(d, n, &hook));
let style = order.into_iter().find_map(|n| top_style(d, n, &hook));
let id = s.edit("Make Compound Shape", |d, sel| {
let gid = d.alloc_id();
@@ -179,7 +186,44 @@ fn make(s: &mut Session, p: &Value) -> Result<Value> {
sel.set([id]);
Ok(id)
})?;
Ok(json!({ "id": id.0 }))
let mut out = json!({ "id": id.0 });
if no_area {
out["warning"] = json!(OPEN_PATHS_ADD_NO_AREA);
}
Ok(out)
}
/// Member `n` holds an open path that adds no area to a compound shape: one of the paths it takes
/// part as ([`effects::member_leaves`]), inside a group or a compound path too, has an open subpath
/// that encloses no area once closed (a straight line, or an evenodd contour traced twice), or it
/// has an open subpath and its subpaths, all closed, enclose no area together (open evenodd
/// subpaths that cancel one another or a closed subpath). The area is the one the path's fill rule
/// gives, which also keeps a self-crossing path whose signed area is zero (a bow tie) from the
/// warning, as Divide measures it. An area that can't be measured gives no warning.
fn adds_no_area(d: &Document, n: &Node, hook: effects::OutlineHook) -> bool {
effects::member_leaves(Some(d), n, Some(hook)).iter().any(|leaf| {
let (paths, rule): (Vec<&PathData>, FillRule) = match &leaf.kind {
NodeKind::Compound { children, rule } => (children.iter().filter_map(|c| c.path_data()).collect(), *rule),
NodeKind::Path { path, rule, .. } => (vec![path], *rule),
_ => return false,
};
let subpaths: Vec<&SubPath> = paths.iter().flat_map(|p| &p.subpaths).collect();
if subpaths.iter().all(|sp| sp.closed) {
return false;
}
let closed = |sp: &SubPath| {
let mut sp = sp.clone();
sp.closed = true;
sp
};
// An area that can't be measured counts as an area, so a failed measurement gives no warning.
let no_area = |p: PathData| po::try_area(&p, rule).is_ok_and(|a| a <= 0.0);
subpaths.iter().filter(|sp| !sp.closed).any(|sp| {
// The signed-area test alone only holds for nonzero: evenodd can fill nothing where
// the signed area is not zero (a contour traced twice).
!(rule == FillRule::NonZero && po::encloses_area(sp)) && no_area(PathData::single(closed(sp)))
}) || (subpaths.len() > 1 && no_area(PathData::new(subpaths.iter().map(|sp| closed(sp)).collect())))
})
}
/// The paint and transparency of the frontmost shape `n` adds to a compound shape's area, from the
+10 -144
View File
@@ -55,7 +55,16 @@ pub fn specs() -> Vec<CommandSpec> {
None,
"{cx, cy, diameter=100, opacity=50 (%), brightness=30 (%), growth=20 (%), fuzziness=50 (%), rays=15, longest=300 (%), rayFuzziness=100 (%), rotation=0 (deg, turns the rays clockwise), x2?, y2? (ring end; else pathLength at direction), pathLength=300, rings=10, largest=50 (%), direction=45 (deg counter-clockwise from 3 o'clock: where the rings run from the centre), seed?, ringSeed? (whole number below 2^53: deterministically places every ring along the path, including the first for small seed values, keeping their count and sizes)} → {id}",
has_doc,
flare
super::flare::flare
),
cmd!(
"shape.editFlare",
"Edit Flare",
[],
None,
"{ids?|id?: flares (default: the selected flares), cx?, cy? (the center, where it is drawn now), x2?, y2? (the rings' end point, where it is drawn now; else pathLength at direction from the center, both where it is drawn now, when either is given; else where it was), diameter?, opacity?, brightness?, growth?, fuzziness?, rays?, longest?, rayFuzziness?, rotation? (deg, turns the rays clockwise), pathLength?, rings?, largest?, direction? (as shape.flare: what is left out stays as it was)} draws each flare again in its place, moved, scaled, rotated, reflected or sheared as it has been since it was drawn, as one undo step (none when nothing changes); a flare whose parts were edited, or that is locked or hidden, is not one → {ids}",
has_doc,
super::flare::edit_flare
),
cmd!(
"shape.circleThroughPoints",
@@ -515,149 +524,6 @@ fn star(s: &mut Session, p: &Value) -> Result<Value> {
add_art_turned(s, "Star", path_kind(path, None), constrained_turn(s, rot))
}
/// Flare tool: a lens flare built from radial-gradient paths in Screen mode — a bright centre, a halo
/// ring, rays of varying length and rings along the path to the end point.
fn flare(s: &mut Session, p: &Value) -> Result<Value> {
use vectorcraft_color::{BlendMode, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
let c = Point::new(f64_req(p, "cx", "shape.flare")?, f64_req(p, "cy", "shape.flare")?);
let numbers = [
"diameter",
"opacity",
"brightness",
"growth",
"fuzziness",
"rays",
"longest",
"rayFuzziness",
"rotation",
"rings",
"largest",
"x2",
"y2",
"direction",
"pathLength",
"seed",
"ringSeed",
];
check_numbers(p, &numbers, "shape.flare")?;
let pct = |k: &str, d: f64| (f64_or(p, k, d) / 100.0).clamp(0.0, 10.0);
let r = (f64_or(p, "diameter", 100.0) / 2.0).max(0.5);
let opacity = pct("opacity", 50.0).min(1.0) as f32;
let brightness = pct("brightness", 30.0).min(1.0) as f32;
let growth = pct("growth", 20.0);
let fuzz = pct("fuzziness", 50.0).min(1.0);
let rays = p.get("rays").and_then(Value::as_u64).unwrap_or(15).min(50) as usize;
let longest = pct("longest", 300.0);
let ray_fuzz = pct("rayFuzziness", 100.0).min(1.0);
let ray_turn = f64_or(p, "rotation", 0.0).to_radians();
let rings = p.get("rings").and_then(Value::as_u64).unwrap_or(10).min(50) as usize;
let largest = pct("largest", 50.0);
let end = match (p.get("x2").and_then(Value::as_f64), p.get("y2").and_then(Value::as_f64)) {
(Some(x), Some(y)) => Point::new(x, y),
_ => {
let a = f64_or(p, "direction", 45.0).to_radians();
c + vectorcraft_geom::Vec2::new(a.cos(), -a.sin()) * f64_or(p, "pathLength", 300.0)
}
};
// Deterministic pseudo-random sizes (same parameters → same flare). `ringSeed` places the rings
// along the path from a sequence of its own; their count and sizes and the other parts stay.
let seed_of = |key: &str| match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(v) => v.as_u64().map(Some).ok_or_else(|| bad("shape.flare", format!("`{key}` must be a whole number of at least 0, not {v}"))),
};
// Xorshift64. Both streams start from a nonzero state.
let random = |mut state: u64| {
move || {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
(state >> 11) as f64 / (1u64 << 53) as f64
}
};
let mut rnd = random(seed_of("seed")?.unwrap_or(0x2545_f491_4f6c_dd1d) | 1);
// Each `ringSeed` below 2^53 (what a JSON number holds exactly) gets a state of its own.
let ring_seed = match seed_of("ringSeed")? {
Some(r) if r >= 1 << 53 => return Err(bad("shape.flare", format!("`ringSeed` must be below 2^53, not {r}"))),
r => r,
};
let mut ring_at = ring_seed.map(|r| {
// SplitMix64 initializes the ring-position stream.
let mut z = r.wrapping_add(0x9e37_79b9_7f4a_7c15);
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
random(z ^ (z >> 31))
});
let stop = |offset: f32, opacity: f32| GradientStop { opacity, ..GradientStop::new(offset, vectorcraft_color::Color::WHITE) };
let radial = |centre: Point, radius: f64, stops: Vec<GradientStop>| {
let mut g = GradientPaint::new(Gradient::new(GradientKind::Radial, stops));
g.geom = Some(GradientGeom { start: centre, end: centre + vectorcraft_geom::Vec2::new(radius, 0.0), aspect: 1.0, focal: None });
Paint::Gradient(Box::new(g))
};
let circle = |centre: Point, radius: f64| shapes::ellipse(Rect::from_center_size(centre, (radius * 2.0, radius * 2.0)));
let mut parts: Vec<(&str, PathData, Paint, f32)> = vec![];
// Halo: a soft ring just outside the centre.
let halo_r = r * (1.0 + growth) * 1.6;
let inner = (1.0 - fuzz as f32 * 0.6).clamp(0.05, 0.95);
parts.push(("Halo", circle(c, halo_r), radial(c, halo_r, vec![stop(0.0, 0.0), stop(inner * 0.75, 0.0), stop(inner, 0.5), stop(1.0, 0.0)]), 1.0));
// Rays: thin spikes of random length (Longest = % of the centre radius), fading outwards.
// `rotation` turns them clockwise about the center.
if rays > 0 {
let mut bp = vectorcraft_geom::BezPath::new();
let mut reach: f64 = 0.0;
for i in 0..rays {
let a = std::f64::consts::TAU * (i as f64 + rnd() * 0.6) / rays as f64 + ray_turn;
let len = r * longest * (1.0 - ray_fuzz * 0.75 * rnd()).max(0.1);
reach = reach.max(len);
let w = r * 0.035;
let dir = vectorcraft_geom::Vec2::new(a.cos(), a.sin());
let n = vectorcraft_geom::Vec2::new(-dir.y, dir.x) * w;
bp.move_to(c + n);
bp.line_to(c + dir * len);
bp.line_to(c - n);
bp.line_to(c - dir * (w * 4.0));
bp.close_path();
}
parts.push(("Rays", PathData::from_bezpath(&bp), radial(c, reach, vec![stop(0.0, 0.9), stop(0.25, 0.35), stop(1.0, 0.0)]), 1.0));
}
// Centre: bright core fading to transparent.
parts.push(("Center", circle(c, r), radial(c, r, vec![stop(0.0, 1.0), stop(0.25 + brightness * 0.5, 0.6), stop(1.0, 0.0)]), opacity));
// Rings along the path to the end point (Largest = % of the average ring size).
for _ in 0..rings {
let t = rnd();
let t = ring_at.as_mut().map_or(t, |next| next());
let at = c + (end - c) * t;
let rr = (r * largest * (0.25 + rnd() * 0.75)).max(0.5);
let solid = rnd() < 0.5;
let stops = if solid {
vec![stop(0.0, 0.25), stop(0.8, 0.2), stop(1.0, 0.0)]
} else {
vec![stop(0.0, 0.0), stop(0.7, 0.05), stop(0.92, 0.35), stop(1.0, 0.0)]
};
parts.push(("Ring", circle(at, rr), radial(at, rr, stops), 1.0));
}
let parent = s.doc()?.target_parent()?;
let id = s.edit("Flare", |d, sel| {
let children = parts
.into_iter()
.map(|(name, pd, paint, op)| {
let mut n = Node::path(d.alloc_id(), pd, Appearance::basic(paint, Paint::None, 0.0));
n.name = Some(name.into());
n.blend = BlendMode::Screen;
n.opacity = op;
super::object::align_new_object(d, &mut n);
std::sync::Arc::new(n)
})
.collect();
let gid = d.alloc_id();
let mut g = Node::group(gid, children);
g.name = Some("Flare".into());
d.insert(parent, usize::MAX, g)?;
sel.set([gid]);
Ok(gid)
})?;
Ok(json!({ "id": id.0 }))
}
fn line(s: &mut Session, p: &Value) -> Result<Value> {
let a = Point::new(f64_req(p, "x1", "shape.line")?, f64_req(p, "y1", "shape.line")?);
let b = Point::new(f64_req(p, "x2", "shape.line")?, f64_req(p, "y2", "shape.line")?);
+1
View File
@@ -1611,6 +1611,7 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
}
} else {
super::object::keep_pixel_aligned(&mut c, sc);
super::buildcmds::clear_part_name(d, par, &mut c);
new_ids.push(d.insert(par, idx, c)?);
}
}
+5 -1
View File
@@ -182,7 +182,7 @@ impl Expandable {
n.walk(&mut |c| {
let shape = matches!(c.kind, NodeKind::Path { .. } | NodeKind::Compound { .. });
e.text |= matches!(c.kind, NodeKind::Text(_));
e.live |= matches!(c.kind, NodeKind::Path { live: Some(_), .. });
e.live |= matches!(c.kind, NodeKind::Path { live: Some(_), .. }) || c.extras().flare.is_some();
e.effects |= !c.appearance.effects.is_empty();
e.envelope |= matches!(c.kind, NodeKind::Envelope { .. });
e.blends |= matches!(c.kind, NodeKind::Blend { .. });
@@ -503,10 +503,14 @@ fn end_dimension_links(s: &mut Session, ended: &mut Vec<EndedLink>) -> Result<()
Ok(())
}
/// Makes the live shapes in `n` plain paths, and the flares plain groups of their parts.
fn drop_live(n: &mut Node) {
if let NodeKind::Path { live, .. } = &mut n.kind {
*live = None;
}
if n.extras().flare.is_some() {
n.extras_mut().flare = None;
}
if let Some(ch) = n.children_mut() {
for c in ch.iter_mut() {
drop_live(Arc::make_mut(c));
+16 -4
View File
@@ -297,7 +297,17 @@ pub(crate) fn write_file(path: &str, bytes: &[u8]) -> Result<()> {
vectorcraft_doc::cancel::check()?;
may_write(path)?;
// Never a half-written file: see [`write_atomic`].
write_atomic(std::path::Path::new(path), bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))
write_atomic(std::path::Path::new(path), bytes).map_err(|e| write_error(path, e))
}
/// The error writing `path` failed with: [`EngineError::Cancelled`] for work canceled before the
/// file was put in place ([`vectorcraft_format::write_atomic_with`]), otherwise the path and the reason.
#[cfg(not(target_arch = "wasm32"))]
fn write_error(path: &str, error: std::io::Error) -> EngineError {
if error.get_ref().is_some_and(|e| e.is::<vectorcraft_doc::cancel::Cancelled>()) {
return EngineError::Cancelled;
}
EngineError::Other(format!("{path}: {error}"))
}
/// [`write_file`] with what `fill` writes into the file (a save streamed into it).
@@ -305,7 +315,7 @@ pub(crate) fn write_file(path: &str, bytes: &[u8]) -> Result<()> {
pub fn write_file_with(path: &str, fill: &mut dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>) -> Result<()> {
vectorcraft_doc::cancel::check()?;
may_write(path)?;
vectorcraft_format::write_atomic_with(std::path::Path::new(path), |f| fill(f)).map_err(|e| EngineError::Other(format!("{path}: {e}")))
vectorcraft_format::write_atomic_with(std::path::Path::new(path), |f| fill(f)).map_err(|e| write_error(path, e))
}
/// The save commands' writer: preserves a filesystem location refusal as a typed error. Other
@@ -324,8 +334,10 @@ pub fn write_save_file_with(path: &str, fill: &mut dyn FnMut(&mut dyn std::io::W
#[cfg(not(target_arch = "wasm32"))]
pub(super) fn save_write_error(path: &str, error: std::io::Error) -> EngineError {
let reason = format!("{path}: {error}");
if vectorcraft_format::read_only_location(&error) { EngineError::ReadOnlyLocation(reason) } else { EngineError::Other(reason) }
if !vectorcraft_format::read_only_location(&error) {
return write_error(path, error);
}
EngineError::ReadOnlyLocation(format!("{path}: {error}"))
}
#[cfg(target_arch = "wasm32")]
+6 -3
View File
@@ -962,7 +962,8 @@ pub(crate) fn size_note(bytes: &[u8]) -> Option<String> {
/// TIFF ([`vectorcraft_doc::cmyk::turned_cmyk`]). An image the decoder reads and that is stored as
/// PNG keeps its gray or RGB samples at 8 or 16 bits, and the gray or RGB ICC profile they are in;
/// other samples become 8-bit RGBA. A PSD/PSB composite's stored image keeps its imported
/// clipping path ([`image_clip`]).
/// clipping path ([`image_clip`]), and a PNG or TIFF that keeps such a path (as Unembed writes
/// it) is read with that path.
pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
let ppi = super::ppi::resolution(bytes);
if let Some((w, h)) = vectorcraft_doc::cmyk::oversized_tiff(bytes) {
@@ -1139,13 +1140,15 @@ pub fn texture_image(bytes: &[u8]) -> Result<String> {
texture.and_then(|t| t.to_stored()).ok_or_else(|| err("the image can't be read as a texture"))
}
/// An image's encoded `bytes`, `width` × `height` pixels, ready to embed.
/// An image's encoded `bytes`, `width` × `height` pixels, ready to embed, with the clipping path a
/// PNG or TIFF made from a PSD or PSB file keeps ([`image_clip`]).
fn stored(bytes: Vec<u8>, mime: &'static str, (width, height): (u32, u32), ppi: Option<(f64, f64)>) -> Result<RasterImage> {
if width == 0 || height == 0 {
return Err(err("the image is empty"));
}
let blob = ImageBlob::new(mime, bytes);
Ok(RasterImage { key: blob.content_key(), blob, width, height, ppi, clip: None })
let clip = image_clip(&blob).map(|path| (path, vectorcraft_geom::FillRule::EvenOdd));
Ok(RasterImage { key: blob.content_key(), blob, width, height, ppi, clip })
}
/// The keyword of the PNG text chunk holding the clipping path of the file a PNG was made from
+17 -1
View File
@@ -19,6 +19,18 @@ pub(super) const OPTIONS: &[FormatOption] = &[super::ARTBOARD, super::ARTBOARDS,
/// Encode `doc` as `kind`: the chosen artboard (default the first), or with `use_artboards` one
/// picture per chosen artboard (default all).
pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kind: Kind) -> Result<Encoded> {
encode_flattening(doc, p, use_artboards, kind, crate::flatten_raster_effects)
}
/// [`encode`] with `flatten` turning raster effects into images. The chosen artboards are checked
/// first, so an export that is refused does not call `flatten`.
pub(super) fn encode_flattening(
doc: &Document,
p: &Value,
use_artboards: Option<bool>,
kind: Kind,
flatten: impl FnOnce(&Document) -> Option<Document>,
) -> Result<Encoded> {
let f = super::format(kind.id()).ok_or_else(|| bad(C, "no metafile format"))?;
let pick: ArtboardPick = super::encode::options(f, p)?;
let n = doc.artboards.len();
@@ -26,12 +38,16 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kin
Some(true) => pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect()),
_ => vec![pick.one(n).map_err(|e| bad(C, e))?],
};
if boards.is_empty() {
return Err(bad(C, "the document has no artboard"));
}
let rects = boards
.iter()
.map(|&b| doc.artboards.get(b).map(|a| a.rect).ok_or_else(|| bad(C, format!("no artboard {}", b + 1))))
.collect::<Result<Vec<_>>>()?;
vectorcraft_metafile::check_regions(&rects).map_err(|e| bad(C, e))?;
// Raster effects (shadows, glows, blurs) as images, as PDF export does.
let flat = crate::flatten_raster_effects(doc);
let flat = flatten(doc);
let src = flat.as_ref().unwrap_or(doc);
let outs = vectorcraft_metafile::export_regions(src, &rects, kind).map_err(|e| bad(C, e))?;
let mut enc = Encoded::default();
+202 -6
View File
@@ -69,7 +69,7 @@ pub(crate) const OPTIONS: &[FormatOption] = &[
name: "bleed",
ty: "object",
default: "null",
description: "{useDocument, top, bottom, left, right} in points: the page grows by the bleed (BleedBox) around its artboard (TrimBox); a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning",
description: "{useDocument, top, bottom, left, right} in points: the page grows by the bleed (BleedBox) around its artboard (TrimBox); a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning, and so do objects that reach the trim edge on a side with a bleed but stop short of the bleed edge",
},
FormatOption {
name: "output",
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export PDF",
[],
None,
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged Line truncated
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning, and so does a count of the visible objects that reach the trim edge (within 0.5 pt) on a side with a bleed but end before the bleed edge; layers that don't print are left out unless includeNonPrinting, and art and boxes are written unchanged). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in Line truncated
has_doc,
export_pdf
),
@@ -295,6 +295,8 @@ pub(super) fn encode_art_page(cmd: &str, doc: &Document, p: &Value) -> Result<Op
o.insert("preserveEditing".into(), json!(false));
}
let (bytes, mut notes) = encode(cmd, &art, &q)?;
// The page is the art's bounds, so every object at its edge would count.
notes.retain(|n| !is_short_of_bleed(&n.text));
if left_out {
notes.push(Note::setting(EDITING_NEEDS_THE_ARTBOARDS));
}
@@ -317,6 +319,191 @@ pub(super) fn art_page(cmd: &str, doc: &Document, p: &Value) -> Result<Option<(D
/// ([`vectorcraft_pdf::PdfSettings::leaves_out_bleed`]).
pub const BLEED_LEFT_OUT: &str = "the document sets a bleed that this PDF/X file leaves out: turn on Use document bleed settings";
/// How far, in points, an object's edge may sit inside the trim edge, or short of the bleed edge,
/// and still count as reaching it in [`short_of_bleed`]. A side whose bleed is no larger has none.
const EDGE_TOLERANCE: f64 = 0.5;
/// How many objects of `doc` reach the trim edge (an artboard's edge, within [`EDGE_TOLERANCE`]) of
/// one of `artboards` (`None`: all of them) on a side where `bleed` (`[top, bottom, left, right]`
/// in points) is set, but end before that side's bleed edge. The objects are the members of the
/// visible layers and sublayers, a group counted as one, measured as [`drawn_bounds`] measures them
/// and cut to the clipping paths of the layers they are on. Template layers, layers with an opacity
/// mask and, unless `non_printing`, layers whose Print option is off are left out. A side whose
/// bleed is [`EDGE_TOLERANCE`] or less counts as having none. Each object counts once.
pub fn short_of_bleed(doc: &Document, bleed: [f64; 4], artboards: Option<&[usize]>, non_printing: bool) -> usize {
let bleed = bleed.map(|b| if b.is_finite() && b > EDGE_TOLERANCE { b } else { 0.0 });
if bleed.iter().all(|b| *b == 0.0) {
return 0;
}
let trims: Vec<vectorcraft_geom::Rect> = match artboards {
Some(picked) => picked.iter().filter_map(|&i| doc.artboards.get(i)).map(|a| a.rect).collect(),
None => doc.artboards.iter().map(|a| a.rect).collect(),
};
let symbols = doc.symbol_boxes();
let mut count = 0;
// Each object with the clipping path of the layers above it.
let mut stack: Vec<(&Node, Option<vectorcraft_geom::Rect>)> = doc.layers.iter().map(|l| (&**l, None)).collect();
while let Some((n, clip)) = stack.pop() {
if let NodeKind::Layer { template, printable, children, clip: clipping, .. } = &n.kind {
// An opacity mask decides what shows, so a masked layer's art is not measured.
if !n.visible || *template || !(*printable || non_printing) || n.opacity <= 0.0 || n.extras().mask.is_some() {
continue;
}
// A clipping layer's first child clips the others, and its fills and strokes are an
// object of their own.
let (inner, members) = if *clipping {
let Some(own) = clip_region(children, &symbols) else { continue };
let inner = clip.map_or(own, |c| c.intersect(own));
if let Some(first) = children.first()
&& let Drawn::Bounds(b) = clip_paint_drawn(first, inner, &symbols)
{
let b = clip.map_or(b, |c| c.intersect(b));
if b.area() > 0.0 && trims.iter().any(|t| stops_short(b, *t, bleed)) {
count += 1;
}
}
(Some(inner), children.get(1..).unwrap_or_default())
} else {
(clip, &children[..])
};
stack.extend(members.iter().map(|c| (&**c, inner)));
continue;
}
let Drawn::Bounds(b) = drawn_bounds(n, &symbols) else { continue };
let b = clip.map_or(b, |c| c.intersect(b));
if b.area() > 0.0 && trims.iter().any(|t| stops_short(b, *t, bleed)) {
count += 1;
}
}
count
}
/// What [`drawn_bounds`] finds an object draws.
enum Drawn {
/// Nothing: it is hidden, a guide, at 0% opacity, or a path that paints nothing.
Nothing,
/// Art within these bounds.
Bounds(vectorcraft_geom::Rect),
/// Art whose bounds aren't known, which is not measured: brush art paints past the visual
/// bounds by an amount they don't give, an opacity mask hides part of what they hold, and area
/// type and type on a path are bounded by their frame or path.
Unknown,
}
/// Whether path or compound path `n` paints: one of its fills and strokes is visible, has a paint
/// and an opacity above 0 and, a stroke, a width above 0. Other objects count as painting.
fn paints(n: &Node) -> bool {
!matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. })
|| n.appearance.items.iter().any(|i| {
i.visible() && i.opacity() > 0.0 && !i.paint().is_none() && !matches!(i, vectorcraft_doc::AppearanceItem::Stroke(s) if s.width <= 0.0)
})
}
/// What `n` draws on a page, by its visual bounds (strokes included): a group without a clipping
/// path by the members that draw, and a clip group by the part of them inside its clipping path
/// together with what the clipping path paints itself ([`clip_paint_drawn`]).
/// Hidden objects, guides, objects at 0% opacity and paths that paint nothing draw nothing. Art
/// with a brushed stroke that draws, in `n` or (outside groups) in the objects it holds, art with
/// an opacity mask, and area type and type on a path are [`Drawn::Unknown`].
fn drawn_bounds(n: &Node, symbols: &vectorcraft_doc::SymbolBoxes) -> Drawn {
if !n.visible || n.is_guide() || n.opacity <= 0.0 || !paints(n) {
return Drawn::Nothing;
}
// An opacity mask decides what shows of the object, and the bounds of area type and type on a
// path are its frame or path, not its glyphs.
let frame_bounds = matches!(&n.kind, NodeKind::Text(t) if !matches!(t.kind, vectorcraft_doc::TextKind::Point));
if vectorcraft_brush::reach(n) > 0.0 || n.extras().mask.is_some() || frame_bounds {
return Drawn::Unknown;
}
let members = |children: &[Arc<Node>]| {
let mut out = Some(None);
for c in children {
out = match (out, drawn_bounds(c, symbols)) {
(None, _) | (_, Drawn::Unknown) => None,
(Some(acc), Drawn::Bounds(b)) => Some(vectorcraft_geom::union_opt(acc, Some(b))),
(keep, Drawn::Nothing) => keep,
};
}
out
};
let measured = match &n.kind {
NodeKind::Group { clip: false, .. } => match members(n.editing_children()) {
Some(art) => art.and_then(|_| n.visual_of_members(std::iter::once(art))),
None => return Drawn::Unknown,
},
NodeKind::Group { clip: true, children } => {
let Some(region) = clip_region(children, symbols) else { return Drawn::Nothing };
let Some(art) = members(children.get(1..).unwrap_or_default()) else { return Drawn::Unknown };
let art = art.map(|a| region.intersect(a)).filter(|b| b.area() > 0.0);
match children.first().map_or(Drawn::Nothing, |first| clip_paint_drawn(first, region, symbols)) {
Drawn::Unknown => return Drawn::Unknown,
Drawn::Bounds(b) => vectorcraft_geom::union_opt(art, Some(b)),
Drawn::Nothing => art,
}
}
_ if vectorcraft_brush::reach_within(n) > 0.0 => return Drawn::Unknown,
_ => n.visual_bounds_with(symbols),
};
measured.map_or(Drawn::Nothing, Drawn::Bounds)
}
/// The region the clipping path of a clip group or clipping layer with `children` clips to: its
/// geometric bounds, without its strokes.
fn clip_region(children: &[Arc<Node>], symbols: &vectorcraft_doc::SymbolBoxes) -> Option<vectorcraft_geom::Rect> {
children.first()?.geometric_bounds_with(symbols)
}
/// What clipping path `clip` paints itself ([`Node::clip_paint`]): its fills inside `region`, the
/// region it clips to, and its strokes over the clipped art, unclipped.
fn clip_paint_drawn(clip: &Node, region: vectorcraft_geom::Rect, symbols: &vectorcraft_doc::SymbolBoxes) -> Drawn {
let paint = clip.clip_paint();
let mut out = None;
for (part, clipped) in [(paint.fill, true), (paint.stroke, false)] {
let Some(part) = part else { continue };
match drawn_bounds(&part, symbols) {
Drawn::Unknown => return Drawn::Unknown,
Drawn::Nothing => {}
Drawn::Bounds(b) => {
let b = if clipped { region.intersect(b) } else { b };
out = vectorcraft_geom::union_opt(out, Some(b).filter(|b| b.area() > 0.0));
}
}
}
out.map_or(Drawn::Nothing, Drawn::Bounds)
}
/// Whether bounds `b` reach the trim edge `t` (within [`EDGE_TOLERANCE`] on either side of it) on a
/// side where `bleed` (`[top, bottom, left, right]`) is above 0 and end before the bleed edge there.
/// Document space has y down.
fn stops_short(b: vectorcraft_geom::Rect, t: vectorcraft_geom::Rect, [top, bottom, left, right]: [f64; 4]) -> bool {
let tol = EDGE_TOLERANCE;
let across = b.x0 < t.x1 && b.x1 > t.x0;
let down = b.y0 < t.y1 && b.y1 > t.y0;
let reaches = |near: f64, far: f64, edge: f64| near <= edge + tol && far >= edge - tol;
(across && top > 0.0 && reaches(b.y0, b.y1, t.y0) && b.y0 > t.y0 - top + tol)
|| (across && bottom > 0.0 && reaches(-b.y1, -b.y0, -t.y1) && b.y1 < t.y1 + bottom - tol)
|| (down && left > 0.0 && reaches(b.x0, b.x1, t.x0) && b.x0 > t.x0 - left + tol)
|| (down && right > 0.0 && reaches(-b.x1, -b.x0, -t.x1) && b.x1 < t.x1 + right - tol)
}
/// The warning for `n` objects that [`short_of_bleed`] finds; `None` for none.
pub fn short_of_bleed_warning(n: usize) -> Option<String> {
match n {
0 => None,
1 => Some(format!("1 object {SHORT_OF_BLEED_ONE}")),
_ => Some(format!("{n} objects {SHORT_OF_BLEED_OTHER}")),
}
}
/// The end of [`short_of_bleed_warning`] for one object and for more.
const SHORT_OF_BLEED_ONE: &str = "reaches the trim edge but stops short of the bleed";
const SHORT_OF_BLEED_OTHER: &str = "reach the trim edge but stop short of the bleed";
/// Whether `text` is a warning [`short_of_bleed_warning`] gives.
pub fn is_short_of_bleed(text: &str) -> bool {
text.ends_with(SHORT_OF_BLEED_ONE) || text.ends_with(SHORT_OF_BLEED_OTHER)
}
/// The end of the writer's warning for a page longer than 14,400 pt written with a `UserUnit`
/// above 1.
const SHOWN_SMALLER: &str = "so apps that ignore UserUnit show it that many times smaller";
@@ -340,7 +527,7 @@ pub(super) fn encode_at(cmd: &str, doc: &Document, p: &Value, modified: Option<i
let mut notes: Vec<Note> = placed.into_iter().map(Note::loss).collect();
// The editing data leaves out an Export for Screens folder outside the read roots.
let native = || Ok(vectorcraft_format::save(&super::access::with_readable_settings_folder(doc), false));
let (bytes, drawn) = encode_carrying_at(cmd, &full, p, modified, native, || Ok(None))?;
let (bytes, drawn) = encode_carrying_at(cmd, &full, p, modified, true, native, || Ok(None))?;
notes.extend(drawn);
if notes.iter().any(|n| n.text.ends_with(SHOWN_SMALLER)) && options(cmd, &full, p)?.settings.standard == Standard::None {
for n in notes.iter_mut().filter(|n| n.text.ends_with(SHOWN_SMALLER)) {
@@ -364,7 +551,8 @@ fn overflow_warning(cmd: &str, doc: &Document, p: &Value) -> Result<Option<Strin
/// [`encode`] the pages of `doc`, carrying `native()` as the editing data (a `.ai` file: the
/// native document with its save options, whose pages may be left blank), and `private()`, the
/// editing copy of the art for other apps with what it couldn't hold, on every page.
/// editing copy of the art for other apps with what it couldn't hold, on every page. It doesn't
/// warn about art that stops short of the bleed ([`short_of_bleed`]), which PDF export does.
pub(super) fn encode_carrying(
cmd: &str,
doc: &Document,
@@ -372,20 +560,26 @@ pub(super) fn encode_carrying(
native: impl FnOnce() -> Result<Vec<u8>>,
private: impl FnOnce() -> Result<Option<(vectorcraft_pdf::PrivateData, Vec<String>)>>,
) -> Result<(Vec<u8>, Vec<Note>)> {
encode_carrying_at(cmd, doc, p, None, native, private)
encode_carrying_at(cmd, doc, p, None, false, native, private)
}
/// [`encode_carrying`] modified at `modified` (Unix seconds) when given, instead of the time of
/// writing.
/// writing, warning about art that stops short of the bleed when `bleed_check` is true.
fn encode_carrying_at(
cmd: &str,
doc: &Document,
p: &Value,
modified: Option<i64>,
bleed_check: bool,
native: impl FnOnce() -> Result<Vec<u8>>,
private: impl FnOnce() -> Result<Option<(vectorcraft_pdf::PrivateData, Vec<String>)>>,
) -> Result<(Vec<u8>, Vec<Note>)> {
let mut opts = options_at(cmd, doc, p, modified.or_else(vectorcraft_doc::metadata::output_time))?;
// Measured before the pages' background colors join the art. Only art that prints counts:
// createLayers writes non-printing layers with /PrintState /OFF, so they count only with
// includeNonPrinting, which writes them as printing art.
let set = &opts.settings;
let short = if bleed_check { short_of_bleed(doc, set.bleed_of(doc), opts.artboards.as_deref(), set.include_non_printing) } else { 0 };
// The pages' background colors, behind the art (the editing data keeps them as colors).
let pages = opts.artboards.clone().unwrap_or_else(|| (0..doc.artboards.len()).collect());
let filled = super::export::with_artboard_fills(doc, p, pages).map_err(|e| bad(cmd, e))?;
@@ -401,6 +595,8 @@ fn encode_carrying_at(
if opts.settings.leaves_out_bleed(doc) {
notes.push(Note::loss(BLEED_LEFT_OUT));
}
// Art that reaches the trim edge but leaves part of the page's bleed empty.
notes.extend(short_of_bleed_warning(short).map(Note::loss));
if opts.settings.preserve_editing {
if opts.artboards.as_ref().is_none_or(|v| v.iter().copied().eq(0..doc.artboards.len())) {
opts.native = Some(native()?);
+44 -6
View File
@@ -629,6 +629,24 @@ impl<W: std::io::Write> std::io::Write for Counted<W> {
}
}
/// A writer that fails once the work running on this thread is canceled
/// ([`crate::cancel::is_cancelled`]), so a streamed save stops writing into its temporary file.
/// It sits under the stream's buffer: it is checked once per buffer written, not per write.
struct StopsWhenCancelled<W>(W);
impl<W: std::io::Write> std::io::Write for StopsWhenCancelled<W> {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
if crate::cancel::is_cancelled() {
return Err(std::io::Error::other(crate::cancel::Cancelled));
}
self.0.write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
self.0.flush()
}
}
/// The artboards a native or `.ai` save also writes to files of their own: with
/// `separateArtboards`, those `range` names (default all).
fn separate_boards(cmd: &str, f: &Format, doc: &Document, p: &Value) -> Result<Vec<usize>> {
@@ -1026,10 +1044,15 @@ impl SaveJob {
}
/// [`SaveJob::write`], once `stop` has seen the paths of every file it writes to a path, in
/// order: when `stop` returns a value, nothing is written and that value is returned.
/// order: when `stop` returns a value, nothing is written and that value is returned. Work
/// canceled ([`crate::cancel`]) before the first file is written returns
/// [`crate::EngineError::Cancelled`] and writes nothing; once the first file is written, the
/// others are written too.
pub fn write_unless(&self, stop: impl FnOnce(&[&str]) -> Option<Value>, mut write: impl FnMut(&str, &[u8]) -> Result<()>) -> Result<Value> {
let (plan, doc) = (&self.plan, &*self.doc);
crate::cancel::check()?;
let enc = self.encode()?;
crate::cancel::check()?;
let extra = json!({ "format": plan.format.id, "warnings": enc.notes() });
let Some(path) = &plan.path else {
let mut out = write_encoded(None, &plan.name, doc, &enc, extra)?;
@@ -1046,8 +1069,13 @@ impl SaveJob {
if let Some(stopped) = stop(&files.iter().map(|(p, _)| p.as_str()).collect::<Vec<_>>()) {
return Ok(stopped);
}
for (p, bytes) in &files {
write(p, bytes)?;
for (i, (p, bytes)) in files.iter().enumerate() {
if i == 0 {
write(p, bytes)?;
} else {
// Once a file is in place, a Cancel no longer stops the save: the set is written whole.
crate::cancel::scope(&crate::cancel::CancelToken::new(), None, || write(p, bytes))?;
}
}
let bytes = files.first().map_or(0, |f| f.1.len());
let mut out = super::merge(json!({ "path": path, "bytes": bytes }), extra);
@@ -1070,11 +1098,15 @@ impl SaveJob {
/// [`SaveJob::write`] through `stream`, which writes the file at a path with what the filler
/// it is given writes (atomically, as [`vectorcraft_format::write_atomic_with`]). A native
/// file goes into it as it is encoded ([`SaveJob::streams`]), never held whole in memory;
/// other files are encoded first, then written into it.
/// other files are encoded first, then written into it. Work canceled ([`crate::cancel`])
/// while the native file is encoded, or before its filler returns, returns
/// [`crate::EngineError::Cancelled`]: the filler fails, so `stream` keeps the file as it was
/// (the atomic writer checks once more before it puts the file in place).
pub fn write_streamed(&self, stream: StreamWrite) -> Result<Value> {
let (Some(path), true) = (&self.plan.path, self.streams()) else {
return self.write(|p, b| stream(p, &mut |w| w.write_all(b)));
};
crate::cancel::check()?;
let (cmd, f) = (self.plan.mode.command(), self.plan.format);
let doc = self.doc.without_edit_modes();
let doc = match f.id {
@@ -1091,16 +1123,22 @@ impl SaveJob {
let mut failed = None;
let mut written = 0u64;
let mut fill = |w: &mut dyn std::io::Write| {
let mut out = Counted { inner: std::io::BufWriter::with_capacity(STREAM_BUFFER, w), n: 0 };
let mut out = Counted { inner: std::io::BufWriter::with_capacity(STREAM_BUFFER, StopsWhenCancelled(w)), n: 0 };
let r = super::native::encode_to(cmd, f, &doc, &self.params, &mut out);
written = out.n;
match r {
let r = match r {
Ok(()) => out.inner.flush(),
Err(e) => {
failed = Some(e);
Err(std::io::Error::other("the file couldn't be encoded"))
}
};
// The last check before the file is replaced: a canceled save leaves it as it was.
if crate::cancel::is_cancelled() {
failed = Some(crate::EngineError::Cancelled);
return Err(std::io::Error::other(crate::cancel::Cancelled));
}
r
};
let r = stream(path, &mut fill);
r.map_err(|e| failed.take().unwrap_or(e))?;
+5 -1
View File
@@ -1349,10 +1349,14 @@ fn encode_and_write(export: ScreenExport, writer: &mut dyn FnMut(&str, &[u8]) ->
}
// The document a PDF row writes: with Include Bleed, the artboards as they are.
let pdf_doc = ungrown.as_deref();
// A PDF page of an artboard has the artboard as its trim, with or without Include Bleed. A
// page of its art's bounds has every object at its edge: it doesn't say whether art stops
// short of the bleed.
let artboard_page = o.assets.is_none() && o.layers.is_none() && o.selection.is_none();
let mut write = |doc: &Document, format: &str, options: &Value| -> Result<Vec<u8>> {
// The steps are the files: an encoder's own steps (artboards, pages) are not reported.
let (bytes, given) = vectorcraft_doc::cancel::quiet(|| encode_with_notes(doc, format, options))?;
for n in given {
for n in given.into_iter().filter(|n| artboard_page || !super::pdf::is_short_of_bleed(&n.text)) {
add_note(&mut notes, n);
}
Ok(bytes)
+103
View File
@@ -935,6 +935,109 @@ fn a_save_that_fails_while_streaming_leaves_the_file_as_it_was() {
let _ = std::fs::remove_dir_all(&d);
}
/// A save canceled (Background Save's Cancel) before it starts, while a native file streams into
/// its temporary file, or after the last byte went into it, fails with `Cancelled` and leaves the
/// file as it was, with no temporary file behind. A file encoded first is never written.
#[test]
fn a_canceled_save_leaves_the_file_as_it_was() {
/// Passes every write on, and cancels the save after the first one.
struct CancelAfterFirst<'a> {
inner: &'a mut dyn std::io::Write,
token: crate::cancel::CancelToken,
}
impl std::io::Write for CancelAfterFirst<'_> {
fn write(&mut self, b: &[u8]) -> std::io::Result<usize> {
let n = self.inner.write(b)?;
self.token.cancel();
Ok(n)
}
fn flush(&mut self) -> std::io::Result<()> {
self.inner.flush()
}
}
let d = tmp_dir("stream-cancel");
// A small document's file goes in one piece; a large one's in several.
for count in [1, 1500] {
let mut s = session(2000.0, 2000.0, 1);
for i in 0..count {
s.execute("shape.rectangle", &json!({"x": i % 100 * 20, "y": i / 100 * 20, "width": 10, "height": 10})).unwrap();
}
let path = d.join("a.vectorcraft").to_string_lossy().to_string();
s.execute("file.saveCopy", &json!({"path": path})).unwrap();
let before = std::fs::read(&path).unwrap();
s.execute("shape.ellipse", &json!({"x": 0, "y": 0, "width": 50, "height": 50})).unwrap();
let plan = save_plan(&s, SaveMode::Copy, &json!({"path": path})).unwrap();
let job = save_job(&mut s, plan).unwrap();
assert!(job.streams());
let token = crate::cancel::CancelToken::new();
let r = crate::cancel::scope(&token, None, || {
job.write_streamed(&mut |p, fill| super::write_file_with(p, &mut |w| fill(&mut CancelAfterFirst { inner: w, token: token.clone() })))
});
assert!(matches!(r, Err(EngineError::Cancelled)), "{count}: {r:?}");
assert_eq!(std::fs::read(&path).unwrap(), before, "{count} objects");
assert_eq!(std::fs::read_dir(&d).unwrap().count(), 1, "no temporary file is left");
// Canceled before it starts: the file isn't opened.
let mut opened = false;
let r = crate::cancel::scope(&token, None, || {
job.write_streamed(&mut |_, _| {
opened = true;
Ok(())
})
});
assert!(matches!(r, Err(EngineError::Cancelled)) && !opened, "{r:?}");
}
// A file encoded first (SVG): nothing reaches the writer.
let mut s = session(200.0, 100.0, 1);
s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
let plan = save_plan(&s, SaveMode::Copy, &json!({"path": d.join("a.svg").to_string_lossy()})).unwrap();
let job = save_job(&mut s, plan).unwrap();
let token = crate::cancel::CancelToken::new();
token.cancel();
let mut writes = 0;
let r = crate::cancel::scope(&token, None, || {
job.write_streamed(&mut |_, _| {
writes += 1;
Ok(())
})
});
assert!(matches!(r, Err(EngineError::Cancelled)), "{r:?}");
let r = crate::cancel::scope(&token, None, || {
job.write(|_, _| {
writes += 1;
Ok(())
})
});
assert!(matches!(r, Err(EngineError::Cancelled)) && writes == 0, "{r:?}");
assert!(!d.join("a.svg").exists());
let _ = std::fs::remove_dir_all(&d);
}
/// A save that writes several files (EPS with Use Artboards) and is canceled once its first file is
/// in place writes the others too and succeeds: the set is never left half written.
#[test]
fn a_save_canceled_after_its_first_file_writes_them_all() {
let d = tmp_dir("cancel-files");
let mut s = session(100.0, 100.0, 2);
s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 30, "height": 30})).unwrap();
let path = d.join("logo.eps").to_string_lossy().to_string();
let plan = save_plan(&s, SaveMode::Copy, &json!({"path": path, "options": {"useArtboards": true}})).unwrap();
let job = save_job(&mut s, plan).unwrap();
let token = crate::cancel::CancelToken::new();
let mut written = vec![];
let r = crate::cancel::scope(&token, None, || {
job.write(|p, b| {
super::write_save_file(p, b)?;
written.push(p.to_string());
token.cancel();
Ok(())
})
});
assert!(r.is_ok(), "{r:?}");
assert_eq!(written.len(), 3, "{written:?}");
assert!(written.iter().all(|p| std::path::Path::new(p).is_file()), "{written:?}");
let _ = std::fs::remove_dir_all(&d);
}
/// A save that fails leaves File Info's dates and the saved state alone; one that works stamps them.
#[test]
fn a_failed_save_does_not_stamp_the_documents_dates() {
@@ -95,6 +95,65 @@ fn raster_effects_are_written_as_images() {
assert!(kinds.contains(&114), "the shadow is an image with transparency");
}
/// An export refused for an empty or non-finite artboard among the chosen ones, or for no
/// artboard, gives the same error as before and turns no raster effect into an image; an export
/// that goes ahead does so once, and writes what `document.export` writes.
#[test]
fn a_refused_export_turns_no_raster_effects_into_images() {
use vectorcraft_geom::Rect;
use vectorcraft_metafile::Kind;
let mut s = two_boards();
let id = s.execute("shape.rectangle", &json!({"x": 50, "y": 50, "width": 30, "height": 30})).unwrap()["id"].clone();
s.execute("effect.apply", &json!({"effect": "stylize.dropShadow", "ids": [id]})).unwrap();
let doc = s.doc().unwrap().doc.as_ref().clone();
let run = |doc: &vectorcraft_doc::Document, p: Value, kind: Kind| {
let mut calls = 0;
let r = super::metafile::encode_flattening(doc, &p, Some(true), kind, |d| {
calls += 1;
crate::flatten_raster_effects(d)
});
(r.map(|e| e.files).map_err(|e| e.to_string()), calls)
};
for kind in [Kind::Emf, Kind::Wmf] {
let (files, calls) = run(&doc, json!({}), kind);
assert_eq!(calls, 1, "{kind:?}");
let files = files.unwrap();
assert_eq!(files.len(), 2, "{kind:?}");
let r = s.execute("document.export", &json!({"format": kind.id(), "useArtboards": true})).unwrap();
let written: Vec<Vec<u8>> = r["files"].as_array().unwrap().iter().map(b64).collect();
assert_eq!(files.into_iter().map(|(_, b)| b).collect::<Vec<_>>(), written, "{kind:?}");
// The first artboard is fine; the second is empty, or has a corner that isn't finite.
let x = doc.artboards[0].rect.x1 + 10.0;
for empty in [Rect::new(x, 0.0, x, 100.0), Rect::new(0.0, 0.0, f64::NAN, 100.0), Rect::new(0.0, 0.0, 100.0, f64::INFINITY)] {
let mut bad_doc = doc.clone();
bad_doc.artboards[1].rect = empty;
for p in [json!({}), json!({"artboards": [0, 1]}), json!({"artboards": [1]})] {
let (files, calls) = run(&bad_doc, p.clone(), kind);
let e = files.err().unwrap_or_default();
assert!(e.contains("the export region is empty"), "{kind:?} {p}: {e}");
assert_eq!(calls, 0, "{kind:?} {p}");
}
}
// Reversed corners are an artboard like any other.
let mut flipped = doc.clone();
let r1 = flipped.artboards[1].rect;
flipped.artboards[1].rect = Rect::new(r1.x1, r1.y1, r1.x0, r1.y0);
let (files, calls) = run(&flipped, json!({}), kind);
assert_eq!((files.map(|f| f.len()), calls), (Ok(2), 1), "{kind:?}");
// No artboard to write.
let mut none = doc.clone();
none.artboards.clear();
let (files, calls) = run(&none, json!({}), kind);
let e = files.err().unwrap_or_default();
assert!(e.contains("the document has no artboard"), "{kind:?}: {e}");
assert_eq!(calls, 0, "{kind:?}");
}
// Through the command, the refusal reads as it did.
std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).artboards[1].rect = Rect::new(0.0, 0.0, 0.0, 100.0);
let e = s.execute("document.export", &json!({"format": "emf", "useArtboards": true})).unwrap_err().to_string();
assert!(e.contains("the export region is empty"), "{e}");
}
/// Two placed images whose pixel data can't be decoded are left out of an EMF or WMF, and
/// `warnings` holds the note raster exports give, once, without naming either image's key.
#[test]
+220
View File
@@ -171,6 +171,226 @@ fn a_pdfx_file_that_leaves_out_the_document_bleed_warns() {
assert!(!left_out(&warnings), "{warnings:?}");
}
/// A 200 × 100 pt document with no art, bleed `bleed` (pt).
fn bleed_session(bleed: Value) -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
s.execute("document.setup", &json!({ "bleed": bleed })).unwrap();
s
}
/// A rectangle from (x0, y0) to (x1, y1) without a stroke, on the current layer.
fn plain_rect(s: &mut Session, [x0, y0, x1, y1]: [f64; 4]) -> Value {
let id = s.execute("shape.rectangle", &json!({"x": x0, "y": y0, "width": x1 - x0, "height": y1 - y0})).unwrap()["id"].clone();
s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap();
id
}
/// The warnings of a PDF that carries the document's bleed that say art stops short of it.
fn short_of_bleed(s: &mut Session) -> Vec<String> {
let (_, warnings) = pdf(s, json!({"bleed": {"useDocument": true}}));
warnings.into_iter().filter(|w| super::pdf::is_short_of_bleed(w)).collect()
}
const MM: f64 = 72.0 / 25.4;
/// A bleed raised from 2 mm to 5 mm leaves a background that filled the old bleed, and a band
/// placed against the trim edge, short of the new one: the export warns once, counting both.
#[test]
fn art_that_reaches_the_trim_edge_but_stops_short_of_the_bleed_warns() {
let mut s = bleed_session(json!(2.0 * MM));
let (b, w, h) = (2.0 * MM, 200.0, 100.0);
plain_rect(&mut s, [-b, -b, w + b, h + b]);
plain_rect(&mut s, [0.0, 0.0, w, 20.0]);
// At 2 mm the background reaches the bleed; the band stops at the trim edge.
assert_eq!(short_of_bleed(&mut s), ["1 object reaches the trim edge but stops short of the bleed"]);
s.execute("document.setup", &json!({"bleed": 5.0 * MM})).unwrap();
assert_eq!(short_of_bleed(&mut s), ["2 objects reach the trim edge but stop short of the bleed"]);
// The PDF/X presets carry the document's bleed.
let (_, warnings) = pdf(&mut s, json!({"preset": "PDF/X-4:2010"}));
assert!(warnings.iter().any(|w| super::pdf::is_short_of_bleed(w)), "{warnings:?}");
// A PDF/X file with a bleed on the top alone leaves out the rest of the document's bleed, and
// the background and the band stop short at the top: the warning comes right after
// BLEED_LEFT_OUT.
let (_, warnings) = pdf(&mut s, json!({"standard": "pdfX4", "bleed": {"top": 9}}));
assert_eq!(warnings.first().map(String::as_str), Some(super::pdf::BLEED_LEFT_OUT), "{warnings:?}");
assert_eq!(warnings.get(1).map(String::as_str), Some("2 objects reach the trim edge but stop short of the bleed"), "{warnings:?}");
// A page without the bleed (the default preset) doesn't warn, and neither does a page of the art's bounds.
let (_, warnings) = pdf(&mut s, json!({}));
assert!(!warnings.iter().any(|w| super::pdf::is_short_of_bleed(w)), "{warnings:?}");
let (_, warnings) = pdf(&mut s, json!({"bleed": {"useDocument": true}, "useArtboards": false}));
assert!(!warnings.iter().any(|w| super::pdf::is_short_of_bleed(w)), "{warnings:?}");
// An explicit bleed counts too, and the Summary lists the warning.
let (_, warnings) = pdf(&mut s, json!({"bleed": {"top": 9, "bottom": 9, "left": 9, "right": 9}}));
assert!(warnings.iter().any(|w| super::pdf::is_short_of_bleed(w)), "{warnings:?}");
let v = s.execute("document.pdfSettings", &json!({"bleed": {"useDocument": true}, "includeDocument": true})).unwrap();
assert!(v["warnings"].as_array().unwrap().iter().any(|w| super::pdf::is_short_of_bleed(w.as_str().unwrap())), "{v}");
// A group counts once, measured by its visible members: a hidden member that fills the bleed
// doesn't hide a visible one at the trim edge.
let mut s = bleed_session(json!(9));
let fill = plain_rect(&mut s, [-9.0, -9.0, 209.0, 109.0]);
let band = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
let side = plain_rect(&mut s, [0.0, 40.0, 20.0, 60.0]);
s.execute("object.group", &json!({"ids": [fill, band, side]})).unwrap();
s.execute("object.hide", &json!({"ids": [fill]})).unwrap();
assert_eq!(short_of_bleed(&mut s), ["1 object reaches the trim edge but stops short of the bleed"]);
// A clip group is measured by the art inside its clipping path, not by a clipping path that
// reaches the bleed edge.
let mut s = bleed_session(json!(9));
let art = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
let clip = plain_rect(&mut s, [-9.0, -9.0, 209.0, 109.0]);
s.execute("select.set", &json!({"ids": [art, clip]})).unwrap();
s.execute("object.clippingMask.make", &json!({})).unwrap();
assert_eq!(short_of_bleed(&mut s).len(), 1);
// A clipping path that paints a fill reaching the trim edge counts, though the art it clips is
// inside: in a clip group, and as an object of its own in a clipping layer.
let mut s = bleed_session(json!(9));
let art = plain_rect(&mut s, [20.0, 30.0, 60.0, 60.0]);
let clip = plain_rect(&mut s, [0.0, 0.0, 200.0, 100.0]);
s.execute("select.set", &json!({"ids": [art, clip]})).unwrap();
s.execute("object.clippingMask.make", &json!({})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
s.execute("paint.setFill", &json!({"ids": [clip], "color": "#ff0000"})).unwrap();
assert_eq!(short_of_bleed(&mut s).len(), 1);
let mut s = bleed_session(json!(9));
let clipping = s.execute("layer.new", &json!({})).unwrap()["id"].clone();
plain_rect(&mut s, [20.0, 30.0, 60.0, 60.0]);
let clip = plain_rect(&mut s, [0.0, 0.0, 200.0, 100.0]);
s.execute("layer.clippingMask.toggle", &json!({"id": clipping})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
s.execute("paint.setFill", &json!({"ids": [clip], "color": "#ff0000"})).unwrap();
assert_eq!(short_of_bleed(&mut s).len(), 1);
// A hidden brushed member doesn't keep a group's visible art at the trim edge from counting.
let mut s = bleed_session(json!(9));
let brushed = plain_rect(&mut s, [-9.0, -9.0, 209.0, 109.0]);
s.execute("brush.apply", &json!({"ids": [brushed], "name": "Charcoal"})).unwrap();
let band = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
s.execute("object.group", &json!({"ids": [brushed, band]})).unwrap();
s.execute("object.hide", &json!({"ids": [brushed]})).unwrap();
assert_eq!(short_of_bleed(&mut s).len(), 1);
// A clipping layer clips its art to the clipping path's geometry, not to the stroke around it:
// the stroke reaches the trim edge, but the art it clips stops 5 pt inside.
let mut s = bleed_session(json!(9));
let clipping = s.execute("layer.new", &json!({})).unwrap()["id"].clone();
plain_rect(&mut s, [-9.0, -9.0, 209.0, 109.0]);
let clip = plain_rect(&mut s, [5.0, 5.0, 195.0, 95.0]);
s.execute("layer.clippingMask.toggle", &json!({"id": clipping})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [clip], "color": "#ff0000"})).unwrap();
s.execute("stroke.set", &json!({"ids": [clip], "weight": 10})).unwrap();
assert_eq!(short_of_bleed(&mut s), ["1 object reaches the trim edge but stops short of the bleed"]);
}
/// No warning for art that already fills the bleed, art inside the trim, a document without a
/// bleed, art on hidden, non-printing or template layers, a side without a bleed, area type, a
/// masked object, or a `.ai` save.
#[test]
fn art_that_fills_the_bleed_or_stays_inside_does_not_warn() {
let mut s = bleed_session(json!(9));
plain_rect(&mut s, [-9.0, -9.0, 209.0, 109.0]);
plain_rect(&mut s, [-20.0, 40.0, 50.0, 60.0]);
plain_rect(&mut s, [10.0, 10.0, 190.0, 90.0]);
assert!(short_of_bleed(&mut s).is_empty());
// A document without a bleed has nothing to fall short of.
let mut s = bleed_session(json!(0));
plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
assert!(short_of_bleed(&mut s).is_empty());
// Layers that don't print.
for props in [json!({"visible": false}), json!({"printable": false}), json!({"template": true})] {
let mut s = bleed_session(json!(9));
let layer = s.execute("layer.new", &json!({})).unwrap()["id"].clone();
plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
let mut p = props.clone();
p["id"] = layer;
s.execute("layer.setProps", &p).unwrap();
assert!(short_of_bleed(&mut s).is_empty(), "{props}");
}
// A hidden object, and a group whose hidden member is the one at the trim edge.
let mut s = bleed_session(json!(9));
let id = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
s.execute("object.hide", &json!({"ids": [id]})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
let mut s = bleed_session(json!(9));
let edge = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
let inside = plain_rect(&mut s, [10.0, 30.0, 50.0, 60.0]);
s.execute("object.group", &json!({"ids": [edge, inside]})).unwrap();
s.execute("object.hide", &json!({"ids": [edge]})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// Art that lies in the bleed alone, away from the trim edge.
let mut s = bleed_session(json!(9));
plain_rect(&mut s, [20.0, -5.0, 60.0, -3.0]);
assert!(short_of_bleed(&mut s).is_empty());
// A guide in a group at the trim edge.
let mut s = bleed_session(json!(9));
let guide = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
s.execute("view.guides.make", &json!({})).unwrap();
let inside = plain_rect(&mut s, [10.0, 30.0, 50.0, 60.0]);
s.execute("object.group", &json!({"ids": [guide, inside]})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// A brushed stroke, whose brush art can paint past its visual bounds, is not measured.
let mut s = bleed_session(json!(9));
let id = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
s.execute("brush.apply", &json!({"ids": [id], "name": "Charcoal"})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// A path with no fill and no stroke paints nothing.
let mut s = bleed_session(json!(9));
let id = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
s.execute("paint.setFill", &json!({"ids": [id], "none": true})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// An object at 0% opacity draws nothing.
let mut s = bleed_session(json!(9));
let id = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
s.execute("object.setProps", &json!({"ids": [id], "opacity": 0})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// A clipping layer whose clipping path lies inside the trim draws none of its art at the edge.
let mut s = bleed_session(json!(9));
let clipping = s.execute("layer.new", &json!({})).unwrap()["id"].clone();
plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
plain_rect(&mut s, [10.0, 10.0, 60.0, 60.0]);
s.execute("layer.clippingMask.toggle", &json!({"id": clipping})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// A bleed on the top alone: art short at the left doesn't count, art short at the top does.
let mut s = bleed_session(json!([9, 0, 0, 0]));
plain_rect(&mut s, [0.0, 30.0, 40.0, 60.0]);
assert!(short_of_bleed(&mut s).is_empty());
plain_rect(&mut s, [60.0, 0.0, 100.0, 40.0]);
assert_eq!(short_of_bleed(&mut s).len(), 1);
// Area type is bounded by its frame, not its glyphs: a frame at the trim edge is not measured.
let mut s = bleed_session(json!(9));
s.execute("text.create", &json!({"x": 0, "y": 0, "text": "Title", "size": 12, "area": {"width": 200, "height": 40}})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// An opacity mask decides what shows of the object, so a masked object is not measured.
let mut s = bleed_session(json!(9));
let band = plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
let mask = plain_rect(&mut s, [20.0, 30.0, 60.0, 60.0]);
s.execute("transparency.makeOpacityMask", &json!({"ids": [band, mask]})).unwrap();
assert!(short_of_bleed(&mut s).is_empty());
// A `.ai` save with a bleed doesn't warn: the check is PDF export's.
let mut s = bleed_session(json!(9));
plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
assert_eq!(short_of_bleed(&mut s).len(), 1);
let r = s.execute("document.export", &json!({"format": "ai", "bleed": {"useDocument": true}})).unwrap();
assert!(!r["warnings"].to_string().contains("short of the bleed"), "{}", r["warnings"]);
}
/// The warning changes neither the art nor the page boxes.
#[test]
fn the_bleed_warning_changes_no_geometry_and_no_page_box() {
let mut s = bleed_session(json!(9));
plain_rect(&mut s, [0.0, 0.0, 200.0, 20.0]);
let before = s.doc().unwrap().doc.clone();
let v = s.execute("document.exportPdf", &json!({"bleed": {"useDocument": true}})).unwrap();
assert!(v["warnings"].as_array().unwrap().iter().any(|w| super::pdf::is_short_of_bleed(w.as_str().unwrap())), "{v}");
assert_eq!(s.doc().unwrap().doc, before);
let info = s.execute("document.pdfInfo", &json!({"name": "x.pdf", "dataBase64": v["dataBase64"]})).unwrap();
let boxes = &info["pageInfo"][0]["boxes"];
let side = |b: &Value| {
let n: Vec<f64> = b.as_array().unwrap().iter().map(|x| x.as_f64().unwrap()).collect();
(((n[2] - n[0]) * 100.0).round() / 100.0, ((n[3] - n[1]) * 100.0).round() / 100.0)
};
assert_eq!(side(&boxes["trim"]), (200.0, 100.0), "{info}");
assert_eq!(side(&boxes["bleed"]), (218.0, 118.0), "{info}");
}
/// The ink amounts (0..1) `doc` shows at `p` in its images (the topmost image there).
fn image_inks_at(doc: &vectorcraft_doc::Document, p: vectorcraft_geom::Point) -> Option<[f32; 4]> {
fn visit(n: &vectorcraft_doc::Node, out: &mut Vec<vectorcraft_doc::ImageObject>) {
@@ -602,6 +602,56 @@ fn relink_and_update_follow_the_clipping_path_of_a_linked_psd() {
assert_eq!(clip_group(&s.doc().unwrap().doc, group), (squared, true, NodeId(image)), "links.update reads the clipping path again");
}
/// Unembed keeps the clip group of the clipping path an embedded PSD file's image came with, with a
/// path and with a folder, and so do relinking to the written file, placing it and opening it.
#[test]
fn unembed_keeps_the_clipping_path_of_an_embedded_psd() {
let dir = vectorcraft_testkit::TempDir::new("psd-unembed-clip");
// An RGB file is kept as a PNG, a CMYK one as a TIFF.
let cmyk = psd(1, 4, (100, 50), 8, 4, &[], &triangle_resources(), &[], &raw(&[&[0; 5000], &[255; 5000], &[255; 5000], &[0; 5000]]));
let files = [("rgb", red_psd(&triangle_resources())), ("cmyk", cmyk)];
for ((kind, file), folder) in files.iter().flat_map(|f| [(f, false), (f, true)]) {
let data = vectorcraft_format::base64_encode(file);
let mut s = Session::new();
s.execute("file.new", &json!({"width": 100, "height": 50})).unwrap();
let r = s.execute("file.place", &json!({"name": "cut.psd", "dataBase64": data, "at": [50, 25]})).unwrap();
let (group, image) = (NodeId(r["ids"][0].as_u64().unwrap()), NodeId(r["image"].as_u64().unwrap()));
let before = clip_group(&s.doc().unwrap().doc, group);
// Without an extension the image is written in the format it is stored in.
let path = if folder {
let out = dir.join(format!("folder-{kind}"));
std::fs::create_dir_all(&out).unwrap();
let r = s.execute("links.unembed", &json!({"ids": [image.0], "folder": out})).unwrap();
r["unembedded"][0]["path"].as_str().unwrap().to_string()
} else {
let r = s.execute("links.unembed", &json!({"id": image.0, "path": dir.join(format!("written-{kind}"))})).unwrap();
r["path"].as_str().unwrap().to_string()
};
let ext = if *kind == "rgb" { ["png"].as_slice() } else { ["tif", "tiff"].as_slice() };
assert!(ext.contains(&super::extension(&path).as_str()), "{kind}: {path}");
for step in ["unembed", "relink"] {
if step == "relink" {
s.execute("links.relink", &json!({"ids": [image.0], "path": path})).unwrap();
}
let d = &s.doc().unwrap().doc;
let NodeKind::Image(im) = &d.node(image).unwrap().kind else { panic!("an image") };
assert!(im.link.is_some(), "linked to the file written");
assert_eq!(clip_group(d, group), before, "{kind}, {step}, folder: {folder}");
}
// Placing the written file gives the same clip group as placing the PSD file did.
let r = s.execute("file.place", &json!({"path": path, "at": [50, 25]})).unwrap();
let placed = NodeId(r["ids"][0].as_u64().unwrap());
let (anchors, even_odd, _) = clip_group(&s.doc().unwrap().doc, placed);
assert_eq!((anchors, even_odd), (before.0.clone(), true), "{kind}, place");
// Opening it gives a document of the image in that clip group.
s.execute("document.open", &json!({"path": path})).unwrap();
let d = &s.doc().unwrap().doc;
let top = d.layers[0].children().and_then(|c| c.first()).map(|c| c.id).expect("an object");
let (anchors, even_odd, _) = clip_group(d, top);
assert_eq!((anchors, even_odd), (before.0.clone(), true), "{kind}, open");
}
}
/// The PNG a PSD file's merged image is kept as holds the clipping path the file names, and only a
/// text chunk within the size limit that reads as a path gives one back.
#[test]
@@ -610,6 +610,35 @@ fn include_bleed_pdfx_rows_do_not_warn_about_the_bleed() {
assert!(warned(&export(&mut s, json!({"includeBleed": true, "selection": "one", "formats": row}))));
}
/// A PDF row with a bleed warns about art that reaches an artboard's edge and stops short of the
/// bleed, with or without Include Bleed: the page's trim is the artboard either way. It doesn't
/// warn about art that reaches the bleed, or on a page of a selection's bounds.
#[test]
fn pdf_rows_warn_about_art_short_of_the_bleed_on_artboard_pages_only() {
let warned = |r: &Value| r["warnings"].as_array().unwrap().iter().any(|w| super::pdf::is_short_of_bleed(w.as_str().unwrap()));
let row = json!([{"format": "pdf", "bleed": {"useDocument": true}}]);
let mut s = session(1);
s.execute("document.setup", &json!({"bleed": 6})).unwrap();
// Against the artboard's top edge.
s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 40, "height": 10})).unwrap();
assert!(warned(&export(&mut s, json!({"formats": row}))));
assert!(warned(&export(&mut s, json!({"includeBleed": true, "formats": row}))));
assert!(warned(&export(&mut s, json!({"includeBleed": true, "formats": [{"format": "pdf"}]}))), "the row takes the document's bleed");
assert!(!warned(&export(&mut s, json!({"selection": "one", "formats": row}))));
assert!(!warned(&export(&mut s, json!({"includeBleed": true, "selection": "one", "formats": row}))));
// Out to the bleed edge on the top, left and right.
let mut s = session(1);
s.execute("document.setup", &json!({"bleed": 6})).unwrap();
s.execute("shape.rectangle", &json!({"x": -6, "y": -6, "width": 52, "height": 16})).unwrap();
assert!(!warned(&export(&mut s, json!({"formats": row}))));
assert!(!warned(&export(&mut s, json!({"includeBleed": true, "formats": row}))));
// Without a document bleed, a row's own bleed warns.
let mut s = session(1);
s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 40, "height": 10})).unwrap();
let row = json!([{"format": "pdf", "bleed": {"top": 6, "bottom": 6, "left": 6, "right": 6}}]);
assert!(warned(&export(&mut s, json!({"includeBleed": true, "formats": row}))));
}
/// Each `[x0 y0 x1 y1]` that follows `key` in a PDF's bytes, in the order the file has them, read
/// as text without VectorCraft's PDF reader (PDF 32000-1:2008, 14.11.2, Page Boundaries).
fn raw_boxes(pdf: &[u8], key: &str) -> Vec<[f64; 4]> {
+246
View File
@@ -0,0 +1,246 @@
//! Flares (the Flare tool): `shape.flare` draws a group of radial-gradient paths that keeps the
//! settings it was drawn with ([`FlareSpec`]), and `shape.editFlare` draws it again from them.
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_doc::flare::{DEFAULT_SEED, FlareSpec, json_close, part_node, parts};
use vectorcraft_doc::{Document, Node, NodeId};
use vectorcraft_geom::{Affine, Point, Vec2};
use super::{EngineError, Result, Session, bad, check_numbers, f64_or, f64_req, given_objects, number_or};
const C: &str = "shape.editFlare";
/// `shape.flare`'s settings besides the center, the rings' end point, the counts and the seed:
/// (key, default).
const SETTINGS: [(&str, f64); 9] = [
("diameter", 100.0),
("opacity", 50.0),
("brightness", 30.0),
("growth", 20.0),
("fuzziness", 50.0),
("longest", 300.0),
("rayFuzziness", 100.0),
("rotation", 0.0),
("largest", 50.0),
];
/// The whole number of 0 or more `p` gives for `key`, or `default`.
fn count_or(p: &Value, key: &str, default: u64, cmd: &str) -> Result<u64> {
let n = number_or(p, key, default as f64, cmd)?;
if n.is_finite() && n >= 0.0 && n.fract() == 0.0 {
Ok(n as u64)
} else {
Err(bad(cmd, format!("`{key}` must be a whole number of at least 0, not {n}")))
}
}
/// `end`, the rings' end point, or an error naming `x2` or `y2` when that coordinate is not a
/// finite number (a `pathLength` so large that the end point overflows).
fn finite_end(end: Point, cmd: &str) -> Result<Point> {
match [("x2", end.x), ("y2", end.y)].into_iter().find(|(_, v)| !v.is_finite()) {
None => Ok(end),
Some((key, _)) => Err(bad(cmd, format!("{key} must be a finite coordinate"))),
}
}
/// `shape.flare`'s params `p` with every setting given: the defaults filled in, the counts at most
/// 50 and the rings' end point as `x2`, `y2` (from `pathLength` and `direction` when `p` gives no
/// end point), with `ringSeed` when `p` gives one.
fn settings_of(p: &Value, cmd: &str) -> Result<Value> {
let c = Point::new(f64_req(p, "cx", cmd)?, f64_req(p, "cy", cmd)?);
let mut numbers: Vec<&str> = SETTINGS.iter().map(|(key, _)| *key).collect();
numbers.extend(["x2", "y2", "direction", "pathLength", "seed", "ringSeed"]);
check_numbers(p, &numbers, cmd)?;
let seed_of = |key: &str| match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(v) => v.as_u64().map(Some).ok_or_else(|| bad(cmd, format!("`{key}` must be a whole number of at least 0, not {v}"))),
};
let seed = seed_of("seed")?.unwrap_or(DEFAULT_SEED);
// Each `ringSeed` below 2^53 (what a JSON number holds exactly) places the rings anew.
let ring_seed = match seed_of("ringSeed")? {
Some(r) if r >= 1 << 53 => return Err(bad(cmd, format!("`ringSeed` must be below 2^53, not {r}"))),
r => r,
};
let rays = count_or(p, "rays", 15, cmd)?.min(50);
let rings = count_or(p, "rings", 10, cmd)?.min(50);
let end = match (p.get("x2").and_then(Value::as_f64), p.get("y2").and_then(Value::as_f64)) {
(Some(x), Some(y)) => Point::new(x, y),
_ => {
let a = f64_or(p, "direction", 45.0).to_radians();
finite_end(c + Vec2::new(a.cos(), -a.sin()) * f64_or(p, "pathLength", 300.0), cmd)?
}
};
let mut v = json!({ "cx": c.x, "cy": c.y, "x2": end.x, "y2": end.y, "rays": rays, "rings": rings, "seed": seed });
if let Some(r) = ring_seed {
v["ringSeed"] = json!(r);
}
for (key, default) in SETTINGS {
v[key] = json!(f64_or(p, key, default));
}
Ok(v)
}
/// The objects of a flare drawn with the settings `v`, transformed by `xf`. A new flare's parts
/// (`old` None) get new ids and take the document's Align New Objects to Pixel Grid. A flare drawn
/// again from its parts `old` keeps, for each part, the id and pixel-aligned property of the old
/// part it replaces (the same kind of part, counted in order: the second ring replaces the second
/// ring); a part that replaces none gets a new id and the first old part's property.
fn part_nodes(d: &mut Document, v: &Value, xf: Affine, old: Option<&[Arc<Node>]>) -> Vec<Arc<Node>> {
let mut seen: Vec<&str> = vec![];
parts(v)
.into_iter()
.map(|part| {
let name = part.0;
let nth = seen.iter().filter(|n| **n == name).count();
seen.push(name);
let replaced = old.and_then(|old| old.iter().filter(|c| c.name.as_deref() == Some(name)).nth(nth));
let id = replaced.map_or_else(|| d.alloc_id(), |c| c.id);
let mut n = part_node(id, part, Affine::IDENTITY, false);
match old {
None => super::object::align_new_object(d, &mut n),
Some(old) => n.extras_mut().pixel_aligned = replaced.or(old.first()).is_some_and(|c| c.extras().pixel_aligned),
}
if xf != Affine::IDENTITY {
n.transform(xf, false);
}
Arc::new(n)
})
.collect()
}
/// `shape.flare`: a flare group that keeps its settings.
pub(super) fn flare(s: &mut Session, p: &Value) -> Result<Value> {
let v = settings_of(p, "shape.flare")?;
let parent = s.doc()?.target_parent()?;
let id = s.edit("Flare", |d, sel| {
let children = part_nodes(d, &v, Affine::IDENTITY, None);
let gid = d.alloc_id();
let mut g = Node::group(gid, children);
g.name = Some("Flare".into());
g.extras_mut().flare = Some(Box::new(FlareSpec::new(v)));
d.insert(parent, usize::MAX, g)?;
sel.set([gid]);
Ok(gid)
})?;
Ok(json!({ "id": id.0 }))
}
/// The settings of flare `id`: a group drawn by the Flare tool whose parts are still the ones its
/// settings draw, in place ([`FlareSpec::draws`]). A flare whose parts were edited, distorted,
/// removed or added to, or whose art was flattened to a line, is no longer one.
pub fn flare_settings(d: &Document, id: NodeId) -> Option<FlareSpec> {
let n = d.node(id)?;
let spec = n.extras().flare.as_deref()?;
// Settings a file holds are read as `shape.flare` reads them.
let spec = FlareSpec { params: settings_of(&spec.params, "shape.flare").ok()?, transform: spec.transform };
spec.draws(n).then_some(spec)
}
/// The flares `shape.editFlare` changes: those `p` names, else the selected flares. Each must be a
/// flare that can be edited.
fn flares_to_edit(s: &Session, p: &Value) -> Result<Vec<(NodeId, FlareSpec)>> {
let given = given_objects(s, p, C)?;
let d = &s.doc()?.doc;
let flare = |id: NodeId| flare_settings(d, id).filter(|_| d.is_editable(id)).map(|spec| (id, spec));
let flares: Vec<(NodeId, FlareSpec)> = match &given {
Some(ids) => ids.iter().map(|id| flare(*id)).collect::<Option<Vec<_>>>().unwrap_or_default(),
None => s.doc()?.selection.objects.iter().filter_map(|id| flare(*id)).collect(),
};
if flares.is_empty() {
return Err(EngineError::Other("select a flare".into()));
}
Ok(flares)
}
/// The settings `old` changed as `p` asks (`shape.editFlare`'s params). The center and the end
/// point `p` gives are in the document, where the flare is now drawn, which `xf` maps from where
/// it was drawn.
fn edited(old: &Value, p: &Value, xf: Affine) -> Result<Value> {
let mut v = old.clone();
let inv = xf.inverse();
let point = |kx: &str, ky: &str| -> Result<Option<Point>> {
if p.get(kx).is_none_or(Value::is_null) && p.get(ky).is_none_or(Value::is_null) {
return Ok(None);
}
// A point that leaves the finite range where the flare was drawn is refused, not stored.
let q = inv * Point::new(f64_req(p, kx, C)?, f64_req(p, ky, C)?);
match [(kx, q.x), (ky, q.y)].into_iter().find(|(_, v)| !v.is_finite()) {
None => Ok(Some(q)),
Some((key, _)) => Err(bad(C, format!("{key} must be a finite coordinate"))),
}
};
let c = point("cx", "cy")?;
let end = point("x2", "y2")?;
if let Some(c) = c {
v["cx"] = json!(c.x);
v["cy"] = json!(c.y);
}
let centre = Point::new(f64_or(&v, "cx", 0.0), f64_or(&v, "cy", 0.0));
let old_end = Point::new(f64_or(&v, "x2", centre.x), f64_or(&v, "y2", centre.y));
let end = match end {
Some(e) => e,
None if p.get("pathLength").is_some_and(|l| !l.is_null()) || p.get("direction").is_some_and(|a| !a.is_null()) => {
// The path length and the direction are where the flare is drawn now; the direction is
// measured counter-clockwise from 3 o'clock, as `shape.flare` takes it.
let (c, e) = (xf * centre, xf * old_end);
let d = e - c;
let a = number_or(p, "direction", (-d.y).atan2(d.x).to_degrees(), C)?.to_radians();
finite_end(inv * (c + Vec2::new(a.cos(), -a.sin()) * number_or(p, "pathLength", d.hypot(), C)?), C)?
}
// Moving the center leaves the rings' end point where it is.
None => old_end,
};
v["x2"] = json!(end.x);
v["y2"] = json!(end.y);
for (key, _) in SETTINGS {
if p.get(key).is_some_and(|x| !x.is_null()) {
v[key] = json!(number_or(p, key, 0.0, C)?);
}
}
for key in ["rays", "rings"] {
if p.get(key).is_some_and(|x| !x.is_null()) {
v[key] = json!(count_or(p, key, 0, C)?.min(50));
}
}
settings_of(&v, C)
}
/// `shape.editFlare`: draw the flares again with the settings `p` changes, each in its place and
/// transformed as it has been since it was drawn, as one undo step.
pub(super) fn edit_flare(s: &mut Session, p: &Value) -> Result<Value> {
let mut numbers: Vec<&str> = SETTINGS.iter().map(|(key, _)| *key).collect();
numbers.extend(["cx", "cy", "x2", "y2", "pathLength", "direction", "rays", "rings"]);
check_numbers(p, &numbers, C)?;
let flares = flares_to_edit(s, p)?;
let mut changed: Vec<(NodeId, FlareSpec)> = vec![];
for (id, spec) in &flares {
let v = edited(&spec.params, p, spec.transform)?;
if !json_close(&v, &spec.params, 1e-9) {
changed.push((*id, FlareSpec { params: v, transform: spec.transform }));
}
}
let ids: Vec<u64> = flares.iter().map(|(id, _)| id.0).collect();
// Nothing changes: no undo step.
if changed.is_empty() {
return Ok(json!({ "ids": ids }));
}
let edited_ids: Vec<NodeId> = changed.iter().map(|(id, _)| *id).collect();
s.edit("Edit Flare", |d, _| {
for (id, spec) in changed {
let old: Vec<Arc<Node>> = d.node(id).and_then(Node::children).cloned().unwrap_or_default();
let children = part_nodes(d, &spec.params, spec.transform, Some(&old));
let n = d.node_mut(id).ok_or(EngineError::NoNode(id))?;
if let Some(ch) = n.children_mut() {
*ch = children;
}
n.extras_mut().flare = Some(Box::new(spec));
}
if !crate::sanity::objects_in_range(d, &edited_ids) {
return Err(EngineError::Other("result would exceed the canvas (coordinates out of range)".into()));
}
Ok(())
})?;
Ok(json!({ "ids": ids }))
}
+2 -19
View File
@@ -19,23 +19,6 @@ use crate::DocState;
const MAX_FONTS: usize = 1_000;
/// The longest family or style name listed or given (bytes).
const MAX_NAME: usize = 256;
/// The CSS generic font families (CSS Fonts Module Level 4), which SVG and HTML files name in place
/// of a font and no font file provides; compared in any ASCII case. The list leaves out
/// `fangsong`, which is also the family name of a Chinese font (FangSong).
const GENERIC_FAMILIES: &[&str] = &[
"serif",
"sans-serif",
"monospace",
"cursive",
"fantasy",
"system-ui",
"ui-serif",
"ui-sans-serif",
"ui-monospace",
"ui-rounded",
"math",
"emoji",
];
/// The longest folder path given (bytes).
const MAX_PATH: usize = 4096;
/// The most files one `text.addFontFiles` copies: as many as a search keeps.
@@ -105,10 +88,10 @@ pub struct MissingFont {
/// The fonts the type of `d` uses, in its layers, symbols and patterns, opacity masks included (a composite font's parts, those
/// its characters are drawn in, in place of its name), that aren't available as named (sorted by family and style, each once whatever version its type names; at most 1000). CSS generic families such as `sans-serif`
/// ([`GENERIC_FAMILIES`]) and names longer than 256 bytes are left out.
/// ([`vectorcraft_text::GENERIC_FAMILIES`]) and names longer than 256 bytes are left out.
pub fn missing_fonts(d: &Document) -> Vec<MissingFont> {
let db = FontDb::global();
let generic = |family: &str| GENERIC_FAMILIES.iter().any(|g| g.eq_ignore_ascii_case(family.trim()));
let generic = vectorcraft_text::is_generic_family;
let mut used: Vec<(String, String)> = super::fonts::used_fonts(d).into_iter().map(|(family, style, _)| (family, style)).collect();
// Sorted by family and style: the versions type names of one face are neighbors.
used.dedup();
+34 -7
View File
@@ -13,6 +13,7 @@ use serde_json::{Value, json};
use vectorcraft_doc::{Artboard, ArtboardSide, Document, LAYER_COLORS, LayerColor, Node, NodeId, NodeKind, Scaling};
use vectorcraft_geom::{Affine, Rect};
use super::buildcmds::LivePaintMove;
use super::{
CommandSpec, Result, Session, bad, bool_or, check_numbers, check_switches, checked_id, checked_ids_param, checked_node, checked_nodes_param, cmd,
color_value, f64_or, has_doc, has_selection, ids_param, index, object_param, ok, str_param, switch_or,
@@ -83,7 +84,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Layer Options…",
["Window", "Layers"],
None,
"{ids?|id? (default: the highlighted rows, else the current layer), name? (with prefs.identifyObjectsBy xmlId: a valid XML ID, stored as the object name), visible?, locked?, template?, printable?, preview?, dimImages?: 0..100|false, color?: index 0..26|\"#rrggbb\"|preset name (a hex color with an alpha part, #rrggbbaa or #rgba, is an error)} Layer Options; rows that are not layers take name, visible and locked, and `ids` may name ruler guides (their `guide.list` id), which hide or lock on their own. Template on also locks the layer and dims its images to 50% (unless given); off unlocks it and stops dimming. One undo step",
"{ids?|id? (default: the highlighted rows, else the current layer), name? (with prefs.identifyObjectsBy xmlId: a valid XML ID, stored as the object name), visible?, locked?, template?, printable?, preview?, dimImages?: 0..100|false, color?: index 0..26|\"#rrggbb\"|preset name (a hex color with an alpha part, #rrggbbaa or #rgba, is an error)} Layer Options; rows that are not layers take name, visible and locked, and `ids` may name ruler guides (their `guide.list` id), which hide or lock on their own. Template on also locks the layer and dims its images to 50% (unless given); off unlocks it and stops dimming. A path directly in a Live Paint group can't take the name Face or Edge, which name the group's faces and edges, unless it has it already. One undo step",
has_doc,
set_props
),
@@ -110,7 +111,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Rows",
[],
None,
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies, which may also go above or below a row they copy (the target among `ids`). Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies, which may also go above or below a row they copy (the target among `ids`). A row that goes into a Live Paint group from elsewhere joins its paths as livePaint.merge adds them, and the group is selected (paths, compound paths, groups of them and Live Paint groups; anything else is refused and nothing moves); a row that goes into or leaves a Live Paint group's paths makes the group's faces and edges again, keeping the paint of those that stay. Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids} (a row that joined a Live Paint group is listed as the group)",
has_doc,
move_rows
),
@@ -119,7 +120,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Reorder",
[],
None,
"{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers; an Intertwine group takes and gives up members as layer.move does), deselecting every selected object left hidden or locked (the key object too)",
"{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers; an Intertwine group takes and gives up members as layer.move does), deselecting every selected object left hidden or locked (the key object too); a Live Paint group or its paths take a row as layer.move does",
has_doc,
move_node
),
@@ -625,12 +626,22 @@ fn highlight(s: &mut Session, p: &Value) -> Result<Value> {
"add" | "toggle" => {}
other => return Err(bad(C, format!("mode is set, add or toggle, not `{other}`"))),
}
// `rows` keeps the highlight order. With more than 8 ids, `held` holds the same rows as a set and
// answers each lookup; with fewer, each lookup searches `rows`.
let mut held: Option<HashSet<NodeId>> = (ids.len() > 8).then(|| rows.iter().copied().collect());
let mut last = None;
for id in ids {
if mode == "toggle" && rows.contains(&id) {
let has = held.as_ref().map_or_else(|| rows.contains(&id), |h| h.contains(&id));
if mode == "toggle" && has {
rows.retain(|r| *r != id);
} else if !rows.contains(&id) {
if let Some(h) = &mut held {
h.remove(&id);
}
} else if !has {
rows.push(id);
if let Some(h) = &mut held {
h.insert(id);
}
last = Some(id);
}
}
@@ -651,6 +662,10 @@ fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
if ids.is_empty() {
return Err(bad(C, "no rows"));
}
if let Some(v) = str_param(p, "name").filter(|v| !v.trim().is_empty()) {
let name = if xml_id { vectorcraft_doc::xml_id::to_object_name(v) } else { v.to_string() };
super::buildcmds::check_part_name(&s.doc()?.doc, &ids, &name)?;
}
s.edit("Layer Options", |d, sel| {
for id in &ids {
apply_options(d.node_mut(*id).ok_or(EngineError::NoNode(*id))?, p, xml_id);
@@ -807,7 +822,15 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
if parent.is_some_and(|p| locked_within(d, p)) {
return Err(EngineError::Other("the layer or group is locked".into()));
}
let label = if copy { "Duplicate Rows" } else { "Move Rows" };
// Rows that go into a Live Paint group join its paths, as Live Paint › Merge adds them.
let live_paint = LivePaintMove::plan(d, &ids, parent, copy)?;
let label = if live_paint.joins() {
"Merge Live Paint"
} else if copy {
"Duplicate Rows"
} else {
"Move Rows"
};
// Where each moved row comes from (a copy has a new id, so it comes from nowhere), and the
// Intertwine groups it leaves.
let from: std::collections::HashMap<NodeId, Option<NodeId>> = ids.iter().map(|i| (*i, d.parent_of(*i))).collect();
@@ -848,6 +871,7 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
}
let placed: Vec<(NodeId, Option<NodeId>)> = out.iter().map(|o| (*o, from.get(o).copied().flatten())).collect();
super::intertwine::settle_members(d, &placed, &left)?;
let out = live_paint.finish(d, sel, &out)?;
sel.prune(d);
sel.deselect_uneditable(d);
Ok(out)
@@ -870,11 +894,14 @@ fn move_node(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(what) = super::intertwine::refused_in(d, parent, n) {
return Err(bad(C, format!("{what} can't be intertwined")));
}
let live_paint = LivePaintMove::plan(d, &[id], parent, false)?;
let label = if live_paint.joins() { "Merge Live Paint" } else { "Reorder" };
let from = d.parent_of(id);
let left = super::intertwine::groups_of(d, &[id]);
s.edit("Reorder", |d, sel| {
s.edit(label, |d, sel| {
d.move_node(id, parent, index)?;
super::intertwine::settle_members(d, &[(id, from)], &left)?;
live_paint.finish(d, sel, &[id])?;
sel.prune(d);
sel.deselect_uneditable(d);
Ok(())
+3 -2
View File
@@ -132,7 +132,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Locate Object",
["Window", "Layers"],
None,
"{id?, layersOnly?} (default: the last selected object) highlight the object's row; the Layers panel opens the layers around it and scrolls to it, also when the row was already highlighted →{id, ancestry: [layer…, id]}. layersOnly (default false; the panel sends true while Show Layers Only is on, as Locate Layer) highlights the innermost layer or sublayer holding the object instead, or a layer id itself → {id: layer, objectId, ancestry: [layer…]}",
"{id?, layersOnly?} (default: the frontmost selected object in the stacking order) highlight the object's row; the Layers panel opens the layers around it and scrolls to it, also when the row was already highlighted → {id, ancestry: [layer…, id]}. layersOnly (default false; the panel sends true while Show Layers Only is on, as Locate Layer) highlights the innermost layer or sublayer holding the object instead, or a layer id itself → {id: layer, objectId, ancestry: [layer…]}",
has_doc,
locate
),
@@ -437,7 +437,8 @@ fn locate(s: &mut Session, p: &Value) -> Result<Value> {
let id = object_param(p, "id", "layer.locate")?;
let layers_only = switch_or(p, "layersOnly", false, "layer.locate")?;
let st = s.doc_mut()?;
let id = id.or_else(|| st.selection.objects.last().copied()).ok_or_else(|| bad("layer.locate", "nothing selected"))?;
// With no id, the frontmost selected object in the stacking order, whatever order it was selected in.
let id = id.or_else(|| st.selection.in_paint_order(&st.doc).last().copied()).ok_or_else(|| bad("layer.locate", "nothing selected"))?;
let mut ancestry = st.doc.ancestry(id).ok_or(EngineError::NoNode(id))?;
if layers_only {
// Locate Layer: the innermost layer or sublayer holding the object (a layer locates itself).
+3 -2
View File
@@ -108,7 +108,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Unembed",
[],
None,
"{id?: an embedded image (default: the one selected), path?, ids?: [image ids] (instead of id; one id is the same as id), folder?} write the image's pixels to the file at path (PNG, JPEG, GIF or WebP as stored, other images as PNG; a path ending in .png/.jpg/.jpeg/.gif/.webp/.tif/.tiff/.bmp converts them) and link the image to it, keeping its bounds. One undo step → {id, path}; no path → {name, dataBase64} (nothing changes: there is no file to link to). With folder: write each embedded image of ids or id (default: the selected embedded images) to a new file in folder, as stored (as PNG when that format is not one of VectorCraft's raster file formats), named after the image (characters a file name can't hold become _; Image when nothing is left), with Name 2 … Name 99 when the name is taken; a file already there is never replaced. Linked images among ids are left as they are. Each image links to its file and keeps its bounds. One undo step (undo does not remove the files); when a file can't be written, the files this call wrote are removed and nothing changes → {unembedded: [{id, path}], skipped: [ids of linked images]}; id with ids, path with folder, and ids of more or fewer than one image without folder are errors",
"{id?: an embedded image (default: the one selected), path?, ids?: [image ids] (instead of id; one id is the same as id), folder?} write the image's pixels to the file at path (PNG, JPEG, GIF or WebP as stored, other images as PNG; a path ending in .png/.jpg/.jpeg/.gif/.webp/.tif/.tiff/.bmp converts them) and link the image to it, keeping its bounds; written as stored (here and with folder), an image from a PSD or PSB file keeps the clip group of the clipping path that file names, and the file written keeps the path, so Open, Place, Relink and Update Links read the file with that clip group. One undo step → {id, path}; no path → {name, dataBase64} (nothing changes: there is no file to link to). With folder: write each embedded image of ids or id (default: the selected embedded images) to a new file in folder, as stored (as PNG when that format is not one of VectorCraft's raster file formats), named after the image (characters a file name can't hold become _; Image when nothing is left), with Name 2 … Name 99 when the name is taken; a file already there is never replaced. Linked images among ids are left as they are. Each image links to its file and keeps its bounds. One undo step (undo does not remove the files); when a file can't be written, the files this call wrote are removed and nothing changes → {unembedded: [{id, path}], skipped: [ids of linked images]}; id with ids, path with folder, and ids of more or fewer than one image without folder are errors",
has_doc,
unembed
),
@@ -634,7 +634,8 @@ pub(crate) fn readable_and_kept(blob: ImageBlob, unread: bool, linked: bool) ->
/// The linked image file `bytes` (read from `path`, when there is one), read with its preview: a
/// DCS file's plates, else its image ([`super::place::dcs::raster`]); an error when its pixels
/// can't be read ([`readable`]).
/// can't be read ([`readable`]). A PNG or TIFF that Unembed wrote from a PSD or PSB file's image
/// is read with the clipping path it keeps ([`fileio::raster_image`]).
fn linked_image(bytes: &[u8], path: Option<&str>) -> Result<RasterImage> {
let mut img = super::place::dcs::raster(bytes, path)?;
img.blob = readable(img.blob, kept_unread(bytes), true)?;
+38 -1
View File
@@ -214,6 +214,25 @@ fn spine_points_param(p: &Value, cmd: &str) -> Result<Vec<usize>> {
list.iter().map(|i| i.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or_else(wrong)).collect()
}
/// Whether linking handle `out` of spine point `index` at `q` would leave the blend's spine as it
/// is (false when the blend or the point is not there, for the edit to report it).
fn spine_link_unchanged(s: &Session, p: &Value, cmd: &str, index: usize, out: bool, q: Point) -> Result<bool> {
let id = match crate::cmd::object_param(p, "id", cmd)? {
Some(id) => Some(id),
None => selected_of(s, is_blend).first().copied(),
};
let d = &s.doc()?.doc;
let Some(NodeKind::Blend { children, spec }) = id.and_then(|id| d.node(id)).map(|n| &n.kind) else { return Ok(false) };
let Some((path, _)) = live::pin_spine(children, spec) else { return Ok(false) };
Ok(path.subpaths.first().is_some_and(|sp| {
sp.anchors.get(index).is_some_and(|a| {
let mut linked = *a;
linked.link_handle(out, q, sp.has_segment(index, !out));
linked == *a
})
}))
}
pub(super) fn spine_move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "object.blend.spine.moveAnchor";
let index = index_param(p, "anchor", C)?;
@@ -225,15 +244,33 @@ pub(super) fn spine_move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
Some(_) => return Err(bad(C, "handle must be in or out")),
};
let independent = switch_or(p, "independent", false, C)?;
let link = switch_or(p, "link", false, C)?;
let with = spine_points_param(p, C)?;
// Any `with`, even an empty list, asks to move points, which a handle drag doesn't.
if handle.is_some() && p.get("with").is_some_and(|v| !v.is_null()) {
return Err(bad(C, "`with` moves points, not a handle"));
}
if link && independent {
return Err(bad(C, "`link` and `independent` cannot both be true"));
}
if link && handle.is_none() {
return Err(bad(C, "`link` places a handle: give `handle`"));
}
if link && let Some(out) = handle {
// A spine point the linked handles would leave as it is records no undo step.
if spine_link_unchanged(s, p, C, index, out, q)? {
return ok();
}
}
edit_spine(s, p, C, "Reshape Spine", |sp, anchors, keys| {
let pull_out = handle.is_some_and(|out| sp.has_segment(index, !out));
let a = sp.anchors.get_mut(index).ok_or_else(|| bad(C, "no such spine point"))?;
if let Some(out) = handle {
a.set_handle(out, q, independent);
if link {
a.link_handle(out, q, pull_out);
} else {
a.set_handle(out, q, independent);
}
return Ok(());
}
let delta = q - a.p;
+1 -1
View File
@@ -99,7 +99,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Spine Point",
[],
None,
"{id? (default: the selected blend), anchor: index, x, y, with?: [index…], handle?: in|out, independent?: bool} move a point of the blend's spine (its handles along), and the points `with` names by as much, or with `handle` place that handle's end at (x, y) (a smooth point keeps the other handle in line unless `independent`). A key object sitting on a moved point moves with it. The first edit turns the straight spine into a path",
"{id? (default: the selected blend), anchor: index, x, y, with?: [index…], handle?: in|out, independent?: bool, link?: bool} move a point of the blend's spine (its handles along), and the points `with` names by as much, or with `handle` place that handle's end at (x, y) (a smooth point keeps the other handle in line unless `independent`; `link` makes the point smooth with the other handle in line at its own length, a retracted one pulled out to the moved handle's length where a segment leaves the point on its side; `link` needs `handle` and cannot go with `independent`). A key object sitting on a moved point moves with it. The first edit turns the straight spine into a path",
has_doc,
spine_move_anchor
),
+126 -16
View File
@@ -133,7 +133,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Create Object Mosaic…",
["Object"],
None,
"{columns=10, rows=10 (whole numbers, kept within 1..1000), width?, height? (new size in pt; default the image's), spacingX=0, spacingY=0 (pt between tiles), gray?: bool, deleteRaster?: bool} a group of rectangles coloured by the selected image's average tile colours → {id, tiles}",
"{columns=10, rows=10 (whole numbers, kept within 1..1000), width?, height? (new size in pt, 0.1..1000000; default the image's), percentages?: bool (width and height are percentages of the image's size, default 100), constrain?: \"width\"|\"height\"|null (Constrain Ratio: the mosaic keeps the image's proportions, the named side's size leads and the other side's is worked out from it, both growing or shrinking in proportion to keep the sizes within 0.1..1000000), useRatio?: bool|\"width\"|\"height\" (square tiles as drawn, spacing taken off: the count on the side named, or with true on the constrained side, columns by default, stays and the other is the count, 1..1000, whose tiles come closest to square), spacingX=0, spacingY=0 (pt between tiles), gray?: bool, deleteRaster?: bool} a group of rectangles colored by the selected image's average tile colors → {id, tiles, columns, rows}",
has_image,
object_mosaic
),
@@ -970,7 +970,23 @@ pub(crate) fn has_image(s: &Session) -> std::result::Result<(), String> {
}
}
fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
/// What `object.createObjectMosaic` makes from its params: the image, the tile counts, the tiles'
/// placement, their size and spacing in image pixels, and the options.
struct MosaicPlan {
id: NodeId,
im: ImageObject,
cols: u32,
rows: u32,
xf: Affine,
tile: (f64, f64),
gap: (f64, f64),
gray: bool,
delete: bool,
}
/// The mosaic `object.createObjectMosaic` would make from `p`, worked out without decoding the
/// image or changing the document.
fn mosaic_plan(s: &Session, p: &Value) -> Result<MosaicPlan> {
const C: &str = "object.createObjectMosaic";
let st = s.doc()?;
let id = st
@@ -980,28 +996,97 @@ fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
.copied()
.find(|id| matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Image(_))))
.ok_or_else(|| bad(C, "select an image"))?;
let node = st.doc.node(id).cloned().ok_or(EngineError::NoNode(id))?;
let node = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
let NodeKind::Image(im) = &node.kind else { return Err(bad(C, "select an image")) };
let blob = st.doc.images.get(&im.key).filter(|b| !b.bytes.is_empty()).ok_or_else(|| bad(C, "the image has no embedded pixels"))?;
let raster = vectorcraft_trace::Raster::decode(&blob.bytes).map_err(|e| bad(C, e.to_string()))?;
let cols = whole_or(p, "columns", 10, C)?.clamp(1, 1000) as u32;
let rows = whole_or(p, "rows", 10, C)?.clamp(1, 1000) as u32;
if !st.doc.images.get(&im.key).is_some_and(|b| !b.bytes.is_empty()) {
return Err(bad(C, "the image has no embedded pixels"));
}
let mut cols = whole_or(p, "columns", 10, C)?.clamp(1, 1000) as u32;
let mut rows = whole_or(p, "rows", 10, C)?.clamp(1, 1000) as u32;
let gray = switch_or(p, "gray", false, C)?;
let colors = vectorcraft_trace::mosaic(&raster, cols, rows);
let percentages = switch_or(p, "percentages", false, C)?;
// A side named "width" (true) or "height" (false), as `constrain` and `useRatio` take it.
let side = |key: &str, v: &Value, also: &str| match v.as_str() {
Some("width") => Ok(true),
Some("height") => Ok(false),
_ => Err(bad(C, format!("`{key}` must be one of {}", format_args!("\"width\", \"height\"{also} or null")))),
};
let constrain = match p.get("constrain") {
None | Some(Value::Null) => None,
Some(v) => Some(side("constrain", v, "")?),
};
// Use Ratio's kept side: true keeps Constrain Ratio's side (the width when it is left out).
let use_ratio = match p.get("useRatio") {
None | Some(Value::Null | Value::Bool(false)) => None,
Some(Value::Bool(true)) => Some(constrain.unwrap_or(true)),
Some(v) => Some(side("useRatio", v, ", true, false")?),
};
// Tiles in image space, placed by the image transform (scaled to a new size if asked).
let b = node.geometric_bounds().ok_or_else(|| bad(C, "image has no bounds"))?;
check_numbers(p, &["width", "height", "spacingX", "spacingY"], C)?;
let (nw, nh) = (f64_or(p, "width", b.width()).max(0.1), f64_or(p, "height", b.height()).max(0.1));
let resize = Affine::translate(b.origin().to_vec2())
* Affine::scale_non_uniform(nw / b.width().max(1e-9), nh / b.height().max(1e-9))
* Affine::translate(-b.origin().to_vec2());
let (bw, bh) = (b.width().max(1e-9), b.height().max(1e-9));
// A size given (pt, or % of the image's) is from 0.1 to 1,000,000; one left out is the image's.
let size = |key: &str, base: f64| -> Result<f64> {
let Some(x) = p.get(key).and_then(Value::as_f64) else { return Ok(base) };
let (min, max) = (0.1, 1_000_000.0);
if !(min..=max).contains(&x) {
return Err(bad(C, format!("`{key}` must be between {min} and {max} (got {x})")));
}
Ok(if percentages { base * x / 100.0 } else { x })
};
let (mut nw, mut nh) = (size("width", bw)?, size("height", bh)?);
// Constrain Ratio keeps the image's proportions: the named side leads and the other follows.
match constrain {
Some(true) => nh = nw * bh / bw,
Some(false) => nw = nh * bw / bh,
None => {}
}
// A size under 0.1 pt grows to 0.1 pt, in proportion while Constrain Ratio keeps it. A side
// Constrain Ratio works out above 1,000,000 pt shrinks to 1,000,000 pt, the other with it.
let (nw, nh) = match constrain {
Some(_) => {
let k = (0.1 / nw.min(nh)).max(1.0).min(1_000_000.0 / nw.max(nh));
// Proportions over 10,000,000 to 1 leave no size with both sides within the range.
if nw.min(nh) * k < 0.1 * (1.0 - 1e-9) {
return Err(bad(C, "the image's proportions leave no size with both sides between 0.1 and 1000000 pt"));
}
(nw * k, nh * k)
}
None => (nw.max(0.1), nh.max(0.1)),
};
let resize = Affine::translate(b.origin().to_vec2()) * Affine::scale_non_uniform(nw / bw, nh / bh) * Affine::translate(-b.origin().to_vec2());
let xf = resize * im.xf;
let (tw, th) = (im.width as f64 / cols as f64, im.height as f64 / rows as f64);
// Spacing is in points; convert to image pixels along each axis.
// Points per image pixel along each of the image's axes (the image may be turned).
let ppx = (xf * Point::new(1.0, 0.0) - xf * Point::ZERO).hypot().max(1e-9);
let ppy = (xf * Point::new(0.0, 1.0) - xf * Point::ZERO).hypot().max(1e-9);
let (gx, gy) = ((f64_or(p, "spacingX", 0.0).max(0.0) / ppx).min(tw * 0.9), (f64_or(p, "spacingY", 0.0).max(0.0) / ppy).min(th * 0.9));
let (sx, sy) = (f64_or(p, "spacingX", 0.0).max(0.0), f64_or(p, "spacingY", 0.0).max(0.0));
let (iw, ih) = (im.width as f64, im.height as f64);
// Use Ratio: square tiles as drawn, spacing taken off, from the count on the kept side,
// measured along the image's axes.
match use_ratio {
Some(true) => rows = mosaic_square_count(cols, iw * ppx, ih * ppy, sx, sy),
Some(false) => cols = mosaic_square_count(rows, ih * ppy, iw * ppx, sy, sx),
None => {}
}
let (tw, th) = (iw / cols as f64, ih / rows as f64);
// Spacing is in points; convert to image pixels along each axis.
let gap = ((sx / ppx).min(tw * 0.9), (sy / ppy).min(th * 0.9));
let delete = switch_or(p, "deleteRaster", false, C)?;
Ok(MosaicPlan { id, im: im.as_ref().clone(), cols, rows, xf, tile: (tw, th), gap, gray, delete })
}
/// The tile counts (columns, rows) `object.createObjectMosaic` would use with `p`, Use Ratio
/// included, without making the mosaic (the dialog's Use Ratio button shows them).
pub fn mosaic_counts(s: &Session, p: &Value) -> Result<(u32, u32)> {
mosaic_plan(s, p).map(|m| (m.cols, m.rows))
}
fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "object.createObjectMosaic";
let MosaicPlan { id, im, cols, rows, xf, tile: (tw, th), gap: (gx, gy), gray, delete } = mosaic_plan(s, p)?;
let blob = s.doc()?.doc.images.get(&im.key).ok_or_else(|| bad(C, "the image has no embedded pixels"))?;
let raster = vectorcraft_trace::Raster::decode(&blob.bytes).map_err(|e| bad(C, e.to_string()))?;
let colors = vectorcraft_trace::mosaic(&raster, cols, rows);
let (gid, n) = s.edit("Create Object Mosaic", |d, sel| {
let mut tiles = vec![];
for r in 0..rows {
@@ -1039,7 +1124,32 @@ fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
sel.set([gid]);
Ok((gid, n))
})?;
Ok(json!({ "id": gid.0, "tiles": n }))
Ok(json!({ "id": gid.0, "tiles": n, "columns": cols, "rows": rows }))
}
/// The tile count along one side of an Object Mosaic whose tiles, as drawn, come closest to square
/// (Use Ratio): `kept` tiles span `kept_len` on the other side, and this side is `other_len` long.
/// Each tile is its cell less the gap on its side (`kept_gap`, `other_gap`), and a gap takes at
/// most 90% of a cell, as the tiles are drawn. Within 1..1000, the smaller count on a tie; all
/// lengths in points.
pub(crate) fn mosaic_square_count(kept: u32, kept_len: f64, other_len: f64, kept_gap: f64, other_gap: f64) -> u32 {
let drawn = |len: f64, n: u32, gap: f64| {
let cell = len / n.max(1) as f64;
cell - gap.max(0.0).min(cell * 0.9)
};
let side = drawn(kept_len, kept, kept_gap);
if !(side.is_finite() && side > 0.0 && other_len.is_finite() && other_len > 0.0) {
return 1;
}
// A tile on this side shrinks as the count grows: find the first count whose tile is no wider
// than `side`, then take it or the count before it, whichever is closer.
let (mut lo, mut hi) = (1u32, 1000u32);
while lo < hi {
let mid = (lo + hi) / 2;
if drawn(other_len, mid, other_gap) > side { lo = mid + 1 } else { hi = mid }
}
let off = |n: u32| (drawn(other_len, n, other_gap) - side).abs();
if lo > 1 && off(lo - 1) <= off(lo) { lo - 1 } else { lo }
}
fn polygon_path(pts: &[Point]) -> PathData {
+12 -7
View File
@@ -371,16 +371,21 @@ pub(super) fn isolate(s: &mut Session, p: &Value) -> Result<Value> {
}
/// Leaving isolation mode in `isolated` for `next` (None: out of isolation mode) adds the paths drawn
/// in the Live Paint group isolation put new art in to that group, as `livePaint.merge` does, in one
/// undo step ([`crate::cmd::buildcmds::merge_drawn_in_isolation`]), unless `next` is that group or is
/// inside it; → the group when paths were added.
/// in each Live Paint group that is `isolated` or holds it to that group, as `livePaint.merge` does,
/// innermost group first, one undo step per group ([`crate::cmd::buildcmds::merge_drawn_in_isolation`]).
/// A group that `next` is or is inside is skipped, since isolation stays in it. → the outermost group
/// that paths were added to.
fn add_drawn_live_paint(s: &mut Session, isolated: NodeId, next: Option<NodeId>) -> Result<Option<NodeId>> {
let d = &s.doc()?.doc;
let Some(g) = crate::cmd::buildcmds::isolated_live_paint(d, isolated) else { return Ok(None) };
if next.is_some_and(|n| d.ancestry(n).is_some_and(|a| a.contains(&g))) {
return Ok(None);
let stays = next.and_then(|n| d.ancestry(n)).unwrap_or_default();
let left: Vec<NodeId> = crate::cmd::buildcmds::isolated_live_paints(d, isolated).into_iter().filter(|g| !stays.contains(g)).collect();
let mut added = None;
for g in left {
if crate::cmd::buildcmds::merge_drawn_in_isolation(s, g)? {
added = Some(g);
}
}
Ok(crate::cmd::buildcmds::merge_drawn_in_isolation(s, g)?.then_some(g))
Ok(added)
}
pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
+2 -2
View File
@@ -250,7 +250,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Exit Isolation Mode",
[],
None,
"{all?: bool (default false)} leave isolation mode; from an isolated sublayer, go up one level to its parent layer instead (the next call goes up again), unless all is true or the parent layer is hidden or locked; no undo step for the move up; while a symbol is edited, a group isolated in its art goes back to the symbol's layer first, with or without all; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same",
"{all?: bool (default false)} leave isolation mode; from an isolated sublayer, go up one level to its parent layer instead (the next call goes up again), unless all is true or the parent layer is hidden or locked; no undo step for the move up; while a symbol is edited, a group isolated in its art goes back to the symbol's layer first, with or without all; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same. Leaving a Live Paint group drawn in another isolated Live Paint group, and that group too, does this for each, innermost first, one undo step each",
has_doc,
exit_isolation
),
@@ -259,7 +259,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Object Properties",
[],
None,
"{ids?|id?, name?, visible?, locked? (visible: false or locked: true deselects every selected object hidden or locked after the call, the key object included), opacity?: 0..100, blend?: \"Multiply\"…, isolate?, knockout?: \"on\"|\"off\"|\"neutral\"|bool (true = on, false = neutral), knockoutShape?: bool, data?: {key: \"value\" | null (removes it)} (the object's own data, SVG data-* attributes: {pivot: \"100,180\"} is data-pivot; document.node → attrs.data)}. On a path directly in a graph series, the graph also stores the object's opacity and blend mode, and on a series group the group's opacity, blend mode, isolate, knockout and knockoutShape (exceptions: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring, the graph stores that object's opacity and blend mode for every label or line of its kind",
"{ids?|id?, name?, visible?, locked? (visible: false or locked: true deselects every selected object hidden or locked after the call, the key object included), opacity?: 0..100, blend?: \"Multiply\"…, isolate?, knockout?: \"on\"|\"off\"|\"neutral\"|bool (true = on, false = neutral), knockoutShape?: bool, data?: {key: \"value\" | null (removes it)} (the object's own data, SVG data-* attributes: {pivot: \"100,180\"} is data-pivot; document.node → attrs.data)}. On a path directly in a graph series, the graph also stores the object's opacity and blend mode, and on a series group the group's opacity, blend mode, isolate, knockout and knockoutShape (exceptions: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring, the graph stores that object's opacity and blend mode for every label or line of its kind. A path directly in a Live Paint group can't take the name Face or Edge, which name the group's faces and edges, unless it has it already",
has_doc,
set_props
),
+3
View File
@@ -65,6 +65,9 @@ pub(super) fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
})
};
let d = &s.doc()?.doc;
if let Some(v) = str_param(p, "name") {
crate::cmd::buildcmds::check_part_name(d, &ids, v)?;
}
// A graph keeps the object opacity and blend mode set on a mark of a series for the whole series, and set on a label
// for its kind of label, so a value a mark or label already has still replaces the one another left on the graph.
let transparency = opacity.is_some() || blend.is_some();
+1 -1
View File
@@ -30,7 +30,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Attributes",
[],
None,
"{ids?|id?, item?, target?: \"object\"|\"contents\"} → {ids, overprintFill, overprintStroke, showCenter, imageMap: \"none\"|\"rectangle\"|\"polygon\", url, note, fillRule: \"nonZero\"|\"evenOdd\" (of the paths and compound paths in them), reversed (their subpaths run counter-clockwise on screen: Reverse Path Direction On), recentUrls: [newest first]} the Attributes panel's values for `ids` or the selection, overprint aimed as object.setOverprint aims; a value is null where they differ (or nothing has a fill, stroke or path)",
"{ids?|id?, item?, target?: \"object\"|\"contents\"} → {ids, overprintFill, overprintStroke, showCenter, imageMap: \"none\"|\"rectangle\"|\"polygon\", url, note, fillRule: \"nonZero\"|\"evenOdd\" (of the paths and compound paths in them), reversed (their subpaths run counter-clockwise on screen: Reverse Path Direction On), recentUrls: [newest first, at most 30]} the Attributes panel's values for `ids` or the selection, overprint aimed as object.setOverprint aims; a value is null where they differ (or nothing has a fill, stroke or path)",
has_doc,
|s, p| Ok(attributes(s, p)?.to_json())
),
+1
View File
@@ -382,6 +382,7 @@ pub fn check_keys(id: &str, doc: &'static str, params: &Value) -> Result<()> {
const EXCLUSIVE_KEYS: &[(&str, &str, &str)] = &[
("addon.pathtools.cornerSet", "items", "ids"),
("addon.pathtools.cornerRemove", "items", "ids"),
("addon.pathtools.bridge", "radius", "gap"),
("links.unembed", "id", "ids"),
("links.unembed", "path", "folder"),
];
+40 -1
View File
@@ -50,7 +50,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Direction Handle",
[],
None,
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool}",
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool, link?: bool} move a direction handle; independent moves only that side and makes the anchor a corner; link makes the anchor smooth with the other handle in line at its own length (a retracted one is pulled out to the moved handle's length where a segment leaves the anchor on its side); link and independent cannot both be true; both default false",
has_doc,
set_handle
),
@@ -457,6 +457,9 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
let ai = index_opt(p, "anchor", "path.setHandle")?.ok_or_else(|| bad("path.setHandle", "missing anchor"))?;
let out = str_param(p, "which") != Some("in");
let pos = Point::new(f64_req(p, "x", "path.setHandle")?, f64_req(p, "y", "path.setHandle")?);
if switch_or(p, "link", false, "path.setHandle")? {
return link_handle(s, p, id, si, ai, out, pos);
}
let independent = switch_or(p, "independent", false, "path.setHandle")?;
// A handle already there, on an anchor already of the kind it would get, changes nothing and
// records no undo step. The handle is compared directly: `set_handle` would recompute the
@@ -476,6 +479,42 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
ok()
}
/// `path.setHandle` with `link` (the Anchor Point tool's Alt-drag on a handle): the handle goes to
/// (x, y) and the anchor becomes smooth, its other handle turned in line at its own length. A
/// retracted other handle is pulled out to the moved handle's length when a segment leaves the
/// anchor on its side, and stays retracted at an open end. An anchor the edit would leave as it
/// is records no undo step.
fn link_handle(s: &mut Session, p: &Value, id: NodeId, si: usize, ai: usize, out: bool, pos: Point) -> Result<Value> {
const C: &str = "path.setHandle";
if switch_or(p, "independent", false, C)? {
return Err(bad(C, "`link` and `independent` cannot both be true"));
}
if !(pos.x.abs() < 1e9 && pos.y.abs() < 1e9) {
return Err(bad(C, "x and y must be finite"));
}
if s.script_running() {
return Err(EngineError::Busy);
}
let unchanged = s.doc()?.doc.node(id).and_then(|n| n.path_data()).and_then(|pd| pd.subpaths.get(si)).is_some_and(|sp| {
sp.anchors.get(ai).is_some_and(|a| {
let mut linked = *a;
linked.link_handle(out, pos, sp.has_segment(ai, !out));
linked == *a
})
});
if unchanged {
return ok();
}
s.edit("Reshape", |d, _| {
let sp = path_mut(d, id)?.subpaths.get_mut(si).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
let pull_out = sp.has_segment(ai, !out);
let a = sp.anchors.get_mut(ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
a.link_handle(out, pos, pull_out);
Ok(())
})?;
ok()
}
/// `path.moveAnchor`: one anchor to (x, y), its handles keeping their offsets (the Anchor Point
/// tool's Shift-drag).
fn move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
@@ -88,6 +88,7 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.type.textTweaker",
"addon.units.convert",
"addon.units.selectionSize",
"app.toast",
"appearance.addEffect",
"appearance.addFill",
"appearance.addStroke",
@@ -177,6 +178,7 @@ pub(super) const ALLOWED: &[&str] = &[
"edit.duplicate",
"edit.findNext",
"edit.findReplace",
"edit.replaceMatch",
"effect.apply",
"effect.deferredStatus",
"effect.duplicate",
@@ -555,6 +557,7 @@ pub(super) const ALLOWED: &[&str] = &[
"select.update",
"shape.arc",
"shape.circleThroughPoints",
"shape.editFlare",
"shape.ellipse",
"shape.flare",
"shape.line",
@@ -689,6 +692,7 @@ pub(super) const ALLOWED: &[&str] = &[
"type.pathOptions",
"type.resetHorizontalScale",
"type.resetTracking",
"type.retype",
"type.ruby",
"type.scaleTextAttributes",
"type.size.decrease",
+2
View File
@@ -157,6 +157,8 @@ pub const PREF_SPECS: &[PrefSpec] = &[
p!("scrubNumericFields", "General", "Options", "Scrub Numeric Fields by Dragging", bool),
p!("trackpadRotateView", "General", "Options", "Trackpad Gesture to Rotate View", bool),
p!("holdToolKeys", "General", "Options", "Hold a Tool Shortcut to Use the Tool Temporarily", bool),
p!("holdShortcuts", "General", "Options", "Hold Shortcuts", bool),
p!("keyHoldDelay", "General", "Options", "Hold Shortcut Delay", num(0.2, 1.0, "s")),
p!("boundingBoxWhileMovingAndDrawing", "General", "Options", "Show Bounding Box While Moving and Drawing", bool),
// Selection & Anchor Display
p!("selectionTolerance", "Selection & Anchor Display", "Selection", "Tolerance", num(1.0, 8.0, "px")),
+17 -14
View File
@@ -34,7 +34,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Recolor Artwork",
["Edit", "Edit Colors"],
None,
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex); may be empty: an empty row recolours nothing, adds no library swatch and gives `group` no colour unless `added`], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint), added?: false (an empty row's new color is a color added to `group`)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour | null | \"keep\"] (what `group` is rewritten with, a null removing the group's swatch at its place and \"keep\" leaving that swatch its colour, without the Global Adjust (past the swatches it adds nothing; refused for a swatch that is not a colour); default: the new colors of the rows with current colors, in order, then those of the empty rows with `added`, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke, and on a graph label the new paint of its characters and rows for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex); may be empty: an empty row recolours nothing, adds no library swatch and gives `group` no colour unless `added`], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint), added?: false (an empty row's new color is a color added to `group`)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour | null | \"keep\"] (what the color swatches of `group` are rewritten with, in order: a gradient, pattern or None swatch keeps its place and paint; a null removing the color swatch at its place and \"keep\" leaving that swatch its colour, without the Global Adjust (past the color swatches it adds nothing); default: the new colors of the rows with current colors, in order, then those of the empty rows with `added`, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke, and on a graph label the new paint of its characters and rows for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
has_doc,
apply
),
@@ -1680,12 +1680,18 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
Some(Value::Array(cs)) => Some(cs),
Some(_) => return Err(bad(C, "`groupColors` must be an array")),
};
// A null in groupColors removes the group's swatch at its place, and "keep" leaves the swatch
// at its place its color, without the Global Adjust.
let own: Vec<Option<Color>> = match group {
Some(g) => {
s.doc()?.doc.swatch_groups.iter().find(|x| x.name == g).map(|g| g.swatches.iter().map(|w| w.paint.color()).collect()).unwrap_or_default()
}
// The places of groupColors are those of the group's color swatches: a gradient, pattern or
// None swatch keeps its place and paint. A null removes the color swatch at its place, and
// "keep" leaves it its color, without the Global Adjust.
let own: Vec<Color> = match group {
Some(g) => s
.doc()?
.doc
.swatch_groups
.iter()
.find(|x| x.name == g)
.map(|g| g.swatches.iter().filter_map(|w| w.paint.color()).collect())
.unwrap_or_default(),
None => vec![],
};
let new: Vec<Option<Color>> = match group_colors {
@@ -1694,12 +1700,8 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.enumerate()
.map(|(i, v)| match v {
Value::Null => Ok(None),
// Past the group's swatches it adds nothing.
Value::String(k) if k == "keep" => match own.get(i) {
Some(Some(c)) => Ok(Some(*c)),
Some(None) => Err(bad(C, format!("the swatch at place {i} of groupColors is not a colour to keep"))),
None => Ok(None),
},
// Past the group's color swatches it adds nothing.
Value::String(k) if k == "keep" => Ok(own.get(i).copied()),
v => color_value(v)
.map(|c| adjust.apply(c))
.map(|c| Some(in_doc_model(palette.as_ref().map_or(c, |pl| pl.nearest(c)))))
@@ -1747,6 +1749,7 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.map(|g| {
g.swatches
.iter()
.filter(|w| w.paint.color().is_some())
.zip(&new)
.filter(|(w, _)| w.global && !w.is_reserved())
.filter_map(|(w, c)| Some((w, (*c)?)))
@@ -1766,7 +1769,7 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.collect();
map.converted.set(false);
let changed = keeping_series_paint(d, &ids, |d| Ok(Recolor::with_links(scope, &f, &lf).run(d, &ids)))?;
let edit = group.map(|g| super::swatch::rewrite_group(d, g, &new, rename, C)).transpose()?;
let edit = group.map(|g| super::swatch::rewrite_group(d, g, &new, true, rename, C)).transpose()?;
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(C, e))?;
// Rewriting the group's swatches can change the colors of art linked to them, left out or
// not, and of the patterns it uses. Art that only loses its link keeps its colors and is
+619
View File
@@ -0,0 +1,619 @@
//! Type › Retype (#4934), phase 1: outlined text whose glyph shapes are glyphs of a font the app
//! has becomes live point text again, in that font and size, at the same baseline.
//!
//! Behaviour follows the public description of Illustrator's Retype
//! (<https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/identify-fonts-using-retype.html>,
//! <https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/apply-retype-suggested-fonts-to-live-text.html>):
//! select outlined text and Retype finds the fonts that match it, from the fonts on the device among
//! others, for use as live text. Illustrator ranks candidate fonts in a panel; this phase is local
//! and exact instead, and sets the text itself, as #4934 asks. Each selected glyph shape (a path or compound
//! path, inside groups too) is compared with the glyphs of the candidate fonts
//! ([`vectorcraft_text::retype`]), the same up to uniform scale, rotation and translation. Matched
//! glyphs map back to characters through the font's cmap and are rebuilt as point text, one object
//! per line of glyphs, with the first glyph's fill and stroke. Shapes that match no font stay as
//! they are and are reported. Near matches (another version of the font, simplified outlines,
//! merged glyphs) and images are phase 2.
use std::f64::consts::{PI, TAU};
use std::sync::Arc;
use kurbo::{BezPath, Point, Vec2};
use serde_json::{Value, json};
use vectorcraft_doc::{Appearance, CharStyle, Document, Node, NodeId, NodeKind, TextObject};
use vectorcraft_text::FontDb;
use vectorcraft_text::retype::{GlyphMatch, RetypeIndex};
use super::edit::selected_roots;
use super::{CommandSpec, EngineError, Result, Session, bad, cmd, has_selected_path};
/// At most this many shapes are compared.
const MAX_PIECES: usize = 2048;
/// Groups deeper than this are not looked into.
const MAX_DEPTH: usize = 16;
/// Extra families named by `fonts`.
const MAX_FONT_PARAMS: usize = 32;
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"type.retype",
"Retype",
["Type"],
None,
"{fonts?: [family…]} turn the selected outlined text (glyph paths and compound paths, inside groups too) back into live point text: each shape is matched against the glyphs of the fonts the app has loaded, the document's fonts and the families in fonts, the same up to uniform scale, rotation and translation (exact matches only); matched glyphs become point text in that font and size at the same baseline, one object per line, with the first glyph's fill, stroke, opacity and blend mode, in one undo step; a line splits where its type would not draw the outlines' glyphs in their places (tracking, manual spacing, font substitutions); shapes that match no font, glyphs type cannot draw as they are, and shapes with their own opacity mask stay as they are → {ids (the new type), texts, fonts: [{family, style, size}], unmatched: [id…], truncated (shapes past the limits of 2048 shapes or 16 nested groups were left out)}; an error when no shape matches",
has_selected_path,
retype
)]
}
/// A shape to match: a path or compound path, in document space.
struct Piece {
id: NodeId,
/// The group or layer holding it: glyphs of different groups, which may composite
/// differently, never share a line.
parent: Option<NodeId>,
/// Other art (not retyped) lies between it and the shape before it, so the type after that
/// art must stay painted after it: the line ends here.
after_barrier: bool,
path: BezPath,
appearance: Appearance,
/// The shape's own transparency, which the new type takes.
opacity: f32,
blend: vectorcraft_color::BlendMode,
/// The shape has what type cannot take (its own opacity mask, more than one fill or stroke,
/// effects, a brush, width profile or arrowheads): it stays an outline.
keeps_outline: bool,
}
/// The shapes in `n` (held by `parent`), in paint order. `barrier` is set when art that is not a
/// shape lies before the next one; it starts set for a root that does not follow the last root.
/// `truncated` is set when shapes past [`MAX_PIECES`] or [`MAX_DEPTH`] were left out.
fn collect(n: &Node, parent: Option<NodeId>, depth: usize, barrier: &mut bool, truncated: &mut bool, out: &mut Vec<Piece>) {
if out.len() >= MAX_PIECES || depth > MAX_DEPTH {
*barrier = true;
*truncated = true;
return;
}
// Hidden and locked art is left as it is: a hidden glyph must not come back as visible type.
if !n.visible || n.locked {
*barrier = true;
return;
}
let piece = |path: BezPath, after_barrier: bool| Piece {
id: n.id,
parent,
after_barrier,
path,
appearance: (*n.appearance).clone(),
opacity: n.opacity,
blend: n.blend,
keeps_outline: n.extras().mask.is_some() || !type_can_paint(&n.appearance),
};
match &n.kind {
NodeKind::Group { children, clip: false } => {
for c in children {
collect(c, Some(n.id), depth + 1, barrier, truncated, out);
}
}
// Only closed shapes can be glyphs: an open path stroked along a glyph's outline is not one.
NodeKind::Path { path, clipping: false, guide: false, .. } if path.is_closed() => out.push(piece(path.to_bezpath(), std::mem::take(barrier))),
NodeKind::Compound { children, .. } => {
let mut path = BezPath::new();
for c in children {
match &c.kind {
// A hidden or locked path keeps its whole compound as it is.
NodeKind::Path { path: p, .. } if p.is_closed() && c.visible && !c.locked => path.extend(p.to_bezpath()),
_ => {
*barrier = true;
return;
}
}
}
out.push(piece(path, std::mem::take(barrier)));
}
// Live type, images, clip groups and the rest stay, and the type after them stays after them.
_ => *barrier = true,
}
}
/// Can type's character style paint `ap` as it is: a basic appearance (at most one fill and one
/// stroke, no effects, no item opacity or blend), with a plain stroke?
fn type_can_paint(ap: &Appearance) -> bool {
ap.is_basic() && ap.stroke().is_none_or(|s| s.start_arrow.is_none() && s.end_arrow.is_none() && s.profile.is_none() && s.brush.is_none())
}
/// The faces to match against: the families in `fonts`, the document's fonts, then every loaded face.
fn candidate_faces(db: &FontDb, d: &Document, fonts: &[String]) -> Vec<Arc<vectorcraft_text::FontFace>> {
let mut families: Vec<String> = fonts.iter().take(MAX_FONT_PARAMS).cloned().collect();
d.walk(|n| {
if let NodeKind::Text(t) = &n.kind {
for r in &t.runs {
if !families.contains(&r.style.font_family) && families.len() < vectorcraft_text::retype::MAX_FACES {
families.push(r.style.font_family.clone());
}
}
}
});
let cap = vectorcraft_text::retype::MAX_FACES;
let mut faces = vec![];
'families: for f in &families {
for style in db.styles(f) {
// No more faces are loaded than the index takes.
if faces.len() >= cap {
break 'families;
}
if let Some(face) = db.face(f, &style)
&& !faces.iter().any(|k: &Arc<vectorcraft_text::FontFace>| k.id() == face.id())
{
faces.push(face);
}
}
}
for face in db.loaded_faces() {
if faces.len() >= cap {
break;
}
if !faces.iter().any(|k| k.id() == face.id()) {
faces.push(face);
}
}
faces
}
/// One line of retyped glyphs.
struct Line {
pieces: Vec<NodeId>,
/// What each piece matched, as `pieces`.
matches: Vec<GlyphMatch>,
/// Every glyph the first piece fits, while the line holds only it: the next glyph may tell
/// which one it is (see [`join`]).
first_cands: Vec<GlyphMatch>,
text: String,
face: Arc<vectorcraft_text::FontFace>,
scale: f64,
angle: f64,
origin: Point,
end: Point,
appearance: Appearance,
parent: Option<NodeId>,
opacity: f32,
blend: vectorcraft_color::BlendMode,
}
impl Line {
fn dir(&self) -> Vec2 {
Vec2::new(self.angle.cos(), self.angle.sin())
}
/// Does glyph `m` of shape `pc` continue this line (same group, paint and transparency, same
/// font, size and turn, on its baseline, after its end)?
fn continues(&self, pc: &Piece, m: &GlyphMatch) -> bool {
let size = self.scale * self.face.units_per_em();
let d = m.origin - self.origin;
let dir = self.dir();
let across = d.cross(dir).abs();
pc.parent == self.parent
&& pc.appearance == self.appearance
&& pc.opacity == self.opacity
&& pc.blend == self.blend
&& m.face.id() == self.face.id()
// One size and turn for the whole line: the type sets every glyph at the first one's.
&& (m.scale - self.scale).abs() <= self.scale * 1e-4
// Wrapped: type turned 180° has angles near +π and −π.
&& ((m.angle - self.angle + PI).rem_euclid(TAU) - PI).abs() < 1e-5
&& across < size * 0.05
&& (m.origin - self.end).dot(dir) > -size * 0.25
}
fn push(&mut self, id: NodeId, m: &GlyphMatch) {
// A gap wider than half a space before the glyph is spaces the outlines left no shape for.
let dir = self.dir();
let gap = (m.origin - self.end).dot(dir);
let space = space_advance(&self.face) * self.scale;
if space > 0.0 && gap > space * 0.5 {
let n = ((gap / space).round() as usize).clamp(1, 64);
self.text.extend(std::iter::repeat_n(' ', n));
}
self.text.push(m.ch);
self.pieces.push(id);
self.matches.push(m.clone());
self.end = m.origin + dir * (m.face.advance(m.gid) * m.scale);
}
/// The line of this one's glyphs `from..to`, with its group, paint and transparency.
fn part(&self, from: usize, to: usize) -> Option<Line> {
let (ids, ms) = (self.pieces.get(from..to)?, self.matches.get(from..to)?);
let (first, m) = (ids.first()?, ms.first()?);
let dir = Vec2::new(m.angle.cos(), m.angle.sin());
let mut l = Line {
pieces: vec![*first],
matches: vec![m.clone()],
first_cands: vec![],
text: m.ch.to_string(),
face: m.face.clone(),
scale: m.scale,
angle: m.angle,
origin: m.origin,
end: m.origin + dir * (m.face.advance(m.gid) * m.scale),
appearance: self.appearance.clone(),
parent: self.parent,
opacity: self.opacity,
blend: self.blend,
};
for (id, m) in ids.iter().zip(ms).skip(1) {
l.push(*id, m);
}
Some(l)
}
/// The point type that sets this line.
fn text_object(&self, system_layout: bool) -> TextObject {
let style = CharStyle {
font_family: self.face.family.clone(),
font_style: self.face.style.clone(),
// The version that matched, when two of the family and style are loaded.
font_version: (!self.face.version.is_empty()).then(|| self.face.version.clone()),
// Each outlined glyph was drawn on its own; a ligature would draw another shape.
features: vec!["-liga".into()],
size: self.scale * self.face.units_per_em(),
fill: self.appearance.fill_paint(),
stroke: self.appearance.stroke_paint(),
stroke_width: self.appearance.stroke_width(),
..Default::default()
};
let mut style = style;
if let Some(st) = self.appearance.stroke() {
style.stroke_cap = st.cap;
style.stroke_join = st.join;
style.stroke_miter_limit = st.miter_limit;
style.stroke_dash = st.dash.clone();
style.stroke_align = st.align;
}
let mut t = TextObject::point(self.origin, &self.text, style);
if self.angle != 0.0 {
t.xf *= kurbo::Affine::rotate(self.angle);
}
t.para = super::create::new_type_para();
t.system_layout = system_layout;
super::typecmd::refresh_bounds(&mut t);
t
}
/// The first of this line's glyphs its type does not draw as the outlines did: another glyph
/// (a substitution the font makes) or the same glyph elsewhere (tracking, manual spacing,
/// more space than whole spaces make); `None` when the type draws every glyph in its place.
fn first_mismatch(&self, t: &TextObject) -> Option<usize> {
let lay = vectorcraft_text::layout(FontDb::global(), t);
let mut drawn = lay.glyphs.iter().filter(|g| !g.outline.elements().is_empty());
let tol = (self.scale * self.face.units_per_em() * 0.01).max(0.01);
for (k, m) in self.matches.iter().enumerate() {
let Some(g) = drawn.next() else { return Some(k) };
let at = t.xf * (g.xf * Point::ORIGIN);
if g.font_id != m.face.id() || g.gid != m.gid || at.distance(m.origin) > tol {
return Some(k);
}
}
// Ink the outlines did not have: the last glyph is where it went wrong.
drawn.next().map(|_| self.matches.len().saturating_sub(1))
}
}
/// `lines` checked against their own layout: a line splits where its type stops drawing the
/// outlines, and a glyph its type cannot draw even on its own stays an outline (`unmatched`).
/// The glyphs laid out are bounded by a multiple of the number of glyphs.
fn verified(lines: Vec<Line>, system_layout: bool, unmatched: &mut Vec<NodeId>) -> Vec<Line> {
// Glyphs laid out in all, at most: past it, the glyphs left unchecked stay outlines.
let mut budget = lines.iter().map(|l| l.pieces.len()).sum::<usize>().saturating_mul(16).saturating_add(256);
let mut todo: std::collections::VecDeque<Line> = lines.into();
let mut out = vec![];
while let Some(l) = todo.pop_front() {
let n = l.pieces.len();
// The line's type is laid out over a window from its start that doubles while the type
// draws the window's glyphs as the outlines do, so finding where it stops costs about
// twice the glyphs before that point, not the whole rest of the line each time.
let mut w = 8usize;
loop {
let e = n.min(w);
let Some(part) = l.part(0, e) else { break };
let Some(left) = budget.checked_sub(e) else {
// Unchecked glyphs stay outlines.
unmatched.extend(l.pieces.iter().copied());
break;
};
budget = left;
match part.first_mismatch(&part.text_object(system_layout)) {
// The whole line is drawn as it was: one object.
None if e == n => {
out.push(part);
break;
}
None => w = w.saturating_mul(2),
// The first glyph on its own may still be drawn as it was (a contextual form
// changed it in the line); else it stays an outline. Checked again either way.
Some(0) if n > 1 => {
todo.extend_front_parts(&l, [(0, 1), (1, n)]);
break;
}
Some(0) => {
unmatched.extend(l.pieces.first().copied());
break;
}
// The glyphs before the mismatch, then the rest, each checked as a line of its
// own: the type before the mismatch may draw otherwise without what follows it (a
// font can place a glyph by the glyph after it).
Some(k) => {
todo.extend_front_parts(&l, [(0, k), (k, n)]);
break;
}
}
}
}
out
}
/// Puts parts of a line at the front of the work list, in order.
trait FrontParts {
fn extend_front_parts<const N: usize>(&mut self, l: &Line, ranges: [(usize, usize); N]);
}
impl FrontParts for std::collections::VecDeque<Line> {
fn extend_front_parts<const N: usize>(&mut self, l: &Line, ranges: [(usize, usize); N]) {
for (a, b) in ranges.into_iter().rev() {
if let Some(p) = l.part(a, b) {
self.push_front(p);
}
}
}
}
fn space_advance(face: &vectorcraft_text::FontFace) -> f64 {
face.mapped_chars().iter().find(|(c, _)| *c == ' ').map(|(_, g)| face.advance(*g)).unwrap_or(0.0)
}
/// Add shape `pc` to line `l` when one of its candidate glyphs `cands`, in one of its poses,
/// continues it (one shape can be several glyphs, and a glyph that looks the same turned fits in
/// more than one pose). A line of one shape may turn to another of that shape's candidates to take
/// the next one: an L or a turned L half round, an I upright or upside down, and the glyph after it
/// tells which. Whether it was added.
fn join(l: &mut Line, pc: &Piece, cands: &[GlyphMatch]) -> bool {
let fits = |l: &Line| cands.iter().flat_map(|c| c.poses()).find(|mp| l.continues(pc, mp));
if let Some(mp) = fits(l) {
l.push(pc.id, &mp);
return true;
}
let (Some(id), [current]) = (l.pieces.first().copied(), l.matches.as_slice()) else { return false };
let current = current.clone();
let others: Vec<GlyphMatch> = l
.first_cands
.iter()
.flat_map(|c| c.poses())
.filter(|fp| !(fp.gid == current.gid && fp.face.id() == current.face.id() && fp.angle == current.angle))
.collect();
for fp in others {
let mut turned = reposed(l, id, &fp);
if let Some(mp) = fits(&turned) {
turned.push(pc.id, &mp);
*l = turned;
return true;
}
}
false
}
/// Line `l`'s group, paint and transparency with glyph `m` (shape `id`) alone on it.
fn reposed(l: &Line, id: NodeId, m: &GlyphMatch) -> Line {
let dir = Vec2::new(m.angle.cos(), m.angle.sin());
Line {
pieces: vec![id],
matches: vec![m.clone()],
first_cands: l.first_cands.clone(),
text: m.ch.to_string(),
face: m.face.clone(),
scale: m.scale,
angle: m.angle,
origin: m.origin,
end: m.origin + dir * (m.face.advance(m.gid) * m.scale),
appearance: l.appearance.clone(),
parent: l.parent,
opacity: l.opacity,
blend: l.blend,
}
}
/// A new line of shape `pc` alone, as the first of its candidate glyphs `cands` (none: `None`).
fn new_line(pc: &Piece, cands: &[GlyphMatch]) -> Option<Line> {
let m = cands.first()?;
let dir = Vec2::new(m.angle.cos(), m.angle.sin());
Some(Line {
pieces: vec![pc.id],
matches: vec![m.clone()],
first_cands: cands.to_vec(),
text: m.ch.to_string(),
face: m.face.clone(),
scale: m.scale,
angle: m.angle,
origin: m.origin,
end: m.origin + dir * (m.face.advance(m.gid) * m.scale),
appearance: pc.appearance.clone(),
parent: pc.parent,
opacity: pc.opacity,
blend: pc.blend,
})
}
fn retype(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "type.retype";
let fonts: Vec<String> = match p.get("fonts") {
None | Some(Value::Null) => vec![],
Some(Value::Array(a)) => {
a.iter().map(|v| v.as_str().map(str::to_owned).ok_or_else(|| bad(C, "fonts must be a list of family names"))).collect::<Result<_>>()?
}
Some(_) => return Err(bad(C, "fonts must be a list of family names")),
};
let roots = selected_roots(s)?;
let db = FontDb::global();
let system_layout = s.doc()?.doc.setup.system_layout;
let (lines, unmatched, truncated) = {
let d = &s.doc()?.doc;
let mut pieces = vec![];
let mut truncated = false;
let mut last: Option<(Option<NodeId>, usize)> = None;
// Carried across roots: a selected root that yields no shape (live type, an open path) still
// ends the line.
let mut barrier = true;
for r in &roots {
let Some(n) = d.node(*r) else { continue };
let parent = d.parent_of(*r);
let idx = d.position(*r).map(|(_, i, _)| i);
// A root right after the last one, in the same parent, continues its lines; unselected
// art between two roots is a barrier.
if !matches!((last, idx), (Some((p, i)), Some(j)) if p == parent && i + 1 == j) {
barrier = true;
}
last = idx.map(|i| (parent, i));
collect(n, parent, 0, &mut barrier, &mut truncated, &mut pieces);
}
if pieces.is_empty() {
return Err(EngineError::Other("Retype: select outlined text (paths or compound paths)".into()));
}
// Only glyphs with a selected shape's key (segments per contour) can match one: the others are
// not sampled.
let wanted: std::collections::BTreeSet<u64> =
pieces.iter().filter(|pc| !pc.keeps_outline).filter_map(|pc| vectorcraft_text::retype::shape_key(&pc.path)).collect();
// Nothing to match (every shape stays an outline): no font is read.
let index = if wanted.is_empty() { RetypeIndex::default() } else { RetypeIndex::build(db, candidate_faces(db, d, &fonts), &wanted) };
let found: Vec<Vec<GlyphMatch>> = pieces.iter().map(|pc| if pc.keeps_outline { vec![] } else { index.matches(&pc.path) }).collect();
// The face most shapes match, so a glyph several fonts share is set in the same font as
// the glyphs around it.
let mut votes: Vec<(u32, usize)> = vec![];
for ms in &found {
// Each shape votes once for each face it fits.
let mut faces: Vec<u32> = ms.iter().map(|m| m.face.id()).collect();
faces.sort_unstable();
faces.dedup();
for f in faces {
match votes.iter_mut().find(|(v, _)| *v == f) {
Some(v) => v.1 += 1,
None => votes.push((f, 1)),
}
}
}
let rank = |face: u32| votes.iter().find(|(f, _)| *f == face).map_or(0, |v| v.1);
let mut lines: Vec<Line> = vec![];
let mut unmatched = vec![];
// An unmatched shape between glyphs ends the line: the type after it is painted after it.
let mut open = false;
for (pc, ms) in pieces.iter().zip(&found) {
if pc.after_barrier {
open = false;
}
// The shape's candidates in the face most shapes fit (the first such face, as the
// matches come upright and closest first).
let face = ms.iter().enumerate().max_by_key(|(i, m)| (rank(m.face.id()), std::cmp::Reverse(*i))).map(|(_, m)| m.face.id());
let cands: Vec<GlyphMatch> = ms.iter().filter(|m| Some(m.face.id()) == face).cloned().collect();
if cands.is_empty() {
unmatched.push(pc.id);
open = false;
continue;
}
let joined = match lines.last_mut() {
Some(l) if open => join(l, pc, &cands),
_ => false,
};
if !joined {
lines.extend(new_line(pc, &cands));
}
open = true;
}
// A lone one-contour glyph (a period, a hyphen, a bullet) is too plain to tell from drawn
// art (a dot, a bar): beside other shapes it stays an outline. Selected on its own, it is
// what was asked for. Lone means alone on its baseline as the outlines lie, before the
// layout check splits lines (tracking and manual kerning split them glyph by glyph).
let lone_pieces: std::collections::HashSet<NodeId> =
lines.iter().filter(|l| matches!(l.matches.as_slice(), [m] if m.contours == 1)).flat_map(|l| l.pieces.iter().copied()).collect();
let mut lines = verified(lines, system_layout, &mut unmatched);
if pieces.len() > 1 {
lines.retain(|l| {
let lone = matches!(l.pieces.as_slice(), [id] if lone_pieces.contains(id));
if lone {
unmatched.extend(l.pieces.iter().copied());
}
!lone
});
}
(lines, unmatched, truncated)
};
if lines.is_empty() {
return Err(EngineError::Other(format!("Retype: no selected shape matches a glyph of an available font ({} checked)", unmatched.len())));
}
let made = s.edit("Retype", |d, sel| {
let mut ids = vec![];
let mut emptied = vec![];
for l in &lines {
let Some(first) = l.pieces.first() else { continue };
let (par, idx, _) = d.position(*first).ok_or(EngineError::NoNode(*first))?;
let t = l.text_object(system_layout);
let id = d.alloc_id();
let mut node = Node::new(id, NodeKind::Text(Box::new(t)));
// The glyphs' own transparency (the group's, kept, still applies over it).
node.opacity = l.opacity;
node.blend = l.blend;
d.insert(par, idx, node)?;
for pc in &l.pieces {
if let Some((Some(parent), _, _)) = d.position(*pc) {
emptied.push(parent);
}
d.remove(*pc)?;
}
ids.push(id);
}
// A group left holding only the new type (Create Outlines' group) gives way to it, unless
// the group has transparency, effects, a mask or a name of its own, which then keep
// applying to the type inside it. A group left empty goes.
emptied.sort_unstable();
emptied.dedup();
for g in emptied {
let Some(n) = d.node(g) else { continue };
let NodeKind::Group { children, clip: false } = &n.kind else { continue };
let plain = n.opacity == 1.0
&& n.blend == vectorcraft_color::BlendMode::Normal
&& *n.appearance == Appearance::default()
&& n.name.is_none()
// Its mask, Attributes note and the rest of what few objects have stay with it.
&& {
let mut ex = n.extras().clone();
ex.type_outlines = false;
ex == vectorcraft_doc::NodeExtras::default()
}
// Isolation and knockout change how the group composites its type.
&& !n.isolate
&& n.knockout == vectorcraft_doc::Knockout::default()
&& !n.knockout_shape;
let only_type = children.iter().all(|c| ids.contains(&c.id));
if children.is_empty() {
d.remove(g)?;
} else if plain && only_type {
let kids: Vec<Arc<Node>> = children.clone();
let (par, idx, _) = d.position(g).ok_or(EngineError::NoNode(g))?;
d.remove(g)?;
for (i, k) in kids.into_iter().enumerate() {
d.insert(par, idx + i, (*k).clone())?;
}
}
}
let mut keep: Vec<NodeId> = roots.iter().copied().filter(|r| d.node(*r).is_some()).collect();
keep.extend(&ids);
sel.set(keep);
Ok(ids)
})?;
Ok(json!({
"ids": made.iter().map(|i| i.0).collect::<Vec<_>>(),
"texts": lines.iter().map(|l| l.text.clone()).collect::<Vec<_>>(),
"fonts": lines.iter().map(|l| json!({"family": l.face.family, "style": l.face.style, "size": l.scale * l.face.units_per_em()})).collect::<Vec<_>>(),
"unmatched": unmatched.iter().map(|i| i.0).collect::<Vec<_>>(),
"truncated": truncated,
}))
}
#[cfg(test)]
#[path = "retype_tests.rs"]
mod tests;
+539
View File
@@ -0,0 +1,539 @@
use serde_json::json;
use vectorcraft_doc::{NodeId, NodeKind, TextObject};
use crate::Session;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 600, "height": 400})).unwrap();
s
}
/// Point text, outlined: the id of the outlines' group.
fn outlined(s: &mut Session, p: serde_json::Value) -> u64 {
let id = s.execute("text.create", &p).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap()
}
fn text_of(s: &Session, id: u64) -> TextObject {
let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind else { panic!("text object") };
(**t).clone()
}
fn near(a: f64, b: f64, tol: f64) -> bool {
(a - b).abs() <= tol
}
#[test]
fn outlined_point_text_retypes_to_the_same_text_font_size_and_place() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Retype me, 42!", "size": 36, "font": "Source Sans 3", "style": "Regular"}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Retype me, 42!"]), "{r}");
assert_eq!(r["unmatched"], json!([]));
let id = r["ids"][0].as_u64().unwrap();
let t = text_of(&s, id);
assert_eq!(t.plain_text(), "Retype me, 42!");
let st = t.first_style();
assert_eq!((st.font_family.as_str(), st.font_style.as_str()), ("Source Sans 3", "Regular"));
assert!(near(st.size, 36.0, 0.01), "size {}", st.size);
let o = t.xf.translation();
assert!(near(o.x, 40.0, 0.01) && near(o.y, 100.0, 0.01), "baseline start {o:?}");
// The outlines are gone, in one undo step that brings them back.
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(g)).is_none(), "the emptied group goes");
s.execute("edit.undo", &json!({})).unwrap();
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(g)).is_some() && d.node(NodeId(id)).is_none());
}
#[test]
fn turned_bold_and_serif_type_keeps_its_font_and_angle() {
let mut s = session();
let a = outlined(&mut s, json!({"x": 100, "y": 200, "text": "Bold", "size": 24, "font": "Source Sans 3", "style": "Bold", "rotation": 30}));
let b = outlined(&mut s, json!({"x": 300, "y": 80, "text": "Serif", "size": 18, "font": "Source Serif 4", "style": "Regular"}));
s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Bold", "Serif"]), "{r}");
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
let bold = text_of(&s, ids[0]);
assert_eq!(bold.first_style().font_style, "Bold");
assert!(near(bold.first_style().size, 24.0, 0.01));
// text.create turns as kurbo does: compare the turn the new type has with the old one's.
let turned = kurbo::Affine::translate((100.0, 200.0)) * vectorcraft_geom::rotate_deg(30.0);
for (x, y) in bold.xf.as_coeffs().iter().zip(turned.as_coeffs()) {
assert!(near(*x, y, 1e-3), "{:?} vs {:?}", bold.xf, turned);
}
let serif = text_of(&s, ids[1]);
assert_eq!(serif.first_style().font_family, "Source Serif 4");
assert!(near(serif.first_style().size, 18.0, 0.01));
}
#[test]
fn a_drawn_shape_is_reported_and_left_alone() {
let mut s = session();
let rect = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 80, "height": 40})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [rect]})).unwrap();
let before = s.doc().unwrap().doc.clone();
let e = s.execute("type.retype", &json!({})).unwrap_err().to_string();
assert!(e.contains("no selected shape matches"), "{e}");
assert!(s.doc().unwrap().doc == before, "nothing changes");
// With outlines that would match, a bad `fonts` is refused for itself, and nothing changes.
let g = outlined(&mut s, json!({"x": 40, "y": 200, "text": "AB", "size": 40}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let before = s.doc().unwrap().doc.clone();
for bad in [json!("Source Sans 3"), json!([1]), json!({"family": "x"})] {
let e = s.execute("type.retype", &json!({"fonts": bad})).unwrap_err().to_string();
assert!(e.contains("fonts must be a list of family names"), "{e}");
}
assert!(s.doc().unwrap().doc == before);
}
#[test]
fn mixed_selection_retypes_the_glyphs_and_keeps_the_rest() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Mix", "size": 30}));
let rect = s.execute("shape.rectangle", &json!({"x": 10, "y": 200, "width": 80, "height": 40})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g, rect]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Mix"]));
assert_eq!(r["unmatched"], json!([rect]));
let d = &s.doc().unwrap().doc;
assert!(matches!(d.node(NodeId(rect)).unwrap().kind, NodeKind::Path { .. }), "the rectangle stays");
}
#[test]
fn two_words_keep_their_space() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 20, "y": 60, "text": "two words", "size": 20}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["two words"]));
}
#[test]
fn craft_fonts_glyphs_retype_too() {
let Some(f) = vectorcraft_text::CRAFT_FONTS.iter().find(|f| f.is_japanese()) else {
eprintln!("skipped: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout to run it)");
return;
};
let mut s = session();
let g = outlined(&mut s, json!({"x": 20, "y": 60, "text": "漢字です", "size": 20, "font": f.family, "style": f.style}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({"fonts": [f.family]})).unwrap();
assert_eq!(r["texts"], json!(["漢字です"]), "{r}");
assert_eq!(r["fonts"][0]["family"], json!(f.family));
}
fn children_of(s: &Session, g: u64) -> Vec<u64> {
s.doc().unwrap().doc.node(NodeId(g)).unwrap().children().unwrap().iter().map(|c| c.id.0).collect()
}
#[test]
fn a_shape_between_glyphs_ends_the_line_so_paint_order_holds() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let rect = s.execute("shape.rectangle", &json!({"x": 30, "y": 60, "width": 80, "height": 50})).unwrap()["id"].as_u64().unwrap();
// The rectangle goes between A and B, inside the outlines' group.
s.edit("test", |d, _| {
let n = d.node(NodeId(rect)).unwrap().clone();
d.remove(NodeId(rect))?;
d.insert(Some(NodeId(g)), 1, n)?;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A", "B"]), "{r}");
assert_eq!(r["unmatched"], json!([rect]));
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
assert_eq!(children_of(&s, g), vec![ids[0], rect, ids[1]], "A under the rectangle, B over it");
}
#[test]
fn glyphs_of_different_groups_and_transparency_stay_apart() {
let mut s = session();
let a = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ab", "size": 20}));
let b = outlined(&mut s, json!({"x": 120, "y": 100, "text": "ed", "size": 20}));
let first_d = children_of(&s, b)[1];
s.edit("test", |d, _| {
d.node_mut(NodeId(b)).unwrap().opacity = 0.5;
d.node_mut(NodeId(first_d)).unwrap().opacity = 0.25;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["ab", "e", "d"]), "same baseline, other group; d has its own opacity: {r}");
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(a)).is_none(), "a plain group gives way to its type");
assert_eq!(d.node(NodeId(b)).unwrap().opacity, 0.5, "the half-transparent group stays");
assert_eq!(children_of(&s, b), vec![ids[1], ids[2]]);
assert_eq!(s.doc().unwrap().doc.node(NodeId(ids[2])).unwrap().opacity, 0.25, "the glyph's own opacity carries over");
}
#[test]
fn live_type_between_glyphs_ends_the_line_too() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let live = s.execute("text.create", &json!({"x": 30, "y": 90, "text": "x", "size": 60})).unwrap()["id"].as_u64().unwrap();
s.edit("test", |d, _| {
let n = d.node(NodeId(live)).unwrap().clone();
d.remove(NodeId(live))?;
d.insert(Some(NodeId(g)), 1, n)?;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A", "B"]), "{r}");
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
assert_eq!(children_of(&s, g), vec![ids[0], live, ids[1]], "B stays over the live type");
let t = text_of(&s, ids[0]);
assert!(t.first_style().features.iter().any(|f| f == "-liga"), "glyphs drawn one by one: no ligatures");
}
#[test]
fn an_open_path_along_a_glyph_is_not_a_glyph() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "I", "size": 40}));
s.edit("test", |d, _| {
let glyph = d.node(NodeId(g)).unwrap().children().unwrap()[0].id;
for sp in &mut d.node_mut(glyph).unwrap().path_data_mut().unwrap().subpaths {
sp.closed = false;
}
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
assert!(s.execute("type.retype", &json!({})).is_err(), "nothing matches");
}
#[test]
fn live_type_selected_between_loose_glyphs_still_ends_the_line() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let live = s.execute("text.create", &json!({"x": 30, "y": 90, "text": "x", "size": 60})).unwrap()["id"].as_u64().unwrap();
let (a, b) = (children_of(&s, g)[0], children_of(&s, g)[1]);
// A, the live type and B as siblings in the layer, as Ungroup leaves them.
s.edit("test", |d, _| {
let (par, idx, _) = d.position(NodeId(g)).unwrap();
let live_n = d.node(NodeId(live)).unwrap().clone();
let (an, bn) = (d.node(NodeId(a)).unwrap().clone(), d.node(NodeId(b)).unwrap().clone());
d.remove(NodeId(live))?;
d.remove(NodeId(g))?;
d.insert(par, idx, an)?;
d.insert(par, idx + 1, live_n)?;
d.insert(par, idx + 2, bn)?;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [a, live, b]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A", "B"]), "the selected live type between them ends the line: {r}");
}
#[test]
fn glyphs_selected_inside_groups_join_only_their_siblings() {
let mut s = session();
let g1 = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ab", "size": 20}));
let g2 = outlined(&mut s, json!({"x": 70, "y": 100, "text": "ed", "size": 20}));
let (a, b, c) = (children_of(&s, g1)[0], children_of(&s, g1)[1], children_of(&s, g2)[0]);
s.execute("select.set", &json!({"ids": [a, b, c]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["ab", "e"]), "a and b are siblings; e is in another group: {r}");
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(g2)).is_some(), "d's group stays with c's type and d in it");
}
#[test]
fn tracked_type_splits_where_its_spacing_cannot_be_set_again() {
let mut s = session();
let id = s.execute("text.create", &json!({"x": 40, "y": 100, "text": "abe", "size": 30})).unwrap()["id"].as_u64().unwrap();
// Less than half a space: no whole number of spaces makes up the gap (0.4 em would be two
// spaces in this font, and the outlines cannot tell those apart from tracking).
s.execute("text.setRangeStyle", &json!({"id": id, "start": 1, "end": 3, "tracking": 50})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let g = s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let texts: Vec<String> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect();
assert_eq!(texts.concat(), "abe", "{r}");
assert!(texts.len() > 1, "the tracked glyphs are set where the outlines are, not where untracked type puts them: {r}");
assert_eq!(r["unmatched"], json!([]));
}
#[test]
fn a_masked_glyph_stays_an_outline() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let a = children_of(&s, g)[0];
s.edit("test", |d, _| {
let art = vectorcraft_doc::Node::path(d.alloc_id(), vectorcraft_geom::PathData::default(), Default::default());
d.node_mut(NodeId(a)).unwrap().extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(art, true)));
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["B"]), "{r}");
assert_eq!(r["unmatched"], json!([a]));
assert!(s.doc().unwrap().doc.node(NodeId(a)).unwrap().extras().mask.is_some(), "A keeps its mask");
}
#[test]
fn shapes_past_the_limits_are_reported_as_left_out() {
let mut s = session();
let top = outlined(&mut s, json!({"x": 40, "y": 100, "text": "A", "size": 40}));
let deep = outlined(&mut s, json!({"x": 40, "y": 200, "text": "B", "size": 40}));
// B, deeper than Retype looks.
s.edit("test", |d, _| {
let (par, idx, _) = d.position(NodeId(deep)).unwrap();
let mut n = d.node(NodeId(deep)).unwrap().clone();
d.remove(NodeId(deep))?;
for _ in 0..20 {
n = vectorcraft_doc::Node::group(d.alloc_id(), vec![std::sync::Arc::new(n)]);
}
let wrapper = n.id.0;
d.insert(par, idx, n)?;
Ok(wrapper)
})
.map(|w| s.execute("select.set", &json!({"ids": [top, w]})).unwrap())
.unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A"]));
assert_eq!(r["truncated"], json!(true), "{r}");
}
#[test]
fn a_glyph_painted_beyond_what_type_takes_stays_an_outline() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let a = children_of(&s, g)[0];
s.edit("test", |d, _| {
let n = d.node_mut(NodeId(a)).unwrap();
let mut ap = (*n.appearance).clone();
let fill = ap.items.iter().find(|i| i.is_fill()).unwrap().clone();
ap.items.push(fill);
n.appearance = ap.into();
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["B"]), "two fills: A stays an outline: {r}");
assert_eq!(r["unmatched"], json!([a]));
}
#[test]
fn a_hidden_or_locked_glyph_stays_an_outline() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ABD", "size": 40}));
let k = children_of(&s, g);
s.edit("test", |d, _| {
d.node_mut(NodeId(k[0])).unwrap().visible = false;
d.node_mut(NodeId(k[2])).unwrap().locked = true;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["B"]), "{r}");
let d = &s.doc().unwrap().doc;
assert!(!d.node(NodeId(k[0])).unwrap().visible, "A stays a hidden outline");
assert!(d.node(NodeId(k[2])).unwrap().locked, "D stays a locked outline");
}
#[test]
fn an_isolated_or_knockout_group_keeps_its_type_inside() {
for case in ["isolate", "knockout", "knockout_shape"] {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
s.edit("test", |d, _| {
let n = d.node_mut(NodeId(g)).unwrap();
match case {
"isolate" => n.isolate = true,
"knockout" => n.knockout = vectorcraft_doc::Knockout::On,
_ => n.knockout_shape = true,
}
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let id = r["ids"][0].as_u64().unwrap();
assert_eq!(children_of(&s, g), vec![id], "{case}: the group stays, holding the type");
}
}
#[test]
fn type_turned_half_round_stays_one_object() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 300, "y": 200, "text": "Upside", "size": 30, "rotation": 180}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Upside"]), "{r}");
}
#[test]
fn a_drawn_dot_or_bar_beside_type_stays_art() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let dot = s.execute("shape.ellipse", &json!({"x": 300, "y": 60, "width": 8, "height": 8})).unwrap()["id"].as_u64().unwrap();
// A bar that is exactly a hyphen of the font, somewhere else: the worst case.
let bar = outlined(&mut s, json!({"x": 200, "y": 300, "text": "-", "size": 50}));
s.execute("select.set", &json!({"ids": [g, dot, bar]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["AB"]), "{r}");
let un = r["unmatched"].as_array().unwrap();
assert!(un.contains(&json!(dot)) && un.len() == 2, "the dot and the bar stay art: {r}");
// Selected on its own, the hyphen is what was asked for.
s.execute("select.set", &json!({"ids": [bar]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["-"]), "{r}");
}
/// How long Retype takes with a large CJK face to match against (run with `--ignored
/// --nocapture`; skips when no such face is installed). Not a pass/fail budget: it prints.
#[test]
#[ignore = "timing: needs an installed CJK font"]
fn timing_with_a_large_cjk_face() {
let db = vectorcraft_text::FontDb::global();
let Some(family) = ["Microsoft YaHei", "Yu Gothic", "MS Gothic", "Noto Sans CJK JP", "Hiragino Sans"].into_iter().find(|f| db.has_family(f))
else {
eprintln!("skipped: no large CJK font installed");
return;
};
let face = db.resolve(family, "Regular").map(|(f, _)| f).unwrap();
let mut s = session();
let g = outlined(&mut s, json!({"x": 20, "y": 80, "text": "漢字のテスト ABC", "size": 24, "font": family, "style": face.style}));
for run in ["cold", "warm"] {
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let t0 = std::time::Instant::now();
let r = s.execute("type.retype", &json!({"fonts": [family]})).unwrap();
let ms = t0.elapsed().as_secs_f64() * 1000.0;
eprintln!("{run}: Retype with {family} ({} encoded glyphs) loaded: {ms:.0} ms → {}", face.mapped_chars().len(), r["texts"]);
s.execute("edit.undo", &json!({})).unwrap();
}
}
#[test]
fn a_compound_with_a_locked_or_hidden_part_stays_whole() {
let mut s = session();
// "B" outlines as a compound path of three contours.
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let b = children_of(&s, g)[1];
let part = children_of(&s, b)[1];
s.edit("test", |d, _| {
d.node_mut(NodeId(part)).unwrap().locked = true;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A"]), "{r}");
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(part)).unwrap().locked, "B's locked part, and B, stay as they are");
}
#[test]
fn a_group_with_an_attributes_note_keeps_its_type_inside() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
s.execute("attributes.set", &json!({"ids": [g], "note": "logo, keep"})).unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let id = r["ids"][0].as_u64().unwrap();
assert_eq!(children_of(&s, g), vec![id], "the group and its note stay, holding the type");
}
#[test]
fn nothing_retypable_reads_no_font() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "A", "size": 40}));
let a = children_of(&s, g)[0];
s.edit("test", |d, _| {
let art = vectorcraft_doc::Node::path(d.alloc_id(), vectorcraft_geom::PathData::default(), Default::default());
d.node_mut(NodeId(a)).unwrap().extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(art, true)));
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let e = s.execute("type.retype", &json!({})).unwrap_err().to_string();
assert!(e.contains("(1 checked)"), "the masked shape is reported, and no font was indexed: {e}");
}
#[test]
fn tracked_one_contour_letters_still_become_type() {
for text in ["LIT", "HELLO", "LIST"] {
let mut s = session();
let id = s.execute("text.create", &json!({"x": 40, "y": 100, "text": text, "size": 30})).unwrap()["id"].as_u64().unwrap();
let n = text.len() as u64;
s.execute("text.setRangeStyle", &json!({"id": id, "start": 0, "end": n, "tracking": 50})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let g = s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let texts: Vec<String> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect();
assert_eq!(texts.concat(), text, "split by the tracking, every letter still becomes type: {r}");
assert!(texts.len() > 1, "the tracking splits the line: {r}");
assert_eq!(r["unmatched"], json!([]), "{r}");
}
}
/// How long Retype takes on a few hundred CJK outlines at once (run with `--ignored --nocapture`;
/// skips when no large CJK font is installed). Not a pass/fail budget: it prints.
#[test]
#[ignore = "timing: needs an installed CJK font"]
fn timing_with_hundreds_of_cjk_outlines() {
let db = vectorcraft_text::FontDb::global();
let Some(family) = ["Microsoft YaHei", "Yu Gothic", "MS Gothic", "Noto Sans CJK JP", "Hiragino Sans"].into_iter().find(|f| db.has_family(f))
else {
eprintln!("skipped: no large CJK font installed");
return;
};
let face = db.resolve(family, "Regular").map(|(f, _)| f).unwrap();
// 300 common ideographs, ten lines of thirty.
let chars: Vec<char> = (0x4E00u32..).filter_map(char::from_u32).filter(|c| face.covers(*c)).take(300).collect();
let mut s = session();
let mut groups = vec![];
for (i, line) in chars.chunks(30).enumerate() {
let text: String = line.iter().collect();
groups.push(outlined(&mut s, json!({"x": 20, "y": 40 + 30 * i, "text": text, "size": 20, "font": family, "style": face.style})));
}
for run in ["cold", "warm"] {
s.execute("select.set", &json!({"ids": groups})).unwrap();
let t0 = std::time::Instant::now();
let r = s.execute("type.retype", &json!({"fonts": [family]})).unwrap();
let ms = t0.elapsed().as_secs_f64() * 1000.0;
let typed: usize = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().chars().count()).sum();
eprintln!(
"{run}: Retype of {} {family} outlines: {ms:.0} ms → {typed} characters typed, {} unmatched",
chars.len(),
r["unmatched"].as_array().unwrap().len()
);
s.execute("edit.undo", &json!({})).unwrap();
}
}
#[test]
fn a_long_tracked_line_is_checked_in_time() {
// Tracking splits the line at every glyph: the layout check must not lay out the rest of the
// line again after each split.
let text = "abe".repeat(150);
let mut s = session();
let id = s.execute("text.create", &json!({"x": 10, "y": 100, "text": text, "size": 4})).unwrap()["id"].as_u64().unwrap();
s.execute("text.setRangeStyle", &json!({"id": id, "start": 0, "end": text.len(), "tracking": 50})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let g = s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let t0 = std::time::Instant::now();
let r = s.execute("type.retype", &json!({})).unwrap();
let texts: Vec<String> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect();
assert_eq!(texts.concat(), text);
assert_eq!(r["unmatched"], json!([]));
eprintln!("450 tracked glyphs: {:?}, {} objects", t0.elapsed(), texts.len());
}
+39 -16
View File
@@ -1279,40 +1279,63 @@ impl GroupEdit {
/// Rewrite colour group `group` with `colors`: its swatches take them in order (keeping their
/// names, kinds and global or spot flags), a `None` removes the swatch at its place, extra colors
/// are added as new swatches and swatches past the end are removed. Paints linked to its global
/// are added as new swatches and swatches past the end are removed. With `colors_only`, a swatch
/// that is not a color (a gradient, pattern or None swatch) keeps its place and paint and takes no
/// entry of `colors`, which go to the group's color swatches in order. Paints linked to its global
/// swatches follow (a removed swatch's are unlinked); `rename` renames the group. A built-in swatch
/// (None, Registration) it would change or remove is refused.
pub(super) fn rewrite_group(d: &mut Document, group: &str, colors: &[Option<Color>], rename: Option<&str>, cmd: &str) -> Result<GroupEdit> {
pub(super) fn rewrite_group(
d: &mut Document,
group: &str,
colors: &[Option<Color>],
colors_only: bool,
rename: Option<&str>,
cmd: &str,
) -> Result<GroupEdit> {
let gi = d.swatch_groups.iter().position(|g| g.name == group).ok_or_else(|| bad(cmd, format!("no colour group `{group}`")))?;
let name = match rename.map(str::trim).filter(|n| !n.is_empty() && *n != group) {
Some(n) => d.free_swatch_name(n),
None => group.to_string(),
};
let old = &d.swatch_groups[gi].swatches;
// The place in `colors` of each swatch's new color; none for a swatch kept as it is.
let mut taken = 0;
let places: Vec<Option<usize>> = old
.iter()
.map(|w| {
(!colors_only || w.paint.color().is_some()).then(|| {
taken += 1;
taken - 1
})
})
.collect();
let new_color = |place: Option<usize>| place.and_then(|i| colors.get(i).copied().flatten());
if let Some(w) = old
.iter()
.enumerate()
.find(|(i, w)| w.is_reserved() && colors.get(*i).copied().flatten().is_none_or(|c| w.paint.color() != Some(c)))
.map(|x| x.1)
.zip(&places)
.find(|(w, place)| place.is_some() && w.is_reserved() && new_color(**place).is_none_or(|c| w.paint.color() != Some(c)))
.map(|x| x.0)
{
return Err(bad(cmd, format!("`{}` can't be edited or removed", w.name)));
}
let colorized_ok = super::paint::check_colorized(d).is_ok();
let mut relinks = vec![];
let old = std::mem::take(&mut d.swatch_groups[gi].swatches);
let old_len = old.len();
// The swatches that stay, each with its new color.
let mut kept: Vec<(Swatch, Color)> = vec![];
for (i, w) in old.into_iter().enumerate() {
match colors.get(i).copied().flatten() {
Some(c) => kept.push((w, c)),
None if w.global => relinks.push(Relink { from: w.name.clone(), to: w.name, color: None, keep: false }),
None => {}
// The swatches that stay, each with its new color (none for one kept as it is).
let mut kept: Vec<(Swatch, Option<Color>)> = vec![];
for (w, place) in old.into_iter().zip(places) {
match (place, new_color(place)) {
(None, _) => kept.push((w, None)),
(_, Some(c)) => kept.push((w, Some(c))),
(_, None) if w.global => relinks.push(Relink { from: w.name.clone(), to: w.name, color: None, keep: false }),
(_, None) => {}
}
}
let mut swatches = Vec::with_capacity(kept.len());
for (mut w, c) in kept {
if w.paint.color() != Some(c) {
if let Some(c) = c
&& w.paint.color() != Some(c)
{
// A tint swatch becomes a colour of its own.
w.paint = Paint::solid(c);
if w.global {
@@ -1325,7 +1348,7 @@ pub(super) fn rewrite_group(d: &mut Document, group: &str, colors: &[Option<Colo
let mut free = d.free_swatch_names();
free.insert(&name);
swatches.iter().for_each(|w| free.insert(&w.name));
for c in colors.iter().skip(old_len).flatten() {
for c in colors.iter().skip(taken).flatten() {
let nm = free.take(&color_name(*c));
swatches.push(Swatch { name: nm, paint: Paint::solid(*c), global: false, spot: false });
}
@@ -1379,7 +1402,7 @@ fn swatch_edit_group(s: &mut Session, p: &Value) -> Result<Value> {
{
return Ok(json!({"name": group, "swatches": g.swatches.iter().map(|w| w.name.clone()).collect::<Vec<_>>(), "relinked": 0}));
}
let e = s.edit("Edit Color Group", |d, _| rewrite_group(d, group, &colors, rename, C))?;
let e = s.edit("Edit Color Group", |d, _| rewrite_group(d, group, &colors, false, rename, C))?;
e.defaults(s)?;
Ok(json!({"name": e.name, "swatches": e.swatches, "relinked": e.relinked}))
}
+283
View File
@@ -0,0 +1,283 @@
//! `app.toast`: a short message shown over the window that does not stop work and goes away by
//! itself (a toast). Scripts (`vc.run`), actions (a recorded step), MCP clients and plug-ins raise
//! one with the command, and the app's code can raise one with [`Session::toast`]. The engine
//! queues the messages and the desktop app takes them each frame ([`Session::take_toasts`]) and
//! shows them. A failed script run puts the documents back but keeps the messages it raised.
use std::collections::VecDeque;
use serde_json::{Value, json};
use super::{CommandSpec, Result, always, bad, cmd};
use crate::Session;
const ID: &str = "app.toast";
/// The most characters a message has.
pub const MAX_CHARS: usize = 500;
/// How long a message shows when `seconds` is omitted, and the shortest and longest time it may
/// show.
pub const DEFAULT_SECONDS: f64 = 4.0;
pub const MIN_SECONDS: f64 = 0.5;
pub const MAX_SECONDS: f64 = 60.0;
/// The most messages waiting for the app to take them: past it the oldest one goes. A session
/// without a window (the headless MCP server, `vectorcraft-cli run`) never takes them.
pub const MAX_QUEUED: usize = 32;
/// What kind of news a message is, which sets its color.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Level {
#[default]
Info,
Success,
Warning,
Error,
}
impl Level {
pub const ALL: [Level; 4] = [Level::Info, Level::Success, Level::Warning, Level::Error];
/// Its `level` value.
pub fn param(self) -> &'static str {
match self {
Level::Info => "info",
Level::Success => "success",
Level::Warning => "warning",
Level::Error => "error",
}
}
/// The level whose `level` value is `param`.
pub fn from_param(param: &str) -> Option<Level> {
Level::ALL.into_iter().find(|l| l.param() == param)
}
}
/// A message to show.
#[derive(Clone, Debug, PartialEq)]
pub struct Toast {
pub message: String,
pub level: Level,
/// How long it shows, in seconds.
pub seconds: f64,
}
impl Toast {
/// A message of `level` shown for [`DEFAULT_SECONDS`].
pub fn new(message: impl Into<String>, level: Level) -> Toast {
Toast { message: message.into(), level, seconds: DEFAULT_SECONDS }
}
}
/// The messages waiting for the app to show them.
#[derive(Clone, Debug, Default)]
pub struct Queue(VecDeque<Toast>);
impl Session {
/// Queue `toast` for the app to show. With [`MAX_QUEUED`] waiting, the oldest one goes. Its
/// time is held to [`MIN_SECONDS`] to [`MAX_SECONDS`], and a time that is not a number is
/// [`DEFAULT_SECONDS`].
pub fn toast(&mut self, mut toast: Toast) {
toast.seconds = if toast.seconds.is_nan() { DEFAULT_SECONDS } else { toast.seconds.clamp(MIN_SECONDS, MAX_SECONDS) };
while self.toasts.0.len() >= MAX_QUEUED {
self.toasts.0.pop_front();
}
self.toasts.0.push_back(toast);
}
/// Take the messages queued since the last call, oldest first.
pub fn take_toasts(&mut self) -> Vec<Toast> {
self.toasts.0.drain(..).collect()
}
}
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"app.toast",
"Show Message",
[],
None,
"{message: string (1 to 500 characters, not only whitespace), level?: \"info\" | \"success\" | \"warning\" | \"error\" (default \"info\"), seconds?: number 0.5 to 60 (default 4)} show `message` over the window without stopping work: it goes away after `seconds` or when clicked; messages stack at the window's bottom right, the newest lowest, at most 5 at once; edits no document; an action records it as a step → {message, level, seconds}",
always,
run
)]
}
fn run(s: &mut Session, p: &Value) -> Result<Value> {
let toast = parse(p)?;
let r = json!({"message": &toast.message, "level": toast.level.param(), "seconds": toast.seconds});
s.toast(toast);
Ok(r)
}
/// The message `p` asks for; an invalid value of any key is an error.
fn parse(p: &Value) -> Result<Toast> {
let message = match p.get("message") {
Some(Value::String(m)) => m,
Some(_) => return Err(bad(ID, "`message` must be a string")),
None => return Err(bad(ID, "`message` is required")),
};
if message.trim().is_empty() {
return Err(bad(ID, "`message` must have a character other than whitespace"));
}
let chars = message.chars().count();
if chars > MAX_CHARS {
return Err(bad(ID, format!("`message` has {chars} characters; at most {MAX_CHARS} are allowed")));
}
let level = match p.get("level") {
None => Level::default(),
Some(v) => v.as_str().and_then(Level::from_param).ok_or_else(|| {
let all: Vec<&str> = Level::ALL.iter().map(|l| l.param()).collect();
bad(ID, format!("`level` must be one of {}", all.join(", ")))
})?,
};
let seconds = match p.get("seconds") {
None => DEFAULT_SECONDS,
Some(v) => v
.as_f64()
.filter(|s| (MIN_SECONDS..=MAX_SECONDS).contains(s))
.ok_or_else(|| bad(ID, format!("`seconds` must be a number from {MIN_SECONDS} to {MAX_SECONDS}")))?,
};
Ok(Toast { message: message.clone(), level, seconds })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_message_is_queued_with_its_defaults() {
let mut s = Session::new();
let r = s.execute(ID, &json!({"message": "Saved 3 files"})).unwrap();
assert_eq!(r, json!({"message": "Saved 3 files", "level": "info", "seconds": 4.0}));
assert_eq!(s.take_toasts(), vec![Toast::new("Saved 3 files", Level::Info)]);
// Taken once.
assert_eq!(s.take_toasts(), vec![]);
}
#[test]
fn level_and_seconds_are_kept() {
let mut s = Session::new();
for level in Level::ALL {
s.execute(ID, &json!({"message": "m", "level": level.param(), "seconds": 0.5})).unwrap();
}
s.execute(ID, &json!({"message": "long", "seconds": 60})).unwrap();
let got: Vec<(Level, f64)> = s.take_toasts().iter().map(|t| (t.level, t.seconds)).collect();
assert_eq!(got, vec![(Level::Info, 0.5), (Level::Success, 0.5), (Level::Warning, 0.5), (Level::Error, 0.5), (Level::Info, 60.0)]);
}
#[test]
fn invalid_values_are_errors_and_queue_nothing() {
let mut s = Session::new();
let long = "x".repeat(MAX_CHARS + 1);
for p in [
json!({}),
json!({"message": 3}),
json!({"message": ""}),
json!({"message": " \n\t"}),
json!({"message": long}),
json!({"message": "m", "level": "loud"}),
json!({"message": "m", "level": 1}),
json!({"message": "m", "seconds": 0.4}),
json!({"message": "m", "seconds": 61}),
json!({"message": "m", "seconds": "4"}),
json!({"message": "m", "seconds": null}),
] {
let e = s.execute(ID, &p).unwrap_err().to_string();
assert!(e.contains(ID), "{p}: {e}");
}
assert_eq!(s.take_toasts(), vec![]);
// The longest message is allowed, counted in characters, not bytes.
let most = "é".repeat(MAX_CHARS);
s.execute(ID, &json!({"message": most})).unwrap();
assert_eq!(s.take_toasts().len(), 1);
}
#[test]
fn a_message_queued_by_the_app_shows_for_0_5_to_60_seconds() {
let mut s = Session::new();
for seconds in [f64::INFINITY, 1e9, f64::NEG_INFINITY, 0.0, f64::NAN, 10.0] {
s.toast(Toast { seconds, ..Toast::new("m", Level::Info) });
}
let got: Vec<f64> = s.take_toasts().iter().map(|t| t.seconds).collect();
assert_eq!(got, vec![MAX_SECONDS, MAX_SECONDS, MIN_SECONDS, MIN_SECONDS, DEFAULT_SECONDS, 10.0]);
}
#[test]
fn the_oldest_waiting_message_goes_past_the_limit() {
let mut s = Session::new();
for i in 0..MAX_QUEUED + 2 {
s.toast(Toast::new(format!("{i}"), Level::Info));
}
let left: Vec<String> = s.take_toasts().into_iter().map(|t| t.message).collect();
assert_eq!(left.len(), MAX_QUEUED);
assert_eq!(left.first().map(String::as_str), Some("2"));
assert_eq!(left.last().map(String::as_str), Some("33"));
}
#[test]
fn a_message_is_journaled_without_an_undo_step_or_a_document() {
let mut s = Session::new();
// No document open.
s.execute(ID, &json!({"message": "no document"})).unwrap();
assert_eq!(s.journal.last().unwrap(), &(ID.to_string(), json!({"message": "no document"})));
s.execute("file.new", &json!({})).unwrap();
let undo = s.active().unwrap().history.undo.len();
let revision = s.active().unwrap().revision;
s.execute(ID, &json!({"message": "m", "level": "success"})).unwrap();
assert_eq!(s.journal.last().unwrap(), &(ID.to_string(), json!({"message": "m", "level": "success"})));
assert_eq!(s.active().unwrap().history.undo.len(), undo);
assert_eq!(s.active().unwrap().revision, revision);
}
#[test]
fn a_script_raises_a_message_with_vc_run() {
let mut s = Session::new();
let r = s
.execute(
"script.run",
&json!({"source": "vc.run('app.toast', {message: 'Done: ' + (1 + 1), level: 'success'});", "name": "t.js", "answers": []}),
)
.unwrap();
assert!(r.get("error").is_none_or(Value::is_null), "{r}");
assert_eq!(s.take_toasts(), vec![Toast::new("Done: 2", Level::Success)]);
}
#[test]
fn a_failed_script_run_puts_the_documents_back_and_keeps_its_messages() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
let art = format!("{:?}", s.active().unwrap().doc.layers);
let e = s
.execute(
"script.run",
&json!({
"source": "vc.run('shape.rectangle', {x: 0, y: 0, width: 10, height: 10}); vc.run('app.toast', {message: 'Failed: no artboard'}); throw new Error('stop');",
"name": "t.js",
"answers": [],
}),
)
.unwrap_err()
.to_string();
assert!(e.contains("stop"), "{e}");
assert_eq!(format!("{:?}", s.active().unwrap().doc.layers), art, "the rectangle is put back");
assert_eq!(s.take_toasts(), vec![Toast::new("Failed: no artboard", Level::Info)]);
}
#[test]
fn a_command_batch_raises_its_messages_in_order() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
s.execute(
"command.batch",
&json!({"commands": [
{"command": "app.toast", "params": {"message": "one"}},
{"command": "app.toast", "params": {"message": "two", "level": "warning"}},
]}),
)
.unwrap();
assert_eq!(s.take_toasts(), vec![Toast::new("one", Level::Info), Toast::new("two", Level::Warning)]);
}
}
+200 -64
View File
@@ -10,8 +10,8 @@ use super::object::choice;
use super::threads::ThreadIndex;
use super::typecmd::{area_text, block_gaps, needed_room, refresh_bounds};
use super::{
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, named_ids,
number_or, switch_or, targets, text_param,
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, index_opt,
named_ids, number_or, object_param, switch_or, targets, text_param,
};
pub fn specs() -> Vec<CommandSpec> {
@@ -120,7 +120,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Find and Replace…",
["Edit"],
None,
"{find, replace?: \"\", matchCase?: false, wholeWord?: false, ids?} replace in every text object (or ids) → {count}. Matches never span style runs.",
"{find, replace?: \"\", matchCase?: false, wholeWord?: false, hiddenLayers?: false, lockedLayers?: false, ids?} replace every match in the type the search reaches (or in ids, whatever their layers), as one undo step → {count (every match), replaced (the matches that did not already read as `replace`)}. The search reaches visible, unlocked type on visible, unlocked layers, off locked artboards; hiddenLayers adds the type of hidden layers and sublayers and lockedLayers that of locked ones, while a hidden or locked object or group keeps its type out. Matches never span style runs. When nothing matches, or every match already reads as `replace`, nothing changes and no undo step is recorded.",
has_doc,
find_replace
),
@@ -129,10 +129,19 @@ pub fn specs() -> Vec<CommandSpec> {
"Find Next",
["Edit"],
None,
"{find, matchCase?, wholeWord?} select the next text object (after the selected one, wrapping) containing `find` → {id|null}",
"{find, matchCase?: false, wholeWord?: false, backwards?: false, hiddenLayers?: false, lockedLayers?: false, from?: {id, start, end} (a match this command returned, or the range edit.replaceMatch returned)} find the next match of `find` in the type edit.findReplace reaches and select its type object → {id, start, end (the match's bytes in the object's plain text), index (its place among all the matches, from 1), count, selected} or {id: null, count: 0}. The search visits type objects from the top of the stacking order down and each object's matches in reading order; backwards visits the objects from the bottom up and each object's matches from the last. It goes on after `from` and, past the last match, starts again at the first. Without `from` it goes on after the first selected type object, and with no type selected, or with a null `from`, it starts at the first match. A match on a hidden or locked layer is returned with selected false and the selection stays as it is. Nothing is recorded for undo.",
has_doc,
find_next
),
cmd!(
"edit.replaceMatch",
"Replace",
[],
None,
"{find, replace?: \"\", matchCase?: false, wholeWord?: false, id, start, end} replace one match of `find`, the bytes start..end of type object id as edit.findNext returns them, with `replace`, as one undo step → {id, start, end (the replacement's bytes; pass them to edit.findNext as `from` to go on), replaced}. Bytes that are no match of `find` are refused. When the match already reads as `replace`, nothing changes, no undo step is recorded and replaced is false.",
has_doc,
replace_one
),
cmd!(
"edit.pasteWithoutFormatting",
"Paste without Formatting",
@@ -1657,14 +1666,9 @@ fn is_word(c: char) -> bool {
c.is_alphanumeric() || c == '_'
}
/// Byte ranges of `needle` in `hay`.
pub(crate) fn find_all(hay: &str, needle: &str, match_case: bool, whole_word: bool) -> Vec<(usize, usize)> {
find_all_between(hay, needle, match_case, whole_word, None, None)
}
/// [`find_all`] in run `i` of `runs`: a whole word looks past the run's ends at the characters
/// next to it, so a change of style inside a word is not a word boundary (#5901). Matches stay
/// inside the run.
/// Byte ranges of `needle` in run `i` of `runs`: a whole word looks past the run's ends at the
/// characters next to it, so a change of style inside a word is not a word boundary (#5901).
/// Matches stay inside the run.
fn find_in_run(runs: &[TextRun], i: usize, needle: &str, match_case: bool, whole_word: bool) -> Vec<(usize, usize)> {
let Some(run) = runs.get(i) else { return vec![] };
let before = runs.get(..i).and_then(|r| r.iter().rev().find_map(|r| r.text.chars().next_back()));
@@ -1672,8 +1676,8 @@ fn find_in_run(runs: &[TextRun], i: usize, needle: &str, match_case: bool, whole
find_all_between(&run.text, needle, match_case, whole_word, before, after)
}
/// [`find_all`], with `before` and `after` the characters on either side of `hay` (none at the
/// text's ends), which a whole word must not touch either.
/// Byte ranges of `needle` in `hay`, with `before` and `after` the characters on either side of
/// `hay` (none at the text's ends), which a whole word must not touch either.
fn find_all_between(hay: &str, needle: &str, match_case: bool, whole_word: bool, before: Option<char>, after: Option<char>) -> Vec<(usize, usize)> {
let nc: Vec<char> = needle.chars().collect();
if nc.is_empty() {
@@ -1705,102 +1709,234 @@ fn find_all_between(hay: &str, needle: &str, match_case: bool, whole_word: bool,
/// The visible, unlocked type objects of visible, unlocked layers, off locked artboards, in paint
/// order: the text Find and Replace and Check Spelling go through.
pub(crate) fn all_texts(d: &Document) -> Vec<NodeId> {
fn visit(n: &Node, locks: &LockedArtboards<'_>, v: &mut Vec<NodeId>) {
if !n.visible || n.locked {
searched_texts(d, false, false)
}
/// [`all_texts`], with the type of hidden layers (`hidden_layers`) and of locked layers
/// (`locked_layers`) as well, as Check Hidden Layers and Check Locked Layers of Find and Replace
/// ask. The switches are about layers and sublayers: a hidden or locked object or group keeps its
/// type out, and so does a locked artboard.
fn searched_texts(d: &Document, hidden_layers: bool, locked_layers: bool) -> Vec<NodeId> {
fn visit(n: &Node, locks: &LockedArtboards<'_>, layers: (bool, bool), v: &mut Vec<NodeId>) {
let layer = matches!(n.kind, NodeKind::Layer { .. });
if (!n.visible && !(layer && layers.0)) || (n.locked && !(layer && layers.1)) {
return;
}
if matches!(n.kind, NodeKind::Text(_)) && !locks.holds_id(n.id) {
v.push(n.id);
}
for c in n.children().into_iter().flatten() {
visit(c, locks, v);
visit(c, locks, layers, v);
}
}
let mut v = vec![];
let locks = d.locked_artboards();
for l in &d.layers {
visit(l, &locks, &mut v);
visit(l, &locks, (hidden_layers, locked_layers), &mut v);
}
v
}
/// What Find and Replace looks for: the text, Match Case and Find Whole Word.
struct Query {
find: String,
match_case: bool,
whole_word: bool,
}
impl Query {
/// The `find`, `matchCase` and `wholeWord` params of command `c`. An empty or missing `find`
/// is an error.
fn of(p: &Value, c: &str) -> Result<Self> {
let find = text_param(p, "find", c)?.filter(|f| !f.is_empty()).ok_or_else(|| bad(c, "missing `find`"))?.to_string();
Ok(Self { find, match_case: switch_or(p, "matchCase", false, c)?, whole_word: switch_or(p, "wholeWord", false, c)? })
}
/// The matches in `t`, in reading order, each as (run, start, end) with `start..end` the bytes
/// of the match in the object's plain text. A match stays inside one style run, and an inline
/// graphic is art, not characters to find.
fn matches(&self, t: &TextObject) -> Vec<(usize, usize, usize)> {
let mut hits = vec![];
let mut base = 0;
for (ri, r) in t.runs.iter().enumerate() {
if r.inline.is_none() {
hits.extend(
find_in_run(&t.runs, ri, &self.find, self.match_case, self.whole_word).into_iter().map(|(a, b)| (ri, base + a, base + b)),
);
}
base += r.text.len();
}
hits
}
}
/// Replace bytes `start..end` of the plain text of `t`, which lie inside run `run`, with `rep`.
/// The paragraph styles and the ruby follow the edit, as `text.editRange` moves them. The caller
/// refreshes the bounds.
fn replace_match(t: &mut TextObject, run: usize, start: usize, end: usize, rep: &str) {
let base: usize = t.runs.iter().take(run).map(|r| r.text.len()).sum();
let (Some(a), Some(b)) = (start.checked_sub(base), end.checked_sub(base)) else { return };
if !t.runs.get(run).is_some_and(|r| a <= b && r.text.is_char_boundary(a) && r.text.is_char_boundary(b)) {
return;
}
t.splice_paras(start, end, rep);
if let Some(r) = t.runs.get_mut(run) {
r.text.replace_range(a..b, rep);
}
t.ruby_after_replace(start, end, rep.len());
}
fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.findReplace";
let find = text_param(p, "find", C)?.filter(|f| !f.is_empty()).ok_or_else(|| bad(C, "missing `find`"))?.to_string();
let q = Query::of(p, C)?;
let rep = text_param(p, "replace", C)?.unwrap_or("").to_string();
let (mc, ww) = (switch_or(p, "matchCase", false, C)?, switch_or(p, "wholeWord", false, C)?);
let (hidden, locked) = (switch_or(p, "hiddenLayers", false, C)?, switch_or(p, "lockedLayers", false, C)?);
let ids = match p.get("ids").filter(|v| !v.is_null()) {
Some(_) => text_ids(&s.doc()?.doc, &checked_ids_param(s, p, "ids", C)?),
None => all_texts(&s.doc()?.doc),
None => searched_texts(&s.doc()?.doc, hidden, locked),
};
let st = s.doc()?;
let total: usize = ids
// Every match, and the matches that do not already read as the replacement.
let (total, replaced) = ids
.iter()
.filter_map(|id| match &st.doc.node(*id)?.kind {
NodeKind::Text(t) => Some((0..t.runs.len()).map(|i| find_in_run(&t.runs, i, &find, mc, ww).len()).sum::<usize>()),
NodeKind::Text(t) => {
let plain = t.plain_text();
let hits = q.matches(t);
Some((hits.len(), hits.iter().filter(|(_, a, b)| plain.get(*a..*b) != Some(rep.as_str())).count()))
}
_ => None,
})
.sum();
if total == 0 {
return Ok(json!({ "count": 0 }));
.fold((0, 0), |(n, r), (hn, hr)| (n + hn, r + hr));
if replaced == 0 {
return Ok(json!({ "count": total, "replaced": 0 }));
}
super::overprint::edit_counted(s, "Replace", |d| {
let mut changed = 0;
for id in &ids {
let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
// Matches as (run, start, end) with offsets inside the run. Inline graphics are art, not
// characters to rewrite.
let mut hits = vec![];
let mut base = 0;
for (ri, r) in t.runs.iter().enumerate() {
if r.inline.is_none() {
for (a, b) in find_in_run(&t.runs, ri, &find, mc, ww) {
if r.text.get(a..b) != Some(rep.as_str()) {
hits.push((ri, base + a, base + b, a, b));
}
}
}
base += r.text.len();
}
let plain = t.plain_text();
let hits: Vec<_> = q.matches(t).into_iter().filter(|(_, a, b)| plain.get(*a..*b) != Some(rep.as_str())).collect();
if hits.is_empty() {
continue;
}
// Last match first, so the offsets of earlier ones stay valid. The paragraph styles follow
// each edit, as `text.editRange` does.
for (ri, ta, tb, a, b) in hits.into_iter().rev() {
t.splice_paras(ta, tb, &rep);
if let Some(r) = t.runs.get_mut(ri) {
r.text.replace_range(a..b, &rep);
}
// Last match first, so the offsets of earlier ones stay valid.
for (ri, a, b) in hits.into_iter().rev() {
replace_match(t, ri, a, b, &rep);
}
changed += 1;
refresh_bounds(t);
}
Ok(changed)
})?;
Ok(json!({ "count": total }))
Ok(json!({ "count": total, "replaced": replaced }))
}
/// A match of Find and Replace: bytes `start..end` of the plain text of type object `id`.
#[derive(Clone, Copy)]
struct Match {
id: NodeId,
start: usize,
end: usize,
}
impl Match {
/// The `id`, `start` and `end` that `p` gives for a match, under command `c`: an object id and
/// two byte offsets, put in order as `text.editRange` orders its own.
fn of(p: &Value, c: &str) -> Result<Self> {
let whole = |key: &str| index_opt(p, key, c)?.ok_or_else(|| bad(c, format!("missing `{key}`")));
let id = object_param(p, "id", c)?.ok_or_else(|| bad(c, "missing `id`"))?;
let (start, end) = (whole("start")?, whole("end")?);
Ok(Self { id, start: start.min(end), end: start.max(end) })
}
}
fn find_next(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.findNext";
let find = text_param(p, "find", C)?.filter(|f| !f.is_empty()).ok_or_else(|| bad(C, "missing `find`"))?.to_string();
let (mc, ww) = (switch_or(p, "matchCase", false, C)?, switch_or(p, "wholeWord", false, C)?);
let q = Query::of(p, C)?;
let backwards = switch_or(p, "backwards", false, C)?;
let (hidden, locked) = (switch_or(p, "hiddenLayers", false, C)?, switch_or(p, "lockedLayers", false, C)?);
// A `from` that is no object gives no `id`, and is refused as one without it. A null `from`
// starts at the first match, whatever is selected.
let from = match p.get("from") {
None => None,
Some(Value::Null) => Some(None),
Some(v) => Some(Some(Match::of(v, C)?)),
};
let st = s.doc()?;
let all = all_texts(&st.doc);
let cur = st.selection.objects.first().and_then(|id| all.iter().position(|x| x == id));
let n = all.len();
let start = cur.map(|c| c + 1).unwrap_or(0);
let hit = (0..n).map(|k| all[(start + k) % n.max(1)]).find(|id| match st.doc.node(*id).map(|n| &n.kind) {
Some(NodeKind::Text(t)) => !find_all(&t.plain_text(), &find, mc, ww).is_empty(),
_ => false,
});
match hit {
Some(id) => {
s.select(|_, sel| sel.set([id]))?;
Ok(json!({ "id": id.0 }))
}
None => Ok(json!({ "id": null })),
// The objects in the order the search visits them: from the top of the stacking order down,
// or with Search Backwards from the bottom up.
let mut order = searched_texts(&st.doc, hidden, locked);
if !backwards {
order.reverse();
}
// Every match in that order as (object's place, match): inside an object in reading order, or
// with Search Backwards from its end.
let mut all: Vec<(usize, Match)> = vec![];
for (place, id) in order.iter().enumerate() {
let Some(NodeKind::Text(t)) = st.doc.node(*id).map(|n| &n.kind) else { continue };
let mut hits = q.matches(t);
if backwards {
hits.reverse();
}
all.extend(hits.into_iter().map(|(_, start, end)| (place, Match { id: *id, start, end })));
}
if all.is_empty() {
return Ok(json!({ "id": null, "count": 0 }));
}
// The search goes on from `from`, or from the whole of the first selected type object it
// visits, so that the same call again reaches the next object. From anywhere else it starts
// at the first match.
let from = from.unwrap_or_else(|| {
st.selection.objects.iter().filter(|id| order.contains(id)).find_map(|id| match &st.doc.node(*id)?.kind {
NodeKind::Text(t) => Some(Match { id: *id, start: 0, end: t.runs.iter().map(|r| r.text.len()).sum() }),
_ => None,
})
});
let after = |(place, m): &(usize, Match), at: usize, f: &Match| {
*place > at || (*place == at && if backwards { m.end <= f.start } else { m.start >= f.end })
};
let k = from
.and_then(|f| order.iter().position(|id| *id == f.id).map(|at| (at, f)))
.and_then(|(at, f)| all.iter().position(|hit| after(hit, at, &f)))
.unwrap_or(0);
let Some((_, m)) = all.get(k).copied() else { return Ok(json!({ "id": null, "count": 0 })) };
let count = all.len();
// Type that a selection tool can't reach (on a hidden or locked layer) is found without being
// selected.
let selected = all_texts(&st.doc).contains(&m.id);
if selected && st.selection.objects != [m.id] {
s.select(|_, sel| sel.set([m.id]))?;
}
let index = if backwards { count - k } else { k + 1 };
Ok(json!({ "id": m.id.0, "start": m.start, "end": m.end, "index": index, "count": count, "selected": selected }))
}
fn replace_one(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.replaceMatch";
let q = Query::of(p, C)?;
let rep = text_param(p, "replace", C)?.unwrap_or("").to_string();
let m = Match::of(p, C)?;
let st = s.doc()?;
let t = match st.doc.node(m.id).map(|n| &n.kind) {
Some(NodeKind::Text(t)) => t,
Some(_) => return Err(bad(C, format!("node {} is not text", m.id.0))),
None => return Err(EngineError::NoNode(m.id)),
};
let Some((run, ..)) = q.matches(t).into_iter().find(|(_, a, b)| (*a, *b) == (m.start, m.end)) else {
return Err(bad(C, format!("no match of `find` at bytes {}..{} of object {}", m.start, m.end, m.id.0)));
};
let end = m.start + rep.len();
if t.plain_text().get(m.start..m.end) == Some(rep.as_str()) {
return Ok(json!({ "id": m.id.0, "start": m.start, "end": end, "replaced": false }));
}
s.edit("Replace", |d, _| {
let Some(NodeKind::Text(t)) = d.node_mut(m.id).map(|n| &mut n.kind) else { return Err(EngineError::NoNode(m.id)) };
replace_match(t, run, m.start, m.end, &rep);
refresh_bounds(t);
Ok(())
})?;
Ok(json!({ "id": m.id.0, "start": m.start, "end": end, "replaced": true }))
}
// ---------- Paste without Formatting ----------
+6 -2
View File
@@ -29,6 +29,7 @@ use vectorcraft_tools::{PaintDefaults, Tool};
pub use cmd::clipboard::{Clipboard, SourceLayer};
pub use cmd::create::constrain_click;
pub use cmd::distortcmds::{perspective_click, width_point_pair};
pub use cmd::flare::flare_settings;
pub use cmd::graph::{GraphTypeSubject, calculated_axes as graph_calculated_axes, graph_type_subject};
pub use cmd::params::{check_keys, check_params};
pub use cmd::pathops::auto_simplify_level;
@@ -198,7 +199,8 @@ pub struct Session {
/// `plugin.install` takes `grant` and `allowHeavy` from any request
/// ([`Session::allow_plugin_grants_from_requests`]).
plugin_grants_from_requests: bool,
/// URLs recently given in the Attributes panel (`attributes.set {url}`), newest first; not saved.
/// URLs recently given in the Attributes panel (`attributes.set {url}`), newest first, at most
/// [`cmd::RECENT_URLS`]; not saved.
pub recent_urls: Vec<String>,
/// The saved tracing presets' revision and latest changes ([`Session::trace_presets_revision`]).
pub(crate) trace_preset_changes: cmd::TracePresetChanges,
@@ -360,6 +362,8 @@ pub struct Session {
/// Set while [`Session::tool_typed_text`] passes keyboard input to the active tool
/// ([`vectorcraft_tools::ToolContext::typed_from_keyboard`]).
keyboard_text: bool,
/// The messages `app.toast` and [`Session::toast`] queued for the app to show; not saved.
pub(crate) toasts: cmd::toast::Queue,
}
impl Default for Session {
@@ -415,7 +419,7 @@ use history::history_budget_for;
pub use history::{History, HistoryEntry, NamedStep, default_history_budget};
pub(crate) use interaction::PreviewCopies;
pub use interaction::{Interaction, LastTransform, UndoGroup, UndoScope};
pub use prefs::{DrawMode, PluginBudget, Prefs};
pub use prefs::{DrawMode, KEY_HOLD_DELAY, KEY_HOLD_DELAY_RANGE, PluginBudget, Prefs};
pub use sanity::TOO_DEEP;
pub(crate) use sanity::{deselect_hidden, is_guide_path};
#[cfg(test)]
+24
View File
@@ -97,6 +97,13 @@ pub struct Prefs {
/// A single-key tool shortcut held down chooses its tool until the key is let go, and then the
/// tool active before comes back; a quick press chooses the tool for good.
pub hold_tool_keys: bool,
/// Hold shortcuts act (Edit › Keyboard Shortcuts › Hold Shortcuts, off by default): a key with a
/// hold shortcut runs it when held for [`Self::key_hold_delay`], and its own shortcut when let go
/// sooner. Off, every key runs on its press and the dialog shows no Hold column.
pub hold_shortcuts: bool,
/// Seconds a key with a hold shortcut must stay down before the hold shortcut runs (Hold
/// Shortcut Delay, 0.2 to 1.0). VectorCraft's own default, 0.35.
pub key_hold_delay: f64,
/// With View › Show Bounding Box on, the bounding box stays visible while a drag moves the
/// selection, and the shape tools that show it draw it around the shape being drawn. Off (the
/// default), it hides during a move and while a shape is drawn, except that a Selection tool
@@ -420,6 +427,21 @@ pub struct Prefs {
pub import_matches: Vec<cmd::importmatches::ImportMatch>,
}
/// The default Hold Shortcut Delay, in seconds (VectorCraft's own value).
pub const KEY_HOLD_DELAY: f64 = 0.35;
/// The range of the Hold Shortcut Delay, in seconds.
pub const KEY_HOLD_DELAY_RANGE: (f64, f64) = (0.2, 1.0);
impl Prefs {
/// The Hold Shortcut Delay in seconds, inside its range. A restored settings file is not
/// checked against the range, so a value outside it is brought inside, and one that is not a
/// number gives the default.
pub fn key_hold_delay(&self) -> f64 {
let (min, max) = KEY_HOLD_DELAY_RANGE;
if self.key_hold_delay.is_finite() { self.key_hold_delay.clamp(min, max) } else { KEY_HOLD_DELAY }
}
}
impl Default for Prefs {
fn default() -> Self {
let s = |v: &str| v.to_string();
@@ -451,6 +473,8 @@ impl Default for Prefs {
scrub_numeric_fields: true,
trackpad_rotate_view: true,
hold_tool_keys: true,
hold_shortcuts: false,
key_hold_delay: KEY_HOLD_DELAY,
bounding_box_while_moving_and_drawing: false,
paste_offset: 10.0,
selection_tolerance: 3.0,
+33 -15
View File
@@ -1559,12 +1559,14 @@ fn kind_id(kind: &RunErrorKind) -> &'static str {
}
}
/// `message`, with what to do about a failure that comes from a script written for another program.
fn explained(kind: &RunErrorKind, message: &str) -> String {
/// `e`'s message, with what to do about a failure that comes from a script written for another
/// program. A message the script supplied itself ([`RunError::authored`]) is given as it is.
fn explained(e: &RunError) -> String {
const HOST_OBJECTS: &[&str] = &["app", "Window", "BridgeTalk", "activeDocument", "documents"];
let message = &e.message;
let names_host_object =
message.strip_prefix("ReferenceError: ").is_some_and(|m| HOST_OBJECTS.iter().any(|o| m.split_whitespace().next() == Some(o)));
if *kind == RunErrorKind::Thrown && names_host_object {
if e.kind == RunErrorKind::Thrown && !e.authored && names_host_object {
format!("{message} (scripts here use the `vc` object; objects other applications give their scripts are not available)")
} else {
message.to_string()
@@ -1582,7 +1584,7 @@ fn preprocessor_error(f: include::Failure) -> (RunError, Option<Arc<str>>) {
include::FailKind::Limit => (RunErrorKind::Limit(LimitKind::Host), f.message),
};
let file = (f.index > 0).then_some(f.file);
(RunError { kind, message, line: f.line, column: f.column }, file)
(RunError { kind, message, line: f.line, column: f.column, authored: false }, file)
}
/// `e`, the error `realm` raised in the run of `host`, at the line and column of the file it is in,
@@ -1591,20 +1593,20 @@ fn located(host: &Host, realm: &Realm, e: &RunError) -> (RunError, Option<Arc<st
let map = |m: &include::SourceMap| {
let (index, file, line, column) = m.locate(e.line, e.column);
let message = if e.kind == RunErrorKind::Syntax { relocated(&e.message, e.line, e.column, line, column) } else { e.message.clone() };
(RunError { kind: e.kind.clone(), message, line, column }, index, file)
(RunError { kind: e.kind.clone(), message, line, column, authored: e.authored }, index, file)
};
// An error `$.evalFile` raised for a file it could not run, and no script caught, is at that
// file's place.
if let Some((file, line, column)) = realm.error_mark().and_then(|m| host.eval_failures.borrow().get(m as usize).cloned()) {
let message = if e.kind == RunErrorKind::Syntax { relocated(&e.message, e.line, e.column, line, column) } else { e.message.clone() };
return (RunError { kind: e.kind.clone(), message, line, column }, Some(file));
return (RunError { kind: e.kind.clone(), message, line, column, authored: e.authored }, Some(file));
}
if e.line == 0 {
return (e.clone(), None);
}
// An error in code from a source whose map is not at hand, such as code that `eval` compiled,
// is given without a place.
let unplaced = || (RunError { kind: e.kind.clone(), message: e.message.clone(), line: 0, column: 0 }, None);
let unplaced = || (RunError { line: 0, column: 0, ..e.clone() }, None);
match realm.error_source() {
0 => {
let (e, index, file) = map(&host.script_map.borrow());
@@ -1777,6 +1779,15 @@ impl Session {
self.script_report.as_ref().filter(|r| r["ok"] == false).map(failure_text)
}
/// [`Self::script_failure_text`] split around the message when that message is text the script
/// supplied itself (`messageOrigin` `script`): the text before it, the message and the text after
/// it. `None` when the last run did not fail, or failed with one of the app's own errors.
pub fn script_authored_failure(&self) -> Option<(String, &str, String)> {
let r = self.script_report.as_ref().filter(|r| r["ok"] == false && r["messageOrigin"] == "script")?;
let (before, after) = failure_frame(r);
Some((before, r["message"].as_str().unwrap_or_default(), after))
}
/// Has the running script used up its growth allowance, so a person must answer? A run asked
/// to stop no longer waits: the next [`Session::script_pump`] ends it.
pub fn script_waiting(&self) -> bool {
@@ -1873,7 +1884,7 @@ impl Session {
};
drop(key);
let kind = LimitKind::Interrupted;
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0, authored: false };
let _ = self.script_failed(job, &e);
true
}
@@ -2120,14 +2131,14 @@ impl Session {
// A stop while a dialog waits ends the run there; the interpreter cannot go on from the call.
if job.realm.waits() {
let kind = LimitKind::Interrupted;
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0, authored: false };
return Some(self.script_failed(job, &e));
}
job.host.calls_this_slice.set(0);
let outcome = run_slice(self, &mut job);
match outcome {
Err(panic) => {
let e = RunError { kind: RunErrorKind::Internal, message: panic, line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Internal, message: panic, line: 0, column: 0, authored: false };
Some(self.script_failed(job, &e))
}
Ok(Err(e)) => Some(self.script_failed(job, &e)),
@@ -2144,7 +2155,7 @@ impl Session {
} else {
format!("`answers` has {n} answers the script did not use")
};
Some(self.script_failed(job, &RunError { kind: RunErrorKind::Limit(kind), message, line: 0, column: 0 }))
Some(self.script_failed(job, &RunError { kind: RunErrorKind::Limit(kind), message, line: 0, column: 0, authored: false }))
}
Ok(Ok(Progress::Done(_))) => {
let r = self.script_commit(job);
@@ -2179,7 +2190,7 @@ impl Session {
let unwritten = job.host.flush_files();
if !unwritten.is_empty() {
let message = format!("{UNWRITTEN_FILES}: {}", unwritten.join(", "));
let e = RunError { kind: RunErrorKind::Thrown, message, line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Thrown, message, line: 0, column: 0, authored: false };
return self.script_failed(job, &e);
}
// The working copy goes into the session; `job.world` holds the state before the run.
@@ -2197,7 +2208,7 @@ impl Session {
if changed && (!crate::sanity::doc_sane(&st.doc, &st.selection) || st.doc.too_deep(None)) {
job.world.docs = start;
job.world.swap(self);
let e = RunError { kind: RunErrorKind::Internal, message: INVALID_RESULT.to_string(), line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Internal, message: INVALID_RESULT.to_string(), line: 0, column: 0, authored: false };
return self.script_failed(job, &e);
}
}
@@ -2302,7 +2313,8 @@ fn failure_report(name: &str, e: &RunError, file: Option<&str>, host: &Host, fue
let mut report = json!({
"ok": false,
"kind": kind_id(&e.kind),
"message": explained(&e.kind, &e.message),
"message": explained(e),
"messageOrigin": if e.authored { "script" } else { "built-in" },
"name": name,
"line": e.line,
"column": e.column,
@@ -2395,6 +2407,12 @@ fn close_run(s: &mut Session, host: &Host, report: &mut Value, ending: console::
/// The text of a failed run's error.
fn failure_text(report: &Value) -> String {
let (before, after) = failure_frame(report);
format!("{before}{}{after}", report["message"].as_str().unwrap_or_default())
}
/// The text of a failed run's error before its message and after it.
fn failure_frame(report: &Value) -> (String, String) {
let s = |k: &str| report[k].as_str().unwrap_or_default();
let (line, column) = (report["line"].as_u64().unwrap_or(0), report["column"].as_u64().unwrap_or(0));
let at = match report["file"].as_str() {
@@ -2409,7 +2427,7 @@ fn failure_text(report: &Value) -> String {
} else {
String::new()
};
format!("{}{at}: {} ({}){kept}", s("name"), s("message"), s("kind"))
(format!("{}{at}: ", s("name")), format!(" ({}){kept}", s("kind")))
}
/// A run's slice: the working copy in, the real session lent to the host functions, one measured
+2 -2
View File
@@ -149,6 +149,7 @@ impl Session {
global_edit_options: Default::default(),
select_similar: crate::cmd::SIMILAR[0].0,
keyboard_text: false,
toasts: Default::default(),
script_key: None,
script_engines: crate::script::EnginesKey::new(),
script_stop: vectorcraft_js::Interrupt::new(),
@@ -204,8 +205,7 @@ impl Session {
let _ = self.finish_tool_edit_later();
// The switch goes on whatever the lent tool's last actions did, as for the deactivation.
let _ = self.give_back_tool(view);
let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
let _ = self.apply_actions(acts);
let _ = self.deactivate_tool(view);
// A batch leaves its interaction open in the document it leaves, to keep or roll back with
// the rest of the batch; anything else in progress (a drag) is cancelled.
if self.batch_stash.is_none() {
+293
View File
@@ -3393,6 +3393,149 @@ fn flare_rotation_turns_only_the_rays() {
}
}
/// A flare keeps its settings: `shape.editFlare` draws it again with the settings changed, in its
/// place and transformed as it has been since, as one undo step (none when nothing changes). A
/// flare with a changed part, a locked one and an expanded one are not edited.
#[test]
fn edit_flare_draws_a_transformed_flare_again_in_its_place_in_one_undo_step() {
let mut s = session();
let p = json!({"cx": 200, "cy": 200, "diameter": 60, "rays": 9, "rings": 4, "x2": 400, "y2": 200, "seed": 3});
let id = NodeId(s.execute("shape.flare", &p).unwrap()["id"].as_u64().unwrap());
// Reflected twice, sheared and back, turned a quarter and moved: it stays a flare.
for (c, p) in [
("object.reflect", json!({"axis": "vertical"})),
("object.reflect", json!({"axis": "horizontal"})),
("object.shear", json!({"angle": 30})),
("object.shear", json!({"angle": -30})),
("object.rotate", json!({"angle": 90})),
("object.move", json!({"dx": 50, "dy": 10})),
] {
s.execute(c, &p).unwrap();
}
let spec = |s: &Session| flare_settings(&s.doc().unwrap().doc, id).expect("still a flare");
let part = |s: &Session, name: &str| {
let g = s.doc().unwrap().doc.node(id).unwrap();
g.children().unwrap().iter().filter(|c| c.name.as_deref() == Some(name)).map(|c| c.geometric_bounds().unwrap()).collect::<Vec<_>>()
};
let (c, e) = (spec(&s).center().unwrap(), spec(&s).end().unwrap());
// The quarter turn made the rings run vertically, 200 points from the center.
assert!((c.distance(e) - 200.0).abs() < 1e-6 && (c.x - e.x).abs() < 1e-6, "{c:?} {e:?}");
let undo = s.doc().unwrap().history.undo.len();
s.execute("shape.editFlare", &json!({"diameter": 100, "rings": 6, "rays": 0})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
assert_eq!(s.doc().unwrap().selection.objects, vec![id]);
let centre = part(&s, "Center")[0];
assert!(centre.center().distance(c) < 1e-6 && (centre.width() - 100.0).abs() < 1e-6, "{centre:?}");
assert_eq!((part(&s, "Ring").len(), part(&s, "Rays").len()), (6, 0));
assert!(spec(&s).end().unwrap().distance(e) < 1e-6, "the end point stays");
// Each ring lies on the line from the center to the end point.
assert!(part(&s, "Ring").iter().all(|r| (r.center().x - c.x).abs() < 1e-6), "{:?}", part(&s, "Ring"));
// The center handle, where it is drawn now: the end point stays where it is.
s.execute("shape.editFlare", &json!({"ids": [id.0], "cx": c.x + 20.0, "cy": c.y})).unwrap();
assert!(spec(&s).center().unwrap().distance(Point::new(c.x + 20.0, c.y)) < 1e-6);
assert!(spec(&s).end().unwrap().distance(e) < 1e-6);
assert!(part(&s, "Center")[0].center().distance(Point::new(c.x + 20.0, c.y)) < 1e-6);
// The end handle, then the path length and direction.
s.execute("shape.editFlare", &json!({"x2": c.x + 20.0, "y2": c.y + 80.0})).unwrap();
assert!(spec(&s).end().unwrap().distance(Point::new(c.x + 20.0, c.y + 80.0)) < 1e-6);
// The path length and direction are where the flare is drawn now, though it was turned.
s.execute("shape.editFlare", &json!({"direction": 0, "pathLength": 50})).unwrap();
assert!(spec(&s).end().unwrap().distance(Point::new(c.x + 70.0, c.y)) < 1e-6, "{:?}", spec(&s).end());
s.execute("edit.undo", &json!({})).unwrap();
// Nothing changes: no undo step.
let undo = s.doc().unwrap().history.undo.len();
s.execute("shape.editFlare", &json!({"diameter": 100})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), undo);
// Bad values are refused.
for bad in [json!({"rings": 2.5}), json!({"diameter": "big"}), json!({"cx": 10}), json!({"diameter": 1e20})] {
assert!(s.execute("shape.editFlare", &bad).is_err(), "{bad}");
}
assert_eq!(s.doc().unwrap().history.undo.len(), undo);
s.execute("edit.undo", &json!({})).unwrap();
assert!(spec(&s).end().unwrap().distance(e) < 1e-6, "undo puts the end point back");
// A changed part: no longer a flare.
s.edit("Opacity", |d, _| {
let ring = d.node(id).unwrap().children().unwrap().iter().find(|c| c.name.as_deref() == Some("Center")).unwrap().id;
d.node_mut(ring).unwrap().opacity = 0.25;
Ok(())
})
.unwrap();
assert_eq!(s.execute("shape.editFlare", &json!({"rings": 3})).unwrap_err().to_string(), "select a flare");
s.execute("edit.undo", &json!({})).unwrap();
// A locked flare.
s.execute("object.lock", &json!({})).unwrap();
assert!(s.execute("shape.editFlare", &json!({"ids": [id.0], "rings": 3})).is_err());
s.execute("object.unlockAll", &json!({})).unwrap();
// Object › Expand: a plain group that is no longer a flare.
s.execute("object.expand", &json!({"object": true, "fill": false, "stroke": false})).unwrap();
assert!(s.doc().unwrap().doc.node(id).unwrap().extras().flare.is_none());
assert!(s.execute("shape.editFlare", &json!({"rings": 3})).is_err());
}
/// `shape.flare` reads whole-number counts written as floats, and refuses fractions.
#[test]
fn flare_counts_are_whole_numbers() {
let mut s = session();
let id = NodeId(s.execute("shape.flare", &json!({"cx": 100, "cy": 100, "rays": 4.0, "rings": 2})).unwrap()["id"].as_u64().unwrap());
let g = s.doc().unwrap().doc.node(id).unwrap();
let rays = g.children().unwrap().iter().find(|c| c.name.as_deref() == Some("Rays")).unwrap();
assert_eq!(rays.path_data().unwrap().subpaths.len(), 4);
assert!(s.execute("shape.flare", &json!({"cx": 100, "cy": 100, "rays": 2.5})).is_err());
}
/// `shape.editFlare` on a flare scaled far down: a `pathLength`, an end point or a center that,
/// taken back to where the flare was drawn, is not a finite number is an error, and the flare keeps
/// its settings.
#[test]
fn edit_flare_end_points_that_are_not_finite_are_errors() {
let mut s = session();
let id = NodeId(s.execute("shape.flare", &json!({"cx": 100, "cy": 100, "rings": 2})).unwrap()["id"].as_u64().unwrap());
s.execute("object.scale", &json!({"sx": 1e-4, "sy": 1e-4})).unwrap();
let before = flare_settings(&s.doc().unwrap().doc, id).expect("a flare");
for (p, key) in [
(json!({"pathLength": 1e305}), "x2"),
(json!({"x2": 1e305, "y2": 0}), "x2"),
(json!({"x2": 0, "y2": -1e305}), "y2"),
(json!({"cx": 1e305, "cy": 0}), "cx"),
] {
let err = s.execute("shape.editFlare", &p).unwrap_err().to_string();
assert!(err.ends_with(&format!("{key} must be a finite coordinate")), "{p}: {err}");
assert_eq!(flare_settings(&s.doc().unwrap().doc, id).expect("still a flare"), before, "{p}");
}
}
/// A flare drawn again keeps its parts' pixel-aligned property, whatever the document's Align New
/// Objects to Pixel Grid is now, and a pixel-aligned flare that was moved is still a flare.
#[test]
fn edit_flare_keeps_its_parts_pixel_alignment() {
let mut s = session();
let aligned = |s: &Session, id: NodeId| -> Vec<bool> {
s.doc().unwrap().doc.node(id).unwrap().children().unwrap().iter().map(|c| c.extras().pixel_aligned).collect()
};
s.execute("document.setup", &json!({"alignNewObjectsToPixelGrid": true})).unwrap();
let on = NodeId(s.execute("shape.flare", &json!({"cx": 100.3, "cy": 200.6, "rings": 2})).unwrap()["id"].as_u64().unwrap());
s.execute("object.move", &json!({"dx": 10.25, "dy": 3.5})).unwrap();
s.execute("document.setup", &json!({"alignNewObjectsToPixelGrid": false})).unwrap();
let part = |s: &Session, id: NodeId, name: &str| -> NodeId {
s.doc().unwrap().doc.node(id).unwrap().children().unwrap().iter().find(|c| c.name.as_deref() == Some(name)).unwrap().id
};
let centre = part(&s, on, "Center");
s.execute("shape.editFlare", &json!({"rings": 4})).unwrap();
assert!(aligned(&s, on).len() > 4 && aligned(&s, on).iter().all(|a| *a));
// Each part drawn again keeps its id and its own property: without the rays, the center does
// not take theirs.
assert_eq!(part(&s, on, "Center"), centre);
s.execute("object.setPixelAligned", &json!({"ids": [centre.0], "on": false})).unwrap();
s.execute("select.set", &json!({"ids": [on.0]})).unwrap();
s.execute("shape.editFlare", &json!({"rays": 0})).unwrap();
let node = |s: &Session, id: NodeId| s.doc().unwrap().doc.node(id).unwrap().extras().pixel_aligned;
assert!(!node(&s, centre) && node(&s, part(&s, on, "Halo")));
let off = NodeId(s.execute("shape.flare", &json!({"cx": 300.3, "cy": 200.6, "rings": 2})).unwrap()["id"].as_u64().unwrap());
s.execute("document.setup", &json!({"alignNewObjectsToPixelGrid": true})).unwrap();
s.execute("shape.editFlare", &json!({"rings": 4})).unwrap();
assert!(aligned(&s, off).iter().all(|a| !*a));
}
/// `shape.flare`'s `ringSeed` places the rings along the path anew and keeps their count and
/// sizes and the other parts; the same `ringSeed` draws the same flare, neighboring ones differ,
/// and a seed that is not a whole number of at least 0 (for `ringSeed`, below 2^53) is refused.
@@ -3453,6 +3596,38 @@ fn flare_small_ring_seeds_spread_the_first_ring_along_the_path() {
assert!(hi - lo > 250.0, "small seeds spread the first ring along the path: {positions:?}");
}
/// A flare drawn with a small `ringSeed` and then drawn again by `shape.editFlare` keeps its first
/// ring where `shape.flare` put it: the SplitMix64-initialized Xorshift64 stream's first value
/// along the path, for each seed.
#[test]
fn edit_flare_draws_the_first_ring_of_a_small_ring_seed_where_it_was() {
let first_t = |seed: u64| {
let mut z = seed.wrapping_add(0x9e37_79b9_7f4a_7c15);
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
let mut state = z ^ (z >> 31);
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
(state >> 11) as f64 / (1u64 << 53) as f64
};
let ring_x = |s: &Session, id: NodeId| {
let NodeKind::Group { children, .. } = &s.doc().unwrap().doc.node(id).unwrap().kind else { panic!("flare is a group") };
children.iter().find(|n| n.name.as_deref() == Some("Ring")).unwrap().geometric_bounds().unwrap().center().x
};
let mut s = session();
for seed in [0, 1, 2, 5, 11] {
let p = json!({"cx": 20, "cy": 30, "x2": 1020, "y2": 30, "rays": 0, "rings": 1, "ringSeed": seed});
let id = NodeId(s.execute("shape.flare", &p).unwrap()["id"].as_u64().unwrap());
let expected = 20.0 + 1000.0 * first_t(seed);
assert!((ring_x(&s, id) - expected).abs() < 1e-6, "seed {seed}: drawn at {}, expected {expected}", ring_x(&s, id));
s.execute("shape.editFlare", &json!({"ids": [id.0], "opacity": 80})).unwrap();
assert!((ring_x(&s, id) - expected).abs() < 1e-6, "seed {seed}: drawn again at {}, expected {expected}", ring_x(&s, id));
s.execute("shape.editFlare", &json!({"ids": [id.0], "opacity": 40})).unwrap();
assert!((ring_x(&s, id) - expected).abs() < 1e-6, "seed {seed}: a second edit keeps the ring");
}
}
/// `shape.ellipse` without `anchors`, or with 4, draws the live ellipse it always drew.
#[test]
fn ellipse_with_four_anchors_is_the_live_ellipse() {
@@ -4329,6 +4504,124 @@ fn object_mosaic_refuses_a_boolean_given_as_text() {
assert_eq!((r["tiles"].clone(), images(&s)), (json!(2), 1));
}
/// The size of the mosaic a call makes from the 100 × 50 pt image selected in `s`, with its column and row counts.
fn mosaic_size(s: &mut Session, p: serde_json::Value) -> (f64, f64, serde_json::Value, serde_json::Value) {
let image = s.doc().unwrap().selection.objects.clone();
let r = s.execute("object.createObjectMosaic", &p).unwrap();
let b = s.doc().unwrap().doc.node(NodeId(r["id"].as_u64().unwrap())).unwrap().geometric_bounds().unwrap();
s.execute("select.set", &json!({ "ids": image })).unwrap();
((b.width() * 1e6).round() / 1e6, (b.height() * 1e6).round() / 1e6, r["columns"].clone(), r["rows"].clone())
}
/// Resize Using Percentages reads the new width and height as percentages of the image's size; Constrain Ratio keeps
/// the image's proportions, the named side leading; Use Ratio makes the tiles square from the count on the
/// constrained side (columns by default), and the call answers the counts it used.
#[test]
fn object_mosaic_resizes_by_percentages_constrains_the_ratio_and_squares_the_tiles() {
let mut s = session();
rect(&mut s, 0.0, 0.0, 100.0, 50.0);
s.execute("paint.setStroke", &json!({"none": true})).unwrap();
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
assert_eq!(mosaic_size(&mut s, json!({"columns": 2, "rows": 1})), (100.0, 50.0, json!(2), json!(1)));
assert_eq!(mosaic_size(&mut s, json!({"width": 50, "height": 200, "percentages": true})), (50.0, 100.0, json!(10), json!(10)));
// A side left out is 100% of the image's.
assert_eq!(mosaic_size(&mut s, json!({"width": 150, "percentages": true})).0, 150.0);
assert_eq!(mosaic_size(&mut s, json!({"width": 200, "height": 10, "constrain": "width"})), (200.0, 100.0, json!(10), json!(10)));
assert_eq!(mosaic_size(&mut s, json!({"width": 10, "height": 25, "constrain": "height"})), (50.0, 25.0, json!(10), json!(10)));
assert_eq!(mosaic_size(&mut s, json!({"width": 50, "constrain": "width", "percentages": true})), (50.0, 25.0, json!(10), json!(10)));
// Square tiles: 10 columns of 10 pt over 50 pt are 5 rows; 4 rows of 12.5 pt over 100 pt are 8 columns.
assert_eq!(mosaic_size(&mut s, json!({"columns": 10, "rows": 3, "useRatio": true})), (100.0, 50.0, json!(10), json!(5)));
assert_eq!(mosaic_size(&mut s, json!({"columns": 3, "rows": 4, "useRatio": true, "constrain": "height"})), (100.0, 50.0, json!(8), json!(4)));
// A side named for Use Ratio is kept without Constrain Ratio: the size stays as given.
assert_eq!(mosaic_size(&mut s, json!({"rows": 4, "height": 100, "useRatio": "height"})), (100.0, 100.0, json!(4), json!(4)));
// On a new size: 30 columns over 300 × 50 pt are 5 rows.
assert_eq!(mosaic_size(&mut s, json!({"columns": 30, "width": 300, "useRatio": true})), (300.0, 50.0, json!(30), json!(5)));
// The count is kept within 1..1000.
assert_eq!(mosaic_size(&mut s, json!({"columns": 1, "width": 1, "height": 5000, "useRatio": true})).3, json!(1000));
assert_eq!(mosaic_size(&mut s, json!({"columns": 1, "width": 5000, "height": 1, "useRatio": true})).3, json!(1));
// A size under 0.1 pt grows in proportion while Constrain Ratio keeps it.
let (w, h, ..) = mosaic_size(&mut s, json!({"width": 0.1, "constrain": "width"}));
assert!((w - 0.2).abs() < 1e-6 && (h - 0.1).abs() < 1e-6, "{w} × {h}");
// A side Constrain Ratio works out above 1,000,000 pt shrinks to it, in proportion: a height of
// 1,000,000 pt over the 100 × 50 pt image would need a width of 2,000,000 pt.
assert_eq!(mosaic_size(&mut s, json!({"height": 1e6, "constrain": "height"})), (1e6, 5e5, json!(10), json!(10)));
// An image 20,000,000 times wider than it is tall has no such size: the call is refused.
s.execute("object.scale", &json!({"sx": 1, "sy": 1e-7})).unwrap();
let r = s.execute("object.createObjectMosaic", &json!({"width": 1e6, "constrain": "width"}));
let msg = "the image's proportions leave no size with both sides between 0.1 and 1000000 pt";
assert!(matches!(&r, Err(EngineError::BadParams { msg: m, .. }) if m == msg), "{r:?}");
}
/// Use Ratio squares the tiles as drawn: with 4 pt between columns, 10 columns of 10 pt cells draw 6 pt wide, so the
/// rows are 6 pt plus their own 4 pt apart (5 rows down 50 pt); on an image turned 90°, the tiles are measured along
/// its own axes.
#[test]
fn object_mosaic_use_ratio_takes_spacing_and_turned_images_into_account() {
let mut s = session();
rect(&mut s, 0.0, 0.0, 100.0, 50.0);
s.execute("paint.setStroke", &json!({"none": true})).unwrap();
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
let image = s.doc().unwrap().selection.objects.clone();
let counts = |s: &Session, p: serde_json::Value| crate::cmd::mosaic_counts(s, &p).unwrap();
assert_eq!(counts(&s, json!({"columns": 10, "useRatio": true, "spacingX": 4, "spacingY": 4})), (10, 5));
assert_eq!(counts(&s, json!({"columns": 10, "useRatio": true, "spacingX": 4})), (10, 8));
assert_eq!(counts(&s, json!({"columns": 10, "rows": 7})), (10, 7), "without Use Ratio the counts are kept");
let r = s.execute("object.createObjectMosaic", &json!({"columns": 10, "useRatio": true, "spacingX": 4})).unwrap();
let g = s.doc().unwrap().doc.node(NodeId(r["id"].as_u64().unwrap())).unwrap().clone();
let t = g.children().unwrap()[0].geometric_bounds().unwrap();
assert!((t.width() - 6.0).abs() < 1e-6 && (t.height() - 6.25).abs() < 1e-6, "{t:?}");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("select.set", &json!({ "ids": image })).unwrap();
// Turned 90°, the image's 100 pt side runs down the page; 10 columns along it are still 5 rows across its 50.
s.execute("object.rotate", &json!({"angle": 90})).unwrap();
assert_eq!(counts(&s, json!({"columns": 10, "useRatio": true})), (10, 5));
}
#[test]
fn object_mosaic_square_count_is_the_nearest_whole_count() {
use crate::cmd::menucmds::mosaic_square_count;
assert_eq!(mosaic_square_count(10, 100.0, 50.0, 0.0, 0.0), 5);
assert_eq!(mosaic_square_count(3, 100.0, 50.0, 0.0, 0.0), 2);
assert_eq!(mosaic_square_count(0, 100.0, 50.0, 0.0, 0.0), 1);
assert_eq!(mosaic_square_count(10, 0.0, 50.0, 0.0, 0.0), 1);
assert_eq!(mosaic_square_count(1000, 1.0, 1000.0, 0.0, 0.0), 1000);
// Spacing wider than a cell leaves 10% of it, on either side.
assert_eq!(mosaic_square_count(10, 100.0, 50.0, 50.0, 0.0), 50);
// 10 columns of 1 pt tiles (9 pt gaps) over 100 pt; rows 100 pt apart are capped too, so 10 rows draw 1 pt.
assert_eq!(mosaic_square_count(10, 100.0, 100.0, 9.0, 100.0), 10);
// 15 pt tiles over 50 pt: 3 rows draw 16.7 pt and 4 rows 12.5 pt, so 3.
assert_eq!(mosaic_square_count(1, 15.0, 50.0, 0.0, 0.0), 3);
}
/// A Constrain Ratio side that is not "width" or "height", a new size of 0 or less, and Use Ratio or Resize Using
/// Percentages given as text are errors naming the key; no mosaic is made.
#[test]
fn object_mosaic_refuses_a_bad_ratio_side_size_or_switch() {
let mut s = session();
rect(&mut s, 0.0, 0.0, 100.0, 50.0);
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
let undo = |s: &Session| s.doc().unwrap().history.undo.len();
let before = undo(&s);
for (p, msg) in [
(json!({"constrain": "both"}), "`constrain` must be one of \"width\", \"height\" or null"),
(json!({"constrain": 1}), "`constrain` must be one of \"width\", \"height\" or null"),
(json!({"width": 0}), "`width` must be between 0.1 and 1000000 (got 0)"),
(json!({"height": -5, "percentages": true}), "`height` must be between 0.1 and 1000000 (got -5)"),
(json!({"width": 2e6, "percentages": true}), "`width` must be between 0.1 and 1000000 (got 2000000)"),
// A side Constrain Ratio works out is not used, but a size given for it is still checked.
(json!({"width": 200, "height": 0, "constrain": "width"}), "`height` must be between 0.1 and 1000000 (got 0)"),
(json!({"useRatio": "true"}), "`useRatio` must be one of \"width\", \"height\", true, false or null"),
(json!({"useRatio": 1}), "`useRatio` must be one of \"width\", \"height\", true, false or null"),
(json!({"percentages": 1}), "`percentages` must be true or false"),
] {
let r = s.execute("object.createObjectMosaic", &p);
assert!(matches!(&r, Err(EngineError::BadParams { msg: m, .. }) if m == msg), "{p}: {r:?}");
assert_eq!(undo(&s), before, "{p}");
}
let r = s.execute("object.createObjectMosaic", &json!({"constrain": null, "useRatio": null, "percentages": null})).unwrap();
assert_eq!(r["tiles"], json!(100));
}
#[test]
fn snap_to_pixel_rounds_drawing_and_moves() {
let mut s = session();
@@ -176,3 +176,61 @@ fn a_handle_already_in_place_on_a_smooth_anchor_records_no_undo_step() {
.unwrap();
assert_eq!(undo_steps(&s), 1);
}
/// `path.setHandle` with `link` makes a corner smooth: the other handle turns in line at its own
/// length, a retracted one is pulled out to the moved handle's length where a segment leaves the
/// anchor on its side and stays retracted at an open end. A handle already in place on a corner
/// still links; a request that changes nothing records no undo step; `link` that is not a boolean
/// or goes with `independent` is refused.
#[test]
fn a_linked_handle_makes_the_anchor_smooth() {
let (mut s, id) = long_path(100);
let p = anchor(&s, id, 5).p;
let corner = Anchor { p, h_in: p + Vec2::new(-6.0, 8.0), h_out: p + Vec2::new(3.0, 0.0), kind: AnchorKind::Corner };
let path = Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(id).unwrap().path_data_mut().unwrap();
path.subpaths[0].anchors[5] = corner;
let link = |x: f64, y: f64, ai: usize| json!({"id": id.0, "anchor": ai, "which": "out", "x": x, "y": y, "link": true});
let near = |a: Point, b: Point| a.distance(b) < 1e-9;
// The out handle stays where it is; the corner becomes smooth, the in handle turned opposite it.
s.execute("path.setHandle", &link(corner.h_out.x, corner.h_out.y, 5)).unwrap();
assert_eq!(undo_steps(&s), 1);
let a = anchor(&s, id, 5);
assert_eq!((a.kind, a.h_out), (AnchorKind::Smooth, corner.h_out));
assert!(near(a.h_in, p + Vec2::new(-10.0, 0.0)), "{a:?}");
// Moved: the in handle keeps its length of 10.
let to = p + Vec2::new(4.0, 3.0);
s.execute("path.setHandle", &link(to.x, to.y, 5)).unwrap();
assert_eq!(undo_steps(&s), 2);
let a = anchor(&s, id, 5);
assert!(a.kind == AnchorKind::Smooth && a.h_out == to && near(a.h_in, p + Vec2::new(-8.0, -6.0)), "{a:?}");
// The same request again changes nothing.
s.execute("path.setHandle", &link(to.x, to.y, 5)).unwrap();
assert_eq!(undo_steps(&s), 2);
// A retracted in handle on an inner anchor is pulled out; at the open start it stays retracted.
let q = anchor(&s, id, 7).p;
s.execute("path.setHandle", &link(q.x, q.y + 5.0, 7)).unwrap();
let a = anchor(&s, id, 7);
assert!(a.kind == AnchorKind::Smooth && near(a.h_in, q + Vec2::new(0.0, -5.0)), "{a:?}");
let q = anchor(&s, id, 0).p;
s.execute("path.setHandle", &link(q.x, q.y + 5.0, 0)).unwrap();
let a = anchor(&s, id, 0);
assert!(a.kind == AnchorKind::Smooth && a.h_in == q && a.h_out == q + Vec2::new(0.0, 5.0), "{a:?}");
let before = s.doc().unwrap().doc.clone();
let undo = undo_steps(&s);
for bad in [
json!({"id": id.0, "anchor": 5, "which": "out", "x": 0, "y": 0, "link": "yes"}),
json!({"id": id.0, "anchor": 5, "which": "out", "x": 0, "y": 0, "link": 1}),
json!({"id": id.0, "anchor": 5, "which": "out", "x": 0, "y": 0, "link": true, "independent": true}),
json!({"id": id.0, "anchor": 5, "which": "out", "x": 0, "y": 0, "link": true, "independent": "no"}),
json!({"id": id.0, "anchor": 100, "which": "out", "x": 0, "y": 0, "link": true}),
json!({"id": id.0, "anchor": 7, "which": "out", "x": 1.7e308, "y": 1.7e308, "link": true}),
json!({"id": id.0, "anchor": 7, "which": "out", "x": 0, "y": -1e9, "link": true}),
] {
assert!(s.execute("path.setHandle", &bad).is_err(), "{bad}");
}
assert!(s.doc().unwrap().doc == before, "a refused request changed the document");
assert_eq!(undo_steps(&s), undo);
}
+17
View File
@@ -90,6 +90,23 @@ fn values_that_differ_read_null_and_recent_urls_keep_the_newest_first() {
assert_eq!(info(&mut s, json!({"ids": [p.0, a.0]}))["showCenter"], Value::Null);
}
/// The recent URLs keep the 30 newest distinct URLs, the most the panel's URL menu can list, and
/// a URL given again moves to the front without taking a second place.
#[test]
fn recent_urls_keep_the_thirty_newest() {
let mut s = session();
rect(&mut s, 0.0);
for i in 0..35 {
run(&mut s, "attributes.set", json!({"url": format!("https://example.com/{i}")}));
}
let want: Vec<String> = (5..35).rev().map(|i| format!("https://example.com/{i}")).collect();
assert_eq!(info(&mut s, json!({}))["recentUrls"], json!(want));
run(&mut s, "attributes.set", json!({"url": "https://example.com/20"}));
let urls = info(&mut s, json!({}))["recentUrls"].as_array().unwrap().clone();
assert_eq!((urls.len(), urls[0].as_str(), urls[1].as_str()), (30, Some("https://example.com/20"), Some("https://example.com/34")));
assert_eq!(urls.iter().filter(|u| *u == "https://example.com/20").count(), 1);
}
/// A five-pointed star drawn as one self-intersecting path (its centre is wound twice).
fn star(s: &mut Session) -> NodeId {
let (c, r) = (50.0f64, 45.0f64);
+32
View File
@@ -431,3 +431,35 @@ fn a_spine_segment_bends_with_perpendicular_handles() {
use vectorcraft_geom::kurbo::ParamCurve;
assert!(sp.segment(0).eval(0.5).distance(Point::new(55.0, 45.0)) < 1e-9, "{sp:?}");
}
/// `link` with `handle` makes a spine point smooth, the other handle in line opposite the moved
/// one, without moving the keys; the same request again records no undo step, and `link` that is
/// not a boolean, goes with `independent` or comes without `handle` is refused.
#[test]
fn a_linked_spine_handle_makes_the_point_smooth() {
let mut s = session();
let (_, _, g) = blend(&mut s);
s.execute("object.blend.spine.addAnchor", &json!({"x": 55, "y": 5})).unwrap();
let undo = |s: &Session| s.doc().unwrap().history.undo.len();
let link = json!({"anchor": 1, "handle": "out", "x": 75, "y": 25, "link": true});
s.execute("object.blend.spine.moveAnchor", &link).unwrap();
let a = spec(&s, g).spine.unwrap().subpaths[0].anchors[1];
assert_eq!((a.kind, a.h_out), (vectorcraft_geom::AnchorKind::Smooth, Point::new(75.0, 25.0)));
let (din, dout) = (a.h_in - a.p, a.h_out - a.p);
assert!(din.hypot() > 1e-6 && (din.normalize() + dout.normalize()).hypot() < 1e-9, "{a:?}");
let st = steps(&s, g);
assert_eq!((center(&st[0]), center(&st[2])), (Point::new(5.0, 5.0), Point::new(105.0, 5.0)), "the keys stay put");
let done = undo(&s);
s.execute("object.blend.spine.moveAnchor", &link).unwrap();
assert_eq!(undo(&s), done, "an unchanged spine recorded an undo step");
let before = spec(&s, g);
for bad in [
json!({"anchor": 1, "handle": "out", "x": 75, "y": 25, "link": "yes"}),
json!({"anchor": 1, "handle": "out", "x": 75, "y": 25, "link": true, "independent": true}),
json!({"anchor": 1, "x": 75, "y": 25, "link": true}),
] {
assert!(s.execute("object.blend.spine.moveAnchor", &bad).is_err(), "{bad}");
}
assert_eq!(spec(&s, g), before);
assert_eq!(undo(&s), done);
}
+81 -1
View File
@@ -117,7 +117,8 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
"game-trails",
"energy-beams",
"dry-media",
"tech-circuit"
"tech-circuit",
"arrows"
]
);
assert!(libs.iter().all(|l| l["category"] == "builtIn"));
@@ -145,6 +146,12 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
[("Chalk Grain", "art"), ("Graphite Pencil", "art"), ("Wax Crayon", "art"), ("Charcoal Dust", "art")]
);
assert_eq!((libs[9]["name"].as_str(), libs[9]["count"].as_u64()), (Some("Dry Media"), Some(4)));
let arrows = run(&mut s, "brush.library", json!({"library": "Arrows"}));
assert_eq!(
arrows["brushes"].as_array().unwrap().iter().map(|b| (b["name"].as_str().unwrap(), b["type"].as_str().unwrap())).collect::<Vec<_>>(),
[("Solid Arrow", "art"), ("Open Arrow", "art"), ("Double Arrow", "art"), ("Chevron Arrow", "art"), ("Dashed Arrow", "art")]
);
assert_eq!((libs[11]["name"].as_str(), libs[11]["count"].as_u64()), (Some("Arrows"), Some(5)));
run(&mut s, "file.new", json!({"width": 200, "height": 200}));
let id = run(&mut s, "shape.rectangle", json!({"x": 10, "y": 20, "width": 40, "height": 8}))["id"].as_u64().unwrap();
let added = run(&mut s, "brush.addFromLibrary", json!({"library": "energy-beams", "name": "Laser Bolt", "apply": true, "ids": [id]}));
@@ -162,6 +169,7 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
("game-trails", "art"),
("energy-beams", "art"),
("dry-media", "art"),
("arrows", "art"),
] {
let (_, lib) = cmd::brushlib::library(&s, id).unwrap();
assert!(lib.len() >= 4, "{id}");
@@ -220,6 +228,78 @@ fn black_stroke() -> vectorcraft_doc::StrokeLayer {
vectorcraft_doc::StrokeLayer::new(vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK), 1.0)
}
#[test]
fn arrows_library_lists_renders_and_applies_original_brushes() {
let mut s = session();
let listed = run(&mut s, "brush.libraries", json!({}));
let entry = listed["libraries"].as_array().unwrap().iter().find(|l| l["id"] == "arrows").unwrap();
assert_eq!((entry["name"].as_str(), entry["category"].as_str(), entry["count"].as_u64()), (Some("Arrows"), Some("builtIn"), Some(5)));
let (_, lib) = cmd::brushlib::library(&s, "Arrows").unwrap();
assert_eq!(
lib.brushes.iter().map(|b| (b.name.as_str(), b.kind.type_id())).collect::<Vec<_>>(),
[("Solid Arrow", "art"), ("Open Arrow", "art"), ("Double Arrow", "art"), ("Chevron Arrow", "art"), ("Dashed Arrow", "art")]
);
for b in &lib.brushes {
for length in [2.0, 200.0] {
let pieces = vectorcraft_brush::stroke_pieces(&lib.doc, b, &line_to(length), &black_stroke());
let pts = anchors(&pieces.iter().collect::<Vec<_>>());
assert!(!pts.is_empty() && pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()), "{} at {length} pt", b.name);
}
}
let path = run(&mut s, "shape.line", json!({"x1": 10, "y1": 20, "x2": 210, "y2": 20}))["id"].as_u64().unwrap();
let before = undo_len(&s);
let added = run(&mut s, "brush.addFromLibrary", json!({"library": "arrows", "name": "Double Arrow", "apply": true, "ids": [path]}));
assert_eq!(strs(&added["added"]), ["Double Arrow"]);
assert_eq!(added["applied"], json!([path]));
assert_eq!(undo_len(&s), before + 1);
assert_eq!(doc(&s).node(NodeId(path)).unwrap().appearance.stroke().unwrap().brush.as_deref(), Some("Double Arrow"));
run(&mut s, "edit.undo", json!({}));
assert!(vectorcraft_brush::find(doc(&s), "Double Arrow").is_none());
run(&mut s, "edit.redo", json!({}));
assert_eq!(brush(&s, "Double Arrow"), lib.brushes[2]);
}
#[test]
fn the_chevron_arrows_second_chevron_keeps_its_length_on_a_long_path() {
let s = session();
let (_, lib) = cmd::brushlib::library(&s, "Arrows").unwrap();
let b = lib.brush("Chevron Arrow").unwrap();
let widths = |length: f64| {
let pieces = vectorcraft_brush::stroke_pieces(&lib.doc, b, &line_to(length), &black_stroke());
let children = pieces[0].children().unwrap();
assert_eq!(children.len(), 3, "shaft, head and second chevron");
children[1..].iter().map(|n| n.geometric_bounds().unwrap().width()).collect::<Vec<_>>()
};
let short = widths(100.0);
for (long, short) in widths(400.0).into_iter().zip(short) {
assert!((long - short).abs() < 1e-6, "the heads keep their length: {long} on 400 pt, {short} on 100 pt");
}
}
#[test]
fn dashed_arrow_keeps_separate_dashes_and_survives_library_save() {
let mut s = session();
let (_, lib) = cmd::brushlib::library(&s, "Arrows").unwrap();
let b = lib.brush("Dashed Arrow").unwrap();
let mut curve = line_to(40.0);
curve.curve_to((60.0, -40.0), (140.0, 40.0), (200.0, 0.0));
for path in [line_to(2.0), line_to(200.0), curve] {
let pieces = vectorcraft_brush::stroke_pieces(&lib.doc, b, &path, &black_stroke());
let pts = anchors(&pieces.iter().collect::<Vec<_>>());
assert!(!pts.is_empty() && pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()));
}
let pieces = vectorcraft_brush::stroke_pieces(&lib.doc, b, &line_to(200.0), &black_stroke());
let children = pieces[0].children().unwrap();
assert_eq!(children.len(), 6, "five separate dashes and one head");
let bounds: Vec<_> = children.iter().map(|n| n.geometric_bounds().unwrap()).collect();
assert!(bounds.windows(2).all(|p| p[0].x1 < p[1].x0), "the dashes and head remain separated");
run(&mut s, "brush.addFromLibrary", json!({"library": "arrows", "name": "Dashed Arrow"}));
let saved = run(&mut s, "brush.saveLibrary", json!({"names": ["Dashed Arrow"]}));
let bytes = vectorcraft_format::base64_decode(saved["dataBase64"].as_str().unwrap()).unwrap();
let reopened = vectorcraft_format::load(&bytes).unwrap();
assert_eq!(vectorcraft_brush::find(&reopened, "Dashed Arrow").unwrap(), *b);
}
/// Original circuit art and repeat tiles survive adding, applying and saving a library.
#[test]
fn the_tech_circuit_library_constructs_adds_and_applies_each_brush() {
+376
View File
@@ -5027,6 +5027,73 @@ fn live_paint_does_not_count_art_named_like_its_parts() {
}
}
/// A path drawn in an isolated Live Paint group can't be named Face or Edge, the names of the
/// group's faces and edges: `object.setProps` and `layer.setProps` return an error and rename
/// nothing, so Gap Options and a path dragged into the group keep the path. A face keeps its name.
#[test]
fn live_paint_refuses_part_names_for_paths_drawn_in_it() {
use vectorcraft_tools::builder::{EDGE_NAME, FACE_NAME, faces};
let mut s = session();
let g = live(&mut s);
let face = faces(&node(&s, g))[0].id;
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
let a = line_across(&mut s, 50.0);
// Hidden, the path stays in the group as drawn when isolation mode ends.
s.execute("object.setProps", &json!({"id": a.0, "visible": false})).unwrap();
let before = (s.doc().unwrap().doc.clone(), s.doc().unwrap().history.undo.len());
for name in [FACE_NAME, EDGE_NAME] {
let calls = [
("object.setProps", json!({"id": a.0, "name": name})),
("layer.setProps", json!({"id": a.0, "name": name})),
("layer.setProps", json!({"ids": [face.0, a.0], "name": name})),
];
for (c, p) in calls {
let err = s.execute(c, &p).unwrap_err().to_string();
assert!(err.contains("give the path another name"), "{c} {p}: {err}");
}
}
assert!(s.doc().unwrap().doc == before.0, "nothing was renamed");
assert_eq!(s.doc().unwrap().history.undo.len(), before.1);
s.execute("layer.setProps", &json!({"id": face.0, "name": FACE_NAME})).unwrap();
s.execute("object.exitIsolation", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "the hidden path stays in the group");
s.execute("livePaint.gapOptions", &json!({"ids": [g.0], "detect": true})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "Gap Options keeps the path");
let b = line_to_right_face(&mut s, 30.0);
s.execute("layer.move", &json!({"ids": [b.0], "target": g.0, "place": "inside"})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "a path dragged in keeps it");
assert_eq!(faces(&node(&s, g)).len(), 5);
}
/// A path pasted into an isolated Live Paint group under the name of a face or an edge loses the
/// name, so Gap Options keeps it and it joins the group's paths when isolation mode ends.
#[test]
fn live_paint_paste_clears_part_names() {
use vectorcraft_tools::builder::{EDGE_NAME, FACE_NAME, faces, sources};
for name in [FACE_NAME, EDGE_NAME] {
let mut s = session();
let g = live(&mut s);
let r = rect(&mut s, 20.0, 40.0, 60.0, 20.0);
s.execute("object.setProps", &json!({"id": r.0, "name": name})).unwrap();
s.execute("select.set", &json!({"ids": [r.0]})).unwrap();
s.execute("edit.copy", &json!({})).unwrap();
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
s.execute("edit.pasteInPlace", &json!({})).unwrap();
let pasted = s.doc().unwrap().selection.objects.clone();
assert_eq!(pasted.len(), 1);
let d = &s.doc().unwrap().doc;
assert_eq!(d.parent_of(pasted[0]), Some(g), "{name}: the paste goes into the group");
assert_eq!(d.node(pasted[0]).unwrap().name, None, "{name}: the paste loses the name");
assert_eq!(d.node(r).unwrap().name.as_deref(), Some(name), "the path outside keeps its name");
s.execute("livePaint.gapOptions", &json!({"ids": [g.0], "detect": true})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(pasted[0]), Some(g), "{name}: Gap Options keeps the paste");
s.execute("object.exitIsolation", &json!({})).unwrap();
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(pasted[0]), Some(sources(&n).unwrap().id), "{name}: the paste joined");
assert!(faces(&n).len() > 3);
}
}
/// With Real-time Drawing and Editing off, a rectangle still being drawn in a Live Paint group
/// isolated in a pattern tile is drawn first when Exit Isolation Mode leaves pattern editing, and
/// joins the group with the tile saved.
@@ -5098,6 +5165,315 @@ fn live_paint_isolation_adds_a_drawn_group_isolated_inside_it() {
}
}
/// With Live Paint group `inner` made in isolated Live Paint group `outer` and then isolated itself,
/// leaving both levels (`object.exitIsolation`, or `object.isolate` on the layer) adds the path drawn
/// in `inner` to it and then `inner` and the path drawn directly in `outer` to `outer`, one undo step
/// each. Isolating `outer` from `inner` adds only `inner`'s drawn path, and `outer` keeps its own.
#[test]
fn live_paint_isolation_merges_nested_live_paint_groups_it_leaves() {
use vectorcraft_tools::builder::{faces, sources};
for to in ["exit", "layer", "outer"] {
let mut s = session();
let outer = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(outer).unwrap();
s.execute("object.isolate", &json!({"id": outer.0})).unwrap();
let a = line_across(&mut s, 50.0);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(outer));
let inner = live(&mut s);
assert_eq!(s.doc().unwrap().doc.parent_of(inner), Some(outer), "the inner group is drawn in the outer one");
s.execute("object.isolate", &json!({"id": inner.0})).unwrap();
let b = line_across(&mut s, 30.0);
assert_eq!(s.doc().unwrap().doc.parent_of(b), Some(inner));
let steps = s.doc().unwrap().history.undo.len();
match to {
"exit" => s.execute("object.exitIsolation", &json!({})).unwrap(),
"layer" => s.execute("object.isolate", &json!({"id": layer.0})).unwrap(),
_ => s.execute("object.isolate", &json!({"id": outer.0})).unwrap(),
};
let d = &s.doc().unwrap().doc;
if to == "outer" {
assert_eq!(s.doc().unwrap().isolation, Some(outer));
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "only the inner group's path joins");
let n = node(&s, inner);
assert_eq!(d.parent_of(b), Some(sources(&n).unwrap().id), "the path drawn in the inner group joined it");
assert_eq!(d.parent_of(inner), Some(outer), "the inner group stays drawn in the outer one");
assert_eq!(d.parent_of(a), Some(outer), "the path drawn in the outer group stays as drawn");
continue;
}
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 2, "{to}: one undo step for each group");
assert!(d.node(inner).is_none(), "{to}: the inner group joined the outer one");
let n = node(&s, outer);
let src = sources(&n).unwrap().id;
assert_eq!(d.parent_of(a), Some(src), "{to}: the path drawn in the outer group joined it");
assert!(d.ancestry(b).unwrap().contains(&src), "{to}: the path drawn in the inner group is among the outer group's paths");
assert!(n.children().unwrap().iter().all(|c| c.id == src || c.path_data().is_some()), "{to}: only parts are left in the outer group");
assert!(faces(&n).len() > 3, "{to}: the added paths cut the outer group's faces");
if to == "exit" {
assert_eq!(s.doc().unwrap().selection.objects, vec![outer]);
}
}
}
/// A line from left of the [`live`] group to its right face, so it cuts the two faces left of it.
fn line_to_right_face(s: &mut Session, y: f64) -> NodeId {
let r = s.execute("path.create", &json!({"anchors": [{"x": -10, "y": y}, {"x": 105, "y": y}]})).unwrap();
NodeId(r["id"].as_u64().unwrap())
}
fn undo_label(s: &Session) -> Option<String> {
s.doc().unwrap().history.undo.last().map(|e| e.label.clone())
}
/// Paths dragged into a Live Paint group in the Layers panel join its paths as Live Paint › Merge
/// adds them: they go among its sources and cut the faces they cross, a painted face they do not
/// cross keeps its fill, and the drop is one "Merge Live Paint" undo step that selects the group.
#[test]
fn layers_drag_adds_paths_to_a_live_paint_group() {
use vectorcraft_tools::builder::{face_at, faces, sources};
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let mut s = session();
let g = live(&mut s);
s.execute("livePaint.fill", &json!({"group": g.0, "point": [125, 50], "color": "#00ff00"})).unwrap();
let layer = s.doc().unwrap().doc.parent_of(g);
let (a, b) = (line_to_right_face(&mut s, 30.0), line_to_right_face(&mut s, 70.0));
assert_eq!(s.doc().unwrap().doc.parent_of(a), layer);
let steps = s.doc().unwrap().history.undo.len();
let r = s.execute("layer.move", &json!({"ids": [a.0, b.0], "target": g.0, "place": "inside"})).unwrap();
assert_eq!(r["ids"], json!([g.0]), "the rows that joined are listed as the group");
let d = s.doc().unwrap();
assert_eq!(d.history.undo.len(), steps + 1, "both paths join in one undo step");
assert_eq!(undo_label(&s).as_deref(), Some("Merge Live Paint"));
assert_eq!(s.doc().unwrap().selection.objects, vec![g]);
let n = node(&s, g);
let src = sources(&n).unwrap();
assert_eq!(src.children().unwrap().len(), 4);
for id in [a, b] {
assert_eq!(s.doc().unwrap().doc.parent_of(id), Some(src.id), "{id} joined the sources");
}
assert_eq!(faces(&n).len(), 7, "two lines cut each of the two faces they cross in three");
assert_eq!(face_at(&n, Point::new(125.0, 50.0)).unwrap().appearance.fill_paint(), green, "the face the lines do not cross keeps its fill");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 3);
for id in [a, b] {
assert_eq!(s.doc().unwrap().doc.parent_of(id), layer, "Undo puts {id} back where it was");
}
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 7);
}
/// A path named like a Live Paint group's sources group joins the group when it is dragged in, in
/// front of the sources group or behind it: the group keeps its own sources group and the path
/// goes among its paths.
#[test]
fn layers_drag_of_a_path_named_like_the_sources_group_joins_a_live_paint_group() {
use vectorcraft_tools::builder::{SOURCES_NAME, faces, sources};
for index in [0, 99] {
let mut s = session();
let g = live(&mut s);
let a = line_to_right_face(&mut s, 30.0);
s.execute("object.setProps", &json!({"id": a.0, "name": SOURCES_NAME})).unwrap();
s.execute("node.move", &json!({"id": a.0, "parent": g.0, "index": index})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Merge Live Paint"), "index {index}");
let n = node(&s, g);
let src = sources(&n).unwrap();
assert!(src.children().is_some(), "index {index}: the sources group is a group");
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(src.id), "index {index}: the path joined the sources");
assert_eq!(faces(&n).len(), 5, "index {index}");
}
}
/// An object drawn in a Live Paint group and named like its sources group can be moved ahead of the
/// sources group: the group keeps its own sources group and stays a Live Paint group.
#[test]
fn layers_reorder_of_an_object_named_like_the_sources_group_keeps_the_live_paint_group() {
use vectorcraft_tools::builder::{SOURCES_NAME, is_live_paint, sources};
let mut s = session();
let g = live(&mut s);
let real = sources(&node(&s, g)).unwrap().id;
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
let a = line_across(&mut s, 50.0);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g));
s.execute("object.setProps", &json!({"id": a.0, "name": SOURCES_NAME})).unwrap();
s.execute("node.move", &json!({"id": a.0, "parent": g.0, "index": 0})).unwrap();
let n = node(&s, g);
assert!(is_live_paint(&n));
assert_eq!(sources(&n).unwrap().id, real);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "the object stays where it was drawn");
}
/// A path named `Face` that is dragged into a Live Paint group is not one of its faces: the face it
/// covers keeps its own fill.
#[test]
fn layers_drag_of_a_path_named_face_does_not_repaint_the_group() {
use vectorcraft_tools::builder::{face_at, faces};
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let mut s = session();
let g = live(&mut s);
s.execute("livePaint.fill", &json!({"group": g.0, "point": [25, 50], "color": "#00ff00"})).unwrap();
let a = rect(&mut s, 0.0, 0.0, 50.0, 100.0);
set_fill(&mut s, a, Color::rgb(0.0, 0.0, 1.0));
s.execute("object.setProps", &json!({"id": a.0, "name": "Face"})).unwrap();
s.execute("node.move", &json!({"id": a.0, "parent": g.0, "index": 99})).unwrap();
let n = node(&s, g);
assert_eq!(faces(&n).len(), 3);
assert_eq!(face_at(&n, Point::new(25.0, 50.0)).unwrap().appearance.fill_paint(), green);
}
/// An Alt-drag into a Live Paint group adds a copy and leaves the path where it was; a drop above
/// one of the group's faces, and `node.move` into the group, add the path the same way.
#[test]
fn layers_drag_copy_and_drop_beside_a_part_add_to_a_live_paint_group() {
use vectorcraft_tools::builder::{faces, sources};
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g);
let a = line_to_right_face(&mut s, 30.0);
s.execute("layer.move", &json!({"ids": [a.0], "target": g.0, "copy": true})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), layer, "the path itself stays");
let n = node(&s, g);
assert_eq!(faces(&n).len(), 5);
let src = sources(&n).unwrap().children().unwrap().clone();
assert_eq!(src.len(), 3);
assert!(src.iter().all(|c| c.id != a), "a copy joined");
let (face, other_face) = (faces(&n)[0].id, faces(&n)[1].id);
let b = line_to_right_face(&mut s, 70.0);
// A face dragged along is made again with the others, so only the group is listed.
let r = s.execute("layer.move", &json!({"ids": [b.0, other_face.0], "target": face.0, "place": "above"})).unwrap();
assert_eq!(r["ids"], json!([g.0]));
assert_eq!(s.doc().unwrap().layer_rows, vec![g]);
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(b), Some(sources(&n).unwrap().id), "a drop beside a face joins");
assert_eq!(faces(&n).len(), 7);
let c = line_to_right_face(&mut s, 50.0);
s.execute("node.move", &json!({"id": c.0, "parent": g.0, "index": 0})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Merge Live Paint"));
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(c), Some(sources(&n).unwrap().id), "node.move into the group joins");
assert_eq!(faces(&n).len(), 9);
}
/// Dragging type, or type with a path, into a Live Paint group is refused with Make's message and
/// moves nothing, as Merge refuses it; a drop beside the group is an ordinary move.
#[test]
fn layers_drag_refuses_type_into_a_live_paint_group() {
use vectorcraft_tools::builder::faces;
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g);
let a = line_to_right_face(&mut s, 30.0);
let text = NodeId(s.execute("text.create", &json!({"x": 20, "y": 20, "text": "Hi"})).unwrap()["id"].as_u64().unwrap());
let before = (s.doc().unwrap().doc.clone(), s.doc().unwrap().history.undo.len());
for p in [json!({"ids": [a.0, text.0], "target": g.0}), json!({"ids": [text.0], "target": g.0, "copy": true})] {
let err = s.execute("layer.move", &p).unwrap_err().to_string();
assert!(err.contains("Live Paint takes paths and compound paths"), "{err}");
}
assert!(s.execute("node.move", &json!({"id": text.0, "parent": g.0, "index": 0})).is_err());
assert!(s.doc().unwrap().doc == before.0, "nothing moved");
assert_eq!(s.doc().unwrap().history.undo.len(), before.1);
s.execute("layer.move", &json!({"ids": [a.0, text.0], "target": g.0, "place": "above"})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Move Rows"));
assert_eq!(s.doc().unwrap().doc.parent_of(text), layer);
assert_eq!(faces(&node(&s, g)).len(), 3);
}
/// A path dragged out of a Live Paint group's sources leaves its faces and edges: the group makes
/// them again from the paths left, and with none left it has no faces until a path joins it again.
/// Reordering the sources, or the group's own faces, makes nothing again.
#[test]
fn layers_drag_out_of_a_live_paint_group_makes_its_faces_again() {
use vectorcraft_tools::builder::{faces, sources};
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g).unwrap();
let n = node(&s, g);
let src: Vec<NodeId> = sources(&n).unwrap().children().unwrap().iter().map(|c| c.id).collect();
let face_ids: Vec<NodeId> = faces(&n).iter().map(|f| f.id).collect();
s.execute("layer.move", &json!({"ids": [src[0].0], "target": src[1].0, "place": "above"})).unwrap();
s.execute("layer.move", &json!({"ids": [face_ids[0].0], "target": face_ids[2].0, "place": "above"})).unwrap();
let n = node(&s, g);
assert_eq!(sources(&n).unwrap().children().unwrap().len(), 2, "a reorder keeps the sources");
let mut now: Vec<NodeId> = faces(&n).iter().map(|f| f.id).collect();
now.sort();
let mut was = face_ids.clone();
was.sort();
assert_eq!(now, was, "and the faces");
s.execute("layer.move", &json!({"ids": [src[0].0], "target": layer.0})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Move Rows"));
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(src[0]), Some(layer));
assert_eq!(sources(&n).unwrap().children().unwrap().len(), 1);
assert_eq!(faces(&n).len(), 1, "one rectangle left");
s.execute("node.move", &json!({"id": src[1].0, "parent": layer.0, "index": 0})).unwrap();
let n = node(&s, g);
assert!(vectorcraft_tools::builder::is_live_paint(&n), "the group stays a Live Paint group");
assert!(sources(&n).unwrap().children().unwrap().is_empty());
assert!(faces(&n).is_empty() && vectorcraft_tools::builder::edges(&n).is_empty());
s.execute("layer.move", &json!({"ids": [src[0].0], "target": g.0})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 1, "a path joins the empty group");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 1);
}
/// A path dragged from a Live Paint group's sources into the group itself stays among its paths,
/// and the faces it bounds keep their paint, also when it is the group's only path.
#[test]
fn layers_drag_a_source_path_into_its_own_live_paint_group_keeps_the_paint() {
use vectorcraft_tools::builder::{face_at, faces, sources};
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let blue = Paint::solid(Color::from_hex("#0000ff").unwrap());
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g).unwrap();
s.execute("livePaint.fill", &json!({"group": g.0, "point": [25, 50], "color": "#00ff00"})).unwrap();
let src: Vec<NodeId> = sources(&node(&s, g)).unwrap().children().unwrap().iter().map(|c| c.id).collect();
s.execute("layer.move", &json!({"ids": [src[0].0], "target": g.0, "place": "inside"})).unwrap();
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(src[0]), Some(sources(&n).unwrap().id), "the path stays among the group's paths");
assert_eq!(faces(&n).len(), 3);
assert_eq!(face_at(&n, Point::new(25.0, 50.0)).unwrap().appearance.fill_paint(), green, "the face it bounds keeps its fill");
s.execute("layer.move", &json!({"ids": [src[1].0], "target": layer.0})).unwrap();
s.execute("livePaint.fill", &json!({"group": g.0, "point": [50, 50], "color": "#0000ff"})).unwrap();
s.execute("layer.move", &json!({"ids": [src[0].0], "target": g.0, "place": "inside"})).unwrap();
let n = node(&s, g);
assert_eq!(faces(&n).len(), 1);
assert_eq!(face_at(&n, Point::new(50.0, 50.0)).unwrap().appearance.fill_paint(), blue, "the only path's face keeps its fill");
}
/// A Live Paint group among another Live Paint group's paths gives it faces and edges: a path
/// dragged into or out of the inner group's paths, or from the outer group's paths into the inner
/// group's, makes the inner group's faces and edges again and then the outer group's.
#[test]
fn layers_drag_into_a_nested_live_paint_group_makes_the_outer_group_again() {
use vectorcraft_tools::builder::{faces, sources};
let mut s = session();
let outer = live(&mut s);
let inner = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(outer).unwrap();
let first_source = |s: &Session, g: NodeId| sources(&node(s, g)).unwrap().children().unwrap()[0].id;
let into = |s: &mut Session, row: NodeId, g: NodeId| {
let target = first_source(s, g);
s.execute("layer.move", &json!({"ids": [row.0], "target": target.0, "place": "above"})).unwrap();
};
into(&mut s, inner, outer);
assert_eq!(s.doc().unwrap().doc.parent_of(inner), Some(sources(&node(&s, outer)).unwrap().id));
let plain = faces(&node(&s, outer)).len();
let a = line_to_right_face(&mut s, 30.0);
into(&mut s, a, inner);
assert_eq!(faces(&node(&s, inner)).len(), 5);
let cut = faces(&node(&s, outer)).len();
assert!(cut > plain, "a path joining the inner group cuts the outer group's faces: {cut} faces, {plain} before");
s.execute("layer.move", &json!({"ids": [a.0], "target": layer.0})).unwrap();
assert_eq!(faces(&node(&s, inner)).len(), 3);
assert_eq!(faces(&node(&s, outer)).len(), plain, "a path leaving the inner group leaves the outer group's faces");
into(&mut s, a, outer);
assert_eq!(faces(&node(&s, outer)).len(), cut);
into(&mut s, a, inner);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(sources(&node(&s, inner)).unwrap().id));
assert_eq!(faces(&node(&s, inner)).len(), 5);
assert_eq!(faces(&node(&s, outer)).len(), cut, "the outer group is made after the inner one");
}
/// Give Live Paint group `g` a lock, hidden state, appearance, knockout, opacity mask and
/// graphic style link, and return it as it then is.
fn dress_live_group(s: &mut Session, g: NodeId) -> Node {
+105
View File
@@ -696,3 +696,108 @@ fn a_locked_or_hidden_layer_keeps_the_isolated_compound_shape_from_clicks() {
assert!(selected(&s).is_empty(), "{prop}: nor by a marquee");
}
}
/// A straight line, closed as a compound shape closes open paths, encloses no area, so it
/// contributes no area to the shape: Make Compound Shape still makes it, in any mode and at any
/// place in the stack, and its reply carries a warning that names Outline Stroke. The shape draws
/// the area the other members make in that mode: the square alone in Add, or on top in Subtract,
/// and nothing in Intersect or when the line is the backmost member in Subtract. A line in a group,
/// beside a closed path too, an open evenodd square traced twice, and open evenodd subpaths that cancel one another or a closed
/// subpath of the same path are the same. An open path that encloses an area once closed (a bow tie
/// whose lobes cancel in signed area included) and closed shapes alone give no warning (#7849).
#[test]
fn lines_that_add_no_area_are_reported() {
use crate::cmd::OPEN_PATHS_ADD_NO_AREA;
fn line_of(s: &mut Session) -> NodeId {
NodeId(run(s, "shape.line", json!({"x1": 20, "y1": 50, "x2": 180, "y2": 50}))["id"].as_u64().unwrap())
}
fn vee_of(s: &mut Session) -> NodeId {
let anchors = json!([{"x": 20, "y": 50}, {"x": 100, "y": 150}, {"x": 180, "y": 50}]);
NodeId(run(s, "path.create", json!({ "anchors": anchors }))["id"].as_u64().unwrap())
}
fn bow_tie_of(s: &mut Session) -> NodeId {
let anchors = json!([{"x": 20, "y": 0}, {"x": 180, "y": 100}, {"x": 180, "y": 0}, {"x": 20, "y": 100}]);
NodeId(run(s, "path.create", json!({ "anchors": anchors }))["id"].as_u64().unwrap())
}
fn twice_around_of(s: &mut Session) -> NodeId {
let d = "M20 20 L80 20 L80 80 L20 80 L20 20 L80 20 L80 80 L20 80";
let id = NodeId(run(s, "path.create", json!({ "d": d }))["id"].as_u64().unwrap());
run(s, "path.setFillRule", json!({"rule": "evenOdd"}));
id
}
fn evenodd_of(s: &mut Session, d: &str) -> NodeId {
let id = NodeId(run(s, "path.create", json!({ "d": d }))["id"].as_u64().unwrap());
run(s, "path.setFillRule", json!({"rule": "evenOdd"}));
id
}
fn two_open_squares_of(s: &mut Session) -> NodeId {
evenodd_of(s, "M20 20 L80 20 L80 80 L20 80 M20 20 L80 20 L80 80 L20 80")
}
fn open_over_closed_of(s: &mut Session) -> NodeId {
evenodd_of(s, "M20 20 L80 20 L80 80 L20 80 Z M20 20 L80 20 L80 80 L20 80")
}
fn group_of(s: &mut Session, ids: &[NodeId]) -> NodeId {
run(s, "select.set", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()}));
NodeId(run(s, "object.group", json!({}))["id"].as_u64().unwrap())
}
type Build = fn(&mut Session) -> NodeId;
// (case, mode, the other member, whether it goes behind the 100 pt square, warned, area drawn)
type Case = (&'static str, &'static str, Build, bool, bool, Option<f64>);
let cases: [Case; 13] = [
("an open evenodd square traced twice", "add", twice_around_of, false, true, Some(10_000.0)),
("two open evenodd squares on one another", "add", two_open_squares_of, false, true, Some(10_000.0)),
("an open evenodd square on the same closed square", "add", open_over_closed_of, false, true, Some(10_000.0)),
("a line", "add", line_of, false, true, Some(10_000.0)),
("a line, subtracting", "subtract", line_of, false, true, Some(10_000.0)),
("a line, intersecting", "intersect", line_of, false, true, Some(0.0)),
("a line behind, subtracting", "subtract", line_of, true, true, Some(0.0)),
(
"a group of lines",
"add",
|s| {
let ids = [line_of(s), line_of(s)];
group_of(s, &ids)
},
false,
true,
Some(10_000.0),
),
(
"a group of a line and a square",
"add",
|s| {
let ids = [line_of(s), square(s, 200.0, "#00ff00")];
group_of(s, &ids)
},
false,
true,
Some(20_000.0),
),
("an open path that encloses an area", "add", vee_of, false, false, None),
("an open bow tie, whose signed area is zero", "add", bow_tie_of, false, false, None),
("a square", "add", |s| square(s, 50.0, "#0000ff"), false, false, Some(15_000.0)),
("a square, subtracting", "subtract", |s| square(s, 50.0, "#0000ff"), false, false, Some(5_000.0)),
];
for (what, mode, build, behind, warned, want) in cases {
let mut s = Session::new();
run(&mut s, "file.new", json!({"width": 400, "height": 300}));
let (back, front) = if behind {
let other = build(&mut s);
(other, square(&mut s, 0.0, "#ff0000"))
} else {
let sq = square(&mut s, 0.0, "#ff0000");
(sq, build(&mut s))
};
run(&mut s, "select.set", json!({"ids": [back.0, front.0]}));
let r = run(&mut s, "object.compoundShape.make", json!({ "mode": mode }));
let id = NodeId(r["id"].as_u64().unwrap_or_else(|| panic!("{what}: {r}")));
assert_eq!(node(&s, id).children().unwrap().len(), 2, "{what}: both are members");
assert_eq!(r.get("warning").and_then(Value::as_str), warned.then_some(OPEN_PATHS_ADD_NO_AREA), "{what}: {r}");
if let Some(want) = want {
let d = &s.doc().unwrap().doc;
let hook = |c: &Node| effects::outline_object(Some(d), c);
let got = effects::compound_shape_area(None, &node(&s, id), Some(&hook)).map_or(0.0, |p| area(&p));
assert!((got - want).abs() < 0.5, "{what}: draws {got}, not {want}");
}
}
}
@@ -377,7 +377,7 @@ fn ids_cases(d: u64) -> Vec<(&'static str, &'static str, serde_json::Value, Unse
("addon.color.filter", "ids", json!({"effect": "addon.color.invert"}), Selected),
("addon.color.applyNearestSwatch", "ids", json!({}), Selected),
("edit.colors.overprintBlack", "ids", json!({}), Selected),
("edit.findReplace", "ids", json!({"find": "A", "replace": "B"}), Gives(json!({"count": 1}))),
("edit.findReplace", "ids", json!({"find": "A", "replace": "B"}), Gives(json!({"count": 1, "replaced": 1}))),
("layer.highlight", "ids", json!({}), Fails("missing ids")),
("layer.move", "ids", json!({ "target": d }), Fails("missing ids")),
("library.add", "ids", json!({"kind": "graphic"}), Selected),
+214
View File
@@ -167,6 +167,183 @@ fn clicking_rows_at_any_depth_highlights_them_and_sets_the_current_layer() {
assert_eq!(document_rows(&s), vec![g.0, c.0], "document.inspect lists the rows");
}
/// Run `layer.highlight` with `ids` and `mode` → (the rows it returned, the current layer), after
/// checking that the call counted one revision and left the rows it returned highlighted.
fn highlight_rows(s: &mut Session, ids: &[NodeId], mode: &str) -> (Vec<NodeId>, Option<NodeId>) {
let revision = s.doc().unwrap().revision;
let r = run(s, "layer.highlight", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "mode": mode}));
let st = s.doc().unwrap();
assert_eq!(st.revision, revision + 1, "{mode} {ids:?}");
let rows: Vec<NodeId> = r["rows"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
assert_eq!(rows, st.layer_rows, "{mode} {ids:?}");
(rows, st.active_layer)
}
/// `layer.highlight` keeps the rows in highlight order: `set` and `add` take a repeated id once,
/// `toggle` takes an id listed twice off and on again (or on and off, and its layer becomes the
/// current one), unknown ids and ids after the first 100,000 are dropped, rows highlighted twice
/// stay as they are on `add`, and `toggle` takes every copy off.
#[test]
fn highlighting_rows_keeps_their_order_with_repeated_unknown_and_excess_ids() {
let mut s = session();
let (layer, sub, a, g, b, c) = tree(&mut s);
let unknown = NodeId(9999);
assert_eq!(highlight_rows(&mut s, &[a, g, a, unknown, c], "set"), (vec![a, g, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[g, b, a, b], "add"), (vec![a, g, c, b], Some(sub)));
assert_eq!(highlight_rows(&mut s, &[c, c], "toggle"), (vec![a, g, b, c], Some(layer)));
// `sub` goes on and off again; it was the last row added, so its layer is the current one.
assert_eq!(highlight_rows(&mut s, &[sub, sub], "toggle"), (vec![a, g, b, c], Some(sub)));
assert_eq!(highlight_rows(&mut s, &[a, unknown], "toggle"), (vec![g, b, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[], "add"), (vec![g, b, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[], "toggle"), (vec![g, b, c], Some(layer)));
s.doc_mut().unwrap().active_layer = Some(sub);
assert_eq!(highlight_rows(&mut s, &[], "set"), (vec![], Some(sub)), "no rows: the current layer stays");
let mut excess = vec![unknown; 100_000];
excess.push(a);
assert_eq!(highlight_rows(&mut s, &excess, "set"), (vec![], Some(sub)), "only the first 100,000 ids count");
s.doc_mut().unwrap().layer_rows = vec![a, a, g];
assert_eq!(highlight_rows(&mut s, &[a, c], "add"), (vec![a, a, g, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[a], "toggle"), (vec![g, c], Some(layer)));
// The same with more than 8 ids.
s.doc_mut().unwrap().layer_rows = vec![a, a, g];
assert_eq!(highlight_rows(&mut s, &[a, c, c, c, c, c, c, c, c], "add"), (vec![a, a, g, c], Some(layer)));
s.doc_mut().unwrap().layer_rows = vec![a, a, g];
assert_eq!(highlight_rows(&mut s, &[a, b, b, b, b, b, b, b, b], "toggle"), (vec![g], Some(sub)), "`b` goes on and off 4 times");
assert_eq!(highlight_rows(&mut s, &[c, g, sub, g, sub, a, unknown, a, c, layer], "toggle"), (vec![g, layer], Some(layer)));
let revision = s.doc().unwrap().revision;
assert!(s.execute("layer.highlight", &json!({"ids": [b.0], "mode": "nope"})).is_err());
let st = s.doc().unwrap();
assert_eq!((st.revision, st.layer_rows.clone()), (revision, vec![g, layer]), "a bad mode changes nothing");
}
/// `layer.highlight`'s rule as a search of the highlighted rows for each id in `p`. The tests
/// compare the command with it.
fn highlight_by_search(st: &mut DocState, p: &Value) -> Value {
let mut ids: Vec<NodeId> = p["ids"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
ids.truncate(crate::cmd::layer::MAX_ROWS);
let mode = p["mode"].as_str().unwrap_or("set");
ids.retain(|id| st.doc.node(*id).is_some());
let mut rows = st.highlighted_rows();
if mode == "set" {
rows.clear();
}
let mut last = None;
for id in ids {
if mode == "toggle" && rows.contains(&id) {
rows.retain(|r| *r != id);
} else if !rows.contains(&id) {
rows.push(id);
last = Some(id);
}
}
if let Some(layer) = last.or(rows.last().copied()).and_then(|id| st.doc.layer_containing(id)) {
st.active_layer = Some(layer);
}
st.layer_rows = rows;
st.revision += 1;
json!({ "rows": st.layer_rows.iter().map(|i| i.0).collect::<Vec<_>>() })
}
/// Two sessions with `n` squares on a layer and a sublayer after them, and the squares' ids.
fn highlight_pair(n: usize) -> (Session, Session, Vec<NodeId>, NodeId) {
let make = || {
let mut s = super::large_edits::session(n, super::large_edits::square);
let sub = id(&run(&mut s, "layer.newSublayer", json!({"name": "Sub"})));
(s, sub)
};
let ((cmd, sub), (search, other)) = (make(), make());
assert_eq!(sub, other);
let squares = super::large_edits::layer(&cmd, 0).into_iter().filter(|i| *i != sub).collect();
(cmd, search, squares, sub)
}
/// `p` for `layer.highlight` with `ids` and `mode`.
fn highlight_params(ids: impl IntoIterator<Item = NodeId>, mode: &str) -> Value {
json!({"ids": ids.into_iter().map(|i| i.0).collect::<Vec<_>>(), "mode": mode})
}
/// On 3,000 rows `layer.highlight` gives what [`highlight_by_search`] gives: the same rows in the
/// same order, the same current layer and the same returned rows, with repeated, unknown and
/// toggled ids.
#[test]
fn layer_highlight_matches_a_search_of_the_rows_for_each_id() {
let (mut cmd, mut search, sq, sub) = highlight_pair(3_000);
let unknown = NodeId(u64::MAX);
let steps = [
highlight_params(sq[..2_000].iter().copied(), "set"),
highlight_params(sq[1_000..].iter().copied().chain([sub, sq[0]]), "add"),
highlight_params([sq[5], sq[5], sub, sq[2_999], unknown, sub, sub], "toggle"),
highlight_params(sq[500..520].iter().chain(&sq[510..515]).copied(), "toggle"),
highlight_params(sq.iter().rev().step_by(7).copied(), "add"),
highlight_params(sq.iter().step_by(3).copied().chain([sub]), "toggle"),
highlight_params(Vec::new(), "add"),
highlight_params(sq.iter().rev().step_by(2).chain(&sq[..10]).copied(), "set"),
highlight_params(Vec::new(), "set"),
];
for p in &steps {
let r = run(&mut cmd, "layer.highlight", p.clone());
let expected = highlight_by_search(search.doc_mut().unwrap(), p);
let (a, b) = (cmd.doc().unwrap(), search.doc().unwrap());
assert_eq!(r, expected, "{}", p["mode"]);
assert_eq!((&a.layer_rows, a.active_layer, a.revision), (&b.layer_rows, b.active_layer, b.revision), "{}", p["mode"]);
}
}
/// Time `layer.highlight` against [`highlight_by_search`] on one layer of 20,000 paths: `set` of
/// all of them, `add` of 10,000 already highlighted and `toggle` of one, 7 runs each, both checked
/// to give the same rows and current layer.
/// Run with `cargo test --release -p vectorcraft-engine --lib layer_highlight_timing -- --ignored --nocapture`.
#[test]
#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
fn layer_highlight_timing() {
let (mut cmd, mut search, sq, _) = highlight_pair(20_000);
let steps = [
("set of 20,000", highlight_params(sq.iter().copied(), "set")),
("add of 10,000", highlight_params(sq[5_000..15_000].iter().copied(), "add")),
("toggle of 1", highlight_params([sq[10_000]], "toggle")),
];
let mut ms = vec![(Vec::new(), Vec::new()); steps.len()];
for run_no in 0..7 {
for (i, (_, p)) in steps.iter().enumerate() {
let mut time_cmd = || {
let start = std::time::Instant::now();
let r = cmd.execute("layer.highlight", p).unwrap();
(start.elapsed().as_secs_f64() * 1000.0, r)
};
let mut time_search = || {
let start = std::time::Instant::now();
let r = highlight_by_search(search.doc_mut().unwrap(), p);
(start.elapsed().as_secs_f64() * 1000.0, r)
};
// Alternate which goes first.
let ((tc, rc), (ts, rs)) = if run_no % 2 == 0 {
let c = time_cmd();
(c, time_search())
} else {
let s = time_search();
(time_cmd(), s)
};
assert_eq!(rc, rs);
let (a, b) = (cmd.doc().unwrap(), search.doc().unwrap());
assert_eq!((&a.layer_rows, a.active_layer), (&b.layer_rows, b.active_layer));
ms[i].0.push(ts);
ms[i].1.push(tc);
}
}
let median = |v: &[f64]| {
let mut v = v.to_vec();
v.sort_by(f64::total_cmp);
v[v.len() / 2]
};
for ((name, _), (search_ms, cmd_ms)) in steps.iter().zip(&ms) {
println!(
"{name}: search {:.3} ms, command {:.3} ms (median of 7); search runs {search_ms:.3?}, command runs {cmd_ms:.3?}",
median(search_ms),
median(cmd_ms)
);
}
}
fn document_rows(s: &Session) -> Vec<u64> {
crate::inspect::document(s)["layerRows"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
}
@@ -1102,6 +1279,43 @@ fn locate_object_highlights_its_row() {
assert!(s.execute("layer.locate", &json!({})).is_err());
}
/// With several objects selected, Locate Object finds the frontmost one in the stacking order,
/// whatever order they were selected in; an `id` still wins.
#[test]
fn locate_object_finds_the_frontmost_selected_object() {
let mut s = session();
let (_, sub, a, g, b, c) = tree(&mut s);
let top = id(&run(&mut s, "layer.new", json!({"top": true})));
let d = rect(&mut s, 400.0);
let locate = |s: &mut Session, ids: &[NodeId]| {
run(s, "select.set", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()}));
assert_eq!(s.doc().unwrap().selection.objects.last(), ids.last(), "selected in this order");
run(s, "layer.locate", json!({}))["id"].clone()
};
// In one sublayer, the group in front of the rectangle selected last.
assert_eq!(locate(&mut s, &[g, a]), json!(g.0));
assert_eq!(s.doc().unwrap().highlighted_rows(), vec![g]);
// The sublayer sits in front of the art directly in its layer.
assert_eq!(locate(&mut s, &[a, c]), json!(a.0));
// A higher layer wins over everything below it.
assert_eq!(locate(&mut s, &[d, b, c]), json!(d.0));
assert_eq!(s.doc().unwrap().highlighted_rows(), vec![d]);
// A group and its member: the member paints after the group it is in.
assert_eq!(locate(&mut s, &[b, g]), json!(b.0));
// Added one at a time, as by Shift-clicks.
run(&mut s, "select.set", json!({"ids": [d.0]}));
run(&mut s, "select.add", json!({"ids": [a.0]}));
assert_eq!(run(&mut s, "layer.locate", json!({}))["id"], d.0);
// An id still locates that object, behind the selection or not.
assert_eq!(run(&mut s, "layer.locate", json!({"id": c.0}))["id"], c.0);
assert_eq!(s.doc().unwrap().highlighted_rows(), vec![c]);
// Locate Layer takes the layer of the frontmost selected object.
run(&mut s, "select.set", json!({"ids": [d.0, a.0]}));
assert_eq!(run(&mut s, "layer.locate", json!({"layersOnly": true})), json!({"id": top.0, "objectId": d.0, "ancestry": [top.0]}));
run(&mut s, "select.set", json!({"ids": [a.0, c.0]}));
assert_eq!(run(&mut s, "layer.locate", json!({"layersOnly": true}))["id"], sub.0);
}
/// Locate Layer (`layersOnly`, sent while Show Layers Only is on) highlights the innermost layer
/// or sublayer holding the object, through any groups; a layer locates itself.
#[test]
+183 -4
View File
@@ -2377,7 +2377,8 @@ fn find_and_replace_leaves_type_on_a_locked_artboard() {
/// Find and Replace that replaces each match with the text it is (`CAT` found in `cat`, ignoring
/// case, and replaced by `cat`) records no undo step: the step to redo stays and the document stays
/// unmodified. It still replies with the count. A replacement that changes the text is one undo step.
/// unmodified. It still replies with the count, and with no match replaced. A replacement that
/// changes the text is one undo step.
#[test]
fn find_and_replace_that_changes_nothing_records_no_undo_step() {
let mut s = session();
@@ -2385,9 +2386,9 @@ fn find_and_replace_that_changes_nothing_records_no_undo_step() {
select_with_a_step_to_redo(&mut s, &[a]);
let before = history(&s);
assert_eq!((before.1, before.2), (1, false), "a step to redo, and nothing unsaved");
assert_eq!(s.execute("edit.findReplace", &json!({"find": "CAT", "replace": "cat"})).unwrap(), json!({"count": 2}));
assert_eq!(s.execute("edit.findReplace", &json!({"find": "CAT", "replace": "cat"})).unwrap(), json!({"count": 2, "replaced": 0}));
assert_eq!((history(&s), plain(&s, a)), (before, "cat cat".to_string()));
assert_eq!(s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog"})).unwrap(), json!({"count": 2}));
assert_eq!(s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog"})).unwrap(), json!({"count": 2, "replaced": 2}));
assert_eq!((history(&s), plain(&s, a)), ((before.0 + 1, 0, true), "dog dog".to_string()));
}
@@ -2424,12 +2425,190 @@ fn find_next_cycles_through_text_objects() {
let _ = text(&mut s, "banana");
let c = text(&mut s, "pineapple");
s.execute("select.none", &json!({})).unwrap();
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "APPLE"})).unwrap()), a);
// From the top of the stacking order down, then round again.
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "APPLE"})).unwrap()), c);
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "apple"})).unwrap()), a);
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "apple"})).unwrap()), c);
// A selection that starts with a shape goes on after its first type object.
let shape = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
sel(&mut s, &[shape, c]);
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "apple"})).unwrap()), a);
assert!(s.execute("edit.findNext", &json!({"find": "zzz"})).unwrap()["id"].is_null());
}
/// The match `r` (an `edit.findNext` result) as (object, start, end, index, count).
fn found(r: &Value) -> (u64, u64, u64, u64, u64) {
let n = |k: &str| r[k].as_u64().unwrap_or_else(|| panic!("no `{k}` in {r}"));
(n("id"), n("start"), n("end"), n("index"), n("count"))
}
/// Find Next steps through the matches one by one when each call is given the match before it:
/// the objects from the top of the stacking order down, each object's matches in reading order,
/// and round again after the last. Search Backwards visits them the other way. Each match is
/// returned with its bytes and its object is selected; nothing is recorded for undo.
#[test]
fn find_next_steps_through_the_matches_in_both_directions() {
let mut s = session();
let bottom = text(&mut s, "cat éa cat");
let _ = text(&mut s, "dog");
let top = text(&mut s, "a cat");
s.execute("select.none", &json!({})).unwrap();
let before = history(&s);
let step = |s: &mut Session, from: &Value, backwards: bool| {
let from = if from.is_null() { Value::Null } else { json!({"id": from["id"], "start": from["start"], "end": from["end"]}) };
s.execute("edit.findNext", &json!({"find": "cat", "from": from, "backwards": backwards})).unwrap()
};
// "é" is two bytes, so the second match of the bottom object is at bytes 8..11.
let forward = [(top.0, 2, 5, 1, 3), (bottom.0, 0, 3, 2, 3), (bottom.0, 8, 11, 3, 3), (top.0, 2, 5, 1, 3)];
let mut at = Value::Null;
for want in forward {
at = step(&mut s, &at, false);
assert_eq!((found(&at), selected(&s), at["selected"].clone()), (want, vec![NodeId(want.0)], json!(true)));
}
let backward = [(bottom.0, 8, 11, 3, 3), (bottom.0, 0, 3, 2, 3), (top.0, 2, 5, 1, 3), (bottom.0, 8, 11, 3, 3)];
s.execute("select.none", &json!({})).unwrap();
let mut at = Value::Null;
for want in backward {
at = step(&mut s, &at, true);
assert_eq!((found(&at), selected(&s)), (want, vec![NodeId(want.0)]));
}
assert_eq!(history(&s), before, "finding is no undo step");
// A `from` in an object the search does not visit starts at the first match.
let r = s.execute("edit.findNext", &json!({"find": "cat", "from": {"id": 999_999, "start": 0, "end": 0}})).unwrap();
assert_eq!(found(&r), (top.0, 2, 5, 1, 3));
// So does a null `from`, with a type object selected.
sel(&mut s, &[top]);
let r = s.execute("edit.findNext", &json!({"find": "cat", "from": null})).unwrap();
assert_eq!(found(&r), (top.0, 2, 5, 1, 3));
// Nothing found: no match, and the selection stays.
let r = s.execute("edit.findNext", &json!({"find": "zebra"})).unwrap();
assert_eq!((r, selected(&s)), (json!({"id": null, "count": 0}), vec![top]));
}
/// Check Hidden Layers and Check Locked Layers: Find Next and Find and Replace leave the type of
/// a hidden layer and of a locked layer alone unless the switch for it is on. A match on such a
/// layer is returned without being selected. A hidden or locked object keeps its type out with
/// the switches on.
#[test]
fn find_and_replace_reach_hidden_and_locked_layers_only_when_asked() {
for (prop, switch, other) in [("visible", "hiddenLayers", "lockedLayers"), ("locked", "lockedLayers", "hiddenLayers")] {
let mut s = session();
let open = text(&mut s, "cat one");
let layer = id_of(&s.execute("layer.new", &json!({})).unwrap());
let closed = text(&mut s, "cat two");
let object = text(&mut s, "cat three");
let off = |id: NodeId| if prop == "visible" { json!({"id": id.0, "visible": false}) } else { json!({"id": id.0, "locked": true}) };
s.execute("object.setProps", &off(object)).unwrap();
s.execute("layer.setProps", &off(layer)).unwrap();
sel(&mut s, &[open]);
// Without the switch, and with only the other one, the one reachable match is found.
for p in [json!({"find": "cat"}), json!({"find": "cat", other: true})] {
let r = s.execute("edit.findNext", &p).unwrap();
assert_eq!(found(&r), (open.0, 0, 3, 1, 1), "{prop} {p}");
}
// With it, the layer's type is searched (it is above, so it comes first) and not selected.
s.execute("select.none", &json!({})).unwrap();
let r = s.execute("edit.findNext", &json!({"find": "cat", switch: true})).unwrap();
assert_eq!((found(&r), r["selected"].clone(), selected(&s)), ((closed.0, 0, 3, 1, 2), json!(false), vec![]), "{prop}");
let r = s.execute("edit.findNext", &json!({"find": "cat", switch: true, "from": {"id": closed.0, "start": 0, "end": 3}})).unwrap();
assert_eq!((found(&r), r["selected"].clone(), selected(&s)), ((open.0, 0, 3, 2, 2), json!(true), vec![open]), "{prop}");
// Replace All: the same reach.
let n = undo_len(&s);
assert_eq!(
s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog", other: true})).unwrap(),
json!({"count": 1, "replaced": 1}),
"{prop}"
);
assert_eq!((plain(&s, open), plain(&s, closed), plain(&s, object)), ("dog one".into(), "cat two".into(), "cat three".into()), "{prop}");
assert_eq!(
s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog", switch: true})).unwrap(),
json!({"count": 1, "replaced": 1}),
"{prop}"
);
assert_eq!((plain(&s, closed), plain(&s, object), undo_len(&s)), ("dog two".into(), "cat three".into(), n + 2), "{prop}");
}
}
/// Replace changes one match, the bytes Find Next returned, as one undo step, and returns the
/// replacement's bytes to go on from. Bytes that are no match are refused, and a match that
/// already reads as the replacement is left with no undo step.
#[test]
fn replace_match_replaces_the_one_match_found() {
let mut s = session();
let t = text(&mut s, "cat cat Cat");
s.execute("select.none", &json!({})).unwrap();
let first = s.execute("edit.findNext", &json!({"find": "cat"})).unwrap();
assert_eq!(found(&first), (t.0, 0, 3, 1, 3));
let n = undo_len(&s);
let r = s.execute("edit.replaceMatch", &json!({"find": "cat", "replace": "horse", "id": t.0, "start": 0, "end": 3})).unwrap();
assert_eq!(r, json!({"id": t.0, "start": 0, "end": 5, "replaced": true}));
assert_eq!((plain(&s, t), undo_len(&s)), ("horse cat Cat".to_string(), n + 1));
// Replace & Find: on from the replacement, so text put in is not searched again.
let r = s.execute("edit.replaceMatch", &json!({"find": "cat", "replace": "a cat", "id": t.0, "start": 6, "end": 9})).unwrap();
let next = s.execute("edit.findNext", &json!({"find": "cat", "from": {"id": r["id"], "start": r["start"], "end": r["end"]}})).unwrap();
assert_eq!((plain(&s, t), found(&next)), ("horse a cat Cat".to_string(), (t.0, 12, 15, 2, 2)));
// Match Case decides what a match is.
let shape = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
s.execute("select.none", &json!({})).unwrap();
let before = (history(&s), plain(&s, t));
for (p, want) in [
(json!({"find": "cat", "replace": "x", "matchCase": true, "id": t.0, "start": 12, "end": 15}), "at bytes 12..15 of object"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": 1, "end": 4}), "at bytes 1..4 of object"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": 4, "end": 1}), "at bytes 1..4 of object"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": 0}), "missing `end`"),
(json!({"find": "cat", "replace": "x", "start": 0, "end": 3}), "missing `id`"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": "0", "end": 3}), "`start` must be a whole number"),
(json!({"find": "", "replace": "x", "id": t.0, "start": 0, "end": 3}), "missing `find`"),
(json!({"find": "cat", "replace": 5, "id": t.0, "start": 8, "end": 11}), "`replace` must be a string"),
(json!({"find": "cat", "replace": "x", "id": shape.0, "start": 0, "end": 3}), "is not text"),
] {
let r = s.execute("edit.replaceMatch", &p);
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if msg.contains(want)), "{p}: {r:?}");
assert_eq!((history(&s), plain(&s, t)), before, "{p}");
}
let r = s.execute("edit.replaceMatch", &json!({"find": "cat", "replace": "x", "id": 999_999, "start": 0, "end": 3}));
assert!(matches!(r, Err(EngineError::NoNode(NodeId(999_999)))), "{r:?}");
// A match that already reads as the replacement: nothing to undo.
let r = s.execute("edit.replaceMatch", &json!({"find": "CAT", "replace": "Cat", "id": t.0, "start": 12, "end": 15})).unwrap();
assert_eq!((r, history(&s)), (json!({"id": t.0, "start": 12, "end": 15, "replaced": false}), before.0));
// Find Next refuses a `from` that is not a match.
for (from, want) in [
(json!(5), "missing `id`"),
(json!({"id": t.0, "start": 2}), "missing `end`"),
(json!({"id": "x", "start": 0, "end": 1}), "`id` must be a whole number"),
] {
let r = s.execute("edit.findNext", &json!({"find": "cat", "from": from}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if msg.contains(want)), "{from}: {r:?}");
}
for key in ["backwards", "hiddenLayers", "lockedLayers"] {
let r = s.execute("edit.findNext", &json!({"find": "cat", key: "yes"}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if *msg == format!("`{key}` must be true or false")), "{key}: {r:?}");
}
for key in ["hiddenLayers", "lockedLayers"] {
let r = s.execute("edit.findReplace", &json!({"find": "cat", key: 1}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if *msg == format!("`{key}` must be true or false")), "{key}: {r:?}");
}
}
/// Ruby over text after a replaced match moves with the text, for Replace and for Replace All, as
/// it does when the text is typed.
#[test]
fn find_and_replace_moves_the_ruby_after_a_match() {
for all in [false, true] {
let mut s = session();
let t = text(&mut s, "ab 漢字");
sel(&mut s, &[t]);
s.execute("type.ruby", &json!({"text": "かんじ", "start": 3, "end": 9})).unwrap();
if all {
s.execute("edit.findReplace", &json!({"find": "ab", "replace": "abcd"})).unwrap();
} else {
s.execute("edit.replaceMatch", &json!({"find": "ab", "replace": "abcd", "id": t.0, "start": 0, "end": 2})).unwrap();
}
let NodeKind::Text(tt) = &node(&s, t).kind else { panic!() };
assert_eq!((tt.plain_text().as_str(), tt.ruby.first().map(|r| (r.start, r.end))), ("abcd 漢字", Some((5, 11))), "all: {all}");
}
}
/// The Type menu's commands and Find and Replace and Find Next refuse a param of the wrong type, or
/// `ids` that name no object, with an error naming the param, and leave the text, the selection and
/// the undo history as they were, even when Insert Character is also given a source it would use
+9 -4
View File
@@ -326,9 +326,11 @@ fn a_confined_package_names_files_outside_the_read_root_by_name() {
let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
String::from_utf8(zip["poster Folder/poster Report.txt"].clone()).unwrap()
};
// Reopened existing links use native separators; missing links keep their stored path.
let red = dir.0.join("art").join("red.png").to_string_lossy().into_owned();
let person = report(&run(&mut s, "file.package", json!({})));
assert!(person.contains(&format!("From: {}\n", dir.file("poster.vectorcraft"))), "{person}");
assert!(person.contains(&format!("{} → Links/red.png", dir.file("art/red.png"))), "{person}");
assert!(person.contains(&format!("{red} → Links/red.png")), "{person}");
assert!(person.contains(&format!("blue.png: not found ({})", dir.file("art/blue.png"))), "{person}");
let in_root = dir.0.join("in");
@@ -339,16 +341,19 @@ fn a_confined_package_names_files_outside_the_read_root_by_name() {
assert!(text.contains("\nred.png → Links/red.png\n") && text.contains("\nblue.png: not found (blue.png), not copied\n"), "{text}");
let base = dir.0.to_string_lossy().into_owned();
assert!(!text.contains(&base), "{text}");
// Compare serialized JSON with the path encoded the same way, without its outer quotes.
let json_base = serde_json::to_string(&base).unwrap();
let json_base = &json_base[1..json_base.len() - 1];
for key in ["missingLinks", "warnings", "files"] {
assert!(!client[key].to_string().contains(&base), "{key}: {client}");
assert!(!client[key].to_string().contains(json_base), "{key}: {client}");
}
// Document Info, whose report the package holds, gives no link either.
for p in [json!({}), json!({"format": "text"})] {
let info = crate::file_access::confine(roots.as_ref(), || run(&mut s, "document.info", p.clone()));
assert!(!info.to_string().contains(&base), "{p}: {info}");
assert!(!info.to_string().contains(json_base), "{p}: {info}");
}
let info = run(&mut s, "document.info", json!({"format": "text"}));
assert!(info.to_string().contains(&dir.file("art/red.png")), "the person's: {info}");
assert!(info["text"].as_str().unwrap().contains(&red), "the person's: {info}");
}
/// A confined request packages no document that links, or places a native document or a PDF with
+4
View File
@@ -1121,6 +1121,10 @@ fn path_commands_refuse_a_param_of_the_wrong_type() {
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
let r = ids(&s.execute("object.path.offsetPath", &json!({"offset": "0.1 in", "joins": "Bevel"})).unwrap());
assert!(close(bounds(&s, r[0]), Rect::new(92.8, 92.8, 157.2, 147.2), 1e-2), "{:?}", bounds(&s, r[0]));
// A product with a unit, which the offset used to refuse: 0.05x2 in is 0.1 in.
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
let r = ids(&s.execute("object.path.offsetPath", &json!({"offset": "0.05x2 in", "joins": "Bevel"})).unwrap());
assert!(close(bounds(&s, r[0]), Rect::new(92.8, 92.8, 157.2, 147.2), 1e-2), "{:?}", bounds(&s, r[0]));
// Null switches keep Clean Up's defaults, which remove the stray point.
let r = s.execute("object.path.cleanUp", &json!({"strayPoints": null, "unpaintedObjects": null, "emptyTextPaths": null})).unwrap();
assert_eq!(r["removed"], 1);
+21
View File
@@ -176,3 +176,24 @@ fn a_file_over_the_limit_is_refused_before_it_is_parsed() {
assert!(s.execute("prefs.import", &json!({"path": missing.to_string_lossy()})).is_err());
assert_eq!(s.prefs.to_json().to_string(), before);
}
/// Hold Shortcuts is off by default. The Hold Shortcut Delay takes 0.2 to 1.0 s and refuses other
/// values; a value from a settings file outside the range is brought inside it.
#[test]
fn hold_shortcut_preferences() {
let mut s = Session::new();
assert!(!s.prefs.hold_shortcuts);
assert_eq!(s.prefs.key_hold_delay(), 0.35);
for ok in [0.2, 1.0] {
s.execute("prefs.set", &json!({"key": "keyHoldDelay", "value": ok})).unwrap();
assert_eq!(s.prefs.key_hold_delay(), ok);
}
for bad in [0.1, 1.5] {
assert!(is_bad_params(s.execute("prefs.set", &json!({"key": "keyHoldDelay", "value": bad}))), "{bad}");
}
s.execute("prefs.set", &json!({"key": "holdShortcuts", "value": true})).unwrap();
assert!(s.prefs.hold_shortcuts);
let restored: Prefs = serde_json::from_value(json!({"keyHoldDelay": 5.0})).unwrap();
assert_eq!(restored.key_hold_delay(), 1.0);
assert!(!restored.hold_shortcuts);
}
+43
View File
@@ -836,6 +836,49 @@ fn a_null_in_group_colors_removes_that_swatch_and_the_ones_after_it_keep_their_p
assert_eq!(link(&s, green), ("#00ff00".into(), Some(names[2].clone())), "art linked to a swatch that stays keeps its link");
}
/// A gradient or pattern swatch of the group keeps its place and its paint when `recolor.apply`
/// rewrites the group: the group's colors, from the rows or from `groupColors`, go to its color
/// swatches in order.
#[test]
fn apply_with_a_group_keeps_its_gradient_swatch() {
let mut s = session();
run(&mut s, "swatch.newGroup", json!({"name": "Brand", "colors": ["#ff0000", "#0000ff"]}));
let fade = vectorcraft_color::Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default())));
s.edit("test", |d, _| {
let w = vectorcraft_color::Swatch { name: "Fade".into(), paint: fade.clone(), global: false, spot: false };
d.swatch_groups.iter_mut().find(|g| g.name == "Brand").unwrap().swatches.insert(1, w);
Ok(())
})
.unwrap();
let group = |s: &Session| -> Vec<(String, Option<String>)> {
let g = s.doc().unwrap().doc.swatch_groups.iter().find(|g| g.name == "Brand").unwrap().swatches.clone();
g.iter().map(|w| (w.name.clone(), w.paint.color().map(|c| c.to_hex()))).collect()
};
let names: Vec<String> = group(&s).into_iter().map(|(n, _)| n).collect();
rect(&mut s, json!("#ff0000"));
rect(&mut s, json!("#0000ff"));
select_all(&mut s);
// The rows' new colors go to the red and blue swatches; the gradient stays between them.
let map = json!([{"from": ["#ff0000"], "to": "#00ff00"}, {"from": ["#0000ff"], "to": "#ffff00"}]);
run(&mut s, "recolor.apply", json!({"map": map, "group": "Brand"}));
let want = |a: &str, b: &str| vec![(names[0].clone(), Some(a.to_string())), (names[1].clone(), None), (names[2].clone(), Some(b.to_string()))];
assert_eq!(group(&s), want("#00ff00", "#ffff00"));
assert_eq!(gradient_at(&s, 1), fade, "the gradient swatch keeps its paint");
// `groupColors` counts the color swatches only: "keep" is the first, and the second color is
// the blue swatch's.
run(&mut s, "recolor.apply", json!({"map": [], "group": "Brand", "groupColors": ["keep", "#123456"]}));
assert_eq!(group(&s), want("#00ff00", "#123456"));
// A null removes the color swatch at its place and leaves the gradient.
run(&mut s, "recolor.apply", json!({"map": [], "group": "Brand", "groupColors": [null, "#123456"]}));
assert_eq!(group(&s), [(names[1].clone(), None), (names[2].clone(), Some("#123456".into()))]);
assert_eq!(gradient_at(&s, 0), fade);
}
/// The paint of the swatch at place `i` of the group "Brand".
fn gradient_at(s: &Session, i: usize) -> vectorcraft_color::Paint {
s.doc().unwrap().doc.swatch_groups.iter().find(|g| g.name == "Brand").unwrap().swatches[i].paint.clone()
}
/// A row whose new color was removed keeps its art's colors: art in it linked to another swatch of
/// the group, which the rewrite gives another color, loses the link instead of following it.
#[test]
+25
View File
@@ -77,6 +77,31 @@ fn script_missing_include_reports_origin() {
assert!(report["message"].as_str().unwrap().contains("include file not found: nope.jsxinc"), "{report}");
assert_eq!(report["log"], json!([]), "nothing ran before the include was read");
assert!(report.get("file").is_none(), "the line is the script's own");
assert_eq!(report["messageOrigin"], "built-in");
let _ = std::fs::remove_dir_all(base);
}
/// An error in an included file keeps where its message came from: a value the file threw is the
/// script's own text, and an error the app raised for it, or for a file `$.evalFile` could not run, is not.
#[test]
fn script_include_errors_keep_their_message_origin() {
let base = folder("origin");
write(&base.join("main/lib.jsxinc"), "var a = 1;\n throw new RangeError('invalid array length');");
write(&base.join("main/native.jsxinc"), "var a = 1;\n new Array(-1);");
for (text, message, origin) in [
("#include \"lib.jsxinc\"", "RangeError: invalid array length", "script"),
("#include \"native.jsxinc\"", "RangeError: invalid array length", "built-in"),
("try {\n#include \"native.jsxinc\"\n} catch (e) { throw e; }", "RangeError: invalid array length", "built-in"),
("try {\n#include \"native.jsxinc\"\n} catch (e) { throw e.message; }", "invalid array length", "script"),
] {
let report = failed(&base, text);
assert_eq!((report["message"].as_str(), report["messageOrigin"].as_str()), (Some(message), Some(origin)), "{text}: {report}");
}
let report = failed(&base, "#include \"lib.jsxinc\"");
let file = report["file"].as_str().map(|f| Path::new(f).ends_with("lib.jsxinc"));
assert_eq!((file, report["line"].as_u64(), report["column"].as_u64()), (Some(true), Some(2), Some(3)), "{report}");
let report = failed(&base, "$.evalFile('nope.jsx');");
assert_eq!(report["messageOrigin"], "built-in", "{report}");
let _ = std::fs::remove_dir_all(base);
}
+52
View File
@@ -170,6 +170,58 @@ fn an_error_names_the_script_its_place_and_kind() {
assert_eq!(s.script_report().unwrap()["line"], 1);
}
/// A failed run's report keeps its message and kind and says where the message came from: text the
/// script supplied, or one of the app's own errors. The status text and the console line read the
/// same either way, and only the app's own errors get advice about other applications' objects.
#[test]
fn failed_script_report_keeps_message_and_adds_origin() {
let mut s = two_docs();
for (source, kind, message, origin) in [
("throw new Error('invalid array length');", "thrown", "Error: invalid array length", "script"),
("throw new RangeError('invalid array length');", "thrown", "RangeError: invalid array length", "script"),
("throw 'invalid array length';", "thrown", "invalid array length", "script"),
("throw 'ReferenceError: app is not defined';", "thrown", "ReferenceError: app is not defined", "script"),
("try { new Array(-1); } catch (e) { throw new Error(e.message); }", "thrown", "Error: invalid array length", "script"),
("new Array(-1);", "thrown", "RangeError: invalid array length", "built-in"),
("try { new Array(-1); } catch (e) { throw e; }", "thrown", "RangeError: invalid array length", "built-in"),
("vc.run();", "thrown", "TypeError: vc.run: give a command id, as a string", "built-in"),
] {
let e = run(&mut s, source).unwrap_err().to_string();
let report = s.script_report().unwrap().clone();
assert_eq!(
(report["kind"].as_str(), report["message"].as_str(), report["messageOrigin"].as_str()),
(Some(kind), Some(message), Some(origin)),
"{source}"
);
let (line, column) = (&report["line"], &report["column"]);
let before = format!("t.js: line {line}, column {column}: ");
assert_eq!(e, format!("{before}{message} ({kind})"), "{source}");
assert_eq!(s.script_failure_text().as_deref(), Some(e.as_str()));
let authored = s.script_authored_failure();
assert_eq!(authored, (origin == "script").then(|| (before.clone(), message, format!(" ({kind})"))), "{source}");
let console = s.execute("script.console", &json!({})).unwrap();
let error = console["lines"].as_array().unwrap().iter().rev().find(|l| l["kind"] == "error").map(|l| l["text"].clone());
assert_eq!(error, Some(json!(format!("t.js:{line}:{column}: {message}"))), "{source}");
}
// The app's own reference error names the `vc` object; the same text a script threw does not.
run(&mut s, "app.activeDocument;").unwrap_err();
assert!(s.script_report().unwrap()["message"].as_str().unwrap().contains("`vc`"));
assert_eq!(s.script_report().unwrap()["messageOrigin"], "built-in");
// An error in code `eval` compiled keeps where its message came from.
let e = run(&mut s, "eval(\"throw new Error('invalid array length')\");").unwrap_err().to_string();
assert_eq!(e, "t.js: Error: invalid array length (thrown)");
assert_eq!(s.script_authored_failure(), Some(("t.js: ".to_string(), "Error: invalid array length", " (thrown)".to_string())));
// Syntax errors and limits are the app's own.
run(&mut s, "var = 1;").unwrap_err();
assert_eq!((s.script_report().unwrap()["kind"].as_str(), s.script_authored_failure()), (Some("syntax"), None));
s.execute("script.run", &json!({"source": "while (true) {}", "name": "t.js", "maxFuel": 100_000})).unwrap_err();
assert_eq!((s.script_report().unwrap()["messageOrigin"].as_str(), s.script_authored_failure()), (Some("built-in"), None));
// A run that completes has no failure to split.
run(&mut s, "throw 'x';").unwrap_err();
run(&mut s, "1").unwrap();
assert_eq!(s.script_authored_failure(), None);
}
/// An error raised where the run has no place for it, such as in code `eval` compiled, is named
/// with the script and its kind alone, with one colon after the script's name.
#[test]
+15 -5
View File
@@ -192,8 +192,7 @@ impl Session {
.then(|| self.tool.options().get("meshPoints").cloned())
.flatten()
.filter(|v| v.as_array().is_some_and(|a| !a.is_empty()));
let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
self.apply_actions(acts)?;
self.deactivate_tool(view)?;
self.keep_tool_settings();
self.tool = self.make_tool(id);
if let Some(selection) = text_selection {
@@ -209,6 +208,18 @@ impl Session {
Ok(())
}
/// Deactivate the tool and apply the actions it returns. In a batch, a Cancel is left out: the
/// batch settled the tool's drag when it began, and the open interaction holds the batch's
/// steps, which the batch keeps or rolls back as a whole.
pub(crate) fn deactivate_tool(&mut self, view: ViewInfo) -> Result<()> {
let mut acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
if self.batch_stash.is_some() {
acts.retain(|a| !matches!(a, Action::Cancel));
}
self.apply_actions(acts)?;
Ok(())
}
/// The selection tools other than Direct Selection pick whole objects: with one of them chosen,
/// an object selected in a symbol instance's art gives way to the instance. The revision
/// changes with it, so panels that cache by revision show the instance.
@@ -301,8 +312,7 @@ impl Session {
// them all (#8090). Group Selection picks no mesh points, so the Eyedropper keeps its own.
let mesh_points =
(lender.id() == "eyedropper" && self.tool.id() != "groupSelection").then(|| self.tool.options().get("meshPoints").cloned()).flatten();
let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
let r = self.apply_actions(acts);
let r = self.deactivate_tool(view);
self.keep_tool_settings();
self.tool = lender;
if let Some(points) = mesh_points {
@@ -315,7 +325,7 @@ impl Session {
self.lent_selection = left;
}
self.after_command(None);
r.map(drop)
r
}
/// A fresh `id` tool with the options it keeps ([`settings`]): its last values, from this
+2
View File
@@ -1012,6 +1012,8 @@ fn structured_junk() {
("addon.pathtools.bridge", json!({"radius": 1e-308, "keepOriginals": "x"})),
("addon.pathtools.bridge", json!({"radius": 1000, "keepOriginals": true, "ids": [0, 1, 2, 3, u64::MAX]})),
("addon.pathtools.bridge", json!({"radius": f64::MAX, "ids": [1, 1], "junk": [0]})),
("addon.pathtools.bridge", json!({"gap": -1e308, "reach": f64::MAX, "ids": [0, 1, 2]})),
("addon.pathtools.bridge", json!({"gap": 1000, "reach": 10000, "radius": null, "keepOriginals": true})),
// Refused before anything is written: no format of that name, a time that is no time.
("addon.document.saveTimestampedCopy", json!({"format": "png", "folder": 7})),
("addon.document.saveTimestampedCopy", json!({"format": "svg", "time": [1e308], "folder": null})),
+4 -2
View File
@@ -38,11 +38,13 @@ pub(crate) use blend::{MAX_BLEND_OBJECTS, MAX_KEYS as MAX_BLEND_KEYS, PLUGIN as
pub(crate) use brush::{
BrushesRead, MANAGER_NAME as BRUSH_MANAGER, brushes_kept, plugin_name as brush_plugin_name, read_brush_object, turn_over as turn_brush_art_over,
};
#[cfg(test)]
pub(crate) use envelope::DASH_CHECKS_MADE;
pub(crate) use envelope::DRAWN as ENVELOPE_DRAWN;
pub(crate) use envelope::MAX_CHECKED;
pub(crate) use envelope::TYPE_DRAWN as ENVELOPE_TYPE_DRAWN;
pub(crate) use envelope::{GridPoint as EnvelopeGridPoint, PLUGIN as DEFORM_PLUGIN, outline as envelope_outline, upright as envelope_upright};
pub(crate) use envelope::{MAX_ANY as ENVELOPE_MAX_ANY, MAX_SOLID as ENVELOPE_MAX_SOLID};
pub(crate) use envelope::{MAX_CHECKED, MAX_DASH_CHECKS};
pub(crate) use envelope::{WARPED_TYPE_DRAWN, WarpedType};
#[cfg(test)]
pub(crate) use frames::TEXT_FRAME_SCANS;
@@ -67,7 +69,7 @@ pub use read::{
#[cfg(test)]
pub(crate) use style::ART_STYLE_PARSES;
pub(crate) use read::is_look_slot;
pub(crate) use read::{clip_by_type, is_look_slot};
pub(crate) use style::{MAX_LISTED, MAX_LISTED_NAME, warp_number};
#[cfg(test)]
+2 -1
View File
@@ -10,7 +10,8 @@
//! locally, never committed): the blend's own art on `%_` lines, a group holding the key objects
//! and the spine, each object's `/ArtDictionary` naming its part (`ShapeBlendPathType`: `K` a key,
//! `S` the spine) and a key's id (`ShapeBlendPathID`); then the steps drawn, a group on plain
//! lines; then `(Adobe Path Blends) 1 0 n XP` and `n` bytes as hex on `%` lines. Those bytes
//! lines; then `(Adobe Path Blends) 1 0 n XP` and `n` bytes as hex on `%` lines (`%_%` lines
//! for a blend in hidden art, as an opacity mask's is: all of it is on `%_` lines). Those bytes
//! start `DCBA`. A blend whose spine was never edited has no spine part: only its keys.
//!
//! The reader reads the words after `DCBA` (little endian) this way. Word 1 is the spacing: 0 is
+80 -4
View File
@@ -59,6 +59,16 @@ pub(crate) fn drawn_note(typed: bool) -> &'static str {
pub(super) const MAX_PENDING: usize = 64;
/// The most envelopes and warped text objects one import draws to check; more keep their drawn art.
pub(crate) const MAX_CHECKED: usize = 256;
/// The most strokes with dashes aligned to corners one import draws to check against their drawn
/// looks (apart from [`MAX_CHECKED`]); more keep their drawn looks.
pub(crate) const MAX_DASH_CHECKS: usize = 256;
#[cfg(test)]
thread_local! {
/// How many strokes with dashes aligned to corners have been drawn on this thread to check them
/// against their looks.
pub(crate) static DASH_CHECKS_MADE: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
/// The most rows or columns of a mesh read (Make with Mesh's own limit).
const MAX_GRID: u32 = 50;
/// How far, in points over width and height together, a saved size may lie from the contents'
@@ -692,6 +702,8 @@ pub struct WarpedType {
pub(super) checks: usize,
pub(super) spent: Spent,
pub(super) page: Option<Rect>,
/// [`super::Structure::type_clips`]: type in an envelope's contents clips its clipping group too.
pub(super) type_clips: HashMap<NodeId, NodeId>,
/// The envelopes of type that may open live in layers built without a page, by their place
/// among them ([`Self::open_alone`]): none when `None`.
pub(super) alone: Option<BTreeSet<usize>>,
@@ -811,8 +823,10 @@ impl WarpedType {
texts.insert(slot, text);
hidden.push(id);
}
let typed = |slot: NodeId| texts.get(&slot).map(|t| t.id);
for n in before.iter_mut().chain(inner.iter_mut()) {
put_type(n, &texts);
super::clip_by_type(n, &self.type_clips, &typed, &mut |_| ());
}
// A warp that VectorCraft's own warp doesn't draw as its drawn art may still draw as the
// grid the file saves for it: then it opens as a mesh envelope on that grid.
@@ -980,10 +994,11 @@ pub(super) fn warps(appearance: &Appearance) -> bool {
appearance.effects.iter().any(warp) || appearance.items.iter().any(|i| i.visible() && i.effects().iter().any(warp))
}
/// Do `live` and `drawn` draw alike: few of the pixels either inks differ, and fewer still where a
/// whole patch differs; and, on `page` (when the file has one), do they differ little enough that
/// with the differences in `spent` the page check still takes the layers' art (it is added to
/// `spent` when they do)? Both are drawn on `layer`, a layer id no other node has.
/// Do `live` and `drawn` draw alike? Either neither has any paint ([`paints`]), or few of the
/// pixels either inks differ and fewer still where a whole patch differs, and, on `page` (when the
/// file has one), they differ little enough that with the differences in `spent` the page check
/// still takes the layers' art (it is added to `spent` when they do). Both are drawn on `layer`, a
/// layer id no other node has.
pub(super) fn drawn_alike(live: &Node, drawn: &Node, layer: NodeId, shared: &Shared<'_>, page: Option<Rect>, spent: &mut Spent) -> bool {
alike_within(live, drawn, live.visual_bounds(), layer, shared, page, spent)
}
@@ -997,6 +1012,12 @@ pub(super) fn warped_alike(live: &Node, drawn: &Node, layer: NodeId, shared: &Sh
/// [`drawn_alike`], with `live` measured as `reach`.
fn alike_within(live: &Node, drawn: &Node, reach: Option<Rect>, layer: NodeId, shared: &Shared<'_>, page: Option<Rect>, spent: &mut Spent) -> bool {
// Neither has any paint (type with no fill and no stroke, its drawn art the outlines unpainted):
// both draw nothing, so they draw alike and add nothing to what the page check sees. Their
// shapes aren't compared. Art that paints, however faintly, is compared as before.
if !paints(live, 0) && !paints(drawn, 0) {
return true;
}
let (Some(a), Some(b)) = (reach, drawn.visual_bounds()) else { return false };
let region = a.union(b).inflate(2.0, 2.0);
if !(region.is_finite() && region.width() > 0.0 && region.height() > 0.0) || region.width().max(region.height()) > 1e6 {
@@ -1029,6 +1050,26 @@ fn alike_within(live: &Node, drawn: &Node, reach: Option<Rect>, layer: NodeId, s
true
}
/// Does `n`, shown, paint anything: a fill or stroke of its own or of its type with a paint, an
/// effect, or an object of another kind than a path, type or container (an image, a mesh, a symbol
/// instance…)? Hidden objects paint nothing. Past `depth` 64 it is taken to paint.
fn paints(n: &Node, depth: usize) -> bool {
if depth > 64 {
return true;
}
if !n.visible {
return false;
}
if n.appearance.items.iter().any(|i| i.visible() && !i.paint().is_none()) || n.appearance.effects.iter().any(|e| e.visible) {
return true;
}
match &n.kind {
NodeKind::Path { .. } => false,
NodeKind::Text(t) => t.runs.iter().any(|r| !r.style.fill.is_none() || !r.style.stroke.is_none()),
_ => n.children().is_none_or(|c| c.iter().any(|c| paints(c, depth + 1))),
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -1056,6 +1097,41 @@ mod tests {
}
}
/// A 40 × 40 square at (10, 10) filled black at `opacity`, or with no fill when `None`.
fn square_node(id: u64, opacity: Option<f32>) -> Node {
let mut bp = BezPath::new();
bp.move_to((10.0, 10.0));
bp.line_to((50.0, 10.0));
bp.line_to((50.0, 50.0));
bp.line_to((10.0, 50.0));
bp.close_path();
let mut n = Node::new(
NodeId(id),
NodeKind::Path { path: PathData::from_bezpath(&bp), rule: Default::default(), live: None, clipping: false, guide: false },
);
let mut appearance = (*n.appearance).clone();
appearance.items.clear();
if let Some(o) = opacity {
appearance.items.push(AppearanceItem::Fill(vectorcraft_doc::FillLayer::new(Paint::solid(Color::BLACK))));
n.opacity = o;
}
n.appearance = appearance.into();
n
}
/// Two objects with no paint draw alike; two that paint too faintly to ink a pixel (an alpha of
/// 8 or less) aren't taken as alike, nor is one with paint against one without.
#[test]
fn art_with_no_paint_draws_alike_and_faint_art_is_still_compared() {
let shared = Shared { patterns: &[], images: &BTreeMap::new() };
let alike = |a: &Node, b: &Node| drawn_alike(a, b, NodeId(999), &shared, None, &mut Spent::default());
let (none, other_none) = (square_node(1, None), square_node(2, None));
assert!(alike(&none, &other_none));
let (faint, other_faint) = (square_node(1, Some(0.02)), square_node(2, Some(0.02)));
assert!(!alike(&faint, &other_faint));
assert!(!alike(&none, &square_node(2, Some(1.0))));
}
/// "AVA" at 40 points, at (10, 60).
fn type_node(id: u64, style: CharStyle) -> Node {
Node::new(NodeId(id), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 60.0), "AVA", CharStyle { size: 40.0, ..style }))))
+12 -1
View File
@@ -5,7 +5,8 @@
//! - Any other line starting with `%` is a [`Tok::Comment`] (the section markers).
//! - `%_` later in a line starts tokens too, hidden (a pseudo-comment operator after its
//! operands, as a gradient stop's `… 50 100 %_Bs`: AI7 spec §1.4.3); any other `%` later in a
//! line starts a comment that is skipped.
//! line starts a comment that is skipped, but for a line of hex digits after `%_` (a hidden
//! blend's record), a hidden [`Tok::Comment`].
//! - The binary image data after `%%BeginData:` is one [`Tok::Data`]; the binary preview of a placed
//! file is one [`Tok::Preview`].
//! - A document included whole (`%%BeginDocument:` … `%%EndDocument` lines, DSC 3.0 p. 68, nested
@@ -222,6 +223,12 @@ impl<'a> Lexer<'a> {
if prefixed && PLACE.iter().chain(&NOTES).chain(&RELATIVE).any(|m| line.starts_with(m)) {
return Some(Token { tok: Tok::Comment(line.get(1..).unwrap_or_default()), hidden: true });
}
// And a line of hex digits, as a hidden blend's record is written (`%_%4443…`
// after its `XP`), like the plain one on `%` lines.
let digits = line.get(1..).unwrap_or_default();
if prefixed && !digits.trim_ascii_end().is_empty() && digits.trim_ascii_end().iter().all(u8::is_ascii_hexdigit) {
return Some(Token { tok: Tok::Comment(digits), hidden: true });
}
// A comment later in a line.
continue;
}
@@ -470,6 +477,10 @@ mod tests {
let toks = all(b"1 % a note (\n2 %_Bs\n3 %_ 4\n");
let words: Vec<_> = toks.iter().map(|t| (t.tok.clone(), t.hidden)).collect();
assert_eq!(words, [(Tok::Num(1.0), false), (Tok::Num(2.0), false), (Tok::Word(b"Bs"), true), (Tok::Num(3.0), false)]);
// A hidden line of hex digits (a hidden blend's record) is a comment; other text after
// `%_%` stays skipped.
let toks = all(b"%_%44434241\n%_% not hex\n%_%\n1\n");
assert_eq!(toks, [t(Tok::Comment(b"44434241"), true), t(Tok::Num(1.0), false)]);
}
#[test]
+50
View File
@@ -195,6 +195,10 @@ pub struct Structure {
pub unread_elsewhere: Vec<(NodeId, Rect)>,
/// The names of text objects, by their slot's id.
pub slot_names: HashMap<NodeId, String>,
/// The clipping groups whose type clips them, by the group's id: the text slot of that type,
/// the group's last object ([`Reader::end_container`]). Once the slot holds its type, the type
/// clips the group ([`clip_by_type`]).
pub type_clips: HashMap<NodeId, NodeId>,
/// Where the drawn looks lay that objects read with their art style took the place of (the
/// document's coordinates): the page draws Illustrator's rendering of those styles there.
pub restyled: Vec<Rect>,
@@ -595,6 +599,13 @@ struct Reader<'a> {
envelope_checks: usize,
/// How far the live envelopes read so far draw from their drawn art ([`super::envelope::Spent`]).
envelope_spent: super::envelope::Spent,
/// How many more strokes with dashes aligned to corners this import may draw to check
/// ([`super::MAX_DASH_CHECKS`]).
dash_checks: usize,
/// Whether this reader reads only what comes before the first layer (swatches, brushes, styles,
/// symbols) for a file whose layers another reader reads: it makes no more checks once it
/// reaches the layers, so it spends none of theirs.
defs_only: bool,
/// The text objects read with a Warp ([`super::envelope::WarpedType`]).
warped_type: Vec<super::envelope::WarpedLook>,
/// The envelopes of type read with their drawn art, settled once the type is laid out
@@ -662,6 +673,8 @@ struct Reader<'a> {
obj_hidden: bool,
/// The names of text objects, by their slot's id.
slot_names: HashMap<NodeId, String>,
/// [`Structure::type_clips`].
type_clips: HashMap<NodeId, NodeId>,
/// [`Structure::xml_ids`].
xml_ids: HashMap<String, Option<NodeId>>,
/// The bytes of the ids in `xml_ids`.
@@ -732,6 +745,40 @@ pub(crate) fn is_look_slot(name: Option<&str>) -> bool {
name == Some(document::LOOK_SLOT)
}
/// Make the clipping groups of [`Structure::type_clips`] in `n` and its groups clip by their type,
/// once their slots are filled: where a group's slot became one text object (`typed` gives its id by
/// the slot's) that is still the group's last object, that text object moves to the front as its
/// clipping path, and `clipping` is called on it. Where the slot was left empty or became several
/// objects, the group stays as read, unclipped. How many groups clip.
pub(crate) fn clip_by_type(
n: &mut Node,
clips: &HashMap<NodeId, NodeId>,
typed: &impl Fn(NodeId) -> Option<NodeId>,
clipping: &mut impl FnMut(&mut Node),
) -> usize {
if clips.is_empty() || matches!(n.kind, NodeKind::Compound { .. }) {
return 0;
}
let mut made = 0;
if let Some(children) = n.children_mut() {
for c in children.iter_mut().filter(|c| c.children().is_some_and(|k| !k.is_empty())) {
made += clip_by_type(Arc::make_mut(c), clips, typed, clipping);
}
}
let Some(text) = clips.get(&n.id).and_then(|slot| typed(*slot)) else { return made };
if let NodeKind::Group { children, clip } = &mut n.kind
&& !*clip
&& children.last().is_some_and(|last| last.id == text && matches!(last.kind, NodeKind::Text(_)))
&& let Some(mut last) = children.pop()
{
clipping(Arc::make_mut(&mut last));
children.insert(0, last);
*clip = true;
made += 1;
}
made
}
impl<'a> Reader<'a> {
/// A reader of the editing data `data` as a whole, with the names its gradients and patterns
/// get in the document and its art styles found first ([`swatch_names`]): the symbols defined
@@ -824,6 +871,8 @@ impl<'a> Reader<'a> {
envelopes: Vec::new(),
envelope_checks: super::envelope::MAX_CHECKED,
envelope_spent: super::envelope::Spent::default(),
dash_checks: super::MAX_DASH_CHECKS,
defs_only: false,
warped_type: Vec::new(),
typed_envelopes: Vec::new(),
envelopes_drawn: Vec::new(),
@@ -853,6 +902,7 @@ impl<'a> Reader<'a> {
done: false,
obj_hidden: false,
slot_names: HashMap::new(),
type_clips: HashMap::new(),
xml_ids: HashMap::new(),
xml_id_bytes: 0,
art_size: None,
+30 -1
View File
@@ -16,6 +16,9 @@ impl<'a> Reader<'a> {
if matches!(kind, Kind::Layer(_)) {
self.ensure_space();
self.check_symbols();
if self.defs_only {
(self.envelope_checks, self.dash_checks) = (0, 0);
}
}
let base = if matches!(kind, Kind::Obj(_)) { self.stack.len() } else { self.frames.last().map_or(0, |f| f.base) };
self.frames.push(Frame {
@@ -120,11 +123,13 @@ impl<'a> Reader<'a> {
}
// A group holding only clipping paths (`q … u <path> W n U … Q`) doesn't clip on its own: `u`/`U` don't save
// the graphics state as `q`/`Q` do, so its paths clip the clipping group around it, as the file's PDF part draws it.
// In a compound path (`*u u <path> W n … U *U`, possibly nested in other groups) they are the compound
// path's subpaths, as its other grouped paths are: the compound clipping path, their union.
if matches!(kind, Kind::Group)
&& unread.is_empty()
&& !clips.is_empty()
&& clips.len() == kids.len()
&& matches!(self.frames.last(), Some(Frame { kind: Kind::Clip, .. }))
&& (matches!(self.frames.last(), Some(Frame { kind: Kind::Clip, .. })) || self.in_compound())
{
for kid in kids {
if let Some(parent) = self.frames.last_mut() {
@@ -134,6 +139,15 @@ impl<'a> Reader<'a> {
}
return Ok(());
}
// A clipping group (`q` … `Q`) with no clipping path whose last object is type: that type is
// its clipping path, as Illustrator writes a clipping mask of type made from the text
// document (`/AI11Text`), which has no `W`. The slot is filled later ([`clip_by_type`]).
let type_clip = match kids.last() {
Some(last) if matches!(kind, Kind::Clip) && clips.is_empty() && !super::is_look_slot(last.name.as_deref()) => {
slot_of(last.name.as_deref()).map(|_| last.id)
}
_ => None,
};
// A compound path of clipping paths clips its clipping group.
let clipping = matches!(kind, Kind::Compound) && !clips.is_empty();
self.group_ended = !matches!(kind, Kind::Compound);
@@ -179,6 +193,9 @@ impl<'a> Reader<'a> {
if clipping && let Some(f) = self.frames.last_mut() {
f.clips.push(f.children.len());
}
if let Some(slot) = type_clip {
self.type_clips.insert(node.id, slot);
}
if compound_members {
self.compound_groups.insert(node.id);
}
@@ -197,6 +214,18 @@ impl<'a> Reader<'a> {
Ok(())
}
/// Is the innermost open frame a compound path (`*u`), or a group in one with only groups between them?
fn in_compound(&self) -> bool {
for f in self.frames.iter().rev() {
match f.kind {
Kind::Group => {}
Kind::Compound => return true,
_ => return false,
}
}
false
}
/// The compound path of `kids`, painted and made transparent as its subpaths say.
fn compound(&mut self, mut kids: Vec<Node>, gs: &GState) -> Option<Node> {
// The compound path's paint is its last path's (a gradient's instance wraps only
+4 -1
View File
@@ -837,11 +837,13 @@ impl<'a> Reader<'a> {
}
/// Lend `sub`, a reader of a definition, what this import may still spend on laying out blends
/// and checking envelopes ([`Reader::take_back_budgets`] takes back what is left).
/// and checking envelopes and aligned dashes ([`Reader::take_back_budgets`] takes back what is
/// left).
fn lend_budgets(&mut self, sub: &mut Reader<'_>) {
sub.blend_budget = self.blend_budget;
sub.envelope_checks = self.envelope_checks;
sub.envelope_spent = std::mem::take(&mut self.envelope_spent);
sub.dash_checks = self.dash_checks;
}
/// Take back from `sub` what [`Self::lend_budgets`] lent it, less what it spent.
@@ -849,6 +851,7 @@ impl<'a> Reader<'a> {
self.blend_budget = sub.blend_budget;
self.envelope_checks = sub.envelope_checks;
self.envelope_spent = std::mem::take(&mut sub.envelope_spent);
self.dash_checks = sub.dash_checks;
}
/// In a pattern's definition, the operands of its first operator start with its head,
+61 -2
View File
@@ -336,6 +336,7 @@ fn repoint(n: &mut Node, renamed: &std::collections::BTreeMap<String, String>) {
/// those the swatches take.
pub fn palette(data: &[u8], patterns: &[PatternDef], names: &mut obj::Names) -> Option<PaletteSwatches> {
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
// The palette, the gradients and the patterns it names come before the art, so an error in the
// art leaves them read.
let _ = r.run();
@@ -396,6 +397,7 @@ pub fn brushes(data: &[u8], patterns: &[PatternDef], names: &mut obj::Names) ->
// Brush objects are plug-in objects: data without one isn't read again.
memchr::memmem::find(data, b"BeginPluginObject")?;
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
// The brushes come before the art, so an error in the art leaves them read.
let _ = r.run();
let (mut lib, unread) = r.brush_library()?;
@@ -449,6 +451,7 @@ pub fn graphic_styles(data: &[u8], large_canvas: bool, names: &mut obj::Names) -
return (vec![], 1.0);
}
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
r.large_canvas = large_canvas.then_some(1.0);
// The styles come before the art, so an error in the art leaves them read.
let _ = r.run();
@@ -482,6 +485,7 @@ pub struct Symbols {
pub fn symbols(data: &[u8], names: &mut obj::Names) -> Option<Symbols> {
crate::import::ai::find(data, b"BeginSymbol")?;
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
// The symbols come before the art, so an error in the art leaves them read.
let _ = r.run();
r.check_symbols();
@@ -536,10 +540,20 @@ pub fn symbols(data: &[u8], names: &mut obj::Names) -> Option<Symbols> {
Some(Symbols { symbols, images, swatches, canvas_scale: r.canvas_scale, own_size: r.symbols_own_size })
}
/// A reader of all of `data` for what doesn't depend on how its art draws (its artboards, its
/// variable library): it checks no envelope and no stroke with aligned dashes against its drawn
/// look, so it spends none of the import's checks ([`super::MAX_CHECKED`],
/// [`super::MAX_DASH_CHECKS`]), which are the layers' reader's.
fn reader_aside(data: &[u8]) -> Reader<'_> {
let mut r = Reader::new(data);
(r.envelope_checks, r.dash_checks) = (0, 0);
r
}
/// [`artboards`] as far as reading `data` from its start gets: those read before an error, and
/// those of a `/Document` still open when it stopped (its art can be what stopped it).
fn artboards_read(data: &[u8], names: &mut obj::Names) -> (Vec<(String, Rect)>, Option<usize>) {
let mut r = Reader::new(data);
let mut r = reader_aside(data);
r.names = obj::Names::new(names.encoding);
let _ = r.run();
let open: Vec<Obj> = r.frames.iter().filter_map(|f| if let Kind::Obj(o) = &f.kind { Some((**o).clone()) } else { None }).collect();
@@ -608,7 +622,7 @@ pub fn variables(data: &[u8], names: &mut obj::Names) -> VariableRead {
if crate::import::ai::find(data, b"variableSets").is_none() {
return VariableRead::default();
}
let mut r = Reader::new(data);
let mut r = reader_aside(data);
r.names = obj::Names::new(names.encoding);
let _ = r.run();
if r.variables.present {
@@ -1385,6 +1399,7 @@ impl<'a> Reader<'a> {
unread: self.unread,
unread_elsewhere: self.unread_elsewhere,
slot_names: self.slot_names,
type_clips: self.type_clips.clone(),
restyled: self.restyled,
placeholders: self.placeholders,
placed_elsewhere: self.placed_elsewhere,
@@ -1397,6 +1412,7 @@ impl<'a> Reader<'a> {
spent: self.envelope_spent,
page,
alone: None,
type_clips: self.type_clips,
},
styles_read,
text_patterns,
@@ -1960,6 +1976,20 @@ impl LibraryWalk {
}
}
/// Whether an XML node in `o` or the dictionaries it holds has a value or a type
/// (`xmlnode-nodevalue`, `xmlnode-nodetype`). `seen` counts the dictionaries looked at; past
/// [`MAX_LIBRARY_NODES`] of them, or deeper than [`MAX_DEPTH`], the library is taken to hold some.
fn holds_values(o: &Obj, seen: &mut usize, depth: usize) -> bool {
*seen = seen.saturating_add(1);
if *seen > MAX_LIBRARY_NODES || depth > MAX_DEPTH {
return true;
}
if o.ty == "XMLNode" && (o.get("xmlnode-nodevalue").is_some() || o.get("xmlnode-nodetype").is_some()) {
return true;
}
o.items().any(|c| holds_values(c, seen, depth + 1))
}
/// The library of the `variableSets` element `sets` (see [`variable_library`]).
fn read_variable_sets(sets: &Obj) -> VariableRead {
let mut walk = LibraryWalk::default();
@@ -1979,5 +2009,34 @@ fn read_variable_sets(sets: &Obj) -> VariableRead {
if walk.nodes > MAX_LIBRARY_NODES {
return VariableRead { variables: Variables::default(), bindings: vec![], bindings_skipped: 0, skipped: 1, present: true };
}
if vars == Variables::default() && walk.bindings.is_empty() && !holds_values(sets, &mut 0, 0) {
// The empty library a file can keep: nodes with names and nothing else (no value, no
// type). There is nothing in it to list, so nothing was left out.
walk.skipped = 0;
}
VariableRead { variables: vars, bindings: walk.bindings, bindings_skipped: walk.bindings_skipped, skipped: walk.skipped, present: true }
}
#[cfg(test)]
mod tests {
use super::*;
use std::rc::Rc;
/// An XML node holding `child` (when given) and nothing else: no value, no type.
fn node(child: Option<Obj>) -> Obj {
let children = Obj { ty: "Array".into(), content: child.map(|c| V::Obj(Rc::new(c))).into_iter().collect(), ..Obj::default() };
Obj { ty: "XMLNode".into(), entries: vec![(Some("xmlnode-children".into()), vec![V::Obj(Rc::new(children))])], ..Obj::default() }
}
/// An empty library is taken to hold values past the caps on what is looked at: nested deeper
/// than [`MAX_DEPTH`], or once [`MAX_LIBRARY_NODES`] dictionaries have been looked at.
#[test]
fn an_empty_library_past_the_caps_is_taken_to_hold_values() {
let shallow = node(Some(node(None)));
assert!(!holds_values(&shallow, &mut 0, 0));
let deep = (0..MAX_DEPTH).fold(node(None), |inner, _| node(Some(inner)));
assert!(holds_values(&deep, &mut 0, 0));
let mut seen = MAX_LIBRARY_NODES;
assert!(holds_values(&shallow, &mut seen, 0));
}
}
+233 -20
View File
@@ -832,15 +832,32 @@ impl<'a> Reader<'a> {
})
});
// An image with a Warp is the object only where its live warp draws as its drawn look, and
// while the import has a check left for it; otherwise its drawn look stays.
// while the import has a check left for it; otherwise its drawn look stays. So is a stroke
// with dashes aligned to corners and path ends, whose fitting is VectorCraft's own, within
// checks of its own ([`crate::import::ai::MAX_DASH_CHECKS`]) and without weighing the page:
// the envelopes' checks and share of the page check stay theirs alone. Type with such
// dashes keeps its drawn look, as before.
let appearance = match appearance {
Some(ap) if aligns_dashes(&ap) && slot_of(object.name.as_deref()).is_some() => None,
Some(ap) if matches!(object.kind, NodeKind::Image(_)) && ap.effects.iter().any(|e| e.id.starts_with("warp.")) => {
let alike = self.envelope_checks > 0 && {
self.envelope_checks -= 1;
let layer = self.doc.alloc_id();
let shared = crate::import::ai::envelope::Shared { patterns: &self.doc.patterns, images: &self.doc.images };
let shown = !hidden && object.visible && look.visible;
image_warp_alike(object, &ap, look, &self.hidden_ids, hidden, layer, &shared, page.filter(|_| shown), &mut self.envelope_spent)
look_alike(object, &ap, look, &self.hidden_ids, hidden, layer, &shared, page.filter(|_| shown), &mut self.envelope_spent)
};
alike.then_some(ap)
}
Some(ap) if aligns_dashes(&ap) => {
let alike = self.dash_checks > 0 && {
self.dash_checks -= 1;
#[cfg(test)]
crate::import::ai::DASH_CHECKS_MADE.set(crate::import::ai::DASH_CHECKS_MADE.get() + 1);
let layer = self.doc.alloc_id();
let shared = crate::import::ai::envelope::Shared { patterns: &self.doc.patterns, images: &self.doc.images };
let mut spent = crate::import::ai::envelope::Spent::default();
look_alike(object, &ap, look, &self.hidden_ids, hidden, layer, &shared, None, &mut spent)
};
alike.then_some(ap)
}
@@ -1062,23 +1079,35 @@ fn tick(vals: &[V]) -> Option<(Affine, Rect, String)> {
}
/// The gradients and patterns `look` paints with, placed as it draws them, by their swatch's name
/// (the first of each; a pattern's name after `PATTERN_KEY`).
fn placed_paints(look: &Node, out: &mut HashMap<String, Paint>, depth: usize) {
/// (the first of each; a pattern's name after `PATTERN_KEY`). With `fill_patterns`, a pattern only
/// where the look fills with it: a style's pattern is a fill, so a path's stack takes it from the
/// look's fills alone (type keeps taking it from either). `moved` gets each pattern that the look
/// also places elsewhere than its first placement.
fn placed_paints(look: &Node, out: &mut HashMap<String, Paint>, moved: &mut HashSet<String>, fill_patterns: bool, depth: usize) {
if depth > MAX_DEPTH {
return;
}
for item in &look.appearance.items {
let key = match item.paint() {
Paint::Gradient(g) => g.swatch.clone(),
Paint::Pattern { pattern, .. } => Some(format!("{PATTERN_KEY}{pattern}")),
Paint::Pattern { pattern, .. } if item.is_fill() || !fill_patterns => Some(format!("{PATTERN_KEY}{pattern}")),
_ => None,
};
if let Some(key) = key {
out.entry(key).or_insert_with(|| item.paint().clone());
match out.get(&key) {
Some(first) => {
if matches!(first, Paint::Pattern { .. }) && first != item.paint() {
moved.insert(key);
}
}
None => {
out.insert(key, item.paint().clone());
}
}
}
}
for c in look.children().into_iter().flatten() {
placed_paints(c, out, depth + 1);
placed_paints(c, out, moved, fill_patterns, depth + 1);
}
}
@@ -1224,18 +1253,19 @@ fn moves_with(object: &Node, st: &crate::import::ai::style::ArtStyle) -> bool {
/// Is `object` an image without an opacity mask, and `st` one Warp on it with nothing else that
/// paints ([`crate::import::ai::style::ArtStyle::image_warp`])? Such an image is read with its Warp
/// live where that draws as its drawn look ([`image_warp_alike`]).
/// live where that draws as its drawn look ([`look_alike`]).
fn image_warps(object: &Node, st: &crate::import::ai::style::ArtStyle) -> bool {
matches!(object.kind, NodeKind::Image(_)) && object.extras().mask.is_none() && st.image_warp
}
/// Does image `object` with `appearance` (its style's Warp) draw as `look`, its drawn look, compared
/// over all that the warp draws ([`crate::import::ai::envelope::warped_alike`]) on `layer`, a layer
/// id no other node has? Both are drawn shown, opaque and in the Normal mode; a hidden look is drawn
/// with every object in it shown, as the hidden object's look holds them. Unless the look is on
/// `%_` lines itself (`hidden`), the copies in it that are on `%_` lines (`hidden_ids`) are left out.
/// Does `object` with `appearance` (an image's Warp, or a stroke with dashes aligned to corners)
/// draw as `look`, its drawn look, compared over all that it draws, effects included
/// ([`crate::import::ai::envelope::warped_alike`]), on `layer`, a layer id no other node has? Both
/// are drawn shown, opaque and in the Normal mode; a hidden look is drawn with every object in it
/// shown, as the hidden object's look holds them. Unless the look is on `%_` lines itself
/// (`hidden`), the copies in it that are on `%_` lines (`hidden_ids`) are left out.
#[allow(clippy::too_many_arguments)]
fn image_warp_alike(
fn look_alike(
object: &Node,
appearance: &Appearance,
look: &Node,
@@ -1261,6 +1291,11 @@ fn image_warp_alike(
crate::import::ai::envelope::warped_alike(&live, &plain, layer, shared, page, spent)
}
/// Does `appearance` stroke with dashes aligned to corners and path ends?
fn aligns_dashes(appearance: &Appearance) -> bool {
appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.dash.as_ref().is_some_and(|d| d.align_corners && d.is_dashed())))
}
/// Show every object in container `n`, at any depth.
fn show_members(n: &mut Node) {
for c in n.children_mut().into_iter().flatten() {
@@ -1282,7 +1317,7 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
let slot = slot_of(object.name.as_deref()).is_some();
// Several fills and strokes, on a path or a compound path.
let stacked = !slot && !st.simple && st.stacked && matches!(object.kind, NodeKind::Path { .. } | NodeKind::Compound { .. });
// One Warp on an image, checked against its drawn look by the caller ([`image_warp_alike`]).
// One Warp on an image, checked against its drawn look by the caller ([`look_alike`]).
let image_warp = !st.simple && image_warps(object, st);
// A symbol instance draws its symbol's art: it keeps its drawn look.
if !st.plain
@@ -1301,15 +1336,22 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
let own_gradient = object.appearance.fill().filter(|f| matches!(f.paint, Paint::Gradient(_)));
// A style's gradients are written in a space of the object's bounds that isn't documented; its
// drawn look has each where the app placed it.
let mut placed = HashMap::new();
placed_paints(look, &mut placed, 0);
let (mut placed, mut moved) = (HashMap::new(), HashSet::new());
placed_paints(look, &mut placed, &mut moved, stacked, 0);
// A stack's gradients are each its own swatch, placed where the drawn look has it: one fitted
// to the object's bounds instead could lie elsewhere, so such a stack keeps its drawn look.
// to the object's bounds instead could lie elsewhere, so such a stack keeps its drawn look. So
// are its patterns, each once, and each placed one way in the look: `placed_paints` keeps the
// first placement of each name, and which of several is the style's isn't known. The same
// placement again (a compound path's look fills each subpath) is still one.
if stacked {
let mut seen = HashSet::new();
let (mut seen, mut seen_patterns) = (HashSet::new(), HashSet::new());
let placed_apart = st.items.iter().all(|i| match i {
StyleItem::Gradient { name: Some(n), .. } => seen.insert(n) && placed.contains_key(paints.names.get(Global::Gradient, n)),
StyleItem::Gradient { name: None, .. } => false,
StyleItem::Pattern { name, .. } => {
let key = format!("{PATTERN_KEY}{}", paints.names.get(Global::Pattern, name));
seen_patterns.insert(key.clone()) && placed.contains_key(&key) && !moved.contains(&key)
}
_ => true,
});
if !placed_apart {
@@ -1382,7 +1424,134 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
} else {
object.appearance.contents_index
};
Some(Appearance { items, effects: st.effects.clone(), contents_index })
let appearance = Appearance { items, effects: st.effects.clone(), contents_index };
// Zig Zag's ridges are placed by VectorCraft's own rule: on objects other than type it is kept
// only where they draw the outline the drawn look has.
if !slot && st.effects.iter().any(|e| e.id == "distort.zigZag") && !draws_look_outline(object, &appearance, look) {
return None;
}
Some(appearance)
}
/// How far, in points, an outline drawn with a reshaping effect may lie from its drawn look's
/// ([`draws_look_outline`]): the look's coordinates are written to a few decimals.
const OUTLINE_TOLERANCE: f64 = 0.25;
/// How far, in points, a flattened outline in [`draws_look_outline`] may lie from its curves.
const OUTLINE_FLATNESS: f64 = OUTLINE_TOLERANCE / 10.0;
/// How far apart, in points, [`draws_look_outline`] checks points along each flattened segment.
const OUTLINE_SPACING: f64 = OUTLINE_TOLERANCE / 2.0;
/// How close, in points, each checked point must lie to the other flattened outline: every point
/// between two checked ones is within half the spacing of one, and both outlines are within the
/// flatness of their curves, so the curves are then within [`OUTLINE_TOLERANCE`] of each other.
const OUTLINE_POINT_LIMIT: f64 = OUTLINE_TOLERANCE - 2.0 * OUTLINE_FLATNESS - OUTLINE_SPACING / 2.0;
/// Most point-to-segment distances worked out for one object, over all its look's outlines.
const MAX_OUTLINE_PAIRS: usize = 4_000_000;
/// Does path or compound path `object` with `appearance`'s effects draw every outline of its drawn look
/// `look`, as `look` draws its own (each within [`OUTLINE_TOLERANCE`] of the other)? `false` for
/// anything else: a look holding other than paths, outlines too detailed to compare.
fn draws_look_outline(object: &Node, appearance: &Appearance, look: &Node) -> bool {
fn leaves(n: &Node, out: &mut Vec<vectorcraft_geom::PathData>, depth: usize) -> bool {
match &n.kind {
NodeKind::Path { path, .. } => {
out.push(path.clone());
true
}
NodeKind::Compound { children, .. } => {
out.push(vectorcraft_geom::PathData::new(
children.iter().filter_map(|c| c.path_data()).flat_map(|p| p.subpaths.iter().cloned()).collect(),
));
true
}
NodeKind::Group { clip: false, .. } if depth < MAX_DEPTH => n.children().into_iter().flatten().all(|c| leaves(c, out, depth + 1)),
_ => false,
}
}
/// The segments of `paths` flattened, at most `max` of them.
fn segments(paths: &[vectorcraft_geom::PathData], max: usize) -> Option<Vec<kurbo::Line>> {
let mut out = vec![];
let (mut start, mut last) = (None, None);
let mut over = false;
for p in paths {
vectorcraft_geom::flatten(p.to_bezpath(), OUTLINE_FLATNESS, |el| {
let mut add = |a: kurbo::Point, b: kurbo::Point| {
if out.len() < max {
out.push(kurbo::Line::new(a, b));
} else {
over = true;
}
};
match el {
kurbo::PathEl::MoveTo(q) => (start, last) = (Some(q), Some(q)),
kurbo::PathEl::LineTo(q) => {
if let Some(l) = last {
add(l, q);
}
last = Some(q);
}
kurbo::PathEl::ClosePath => {
if let (Some(l), Some(s)) = (last, start) {
add(l, s);
}
last = start;
}
_ => {}
}
});
}
(!over && !out.is_empty()).then_some(out)
}
/// Does every point of segments `a` lie close enough to segments `b` ([`OUTLINE_POINT_LIMIT`])?
/// Each segment is checked at both ends (the last point of an open outline starts no segment)
/// and at points at most [`OUTLINE_SPACING`] apart between them (two outlines can share their
/// vertices and join them differently). Each point's distance to each segment of `b` (a
/// projection onto it) is taken from `budget`: `false` once that runs out.
fn near(a: &[kurbo::Line], b: &[kurbo::Line], budget: &mut usize) -> bool {
use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveNearest};
let close = |p: kurbo::Point| b.iter().any(|t| t.nearest(p, 1e-6).distance_sq <= OUTLINE_POINT_LIMIT * OUTLINE_POINT_LIMIT);
for s in a {
let steps = (s.arclen(1e-6) / OUTLINE_SPACING).ceil();
let steps = if steps.is_finite() && steps >= 1.0 { steps as usize } else { 1 };
let Some(left) = budget.checked_sub(steps.saturating_add(1).saturating_mul(b.len())) else { return false };
*budget = left;
if !(0..=steps).all(|k| close(s.eval(k as f64 / steps as f64))) {
return false;
}
}
true
}
/// The box round segments `lines` (`None` without any).
fn bounds(lines: &[kurbo::Line]) -> Option<kurbo::Rect> {
let first = lines.first()?.p0;
Some(lines.iter().fold(kurbo::Rect::from_points(first, first), |r, l| r.union_pt(l.p0).union_pt(l.p1)))
}
let (mut ours, mut theirs) = (vec![], vec![]);
if !matches!(object.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) || !leaves(object, &mut ours, 0) || !leaves(look, &mut theirs, 0) {
return false;
}
// The object's outline reshaped as it is drawn: its effects from its own bounds.
for path in &mut ours {
let bounds = kurbo::Shape::bounding_box(&path.to_bezpath());
*path = vectorcraft_effects::apply_geometry(&appearance.effects, path, bounds);
}
let max = MAX_OUTLINE_PAIRS.isqrt();
let Some(ours) = segments(&ours, max) else { return false };
let Some(ours_box) = bounds(&ours) else { return false };
// Two outlines each within the tolerance of the other have boxes as close: the boxes are
// compared first, then the points, from one budget for the object.
let boxed = |t: &[kurbo::Line]| {
let Some(r) = bounds(t) else { return false };
[r.x0 - ours_box.x0, r.y0 - ours_box.y0, r.x1 - ours_box.x1, r.y1 - ours_box.y1].iter().all(|d| d.abs() <= OUTLINE_TOLERANCE)
};
let mut budget = MAX_OUTLINE_PAIRS;
// Each of the look's outlines (a fill and a stroke draw the same one) is the object's.
theirs
.iter()
.all(|t| segments(std::slice::from_ref(t), max).is_some_and(|t| boxed(&t) && near(&t, &ours, &mut budget) && near(&ours, &t, &mut budget)))
}
/// A graphic style's appearance from art style `st`, on no object: `None` when the style isn't one
@@ -1673,6 +1842,50 @@ mod tests {
Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(fill, Paint::None, 0.0)))
}
/// The outline check works from one budget for the object: a look of the outline drawn twice
/// (a fill and a stroke) matches, one drawn thousands of times gives up and keeps the drawn
/// look instead of comparing every copy.
#[test]
fn the_outline_check_has_one_budget_for_the_object() {
let zig = vectorcraft_doc::Effect {
id: "distort.zigZag".into(),
params: serde_json::json!({"size": 3.0, "relative": false, "ridges": 4, "points": "corner"}),
visible: true,
};
let path = shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 60.0));
let appearance = Appearance { effects: vec![zig.clone()], ..Appearance::basic(Paint::None, Paint::None, 0.0) };
let object = Node::path(NodeId(1), path.clone(), appearance.clone());
let outline = vectorcraft_effects::apply_geometry(std::slice::from_ref(&zig), &path, Rect::new(0.0, 0.0, 100.0, 60.0));
let look = |copies: u64| {
let drawn = (0..copies).map(|i| Arc::new(Node::path(NodeId(10 + i), outline.clone(), Appearance::default()))).collect();
Node::group(NodeId(2), drawn)
};
assert!(draws_look_outline(&object, &appearance, &look(2)));
let started = std::time::Instant::now();
assert!(!draws_look_outline(&object, &appearance, &look(5_000)));
assert!(started.elapsed() < std::time::Duration::from_secs(5), "{:?}", started.elapsed());
}
/// The outline check holds for every point of the outlines, not only the points it checks: a
/// 0.25 pt line whose look has only short pieces over its ends, 0.24 pt away, leaves the
/// line's middle about 0.27 pt from the look, so the drawn look stays. The line drawn 0.1 pt
/// away matches.
#[test]
fn the_outline_check_holds_between_the_points_it_checks() {
use kurbo::Point;
use vectorcraft_geom::{PathData, SubPath};
let appearance = Appearance::basic(Paint::None, Paint::None, 0.0);
let line = PathData::new(vec![SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(0.25, 0.0)], false)]);
let object = Node::path(NodeId(1), line, appearance.clone());
let look = |pieces: &[[Point; 2]]| {
let drawn = PathData::new(pieces.iter().map(|p| SubPath::polyline(p, false)).collect());
Node::group(NodeId(2), vec![Arc::new(Node::path(NodeId(3), drawn, Appearance::default()))])
};
let ends = [[Point::new(0.0, 0.24), Point::new(0.01, 0.24)], [Point::new(0.24, 0.24), Point::new(0.25, 0.24)]];
assert!(!draws_look_outline(&object, &appearance, &look(&ends)));
assert!(draws_look_outline(&object, &appearance, &look(&[[Point::new(0.0, 0.1), Point::new(0.25, 0.1)]])));
}
/// An image draws no stroke, so an image with a brush in its art style keeps its drawn look.
#[test]
fn an_image_with_a_brush_keeps_its_drawn_look() {
+23 -15
View File
@@ -188,10 +188,11 @@ pub(super) struct ArtStyle {
/// It would be [`Self::simple`] but for a Stroke Style filter's variable width written as one
/// centered array ([`centered_widths`]): an object whose drawn look is empty takes it with its profile.
pub uneven: bool,
/// It is several fills and strokes in solid colours or gradients (strokes without a brush),
/// each with its own visibility, opacity and blend mode but no effects of its own, under only
/// the effects any object takes that don't move the outline: what a path or compound path is
/// read with when each gradient is placed as its drawn look has it (`read::ops`' `styled`).
/// It is several fills and strokes in solid colours, gradients or patterns (strokes without a
/// brush), each with its own visibility, opacity and blend mode but no effects of its own, under
/// only the effects any object takes that don't move the outline, and under none when a pattern
/// paints: what a path or compound path is read with when each gradient and pattern is placed as
/// its drawn look has it (`read::ops`' `styled`).
pub stacked: bool,
/// It is one Warp on the whole object, under fills and strokes that paint nothing and have no
/// effects of their own: what an image is read with when its live warp draws as its drawn look
@@ -1469,11 +1470,10 @@ fn stroke_item(f: &Filter, align: StrokeAlign) -> Result<Option<StyleItem>, ()>
if !f.paints.0 {
return Ok(None);
}
// Dashes aligned to corners and path ends draw as the look's pieces: a solid end at each end
// and the pattern, fitted, between them.
if f.params.get("BSDashAdj").is_some_and(|v| *v != 0.0) {
return Err(());
}
// Dashes aligned to corners and path ends (the switch in the stroke's dictionary): the look
// draws them fitted between solid ends, which the reader checks the stroke against before it
// takes it.
let aligned = f.params.get("BSDashAdj").is_some_and(|v| *v != 0.0);
match &f.stroke {
Some(p) if !f.gradient && f.pattern.is_none() => Ok(Some(StyleItem::Stroke {
paint: p.clone(),
@@ -1481,7 +1481,7 @@ fn stroke_item(f: &Filter, align: StrokeAlign) -> Result<Option<StyleItem>, ()>
cap: f.cap,
join: f.join,
miter: f.miter,
dash: f.dash.clone(),
dash: f.dash.clone().map(|d| Dash { align_corners: aligned, ..d }),
profile: width_profile(&f.arrays),
align,
brush: None,
@@ -1744,8 +1744,9 @@ impl Builder<'_> {
/// Is `e`, on the whole object, an effect any object is read with? Of the Distort & Transform
/// effects: Transform without copies (Random is never read), Twist, a Tweak that moves nothing,
/// Pucker & Bloat at 0, and Free Distort when its corners make a parallelogram (an affine map).
/// Zig Zag is left to type. Which objects Transform, Twist and Free Distort are read on is
/// Pucker & Bloat at 0, Free Distort when its corners make a parallelogram (an affine map), and Zig
/// Zag (on objects other than type only where it draws its drawn look's outline: `read::ops`'
/// `styled`). Which objects Transform, Twist and Free Distort are read on is
/// `read::ops`' `moves_with`.
fn any_object_takes(e: &Effect) -> bool {
match e.id.as_str() {
@@ -1762,7 +1763,8 @@ fn any_object_takes(e: &Effect) -> bool {
| "path.outlineObject"
| "path.outlineStroke"
| "distort.twist"
| "distort.tweak" => true,
| "distort.tweak"
| "distort.zigZag" => true,
// Copies are drawn as one path, its fills under all its strokes, where the file paints each
// copy's fill and stroke in turn.
"distort.transform" => e.params["copies"].as_i64() == Some(0),
@@ -1861,9 +1863,15 @@ fn style(filters: &[Filter]) -> ArtStyle {
&& st.plain
&& !st.pathfinder
&& !st.moves_outline()
&& st.items.iter().all(|i| matches!(i, StyleItem::Fill(_) | StyleItem::Gradient { .. } | StyleItem::Stroke { brush: None, .. }))
&& st.items.iter().all(|i| {
matches!(i, StyleItem::Fill(_) | StyleItem::Gradient { .. } | StyleItem::Pattern { .. } | StyleItem::Stroke { brush: None, .. })
})
&& st.looks.iter().all(|l| l.effects.is_empty())
&& st.effects.iter().all(any_object_takes);
&& st.effects.iter().all(any_object_takes)
// A pattern fill under the object's effects keeps the drawn look, a conservative rule: in
// one file a Scribble over a pattern fill drew unlike its look, its tiles placed as the
// look's are (why isn't established).
&& (st.effects.is_empty() || !st.items.iter().any(|i| matches!(i, StyleItem::Pattern { .. })));
st.image_warp = st.plain
&& matches!(st.effects.as_slice(), [e] if e.id.starts_with("warp."))
&& st.items.iter().all(|i| matches!(i, StyleItem::Fill(p) | StyleItem::Stroke { paint: p, .. } if p.is_none()))
+9 -4
View File
@@ -61,13 +61,17 @@ fn a_uniform_or_unreadable_width_profile_stays_a_live_stroke() {
}
#[test]
fn dashes_aligned_to_corners_keep_the_drawn_look() {
// GUARDS: the look holds the fitted pattern and the solid ends the style's dash array doesn't.
fn dashes_aligned_to_corners_read_as_aligned_dashes() {
// The look holds the fitted pattern, which the style's dash array doesn't: the reader takes the
// stroke only where VectorCraft's own fitting draws as that look.
let data = b"/KnownStyle :\n(Stitches) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n2 /FillOrStroke ,\n/Dictionary : /NotRecorded ,\n\
/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n\
/StrokeStyle : 0 R\n0 0 0 0 0 0 1 XA\n1 J 0 j 2 w 10 M [5 10 ]0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n;\n";
assert!(!art_styles(data)["Stitches"].plain);
let style = &art_styles(data)["Stitches"];
assert!(style.plain, "{style:?}");
let [StyleItem::Stroke { dash: Some(dash), .. }] = style.items.as_slice() else { panic!("{:?}", style.items) };
assert_eq!((dash.pattern.as_slice(), dash.align_corners), ([5.0, 10.0].as_slice(), true));
}
/// The style `Shade`: a Drop Shadow whose dictionary holds `keys`.
@@ -1023,7 +1027,8 @@ fn any_object_takes_the_distort_effects_that_draw_as_its_drawn_look() {
assert!(simple("Adobe Free Distort", &corners(src, [[0.2, 0.0], [1.2, 0.0], [0.0, -1.0], [1.0, -1.0]])));
assert!(!simple("Adobe Free Distort", &corners(src, [[0.2, 0.0], [1.2, 0.1], [0.0, -1.0], [1.0, -1.0]])));
assert!(!simple("Adobe Punk and Bloat", "-35 /Real (d_factor) ,\n"));
assert!(!simple("Adobe Zigzag", ""));
// Zig Zag: objects other than type check it against their drawn look (`read::ops`).
assert!(simple("Adobe Zigzag", ""));
assert!(!simple("Adobe Transform", &format!("1 /Int (numCopies) ,\n{SWITCHES}")));
// With another effect, only type takes it.
let chain = [basic("Adobe Twirl", "45 /Real (angle) ,\n"), basic("Adobe Offset Path", "4 /Real (ofst) ,\n0 /Int (jntp) ,\n4 /Real (mlim) ,\n")];
+444 -10
View File
@@ -1260,6 +1260,191 @@ fn a_style_pattern_fill_is_placed_as_a_direct_one() {
}
}
/// An art style `Stacked` whose stack holds `filters` (basic filters, top first).
fn stacked_style(filters: &[String]) -> String {
format!(
"%AI9_BeginArtStyles\n/KnownStyle :\n(Stacked) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
/CompoundFilter :\n(Stack Style Filter) 0 0 /Filter ,\n1 /Visible ,\n{}\
/BasicFilter :\n(Conduit Filter) 0 0 /Filter ,\n1 /Visible ,\n;\n /Part ,\n;\n /Part ,\n;\n%AI9_EndArtStyles\n",
filters.concat()
)
}
/// A fill filter painting with `paint` (operators).
fn fill_filter(paint: &str) -> String {
format!(
"/BasicFilter :\n(Fill Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n/FillStyle : 0 O\n{paint}\n0 1 Xd\n/Def ;\n (FillStyle) ,\n; /Dict ;\n /Part ,\n"
)
}
/// A black stroke filter `width` wide.
fn stroke_filter(width: f64) -> String {
format!(
"/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n\
/StrokeStyle : 0 R\n0 0 0 1 0 0 0 XA\n0 J 0 j {width} w 10 M []0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n"
)
}
/// The layers of a file whose object (`own`, on `%_` lines) has the style `Stacked` and the drawn
/// look `look`.
fn stacked_object(look: &str, own: &str) -> String {
let own: String = own.lines().map(|l| format!("%_{l}\n")).collect();
layer(&format!("0 Ae\nu\n{look}U\n{own}1 (Stacked) XW\n"))
}
/// The pattern placement of `n`'s fill painting with a pattern.
fn pattern_xf(n: &Node) -> [f64; 6] {
n.appearance
.items
.iter()
.find_map(|i| match i.paint() {
Paint::Pattern { xf, .. } => Some(xf.as_coeffs()),
_ => None,
})
.unwrap_or_else(|| panic!("no pattern fill: {:?}", n.appearance.items))
}
/// A path or compound path whose art style fills it with a pattern (as a stack of fills and strokes
/// can) comes in as itself with that fill, the pattern placed where the drawn look places it (not
/// where the style's own operands would), among the style's other fills and strokes in their order.
#[test]
fn a_path_with_a_style_pattern_fill_comes_in_as_the_path_with_it() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let hole = rect_path(30.0, 40.0, 50.0, 60.0);
// The style's operands and the look's differ: the look's placement is taken.
let (style_ops, look_ops) = ("0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]", "25 30 1.5 .75 30 1 45 10 0 [.8 .1 -.2 1.1 4 -6]");
let pattern = fill_filter(&format!("(Dots) {style_ops} p"));
let look_xf = |shape: &str| {
let direct = read_ok(&format!("{DOTS}{}", layer(&format!("(Dots) {look_ops} p\n{shape}f\n"))));
pattern_xf(&art(&direct.doc)[0])
};
let close = |a: [f64; 6], b: [f64; 6]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9);
// The style's operands alone would place it elsewhere.
let style_xf = pattern_xf(&art(&read_ok(&format!("{DOTS}{}", layer(&format!("(Dots) {style_ops} p\n{rect}f\n")))).doc)[0]);
assert!(!close(style_xf, look_xf(&rect)), "{style_xf:?}");
// A path filled with the pattern alone.
let look = format!("(Dots) {look_ops} p\n{rect}f\n");
let r = read_ok(&format!("{}{DOTS}{}", stacked_style(std::slice::from_ref(&pattern)), stacked_object(&look, &format!("{rect}n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Path { .. })), "the path: {a:#?} {:?}", r.warnings);
assert!(close(pattern_xf(&a[0]), look_xf(&rect)), "{:?} {:?}", pattern_xf(&a[0]), look_xf(&rect));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
// A compound path, the pattern over a solid fill and under a 3 unit stroke.
let style = stacked_style(&[stroke_filter(3.0), pattern.clone(), fill_filter("0 1 1 0 1 0 0 Xa")]);
let look = format!("{RED}*u\n{rect}f\n{hole}f\n*U\n(Dots) {look_ops} p\n*u\n{rect}f\n{hole}f\n*U\n");
let own = format!("*u\n{rect}n\n{hole}n\n*U");
let r = read_ok(&format!("{style}{DOTS}{}", stacked_object(&look, &own)));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Compound { .. })), "the compound path: {a:#?} {:?}", r.warnings);
let items: Vec<String> = a[0]
.appearance
.items
.iter()
.map(|i| match (i, i.paint()) {
(AppearanceItem::Fill(_), Paint::Pattern { .. }) => "pattern fill".into(),
(AppearanceItem::Fill(_), p) => format!("fill {:?}", p.color()),
(AppearanceItem::Stroke(s), _) => format!("stroke {}", s.width),
})
.collect();
assert_eq!(items, [format!("fill {:?}", Some(Color::rgb(1.0, 0.0, 0.0))), "pattern fill".into(), "stroke 3".into()]);
assert!(close(pattern_xf(&a[0]), look_xf(&format!("*u\n{rect}f\n{hole}f\n*U\n"))));
}
/// A stack's pattern fill keeps the drawn look where the look doesn't fill with that pattern: its
/// placement isn't known. A look that only strokes with it doesn't place the fill either.
#[test]
fn a_style_pattern_fill_the_look_doesnt_paint_keeps_the_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let pattern = fill_filter(&format!("(Dots) {ops} p"));
for (why, look) in
[("a look without the pattern", format!("{RED}{rect}f\n")), ("a look that strokes with it", format!("(Dots) {ops} P\n{rect}S\n"))]
{
let r = read_ok(&format!("{}{DOTS}{}", stacked_style(std::slice::from_ref(&pattern)), stacked_object(&look, &format!("{rect}n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "{why}: the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{why}: {:?}", r.warnings);
}
}
/// A stack that fills with one pattern twice keeps the drawn look: which of the look's placements is
/// whose isn't known.
#[test]
fn a_stack_with_one_pattern_twice_keeps_the_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let pattern = fill_filter(&format!("(Dots) {ops} p"));
let look = format!("(Dots) {ops} p\n{rect}f\n(Dots) {ops} p\n{rect}f\n");
let r = read_ok(&format!("{}{DOTS}{}", stacked_style(&[pattern.clone(), pattern]), stacked_object(&look, &format!("{rect}n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
}
/// A stack that fills with a pattern once, whose drawn look fills with it twice at different
/// placements, keeps the drawn look: which placement is the style's isn't known. A look filling with
/// it twice at the same placement still comes in as the path with that fill.
#[test]
fn a_look_placing_a_stacks_pattern_twice_keeps_the_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let other = "25 30 1.5 .75 30 1 45 10 0 [.8 .1 -.2 1.1 4 -6]";
let pattern = fill_filter(&format!("(Dots) {ops} p"));
let read = |second: &str| {
let look = format!("(Dots) {ops} p\n{rect}f\n(Dots) {second} p\n{rect}f\n");
read_ok(&format!("{}{DOTS}{}", stacked_style(std::slice::from_ref(&pattern)), stacked_object(&look, &format!("{rect}n"))))
};
let r = read(other);
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let r = read(ops);
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Path { .. })), "the path: {a:#?} {:?}", r.warnings);
}
/// A style's pattern fill under an effect on the object keeps the drawn look, a conservative rule
/// (in one file a Scribble over a pattern fill drew unlike its look; why isn't established).
#[test]
fn a_path_with_a_style_pattern_fill_under_an_effect_keeps_its_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let hidden = rect.replace('\n', "\n%_");
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let shadow = "/BasicFilter :\n(Adobe Drop Shadow) 1 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n2 /Int (blnd) ,\n0.43 /Real (opac) ,\n\
37 /Real (dark) ,\n-13 /Real (vert) ,\n11 /Real (horz) ,\n17 /Real (blur) ,\n\
/FillStyle : 0 O\n0 0 0 0 0 1 0 Xa\n0 1 0 0 0 Xy\n0 J 0 j 1 w 10 M []0 d\n0 XR\n0 1 Xd\n/Def ;\n (sclr) ,\n0 /Int (csrc) ,\n; /Dict ;\n /Part ,\n";
let style = tiled_style("Dots", ops);
// After the stack, in the object's chain.
let end = ";\n /Part ,\n;\n%AI9_EndArtStyles";
assert!(style.contains(end));
let style = style.replace(end, &format!(";\n /Part ,\n{shadow};\n%AI9_EndArtStyles"));
// The style reads, with its pattern fill and the shadow: what keeps the look is the rule.
let st = crate::import::ai::style::art_styles(style.as_bytes());
let tiled = &st["Tiled"];
assert!(tiled.plain && tiled.effects.len() == 1, "{tiled:?}");
let look = format!("0 Ae\nu\n(Dots) {ops} p\n{rect}f\nU\n");
let r = read_ok(&format!("{style}{DOTS}{}", layer(&format!("{look}%_{hidden}n\n1 (Tiled) XW\n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
}
/// Type whose style fills it with a pattern takes the placement from its drawn look wherever the look
/// paints with that pattern, a stroke of it too (as before paths took such styles): the look's
/// fills-only rule is the path stack's.
#[test]
fn type_with_a_style_pattern_fill_takes_a_stroke_only_looks_placement() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let (style_ops, look_ops) = ("0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]", "25 30 1.5 .75 30 1 45 10 0 [.8 .1 -.2 1.1 4 -6]");
let look = format!("0 Ae\nu\n/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\n(Dots) {look_ops} P\n{rect}S\nU\n");
let own = "%_/AI11Text :\n%_0 /FreeUndo ,\n%_0 /FrameIndex ,\n%_0 /StoryIndex ,\n%_;\n";
let styled = read_ok(&format!("{}{DOTS}{}", tiled_style("Dots", style_ops), layer(&format!("{look}{own}1 (Tiled) XW\n"))));
let stroked = read_ok(&format!("{DOTS}{}", layer(&format!("(Dots) {look_ops} P\n{rect}S\n"))));
let Paint::Pattern { xf: got, .. } = fill(&art(&styled.doc)[0]) else { panic!("{:?} {:?}", art(&styled.doc), styled.warnings) };
let want = pattern_xf(&art(&stroked.doc)[0]);
assert!(got.as_coeffs().iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-9), "{got:?} {want:?}");
}
/// An art style's pattern fill paints with the pattern under the name it is shown with.
#[test]
fn a_style_pattern_fill_paints_with_the_shown_name() {
@@ -1549,6 +1734,42 @@ fn a_clipping_path_alone_in_a_group_clips_its_clipping_group() {
assert_eq!(fill(&children[1]).color(), Some(Color::rgb(1.0, 0.0, 0.0)));
}
/// Clipping paths grouped in a compound path (`*u u <path> W n … U *U`, possibly nested in other groups) are
/// the compound path's subpaths, as its other grouped paths are: the compound clipping path, their union, clips its
/// clipping group, however many there are and wherever in the group it is written.
#[test]
fn clipping_paths_grouped_in_a_compound_path_are_its_subpaths() {
let square = rect_path(0.0, 0.0, 80.0, 80.0);
let (a, b, c) = (rect_path(0.0, 0.0, 10.0, 10.0), rect_path(30.0, 0.0, 40.0, 10.0), rect_path(60.0, 0.0, 70.0, 10.0));
let clip = |p: &str| format!("{p}h\nW\nn\n");
let bodies = [
// One group of them, after the art.
format!("0 Ae\nq\n{RED}{square}f\n*u\n0 Ae\nu\n{}{}{}U\n*U\nQ\n", clip(&a), clip(&b), clip(&c)),
// Groups in a group, and one path straight in the compound path, before the art.
format!("0 Ae\nq\n*u\n0 Ae\nu\n0 Ae\nu\n{}{}U\n0 Ae\nu\n{}U\nU\n*U\n{RED}{square}f\nQ\n", clip(&a), clip(&b), clip(&c)),
format!("0 Ae\nq\n*u\n0 Ae\nu\n{}{}U\n{}*U\n{RED}{square}f\nQ\n", clip(&a), clip(&b), clip(&c)),
];
for body in &bodies {
let doc = read_ok(&layer(body)).doc;
let NodeKind::Group { children, clip: true } = &art(&doc)[0].kind else { panic!("{body}: {:?}", art(&doc)[0].kind) };
assert_eq!(children.len(), 2, "{body}: {children:?}");
let NodeKind::Compound { children: subpaths, .. } = &children[0].kind else { panic!("{body}: {:?}", children[0].kind) };
assert_eq!(subpaths.len(), 3, "{body}: {subpaths:?}");
assert!(subpaths.iter().all(|p| matches!(p.kind, NodeKind::Path { clipping: true, .. })), "{body}: {subpaths:?}");
assert_eq!(fill(&children[1]).color(), Some(Color::rgb(1.0, 0.0, 0.0)), "{body}");
}
// Hundreds of them, one union: not clipping groups nested past the document's depth limit.
let many = format!("0 Ae\nq\n{RED}{square}f\n*u\n0 Ae\nu\n{}U\n*U\nQ\n", clip(&a).repeat(300));
let doc = read_ok(&layer(&many)).doc;
let NodeKind::Group { children, clip: true } = &art(&doc)[0].kind else { panic!("{:?}", art(&doc)[0].kind) };
let NodeKind::Compound { children: subpaths, .. } = &children[0].kind else { panic!("{:?}", children[0].kind) };
assert_eq!(subpaths.len(), 300);
// A group of clipping paths outside a compound path or a clipping group is read as before: a clipping group.
let alone = format!("0 Ae\nu\n{}{}U\n{RED}{square}f\n", clip(&a), clip(&b));
let doc = read_ok(&layer(&alone)).doc;
assert!(matches!(art(&doc)[0].kind, NodeKind::Group { clip: true, .. }), "{:?}", art(&doc)[0].kind);
}
/// #1410: a compound path shows its last path's paint, and paths grouped in it stay its paths.
#[test]
fn compound_path_takes_its_last_paths_paint() {
@@ -2507,6 +2728,37 @@ fn ai_variable_library_edge_cases() {
assert_eq!(notes, ["the file's variable library couldn't be read: the Variables panel doesn't list it"]);
}
/// The empty library a file can keep, its nodes named and nothing else (no value, no type, empty
/// attributes), has nothing to list: it comes in without a note. A node that has a value or a type
/// isn't empty, so the same skeleton with a value, or with a type, still gets the note.
#[test]
fn an_empty_variable_library_gives_no_note() {
// A node with a name and nothing else: its children, then its attributes, as `%_` lines.
fn bare(name: &str, attributes: &[&str], children: &[String]) -> String {
let close = |n: &str, key: &str| format!("{}%_; {key},\n", n.strip_suffix("%_;\n").unwrap_or(n));
let attributes: String = attributes.iter().map(|a| close(&bare(a, &[], &[]), &format!("({a}) "))).collect();
let children: String = children.iter().map(|c| close(c, "")).collect();
format!(
"%_/XMLNode :\n%_/Dictionary :\n{attributes}%_; (xmlnode-attributes) ,\n%_/Array :\n{children}%_; (xmlnode-children) ,\n%_({name}) /String (xmlnode-nodename) ,\n%_;\n"
)
}
let data_sets = bare("v:sampleDataSets", &["xmlns:v", "xmlns"], &[]);
let skeleton = bare("variableSets", &[], &[bare("variableSet", &["varSetName"], std::slice::from_ref(&data_sets))]);
let (vars, notes) = read_library(&skeleton);
assert_eq!(vars, vectorcraft_doc::Variables::default());
assert!(notes.is_empty(), "{notes:?}");
let unread = ["the file's variable library couldn't be read: the Variables panel doesn't list it"];
// The same skeleton but for one entry of the data sets node: a value, then a type.
let with = |entry: &str| {
let data_sets = data_sets.replace("(xmlnode-nodename) ,\n", &format!("(xmlnode-nodename) ,\n{entry}"));
bare("variableSets", &[], &[bare("variableSet", &["varSetName"], &[data_sets])])
};
for entry in ["%_(x) /String (xmlnode-nodevalue) ,\n", "%_1 /Int (xmlnode-nodetype) ,\n"] {
let (_, notes) = read_library(&with(entry));
assert_eq!(notes, unread, "{entry}");
}
}
/// When the layers can't be read, or reading stops before the library, [`variables`] still reads
/// it, for the file read from its PDF part.
#[test]
@@ -3741,6 +3993,70 @@ fn placed_files_are_linked_images_showing_their_preview() {
assert!(read(stream(&layer("~\n")).as_bytes()).unwrap_err().contains("`~`"));
}
/// Type made a clipping mask: a clipping group (`q` … `Q`) with no clipping path, whose last object
/// is a text object, is clipped by that type once its slot holds it, the type first as its
/// clipping path. Anything else stays as it was read.
#[test]
fn type_that_ends_a_clipping_group_without_a_clipping_path_clips_it() {
let text = |story: u32| format!("/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n{story} /StoryIndex ,\n;\n");
let square = format!("{RED}{}f\n", rect_path(0.0, 0.0, 10.0, 10.0));
let clipper = format!("{RED}{}h W n\n", rect_path(2.0, 2.0, 8.0, 8.0));
let r = read_ok(&layer(&format!("q\n{square}{}Q\n", text(4))));
let a = art(&r.doc);
let [group] = a.as_slice() else { panic!("{a:#?}") };
let slot = group.children().and_then(|c| c.last()).map(|n| n.id).unwrap();
assert!(matches!(group.kind, NodeKind::Group { clip: false, .. }), "read as it is, until the slot holds its type");
assert_eq!(r.type_clips.get(&group.id), Some(&slot));
assert_eq!(r.warped_type.type_clips, r.type_clips, "envelopes' contents are clipped by their type too");
// Filled with one text object, the slot's type clips the group.
let typed = |doc: &Document, one: bool| {
let mut layer = (*doc.layers[0]).clone();
let mut n = 0;
let put = |n: &mut Node| {
if let NodeKind::Group { children, .. } = &mut n.kind
&& let Some(last) = children.last_mut()
&& last.id == slot
{
let t = Node::new(
vectorcraft_doc::NodeId(9_000),
NodeKind::Text(Box::new(vectorcraft_doc::TextObject::point(kurbo::Point::ZERO, "M", Default::default()))),
);
if one {
*last = Arc::new(t);
} else {
let mut stroke = t.clone();
stroke.id = vectorcraft_doc::NodeId(9_001);
*last = Arc::new(t);
children.push(Arc::new(stroke));
}
}
};
layer.children_mut().unwrap().iter_mut().for_each(|c| put(Arc::make_mut(c)));
let clipped = clip_by_type(&mut layer, &r.type_clips, &|s| (s == slot).then_some(vectorcraft_doc::NodeId(9_000)), &mut |_| n += 1);
(layer, clipped, n)
};
let (layer_one, clipped, called) = typed(&r.doc, true);
assert_eq!((clipped, called), (1, 1));
let g = &layer_one.children().unwrap()[0];
let NodeKind::Group { children, clip: true } = &g.kind else { panic!("{g:#?}") };
assert!(matches!(children[0].kind, NodeKind::Text(_)) && matches!(children[1].kind, NodeKind::Path { .. }), "{children:#?}");
// Several objects in its place (the type and strokes round it): the group stays unclipped.
let (layer_two, clipped, _) = typed(&r.doc, false);
assert_eq!(clipped, 0);
assert!(matches!(layer_two.children().unwrap()[0].kind, NodeKind::Group { clip: false, .. }));
// A clipping path in the group clips it, not the type; type that isn't last doesn't; nor does a
// group (`u` … `U`) or the type a look draws.
for body in [
format!("q\n{square}{clipper}{}Q\n", text(4)),
format!("q\n{}{square}Q\n", text(4)),
format!("u\n{square}{}U\n", text(4)),
format!("q\n{square}/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\nQ\n"),
] {
let r = read_ok(&layer(&body));
assert!(r.type_clips.is_empty(), "{body}: {:?}", r.type_clips);
}
}
#[test]
fn text_objects_are_slots_named_after_their_story() {
let words = "/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n3 /StoryIndex ,\n;\n%_/ArtDictionary :\n%_/XMLUID : (Title) ; (AI10_ArtUID) ,\n%_;\n";
@@ -6272,21 +6588,13 @@ fn a_stroke_offset_filter_keeps_its_strokes_style() {
}
/// A Stroke Offset stroke this doesn't read as a stroke keeps the object's drawn look: a switch
/// written as another kind, dashes aligned to corners and path ends, a gradient.
/// written as another kind, a gradient.
#[test]
fn a_stroke_offset_filter_with_a_stroke_this_does_not_read_keeps_the_drawn_look() {
let outside = "0 /Bool (StrokeOffsetInside) ,\n";
let gradient = "0 R\nBb\n0 0 0 0 Bh\n2 (Red ramp) 0 0 90 1 1 0 0 1 0 0 1 Bg\n0 BB\n0 J 0 j 2 w 10 M []0 d\n0 XR\n1 0 Xd";
let cases = [
("a switch written as a number", offset_stroke_style_with("Edge", "1 /Int (StrokeOffsetInside) ,\n", OFFSET_STROKE)),
(
"dashes aligned to corners",
offset_stroke_style_with(
"Edge",
&format!("{outside}/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n"),
&OFFSET_STROKE.replace("[]0 d", "[5 10 ]0 d"),
),
),
("a gradient", offset_stroke_style_with("Edge", outside, gradient)),
];
for (why, style) in cases {
@@ -6295,6 +6603,26 @@ fn a_stroke_offset_filter_with_a_stroke_this_does_not_read_keeps_the_drawn_look(
}
}
/// A Stroke Offset stroke with dashes aligned to corners and path ends reads as such a stroke,
/// outside the path; the object takes it only where it draws as its drawn look. Here the look (a
/// filled square) draws otherwise, so the look check keeps the drawn look.
#[test]
fn a_stroke_offset_with_dashes_aligned_to_corners_unlike_its_look_keeps_the_look() {
use crate::import::ai::style::StyleItem;
use vectorcraft_doc::StrokeAlign;
let keys = "0 /Bool (StrokeOffsetInside) ,\n/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n";
let style = offset_stroke_style_with("Edge", keys, &OFFSET_STROKE.replace("[]0 d", "[5 10 ]0 d"));
let styles = crate::import::ai::style::art_styles(style.as_bytes());
let Some(StyleItem::Stroke { dash: Some(dash), align, .. }) = styles["Edge"].items.iter().find(|i| matches!(i, StyleItem::Stroke { .. })) else {
panic!("{:?}", styles["Edge"])
};
assert_eq!((dash.pattern.as_slice(), dash.align_corners, *align), ([5.0, 10.0].as_slice(), true, StrokeAlign::Outside));
let r = read_ok(&format!("%AI9_BeginArtStyles\n{style}%AI9_EndArtStyles\n{}", layer(&styled_square("Edge"))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
}
/// A listed `[Default]` style whose stroke is aligned outside comes in as the default graphic
/// style with that stroke.
#[test]
@@ -7338,6 +7666,96 @@ fn an_object_with_a_distort_effect_drawn_another_way_keeps_its_drawn_look() {
}
}
#[test]
fn a_path_with_zig_zag_comes_in_as_itself_where_its_look_has_that_outline() {
// GUARDS: Zig Zag on a path came in as its drawn look even where the live effect draws the same outline.
let keys = "3 /Real (amount) ,\n1 /Real (absoluteness) ,\n2 /Real (ridges) ,\n0 /Real (roundness) ,\n";
let zig = vectorcraft_doc::Effect {
id: "distort.zigZag".into(),
params: serde_json::json!({"size": 3.0, "relative": false, "ridges": 2, "points": "corner"}),
visible: true,
};
// The square as the document has it (y up in the file, down in the document).
let plain = read_ok(&layer(&format!("{RED}{}f\n", rect_path(20.0, 20.0, 60.0, 50.0))));
let square = art(&plain.doc)[0].path_data().unwrap().clone();
let to_file = |p: Point| {
let start = square.subpaths[0].anchors[0].p;
Point::new(p.x - start.x + 20.0, start.y - p.y + 20.0)
};
let outline = vectorcraft_effects::apply_geometry(std::slice::from_ref(&zig), &square, square.bounds().unwrap());
// The look: the outline the effect draws, as straight segments.
let ops = |shift: f64| -> String {
let mut out = String::new();
for sp in &outline.subpaths {
for (i, a) in sp.anchors.iter().enumerate() {
let p = to_file(a.p);
out.push_str(&format!("{:.4} {:.4} {}\n", p.x + shift, p.y, if i == 0 { "m" } else { "L" }));
}
}
out
};
let hidden_rect = rect_path(20.0, 20.0, 60.0, 50.0).replace('\n', "\n%_");
let object = |look: &str| format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{look}f\nU\n%_{hidden_rect}f\n1 (Bent) XW\n");
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(0.0)))));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let a = art(&r.doc);
assert_eq!(a.len(), 1, "{a:#?}");
assert!(matches!(a[0].kind, NodeKind::Path { .. }), "the object, not its look: {a:#?}");
let e = &a[0].appearance.effects;
assert_eq!(e.len(), 1, "{e:?}");
assert_eq!(
(e[0].id.as_str(), &e[0].params),
("distort.zigZag", &serde_json::json!({"size": 3.0, "relative": false, "ridges": 2, "points": "corner"}))
);
// A look whose ridges lie elsewhere (here 1 pt to the right) keeps the drawn look.
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(1.0)))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
assert!(matches!(art(&r.doc)[0].kind, NodeKind::Group { .. }));
// An open path (filled without closing it, `F`): its look's outline matches, and a look whose
// last point lies 3 pt away from where the effect ends it keeps the drawn look.
let open_path = "20 20 m\n60 20 L\n60 50 L\n";
let plain = read_ok(&layer(&format!("{RED}{open_path}F\n")));
let open = art(&plain.doc)[0].path_data().unwrap().clone();
assert!(!open.subpaths[0].closed);
let start = open.subpaths[0].anchors[0].p;
let outline = vectorcraft_effects::apply_geometry(std::slice::from_ref(&zig), &open, open.bounds().unwrap());
let ops = |last_shift: f64| -> String {
let mut out = String::new();
for sp in &outline.subpaths {
for (i, a) in sp.anchors.iter().enumerate() {
let shift = if i + 1 == sp.anchors.len() { last_shift } else { 0.0 };
let p = Point::new(a.p.x - start.x + 20.0 + shift, start.y - a.p.y + 20.0);
out.push_str(&format!("{:.4} {:.4} {}\n", p.x, p.y, if i == 0 { "m" } else { "L" }));
}
}
out
};
let hidden_open = open_path.replace('\n', "\n%_");
let object = |look: &str| format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{look}F\nU\n%_{hidden_open}F\n1 (Bent) XW\n");
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(0.0)))));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(3.0)))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
// A Zig Zag of no size on an open path through the corners of its look's square, joined
// across it: the vertices match, the segments between them don't, so the drawn look stays.
let flat = "0 /Real (amount) ,\n1 /Real (absoluteness) ,\n0 /Real (ridges) ,\n0 /Real (roundness) ,\n";
let bowtie = "%_20 20 m\n%_60 50 L\n%_60 20 L\n%_20 50 L\n%_F\n";
let crossed = format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{}f\nU\n{bowtie}1 (Bent) XW\n", rect_path(20.0, 20.0, 60.0, 50.0));
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", flat, BLUE_FILL), layer(&crossed)));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
// A look worked out by hand rather than by the effect: Zig Zag of 3 pt with one ridge per
// segment and corner points, on a line from (20, 20) to (60, 20), puts the line's ends 3 pt up
// the page and its middle 3 pt down. The same look mirrored keeps the drawn look.
let one = "3 /Real (amount) ,\n1 /Real (absoluteness) ,\n1 /Real (ridges) ,\n0 /Real (roundness) ,\n";
let line = "20 20 m\n60 20 L\n".replace('\n', "\n%_");
let object = |look: &str| format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{look}F\nU\n%_{line}F\n1 (Bent) XW\n");
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", one, BLUE_FILL), layer(&object("20 23 m\n40 17 L\n60 23 L\n"))));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
assert!(matches!(art(&r.doc)[0].kind, NodeKind::Path { .. }), "{:#?}", art(&r.doc));
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", one, BLUE_FILL), layer(&object("20 17 m\n40 23 L\n60 17 L\n"))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
}
/// The gradient `G`, white to black, defined for a document.
const GRADIENT_G: &str = "%AI5_BeginGradient: (G)\n(G) 0 2 Bd\n[\n%_1 0 50 0 Bs\n%_0 0 50 100 Bs\nBD\n%AI5_EndGradient\n";
@@ -8746,7 +9164,7 @@ fn warped_type_on_the_page_spends_what_is_left_of_the_budget() {
let copy = |w: &super::envelope::WarpedLook| super::envelope::WarpedLook { slot: w.slot, look: w.look.clone(), left_out: None };
let page = Some(Rect::new(0.0, 60.0, 60.0, 100.0));
let settle = |w: &super::envelope::WarpedLook, spent| {
let warped = super::envelope::WarpedType { looks: vec![copy(w)], envelopes: vec![], checks: 1, spent, page, alone: None };
let warped = super::envelope::WarpedType { looks: vec![copy(w)], checks: 1, spent, page, ..Default::default() };
warped.settle(&mut doc.clone(), Some, &Default::default(), &mut vec![])
};
let spent = || super::envelope::Spent { any: MAX_DIFFERENCE / 2.0, solid: MAX_SOLID_DIFFERENCE / 2.0 };
@@ -9519,6 +9937,22 @@ fn a_blend_comes_in_as_a_live_blend() {
assert!(!s.warnings.iter().any(|w| w == super::blend::DRAWN), "{:?}", s.warnings);
}
/// A blend in an opacity mask's art is written on `%_` lines, its record's hex digits on `%_%`
/// lines: it comes in live there too.
#[test]
fn a_blend_in_an_opacity_mask_comes_in_live() {
let body = blend_file("%_10 50 m\n%_110 50 L\n", [Some("A"), Some("B")], &blend_record(&['A', 'B']));
let mask_art: String = body.lines().map(|l| if l.starts_with("%_") { format!("{l}\n") } else { format!("%_{l}\n") }).collect();
assert!(mask_art.contains("\n%_%44434241"), "{mask_art}");
let mask = format!("%_/ArtDictionary :\n%_/Mask :\n%_X=\n%_u\n{mask_art}%_U\n%_X+\n%_(Art) ,\n%_; (AI9_Mask) ,\n%_;\n");
let s = read_ok(&layer(&format!("{RED}0 0 m\n0 80 L\n80 80 L\n80 0 L\nf\n{mask}")));
let m = art(&s.doc)[0].extras().mask.clone().expect("a mask");
let blend = m.art.children().and_then(|c| c.first()).cloned().unwrap_or(m.art.clone());
let NodeKind::Blend { children, spec } = &blend.kind else { panic!("a live blend: {:?} {:?}", blend.kind, s.warnings) };
assert_eq!((children.len(), spec.spacing), (2, vectorcraft_doc::live::BlendSpacing::Steps(3)));
assert!(!s.warnings.iter().any(|w| w == super::blend::DRAWN), "{:?}", s.warnings);
}
/// A blend whose spine was never edited has no spine written, only its keys: its spine is the
/// straight line between the keys' centers, in the record's order, and the blend comes in live.
/// With the record naming the keys in their order (here the left key, named `B`, first) the blend
+36 -22
View File
@@ -1,4 +1,4 @@
use super::paint::is_mesh;
use super::paint::{is_mesh, polygon, shading_extent};
use super::state::{GState, Space};
use super::{
Affine, Color, FillRule, Interp, Key, LineCap, LineJoin, MAX_DASH_ENTRIES, MAX_DASHES, MAX_GSAVE, MAX_PATH, Obj, Op, Paint, Point, PsError, Rc,
@@ -519,29 +519,43 @@ impl Interp<'_> {
}
self.stroke_path(bp)?;
}
ShFill => {
let d = self.pop_dict()?;
if self.g.null {
return Ok(());
}
if is_mesh(&d) {
let m = self.xf();
return self.mesh_fill(&d, m);
}
let m = self.xf();
if let Some(g) = self.gradient(&d, m)? {
let area = self.clip_bounds()?;
let paint = Paint::Gradient(Box::new(g));
let clips = self.g.clips.clone();
self.out.fill(area.to_path(0.1), FillRule::NonZero, paint, self.g.overprint, &clips);
if let Some((_, n)) = self.out.drawn.last() {
let id = n.id;
self.out.shadings.insert(id);
}
}
}
ShFill => self.shfill()?,
_ => self.data_op(op)?,
}
Ok(())
}
/// `shfill`: shading `sh` over the clip, as a gradient mesh or a gradient fill.
fn shfill(&mut self) -> Res {
let d = self.pop_dict()?;
if self.g.null {
return Ok(());
}
if is_mesh(&d) {
let m = self.xf();
return self.mesh_fill(&d, m);
}
let m = self.xf();
if let Some(g) = self.gradient(&d, m)? {
let area = self.clip_bounds()?;
// Not extended, it paints only between its ends.
let extent = shading_extent(&d, m, area);
let path = match &extent {
Some(pts) if pts.len() < 3 => return Ok(()),
Some(pts) => polygon(pts),
None => area.to_path(0.1),
};
let paint = Paint::Gradient(Box::new(g));
let clips = self.g.clips.clone();
self.out.fill(path, FillRule::NonZero, paint, self.g.overprint, &clips);
// Only a fill of the whole clip can stand in for the clip's shape.
if extent.is_none()
&& let Some((_, n)) = self.out.drawn.last()
{
let id = n.id;
self.out.shadings.insert(id);
}
}
Ok(())
}
}
+129
View File
@@ -450,6 +450,135 @@ fn is_gradient(sh: &DictRef) -> bool {
matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))
}
/// How far (points) the sides of the polygon a radial shading's circle is cut to may lie inside it.
const RING_TOLERANCE: f64 = 0.01;
/// Most sides of that polygon.
const MAX_RING: usize = 1024;
/// The part of `area` (in the document) that axial or radial shading `sh`, mapped into the
/// document by `m`, paints, as a convex polygon; `None` when it paints all of it. Without
/// `Extend` an axial shading paints only between the lines through its ends across its axis, and
/// a radial one only over its circles (PLRM 3rd ed. §4.9.3, shading types 2 and 3: `Extend`
/// defaults to `[false false]`). A radial shading extended at one end only, or starting from a
/// circle with a radius, is not bounded here (it paints all of `area`).
pub(super) fn shading_extent(sh: &DictRef, m: Affine, area: Rect) -> Option<Vec<Point>> {
let d = sh.borrow();
let nums = |k: &str| -> Vec<f64> {
d.get(&Key::name(k)).and_then(Obj::items).map(|i| i.borrow().iter().filter_map(Obj::as_num).collect()).unwrap_or_default()
};
let extend: Vec<bool> = d
.get(&Key::name("Extend"))
.and_then(Obj::items)
.map(|i| i.borrow().iter().map(|o| matches!(o, Obj::Bool(true))).collect())
.unwrap_or_default();
let (e0, e1) = (extend.first().copied().unwrap_or(false), extend.get(1).copied().unwrap_or(false));
if (e0 && e1) || area.width() <= 0.0 || area.height() <= 0.0 || m.determinant().abs() < 1e-12 || !m.as_coeffs().iter().all(|v| v.is_finite()) {
return None;
}
let inv = m.inverse();
// `area` in the shading's own space, where its axis and circles are.
let corners: Vec<Point> =
[(area.x0, area.y0), (area.x1, area.y0), (area.x1, area.y1), (area.x0, area.y1)].map(|(x, y)| inv * Point::new(x, y)).to_vec();
let mut poly = corners.clone();
let c = nums("Coords");
let at = |i: usize| c.get(i).copied().filter(|v| v.is_finite()).unwrap_or(0.0);
match d.get(&Key::name("ShadingType")).and_then(Obj::as_num) {
Some(2.0) => {
let (p0, p1) = (Point::new(at(0), at(1)), Point::new(at(2), at(3)));
let axis = p1 - p0;
if axis.hypot2() < 1e-18 {
return None;
}
if !e0 {
poly = clip_half(&poly, |p| (p - p0).dot(axis));
}
if !e1 {
poly = clip_half(&poly, |p| (p1 - p).dot(axis));
}
}
Some(3.0) if !e0 && !e1 && at(2) <= 0.0 && at(5) > 0.0 => {
// The circles from a point to a circle cover the hull of that point and circle.
let (p0, c1, r1) = (Point::new(at(0), at(1)), Point::new(at(3), at(4)), at(5));
// Enough sides that each lies within `RING_TOLERANCE` of the circle in the document
// (the radius scaled by the most `m` stretches any direction), from 64 to `MAX_RING`.
let [a, b, c, d, ..] = m.as_coeffs();
let (sum, det) = (a * a + b * b + c * c + d * d, a * d - b * c);
let stretch = ((sum + (sum * sum - 4.0 * det * det).max(0.0).sqrt()) / 2.0).sqrt();
let r = r1 * stretch;
let sides = (std::f64::consts::PI / (1.0 - RING_TOLERANCE / r).clamp(-1.0, 1.0).acos()).ceil();
let sides = if sides.is_finite() { (sides as usize).clamp(64, MAX_RING) } else { MAX_RING };
let ring: Vec<Point> = (0..sides).map(|i| c1 + Vec2::from_angle(i as f64 * std::f64::consts::TAU / sides as f64) * r1).collect();
for edge in hull(&[ring, vec![p0]].concat()).windows(2) {
if let [a, b] = edge {
let (a, b) = (*a, *b);
poly = clip_half(&poly, |p| (b - a).cross(p - a));
}
}
}
_ => return None,
}
// Nothing cut: it paints the whole area.
if poly.len() == 4 && poly.iter().zip(&corners).all(|(a, b)| (*a - *b).hypot2() < 1e-18) {
return None;
}
Some(poly.into_iter().map(|p| m * p).collect())
}
/// Convex polygon `poly` cut to where `f` (a linear function) is zero or more.
fn clip_half(poly: &[Point], f: impl Fn(Point) -> f64) -> Vec<Point> {
let mut out = Vec::with_capacity(poly.len() + 1);
for (i, &a) in poly.iter().enumerate() {
let Some(&b) = poly.get((i + 1) % poly.len()) else { continue };
let (fa, fb) = (f(a), f(b));
if fa >= 0.0 {
out.push(a);
}
if (fa >= 0.0) != (fb >= 0.0) {
out.push(a.lerp(b, fa / (fa - fb)));
}
}
out
}
/// The convex hull of `pts`, counter-clockwise, its first point repeated at the end.
fn hull(pts: &[Point]) -> Vec<Point> {
let mut p = pts.to_vec();
p.sort_by(|a, b| a.x.total_cmp(&b.x).then(a.y.total_cmp(&b.y)));
let mut h: Vec<Point> = Vec::with_capacity(p.len() * 2);
let turn = |h: &[Point], q: Point| match h {
[.., a, b] => (*b - *a).cross(q - *a) <= 0.0,
_ => false,
};
for &q in &p {
while turn(&h, q) {
h.pop();
}
h.push(q);
}
let lower = h.len() + 1;
for &q in p.iter().rev().skip(1) {
while h.len() >= lower && turn(&h, q) {
h.pop();
}
h.push(q);
}
h
}
/// A closed path through `pts`.
pub(super) fn polygon(pts: &[Point]) -> kurbo::BezPath {
let mut bp = kurbo::BezPath::new();
for (i, p) in pts.iter().enumerate() {
if i == 0 {
bp.move_to(*p);
} else {
bp.line_to(*p);
}
}
bp.close_path();
bp
}
/// Is shading `sh` one [`Interp::mesh_fill`] paints?
pub(super) fn is_mesh(sh: &DictRef) -> bool {
matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))
+26
View File
@@ -329,6 +329,7 @@ pub(super) fn build_weighing(
unread,
unread_elsewhere,
slot_names,
type_clips,
restyled,
placeholders,
placed_elsewhere,
@@ -527,6 +528,7 @@ pub(super) fn build_weighing(
let mut made = vec![];
let mut filled = std::collections::HashMap::new();
fill_slots(&mut doc, &mut layers, &mut content.into_iter(), &slot_names, &mut empty, &mut made, &mut vec![], &mut filled);
clip_by_type(&mut layers, &type_clips, &filled);
doc.layers = layers;
made.sort();
let threaded_frames: BTreeSet<NodeId> =
@@ -2155,6 +2157,30 @@ fn unmark(nodes: &mut [Arc<Node>], shown: bool, prints: bool, found: &mut Vec<(N
}
}
/// Make the clipping groups in `layers` that their type clips ([`Structure::type_clips`]) clip by it,
/// where its slot became one text object (`filled`). The page shows that type by what it clips, so
/// it is never weighed as type the page doesn't draw ([`prune_unseen`]).
fn clip_by_type(
layers: &mut [Arc<Node>],
type_clips: &std::collections::HashMap<NodeId, NodeId>,
filled: &std::collections::HashMap<NodeId, Filled>,
) {
let one = |slot: NodeId| {
filled.get(&slot).and_then(|f| match f.objects.as_slice() {
[id] => Some(*id),
_ => None,
})
};
let mut seen = |n: &mut Node| {
if let Some(name) = n.name.as_deref().and_then(|m| m.strip_prefix(MADE)) {
n.name = (!name.is_empty()).then(|| name.to_string());
}
};
for l in layers {
ai::clip_by_type(Arc::make_mut(l), type_clips, &one, &mut seen);
}
}
/// Take object `id` out of `nodes` (`hide`: leave it, hidden); whether it was there.
fn take_out(nodes: &mut Vec<Arc<Node>>, id: NodeId, hide: bool) -> bool {
if let Some(i) = nodes.iter().position(|n| n.id == id) {
+90
View File
@@ -1180,6 +1180,96 @@ fn filter_output_counts_against_the_memory_budget() {
assert!(err.contains("too much memory"), "{err}");
}
/// A shading painted with `shfill` and not extended paints only between its ends: an axial one
/// between the lines through them across its axis, a radial one from a point over its circles
/// (PLRM 3rd ed. §4.9.3: `Extend` is `[false false]` by default). Extended both ways it paints
/// the whole clip.
#[test]
fn shadings_not_extended_paint_only_between_their_ends() {
let shade = |kind: u8, coords: &str, extend: &str| {
let r = read(&format!(
"<< /ShadingType {kind} /ColorSpace /DeviceRGB /Coords [{coords}] {extend} \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill"
));
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
bounds(&n)
};
// Axial, from x 10 to 90 (and its reflection in y: the document's y runs down).
let b = shade(2, "10 0 90 0", "");
assert!(near(b, Rect::new(10.0, 0.0, 90.0, 100.0)), "{b:?}");
let b = shade(2, "10 0 90 0", "/Extend [false true]");
assert!(near(b, Rect::new(10.0, 0.0, 100.0, 100.0)), "{b:?}");
let b = shade(2, "10 0 90 0", "/Extend [true true]");
assert!(near(b, Rect::new(0.0, 0.0, 100.0, 100.0)), "{b:?}");
// Radial from the centre point to a circle of radius 30.
let b = shade(3, "50 50 0 50 50 30", "");
assert!((b.width() - 60.0).abs() < 0.5 && (b.height() - 60.0).abs() < 0.5 && (b.center().x - 50.0).abs() < 0.5, "{b:?}");
// Its circle is cut to a polygon whose sides lie within 0.01 pt of it, also for a large one.
let r = read(
"<< /ShadingType 3 /ColorSpace /DeviceRGB /Coords [50 50 0 50 50 45] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
let NodeKind::Path { path, .. } = &n.kind else { panic!("{n:?}") };
let ring: Vec<Point> = path.subpaths.iter().flat_map(|s| s.anchors.iter().map(|a| a.p)).collect();
let centre = Point::new(50.0, 50.0);
for (a, b) in ring.iter().zip(ring.iter().cycle().skip(1)) {
assert!((a.distance(centre) - 45.0).abs() < 1e-6, "{a:?}");
assert!(a.midpoint(*b).distance(centre) > 45.0 - 0.01, "{a:?} {b:?}");
}
// Stretched 4 times across and squashed to a quarter down (areas unchanged), the sides still
// lie within 0.01 pt of the ellipse it becomes.
let r = read(
"50 50 translate 4 0.25 scale << /ShadingType 3 /ColorSpace /DeviceRGB /Coords [0 0 0 0 0 10] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
let NodeKind::Path { path, .. } = &n.kind else { panic!("{n:?}") };
let sides = path.subpaths.iter().map(|s| s.anchors.len()).sum::<usize>();
// A side of a regular polygon in the circle lies 1 - cos(pi / sides) of the radius inside it;
// stretched to 40 pt across, that is at most 0.01 pt.
assert!(40.0 * (1.0 - (std::f64::consts::PI / sides as f64).cos()) <= 0.01 + 1e-9, "{sides} sides");
let b = shade(3, "50 50 0 50 50 30", "/Extend [true true]");
assert!(near(b, Rect::new(0.0, 0.0, 100.0, 100.0)), "{b:?}");
// Axial along y, and extended at its start only.
let b = shade(2, "0 20 0 70", "");
assert!(near(b, Rect::new(0.0, 30.0, 100.0, 80.0)), "{b:?}");
let b = shade(2, "10 0 90 0", "/Extend [true false]");
assert!(near(b, Rect::new(0.0, 0.0, 90.0, 100.0)), "{b:?}");
// Diagonal: from (60, 60) to (90, 90) it paints where x + y lies from 120 to 180, a strip
// across the square's top-right corner whose own corners are cut off.
let r = read(
"<< /ShadingType 2 /ColorSpace /DeviceRGB /Coords [60 60 90 90] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
assert!(near(bounds(&n), Rect::new(20.0, 0.0, 100.0, 80.0)), "{:?}", bounds(&n));
let NodeKind::Path { path, .. } = &n.kind else { panic!("{n:?}") };
for a in path.subpaths.iter().flat_map(|s| s.anchors.iter()) {
// Back in PostScript's y-up space.
let s = a.p.x + (100.0 - a.p.y);
assert!((120.0 - 1e-6..=180.0 + 1e-6).contains(&s), "{a:?}");
}
// The current transformation turns the axis: rotated a quarter turn about the centre, an axis
// from -40 to 40 along x runs up the page from y 10 to 90.
let r = read(
"50 50 translate 90 rotate << /ShadingType 2 /ColorSpace /DeviceRGB /Coords [-40 0 40 0] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
assert!(near(bounds(&n), Rect::new(0.0, 10.0, 100.0, 90.0)), "{:?}", bounds(&n));
// Radial from a point off the circle's centre covers the hull of that point and the circle.
let b = shade(3, "20 50 0 60 50 30", "");
assert!((b.x0 - 20.0).abs() < 0.5 && (b.x1 - 90.0).abs() < 0.5 && (b.y0 - 20.0).abs() < 0.5 && (b.y1 - 80.0).abs() < 0.5, "{b:?}");
// Radial shadings this doesn't bound (extended at one end, or starting from a circle) still
// paint the whole area.
for (coords, extend) in [("50 50 0 50 50 30", "/Extend [true false]"), ("50 50 0 50 50 30", "/Extend [false true]"), ("50 50 10 50 50 30", "")] {
let b = shade(3, coords, extend);
assert!(near(b, Rect::new(0.0, 0.0, 100.0, 100.0)), "{coords} {extend}: {b:?}");
}
}
/// A sampled function of one input in an axial shading: interpolated linearly, its gradient has a
/// stop at every sample (exact, not sampled evenly); with `Order 3` it is a cubic through the
/// samples (PLRM 3rd ed. §3.10.1, Table 3.36), kept in its range.
+254 -1
View File
@@ -5887,12 +5887,18 @@ fn type_envelope_on(keys: &str, shape: &str, drawn: &str, after: &str) -> String
/// [`type_envelope_on`] around the type of story `story`.
fn type_envelope_on_story(story: u32, keys: &str, shape: &str, drawn: &str, after: &str) -> String {
type_envelope_holding(keys, shape, &format!("{}{after}", text_object(story)), drawn)
}
/// [`type_envelope_on`] whose contents are `contents` (on plain lines, written on `%_` ones), which
/// hold its text objects.
fn type_envelope_holding(keys: &str, shape: &str, contents: &str, drawn: &str) -> String {
let hidden = |s: &str| -> String { s.lines().map(|l| format!("%_{l}\n")).collect() };
format!(
"{}{}%_X=\n{}%_X+\n%_ (AIDeformArtKey) ,\n%_1 /Int (AIDeformStyle) ,\n%_;\n%_\n%_9 () XW\nu\n{drawn}U\n9 () XW\n(Adobe Deform Plugin) 1 0 0 XP\n",
hidden(&format!("u\n{shape}U\n")),
hidden(&format!("/ArtDictionary :\n{keys}")),
hidden(&format!("u\n{}{after}U\n9 () XW\n", text_object(story))),
hidden(&format!("u\n{contents}U\n9 () XW\n")),
)
}
@@ -5998,6 +6004,32 @@ fn an_envelope_of_type_that_draws_as_its_drawn_art_opens_live() {
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
}
/// An envelope of type with no fill and no stroke, its drawn art the bent outlines unpainted, opens
/// live: neither draws a pixel, so they draw alike, and the type stays editable.
#[test]
fn an_envelope_of_unpainted_type_whose_drawn_art_paints_nothing_opens_live() {
let Some(family) = installed_family() else { return };
// The outlines come from the type filled; the file's type has its fill turned off (`/56 false`).
let filled = type_envelope_text(&family, None);
let mut doc = text_document(&[("FLUX\r", 0, (8170.0, 8180.0), (0.0, 0.0), 0.0)])
.replace("(Helvetica)", &format!("({family})"))
.replace("/53 <<", "/56 false /53 <<");
while ascii85(doc.as_bytes()).len() % 60 == 1 {
doc.push('\n');
}
assert_eq!(text_fill(&made_envelope_type(&doc)), None);
let (drawn, _) = drawn_envelope(&arc_envelope(&made_envelope_type(&filled), 30.0));
assert!(drawn.contains("f\n"), "{drawn}");
let unpainted = drawn.replace("f\n", "n\n");
let art = native_with_text(&layer("Art", true, &format!("{}\n{}", square(10, 10), type_envelope(&arc_keys(0.3), &unpainted))), &doc);
let r = import(&eps(&page_square(10, 10), &art)).unwrap();
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
let (envelopes, loose) = envelopes_and_type(&r.document);
assert_eq!(envelopes, [vec!["FLUX".to_string()]], "{:?}", r.warnings);
assert!(loose.is_empty(), "{loose:?}");
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
}
/// An envelope of type whose live envelope draws apart from its drawn art (the file's art bends the
/// other way) keeps its drawn art and its type, hidden, with a note.
#[test]
@@ -6556,6 +6588,86 @@ fn a_warp_of_type_opens_as_a_mesh_on_its_saved_grid_and_keeps_its_shape_when_its
}
}
/// In the layers, type from the text document made a clipping mask (a clipping group with no
/// clipping path, the type last) clips the group's art as the page draws it: the type comes in as
/// the group's clipping path, editable, and the art doesn't paint past it.
#[test]
fn type_made_a_clipping_mask_clips_its_group_in_the_layers() {
use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions, envelope_content_bounds};
let Some(family) = installed_family() else { return };
let doc = type_envelope_text(&family, None);
// The page: the type's glyphs in the yellow of the square they clip, which covers the page, and
// drawn through a flat mesh over their box, which leaves them where they are.
let mut yellow = made_envelope_type(&type_envelope_text(&family, Some("/0 << /0 2 /1 [ 1.0 0.0 0.0 1.0 0.0 ] >>")));
yellow.visible = true;
let content = vec![std::sync::Arc::new(yellow)];
let g = envelope_content_bounds(&content).unwrap();
let points = vec![kurbo::Point::new(g.x0, g.y0), kurbo::Point::new(g.x1, g.y0), kurbo::Point::new(g.x0, g.y1), kurbo::Point::new(g.x1, g.y1)];
let kind = Box::new(EnvelopeKind::Mesh { rows: 1, cols: 1, points, handles: vec![[kurbo::Vec2::ZERO; 4]; 4] });
let options = EnvelopeOptions::NEW;
let flat = Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope { content, kind, fidelity: 50.0, editing: false, options, frame: Box::default() },
);
let (_, page) = drawn_envelope(&flat);
let clipped = format!("q\n0 0 1 0 k\n0 0 m\n100 0 L\n100 100 L\n0 100 L\nf\n{}Q\n", text_object(0));
let art = native_with_text(&layer("Art", true, &clipped), &doc);
let r = import(&eps(&page, &art)).unwrap();
// The layers are used, none of their art replaced with the page's (the note on how the type
// differs from the page is about the edges of its glyphs).
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
assert!(!r.warnings.iter().any(|w| w.contains("came in as its art") || w.contains("weren't read")), "{:?}", r.warnings);
let children = r.document.layers[0].children().unwrap();
let [group] = children.as_slice() else { panic!("{children:#?}") };
let NodeKind::Group { children, clip: true } = &group.kind else { panic!("not clipped: {group:#?}") };
let (NodeKind::Text(t), NodeKind::Path { .. }) = (&children[0].kind, &children[1].kind) else { panic!("{children:#?}") };
assert_eq!(t.plain_text(), "FLUX");
}
/// Type made a clipping mask in an envelope's contents (a clipping group with no clipping path, the
/// type last) clips the art under it there, as the drawn art shows: the envelope opens live, its
/// type editable as the group's clipping path. The art it clips covers the type's glyphs and stays
/// inside their box, so the envelope maps from that box however the art past the type would count.
#[test]
fn an_envelope_whose_type_clips_its_contents_opens_live_with_the_type_clipping_them() {
let Some(family) = installed_family() else { return };
let doc = type_envelope_text(&family, None);
// What it draws: the type in the yellow of the square it clips, which covers it.
let yellow = made_envelope_type(&type_envelope_text(&family, Some("/0 << /0 2 /1 [ 1.0 0.0 0.0 1.0 0.0 ] >>")));
let shaped = |text: Node| {
let mut text = text;
text.visible = true;
let options = vectorcraft_doc::live::EnvelopeOptions::NEW;
let content = vec![std::sync::Arc::new(text)];
Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope { content, kind: Box::new(rising_kind()), fidelity: 50.0, editing: false, options, frame: Box::default() },
)
};
let glyphs = vectorcraft_doc::live::envelope_content_bounds(&[std::sync::Arc::new(yellow.clone())]).unwrap();
let (drawn, page) = drawn_envelope(&shaped(yellow));
// A yellow square over the glyphs' box, just inside it.
let (x0, y0) = to_art(kurbo::Point::new(glyphs.x0 + 0.01, glyphs.y1 - 0.01));
let (x1, y1) = to_art(kurbo::Point::new(glyphs.x1 - 0.01, glyphs.y0 + 0.01));
let contents = format!("q\n0 0 1 0 k\n{x0} {y0} m\n{x1} {y0} L\n{x1} {y1} L\n{x0} {y1} L\nf\n{}Q\n", text_object(0));
let envelope = type_envelope_holding(&arc_keys(0.3), &rising_grid(), &contents, &drawn);
let art = native_with_text(&layer("Art", true, &format!("{}\n{envelope}", square(10, 10))), &doc);
let r = import(&eps(&format!("{}\n{page}", page_square(10, 10)), &art)).unwrap();
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
let mut live = vec![];
r.document.walk(|n| {
if let NodeKind::Envelope { content, .. } = &n.kind {
live.push(content.clone());
}
});
let [content] = live.as_slice() else { panic!("{:?}", r.warnings) };
let [group] = content.as_slice() else { panic!("{content:#?}") };
let NodeKind::Group { children, clip: true } = &group.kind else { panic!("not clipped: {group:#?}") };
let (NodeKind::Text(t), NodeKind::Path { .. }) = (&children[0].kind, &children[1].kind) else { panic!("{children:#?}") };
assert_eq!(t.plain_text(), "FLUX");
}
/// A warp of stroked type with Distort Appearance whose drawn art maps the type's bounds with its
/// strokes onto the grid the file saves (not its glyphs' bounds alone) opens live as a mesh envelope
/// mapping from that box (#3179). The drawn art strokes the bent outlines at the stroke's own weight,
@@ -7198,6 +7310,147 @@ fn warped_type_that_draws_apart_from_its_look_comes_in_as_the_look() {
}
}
/// An art style section with style `Dashed`: a black stroke 2 units wide with butt caps, miter joins
/// and dashes of 6 and gaps of 4, aligned to corners and path ends (`BSDashAdj`).
fn aligned_dash_style() -> String {
"%AI9_BeginArtStyles\n/KnownStyle :\n(Dashed) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n2 /FillOrStroke ,\n/Dictionary : /NotRecorded ,\n\
/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n\
/StrokeStyle : 0 R\n0 0 0 1 0 0 0 XA\n0 J 0 j 2 w 10 M [6 4 ]0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n;\n%AI9_EndArtStyles\n"
.to_string()
}
/// The open path of [`aligned_dash_file`], a corner at (80, 20), in the document's coordinates.
fn aligned_dash_path() -> kurbo::BezPath {
let mut bp = kurbo::BezPath::new();
bp.move_to((20.0, 20.0));
bp.line_to((80.0, 20.0));
bp.line_to((80.0, 70.0));
bp
}
/// What [`aligned_dash_style`] draws along [`aligned_dash_path`], with its dashes aligned to corners
/// and path ends by VectorCraft or (`aligned` false) not, as look operators in black.
fn aligned_dash_look(aligned: bool) -> String {
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Dash, LineCap, LineJoin, StrokeLayer};
let mut stroke = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
(stroke.cap, stroke.join, stroke.miter_limit) = (LineCap::Butt, LineJoin::Miter, 10.0);
stroke.dash = Some(Dash { pattern: vec![6.0, 4.0], offset: 0.0, align_corners: aligned });
let outline = vectorcraft_effects::stroke::line_outline(&aligned_dash_path(), &stroke, 2.0, 0.01);
assert!(!outline.elements().is_empty());
drawn_as_operators(&outline).replace("0 1 1 0 1 0 0 Xa", "0 0 0 1 0 0 0 Xa")
}
/// The editing copy of [`aligned_dash_path`] under [`aligned_dash_style`], with the look `drawing`.
fn aligned_dash_file(drawing: &str) -> String {
aligned_dash_files(drawing, 1)
}
/// [`aligned_dash_file`] with `n` such paths.
fn aligned_dash_files(drawing: &str, n: usize) -> String {
let own = "%_0 0 0 1 0 0 0 XA\n%_2 w\n%_20 80 m\n%_80 80 L\n%_80 30 L\n%_S\n";
let one = format!("u\n{drawing}\nU\n9 () XW\n{own}1 (Dashed) XW\n");
native(&(aligned_dash_style() + &layer("Art", true, &one.repeat(n))))
}
/// The paths of `d` that stroke with dashes, each with whether its dashes are aligned to corners.
fn dashed_paths(d: &Document) -> Vec<bool> {
let mut out = vec![];
d.walk(|n| {
if matches!(n.kind, NodeKind::Path { .. }) {
for i in &n.appearance.items {
if let vectorcraft_doc::AppearanceItem::Stroke(s) = i
&& let Some(dash) = &s.dash
{
out.push(dash.align_corners);
}
}
}
});
out
}
/// A stroke whose dashes are aligned to corners and path ends comes in as the path with that stroke,
/// editable, where VectorCraft's fitting draws as its drawn look.
#[test]
fn dashes_aligned_to_corners_that_draw_as_the_look_come_in_live() {
let (d, notes) = crate::ai_alone(&private(&aligned_dash_file(&aligned_dash_look(true)))).unwrap();
assert_eq!(dashed_paths(&d), [true], "{notes:?}");
assert!(!notes.iter().any(|w| w.contains("drawn look")), "{notes:?}");
}
/// Where the look draws the dashes elsewhere (here, not fitted), the path keeps its drawn look.
#[test]
fn dashes_aligned_to_corners_that_draw_apart_from_the_look_keep_it() {
let (d, notes) = crate::ai_alone(&private(&aligned_dash_file(&aligned_dash_look(false)))).unwrap();
assert!(dashed_paths(&d).is_empty(), "{notes:?}");
let looks = d.layers[0].children().unwrap();
assert!(matches!(looks.as_slice(), [l] if matches!(l.kind, NodeKind::Group { .. }) && l.visual_bounds().is_some()), "{looks:#?}");
}
/// The strokes with aligned dashes one import checks against their looks are limited
/// ([`crate::import::ai::MAX_DASH_CHECKS`]), apart from the envelopes' checks: past the
/// limit, a path that would draw as its look keeps the look.
#[test]
fn dashes_aligned_to_corners_past_their_checks_keep_the_look() {
let n = crate::import::ai::MAX_DASH_CHECKS;
let (d, notes) = crate::ai_alone(&private(&aligned_dash_files(&aligned_dash_look(true), n + 1))).unwrap();
assert_eq!(dashed_paths(&d).len(), n, "{notes:?}");
let looks = d.layers[0].children().unwrap().iter().filter(|c| matches!(c.kind, NodeKind::Group { .. })).count();
assert_eq!(looks, 1);
}
/// The reads of a file apart from its layers check no stroke with dashes aligned to corners in its
/// layers against its look: the import's checks ([`crate::import::ai::MAX_DASH_CHECKS`]) are its
/// layers' reader's, though those reads go over all of the data. Its artboards and variable library
/// are read with no checks at all, and its swatches (and so its brushes, styles and symbols, read
/// the same way) with none once their reader reaches the layers. The layers' reader still checks
/// the one such stroke.
#[test]
fn the_reads_apart_from_the_layers_check_no_aligned_dashes() {
use vectorcraft_testkit::ai::{sample_variable_sets, variable_library_data};
let library = variable_library_data(&sample_variable_sets("variableAndTypes", &[]));
let own = "%_0 0 0 1 0 0 0 XA\n%_2 w\n%_20 80 m\n%_80 80 L\n%_80 30 L\n%_S\n";
let one = format!("u\n{}\nU\n9 () XW\n{own}1 (Dashed) XW\n", aligned_dash_look(true));
let data = native(&(library + &aligned_dash_style() + &layer("Art", true, &one)));
let checks = |f: &dyn Fn()| {
crate::import::ai::DASH_CHECKS_MADE.set(0);
f();
crate::import::ai::DASH_CHECKS_MADE.get()
};
let names = crate::import::ai::Names::default;
assert_eq!(checks(&|| drop(crate::ai_alone(&private(&data)))), 1);
assert_eq!(checks(&|| drop(crate::import::ai::artboards(data.as_bytes(), &mut names()))), 0);
assert_eq!(checks(&|| assert!(crate::import::ai::variables(data.as_bytes(), &mut names()).present)), 0);
assert_eq!(checks(&|| drop(crate::import::ai::palette(data.as_bytes(), &[], &mut names()))), 0);
}
/// Type under a style with dashes aligned to corners keeps its drawn look, as before, and takes no
/// such stroke: the look check isn't made for type.
#[test]
fn type_with_dashes_aligned_to_corners_keeps_its_drawn_look() {
let doc = text_document(&[("TILT\r", 0, (8200.0, 8180.0), (0.0, 0.0), 0.0)]);
let own: String = text_object(0).lines().map(|l| format!("%_{l}\n")).collect();
let look = format!("u\n{}\nU\n9 () XW\n", aligned_dash_look(true));
let file = native_with_text(&(aligned_dash_style() + &layer("Art", true, &format!("{look}{own}1 (Dashed) XW\n"))), &doc);
let (d, notes) = crate::ai_alone(&private(&file)).unwrap();
// The look stays, and the type takes no stroke with aligned dashes.
let kids = d.layers[0].children().unwrap();
assert!(kids.iter().any(|c| matches!(c.kind, NodeKind::Group { .. }) && c.visual_bounds().is_some()), "{notes:?}");
let mut aligned = false;
d.walk(|n| {
if matches!(n.kind, NodeKind::Text(_)) {
aligned |= n
.appearance
.items
.iter()
.any(|i| matches!(i, vectorcraft_doc::AppearanceItem::Stroke(s) if s.dash.as_ref().is_some_and(|d| d.align_corners)));
}
});
assert!(!aligned, "{notes:?}");
}
/// Warped type that a text variable binds stays type with the effect live and keeps its binding,
/// though its live warp draws apart from its look.
#[test]
+1 -1
View File
@@ -70,7 +70,7 @@ fn sheet(p: &PrintPage, job: &PrintJob) -> Result<(String, Vec<Page>), String> {
}
let opts = |region: Rect| EpsOptions { level: job.level, region, ..EpsOptions::default() };
let art_opts = opts(r);
let art = Scene::new(p.doc, &art_opts).run();
let art = Scene::new(p.doc, &art_opts).on_plate(p.ink.is_some()).run();
// The marks' area: the drawing space the page shows (within the tile).
let paper = Rect::new(0.0, 0.0, w, h);
let shown = if p.view.determinant().abs() > 1e-12 { p.view.inverse().transform_rect_bbox(paper) } else { paper };
+222 -3
View File
@@ -1,9 +1,12 @@
//! PostScript print jobs: DSC page comments, the setup of each sheet, and a file the PostScript
//! reader reads back.
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Document, Node, NodeId};
use vectorcraft_geom::{Affine, Rect, shapes};
use vectorcraft_color::{
Color, Freeform, FreeformPoint, Gradient, GradientGeom, GradientKind, GradientPaint, GradientSpread, GradientStop, Paint, Swatch,
};
use vectorcraft_doc::{Appearance, CharStyle, Document, Node, NodeId, NodeKind, StrokeGradientMode, TextObject};
use vectorcraft_geom::{Affine, Point, Rect, Vec2, shapes};
use vectorcraft_testkit::raster::{Image, render_region};
use super::*;
@@ -110,3 +113,219 @@ fn separations_screens_flatness_negatives_and_tiles() {
assert!(print(&[], &[], &job).is_err());
assert!(print(&[PrintPage { size: (f64::NAN, 1.0), ..page(&d, None) }], &[0], &job).is_err());
}
/// A 200 × 100 pt CMYK document with spot swatch `Ink` (100% K): a rectangle over the whole page
/// painted `under`, when there is one, then `art`.
fn over(under: Option<Paint>, art: &[Node]) -> Document {
let mut d = Document::new(200.0, 100.0);
d.color_mode = vectorcraft_doc::ColorMode::Cmyk;
d.swatches.push(Swatch { name: "Ink".into(), paint: Paint::solid(Color::cmyk(0.0, 0.0, 0.0, 1.0)), global: true, spot: true });
let layer = d.layers[0].id;
let under = under.map(|p| Node::path(NodeId(0), shapes::rectangle(Rect::new(0.0, 0.0, 200.0, 100.0)), Appearance::basic(p, Paint::None, 0.0)));
for mut n in under.into_iter().chain(art.iter().cloned()) {
n.id = d.alloc_id();
d.insert(Some(layer), usize::MAX, n).unwrap();
}
d
}
/// Ink `ink`'s plate of `d` as the print plan separates it for PostScript, and as a PostScript
/// separation at `level` read back, both drawn at 1 px a point.
fn plate_of(d: &Document, ink: &str, level: Level) -> (Image, Image) {
let area = Rect::new(0.0, 0.0, 200.0, 100.0);
let settings = serde_json::from_value(serde_json::json!({"output": {"mode": "separations"}})).unwrap();
let plan = vectorcraft_pdf::plan(d, &vectorcraft_pdf::PrintOptions { settings, postscript: true, ..Default::default() }).unwrap();
let i = plan.sheets.iter().find(|s| s.ink.as_ref().is_some_and(|p| p.name == ink)).and_then(|s| s.plate).unwrap();
let plate = &plan.plates[i];
let page = PrintPage {
doc: plate,
size: (200.0, 100.0),
view: Affine::IDENTITY,
window: None,
place: Affine::IDENTITY,
copies: &[],
area,
marks: None,
negative: false,
ink: Some((ink, 85.0, 15.0)),
};
let out = print(&[page], &[0], &PrintJob { level, ..PrintJob::default() }).unwrap();
assert!(level == Level::Three || !text(&out).contains("shfill"), "Level 2 has no smooth shadings");
let back = crate::import(&out.bytes).unwrap().document;
(render_region(plate, area, 1.0), render_region(&back, area, 1.0))
}
/// Ink `ink`'s PostScript plate of `art` over a page of 100% `ink` (`under`), checked against the
/// plate of `art` alone (drawn from the print plan, or with `postscript` from its PostScript
/// plate): where `art` puts none of the ink down, the ink under it prints, and where it puts ink
/// down, its own amount prints. The pixels of the page where `art` alone puts no ink, those of
/// them where the ink under it does not print, and the pixels where `art` puts ink down that do
/// not print its amount.
fn keeps_the_ink_below(art: &[Node], under: &Paint, ink: &str, level: Level, postscript: bool) -> (usize, usize, usize) {
let (plan, own) = plate_of(&over(None, art), ink, level);
let alone = if postscript { own } else { plan };
let (_, printed) = plate_of(&over(Some(under.clone()), art), ink, level);
// Pixels whose neighbors all have paper (or all have ink) on the plate of `art` alone: an
// edge falls on either side of a pixel's center, and the edge of the inked part is lightest.
let around = |x: u32, y: u32, paper: bool| {
(x.saturating_sub(1)..=(x + 1).min(alone.width - 1))
.all(|i| (y.saturating_sub(1)..=(y + 1).min(alone.height - 1)).all(|j| (alone.over_white(i, j)[0] >= 254) == paper))
};
let (mut paper, mut knocked_out, mut wrong) = (0, 0, 0);
for y in 0..alone.height {
for x in 0..alone.width {
let (a, p) = (alone.over_white(x, y)[0], printed.over_white(x, y)[0]);
if around(x, y, true) {
paper += 1;
knocked_out += usize::from(p > 60);
} else if around(x, y, false) {
wrong += usize::from(a.abs_diff(p) > 48);
}
}
}
(paper, knocked_out, wrong)
}
/// A rectangle from (20, 10) to (180, 90) with `fill` and `stroke` (16 pt), each set to
/// overprint.
fn overprinting(fill: Paint, stroke: Paint) -> Node {
let mut n = Node::path(NodeId(0), shapes::rectangle(Rect::new(20.0, 10.0, 180.0, 90.0)), Appearance::basic(fill, stroke, 16.0));
for it in &mut n.appearance.items {
*it.overprint_mut() = true;
}
n
}
/// `stops` (offset, color) as a `kind` gradient placed at `geom`, spreading as `spread`.
fn gradient(kind: GradientKind, stops: &[(f32, Color)], geom: GradientGeom, spread: GradientSpread) -> Paint {
let stops = stops.iter().map(|(o, c)| GradientStop::new(*o, *c)).collect();
let mut g = GradientPaint::new(Gradient { spread, repeats: 2, ..Gradient::new(kind, stops) });
g.geom = Some(geom);
Paint::Gradient(Box::new(g))
}
#[test]
fn an_overprinting_gradient_keeps_the_ink_below_where_it_puts_none_on_a_postscript_plate() {
// Cyan in the outer stops, none from 0.3 to 0.6 (magenta only there).
let (inked, none) = (Color::cmyk(0.6, 0.3, 0.0, 0.0), Color::cmyk(0.0, 0.3, 0.0, 0.0));
let stops = [(0.0, inked), (0.3, none), (0.6, none), (1.0, inked)];
let c = Point::new(100.0, 50.0);
let around = GradientGeom { start: c, end: c + Vec2::new(70.0, -20.0), aspect: 0.7, focal: None };
let across = GradientGeom { start: Point::new(30.0, 40.0), end: Point::new(170.0, 60.0), aspect: 1.0, focal: None };
let pad = GradientSpread::Pad;
let fills = [
("linear", gradient(GradientKind::Linear, &stops, across, pad)),
("radial", gradient(GradientKind::Radial, &stops, around, pad)),
("off-center radial", gradient(GradientKind::Radial, &stops, GradientGeom { focal: Some(c + Vec2::new(-20.0, 10.0)), ..around }, pad)),
("conic", gradient(GradientKind::Conic, &stops, around, pad)),
("diamond", gradient(GradientKind::Diamond, &stops, around, pad)),
("repeating linear", gradient(GradientKind::Linear, &stops, across, GradientSpread::Repeat)),
("reflecting radial", gradient(GradientKind::Radial, &stops, around, GradientSpread::Reflect)),
// A hard edge: two stops at 0.5, the inked half first.
("hard edge", gradient(GradientKind::Linear, &[(0.0, inked), (0.5, inked), (0.5, none), (1.0, none)], across, pad)),
// Starting and ending with no cyan, padding past both ends.
("none at the ends", gradient(GradientKind::Linear, &[(0.2, none), (0.4, none), (0.5, inked), (0.8, none)], across, pad)),
];
// Many stretches with no cyan.
let many: Vec<(f32, Color)> = (0..16).map(|i| (i as f32 / 15.0, if i % 4 < 2 { inked } else { none })).collect();
let fills = fills.into_iter().chain([("many stops", gradient(GradientKind::Linear, &many, across, pad))]);
let cyan = Paint::solid(Color::cmyk(1.0, 0.0, 0.0, 0.0));
let cases: Vec<_> = fills.map(|(name, fill)| (name, overprinting(fill, Paint::None), cyan.clone(), "Cyan")).collect();
assert_keeps_the_ink_below(&cases);
}
#[test]
fn an_overprinting_gradient_with_a_hard_stop_at_an_end_keeps_the_ink_below_on_a_postscript_plate() {
// Two stops at an end, one with cyan and one without: Level 2's bands pad with the end stop,
// Level 3's shading with the stretch next to it, so each level is checked against its own
// plate of the gradient alone.
let (inked, none) = (Color::cmyk(0.6, 0.3, 0.0, 0.0), Color::cmyk(0.0, 0.3, 0.0, 0.0));
let ends = [
("none then cyan at 0", [(0.0, none), (0.0, inked), (1.0, inked)]),
("cyan then none at 1", [(0.0, inked), (1.0, inked), (1.0, none)]),
("cyan then none at 0", [(0.0, inked), (0.0, none), (1.0, none)]),
("none then cyan at 1", [(0.0, none), (1.0, none), (1.0, inked)]),
];
let c = Point::new(100.0, 50.0);
let around = GradientGeom { start: c, end: c + Vec2::new(50.0, -10.0), aspect: 0.7, focal: None };
let across = GradientGeom { start: Point::new(40.0, 40.0), end: Point::new(160.0, 60.0), aspect: 1.0, focal: None };
let pad = GradientSpread::Pad;
let cyan = Paint::solid(Color::cmyk(1.0, 0.0, 0.0, 0.0));
let shapes = [(GradientKind::Linear, across, "linear"), (GradientKind::Radial, around, "radial"), (GradientKind::Diamond, around, "diamond")];
let mut cases = vec![];
for (name, stops) in &ends {
for (kind, geom, shape) in shapes {
let fill = gradient(kind, stops, geom, pad);
cases.push((format!("{shape}, {name}"), overprinting(fill, Paint::None), cyan.clone(), "Cyan"));
}
}
let cases: Vec<_> = cases.iter().map(|(name, art, under, ink)| (name.as_str(), art.clone(), under.clone(), *ink)).collect();
assert_keeps_the_ink_below_of(&cases, true);
}
/// [`keeps_the_ink_below`] for each of `cases` (a name, the art, the paint under it and the ink
/// of the plate) at Level 3 and Level 2, with every case that fails named.
fn assert_keeps_the_ink_below(cases: &[(&str, Node, Paint, &str)]) {
assert_keeps_the_ink_below_of(cases, false);
}
/// [`assert_keeps_the_ink_below`], checked against the PostScript plate of each case's art alone
/// with `postscript`.
fn assert_keeps_the_ink_below_of(cases: &[(&str, Node, Paint, &str)], postscript: bool) {
let mut failed = vec![];
for (name, art, under, ink) in cases {
for level in [Level::Three, Level::Two] {
let (paper, knocked_out, wrong) = keeps_the_ink_below(std::slice::from_ref(art), under, ink, level, postscript);
if knocked_out + wrong >= 100 {
failed.push(format!("{name} at level {level:?}: {knocked_out} of {paper} knocked out, {wrong} of the others differ"));
}
}
}
assert!(failed.is_empty(), "{failed:#?}");
}
#[test]
fn overprinting_gradient_strokes_type_freeforms_and_spot_inks_keep_the_ink_below_on_postscript_plates() {
let (inked, none) = (Color::cmyk(0.6, 0.3, 0.0, 0.0), Color::cmyk(0.0, 0.3, 0.0, 0.0));
let stops = [(0.0, inked), (0.3, none), (0.6, none), (1.0, inked)];
let across = GradientGeom { start: Point::new(30.0, 40.0), end: Point::new(170.0, 60.0), aspect: 1.0, focal: None };
let linear = gradient(GradientKind::Linear, &stops, across, GradientSpread::Pad);
let stroked = |mode: StrokeGradientMode| {
let mut n = overprinting(Paint::None, linear.clone());
if let Some(st) = n.appearance.stroke_mut() {
st.gradient_mode = mode;
}
n
};
// Type: a gradient placed on the characters' bounds.
let on_type = GradientPaint::new(Gradient::new(GradientKind::Linear, stops.iter().map(|(o, c)| GradientStop::new(*o, *c)).collect()));
let style = CharStyle { fill: Paint::Gradient(Box::new(on_type)), overprint_fill: true, size: 80.0, ..Default::default() };
let text = Node::new(NodeId(0), NodeKind::Text(Box::new(TextObject::point(Point::new(20.0, 85.0), "HIM", style))));
// A freeform gradient with wide spreads of pure color around its points: none of the cyan
// around the left one.
let mut freeform = GradientPaint::new(Gradient::new(GradientKind::Freeform, vec![GradientStop::new(0.0, none), GradientStop::new(1.0, inked)]));
let pure = |at: Point, c: Color| FreeformPoint { spread: 0.9, ..FreeformPoint::new(at, c) };
let points = vec![pure(Point::new(50.0, 50.0), none), pure(Point::new(150.0, 50.0), inked)];
freeform.freeform = Some(Freeform { points, ..Default::default() });
// A spot ink's own plate: its tints in the outer stops, none of it from 0.3 to 0.6.
let tint = |t: f32| GradientStop { swatch: Some("Ink".into()), tint: t, ..GradientStop::new(0.0, Color::cmyk(0.0, 0.0, 0.0, t)) };
let spot = [
GradientStop { offset: 0.0, ..tint(0.8) },
GradientStop::new(0.3, none),
GradientStop::new(0.6, none),
GradientStop { offset: 1.0, ..tint(0.5) },
];
let mut on_spot = GradientPaint::new(Gradient::new(GradientKind::Linear, spot.to_vec()));
on_spot.geom = Some(across);
let cyan = Paint::solid(Color::cmyk(1.0, 0.0, 0.0, 0.0));
let full = Paint::Solid { color: Color::cmyk(0.0, 0.0, 0.0, 1.0), swatch: Some("Ink".into()), tint: 1.0 };
let cases = [
("stroke within", stroked(StrokeGradientMode::Within), cyan.clone(), "Cyan"),
("stroke along", stroked(StrokeGradientMode::Along), cyan.clone(), "Cyan"),
("stroke across", stroked(StrokeGradientMode::Across), cyan.clone(), "Cyan"),
("type", text, cyan.clone(), "Cyan"),
("freeform", overprinting(Paint::Gradient(Box::new(freeform)), Paint::None), cyan, "Cyan"),
("spot", overprinting(Paint::Gradient(Box::new(on_spot)), Paint::None), full, "Ink"),
];
assert_keeps_the_ink_below(&cases);
}
Loaded 100 of 296 files, more files were not shown because too many files have changed in this diff. Show more