Merge main into feat/weed-box-and-lines

This commit is contained in:
dotCooCoo committed 2026-11-12 07:20:06 -08:00
commit fa0a0753bb
178 files changed
+8892 -1151

No files matched your search

+1
View File
@@ -128,6 +128,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 2026-11-02: Mouse wheel over a closed font-family field in Character, Properties or Control changes selected text through the family list using saved font filters (excluding search text), one undo step per notch, stopping at the ends (#5253). Scores and estimates unchanged.
- 2026-10-31: Pattern libraries: Window › Swatch Libraries › Patterns and the Swatches panel's library menu open Geometric Patterns, a built-in library of eleven pattern swatches (dots, stripes, checks, a grid and shapes); clicking one adds its pattern and swatch to the document, once, and applies it to the active fill or stroke (`swatch.library.add`).
- 2026-11-11: Pattern libraries: Patterns › Grit Textures, a second built-in pattern library, holds eight seamless black textures (Fine Grain, Coarse Grit, Sand, Speckle, Stipple, Scratches, Sparse Flecks and Dense Flecks) on tiles of 18 to 36 pt, each drawn the same way every time; marks that reach past a tile edge continue on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
- 2026-11-11: Pattern libraries: Patterns › Optical Effects, a third built-in pattern library, of VectorCraft's own designs, holds eight black wave, moiré and op-art tiles (Sine Bands, Ripple Lines, Interference Rings, Offset Rings, Warped Checks, Pinched Stripes, Chevron Pulse and Radiating Lenses) of 32 to 48 pt, each drawn the same way every time; each tile is one period of its design, and art that reaches past a tile edge continues on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
- 2026-11-01: Find Nearest Swatch joins the Color Effects add-on (Object › Plug-ins › Color Effects): for each colour of the selection, the closest swatches of the document, a built-in library or a library or colour book the user loaded, with their CIEDE2000 difference; Apply gives each colour its nearest swatch as one undo step, linking global and spot swatches and adding a library's to the document first, so a process colour becomes the closest spot colour (`addon.color.nearestSwatch`, `addon.color.applyNearestSwatch`, #4923).
- 2026-11-01: Expand Dashes into Paths joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): each selected path's dashed stroke becomes separate open paths, one per dash, laid out exactly as the stroke draws them (pattern, offset, Align Dashes to Corners and Path Ends), each keeping the stroke with the dashes off, so the gaps are real gaps for cutters and plotters, as one undo step (`addon.pathtools.expandDashes`, #4922).
- 2026-11-01: Randomize Opacity joins the Arrange Tools add-on (Object › Plug-ins › Arrange Tools): each selected object gets its own opacity at random between a minimum and a maximum percent, with a seed that repeats the result, as one undo step (`addon.arrange.randomizeOpacity`, #4925).
+2
View File
@@ -381,6 +381,8 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
exists: Some(std::sync::Arc::new(|p: &str| std::path::Path::new(p).exists())),
// Background Save and Export write from a worker thread.
write_shared: Some(std::sync::Arc::new(write_file)),
save_write: Some(std::sync::Arc::new(fileio::write_save_file)),
save_stream: Some(std::sync::Arc::new(fileio::write_save_file_with)),
// Native saves stream into the file as they are encoded.
stream_shared: Some(std::sync::Arc::new(|p: &str, fill: &mut dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>| {
fileio::write_file_with(p, fill).map_err(|e| e.to_string())
+44 -8
View File
@@ -102,13 +102,22 @@ fn answer(code: u32, results: &HashMap<String, OwnedValue>) -> Result<Option<Sav
log::warn!("the portal's save dialog picked a file name that isn't UTF-8: nothing is saved");
return Ok(None);
};
let filter = results.get("current_filter").and_then(|v| {
let (label, _globs): (String, Vec<(u32, String)>) = v.try_clone().ok()?.try_into().ok()?;
Some(label)
});
let filter = results.get("current_filter").and_then(|v| filter_label(v));
Ok(Some(Saved { path, filter }))
}
/// The label of a file type as the portal sends it, a `(sa(us))` structure; `None` for a value of
/// another shape.
fn filter_label(value: &Value<'_>) -> Option<String> {
match value {
Value::Structure(s) => match s.fields() {
[Value::Str(label), Value::Array(globs)] if globs.element_signature() == "(us)" => Some(label.to_string()),
_ => None,
},
_ => None,
}
}
/// `file:///home/me/A%20b.svg` → `/home/me/A b.svg` (its bytes); `None` for a file elsewhere
/// (`file://host/`) or another scheme.
fn file_uri_path(uri: &str) -> Option<Vec<u8>> {
@@ -396,6 +405,36 @@ mod tests {
assert_eq!(pick_answer(saved, &request), ["/home/me/Art/poster"]);
}
/// A `current_filter` of another shape than `(sa(us))` (a structure with fewer, other or more
/// fields, a string) gives the path alone; `uris` of another shape is an error.
#[test]
fn an_answer_of_another_shape_is_not_read() {
let malformed = [
Value::from(("SVG".to_string(),)),
Value::from(("SVG".to_string(), vec![(0u32,)])),
Value::from(("SVG".to_string(), vec![("*.svg".to_string(), 0u32)])),
Value::from((1u32, vec![(0u32, "*.svg".to_string())])),
Value::from(("SVG".to_string(), vec![(0u32, "*.svg".to_string())], 1u32)),
Value::from("SVG"),
];
for filter in malformed {
let mut r = results("file:///tmp/card", None);
r.insert("current_filter".to_string(), OwnedValue::try_from(filter).unwrap());
assert_eq!(answer(0, &r), Ok(Some(Saved { path: "/tmp/card".into(), filter: None })));
}
let malformed = [
Value::from(vec![1u32]),
Value::from(vec![("file:///tmp/card".to_string(),)]),
Value::from(Vec::<String>::new()),
Value::from("file:///tmp/card"),
];
for uris in malformed {
let mut r = HashMap::new();
r.insert("uris".to_string(), OwnedValue::try_from(uris).unwrap());
assert!(answer(0, &r).is_err());
}
}
/// Cancel (1) and a dialog closed another way (2) answer no file; an answer without a local file
/// is an error, and rfd shows the dialog instead.
#[test]
@@ -486,10 +525,7 @@ mod tests {
}
let Ok((_parent, _title, options)) = msg.body().deserialize::<(String, String, HashMap<String, OwnedValue>)>() else { break };
let text = |key: &str| options.get(key).and_then(|v| String::try_from(v.try_clone().ok()?).ok());
let filter = options.get("current_filter").and_then(|v| {
let (label, _): (String, Vec<(u32, String)>) = v.try_clone().ok()?.try_into().ok()?;
Some(label)
});
let filter = options.get("current_filter").and_then(|v| filter_label(v));
let calls = log.lock().map(|mut l| {
l.push((text("current_name"), filter));
l.len()
+26 -4
View File
@@ -133,6 +133,13 @@ pub(crate) fn tiff(bytes: &[u8]) -> Option<(tiff::ColorType, tiff::decoder::Deco
Some((d.colortype().ok()?, d))
}
/// The Orientation tag of TIFF `bytes`' first image, of any unsigned type; `None` for other images
/// and TIFFs without one. Reads only its header.
pub fn tiff_orientation(bytes: &[u8]) -> Option<u16> {
let (_, mut d) = tiff(bytes)?;
d.find_tag_unsigned::<u16>(tiff::tags::Tag::Orientation).ok().flatten()
}
/// Does the TIFF `d` reads store one plane per channel (PlanarConfiguration 2)?
fn planar(d: &mut tiff::decoder::Decoder<Cursor<&[u8]>>) -> bool {
d.find_tag_unsigned::<u16>(tiff::tags::Tag::PlanarConfiguration).ok().flatten().is_some_and(|p| p != 1)
@@ -309,10 +316,10 @@ fn tiff_inks(bytes: &[u8]) -> Option<Inks> {
Inks::new(w, h, read_samples(&mut d, n, 4)?)
}
/// CMYK TIFF `bytes` as Open and Place store them: as they are, or, when they store one plane per
/// ink, which the image decoder doesn't read, their ink amounts written again by
/// [`ImageBlob::cmyk_tiff_at`] with the resolution `ppi`. `None` for other images and for CMYK
/// TIFFs whose inks [`ImageBlob::cmyk`] doesn't read.
/// CMYK TIFF `bytes` that no orientation turns ([`turned_cmyk`] stores the others) as Open and
/// Place store them: as they are, or, when they store one plane per ink, which the image decoder
/// doesn't read, their ink amounts written again by [`ImageBlob::cmyk_tiff_at`] with the resolution
/// `ppi`. `None` for other images and for CMYK TIFFs whose inks [`ImageBlob::cmyk`] doesn't read.
pub fn stored_cmyk_tiff(bytes: &[u8], ppi: Option<(f64, f64)>) -> Option<Vec<u8>> {
let inks = tiff_inks(bytes)?;
let (_, mut d) = tiff(bytes)?;
@@ -322,6 +329,21 @@ pub fn stored_cmyk_tiff(bytes: &[u8], ppi: Option<(f64, f64)>) -> Option<Vec<u8>
ImageBlob::cmyk_tiff_at(&inks, ppi).map(|b| Arc::unwrap_or_clone(b.bytes))
}
/// CMYK JPEG or TIFF `bytes` that `orientation` turns or flips, as Open and Place store them: their
/// ink amounts ([`ImageBlob::cmyk`], 8 bits each) turned and written again by
/// [`ImageBlob::cmyk_tiff_at`] with the resolution `ppi` of the turned pixels, with the turned
/// width and height. `None` for other images and for CMYK images whose inks [`ImageBlob::cmyk`]
/// doesn't read.
pub fn turned_cmyk(bytes: &[u8], orientation: image::metadata::Orientation, ppi: Option<(f64, f64)>) -> Option<(Vec<u8>, (u32, u32))> {
let inks = if bytes.starts_with(&[0xFF, 0xD8]) { jpeg_inks(bytes) } else { tiff_inks(bytes) }?;
// Four 8-bit inks to a pixel, turned as four 8-bit channels are.
let mut px = image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(inks.width, inks.height, inks.data)?);
px.apply_orientation(orientation);
let inks = Inks::new(px.width(), px.height(), px.into_bytes())?;
let tiff = ImageBlob::cmyk_tiff_at(&inks, ppi)?;
Some((Arc::unwrap_or_clone(tiff.bytes), (inks.width, inks.height)))
}
/// A TIFF whose pixels have samples after their colour, which the image decoder doesn't read at
/// all, as RGBA pixels: CMYK with an alpha channel (5 samples), each colour converted by `rgb` (ink
/// amounts 0..1 → sRGB 0..1; the inks can't be kept with the transparency, so they show as RGB),
+2 -2
View File
@@ -450,7 +450,7 @@ fn a_marquee_meets_blends_and_envelopes_by_their_box() {
envelope,
NodeKind::Envelope {
content,
kind: Box::new(crate::live::EnvelopeKind::Warp { style: "arc".to_string(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true }),
kind: Box::new(crate::live::EnvelopeKind::Warp { style: "arc".to_string(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true, version: 0 }),
fidelity: 100.0,
editing: false,
options: Default::default(),
@@ -1192,7 +1192,7 @@ fn objects_at_edit_contents_uses_general_order() {
d.alloc_id(),
NodeKind::Envelope {
content: vec![inner(a), inner(b)],
kind: Box::new(crate::live::EnvelopeKind::Warp { style: "arc".to_string(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true }),
kind: Box::new(crate::live::EnvelopeKind::Warp { style: "arc".to_string(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true, version: 0 }),
fidelity: 100.0,
editing: true,
options: Default::default(),
+197 -3
View File
@@ -60,12 +60,12 @@ pub use envelope::{
pub(crate) use expand::max_outset;
pub use expand::{
Hooks, MAX_GENERATED, Outliner, PatternTiles, affine_near, expand_deep, expand_deep_hooks, expand_live, expand_live_hooks, expand_live_with,
expanded_group, expanded_group_hooks, is_live, mesh_quad_nodes, subtree_has_live,
expanded_group, expanded_group_hooks, is_live, mesh_quad_nodes, mesh_warp_cost, mesh_warp_image, subtree_has_live,
};
#[cfg(test)]
use mesh::grid_eval;
pub use mesh::{Coons, GradientMesh, MeshAppearance, MeshPiece, MeshPoint, MeshQuad, default_fidelity, grid_points, nodes_bounds};
pub use warp::{WarpStyle, fit_piece, map_nonlinear, map_nonlinear_within, pieces, warp_point};
pub use warp::{WARP_NET, WarpNet, WarpStyle, fit_piece, map_nonlinear, map_nonlinear_within, pieces, uses_net, warp_point, warp_version};
#[cfg(test)]
mod tests {
@@ -132,6 +132,200 @@ mod tests {
let (r0, a) = (4.0 / PI, 0.5 / (4.0 / PI));
assert!((nx - (r0 - 0.25) * a.sin()).abs() < 1e-12 && (ny - (r0 - (r0 - 0.25) * a.cos())).abs() < 1e-12);
}
/// Each warp style's Bézier net, at points worked out by a separate implementation of the same
/// nets: (style, bend %, horizontal and vertical distortion %, vertical, box w × h, (u, v)) →
/// the point in the box (origin at its top left, y down).
#[test]
fn warp_nets_bend_each_style_as_its_own_patch() {
#[rustfmt::skip]
let samples = [
("arc", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, -31.1605665, 30.1243045),
("arc", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 170.241998, 58.8743443),
("arc", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 50.6087118, 47.6275948),
("arcLower", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 18.8784581, 35.5028749),
("arcLower", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 164.486168, 119.348666),
("arcLower", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 38.1073767, 36.0911629),
("arcUpper", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 17.3830689, 17.1599587),
("arcUpper", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 160.498463, 86.7390371),
("arcUpper", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 46.1081993, 36.0252855),
("arch", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 16.261527, 11.6570838),
("arch", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 164.984631, 57.3903712),
("arch", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 49.2508226, 36.2064484),
("bulge", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 16.261527, 22.6628335),
("bulge", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 164.984631, 116.087703),
("bulge", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 42.965576, 36.2064484),
("shellLower", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 10.6489723, 25.9914004),
("shellLower", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 208.565464, 99.4817585),
("shellLower", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 41.043987, 36.1302767),
("shellUpper", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, -21.8346746, 41.6042708),
("shellUpper", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 160.791499, 90.3680631),
("shellUpper", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 42.9282896, 36.1475509),
("flag", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 20.0, 55.92),
("flag", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 160.0, 55.44),
("flag", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 58.098, 35.91),
("wave", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 20.0, 40.8864),
("wave", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 160.0, 83.7792),
("wave", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 42.33, 35.91),
("fish", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 20.0, 19.632),
("fish", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 160.0, 62.352),
("fish", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 44.994, 35.91),
("rise", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 20.0, 146.64),
("rise", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 160.0, 102.48),
("rise", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 118.686, 35.91),
("fisheye", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 9.1136, 27.2784),
("fisheye", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 166.2208, 94.1472),
("fisheye", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 47.514, 35.7048),
("inflate", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, -0.16, 27.84),
("inflate", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 166.48, 97.68),
("inflate", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 45.75, 36.54),
("squeeze", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 40.16, 27.84),
("squeeze", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 153.52, 97.68),
("squeeze", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 45.75, 36.0),
("twist", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.1, 0.3, 32.2472, 27.9588),
("twist", 60.0, 0.0, 0.0, false, 200.0, 100.0, 0.8, 0.9, 149.1136, 89.2224),
("twist", -40.0, 30.0, -50.0, true, 150.0, 60.0, 0.25, 0.6, 45.56325, 33.8769),
];
for (style, bend, dh, dv, vertical, w, h, u, v, x, y) in samples {
let Some(st) = WarpStyle::from_id(style) else { panic!("{style}") };
let p = WarpNet::new(st, bend / 100.0, dh / 100.0, dv / 100.0, w, h, vertical).at(u, v);
assert!(p.distance(Point::new(x, y)) < 1e-6, "{style} {bend} {dh} {dv} {vertical} ({u}, {v}): {p:?} vs ({x}, {y})");
}
}
/// Arc's edges are concentric circles: at 100 % on a 200 × 100 box the bottom edge is the half
/// circle through the bottom corners about the bottom's middle, and the top edge the one 100
/// further out. One cubic for a half circle strays up to 1.84 % of the radius from the circle.
#[test]
fn warp_net_arc_edges_are_concentric_circles() {
let net = WarpNet::new(WarpStyle::Arc, 1.0, 0.0, 0.0, 200.0, 100.0, false);
let center = Point::new(100.0, 100.0);
for i in 0..=20 {
let u = f64::from(i) / 20.0;
for (v, r) in [(0.0, 200.0), (1.0, 100.0)] {
let d = net.at(u, v).distance(center);
assert!((d - r).abs() < 0.0184 * r, "u {u}, v {v}: {d} from the center, not {r}");
// Its ends and middle lie on the circle.
if i % 10 == 0 {
assert!((d - r).abs() < 1e-9, "u {u}, v {v}: {d} from the center, not {r}");
}
}
}
// Bend 0 leaves the box as it is.
for st in [WarpStyle::Arc, WarpStyle::ShellLower, WarpStyle::Bulge, WarpStyle::Twist] {
let flat = WarpNet::new(st, 0.0, 0.0, 0.0, 200.0, 100.0, false);
assert!(flat.at(0.3, 0.7).distance(Point::new(60.0, 70.0)) < 1e-9, "{st:?}");
}
}
/// The horizontal distortion scales each column of the net about its middle (narrowing the left
/// side for a positive value), then the vertical one each row (narrowing the top).
#[test]
fn warp_net_distortion_scales_the_columns_then_the_rows() {
let corners = |dh: f64, dv: f64| {
let net = WarpNet::new(WarpStyle::Arc, 0.0, dh, dv, 200.0, 100.0, false);
[net.at(0.0, 0.0), net.at(1.0, 0.0), net.at(0.0, 1.0), net.at(1.0, 1.0)]
};
let near = |got: [Point; 4], want: [(f64, f64); 4]| got.iter().zip(want).all(|(p, (x, y))| p.distance(Point::new(x, y)) < 1e-9);
assert!(near(corners(0.5, 0.0), [(0.0, 25.0), (200.0, -25.0), (0.0, 75.0), (200.0, 125.0)]), "{:?}", corners(0.5, 0.0));
assert!(near(corners(0.0, 0.5), [(50.0, 0.0), (150.0, 0.0), (-50.0, 100.0), (250.0, 100.0)]), "{:?}", corners(0.0, 0.5));
// Both coordinates scale: after the columns the top row runs from (0, 15) to (200, -15), and
// it then scales by 1.4 about its middle, (100, 0).
assert!(near(corners(0.3, -0.4), [(-40.0, 21.0), (240.0, -21.0), (40.0, 91.0), (160.0, 109.0)]), "{:?}", corners(0.3, -0.4));
}
/// Numbers no warp can take still give a finite net: a bend or distortion that isn't a number
/// counts as 0, and out of range as its limit; a size that isn't a number as 0.
#[test]
fn warp_net_takes_any_numbers() {
for st in [WarpStyle::Arc, WarpStyle::ShellUpper, WarpStyle::Wave, WarpStyle::Inflate, WarpStyle::Twist] {
for (b, dh, w, h) in
[(f64::NAN, 0.2, 10.0, 10.0), (5.0, f64::INFINITY, 10.0, 0.0), (-1e300, -3.0, f64::NAN, 1e-300), (1e-300, 0.0, 0.0, 0.0)]
{
for vertical in [false, true] {
let p = WarpNet::new(st, b, dh, dh, w, h, vertical).at(0.3, 0.6);
assert!(p.x.is_finite() && p.y.is_finite(), "{st:?} {b} {dh} {w} {h}: {p:?}");
}
}
}
let clamped = WarpNet::new(WarpStyle::Flag, 7.0, 0.0, 0.0, 200.0, 100.0, false);
assert_eq!(clamped, WarpNet::new(WarpStyle::Flag, 1.0, 0.0, 0.0, 200.0, 100.0, false));
}
/// A box near the largest finite size still warps: Flag on a 1e308 × 100 box moves points only
/// up and down, as on a 1 × 1e-306 one scaled up, and on a 1e308 × 1e-300 box keeps the box's
/// height. Fisheye at 100 % on a 1.7e308 square, whose net goes past the largest finite number,
/// gives finite points inside the box and past it, and the unit square's points scaled up where
/// those are finite. Fisheye moves y by the height alone, so on boxes of the largest finite
/// width and a height of 1e-300 or 100 every y is the unit square's times the height, also
/// where x goes past the largest finite number.
#[test]
fn warp_net_bends_a_huge_box_without_overflowing() {
let w = 1e308;
let flag = WarpNet::new(WarpStyle::Flag, 0.5, 0.0, 0.0, w, 100.0, false);
let small = WarpNet::new(WarpStyle::Flag, 0.5, 0.0, 0.0, 1.0, 100.0 / w, false);
for (u, v) in [(0.0, 0.0), (0.3, 0.6), (0.9, 1.0), (1.0, 0.5)] {
let (p, q) = (flag.at(u, v), small.at(u, v));
assert!(p.is_finite(), "({u}, {v}): {p:?}");
assert!((p.x - u * w).abs() <= 1e-12 * w, "({u}, {v}): {p:?}");
assert!((p.y - q.y * w).abs() <= 1e-9 * p.y.abs().max(1.0), "({u}, {v}): {p:?} against {q:?}");
}
let thin = WarpNet::new(WarpStyle::Flag, 0.5, 0.0, 0.0, w, 1e-300, false);
assert_eq!(thin.at(0.0, 1.0), Point::new(0.0, 1e-300));
let fisheye = WarpNet::new(WarpStyle::Fisheye, 1.0, 0.0, 0.0, 1.7e308, 1.7e308, false);
for (u, v) in [(0.1, 0.1), (0.8, 0.3), (1.5, 0.5), (3.0, 3.0)] {
let p = fisheye.at(u, v);
assert!(p.is_finite(), "({u}, {v}): {p:?}");
}
let unit = WarpNet::new(WarpStyle::Fisheye, 1.0, 0.0, 0.0, 1.0, 1.0, false);
let near = |a: f64, b: f64| (a - b).abs() <= 1e-12 * b.abs().max(f64::MIN_POSITIVE);
let (p, q) = (fisheye.at(0.1, 0.1), unit.at(0.1, 0.1));
assert!(near(p.x, q.x * 1.7e308) && near(p.y, q.y * 1.7e308), "{p:?} against {q:?}");
// The bottom of a box with a subnormal height stays exactly at that height: the net is
// built on the box halved, and the height's lowest bit but one is set.
let low = f64::MIN_POSITIVE / 4.0 + f64::from_bits(2);
let sub = WarpNet::new(WarpStyle::Fisheye, 1.0, 0.0, 0.0, f64::MAX, low, false).at(0.0, 1.0);
assert_eq!(sub.y, low, "{sub:?}");
for h in [1e-300, 100.0] {
let tall = WarpNet::new(WarpStyle::Fisheye, 1.0, 0.0, 0.0, f64::MAX, h, false);
for (u, v) in [(0.1, 0.1), (0.9, 0.4), (0.5, 0.8)] {
let (p, q) = (tall.at(u, v), unit.at(u, v));
assert!(p.is_finite() && near(p.y, q.y * h), "h {h}, ({u}, {v}): {p:?} against {q:?}");
}
}
}
/// Content with no width or no height takes the middle of a warp envelope's patch along that
/// side: under Arc a vertical line stays vertical, under Bulge a horizontal line stays straight.
#[test]
fn warp_envelopes_bend_flat_content_as_the_middle_of_the_patch() {
let warp = |style: &str| EnvelopeKind::Warp { style: style.into(), bend: 50.0, h: 0.0, v: 0.0, horizontal: true, version: WARP_NET };
let arc = warp("arc");
let map = envelope_mapper(&arc, Rect::new(100.0, 0.0, 100.0, 100.0));
for y in [0.0, 30.0, 100.0] {
let p = map(Point::new(100.0, y));
assert!((p.x - 100.0).abs() <= 1e-9, "{y}: {p:?}");
}
let bulge = warp("bulge");
let map = envelope_mapper(&bulge, Rect::new(0.0, 50.0, 200.0, 50.0));
for x in [0.0, 70.0, 200.0] {
let p = map(Point::new(x, 50.0));
assert!((p.y - 50.0).abs() <= 1e-9, "{x}: {p:?}");
}
}
/// A warp envelope's map version: none in a file reads as 0 (the earlier map), 0 is written
/// as none, so files keep their bytes, and the nets' version is written.
#[test]
fn warp_envelopes_write_their_map_version_only_when_it_has_one() {
let old: EnvelopeKind = serde_json::from_str(r#"{"type":"warp","style":"arc","bend":20}"#).unwrap();
assert!(matches!(old, EnvelopeKind::Warp { version: 0, .. }), "{old:?}");
assert!(!serde_json::to_string(&old).unwrap().contains("version"));
let new = EnvelopeKind::Warp { style: "arc".into(), bend: 20.0, h: 0.0, v: 0.0, horizontal: true, version: WARP_NET };
let text = serde_json::to_string(&new).unwrap();
assert!(text.contains(r#""version":1"#), "{text}");
assert_eq!(serde_json::from_str::<EnvelopeKind>(&text).unwrap(), new);
}
use vectorcraft_geom::shapes;
fn rect_node(x: f64, y: f64, w: f64, h: f64, c: Color) -> Arc<Node> {
@@ -537,7 +731,7 @@ mod tests {
#[test]
fn an_envelope_maps_from_its_box_with_its_margins() {
let rect = Node::path(NodeId(2), vectorcraft_geom::shapes::rectangle(Rect::new(10.0, 20.0, 110.0, 70.0)), crate::Appearance::default_art());
let kind = EnvelopeKind::Warp { style: "arc".into(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true };
let kind = EnvelopeKind::Warp { style: "arc".into(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true, version: 0 };
let content = [Arc::new(rect)];
let src = |content: &[Arc<Node>], frame: Affine, options: EnvelopeOptions| EnvelopeMap::new(content, &kind, frame, options).unwrap().src();
// Top, bottom, left and right.
+8
View File
@@ -3,6 +3,10 @@ use super::mesh::{GradientMesh, MeshPoint, grid_len, grid_points, surface_of};
use super::{Affine, Arc, Color, Deserialize, Node, NodeId, NodeKind, PathData, Point, Rect, Serialize, Vec2, yes};
use vectorcraft_geom::Homography;
fn is_zero(n: &u32) -> bool {
*n == 0
}
/// How an envelope distorts its content.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
@@ -19,6 +23,10 @@ pub enum EnvelopeKind {
v: f64,
#[serde(default = "yes")]
horizontal: bool,
/// The map the warp draws with: [`WARP_NET`](super::WARP_NET) for its style's Bézier net,
/// 0 (as in files from before the version existed) for [`warp_point`](super::warp_point).
#[serde(default, skip_serializing_if = "is_zero")]
version: u32,
},
/// A `(rows+1)×(cols+1)` grid of points (row-major) the content's bounding box maps onto.
Mesh {
+34 -13
View File
@@ -178,29 +178,46 @@ fn affine_between(s: [Point; 3], d: [Point; 3]) -> Option<Affine> {
a.is_finite().then_some(a)
}
/// Image `n` (`im`) pushed through the warp as a raster mesh warp: its frame cut into
/// `w.cells`² cells of two triangles, each a clip group showing the image under the affine map
/// that takes the triangle where the warp takes its corners (with Preserve Shape Using
/// Transparency, the image masked by the triangle; with Anti-Alias off, drawn without smoothing).
/// Each piece reaches a little past its edges (at most half a point) so neighbours overlap and no
/// seams show.
/// Image `n` (`im`) pushed through the envelope's warp as a raster mesh warp ([`mesh_warp_image`]
/// with `w.cells` cells, Preserve Shape Using Transparency and Anti-Alias as the envelope's
/// options say).
fn warp_image(n: &Node, im: &ImageObject, w: &Warper) -> Node {
let k = w.cells.max(1);
// Two triangles a cell, three objects each; an image an inner envelope already cut into
// pieces is cut again here, so the pieces count against [`MAX_GENERATED`]. Past it, the image
// is left out.
if !Generating::charge(k.saturating_mul(k).saturating_mul(6)) {
// An image an inner envelope already cut into pieces is cut again here, so the pieces count
// against [`MAX_GENERATED`]. Past it, the image is left out.
if !Generating::charge(mesh_warp_cost(k)) {
let mut g = n.clone();
g.kind = NodeKind::Group { children: vec![], clip: false };
return g;
}
mesh_warp_image(n, im, w.f, k, !w.options.anti_alias, w.options.preserve_shape == PreserveShape::Transparency)
}
/// How many objects [`mesh_warp_image`] makes of one image with `cells` rows and columns: two
/// triangles a cell, three objects each.
pub fn mesh_warp_cost(cells: usize) -> usize {
let k = cells.max(1);
k.saturating_mul(k).saturating_mul(6)
}
/// Image `n` (`im`) pushed through point map `f` as a raster mesh warp: its frame cut into
/// `cells`² cells of two triangles, each a clip group showing the image under the affine map
/// that takes the triangle where `f` takes its corners (with `masked`, the image masked by the
/// triangle instead; with `pixelated`, drawn without smoothing). Each piece reaches a little past
/// its edges (at most half a point) so neighbors overlap and no seams show. Each piece keeps the
/// color `n` colorizes a grayscale image with. The result is a group with `n`'s id, name,
/// transparency, opacity mask and appearance.
pub fn mesh_warp_image(n: &Node, im: &ImageObject, f: &dyn Fn(Point) -> Point, cells: usize, pixelated: bool, masked: bool) -> Node {
let k = cells.max(1);
// A grayscale image's fill color colorizes each piece; the group of pieces takes none.
let colorize = n.extras().colorize.clone();
let (pw, ph) = (im.width as f64, im.height as f64);
let at = |i: usize, j: usize| Point::new(pw * i as f64 / k as f64, ph * j as f64 / k as f64);
let mut pieces = Vec::with_capacity(2 * k * k);
for j in 0..k {
for i in 0..k {
let s = [at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1)];
let d = s.map(|p| (w.f)(im.xf * p));
let d = s.map(|p| f(im.xf * p));
for t in [[0, 1, 2], [0, 2, 3]] {
let (st, dt) = (t.map(|v| s[v]), t.map(|v| d[v]));
let Some(xf) = affine_between(st, dt) else { continue };
@@ -216,8 +233,9 @@ fn warp_image(n: &Node, im: &ImageObject, w: &Warper) -> Node {
.collect();
let shape = PathData::single(SubPath::polyline(&tri, true));
let mut image = Node::new(n.id, NodeKind::Image(Box::new(ImageObject { xf, ..im.clone() })));
image.extras_mut().pixelated = !w.options.anti_alias;
if w.options.preserve_shape == PreserveShape::Transparency {
image.extras_mut().pixelated = pixelated;
image.extras_mut().colorize = colorize.clone();
if masked {
// Preserve Shape Using Transparency: the triangle is the piece's alpha (a
// white opacity mask) instead of its clipping path.
let white = Node::path(n.id, shape, Appearance::basic(Paint::solid(Color::WHITE), Paint::None, 0.0));
@@ -234,6 +252,9 @@ fn warp_image(n: &Node, im: &ImageObject, w: &Warper) -> Node {
}
let mut g = n.clone();
g.kind = NodeKind::Group { children: pieces, clip: false };
if let Some(e) = g.extras_if_any() {
e.colorize = None;
}
g
}
+11 -2
View File
@@ -1,5 +1,5 @@
use super::envelope::{EnvelopeKind, H_DOWN, H_LEFT, H_RIGHT, H_UP, envelope_grid, mesh_at};
use super::warp::{WarpStyle, flatten_subpath, resample, warp_point};
use super::warp::{WarpNet, WarpStyle, flatten_subpath, resample, uses_net, warp_point};
use super::{
Affine, Anchor, Arc, Color, CubicBez, Deserialize, Node, ParamCurve, PathData, Point, Rect, Serialize, Shape, SubPath, Vec2, fifty, lerp_color,
one,
@@ -1731,10 +1731,19 @@ pub(super) fn grid_eval(rows: usize, cols: usize, pts: &[Point], u: f64, v: f64)
pub(super) fn surface_of<'a>(kind: &'a EnvelopeKind, src: Rect, frame: Affine) -> Box<dyn Fn(f64, f64) -> Point + 'a> {
let flat = move |u: f64, v: f64| frame * Point::new(src.x0 + u * src.width(), src.y0 + v * src.height());
match kind {
EnvelopeKind::Warp { style, bend, h: dh, v: dv, horizontal } => {
EnvelopeKind::Warp { style, bend, h: dh, v: dv, horizontal, version } => {
let st = WarpStyle::from_id(style).unwrap_or(WarpStyle::Arc);
let b = bend.clamp(-100.0, 100.0) / 100.0;
let (dh, dv) = (dh.clamp(-100.0, 100.0) / 100.0, dv.clamp(-100.0, 100.0) / 100.0);
if uses_net(*version) {
let net = WarpNet::new(st, b, dh, dv, src.width(), src.height(), !*horizontal);
// Content with no width or no height takes the middle of the patch along that side.
let (flat_u, flat_v) = (src.width() <= 0.0, src.height() <= 0.0);
return Box::new(move |u: f64, v: f64| {
let (u, v) = (if flat_u { 0.5 } else { u }, if flat_v { 0.5 } else { v });
frame * (src.origin() + net.at(u, v).to_vec2())
});
}
let c = src.center();
let (hw, hh) = (src.width() / 2.0, src.height() / 2.0);
let horizontal = *horizontal;
+331
View File
@@ -109,6 +109,337 @@ pub fn warp_point(style: WarpStyle, b: f64, dh: f64, dv: f64, aspect: f64, x: f6
(x2, y2)
}
// =====================================================================================
// Warp nets: each style as one Bézier patch over its box
// =====================================================================================
/// The `version` a Warp effect's params or a warp envelope carries for the [`WarpNet`] map. With
/// none (or 0) a warp draws with [`warp_point`], as every warp did before, so saved documents keep
/// their look; new and imported warps are given this one.
pub const WARP_NET: u32 = 1;
/// Does a warp of map `version` draw with [`WarpNet`]? A version newer than this build knows draws
/// with the newest map it has.
pub fn uses_net(version: u32) -> bool {
version >= WARP_NET
}
/// The map version `v` names when it is one this build draws: a whole number from 0 to
/// [`WARP_NET`], written as an integer or as a float (`1` or `1.0`).
pub fn warp_version(v: &serde_json::Value) -> Option<u32> {
let n = v.as_f64()?;
(n.fract() == 0.0 && (0.0..=f64::from(WARP_NET)).contains(&n)).then_some(n as u32)
}
/// A style's own control net: `rows` × `cols` points (2 to 4 each) of a Bézier patch, row by row
/// from the top, in the box's coordinates (origin at its top left, y down).
#[derive(Clone, Copy, Debug)]
struct Net {
rows: usize,
cols: usize,
p: [[Point; 4]; 4],
}
impl Net {
/// The undistorted box `w` × `h` as a `rows` × `cols` net.
fn flat(w: f64, h: f64, rows: usize, cols: usize) -> Self {
let mut p = [[Point::ZERO; 4]; 4];
for (r, row) in p.iter_mut().enumerate().take(rows) {
for (c, q) in row.iter_mut().enumerate().take(cols) {
*q = Point::new(w * (c as f64 / (cols - 1) as f64), h * (r as f64 / (rows - 1) as f64));
}
}
Self { rows, cols, p }
}
/// Upside down within a box `h` high: the rows in reverse order, each point mirrored.
fn mirrored(self, h: f64) -> Self {
let mut out = self;
for (to, from) in out.p[..self.rows].iter_mut().zip(self.p[..self.rows].iter().rev()) {
for (q, f) in to.iter_mut().zip(from).take(self.cols) {
*q = Point::new(f.x, h - f.y);
}
}
out
}
/// Rows and columns exchanged, and x with y: a net made on the box turned on its side.
fn transposed(self) -> Self {
let mut out = Self { rows: self.cols, cols: self.rows, p: [[Point::ZERO; 4]; 4] };
for (r, row) in self.p[..self.rows].iter().enumerate() {
for (c, q) in row[..self.cols].iter().enumerate() {
out.p[c][r] = Point::new(q.y, q.x);
}
}
out
}
/// Each column scaled about the midpoint of its end points by `1 + a (2t - 1)`, `t` running from
/// 0 at the left column to 1 at the right: a horizontal distortion `a` (-1..1).
fn distort_columns(&mut self, a: f64) {
let (rows, cols) = (self.rows, self.cols);
for c in 0..cols {
let s = 1.0 + a * (2.0 * c as f64 / (cols - 1) as f64 - 1.0);
let mid = half_way(self.p[0][c], self.p[rows - 1][c]);
for row in &mut self.p[..rows] {
row[c] = mid + (row[c] - mid) * s;
}
}
}
/// Each row scaled about the midpoint of its end points by `1 + a (2t - 1)`, `t` running from 0
/// at the top row to 1 at the bottom: a vertical distortion `a` (-1..1).
fn distort_rows(&mut self, a: f64) {
let (rows, cols) = (self.rows, self.cols);
for (r, row) in self.p[..rows].iter_mut().enumerate() {
let s = 1.0 + a * (2.0 * r as f64 / (rows - 1) as f64 - 1.0);
let mid = half_way(row[0], row[cols - 1]);
for q in &mut row[..cols] {
*q = mid + (*q - mid) * s;
}
}
}
/// The same patch as a bicubic net (degree elevation, which leaves the surface as it is).
fn bicubic(self) -> [[Point; 4]; 4] {
let rows: Vec<[Point; 4]> = self.p[..self.rows].iter().map(|row| cubic_line(&row[..self.cols])).collect();
let mut out = [[Point::ZERO; 4]; 4];
for c in 0..4 {
let col: Vec<Point> = rows.iter().map(|row| row[c]).collect();
for (to, q) in out.iter_mut().zip(cubic_line(&col)) {
to[c] = q;
}
}
out
}
}
/// The point half way from `a` to `b`, as halves added: two finite points always give a finite one.
fn half_way(a: Point, b: Point) -> Point {
Point::new(0.5 * a.x + 0.5 * b.x, 0.5 * a.y + 0.5 * b.y)
}
/// A Bézier curve of 2 to 4 control points as the 4 of the same curve's cubic form.
fn cubic_line(p: &[Point]) -> [Point; 4] {
match *p {
[a, b] => [a, a.lerp(b, 1.0 / 3.0), a.lerp(b, 2.0 / 3.0), b],
[a, b, c] => [a, a.lerp(b, 2.0 / 3.0), c.lerp(b, 2.0 / 3.0), c],
[a, b, c, d] => [a, b, c, d],
_ => [Point::ZERO; 4],
}
}
/// The handle offsets (along the chord, across it) of a cubic circular arc over a chord `chord`
/// long that turns through θ = |`b`| × 180°: each handle is 4/3 tan(θ/4) of the radius long, along
/// the arc's end tangent. With the radius `chord / (2 sin(θ/2))` that length is
/// `chord / (3 cos²(θ/4))`, which a bend near 0 leaves at a third of the chord.
fn arc_handles(chord: f64, b: f64) -> (f64, f64) {
let th = b.abs().min(1.0) * PI;
let len = chord / (3.0 * (th / 4.0).cos().powi(2));
(len * (th / 2.0).cos(), len * (th / 2.0).sin())
}
/// A row from (0, `y`) to (`w`, `y`) bent into a circular arc of |`b`| × 180°: up for a positive
/// `b` when `up`, down when not, the other way for a negative one.
fn arc_row(w: f64, y: f64, b: f64, up: bool) -> [Point; 4] {
let (ax, ay) = arc_handles(w, b);
let dy = if (b > 0.0) == up { -ay } else { ay };
[Point::new(0.0, y), Point::new(ax, y + dy), Point::new(w - ax, y + dy), Point::new(w, y)]
}
/// Arc at bend |`b`| as four rows: the bottom edge bends up through the bottom corners, the top
/// edge is the arc around the same center `h` further out, and the rows between are spaced evenly
/// along the radii. The top corners lie `h` out from the bottom ones along the radii, which lean
/// out by θ/2.
fn arc_rows(w: f64, h: f64, b: f64) -> [[Point; 4]; 4] {
let th = b.abs().min(1.0) * PI;
let (s, c) = (th / 2.0).sin_cos();
let (tl, tr) = (Point::new(-h * s, h * (1.0 - c)), Point::new(w + h * s, h * (1.0 - c)));
let (ax, ay) = arc_handles(tr.x - tl.x, b);
let top = [tl, Point::new(tl.x + ax, tl.y - ay), Point::new(tr.x - ax, tr.y - ay), tr];
let bottom = arc_row(w, h, b.abs(), true);
let mut out = [[Point::ZERO; 4]; 4];
for (r, row) in out.iter_mut().enumerate() {
for (q, (t, u)) in row.iter_mut().zip(top.iter().zip(bottom)) {
*q = t.lerp(u, r as f64 / 3.0);
}
}
out
}
/// Warp style `style`'s own net at bend `b` (-1..1) over the box `w` × `h`, before distortion.
/// `vertical`: the net of the box turned on its side, where Rise moves the other half.
fn style_net(style: WarpStyle, b: f64, w: f64, h: f64, vertical: bool) -> Net {
use WarpStyle::*;
let two = |top: [Point; 4], bottom: [Point; 4]| {
let mut p = [[Point::ZERO; 4]; 4];
(p[0], p[1]) = (top, bottom);
Net { rows: 2, cols: 4, p }
};
let flat_row = |y: f64| [0.0, 1.0, 2.0, 3.0].map(|c| Point::new(w * c / 3.0, y));
match style {
Arc => {
let rows = arc_rows(w, h, b);
let net = two(rows[0], rows[3]);
if b < 0.0 { net.mirrored(h) } else { net }
}
ArcUpper => two(arc_row(w, 0.0, b, true), flat_row(h)),
ArcLower => two(flat_row(0.0), arc_row(w, h, b, false)),
Arch => {
let top = arc_row(w, 0.0, b, true);
two(top, top.map(|q| Point::new(q.x, q.y + h)))
}
Bulge => two(arc_row(w, 0.0, b, true), arc_row(w, h, b, false)),
ShellLower | ShellUpper => {
let a = arc_rows(w, h, b);
let mut net = Net::flat(w, h, 4, 4);
if b >= 0.0 {
// The outer arc and the ends of the row inside it, upside down for Shell Lower.
net.p[0] = a[0];
(net.p[1][0], net.p[1][3]) = (a[1][0], a[1][3]);
if style == ShellLower { net.mirrored(h) } else { net }
} else {
// The inner arc and the ends of the row outside it, upside down for Shell Upper.
net.p[3] = a[3];
(net.p[2][0], net.p[2][3]) = (a[2][0], a[2][3]);
if style == ShellUpper { net.mirrored(h) } else { net }
}
}
Flag | Fish | Rise => {
let mut net = Net::flat(w, h, 2, 4);
let d = 2.0 * b * h;
match style {
Flag => {
for row in &mut net.p[..2] {
(row[1].y, row[2].y) = (row[1].y + d, row[2].y - d);
}
}
Fish => {
(net.p[0][1].y, net.p[0][2].y) = (net.p[0][1].y - d, net.p[0][2].y + d);
(net.p[1][1].y, net.p[1][2].y) = (net.p[1][1].y + d, net.p[1][2].y - d);
}
_ => {
for row in &mut net.p[..2] {
if vertical {
(row[2].y, row[3].y) = (row[2].y - d, row[3].y - d);
} else {
(row[0].y, row[1].y) = (row[0].y + d, row[1].y + d);
}
}
}
}
net
}
Wave => {
let mut net = Net::flat(w, h, 3, 4);
let d = 2.0 * b * h;
(net.p[1][1].y, net.p[1][2].y) = (net.p[1][1].y + d, net.p[1][2].y - d);
net
}
Fisheye => {
let mut net = Net::flat(w, h, 4, 4);
let c = Point::new(w / 2.0, h / 2.0);
for row in &mut net.p[1..3] {
for q in &mut row[1..3] {
*q = c + (*q - c) * (1.0 + 4.0 * b);
}
}
net
}
Inflate | Squeeze => {
let mut net = Net::flat(w, h, 3, 3);
let side = if style == Inflate { b * w / 2.0 } else { -b * w / 2.0 };
net.p[0][1].y -= b * h / 2.0;
net.p[2][1].y += b * h / 2.0;
net.p[1][0].x -= side;
net.p[1][2].x += side;
net
}
Twist => {
// The four inner points move round: clockwise for a positive bend.
let mut net = Net::flat(w, h, 4, 4);
let (dx, dy) = (b.abs() * w, b.abs() * h);
if b >= 0.0 {
net.p[1][1].x += dx;
net.p[1][2].y += dy;
net.p[2][2].x -= dx;
net.p[2][1].y -= dy;
} else {
net.p[1][1].y += dy;
net.p[1][2].x -= dx;
net.p[2][2].y -= dy;
net.p[2][1].x += dx;
}
net
}
}
}
/// A warp as one bicubic Bézier patch over its box: the style's own net at the bend, its columns
/// scaled by the horizontal distortion and then its rows by the vertical one. Points are in the
/// box's coordinates (origin at its top left, y down).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct WarpNet {
/// The control points over the box divided by `scale`.
net: [[Point; 4]; 4],
/// 1, or a power of two when the net over the box itself does not fit in finite numbers.
scale: f64,
w: f64,
h: f64,
}
impl WarpNet {
/// The net of `style` over a box `w` × `h` at bend `b` and distortions `dh` and `dv` (each
/// -1..1, clamped); `vertical` bends along the box's height.
pub fn new(style: WarpStyle, b: f64, dh: f64, dv: f64, w: f64, h: f64, vertical: bool) -> Self {
let unit = |x: f64| if x.is_finite() { x.clamp(-1.0, 1.0) } else { 0.0 };
let size = |x: f64| if x.is_finite() { x.max(0.0) } else { 0.0 };
let (b, dh, dv, w, h) = (unit(b), unit(dh), unit(dv), size(w), size(h));
let build = |w: f64, h: f64| {
let mut net = if vertical { style_net(style, b, h, w, true).transposed() } else { style_net(style, b, w, h, false) };
net.distort_columns(dh);
net.distort_rows(dv);
net.bicubic()
};
// A box near the largest finite size can overflow the net. The net is then built on the box
// divided by the smallest power of two that fits (2 to 4096), an exact division for every
// side above the subnormal range, and points are multiplied back as they are read.
let mut out = Self { net: build(w, h), scale: 1.0, w, h };
while out.scale < 4096.0 && !out.net.iter().flatten().all(|q| q.is_finite()) {
let scale = out.scale * 2.0;
out = Self { net: build(w / scale, h / scale), scale, w, h };
}
out
}
/// The point at `(u, v)` of the box (0..1 across and down; outside, the patch goes on). A
/// coordinate the patch would send past the largest finite number is the box's own, held to
/// the finite range.
pub fn at(&self, u: f64, v: f64) -> Point {
let p = self.at_scaled(u, v);
let held = |x: f64| if x.is_nan() { 0.0 } else { x.clamp(-f64::MAX, f64::MAX) };
let coord = |x: f64, flat: f64| if (x * self.scale).is_finite() { x * self.scale } else { held(flat) };
Point::new(coord(p.x, u * self.w), coord(p.y, v * self.h))
}
/// [`Self::at`] divided by the net's scale.
fn at_scaled(&self, u: f64, v: f64) -> Point {
let bern = |t: f64| {
let s = 1.0 - t;
[s * s * s, 3.0 * t * s * s, 3.0 * t * t * s, t * t * t]
};
let (bu, bv) = (bern(u), bern(v));
let (mut x, mut y) = (0.0, 0.0);
for (row, wv) in self.net.iter().zip(bv) {
for (q, wu) in row.iter().zip(bu) {
x += wv * wu * q.x;
y += wv * wu * q.y;
}
}
Point::new(x, y)
}
}
/// Segment as a cubic; straight lines get handles at 1/3 and 2/3 so a non-linear map bends them.
fn seg_cubic(sp: &SubPath, i: usize) -> CubicBez {
let c = sp.segment(i);
+48
View File
@@ -180,6 +180,24 @@ impl ObjectsOnPath {
});
Some((spacing, start))
}
/// Move the object `member` to the place on the path of the object `target`: the objects
/// between them each move one place toward where `member` was, except the objects for which
/// `fixed` is true, which keep their places and are passed over. Only the order changes, not the
/// Space or the start. Returns `member`'s new index, or `None` when either one is not an object
/// of the group.
pub fn move_member(&mut self, member: NodeId, target: NodeId, fixed: impl Fn(NodeId) -> bool) -> Option<usize> {
let moves = |id: NodeId| id == member || id == target || !fixed(id);
let slots: Vec<usize> = (0..self.members.len()).filter(|&i| moves(self.members[i].id)).collect();
let from = slots.iter().position(|&i| self.members[i].id == member)?;
let to = slots.iter().position(|&i| self.members[i].id == target)?;
let mut moving: Vec<_> = slots.iter().map(|&i| self.members[i]).collect();
let m = moving.remove(from);
moving.insert(to, m);
for (&i, m) in slots.iter().zip(moving) {
self.members[i] = m;
}
Some(slots[to])
}
/// The children given new ids (a copy of the group): the path and the objects by their new ids.
pub fn rename(&mut self, ids: &HashMap<NodeId, NodeId>) {
let to = |id: NodeId| ids.get(&id).copied().unwrap_or(id);
@@ -487,6 +505,36 @@ mod tests {
assert_eq!(layout(400.0, true, 4, Some(300.0), 400.0), (0.0, 100.0));
}
#[test]
fn moving_an_object_shifts_the_ones_between_it_and_its_new_place() {
let (a, b, c) =
(rect(2, Rect::new(0.0, 0.0, 10.0, 10.0)), rect(3, Rect::new(20.0, 0.0, 30.0, 10.0)), rect(4, Rect::new(40.0, 0.0, 50.0, 10.0)));
let rec = ObjectsOnPath { spacing: Some(30.0), start: 5.0, ..ObjectsOnPath::new(NodeId(1), &[&a, &b, &c], CENTER, 15.0) };
let order = |r: &ObjectsOnPath| r.members.iter().map(|m| m.id.0).collect::<Vec<_>>();
let free = |_: NodeId| false;
let mut fwd = rec.clone();
assert_eq!(fwd.move_member(NodeId(2), NodeId(4), free), Some(2));
assert_eq!(order(&fwd), [3, 4, 2], "the first to the last place");
assert_eq!((fwd.spacing, fwd.start, fwd.pivot, fwd.rotate), (rec.spacing, rec.start, rec.pivot, rec.rotate));
let mut back = rec.clone();
assert_eq!(back.move_member(NodeId(4), NodeId(2), free), Some(0));
assert_eq!(order(&back), [4, 2, 3], "the last to the first place");
let mut same = rec.clone();
assert_eq!(same.move_member(NodeId(3), NodeId(3), free), Some(1));
assert_eq!(same, rec, "onto its own place");
let mut other = rec.clone();
assert_eq!(other.move_member(NodeId(1), NodeId(3), free), None, "the path is not one of the objects");
assert_eq!(other.move_member(NodeId(3), NodeId(9), free), None);
assert_eq!(other, rec);
// A fixed object between them keeps its place; the others pass over it.
let mut over = rec.clone();
assert_eq!(over.move_member(NodeId(2), NodeId(4), |id| id == NodeId(3)), Some(2));
assert_eq!(order(&over), [4, 3, 2], "the first and last trade places round the fixed one");
let mut back_over = rec.clone();
assert_eq!(back_over.move_member(NodeId(4), NodeId(2), |id| id == NodeId(3)), Some(0));
assert_eq!(order(&back_over), [4, 3, 2]);
}
#[test]
fn a_group_saved_without_space_reads_as_auto() {
let a = rect(2, Rect::new(0.0, 0.0, 10.0, 10.0));
+31
View File
@@ -59,6 +59,11 @@ pub struct Selection {
/// that object ([`crate::symbol_overrides`]). Any other selection change clears it.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub symbol_part: Option<SymbolPart>,
/// An object of an Objects on Path group, chosen with its Select/Move widget: the group is the
/// one selected object, and the object is one of its objects on the path
/// ([`crate::objects_on_path::ObjectsOnPath::members`]). Any other selection change clears it.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub on_path_member: Option<NodeId>,
}
/// See [`Selection::symbol_part`].
@@ -94,6 +99,13 @@ impl Selection {
self.guides.clear();
self.key_guide = None;
self.symbol_part = None;
self.on_path_member = None;
}
/// Select only the Objects on Path group `group`, with its object `member` (see
/// [`Selection::on_path_member`]).
pub fn set_on_path_member(&mut self, group: NodeId, member: NodeId) {
self.set([group]);
self.on_path_member = Some(member);
}
/// Select only instance `instance`, with the object at `path` of its symbol's art (see
/// [`Selection::symbol_part`]).
@@ -115,6 +127,7 @@ impl Selection {
self.target = None;
self.slices.clear();
self.symbol_part = None;
self.on_path_member = None;
if !self.objects.contains(&id) {
self.objects.push(id);
}
@@ -123,6 +136,7 @@ impl Selection {
self.target = None;
self.slices.clear();
self.symbol_part = None;
self.on_path_member = None;
self.objects.retain(|x| *x != id);
self.anchors.remove(&id);
self.segments.remove(&id);
@@ -152,6 +166,7 @@ impl Selection {
/// Shift-click on a guide).
pub fn toggle_guide(&mut self, i: NodeId) {
self.symbol_part = None;
self.on_path_member = None;
if let Some(k) = self.guides.iter().position(|g| *g == i) {
self.guides.remove(k);
if self.key_guide == Some(i) {
@@ -258,6 +273,22 @@ impl Selection {
if !part_kept {
self.symbol_part = None;
}
// A chosen object on a path needs its Objects on Path group selected alone, with no anchors
// or guides, and still one of the group's objects, neither hidden nor locked.
let member_kept = self.on_path_member.is_some_and(|m| {
let [g] = self.objects.as_slice() else { return false };
self.anchors.is_empty()
&& self.guides.is_empty()
&& doc.is_editable(m)
&& found
.get(g)
.and_then(|p| doc.node_at(p))
.and_then(|n| n.extras().objects_on_path.as_deref().filter(|_| crate::objects_on_path::is_objects_on_path(n)))
.is_some_and(|rec| rec.members.iter().any(|x| x.id == m))
});
if !member_kept {
self.on_path_member = None;
}
}
/// Deselect the objects that are hidden or locked, themselves or through a group or layer
/// around them (and so the key object when it is one): hidden or locked art can't stay
+43
View File
@@ -179,6 +179,49 @@ fn selection_changes_clear_the_target() {
assert_eq!(s.target, None);
}
#[test]
fn a_chosen_object_on_a_path_needs_its_group_selected_alone() {
use vectorcraft_geom::{Point, Rect, shapes};
let mut d = Document::new(200.0, 200.0);
let l = d.layers[0].id;
let (line, a, b, g, other) = (d.alloc_id(), d.alloc_id(), d.alloc_id(), d.alloc_id(), d.alloc_id());
let line = Node::path(line, shapes::line(Point::new(0.0, 100.0), Point::new(200.0, 100.0)), Default::default());
let a = Node::path(a, shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Default::default());
let b = Node::path(b, shapes::rectangle(Rect::new(20.0, 0.0, 30.0, 10.0)), Default::default());
let rec = crate::objects_on_path::ObjectsOnPath::new(line.id, &[&a, &b], crate::objects_on_path::CENTER, 0.0);
let (line_id, a_id) = (line.id, a.id);
let mut group = Node::new(g, NodeKind::Group { children: vec![Arc::new(line), Arc::new(a), Arc::new(b)], clip: false });
group.extras_mut().objects_on_path = Some(Box::new(rec));
d.insert(Some(l), 0, group).unwrap();
d.insert(Some(l), 1, Node::path(other, shapes::rectangle(Rect::new(150.0, 0.0, 160.0, 10.0)), Default::default())).unwrap();
let mut s = Selection::default();
s.set_on_path_member(g, a_id);
s.prune(&d);
assert_eq!((s.objects.as_slice(), s.on_path_member), (&[g][..], Some(a_id)));
s.add(other);
assert_eq!(s.on_path_member, None, "another object joins the selection");
s.set_on_path_member(g, a_id);
s.set([g]);
assert_eq!(s.on_path_member, None, "a new selection");
// The path is not one of the objects, nor is an object outside the group.
for m in [line_id, other] {
s.set_on_path_member(g, m);
s.prune(&d);
assert_eq!(s.on_path_member, None, "{m:?}");
}
// A locked object is not chosen.
s.set_on_path_member(g, a_id);
d.node_mut(a_id).unwrap().locked = true;
s.prune(&d);
assert_eq!((s.objects.as_slice(), s.on_path_member), (&[g][..], None), "locked");
d.node_mut(a_id).unwrap().locked = false;
// Once the group is a plain group, no object of it is chosen.
s.set_on_path_member(g, a_id);
d.node_mut(g).unwrap().extras_mut().objects_on_path = None;
s.prune(&d);
assert_eq!((s.objects.as_slice(), s.on_path_member), (&[g][..], None));
}
#[test]
fn a_key_object_needs_two_or_more_selected_objects() {
let mut s = Selection::default();
+26 -2
View File
@@ -194,8 +194,14 @@ fn round(h: &str, width: f64) -> StrokeLayer {
StrokeLayer { cap: LineCap::Round, join: LineJoin::Round, ..stroke(h, width) }
}
/// Live effect `id` with `params` (the others keep the effect's defaults).
fn fx(id: &str, params: Value) -> Effect {
/// Live effect `id` with `params` (the others keep the effect's defaults). A Warp draws with its
/// style's Bézier net, as a new Warp does.
fn fx(id: &str, mut params: Value) -> Effect {
if id.starts_with("warp.")
&& let Value::Object(m) = &mut params
{
m.entry("version").or_insert(json!(crate::live::WARP_NET));
}
Effect { id: id.into(), params, visible: true }
}
@@ -657,6 +663,24 @@ mod tests {
assert_eq!(ids.iter().position(|&i| i == "textures"), ids.iter().position(|&i| i == "hand-drawn").map(|i| i + 1), "after Hand-Drawn");
}
/// The built-in styles' Warps draw with the map a new Warp takes.
#[test]
fn builtin_warp_styles_take_the_nets_map() {
let mut warps = 0;
for b in STYLE_LIBRARIES {
let lib = builtin_style_library(b.id).unwrap();
for g in &lib.styles {
let mut effects: Vec<&Effect> = g.appearance.effects.iter().collect();
effects.extend(g.appearance.items.iter().flat_map(|i| i.effects()));
for e in effects.into_iter().filter(|e| e.id.starts_with("warp.")) {
assert_eq!(e.params["version"], json!(crate::live::WARP_NET), "{} › {}: {}", b.id, g.name, e.id);
warps += 1;
}
}
}
assert!(warps >= 3, "{warps}");
}
#[test]
fn painted_and_sketched_follows_textures_with_one_effect_per_style() {
let ids: Vec<&str> = STYLE_LIBRARIES.iter().map(|b| b.id).collect();
+1 -1
View File
@@ -116,7 +116,7 @@ fn lengths_of(id: &str) -> Lengths {
}
}
const WARP_DOC: &str = "{bend: % (-100..100, 50; with a bend or a distortion, placed gradients move and scale from the object's bounds to its warped bounds), horizontal: % distortion (0), vertical: % distortion (0), orientation: \"horizontal\"|\"vertical\"}";
const WARP_DOC: &str = "{bend: % (-100..100, 50; with a bend or a distortion, placed gradients move and scale from the object's bounds to its warped bounds, and images bend as 10 × 10 cells of two triangles unless the pieces would make the art pass 2,000,000 objects or the image's frame keeps its shape past the anchor budget), horizontal: % distortion (0), vertical: % distortion (0), orientation: \"horizontal\"|\"vertical\", version: 0|1 (the map: 1 bends each style as one Bézier patch over the bounds, which new and imported warps get; 0, or none, is VectorCraft's earlier map, which warps saved without a version keep)}";
const DT: &[&str] = &["Effect", "Distort & Transform"];
+1 -1
View File
@@ -96,7 +96,7 @@ pub use stylize::{ScribbleSetting, scribble_setting_id, scribble_settings};
pub use svg_filter::SVG_FILTER;
pub use trap::TRAP;
pub use vectorcraft_three_d::Mesh;
pub use warp::{WarpStyle, warp_point};
pub use warp::{WARP_NET, WarpNet, WarpStyle, map_version, warp_point, warp_version};
mod catalog;
mod geometry;
+25 -2
View File
@@ -31,7 +31,8 @@ pub fn merged_params(id: &str, params: &Value) -> Value {
/// (`lightRotation`, `lightHeight`, `lightBehind`). Scribble took one `variation` before its
/// separate `overlapVariation` and `spacingVariation`. Earlier values (from a file or a script of
/// then) become the current ones that show exactly the same, unless those are given too, which win.
/// Scribble's angle is also stored above -180° and up to 180° (270° becomes -90°).
/// Scribble's angle is also stored above -180° and up to 180° (270° becomes -90°), and a Warp's
/// map `version` given as a whole float is stored as an integer.
pub fn upgrade_params(id: &str, params: &Value) -> Value {
match params {
Value::Object(m) => {
@@ -39,6 +40,7 @@ pub fn upgrade_params(id: &str, params: &Value) -> Value {
upgrade_perspective(id, &mut m);
upgrade_light(id, &mut m);
upgrade_scribble(id, &mut m);
upgrade_warp_version(id, &mut m);
Value::Object(m)
}
other => other.clone(),
@@ -71,6 +73,19 @@ fn upgrade_perspective(id: &str, m: &mut Map<String, Value>) {
}
}
/// A Warp's map `version` given as a whole float (`1.0`) is stored as the integer.
fn upgrade_warp_version(id: &str, m: &mut Map<String, Value>) {
if !id.starts_with("warp.") {
return;
}
if let Some(v) = m.get_mut("version")
&& !v.is_u64()
&& let Some(n) = crate::warp::warp_version(v)
{
*v = json!(n);
}
}
fn upgrade_scribble(id: &str, m: &mut Map<String, Value>) {
if id != "stylize.scribble" {
return;
@@ -91,7 +106,15 @@ pub fn new_effect(id: &str, params: &Value) -> Option<Effect> {
if !catalog_index().contains_key(id) {
vectorcraft_plugins::effect::installed(id)?;
}
Some(Effect { id: id.to_string(), params: merged_params(id, params), visible: true })
let mut params = merged_params(id, params);
// A new Warp takes its style's Bézier net unless a map is given; the catalog's defaults carry
// no version, so warps saved without one keep the earlier map.
if id.starts_with("warp.")
&& let Value::Object(m) = &mut params
{
m.entry("version").or_insert(json!(crate::warp::WARP_NET));
}
Some(Effect { id: id.to_string(), params, visible: true })
}
/// Scale the distance parameters of `e` by `s` (Scale Strokes & Effects; see
+280 -16
View File
@@ -4,19 +4,22 @@
//! Geometry effects reach them through outlines: [`outline_art`] turns the object into plain paths
//! (glyph outlines, the evaluated live object, the symbol's art) and [`reshape`] runs each effect
//! over all of them as one piece, with the whole art's bounds as the effect's reference box, so a
//! warp bends a line of type as a whole. An image is clipped by its reshaped frame. Raster effects
//! (shadows, glows, blur, feather) stay on the result for the renderer and exporters. Type without
//! warp bends a line of type as a whole. An image is clipped by its reshaped frame, and a Warp
//! effect bends its pixels with the frame ([`cut_warped_images`]). Raster effects (shadows, glows, blur,
//! feather) stay on the result for the renderer and exporters. Type without
//! inline graphics whose own fills or strokes have geometry effects is outlined too: each of those
//! effects reshapes the whole outline that its fill or stroke paints. An image's own fills and
//! strokes paint only the shape that a Convert to Shape or Outline Object effect on them gives
//! them ([`image_rows`]).
use std::collections::HashSet;
use std::rc::Rc;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use vectorcraft_doc::live::Hooks;
use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, Node, NodeId, NodeKind};
use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Rect, Shape, shapes};
use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, ImageObject, Node, NodeId, NodeKind};
use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Shape, shapes};
use crate::{Budget, GeomContext, OutlineHook, apply_one, is_geometry, merged_params};
@@ -548,7 +551,14 @@ fn as_art_opts(
let mut art = match &n.kind {
NodeKind::Image(im) => {
let frame = shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf);
let image = Node::new(n.id, n.kind.clone());
let mut image = Node::new(n.id, n.kind.clone());
// Its pixels draw as the image's do: colorized by a grayscale image's fill color, and
// smoothed or not.
{
let mut e = image.extras_mut();
e.colorize = n.extras().colorize.clone();
e.pixelated = n.extras().pixelated;
}
let clipped = || {
let mut clip = Node::path(n.id, frame.clone(), Appearance::default());
if let NodeKind::Path { clipping, .. } = &mut clip.kind {
@@ -632,9 +642,9 @@ pub(crate) fn geometry_effects(n: &Node) -> Vec<&Effect> {
/// Apply `fx` to every path under `art` as one piece: each effect takes the whole art's bounds as
/// its reference box and the art's seed (a random Transform moves the pieces together). Images and
/// symbol instances follow a Transform effect the same way ([`transform_placed`]); other geometry
/// effects leave them as they are (a raster follows a non-affine map only as a mesh warp). The
/// paths keep to one [`Budget::EFFECTS`] together (or to what they cost, when that is more): a path
/// symbol instances follow a Transform effect the same way ([`transform_placed`]), and images
/// follow a Warp effect as a raster mesh warp ([`cut_warped_images`]); other geometry effects leave them
/// as they are. The paths keep to one [`Budget::EFFECTS`] together (or to what they cost, when that is more): a path
/// whose effect would pass what the others leave of it keeps its shape. The swatches and patterns
/// that live-effect plug-ins painting their pieces name are looked up in `doc`, and a deferred one
/// is listed by its index in `owner`, the effect list `fx` was taken from ([`reshape_leaves_apart`]).
@@ -705,8 +715,9 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
let max = budget.at_least(used);
// Read before the effects run: a path's own copies don't make it art of several objects.
let copy_whole = copies_whole(art);
let mut warped = WarpedImages::new();
for e in fx {
let Some(bounds) = art.geometric_bounds() else { break };
let Some(bounds) = warped.bounds(art) else { break };
let params = merged_params(&e.id, &e.params);
// Where a live-effect plug-in sits, which it is listed by when it is deferred.
let effect = owner.iter().position(|x| std::ptr::eq(x, *e)).or_else(|| listed.iter().position(|x| std::ptr::eq(*x, *e)));
@@ -739,10 +750,21 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
}
let mut groups = vec![];
if follows {
group_marks(art, &mut vec![], &HashSet::new(), &mut groups);
group_marks(art, &mut vec![], &HashSet::new(), None, &mut groups);
// The images earlier Warps bend are measured by their pieces only when a group's
// gradient needs the bounds.
if !groups.is_empty()
&& let Some(images) = warped.when_cut(art)
{
groups.clear();
group_marks(art, &mut vec![], &HashSet::new(), Some(images), &mut groups);
}
}
// The ids of the paths that kept their shape (past the budget).
// The ids of the paths that kept their shape (past the budget), and their places in the
// order [`for_each_leaf`] visits the paths.
let mut kept_ids = HashSet::new();
let mut kept_leaves = HashSet::new();
let mut leaf_at = 0usize;
let transform = (e.id == "distort.transform").then(|| {
let (m, copies) = crate::distort::transform_map(bounds, &params, seed);
let options = crate::distort::TransformOptions::of(&params);
@@ -757,6 +779,8 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
continue;
}
for_each_leaf(art, &mut |leaf| {
let at = leaf_at;
leaf_at += 1;
let Some((path, rule)) = leaf_geometry(leaf) else { return };
// What the other paths leave of the budget.
let before = Budget::of(&path);
@@ -789,6 +813,7 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
let stage = effect.map(|effect| vectorcraft_plugins::deferred::Stage { object: seed, effect, item: None });
let Some(out) = apply_one(&e.id, &params, &path, bounds, &GeomContext { seed, stage, ..GeomContext::of(leaf) }, room) else {
kept_ids.insert(leaf.id);
kept_leaves.insert(at);
return;
};
used = used.minus(before).plus(Budget::of(&out));
@@ -804,6 +829,16 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
if boxes {
rebase_leaves(art, &mut leaves.into_iter());
}
// Warp bends images too: each one's pixels follow the warp's map over the same box. The
// images are cut into pieces once, after the last effect ([`cut_warped_images`]). An image
// whose clipping frame kept its shape (past the budget) keeps its pixels as they are.
if let Some(style) = e.id.strip_prefix("warp.").and_then(crate::warp::WarpStyle::from_id)
&& crate::warp::bends(&e.id, &params)
{
let f: WarpMap = Rc::from(crate::warp::warp_map(bounds, style, &params));
warped.reserve(art);
mark_warped_images(art, &f, &kept_leaves, false, &mut 0, &mut warped);
}
if let Some((m, copies, options, _)) = transform
&& options.objects
{
@@ -816,14 +851,16 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
// follow their bounds under Free Distort and Warp (they stay when no path changed them).
// Each stays when a path under it that its bounds measure kept its shape (past the budget).
let mut after = vec![];
let held = (!groups.is_empty() || !kept_ids.is_empty()) && group_marks(art, &mut vec![], &kept_ids, &mut after).1;
let images = if groups.is_empty() { None } else { warped.when_cut(art) };
let held = (!groups.is_empty() || !kept_ids.is_empty()) && group_marks(art, &mut vec![], &kept_ids, images, &mut after).1;
if !groups.is_empty() {
carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, &params, bounds, from, to, seed));
}
if follows && !held {
whole.push(crate::Carry::of(&e.id, &params, bounds, Some(bounds), art.geometric_bounds(), seed));
whole.push(crate::Carry::of(&e.id, &params, bounds, Some(bounds), warped.bounds(art), seed));
}
}
cut_warped_images(art, &warped);
whole
}
@@ -1445,17 +1482,25 @@ type GroupMark = (Vec<usize>, Option<Rect>, bool);
/// The geometric bounds of `n` (as [`Node::geometric_bounds`] gives them) and whether a path or
/// compound path below it that those bounds measure is in `kept`, measured in one walk. Each group below `n` that
/// [`GroupMark`] describes goes into `out`, reached from `n` through `at`.
fn group_marks(n: &Node, at: &mut Vec<usize>, kept: &HashSet<NodeId>, out: &mut Vec<GroupMark>) -> (Option<Rect>, bool) {
/// [`GroupMark`] describes goes into `out`, reached from `n` through `at`. An image that `images`
/// lists is measured by the pieces it will be cut into ([`WarpedImages::image_bounds`]).
fn group_marks(
n: &Node,
at: &mut Vec<usize>,
kept: &HashSet<NodeId>,
images: Option<&WarpedImages>,
out: &mut Vec<GroupMark>,
) -> (Option<Rect>, bool) {
match &n.kind {
NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => (n.geometric_bounds(), kept.contains(&n.id)),
NodeKind::Image(_) => (images.map_or_else(|| n.geometric_bounds(), |w| w.image_bounds(n)), false),
NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } if !n.extras().type_outlines => {
let layer = matches!(n.kind, NodeKind::Layer { .. });
let skip = children.len().saturating_sub(n.editing_children().len());
let (mut bounds, mut held) = (None, false);
for (i, c) in children.iter().enumerate() {
at.push(i);
let (b, h) = group_marks(c, at, kept, out);
let (b, h) = group_marks(c, at, kept, images, out);
if is_member_group(c) && (c.appearance.has_positioned_gradient() || c.appearance.has_unplaced_gradient()) {
out.push((at.clone(), b, h));
}
@@ -1590,6 +1635,225 @@ pub(crate) fn transform_placed_within(n: &mut Node, m: Affine, copies: usize, ma
copy_placed(n, m, copies, &mut room);
}
/// Rows and columns of the pieces a Warp effect cuts an image into (VectorCraft's own number).
pub(crate) const WARP_IMAGE_CELLS: usize = 10;
/// A Warp effect's point map, shared by the images it bends.
pub(crate) type WarpMap = Rc<dyn Fn(Point) -> Point>;
/// One image a Warp effect bent: the image's own key, and each warp it took with the placement
/// the image had when it took it, in order.
type WarpedImage = (String, Vec<(WarpMap, Affine)>);
/// The images Warp effects bend while [`reshape_leaves_apart`] runs the effects. Each such image's
/// key is replaced by a key of this table ([`WarpedImages::add`]), which a copy a later Transform
/// effect makes keeps. The images are cut into pieces once, after the last effect
/// ([`cut_warped_images`]): the effects after a Warp reshape the image's frame, not each piece,
/// and a later Warp or Transform moves the one set of pieces.
pub(crate) struct WarpedImages {
/// What this table's keys start with: no image key in the art starts with it
/// ([`WarpedImages::reserve`]).
prefix: String,
/// The prefix was checked against the art's image keys.
reserved: bool,
images: Vec<WarpedImage>,
}
impl WarpedImages {
pub(crate) fn new() -> Self {
static TABLES: AtomicUsize = AtomicUsize::new(0);
Self { prefix: format!("\0warp{}:", TABLES.fetch_add(1, Ordering::Relaxed)), reserved: false, images: vec![] }
}
/// Before the first image of `art` is marked: lengthen the prefix until no image key in `art`
/// starts with it, so no key from the document is read as one of this table's.
pub(crate) fn reserve(&mut self, art: &Node) {
if self.reserved {
return;
}
self.reserved = true;
let mut keys = vec![];
art.walk(&mut |c| {
if let NodeKind::Image(im) = &c.kind {
keys.push(im.key.clone());
}
});
while keys.iter().any(|k| k.starts_with(self.prefix.as_str())) {
self.prefix.push(':');
}
}
/// What this table's keys start with.
#[cfg(test)]
pub(crate) fn prefix(&self) -> &str {
&self.prefix
}
/// The image that `key`, a key of this table, stands for.
fn get(&self, key: &str) -> Option<&WarpedImage> {
self.images.get(key.strip_prefix(self.prefix.as_str())?.parse::<usize>().ok()?)
}
/// Record that the image with key `key`, placed by `xf`, takes warp `f`; returns the image's
/// new key.
fn add(&mut self, key: &str, xf: Affine, f: &WarpMap) -> String {
let (own, mut warps) = self.get(key).cloned().unwrap_or_else(|| (key.to_string(), vec![]));
warps.push((f.clone(), xf));
self.images.push((own, warps));
format!("{}{}", self.prefix, self.images.len() - 1)
}
/// Does the art `n` have room, within `max` nodes, for the pieces of every image under it that
/// this table lists?
fn fits(&self, n: &Node, max: usize) -> bool {
let mut count = 0usize;
n.walk(&mut |c| {
if let NodeKind::Image(im) = &c.kind
&& self.get(&im.key).is_some()
{
count += 1;
}
});
vectorcraft_doc::live::mesh_warp_cost(WARP_IMAGE_CELLS).saturating_mul(count) <= max.saturating_sub(n.count())
}
/// The geometric bounds of `art` as it draws after the effects so far: each image this table
/// lists measured by the pieces the warps and moves it took would cut it into, when the art
/// has room for them ([`cut_warped_images`]).
pub(crate) fn bounds(&self, art: &Node) -> Option<Rect> {
if self.images.is_empty() || !self.fits(art, crate::distort::MAX_COPY_OBJECTS) {
return art.geometric_bounds();
}
// The pieces the images would be cut into now: each group of pieces is shown or hidden as
// its image is, and hidden objects are left out of a layer's bounds.
let mut probe = art.clone();
restore_warped_images(&mut probe, self, true);
probe.geometric_bounds()
}
/// The geometric bounds of image `n`: when this table lists it, measured by the pieces the
/// warps and moves it took would cut it into.
fn image_bounds(&self, n: &Node) -> Option<Rect> {
let NodeKind::Image(im) = &n.kind else { return n.geometric_bounds() };
if self.get(&im.key).is_none() {
return n.geometric_bounds();
}
let mut probe = Node::group(n.id, vec![Arc::new(n.clone())]);
restore_warped_images(&mut probe, self, true);
probe.geometric_bounds()
}
/// This table when the art `art` has room for the pieces of the images it lists, so that a
/// measure of the art takes them bent ([`WarpedImages::bounds`]); `None` otherwise.
fn when_cut(&self, art: &Node) -> Option<&Self> {
(!self.images.is_empty() && self.fits(art, crate::distort::MAX_COPY_OBJECTS)).then_some(self)
}
}
/// Record in `warped` that each image under `n` takes warp `f`, walking the groups and layers
/// [`for_each_leaf`] walks and counting the paths it passes in `at`. `kept` holds the places of
/// the paths that kept their shape (past the budget), in the order [`for_each_leaf`] visits the
/// paths of the art: an image in a clip group whose clipping art holds one (`held`) does not take
/// the warp.
pub(crate) fn mark_warped_images(n: &mut Node, f: &WarpMap, kept: &HashSet<usize>, held: bool, at: &mut usize, warped: &mut WarpedImages) {
let (NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. }) = &mut n.kind else { return };
let mut held = held;
// A clip group's first member is its clipping art: when a path in it kept its shape, it and
// the members it clips keep theirs.
if *clip && let Some(first) = children.first() {
let start = *at;
held |= (start..start + leaf_count(first)).any(|p| kept.contains(&p));
}
for c in children.iter_mut() {
match &c.kind {
NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => *at += 1,
NodeKind::Group { .. } | NodeKind::Layer { .. } => mark_warped_images(Arc::make_mut(c), f, kept, held, at, warped),
NodeKind::Image(_) if !held => {
if let NodeKind::Image(im) = &mut Arc::make_mut(c).kind {
im.key = warped.add(&im.key, im.xf, f);
}
}
_ => {}
}
}
}
/// Give each image under `n` that `warped` lists its own key back, and cut it into the pieces of
/// a raster mesh warp ([`vectorcraft_doc::live::mesh_warp_image`], each piece drawn as the image
/// is, smoothed or not) through the warps it took and the moves between and after them
/// ([`warped_map`]). The art keeps to [`crate::distort::MAX_COPY_OBJECTS`] nodes: when the pieces
/// would pass it, no image is cut. An image whose placement has no inverse is not cut either.
fn cut_warped_images(n: &mut Node, warped: &WarpedImages) {
cut_warped_images_within(n, warped, crate::distort::MAX_COPY_OBJECTS);
}
/// [`cut_warped_images`] with the art keeping to `max` nodes.
pub(crate) fn cut_warped_images_within(n: &mut Node, warped: &WarpedImages, max: usize) {
if warped.images.is_empty() {
return;
}
let cut = warped.fits(n, max);
restore_warped_images(n, warped, cut);
}
/// The walk of [`cut_warped_images`]: each listed image gets its key back, and with `cut` is cut
/// into pieces.
fn restore_warped_images(n: &mut Node, warped: &WarpedImages, cut: bool) {
let Some(children) = n.children_mut() else { return };
for c in children.iter_mut() {
let NodeKind::Image(im) = &c.kind else {
if c.children().is_some() {
restore_warped_images(Arc::make_mut(c), warped, cut);
}
continue;
};
let Some((key, warps)) = warped.get(&im.key) else { continue };
let mut image = (**c).clone();
let NodeKind::Image(own) = &mut image.kind else { continue };
own.key = key.clone();
// The pieces start from the image as it was placed when it took its first warp.
let first = warps.first().map(|(_, at)| ImageObject { xf: *at, ..(**own).clone() });
let map = warped_map(warps, own.xf);
*c = Arc::new(match (first, map) {
(Some(first), Some(map)) if cut => {
let pixelated = image.extras().pixelated;
vectorcraft_doc::live::mesh_warp_image(&image, &first, &*map, WARP_IMAGE_CELLS, pixelated, false)
}
_ => image,
});
}
}
/// The map that takes a point of an image placed by the first of `warps`' placements to where the
/// warps and the moves between them take it, for an image now placed by `placed`: each warp in
/// turn, then the move from the placement the image had when it took that warp to the one it had
/// at the next, or to `placed` after the last. `None` when a placement has no inverse.
fn warped_map(warps: &[(WarpMap, Affine)], placed: Affine) -> Option<Box<dyn Fn(Point) -> Point>> {
let mut steps: Vec<(WarpMap, Affine)> = Vec::with_capacity(warps.len());
for (i, (f, at)) in warps.iter().enumerate() {
let det = at.determinant();
if !det.is_finite() || det == 0.0 {
return None;
}
let next = warps.get(i + 1).map_or(placed, |(_, at)| *at);
let m = next * at.inverse();
if !m.is_finite() {
return None;
}
steps.push((f.clone(), m));
}
Some(Box::new(move |p| steps.iter().fold(p, |q, (f, m)| *m * f(q))))
}
/// How many paths [`for_each_leaf`] visits in `n`.
fn leaf_count(n: &Node) -> usize {
match &n.kind {
NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => 1,
NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => children.iter().map(|c| leaf_count(c)).sum(),
_ => 0,
}
}
/// An object that a Transform effect places through its transform rather than reshapes: an image
/// (pixel space to document) or a symbol instance (the symbol's art to document).
fn is_placed(n: &Node) -> bool {
+6 -6
View File
@@ -29,7 +29,7 @@ const MAX_PAINT_COPIES: usize = 256 << 20;
/// The most face and box tests a group's transparent members' faces take together to rejoin their
/// members' last runs; past them each starts a run of its own.
const MAX_OVERLAP_TESTS: usize = 1 << 22;
pub(crate) const MAX_OVERLAP_TESTS: usize = 1 << 22;
/// The width of the stroke around each face that covers the seams between faces.
const SEAM_WIDTH: f64 = 0.75;
@@ -628,14 +628,14 @@ pub(crate) fn scoped<'a>(id: NodeId, surfaces: Vec<(&'a [Scope], Arc<Node>)>, le
/// What a face can paint, to tell whether two faces overlap: the convex hull of the points and
/// control points of its outline, which holds the outline, and the hull's box grown by half the
/// seam stroke.
struct Coverage {
bounds: Rect,
pub(crate) struct Coverage {
pub(crate) bounds: Rect,
hull: Vec<Point>,
}
impl Coverage {
/// `None` for a face with no outline and no box.
fn of(face: &Node) -> Option<Coverage> {
pub(crate) fn of(face: &Node) -> Option<Coverage> {
let points: Vec<Point> = match face.path_data() {
Some(path) => path
.to_bezpath()
@@ -663,7 +663,7 @@ impl Coverage {
/// Do the two faces' hulls, each grown by half the seam stroke, overlap? A test of the
/// separating axes of their edges and of the page's axes: `true` whenever they overlap, and
/// sometimes near a corner when they don't.
fn meets(&self, other: &Coverage) -> bool {
pub(crate) fn meets(&self, other: &Coverage) -> bool {
fn normals(hull: &[Point]) -> impl Iterator<Item = Vec2> + '_ {
(0..hull.len()).filter_map(|i| {
let (a, b) = (hull.get(i)?, hull.get((i + 1) % hull.len())?);
@@ -710,7 +710,7 @@ fn convex_hull(mut points: Vec<Point>) -> Vec<Point> {
}
/// Do boxes `a` and `b` overlap with some area?
fn overlaps(a: Rect, b: Rect) -> bool {
pub(crate) fn overlaps(a: Rect, b: Rect) -> bool {
a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1
}
+77 -12
View File
@@ -700,10 +700,11 @@ type ShadowAndSurfaces = (Vec<Arc<Node>>, Vec<Arc<Node>>);
/// Rotate turns every fill and stroke, each in its own paint. Extrude & Bevel and Inflate build a
/// solid from the path for the top visible fill and one from the outline of each visible stroke,
/// each in its own paint. When every one is opaque with normal blending and no colored light makes
/// a surface one composite or masks it, their faces are drawn in one back-to-front order (where
/// depths tie, as for the caps turned toward the viewer, in the order of the appearance, and with
/// caps, a shape's fill walls before the faces of its covering strokes that overlap them:
/// [`draw_order`]);
/// a surface one composite, their faces are drawn in one back-to-front order (where depths tie, as
/// for the caps turned toward the viewer, in the order of the appearance, and with caps, a shape's
/// fill walls before the faces of its covering strokes that overlap them: [`draw_order`]), the
/// faces of a solid in a gradient with transparent stops in runs that carry its opacity mask
/// ([`in_runs`]);
/// otherwise each solid is a surface of its own, in that order. A member's opacity mask and
/// blending mode, and those of a group it is in, apply to the surfaces of the members it holds
/// ([`masked`]). The art comes in two parts: the effect's shadow ([`cast_shadow`], none with it
@@ -856,19 +857,21 @@ fn surfaces_for(n: &Node, fx: &Effect, shapes: &[Profile]) -> Option<Vec<Arc<Nod
return Some(masked(n.id, surfaces.into_iter().map(|(_, s, scopes)| (scopes, Arc::new(s))).collect()));
}
// One order takes a plain group of faces from each solid, one face for each facet. With
// colored lights a surface can instead be one clipped composite of all its facets, or carry an
// opacity mask, and then it stays whole.
let plain = surfaces.iter().all(|(depths, s, _)| {
s.extras().mask.is_none() && matches!(&s.kind, NodeKind::Group { children, clip: false } if children.len() == depths.len())
});
// colored lights a surface can instead be one clipped composite of all its facets. A composite
// has no faces to order, so when any surface is one, every surface of the solid, masked ones
// included, draws whole in member order.
let plain = surfaces.iter().all(|(depths, s, _)| matches!(&s.kind, NodeKind::Group { children, clip: false } if children.len() == depths.len()));
if !opaque || !plain {
return Some(surfaces.into_iter().map(|(_, s, _)| Arc::new(s)).collect());
}
// A surface in a gradient with transparent stops carries an opacity mask: its faces go in runs
// ([`in_runs`]), and each run carries the mask.
let masks: Vec<Option<Box<OpacityMask>>> = surfaces.iter().map(|(_, s, _)| s.extras().mask.clone()).collect();
let (mut placed, mut faces) = (vec![], vec![]);
for (depths, s, _) in surfaces {
for (surface, (depths, s, _)) in surfaces.into_iter().enumerate() {
if let NodeKind::Group { children, .. } = s.kind {
placed.extend(depths);
faces.extend(children.into_iter().map(Some));
faces.extend(children.into_iter().map(|face| Some((surface, face))));
}
}
let sealed = match fx.id.as_str() {
@@ -877,7 +880,69 @@ fn surfaces_for(n: &Node, fx: &Effect, shapes: &[Profile]) -> Option<Vec<Arc<Nod
_ => extrude_options(&p).cap,
};
let order = draw_order(&placed, sealed);
Some(vec![Arc::new(Node::group(n.id, order.into_iter().filter_map(|k| faces.get_mut(k).and_then(Option::take)).collect()))])
let faces: Vec<(usize, Arc<Node>)> = order.into_iter().filter_map(|k| faces.get_mut(k).and_then(Option::take)).collect();
let children = if masks.iter().all(Option::is_none) { faces.into_iter().map(|(_, face)| face).collect() } else { in_runs(n.id, faces, &masks) };
Some(vec![Arc::new(Node::group(n.id, children))])
}
/// `faces` in their back-to-front order, each with the index of its surface, where some surfaces
/// carry an opacity mask (`masks`, by surface). A face of a surface without one goes in the order
/// on its own. The faces of a masked surface share a run, one group with the surface's mask. Such a
/// face joins its surface's last run unless a face drawn after that run overlaps it: only then does
/// the surface split, where one group can't be both behind and in front of another face.
fn in_runs(id: NodeId, faces: Vec<(usize, Arc<Node>)>, masks: &[Option<Box<OpacityMask>>]) -> Vec<Arc<Node>> {
use crate::revolve::{Coverage, overlaps};
struct Run {
surface: Option<usize>,
bounds: Rect,
faces: Vec<Arc<Node>>,
cover: Vec<Coverage>,
}
let mut runs: Vec<Run> = vec![];
let mut last_run = vec![None; masks.len()];
// Past this many tests a face starts a run of its own, which never draws out of order.
let mut budget = crate::revolve::MAX_OVERLAP_TESTS;
for (surface, face) in faces {
let Some(cover) = Coverage::of(&face) else {
// A face with no outline and no box overlaps nothing.
runs.push(Run { surface: None, bounds: Rect::ZERO, faces: vec![face], cover: vec![] });
continue;
};
if masks.get(surface).is_none_or(Option::is_none) {
runs.push(Run { surface: None, bounds: cover.bounds, faces: vec![face], cover: vec![cover] });
continue;
}
let mut clear = |r: &Run| {
budget = budget.saturating_sub(1);
if !overlaps(r.bounds, cover.bounds) {
return budget > 0;
}
budget = budget.saturating_sub(r.cover.len());
budget > 0 && r.cover.iter().all(|c| !overlaps(c.bounds, cover.bounds) || !c.meets(&cover))
};
let joins = last_run.get(surface).copied().flatten().filter(|&i: &usize| runs.get(i + 1..).is_some_and(|later| later.iter().all(&mut clear)));
match joins.and_then(|i| runs.get_mut(i)) {
Some(run) => {
run.bounds = run.bounds.union(cover.bounds);
run.faces.push(face);
run.cover.push(cover);
}
None => {
if let Some(last) = last_run.get_mut(surface) {
*last = Some(runs.len());
}
runs.push(Run { surface: Some(surface), bounds: cover.bounds, faces: vec![face], cover: vec![cover] });
}
}
}
runs.into_iter()
.filter_map(|mut r| {
let Some(mask) = r.surface.and_then(|s| masks.get(s)).cloned().flatten() else { return r.faces.pop() };
let mut group = Node::group(id, r.faces);
group.extras_mut().mask = Some(mask);
Some(Arc::new(group))
})
.collect()
}
fn geometry(path: &PathData, fx: &[Effect], ctx: &GeomContext) -> PathData {
+73 -7
View File
@@ -415,15 +415,16 @@ fn a_translucent_stroke_is_a_surface_of_its_own() {
}
/// With a light that is not white, a fill in a gradient with transparent stops is drawn with an
/// opacity mask over its whole surface: the fill's solid and the stroke's stay surfaces of their
/// own, and the mask stays on the fill's. Under a white light the same object is one surface.
/// opacity mask: its faces still take their places in the one order of the fill's and the
/// stroke's faces, in runs that each carry the mask. Under a white light the faces carry the
/// gradient itself and no mask.
#[test]
fn a_masked_surface_under_a_colored_light_stays_whole() {
fn a_masked_surface_under_a_colored_light_keeps_the_shared_face_order() {
use vectorcraft_doc::color::{Gradient, GradientKind, GradientPaint, GradientStop};
let mut half = GradientStop::new(1.0, RED);
half.opacity = 0.5;
let gradient = GradientPaint::new(Gradient::new(GradientKind::Linear, vec![GradientStop::new(0.0, RED), half]));
for (lights, surfaces) in [(json!({"lights": [{"color": "#ff8080"}]}), 2), (json!({}), 1)] {
for (lights, masked) in [(json!({"lights": [{"color": "#ff8080"}]}), true), (json!({}), false)] {
let mut n = stroked_rect(100.0);
if let Some(AppearanceItem::Fill(f)) = n.appearance.items.iter_mut().find(|i| matches!(i, AppearanceItem::Fill(_))) {
f.paint = Paint::Gradient(Box::new(gradient.clone()));
@@ -431,8 +432,10 @@ fn a_masked_surface_under_a_colored_light_stays_whole() {
n.appearance.effects.push(fx(EXTRUDE, lights.clone()));
let art = solid_art(&n).unwrap();
let drawn = art.children().unwrap();
assert_eq!(drawn.len(), surfaces, "{lights}");
assert_eq!(drawn[0].extras().mask.is_some(), surfaces == 2, "{lights}");
assert_eq!(drawn.len(), 1, "{lights}: one order of faces");
let runs: Vec<&Arc<Node>> = drawn[0].children().unwrap().iter().filter(|c| c.extras().mask.is_some()).collect();
assert_eq!(!runs.is_empty(), masked, "{lights}");
assert!(runs.iter().all(|r| r.children().unwrap().iter().all(|f| !blue(f))), "{lights}: the mask stays on the fill's faces");
}
}
@@ -847,7 +850,9 @@ fn classic_shading_keeps_a_gradients_transparency() {
}
let art = solid_art(&n).unwrap();
let surface = &art.children().unwrap()[0];
assert_eq!(surface.extras().mask.is_some(), masked, "{end}");
let mut has_mask = false;
surface.walk(&mut |c| has_mask |= c.extras().mask.is_some());
assert_eq!(has_mask, masked, "{end}");
let mut opaque = true;
surface.walk(&mut |c| {
for item in &c.appearance.items {
@@ -862,6 +867,67 @@ fn classic_shading_keeps_a_gradients_transparency() {
}
}
/// A group member in a gradient with transparent stops keeps the shared back-to-front order of
/// every member's faces: its faces go in runs that carry its opacity mask, and the other member's
/// faces are drawn between them where they are in front of some and behind others. Here a square
/// frame in the gradient holds a square in its hole: the frame's inner walls are behind the square
/// and its front cap is in front of the square's walls.
#[test]
fn a_member_in_a_transparent_gradient_keeps_the_shared_face_order() {
use vectorcraft_doc::color::{Gradient, GradientKind, GradientPaint, GradientStop};
let square = |b: &mut BezPath, x0: f64, x1: f64, clockwise: bool| {
let corners = [(x0, x0), (x1, x0), (x1, x1), (x0, x1)];
let mut points = corners.to_vec();
if !clockwise {
points.reverse();
}
b.move_to(points[0]);
for p in &points[1..] {
b.line_to(*p);
}
b.close_path();
};
let art = |id: &str, params: &Value, end_opacity: f32| {
let mut end = GradientStop::new(1.0, Color::BLACK);
end.opacity = end_opacity;
let gradient = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, vec![GradientStop::new(0.0, RED), end]))));
let mut b = BezPath::new();
square(&mut b, 100.0, 300.0, true);
square(&mut b, 150.0, 250.0, false);
let frame = Node::path(NodeId(1), PathData::from_bezpath(&b), Appearance::basic(gradient, Paint::None, 0.0));
let mut b = BezPath::new();
square(&mut b, 185.0, 215.0, true);
let inner = Node::path(NodeId(2), PathData::from_bezpath(&b), Appearance::basic(Paint::solid(BLUE), Paint::None, 0.0));
let mut g = Node::group(NodeId(3), vec![Arc::new(frame), Arc::new(inner)]);
g.appearance.effects.push(fx(id, params.clone()));
solid_art(&g).unwrap_or_else(|| panic!("{id}"))
};
// The drawing order: `M` for a group with an opacity mask, `F` for a face outside one.
fn visit(n: &Node, order: &mut String) {
if n.extras().mask.is_some() {
order.push('M');
return;
}
if n.path_data().is_some() {
order.push('F');
}
for c in n.children().into_iter().flatten() {
visit(c, order);
}
}
let order = |art: &Node| {
let mut order = String::new();
visit(art, &mut order);
order
};
for (id, params) in [(CLASSIC_EXTRUDE, json!({})), (EXTRUDE, json!({"lights": [{"color": "#ff8080"}]}))] {
assert!(!order(&art(id, &params, 1.0)).contains('M'), "{id}: an opaque gradient needs no mask");
let masked = order(&art(id, &params, 0.5));
let (first, last) = (masked.find('M').unwrap(), masked.rfind('M').unwrap());
assert!(masked.get(first..last).is_some_and(|between| between.contains('F')), "{id}: faces between the member's runs: {masked}");
}
}
#[test]
fn classic_parameters_are_checked() {
let n = classic(json!({}));
+362
View File
@@ -209,6 +209,57 @@ fn warp_arc_bends_the_top_edge() {
assert!(b.x0 < -1.0 || b.x1 > 101.0, "{b:?}");
}
/// A Warp of `version` 1 bends its bounds as its style's Bézier net; one without a version, as
/// saved before the version existed, draws as it always did. Flag at 60 % on a 200 × 100 box: the
/// net moves the top edge up to 6 × 0.6 × 100 × max u(1 - u)(1 - 2u) = 34.64 out, the earlier map
/// moves it 0.6 × 25 = 15.
#[test]
fn a_warp_draws_with_the_map_its_version_names() {
let rect = shapes::rectangle(Rect::new(10.0, 20.0, 210.0, 120.0));
// u(1 - u)(1 - 2u) peaks at √3 / 18.
let peak = 360.0 * 3f64.sqrt() / 18.0;
for (version, out) in [(json!(1), peak), (json!(null), 15.0), (json!(0), 15.0)] {
let b = run("warp.flag", json!({"bend": 60, "version": version}), &rect).bounds().unwrap();
assert!(close(b.y0, 20.0 - out, 0.1) && close(b.y1, 120.0 + out, 0.1), "version {version}: {b:?}");
assert!(close(b.x0, 10.0, 1e-9) && close(b.x1, 210.0, 1e-9), "version {version}: {b:?}");
}
}
/// A straight line has a box with no width or no height, and the net bends it as the middle of
/// the patch along that side: under Arc a vertical line stays vertical, and under Bulge, Fisheye,
/// Inflate and Squeeze a horizontal line stays straight.
#[test]
fn a_warp_bends_a_flat_box_as_the_middle_of_its_patch() {
let anchors = |p: &PathData| p.subpaths.iter().flat_map(|s| s.anchors.clone()).collect::<Vec<_>>();
let vertical = shapes::line(Point::new(100.0, 0.0), Point::new(100.0, 100.0));
let out = run("warp.arc", json!({"bend": 50, "version": 1}), &vertical);
assert!(anchors(&out).iter().all(|a| close(a.p.x, 100.0, 1e-9) && close(a.h_in.x, 100.0, 1e-9) && close(a.h_out.x, 100.0, 1e-9)), "{out:?}");
let horizontal = shapes::line(Point::new(0.0, 50.0), Point::new(200.0, 50.0));
for style in ["bulge", "fisheye", "inflate", "squeeze"] {
let out = run(&format!("warp.{style}"), json!({"bend": 50, "version": 1}), &horizontal);
assert!(
anchors(&out).iter().all(|a| close(a.p.y, 50.0, 1e-9) && close(a.h_in.y, 50.0, 1e-9) && close(a.h_out.y, 50.0, 1e-9)),
"{style}: {out:?}"
);
}
}
/// A new Warp takes the nets' version unless one is given, and the catalog's defaults carry none,
/// so a saved warp's params don't gain one.
#[test]
fn new_warps_take_the_nets_version() {
for (s, _) in WARP_STYLES {
let id = format!("warp.{s}");
let Some(e) = crate::new_effect(&id, &json!({"bend": 20})) else { panic!("{id}") };
assert_eq!(e.params["version"], json!(crate::WARP_NET), "{id}");
let Some(e) = crate::new_effect(&id, &json!({"version": 0})) else { panic!("{id}") };
assert_eq!(e.params["version"], json!(0), "{id}");
assert!(crate::merged_params(&id, &json!({"bend": 20})).get("version").is_none(), "{id}");
}
let Some(e) = crate::new_effect("distort.twist", &json!({})) else { panic!("twist") };
assert!(e.params.get("version").is_none());
}
#[test]
fn transform_copies_and_move() {
let out = run("distort.transform", json!({"moveH": 20, "copies": 3}), &square());
@@ -318,6 +369,317 @@ fn stacked_transform_copies_stay_within_the_image_budget() {
assert_eq!(count(&evaluate_container(None, &g).unwrap()), 1001);
}
/// A 40 × 40 px image placed at (0, 0) at one point a pixel, with id `id`.
fn warp_test_image(id: u64) -> std::sync::Arc<Node> {
use vectorcraft_doc::{ImageObject, NodeId};
let im = ImageObject { key: "k".into(), width: 40, height: 40, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
std::sync::Arc::new(Node::new(NodeId(id), NodeKind::Image(Box::new(im))))
}
/// How many images `art` holds, and the keys they have.
fn warp_test_images(art: &Node) -> (usize, std::collections::BTreeSet<String>) {
let (mut n, mut keys) = (0, std::collections::BTreeSet::new());
art.walk(&mut |c| {
if let NodeKind::Image(im) = &c.kind {
n += 1;
keys.insert(im.key.clone());
}
});
(n, keys)
}
#[test]
fn warped_images_stay_within_the_object_budget() {
use std::rc::Rc;
use std::sync::Arc;
use vectorcraft_doc::NodeId;
let lift: crate::reshape::WarpMap = Rc::new(|p: Point| Point::new(p.x, p.y - p.x * 0.1));
let cost = vectorcraft_doc::live::mesh_warp_cost(crate::reshape::WARP_IMAGE_CELLS);
let none = std::collections::HashSet::new();
let k = || std::collections::BTreeSet::from(["k".to_string()]);
let warp = |art: &mut Node, warps: usize| {
let mut warped = crate::reshape::WarpedImages::new();
for _ in 0..warps {
crate::reshape::mark_warped_images(art, &lift, &none, false, &mut 0, &mut warped);
}
warped
};
// The art has room for one image's pieces only: neither image is cut, and each gets its own
// key back.
let mut art = Node::group(NodeId(1), vec![warp_test_image(2), warp_test_image(3)]);
let warped = warp(&mut art, 1);
let max = art.count() + cost;
crate::reshape::cut_warped_images_within(&mut art, &warped, max);
assert_eq!(warp_test_images(&art), (2, k()));
// With room for both, each is cut into 200 pieces once, however many warps it took.
let mut art = Node::group(NodeId(1), vec![warp_test_image(2), warp_test_image(3)]);
let warped = warp(&mut art, 3);
let max = art.count() + 2 * cost;
crate::reshape::cut_warped_images_within(&mut art, &warped, max);
assert_eq!(warp_test_images(&art), (400, k()));
// Images clipped by their frames: the second frame (the second path) kept its shape, so its
// image stays whole, and the first is cut. The third's frame is a group of two paths, the
// second of them kept, with an image after them, and its image sits in a group of its own:
// both stay whole too.
let frame = |id: u64| Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 40.0)), Default::default()));
let clip_group = |id: u64, children: Vec<Arc<Node>>| Arc::new(Node::new(NodeId(id), NodeKind::Group { children, clip: true }));
let nested = clip_group(
4,
vec![
Arc::new(Node::group(NodeId(4), vec![frame(4), frame(4), warp_test_image(5)])),
Arc::new(Node::group(NodeId(4), vec![warp_test_image(4)])),
],
);
let mut art =
Node::group(NodeId(1), vec![clip_group(2, vec![frame(2), warp_test_image(2)]), clip_group(3, vec![frame(3), warp_test_image(3)]), nested]);
let (mut at, mut warped) = (0, crate::reshape::WarpedImages::new());
crate::reshape::mark_warped_images(&mut art, &lift, &std::collections::HashSet::from([1, 3]), false, &mut at, &mut warped);
assert_eq!(at, 4);
crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
assert_eq!(warp_test_images(&art), (203, k()));
}
/// An image key from the document that looks like a key of the table is not read as one, and a
/// hidden image stays out of the bounds the later effects take, as it does before it is warped.
#[test]
fn warped_images_keep_document_keys_and_hidden_images_apart() {
use std::rc::Rc;
use std::sync::Arc;
use vectorcraft_doc::NodeId;
let lift: crate::reshape::WarpMap = Rc::new(|p: Point| Point::new(p.x, p.y - p.x * 0.1));
let none = std::collections::HashSet::new();
let mut warped = crate::reshape::WarpedImages::new();
let lookalike = format!("{}0", warped.prefix());
let mut b = (*warp_test_image(3)).clone();
if let NodeKind::Image(im) = &mut b.kind {
im.key = lookalike.clone();
}
let mut art = Node::group(NodeId(1), vec![warp_test_image(2), Arc::new(b)]);
warped.reserve(&art);
crate::reshape::mark_warped_images(&mut art, &lift, &none, false, &mut 0, &mut warped);
crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
assert_eq!(warp_test_images(&art), (400, std::collections::BTreeSet::from(["k".to_string(), lookalike])));
// A layer of a 10 × 10 square and a hidden 40 × 40 image: the warped image is not measured.
let square = Arc::new(Node::path(NodeId(4), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default()));
let mut hidden = (*warp_test_image(5)).clone();
hidden.visible = false;
let mut layer = Node::layer(NodeId(6), "Layer 1", vectorcraft_doc::LayerColor::Preset(0));
if let Some(children) = layer.children_mut() {
*children = vec![square, Arc::new(hidden)];
}
let before = layer.geometric_bounds();
let mut warped = crate::reshape::WarpedImages::new();
warped.reserve(&layer);
crate::reshape::mark_warped_images(&mut layer, &lift, &none, false, &mut 0, &mut warped);
assert_eq!(warped.bounds(&layer), before);
// A shown image is measured by the pieces it is cut into.
let mut art = Node::group(NodeId(1), vec![warp_test_image(2)]);
let mut warped = crate::reshape::WarpedImages::new();
warped.reserve(&art);
crate::reshape::mark_warped_images(&mut art, &lift, &none, false, &mut 0, &mut warped);
let measured = warped.bounds(&art);
crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
assert_eq!(measured, art.geometric_bounds());
assert!(measured.is_some_and(|b| b.y0 < -3.9), "{measured:?}");
// An image placed at a tiny scale (a placement with a tiny determinant) is cut too; one placed
// with no area is not.
for (scale, pieces) in [(1e-7, 200), (0.0, 1)] {
let mut image = (*warp_test_image(2)).clone();
if let NodeKind::Image(im) = &mut image.kind {
im.xf = Affine::scale(scale);
}
let mut art = Node::group(NodeId(1), vec![Arc::new(image)]);
let mut warped = crate::reshape::WarpedImages::new();
crate::reshape::mark_warped_images(&mut art, &lift, &none, false, &mut 0, &mut warped);
crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
assert_eq!(warp_test_images(&art).0, pieces, "{scale}");
}
}
/// An image whose frame keeps its shape because the warp would pass the anchor budget keeps its
/// pixels as they are; within the budget, both bend.
#[test]
fn an_image_whose_frame_passes_the_budget_stays_whole() {
use std::sync::Arc;
use vectorcraft_doc::NodeId;
let clipped = || {
let mut frame = Node::path(NodeId(1), shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 40.0)), Appearance::default());
if let NodeKind::Path { clipping, .. } = &mut frame.kind {
*clipping = true;
}
Node::new(NodeId(1), NodeKind::Group { children: vec![Arc::new(frame), warp_test_image(1)], clip: true })
};
let arc = fx("warp.arc", json!({"bend": 50, "version": 1}));
let k = || std::collections::BTreeSet::from(["k".to_string()]);
let mut art = clipped();
crate::reshape::reshape_leaves_within(&mut art, &[&arc], Budget { anchors: 0, lines: 0 }, None);
assert_eq!(art.children().and_then(|c| c.first()).and_then(|c| c.path_data()).map(|p| p.anchor_count()), Some(4));
assert_eq!(warp_test_images(&art), (1, k()));
let mut art = clipped();
crate::reshape::reshape_leaves_within(&mut art, &[&arc], Budget::EFFECTS, None);
assert!(art.children().and_then(|c| c.first()).and_then(|c| c.path_data()).is_some_and(|p| p.anchor_count() > 4));
assert_eq!(warp_test_images(&art), (200, k()));
}
/// The first image under `n` (the first piece of a cut image).
fn first_image(n: &Node) -> Option<vectorcraft_doc::ImageObject> {
let mut first = None;
n.walk(&mut |c| {
if first.is_none()
&& let NodeKind::Image(im) = &c.kind
{
first = Some((**im).clone());
}
});
first
}
#[test]
fn effects_after_a_warp_reshape_an_images_frame_and_not_its_pieces() {
let image = |effects: Vec<Effect>| {
let mut n = (*warp_test_image(1)).clone();
n.appearance.effects = effects;
n
};
// Each piece's clipping path, and the image's frame (the outer clip group's clipping path).
let clips = |art: &Node| {
let (mut pieces, mut frame) = (vec![], None);
art.walk(&mut |c| {
if let NodeKind::Group { children, clip: true } = &c.kind
&& let Some(path) = children.first().and_then(|p| p.path_data())
{
if matches!(children.get(1).map(|i| &i.kind), Some(NodeKind::Image(_))) && path.anchor_count() == 3 {
pieces.push(path.anchor_count());
} else if frame.is_none() {
frame = Some(path.anchor_count());
}
}
});
(pieces, frame)
};
let arc = fx("warp.arc", json!({"bend": 50, "version": 1}));
for after in [
fx("distort.roughen", json!({"size": 5, "detail": 10})),
fx("stylize.roundCorners", json!({"radius": 5})),
fx("path.offsetPath", json!({"offset": -2})),
] {
let art = crate::reshape::reshape(None, &image(vec![arc.clone(), after.clone()]), None).unwrap();
let (pieces, frame) = clips(&art);
assert_eq!(pieces.len(), 200, "{}", after.id);
assert!(frame.is_some_and(|n| n > 4), "{}: {frame:?}", after.id);
assert_eq!(warp_test_images(&art), (200, std::collections::BTreeSet::from(["k".to_string()])), "{}", after.id);
}
// Two warps cut the image once, through both maps; a Transform after them moves the pieces.
let flag = fx("warp.flag", json!({"bend": 30, "version": 1}));
let mv = fx("distort.transform", json!({"moveH": 100, "moveV": 0}));
let art = crate::reshape::reshape(None, &image(vec![arc.clone(), flag.clone()]), None).unwrap();
assert_eq!(warp_test_images(&art).0, 200);
let moved = crate::reshape::reshape(None, &image(vec![arc.clone(), flag.clone(), mv]), None).unwrap();
assert_eq!(warp_test_images(&moved).0, 200);
let box1 = Rect::new(0.0, 0.0, 40.0, 40.0);
let f1 = crate::warp::warp_map(box1, crate::warp::WarpStyle::Arc, &merged_params("warp.arc", &arc.params));
// The flag bends the box the arc leaves, which the arc's frame measures.
let box2 = crate::reshape::reshape(None, &image(vec![arc.clone()]), None).unwrap().geometric_bounds().unwrap();
let f2 = crate::warp::warp_map(box2, crate::warp::WarpStyle::Flag, &merged_params("warp.flag", &flag.params));
// The first piece's corners: the pixels (0, 0), (4, 0) and (4, 4).
for (art, by) in [(&art, 0.0), (&moved, 100.0)] {
let piece = first_image(art).unwrap();
for p in [Point::new(0.0, 0.0), Point::new(4.0, 0.0), Point::new(4.0, 4.0)] {
let want = f2(f1(p)) + vectorcraft_geom::Vec2::new(by, 0.0);
assert!((piece.xf * p).distance(want) < 1e-6, "{p:?}: {:?} {want:?}", piece.xf * p);
}
}
}
/// A warp with no version (VectorCraft's earlier map) bends an image's pixels with that map, as it
/// bends the frame.
#[test]
fn an_images_pixels_take_the_map_their_warps_version_names() {
for version in [json!(null), json!(0), json!(1)] {
let mut params = json!({"bend": 50});
if !version.is_null() {
params["version"] = version.clone();
}
let mut n = (*warp_test_image(1)).clone();
n.appearance.effects = vec![fx("warp.arc", params.clone())];
let art = crate::reshape::reshape(None, &n, None).unwrap();
let f = crate::warp::warp_map(Rect::new(0.0, 0.0, 40.0, 40.0), crate::warp::WarpStyle::Arc, &merged_params("warp.arc", &params));
let piece = first_image(&art).unwrap();
for p in [Point::new(0.0, 0.0), Point::new(4.0, 0.0), Point::new(4.0, 4.0)] {
assert!((piece.xf * p).distance(f(p)) < 1e-6, "{version}: {p:?}");
}
// The frame has an anchor where the map takes each corner.
let frame = art.children().and_then(|c| c.first()).and_then(|c| c.path_data()).unwrap();
for corner in [Point::new(0.0, 0.0), Point::new(40.0, 0.0), Point::new(40.0, 40.0), Point::new(0.0, 40.0)] {
let near = frame.subpaths.iter().flat_map(|s| &s.anchors).any(|a| a.p.distance(f(corner)) < 1e-6);
assert!(near, "{version}: {corner:?}");
}
}
}
/// Under a group's Warp effect, a nested group's own placed gradient follows the nested group's
/// bounds to where its image's pieces draw them.
#[test]
fn a_nested_groups_gradient_follows_its_warped_image() {
use std::sync::Arc;
use vectorcraft_color::{Color, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, FillLayer, NodeId};
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let geom = GradientGeom { start: (5.0, 20.0).into(), end: (35.0, 20.0).into(), aspect: 1.0, focal: None };
let placed = Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), ..GradientPaint::new(Gradient::new(GradientKind::Linear, stops)) }));
let mut inner = Node::group(NodeId(5), vec![warp_test_image(1)]);
inner.appearance.items.push(AppearanceItem::Fill(FillLayer::new(placed)));
let square = Node::path(NodeId(2), shapes::rectangle(Rect::new(60.0, 0.0, 100.0, 40.0)), Appearance::default());
let mut g = Node::group(NodeId(10), vec![Arc::new(inner), Arc::new(square)]);
g.appearance.effects.push(fx("warp.arc", json!({"bend": 50, "version": 1})));
let art = crate::group::evaluate_container(None, &g).unwrap();
assert_eq!(warp_test_images(&art).0, 200);
let (from, mut to) = (Rect::new(0.0, 0.0, 40.0, 40.0), None);
art.walk(&mut |c| {
if c.id == NodeId(5) && to.is_none() {
to = c.geometric_bounds();
}
});
let to = to.unwrap();
assert!(to.y0 < from.y0 - 1.0, "the pieces draw the image bent: {to:?}");
let follow = |p: Point| Point::new(to.x0 + (p.x - from.x0) / from.width() * to.width(), to.y0 + (p.y - from.y0) / from.height() * to.height());
let mut checked = 0;
art.walk(&mut |c| {
if c.id != NodeId(5) {
return;
}
for item in &c.appearance.items {
let Paint::Gradient(gp) = item.paint() else { continue };
let got = gp.geom.unwrap();
assert!(got.start.distance(follow(geom.start)) < 1e-6 && got.end.distance(follow(geom.end)) < 1e-6, "{got:?} in {to:?}");
checked += 1;
}
});
assert!(checked > 0);
}
/// An image under a geometry effect other than a Warp draws as the image does: colorized by
/// a grayscale image's fill color, and smoothed or not.
#[test]
fn an_image_under_a_geometry_effect_keeps_its_color_and_smoothing() {
let mut n = (*warp_test_image(1)).clone();
n.appearance.effects = vec![fx("distort.roughen", json!({"size": 5, "detail": 10}))];
n.extras_mut().colorize = Some(Box::new(vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0))));
n.extras_mut().pixelated = true;
let art = crate::reshape::reshape(None, &n, None).unwrap();
let mut seen = vec![];
art.walk(&mut |c| {
if matches!(c.kind, NodeKind::Image(_)) {
seen.push((c.extras().colorize.clone(), c.extras().pixelated));
}
});
assert_eq!(seen, vec![(n.extras().colorize.clone(), true)]);
}
/// What `effects` make of `path` within `budget`.
fn within(effects: &[Effect], path: &PathData, budget: Budget) -> PathData {
apply_geometry_within(effects, path, path.bounds().unwrap(), &GeomContext::default(), budget)
+34 -11
View File
@@ -1,25 +1,49 @@
//! Warp effects: 15 envelope styles plus horizontal/vertical perspective distortion.
//!
//! Each style is a map on normalised box coordinates (x, y) ∈ [-1, 1]² (y down). The path is
//! split into short pieces whose control points are mapped (see `map_nonlinear`).
//! A warp with `version` [`WARP_NET`] is its style's Bézier patch over the box ([`WarpNet`]);
//! one without (saved before the version existed) is a map on normalized box coordinates
//! (x, y) ∈ [-1, 1]² (y down), [`warp_point`]. The path is split into short pieces whose control
//! points are mapped (see `map_nonlinear`).
use serde_json::Value;
use vectorcraft_geom::{PathData, Point, Rect};
use crate::util::{map_nonlinear_within, num, text};
pub use vectorcraft_doc::live::{WarpStyle, warp_point};
pub use vectorcraft_doc::live::{WARP_NET, WarpNet, WarpStyle, uses_net, warp_point, warp_version};
/// The map version warp params `p` ask for: their `version`, 0 (the first map) when absent.
pub fn map_version(p: &Value) -> u32 {
let v = num(p, "version", 0.0);
if v.is_finite() && v >= 0.0 { v.min(f64::from(u32::MAX)) as u32 } else { 0 }
}
/// Apply a warp to `path` using box `b`, making at most `max` anchors ([`map_nonlinear_within`]).
pub fn warp(path: &PathData, b: Rect, style: WarpStyle, p: &Value, max: usize) -> PathData {
let piece = b.width().hypot(b.height()) / 24.0;
map_nonlinear_within(path, piece, max, warp_map(b, style, p))
}
/// The point map a warp of `style` with params `p` applies to box `b`: what [`warp`] moves each
/// point of a path to.
pub(crate) fn warp_map(b: Rect, style: WarpStyle, p: &Value) -> Box<dyn Fn(Point) -> Point> {
let bend = num(p, "bend", 50.0).clamp(-100.0, 100.0) / 100.0;
let dh = num(p, "horizontal", 0.0).clamp(-100.0, 100.0) / 100.0;
let dv = num(p, "vertical", 0.0).clamp(-100.0, 100.0) / 100.0;
let vertical = text(p, "orientation", "horizontal").eq_ignore_ascii_case("vertical");
if uses_net(map_version(p)) {
let net = WarpNet::new(style, bend, dh, dv, b.width(), b.height(), vertical);
let (w, h) = (b.width(), b.height());
// A box with no width or no height takes the middle of the patch along that side.
return Box::new(move |q: Point| {
let (u, v) = (if w > 0.0 { (q.x - b.x0) / w } else { 0.5 }, if h > 0.0 { (q.y - b.y0) / h } else { 0.5 });
b.origin() + net.at(u, v).to_vec2()
});
}
let c = b.center();
let hw = (b.width() / 2.0).max(1e-9);
let hh = (b.height() / 2.0).max(1e-9);
let f = |q: Point| {
Box::new(move |q: Point| {
let (x, y) = ((q.x - c.x) / hw, (q.y - c.y) / hh);
let (x2, y2) = if vertical {
let (a, b2) = warp_point(style, bend, dh, dv, hw / hh, y, x);
@@ -28,18 +52,17 @@ pub fn warp(path: &PathData, b: Rect, style: WarpStyle, p: &Value, max: usize) -
warp_point(style, bend, dh, dv, hh / hw, x, y)
};
Point::new(c.x + x2 * hw, c.y + y2 * hh)
};
let piece = b.width().hypot(b.height()) / 24.0;
map_nonlinear_within(path, piece, max, f)
})
}
/// Does warp effect `id` with params `p` move any point? Every style leaves the box as it is with
/// no bend and no distortion, and Arc (`warp.arc`) takes a bend under 0.0001 % as none: the
/// threshold must match the one in [`warp_point`]'s Arc case (`warp_bends_when_the_warp_moves_the_outline`
/// tests both sides of it).
/// no bend and no distortion. With the first map, Arc (`warp.arc`) takes a bend under 0.0001 % as
/// none: the threshold must match the one in [`warp_point`]'s Arc case
/// (`warp_bends_when_the_warp_moves_the_outline` tests both sides of it). With [`WarpNet`] any
/// bend moves the outline.
pub(crate) fn bends(id: &str, p: &Value) -> bool {
let share = |key: &str, default: f64| num(p, key, default).clamp(-100.0, 100.0) / 100.0;
let bend = share("bend", 50.0);
let bent = if id == "warp.arc" { bend.abs() >= 1e-6 } else { bend != 0.0 };
let bent = if id == "warp.arc" && !uses_net(map_version(p)) { bend.abs() >= 1e-6 } else { bend != 0.0 };
bent || share("horizontal", 0.0) != 0.0 || share("vertical", 0.0) != 0.0
}
+165
View File
@@ -176,6 +176,7 @@ pub const BUILTIN: &[BuiltinBrushLibrary] = &[
BuiltinBrushLibrary { id: "scatter-shapes", name: "Scatter Shapes", make: scatter_shapes },
BuiltinBrushLibrary { id: "game-trails", name: "Game Trails", make: game_trails },
BuiltinBrushLibrary { id: "energy-beams", name: "Energy Beams", make: energy_beams },
BuiltinBrushLibrary { id: "dry-media", name: "Dry Media", make: dry_media },
];
/// Built-in library `id`, made once.
@@ -474,6 +475,170 @@ fn energy_beams() -> BrushLibrary {
built("Energy Beams", Document::new(100.0, 100.0), brushes)
}
/// The fixed-seed number source of the Dry Media grain: integer steps and plain arithmetic, so the
/// art is the same on every run and every platform.
struct Grain(u64);
impl Grain {
/// The next number in 0..1.
fn next(&mut self) -> f64 {
self.0 = self.0.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
(self.0 >> 11) as f64 / (1u64 << 53) as f64
}
/// The next number in `a`..`b`.
fn range(&mut self, a: f64, b: f64) -> f64 {
a + (b - a) * self.next()
}
}
/// `floor` at x = `x0` and `x1`, rising smoothly to 1 within `ramp` pt of each.
fn ends(x: f64, x0: f64, x1: f64, ramp: f64, floor: f64) -> f64 {
let t = ((x - x0).min(x1 - x) / ramp).clamp(0.0, 1.0);
floor + (1.0 - floor) * t * t * (3.0 - 2.0 * t)
}
/// A closed band from x = `x0` to `x1` in `n` steps, at most `half` pt either side of y = 0 times
/// `taper(x)`; each edge point is pulled in by up to `rough` of that.
fn rough_band(g: &mut Grain, (x0, x1): (f64, f64), n: usize, half: f64, rough: f64, taper: impl Fn(f64) -> f64) -> PathData {
let xs: Vec<f64> = (0..=n).map(|i| x0 + (x1 - x0) * i as f64 / n as f64).collect();
let mut pts: Vec<Point> = xs.iter().map(|&x| Point::new(x, -half * taper(x) * (1.0 - rough * g.next()))).collect();
let bottom: Vec<Point> = xs.iter().rev().map(|&x| Point::new(x, half * taper(x) * (1.0 - rough * g.next()))).collect();
pts.extend(bottom);
PathData::single(SubPath::polyline(&pts, true))
}
/// A small four-cornered fleck around (`cx`, `cy`), at most `w` × `h` pt either side; one corner
/// in each direction, so its outline never crosses itself.
fn fleck(g: &mut Grain, cx: f64, cy: f64, w: f64, h: f64) -> PathData {
let mut side = |a: f64, b: f64| g.range(a, b);
let pts = [
(cx - w * side(0.6, 1.0), cy + h * side(-0.3, 0.3)),
(cx + w * side(-0.3, 0.3), cy - h * side(0.6, 1.0)),
(cx + w * side(0.6, 1.0), cy + h * side(-0.3, 0.3)),
(cx + w * side(-0.3, 0.3), cy + h * side(0.6, 1.0)),
];
polygon(&pts)
}
/// `body` with `holes` (inside it, apart from each other) cut out, even-odd, in gray `k`: what
/// lies under the stroke shows through the holes.
fn holed(body: PathData, holes: Vec<PathData>, k: f32) -> Node {
let children = std::iter::once(body).chain(holes).map(|p| Arc::new(Node::path(NodeId(0), p, Appearance::default()))).collect();
let mut n = Node::new(NodeId(0), NodeKind::Compound { children, rule: FillRule::EvenOdd });
n.appearance = Appearance { items: vec![AppearanceItem::Fill(FillLayer::new(Paint::solid(Color::gray(k))))], ..Default::default() }.into();
n
}
/// Path `p` filled with gray `k` (1 is black).
fn ink(p: PathData, k: f32) -> Node {
filled(p, Paint::solid(Color::gray(k)))
}
/// Slivers `w` × `h` pt (ranges) in `count` slots along x = 6..94 inside a band `half` pt wide
/// times `taper`. Each stays within `reach` of the band's half width from y = 0, taken where the
/// band is narrowest over the sliver and the 3 pt either side of it, so with `reach` below the
/// band's roughness margin no sliver touches the band's edge or another sliver.
fn slivers(g: &mut Grain, count: usize, half: f64, reach: f64, (w, h): ((f64, f64), (f64, f64)), taper: impl Fn(f64) -> f64) -> Vec<PathData> {
let slot = 88.0 / count as f64;
(0..count)
.map(|i| {
let cx = 6.0 + slot * (i as f64 + 0.5);
let (w, h) = (g.range(w.0, w.1), g.range(h.0, h.1));
let room = reach * half * taper(cx - w - 3.0).min(taper(cx + w + 3.0));
let cy = g.range(-1.0, 1.0) * (room - h).max(0.0);
fleck(g, cx, cy, w, h)
})
.collect()
}
/// Dry Media: art brushes of grainy dry drawing marks, chalk, pencil, crayon and charcoal (original
/// vector grain from fixed seeds; every brush 100 pt long, black and grays that take the stroke
/// color as tints, gaps cut out so the paper shows).
pub(crate) fn dry_media() -> BrushLibrary {
// Chalk Grain, 100 × 8 pt: a soft band with narrow scratches and chips along its edges.
let chalk = {
let mut g = Grain(0x0c4a_1c0a);
let taper = |x: f64| ends(x, 0.0, 100.0, 10.0, 0.35);
let body = rough_band(&mut g, (0.0, 100.0), 36, 4.0, 0.25, taper);
let scratches = slivers(&mut g, 14, 4.0, 0.7, ((1.2, 2.4), (0.15, 0.3)), taper);
let mut parts = vec![holed(body, scratches, 0.8)];
for i in 0..18 {
let cx = 3.0 + 94.0 * (i as f64 + g.range(0.2, 0.8)) / 18.0;
let side = if i % 2 == 0 { -1.0 } else { 1.0 };
let cy = side * 4.0 * taper(cx) * g.range(0.7, 0.95);
let (w, h) = (g.range(0.3, 0.7), g.range(0.25, 0.5));
let f = fleck(&mut g, cx, cy, w, h);
parts.push(ink(f, 1.0));
}
group(parts)
};
// Graphite Pencil, 100 × 2.5 pt: a solid tapered core with fine slanted hatching at its edges.
let pencil = {
let mut g = Grain(0x009e_4c11);
let core = rough_band(&mut g, (0.0, 100.0), 40, 0.8, 0.12, |x| ends(x, 0.0, 100.0, 18.0, 0.25));
let mut parts = vec![ink(core, 1.0)];
for i in 0..24 {
let x0 = 2.0 + 92.0 * (i as f64 + g.range(0.0, 0.4)) / 24.0;
let len = g.range(1.5, 3.0);
let t = g.range(0.12, 0.2);
let slant = g.range(0.1, 0.3);
let y0 = if i % 2 == 0 { -g.range(0.85, 1.05) } else { g.range(0.85, 1.25) - t - slant };
parts.push(ink(polygon(&[(x0, y0 + slant), (x0 + len, y0), (x0 + len, y0 + t), (x0, y0 + slant + t)]), 0.6));
}
group(parts)
};
// Wax Crayon, 100 × 6 pt: a dense band with small gaps in its middle and short overlapping
// marks along both edges.
let crayon = {
let mut g = Grain(0x00c0_a7e5);
let taper = |x: f64| ends(x, 0.0, 100.0, 6.0, 0.5);
let body = rough_band(&mut g, (0.0, 100.0), 30, 2.6, 0.2, taper);
let gaps = slivers(&mut g, 16, 2.6, 0.34, ((0.6, 1.6), (0.15, 0.3)), taper);
let mut parts = vec![holed(body, gaps, 0.9)];
for i in 0..36 {
let w = g.range(1.0, 2.2);
let cx = (1.0 + w).max(98.0 * (i as f64 + g.range(0.0, 1.0)) / 36.0).min(99.0 - w);
let side = if i % 2 == 0 { -1.0 } else { 1.0 };
let h = g.range(0.4, 0.6);
// Clear of the gaps, which stay within 0.9 pt of the middle.
let inner = 0.9 + h;
let cy = side * g.range(inner, (2.4 * taper(cx)).max(inner));
let f = fleck(&mut g, cx, cy, w, h);
parts.push(ink(f, 1.0));
}
group(parts)
};
// Charcoal Dust, 100 × 7 pt: a dark band broken into pieces, with flecks of dust either side.
let dust = {
let mut g = Grain(0xc4a2_c0a1);
let mut parts = vec![];
let mut x0 = 0.0;
while x0 < 100.0 {
let x1 = (x0 + g.range(14.0, 24.0)).min(100.0);
let x1 = if 100.0 - x1 < 8.0 { 100.0 } else { x1 };
let piece = rough_band(&mut g, (x0, x1), 10, 2.0, 0.3, |x| ends(x, 0.0, 100.0, 8.0, 0.4) * ends(x, x0, x1, 2.0, 0.3));
parts.push(ink(piece, 1.0));
x0 = x1 + g.range(1.5, 3.0);
}
for i in 0..30 {
let cx = 2.0 + 96.0 * (i as f64 + g.range(0.2, 0.8)) / 30.0;
let side = if g.next() < 0.5 { -1.0 } else { 1.0 };
let s = g.range(0.15, 0.3);
let cy = side * g.range(2.3, 3.5 - s);
let f = fleck(&mut g, cx, cy, s, s);
parts.push(ink(f, if i % 3 == 0 { 0.7 } else { 1.0 }));
}
group(parts)
};
let brushes = vec![
art("Chalk Grain", chalk, Colorization::Tints),
art("Graphite Pencil", pencil, Colorization::Tints),
art("Wax Crayon", crayon, Colorization::Tints),
art("Charcoal Dust", dust, Colorization::Tints),
];
built("Dry Media", Document::new(100.0, 100.0), brushes)
}
// ---------- commands ----------
fn builtin_info(b: &BuiltinBrushLibrary) -> LibraryInfo {
+7 -4
View File
@@ -92,9 +92,9 @@ pub use pdfimport::{LoadOptions, page_document};
pub(crate) use save::job_for;
pub(crate) use save::save as save_document;
pub use save::{
SAVE_FORMATS, SaveJob, SaveMode, SavePlan, StreamWrite, TEMPLATE_FORMATS, dialog_folder, export_folder, leave_out_unreadable_save_paths,
reads_option as save_reads_option, remembered_save_options, save_filters, save_format, save_job, save_plan, save_with, stamp_save_dates,
template_filters, templates_dialog_folder, templates_folder,
SAVE_FORMATS, SaveJob, SaveMode, SavePlan, StreamWrite, TEMPLATE_FORMATS, dialog_folder, documents_dialog_folder, export_folder,
leave_out_unreadable_save_paths, reads_option as save_reads_option, remembered_save_options, save_filters, save_format, save_job, save_plan,
save_with, stamp_save_dates, template_filters, templates_dialog_folder, templates_folder,
};
pub(crate) use screens::{
PARAM_KEYS as SCREEN_PARAM_KEYS, ROW_KEYS as SCREEN_ROW_KEYS, UNWRITTEN_FORMATS as SCREEN_UNWRITTEN_FORMATS,
@@ -123,7 +123,10 @@ mod formats;
#[cfg(not(target_arch = "wasm32"))]
pub(crate) use access::list_dir;
pub use access::write_file_with;
pub use access::{write_file_with, write_save_file, write_save_file_with};
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests_readonly;
#[cfg(not(target_arch = "wasm32"))]
pub(crate) use access::{Placed, copy_new, file_metadata};
pub(crate) use access::{
+25
View File
@@ -112,6 +112,31 @@ pub fn write_file_with(path: &str, fill: &mut dyn FnMut(&mut dyn std::io::Write)
vectorcraft_format::write_atomic_with(std::path::Path::new(path), |f| fill(f)).map_err(|e| EngineError::Other(format!("{path}: {e}")))
}
/// The save commands' writer: preserves a filesystem location refusal as a typed error. Other
/// writers keep their existing errors; an automation-root refusal is never reclassified.
pub fn write_save_file(path: &str, bytes: &[u8]) -> Result<()> {
write_save_file_with(path, &mut |w| w.write_all(bytes))
}
/// [`write_save_file`] for a streamed save.
#[cfg(not(target_arch = "wasm32"))]
pub fn write_save_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| save_write_error(path, e))
}
#[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) }
}
#[cfg(target_arch = "wasm32")]
pub fn write_save_file_with(path: &str, fill: &mut dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>) -> Result<()> {
write_file_with(path, fill)
}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn create_dir(path: &str) -> Result<()> {
may_write(path)?;
+27 -12
View File
@@ -825,6 +825,9 @@ pub(crate) fn size_note(bytes: &[u8]) -> Option<String> {
/// A TIFF with more strips or tiles than the decoder can count
/// ([`vectorcraft_doc::cmyk::oversized_tiff`]) is refused as too large to draw. JPEG XL images are
/// read with [`jxlread`] and stored as PNG, with the ICC profile their colors are left in.
/// A PNG, JPEG, GIF, WebP or TIFF whose orientation ([`exif_orientation`]) turns or flips it is
/// stored as it is shown, with its resolution's axes swapped when it turns a quarter; a CMYK JPEG
/// or TIFF keeps its inks, 8 bits each, as a CMYK TIFF ([`vectorcraft_doc::cmyk::turned_cmyk`]).
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) {
@@ -863,7 +866,16 @@ pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
let f = image_format(kind).ok_or_else(|| err(format!("{kind:?} images can't be opened (see document.formats)")))?;
// A photo whose EXIF orientation turns or flips it (a camera held upright) is stored as it is
// seen, so it places the way it was taken (#4284); the others keep their own bytes.
let turned = matches!(f.id, "png" | "jpg" | "gif" | "webp" | "tiff") && exif_orientation(bytes).is_some();
let orientation = matches!(f.id, "png" | "jpg" | "gif" | "webp" | "tiff").then(|| exif_orientation(bytes)).flatten();
let turned = orientation.is_some();
// The resolution describes the stored pixels; a quarter turn swaps its axes.
let quarter = orientation.is_some_and(|o| o.to_exif() >= 5);
let shown_ppi = ppi.map(|(x, y)| if quarter { (y, x) } else { (x, y) });
if let Some(orientation) = orientation.filter(|_| matches!(f.id, "jpg" | "tiff"))
&& let Some((tiff, size)) = vectorcraft_doc::cmyk::turned_cmyk(bytes, orientation, shown_ppi)
{
return stored(tiff, "image/tiff", size, shown_ppi);
}
let kept = match f.id {
_ if turned => None,
"png" | "jpg" | "gif" | "webp" => Some(bytes.to_vec()),
@@ -879,36 +891,39 @@ pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
vectorcraft_doc::cmyk::extra_samples_tiff_rgba(bytes, |c| cms.cmyk_to_srgb(c, false))
};
let mut img = match (f.id == "tiff").then(extra_samples).flatten() {
Some(img) => img,
Some(img) => image::DynamicImage::ImageRgba8(img),
None => match (f.id == "tiff").then(|| vectorcraft_doc::cmyk::group3_tiff_rgba(bytes)).flatten() {
Some(read) => read.map_err(err)?,
Some(read) => image::DynamicImage::ImageRgba8(read.map_err(err)?),
None => {
use image::ImageDecoder as _;
let mut decoder = reader.into_decoder().map_err(err)?;
let decoder = reader.into_decoder().map_err(err)?;
// The allowance counts the decoded samples and the RGBA pixels they become (#1717).
let (w, h) = decoder.dimensions();
if decoder.total_bytes() > MAX_RASTER_ALLOC || u64::from(w) * u64::from(h) * 4 > MAX_RASTER_ALLOC {
return Err(err(format!("an image of {w} × {h} pixels is too large to draw")));
}
let orientation = decoder.orientation().unwrap_or(image::metadata::Orientation::NoTransforms);
let mut img = image::DynamicImage::from_decoder(decoder).map_err(err)?;
img.apply_orientation(orientation);
img.to_rgba8()
image::DynamicImage::from_decoder(decoder).map_err(err)?
}
},
};
img.apply_orientation(orientation.unwrap_or(image::metadata::Orientation::NoTransforms));
let mut img = img.into_rgba8();
if f.id == "tga" {
super::tgaread::fix_alpha(bytes, &mut img);
}
as_png(img, None, ppi)
as_png(img, None, shown_ppi)
}
/// The EXIF orientation of encoded image `bytes` when it turns or flips the pixels; `None` when
/// it leaves them as stored, or the image has none.
/// it leaves them as stored, or the image has none. A TIFF the image decoder can't open (one with
/// extra samples) has its Orientation tag read from its first image
/// ([`vectorcraft_doc::cmyk::tiff_orientation`]).
pub(crate) fn exif_orientation(bytes: &[u8]) -> Option<image::metadata::Orientation> {
use image::ImageDecoder as _;
let mut decoder = image::ImageReader::new(Cursor::new(bytes)).with_guessed_format().ok()?.into_decoder().ok()?;
decoder.orientation().ok().filter(|o| *o != image::metadata::Orientation::NoTransforms)
use image::metadata::Orientation;
let decoded = || image::ImageReader::new(Cursor::new(bytes)).with_guessed_format().ok()?.into_decoder().ok()?.orientation().ok();
let tagged = || vectorcraft_doc::cmyk::tiff_orientation(bytes).and_then(|v| Orientation::from_exif(u8::try_from(v).ok()?));
decoded().or_else(tagged).filter(|o| *o != Orientation::NoTransforms)
}
/// `img` stored as a PNG that keeps the file's resolution and carries `icc`, the ICC profile its
+7 -2
View File
@@ -157,6 +157,11 @@ fn documents_folder() -> Option<std::path::PathBuf> {
Some(home.join("Documents"))
}
/// A Save As after a refused Save starts in Documents, else home, never the refused folder.
pub fn documents_dialog_folder() -> Option<String> {
documents_folder().filter(|p| p.is_dir()).map(|p| p.to_string_lossy().into_owned()).or_else(home_folder)
}
/// `XDG_DOCUMENTS_DIR` in a `user-dirs.dirs` file's `text`, `$HOME` being `home`. None when it isn't
/// set, is relative, or is the home folder itself (the spec's way of turning it off).
fn xdg_documents(text: &str, home: &std::path::Path) -> Option<std::path::PathBuf> {
@@ -1043,7 +1048,7 @@ pub(crate) fn save(s: &mut Session, mode: SaveMode, p: &Value) -> Result<Value>
let plan = save_plan(s, mode, p)?;
let job = save_job(s, plan)?;
let uid = s.doc()?.uid;
let mut out = job.write_streamed(&mut super::write_file_with)?;
let mut out = job.write_streamed(&mut super::write_save_file_with)?;
job.complete(s, uid);
leave_out_unreadable_save_paths(&mut out, str_param(p, "path"));
Ok(out)
@@ -1170,7 +1175,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
"Save Document",
[],
None,
"{path?, format?: vectorcraft|template|pdf|svg|svgz|ai|eps (default: the path's extension, else the document's own format), options?: {…the format's options, see file.formatOptions; default: as last saved}, svg?: {…SVG options} (an SVG save keeps hidden layers, display:none, unless hiddenLayers is false), …the SVG and PDF options given flat instead (an option given flat or in svg and in options with different values is an error), compress?: bool (native, also in options: gzip; default: the useCompression preference; warnings say when the format doesn't read compress, version, preview or precision given flat, or a key given in options), version?: 4 (3, 2 or 1: for older VectorCraft versions; 1 and 2 are never compressed), preview?: false (embed a PNG of the first artboard, at most 256 px), precision?: 0..9 (native: round path anchors and handles to this many decimal places, a smaller file; colors, transforms and type stay exact; default: exact, and a later save without it writes exactly again), separateArtboards?: false (native and .ai: also save each artboard of `range` to <name>-<artboard>.<ext> beside the file, holding that artboard and the art touching it; the result's files lists every file written), range?: \"1-3, 5\"|\"all\" (default; with separateArtboards), includeLinked?: false (keep linked files' own pixels, not just their previews; they stay linked), embedProfiles?: true (carry the ICC profiles loaded from files that the document is tagged with; opening the file installs them where missing), pdfCompatible?: true (native: also carry a PDF of every artboard; false omits it) | true for .ai (false: blank pages, only the native document; a .ai file's compress, default true, is its compression.compressText), modified?: Unix seconds|null (the File Info modified date, and created date when there is none, a save to a file stamps; default now, recorded in the journal so a replay matches; null: leave the dates)} → {path, format, bytes, warnings, files?: [path…] (the file and its artboards' files), linked?: [path…] (images an SVG links to)}. Save writes one artboard, except a .ai file and EPS (below): a .ai file is a PDF-compatible file of every artboard carrying the native document (preserveEditing always on; PDF options flat or in options), which document.open restores exactly, on the active artboard (the app's, else the one the document opened on; with editingData: false, the first); separateArtboards writes more files, one per artboard. EPS takes the options of document.exportEps: by default one file whose bounding box fits the visible art (the first artboard when no art shows), carrying the whole editable document; useArtboards: true (also when artboard, artboards or range names artboards; file.formatOptions then reports it true) makes the chosen artboard the page, drawn with its background color (without Use Artboards, only the first artboard's page when no art shows has its color), and with two or more chosen the file at the path is the central file of the visible art (again the first artboard when none shows) and each artboard is also written to <name>_<artboard>.eps beside it, holding that artboard; selectedOnly is refused; its PostScript appearance flattens transparency, as EPS requires. Without a path it writes the document's own file in its own format: a document opened from or saved as SVG/PDF/EPS saves as that again (warnings name what the format loses). No path known (never saved, converted from an older version, restored by Data Recovery, or another format) → {dataBase64, format, name, folder?, warnings} and the document stays modified. Under automation read roots, a reply leaves out the document's own file outside them when no path is given (files and linked then name the files by their file names), and a suggested folder outside them. A key that no save format takes, beside the path or in options, and an unknown key inside a PDF option's object or svg, are refused",
"{path?, format?: vectorcraft|template|pdf|svg|svgz|ai|eps (default: the path's extension, else the document's own format), options?: {…the format's options, see file.formatOptions; default: as last saved}, svg?: {…SVG options} (an SVG save keeps hidden layers, display:none, unless hiddenLayers is false), …the SVG and PDF options given flat instead (an option given flat or in svg and in options with different values is an error), compress?: bool (native, also in options: gzip; default: the useCompression preference; warnings say when the format doesn't read compress, version, preview or precision given flat, or a key given in options), version?: 4 (3, 2 or 1: for older VectorCraft versions; 1 and 2 are never compressed), preview?: false (embed a PNG of the first artboard, at most 256 px), precision?: 0..9 (native: round path anchors and handles to this many decimal places, a smaller file; colors, transforms and type stay exact; default: exact, and a later save without it writes exactly again), separateArtboards?: false (native and .ai: also save each artboard of `range` to <name>-<artboard>.<ext> beside the file, holding that artboard and the art touching it; the result's files lists every file written), range?: \"1-3, 5\"|\"all\" (default; with separateArtboards), includeLinked?: false (keep linked files' own pixels, not just their previews; they stay linked), embedProfiles?: true (carry the ICC profiles loaded from files that the document is tagged with; opening the file installs them where missing), pdfCompatible?: true (native: also carry a PDF of every artboard; false omits it) | true for .ai (false: blank pages, only the native document; a .ai file's compress, default true, is its compression.compressText), modified?: Unix seconds|null (the File Info modified date, and created date when there is none, a save to a file stamps; default now, recorded in the journal so a replay matches; null: leave the dates)} → {path, format, bytes, warnings, files?: [path…] (the file and its artboards' files), linked?: [path…] (images an SVG links to)}. Save writes one artboard, except a .ai file and EPS (below): a .ai file is a PDF-compatible file of every artboard carrying the native document (preserveEditing always on; PDF options flat or in options), which document.open restores exactly, on the active artboard (the app's, else the one the document opened on; with editingData: false, the first); separateArtboards writes more files, one per artboard. EPS takes the options of document.exportEps: by default one file whose bounding box fits the visible art (the first artboard when no art shows), carrying the whole editable document; useArtboards: true (also when artboard, artboards or range names artboards; file.formatOptions then reports it true) makes the chosen artboard the page, drawn with its background color (without Use Artboards, only the first artboard's page when no art shows has its color), and with two or more chosen the file at the path is the central file of the visible art (again the first artboard when none shows) and each artboard is also written to <name>_<artboard>.eps beside it, holding that artboard; selectedOnly is refused; its PostScript appearance flattens transparency, as EPS requires. Without a path it writes the document's own file in its own format: a document opened from or saved as SVG/PDF/EPS saves as that again (warnings name what the format loses). No path known (never saved, converted from an older version, restored by Data Recovery, or another format) → {dataBase64, format, name, folder?, warnings} and the document stays modified. Under automation read roots, a reply leaves out the document's own file outside them when no path is given (files and linked then name the files by their file names), and a suggested folder outside them. A key that no save format takes, beside the path or in options, and an unknown key inside a PDF option's object or svg, are refused. A terminal filesystem permission/read-only refusal returns READ_ONLY_LOCATION: followed by the reason; recovery-copy failures keep their original error. Non-UI callers never open a save panel",
has_doc,
|s, p| save(s, SaveMode::Save, p)
),
+248
View File
@@ -907,6 +907,254 @@ fn a_photo_places_the_way_its_exif_orientation_says() {
assert!(red(px.get_pixel(4, 3)) && !red(px.get_pixel(4, 12)), "the left half is on top");
}
/// Where the first stored pixel shows once EXIF (or TIFF) `orientation` turns the image, as
/// (right, bottom): orientations 1 and 5 keep it at the top left, 2 and 6 put it at the top right,
/// 3 and 7 at the bottom right, 4 and 8 at the bottom left. Values outside 1 to 8 leave it.
fn first_pixel_at(orientation: u16) -> (bool, bool) {
match orientation {
2 | 6 => (true, false),
3 | 7 => (true, true),
4 | 8 => (false, true),
_ => (false, false),
}
}
/// A little-endian EXIF block (a TIFF header and directory, as a PNG `eXIf` chunk or a WebP
/// `EXIF` chunk holds it) with an Orientation of `orientation` and an XResolution and YResolution
/// of `x` and `y` pixels per inch.
fn exif_block(orientation: u16, (x, y): (u32, u32)) -> Vec<u8> {
let entry = |tag: u16, kind: u16, value: u32| [&tag.to_le_bytes()[..], &kind.to_le_bytes(), &1u32.to_le_bytes(), &value.to_le_bytes()].concat();
// Orientation, XResolution, YResolution, ResolutionUnit inches; the two rationals follow.
[
b"II".as_slice(),
&[0x2a, 0, 8, 0, 0, 0],
&4u16.to_le_bytes(),
&entry(0x0112, 3, u32::from(orientation)),
&entry(0x011a, 5, 62),
&entry(0x011b, 5, 70),
&entry(0x0128, 3, 2),
&[0, 0, 0, 0],
&[x.to_le_bytes(), 1u32.to_le_bytes(), y.to_le_bytes(), 1u32.to_le_bytes()].concat(),
]
.concat()
}
/// A photo turned a quarter by its EXIF orientation keeps its physical size: the resolution's
/// axes swap with the pixels', in what Place reports and in the stored image. Every orientation
/// puts the first stored pixel in its corner once, and the stored image, read again, is not turned
/// a second time. Values outside 1 to 8 leave the photo as stored.
#[test]
fn a_quarter_turn_swaps_the_resolution_axes() {
// 48 × 32: the top-left 16 × 16 (one whole JPEG MCU) red, the rest white.
let rgb = image::RgbImage::from_fn(48, 32, |x, y| if x < 16 && y < 16 { image::Rgb([220, 0, 0]) } else { image::Rgb([255, 255, 255]) });
let mut jpg = Vec::new();
image::DynamicImage::ImageRgb8(rgb).write_to(&mut Cursor::new(&mut jpg), image::ImageFormat::Jpeg).unwrap();
for orientation in [0u16, 1, 2, 3, 4, 5, 6, 7, 8, 9] {
let exif = [b"Exif\0\0".as_slice(), &exif_block(orientation, (300, 150))].concat();
// Without a JFIF density the resolution comes from the EXIF block.
let mut turned = jpg[..2].to_vec();
turned.extend([0xff, 0xe1]);
turned.extend(u16::try_from(exif.len() + 2).unwrap().to_be_bytes());
turned.extend(&exif);
turned.extend(&jpg[2..]);
let what = format!("orientation {orientation}");
assert_eq!(super::ppi::resolution(&turned), Some((300.0, 150.0)), "{what}: as stored");
let quarter = (5..=8).contains(&orientation);
let (size, ppi) = if quarter { ((32, 48), (150.0, 300.0)) } else { ((48, 32), (300.0, 150.0)) };
let img = raster_image(&turned).unwrap();
assert_eq!(((img.width, img.height), img.ppi), (size, Some(ppi)), "{what}");
assert_eq!(super::ppi::resolution(&img.blob.bytes), Some(ppi), "{what}: the stored image");
let px = image::load_from_memory(&img.blob.bytes).unwrap().to_rgb8();
let red = |x: u32, y: u32| px.get_pixel(x, y)[1] < 80;
let (w, h) = size;
let corners = [(false, false), (true, false), (true, true), (false, true)];
let reds: Vec<_> =
corners.into_iter().filter(|&(right, bottom)| red(if right { w - 4 } else { 4 }, if bottom { h - 4 } else { 4 })).collect();
assert_eq!(reds, [first_pixel_at(orientation)], "{what}: the first stored pixel's corner");
let again = raster_image(&img.blob.bytes).unwrap();
assert_eq!(((again.width, again.height), again.ppi), (size, Some(ppi)), "{what}: read again, it isn't turned again");
}
}
/// `tiff` (little-endian) with an Orientation tag (274) of `value`, a SHORT or, when `long`, a
/// LONG, and, when `y_ppi` is given, a YResolution (283, which `tiff` must have) of that many
/// pixels per inch: its first directory copied to the end of the file with the tag added in order,
/// and the header pointing there, so that every other offset in the file still holds.
fn tiff_oriented(tiff: &[u8], value: u16, long: bool, y_ppi: Option<u32>) -> Vec<u8> {
let at = usize::try_from(u32::from_le_bytes(tiff[4..8].try_into().unwrap())).unwrap();
let n = usize::from(u16::from_le_bytes([tiff[at], tiff[at + 1]]));
let mut entries: Vec<Vec<u8>> = tiff[at + 2..at + 2 + 12 * n].chunks(12).map(<[u8]>::to_vec).collect();
let i = entries.iter().position(|e| u16::from_le_bytes([e[0], e[1]]) > 274).unwrap_or(n);
let (kind, v) = if long { (4u16, u32::from(value).to_le_bytes()) } else { (3, [value.to_le_bytes(), [0, 0]].concat().try_into().unwrap()) };
entries.insert(i, [&274u16.to_le_bytes()[..], &kind.to_le_bytes(), &1u32.to_le_bytes(), &v].concat());
let mut out = tiff.to_vec();
if out.len() % 2 == 1 {
out.push(0);
}
if let Some(y) = y_ppi {
let rational = u32::try_from(out.len()).unwrap();
out.extend([y.to_le_bytes(), 1u32.to_le_bytes()].concat());
let e = entries.iter_mut().find(|e| u16::from_le_bytes([e[0], e[1]]) == 283).unwrap();
e[8..12].copy_from_slice(&rational.to_le_bytes());
}
let ifd = u32::try_from(out.len()).unwrap();
out[4..8].copy_from_slice(&ifd.to_le_bytes());
out.extend(u16::try_from(n + 1).unwrap().to_le_bytes());
out.extend(entries.concat());
out.extend([0; 4]);
out
}
/// TIFFs the image decoder can't read, grayscale with an alpha channel and 1-bit ones compressed
/// with CCITT Group 3, turn and flip as their Orientation tag says, as the others do (#4284),
/// whether the tag is a SHORT or a LONG. A quarter turn swaps the resolution's axes.
#[test]
fn tiffs_read_without_the_image_decoder_follow_their_orientation() {
// 3 × 2 at 150 × 300 ppi, the first pixel black and the rest white, opaque.
let gray = hand_tiff(1, 8, &[2], false, &[vec![0, 255, 255, 255, 255, 255], vec![255; 6]]);
let rows: Vec<Vec<bool>> = (0..2).map(|y| (0..3).map(|x| x == 0 && y == 0).collect()).collect();
let g = vectorcraft_testkit::tiff::Group3 {
rows: &rows,
compression: 2,
t4_options: 0,
photometric: 0,
fill_order: 1,
rows_per_strip: 2,
tile: None,
rtc: false,
};
let fax = vectorcraft_testkit::tiff::group3(&g);
// The Group 3 file declares no resolution.
for (kind, file, y_ppi) in [("Group 3", fax, None), ("gray with alpha", gray, Some(300))] {
assert!(image::load_from_memory(&file).is_err(), "{kind}: the image decoder reads it now");
for (orientation, long) in (1..=8).flat_map(|o| [(o, false), (o, true)]) {
let what = format!("{kind}, orientation {orientation}, LONG {long}");
let img = raster_image(&tiff_oriented(&file, orientation, long, y_ppi)).unwrap_or_else(|e| panic!("{what}: {e}"));
let quarter = orientation >= 5;
let size = if quarter { (2, 3) } else { (3, 2) };
let ppi = y_ppi.map(|y| if quarter { (f64::from(y), 150.0) } else { (150.0, f64::from(y)) });
assert_eq!(((img.width, img.height), img.ppi), (size, ppi), "{what}");
assert_eq!(super::ppi::resolution(&img.blob.bytes), ppi, "{what}: the stored image");
let px = image::load_from_memory(&img.blob.bytes).unwrap().to_luma8();
let (right, bottom) = first_pixel_at(orientation);
let (x, y) = (if right { size.0 - 1 } else { 0 }, if bottom { size.1 - 1 } else { 0 });
let black: Vec<_> = px.enumerate_pixels().filter(|p| p.2[0] < 128).map(|p| (p.0, p.1)).collect();
assert_eq!(black, [(x, y)], "{what}: the first stored pixel's corner");
}
}
}
/// A CMYK TIFF that its Orientation tag turns or flips keeps its inks, turned, whether it stores
/// them together or one plane per ink, at 8 or 16 bits; a quarter turn swaps the resolution's axes.
/// Read again, the stored image is not turned a second time.
#[test]
fn cmyk_tiffs_turned_by_their_orientation_keep_their_inks() {
// 3 × 2 at 150 × 300 ppi: the first pixel full cyan, the others 30% black.
let first: [u8; 4] = [255, 0, 0, 0];
let other: [u8; 4] = [0, 0, 0, 77];
let channel = |i: usize| -> Vec<u16> { (0..6).map(|p| u16::from(if p == 0 { first[i] } else { other[i] })).collect() };
for (bits, planar) in [(8, false), (8, true), (16, false), (16, true)] {
let channels: Vec<Vec<u16>> = (0..4).map(|i| channel(i).iter().map(|v| if bits == 16 { v * 257 } else { *v }).collect()).collect();
let file = hand_tiff(5, bits, &[], planar, &channels);
for orientation in 1..=8 {
let what = format!("{bits} bits, planar {planar}, orientation {orientation}");
let img = raster_image(&tiff_oriented(&file, orientation, false, Some(300))).unwrap_or_else(|e| panic!("{what}: {e}"));
let quarter = orientation >= 5;
let size = if quarter { (2, 3) } else { (3, 2) };
let ppi = if quarter { (300.0, 150.0) } else { (150.0, 300.0) };
assert_eq!(((img.width, img.height), img.ppi, img.blob.mime.as_str()), (size, Some(ppi), "image/tiff"), "{what}");
assert_eq!(super::ppi::resolution(&img.blob.bytes), Some(ppi), "{what}: the stored image");
let inks = img.blob.cmyk().unwrap_or_else(|| panic!("{what}: the inks are lost"));
assert_eq!((inks.width, inks.height), size, "{what}: the inks' size");
let (right, bottom) = first_pixel_at(orientation);
let at = (if right { size.0 - 1 } else { 0 }, if bottom { size.1 - 1 } else { 0 });
for (i, px) in inks.data.chunks(4).enumerate() {
let (x, y) = (u32::try_from(i).unwrap() % size.0, u32::try_from(i).unwrap() / size.0);
assert_eq!(px, if (x, y) == at { first } else { other }, "{what}: the inks of pixel ({x}, {y})");
}
let again = raster_image(&img.blob.bytes).unwrap();
assert_eq!(((again.width, again.height), again.blob.cmyk()), (size, Some(inks)), "{what}: read again, it isn't turned again");
}
}
}
/// A CMYK JPEG that its EXIF orientation turns or flips keeps its inks, turned, stored as a CMYK
/// TIFF; a quarter turn swaps the resolution's axes. Orientation 1 keeps the JPEG as it is, and
/// the stored image, read again, is not turned a second time.
#[test]
fn cmyk_jpegs_turned_by_their_orientation_keep_their_inks() {
use vectorcraft_render::encode::jpeg::{self, ColorModel, JpegOptions};
// 48 × 32: the top-left 16 × 16 (one whole JPEG MCU) full cyan, the rest 30% black.
let inks: Vec<u8> =
(0..32u32).flat_map(|y| (0..48u32).flat_map(move |x| if x < 16 && y < 16 { [255, 0, 0, 0] } else { [0, 0, 0, 77] })).collect();
let o = JpegOptions { color_model: ColorModel::Cmyk, embed_icc: false, ..Default::default() };
let jpg = jpeg::encode(&inks, 48, 32, 100, None, &o).unwrap();
for orientation in 1..=8u16 {
let exif = [b"Exif\0\0".as_slice(), &exif_block(orientation, (300, 150))].concat();
let mut file = jpg[..2].to_vec();
file.extend([0xff, 0xe1]);
file.extend(u16::try_from(exif.len() + 2).unwrap().to_be_bytes());
file.extend(&exif);
file.extend(&jpg[2..]);
let what = format!("orientation {orientation}");
let quarter = orientation >= 5;
let (size, ppi) = if quarter { ((32, 48), (150.0, 300.0)) } else { ((48, 32), (300.0, 150.0)) };
let mime = if orientation == 1 { "image/jpeg" } else { "image/tiff" };
let img = raster_image(&file).unwrap_or_else(|e| panic!("{what}: {e}"));
assert_eq!(((img.width, img.height), img.ppi, img.blob.mime.as_str()), (size, Some(ppi), mime), "{what}");
assert_eq!(super::ppi::resolution(&img.blob.bytes), Some(ppi), "{what}: the stored image");
let inks = img.blob.cmyk().unwrap_or_else(|| panic!("{what}: the inks are lost"));
assert_eq!((inks.width, inks.height), size, "{what}: the inks' size");
let (w, h) = size;
let at = |x: u32, y: u32| inks.data[usize::try_from((y * w + x) * 4).unwrap()..][..4].to_vec();
let cyan = |p: &[u8]| p[0] > 200 && p[3] < 40;
let corners = [(false, false), (true, false), (true, true), (false, true)];
let cyans: Vec<_> =
corners.into_iter().filter(|&(right, bottom)| cyan(&at(if right { w - 4 } else { 4 }, if bottom { h - 4 } else { 4 }))).collect();
assert_eq!(cyans, [first_pixel_at(orientation)], "{what}: the first stored pixel's corner");
let black = at(w / 2, h / 2);
assert!(black[0] < 40 && (60..=95).contains(&black[3]), "{what}: the other inks, {black:?}");
let again = raster_image(&img.blob.bytes).unwrap();
assert_eq!(((again.width, again.height), again.blob.cmyk()), (size, Some(inks)), "{what}: read again, it isn't turned again");
}
}
/// A PNG (its `eXIf` chunk and `pHYs` resolution), a WebP (its `EXIF` chunk) and an RGB TIFF read
/// by the image decoder, turned a quarter by their orientation, swap their resolution's axes; a
/// half turn keeps them.
#[test]
fn png_webp_and_rgb_tiff_turned_a_quarter_swap_their_resolution() {
use image::ImageEncoder as _;
let rgb = image::RgbImage::from_fn(3, 2, |x, y| image::Rgb(if x == 0 && y == 0 { [0, 0, 0] } else { [255, 255, 255] }));
for orientation in [3u16, 6, 8] {
let mut png = Vec::new();
let mut enc = image::codecs::png::PngEncoder::new(&mut png);
enc.set_exif_metadata(exif_block(orientation, (150, 300))).unwrap();
enc.write_image(rgb.as_raw(), 3, 2, image::ExtendedColorType::Rgb8).unwrap();
let png = super::ppi::with_png_resolution(&png, (150.0, 300.0));
let mut webp = Vec::new();
let mut enc = image::codecs::webp::WebPEncoder::new_lossless(&mut webp);
enc.set_exif_metadata(exif_block(orientation, (150, 300))).unwrap();
enc.write_image(rgb.as_raw(), 3, 2, image::ExtendedColorType::Rgb8).unwrap();
let channel = |c: usize| -> Vec<u16> { rgb.pixels().map(|p| u16::from(p[c])).collect() };
let tiff = tiff_oriented(&hand_tiff(2, 8, &[], false, &[channel(0), channel(1), channel(2)]), orientation, false, Some(300));
for (kind, file) in [("PNG", png), ("WebP", webp), ("TIFF", tiff)] {
let what = format!("{kind}, orientation {orientation}");
assert_eq!(super::ppi::resolution(&file), Some((150.0, 300.0)), "{what}: as stored");
let quarter = orientation >= 5;
let (size, ppi) = if quarter { ((2, 3), (300.0, 150.0)) } else { ((3, 2), (150.0, 300.0)) };
let img = raster_image(&file).unwrap_or_else(|e| panic!("{what}: {e}"));
assert_eq!(((img.width, img.height), img.ppi), (size, Some(ppi)), "{what}");
assert_eq!(super::ppi::resolution(&img.blob.bytes), Some(ppi), "{what}: the stored image");
let px = image::load_from_memory(&img.blob.bytes).unwrap().to_luma8();
let (right, bottom) = first_pixel_at(orientation);
let at = (if right { size.0 - 1 } else { 0 }, if bottom { size.1 - 1 } else { 0 });
let black: Vec<_> = px.enumerate_pixels().filter(|p| p.2[0] < 128).map(|p| (p.0, p.1)).collect();
assert_eq!(black, [at], "{what}: the first stored pixel's corner");
}
}
}
/// With `importer` named, a file up to the importer's limit is read whole and a larger one is an
/// error, whatever its content.
#[test]
@@ -0,0 +1,52 @@
//! Save errors retain their type without changing the other filesystem writers (#6146).
use std::io::{self, ErrorKind};
use serde_json::json;
use super::{SaveMode, access, save_plan, save_with, write_file_with, write_save_file_with};
use crate::{EngineError, READ_ONLY_LOCATION, Session};
#[test]
fn readonly_error_is_typed_and_other_writers_keep_their_error() {
let dir = vectorcraft_testkit::temp_dir("save-refusal");
let path = dir.join("Poster.vectorcraft").to_string_lossy().into_owned();
for kind in [ErrorKind::PermissionDenied, ErrorKind::ReadOnlyFilesystem, ErrorKind::StorageFull, ErrorKind::NotFound, ErrorKind::Other] {
let typed = write_save_file_with(&path, &mut |_| Err(io::Error::new(kind, "injected"))).unwrap_err();
let ordinary = write_file_with(&path, &mut |_| Err(io::Error::new(kind, "injected"))).unwrap_err();
let reason = format!("{path}: injected");
assert!(matches!(&ordinary, EngineError::Other(_)));
assert_eq!(ordinary.to_string(), reason);
if matches!(kind, ErrorKind::PermissionDenied | ErrorKind::ReadOnlyFilesystem) {
assert!(matches!(&typed, EngineError::ReadOnlyLocation(_)));
assert_eq!(typed.to_string(), format!("{READ_ONLY_LOCATION}: {reason}"));
} else {
assert!(matches!(&typed, EngineError::Other(_)));
assert_eq!(typed.to_string(), reason);
}
assert!(!std::path::Path::new(&path).exists());
}
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn readonly_failed_save_keeps_document_and_options() {
let mut session = Session::new();
session.execute("file.new", &json!({"width": 40, "height": 40})).unwrap();
session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 10, "height": 10})).unwrap();
let st = session.doc_mut().unwrap();
st.path = Some("Poster.svg".into());
st.format = "svg";
st.save_options = json!({"decimals": 3}).as_object().unwrap().clone();
let before = serde_json::to_value(&*st.doc).unwrap();
let options = st.save_options.clone();
let plan = save_plan(&session, SaveMode::Save, &json!({"modified": null})).unwrap();
let e = save_with(&mut session, plan, |path, _| Err(access::save_write_error(path, io::Error::from(ErrorKind::PermissionDenied)))).unwrap_err();
assert!(matches!(e, EngineError::ReadOnlyLocation(_)));
let st = session.doc().unwrap();
assert_eq!(st.path.as_deref(), Some("Poster.svg"));
assert_eq!(st.format, "svg");
assert_eq!(st.save_options, options);
assert!(st.is_dirty());
assert_eq!(serde_json::to_value(&*st.doc).unwrap(), before);
}
@@ -730,7 +730,7 @@ fn a_refused_export_into_a_presets_folder_outside_the_read_root_names_it_by_its_
let settings = json!({"formats": [{"format": "png"}], "folder": parent});
s.execute("document.exportPresets.save", &json!({"name": "Parent", "settings": settings})).unwrap();
let e = confine(confined.as_ref(), || s.execute("document.exportForScreens", &json!({"exportPreset": "Parent"}))).unwrap_err().to_string();
let root = inside.display().to_string();
let root = crate::cmd::findfiles::plain(inside.canonicalize().unwrap()).display().to_string();
let name = tmp.0.file_name().unwrap().to_string_lossy().into_owned();
assert!(e.contains(&format!("root {root}: {name}")), "{e}");
}
+11 -1
View File
@@ -183,6 +183,16 @@ fn a_picked_folder_inside_other_apps_folders_is_refused() {
assert!(p.error().is_some_and(|e| e.ends_with("is not a folder")), "{p:?}");
let p = search(&root, "missing", Limits::default(), 1, &[]);
assert!(p.error().is_some_and(|e| e.starts_with(&root.join("missing").display().to_string())), "{p:?}");
// Each failure has the same reason without the folder's path.
let briefs = [
("missing", "the folder can't be read"),
("file.ttf", "the path isn't a folder"),
("refused", "VectorCraft doesn't search other apps' or the system's folders"),
("Users/Public/x", "VectorCraft doesn't search the Shared or Public folder in Users"),
];
for (picked, why) in briefs {
assert_eq!(search(&root, picked, Limits::default(), 1, &[]).failure(), Some(why), "{picked}");
}
}
#[test]
@@ -362,7 +372,7 @@ fn a_picked_folder_that_cant_be_listed_fails_the_search() {
let p = search(&root, "locked", Limits::default(), 2, &["y.ttf"]);
std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o755)).unwrap();
if enforced {
assert!(matches!(&p.end, Some(End::Failed(e)) if e.contains("locked")), "{p:?}");
assert!(matches!(&p.end, Some(End::Failed(e, "the folder can't be listed")) if e.contains("locked")), "{p:?}");
} else {
assert_eq!(found(&root, &p), ["locked/y.ttf"]);
}
+51 -15
View File
@@ -23,6 +23,13 @@ const CHECK_EVERY: u64 = 1024;
/// How a search ends when every walker thread stopped on a bug.
const INTERNAL: &str = "every search thread stopped on an internal error (please report this bug)";
/// Why a search couldn't start, without the folder's path ([`Progress::failure`]).
const UNREADABLE: &str = "the folder can't be read";
const NOT_A_FOLDER: &str = "the path isn't a folder";
const SHARED: &str = "VectorCraft doesn't search the Shared or Public folder in Users";
const APPS: &str = "VectorCraft doesn't search other apps' or the system's folders";
const UNLISTED: &str = "the folder can't be listed";
/// What a search looks for.
pub trait Visitor: Send + Sync {
/// Whether the regular file named `name` is to be read: asked of the files a folder lists until
@@ -77,8 +84,9 @@ pub enum End {
/// reached their [`Limits`]. Folders deeper than [`Limits::depth`] are skipped and an item
/// keeps at most [`Limits::per_item`] files, without ending the search.
Limit,
/// It couldn't start: the folder can't be read, isn't a folder or isn't one to search.
Failed(String),
/// It couldn't start: the folder can't be read, isn't a folder or isn't one to search. Why,
/// and the same without the folder's path.
Failed(String, &'static str),
}
/// Where a search stands ([`Search::progress`]).
@@ -114,7 +122,7 @@ impl Progress {
None => "searching",
Some(End::Done | End::Found) => "done",
Some(End::Stopped | End::Time | End::Limit) => "stopped",
Some(End::Failed(_)) => "failed",
Some(End::Failed(..)) => "failed",
}
}
@@ -131,10 +139,38 @@ impl Progress {
/// Why a failed search failed.
pub fn error(&self) -> Option<&str> {
match &self.end {
Some(End::Failed(e)) => Some(e),
Some(End::Failed(e, _)) => Some(e),
_ => None,
}
}
/// Why a failed search failed, without the folder's path.
pub fn failure(&self) -> Option<&'static str> {
match &self.end {
Some(End::Failed(_, why)) => Some(why),
_ => None,
}
}
/// Keep what the caller asking now may read under its read roots ([`crate::file_access::current`]),
/// for a reply to it: the files found inside them. Returns the folder searched (`given` until a
/// walker checked it) and why the search failed, when that folder lies inside them too;
/// otherwise no folder and why without its path ([`Self::failure`]). Without read roots in
/// force, everything is kept.
pub fn keep_readable(&mut self, given: &str) -> (Option<String>, Option<String>) {
let folder = if self.folder.as_os_str().is_empty() { given.to_string() } else { self.folder.to_string_lossy().into_owned() };
if crate::file_access::current().is_none() {
return (Some(folder), self.error().map(str::to_string));
}
// A path that isn't valid text is never shown: its lossy form names another file.
let readable = |p: &Path| p.to_str().is_some_and(|p| crate::file_access::check_read(p).is_ok());
self.hits.retain(|(path, _)| readable(path));
if readable(Path::new(given)) && (self.folder.as_os_str().is_empty() || readable(&self.folder)) {
(Some(folder), self.error().map(str::to_string))
} else {
(None, self.failure().map(str::to_string))
}
}
}
/// Walker threads shared out among searches: all of them together run at most `cap` threads.
@@ -306,7 +342,7 @@ pub(crate) fn start_in(
return Err("the search couldn't start: try again in a moment".into());
}
if w.alive == 0 && w.end.is_none() {
shared.finish(&mut w, End::Failed(INTERNAL.into()));
shared.finish(&mut w, End::Failed(INTERNAL.into(), INTERNAL));
}
}
Ok(Search { shared })
@@ -401,13 +437,13 @@ impl Shared {
fn prepare(&self, root: &Path) {
let rules = self.rules.get_or_init(|| self.given.clone().unwrap_or_else(Rules::system));
let path = root.display();
let checked = match std::fs::canonicalize(root) {
Err(e) => Err(format!("{path}: {e}")),
Ok(folder) if !folder.is_dir() => Err(format!("{path} is not a folder")),
let (checked, brief) = match std::fs::canonicalize(root) {
Err(e) => (Err(format!("{path}: {e}")), UNREADABLE),
Ok(folder) if !folder.is_dir() => (Err(format!("{path} is not a folder")), NOT_A_FOLDER),
Ok(folder) => match rules.refusal(&folder) {
None => Ok(folder),
Some(Refusal::Shared) => Err(format!("VectorCraft doesn't search the Shared or Public folder in Users: {path}")),
Some(Refusal::Apps) => Err(format!("VectorCraft doesn't search other apps' or the system's folders: {path}")),
None => (Ok(folder), INTERNAL),
Some(Refusal::Shared) => (Err(format!("VectorCraft doesn't search the Shared or Public folder in Users: {path}")), SHARED),
Some(Refusal::Apps) => (Err(format!("VectorCraft doesn't search other apps' or the system's folders: {path}")), APPS),
},
};
let mut w = self.lock();
@@ -416,7 +452,7 @@ impl Shared {
w.folder = folder.clone();
w.stack.push((folder, 0));
}
Err(e) => self.finish(&mut w, End::Failed(e)),
Err(e) => self.finish(&mut w, End::Failed(e, brief)),
}
}
@@ -430,7 +466,7 @@ impl Shared {
let mut w = self.lock();
// The picked folder itself: the search can't run, and says why.
if depth == 0 {
self.finish(&mut w, End::Failed(format!("{}: {e}", plain(dir.to_path_buf()).display())));
self.finish(&mut w, End::Failed(format!("{}: {e}", plain(dir.to_path_buf()).display()), UNLISTED));
} else {
w.unreadable += 1;
w.folders += 1;
@@ -610,7 +646,7 @@ fn walker(s: &Shared) {
if done.is_err() {
let mut w = s.lock();
match job {
Job::Prepare(_) => s.finish(&mut w, End::Failed(INTERNAL.into())),
Job::Prepare(_) => s.finish(&mut w, End::Failed(INTERNAL.into(), INTERNAL)),
Job::List(..) => w.unreadable += 1,
}
}
@@ -640,7 +676,7 @@ impl Drop for Alive {
let mut w = self.0.lock();
w.alive = w.alive.saturating_sub(1);
if w.alive == 0 && w.end.is_none() {
self.0.finish(&mut w, End::Failed(INTERNAL.into()));
self.0.finish(&mut w, End::Failed(INTERNAL.into(), INTERNAL));
}
drop(w);
self.0.pool.release(1);
+18 -10
View File
@@ -76,7 +76,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Find Font Files",
[],
None,
"{folder?: an absolute path, fonts?: [{family, style?}] (1 to 1000; default: the active document's missing fonts, as text.missingFonts lists them), maxSeconds?: 60 (1 to 600), stop?: false (true: stop the last search)} with folder: look in it and its subfolders for font files that make the fonts available, on separate threads, and answer at once (state: searching); without folder: the last search's state, with the files found so far. A search reads the table directories and the name, fvar and OS/2 tables of .ttf, .otf, .ttc and .otc files of at most 256 MB and, on macOS, of suitcase fonts (files without an extension or with .suit, whose fonts are in a resource fork of at most 8 MB), and lists a file for a font when the file, added with text.addFontFiles, makes the font resolve exactly as text.fonts resolves it; fonts that resolve exactly already are left out. It doesn't enter app packages, folders named Program Files (also x86 and Arm), ProgramData, $Recycle.Bin or System Volume Information, the system's folders at the root of a volume, the Shared and Public folders in Users, a home folder's Library, AppData, Applications, snap and dot folders, a Library folder's app data folders or the folders the environment names for apps' data, and a search of a folder inside one of them fails; the walk also skips other hidden folders, folders whose contents are in the cloud and folders more than 64 levels deep, and follows no links (a picked path is resolved through its links); none on the web → {id (absent while idle), state: idle|searching|done|stopped|failed, folder?, fonts: [{family, style, status, files: [paths]}], searched?: {folders, files, fontFiles}, skipped?, unreadable?, stopped?: stop|time|limit, error?, seconds?}",
"{folder?: an absolute path, fonts?: [{family, style?}] (1 to 1000; default: the active document's missing fonts, as text.missingFonts lists them), maxSeconds?: 60 (1 to 600), stop?: false (true: stop the last search)} with folder: look in it and its subfolders for font files that make the fonts available, on separate threads, and answer at once (state: searching); without folder: the last search's state, with the files found so far. A search reads the table directories and the name, fvar and OS/2 tables of .ttf, .otf, .ttc and .otc files of at most 256 MB and, on macOS, of suitcase fonts (files without an extension or with .suit, whose fonts are in a resource fork of at most 8 MB), and lists a file for a font when the file, added with text.addFontFiles, makes the font resolve exactly as text.fonts resolves it; fonts that resolve exactly already are left out. It doesn't enter app packages, folders named Program Files (also x86 and Arm), ProgramData, $Recycle.Bin or System Volume Information, the system's folders at the root of a volume, the Shared and Public folders in Users, a home folder's Library, AppData, Applications, snap and dot folders, a Library folder's app data folders or the folders the environment names for apps' data, and a search of a folder inside one of them fails; the walk also skips other hidden folders, folders whose contents are in the cloud and folders more than 64 levels deep, and follows no links (a picked path is resolved through its links). With automation read roots, a reply leaves out the files found outside the caller's roots, and the folder when it is outside them (error then gives the reason without the path); none on the web → {id (absent while idle), state: idle|searching|done|stopped|failed, folder?, fonts: [{family, style, status, files: [paths]}], searched?: {folders, files, fontFiles}, skipped?, unreadable?, stopped?: stop|time|limit, error?, seconds?}",
always,
find
),
@@ -85,7 +85,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Add Font Files",
[],
None,
"{files: [paths the last text.findFontFiles search found] (1 to 1000)} copy the font files into VectorCraft's own Fonts folder (next to the preferences; the desktop app and vectorcraft-cli read it), never replacing a file there: the names Name.otf, Name 2.otf … Name 99.otf are tried in turn until one is free, which gets the copy, or is a file with the same contents, which is kept; then scan the fonts again, as text.rescanFonts does, and type set in them redraws. Only regular .ttf, .otf, .ttc, .otc, .woff and .woff2 files and suitcase fonts (with their resource fork) are copied, at most 256 MB a file and 1 GB in all; any other file is skipped. Add only fonts you own or are licensed to install; none on the web → {folder, copied: [{from, to}], kept: [{from, to}], skipped: [{file, reason}], families?, faces?}",
"{files: [paths the last text.findFontFiles search found] (1 to 1000)} copy the font files into VectorCraft's own Fonts folder (next to the preferences; the desktop app and vectorcraft-cli read it), never replacing a file there: the names Name.otf, Name 2.otf … Name 99.otf are tried in turn until one is free, which gets the copy, or is a file with the same contents, which is kept; then scan the fonts again, as text.rescanFonts does, and type set in them redraws. Only regular .ttf, .otf, .ttc, .otc, .woff and .woff2 files and suitcase fonts (with their resource fork) are copied, at most 256 MB a file and 1 GB in all; any other file is skipped. Add only fonts you own or are licensed to install. With automation read roots, folder is null when the Fonts folder is outside them, and a to or file path outside them is given as its file name; none on the web → {folder, copied: [{from, to}], kept: [{from, to}], skipped: [{file, reason}], families?, faces?}",
always,
add
),
@@ -275,7 +275,9 @@ fn find(s: &mut Session, p: &Value) -> Result<Value> {
/// Where the session's last search stands (`text.findFontFiles` without `folder`).
fn state(s: &Session) -> Value {
let Some(f) = &s.font_search else { return json!({ "state": "idle", "fonts": [] }) };
let p = f.search.progress();
let mut p = f.search.progress();
// Only what the caller asking now may read: a search another caller started can hold more.
let (folder, error) = p.keep_readable(&f.folder);
let mut files: Vec<Vec<String>> = vec![vec![]; f.fonts.len()];
for (path, items) in &p.hits {
for i in items {
@@ -293,16 +295,18 @@ fn state(s: &Session) -> Value {
json!({ "family": font.family, "style": font.style, "status": font.status.as_str(), "files": files })
})
.collect();
let folder = if p.folder.as_os_str().is_empty() { f.folder.clone() } else { p.folder.to_string_lossy().into_owned() };
let mut out = json!({
"id": f.id, "state": p.state(), "folder": folder, "fonts": fonts,
"id": f.id, "state": p.state(), "fonts": fonts,
"searched": { "folders": p.folders, "files": p.files, "fontFiles": p.read },
"skipped": p.skipped, "unreadable": p.unreadable, "seconds": (p.seconds * 10.0).round() / 10.0,
});
if let Some(folder) = folder {
out["folder"] = json!(folder);
}
if let Some(why) = p.stopped() {
out["stopped"] = json!(why);
}
if let Some(e) = p.error() {
if let Some(e) = error {
out["error"] = json!(e);
}
out
@@ -348,12 +352,16 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
// VectorCraft's own Fonts folder: no automation root applies to it.
crate::file_access::unconfined(|| super::fileio::create_dir(&dir.to_string_lossy()))?;
let report = copy_into(&files, dir);
let pairs = |v: &[(PathBuf, PathBuf)]| {
v.iter().map(|(from, to)| json!({ "from": from.to_string_lossy(), "to": to.to_string_lossy() })).collect::<Vec<_>>()
// The caller sees the Fonts folder and the copies in it only where its read roots reach.
let readable = |p: &Path| crate::file_access::current().is_none() || p.to_str().is_some_and(|p| crate::file_access::check_read(p).is_ok());
let shown = |p: &Path| -> String {
let shown = if readable(p) { Some(p.as_os_str()) } else { p.file_name() };
shown.map(|s| s.to_string_lossy().into_owned()).unwrap_or_default()
};
let pairs = |v: &[(PathBuf, PathBuf)]| v.iter().map(|(from, to)| json!({ "from": from.to_string_lossy(), "to": shown(to) })).collect::<Vec<_>>();
let mut out = json!({
"folder": dir.to_string_lossy(), "copied": pairs(&report.copied), "kept": pairs(&report.kept),
"skipped": report.skipped.iter().map(|(file, why)| json!({ "file": file.to_string_lossy(), "reason": why })).collect::<Vec<_>>(),
"folder": readable(dir).then(|| dir.to_string_lossy()), "copied": pairs(&report.copied), "kept": pairs(&report.kept),
"skipped": report.skipped.iter().map(|(file, why)| json!({ "file": shown(file), "reason": why })).collect::<Vec<_>>(),
});
if !report.copied.is_empty() || !report.kept.is_empty() {
// The fonts are cataloged and type set in them redraws, as Refresh Font List does it.
+16 -7
View File
@@ -29,7 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Find Linked Files",
[],
None,
"{folder?: an absolute path, ids?: [image or placed document ids] (default: the active document's missing links), maxSeconds?: 60 (1 to 600), stop?: false (true: stop the last search)} with folder: look in it and its subfolders, on separate threads, for files with the names of the linked files (in any letter case), and answer at once with the search's state (searching while it runs); without folder: the last search's state, with the files found so far. Each linked file's files come best first: same (the size and hash saved with the link), size (the saved size, where there is no saved hash or the file is larger than 1 GiB), then name. Within each kind, a file whose name has the link's letter case comes first. Then each file's folder names are compared with the saved path's, from the innermost outward up to the first one that differs, and a file with more matching names comes first; files that still tie are listed by path. Before the comparison, the saved path's parent-folder steps (.., or the empty components of a classic Mac :: run) are resolved, and . components in a slash path are skipped. A search looks for at most 1000 linked files and keeps the first 10 files of each one's name, and up to 10 that are the same file; it ends once every linked file has its same file, and searches only the folders text.findFontFiles may search, with the same maxSeconds, depth and count limits; none on the web → {id (absent while idle), state: idle|searching|done|stopped|failed, folder?, links: [{name, path, ids, files: [{path, size, match: same|size|name, caseDiffers?: true}]}], searched?: {folders, files, read}, skipped?, unreadable?, stopped?: stop|time|limit, error?, seconds?}",
"{folder?: an absolute path, ids?: [image or placed document ids] (default: the active document's missing links), maxSeconds?: 60 (1 to 600), stop?: false (true: stop the last search)} with folder: look in it and its subfolders, on separate threads, for files with the names of the linked files (in any letter case), and answer at once with the search's state (searching while it runs); without folder: the last search's state, with the files found so far. Each linked file's files come best first: same (the size and hash saved with the link), size (the saved size, where there is no saved hash or the file is larger than 1 GiB), then name. Within each kind, a file whose name has the link's letter case comes first. Then each file's folder names are compared with the saved path's, from the innermost outward up to the first one that differs, and a file with more matching names comes first; files that still tie are listed by path. Before the comparison, the saved path's parent-folder steps (.., or the empty components of a classic Mac :: run) are resolved, and . components in a slash path are skipped. A search looks for at most 1000 linked files and keeps the first 10 files of each one's name, and up to 10 that are the same file; it ends once every linked file has its same file, and searches only the folders text.findFontFiles may search, with the same maxSeconds, depth and count limits. With automation read roots, a reply leaves out the files found outside the caller's roots, a link's path outside them, and the folder when it is outside them (error then gives the reason without the path); none on the web → {id (absent while idle), state: idle|searching|done|stopped|failed, folder?, links: [{name, path?, ids, files: [{path, size, match: same|size|name, caseDiffers?: true}]}], searched?: {folders, files, read}, skipped?, unreadable?, stopped?: stop|time|limit, error?, seconds?}",
always,
find
)]
@@ -52,6 +52,8 @@ pub(crate) struct LinkSearch {
pub(crate) id: u64,
/// The folder as given.
pub(crate) folder: String,
/// The path of the document the links were taken from, which a relative link path starts from.
pub(crate) doc: Option<String>,
pub(crate) links: Vec<Sought>,
/// The size of each file read, by the path the search reports ([`LinkFiles::sizes`]).
pub(crate) sizes: Arc<Mutex<HashMap<PathBuf, u64>>>,
@@ -163,6 +165,7 @@ fn find(s: &mut Session, p: &Value) -> Result<Value> {
if links.is_empty() {
return Err(bad(C, if ids.is_some() { "these objects show no linked files" } else { "no linked files are missing" }));
}
let doc = super::links::LinkBase::of(st).doc.map(str::to_string);
// A new search stops the last one.
s.link_search = None;
let threads = s.search_threads.unwrap_or_else(findfiles::threads);
@@ -171,7 +174,7 @@ fn find(s: &mut Session, p: &Value) -> Result<Value> {
let visitor = Arc::new(LinkFiles::new(&links, sizes.clone()));
let search =
findfiles::start(PathBuf::from(&folder), s.search_rules.clone(), limits, threads, 2 * links.len(), visitor).map_err(EngineError::Other)?;
s.link_search = Some(LinkSearch { id: NEXT.fetch_add(1, Ordering::Relaxed), folder, links, sizes, search });
s.link_search = Some(LinkSearch { id: NEXT.fetch_add(1, Ordering::Relaxed), folder, doc, links, sizes, search });
Ok(state(s))
}
@@ -209,7 +212,9 @@ fn shared_folders(saved: &str, found: &Path) -> usize {
/// Where the session's last search stands (`links.findFiles` without `folder`).
fn state(s: &Session) -> Value {
let Some(l) = &s.link_search else { return json!({ "state": "idle", "links": [] }) };
let p = l.search.progress();
let mut p = l.search.progress();
// Only what the caller asking now may read: a search another caller started can hold more.
let (folder, error) = p.keep_readable(&l.folder);
let n = l.links.len();
let sizes = lock(&l.sizes).clone();
// Per linked file: the files found, each with whether it is the same file.
@@ -267,19 +272,23 @@ fn state(s: &Session) -> Value {
f
})
.collect();
json!({ "name": link.name, "path": link.path, "ids": link.ids, "files": files })
let mut row = json!({ "name": link.name, "ids": link.ids, "files": files });
super::links::note_path(&mut row, "path", &link.path, l.doc.as_deref());
row
})
.collect();
let folder = if p.folder.as_os_str().is_empty() { l.folder.clone() } else { p.folder.to_string_lossy().into_owned() };
let mut out = json!({
"id": l.id, "state": p.state(), "folder": folder, "links": links,
"id": l.id, "state": p.state(), "links": links,
"searched": { "folders": p.folders, "files": p.files, "read": p.read },
"skipped": p.skipped, "unreadable": p.unreadable, "seconds": (p.seconds * 10.0).round() / 10.0,
});
if let Some(folder) = folder {
out["folder"] = json!(folder);
}
if let Some(why) = p.stopped() {
out["stopped"] = json!(why);
}
if let Some(e) = p.error() {
if let Some(e) = error {
out["error"] = json!(e);
}
out
+3 -3
View File
@@ -436,7 +436,7 @@ pub(crate) fn full_linked_images<'a>(d: &'a Document, base: LinkBase) -> (Cow<'a
continue;
};
let preview = d.images.get(&key).map(|b| b.bytes.clone());
// A file read as it is keeps its own type; one turned upright (EXIF orientation) is the PNG it became.
// A file read as it is keeps its own type; one turned upright by its orientation is the PNG, or CMYK TIFF, it became.
let mime = match fileio::format_for_name(g.link.name()) {
Some(f) if img.blob.bytes.as_slice() == bytes.as_slice() => f.mime.to_string(),
_ => img.blob.mime.clone(),
@@ -898,12 +898,12 @@ fn rows<'a>(gs: impl Iterator<Item = &'a Group>, doc_path: Option<&str>) -> Vec<
/// May a reply to the caller asking now carry the link path `path` (of the document saved at
/// `doc_path`)? Always without read roots in force; with them, only when the file it names (a
/// relative path taken from the document's folder) lies inside them.
fn path_shown(path: &str, doc_path: Option<&str>) -> bool {
pub(crate) fn path_shown(path: &str, doc_path: Option<&str>) -> bool {
crate::file_access::current().is_none() || fileio::document_path(path, doc_path).is_ok_and(|p| crate::file_access::check_read(&p).is_ok())
}
/// `row[key] = path` when [`path_shown`] says so; otherwise `row` has no `key`.
fn note_path(row: &mut Value, key: &str, path: &str, doc_path: Option<&str>) {
pub(crate) fn note_path(row: &mut Value, key: &str, path: &str, doc_path: Option<&str>) {
if path_shown(path, doc_path) {
row[key] = json!(path);
} else if let Some(o) = row.as_object_mut() {
+4 -4
View File
@@ -145,7 +145,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Make with Warp…",
["Object", "Envelope Distort"],
Some("Cmd+Alt+Shift+W"),
"{ids?, style?: arc|arcLower|arcUpper|arch|bulge|shellLower|shellUpper|flag|wave|fish|rise|fisheye|inflate|squeeze|twist (arc), bend?: % -100..100 (50), h?: horizontal distortion % -100..100 (0), v?: vertical distortion % (0), horizontal?: bool (true) | orientation?: horizontal|vertical, horizontalDistortion?: as h, verticalDistortion?: as v} envelope the selected objects with a warp (Envelope Options from object.envelope.options with nothing selected; type maps from its glyph outline bounds) → {id}",
"{ids?, style?: arc|arcLower|arcUpper|arch|bulge|shellLower|shellUpper|flag|wave|fish|rise|fisheye|inflate|squeeze|twist (arc), bend?: % -100..100 (50), h?: horizontal distortion % -100..100 (0), v?: vertical distortion % (0), horizontal?: bool (true) | orientation?: horizontal|vertical, horizontalDistortion?: as h, verticalDistortion?: as v, version?: 0|1 (1: each style bends the bounds as one Bézier patch; 0: VectorCraft's earlier map)} envelope the selected objects with a warp (Envelope Options from object.envelope.options with nothing selected; type maps from its glyph outline bounds) → {id}",
has_selection,
env_make_warp
),
@@ -172,7 +172,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Reset with Warp…",
["Object", "Envelope Distort"],
None,
"{style?, bend?, h?, v?, horizontal? | orientation? (as makeWithWarp; unset: the envelope's current warp, else arc 50 %), horizontalDistortion?: as h, verticalDistortion?: as v} make the selected envelopes warp envelopes, keeping their content",
"{style?, bend?, h?, v?, horizontal? | orientation? (as makeWithWarp; unset: the envelope's current warp, else arc 50 %), horizontalDistortion?: as h, verticalDistortion?: as v, version?: as makeWithWarp (unset: a warp envelope's own, else 1)} make the selected envelopes warp envelopes, keeping their content",
has_envelope,
env_reset_warp
),
@@ -190,7 +190,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Envelope Info",
[],
None,
"{} the selected envelope's settings, or with none selected the defaults new envelopes get → {id: n|null, type: warp|mesh|topObject, style, bend, h, v, horizontal, rows, cols, fidelity, antiAlias, preserveShape: clippingMask|transparency, distortAppearance, distortLinearGradients, distortPatternFills, boundsMargin?: [top, bottom, left, right] (shares of the content's height and width, reported only when not zero: with distortAppearance, how far the box the content maps from reaches past its geometric bounds), editing}",
"{} the selected envelope's settings, or with none selected the defaults new envelopes get → {id: n|null, type: warp|mesh|topObject, style, bend, h, v, horizontal, version (a warp's map: 1, each style as one Bézier patch; 0, the earlier map), rows, cols, fidelity, antiAlias, preserveShape: clippingMask|transparency, distortAppearance, distortLinearGradients, distortPatternFills, boundsMargin?: [top, bottom, left, right] (shares of the content's height and width, reported only when not zero: with distortAppearance, how far the box the content maps from reaches past its geometric bounds), editing}",
has_doc,
env_info
),
@@ -208,7 +208,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Envelope Options…",
["Object", "Envelope Distort"],
None,
"{fidelity?: 0..100, antiAlias?: bool, preserveShape?: clippingMask|transparency, distortAppearance?: bool, distortLinearGradients?: bool, distortPatternFills?: bool (the last two work with distortAppearance; on an envelope with boundsMargin, distortAppearance also switches the content between the box with the margins and its geometric box), style?, bend?, h?, v?, horizontal? (warp envelopes), horizontalDistortion?: as h, verticalDistortion?: as v, orientation?: horizontal|vertical} set the selected envelopes' options; with no envelope selected, the options new envelopes get (see object.envelope.info)",
"{fidelity?: 0..100, antiAlias?: bool, preserveShape?: clippingMask|transparency, distortAppearance?: bool, distortLinearGradients?: bool, distortPatternFills?: bool (the last two work with distortAppearance; on an envelope with boundsMargin, distortAppearance also switches the content between the box with the margins and its geometric box), style?, bend?, h?, v?, horizontal? (warp envelopes), horizontalDistortion?: as h, verticalDistortion?: as v, orientation?: horizontal|vertical, version?: 0|1 (warp envelopes' map, as makeWithWarp)} set the selected envelopes' options; with no envelope selected, the options new envelopes get (see object.envelope.info)",
has_doc,
env_options
),
+11 -6
View File
@@ -13,9 +13,14 @@ const WARP_NUMBERS: &[&str] = &["bend", "h", "v", "horizontalDistortion", "verti
fn warp_kind(p: &Value, cmd: &str, cur: Option<&EnvelopeKind>) -> Result<EnvelopeKind> {
check_numbers(p, WARP_NUMBERS, cmd)?;
let (mut style, mut bend, mut h, mut v, mut horizontal) = ("arc".to_string(), 50.0, 0.0, 0.0, true);
if let Some(EnvelopeKind::Warp { style: s0, bend: b0, h: h0, v: v0, horizontal: z0 }) = cur {
(style, bend, h, v, horizontal) = (s0.clone(), *b0, *h0, *v0, *z0);
// A new warp takes its style's Bézier net; an edited one keeps the map it has unless `version`
// names one.
let (mut style, mut bend, mut h, mut v, mut horizontal, mut version) = ("arc".to_string(), 50.0, 0.0, 0.0, true, live::WARP_NET);
if let Some(EnvelopeKind::Warp { style: s0, bend: b0, h: h0, v: v0, horizontal: z0, version: n0 }) = cur {
(style, bend, h, v, horizontal, version) = (s0.clone(), *b0, *h0, *v0, *z0, *n0);
}
if let Some(n) = p.get("version") {
version = live::warp_version(n).ok_or_else(|| bad(cmd, format!("`version` must be 0 or {}", live::WARP_NET)))?;
}
if let Some(s) = text_param(p, "style", cmd)? {
let s = s.strip_prefix("warp.").unwrap_or(s);
@@ -32,7 +37,7 @@ fn warp_kind(p: &Value, cmd: &str, cur: Option<&EnvelopeKind>) -> Result<Envelop
Some(o) => o == "horizontal",
None => given,
};
Ok(EnvelopeKind::Warp { style, bend, h, v, horizontal })
Ok(EnvelopeKind::Warp { style, bend, h, v, horizontal, version })
}
/// The options and fidelity new envelopes get (Envelope Options with no envelope selected).
@@ -206,8 +211,8 @@ pub(super) fn env_info(s: &mut Session, _: &Value) -> Result<Value> {
return Ok(envelope_options_json(json!({ "id": null }), &options, fidelity));
};
let v = match &**kind {
EnvelopeKind::Warp { style, bend, h, v, horizontal } => {
json!({"type": "warp", "style": style, "bend": bend, "h": h, "v": v, "horizontal": horizontal})
EnvelopeKind::Warp { style, bend, h, v, horizontal, version } => {
json!({"type": "warp", "style": style, "bend": bend, "h": h, "v": v, "horizontal": horizontal, "version": version})
}
EnvelopeKind::Mesh { rows, cols, .. } => json!({"type": "mesh", "rows": rows, "cols": cols}),
EnvelopeKind::TopObject { .. } => json!({"type": "topObject"}),
+89 -2
View File
@@ -9,6 +9,10 @@
//! from the tool's options (Objects on Path Tool Options). `object.objectsOnPath.options` sets the
//! group's Pivot, Rotate and Space (the distance between the objects along the path, and where the
//! first one attaches), and `object.objectsOnPath.expand` makes it a plain group.
//! `object.objectsOnPath.selectMember` chooses one object of a selected group (its Select/Move
//! widget), and `object.objectsOnPath.moveMember` moves one object to another's place along the
//! path, the objects between it and that place each moving one place toward where it was; hidden
//! and locked objects keep their places.
//!
//! After every edit, [`refresh`] puts the objects of each Objects on Path group that changed back
//! on its path: editing the path moves them, an object moved on its own goes back to its place,
@@ -19,7 +23,7 @@
//! Object › Objects on Path › Attach; the order on the path, the attachment point, the distribution,
//! the objects squared to the path; Pivot and Rotate; path edits realign the objects; Expand).
use std::collections::HashMap;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use serde_json::{Value, json};
@@ -28,7 +32,7 @@ use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use vectorcraft_geom::Rect;
use super::edit::{roots_of, selected_roots};
use super::{CommandSpec, EngineError, Result, Session, bad, check_numbers, checked_id, checked_ids_param, cmd, has_selection};
use super::{CommandSpec, EngineError, Result, Session, bad, check_numbers, checked_id, checked_ids_param, cmd, has_doc, has_selection};
/// The id of the Objects on Path tool.
pub const TOOL: &str = "objectsOnPath";
@@ -53,6 +57,24 @@ pub fn specs() -> Vec<CommandSpec> {
has_objects_on_path,
options
),
cmd!(
"object.objectsOnPath.selectMember",
"Select Object on Path",
[],
None,
"{member: id of an object of an Objects on Path group} select the group alone with that object chosen, as a click on the object's Select/Move widget does; any other selection change clears the choice → {group, member}",
has_doc,
select_member
),
cmd!(
"object.objectsOnPath.moveMember",
"Move Object on Path",
[],
None,
"{member: id of an object of an Objects on Path group, target: id of another object of the same group, group?: the group's id (when given, it must be the group of both); neither object nor the group may be hidden or locked} move the object to the target's place along the path; the objects between them each move one place toward where it was, except hidden and locked objects, which keep their places. Only the order along the path changes: Space, the start, Pivot, Rotate and the order in the Layers panel stay. A target that is the object itself changes nothing → {group, member, index}",
has_doc,
move_member
),
cmd!(
"object.objectsOnPath.expand",
"Expand",
@@ -296,6 +318,71 @@ fn options(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "ids": groups.iter().map(|g| g.0).collect::<Vec<_>>() }))
}
// ---------- Select/Move ----------
/// The Objects on Path group whose object `key` of `p` names, checked: an object listed in the
/// group's record (not its path), in a group that is not hidden or locked.
fn member_param(s: &Session, p: &Value, key: &str, cmd: &str) -> Result<(NodeId, NodeId)> {
let v = p.get(key).filter(|v| !v.is_null()).ok_or_else(|| bad(cmd, format!("missing `{key}`")))?;
let id = checked_id(s, v, cmd)?;
let d = &s.doc()?.doc;
let not_on_path = || bad(cmd, format!("`{key}` must name an object attached to the path of an Objects on Path group"));
let g =
d.ancestry(id).unwrap_or_default().into_iter().rev().nth(1).filter(|g| d.node(*g).is_some_and(is_objects_on_path)).ok_or_else(not_on_path)?;
let listed = d.node(g).and_then(|n| n.extras().objects_on_path.as_deref()).is_some_and(|rec| rec.members.iter().any(|m| m.id == id));
if !listed {
return Err(not_on_path());
}
if !d.is_editable(g) {
return Err(bad(cmd, "the Objects on Path group is hidden or locked"));
}
if !d.is_editable(id) {
return Err(bad(cmd, format!("`{key}` names an object that is hidden or locked")));
}
Ok((g, id))
}
fn select_member(s: &mut Session, p: &Value) -> Result<Value> {
let (g, member) = member_param(s, p, "member", "object.objectsOnPath.selectMember")?;
s.select(|_, sel| sel.set_on_path_member(g, member))?;
Ok(json!({ "group": g.0, "member": member.0 }))
}
fn move_member(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "object.objectsOnPath.moveMember";
let (g, member) = member_param(s, p, "member", C)?;
let (target_group, target) = member_param(s, p, "target", C)?;
if target_group != g {
return Err(bad(C, "`target` must be an object of the same Objects on Path group as `member`"));
}
if let Some(v) = p.get("group").filter(|v| !v.is_null())
&& checked_id(s, v, C)? != g
{
return Err(bad(C, "`group` must be the Objects on Path group of `member` and `target`"));
}
let at = |s: &Session| -> Result<usize> {
let rec = s.doc()?.doc.node(g).and_then(|n| n.extras().objects_on_path.as_deref().cloned()).ok_or(EngineError::NoNode(g))?;
rec.members.iter().position(|m| m.id == member).ok_or(EngineError::NoNode(member))
};
// Onto its own place: nothing changes, and no undo step is recorded.
if target == member {
return Ok(json!({ "group": g.0, "member": member.0, "index": at(s)? }));
}
// Hidden and locked objects between them keep their places.
let index = s.edit("Move Object on Path", |d, _| {
let mut rec = d.node(g).and_then(|n| n.extras().objects_on_path.as_deref().cloned()).ok_or(EngineError::NoNode(g))?;
let fixed: HashSet<NodeId> = {
let editable = d.editable();
rec.members.iter().map(|m| m.id).filter(|&id| !editable(id)).collect()
};
let index = rec.move_member(member, target, |id| fixed.contains(&id)).ok_or(EngineError::NoNode(member))?;
let n = d.node_mut(g).ok_or(EngineError::NoNode(g))?;
n.extras_mut().objects_on_path = Some(Box::new(rec));
Ok(index)
})?;
Ok(json!({ "group": g.0, "member": member.0, "index": index }))
}
// ---------- Expand ----------
fn expand(s: &mut Session, p: &Value) -> Result<Value> {
+8
View File
@@ -317,6 +317,14 @@ pub fn check_effect_params(id: &str, effect: &str, params: &Value) -> Result<()>
if effect == vectorcraft_render::effects::SVG_FILTER && given.contains_key("name") && !given.contains_key("xml") {
return Err(bad(id, "an SVG filter is named by its id: give `xml` with `name`"));
}
// A Warp's map is one this build draws: 0, the earlier map, or its style's Bézier net.
let newest = vectorcraft_render::effects::WARP_NET;
if effect.starts_with("warp.")
&& let Some(v) = given.get("version")
&& vectorcraft_render::effects::warp_version(v).is_none()
{
return Err(bad(id, format!("`version` must be 0 or {newest}")));
}
check_effect_color(id, effect, params)?;
check_effect_channel(id, effect, params)
}
+254
View File
@@ -26,6 +26,7 @@ pub struct BuiltinPatternLibrary {
pub const PATTERN_LIBRARIES: &[BuiltinPatternLibrary] = &[
BuiltinPatternLibrary { id: "geometric-patterns", name: "Geometric Patterns", make: geometric_patterns },
BuiltinPatternLibrary { id: "grit-textures", name: "Grit Textures", make: grit_textures },
BuiltinPatternLibrary { id: "optical-effects", name: "Optical Effects", make: optical_effects },
];
/// The library category of the built-in pattern libraries.
@@ -256,6 +257,162 @@ fn grit_textures(d: &mut Document) {
});
}
/// `n` + 1 points of the curve `(t, f(t))` for `t` from `t0` to `t1`, evenly spaced.
fn curve(t0: f64, t1: f64, n: u32, f: impl Fn(f64) -> f64) -> Vec<(f64, f64)> {
(0..=n)
.map(|i| {
let t = t0 + (t1 - t0) * f64::from(i) / f64::from(n);
(t, f(t))
})
.collect()
}
/// The closed band between two curves drawn from the same side to the same side: `upper` forward,
/// then `lower` back.
fn band(upper: &[(f64, f64)], lower: &[(f64, f64)]) -> PathData {
let points: Vec<(f64, f64)> = upper.iter().chain(lower.iter().rev()).copied().collect();
polygon(&points)
}
/// 72 corners of the circle of radius `r` about (`cx`, `cy`), turning the other way with `reverse`.
fn circle(cx: f64, cy: f64, r: f64, reverse: bool) -> SubPath {
const CORNERS: u32 = 72;
let turn = if reverse { -std::f64::consts::TAU } else { std::f64::consts::TAU };
let points: Vec<Point> = (0..CORNERS)
.map(|i| {
let a = turn * f64::from(i) / f64::from(CORNERS);
Point::new(cx + r * a.cos(), cy + r * a.sin())
})
.collect();
SubPath::polyline(&points, true)
}
/// The ring from radius `inner` to `outer` about (`cx`, `cy`): the outer circle and the inner one
/// turning the other way, so the middle stays clear under either fill rule. An `inner` of 0 gives
/// a disk.
fn ring(cx: f64, cy: f64, inner: f64, outer: f64) -> PathData {
let mut subpaths = vec![circle(cx, cy, outer, false)];
if inner > 0.0 {
subpaths.push(circle(cx, cy, inner, true));
}
PathData::new(subpaths)
}
/// A lens `2 × l` long and `2 × h` high about (`cx`, `cy`), lying along x: two half sine waves that
/// meet at its tips, turning the other way with `reverse`.
fn lens(cx: f64, cy: f64, l: f64, h: f64, reverse: bool) -> SubPath {
const STEPS: u32 = 32;
let at = |i: u32, side: f64| {
let t = f64::from(i) / f64::from(STEPS);
Point::new(cx - l + 2.0 * l * t, cy + side * h * (std::f64::consts::PI * t).sin())
};
let mut points: Vec<Point> = (0..=STEPS).map(|i| at(i, -1.0)).chain((1..STEPS).rev().map(|i| at(i, 1.0))).collect();
if reverse {
points.reverse();
}
SubPath::polyline(&points, true)
}
/// Optical Effects: black waves, rings, warped checks, pinched stripes, chevrons and lenses on a
/// clear background. Each tile is one period of its design, so a band that leaves one edge comes
/// back at the same place on the opposite edge. Art that reaches past an edge is kept whole: the
/// tiling draws the part outside the tile on the next tile.
fn optical_effects(d: &mut Document) {
use std::f64::consts::TAU;
// Three bands 5 pt wide, 12 pt apart, each one sine wave across the tile.
let bands = (0..3u32)
.map(|k| {
let mid = move |x: f64| 6.0 + 12.0 * f64::from(k) + 3.0 * (TAU * x / 36.0).sin();
band(&curve(0.0, 36.0, 48, |x| mid(x) - 2.5), &curve(0.0, 36.0, 48, |x| mid(x) + 2.5))
})
.collect();
add(d, "Sine Bands", 36.0, 36.0, TileType::Grid, bands);
// Nine thin waves 4 pt apart, two waves across the tile, each a ninth of a wave on from the one
// above it, so the ninth leads into the first wave of the next tile down.
let lines = (0..9u32)
.map(|k| {
let (y, phase) = (2.0 + 4.0 * f64::from(k), TAU * f64::from(k) / 9.0);
let mid = move |x: f64| y + 2.5 * (TAU * x / 18.0 + phase).sin();
band(&curve(0.0, 36.0, 72, |x| mid(x) - 0.6), &curve(0.0, 36.0, 72, |x| mid(x) + 0.6))
})
.collect();
add(d, "Ripple Lines", 36.0, 36.0, TileType::Grid, lines);
// Thin rings 3 pt apart about the center and rings 3.3 pt apart about a point 4 pt to its
// right. The two sets cross, and the outer rings reach into the next tile across.
let rings = (1..=7u32)
.map(|k| (24.0, 3.0 * f64::from(k)))
.chain((1..=7u32).map(|k| (28.0, 3.3 * f64::from(k))))
.map(|(cx, r)| ring(cx, 24.0, r - 0.6, r + 0.6))
.collect();
add(d, "Interference Rings", 48.0, 48.0, TileType::Grid, rings);
// Rings 2 pt and 1 pt wide by turns about the tile's corner and about its center, the center's
// starting with the narrower one. The corner's rings are the same rings at all four corners.
let mut rings = vec![];
for (c, first) in [(0.0, 0), (20.0, 1)] {
let mut r = 0.0;
for k in 0..5 {
let width = if (k + first) % 2 == 0 { 2.0 } else { 1.0 };
rings.push(ring(c, c, r, r + width));
r += width + 1.2;
}
}
add(d, "Offset Rings", 40.0, 40.0, TileType::Grid, rings);
// An 8 × 8 checkerboard of 4 pt cells whose columns are bent by a sine wave down the tile and
// whose rows by one across it, each edge drawn through five points.
let warp = |x: f64, y: f64| (x + 2.0 * (TAU * y / 32.0).sin(), y + 2.0 * (TAU * x / 32.0).sin());
let cells = (0..8u32)
.flat_map(|row| (0..8u32).map(move |col| (col, row)))
.filter(|(col, row)| (col + row) % 2 == 0)
.map(|(col, row)| {
let (x, y) = (4.0 * f64::from(col), 4.0 * f64::from(row));
let corners = [(x, y), (x + 4.0, y), (x + 4.0, y + 4.0), (x, y + 4.0), (x, y)];
let points: Vec<(f64, f64)> = corners
.windows(2)
.flat_map(|e| {
let (a, b) = (e[0], e[1]);
(0..4u32).map(move |i| {
let t = f64::from(i) / 4.0;
warp(a.0 + (b.0 - a.0) * t, a.1 + (b.1 - a.1) * t)
})
})
.collect();
polygon(&points)
})
.collect();
add(d, "Warped Checks", 32.0, 32.0, TileType::Grid, cells);
// Six upright stripes 6 pt apart that widen from 0.8 pt to 5.6 pt and narrow again down the tile,
// each a sixth of a wave on from the one to its left.
let stripes = (0..6u32)
.map(|k| {
let (x, phase) = (3.0 + 6.0 * f64::from(k), TAU * f64::from(k) / 6.0);
let half = move |y: f64| 1.6 + 1.2 * (TAU * y / 36.0 + phase).cos();
let side = |s: f64| -> Vec<(f64, f64)> { curve(0.0, 36.0, 48, |y| x + s * half(y)).into_iter().map(|(y, at)| (at, y)).collect() };
band(&side(-1.0), &side(1.0))
})
.collect();
add(d, "Pinched Stripes", 36.0, 36.0, TileType::Grid, stripes);
// Four zigzag bands 8 pt apart, two zigzags across the tile; the bend and the width of the bands
// rise and fall from band to band.
let chevrons = [(0.0, 3.0, 4.0), (8.0, 4.5, 2.5), (16.0, 3.0, 1.0), (24.0, 1.5, 2.5)]
.into_iter()
.map(|(y, bend, width)| {
let upper: Vec<(f64, f64)> = (0..=4u32).map(|i| (8.0 * f64::from(i), if i % 2 == 1 { y + bend } else { y })).collect();
let lower: Vec<(f64, f64)> = upper.iter().map(|&(x, y)| (x, y + width)).collect();
band(&upper, &lower)
})
.collect();
add(d, "Chevron Pulse", 32.0, 32.0, TileType::Grid, chevrons);
// Five nested lens outlines 1.5 pt wide about the center, 14 pt to 78 pt long. The longer ones
// reach across the side edges and cross the next tiles' lenses.
let lenses = (0..5u32)
.map(|k| {
let (l, h) = (7.0 + 8.0 * f64::from(k), 4.0 + 4.0 * f64::from(k));
PathData::new(vec![lens(24.0, 24.0, l, h, false), lens(24.0, 24.0, l - 1.5, h - 1.5, true)])
})
.collect();
add(d, "Radiating Lenses", 48.0, 48.0, TileType::Grid, lenses);
}
#[cfg(test)]
mod tests {
use super::*;
@@ -326,4 +483,101 @@ mod tests {
}
assert!(crossing > 0, "no mark reaches past an edge");
}
const OPTICAL: [&str; 8] =
["Sine Bands", "Ripple Lines", "Interference Rings", "Offset Rings", "Warped Checks", "Pinched Stripes", "Chevron Pulse", "Radiating Lenses"];
fn optical_doc() -> Document {
let mut d = Document::new(100.0, 100.0);
optical_effects(&mut d);
d
}
/// The paths of pattern `p`'s art, each with its fill rule.
fn paths(p: &PatternDef) -> Vec<(&PathData, vectorcraft_geom::FillRule)> {
p.art
.iter()
.map(|n| match &n.kind {
vectorcraft_doc::NodeKind::Path { path, rule, .. } => (path, *rule),
_ => panic!("{}: art that is not a path", p.name),
})
.collect()
}
#[test]
fn optical_effects_is_a_pattern_library_of_eight_bounded_tiles() {
let b = PATTERN_LIBRARIES.iter().find(|b| b.id == "optical-effects").expect("Optical Effects is listed");
assert_eq!(b.name, "Optical Effects");
let names: Vec<String> = library_doc(b.id).unwrap().patterns.iter().map(|p| p.name.clone()).collect();
assert_eq!(names, OPTICAL);
// Made twice, the art is the same.
let (a, again) = (optical_doc(), optical_doc());
assert_eq!(a.patterns, again.patterns);
for p in &a.patterns {
let (w, h) = (p.width(), p.height());
assert!((32.0..=48.0).contains(&w) && w == h && p.tile.x0 == 0.0 && p.tile.y0 == 0.0, "{}", p.name);
assert_eq!(p.tile_type, TileType::Grid, "{}", p.name);
let paths = paths(p);
let segments: usize = paths.iter().flat_map(|(path, _)| &path.subpaths).map(SubPath::segment_count).sum();
assert!(!paths.is_empty() && paths.len() <= 600 && segments <= 20_000, "{}: {} paths, {segments} segments", p.name, paths.len());
for (path, _) in &paths {
let b = path.bounds().unwrap_or_else(|| panic!("{}: an empty path", p.name));
assert!([b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()) && b.width() > 0.0 && b.height() > 0.0, "{}: {b:?}", p.name);
assert!(b.x1 > 0.0 && b.y1 > 0.0 && b.x0 < w && b.y0 < h, "{}: {b:?} does not touch the tile", p.name);
}
}
}
/// Just either side of a tile's right and bottom edges, the tiling paints the same points: a band
/// cut off at an edge, or one that comes back at another height or width, paints one side only.
/// No path is another moved by a whole tile, which the tiling would draw twice in one place.
#[test]
fn optical_tiles_join_without_a_seam() {
const SAMPLES: u32 = 400;
const STEP: f64 = 1e-4;
for p in &optical_doc().patterns {
let (w, h) = (p.width(), p.height());
let shapes: Vec<(BezPathFill, Rect)> =
paths(p).into_iter().map(|(path, rule)| ((path.to_bezpath(), rule), path.bounds().unwrap_or(Rect::ZERO))).collect();
let paints = |q: Point| {
let near = Rect::new(q.x - STEP, q.y - STEP, q.x + STEP, q.y + STEP);
p.offsets_covering(near).into_iter().any(|o| {
let at = q - o;
shapes.iter().any(|((bp, rule), b)| {
let inside = b.x0 <= at.x && at.x <= b.x1 && b.y0 <= at.y && at.y <= b.y1;
let turns = if inside { kurbo::Shape::winding(bp, at) } else { 0 };
match rule {
vectorcraft_geom::FillRule::EvenOdd => turns % 2 != 0,
vectorcraft_geom::FillRule::NonZero => turns != 0,
}
})
})
};
let (mut differ, mut painted) = (0, 0);
for i in 0..SAMPLES {
let t = (f64::from(i) + 0.37) / f64::from(SAMPLES);
let (right, bottom) = (Point::new(w, t * h), Point::new(t * w, h));
let (dx, dy) = (kurbo::Vec2::new(STEP, 0.0), kurbo::Vec2::new(0.0, STEP));
for (a, b) in [(right - dx, right + dx), (bottom - dy, bottom + dy)] {
let (pa, pb) = (paints(a), paints(b));
differ += usize::from(pa != pb);
painted += usize::from(pa);
}
}
assert!(differ <= 2, "{}: {differ} of {} points across the edges differ", p.name, 2 * SAMPLES);
assert!(painted > 0, "{}: nothing crosses an edge", p.name);
let bounds: Vec<Rect> = shapes.iter().map(|(_, b)| *b).collect();
let same = |a: &Rect, b: Rect| {
(a.x0 - b.x0).abs() < 1e-9 && (a.y0 - b.y0).abs() < 1e-9 && (a.x1 - b.x1).abs() < 1e-9 && (a.y1 - b.y1).abs() < 1e-9
};
for b in &bounds {
for (dx, dy) in [(w, 0.0), (-w, 0.0), (0.0, h), (0.0, -h), (w, h), (w, -h), (-w, h), (-w, -h)] {
let moved = *b + kurbo::Vec2::new(dx, dy);
assert!(!bounds.iter().any(|o| same(o, moved)), "{}: {b:?} is drawn twice by the tiling", p.name);
}
}
}
}
type BezPathFill = (vectorcraft_geom::BezPath, vectorcraft_geom::FillRule);
}
+4 -2
View File
@@ -87,7 +87,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Image Info",
[],
None,
"{id?} an image object (default: the one selected) → {id, name, linked, link, colorMode: RGB|Grayscale|CMYK, pixelWidth, pixelHeight, ppi: [x, y] at its placed size, width, height}",
"{id?} an image object (default: the one selected) → {id, name, linked, link (the linked file's path; null when embedded, or when automation read roots are in force and the file is outside them), colorMode: RGB|Grayscale|CMYK, pixelWidth, pixelHeight, ppi: [x, y] at its placed size, width, height}",
has_doc,
image_info
),
@@ -891,11 +891,13 @@ pub(crate) fn image_info(s: &mut Session, p: &Value) -> Result<Value> {
let [a, b, c, d, ..] = im.xf.as_coeffs();
let ppi = |x: f64, y: f64| Some(x.hypot(y)).filter(|l| *l > 1e-12).map_or(0.0, |l| 72.0 / l);
let size = n.geometric_bounds().unwrap_or_default();
// A linked file outside the read roots of the caller asking now is left unnamed, as in Link Info.
let doc_path = super::links::LinkBase::of(st).doc;
Ok(json!({
"id": id.0,
"name": n.display_name(),
"linked": im.link.is_some(),
"link": im.link.as_ref().map(|l| &l.path),
"link": im.link.as_ref().map(|l| &l.path).filter(|path| super::links::path_shown(path, doc_path)),
"colorMode": st.doc.images.get(&im.key).map_or("RGB", |b| color_mode(&b.bytes)),
"pixelWidth": im.width,
"pixelHeight": im.height,
+84 -10
View File
@@ -62,13 +62,28 @@ fn err(e: vectorcraft_plugins::Error) -> EngineError {
}
}
/// Under automation read roots, a reply names a file or folder outside them by its name alone.
fn shown_file(path: &str) -> String {
super::fileio::shown_path(path).into_owned()
}
/// A plug-in turned off for the next launch, or the one a launch stopped at, as a reply shows it: a
/// file outside the automation read roots is named by its file name.
fn shown_item(item: &safe_mode::Item) -> Value {
let mut v = item.to_json();
if let Some(file) = item.file.as_deref() {
v["file"] = json!(shown_file(file));
}
v
}
/// JSON description of an installed plug-in.
pub fn describe(p: &Plugin) -> Value {
let m = p.manifest();
let mut v = json!({
"id": m.id, "name": m.name, "version": m.version, "kind": m.kind.name(), "author": m.author, "description": m.description,
"params": m.params_doc(), "paramsSchema": serde_json::to_value(m).ok().and_then(|v| v.get("params").cloned()),
"size": p.size(), "source": p.source(),
"size": p.size(), "source": p.source().map(shown_file),
"permissions": permissions::names(&m.permissions()), "hash": p.hash(), "api": m.api,
});
match m.kind {
@@ -932,9 +947,46 @@ fn describe_installed(p: &Plugin) -> Value {
v
}
/// The folder load `report` as a reply shows it: under automation read roots, a folder outside them
/// is `null` and a failed file outside them is named by its file name, in the errors too.
fn shown_report(mut report: Value) -> Value {
let mut hidden: Vec<(String, String)> = vec![];
if let Some(failed) = report.get_mut("failed").and_then(Value::as_array_mut) {
for row in failed {
let Some(file) = row.get("file").and_then(Value::as_str).map(str::to_string) else { continue };
let shown = shown_file(&file);
if shown != file {
row["file"] = json!(shown);
hidden.push((file, shown));
}
}
}
if let Some(folder) = report.get("folder").and_then(Value::as_str).map(str::to_string) {
let shown = shown_file(&folder);
if shown != folder {
report["folder"] = Value::Null;
hidden.push((folder, shown));
}
}
// A failed file's path holds its folder's: the longer paths are put back first.
hidden.sort_by_key(|(path, _)| std::cmp::Reverse(path.len()));
let unnamed = |text: &str| hidden.iter().fold(text.to_string(), |t, (path, name)| t.replace(path.as_str(), name));
if let Some(e) = report.get("error").and_then(Value::as_str).map(unnamed) {
report["error"] = json!(e);
}
if let Some(failed) = report.get_mut("failed").and_then(Value::as_array_mut) {
for row in failed {
if let Some(e) = row.get("error").and_then(Value::as_str).map(unnamed) {
row["error"] = json!(e);
}
}
}
report
}
fn list(_: &mut Session, _: &Value) -> Result<Value> {
let folder = FOLDER.lock().unwrap_or_else(|e| e.into_inner()).as_ref().map(|(_, _, r)| r.clone());
let disabled: Vec<Value> = safe_mode::disabled().iter().map(safe_mode::Item::to_json).collect();
let folder = FOLDER.lock().unwrap_or_else(|e| e.into_inner()).as_ref().map(|(_, _, r)| shown_report(r.clone()));
let disabled: Vec<Value> = safe_mode::disabled().iter().map(shown_item).collect();
Ok(
json!({"plugins": registry::list().iter().map(|p| describe_installed(p)).collect::<Vec<_>>(), "folder": folder, "safeMode": safe_mode::active(), "disabled": disabled}),
)
@@ -946,11 +998,33 @@ fn safe_mode_state(_: &mut Session, _: &Value) -> Result<Value> {
Ok(json!({
"active": safe_mode::active(),
"source": safe_mode::source().map(safe_mode::Source::name),
"disabled": safe_mode::disabled().iter().map(safe_mode::Item::to_json).collect::<Vec<_>>(),
"pendingItem": safe_mode::previous().map(|i| i.to_json()),
"disabled": safe_mode::disabled().iter().map(shown_item).collect::<Vec<_>>(),
"pendingItem": safe_mode::previous().map(|i| shown_item(&i)),
}))
}
/// The file of a plug-in `plugin.safeMode` lists as `file`, or `plugin.list` as `source`: one they name
/// by its file name (outside the automation read roots) is found by that name, when no other listed
/// file has it.
fn listed_file(file: String) -> String {
let mut listed: Vec<String> = safe_mode::disabled()
.into_iter()
.chain(safe_mode::previous())
.filter_map(|i| i.file)
.chain(registry::list().iter().filter_map(|p| p.source().map(str::to_string)))
.collect();
listed.sort();
listed.dedup();
if listed.contains(&file) {
return file;
}
let mut named = listed.into_iter().filter(|f| shown_file(f) == file);
match (named.next(), named.next()) {
(Some(f), None) => f,
_ => file,
}
}
/// `plugin.setEnabled`: turns a plug-in on or off for the next launch, by `id` or by `file` (a
/// plug-in that stopped a launch while loading may be known by its file alone). It neither loads
/// nor unloads anything now, and uninstalls nothing.
@@ -972,7 +1046,7 @@ fn set_enabled(s: &mut Session, p: &Value) -> Result<Value> {
let stored = if enabled { s.stored_plugin_file(&id).map(safe_mode::Item::file) } else { None };
(registry::get(&id).map(|p| safe_mode::Item::of(&p)).unwrap_or(safe_mode::Item { id: Some(id), ..Default::default() }), stored)
}
(None, Some(file)) => (safe_mode::Item::file(file), None),
(None, Some(file)) => (safe_mode::Item::file(listed_file(file)), None),
(None, None) => return Err(bad(C, "give `id` or `file` (see plugin.safeMode)")),
};
let items: Vec<&safe_mode::Item> = std::iter::once(&item).chain(stored.as_ref()).collect();
@@ -986,7 +1060,7 @@ fn set_enabled(s: &mut Session, p: &Value) -> Result<Value> {
// Without a plug-in folder (a session confined to automation roots), or when the list there
// can't take the change, the change stays in this process and goes with the next change that saves.
let saved = !changed || s.store_disabled_plugins();
Ok(json!({"changed": changed, "saved": saved, "disabled": safe_mode::disabled().iter().map(safe_mode::Item::to_json).collect::<Vec<_>>()}))
Ok(json!({"changed": changed, "saved": saved, "disabled": safe_mode::disabled().iter().map(shown_item).collect::<Vec<_>>()}))
}
fn info(_: &mut Session, p: &Value) -> Result<Value> {
@@ -1055,7 +1129,7 @@ pub fn specs() -> Vec<CommandSpec> {
"List Plug-ins",
[],
None,
"{} → {plugins: [{id, name, version, kind: \"filter\"|\"effect\"|\"exporter\"|\"importer\", author, description, params (doc), paramsSchema, effect? (the effect id of a live effect: plugin.<id>), format? and extensions? (an exporter's or importer's format id, plugin.<id>, for document.export or document.open's importer, and its file extensions), budget?: \"heavy\" (a filter that may compute for longer, see plugin.install's allowHeavy), inputs?: [\"type\"|\"image\"|\"symbolInstance\"] (the objects besides paths a filter reads, see plugin.run), size, source, permissions: [name] (what it may do: the ones its manifest lists, else the ones its kind implies; progress: it may report its progress, see Cancel and write log lines; settings: it may keep settings of its own; cache: it may keep a cache of its own; commands: a filter may run the commands its commandAllowlist names, see docs/plugins.md), commandAllowlist?: [command id] (the commands a filter with the commands permission may run while it runs, with vc_call), hash (the module's SHA-256), api (the plug-in API level it was built for, 1 or 2), paintOutput?: true (a live effect whose pieces have paints of their own, see docs/plugins.md), cacheBytes (the bytes its cache holds; see plugin.clearCache), commands?: [{id, command (its command id, plugin.<id>.<command id>, which runs it), label, params (doc), paramsSchema}] (the menu commands a filter or live effect adds)}], folder: the Additional Plug-ins Folder load report {folder, loaded, failed: [{file, error}]} | null, safeMode: bool (no plug-in loads or runs, see plugin.safeMode), disabled: [{id, file, name, label}] (turned off for the next launch, see plugin.setEnabled)}",
"{} → {plugins: [{id, name, version, kind: \"filter\"|\"effect\"|\"exporter\"|\"importer\", author, description, params (doc), paramsSchema, effect? (the effect id of a live effect: plugin.<id>), format? and extensions? (an exporter's or importer's format id, plugin.<id>, for document.export or document.open's importer, and its file extensions), budget?: \"heavy\" (a filter that may compute for longer, see plugin.install's allowHeavy), inputs?: [\"type\"|\"image\"|\"symbolInstance\"] (the objects besides paths a filter reads, see plugin.run), size, source, permissions: [name] (what it may do: the ones its manifest lists, else the ones its kind implies; progress: it may report its progress, see Cancel and write log lines; settings: it may keep settings of its own; cache: it may keep a cache of its own; commands: a filter may run the commands its commandAllowlist names, see docs/plugins.md), commandAllowlist?: [command id] (the commands a filter with the commands permission may run while it runs, with vc_call), hash (the module's SHA-256), api (the plug-in API level it was built for, 1 or 2), paintOutput?: true (a live effect whose pieces have paints of their own, see docs/plugins.md), cacheBytes (the bytes its cache holds; see plugin.clearCache), commands?: [{id, command (its command id, plugin.<id>.<command id>, which runs it), label, params (doc), paramsSchema}] (the menu commands a filter or live effect adds)}], folder: the Additional Plug-ins Folder load report {folder, loaded, failed: [{file, error}]} | null (under automation read roots, a folder outside them is null, and a failed file and a plug-in's source outside them are named by their file name), safeMode: bool (no plug-in loads or runs, see plugin.safeMode), disabled: [{id, file, name, label}] (turned off for the next launch, see plugin.setEnabled)}",
always,
list
),
@@ -1127,7 +1201,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Safe Mode",
[],
None,
"{} → {active: bool (no plug-in loads or runs: plugin.install, .run, .reload and exporters fail, live effects draw their object's geometry unchanged and the objects keep their effects), source: \"flag\" (started with --safe-mode) | \"startup\" (the user chose Safe Mode, or hasn't chosen yet, after a launch that stopped while a plug-in was loading) | null, disabled: [{id, file, name, label}] (turned off for the next launch; id is null for one known only by its file), pendingItem: {id, file, name, label} | null (the plug-in the last launch was loading when it stopped, until the user chooses; it may not be what stopped it)}. Safe Mode is chosen at launch, never by a command",
"{} → {active: bool (no plug-in loads or runs: plugin.install, .run, .reload and exporters fail, live effects draw their object's geometry unchanged and the objects keep their effects), source: \"flag\" (started with --safe-mode) | \"startup\" (the user chose Safe Mode, or hasn't chosen yet, after a launch that stopped while a plug-in was loading) | null, disabled: [{id, file, name, label}] (turned off for the next launch; id is null for one known only by its file; under automation read roots, a file outside them is named by its file name here and in pendingItem, and plugin.setEnabled takes that name), pendingItem: {id, file, name, label} | null (the plug-in the last launch was loading when it stopped, until the user chooses; it may not be what stopped it)}. Safe Mode is chosen at launch, never by a command",
always,
safe_mode_state
),
@@ -1136,7 +1210,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Enable on Re-launch",
[],
None,
"{id | file: a plug-in as plugin.safeMode's disabled lists it, enabled: bool} turn a plug-in on or off for the next launch (Help › Safe Mode's Enable on Re-launch); nothing loads, unloads or is uninstalled now. Turning on by id also turns on the file the plug-in is stored in. Turning on one that isn't disabled is an error. plugin.install of a disabled plug-in turns it on → {changed, saved: false when the change isn't in the plug-in folder for the next launch (a session without one, or the list there can't be read or written or is full; it is saved with the next change that saves), disabled}",
"{id | file: a plug-in as plugin.safeMode's disabled lists it or as plugin.list's source (under automation read roots, a file outside them by the file name shown, when no other listed file has it), enabled: bool} turn a plug-in on or off for the next launch (Help › Safe Mode's Enable on Re-launch); nothing loads, unloads or is uninstalled now. Turning on by id also turns on the file the plug-in is stored in. Turning on one that isn't disabled is an error. plugin.install of a disabled plug-in turns it on → {changed, saved: false when the change isn't in the plug-in folder for the next launch (a session without one, or the list there can't be read or written or is full; it is saved with the next change that saves), disabled}",
always,
set_enabled
),
@@ -308,7 +308,9 @@ pub(super) const ALLOWED: &[&str] = &[
"object.nudge",
"object.objectsOnPath.attach",
"object.objectsOnPath.expand",
"object.objectsOnPath.moveMember",
"object.objectsOnPath.options",
"object.objectsOnPath.selectMember",
"object.path.addAnchorPoints",
"object.path.cleanUp",
"object.path.divideObjectsBelow",
@@ -646,6 +648,8 @@ pub(super) const ALLOWED: &[&str] = &[
"type.opticalMarginAlignment",
"type.orientation.horizontal",
"type.orientation.vertical",
"type.pathCenter.bottom",
"type.pathCenter.top",
"type.pathOptions",
"type.resetHorizontalScale",
"type.resetTracking",
+32 -7
View File
@@ -97,6 +97,10 @@ pub trait RecoveryStore: Send + Sync {
fn remove(&self, name: &str) -> std::result::Result<(), String>;
/// Where the entries are, as the user knows it (a folder, "browser storage").
fn location(&self) -> String;
/// Is [`RecoveryStore::location`] a folder on this computer (default: no)?
fn in_folder(&self) -> bool {
false
}
/// The areas in the store (default: those with entries).
fn areas(&self) -> std::result::Result<Vec<String>, String> {
let names = self.list()?;
@@ -477,6 +481,9 @@ impl RecoveryStore for FolderStore {
fn location(&self) -> String {
self.0.to_string_lossy().into_owned()
}
fn in_folder(&self) -> bool {
true
}
fn areas(&self) -> std::result::Result<Vec<String>, String> {
Self::names(&self.0, true)
}
@@ -938,6 +945,21 @@ fn sweep(store: &dyn RecoveryStore, area: &str) {
}
}
/// The document's file `path` as a reply names it: under automation read roots, only inside them.
fn shown_path(path: Option<String>) -> Option<String> {
path.filter(|p| crate::file_access::check_read(p).is_ok())
}
/// Where `store` keeps its copies, as a reply names it: a recovery folder outside the automation
/// read roots is `null`.
fn shown_location(store: &dyn RecoveryStore) -> Value {
let location = store.location();
if store.in_folder() && crate::file_access::check_read(&location).is_err() {
return Value::Null;
}
json!(location)
}
fn read_meta(store: &dyn RecoveryStore, file: &str) -> Meta {
store.read(&format!("{file}{META_EXT}")).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default()
}
@@ -1235,7 +1257,7 @@ fn save(s: &mut Session, _: &Value) -> Result<Value> {
}
forget_clean(s);
heartbeat(s);
Ok(json!({ "saved": saved, "skipped": skipped, "location": store.location() }))
Ok(json!({ "saved": saved, "skipped": skipped, "location": shown_location(store.as_ref()) }))
}
/// Who an area of the store belongs to.
@@ -1361,7 +1383,7 @@ fn list(s: &mut Session, _: &Value) -> Result<Value> {
let meta = read_meta(store.as_ref(), f);
let title = if meta.title.is_empty() { f.rsplit('/').next().unwrap_or(f).to_string() } else { meta.title };
rows.push(json!({
"file": f, "title": title, "path": meta.path, "format": meta.format, "saved": meta.saved,
"file": f, "title": title, "path": shown_path(meta.path), "format": meta.format, "saved": meta.saved,
"open": (who == Owner::Mine && open.contains(f)) || left.contains(f), "running": who == Owner::Running,
}));
}
@@ -1370,7 +1392,7 @@ fn list(s: &mut Session, _: &Value) -> Result<Value> {
tidy(store.as_ref(), &area, hold);
}
}
Ok(json!({ "copies": rows, "location": store.location() }))
Ok(json!({ "copies": rows, "location": shown_location(store.as_ref()) }))
}
/// A gone app's area to act on: its name, the copies to act on, and its lock.
@@ -1483,7 +1505,10 @@ fn restore_one(s: &mut Session, store: &Arc<dyn RecoveryStore>, file: &str) -> R
// The copy stays until the document is saved or closed.
st.recovery = Some(RecoveryCopy { file: mine.clone(), doc: st.doc.clone() });
let title = st.title();
Ok(super::fileio::merge(json!({ "index": index, "title": title, "file": mine, "path": meta.path, "warnings": warnings }), links.to_json()))
Ok(super::fileio::merge(
json!({ "index": index, "title": title, "file": mine, "path": shown_path(meta.path), "warnings": warnings }),
links.to_json(),
))
}
fn restore(s: &mut Session, p: &Value) -> Result<Value> {
@@ -1527,7 +1552,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Save Recovery Data",
[],
None,
"{} write a recovery copy of every modified document changed since its last copy, in this app's own area of the store (the app does this every autosaveInterval minutes while autosaveRecovery is on; documents of more than 20000 objects are skipped while recoveryOffForComplex is on). Images are stored apart, each once while unchanged. A copy goes when its document is saved, reverted or closed → {saved: [{file, title, bytes, imageBytes (images written this time)}], skipped: [{title, reason}], location} (location: the recovery folder, or browser storage on the web)",
"{} write a recovery copy of every modified document changed since its last copy, in this app's own area of the store (the app does this every autosaveInterval minutes while autosaveRecovery is on; documents of more than 20000 objects are skipped while recoveryOffForComplex is on). Images are stored apart, each once while unchanged. A copy goes when its document is saved, reverted or closed → {saved: [{file, title, bytes, imageBytes (images written this time)}], skipped: [{title, reason}], location} (location: the recovery folder, or browser storage on the web; null under automation read roots when the folder is outside them)",
has_store,
save
),
@@ -1536,7 +1561,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Recovery Data",
[],
None,
"{} the recovery copies in the store → {copies: [{file (\"<area>/<name>\"), title, path (the document's file, if it had one), format, saved (Unix seconds or null), open (the copy of a document open here), running (kept by another VectorCraft that is running)}], location}; copies neither open nor running were left behind by a crash",
"{} the recovery copies in the store → {copies: [{file (\"<area>/<name>\"), title, path (the document's file, if it had one), format, saved (Unix seconds or null), open (the copy of a document open here), running (kept by another VectorCraft that is running)}], location}; copies neither open nor running were left behind by a crash; under automation read roots, path is null when the document's file is outside them, and location when the recovery folder is",
has_store,
list
),
@@ -1545,7 +1570,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Restore Recovered Documents",
[],
None,
"{file?} open a copy left behind by a crash (default: every one; a running VectorCraft's copies are never taken) as a new document titled \"<name> [Recovered]\": modified, and Save asks where to save it (suggesting its original file) → {restored: [{index, title, file, path, warnings, missingLinks, modifiedLinks, updatedLinks}], failed: [{file, error}] (damaged copies, when restoring every one; a named one fails the command)}. The copy moves to this app's area and stays until the document is saved or closed",
"{file?} open a copy left behind by a crash (default: every one; a running VectorCraft's copies are never taken) as a new document titled \"<name> [Recovered]\": modified, and Save asks where to save it (suggesting its original file) → {restored: [{index, title, file, path, warnings, missingLinks, modifiedLinks, updatedLinks}], failed: [{file, error}] (damaged copies, when restoring every one; a named one fails the command)}; under automation read roots, path is null when the original file is outside them. The copy moves to this app's area and stays until the document is saved or closed",
has_store,
restore
),
+44
View File
@@ -233,6 +233,43 @@ impl Session {
self.scripts_dir.as_deref().filter(|_| !cfg!(target_arch = "wasm32"))
}
/// The last run's report ([`Session::script_report`]) as a reply shows it: under automation read
/// roots, a file the run wrote outside them (`written`) and the file a failed run stopped in
/// (`file`, also in the run's error line in `console`) are named by their file name. What the
/// script wrote itself (`log`, its output lines) stays as written.
pub fn shown_script_report(&self) -> Option<Value> {
let mut report = self.script_report()?.clone();
if let Some(written) = report.get_mut("written").and_then(Value::as_array_mut) {
for path in written.iter_mut() {
if let Some(name) = path.as_str().and_then(hidden_name) {
*path = json!(name);
}
}
}
if let Some(file) = report.get("file").and_then(Value::as_str).map(str::to_string)
&& let Some(name) = hidden_name(&file)
{
// The run's error lines come after every line the script wrote. They are written again
// from the report with the file's name, which also covers a line the console cut inside
// the path. A console that dropped its oldest lines may hold only the last of them.
let before = script::error_lines(&report);
report["file"] = json!(name);
if let Some(message) = report.get("message").and_then(Value::as_str) {
report["message"] = json!(message.replace(&file, &name));
}
let after = script::error_lines(&report);
if let Some(lines) = report.pointer_mut("/console/lines").and_then(Value::as_array_mut) {
let kept = (1..=before.len().min(lines.len()))
.rev()
.find(|&n| lines.iter().rev().take(n).map(Value::as_str).eq(before.iter().rev().take(n).map(|l| Some(l.as_str()))))
.unwrap_or(0);
lines.truncate(lines.len() - kept);
lines.extend(after.iter().skip(after.len().saturating_sub(kept)).map(|l| json!(l)));
}
}
Some(report)
}
/// The text of the script at `path`, which a listing of the Scripts folder gave
/// ([`script::folder::read`]), checked as `script.run` checks a file's.
pub fn installed_script(&self, path: &str) -> Result<String> {
@@ -248,6 +285,13 @@ impl Session {
}
}
/// The file name a reply names `path` by when the file is outside the automation read roots; `None`
/// when a reply may name it whole.
fn hidden_name(path: &str) -> Option<String> {
let shown = super::fileio::shown_path(path);
(shown != path).then(|| shown.into_owned())
}
fn list_installed(s: &mut Session, _: &Value) -> Result<Value> {
let Some(root) = s.scripts_dir() else {
return Ok(json!({"folder": null, "scripts": [], "truncated": false, "unreadable": false}));
+1 -1
View File
@@ -184,7 +184,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Not Aligned to Pixel Grid",
["Select", "Object"],
None,
"{} the paths (not guides) and compound paths whose pixel-aligned property (object.setPixelAligned) is off, looking into groups but not into compound paths → {count}",
"{} the paths (not guides) and compound paths whose pixel-aligned property (object.setPixelAligned) is off, looking into groups, clip groups, blends, envelopes, repeats and Intertwine groups but not into compound paths → {count}",
has_doc,
not_pixel_aligned
),
+1
View File
@@ -1365,6 +1365,7 @@ fn set_path_handle(s: &mut Session, p: &Value) -> Result<Value> {
#[cfg(test)]
mod area_tests;
mod block;
pub(crate) use block::needed_room;
#[cfg(test)]
mod block_tests;
+34 -1
View File
@@ -89,6 +89,39 @@ fn line_widths(db: &vectorcraft_text::FontDb, t: &TextObject) -> std::collection
out
}
/// The room along its lines that a frame of `t`'s text needs for Block to keep the widest line as
/// typed at its present size: that line's width plus its paragraph's indents, as [`block_fit`]
/// measures them, and a margin of under half a size step so that the line is not made a step
/// smaller; with the widest line's first byte and its paragraph's index. A line whose negative
/// indents take more than its width needs its own width. None when no line has a width.
pub(crate) fn needed_room(t: &TextObject) -> Option<(f64, usize, usize)> {
let points = t.style_scale().map(|s| s.points).filter(|p| p.is_finite() && *p > 1e-12)?;
let text = t.plain_text();
let lines = typed_lines(&text);
let widths = line_widths(vectorcraft_text::FontDb::global(), t);
let sizes = first_sizes(&t.runs, &lines);
lines
.iter()
.zip(&sizes)
.filter_map(|(l, size)| {
let width = widths.get(&l.start).copied().filter(|w| w.is_finite() && *w > 1e-9)?;
let size = size * points;
if l.content == l.start || !(size.is_finite() && size > 0.0) {
return None;
}
let para = t.para_at(l.para);
let first = if l.para_start { para.first_line_indent } else { 0.0 };
let indents = para.laid_out_left_indent() + para.right_indent + first;
// Negative indents that take more than the line's width leave the line no room at its
// size; the frame is then as wide as the line itself, and Block makes it larger.
let room = if width + indents > 1e-9 { width + indents } else { width };
// A tenth of a point more size widens the line by 0.1 * width / size.
Some((room + 0.04 * width / size, l.start, l.para))
})
.filter(|r| r.0.is_finite() && r.0 > 1e-9)
.reduce(|a, b| if b.0 > a.0 { b } else { a })
}
/// The size a line set at `size` points and `width` wide takes to fill `avail`, its width growing
/// by `slope` a point of size (`width / size` when the whole line follows its size): rounded down
/// to tenths and kept within [`SIZES`]. A line that fits and would not fit a tenth larger keeps its
@@ -152,7 +185,7 @@ pub(crate) fn block_fit(t: &mut TextObject) -> bool {
let width = widths.get(&l.start).copied().filter(|w| w.is_finite() && *w > 1e-9)?;
let para = t.para_at(l.para);
let first = if l.para_start { para.first_line_indent } else { 0.0 };
let avail = cell - para.left_indent - para.right_indent - first;
let avail = cell - para.laid_out_left_indent() - para.right_indent - first;
let size = size * points;
if !(size.is_finite() && size > 0.0) {
return None;
+249 -3
View File
@@ -188,13 +188,25 @@ fn bad_params_and_other_type_are_refused() {
assert!(!text(&s, id).dynamic_text);
let point = s.execute("text.create", &json!({"x": 10, "y": 500, "text": "point"})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [point]})).unwrap();
// Off leaves point type as it is, with no undo step, and a gap needs it turned on.
let n = undo_len(&s);
assert_eq!(s.execute("type.dynamicText", &json!({"on": false})).unwrap()["ids"], json!([point]));
let e = s.execute("type.dynamicText", &json!({"on": false, "wordGap": 200})).unwrap_err().to_string();
assert!(e.contains("need area type"), "{e}");
assert_eq!(undo_len(&s), n);
assert!(matches!(text(&s, point).kind, TextKind::Point));
let shape = s.execute("shape.rectangle", &json!({"x": 500, "y": 500, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [shape]})).unwrap();
let e = s.execute("type.dynamicText", &json!({})).unwrap_err().to_string();
assert!(e.contains("select type on a path or area type"), "{e}");
// With point type selected too, only the area type changes.
// With point type selected too, both turn on, the point type as area type with Block on.
s.execute("select.set", &json!({"ids": [id, point]})).unwrap();
let n = undo_len(&s);
let r = s.execute("type.dynamicText", &json!({})).unwrap();
assert_eq!(r["ids"], json!([id]));
assert!(text(&s, id).dynamic_text && !text(&s, point).dynamic_text);
assert_eq!(r["ids"], json!([id, point]));
assert!(text(&s, id).dynamic_text && text(&s, point).dynamic_text);
assert!(matches!(text(&s, point).kind, TextKind::Area { .. }));
assert_eq!(undo_len(&s), n + 1);
// A gap with only type on a path selected is an error, and nothing changes.
let path = s.execute("path.create", &json!({"d": "M60 550 L340 550"})).unwrap()["id"].as_u64().unwrap();
let along = s.execute("text.createInPath", &json!({"path": path, "mode": "onPath", "text": "Along"})).unwrap()["id"].as_u64().unwrap();
@@ -438,6 +450,228 @@ fn threaded_frames_are_refused_and_threading_turns_block_off() {
assert!(matches!(text(&s, a).kind, TextKind::Area { .. }));
}
/// 12 pt point type at (300, 100) with `extra` params for `text.create`, selected.
fn point(s: &mut Session, text: &str, extra: Value) -> u64 {
let mut p = json!({"x": 300, "y": 100, "size": 12, "text": text});
if let (Some(p), Some(extra)) = (p.as_object_mut(), extra.as_object()) {
p.extend(extra.clone());
}
let id = s.execute("text.create", &p).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
id
}
/// Where the first glyph of the laid-out line starting at byte `start` is in the document.
fn line_start(t: &TextObject, start: usize) -> vectorcraft_geom::Point {
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
let l = lay.lines.iter().find(|l| l.start == start).expect("a line starts there");
t.xf * lay.glyphs[l.glyph_start].origin
}
#[test]
fn point_type_becomes_area_type_with_block_at_its_widest_line() {
for justify in ["left", "center", "right"] {
let mut s = session();
let id = point(&mut s, "Short\nA much longer line", json!({}));
s.execute("text.setStyle", &json!({"ids": [id], "justify": justify})).unwrap();
let before = line_start(&text(&s, id), 6);
let n = undo_len(&s);
let r = s.execute("type.dynamicText", &json!({})).unwrap();
assert_eq!((r["on"].clone(), r["ids"].clone()), (json!(true), json!([id])));
assert_eq!((r["wordGap"].clone(), r["lineGap"].clone()), (json!(100.0), json!(0.0)), "the reply gives the new frame's gaps");
assert_eq!(undo_len(&s), n + 1, "{justify}: one undo step");
assert_eq!(s.doc().unwrap().history.undo.last().unwrap().label, "Dynamic Text");
let t = text(&s, id);
assert!(t.dynamic_text && matches!(t.kind, TextKind::Area { .. }), "{justify}");
assert_eq!(t.area.fit, AreaFit::None);
assert_block(&t);
assert_eq!(size_at(&t, 6), 12.0, "{justify}: the widest line keeps its size");
assert!(size_at(&t, 0) > 24.0, "{justify}: the short line grows to the frame's width: {}", size_at(&t, 0));
// Across, the widest line stays where it was; the short line above it grew, so it moved down.
let after = line_start(&t, 6);
assert!((after.x - before.x).abs() < 0.05, "{justify}: the widest line stays where it was across: {before:?} → {after:?}");
assert!(after.y > before.y + 12.0, "{justify}");
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow, "{justify}: the frame holds every line");
// Edits fit it again as area type; undo brings the point type back as it was.
s.execute("edit.undo", &json!({})).unwrap();
let back = text(&s, id);
assert!(matches!(back.kind, TextKind::Point) && !back.dynamic_text && size_at(&back, 0) == 12.0, "{justify}");
}
}
#[test]
fn point_type_with_gaps_indents_and_vertical_type_turns_into_block() {
let mut s = session();
// The gaps apply to the frame point type becomes.
let id = point(&mut s, "one\ntwo words here", json!({}));
let r = s.execute("type.dynamicText", &json!({"wordGap": 300, "lineGap": 4})).unwrap();
assert_eq!((r["wordGap"].clone(), r["lineGap"].clone()), (json!(300.0), json!(4.0)));
let t = text(&s, id);
assert!(t.dynamic_text && (t.area.word_gap, t.area.line_gap) == (300.0, 4.0));
assert_block(&t);
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow);
// Indents: the frame takes them in, so the widest line keeps its size.
let id = point(&mut s, "Tiny\nThe widest line of all", json!({"y": 300}));
s.execute("text.setFormat", &json!({"ids": [id], "leftIndent": 20, "firstLineIndent": 10})).unwrap();
let before = line_start(&text(&s, id), 5);
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert_block(&t);
assert_eq!(size_at(&t, 5), 12.0);
assert!((line_start(&t, 5).x - before.x).abs() < 0.05, "{before:?} → {:?}", line_start(&t, 5));
// A nested list item: the frame takes in the level's indent too.
let id = point(&mut s, "Tiny\nThe widest item of all", json!({"y": 200}));
s.execute("text.setFormat", &json!({"ids": [id], "list": "bullet", "listLevel": 3})).unwrap();
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert_eq!(size_at(&t, 5), 12.0, "nested list");
assert!(size_at(&t, 0) > 12.0);
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow);
// Mixed alignments: the widest line keeps its size and its place.
let id = point(&mut s, "Left\nThe widest line, right aligned", json!({"y": 400}));
let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
if let Some(NodeKind::Text(t)) = doc.node_mut(NodeId(id)).map(|n| &mut n.kind) {
let right = vectorcraft_doc::ParaStyle { justify: vectorcraft_doc::Justify::Right, ..t.para.clone() };
t.set_paragraph_styles(vec![t.para.clone(), right]);
}
let before = line_start(&text(&s, id), 5);
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert_eq!(size_at(&t, 5), 12.0, "mixed alignments");
assert!((line_start(&t, 5).x - before.x).abs() < 0.05, "{before:?} → {:?}", line_start(&t, 5));
// A right-to-left list, whose indents the layout mirrors.
let id = point(&mut s, "קצר\nשורה ארוכה בהרבה מהראשונה", json!({"y": 450}));
s.execute("text.setFormat", &json!({"ids": [id], "list": "bullet", "rightIndent": 9})).unwrap();
let widest = "קצר\n".len();
let before = line_start(&text(&s, id), widest);
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert_eq!(size_at(&t, widest), 12.0, "right-to-left list");
assert!((line_start(&t, widest).x - before.x).abs() < 0.05, "{before:?} → {:?}", line_start(&t, widest));
// Point type that was area type with its own options: the new frame takes the defaults but the
// gaps.
let id = point(&mut s, "Was\nonce a frame of two columns", json!({"y": 500}));
s.execute("type.convertToAreaType", &json!({"ids": [id]})).unwrap();
s.execute(
"text.areaOptions",
&json!({"columns": 2, "gutter": 12, "inset": 6, "verticalAlign": "bottom", "firstBaselineMin": 40, "wordGap": 150}),
)
.unwrap();
s.execute("type.convertToPointType", &json!({"ids": [id]})).unwrap();
let before = line_start(&text(&s, id), 4);
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
let defaults = vectorcraft_doc::AreaOptions { word_gap: 150.0, ..Default::default() };
assert_eq!(t.area, defaults);
assert_eq!(size_at(&t, 4), 12.0, "options from an earlier frame");
assert!((line_start(&t, 4).x - before.x).abs() < 0.05, "{before:?} → {:?}", line_start(&t, 4));
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow);
// Vertical type: the frame is as tall as the longest column and grows to the left.
let id = point(&mut s, "縦書き\nもっと長い縦書きの行", json!({"x": 600, "y": 40, "vertical": true}));
let before = line_start(&text(&s, id), "縦書き\n".len());
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert!(t.vertical && t.dynamic_text && matches!(t.kind, TextKind::Area { .. }));
assert_block(&t);
assert_eq!(size_at(&t, "縦書き\n".len()), 12.0);
let after = line_start(&t, "縦書き\n".len());
assert!((after.y - before.y).abs() < 0.05, "the longest column stays where it was down the page: {before:?} → {after:?}");
assert!(after.x < before.x - 12.0, "the short column before it grew, so it moved left: {before:?} → {after:?}");
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow);
}
#[test]
fn point_type_with_negative_indents_wider_than_its_line_turns_into_block() {
// Block makes the line larger; it keeps its start, center or end by its alignment.
let ends = |t: &TextObject| {
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
let l = &lay.lines[0];
((t.xf * vectorcraft_geom::Point::new(l.x0, l.baseline)).x, (t.xf * vectorcraft_geom::Point::new(l.x1 - l.trailing, l.baseline)).x)
};
for justify in ["left", "center", "right"] {
let mut s = session();
let id = point(&mut s, "Short", json!({}));
s.execute("text.setStyle", &json!({"ids": [id], "justify": justify})).unwrap();
s.execute("text.setFormat", &json!({"ids": [id], "leftIndent": -200})).unwrap();
let (b0, b1) = ends(&text(&s, id));
let n = undo_len(&s);
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
assert_eq!(undo_len(&s), n + 1, "{justify}");
let t = text(&s, id);
assert!(t.dynamic_text && matches!(t.kind, TextKind::Area { .. }), "{justify}: the frame is as wide as the line");
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow, "{justify}");
assert!(size_at(&t, 0) > 12.0, "{justify}: Block makes the line larger");
let (a0, a1) = ends(&t);
let kept = match justify {
"left" => (a0, b0),
"center" => ((a0 + a1) / 2.0, (b0 + b1) / 2.0),
_ => (a1, b1),
};
assert!((kept.0 - kept.1).abs() < 0.05, "{justify}: the line keeps its aligned point: {b0},{b1} → {a0},{a1}");
}
}
#[test]
fn point_type_under_a_text_wrap_object_turns_into_block_that_holds_every_line() {
let mut s = session();
let id = point(&mut s, "One\nTwo\nThree\nA much longer line than the rest", json!({}));
// A wrap object above the type, across the top of the frame it becomes.
let r = s.execute("shape.rectangle", &json!({"x": 250, "y": 80, "width": 400, "height": 40})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [r]})).unwrap();
s.execute("object.textWrap.make", &json!({})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert!(t.dynamic_text && matches!(t.kind, TextKind::Area { .. }));
assert!(!t.wrap.is_empty(), "the new area type takes the wrap object");
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow, "the frame holds every line around the wrap");
// A wrap object deeper than any size Block sets, across the whole frame: the lines go below it.
let id = point(&mut s, "Below", json!({"x": 1000, "y": 100}));
let r = s.execute("shape.rectangle", &json!({"x": 900, "y": 80, "width": 400, "height": 9000})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [r]})).unwrap();
s.execute("object.textWrap.make", &json!({})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert!(t.dynamic_text && !t.wrap.is_empty());
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow, "the frame reaches past a deep wrap object");
// An inverted wrap object far below the type holds the lines inside it: the frame reaches it.
let id = point(&mut s, "Inside", json!({"x": 1600, "y": 100}));
let r = s.execute("shape.rectangle", &json!({"x": 1550, "y": 9000, "width": 400, "height": 100})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [r]})).unwrap();
s.execute("object.textWrap.make", &json!({})).unwrap();
s.execute("object.textWrap.options", &json!({"invert": true})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let t = text(&s, id);
assert!(t.dynamic_text && !t.wrap.is_empty());
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow, "the frame reaches a distant inverted wrap object");
}
#[test]
fn point_type_with_nothing_to_fit_is_left_as_it_is() {
let mut s = session();
for blank in ["", " ", "\n\n"] {
let id = point(&mut s, blank, json!({}));
let before = text(&s, id);
let n = undo_len(&s);
let r = s.execute("type.dynamicText", &json!({})).unwrap();
assert_eq!(r["on"], json!(true));
assert_eq!(undo_len(&s), n, "{blank:?}: no undo step");
assert_eq!(text(&s, id), before, "{blank:?}");
// A gap needs type it can apply to.
let e = s.execute("type.dynamicText", &json!({"wordGap": 200})).unwrap_err().to_string();
assert!(e.contains("need area type"), "{blank:?}: {e}");
}
// A line far shorter than the widest one stops at the size limit, and the frame still holds it.
let id = point(&mut s, &format!(".\n{}", "w".repeat(400)), json!({"size": 6}));
s.execute("type.dynamicText", &json!({})).unwrap();
let t = text(&s, id);
assert!(t.dynamic_text);
assert_eq!(size_at(&t, 0), 1296.0);
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow);
}
#[test]
fn long_text_fits_in_a_bounded_number_of_layouts() {
let mut s = session();
@@ -451,4 +685,16 @@ fn long_text_fits_in_a_bounded_number_of_layouts() {
// pass and the caches), plus the reply's own.
let bound = 2 * (2 + 2 * super::block::BLOCK_PASSES as u64) + 4;
assert!(used <= bound, "{used} layouts");
// Long point type: measured, fitted in its frame and fitted again at its depth, with the
// layouts that place and measure the frame.
let id = point(&mut s, &story, json!({}));
let before = vectorcraft_text::test_fonts::layouts_on_this_thread();
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
let used = vectorcraft_text::test_fonts::layouts_on_this_thread() - before;
let t = text(&s, id);
assert!(t.dynamic_text && matches!(t.kind, TextKind::Area { .. }));
assert_block(&t);
assert!(!vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).overflow);
let bound = 2 * (2 + 2 * super::block::BLOCK_PASSES as u64) + 8;
assert!(used <= bound, "point type: {used} layouts");
}
+300 -21
View File
@@ -7,7 +7,7 @@ use vectorcraft_doc::{AreaFit, CharStyle, Document, Justify, LockedArtboards, No
use vectorcraft_geom::{Affine, Rect, shapes};
use super::object::choice;
use super::typecmd::{area_text, block_gaps, refresh_bounds};
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, number_or,
switch_or, targets, text_param,
@@ -60,12 +60,30 @@ pub fn specs() -> Vec<CommandSpec> {
has_selection,
path_options
),
cmd!(
"type.pathCenter.top",
"Center on Top",
["Type", "Type on a Path"],
None,
"{ids?|id?} slide the selected type on a closed path along it so that the middle of the span between its start and end brackets lands on the path's topmost point as the object is drawn (after its transform, so a rotated, scaled or skewed path is measured as it appears; on a level stretch such as a rectangle's top edge, its middle; with several separate topmost points, the middle of the shortest part of the path that holds them all), keeping the span's length (a full turn stays a full turn), and set the first paragraph's alignment to Center unless it is Center or Justify Center, so the type is centered there. Point type and area type in the selection are left as they are. Type on an open or compound path, type in a thread, and type on a path with no length or no height are refused with an error that names them, and nothing changes. When every object is already centered there, nothing changes and no undo step is recorded → {ids, start, end} (the first object's brackets)",
has_closed_path_type,
path_center_top
),
cmd!(
"type.pathCenter.bottom",
"Center on Bottom",
["Type", "Type on a Path"],
None,
"{ids?|id?} as type.pathCenter.top, on the path's bottommost point as drawn. The type is not flipped: on the bottom of a path that runs clockwise it reads upside down until Type on a Path Options › Flip turns it → {ids, start, end} (the first object's brackets)",
has_closed_path_type,
path_center_bottom
),
cmd!(
"type.dynamicText",
"Dynamic Text",
["Type"],
None,
"{ids?|id?, on?: bool, wordGap?: % of a word space 0..1000 (100), lineGap?: pt -1296..1296 (0)} turn Dynamic Text on or off for the selected type on a path and area type (on omitted: the opposite of the first object's setting, or on when a gap is given). On type on a path, the layout scales the text by one factor (every character's size, leading and baseline shift; Type on a Path Options › Spacing stays) so that it fills the span between its start and end brackets, larger or smaller, and fits it again after every edit to the text, the path or the brackets; the first character's size moves in steps of 0.1 pt within 0.1 to 1,296 pt, and at 0.1 pt text that still runs past the end bracket overflows. The stored sizes keep their proportions. On area type it is Block: each line as typed (each paragraph, and each forced line break in one; lines are not broken again) is set to the frame's width, less the inset, the gutters and the paragraph's indents, by changing its font size only: its first character's size, in steps of 0.1 pt within 0.1 to 1,296 pt, the line's other characters keeping their proportions to it, with baseline shifts following. Every character's leading is its size plus lineGap, and the layout sets every paragraph with wordGap as its Desired word spacing, its Minimum or Maximum moving out to wordGap when wordGap lies outside it (the paragraphs keep their own Justification… values, which apply again when Block is off; the gaps are area type's, and are kept while Block is off; a gap with no area type in the selection is an error). The sizes are written into the characters and fitted again after every edit to the text or the frame, in the same undo step; at a size limit a line can be narrower than the frame or wrap. An empty line keeps its size. Block replaces Auto Size and Shrink Text to Fit (Area Type Options › Block is the same setting). Off, the text keeps the sizes it was drawn at. Point type in the selection is left as it is; a selection holding type in a thread is refused (threading type turns Dynamic Text off, keeping its drawn sizes). When nothing changes, no undo step is recorded → {on, ids, fitScale (the first object's factor; 1 when off and for area type), wordGap?, lineGap? (the first area type's; left out without area type)}",
"{ids?|id?, on?: bool, wordGap?: % of a word space 0..1000 (100), lineGap?: pt -1296..1296 (0)} turn Dynamic Text on or off for the selected type on a path and area type, or turn it on for point type (on omitted: the opposite of the first object's setting, point type counting as off, or on when a gap is given). On type on a path, the layout scales the text by one factor (every character's size, leading and baseline shift; Type on a Path Options › Spacing stays) so that it fills the span between its start and end brackets, larger or smaller, and fits it again after every edit to the text, the path or the brackets; the first character's size moves in steps of 0.1 pt within 0.1 to 1,296 pt, and at 0.1 pt text that still runs past the end bracket overflows. The stored sizes keep their proportions. On area type it is Block: each line as typed (each paragraph, and each forced line break in one; lines are not broken again) is set to the frame's width, less the inset, the gutters and the paragraph's indents, by changing its font size only: its first character's size, in steps of 0.1 pt within 0.1 to 1,296 pt, the line's other characters keeping their proportions to it, with baseline shifts following. Every character's leading is its size plus lineGap, and the layout sets every paragraph with wordGap as its Desired word spacing, its Minimum or Maximum moving out to wordGap when wordGap lies outside it (the paragraphs keep their own Justification… values, which apply again when Block is off; the gaps are area type's, and are kept while Block is off; a gap with no area type in the selection, and no point type it turns into area type, is an error). The sizes are written into the characters and fitted again after every edit to the text or the frame, in the same undo step; at a size limit a line can be narrower than the frame or wrap. An empty line keeps its size. Block replaces Auto Size and Shrink Text to Fit (Area Type Options › Block is the same setting). Off, the text keeps the sizes it was drawn at. Turning it on turns point type into area type with Block on, with the default Area Type Options but the gaps (options kept from an earlier frame do not carry over): the frame is as wide (along the lines) as the widest line as typed with its paragraph's indents, so that line keeps its size and sits where it was (by its own alignment), the other lines are set to that width (when negative indents take more than that line's width, the frame is as wide as the line, and Block makes it larger), and the frame then grows in depth (down, or to the left for vertical type) to hold every fitted line, around any Text Wrap objects above it; the gaps apply to it as to area type. Point type with no line to fit (empty, or only spaces and breaks) is left as it is, and so is point type when it is turned off; a selection holding type in a thread is refused (threading type turns Dynamic Text off, keeping its drawn sizes). When nothing changes, no undo step is recorded → {on, ids, fitScale (the first object's factor; 1 when off and for area type), wordGap?, lineGap? (the first area type's; left out without area type)}",
has_dynamic_type,
dynamic_text
),
@@ -328,13 +346,7 @@ fn to_area(s: &mut Session, p: &Value) -> Result<Value> {
// A little slack on the right so the text doesn't rewrap.
let top = lay.lines.first().map(|l| l.baseline - l.ascent).unwrap_or(b.y0).min(b.y0);
let slack = size * 0.5 + trailing;
// Slack goes where the alignment leaves room, so the text doesn't move or rewrap.
let (sl, sr) = match t.para_at(0).justify {
Justify::Center | Justify::JustifyCenter => (slack * 0.5, slack * 0.5),
Justify::Right | Justify::JustifyRight => (slack, 0.0),
Justify::Auto if lay.lines.first().is_some_and(|l| l.rtl) => (slack, 0.0),
_ => (0.0, slack),
};
let (sl, sr) = slack_sides(t.para_at(0).justify, lay.lines.first().is_some_and(|l| l.rtl), slack);
let frame = lay.line_xf.transform_rect_bbox(Rect::new(b.x0 - sl, top, b.x1 + sr, b.y1.max(top + 1.0)));
t.kind = TextKind::Area { frame: shapes::rectangle(frame) };
refresh_bounds(t);
@@ -344,6 +356,107 @@ fn to_area(s: &mut Session, p: &Value) -> Result<Value> {
Ok(ids_json(&ids))
}
/// How `slack` added to point type's lines in a frame is shared before and after them: where the
/// alignment leaves room, so the text doesn't move or rewrap.
fn slack_sides(justify: Justify, rtl: bool, slack: f64) -> (f64, f64) {
match justify {
Justify::Center | Justify::JustifyCenter => (slack * 0.5, slack * 0.5),
Justify::Right | Justify::JustifyRight => (slack, 0.0),
Justify::Auto if rtl => (slack, 0.0),
_ => (0.0, slack),
}
}
/// Point type `t` turned into area type with Dynamic Text's Block on, with the default Area Type
/// Options but its gaps: the frame takes the room along the lines that keeps the widest line as
/// typed at its size ([`needed_room`]), placed so that line stays where it is by its own
/// alignment, and after the fit it takes the depth that holds every line, so nothing overflows.
/// Lines run in line space (for vertical type, down the page), and the frame is mapped to the
/// type's own space by the layout's `line_xf`. `wrap` is the Text Wrap shapes the new area type
/// takes, in the type's own space, which the fit and the depth follow. When negative indents take
/// more than the widest line's width, the frame is as wide as that line and placed so that the
/// line keeps its aligned point. None when no line has a
/// width (empty text, or only spaces and breaks), which Block leaves at its size.
fn point_to_block(t: &TextObject, wrap: &[vectorcraft_doc::WrapShape]) -> Option<TextObject> {
let db = vectorcraft_text::FontDb::global();
// Options point type kept from a frame it had before (columns, inset, alignment, first
// baseline) do not carry over to the new frame.
let mut t = t.clone();
let (word_gap, line_gap) = (t.area.word_gap, t.area.line_gap);
t.area = vectorcraft_doc::AreaOptions { word_gap, line_gap, ..Default::default() };
t.wrap = wrap.to_vec();
let t = &t;
// The room is measured as Block sets the lines in a frame, with the word gap.
let as_block = TextObject { dynamic_text: true, kind: TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, 1.0, 1.0)) }, ..t.clone() };
let (room, widest, para_index) = needed_room(&as_block)?;
let lay = vectorcraft_text::layout(db, t);
let first = lay.lines.first()?;
let line = lay.lines.iter().find(|l| l.start == widest)?;
// Across, the widest line as it is aligned, with its paragraph's indents, which the frame holds.
let para = t.para_at(para_index);
let starts = widest == 0 || t.plain_text().as_bytes().get(widest - 1) == Some(&b'\n');
let start_indent = para.laid_out_left_indent() + if starts { para.first_line_indent } else { 0.0 };
// A horizontal right-to-left list paragraph has its indents mirrored, as the layout sets them.
let mirror = line.rtl && !t.vertical && para.list.is_some();
let (left, right) = if mirror { (para.right_indent, start_indent) } else { (start_indent, para.right_indent) };
let (lo, hi) = (line.x0 - left, line.x1 - line.trailing + right);
let top = lay.lines.iter().map(|l| l.baseline - l.ascent).fold(first.baseline - first.ascent, f64::min);
let bottom = lay.lines.iter().map(|l| l.baseline + l.descent).fold(top, f64::max);
if ![lo, hi, top, bottom, room].iter().all(|v| v.is_finite()) {
return None;
}
// Negative indents can take more than the line's width (hi below lo); the frame is then wider
// than the line with its indents, and the same split of the difference keeps the line's
// aligned point (its start, center or end) where it was when Block makes the line fill it.
let (sl, _) = slack_sides(para.justify, line.rtl, room - (hi - lo));
let frame = |depth: f64| lay.line_xf.transform_rect_bbox(Rect::new(lo - sl, top, lo - sl + room, top + depth.max(1.0)));
let start = frame(bottom - top);
let mut out = t.clone();
out.kind = TextKind::Area { frame: shapes::rectangle(start) };
out.dynamic_text = true;
refresh_bounds(&mut out);
// The lines fitted in one cell from the frame's top deep enough for all of them (every line at
// the largest size Block sets), around any wrap shapes, give the depth the frame takes.
let mut probe = out.clone();
let points = t.style_scale().map_or(1.0, |s| s.points).max(1e-12);
let deep = (bottom - top) + (lay.lines.len() as f64 + 1.0) * 3.0 * (1296.0 + out.area.line_gap.abs()) / points;
// Wrap shapes push lines on past them (an inverted one holds them inside it), so the cell also
// reaches as far again as the farthest one reaches past the frame's top.
let inv = lay.line_xf.inverse();
let deep = deep
+ wrap
.iter()
.filter_map(|w| w.path.bounds().map(|r| inv.transform_rect_bbox(r)).map(|r| (r.y1 - top).max(0.0) + 2.0 * w.wrap.offset.abs()))
.filter(|d| d.is_finite())
.fold(0.0, f64::max);
probe.kind = TextKind::Area { frame: shapes::rectangle(frame(deep)) };
if !wrap.is_empty() {
refresh_bounds(&mut probe);
}
let laid = vectorcraft_text::layout(db, &probe);
if laid.overflow {
return Some(out);
}
let mut grown = start;
for l in &laid.lines {
for y in [l.baseline - l.ascent, l.baseline + l.descent] {
grown = grown.union_pt(laid.line_xf * vectorcraft_geom::Point::new(l.x0, y));
}
}
// Only the depth grows (for vertical type, the columns run on to the left), with a hundredth
// of a point to spare.
if t.vertical {
(grown.y0, grown.y1, grown.x0) = (start.y0, start.y1, grown.x0 - 0.01);
} else {
(grown.x0, grown.x1, grown.y1) = (start.x0, start.x1, grown.y1 + 0.01);
}
if grown.is_finite() && grown != start {
out.kind = TextKind::Area { frame: shapes::rectangle(grown) };
refresh_bounds(&mut out);
}
Some(out)
}
/// (run, byte within the run) for a byte offset into the plain text.
fn locate(runs: &[TextRun], byte: usize) -> Option<(usize, usize)> {
let mut off = 0;
@@ -430,6 +543,136 @@ fn to_point(s: &mut Session, p: &Value) -> Result<Value> {
Ok(ids_json(&ids))
}
/// Whether type on a path `t` runs along one closed path (no open or compound path).
fn on_one_closed_path(t: &TextObject) -> bool {
matches!(&t.kind, TextKind::OnPath { path, .. } if path.subpaths.len() == 1 && path.is_closed())
}
/// Why `type.pathCenter.top` and `.bottom` refuse type on a path `ids`: those on an open or
/// compound path, then those in a thread; None when they take every one.
fn path_center_refusal(d: &Document, ids: &[NodeId]) -> Option<String> {
let open = ids.iter().filter(|id| !path_text(d.node(**id)).is_some_and(on_one_closed_path)).map(|id| id.0.to_string()).collect::<Vec<_>>();
if !open.is_empty() {
let open = open.join(", ");
return Some(format!("type on an open or compound path cannot be centered on its top or bottom: {open}"));
}
let frames = threaded_ids(d, ids);
(!frames.is_empty()).then(|| format!("type on a path in a thread cannot be centered on its top or bottom: {frames}"))
}
/// `type.pathCenter.top` and `.bottom` are enabled for a selection holding type on a path, all of
/// it on one closed path and none of it in a thread.
fn has_closed_path_type(s: &Session) -> std::result::Result<(), String> {
has_selection(s)?;
let st = s.active().ok_or("no document open")?;
let d = &st.doc;
let selected: Vec<NodeId> = st.selection.objects.to_vec();
let paths: Vec<NodeId> = text_ids(d, &selected).into_iter().filter(|id| path_text(d.node(*id)).is_some()).collect();
if paths.is_empty() {
return Err("select type on a closed path".into());
}
path_center_refusal(d, &paths).map_or(Ok(()), Err)
}
/// The brackets that center type on a path `t` on its path's topmost point (`bottom`: its
/// bottommost) as `t.xf` draws it, its span keeping its length; None for a path with no length or
/// no height.
fn centered_brackets(t: &TextObject, bottom: bool) -> Option<(f64, Option<f64>)> {
let TextKind::OnPath { path, end, .. } = &t.kind else { return None };
let (from, to) = t.kind.path_span()?;
let arc = vectorcraft_geom::ArcPath::new(path);
if arc.is_empty() {
return None;
}
let flip = if bottom { Affine::FLIP_Y } else { Affine::IDENTITY };
let middle = arc.topmost(flip * t.xf)? / arc.len();
let run = to - from;
let start = (middle - run * 0.5).rem_euclid(1.0).clamp(0.0, 1.0);
// Without an end bracket the type runs once round; a full turn's end stays on its start.
let end = end.map(|_| if run >= 1.0 - 1e-12 { start } else { (start + run).rem_euclid(1.0).clamp(0.0, 1.0) });
Some((start, end))
}
/// Whether brackets `a` and `b`, fractions of a closed path's length, are at one place within
/// rounding (0 and 1 are one place).
fn same_bracket(a: f64, b: f64) -> bool {
let d = (a - b).rem_euclid(1.0);
d.min(1.0 - d) <= 1e-9
}
fn path_center_top(s: &mut Session, p: &Value) -> Result<Value> {
path_center(s, p, false)
}
fn path_center_bottom(s: &mut Session, p: &Value) -> Result<Value> {
path_center(s, p, true)
}
/// Type › Type on a Path › Center on Top and Center on Bottom: slide the selected type on closed
/// paths along them so the middle of each span lands on the path's top (`bottom`: its bottom) as
/// drawn, and center the first paragraph, in one undo step; none when nothing changes.
fn path_center(s: &mut Session, p: &Value, bottom: bool) -> Result<Value> {
let c = if bottom { "type.pathCenter.bottom" } else { "type.pathCenter.top" };
let centered = |j: Justify| matches!(j, Justify::Center | Justify::JustifyCenter);
// Each object the command changes, with its new brackets when they move and whether its first
// paragraph is set to Center.
let (ids, changes) = {
let d = &s.doc()?.doc;
let ids: Vec<NodeId> = texts(s, p, c)?.into_iter().filter(|i| path_text(d.node(*i)).is_some()).collect();
if ids.is_empty() {
return Err(bad(c, "select type on a closed path"));
}
if let Some(why) = path_center_refusal(d, &ids) {
return Err(bad(c, why));
}
let (mut changes, mut flat) = (vec![], vec![]);
for id in &ids {
let Some(t) = path_text(d.node(*id)) else { continue };
let TextKind::OnPath { start, end, .. } = &t.kind else { continue };
let Some((to_start, to_end)) = centered_brackets(t, bottom) else {
flat.push(id.0.to_string());
continue;
};
let stays = same_bracket(*start, to_start)
&& match (end, to_end) {
(None, None) => true,
(Some(a), Some(b)) => same_bracket(*a, b),
_ => false,
};
let align = !centered(t.para_at(0).justify);
if !stays || align {
changes.push((*id, (!stays).then_some((to_start, to_end)), align));
}
}
if !flat.is_empty() {
let flat = flat.join(", ");
return Err(bad(c, format!("type on a path with no length or no height cannot be centered: {flat}")));
}
(ids, changes)
};
if !changes.is_empty() {
s.edit(if bottom { "Center on Bottom" } else { "Center on Top" }, |d, _| {
for (id, brackets, align) in &changes {
let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
if let (Some(b), TextKind::OnPath { start, end, .. }) = (brackets, &mut t.kind) {
(*start, *end) = *b;
}
if *align {
t.edit_paras(Some(0..1), |para| para.justify = Justify::Center);
}
refresh_bounds(t);
}
Ok(())
})?;
}
let d = &s.doc()?.doc;
let (start, end) = ids.first().and_then(|id| path_text(d.node(*id))).map_or((0.0, None), |t| match &t.kind {
TextKind::OnPath { start, end, .. } => (*start, *end),
_ => (0.0, None),
});
Ok(json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "start": start, "end": end}))
}
/// The options `type.pathOptions` sets; with none of them given it queries.
const PATH_OPTIONS: [&str; 6] = ["start", "end", "flip", "effect", "alignToPath", "spacing"];
@@ -550,14 +793,23 @@ fn dynamic_type(n: Option<&Node>) -> Option<&TextObject> {
path_text(n).or_else(|| area_text(n))
}
/// `type.dynamicText` is enabled for a selection holding type on a path or area type, none of it
/// in a thread.
/// Type `type.dynamicText` takes: type on a path, area type, and point type, which it turns into
/// area type with Block on.
fn dynamic_target(n: Option<&Node>) -> Option<&TextObject> {
match n.map(|n| &n.kind) {
Some(NodeKind::Text(t)) if matches!(t.kind, TextKind::Point) => Some(t),
_ => dynamic_type(n),
}
}
/// `type.dynamicText` is enabled for a selection holding type on a path, area type or point type,
/// none of it in a thread.
fn has_dynamic_type(s: &Session) -> std::result::Result<(), String> {
has_selection(s)?;
let st = s.active().ok_or("no document open")?;
let d = &st.doc;
let selected: Vec<NodeId> = st.selection.objects.to_vec();
let types: Vec<NodeId> = text_ids(d, &selected).into_iter().filter(|id| dynamic_type(d.node(*id)).is_some()).collect();
let types: Vec<NodeId> = text_ids(d, &selected).into_iter().filter(|id| dynamic_target(d.node(*id)).is_some()).collect();
if types.is_empty() {
return Err("select type on a path or area type".into());
}
@@ -583,32 +835,46 @@ fn threaded_ids(d: &Document, ids: &[NodeId]) -> String {
/// Type › Dynamic Text: set `on` (without it, the opposite of the first object's setting, or on
/// when a gap is given) on the selected type on a path and area type (Block, with its gaps), in
/// one undo step, and none when nothing changes. Turning it off keeps the sizes the text was drawn
/// at ([`bake_dynamic_text`]).
/// one undo step, and none when nothing changes. Turning it on also turns the selected point type
/// into area type with Block on ([`point_to_block`]). Turning it off keeps the sizes the text was
/// drawn at ([`bake_dynamic_text`]).
fn dynamic_text(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "type.dynamicText";
let (word_gap, line_gap) = block_gaps(p, C)?;
let (ids, on, planned) = {
let (ids, on, planned, converted) = {
let d = &s.doc()?.doc;
let ids: Vec<NodeId> = texts(s, p, C)?.into_iter().filter(|i| dynamic_type(d.node(*i)).is_some()).collect();
let ids: Vec<NodeId> = texts(s, p, C)?.into_iter().filter(|i| dynamic_target(d.node(*i)).is_some()).collect();
let first = *ids.first().ok_or_else(|| bad(C, "select type on a path or area type"))?;
if let Some(why) = threaded_refusal(d, &ids) {
return Err(bad(C, why));
}
let gap_given = word_gap.is_some() || line_gap.is_some();
if gap_given && !ids.iter().any(|id| area_text(d.node(*id)).is_some()) {
let on = switch_or(p, "on", gap_given || !dynamic_type(d.node(first)).is_some_and(|t| t.dynamic_text), C)?;
// Point type with a line to fit, which turning it on makes area type.
let converts = |id: &NodeId| on && dynamic_target(d.node(*id)).is_some_and(|t| matches!(t.kind, TextKind::Point) && needed_room(t).is_some());
if gap_given && !ids.iter().any(|id| area_text(d.node(*id)).is_some() || converts(id)) {
return Err(bad(C, "wordGap and lineGap need area type in the selection"));
}
let on = switch_or(p, "on", gap_given || !dynamic_type(d.node(first)).is_some_and(|t| t.dynamic_text), C)?;
// Each object as the command leaves it, and only those it changes.
let mut planned: Vec<(NodeId, TextObject)> = vec![];
// The point type that becomes area type, with the gaps applied, by id.
let mut converted: Vec<(NodeId, TextObject)> = vec![];
for id in &ids {
let Some(t) = dynamic_type(d.node(*id)) else { continue };
let Some(t) = dynamic_target(d.node(*id)) else { continue };
let mut after = t.clone();
if matches!(t.kind, TextKind::Area { .. }) {
if matches!(t.kind, TextKind::Area { .. } | TextKind::Point) {
after.area.word_gap = word_gap.unwrap_or(t.area.word_gap);
after.area.line_gap = line_gap.unwrap_or(t.area.line_gap);
}
if matches!(t.kind, TextKind::Point) {
// Point type has no Dynamic Text of its own: on, it becomes area type with Block
// on; off, or with no line to fit, it stays as it is.
if let Some(block) = on.then(|| point_to_block(&after, &[])).flatten() {
planned.push((*id, block));
converted.push((*id, after));
}
continue;
}
match (on, t.dynamic_text) {
(true, true) => refresh_bounds(&mut after),
(true, false) => {
@@ -628,7 +894,7 @@ fn dynamic_text(s: &mut Session, p: &Value) -> Result<Value> {
planned.push((*id, after));
}
}
(ids, on, planned)
(ids, on, planned, converted)
};
if !planned.is_empty() {
s.edit("Dynamic Text", |d, _| {
@@ -637,6 +903,19 @@ fn dynamic_text(s: &mut Session, p: &Value) -> Result<Value> {
**t = after.clone();
}
}
if converted.is_empty() {
return Ok(());
}
// The new area type takes the Text Wrap shapes above it; one that has any is fitted
// again around them, with the depth that holds every line.
for id in vectorcraft_doc::text::resolve_wrap(None, d) {
let Some(NodeKind::Text(t)) = d.node_mut(id).map(|n| &mut n.kind) else { continue };
let block = converted.iter().find(|(c, _)| *c == id).and_then(|(_, src)| point_to_block(src, &t.wrap));
match block {
Some(block) => **t = block,
None => refresh_bounds(t),
}
}
Ok(())
})?;
}
+7
View File
@@ -3,6 +3,9 @@ use super::{NodeId, cancel};
/// The text of [`EngineError::Busy`], which ends every error a frontend reports for it.
pub const SCRIPT_BUSY: &str = "a script is running: stop it or wait for it to finish";
/// Stable prefix for a save refused by the filesystem: choose another destination.
pub const READ_ONLY_LOCATION: &str = "READ_ONLY_LOCATION";
#[derive(Debug, thiserror::Error)]
pub enum EngineError {
#[error("unknown command `{0}`")]
@@ -20,6 +23,10 @@ pub enum EngineError {
NoNode(NodeId),
#[error("{0}")]
Other(String),
/// The save's terminal filesystem error refuses writes here. The reason keeps the path and
/// system message. This never means an automation-root refusal or a recovery-copy failure.
#[error("{code}: {0}", code = READ_ONLY_LOCATION)]
ReadOnlyLocation(String),
/// The caller asked for the command to stop ([`cancel`]). It changed nothing.
#[error("cancelled; nothing was changed")]
Cancelled,
+1 -1
View File
@@ -382,7 +382,7 @@ pub(crate) use command_sets::SELECTS_GIVEN_IDS;
use command_sets::given_ids;
pub use command_sets::{FIT_ACTIVE_ARTBOARD, ON_ACTIVE_ARTBOARD, waits_for_tool_edit};
pub use doc_state::{DocState, OpenRows, RecalledSelection};
pub use error::{EngineError, Result, SCRIPT_BUSY};
pub use error::{EngineError, READ_ONLY_LOCATION, Result, SCRIPT_BUSY};
#[cfg(test)]
use history::history_budget_for;
pub use history::{History, HistoryEntry, NamedStep, default_history_budget};
+22 -8
View File
@@ -2116,6 +2116,27 @@ fn line_to(s: &mut Session, host: &Host, entry: console::Entry, cut: bool) {
host.console.borrow_mut().push(line, cut);
}
/// The error of the failed run `report` describes, as its console lines give it; `name` is the
/// run's name in those lines ([`console::line_name`]).
fn error_text(name: &str, report: &Value) -> String {
let (line, column) = (report["line"].as_u64().unwrap_or(0), report["column"].as_u64().unwrap_or(0));
let message = report["message"].as_str().unwrap_or_default();
match report["file"].as_str() {
Some(file) if line > 0 => format!("{name}: {file}:{line}:{column}: {message}"),
_ if line > 0 => format!("{name}:{line}:{column}: {message}"),
_ => format!("{name}: location unavailable: {message}"),
}
}
/// The console lines of the error of the failed run `report` describes, each as the console keeps
/// it, cut to its limit.
pub(crate) fn error_lines(report: &Value) -> Vec<String> {
let name = console::line_name(report["name"].as_str().unwrap_or_default());
let mut lines = vec![];
each_line(&error_text(&name, report), |line, _| lines.push(line));
lines
}
/// Ends the console lines of `host`'s run: the line `$.write` left unended, then for a failed run
/// (`report["ok"]` false) its error as `name:line:column: message`, then an end line and a report
/// line in the session's console. Adds the run's time, host calls by kind, slowest commands,
@@ -2130,14 +2151,7 @@ fn close_run(s: &mut Session, host: &Host, report: &mut Value, ending: console::
}
}
if report["ok"] == false {
let (line, column) = (report["line"].as_u64().unwrap_or(0), report["column"].as_u64().unwrap_or(0));
let message = report["message"].as_str().unwrap_or_default();
let text = match report["file"].as_str() {
Some(file) if line > 0 => format!("{}: {file}:{line}:{column}: {message}", host.name),
_ if line > 0 => format!("{}:{line}:{column}: {message}", host.name),
_ => format!("{}: location unavailable: {message}", host.name),
};
each_line(&text, |line, cut| line_to(s, host, console::Entry::Error(line), cut));
each_line(&error_text(&host.name, report), |line, cut| line_to(s, host, console::Entry::Error(line), cut));
}
let timing = clock().is_some();
let ms = millis(host.run_nanos.get());
+1
View File
@@ -206,6 +206,7 @@ mod typescale;
mod typeundo;
mod units;
mod variables;
mod warp_images;
mod webexport;
mod widthpoints;
mod widthprofiles;
+142 -1
View File
@@ -104,7 +104,10 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
let list = run(&mut s, "brush.libraries", json!({}));
let libs = list["libraries"].as_array().unwrap();
let ids: Vec<&str> = libs.iter().map(|l| l["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["art-ribbons", "calligraphic-nibs", "bristle-brushes", "pattern-borders", "scatter-shapes", "game-trails", "energy-beams"]);
assert_eq!(
ids,
["art-ribbons", "calligraphic-nibs", "bristle-brushes", "pattern-borders", "scatter-shapes", "game-trails", "energy-beams", "dry-media"]
);
assert!(libs.iter().all(|l| l["category"] == "builtIn"));
let lib = run(&mut s, "brush.library", json!({"library": "art ribbons"}));
assert_eq!(
@@ -124,6 +127,12 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
["Laser Bolt", "Plasma Arc", "Charge Wave", "Spark Trail"]
);
assert_eq!(libs[6]["count"].as_u64(), Some(4));
let dry = run(&mut s, "brush.library", json!({"library": "Dry Media"}));
assert_eq!(
dry["brushes"].as_array().unwrap().iter().map(|b| (b["name"].as_str().unwrap(), b["type"].as_str().unwrap())).collect::<Vec<_>>(),
[("Chalk Grain", "art"), ("Graphite Pencil", "art"), ("Wax Crayon", "art"), ("Charcoal Dust", "art")]
);
assert_eq!((libs[7]["name"].as_str(), libs[7]["count"].as_u64()), (Some("Dry Media"), Some(4)));
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]}));
@@ -137,6 +146,7 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
("scatter-shapes", "scatter"),
("game-trails", "art"),
("energy-beams", "art"),
("dry-media", "art"),
] {
let (_, lib) = cmd::brushlib::library(&s, id).unwrap();
assert!(lib.len() >= 4, "{id}");
@@ -166,6 +176,137 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
assert!(s.execute("brush.library", &json!({"library": "nope"})).is_err());
}
/// Whether `p` lies inside the polygon through `pts` (even-odd ray cast).
fn inside(p: vectorcraft_geom::Point, pts: &[vectorcraft_geom::Point]) -> bool {
let mut odd = false;
for (i, a) in pts.iter().enumerate() {
let b = pts[(i + 1) % pts.len()];
if (a.y > p.y) != (b.y > p.y) && p.x < a.x + (p.y - a.y) * (b.x - a.x) / (b.y - a.y) {
odd = !odd;
}
}
odd
}
/// Every anchor of the paths in `nodes` and their descendants.
fn anchors(nodes: &[&vectorcraft_doc::Node]) -> Vec<vectorcraft_geom::Point> {
let mut out = vec![];
for n in nodes {
n.walk(&mut |c| out.extend(c.path_data().into_iter().flat_map(|p| p.subpaths.iter().flat_map(|sp| sp.anchors.iter().map(|a| a.p)))));
}
out
}
/// Dry Media: four art brushes of grainy dry marks (chalk, pencil, crayon, charcoal) with names
/// of their own. Each one's art is a bounded set of filled vector paths 100 pt long that takes the
/// stroke color as tints, with real even-odd gaps in the chalk and the crayon; it draws finite art
/// on curved and short paths, is the same every time it is made, and goes into a document in one
/// undo step, once, applied, and through a saved library unchanged.
#[test]
fn the_dry_media_library_holds_grainy_art_brushes_with_bounded_art() {
use vectorcraft_brush::{ArtScale, Colorization};
use vectorcraft_geom::FillRule;
let mut s = session();
let (info, lib) = cmd::brushlib::library(&s, "dry-media").unwrap();
assert_eq!((info.name.as_str(), info.category, lib.name.as_str()), ("Dry Media", "builtIn", "Dry Media"));
let names: Vec<String> = lib.brushes.iter().map(|b| b.name.clone()).collect();
assert_eq!(names, ["Chalk Grain", "Graphite Pencil", "Wax Crayon", "Charcoal Dust"]);
let mut total = 0;
for (b, (height, gaps)) in lib.brushes.iter().zip([(8.0, true), (2.5, false), (6.0, true), (7.0, false)]) {
let BrushKind::Art(a) = &b.kind else { panic!("{} is not an art brush", b.name) };
assert_eq!((a.colorization, a.scale, a.width), (Colorization::Tints, ArtScale::Stretch, 100.0), "{}", b.name);
let (mut paths, mut holes) = (0, 0);
a.art.walk(&mut |n| match &n.kind {
NodeKind::Path { path, .. } => {
paths += 1;
assert!(path.subpaths.iter().all(|sp| sp.closed && sp.anchors.len() >= 4), "{}", b.name);
}
NodeKind::Compound { children, rule } => {
assert_eq!(*rule, FillRule::EvenOdd, "{}", b.name);
// The gaps lie inside the band and apart from each other, so each one is a hole.
let body = anchors(&[&*children[0]]);
let boxes: Vec<vectorcraft_geom::Rect> = children[1..].iter().map(|c| c.path_data().unwrap().bounds().unwrap()).collect();
for (i, c) in children[1..].iter().enumerate() {
assert!(anchors(&[&**c]).iter().all(|p| inside(*p, &body)), "{}: gap {i} leaves the band", b.name);
let r = boxes[i];
assert!(boxes[..i].iter().all(|o| r.x0 >= o.x1 || o.x0 >= r.x1 || r.y0 >= o.y1 || o.y0 >= r.y1), "{}: gap {i} overlaps", b.name);
}
holes += children.len() - 1;
}
NodeKind::Group { .. } => {}
other => panic!("{}: unexpected {other:?}", b.name),
});
let pts = anchors(&[&a.art]);
assert!(pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()));
assert!(paths <= 80 && pts.len() <= 500, "{}: {paths} paths, {} anchors", b.name, pts.len());
assert_eq!(holes > 0, gaps, "{}: {holes} gaps", b.name);
let r = vectorcraft_geom::Rect::from_points(pts[0], pts[0]);
let r = pts.iter().fold(r, |r, p| r.union_pt(*p));
assert!(r.x0 >= 0.0 && r.x0 < 0.5 && r.x1 <= 100.0 && r.x1 > 99.5, "{}: {r:?}", b.name);
assert!((r.height() - height).abs() <= height * 0.25 && r.y0 < 0.0 && r.y1 > 0.0, "{}: {r:?}", b.name);
total += pts.len();
// Finite art on a curve and on a 2 pt path.
for (line, width) in [(vec![(0.0, 0.0), (60.0, -40.0), (140.0, 40.0), (200.0, 0.0)], 1.0), (vec![(0.0, 0.0), (2.0, 0.0)], 3.0)] {
let mut bp = vectorcraft_geom::BezPath::new();
bp.move_to(line[0]);
if line.len() == 4 {
bp.curve_to(line[1], line[2], line[3]);
} else {
bp.line_to(line[1]);
}
let stroke = vectorcraft_doc::StrokeLayer::new(vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK), width);
let pieces = vectorcraft_brush::stroke_pieces(&lib.doc, b, &bp, &stroke);
let drawn = anchors(&pieces.iter().collect::<Vec<_>>());
assert!(!drawn.is_empty() && drawn.iter().all(|p| p.x.is_finite() && p.y.is_finite()), "{} on {line:?}", b.name);
}
}
assert!(total <= 1200, "{total} anchors");
// Made again, the same bytes; the checksum pins them across runs and platforms.
let bytes = serde_json::to_string(&cmd::brushlib::dry_media().brushes).unwrap();
assert_eq!(bytes, serde_json::to_string(&lib.brushes).unwrap());
let fnv = bytes.bytes().fold(0xcbf2_9ce4_8422_2325_u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3));
assert_eq!(fnv, 12_859_086_488_513_909_464, "the Dry Media art changed");
// Names of their own: no default brush's, no other built-in library's.
let defaults: Vec<&str> = vectorcraft_brush::defaults().iter().map(|b| b.name.as_str()).collect();
let others: Vec<String> = cmd::brushlib::BUILTIN
.iter()
.filter(|b| b.id != "dry-media")
.flat_map(|b| cmd::brushlib::library(&s, b.id).unwrap().1.brushes.iter().map(|x| x.name.clone()).collect::<Vec<_>>())
.collect();
assert!(names.iter().all(|n| !defaults.contains(&n.as_str()) && !others.contains(n)), "{names:?}");
// Added and applied to a path in one undo step, which undo takes back.
let path = run(&mut s, "shape.line", json!({"x1": 10, "y1": 10, "x2": 150, "y2": 60}))["id"].as_u64().unwrap();
let stroke_brush = |s: &Session| doc(s).node(NodeId(path)).unwrap().appearance.stroke().and_then(|st| st.brush.clone());
let before = (undo_len(&s), brushes(&s));
let r = run(&mut s, "brush.addFromLibrary", json!({"library": "Dry Media", "name": "Wax Crayon", "apply": true, "ids": [path]}));
assert_eq!((strs(&r["added"]), r["applied"].clone()), (vec!["Wax Crayon"], json!([path])));
assert_eq!((undo_len(&s), stroke_brush(&s).as_deref()), (before.0 + 1, Some("Wax Crayon")));
assert_eq!(&brush(&s, "Wax Crayon"), lib.brush("Wax Crayon").unwrap());
run(&mut s, "edit.undo", json!({}));
assert_eq!((brushes(&s), stroke_brush(&s)), (before.1.clone(), None));
run(&mut s, "edit.redo", json!({}));
// The rest in one more step; then nothing new to add.
let r = run(&mut s, "brush.addFromLibrary", json!({"library": "dry-media"}));
assert_eq!((strs(&r["added"]), strs(&r["existing"])), (vec!["Chalk Grain", "Graphite Pencil", "Charcoal Dust"], vec!["Wax Crayon"]));
assert_eq!(undo_len(&s), before.0 + 2);
assert_eq!(
brushes(&s),
[before.1.clone(), vec!["Wax Crayon".into(), "Chalk Grain".into(), "Graphite Pencil".into(), "Charcoal Dust".into()]].concat()
);
let r = run(&mut s, "brush.addFromLibrary", json!({"library": "dry-media"}));
assert_eq!((strs(&r["added"]).len(), undo_len(&s)), (0, before.0 + 2));
// Saved as a library and loaded back: the same brushes, in the document's order.
let saved = run(&mut s, "brush.saveLibrary", json!({ "names": names, "name": "Dry" }));
let b64 = saved["dataBase64"].as_str().unwrap().to_string();
let r = run(&mut s, "brush.loadLibrary", json!({"dataBase64": b64, "name": "Dry.vectorcraft"}));
let (_, reopened) = cmd::brushlib::library(&s, r["library"].as_str().unwrap()).unwrap();
assert_eq!(reopened.len(), lib.len());
for b in &lib.brushes {
assert_eq!(reopened.brush(&b.name), Some(b), "{}", b.name);
}
}
/// Bristle Brushes: one brush per tip shape, every value inside the range the brush keeps (a value
/// outside would be clamped without notice), names no other library or default brush uses; added
/// in one step, not twice, and saved as a library they reopen unchanged.
+4 -6
View File
@@ -88,19 +88,17 @@ fn dynamic_text_refuses_bad_params_and_other_type() {
assert!(err(s.execute("type.dynamicText", &json!({"on": 1}))).contains("on"));
assert_eq!(undo_len(&s), before);
assert!(!text(&s, id).dynamic_text);
// Point type alone: refused (area type takes Block, `typecmd::block_tests`).
let point = s.execute("text.create", &json!({"x": 10, "y": 10, "text": "Point"})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [point]})).unwrap();
assert!(err(s.execute("type.dynamicText", &json!({}))).contains("select type on a path or area type"));
let empty = s.execute("shape.rectangle", &json!({"x": 300, "y": 10, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [empty]})).unwrap();
assert!(s.execute("type.dynamicText", &json!({})).is_err());
// With point type selected too, only the type on a path changes.
// With point type selected too, both change in one undo step: the point type becomes area
// type with Block on (`typecmd::block_tests`).
let before = undo_len(&s);
s.execute("select.set", &json!({"ids": [point, id.0]})).unwrap();
let r = s.execute("type.dynamicText", &json!({"on": true})).unwrap();
assert_eq!(r["ids"], json!([id.0]));
assert!(!text(&s, NodeId(point)).dynamic_text);
assert_eq!(r["ids"], json!([point, id.0]));
assert!(text(&s, NodeId(point)).dynamic_text && text(&s, id).dynamic_text);
assert_eq!(undo_len(&s), before + 1);
}
+34
View File
@@ -147,3 +147,37 @@ fn show_all_hidden_attributes() {
s.execute("edit.undo", &json!({})).unwrap();
assert!(node(&s, id).appearance.has_hidden());
}
/// A Warp applied now takes its style's Bézier net (`version` 1) unless a map is given, an edit
/// keeps the map the effect has (one saved before the version existed keeps the earlier map), and
/// a map this build doesn't draw is refused.
#[test]
fn warps_keep_the_map_their_version_names() {
let (mut s, id) = session_with_rect();
let version = |s: &Session| node(s, id).appearance.effects[0].params.get("version").cloned();
run(&mut s, "effect.apply", json!({"effect": "warp.flag", "params": {"bend": 40}}));
assert_eq!(version(&s), Some(json!(vectorcraft_doc::live::WARP_NET)));
run(&mut s, "effect.setParams", json!({"index": 0, "params": {"bend": 20}, "warpStyle": "arc"}));
assert_eq!(version(&s), Some(json!(vectorcraft_doc::live::WARP_NET)));
// As a file saved before the version existed gives it.
let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
if let Some(Value::Object(p)) = doc.node_mut(id).and_then(|n| n.appearance.effects.first_mut()).map(|e| &mut e.params) {
p.remove("version");
}
run(&mut s, "effect.setParams", json!({"index": 0, "params": {"bend": 10, "horizontal": 20}}));
assert_eq!(version(&s), None);
run(&mut s, "effect.setParams", json!({"index": 0, "params": {"version": 1}}));
assert_eq!(version(&s), Some(json!(1)));
run(&mut s, "effect.apply", json!({"effect": "warp.arc", "params": {"version": 0}}));
assert_eq!(node(&s, id).appearance.effects[1].params["version"], json!(0));
// A whole number given as a float is that version.
run(&mut s, "effect.setParams", json!({"index": 1, "params": {"version": 1.0}}));
assert_eq!(node(&s, id).appearance.effects[1].params["version"], json!(1));
run(&mut s, "effect.setParams", json!({"index": 1, "params": {"version": 0.0}}));
assert_eq!(node(&s, id).appearance.effects[1].params["version"], json!(0));
for bad in [json!(2), json!(-1), json!(0.5), json!("1")] {
assert!(s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"version": bad}})).is_err(), "{bad}");
assert!(s.execute("effect.setParams", &json!({"index": 0, "params": {"version": bad}})).is_err(), "{bad}");
}
assert_eq!(node(&s, id).appearance.effects.len(), 2);
}
+47 -2
View File
@@ -123,6 +123,51 @@ fn reset_with_warp_and_mesh_switch_the_kind_and_keep_the_content() {
assert!(s.execute("object.envelope.resetWithMesh", &json!({})).is_err());
}
/// A new warp envelope bends with its style's Bézier net (`version` [`live::WARP_NET`]) and keeps
/// it through Reset with Warp. One saved before the version existed keeps the earlier map when its
/// warp or its options change.
#[test]
fn new_warp_envelopes_take_the_net_and_saved_ones_keep_their_map() {
// The surface point a quarter of the way along the top edge.
let quarter = |s: &Session, e| live::EnvelopeMap::of(&node(s, e)).unwrap().surface_mesh(4, 4, vectorcraft_color::Color::BLACK).points[1].p;
let at = |x, y| vectorcraft_geom::Point::new(x, y);
let mut s = session();
let (_, e) = enveloped(&mut s, "object.envelope.makeWithWarp", json!({"style": "flag", "bend": 40}));
assert!(matches!(kind(&s, e), EnvelopeKind::Warp { version: live::WARP_NET, .. }), "{:?}", kind(&s, e));
assert_eq!(s.execute("object.envelope.info", &json!({})).unwrap()["version"], json!(live::WARP_NET));
// Flag moves the top edge 6 × bend × height × u(1 - u)(1 - 2u) down at u: 22.5 at u = 1/4.
assert!(quarter(&s, e).distance(at(150.0, 122.5)) < 1e-9, "{:?}", quarter(&s, e));
s.execute("object.envelope.resetWithWarp", &json!({"bend": -40})).unwrap();
assert!(matches!(kind(&s, e), EnvelopeKind::Warp { version: live::WARP_NET, .. }), "{:?}", kind(&s, e));
assert!(quarter(&s, e).distance(at(150.0, 77.5)) < 1e-9, "{:?}", quarter(&s, e));
// As a file saved before the version existed gives it.
let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
if let Some(NodeKind::Envelope { kind, .. }) = doc.node_mut(e).map(|n| &mut n.kind)
&& let EnvelopeKind::Warp { version, .. } = &mut **kind
{
*version = 0;
}
s.execute("object.envelope.options", &json!({"fidelity": 75})).unwrap();
s.execute("object.envelope.resetWithWarp", &json!({"bend": 40})).unwrap();
assert!(matches!(kind(&s, e), EnvelopeKind::Warp { version: 0, .. }), "{:?}", kind(&s, e));
// The earlier map's flag: half the bend times sin(π x), x = -1/2 here, in half heights.
assert!(quarter(&s, e).distance(at(150.0, 90.0)) < 1e-9, "{:?}", quarter(&s, e));
// `version` moves a warp to a map, and a new warp can take the earlier one.
s.execute("object.envelope.options", &json!({"version": 1.0})).unwrap();
assert!(matches!(kind(&s, e), EnvelopeKind::Warp { version: live::WARP_NET, .. }), "{:?}", kind(&s, e));
assert!(quarter(&s, e).distance(at(150.0, 122.5)) < 1e-9, "{:?}", quarter(&s, e));
s.execute("object.envelope.resetWithWarp", &json!({"version": 0})).unwrap();
assert!(matches!(kind(&s, e), EnvelopeKind::Warp { version: 0, .. }), "{:?}", kind(&s, e));
let (_, old) = enveloped(&mut s, "object.envelope.makeWithWarp", json!({"style": "flag", "bend": 40, "version": 0}));
assert!(matches!(kind(&s, old), EnvelopeKind::Warp { version: 0, .. }), "{:?}", kind(&s, old));
for bad in [json!(2), json!(-1), json!(0.5), json!("1"), json!(null)] {
for cmd in ["object.envelope.makeWithWarp", "object.envelope.resetWithWarp", "object.envelope.options"] {
let r = s.execute(cmd, &json!({"version": bad}));
assert!(r.as_ref().is_err_and(|e| e.to_string().contains("`version` must be 0 or 1")), "{cmd} {bad}: {r:?}");
}
}
}
#[test]
fn release_gives_back_the_warp_shape_as_a_mesh_and_keeps_the_transparency() {
let mut s = session();
@@ -141,9 +186,9 @@ fn release_gives_back_the_warp_shape_as_a_mesh_and_keeps_the_transparency() {
let content = node(&s, a);
assert_eq!((content.opacity, content.blend, content.extras().mask.is_some()), (0.4, BlendMode::Multiply, true), "the content keeps the look");
let NodeKind::Mesh(m) = node(&s, ids[1]).kind else { panic!("the warp's shape comes back as a mesh") };
// The mesh follows the arc: its outline reaches below the content's bottom edge at the sides.
// The mesh follows the arc: its top corners swing out past the content's sides and up.
let b = m.outline().bounds().unwrap();
assert!(b.y1 > 201.0, "{b:?}");
assert!(b.x0 < 99.0 && b.x1 > 301.0 && b.y0 < 99.0, "{b:?}");
assert_eq!(s.doc().unwrap().selection.objects, ids);
}
+33 -3
View File
@@ -154,6 +154,35 @@ fn images_bend_as_a_raster_mesh_warp() {
assert_eq!(svg.matches("<image").count(), 1, "the pieces share the image's pixels");
}
#[test]
fn a_colorized_image_keeps_its_color_in_an_envelope() {
let mut s = session();
let img = image::GrayImage::from_pixel(4, 4, image::Luma([0]));
let mut png = vec![];
image::DynamicImage::ImageLuma8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
let im = s
.edit("Place", |d, sel| {
d.images.insert("gray".into(), vectorcraft_doc::ImageBlob::png(png));
let id = d.alloc_id();
let xf = Affine::translate((100.0, 100.0)) * Affine::scale(10.0);
let im =
vectorcraft_doc::ImageObject { key: "gray".into(), width: 4, height: 4, xf, link: None, placement: Default::default(), pixels: None };
d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
sel.set([id]);
Ok(id)
})
.unwrap();
s.execute("paint.setFill", &json!({"color": "#ff0000", "ids": [im.0]})).unwrap();
sel(&mut s, &[im]);
arch(&mut s, 80.0, json!({}));
let img = vectorcraft_render::Renderer::new().render_region(&s.doc().unwrap().doc, Rect::new(0.0, 0.0, 200.0, 200.0), 1.0, true);
// The black pixels draw in the fill color, in the bent shape.
let mid = img.pixel(120, 97);
assert!(mid[0] > 200 && mid[1] < 60 && mid[2] < 60, "the middle rose, red: {mid:?}");
let inside = img.pixel(120, 120);
assert!(inside[0] > 200 && inside[1] < 60 && inside[2] < 60, "red inside: {inside:?}");
}
/// A selected embedded 2×2 image, 80×80 pt at (100, 100): a red column left of a blue one.
fn two_color_image(s: &mut Session) -> NodeId {
let img = image::RgbaImage::from_fn(2, 2, |x, _| if x == 0 { image::Rgba([255, 0, 0, 255]) } else { image::Rgba([0, 0, 255, 255]) });
@@ -286,17 +315,18 @@ fn symbols_bend_with_the_envelope() {
let e = arch(&mut s, 60.0, json!({}));
let pts = anchors(&evaluated(&s, e));
assert!(pts.iter().any(|p| p.y < 90.0), "the symbol's art rose in the middle");
// Editing the symbol redraws the envelope (the renderer's cache follows the symbol's art).
// Editing the symbol redraws the envelope (the renderer's cache follows the symbol's art). The
// arch lifts the middle of the 100..200 box by about 51, so (200, 120) is inside it.
let mut r = vectorcraft_render::Renderer::new();
let region = Rect::new(0.0, 0.0, 400.0, 300.0);
assert!(r.render_region(&s.doc().unwrap().doc, region, 1.0, true).pixel(200, 150)[1] < 60);
assert!(r.render_region(&s.doc().unwrap().doc, region, 1.0, true).pixel(200, 120)[1] < 60);
s.edit("edit symbol", |d, _| {
let art = Node::path(NodeId(0), shapes::rectangle(Rect::new(-10.0, -10.0, -8.0, -8.0)), Default::default());
d.symbols[0].art = Arc::new(art);
Ok(())
})
.unwrap();
assert!(r.render_region(&s.doc().unwrap().doc, region, 1.0, true).pixel(200, 150)[1] > 200);
assert!(r.render_region(&s.doc().unwrap().doc, region, 1.0, true).pixel(200, 120)[1] > 200);
}
fn strokes(nodes: &[Node]) -> usize {
+37
View File
@@ -194,6 +194,43 @@ fn a_search_finds_a_missing_fonts_file_by_its_names() {
assert!(matches!(r["state"].as_str(), Some("stopped" | "done")), "{r}");
}
/// A caller confined by read roots sees, in the replies to a search another caller started, only
/// the files found inside its read roots, and the folder searched and a failed search's path only
/// when they are inside them.
#[test]
fn a_search_shows_a_confined_caller_only_paths_inside_its_read_roots() {
let root = folder("read-roots");
let font = vectorcraft_testkit::fonts::renamed("Findme Sans 3");
let (home, wide) = (root.join("home"), root.join("lrf-wide"));
for dir in [&home, &wide] {
std::fs::create_dir_all(dir).unwrap();
std::fs::write(dir.join("Findme.otf"), &font).unwrap();
}
let mut s = session_for(&root);
let roots = |read: &[&Path]| crate::file_access::AutomationRoots::new(read, &[]).unwrap().unwrap();
let (narrow, broad) = (roots(&[&home]), roots(&[&root]));
let ask = |s: &mut Session, r: &Arc<crate::file_access::AutomationRoots>, p: Value| {
crate::file_access::confine(Some(r), || s.execute("text.findFontFiles", &p).unwrap())
};
// A font no file has keeps the search going through every folder.
let fonts = json!([{"family": "Findme Sans 3"}, {"family": "No Such Sans"}]);
ask(&mut s, &broad, json!({"folder": root, "fonts": fonts}));
finished(&mut s);
let all = ask(&mut s, &broad, json!({}));
assert_eq!((&all["fonts"][0]["files"], &all["folder"]), (&json!([home.join("Findme.otf"), wide.join("Findme.otf")]), &json!(root)), "{all}");
for r in [ask(&mut s, &narrow, json!({})), ask(&mut s, &narrow, json!({"stop": true}))] {
assert!(!r.to_string().contains("lrf-wide") && r.get("folder").is_none(), "{r}");
assert_eq!((&r["fonts"][0]["files"], &r["fonts"][0]["family"]), (&json!([home.join("Findme.otf")]), &json!("Findme Sans 3")), "{r}");
assert_eq!((&r["state"], &r["searched"], &r["id"]), (&all["state"], &all["searched"], &all["id"]), "{r}");
}
// A search that failed: the reason shows without the path to a caller outside its folder.
ask(&mut s, &broad, json!({"folder": wide.join("gone"), "fonts": fonts}));
assert!(finished(&mut s)["error"].as_str().is_some_and(|e| e.contains("lrf-wide")));
let r = ask(&mut s, &narrow, json!({}));
assert_eq!((r["state"].as_str(), r["error"].as_str(), r.get("folder")), (Some("failed"), Some("the folder can't be read"), None), "{r}");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn junk_search_params_never_fail_internally() {
let root = folder("junk");
+111 -1
View File
@@ -271,7 +271,7 @@ fn stop_ends_only_the_search_it_names() {
let (tx, rx) = mpsc::channel();
let search = findfiles::start(root.clone(), s.search_rules.clone(), Limits::default(), 1, 2, Arc::new(Blocked(Mutex::new(rx)))).unwrap();
let links = vec![Sought { name: "a.png".into(), path: "/gone/a.png".into(), ids: vec![], size: None, hash: None }];
s.link_search = Some(LinkSearch { id: 7, folder: root.to_string_lossy().into_owned(), links, sizes: Arc::default(), search });
s.link_search = Some(LinkSearch { id: 7, folder: root.to_string_lossy().into_owned(), doc: None, links, sizes: Arc::default(), search });
let until = Instant::now() + WAIT;
while s.execute("links.findFiles", &json!({})).unwrap()["searched"]["read"] != 1 && Instant::now() < until {
std::thread::sleep(Duration::from_millis(2));
@@ -284,6 +284,116 @@ fn stop_ends_only_the_search_it_names() {
drop(tx);
}
/// A caller confined by read roots sees, in the replies to a search another caller started and to
/// its own, only the paths inside its read roots: the files found outside them, a link's saved path
/// outside them and the folder searched are left out, and the rows, ids and counts stay. Without
/// roots, the replies are as before.
#[test]
fn a_search_shows_a_confined_caller_only_paths_inside_its_read_roots() {
let root = folder("read-roots");
let mut s = session_for(&root);
let photo = png(40, 30, RED);
write(&root.join("lrf-away/photo.png"), &photo);
let id = placed(&mut s, &root.join("lrf-away/photo.png"));
std::fs::remove_file(root.join("lrf-away/photo.png")).unwrap();
// Files of the name with other contents: the search reads every folder.
let other = png(40, 30, BLUE);
let (home, wide) = (root.join("home"), root.join("lrf-wide"));
write(&home.join("photo.png"), &other);
write(&wide.join("photo.png"), &other);
let roots = |read: &[&Path], write: &[&Path]| crate::file_access::AutomationRoots::new(read, write).unwrap().unwrap();
let (narrow, write_only, broad) = (roots(&[&home], &[]), roots(&[], &[&root]), roots(&[&root], &[]));
let ask = |s: &mut Session, r: &Arc<crate::file_access::AutomationRoots>, p: Value| {
crate::file_access::confine(Some(r), || s.execute("links.findFiles", &p).unwrap())
};
let hidden = |r: &Value| {
let text = r.to_string();
assert!(!text.contains("lrf-away") && !text.contains("lrf-wide") && r.get("folder").is_none(), "{r}");
let row = &r["links"][0];
assert_eq!((row["name"].as_str(), &row["ids"], row.get("path")), (Some("photo.png"), &json!([id]), None), "{r}");
};
// Started with the broad roots, over the whole folder.
let r = ask(&mut s, &broad, json!({"folder": root}));
assert_eq!(r["folder"], json!(root), "{r}");
finished(&mut s);
let all = ask(&mut s, &broad, json!({}));
assert_eq!(all["links"][0]["files"].as_array().map(Vec::len), Some(2), "{all}");
for r in [ask(&mut s, &narrow, json!({})), ask(&mut s, &narrow, json!({"stop": true}))] {
hidden(&r);
assert_eq!(r["links"][0]["files"], json!([{"path": home.join("photo.png"), "size": other.len(), "match": "name"}]), "{r}");
assert_eq!((&r["state"], &r["searched"], &r["id"]), (&all["state"], &all["searched"], &all["id"]), "{r}");
}
let r = ask(&mut s, &write_only, json!({}));
hidden(&r);
assert_eq!(r["links"][0]["files"], json!([]), "{r}");
// Without roots, every path shows.
let r = s.execute("links.findFiles", &json!({})).unwrap();
assert_eq!((&r["folder"], &r["links"][0]["path"]), (&json!(root), &json!(root.join("lrf-away/photo.png"))), "{r}");
assert_eq!(r["links"][0]["files"].as_array().map(Vec::len), Some(2), "{r}");
// The narrow caller's own search shows the folder it gave.
let r = ask(&mut s, &narrow, json!({"folder": home}));
assert_eq!(r["folder"], json!(home), "{r}");
finished(&mut s);
let r = ask(&mut s, &narrow, json!({}));
assert_eq!((&r["folder"], r["links"][0].get("path")), (&json!(home), None), "{r}");
// A search that failed: the reason shows without the path to a caller outside its folder.
ask(&mut s, &broad, json!({"folder": root.join("lrf-wide/gone")}));
let r = finished(&mut s);
assert!(r["error"].as_str().is_some_and(|e| e.contains("lrf-wide")), "{r}");
let r = ask(&mut s, &narrow, json!({}));
assert_eq!((r["state"].as_str(), r["error"].as_str()), (Some("failed"), Some("the folder can't be read")), "{r}");
hidden(&r);
let _ = std::fs::remove_dir_all(&root);
}
/// A link's saved path relative to the document is shown to a confined caller when it leads to a
/// file inside its read roots, and left out when `..` leads out of them.
#[test]
fn a_relative_link_path_is_judged_from_the_documents_folder() {
let root = folder("read-roots-relative");
let mut s = session_for(&root);
let home = root.join("home");
write(&root.join("lrf-away/photo.png"), &png(40, 30, RED));
let id = placed(&mut s, &root.join("lrf-away/photo.png"));
std::fs::create_dir_all(&home).unwrap();
s.execute("document.save", &json!({"path": home.join("poster.vectorcraft")})).unwrap();
let narrow = crate::file_access::AutomationRoots::new(&[&home], &[]).unwrap().unwrap();
for (saved, shown) in [("sub/photo.png", true), ("../lrf-away/photo.png", false)] {
s.edit("relative path", |d, _| {
if let NodeKind::Image(im) = &mut d.node_mut(NodeId(id)).unwrap().kind {
im.link.as_mut().unwrap().path = saved.into();
}
Ok(())
})
.unwrap();
let r = crate::file_access::confine(Some(&narrow), || s.execute("links.findFiles", &json!({"folder": home, "ids": [id]})).unwrap());
assert_eq!(r["links"][0].get("path"), shown.then(|| json!(saved)).as_ref(), "{saved}: {r}");
finished(&mut s);
}
let _ = std::fs::remove_dir_all(&root);
}
/// `image.info` leaves a linked file outside the confined caller's read roots unnamed (`link`
/// null), as `links.info` leaves it out, and keeps the other fields.
#[test]
fn image_info_leaves_out_a_link_outside_the_read_roots() {
let root = folder("read-roots-info");
let mut s = session_for(&root);
let pic = root.join("lrf-away/photo.png");
write(&pic, &png(40, 30, RED));
let id = placed(&mut s, &pic);
std::fs::create_dir_all(root.join("home")).unwrap();
let narrow = crate::file_access::AutomationRoots::new(&[&root.join("home")], &[]).unwrap().unwrap();
let ask = |s: &mut Session, cmd: &str| crate::file_access::confine(Some(&narrow), || s.execute(cmd, &json!({"id": id})).unwrap());
let r = ask(&mut s, "image.info");
assert_eq!((&r["link"], &r["linked"], &r["pixelWidth"], &r["id"]), (&Value::Null, &json!(true), &json!(40), &json!(id)), "{r}");
assert!(!r.to_string().contains("lrf-away"), "{r}");
let info = ask(&mut s, "links.info");
assert!(info.get("link").is_none() && !info.to_string().contains("lrf-away"), "{info}");
assert_eq!(s.execute("image.info", &json!({"id": id})).unwrap()["link"], json!(pic));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn relinking_with_copy_puts_the_file_in_the_documents_folder() {
let root = folder("copy");
+2 -2
View File
@@ -570,8 +570,8 @@ fn envelope_warp_make_and_content_stays_inside_bounds() {
let pts = all_anchors(&out);
assert!(pts.len() > 4, "curves are subdivided");
assert!(pts.iter().all(|p| b.contains(*p)), "{b:?}");
// It really is bent: the sides moved down.
assert!(pts.iter().any(|p| p.y > 201.0));
// It really is bent: the top corners swung out past the sides.
assert!(pts.iter().any(|p| p.x < 99.0) && pts.iter().any(|p| p.x > 301.0));
}
#[test]
+133
View File
@@ -531,6 +531,139 @@ fn a_space_that_is_not_usable_is_refused_and_one_too_large_is_kept_to_the_path()
assert_eq!(space(&s, g), (Some(100.0), 0.0));
}
/// The ids of group `g`'s objects in their order along the path, and of its children in the
/// Layers panel's order.
fn orders(s: &Session, g: NodeId) -> (Vec<NodeId>, Vec<NodeId>) {
let n = s.doc().unwrap().doc.node(g).unwrap();
let path = n.extras().objects_on_path.as_deref().unwrap().members.iter().map(|m| m.id).collect();
(path, n.children().unwrap().iter().map(|c| c.id).collect())
}
/// Three objects of different widths (20, 40 and 10 pt) attached to a 300 pt line from (50, 300),
/// in that order, with a Space of 100 pt from 0, Pivot 4 and Rotate 0.
fn three_on_a_line(s: &mut Session) -> (NodeId, [NodeId; 3], NodeId) {
let a = rect(s, 0.0, 0.0, 20.0, 20.0);
let b = rect(s, 100.0, 0.0, 40.0, 20.0);
let c = rect(s, 200.0, 0.0, 10.0, 20.0);
let path = line(s, (50.0, 300.0), (350.0, 300.0));
let g = attach(s, path, &[a, b, c], json!({}));
s.execute("object.objectsOnPath.options", &json!({"spacing": 100})).unwrap();
(g, [a, b, c], path)
}
#[test]
fn move_member_takes_the_target_s_place_and_shifts_the_objects_between() {
let mut s = session();
let (g, [a, b, c], path) = three_on_a_line(&mut s);
let (_, layers) = orders(&s, g);
let before = s.doc().unwrap().doc.node(g).unwrap().extras().objects_on_path.as_deref().cloned().unwrap();
let steps = s.doc().unwrap().history.undo.len();
let v = s.execute("object.objectsOnPath.moveMember", &json!({"member": a.0, "target": c.0})).unwrap();
assert_eq!(v, json!({"group": g.0, "member": a.0, "index": 2}));
assert_eq!(orders(&s, g), (vec![b, c, a], layers.clone()), "the order along the path changes, the Layers order does not");
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "one undo step");
assert_eq!(center(&s, b), Point::new(50.0, 300.0));
assert_eq!(center(&s, c), Point::new(150.0, 300.0));
assert_eq!(center(&s, a), Point::new(250.0, 300.0));
let after = s.doc().unwrap().doc.node(g).unwrap().extras().objects_on_path.as_deref().cloned().unwrap();
assert_eq!(
(after.path, after.pivot, after.rotate, after.spacing, after.start),
(path, before.pivot, before.rotate, before.spacing, before.start)
);
let w = bounds(&s, a);
assert!((w.width() - 20.0).abs() < 1e-9, "the object keeps its art: {w:?}");
// The last one back to the first place, with its group named.
let v = s.execute("object.objectsOnPath.moveMember", &json!({"group": g.0, "member": a.0, "target": b.0})).unwrap();
assert_eq!(v["index"], 0);
assert_eq!(orders(&s, g).0, [a, b, c]);
assert_eq!(center(&s, a), Point::new(50.0, 300.0));
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(orders(&s, g).0, [b, c, a]);
assert_eq!(center(&s, a), Point::new(250.0, 300.0));
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(orders(&s, g).0, [a, b, c]);
assert_eq!(center(&s, c), Point::new(250.0, 300.0));
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(orders(&s, g).0, [b, c, a]);
// Onto its own place: nothing changes and no step is recorded.
let steps = s.doc().unwrap().history.undo.len();
let v = s.execute("object.objectsOnPath.moveMember", &json!({"member": c.0, "target": c.0})).unwrap();
assert_eq!(v["index"], 1);
assert_eq!(s.doc().unwrap().history.undo.len(), steps);
// The order saves and reopens.
let data = s.execute("document.export", &json!({"format": "vectorcraft"})).unwrap()["dataBase64"].clone();
let mut o = Session::new();
o.execute("document.open", &json!({"name": "objects.vectorcraft", "dataBase64": data})).unwrap();
assert_eq!(orders(&o, g), (vec![b, c, a], layers));
assert_eq!(center(&o, a), Point::new(250.0, 300.0));
}
#[test]
fn move_member_refuses_what_is_not_an_object_on_the_same_path() {
let mut s = session();
let (g, [a, b, c], path) = three_on_a_line(&mut s);
let loose = rect(&mut s, 300.0, 20.0, 10.0, 10.0);
let x = rect(&mut s, 0.0, 200.0, 10.0, 10.0);
let other_line = line(&mut s, (50.0, 380.0), (350.0, 380.0));
let h = attach(&mut s, other_line, &[x], json!({}));
let err = |s: &mut Session, p: Value| s.execute("object.objectsOnPath.moveMember", &p).unwrap_err().to_string();
assert!(err(&mut s, json!({"member": path.0, "target": a.0})).contains("`member` must name an object attached"), "the path");
assert!(err(&mut s, json!({"member": a.0, "target": path.0})).contains("`target` must name"), "the path as the target");
assert!(err(&mut s, json!({"member": loose.0, "target": a.0})).contains("`member` must name"), "an object on no path");
assert!(err(&mut s, json!({"member": g.0, "target": a.0})).contains("`member` must name"), "the group itself");
assert!(err(&mut s, json!({"member": a.0, "target": x.0})).contains("same Objects on Path group"), "another group's object");
assert!(err(&mut s, json!({"member": a.0, "target": b.0, "group": h.0})).contains("`group` must be"), "another group named");
assert!(err(&mut s, json!({"target": b.0})).contains("missing `member`"));
assert!(err(&mut s, json!({"member": a.0})).contains("missing `target`"));
assert!(err(&mut s, json!({"member": 99999, "target": b.0})).contains("no such object"));
assert!(err(&mut s, json!({"member": "a", "target": b.0})).contains("invalid object id"));
// A locked object neither moves nor gives its place, and is not chosen.
select(&mut s, &[c]);
s.execute("object.lock", &json!({})).unwrap();
assert!(err(&mut s, json!({"member": c.0, "target": a.0})).contains("`member` names an object that is hidden or locked"));
assert!(err(&mut s, json!({"member": a.0, "target": c.0})).contains("`target` names an object that is hidden or locked"));
assert!(s.execute("object.objectsOnPath.selectMember", &json!({"member": c.0})).is_err());
s.execute("object.unlockAll", &json!({})).unwrap();
// A locked object between the two keeps its place, and the others pass over it.
select(&mut s, &[b]);
s.execute("object.lock", &json!({})).unwrap();
let v = s.execute("object.objectsOnPath.moveMember", &json!({"member": a.0, "target": c.0})).unwrap();
assert_eq!(v["index"], 2);
assert_eq!(orders(&s, g).0, [c, b, a]);
assert_eq!(center(&s, b), Point::new(150.0, 300.0), "the locked object stays where it was");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("object.unlockAll", &json!({})).unwrap();
select(&mut s, &[g]);
s.execute("object.lock", &json!({})).unwrap();
assert!(s.doc().unwrap().doc.node(g).unwrap().locked);
let e = err(&mut s, json!({"member": a.0, "target": b.0}));
assert!(e.contains("hidden or locked"), "a locked group: {e}");
assert!(s.execute("object.objectsOnPath.selectMember", &json!({"member": a.0})).is_err(), "a locked group's object is not chosen");
assert_eq!(orders(&s, g).0, [a, b, c], "nothing refused changed the order");
}
#[test]
fn select_member_selects_the_group_with_the_object_chosen() {
let mut s = session();
let (g, [a, b, _], path) = three_on_a_line(&mut s);
let v = s.execute("object.objectsOnPath.selectMember", &json!({"member": b.0})).unwrap();
assert_eq!(v, json!({"group": g.0, "member": b.0}));
let sel = &s.doc().unwrap().selection;
assert_eq!((sel.objects.as_slice(), sel.on_path_member), (&[g][..], Some(b)));
// Moving the chosen object keeps it chosen.
s.execute("object.objectsOnPath.moveMember", &json!({"member": b.0, "target": a.0})).unwrap();
assert_eq!(s.doc().unwrap().selection.on_path_member, Some(b));
assert!(s.execute("object.objectsOnPath.selectMember", &json!({"member": path.0})).is_err());
select(&mut s, &[g]);
assert_eq!(s.doc().unwrap().selection.on_path_member, None, "another selection clears it");
// Both take their objects without a selection.
select(&mut s, &[]);
s.execute("object.objectsOnPath.moveMember", &json!({"member": a.0, "target": b.0})).unwrap();
assert_eq!(orders(&s, g).0[..2], [a, b]);
s.execute("object.objectsOnPath.selectMember", &json!({"member": a.0})).unwrap();
assert_eq!(s.doc().unwrap().selection.on_path_member, Some(a));
}
#[test]
fn the_space_saves_and_reopens_and_goes_with_a_copy() {
let mut s = session();
+178
View File
@@ -184,6 +184,184 @@ fn a_flip_round_a_closed_path_keeps_the_type_in_place() {
assert!(origins(&s, id)[0].distance(first) < 8.0);
}
/// A circle of radius 100 round (200, 200), starting at 9 o'clock and running clockwise, with
/// type on it from its start.
fn on_circle(s: &mut Session, text: &str) -> NodeId {
path_type(s, "M100 200 A100 100 0 1 1 300 200 A100 100 0 1 1 100 200 Z", [90.0, 200.0], text)
}
#[test]
fn center_on_top_and_bottom_of_a_circle() {
let mut s = session();
let id = on_circle(&mut s, "OOOO");
assert!(near(brackets(&s, id).0, 0.0), "{:?}", brackets(&s, id));
let steps = undo_len(&s);
let r = s.execute("type.pathCenter.top", &json!({})).unwrap();
// Once round, its middle at 12 o'clock, a quarter of the way round: the type sits on the top, centered.
let (start, end) = brackets(&s, id);
assert!(near(start, 0.75) && end.is_none(), "{start} {end:?}");
assert_eq!((r["ids"].clone(), r["end"].clone()), (json!([id.0]), Value::Null));
assert_eq!(text(&s, id).para_at(0).justify, vectorcraft_doc::Justify::Center);
let top = ink(&s, id);
assert!((top.center().x - 200.0).abs() < 0.5 && top.y1 < 101.0, "{top:?}");
assert_eq!((undo_len(&s), last_step(&s)), (steps + 1, "Center on Top".to_string()));
// Again: nothing moves, and no undo step is recorded.
s.execute("type.pathCenter.top", &json!({})).unwrap();
assert_eq!(undo_len(&s), steps + 1);
// The bottom: 6 o'clock, outside the circle (the type is not flipped).
s.execute("type.pathCenter.bottom", &json!({})).unwrap();
let (start, end) = brackets(&s, id);
assert!(near(start, 0.25) && end.is_none(), "{start} {end:?}");
let bottom = ink(&s, id);
assert!((bottom.center().x - 200.0).abs() < 0.5 && bottom.y0 > 299.0, "{bottom:?}");
assert_eq!((undo_len(&s), last_step(&s)), (steps + 2, "Center on Bottom".to_string()));
// Justify Center stays as it is.
s.execute("text.setStyle", &json!({"justify": "justifyCenter"})).unwrap();
s.execute("type.pathCenter.top", &json!({})).unwrap();
assert_eq!(text(&s, id).para_at(0).justify, vectorcraft_doc::Justify::JustifyCenter);
s.execute("edit.undo", &json!({})).unwrap();
assert!(near(brackets(&s, id).0, 0.25));
// Brackets already in place with another alignment: only the alignment changes, in one step.
s.execute("text.setStyle", &json!({"justify": "left"})).unwrap();
let (steps, before) = (undo_len(&s), brackets(&s, id));
s.execute("type.pathCenter.bottom", &json!({})).unwrap();
assert_eq!((undo_len(&s), brackets(&s, id)), (steps + 1, before));
assert_eq!(text(&s, id).para_at(0).justify, vectorcraft_doc::Justify::Center);
}
#[test]
fn center_on_top_twice_records_one_step_for_any_span() {
let mut s = session();
let id = on_circle(&mut s, "OOOO");
for (start, end) in [(0.0, 0.2), (0.13, 0.41), (0.37, 0.52), (0.61, 0.97), (0.89, 0.07), (0.3, 0.3001)] {
s.execute("type.pathOptions", &json!({"start": start, "end": end})).unwrap();
for c in ["type.pathCenter.top", "type.pathCenter.bottom"] {
s.execute(c, &json!({})).unwrap();
let (steps, placed) = (undo_len(&s), brackets(&s, id));
// Again: the brackets stay exactly where they are, and no undo step is recorded.
s.execute(c, &json!({})).unwrap();
assert_eq!((undo_len(&s), brackets(&s, id)), (steps, placed), "{c} {start} {end}");
}
}
}
#[test]
fn center_on_top_keeps_the_span_and_measures_the_path_as_drawn() {
let mut s = session();
let id = on_circle(&mut s, "OOOO");
// A span of a fifth of the path keeps its length.
s.execute("type.pathOptions", &json!({"end": 0.2})).unwrap();
s.execute("type.pathCenter.top", &json!({})).unwrap();
let (start, end) = brackets(&s, id);
assert!(near(start, 0.15) && end.is_some_and(|e| near(e, 0.35)), "{start} {end:?}");
// Turned a quarter turn counter-clockwise, its 3 o'clock point, halfway round, is at the top.
s.execute("type.pathOptions", &json!({"start": 0, "end": null})).unwrap();
s.execute("object.rotate", &json!({"angle": 90})).unwrap();
s.execute("type.pathCenter.top", &json!({})).unwrap();
let (start, _) = brackets(&s, id);
assert!(near(start.rem_euclid(1.0), 0.0) || near(start, 1.0), "{start}");
let bounds = text(&s, id).bounds().unwrap();
let top = ink(&s, id);
assert!((top.center().x - bounds.center().x).abs() < 0.5 && top.y1 < bounds.y0 + 1.0, "{top:?} {bounds:?}");
// A rectangle: the middle of its top edge.
let id = path_type(&mut s, "M100 100 L300 100 L300 300 L100 300 Z", [90.0, 100.0], "OOOO");
s.execute("type.pathCenter.top", &json!({})).unwrap();
let (start, end) = brackets(&s, id);
assert!(near(start, 0.625) && end.is_none(), "{start} {end:?}");
assert!((ink(&s, id).center().x - 200.0).abs() < 0.5);
}
#[test]
fn center_on_top_moves_every_selected_type_on_a_path_in_one_step() {
let mut s = session();
let a = on_circle(&mut s, "OOOO");
let b = path_type(&mut s, "M100 100 L300 100 L300 300 L100 300 Z", [90.0, 100.0], "OOOO");
let p = s.execute("text.create", &json!({"x": 40, "y": 40, "text": "Point"})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [a.0, b.0, p]})).unwrap();
let steps = undo_len(&s);
let r = s.execute("type.pathCenter.top", &json!({})).unwrap();
assert_eq!(r["ids"], json!([a.0, b.0]));
assert!(near(brackets(&s, a).0, 0.75) && near(brackets(&s, b).0, 0.625));
assert_eq!(undo_len(&s), steps + 1);
// Dynamic Text stays on, and the layout fits the text to the span where it now runs: a fifth of
// the circle, at its bottom.
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
s.execute("type.pathOptions", &json!({"start": 0, "end": 0.2})).unwrap();
s.execute("type.dynamicText", &json!({"on": true})).unwrap();
s.execute("type.pathCenter.bottom", &json!({})).unwrap();
assert!(text(&s, a).dynamic_text && near(brackets(&s, a).0, 0.65), "{:?}", brackets(&s, a));
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &text(&s, a));
assert!(lay.fit_scale > 1.5 && !lay.overflow, "{}", lay.fit_scale);
let bottom = ink(&s, a);
assert!((bottom.center().x - 200.0).abs() < 1.0 && bottom.y1 > 300.0, "{bottom:?}");
// Vertical type on a path moves the same way.
s.execute("type.pathOptions", &json!({"start": 0, "end": null})).unwrap();
s.execute("type.orientation.vertical", &json!({})).unwrap();
s.execute("type.pathCenter.top", &json!({})).unwrap();
assert!(near(brackets(&s, a).0, 0.75));
}
#[test]
fn center_on_top_refuses_open_compound_and_threaded_type() {
let mut s = session();
let circle = on_circle(&mut s, "OOOO");
let line = on_line(&mut s);
s.execute("select.set", &json!({"ids": [circle.0, line.0]})).unwrap();
let steps = undo_len(&s);
let before = brackets(&s, circle);
let e = s.execute("type.pathCenter.top", &json!({})).unwrap_err().to_string();
assert!(e.contains("type on an open or compound path cannot be centered on its top or bottom") && e.ends_with(&line.0.to_string()), "{e}");
// Nothing changes, the type on the circle included, and the same holds for an explicit list.
assert_eq!((undo_len(&s), brackets(&s, circle)), (steps, before));
let e = s.execute("type.pathCenter.bottom", &json!({"ids": [circle.0, line.0]})).unwrap_err().to_string();
assert!(e.contains("open or compound path") && e.ends_with(&line.0.to_string()), "{e}");
s.execute("select.set", &json!({"ids": [circle.0]})).unwrap();
for bad in [json!({"ids": "all"}), json!({"ids": [999_999]})] {
assert!(s.execute("type.pathCenter.top", &bad).is_err(), "{bad}");
}
assert_eq!(undo_len(&s), steps);
// Two circles side by side in one path: a compound path.
let pair = path_type(
&mut s,
"M100 450 A40 40 0 1 1 180 450 A40 40 0 1 1 100 450 Z M300 450 A40 40 0 1 1 380 450 A40 40 0 1 1 300 450 Z",
[90.0, 450.0],
"OOOO",
);
let e = s.execute("type.pathCenter.top", &json!({})).unwrap_err().to_string();
assert!(e.contains("open or compound path") && e.ends_with(&pair.0.to_string()), "{e}");
// A closed path that is level all round has no height.
let flat = path_type(&mut s, "M100 400 L300 400 Z", [90.0, 400.0], "OOOO");
let e = s.execute("type.pathCenter.top", &json!({})).unwrap_err().to_string();
assert!(e.contains("type on a path with no length or no height cannot be centered") && e.ends_with(&flat.0.to_string()), "{e}");
// A frame of a thread is refused, alone or with other type on a closed path.
let threaded = on_circle(&mut s, "Threaded story");
let frame = s.execute("shape.rectangle", &json!({"x": 400, "y": 100, "width": 200, "height": 100})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [threaded.0, frame]})).unwrap();
s.execute("text.thread.create", &json!({})).unwrap();
s.execute("select.set", &json!({"ids": [threaded.0]})).unwrap();
let before = brackets(&s, threaded);
for ids in [json!([threaded.0]), json!([circle.0, threaded.0])] {
let steps = undo_len(&s);
let e = s.execute("type.pathCenter.top", &json!({ "ids": ids })).unwrap_err().to_string();
assert!(e.contains("type on a path in a thread cannot be centered on its top or bottom") && e.ends_with(&threaded.0.to_string()), "{e}");
assert_eq!((undo_len(&s), brackets(&s, threaded)), (steps, before));
}
// Without type on one closed path selected, the commands are not available.
let p = s.execute("text.create", &json!({"x": 40, "y": 40, "text": "Point"})).unwrap()["id"].as_u64().unwrap();
for (ids, why) in [
(json!([p]), "select type on a closed path"),
(json!([line.0]), "open or compound path"),
(json!([circle.0, line.0]), "open or compound path"),
(json!([threaded.0]), "in a thread"),
] {
s.execute("select.set", &json!({ "ids": ids })).unwrap();
for c in ["type.pathCenter.top", "type.pathCenter.bottom"] {
let e = s.execute(c, &json!({})).unwrap_err().to_string();
assert!(e.contains(why), "{c} {ids}: {e}");
}
}
}
#[test]
fn align_to_path_and_spacing() {
let mut s = session();
+199
View File
@@ -959,3 +959,202 @@ fn not_aligned_to_pixel_grid_leaves_out_what_cant_be_selected() {
assert_eq!(s.execute("select.object.notAlignedToPixelGrid", &json!({})).unwrap()["count"], 1);
assert_eq!(selected_ids(&s), vec![inside]);
}
/// Run Not Aligned to Pixel Grid with `before` selected, check that it makes no undo step and that
/// its count is the number of objects it selected → the selected ids, sorted.
fn not_aligned(s: &mut Session, before: &[u64]) -> Vec<u64> {
s.execute("select.set", &json!({ "ids": before })).unwrap();
let steps = undo_len(s);
let r = s.execute("select.object.notAlignedToPixelGrid", &json!({})).unwrap();
let ids = selected_ids(s);
assert_eq!(r["count"], json!(ids.len()), "{r}");
assert_eq!(undo_len(s), steps);
ids
}
fn sorted(mut ids: Vec<u64>) -> Vec<u64> {
ids.sort_unstable();
ids
}
/// What Select All selects, sorted.
fn all_ids(s: &mut Session) -> Vec<u64> {
s.execute("select.all", &json!({})).unwrap();
selected_ids(s)
}
fn kind(s: &Session, id: u64) -> NodeKind {
s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind.clone()
}
/// Images, symbol instances, point type, area type and type on a path cannot take the property, so
/// Not Aligned to Pixel Grid leaves them out though Select All selects them; the path a symbol was
/// made from is the symbol's art, not an object of the document.
#[test]
fn not_aligned_to_pixel_grid_leaves_out_images_symbol_instances_and_type() {
let mut s = new_doc();
let p = path(&mut s, "M10.3 20.6 L40.7 20.6 L40.7 30.3 L10.3 30.3 Z", 1.0);
let png = crate::tests_links::png(4, 4, [255, 0, 0]);
s.execute("file.place", &json!({"name": "red.png", "dataBase64": vectorcraft_format::base64_encode(&png), "link": false})).unwrap();
let image = s.doc().unwrap().selection.objects[0].0;
let art = path(&mut s, "M60.5 60 L80 60 L80 80 L60.5 80 Z", 1.0);
let made = s.execute("symbol.new", &json!({"name": "Mark", "ids": [art]})).unwrap()["id"].as_u64().unwrap();
let placed = s.execute("symbol.place", &json!({"name": "Mark", "x": 200.3, "y": 200.3})).unwrap()["id"].as_u64().unwrap();
let point = s.execute("text.create", &json!({"x": 100, "y": 100, "text": "point"})).unwrap()["id"].as_u64().unwrap();
let frame = json!({"width": 80.5, "height": 40.5});
let area = s.execute("text.create", &json!({"x": 100, "y": 150, "text": "area", "area": frame})).unwrap()["id"].as_u64().unwrap();
let on_path = path(&mut s, "M10.5 300 C100 250 200 350 300.5 300", 1.0);
let on_path = s.execute("text.createInPath", &json!({"path": on_path, "mode": "onPath", "text": "on a path"})).unwrap()["id"].as_u64().unwrap();
let in_path = path(&mut s, "M250.5 20.5 L350 20.5 L350 90 L250.5 90 Z", 1.0);
let in_path = s.execute("text.createInPath", &json!({"path": in_path, "mode": "area", "text": "in a path"})).unwrap()["id"].as_u64().unwrap();
assert!(matches!(kind(&s, image), NodeKind::Image(_)));
for id in [made, placed] {
assert!(matches!(kind(&s, id), NodeKind::SymbolInstance { .. }), "{id}");
}
for id in [point, area, on_path, in_path] {
assert!(matches!(kind(&s, id), NodeKind::Text(_)), "{id}");
}
assert!(s.doc().unwrap().doc.node(NodeId(art)).is_none());
assert_eq!(all_ids(&mut s), sorted(vec![p, image, made, placed, point, area, on_path, in_path]));
assert_eq!(not_aligned(&mut s, &[image, made, point]), vec![p]);
// With the path aligned, nothing is left to select.
s.execute("object.setPixelAligned", &json!({"ids": [p]})).unwrap();
assert_eq!(not_aligned(&mut s, &[placed]), Vec::<u64>::new());
}
/// Paths on a template layer, in a hidden or locked sublayer or on a locked artboard are left out,
/// as Select All leaves them out; paths in an unlocked visible sublayer are selected.
#[test]
fn not_aligned_to_pixel_grid_leaves_out_template_layers_locked_sublayers_and_locked_artboards() {
let mut s = new_doc();
s.execute("artboard.new", &json!({"x": 500, "y": 0, "width": 100, "height": 100})).unwrap();
let main = s.doc().unwrap().doc.layers[0].id.0;
let free = path(&mut s, "M10 10 L20 10 L20 20 L10 20 Z", 1.0);
let on_locked_board = path(&mut s, "M510 10 L520 10 L520 20 L510 20 Z", 1.0);
let template = s.execute("layer.new", &json!({"name": "Trace"})).unwrap()["id"].as_u64().unwrap();
let traced = path(&mut s, "M30 10 L40 10 L40 20 L30 20 Z", 1.0);
s.execute("layer.setProps", &json!({"id": template, "template": true})).unwrap();
let sub = |s: &mut Session, name: &str, d: &str| {
let l = s.execute("layer.newSublayer", &json!({"parent": main, "name": name})).unwrap()["id"].as_u64().unwrap();
s.execute("layer.setCurrent", &json!({"id": l})).unwrap();
(l, path(s, d, 1.0))
};
let (_, in_sublayer) = sub(&mut s, "Open", "M50 10 L60 10 L60 20 L50 20 Z");
let (hidden, in_hidden) = sub(&mut s, "Hidden", "M70 10 L80 10 L80 20 L70 20 Z");
let (locked, in_locked) = sub(&mut s, "Locked", "M90 10 L100 10 L100 20 L90 20 Z");
s.execute("layer.setProps", &json!({"id": hidden, "visible": false})).unwrap();
s.execute("layer.setProps", &json!({"id": locked, "locked": true})).unwrap();
s.execute("artboard.setProps", &json!({"index": 1, "locked": true})).unwrap();
let all = all_ids(&mut s);
for id in [traced, in_hidden, in_locked, on_locked_board] {
assert!(!all.contains(&id), "{id}");
}
assert_eq!(not_aligned(&mut s, &[free]), sorted(vec![free, in_sublayer]));
// Unlocked, the artboard's path is selected again.
s.execute("artboard.setProps", &json!({"index": 1, "locked": false})).unwrap();
assert_eq!(not_aligned(&mut s, &[free]), sorted(vec![free, in_sublayer, on_locked_board]));
}
/// A clipping path and the paths it clips are selected, not their clip group; a path with a drop
/// shadow or a Gaussian Blur is selected as the path it is, and its effects are not objects.
#[test]
fn not_aligned_to_pixel_grid_selects_clipping_paths_and_paths_with_effects() {
let mut s = new_doc();
let clipped = path(&mut s, "M10.5 10 L60 10 L60 60 L10.5 60 Z", 1.0);
let clip = path(&mut s, "M20.5 20 L50 20 L50 50 L20.5 50 Z", 1.0);
s.execute("select.set", &json!({"ids": [clipped, clip]})).unwrap();
let group = s.execute("object.clippingMask.make", &json!({})).unwrap()["id"].as_u64().unwrap();
let shadowed = path(&mut s, "M100.5 10 L150 10 L150 60 L100.5 60 Z", 1.0);
s.execute("effect.apply", &json!({"effect": "stylize.dropShadow", "ids": [shadowed]})).unwrap();
let blurred = path(&mut s, "M200.5 10 L250 10 L250 60 L200.5 60 Z", 1.0);
s.execute("effect.apply", &json!({"effect": "blur.gaussian", "params": {"radius": 3}, "ids": [blurred]})).unwrap();
assert!(matches!(kind(&s, group), NodeKind::Group { .. }));
for id in [shadowed, blurred] {
assert!(!s.doc().unwrap().doc.node(NodeId(id)).unwrap().appearance.effects.is_empty(), "{id}");
}
let want = sorted(vec![clipped, clip, shadowed, blurred]);
assert_eq!(not_aligned(&mut s, &[group]), want);
// Object › Align to Pixel Grid takes each object selected; then nothing is left to select.
s.execute("object.setPixelAligned", &json!({"ids": want})).unwrap();
assert_eq!(not_aligned(&mut s, &[group]), Vec::<u64>::new());
}
/// The filter looks into blends, envelopes, repeats and Intertwine groups and selects the paths
/// they are made of, not the objects that hold them; Align to Pixel Grid takes that selection, and
/// then nothing is left to select.
#[test]
fn not_aligned_to_pixel_grid_selects_the_paths_of_blends_envelopes_repeats_and_intertwines() {
let mut s = new_doc();
let b1 = path(&mut s, "M10.5 10 L30 10 L30 30 L10.5 30 Z", 1.0);
let b2 = path(&mut s, "M80.5 10 L100 10 L100 30 L80.5 30 Z", 1.0);
s.execute("select.set", &json!({"ids": [b1, b2]})).unwrap();
let blend = s.execute("object.blend.make", &json!({})).unwrap()["id"].as_u64().unwrap();
let warped = path(&mut s, "M10.5 100 L100 100 L100 150 L10.5 150 Z", 1.0);
let envelope = s.execute("object.envelope.makeWithWarp", &json!({"ids": [warped]})).unwrap()["id"].as_u64().unwrap();
let tile = path(&mut s, "M200.5 10 L220 10 L220 30 L200.5 30 Z", 1.0);
let repeat = s.execute("object.repeat.grid", &json!({"ids": [tile], "rows": 2, "cols": 2})).unwrap()["id"].as_u64().unwrap();
let i1 = path(&mut s, "M200.5 200 L260 200 L260 230 L200.5 230 Z", 1.0);
let i2 = path(&mut s, "M220.5 180 L240 180 L240 250 L220.5 250 Z", 1.0);
let intertwine = s.execute("object.intertwine.make", &json!({"ids": [i1, i2]})).unwrap()["id"].as_u64().unwrap();
assert!(matches!(kind(&s, blend), NodeKind::Blend { .. }));
assert!(matches!(kind(&s, envelope), NodeKind::Envelope { .. }));
assert!(matches!(kind(&s, repeat), NodeKind::Repeat(_)));
assert!(matches!(kind(&s, intertwine), NodeKind::Intertwine { .. }));
let want = sorted(vec![b1, b2, warped, tile, i1, i2]);
assert_eq!(not_aligned(&mut s, &[blend, envelope]), want);
s.execute("object.setPixelAligned", &json!({})).unwrap();
for id in &want {
assert!(aligned(&s, *id), "{id}");
}
assert_eq!(not_aligned(&mut s, &[repeat, intertwine]), Vec::<u64>::new());
}
/// Gradient meshes, placed documents and ruler guides are left out; a live shape is a path and is
/// selected.
#[test]
fn not_aligned_to_pixel_grid_leaves_out_meshes_placed_documents_and_guides_but_takes_live_shapes() {
let mut s = new_doc();
let filled = path(&mut s, "M10.5 10 L60 10 L60 60 L10.5 60 Z", 1.0);
s.execute("paint.setFill", &json!({"color": "#3366cc"})).unwrap();
let mesh = s.execute("object.mesh.create", &json!({"ids": [filled], "rows": 2, "cols": 2})).unwrap()["ids"][0].as_u64().unwrap();
let dir = crate::tests_links::Folder::new("pixelalign-placed");
let file = dir.file("placed.vectorcraft");
let mut d = vectorcraft_doc::Document::new(50.0, 50.0);
let layer = d.layers[0].id;
let id = d.alloc_id();
let rect = vectorcraft_geom::shapes::rectangle(vectorcraft_geom::Rect::new(0.5, 0.5, 40.0, 40.0));
let paint = vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb8(20, 20, 230));
let look = vectorcraft_doc::Appearance::basic(paint, vectorcraft_color::Paint::None, 0.0);
d.insert(Some(layer), 0, vectorcraft_doc::Node::path(id, rect, look)).unwrap();
crate::tests_links::write(&file, &vectorcraft_format::save_file(&d));
let placed = s.execute("file.place", &json!({"path": file, "at": [200, 200]})).unwrap()["ids"][0].as_u64().unwrap();
let guide = path(&mut s, "M0 300.5 L400 300.5", 1.0);
s.execute("view.guides.make", &json!({})).unwrap();
let live = s.execute("shape.rectangle", &json!({"x": 100.3, "y": 20.6, "width": 30.4, "height": 9.7})).unwrap()["id"].as_u64().unwrap();
assert!(matches!(kind(&s, mesh), NodeKind::Mesh(_)));
assert!(matches!(kind(&s, placed), NodeKind::PlacedDocument(_)));
assert!(matches!(kind(&s, guide), NodeKind::Path { guide: true, .. }));
assert!(s.doc().unwrap().doc.node(NodeId(live)).unwrap().live_shape().is_some());
let all = all_ids(&mut s);
assert!(all.contains(&mesh) && all.contains(&placed), "{all:?}");
assert_eq!(not_aligned(&mut s, &[mesh, placed]), vec![live]);
}
/// A compound path goes by its own property, whatever the property of the paths in it (a file can
/// hold paths with the property on inside a compound path): off, it is selected as one object and
/// the paths in it are not; on, it is not selected, though a path in it has the property off.
#[test]
fn not_aligned_to_pixel_grid_takes_a_compound_path_by_its_own_property() {
let mut s = new_doc();
let on = path(&mut s, "M10.5 10 L30 10 L30 30 L10.5 30 Z", 1.0);
let off = path(&mut s, "M50.5 10 L70 10 L70 30 L50.5 30 Z", 1.0);
s.execute("select.set", &json!({"ids": [on, off]})).unwrap();
let compound = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap();
std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(NodeId(on)).unwrap().extras_mut().pixel_aligned = true;
assert!(aligned(&s, on) && !aligned(&s, off) && !aligned(&s, compound));
let other = path(&mut s, "M100 100 L110 100 L110 110 L100 110 Z", 1.0);
assert_eq!(not_aligned(&mut s, &[other]), sorted(vec![compound, other]));
s.execute("object.setPixelAligned", &json!({"ids": [compound]})).unwrap();
assert!(!aligned(&s, off));
assert_eq!(not_aligned(&mut s, &[compound]), vec![other]);
}
+86
View File
@@ -1433,6 +1433,92 @@ fn plugins_folder_set_again_after_clearing_installs_its_plugins() {
run(&mut s, "plugin.remove", json!({"id": id}));
}
/// Under automation read roots, `plugin.list` names the plug-in folder last loaded, its failed
/// files and a plug-in's source file only inside them: a folder outside is `null`, and a file
/// outside is named by its file name.
#[test]
fn plugin_list_leaves_out_paths_outside_the_read_root() {
use crate::file_access::{AutomationRoots, confine};
let _folder = PREFS_FOLDER.lock().unwrap_or_else(|e| e.into_inner());
let base = crate::tests_links::Folder::new("plugin-list-read-root");
let (inside, outside) = (base.0.join("in"), base.0.join("out"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
let id = "test.engine.listroots";
let src = tpl::returning(&tpl::manifest(id, "filter", "{}"), r#"{"objects":[]}"#);
std::fs::write(outside.join("hidden.wasm"), wat::parse_str(src).unwrap()).unwrap();
std::fs::write(outside.join("broken.wasm"), b"\0asm?").unwrap();
let folder = outside.to_string_lossy().to_string();
let mut s = session();
let r = run(&mut s, "plugin.reload", json!({"path": folder}));
assert_eq!(r["loaded"], json!([id]), "{r}");
let broken = outside.join("broken.wasm").to_string_lossy().to_string();
let source = outside.join("hidden.wasm").to_string_lossy().to_string();
let entry = |list: &Value| list["plugins"].as_array().unwrap().iter().find(|p| p["id"] == id).cloned().unwrap();
// The person sees the paths.
let person = run(&mut s, "plugin.list", json!({}));
assert_eq!((&person["folder"]["folder"], &person["folder"]["failed"][0]["file"]), (&json!(folder), &json!(broken)), "{person}");
assert_eq!(entry(&person)["source"], json!(source));
// The client sees their names.
let roots = AutomationRoots::new(&[&inside], &[]).unwrap();
let listed = confine(roots.as_ref(), || s.execute("plugin.list", &json!({}))).unwrap();
let report = &listed["folder"];
assert_eq!((&report["folder"], &report["loaded"], &report["failed"][0]["file"]), (&Value::Null, &json!([id]), &json!("broken.wasm")), "{listed}");
assert_eq!(entry(&listed)["source"], "hidden.wasm");
let info = confine(roots.as_ref(), || s.execute("plugin.info", &json!({"id": id}))).unwrap();
assert_eq!(info["source"], "hidden.wasm");
let outside_text = json!(folder).to_string();
for reply in [&listed, &info] {
assert!(!reply.to_string().contains(outside_text.trim_matches('"')), "no path outside the root: {reply}");
}
// A read root holding the folder shows it whole.
let wider = AutomationRoots::new(&[&outside], &[]).unwrap();
let listed = confine(wider.as_ref(), || s.execute("plugin.list", &json!({}))).unwrap();
assert_eq!(listed["folder"]["folder"], json!(folder), "{listed}");
run(&mut s, "plugin.remove", json!({"id": id}));
}
/// Under automation read roots, a plug-in turned off for the next launch is listed with a file
/// outside them named by its file name, and `plugin.setEnabled` turns it on by that name.
#[test]
fn disabled_plugins_name_files_outside_the_read_root_by_their_names() {
if !in_own_process("disabled_plugins_name_files_outside_the_read_root_by_their_names") {
return;
}
use crate::file_access::{AutomationRoots, confine};
let base = crate::tests_links::Folder::new("plugin-disabled-read-root");
let (inside, outside) = (base.0.join("in"), base.0.join("out"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
let id = "test.engine.disabledroots";
let src = tpl::returning(&tpl::manifest(id, "filter", "{}"), r#"{"objects":[]}"#);
let file = outside.join("off.wasm");
std::fs::write(&file, wat::parse_str(src).unwrap()).unwrap();
let file = file.to_string_lossy().to_string();
let mut s = session();
run(&mut s, "plugin.install", json!({"path": file}));
let roots = AutomationRoots::new(&[&inside], &[]).unwrap();
// The client turns it off by the source plugin.list shows.
let listed = confine(roots.as_ref(), || s.execute("plugin.list", &json!({}))).unwrap();
let source = listed["plugins"].as_array().unwrap().iter().find(|p| p["id"] == id).unwrap()["source"].clone();
assert_eq!(source, "off.wasm", "{listed}");
confine(roots.as_ref(), || s.execute("plugin.setEnabled", &json!({"file": source, "enabled": false}))).unwrap();
assert_eq!(run(&mut s, "plugin.safeMode", json!({}))["disabled"][0]["file"], json!(file), "the person sees the path");
let outside_text = json!(outside.to_string_lossy()).to_string();
for cmd in ["plugin.list", "plugin.safeMode"] {
let r = confine(roots.as_ref(), || s.execute(cmd, &json!({}))).unwrap();
assert_eq!(r["disabled"][0]["file"], "off.wasm", "{cmd}: {r}");
assert!(!r.to_string().contains(outside_text.trim_matches('"')), "{cmd}: no path outside the root: {r}");
}
let r = confine(roots.as_ref(), || s.execute("plugin.setEnabled", &json!({"file": "off.wasm", "enabled": true}))).unwrap();
assert_eq!((&r["changed"], &r["disabled"]), (&json!(true), &json!([])), "{r}");
run(&mut s, "plugin.remove", json!({"id": id}));
}
/// #2541: a plug-in installed in a session with a plug-in store is installed again in the next
/// session that attaches the store, and Remove Plug-in takes it out of the store.
#[test]
+65
View File
@@ -1545,6 +1545,71 @@ impl RecoveryStore for DiesAfterDocument {
}
}
/// Under automation read roots, `file.recovery.save`, `file.recovery.list` and
/// `file.recovery.restore` name a document's file and the recovery folder only inside them.
#[test]
fn recovery_replies_leave_out_paths_outside_the_read_root() {
use crate::file_access::{AutomationRoots, confine};
use serde_json::Value;
let base = crate::tests_links::Folder::new("recovery-read-root");
let (inside, outside) = (base.0.join("in"), base.0.join("out"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
let store: Arc<dyn RecoveryStore> = Arc::new(FolderStore::new(outside.join("recovery")));
let location = outside.join("recovery").to_string_lossy().to_string();
let kept = inside.join("kept.vectorcraft").to_string_lossy().to_string();
let hidden = outside.join("hidden.vectorcraft").to_string_lossy().to_string();
let mut s = Session::new();
s.recovery.set_store(store.clone());
for path in [&kept, &hidden] {
s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
s.execute("file.saveAs", &json!({"path": path})).unwrap();
s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
}
let roots = AutomationRoots::new(&[&inside], &[]).unwrap();
let saved = confine(roots.as_ref(), || s.execute("file.recovery.save", &json!({}))).unwrap();
assert_eq!(saved["location"], Value::Null, "{saved}");
s.execute("shape.ellipse", &json!({"x": 80, "y": 20, "width": 20, "height": 20})).unwrap();
assert_eq!(s.execute("file.recovery.save", &json!({})).unwrap()["location"], json!(location), "the person sees the folder");
let sorted = |v: &Value, key: &str| -> Vec<String> {
let mut out: Vec<String> = v[key].as_array().unwrap().iter().map(|c| c["path"].to_string()).collect();
out.sort();
out
};
let both = |first: Value| {
let mut out = vec![first.to_string(), json!(kept).to_string()];
out.sort();
out
};
assert_eq!(sorted(&s.execute("file.recovery.list", &json!({})).unwrap(), "copies"), both(json!(hidden)));
let listed = confine(roots.as_ref(), || s.execute("file.recovery.list", &json!({}))).unwrap();
assert_eq!((sorted(&listed, "copies"), &listed["location"]), (both(Value::Null), &Value::Null), "{listed}");
let outside_text = json!(outside.to_string_lossy()).to_string();
assert!(!listed.to_string().contains(outside_text.trim_matches('"')), "no path outside the root: {listed}");
// A relative recovery folder is checked as the file system reads it; a store that is no folder
// keeps its name.
let mut relative = Session::new();
relative.recovery.set_store(Arc::new(FolderStore::new("vc-recovery-relative-folder")));
let l = confine(roots.as_ref(), || relative.execute("file.recovery.list", &json!({}))).unwrap();
assert_eq!(l["location"], Value::Null, "{l}");
let (mut memory, _) = session();
let l = confine(roots.as_ref(), || memory.execute("file.recovery.list", &json!({}))).unwrap();
assert_eq!(l["location"], "memory", "{l}");
// After a crash, the copies restored.
drop(s);
let mut s = Session::new();
s.recovery.set_store(store.clone());
let r = confine(roots.as_ref(), || s.execute("file.recovery.restore", &json!({}))).unwrap();
assert_eq!(sorted(&r, "restored"), both(Value::Null), "{r}");
let mut opened: Vec<Option<String>> = s.documents().iter().map(|d| d.path.clone()).collect();
opened.sort();
let mut files = vec![Some(hidden), Some(kept)];
files.sort();
assert_eq!(opened, files, "the documents keep their files");
}
/// A crash between writing a copy's document and its details restores the new document with
/// every image, the one placed since the last copy too (and the first copy likewise).
#[test]
+28
View File
@@ -265,3 +265,31 @@ fn the_slowest_commands_are_the_longest_in_all_then_by_id() {
assert_eq!(ids, ["b.two", "a.one", "c.three", "f", "e"]);
assert_eq!((slow[0].calls, slow[0].total_ms, slow[0].max_ms), (3, 9, 4));
}
/// Under automation read roots, the error lines of a failed run name the included file it stopped
/// in by its file name also when the console cut a line inside the file's path.
#[test]
fn a_cut_error_line_leaves_out_an_included_files_folder_outside_the_read_root() {
use crate::file_access::{AutomationRoots, confine};
let base = crate::tests_links::Folder::new("script-report-cut-line");
let inside = base.0.join("in");
std::fs::create_dir_all(&inside).unwrap();
// A path longer than a console line, as the report of a failed run names it.
let file = base.0.join("out").join("d".repeat(MAX_LINE_BYTES)).join("bad.jsxinc").to_string_lossy().to_string();
let mut report = json!({"ok": false, "name": "t.js", "file": file, "line": 2, "column": 7, "message": format!("Error: stopped\nin {file}")});
let error = script::error_lines(&report);
assert!(error.len() == 2 && error.iter().all(|l| l.len() <= MAX_LINE_BYTES && l.ends_with(CUT_MARK)), "both lines are cut: {error:?}");
let written: Vec<String> = std::iter::once("written by the script".to_string()).chain(error).collect();
report["console"] = json!({"lines": written, "droppedLines": 0, "truncatedLines": 2});
let mut s = Session::new();
s.script_report = Some(report.clone());
let roots = AutomationRoots::new(&[&inside], &[]).unwrap();
let shown = confine(roots.as_ref(), || s.shown_script_report()).unwrap();
assert_eq!((&shown["file"], &shown["message"]), (&json!("bad.jsxinc"), &json!("Error: stopped\nin bad.jsxinc")), "{shown}");
assert_eq!(shown["console"]["lines"], json!(["written by the script", "t.js: bad.jsxinc:2:7: Error: stopped", "in bad.jsxinc"]), "{shown}");
let outside = json!(base.0.join("out").to_string_lossy()).to_string();
assert!(!shown.to_string().contains(outside.trim_matches('"')), "no path outside the root: {shown}");
// The person sees the report as it is.
assert_eq!(s.shown_script_report(), Some(report));
}
+1 -1
View File
@@ -230,7 +230,7 @@ fn script_file_link_escape_refused() {
/// not matter, and outside it where case matters, whether or not the file is there.
#[test]
fn script_file_case_variant_folder() {
let base = folder("case");
let base = crate::cmd::findfiles::plain(folder("case").canonicalize().unwrap());
write(&base.join("main/own.txt"), b"own");
let upper = base.join("MAIN");
let source = |name: &str| {
+157
View File
@@ -234,3 +234,160 @@ fn a_marquee_that_touches_only_a_drop_shadow_does_not_select_its_object() {
// From above B, over B and the shadow: B only.
assert_eq!(press(&mut s, "selection", (105.0, 5.0), (115.0, 30.0), Mods::default()), [b]);
}
/// The selection after a drag with `tool` from `from` to `to`.
fn marquee(s: &mut Session, tool: &str, from: (f64, f64), to: (f64, f64)) -> vectorcraft_doc::Selection {
press(s, tool, from, to, Mods::default());
s.doc().unwrap().selection.clone()
}
/// The point of anchor `(si, ai)` of path `id`.
fn anchor_point(s: &Session, id: NodeId, (si, ai): vectorcraft_doc::AnchorRef) -> Point {
let path = s.doc().unwrap().doc.node(id).and_then(|n| n.path_data()).unwrap();
path.anchors().find(|(s, i, _)| (*s, *i) == (si, ai)).map(|(.., a)| a.p).unwrap()
}
/// The anchors a marquee or a click picked on `id`, as points.
fn picked_points(s: &Session, id: NodeId) -> Vec<Point> {
let refs: Vec<_> = s.doc().unwrap().selection.partial(id).into_iter().flatten().copied().collect();
refs.into_iter().map(|r| anchor_point(s, id, r)).collect()
}
/// The anchors the tool marks as hovered.
fn anchor_marks(s: &mut Session) -> Vec<Point> {
s.overlays(ViewInfo::default())
.into_iter()
.filter_map(|o| if let vectorcraft_tools::Overlay::Anchor { p, .. } = o { Some(p) } else { None })
.collect()
}
fn hover(s: &mut Session, x: f64, y: f64) -> Cursor {
let v = ViewInfo::default();
s.pointer(&PointerEvent::new(PointerKind::Move, x, y), v).unwrap();
s.cursor(Point::new(x, y), Mods::default(), v)
}
#[test]
fn a_direct_selection_marquee_leaves_out_a_drop_shadow() {
let mut s = session();
let (a, b) = shadow_over_b(&mut s);
let (a_before, b_before) = (bounds(&s, a), bounds(&s, b));
assert_ne!(pixel(&s, 90, 50), WHITE);
run(&mut s, "select.none", json!({}));
// Over the shadow alone: no object, no anchor, no segment.
let sel = marquee(&mut s, "directSelection", (85.0, 40.0), (95.0, 60.0));
assert!(sel.objects.is_empty() && sel.anchors.is_empty() && sel.segments.is_empty(), "{sel:?}");
// Over the shadow and B's upper left corner: that anchor of B, and nothing of A.
let sel = marquee(&mut s, "directSelection", (90.0, 5.0), (105.0, 30.0));
assert_eq!(sel.objects, [b]);
assert_eq!(picked_points(&s, b), [Point::new(100.0, 20.0)]);
// Across B's top edge under the shadow, with neither of its anchors inside: that segment.
run(&mut s, "select.none", json!({}));
assert_ne!(pixel(&s, 112, 25), BLUE);
let sel = marquee(&mut s, "directSelection", (110.0, 5.0), (115.0, 30.0));
assert_eq!(sel.objects, [b]);
assert!(sel.segments.contains_key(&b) && !sel.segments.contains_key(&a), "{sel:?}");
assert_eq!((bounds(&s, a), bounds(&s, b)), (a_before, b_before));
}
#[test]
fn direct_selection_hover_leaves_out_a_drop_shadow_and_marks_the_anchor_under_it() {
let mut s = session();
let (_, b) = shadow_over_b(&mut s);
// B's upper left corner lies under the shadow.
assert_ne!(pixel(&s, 101, 21), BLUE);
run(&mut s, "select.none", json!({}));
s.select_tool("directSelection", ViewInfo::default()).unwrap();
for (x, y) in [(90.0, 50.0), (110.0, 50.0)] {
assert_eq!(hover(&mut s, x, y), Cursor::ArrowHollow, "({x}, {y})");
assert!(anchor_marks(&mut s).is_empty(), "({x}, {y})");
}
assert_eq!(hover(&mut s, 101.0, 21.0), Cursor::DirectAnchor);
assert_eq!(anchor_marks(&mut s), [Point::new(100.0, 20.0)]);
// A press there picks that anchor of B.
assert_eq!(press(&mut s, "directSelection", (101.0, 21.0), (101.0, 21.0), Mods::default()), [b]);
assert_eq!(picked_points(&s, b), [Point::new(100.0, 20.0)]);
}
#[test]
fn a_group_selection_click_on_a_drop_shadow_selects_the_object_under_it() {
let mut s = session();
let (a, b) = shadow_over_b(&mut s);
run(&mut s, "select.none", json!({}));
assert_eq!(press(&mut s, "groupSelection", (110.0, 50.0), (110.0, 50.0), Mods::default()), [b]);
assert!(press(&mut s, "groupSelection", (90.0, 50.0), (90.0, 50.0), Mods::default()).is_empty());
assert_eq!(press(&mut s, "groupSelection", (50.0, 50.0), (50.0, 50.0), Mods::default()), [a]);
}
#[test]
fn group_selection_clicks_on_a_drop_shadow_climb_the_groups_of_the_object_under_it() {
let mut s = session();
// B and C in one group, A and D in another above it, and A's shadow over B.
let b = rect(&mut s, 100.0, 20.0, 60.0, 60.0, "#0000ff");
let c = rect(&mut s, 170.0, 20.0, 20.0, 20.0, "#0000ff");
run(&mut s, "select.set", json!({"ids": [b.0, c.0]}));
let gb = id_of(&run(&mut s, "object.group", json!({})));
let a = rect(&mut s, 20.0, 20.0, 60.0, 60.0, "#ff0000");
let d = rect(&mut s, 20.0, 120.0, 20.0, 20.0, "#ff0000");
run(&mut s, "select.set", json!({"ids": [a.0, d.0]}));
let ga = id_of(&run(&mut s, "object.group", json!({})));
shadow(&mut s, a, 40.0);
assert_ne!(pixel(&s, 110, 50), BLUE);
assert_ne!(pixel(&s, 90, 50), WHITE);
run(&mut s, "select.none", json!({}));
let click = |s: &mut Session, x, y| {
let mut sel = press(s, "groupSelection", (x, y), (x, y), Mods::default());
sel.sort_by_key(|n| n.0);
sel
};
assert_eq!(click(&mut s, 110.0, 50.0), [b]);
let mut both = vec![b, gb];
both.sort_by_key(|n| n.0);
assert_eq!(click(&mut s, 110.0, 50.0), both);
// With A selected, a click on its shadow over the canvas does not add A's group.
run(&mut s, "select.set", json!({"ids": [a.0]}));
assert!(click(&mut s, 90.0, 50.0).is_empty());
// On A itself the second click adds it.
assert_eq!(click(&mut s, 50.0, 50.0), [a]);
let mut both = vec![a, ga];
both.sort_by_key(|n| n.0);
assert_eq!(click(&mut s, 50.0, 50.0), both);
}
#[test]
fn a_group_selection_marquee_leaves_out_a_drop_shadow() {
let mut s = session();
let (a, b) = shadow_over_b(&mut s);
run(&mut s, "select.none", json!({}));
let sel = marquee(&mut s, "groupSelection", (85.0, 40.0), (95.0, 60.0));
assert!(sel.objects.is_empty() && sel.anchors.is_empty(), "{sel:?}");
// Over the shadow and B's upper left corner: that anchor of B.
let sel = marquee(&mut s, "groupSelection", (90.0, 5.0), (105.0, 30.0));
assert_eq!(sel.objects, [b]);
assert_eq!(picked_points(&s, b), [Point::new(100.0, 20.0)]);
// With E, a marquee around B that crosses A's shadow selects B whole, and not A.
run(&mut s, "select.none", json!({}));
let v = ViewInfo::default();
s.select_tool("groupSelection", v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Down, 95.0, 10.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 130.0, 50.0), v).unwrap();
s.tool_key(vectorcraft_tools::ToolKey::Letter('e'), Mods::default(), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 165.0, 90.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 165.0, 90.0), v).unwrap();
let sel = s.doc().unwrap().selection.clone();
assert_eq!(sel.objects, [b]);
assert!(sel.partial(b).is_none() && sel.partial(a).is_none(), "{sel:?}");
}
#[test]
fn group_selection_hover_over_a_drop_shadow_marks_nothing() {
let mut s = session();
let (_, b) = shadow_over_b(&mut s);
run(&mut s, "select.none", json!({}));
s.select_tool("groupSelection", ViewInfo::default()).unwrap();
for (x, y) in [(90.0, 50.0), (110.0, 50.0), (101.0, 21.0)] {
assert_eq!(hover(&mut s, x, y), Cursor::GroupSelection, "({x}, {y})");
assert!(anchor_marks(&mut s).is_empty(), "({x}, {y})");
}
assert_eq!(press(&mut s, "groupSelection", (110.0, 50.0), (110.0, 50.0), Mods::default()), [b]);
}
+44 -1
View File
@@ -844,7 +844,7 @@ fn a_grit_texture_adds_once_undoes_and_saves() {
let list = run(&mut s, "swatch.library.list", json!({}));
let ids: Vec<&str> =
list["libraries"].as_array().unwrap().iter().filter(|l| l["category"] == "patterns").map(|l| l["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["geometric-patterns", "grit-textures"]);
assert_eq!(ids, ["geometric-patterns", "grit-textures", "optical-effects"]);
let got = run(&mut s, "swatch.library.get", json!({"library": "Grit Textures"}));
let names: Vec<&str> = got["swatches"].as_array().unwrap().iter().map(|w| w["name"].as_str().unwrap()).collect();
assert_eq!(names, ["Fine Grain", "Coarse Grit", "Sand", "Speckle", "Stipple", "Scratches", "Sparse Flecks", "Dense Flecks"]);
@@ -869,6 +869,49 @@ fn a_grit_texture_adds_once_undoes_and_saves() {
assert_eq!(back.swatch("Stipple").map(|w| &w.paint), doc(&s).swatch("Stipple").map(|w| &w.paint));
}
/// Optical Effects is listed after Grit Textures, and reading it adds nothing. Clicking one of
/// its patterns brings it with its swatch and fills the selection with it, once, as one undo step
/// that also takes both away, and both stay after a save and reopen.
#[test]
fn an_optical_effect_adds_once_fills_undoes_and_saves() {
let mut s = session();
let counts = |d: &vectorcraft_doc::Document| (d.patterns.len(), d.swatches_iter().count());
let empty = counts(doc(&s));
let list = run(&mut s, "swatch.library.list", json!({}));
let ids: Vec<&str> =
list["libraries"].as_array().unwrap().iter().filter(|l| l["category"] == "patterns").map(|l| l["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["geometric-patterns", "grit-textures", "optical-effects"]);
let got = run(&mut s, "swatch.library.get", json!({"library": "Optical Effects"}));
let names: Vec<&str> = got["swatches"].as_array().unwrap().iter().map(|w| w["name"].as_str().unwrap()).collect();
assert_eq!(
names,
["Sine Bands", "Ripple Lines", "Interference Rings", "Offset Rings", "Warped Checks", "Pinched Stripes", "Chevron Pulse", "Radiating Lenses"]
);
assert_eq!(counts(doc(&s)), empty, "reading a library adds no pattern or swatch");
let id = vectorcraft_doc::NodeId(run(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 50, "height": 50}))["id"].as_u64().unwrap());
let undo = undo_len(&s);
let r = run(&mut s, "swatch.library.add", json!({"library": "optical-effects", "names": ["Warped Checks"], "apply": "fill"}));
assert_eq!((r["added"].clone(), r["applied"].clone()), (json!(["Warped Checks"]), json!("Warped Checks")));
assert_eq!((counts(doc(&s)), undo_len(&s)), ((empty.0 + 1, empty.1 + 1), undo + 1));
let def = doc(&s).pattern("Warped Checks").expect("the pattern comes with its swatch").clone();
assert_eq!(def.art.len(), 32, "the black cells of an 8 × 8 checkerboard");
assert!(matches!(doc(&s).swatch("Warped Checks").map(|w| &w.paint), Some(Paint::Pattern { pattern, .. }) if pattern == "Warped Checks"));
let filled = |d: &vectorcraft_doc::Document| matches!(d.node(id).unwrap().appearance.fill_paint(), Paint::Pattern { pattern, .. } if pattern == "Warped Checks");
assert!(filled(doc(&s)));
let r = run(&mut s, "swatch.library.add", json!({"library": "optical-effects", "names": ["Warped Checks"]}));
assert_eq!((r["added"].clone(), r["existing"].clone()), (json!([]), json!(["Warped Checks"])));
assert_eq!((counts(doc(&s)), undo_len(&s)), ((empty.0 + 1, empty.1 + 1), undo + 1), "added once");
run(&mut s, "edit.undo", json!({}));
assert_eq!(counts(doc(&s)), empty);
assert!(doc(&s).pattern("Warped Checks").is_none() && doc(&s).swatch("Warped Checks").is_none() && !filled(doc(&s)));
run(&mut s, "edit.redo", json!({}));
assert!(filled(doc(&s)));
let back = vectorcraft_format::load(&vectorcraft_format::save(doc(&s), false)).unwrap();
assert_eq!(back.pattern("Warped Checks"), Some(&def));
assert_eq!(back.swatch("Warped Checks").map(|w| &w.paint), doc(&s).swatch("Warped Checks").map(|w| &w.paint));
assert!(filled(&back));
}
/// A device name is saved with a `-` after it, which can be another library's own name: neither
/// library replaces the other, and saving either again replaces only itself.
#[test]
+293
View File
@@ -0,0 +1,293 @@
//! Effect › Warp on placed images: the pixels bend with the frame, in the canvas and in exports.
use serde_json::{Value, json};
use vectorcraft_doc::live::{WarpNet, WarpStyle, uses_net, warp_version};
use vectorcraft_doc::{Node, NodeKind};
use vectorcraft_geom::{Affine, Point, Rect};
use crate::*;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
s
}
/// The box of the image [`quarters`] places.
const FRAME: Rect = Rect::new(100.0, 100.0, 180.0, 180.0);
/// The color of the quarter of the image [`quarters`] places that holds (u, v) of its box: red top
/// left, green top right, blue bottom left, yellow bottom right.
fn quarter(u: f64, v: f64) -> [u8; 3] {
match (u < 0.5, v < 0.5) {
(true, true) => [255, 0, 0],
(false, true) => [0, 255, 0],
(true, false) => [0, 0, 255],
(false, false) => [255, 255, 0],
}
}
/// A selected embedded 40×40 px image filling [`FRAME`], each quarter one color ([`quarter`]).
fn quarters(s: &mut Session) -> NodeId {
let img = image::RgbaImage::from_fn(40, 40, |x, y| {
let [r, g, b] = quarter(x as f64 / 40.0, y as f64 / 40.0);
image::Rgba([r, g, b, 255])
});
let mut png = vec![];
img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
s.edit("Place", |d, sel| {
d.images.insert("quarters".into(), vectorcraft_doc::ImageBlob::png(png));
let id = d.alloc_id();
let xf = Affine::translate((FRAME.x0, FRAME.y0)) * Affine::scale(2.0);
let im = vectorcraft_doc::ImageObject {
key: "quarters".into(),
width: 40,
height: 40,
xf,
link: None,
placement: Default::default(),
pixels: None,
};
d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
sel.set([id]);
Ok(id)
})
.unwrap()
}
/// Where an Arc warp bending `bend` % takes the point at (u, v) of [`FRAME`].
fn arced(bend: f64, u: f64, v: f64) -> Point {
let net = WarpNet::new(WarpStyle::Arc, bend / 100.0, 0.0, 0.0, FRAME.width(), FRAME.height(), false);
FRAME.origin() + net.at(u, v).to_vec2()
}
/// Points of the image's box: near each quarter's middle and on both sides of the line between
/// the top and bottom quarters, where a warp that moves the pixels up or down changes the color.
const SAMPLES: [(f64, f64); 10] =
[(0.2, 0.2), (0.8, 0.2), (0.2, 0.8), (0.8, 0.8), (0.4, 0.4), (0.6, 0.4), (0.4, 0.6), (0.6, 0.6), (0.3, 0.62), (0.7, 0.62)];
/// The document drawn over (0, 0)–(400, 400) at one pixel a point, on white.
fn drawn(s: &Session) -> vectorcraft_render::Rendered {
vectorcraft_render::Renderer::new().render_region(&s.doc().unwrap().doc, Rect::new(0.0, 0.0, 400.0, 400.0), 1.0, true)
}
/// The sample points whose color in `img` at `at(u, v)` is not the image's color at (u, v).
fn wrong(img: &vectorcraft_render::Rendered, at: &dyn Fn(f64, f64) -> Point) -> Vec<(f64, f64, [u8; 4])> {
SAMPLES
.iter()
.filter_map(|&(u, v)| {
let p = at(u, v);
let px = img.pixel(p.x.floor() as u32, p.y.floor() as u32);
let want = quarter(u, v);
let near = (0..3).all(|i| (px[i] as i32 - want[i] as i32).abs() <= 40);
(!near).then_some((u, v, px))
})
.collect()
}
/// `quarters` with Effect › Warp › Arc at 50 %: the warp the effect holds, checked to be the
/// Bézier patch [`arced`] follows.
fn arc_image(s: &mut Session) -> NodeId {
let id = quarters(s);
s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"bend": 50}})).unwrap();
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
let e = &n.appearance.effects[0];
assert!(warp_version(&e.params["version"]).is_some_and(uses_net), "{}", e.params);
id
}
fn decoded(v: &Value) -> Vec<u8> {
vectorcraft_format::base64_decode(v["dataBase64"].as_str().unwrap()).unwrap()
}
#[test]
fn an_images_pixels_bend_with_effect_warp() {
let mut s = session();
let id = arc_image(&mut s);
// The arc lifts the middle of the image: the line between the quarters rises there.
assert!(arced(50.0, 0.5, 0.6).y < FRAME.y0 + 0.5 * FRAME.height(), "{:?}", arced(50.0, 0.5, 0.6));
let bent = drawn(&s);
assert_eq!(wrong(&bent, &|u, v| arced(50.0, u, v)), vec![], "each pixel is drawn where the warp takes it");
// Drawn as pieces of the one image, each placed by the warp.
let d = &s.doc().unwrap().doc;
let art = vectorcraft_render::effects::reshape(Some(d), d.node(id).unwrap(), None).unwrap();
let mut pieces = 0;
art.walk(&mut |c| pieces += matches!(c.kind, NodeKind::Image(_)) as usize);
assert!(pieces >= 100, "{pieces} pieces");
// Removing the warp draws the image as it was, in one undo step.
let steps = s.doc().unwrap().history.undo.len();
s.execute("effect.remove", &json!({"index": 0})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
let plain = |u: f64, v: f64| Point::new(FRAME.x0 + u * FRAME.width(), FRAME.y0 + v * FRAME.height());
assert_eq!(wrong(&drawn(&s), &plain), vec![]);
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![], "undo brings the bend back");
}
/// `out`, an export of [`arc_image`]'s document named `name`, opened again: it draws the image
/// bent.
fn opens_bent(name: &str, out: &Value) {
let mut back = session();
back.execute("document.open", &json!({"name": name, "dataBase64": out["dataBase64"]})).unwrap();
assert_eq!(wrong(&drawn(&back), &|u, v| arced(50.0, u, v)), vec![], "{name}");
}
#[test]
fn a_warped_image_keeps_its_bend_in_svg() {
let mut s = session();
arc_image(&mut s);
let svg = s.execute("document.export", &json!({"format": "svg"})).unwrap();
let text = String::from_utf8(decoded(&svg)).unwrap();
assert_eq!(text.matches("<image").count(), 1, "the pieces share the image's pixels");
opens_bent("warped.svg", &svg);
}
#[test]
fn a_warped_image_keeps_its_bend_in_pdf() {
let mut s = session();
arc_image(&mut s);
opens_bent("warped.pdf", &s.execute("document.export", &json!({"format": "pdf", "preserveEditing": false})).unwrap());
}
#[test]
fn a_warped_image_keeps_its_bend_in_ai() {
let mut s = session();
arc_image(&mut s);
opens_bent("warped.ai", &s.execute("file.saveCopy", &json!({"format": "ai"})).unwrap());
}
#[test]
fn a_warped_image_keeps_its_bend_in_eps() {
let mut s = session();
arc_image(&mut s);
opens_bent("warped.eps", &s.execute("document.exportEps", &json!({"previewFormat": "none", "useArtboards": false})).unwrap());
}
#[test]
fn a_warped_image_keeps_its_bend_in_png() {
let mut s = session();
arc_image(&mut s);
let out = s.execute("document.export", &json!({"format": "png"})).unwrap();
let png = image::load_from_memory(&decoded(&out)).unwrap().to_rgba8();
// The artboard starts at (0, 0) and the export draws one pixel a point.
assert_eq!((png.width(), png.height()), (800, 600));
for &(u, v) in &SAMPLES {
let p = arced(50.0, u, v);
let px = png.get_pixel(p.x.floor() as u32, p.y.floor() as u32).0;
let want = quarter(u, v);
assert!((0..3).all(|i| (px[i] as i32 - want[i] as i32).abs() <= 40), "({u}, {v}) at {p:?}: {px:?}");
}
}
/// A group the user made of two clip groups of the same image, each clipped by a rectangle, writes
/// the image once for each: only the pieces of a warp share one.
#[test]
fn svg_writes_an_image_clipped_twice_in_a_users_group_twice() {
let mut s = session();
let im = quarters(&mut s);
s.edit("Clip twice", |d, _| {
let image = d.node(im).cloned().unwrap();
let mut clipped = vec![];
for x in [FRAME.x0, FRAME.x0 + 40.0] {
let mut clip =
Node::path(d.alloc_id(), vectorcraft_geom::shapes::rectangle(Rect::new(x, FRAME.y0, x + 30.0, FRAME.y0 + 30.0)), Default::default());
if let NodeKind::Path { clipping, .. } = &mut clip.kind {
*clipping = true;
}
let image = Node { id: d.alloc_id(), ..image.clone() };
let children = vec![std::sync::Arc::new(clip), std::sync::Arc::new(image)];
clipped.push(std::sync::Arc::new(Node::new(d.alloc_id(), NodeKind::Group { children, clip: true })));
}
let group = Node::group(d.alloc_id(), clipped);
d.remove(im)?;
d.insert(d.default_layer(), 0, group)?;
Ok(())
})
.unwrap();
let svg = s.execute("document.export", &json!({"format": "svg"})).unwrap();
let text = String::from_utf8(decoded(&svg)).unwrap();
assert_eq!(text.matches("<image").count(), 2, "{text}");
}
/// Expand Appearance of a warped image gives objects that draw as the canvas did, with ids of
/// their own, in one undo step.
#[test]
fn expand_appearance_of_a_warped_image_draws_as_the_canvas_did() {
let mut s = session();
let id = arc_image(&mut s);
let steps = s.doc().unwrap().history.undo.len();
s.execute("effect.expandAppearance", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
let d = &s.doc().unwrap().doc;
let mut ids = std::collections::HashSet::new();
let mut images = 0;
for layer in &d.layers {
layer.walk(&mut |c| {
assert!(ids.insert(c.id), "{:?} twice", c.id);
images += matches!(c.kind, NodeKind::Image(_)) as usize;
assert!(c.appearance.effects.iter().all(|e| !e.id.starts_with("warp.")));
});
}
assert!(images >= 100, "{images} pieces");
assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![]);
s.execute("edit.undo", &json!({})).unwrap();
let n = s.doc().unwrap().doc.node(id).unwrap();
assert!(matches!(n.kind, NodeKind::Image(_)) && n.appearance.effects.len() == 1);
assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![]);
}
/// A selected embedded grayscale 40×40 px image filling [`FRAME`], black above white, colorized
/// red by its fill color: red above, nothing below.
fn red_on_clear(s: &mut Session) -> NodeId {
let img = image::GrayImage::from_fn(40, 40, |_, y| image::Luma([if y < 20 { 0 } else { 255 }]));
let mut png = vec![];
image::DynamicImage::ImageLuma8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
let id = s
.edit("Place", |d, sel| {
d.images.insert("gray".into(), vectorcraft_doc::ImageBlob::png(png));
let id = d.alloc_id();
let xf = Affine::translate((FRAME.x0, FRAME.y0)) * Affine::scale(2.0);
let im = vectorcraft_doc::ImageObject {
key: "gray".into(),
width: 40,
height: 40,
xf,
link: None,
placement: Default::default(),
pixels: None,
};
d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
sel.set([id]);
Ok(id)
})
.unwrap();
s.execute("paint.setFill", &json!({"color": "#ff0000", "ids": [id.0]})).unwrap();
id
}
#[test]
fn a_colorized_image_keeps_its_color_when_warped() {
let mut s = session();
red_on_clear(&mut s);
s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"bend": 50}})).unwrap();
let img = drawn(&s);
let (red, white) = ([255u8, 0, 0], [255u8, 255, 255]);
for (u, v, want) in [(0.5, 0.35, red), (0.2, 0.2, red), (0.5, 0.65, white), (0.8, 0.8, white)] {
let p = arced(50.0, u, v);
let px = img.pixel(p.x.floor() as u32, p.y.floor() as u32);
assert!((0..3).all(|i| (px[i] as i32 - want[i] as i32).abs() <= 40), "({u}, {v}) at {p:?}: {px:?}");
}
}
#[test]
fn a_warp_on_a_group_bends_the_image_in_it() {
let mut s = session();
let im = quarters(&mut s);
// A group of the image and a line below it as wide as the image: the group's box is the image's.
let line = s.execute("shape.line", &json!({"x1": FRAME.x0, "y1": FRAME.y1, "x2": FRAME.x1, "y2": FRAME.y1})).unwrap();
let line = NodeId(line["id"].as_u64().unwrap());
s.execute("select.set", &json!({"ids": [im.0, line.0]})).unwrap();
s.execute("object.group", &json!({})).unwrap();
s.execute("effect.apply", &json!({"effect": "warp.arc", "params": {"bend": 50}})).unwrap();
assert_eq!(wrong(&drawn(&s), &|u, v| arced(50.0, u, v)), vec![]);
}
+7
View File
@@ -71,6 +71,13 @@ fn a_found_font_is_copied_without_replacing_a_file_and_its_type_redraws() {
assert!(st.revision > revision && !st.is_dirty());
assert_eq!(s.execute("text.missingFonts", &json!({})).unwrap()["count"], 0);
// A caller whose read roots hold the file but not the Fonts folder: the file is kept, and the
// reply names the copy by its file name only, without the folder.
let downloads = vectorcraft_engine::file_access::AutomationRoots::new(&[&root.join("Downloads")], &[]).unwrap();
let r = vectorcraft_engine::file_access::confine(downloads.as_ref(), || s.execute("text.addFontFiles", &json!({"files": [file]}))).unwrap();
assert_eq!((&r["folder"], &r["kept"]), (&Value::Null, &json!([{"from": file, "to": "Findme 2.otf"}])), "{r}");
assert!(!r.to_string().contains("App Fonts"), "{r}");
// The same file again is kept, not copied a third time.
let r = s.execute("text.addFontFiles", &json!({"files": [file]})).unwrap();
assert_eq!((r["copied"].clone(), r["kept"].clone()), (json!([]), json!([{"from": file, "to": fonts.join("Findme 2.otf")}])), "{r}");
+4 -1
View File
@@ -2682,7 +2682,10 @@ fn arb_ps_token() -> impl Strategy<Value = String> {
// Local VM restored: dictionary changes undone, saves restored twice.
"/a 1 def save /a 2 def", "restore", "save dup restore", "1 dict save exch /k 1 put", "cachestatus", "/n 0 def save /n n 1 add store",
// Executable strings and keys other than names (PLRM 3rd ed., `cvx`, `load`).
"(>>) cvx", "(1 2 add) cvx exec", "(x) cvx dup exec", "0 load", "1 { } def", "(mark) cvx cvlit"
"(>>) cvx", "(1 2 add) cvx exec", "(x) cvx dup exec", "0 load", "1 { } def", "(mark) cvx cvlit",
// CID-keyed fonts found by name over predefined CMaps, horizontal and vertical.
"/Ryumin-Light-90ms-RKSJ-H", "/Ryumin-Light-EUC-V", "/Ryumin-Light-H", "/GBT-EUC-H", "/KSCms-UHC-V", "/UniJIS-UTF16-V",
"[/Ryumin-Light]", "composefont", "<93fa967b8540fd0d41>", "<c7d1a4a4467c>"
])
.prop_map(str::to_string),
]
+18
View File
@@ -6668,6 +6668,7 @@ fn every_effect_a_graphic_style_holds_is_read_back() {
for id in &ids {
cases.push((id, json!({"bend": 30.0, "horizontal": -10.0, "vertical": 20.0, "orientation": "vertical"})));
cases.push((id, json!({"bend": -30.0, "horizontal": 0.0, "vertical": 0.0, "orientation": "horizontal"})));
cases.push((id, json!({"bend": 45.0, "horizontal": 15.0, "vertical": -5.0, "orientation": "horizontal", "version": 1})));
}
for (id, params) in cases {
let effect = fx(id, params.clone());
@@ -6684,6 +6685,10 @@ fn every_effect_a_graphic_style_holds_is_read_back() {
let got = &back.graphic_styles[0].appearance.effects;
assert_eq!(got.len(), 1, "{id} {params}");
assert_eq!(got[0].id, effect.id);
// A warp read from a file bends as its style's Bézier net.
if id.starts_with("warp.") {
assert_eq!(got[0].params["version"], json!(vectorcraft_doc::live::WARP_NET), "{id} {params}");
}
let (g, w) = (vectorcraft_effects::merged_params(&got[0].id, &got[0].params), vectorcraft_effects::merged_params(&effect.id, &effect.params));
for (key, value) in w.as_object().unwrap() {
// Random isn't written, and a style with it isn't read; its seed is the default.
@@ -6704,6 +6709,19 @@ fn every_effect_a_graphic_style_holds_is_read_back() {
}
}
}
// A warp saved before the map version existed is written with its settings too, and reads back on
// the nets' map.
let old = vectorcraft_doc::Effect { id: "warp.flag".into(), params: json!({"bend": 40.0, "horizontal": 10.0}), visible: true };
let mut doc = Document::new(200.0, 100.0);
let mut g = vectorcraft_doc::GraphicStyle::new("Old", Appearance { effects: vec![old], ..Appearance::basic(black_fill(), Paint::None, 0.0) });
g.id = 3;
*doc.graphic_styles = vec![g];
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::PANEL_STYLES), "{:?}", out.warnings);
let back = read_back(&doc);
let [warp] = back.graphic_styles[0].appearance.effects.as_slice() else { panic!("{:?}", back.graphic_styles) };
assert_eq!((warp.id.as_str(), &warp.params["bend"], &warp.params["horizontal"]), ("warp.flag", &json!(40.0), &json!(10.0)));
assert_eq!(warp.params["version"], json!(vectorcraft_doc::live::WARP_NET));
// A Zig Zag with its 0 to 1 settings written under the size's own key, and a turn in radians.
let mut doc = Document::new(200.0, 100.0);
let effects = vec![
+8 -1
View File
@@ -889,9 +889,16 @@ pub(in crate::ai_editing) fn same_appearance(a: &Appearance, b: &Appearance) ->
}
/// Effect `e`'s settings with its defaults filled in, its blending mode in lower case and its color as
/// `#rrggbb`.
/// `#rrggbb`. A Warp's map `version` is left out: the file holds the warp's settings, and the reader
/// gives every warp it reads the newest map, so a warp saved before the version existed is written
/// with its settings as before.
fn normalized_params(e: &Effect) -> Value {
let mut p = vectorcraft_effects::merged_params(&e.id, &e.params);
if e.id.starts_with("warp.")
&& let Value::Object(m) = &mut p
{
m.remove("version");
}
if let Some(m) = word(&p, "mode") {
p["mode"] = Value::String(m);
}
+1
View File
@@ -42,6 +42,7 @@ mod interp;
mod lex;
mod native;
mod obj;
mod predefined_cmap;
mod preview;
mod shading;
mod text;
+1
View File
@@ -244,6 +244,7 @@ fn warp(o: &Obj) -> Option<EnvelopeKind> {
h: percent("DeformHoriz")?,
v: percent("DeformVert")?,
horizontal: !vertical,
version: vectorcraft_doc::live::WARP_NET,
})
}
+2 -276
View File
@@ -14,12 +14,12 @@
use std::sync::Arc;
use craft_pdf::interpret::hayro_cmap::{BfString, CMap, CMapName, load_embedded};
use kurbo::{Affine, BezPath, ParamCurve, ParamCurveArclen};
use vectorcraft_color::Paint;
use vectorcraft_doc::{Burasagari, CharStyle, Justify, NodeKind, ParaStyle, TabAlign, TabStop, TextKind, TextObject, TextRun};
use vectorcraft_geom::AnchorKind;
use super::super::super::predefined_cmap::{self, CMapCodes, composite_font};
use super::super::obj::V;
use super::art::path_data;
use super::{FLIP, GState, HashSet, Kind, Node, NodeId, Reader};
@@ -284,259 +284,15 @@ impl TypeState {
/// How strings in a font with predefined CMap `cmap` decode; `None` when the CMap can't be read.
fn cmap_codes(&mut self, cmap: &str) -> Option<Arc<CMapCodes>> {
if let Some(form) = unicode_cmap(cmap) {
return Some(Arc::new(CMapCodes::Unicode(form)));
}
if let Some((_, codes)) = self.cmaps.iter().find(|(n, _)| n == cmap) {
return codes.clone();
}
let codes = cid_codes(cmap).map(Arc::new);
let codes = predefined_cmap::codes(cmap).map(Arc::new);
self.cmaps.push((cmap.to_string(), codes.clone()));
codes
}
}
/// How a composite font's strings decode.
#[derive(Debug)]
enum CMapCodes {
/// By a predefined CMap's codes to CIDs, then by its character collection's CID → Unicode CMap;
/// with `high_bit`, each byte 0x21 to 0x7E gets its high bit set first. `space` is the CMap's
/// code space ([`code_space`]).
Cids { codes: Box<CMap>, unicode: Box<CMap>, high_bit: bool, space: Option<CodeSpace> },
/// A predefined Unicode CMap: the codes are the characters.
Unicode(Unicode),
}
/// A CMap's code space: ranges of codes, each given by its lowest and highest code, both with the
/// code's length in bytes.
type CodeSpace = &'static [(&'static [u8], &'static [u8])];
/// What control byte `b` is in a composite font's string: `\r` a paragraph break, `\t` a tab.
fn control(b: u8) -> Option<char> {
match b {
b'\r' => Some('\n'),
b'\t' => Some('\t'),
_ => None,
}
}
impl CMapCodes {
/// The characters of string `bytes`, leaving out codes the CMaps don't map; a `\r` is a
/// paragraph break and a `\t` a tab (also as a byte left over after the last whole code of a
/// UTF-16 or UTF-32 string).
fn decode(&self, bytes: &[u8]) -> String {
let (codes, unicode, high_bit, space) = match self {
Self::Unicode(form) => {
let unit = match form {
Unicode::Utf16 => 2,
Unicode::Utf8 => 1,
Unicode::Utf32 => 4,
};
let (whole, rest) = bytes.split_at_checked(bytes.len() - bytes.len() % unit).unwrap_or((bytes, &[]));
let mut text = unicode_text(whole, *form).replace('\r', "\n");
text.extend(rest.last().copied().and_then(control));
return text;
}
Self::Cids { codes, unicode, high_bit, space } => (codes, unicode, *high_bit, space),
};
let euc: Vec<u8>;
let bytes = if high_bit {
euc = bytes.iter().map(|&b| if (0x21..0x7f).contains(&b) { b | 0x80 } else { b }).collect();
euc.as_slice()
} else {
bytes
};
let mut out = String::new();
let mut at = 0;
while let Some(&first) = bytes.get(at) {
// VectorCraft reads a 0x0D byte as a paragraph break and a 0x09 byte as a tab in every
// CMap, as in other fonts' strings, including the row-and-cell CMaps, whose code space
// has no one-byte codes.
if let Some(control) = control(first) {
out.push(control);
at += 1;
continue;
}
let rest = bytes.get(at..).unwrap_or_default();
let code = |len: u8| rest.get(..usize::from(len)).map(|b| b.iter().fold(0u32, |c, &b| c << 8 | u32::from(b)));
let found = match space {
// The code is as long as the code space range it falls in; a byte that starts no
// code in the code space is skipped.
Some(space) => {
let Some(len) = code_len(space, rest) else {
at += 1;
continue;
};
code(len).map(|c| (len, codes.lookup_cid_code(c, len)))
}
None => (1..=4u8).find_map(|len| Some((len, Some(codes.lookup_cid_code(code(len)?, len)?)))),
};
let Some((len, cid)) = found else {
at += 1;
continue;
};
at += usize::from(len);
// A code the CMap leaves out is dropped.
let Some(cid) = cid else { continue };
match unicode.lookup_bf_string(cid) {
// A one-byte Roman code whose CID the table gives as a combining mark alone (0x7E in
// the Mac Shift-JIS CMaps, U+0303): the ASCII character, as Adobe's cid2code.txt lists first.
Some(BfString::Char('\u{300}'..='\u{36f}')) if len == 1 && (0x20..0x7f).contains(&first) => out.push(char::from(first)),
Some(BfString::Char(c)) if c != char::REPLACEMENT_CHARACTER => out.push(c),
Some(BfString::String(s)) => out.extend(s.chars().filter(|c| *c != char::REPLACEMENT_CHARACTER)),
_ => {}
}
}
out
}
}
/// How a predefined Unicode CMap's codes encode their characters.
#[derive(Clone, Copy, PartialEq, Debug)]
enum Unicode {
/// Two bytes a character (`UCS2`) or a UTF-16 surrogate pair, the high byte first.
Utf16,
Utf8,
/// Four bytes, the high byte first.
Utf32,
}
/// The encoding of predefined Unicode CMap `name`: `Uni` and a character collection, then `-UCS2`,
/// `-UTF8`, `-UTF16` or `-UTF32` (and `-HW` for half-width forms), then `-H` or `-V`
/// (`UniJIS-UCS2-H`, `UniGB-UTF16-V`: <https://github.com/adobe-type-tools/cmap-resources>).
fn unicode_cmap(name: &str) -> Option<Unicode> {
let rest = name.strip_suffix("-H").or_else(|| name.strip_suffix("-V"))?;
let rest = rest.strip_suffix("-HW").unwrap_or(rest);
let (collection, form) = rest.rsplit_once('-')?;
let collections = ["UniJIS", "UniJISPro", "UniJIS2004", "UniJISX0213", "UniJISX02132004", "UniHojo", "UniGB", "UniCNS", "UniKS", "UniAKR"];
if !collections.contains(&collection) {
return None;
}
match form {
"UCS2" | "UTF16" => Some(Unicode::Utf16),
"UTF8" => Some(Unicode::Utf8),
"UTF32" => Some(Unicode::Utf32),
_ => None,
}
}
/// The characters string `s` encodes in Unicode form `form` (invalid codes left out).
fn unicode_text(s: &[u8], form: Unicode) -> String {
match form {
Unicode::Utf16 => {
let units = s.as_chunks::<2>().0.iter().map(|b| u16::from_be_bytes(*b));
char::decode_utf16(units).filter_map(Result::ok).collect()
}
Unicode::Utf8 => s.utf8_chunks().map(|chunk| chunk.valid()).collect(),
Unicode::Utf32 => s.as_chunks::<4>().0.iter().filter_map(|b| char::from_u32(u32::from_be_bytes(*b))).collect(),
}
}
/// Predefined CMap `name` among those VectorCraft carries, leaving out the Identity CMaps, whose
/// codes are CIDs of no known character collection.
fn predefined(name: &str) -> Option<CMapName<'_>> {
match CMapName::from_bytes(name.as_bytes()) {
CMapName::Custom(_) | CMapName::IdentityH | CMapName::IdentityV => None,
name => Some(name),
}
}
/// Adobe's predefined CMaps that VectorCraft doesn't carry, by name without `-H` or `-V`
/// (<https://github.com/adobe-type-tools/cmap-resources>): the nearest carried CMap with the same
/// code space, and whether each byte of a row-and-cell code gets its high bit set first (the EUC
/// form of the same code; `GB-H`, `CNS1-H` and `KSC-H` have no one-byte codes, their code space
/// is `<2121>` to `<7E7E>`); `None` for those no carried CMap reads.
fn stand_in(stem: &str) -> Option<Option<(&'static str, bool)>> {
Some(match stem {
"RKSJ" | "78-RKSJ" | "78ms-RKSJ" => Some(("90ms-RKSJ-H", false)),
"78-EUC" => Some(("EUC-H", false)),
"78" | "Add" | "Ext" | "NWP" => Some(("H", false)),
"GB" => Some(("GB-EUC-H", true)),
"CNS1" => Some(("CNS-EUC-H", true)),
"KSC" => Some(("KSC-EUC-H", true)),
"B5" => Some(("ETen-B5-H", false)),
"ETHK-B5" | "HKdla-B5" | "HKdlb-B5" | "HKgccs-B5" | "HKm314-B5" | "HKm471-B5" => Some(("HKscs-B5-H", false)),
"GBT" | "GBT-EUC" | "GBTpc-EUC" | "CNS2" | "KSC-Johab" => None,
_ => return None,
})
}
/// Predefined CMap `cmap`'s codes to CIDs, and its character collection's CID → Unicode CMap. A
/// vertical CMap's codes are read with its horizontal CMap when VectorCraft carries that: the two
/// differ only in the CIDs of vertical glyph forms. A CMap VectorCraft doesn't carry is read with
/// its [`stand_in`].
fn cid_codes(cmap: &str) -> Option<CMapCodes> {
let read = |name: &str| CMap::parse(load_embedded(predefined(name)?)?, load_embedded);
let horizontal = cmap.strip_suffix('V').map(|stem| format!("{stem}H"));
let stem = cmap.strip_suffix("-H").or_else(|| cmap.strip_suffix("-V"));
let (codes, high_bit) = horizontal.iter().map(String::as_str).chain([cmap]).find_map(|n| Some((read(n)?, false))).or_else(|| {
let (name, high_bit) = stand_in(stem?).flatten()?;
Some((read(name)?, high_bit))
})?;
let table = codes.metadata().character_collection.as_ref()?.family.ucs2_cmap()?;
let unicode = CMap::parse(load_embedded(table)?, load_embedded)?;
// A row-and-cell code read in its EUC form falls in the EUC CMap's code space.
let space = if high_bit { stand_in(stem?).flatten().and_then(|(name, _)| code_space(name)) } else { code_space(cmap) };
Some(CMapCodes::Cids { codes: Box::new(codes), unicode: Box::new(unicode), high_bit, space })
}
/// The code space of predefined CMap `cmap`, as Adobe's CMap files give it
/// (<https://github.com/adobe-type-tools/cmap-resources>); a CMap's vertical form has its
/// horizontal form's. `None` for a CMap not listed here.
fn code_space(cmap: &str) -> Option<CodeSpace> {
const RKSJ: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa0", b"\xdf"), (b"\x81\x40", b"\x9f\xfc"), (b"\xe0\x40", b"\xfc\xfc")];
const RKSJ_MAC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa0", b"\xdf"), (b"\xfd", b"\xff"), (b"\x81\x40", b"\x9f\xfc"), (b"\xe0\x40", b"\xfc\xfc")];
const EUC_JP: CodeSpace = &[(b"\x00", b"\x80"), (b"\x8e\xa0", b"\x8e\xdf"), (b"\xa1\xa1", b"\xfe\xfe")];
const ROW_CELL: CodeSpace = &[(b"\x21\x21", b"\x7e\x7e")];
const EUC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa1\xa1", b"\xfe\xfe")];
const GB_PC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xfd", b"\xff"), (b"\xa1\xa1", b"\xfc\xfe")];
const GBK: CodeSpace = &[(b"\x00", b"\x80"), (b"\x81\x40", b"\xfe\xfe")];
const GBK2K: CodeSpace = &[(b"\x00", b"\x7f"), (b"\x81\x40", b"\xfe\xfe"), (b"\x81\x30\x81\x30", b"\xfe\x39\xfe\x39")];
const B5_PC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xfd", b"\xff"), (b"\xa1\x40", b"\xfc\xfe")];
const B5: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa1\x40", b"\xfe\xfe")];
const HKSCS: CodeSpace = &[(b"\x00", b"\x80"), (b"\x87\x40", b"\xfe\xfe")];
const HKDLB: CodeSpace = &[(b"\x00", b"\x80"), (b"\x8e\x40", b"\xfe\xfe")];
const HKGCCS: CodeSpace = &[(b"\x00", b"\x80"), (b"\x8a\x40", b"\xfe\xfe")];
const CNS_EUC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa1\xa1", b"\xfe\xfe"), (b"\x8e\xa1\xa1\xa1", b"\x8e\xa3\xfe\xfe")];
const KSC_PC: CodeSpace = &[(b"\x00", b"\x84"), (b"\xfe", b"\xff"), (b"\xa1\x41", b"\xfd\xfe")];
const UHC: CodeSpace = &[(b"\x00", b"\x80"), (b"\x81\x41", b"\xfe\xfe")];
let stem = match cmap {
"H" | "V" => "",
_ => cmap.strip_suffix("-H").or_else(|| cmap.strip_suffix("-V"))?,
};
let stem = stem.strip_suffix("-HW").unwrap_or(stem);
Some(match stem {
"83pv-RKSJ" | "90pv-RKSJ" => RKSJ_MAC,
_ if stem.ends_with("RKSJ") => RKSJ,
"EUC" | "78-EUC" => EUC_JP,
"" | "78" | "Add" | "Ext" | "NWP" => ROW_CELL,
"GB-EUC" | "GBT-EUC" | "KSC-EUC" => EUC,
"GBpc-EUC" | "GBTpc-EUC" => GB_PC,
"GBK-EUC" | "GBKp-EUC" => GBK,
"GBK2K" => GBK2K,
"B5pc" => B5_PC,
"B5" | "ETen-B5" | "ETenms-B5" | "HKdla-B5" | "HKm314-B5" | "HKm471-B5" => B5,
"HKscs-B5" | "ETHK-B5" => HKSCS,
"HKdlb-B5" => HKDLB,
"HKgccs-B5" => HKGCCS,
"CNS-EUC" => CNS_EUC,
"KSCpc-EUC" => KSC_PC,
"KSCms-UHC" => UHC,
_ => return None,
})
}
/// The length of the code string `bytes` starts with: the length of the code space range whose
/// lowest and highest codes hold each of its bytes between them. `None` when no range does.
fn code_len(space: CodeSpace, bytes: &[u8]) -> Option<u8> {
space
.iter()
.filter(|(lo, hi)| bytes.get(..lo.len()).is_some_and(|b| b.iter().zip(lo.iter().zip(hi.iter())).all(|(b, (lo, hi))| (lo..=hi).contains(&b))))
.map(|(lo, _)| lo.len())
.min()
.and_then(|len| u8::try_from(len).ok())
}
/// Encoding pairs (§3.3.1): codes, each followed by the glyph names from it on, into `table`.
fn encoding_pairs(table: &mut [Option<char>], vals: &[V]) {
let mut code: Option<usize> = None;
@@ -556,36 +312,6 @@ fn encoding_pairs(table: &mut [Option<char>], vals: &[V]) {
}
}
/// A composite font's name `base-CMap`: the base font's name and its CMap's name, when that is a
/// predefined Unicode CMap ([`unicode_cmap`]), one of the predefined CMaps VectorCraft carries
/// ([`predefined`]) or one of the others ([`stand_in`]), in its horizontal (`-H`) or vertical
/// (`-V`) form. A name ending in an Identity CMap is not read as one, nor is one that ends in an
/// unknown CMap name with an encoding part (`UniFoo-UTF8-H`), which would otherwise end in `H`.
fn composite_font(name: &str) -> Option<(&str, &str)> {
if !(name.ends_with("-H") || name.ends_with("-V")) {
return None;
}
// The longest CMap name first: `83pv-RKSJ-H` before `H`.
// No predefined CMap name is longer than 32 bytes.
for (at, _) in name.match_indices('-').filter(|(at, _)| name.len() - at <= 33) {
let (Some(base), Some(cmap)) = (name.get(..at).filter(|b| !b.is_empty()), name.get(at + 1..)) else { continue };
if matches!(cmap, "Identity-H" | "Identity-V") {
return None;
}
let encoding_part =
base.rsplit('-').next().is_some_and(|part| ["UCS2", "UTF8", "UTF16", "UTF32", "HW", "EUC", "RKSJ", "B5", "UHC", "Johab"].contains(&part));
if matches!(cmap, "H" | "V") && encoding_part {
return None;
}
let vertical_of_predefined = || cmap.strip_suffix('V').is_some_and(|stem| predefined(&format!("{stem}H")).is_some());
let other = || cmap.strip_suffix("-H").or_else(|| cmap.strip_suffix("-V")).is_some_and(|stem| stand_in(stem).is_some());
if unicode_cmap(cmap).is_some() || predefined(cmap).is_some() || vertical_of_predefined() || other() {
return Some((base, cmap));
}
}
None
}
/// An operator's `N` operands, the last `N` values before it, when each is a finite number.
fn nums<const N: usize>(vals: &[V]) -> Option<[f64; N]> {
let operands = vals.get(vals.len().checked_sub(N)?..)?;
+1 -1
View File
@@ -1259,7 +1259,7 @@ mod tests {
fn envelopes_in_symbol_definitions_spend_the_imports_checks() {
use crate::import::ai::tests::{drawn_content, envelope_content, envelope_of, straight_mesh, warp_keys};
use vectorcraft_doc::live::EnvelopeKind;
let want = EnvelopeKind::Warp { style: "arc".into(), bend: 50.0, h: 0.0, v: 0.0, horizontal: true };
let want = EnvelopeKind::Warp { style: "arc".into(), bend: 50.0, h: 0.0, v: 0.0, horizontal: true, version: vectorcraft_doc::live::WARP_NET };
let envelope =
envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &warp_keys(1, 0.5, 0.0, 0.0, 0), &envelope_content(), 1, &drawn_content(&want));
let mut reader = Reader::new(b"");
+1
View File
@@ -1159,6 +1159,7 @@ fn effect(f: &Filter, under: Under) -> Option<Effect> {
"horizontal": pct("DeformHoriz"),
"vertical": pct("DeformVert"),
"orientation": if flag("Rotate") { "vertical" } else { "horizontal" },
"version": vectorcraft_doc::live::WARP_NET,
}),
)
}
+2
View File
@@ -495,6 +495,8 @@ fn a_stack_of_fills_with_effects_of_their_own_is_read_as_itself() {
// The warp is the whole object's; the characters paint below every item.
let [warp] = st.effects.as_slice() else { panic!("{:?}", st.effects) };
assert_eq!((warp.id.as_str(), &warp.params["bend"], &warp.params["orientation"]), ("warp.arch", &json!(5.0), &json!("horizontal")));
// A file's warp bends as its style's Bézier net.
assert_eq!(warp.params["version"], json!(vectorcraft_doc::live::WARP_NET));
assert_eq!(st.contents_index, None);
}
+8 -6
View File
@@ -5,6 +5,7 @@ use std::sync::Arc;
use kurbo::{Affine, Point, Rect};
use vectorcraft_color::gradient::GradientKind;
use vectorcraft_color::{BlendMode, Color, Paint};
use vectorcraft_doc::live::WARP_NET;
use vectorcraft_doc::{AppearanceItem, ColorMode, Document, Guide, Knockout, LayerColor, LineCap, LineJoin, Node, NodeKind, Unit};
use super::*;
@@ -7403,15 +7404,16 @@ fn a_warp_envelope_opens_live() {
for (style, bend, h, v, rotate, id) in
[(1, 0.5, 0.0, 0.0, 0, "arc"), (1, 0.5, -0.2, 0.3, 1, "arc"), (8, 0.5, 0.0, 0.0, 0, "flag"), (15, 0.5, 0.0, 0.0, 0, "twist")]
{
let want = EnvelopeKind::Warp { style: id.into(), bend: bend * 100.0, h: h * 100.0, v: v * 100.0, horizontal: rotate == 0 };
let want =
EnvelopeKind::Warp { style: id.into(), bend: bend * 100.0, h: h * 100.0, v: v * 100.0, horizontal: rotate == 0, version: WARP_NET };
let body =
envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &warp_keys(style, bend, h, v, rotate), &envelope_content(), 1, &drawn_content(&want));
let r = read_ok(&layer(&body));
let a = art(&r.doc);
assert_eq!(a.len(), 1, "{a:#?}");
let (content, kind, fidelity, editing, options) = live_envelope(&a[0]);
let EnvelopeKind::Warp { style: s, bend: b, h: dh, v: dv, horizontal } = kind else { panic!("{kind:?}") };
assert_eq!((s.as_str(), *horizontal), (id, rotate == 0));
let EnvelopeKind::Warp { style: s, bend: b, h: dh, v: dv, horizontal, version } = kind else { panic!("{kind:?}") };
assert_eq!((s.as_str(), *horizontal, *version), (id, rotate == 0, WARP_NET));
assert!([(*b, bend), (*dh, h), (*dv, v)].iter().all(|(got, f)| (got - f * 100.0).abs() < 1e-9), "{kind:?}");
assert_eq!((fidelity, editing, options), (50.0, false, vectorcraft_doc::live::EnvelopeOptions::NEW));
assert_eq!(content.len(), 1, "{content:#?}");
@@ -7443,7 +7445,7 @@ fn warp_envelopes_read_every_style() {
"twist",
];
for (n, id) in ids.iter().enumerate() {
let want = EnvelopeKind::Warp { style: (*id).into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true };
let want = EnvelopeKind::Warp { style: (*id).into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true, version: WARP_NET };
let keys = warp_keys(n as u32 + 1, 0.3, 0.0, 0.0, 0);
let r = read_ok(&layer(&envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &keys, &envelope_content(), 1, &drawn_content(&want))));
let a = art(&r.doc);
@@ -7974,7 +7976,7 @@ fn an_envelope_that_doesnt_read_keeps_its_drawn_art() {
#[test]
fn an_envelope_that_doesnt_come_out_as_drawn_keeps_its_drawn_art() {
use vectorcraft_doc::live::EnvelopeKind;
let other = EnvelopeKind::Warp { style: "arc".into(), bend: -50.0, h: 0.0, v: 0.0, horizontal: true };
let other = EnvelopeKind::Warp { style: "arc".into(), bend: -50.0, h: 0.0, v: 0.0, horizontal: true, version: WARP_NET };
let body = envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &warp_keys(1, 0.5, 0.0, 0.0, 0), &envelope_content(), 1, &drawn_content(&other));
let r = read_ok(&layer(&body));
let a = art(&r.doc);
@@ -7989,7 +7991,7 @@ fn an_envelope_that_doesnt_come_out_as_drawn_keeps_its_drawn_art() {
fn a_white_envelope_that_doesnt_come_out_as_drawn_keeps_its_drawn_art() {
use vectorcraft_doc::live::EnvelopeKind;
const WHITE: &str = "0 0 0 0 1 1 1 Xa\n";
let other = EnvelopeKind::Warp { style: "arc".into(), bend: -50.0, h: 0.0, v: 0.0, horizontal: true };
let other = EnvelopeKind::Warp { style: "arc".into(), bend: -50.0, h: 0.0, v: 0.0, horizontal: true, version: WARP_NET };
let content = envelope_content().replace(RED, WHITE);
let drawn = drawn_content(&other).replace(RED, WHITE);
let body = envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &warp_keys(1, 0.5, 0.0, 0.0, 0), &content, 1, &drawn);
+8 -24
View File
@@ -18,6 +18,7 @@ use vectorcraft_geom::BezPath;
use super::interp::{Interp, matrix_obj};
use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
use super::predefined_cmap::Unicode;
/// Most codespace ranges, character and notdef mappings a CMap may hold.
const MAX_RANGES: usize = 1 << 16;
@@ -210,16 +211,6 @@ fn number(data: &[u8], at: usize, n: usize) -> Option<u64> {
(n <= 8).then(|| bytes.iter().fold(0u64, |v, b| v << 8 | u64::from(*b)))
}
/// How a predefined Unicode CMap's codes encode their characters.
#[derive(Clone, Copy, PartialEq, Debug)]
pub(super) enum Unicode {
/// Two bytes a character (`UCS2`) or a UTF-16 surrogate pair, the high byte first.
Utf16,
Utf8,
/// Four bytes, the high byte first.
Utf32,
}
/// The encoding of predefined Unicode CMap `name` and whether it is vertical: one of Adobe's
/// public CMap resources whose name says its codes are Unicode: `Uni` and a character
/// collection, then `-UCS2`, `-UTF8`, `-UTF16` or `-UTF32` (and `-HW` for half-width forms),
@@ -246,18 +237,6 @@ pub(super) fn unicode_cmap(name: &str) -> Option<(Unicode, bool)> {
Some((form, vertical))
}
/// The characters show string `s` encodes in Unicode form `form` (invalid codes left out).
pub(super) fn unicode_text(s: &[u8], form: Unicode) -> String {
match form {
Unicode::Utf16 => {
let units = s.as_chunks::<2>().0.iter().map(|b| u16::from_be_bytes(*b));
char::decode_utf16(units).filter_map(Result::ok).collect()
}
Unicode::Utf8 => String::from_utf8_lossy(s).chars().filter(|c| *c != char::REPLACEMENT_CHARACTER).collect(),
Unicode::Utf32 => s.as_chunks::<4>().0.iter().filter_map(|b| char::from_u32(u32::from_be_bytes(*b))).collect(),
}
}
/// A predefined Identity CMap: two-byte codes, each the CID of its own value; vertical for
/// `Identity-V`.
pub(super) fn identity(name: &str, vertical: bool) -> Obj {
@@ -417,8 +396,13 @@ impl Interp<'_> {
return Ok(d.clone());
}
let text = name.text().map(|t| t.to_string()).unwrap_or_default();
match unicode_cmap(&text) {
Some((_, vertical)) => {
// Another predefined CMap the file doesn't define, without its mappings: its codes are
// read by its name when type is set (see `text`).
let predefined = unicode_cmap(&text)
.map(|(_, vertical)| vertical)
.or_else(|| super::predefined_cmap::known(&text).then(|| super::predefined_cmap::vertical(&text)));
match predefined {
Some(vertical) => {
let mut d = Dict::new();
d.insert(Key::name("CMapName"), Obj::name(&text));
d.insert(Key::name("CMapType"), Obj::Int(1));
+4
View File
@@ -92,6 +92,9 @@ pub(crate) struct Interp<'a> {
pub cid_subrs: super::cid::CidSubrs,
/// The font number `usefont` gave the CMap mappings that follow.
pub cmap_font: i64,
/// The predefined CMaps type was set in so far, by name, with how their strings decode
/// (`None` when one can't be read; see `text`).
pub predefined_cmaps: Vec<(Rc<str>, Option<Rc<super::predefined_cmap::CMapCodes>>)>,
pub g: GState,
pub saved: Vec<GState>,
pub out: Out,
@@ -232,6 +235,7 @@ impl<'a> Interp<'a> {
cff: vec![],
cid_subrs: vec![],
cmap_font: 0,
predefined_cmaps: vec![],
type42_counted: HashSet::new(),
g,
saved: vec![],
+358
View File
@@ -0,0 +1,358 @@
//! Strings in fonts over Adobe's predefined CMaps (<https://github.com/adobe-type-tools/cmap-resources>)
//! read as characters: the codes of a predefined Unicode CMap are the characters; those of the
//! others map to CIDs of a character collection, whose CID → Unicode CMap gives the characters.
//! Used by legacy `.ai` type in composite fonts and by type in CID-keyed fonts found by name.
use craft_pdf::interpret::hayro_cmap::{BfString, CMap, CMapName, load_embedded};
/// How a composite font's strings decode.
#[derive(Debug)]
pub(super) enum CMapCodes {
/// By a predefined CMap's codes to CIDs, then by its character collection's CID → Unicode CMap;
/// with `high_bit`, each byte 0x21 to 0x7E gets its high bit set first. `space` is the CMap's
/// code space ([`code_space`]).
Cids { codes: Box<CMap>, unicode: Box<CMap>, high_bit: bool, space: Option<CodeSpace> },
/// A predefined Unicode CMap: the codes are the characters.
Unicode(Unicode),
}
/// A CMap's code space: ranges of codes, each given by its lowest and highest code, both with the
/// code's length in bytes.
type CodeSpace = &'static [(&'static [u8], &'static [u8])];
/// What control byte `b` is in a composite font's string: `\r` a paragraph break, `\t` a tab.
fn control(b: u8) -> Option<char> {
match b {
b'\r' => Some('\n'),
b'\t' => Some('\t'),
_ => None,
}
}
impl CMapCodes {
/// The characters of string `bytes`, leaving out codes the CMaps don't map; a `\r` is a
/// paragraph break and a `\t` a tab (also as a byte left over after the last whole code of a
/// UTF-16 or UTF-32 string).
pub(super) fn decode(&self, bytes: &[u8]) -> String {
let mut text = String::new();
self.each_code(bytes, |_, chars| text.extend(chars));
text
}
/// The codes of string `bytes`, each with its value and the characters it stands for (as
/// [`Self::decode`] reads them; none for a code the CMaps don't map, or for a byte that starts
/// no code, which counts as a code of its own).
pub(super) fn codes(&self, bytes: &[u8]) -> Decoded {
let mut out = Decoded::default();
self.each_code(bytes, |code, chars| out.push(code, chars));
out
}
/// Calls `emit` with each code of string `bytes` in turn ([`Self::codes`]): its value and the
/// characters it stands for.
fn each_code(&self, bytes: &[u8], mut emit: impl FnMut(u32, &mut dyn Iterator<Item = char>)) {
let value = |b: &[u8]| b.iter().fold(0u32, |c, &b| c << 8 | u32::from(b));
let (codes, unicode, high_bit, space) = match self {
Self::Unicode(form) => {
let unit = match form {
Unicode::Utf16 => 2,
Unicode::Utf8 => 1,
Unicode::Utf32 => 4,
};
let (whole, rest) = bytes.split_at_checked(bytes.len() - bytes.len() % unit).unwrap_or((bytes, &[]));
unicode_codes(whole, *form, |code, c| emit(value(code), &mut c.map(|c| if c == '\r' { '\n' } else { c }).into_iter()));
if let Some(&last) = rest.last() {
emit(value(rest), &mut control(last).into_iter());
}
return;
}
Self::Cids { codes, unicode, high_bit, space } => (codes, unicode, *high_bit, space),
};
// A code's value is that of the string's bytes, also where they're read in their EUC form.
let original = bytes;
let value_at = |at: usize, len: usize| original.get(at..at + len).map_or(0, value);
let euc: Vec<u8>;
let bytes = if high_bit {
euc = bytes.iter().map(|&b| if (0x21..0x7f).contains(&b) { b | 0x80 } else { b }).collect();
euc.as_slice()
} else {
bytes
};
let mut at = 0;
while let Some(&first) = bytes.get(at) {
// VectorCraft reads a 0x0D byte as a paragraph break and a 0x09 byte as a tab in every
// CMap, as in other fonts' strings, including the row-and-cell CMaps, whose code space
// has no one-byte codes.
if let Some(control) = control(first) {
emit(value_at(at, 1), &mut Some(control).into_iter());
at += 1;
continue;
}
let rest = bytes.get(at..).unwrap_or_default();
let code = |len: u8| rest.get(..usize::from(len)).map(value);
let found = match space {
// The code is as long as the code space range it falls in; a byte that starts no
// code in the code space is skipped.
Some(space) => code_len(space, rest).and_then(|len| code(len).map(|c| (len, codes.lookup_cid_code(c, len)))),
None => (1..=4u8).find_map(|len| Some((len, Some(codes.lookup_cid_code(code(len)?, len)?)))),
};
let Some((len, cid)) = found else {
emit(value_at(at, 1), &mut None.into_iter());
at += 1;
continue;
};
let value = value_at(at, usize::from(len));
at += usize::from(len);
// A code the CMap leaves out stands for no character.
match cid.and_then(|cid| unicode.lookup_bf_string(cid)) {
// A one-byte Roman code whose CID the table gives as a combining mark alone (0x7E in
// the Mac Shift-JIS CMaps, U+0303): the ASCII character, as Adobe's cid2code.txt lists first.
Some(BfString::Char('\u{300}'..='\u{36f}')) if len == 1 && (0x20..0x7f).contains(&first) => {
emit(value, &mut Some(char::from(first)).into_iter())
}
Some(BfString::Char(c)) if c != char::REPLACEMENT_CHARACTER => emit(value, &mut Some(c).into_iter()),
Some(BfString::String(s)) => emit(value, &mut s.chars().filter(|c| *c != char::REPLACEMENT_CHARACTER)),
_ => emit(value, &mut None.into_iter()),
}
}
}
}
/// A string's characters, and its codes: each code's value and how many of the characters it
/// stands for, in order.
#[derive(Debug, Default)]
pub(super) struct Decoded {
pub text: String,
pub codes: Vec<(u32, usize)>,
}
impl Decoded {
/// Code `code`, standing for characters `chars`.
pub(super) fn push(&mut self, code: u32, chars: impl IntoIterator<Item = char>) {
let before = self.text.len();
self.text.extend(chars);
let n = self.text.get(before..).map_or(0, |added| added.chars().count());
self.codes.push((code, n));
}
}
/// How strings in a font over predefined CMap `cmap` decode; `None` when the CMap can't be read.
pub(super) fn codes(cmap: &str) -> Option<CMapCodes> {
match unicode_cmap(cmap) {
Some(form) => Some(CMapCodes::Unicode(form)),
None => cid_codes(cmap),
}
}
/// How a predefined Unicode CMap's codes encode their characters.
#[derive(Clone, Copy, PartialEq, Debug)]
pub(super) enum Unicode {
/// Two bytes a character (`UCS2`) or a UTF-16 surrogate pair, the high byte first.
Utf16,
Utf8,
/// Four bytes, the high byte first.
Utf32,
}
/// The encoding of predefined Unicode CMap `name`: `Uni` and a character collection, then `-UCS2`,
/// `-UTF8`, `-UTF16` or `-UTF32` (and `-HW` for half-width forms), then `-H` or `-V`
/// (`UniJIS-UCS2-H`, `UniGB-UTF16-V`: <https://github.com/adobe-type-tools/cmap-resources>).
fn unicode_cmap(name: &str) -> Option<Unicode> {
let rest = name.strip_suffix("-H").or_else(|| name.strip_suffix("-V"))?;
let rest = rest.strip_suffix("-HW").unwrap_or(rest);
let (collection, form) = rest.rsplit_once('-')?;
let collections = ["UniJIS", "UniJISPro", "UniJIS2004", "UniJISX0213", "UniJISX02132004", "UniHojo", "UniGB", "UniCNS", "UniKS", "UniAKR"];
if !collections.contains(&collection) {
return None;
}
match form {
"UCS2" | "UTF16" => Some(Unicode::Utf16),
"UTF8" => Some(Unicode::Utf8),
"UTF32" => Some(Unicode::Utf32),
_ => None,
}
}
/// Calls `out` with each code of string `s` in Unicode form `form` in turn, and the character it
/// encodes (none for an invalid code: a lone surrogate, a byte that starts no UTF-8 character, a
/// value past U+10FFFF).
fn unicode_codes(s: &[u8], form: Unicode, mut out: impl FnMut(&[u8], Option<char>)) {
match form {
Unicode::Utf16 => {
let unit = |i: usize| s.get(i..i + 2).and_then(|b| <[u8; 2]>::try_from(b).ok()).map(u16::from_be_bytes);
let mut at = 0;
while let Some(u) = unit(at) {
let next = unit(at + 2);
let pair = next.filter(|n| (0xd800..0xdc00).contains(&u) && (0xdc00..0xe000).contains(n));
let len = if pair.is_some() { 4 } else { 2 };
let c = char::decode_utf16([u].into_iter().chain(pair)).next().and_then(Result::ok);
out(s.get(at..at + len).unwrap_or_default(), c);
at += len;
}
}
Unicode::Utf8 => {
let mut at = 0;
for chunk in s.utf8_chunks() {
for c in chunk.valid().chars() {
out(s.get(at..at + c.len_utf8()).unwrap_or_default(), Some(c));
at += c.len_utf8();
}
for _ in chunk.invalid() {
out(s.get(at..at + 1).unwrap_or_default(), None);
at += 1;
}
}
}
Unicode::Utf32 => {
for b in s.as_chunks::<4>().0 {
out(b.as_slice(), char::from_u32(u32::from_be_bytes(*b)));
}
}
}
}
/// Predefined CMap `name` among those VectorCraft carries, leaving out the Identity CMaps, whose
/// codes are CIDs of no known character collection.
fn predefined(name: &str) -> Option<CMapName<'_>> {
match CMapName::from_bytes(name.as_bytes()) {
CMapName::Custom(_) | CMapName::IdentityH | CMapName::IdentityV => None,
name => Some(name),
}
}
/// Adobe's predefined CMaps that VectorCraft doesn't carry, by name without `-H` or `-V`
/// (<https://github.com/adobe-type-tools/cmap-resources>): the nearest carried CMap with the same
/// code space, and whether each byte of a row-and-cell code gets its high bit set first (the EUC
/// form of the same code; `GB-H`, `CNS1-H` and `KSC-H` have no one-byte codes, their code space
/// is `<2121>` to `<7E7E>`); `None` for those no carried CMap reads.
fn stand_in(stem: &str) -> Option<Option<(&'static str, bool)>> {
Some(match stem {
"RKSJ" | "78-RKSJ" | "78ms-RKSJ" => Some(("90ms-RKSJ-H", false)),
"78-EUC" => Some(("EUC-H", false)),
"78" | "Add" | "Ext" | "NWP" => Some(("H", false)),
"GB" => Some(("GB-EUC-H", true)),
"CNS1" => Some(("CNS-EUC-H", true)),
"KSC" => Some(("KSC-EUC-H", true)),
"B5" => Some(("ETen-B5-H", false)),
"ETHK-B5" | "HKdla-B5" | "HKdlb-B5" | "HKgccs-B5" | "HKm314-B5" | "HKm471-B5" => Some(("HKscs-B5-H", false)),
"GBT" | "GBT-EUC" | "GBTpc-EUC" | "CNS2" | "KSC-Johab" => None,
_ => return None,
})
}
/// Predefined CMap `cmap`'s codes to CIDs, and its character collection's CID → Unicode CMap. A
/// vertical CMap's codes are read with its horizontal CMap when VectorCraft carries that: the two
/// differ only in the CIDs of vertical glyph forms. A CMap VectorCraft doesn't carry is read with
/// its [`stand_in`].
fn cid_codes(cmap: &str) -> Option<CMapCodes> {
let read = |name: &str| CMap::parse(load_embedded(predefined(name)?)?, load_embedded);
let horizontal = cmap.strip_suffix('V').map(|stem| format!("{stem}H"));
let stem = cmap.strip_suffix("-H").or_else(|| cmap.strip_suffix("-V"));
let (codes, high_bit) = horizontal.iter().map(String::as_str).chain([cmap]).find_map(|n| Some((read(n)?, false))).or_else(|| {
let (name, high_bit) = stand_in(stem?).flatten()?;
Some((read(name)?, high_bit))
})?;
let table = codes.metadata().character_collection.as_ref()?.family.ucs2_cmap()?;
let unicode = CMap::parse(load_embedded(table)?, load_embedded)?;
// A row-and-cell code read in its EUC form falls in the EUC CMap's code space.
let space = if high_bit { stand_in(stem?).flatten().and_then(|(name, _)| code_space(name)) } else { code_space(cmap) };
Some(CMapCodes::Cids { codes: Box::new(codes), unicode: Box::new(unicode), high_bit, space })
}
/// The code space of predefined CMap `cmap`, as Adobe's CMap files give it
/// (<https://github.com/adobe-type-tools/cmap-resources>); a CMap's vertical form has its
/// horizontal form's. `None` for a CMap not listed here.
fn code_space(cmap: &str) -> Option<CodeSpace> {
const RKSJ: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa0", b"\xdf"), (b"\x81\x40", b"\x9f\xfc"), (b"\xe0\x40", b"\xfc\xfc")];
const RKSJ_MAC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa0", b"\xdf"), (b"\xfd", b"\xff"), (b"\x81\x40", b"\x9f\xfc"), (b"\xe0\x40", b"\xfc\xfc")];
const EUC_JP: CodeSpace = &[(b"\x00", b"\x80"), (b"\x8e\xa0", b"\x8e\xdf"), (b"\xa1\xa1", b"\xfe\xfe")];
const ROW_CELL: CodeSpace = &[(b"\x21\x21", b"\x7e\x7e")];
const EUC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa1\xa1", b"\xfe\xfe")];
const GB_PC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xfd", b"\xff"), (b"\xa1\xa1", b"\xfc\xfe")];
const GBK: CodeSpace = &[(b"\x00", b"\x80"), (b"\x81\x40", b"\xfe\xfe")];
const GBK2K: CodeSpace = &[(b"\x00", b"\x7f"), (b"\x81\x40", b"\xfe\xfe"), (b"\x81\x30\x81\x30", b"\xfe\x39\xfe\x39")];
const B5_PC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xfd", b"\xff"), (b"\xa1\x40", b"\xfc\xfe")];
const B5: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa1\x40", b"\xfe\xfe")];
const HKSCS: CodeSpace = &[(b"\x00", b"\x80"), (b"\x87\x40", b"\xfe\xfe")];
const HKDLB: CodeSpace = &[(b"\x00", b"\x80"), (b"\x8e\x40", b"\xfe\xfe")];
const HKGCCS: CodeSpace = &[(b"\x00", b"\x80"), (b"\x8a\x40", b"\xfe\xfe")];
const CNS_EUC: CodeSpace = &[(b"\x00", b"\x80"), (b"\xa1\xa1", b"\xfe\xfe"), (b"\x8e\xa1\xa1\xa1", b"\x8e\xa3\xfe\xfe")];
const KSC_PC: CodeSpace = &[(b"\x00", b"\x84"), (b"\xfe", b"\xff"), (b"\xa1\x41", b"\xfd\xfe")];
const UHC: CodeSpace = &[(b"\x00", b"\x80"), (b"\x81\x41", b"\xfe\xfe")];
let stem = match cmap {
"H" | "V" => "",
_ => cmap.strip_suffix("-H").or_else(|| cmap.strip_suffix("-V"))?,
};
let stem = stem.strip_suffix("-HW").unwrap_or(stem);
Some(match stem {
"83pv-RKSJ" | "90pv-RKSJ" => RKSJ_MAC,
_ if stem.ends_with("RKSJ") => RKSJ,
"EUC" | "78-EUC" => EUC_JP,
"" | "78" | "Add" | "Ext" | "NWP" => ROW_CELL,
"GB-EUC" | "GBT-EUC" | "KSC-EUC" => EUC,
"GBpc-EUC" | "GBTpc-EUC" => GB_PC,
"GBK-EUC" | "GBKp-EUC" => GBK,
"GBK2K" => GBK2K,
"B5pc" => B5_PC,
"B5" | "ETen-B5" | "ETenms-B5" | "HKdla-B5" | "HKm314-B5" | "HKm471-B5" => B5,
"HKscs-B5" | "ETHK-B5" => HKSCS,
"HKdlb-B5" => HKDLB,
"HKgccs-B5" => HKGCCS,
"CNS-EUC" => CNS_EUC,
"KSCpc-EUC" => KSC_PC,
"KSCms-UHC" => UHC,
_ => return None,
})
}
/// The length of the code string `bytes` starts with: the length of the code space range whose
/// lowest and highest codes hold each of its bytes between them. `None` when no range does.
fn code_len(space: CodeSpace, bytes: &[u8]) -> Option<u8> {
space
.iter()
.filter(|(lo, hi)| bytes.get(..lo.len()).is_some_and(|b| b.iter().zip(lo.iter().zip(hi.iter())).all(|(b, (lo, hi))| (lo..=hi).contains(&b))))
.map(|(lo, _)| lo.len())
.min()
.and_then(|len| u8::try_from(len).ok())
}
/// Whether `cmap` names a predefined CMap: a predefined Unicode CMap ([`unicode_cmap`]), one of the
/// predefined CMaps VectorCraft carries ([`predefined`]) or one of the others ([`stand_in`]), in
/// its horizontal (`-H`) or vertical (`-V`) form. The Identity CMaps are not among them.
pub(super) fn known(cmap: &str) -> bool {
let vertical_of_predefined = || cmap.strip_suffix('V').is_some_and(|stem| predefined(&format!("{stem}H")).is_some());
let other = || cmap.strip_suffix("-H").or_else(|| cmap.strip_suffix("-V")).is_some_and(|stem| stand_in(stem).is_some());
unicode_cmap(cmap).is_some() || predefined(cmap).is_some() || vertical_of_predefined() || other()
}
/// Whether predefined CMap `cmap` is a vertical CMap (`-V`, or the row-and-cell `V`).
pub(super) fn vertical(cmap: &str) -> bool {
cmap == "V" || cmap.ends_with("-V")
}
/// A composite font's name `base-CMap`: the base font's name and its CMap's name, when that is a
/// predefined CMap ([`known`]). A name ending in an Identity CMap is not read as one, nor is one
/// that ends in an unknown CMap name with an encoding part (`UniFoo-UTF8-H`), which would otherwise
/// end in `H`.
pub(super) fn composite_font(name: &str) -> Option<(&str, &str)> {
if !(name.ends_with("-H") || name.ends_with("-V")) {
return None;
}
// The longest CMap name first: `83pv-RKSJ-H` before `H`.
// No predefined CMap name is longer than 32 bytes.
for (at, _) in name.match_indices('-').filter(|(at, _)| name.len() - at <= 33) {
let (Some(base), Some(cmap)) = (name.get(..at).filter(|b| !b.is_empty()), name.get(at + 1..)) else { continue };
if matches!(cmap, "Identity-H" | "Identity-V") {
return None;
}
let encoding_part =
base.rsplit('-').next().is_some_and(|part| ["UCS2", "UTF8", "UTF16", "UTF32", "HW", "EUC", "RKSJ", "B5", "UHC", "Johab"].contains(&part));
if matches!(cmap, "H" | "V") && encoding_part {
return None;
}
if known(cmap) {
return Some((base, cmap));
}
}
None
}
+165
View File
@@ -403,6 +403,171 @@ fn named_cidfonts_over_unicode_cmaps_set_their_characters_as_type() {
check("/Ryumin-Light-UniJIS-UCS2-H findfont 20 scalefont setfont <00410042> stringwidth pop dup 5 gt exch 40 lt and");
}
/// The text objects of an import.
fn texts(r: &crate::Imported) -> Vec<vectorcraft_doc::TextObject> {
all(&r.document)
.iter()
.filter_map(|n| match &n.kind {
NodeKind::Text(t) => Some((**t).clone()),
_ => None,
})
.collect()
}
/// A CID-keyed font over one of the other predefined CMaps (Shift-JIS, EUC, GBK, Big Five, UHC,
/// JIS row and cell: <https://github.com/adobe-type-tools/cmap-resources>), the file defining
/// neither, its CIDFont only named: the codes are read by that CMap and its character
/// collection's CIDs to Unicode, and set as type in the font of the CIDFont's name, whether
/// found as `CIDFont-CMap` or composed. Codes the CMap doesn't map and control codes are left out.
#[test]
fn named_cidfonts_over_predefined_cmaps_set_their_characters_as_type() {
let cases: &[(&str, &str, &str)] = &[
// 日 is 0x93FA and 本 0x967B in Shift-JIS.
("83pv-RKSJ-H", "93fa967b41", "日本A"),
("90ms-RKSJ-H", "93fa", "日"),
("EUC-H", "c6fc", "日"),
// JIS row and cell: 日 is 0x467C.
("H", "467c", "日"),
("GBK-EUC-H", "d6d0", "中"),
("B5pc-H", "a4a4", "中"),
("ETen-B5-H", "a4a4", "中"),
("KSCms-UHC-H", "c7d1", "한"),
// A CMap read with the nearest carried one: GB 2312 row and cell in EUC form, 中 0x5650.
("GB-H", "5650", "中"),
// 0x8540 maps to no CID, 0xFD is in no code space range, 0x0D is a control code.
("90ms-RKSJ-H", "854093fa41fd0d42", "日AB"),
];
for (cmap, hex, want) in cases {
let r = super::tests::read(&format!("/Ryumin-Light-{cmap} findfont 20 scalefont setfont 10 20 moveto <{hex}> show"));
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{cmap}: {:?}", r.warnings);
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<Vec<_>>(), [*want], "{cmap}");
let style = &t[0].runs[0].style;
assert_eq!((style.font_family.as_str(), style.font_style.as_str(), style.size), ("Ryumin", "Light", 20.0), "{cmap}");
assert!(!t[0].vertical, "{cmap}");
}
let r = super::tests::read("/X /GBK-EUC-H [/NotInFile] composefont 20 scalefont setfont 10 20 moveto <d6d041> show");
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<String>(), "中A");
// The point moves past the type, along the line.
check("/Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont <93fa967b> stringwidth abs 0.01 lt exch dup 5 gt exch 60 lt and and");
}
/// Type in a CID-keyed font over a predefined CMap, its CIDFont only named, shown with `ashow`,
/// `widthshow` (matching a code by its value) and `xshow`, is spaced as the operator says: the
/// point moves that far, and the characters' tracking makes up the difference, as for type in a
/// font found by name. Over a vertical CMap the extra space runs down the column.
#[test]
fn named_cidfonts_over_predefined_cmaps_take_the_show_operators_spacing() {
// Measured without painting.
let measured = |body: &str| check(&format!("gsave nulldevice {body} grestore"));
let set = "/Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont";
// `ashow` adds 5 to each of the two codes.
measured(&format!(
"{set} 10 20 moveto <93fa967b> show currentpoint pop 10 20 moveto 5 0 <93fa967b> ashow currentpoint pop sub -10 sub abs 0.01 lt"
));
let r = super::tests::read(&format!("{set} 10 20 moveto 5 0 <93fa967b> ashow"));
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["日本"]);
assert!(t[0].runs.iter().all(|run| (run.style.tracking - 250.0).abs() < 0.5), "{:?}", t[0].runs);
// `widthshow` adds 7 to the space, code 0x20.
measured(&format!(
"{set} 10 20 moveto <93fa20967b> show currentpoint pop 10 20 moveto 7 0 32 <93fa20967b> widthshow currentpoint pop sub -7 sub abs 0.01 lt"
));
// A row-and-cell code read in its EUC form keeps the value of the string's bytes: 中 0x5650.
let gb = "/STSong-Light-GB-H findfont 20 scalefont setfont";
measured(&format!(
"{gb} 10 20 moveto <56505650> show currentpoint pop 10 20 moveto 7 0 16#5650 <56505650> widthshow currentpoint pop sub -14 sub abs 0.01 lt"
));
// `xshow` moves 30 a code.
measured(&format!("{set} 10 20 moveto <93fa967b> [30 30] xshow currentpoint pop 70 sub abs 0.01 lt"));
// Down the column: `ashow`'s 5 down each code.
let set = "/Ryumin-Light-90ms-RKSJ-V findfont 20 scalefont setfont";
measured(&format!(
"{set} 10 200 moveto <93fa967b> show currentpoint exch pop 10 200 moveto 0 -5 <93fa967b> ashow currentpoint exch pop sub 10 sub abs 0.01 lt"
));
let r = super::tests::read(&format!("{set} 10 200 moveto 0 -5 <93fa967b> ashow"));
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<String>(), "日本");
assert!(t.iter().all(|t| t.vertical), "{t:?}");
}
/// A CID-keyed font over a vertical predefined CMap (`-V`), the file defining neither, its CIDFont
/// only named: the type is a vertical column, and the point moves down it, not along a line.
#[test]
fn named_cidfonts_over_vertical_cmaps_set_vertical_type() {
for (cmap, hex) in [("90ms-RKSJ-V", "93fa967b"), ("UniJIS-UCS2-V", "65e5672c")] {
let r = super::tests::read(&format!("/Ryumin-Light-{cmap} findfont 20 scalefont setfont 10 20 moveto <{hex}> show"));
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["日本"], "{cmap}: {:?}", r.warnings);
assert!(t[0].vertical, "{cmap}");
check(&format!("/Ryumin-Light-{cmap} findfont 20 scalefont setfont <{hex}> stringwidth dup -60 gt exch -5 lt and exch abs 0.01 lt and"));
}
}
/// Down a column each code of a CID-keyed font over a vertical predefined CMap moves the point one
/// em, the default vertical displacement (PDF Reference 1.7, §5.6.3, `DW2`), also two digits that
/// vertical type sets side by side in one em: `show` and `stringwidth` move the point as far as
/// showing the codes one at a time.
#[test]
fn codes_down_a_column_each_move_the_point_one_em() {
// Measured without painting.
let set = "gsave nulldevice /Ryumin-Light-90ms-RKSJ-V findfont 20 scalefont setfont";
check(&format!("{set} (12) stringwidth grestore -40 sub abs 0.01 lt exch abs 0.01 lt and"));
check(&format!("{set} 10 100 moveto (12) show currentpoint grestore 60 sub abs 0.01 lt exch 10 sub abs 0.01 lt and"));
check(&format!(
"{set} 10 100 moveto (1) show (2) show currentpoint 10 100 moveto (12) show currentpoint grestore \
3 -1 roll sub abs 0.01 lt 3 1 roll sub abs 0.01 lt and"
));
}
/// Type in a CID-keyed font over a predefined CMap is set the same way by `show` and by the show
/// operators that space it: characters the font would join in a ligature (`fi` in the bundled
/// Source Serif 4) are set without the ligature, and the point moves as far.
#[test]
fn named_cid_type_is_set_alike_by_every_show_operator() {
let set = "/SourceSerif4-Regular-UniJIS-UCS2-H findfont 50 scalefont setfont 10 20 moveto";
let features = |show: &str| {
let r = super::tests::read(&format!("{set} <00660069> {show}"));
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["fi"], "{show}");
t[0].runs.iter().map(|r| r.style.features.clone()).collect::<Vec<_>>()
};
let plain = features("show");
assert_eq!(plain, features("0 0 3 -1 roll ashow"));
assert!(plain.iter().all(|f| f.iter().any(|f| f == "-liga")), "{plain:?}");
check(&format!(
"gsave nulldevice {set} <00660069> stringwidth 10 20 moveto 0 0 <00660069> ashow currentpoint grestore \
20 sub 3 -1 roll sub abs 0.01 lt 3 1 roll 10 sub sub abs 0.01 lt and"
));
}
/// A font name ending in the row-and-cell CMap `H` after a name without a hyphen stays a font of
/// the whole name, its strings read byte by byte. Type in a predefined CMap whose mappings aren't
/// available is left out with a warning, and a long string in a CID-keyed font over a predefined
/// CMap shown in a loop runs out of the budget.
#[test]
fn latin_names_ending_in_h_and_cmaps_that_cannot_be_read() {
let r = super::tests::read("/Futura-H findfont 20 scalefont setfont 10 20 moveto (AB) show");
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["AB"]);
let r = super::tests::read("/Ryumin-Light-GBT-H findfont 20 scalefont setfont 10 20 moveto (AB) show 0 0 10 10 rectfill");
assert!(texts(&r).is_empty(), "{:?}", all(&r.document));
assert_eq!(super::tests::program_warnings(&r.warnings), [super::text::UNREAD_CMAP], "{:?}", r.warnings);
super::tests::runs_out_of_budget("/Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont { 100000 string stringwidth pop pop } loop");
}
/// A string in the file, in a CID-keyed font over a predefined CMap, too long to decode within the
/// memory budget stops the program with an error before it is decoded.
#[test]
fn huge_strings_over_predefined_cmaps_count_against_the_memory_budget() {
// Codes the CMap doesn't map, so nothing is laid out when the string is decoded.
let huge = "\u{1}".repeat(17 << 20);
let r = import(&super::tests::eps(&format!(
"0 0 10 10 rectfill /Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont 10 20 moveto ({huge}) stringwidth"
)))
.unwrap();
assert!(r.warnings.iter().any(|w| w.contains("too much memory")), "{:?}", r.warnings);
}
/// A Type 2 CIDFont the file carries (its glyph space one unit an em), over a Unicode CMap the
/// file doesn't define, sets its characters as type at the font's size, not a thousand times it.
#[test]
+8 -1
View File
@@ -5419,7 +5419,14 @@ fn type_envelope_text(family: &str, paint: Option<&str>) -> String {
fn arc_envelope(text: &Node, bend: f64) -> Node {
let mut text = text.clone();
text.visible = true;
let kind = vectorcraft_doc::live::EnvelopeKind::Warp { style: "arc".into(), bend, h: 0.0, v: 0.0, horizontal: true };
let kind = vectorcraft_doc::live::EnvelopeKind::Warp {
style: "arc".into(),
bend,
h: 0.0,
v: 0.0,
horizontal: true,
version: vectorcraft_doc::live::WARP_NET,
};
Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope {
+187 -74
View File
@@ -15,6 +15,7 @@ use super::cid::Base;
use super::graphics::MAX_APART;
use super::interp::{Interp, matrix_obj, matrix_of};
use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, ps_err};
use super::predefined_cmap::Decoded;
use super::type1::Embedded;
/// The font a program uses before it sets one.
@@ -170,8 +171,8 @@ impl Interp<'_> {
ResourceForAll => self.resource_for_all()?,
Show | AShow | WidthShow | AWidthShow | XShow | YShow | XYShow | KShow => {
let (s, spacing) = self.show_operands(op)?;
if let Some((text, font)) = self.unicode_type(&s)? {
self.show_unicode(&text, &font)?;
if let Some((codes, font, vertical)) = self.named_cid_type(&s)? {
self.show_named_cid(&codes, &font, vertical, &spacing)?;
} else if let Some(glyphs) = self.composite_glyphs(&s)? {
self.show_composite(&glyphs, &spacing)?;
} else {
@@ -282,9 +283,9 @@ impl Interp<'_> {
/// How far `s` moves the current point (user space).
fn width_of(&mut self, s: &[u8]) -> Res<Vec2> {
if let Some((text, font)) = self.unicode_type(s)? {
if let Some((codes, font, vertical)) = self.named_cid_type(s)? {
let saved = self.g.font.replace(font);
let r = self.set_text(&text, Point::ZERO).map(|t| t.2);
let r = self.named_cid_width(&codes, vertical);
self.g.font = saved;
return r;
}
@@ -395,18 +396,29 @@ impl Interp<'_> {
}
/// The font named `k`: one the program defined; else, for a name `CIDFont-CMap` whose CMap
/// is a predefined Unicode CMap, the CID-keyed font of those two (the usual name of a
/// CID-keyed font, as `composefont` makes them: PLRM 3rd ed., chapter 8); else a font of
/// that name.
/// is a predefined CMap, the CID-keyed font of those two (the usual name of a CID-keyed font,
/// as `composefont` makes them: PLRM 3rd ed., chapter 8; the CMaps are Adobe's public CMap
/// resources, <https://github.com/adobe-type-tools/cmap-resources>); else a font of that name.
/// A name an installed face has is that face's, and a name split at a bare `H` or `V` (the
/// row-and-cell CMaps) needs a CIDFont name with a hyphen in it (`Ryumin-Light-H`), so
/// `Futura-H` stays a font of that name.
fn find_font(&mut self, k: &Obj) -> Res<DictRef> {
let key = k.key().ok_or(PsError::Ps("typecheck", "findfont".into()))?;
if let Some(Obj::Dict(d)) = self.fonts.borrow().get(&key) {
return Ok(d.clone());
}
let text = k.text().map(|t| t.to_string()).unwrap_or_default();
let split =
text.match_indices('-').map(|(i, _)| i).find(|&i| i > 0 && super::cid::unicode_cmap(text.get(i + 1..).unwrap_or_default()).is_some());
if let Some((cid_font, cmap)) = split.and_then(|i| Some((text.get(..i)?, text.get(i + 1..)?))) {
let split = text
.match_indices('-')
.map(|(i, _)| i)
.find(|&i| i > 0 && super::cid::unicode_cmap(text.get(i + 1..).unwrap_or_default()).is_some())
.and_then(|i| Some((text.get(..i)?, text.get(i + 1..)?)))
.or_else(|| {
let (cid_font, cmap) = super::predefined_cmap::composite_font(&text)?;
let installed = vectorcraft_text::FontDb::global().find_postscript(&text).is_some();
(!installed && !(matches!(cmap, "H" | "V") && !cid_font.contains('-'))).then_some((cid_font, cmap))
});
if let Some((cid_font, cmap)) = split {
let cmap = self.find_cmap(&Obj::name(cmap))?;
let dep = self.find_cid_font(&Obj::name(cid_font))?;
return Ok(self.composed(key, cmap, vec![Obj::Dict(dep)]));
@@ -476,6 +488,15 @@ impl Interp<'_> {
/// [`Self::set_type`] for the characters `text`.
fn set_text(&mut self, text: &str, at: Point) -> Res<(TextObject, TextLayout, Vec2)> {
self.set_text_in(text, at, false)
}
/// [`Self::set_text`], as vertical type when `vertical`: a column anchored at `at`, the top
/// center of its first em box, that moves the current point down the column by the layout's
/// advances. In vertical writing the current point is a glyph's origin 1, by default half its
/// width across and 880 units of 1000 above its origin 0 (PDF Reference 1.7, §5.6.3 "Glyph
/// Metrics in CIDFonts", `DW2`).
fn set_text_in(&mut self, text: &str, at: Point, vertical: bool) -> Res<(TextObject, TextLayout, Vec2)> {
// Laying out type costs about as much as 300 operations, and 64 more a character
// (measured), so `{ (a) stringwidth pop pop } loop` or `cshow` on a long string ends
// within the budget like any other loop instead of running for minutes.
@@ -493,11 +514,29 @@ impl Interp<'_> {
let fill = if self.g.paint.is_none() { Paint::solid(vectorcraft_color::Color::BLACK) } else { self.g.paint.clone() };
let style = CharStyle { font_family, font_style, size, fill, stroke: Paint::None, ..CharStyle::default() };
let mut t = TextObject::point(Point::ZERO, text, style);
t.vertical = vertical;
let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
t.xf = m * Affine::scale_non_uniform(1.0 / size, -1.0 / size);
t.cached_bounds = Some(layout.bounds);
let adv: f64 = layout.glyphs.iter().map(|g| g.advance).sum();
Ok((t, layout, f1 * Point::new(adv / size, 0.0) - f1 * Point::ZERO))
let moved = if vertical { Point::new(0.0, -adv / size) } else { Point::new(adv / size, 0.0) };
Ok((t, layout, f1 * moved - f1 * Point::ZERO))
}
/// [`Self::set_text_in`] for characters the file places one by one: where the layout joins
/// characters in a ligature, the type is set without ligatures, so each character has its own
/// advance.
fn set_placed_text(&mut self, text: &str, at: Point, vertical: bool) -> Res<(TextObject, TextLayout)> {
let (mut t, mut layout, _) = self.set_text_in(text, at, vertical)?;
let glyph_starts: std::collections::HashSet<usize> = layout.glyphs.iter().map(|g| g.byte).collect();
if text.char_indices().any(|(b, _)| !glyph_starts.contains(&b)) {
for run in &mut t.runs {
run.style.features.push("-liga".into());
}
layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
t.cached_bounds = Some(layout.bounds);
}
Ok((t, layout))
}
/// `show`: point type at the current point, which moves past it.
@@ -527,27 +566,30 @@ impl Interp<'_> {
return self.show_type42_outlines(data, glyphs, s, spacing, at, f1);
}
// Each code's character, if it has one that shows (control codes don't).
let chars: Vec<Option<char>> = match &plain {
let chars = match &plain {
Some((_, glyphs)) => glyphs.iter().map(|g| g.ch).collect::<Vec<_>>(),
None => self.named_chars(s).into_iter().map(Some).collect(),
};
let mut codes = Decoded::default();
for (c, &code) in chars.into_iter().zip(s) {
codes.push(u32::from(code), c.filter(|c| !c.is_control()));
}
.into_iter()
.map(|c| c.filter(|c| !c.is_control()))
.collect();
let text: String = chars.iter().flatten().collect();
let (mut t, mut layout, _) = self.set_text(&text, at)?;
let widths: Option<Vec<f64>> = plain.map(|(_, glyphs)| glyphs.iter().map(|g| g.width).collect());
self.show_codes(&codes, widths.as_deref(), spacing, false, s)
}
/// The codes `codes` (each standing for some of its characters, or none) shown in the current
/// font as [`Self::show_plain`] shows a string's, spaced as `spacing` says, each code `widths`
/// wide when given (in glyph space, one unit an em), else as wide as its characters' advances;
/// as vertical type when `vertical`, the codes moving the point down the column. `kern` is the
/// string `kshow` gives its procedure the codes of.
fn show_codes(&mut self, codes: &Decoded, widths: Option<&[f64]>, spacing: &Spacing, vertical: bool, kern: &[u8]) -> Res {
let at = self.user_point()?;
let (_, f1) = self.font()?;
let text = &codes.text;
let (mut t, layout) = self.set_placed_text(text, at, vertical)?;
let size = t.runs.first().map_or(1.0, |r| r.style.size);
let starts: Vec<usize> = text.char_indices().map(|(b, _)| b).collect();
// The file places each character's glyph: where the layout joins characters in a
// ligature, the type is set without ligatures, so each character has its own advance.
let glyph_starts: std::collections::HashSet<usize> = layout.glyphs.iter().map(|g| g.byte).collect();
if starts.iter().any(|b| !glyph_starts.contains(b)) {
for run in &mut t.runs {
run.style.features.push("-liga".into());
}
layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
t.cached_bounds = Some(layout.bounds);
}
// Each character's advance in the layout (text space).
let mut natural = vec![0.0; starts.len()];
for g in &layout.glyphs {
@@ -555,29 +597,30 @@ impl Interp<'_> {
*n += g.advance;
}
}
// Each code's move (user space) and that move in text space, along the baseline and across.
let em = |x: f64| f1 * Point::new(x, 0.0) - f1 * Point::ZERO;
// Each code's move (user space) and that move in text space, along the baseline (down the
// column) and across.
let em = |x: f64| f1 * if vertical { Point::new(0.0, -x) } else { Point::new(x, 0.0) } - f1 * Point::ZERO;
let inv = f1.inverse();
let mut moves = Vec::with_capacity(s.len());
let mut moves = Vec::with_capacity(codes.codes.len());
let mut k = 0;
// What `kshow`'s procedure draws goes after the type.
let start = self.out.drawn.len();
let mut pen = at;
for (i, (&code, c)) in s.iter().zip(&chars).enumerate() {
let own = match &plain {
Some((_, glyphs)) => glyphs.get(i).map_or(0.0, |g| g.width),
None if c.is_some() => natural.get(k).copied().unwrap_or(0.0) / size,
None => 0.0,
for (i, &(code, n)) in codes.codes.iter().enumerate() {
let own = match widths {
Some(widths) => widths.get(i).copied().unwrap_or(0.0),
None => natural.get(k..k + n).map_or(0.0, |w| w.iter().sum::<f64>()) / size,
};
k += usize::from(c.is_some());
k += n;
let mut d = spacing.advance(i, i64::from(code), em(own));
d += self.kern(spacing, s, i, pen + d)?;
d += self.kern(spacing, kern, i, pen + d)?;
pen += d;
let e = inv * Point::new(d.x, d.y) - inv * Point::ZERO;
if ![d.x, d.y, e.x * size, e.y * size].iter().all(|v| v.is_finite()) {
let (along, across) = if vertical { (-e.y * size, e.x * size) } else { (e.x * size, e.y * size) };
if ![d.x, d.y, along, across].iter().all(|v| v.is_finite()) {
return ps_err("undefinedresult", "a show");
}
moves.push((d, e.x * size, e.y * size));
moves.push((d, along, across));
}
let total: Vec2 = moves.iter().map(|m| m.0).sum();
if !(total.x.is_finite() && total.y.is_finite()) {
@@ -589,12 +632,11 @@ impl Interp<'_> {
if across {
// Moves across the baseline (`yshow`, `xyshow`): each character where the file puts it.
let mut pen = at;
for ((d, ..), c) in moves.iter().zip(&chars) {
if let Some(c) = c
&& painted
&& !c.is_whitespace()
{
let (t, ..) = self.set_text(c.encode_utf8(&mut [0; 4]), pen)?;
let mut chars = text.chars();
for ((d, ..), &(_, n)) in moves.iter().zip(&codes.codes) {
let c: String = chars.by_ref().take(n).collect();
if painted && !c.trim().is_empty() {
let (t, ..) = self.set_text_in(&c, pen, vertical)?;
let clips = self.g.clips.clone();
self.out.push(Node::new(NodeId(0), NodeKind::Text(Box::new(t))), &clips);
}
@@ -605,11 +647,17 @@ impl Interp<'_> {
// a character, before the next, are that character's.
let mut lead = Vec2::ZERO;
let mut target: Vec<f64> = Vec::with_capacity(natural.len());
for ((d, along, _), c) in moves.iter().zip(&chars) {
match (c, target.last_mut()) {
(Some(_), _) => target.push(*along),
(None, Some(last)) => *last += along,
(None, None) => lead += *d,
for ((d, along, _), &(_, n)) in moves.iter().zip(&codes.codes) {
if n > 0 {
// A code of several characters: those before its last keep their advances.
let before = natural.get(target.len()..target.len() + n - 1).unwrap_or_default().to_vec();
let rest = *along - before.iter().sum::<f64>();
target.extend(before);
target.push(rest);
} else if let Some(last) = target.last_mut() {
*last += along;
} else {
lead += *d;
}
}
let tracking: Vec<f64> = target
@@ -931,23 +979,47 @@ impl Interp<'_> {
.collect())
}
/// The characters of `s` and the font to set them in when the current font is a CID-keyed
/// font over a predefined Unicode CMap the file doesn't define (`UniJIS-UCS2-H`), whose
/// mappings to CIDs aren't known: its codes say the characters, set as type in the font of
/// its CIDFont's name.
fn unicode_type(&mut self, s: &[u8]) -> Res<Option<(String, DictRef)>> {
let Some((text, font, name)) = self.unicode_parts(s) else { return Ok(None) };
/// The codes of `s` with the characters each stands for, the font to set them in and whether
/// they run down a column, when the current font is a CID-keyed font over a predefined CMap
/// the file doesn't define (`UniJIS-UCS2-H`, `90ms-RKSJ-H`), whose mappings to CIDs the file
/// doesn't give: a Unicode CMap's codes are the characters, another CMap's are read by the CMap
/// of that name and its character collection's CID → Unicode CMap (a code it doesn't map
/// stands for none), set as type in the font of its CIDFont's name, vertical over a vertical
/// CMap (`WMode` 1). Control codes stand for no character. Type in a CMap VectorCraft can't
/// read is left out, with a warning.
fn named_cid_type(&mut self, s: &[u8]) -> Res<Option<(Decoded, DictRef, bool)>> {
let Some((cmap, font, name, vertical)) = self.named_cid_parts() else { return Ok(None) };
// Each code is looked up in the CMap's mappings.
self.spend(s.len() as u64)?;
// The decoded codes and characters are held while the string is shown: checked against
// the memory budget first, so a huge string in the file stops the program with an error.
let held = s.len().saturating_mul(DECODED_BYTES);
self.alloc(held)?;
self.unalloc(held);
let decoded = match self.predefined_codes(&cmap) {
Some(codes) => codes.codes(s),
None => {
self.out.warn(UNREAD_CMAP);
Decoded::default()
}
};
let mut codes = Decoded::default();
let mut chars = decoded.text.chars();
for &(code, n) in &decoded.codes {
codes.push(code, chars.by_ref().take(n).filter(|c| !c.is_control()));
}
// The composite font is copied under the CIDFont's name for every string: charged by
// its size, so a huge font dictionary shown in a loop runs out of the budget.
let entries = font.borrow().len();
self.spend(entries as u64)?;
let mut named = font.borrow().clone();
named.insert(Key::name("FontName"), name);
Ok(Some((text, DictRef::new(named))))
Ok(Some((codes, DictRef::new(named), vertical)))
}
/// The text, the composite font and the CIDFont's name of [`Self::unicode_type`].
fn unicode_parts(&self, s: &[u8]) -> Option<(String, DictRef, Obj)> {
/// The CMap's name, the composite font, the CIDFont's name and the writing mode of
/// [`Self::named_cid_type`].
fn named_cid_parts(&self) -> Option<(String, DictRef, Obj, bool)> {
let font = self.g.font.clone()?;
let f = font.borrow();
if font_type(&f) != Some(0.0) || f.get(&Key::name("FMapType")).and_then(Obj::as_num) != Some(9.0) {
@@ -959,29 +1031,63 @@ impl Interp<'_> {
if cmap.contains_key(&Key::name("CodeSpaceRange")) {
return None;
}
let (form, _) = super::cid::unicode_cmap(&cmap.get(&Key::name("CMapName")).and_then(Obj::text)?)?;
let cmap_name = cmap.get(&Key::name("CMapName")).and_then(Obj::text)?.to_string();
if super::cid::unicode_cmap(&cmap_name).is_none() && !super::predefined_cmap::known(&cmap_name) {
return None;
}
let wmode = f.get(&Key::name("WMode")).or_else(|| cmap.get(&Key::name("WMode"))).and_then(Obj::as_num);
let Some(Obj::Dict(dep)) = f.get(&Key::name("FDepVector")).and_then(|v| v.items()?.get(0)) else { return None };
let name = {
let d = dep.borrow();
d.get(&Key::name("CIDFontName")).or_else(|| d.get(&Key::name("FontName"))).cloned()?
};
Some((super::cid::unicode_text(s, form), font.clone(), name))
Some((cmap_name, font.clone(), name, wmode == Some(1.0)))
}
/// `text` set as point type at the current point in font `font` (see
/// [`Self::unicode_type`]), which moves past it.
fn show_unicode(&mut self, text: &str, font: &DictRef) -> Res {
let at = self.user_point()?;
let saved = self.g.font.replace(font.clone());
let r = self.set_text(text, at);
self.g.font = saved;
let (t, _, adv) = r?;
if !self.g.paint.is_none() && !self.g.null && !text.trim().is_empty() {
let clips = self.g.clips.clone();
self.out.push(Node::new(NodeId(0), NodeKind::Text(Box::new(t))), &clips);
/// How strings in predefined CMap `cmap` decode (a CMap other than a Unicode CMap read once a
/// file); `None` when VectorCraft can't read it.
fn predefined_codes(&mut self, cmap: &str) -> Option<Rc<super::predefined_cmap::CMapCodes>> {
if let Some((form, _)) = super::cid::unicode_cmap(cmap) {
return Some(Rc::new(super::predefined_cmap::CMapCodes::Unicode(form)));
}
self.g.cur = Some(self.xf() * (at + adv));
Ok(())
if let Some((_, codes)) = self.predefined_cmaps.iter().find(|(n, _)| **n == *cmap) {
return codes.clone();
}
let codes = super::predefined_cmap::codes(cmap).map(Rc::new);
// Only the names of the other predefined CMaps reach here (`named_cid_parts`), so the
// list stays short.
self.predefined_cmaps.push((Rc::from(cmap), codes.clone()));
codes
}
/// The codes `codes` (with their characters) set as point type at the current point in font
/// `font` (see [`Self::named_cid_type`]), running down a column when `vertical`, which moves
/// past them, spaced as `spacing` says, as [`Self::show_codes`] shows them. `widthshow` and
/// `awidthshow` match a code by its value (font number 0 times 256 plus the code: PLRM 3rd ed.,
/// `widthshow` in chapter 8); `kshow`'s procedure isn't run between them (a composite font's
/// codes aren't single bytes). Down a column each code moves the point one em, the default
/// vertical displacement of a CIDFont whose metrics the file doesn't give (PDF Reference 1.7,
/// §5.6.3, `DW2`).
fn show_named_cid(&mut self, codes: &Decoded, font: &DictRef, vertical: bool, spacing: &Spacing) -> Res {
let widths = vertical.then(|| vec![1.0; codes.codes.len()]);
let saved = self.g.font.replace(font.clone());
let r = self.show_codes(codes, widths.as_deref(), spacing, vertical, &[]);
self.g.font = saved;
r
}
/// How far the codes `codes` move the current point (user space) when [`Self::show_named_cid`]
/// shows them with no extra spacing.
fn named_cid_width(&mut self, codes: &Decoded, vertical: bool) -> Res<Vec2> {
let (_, f1) = self.font()?;
let moved = if vertical {
Point::new(0.0, -(codes.codes.len() as f64))
} else {
let (t, layout) = self.set_placed_text(&codes.text, Point::ZERO, false)?;
let size = t.runs.first().map_or(1.0, |r| r.style.size);
Point::new(layout.glyphs.iter().map(|g| g.advance).sum::<f64>() / size, 0.0)
};
Ok(f1 * moved - f1 * Point::ZERO)
}
/// The characters of a composite font shown at the current point, spaced as `spacing` says.
@@ -1282,6 +1388,13 @@ const MAX_TYPE1: usize = 256;
/// The warning for CID-keyed type in a CIDFont the file doesn't carry.
const MISSING_CID_FONT: &str = "CID-keyed type in a font the file doesn't carry was left out";
/// Most bytes [`Interp::named_cid_type`] holds for each byte of a string: two lists of codes (16
/// bytes a code) and their characters (up to 4 bytes a character, a few characters a code).
const DECODED_BYTES: usize = 64;
/// The warning for type in a predefined CMap whose mappings VectorCraft doesn't have.
pub(super) const UNREAD_CMAP: &str = "Type in a CMap that couldn't be read was left out";
/// Most Type 42 fonts whose TrueType data is kept between glyphs.
const MAX_TYPE42: usize = 16;
+4 -1
View File
@@ -33,7 +33,10 @@
//! - Type (§15): point type, area type and type on a path as text objects, `type To`, `a b c d tx
//! ty startPt Tp` (the text matrix; the frame or path in art space between it and `TP`), each
//! run's paint style, `Tr` (fill, stroke, both or neither), `/_font size ascent descent Tf`,
//! `Ts Tz Tt TA Tl Ta Ti` and its characters `(…) Tx` (`\r` ends a paragraph), `TO`. Only the
//! `Ts Tz Tt TA Tl Ta Ti` and its characters `(…) Tx` (`\r` ends a paragraph), `TO`. Standard
//! Vertical Roman Alignment is written as `1 Tv` and `0 Tv`, and Tate-chu-yoko in horizontal
//! type as a Kumi block recorded for later use, `1 TY` … `0 TY` (§15.3.4); neither operator is
//! written for type that has neither mark. Only the
//! revisable form is written: readers lay the type out again (§15.1). Fonts are named by their
//! PostScript names in `%%DocumentFonts` and `%%IncludeFont` (§3.1) and re-encoded to
//! Windows-1252 (`TE`, then `%AI3_BeginEncoding: _name name`, `TZ`, §3.3), the 8-bit encoding
+1 -1
View File
@@ -106,7 +106,7 @@ VCLegacy begin
/TE {cleartomark} bd /TZ {cleartomark} bd
/To {pop} bd /Tp {7 {pop} repeat} bd /TP {} bd /TO {} bd
/Tr {pop} bd /Tf {pop pop pop pop} bd /Ts {pop} bd /Tz {pop pop} bd /Tt {pop} bd /TA {pop} bd
/Tl {pop pop} bd /Ta {pop} bd /Ti {pop pop pop} bd /Tx {pop} bd
/Tl {pop pop} bd /Ta {pop} bd /Ti {pop pop pop} bd /Tx {pop} bd /Tv {pop} bd /TY {pop} bd
% The page trailer (3): annotatepage marks nothing.
/annotatepage {} bd
end
+53
View File
@@ -1193,6 +1193,59 @@ fn variable_font_settings_are_warned_as_left_out() {
assert!(String::from_utf8(out.bytes).unwrap().contains("(H\\351llo \\2005\\r) Tx\n"), "still written as text");
}
/// Standard Vertical Roman Alignment is written as `Tv` and Tate-chu-yoko in horizontal type as a
/// Kumi block recorded for later use, `TY` (§15.3.4), each where it changes: the marks read back
/// on the same characters, a block is closed before its text object ends, and type with neither
/// mark has neither operator.
#[test]
fn vertical_roman_and_tate_chu_yoko_are_written_and_read_back() {
use vectorcraft_doc::{TextObject, TextRun};
let plain = style(12.0, Paint::solid(Color::BLACK));
let roman = vectorcraft_doc::CharStyle { standard_vertical_roman: true, ..plain.clone() };
let tcy = vectorcraft_doc::CharStyle { tate_chu_yoko: true, ..plain.clone() };
let both = vectorcraft_doc::CharStyle { tate_chu_yoko: true, standard_vertical_roman: true, ..plain.clone() };
let mut doc = Document::new(300.0, 200.0);
let layer = doc.layers[0].id;
let mut marked = TextObject::point(vectorcraft_geom::Point::new(20.0, 40.0), "A", plain.clone());
for (text, st) in [("12", &tcy), ("b", &roman), ("c", &both), ("34", &tcy)] {
marked.runs.push(TextRun::new(text, st.clone()));
}
let next = TextObject::point(vectorcraft_geom::Point::new(20.0, 80.0), "D", plain.clone());
for t in [marked, next] {
let n = Node::new(doc.alloc_id(), NodeKind::Text(Box::new(t)));
doc.insert(Some(layer), usize::MAX, n).unwrap();
}
let out = write(&doc);
assert!(!out.warnings.iter().any(|w| w == TYPE || w == TYPE_ATTRIBUTES), "{:?}", out.warnings);
let text = String::from_utf8(out.bytes.clone()).unwrap();
assert_eq!((text.matches("1 TY\n").count(), text.matches("0 TY\n").count()), (2, 2), "{text}");
assert_eq!((text.matches("1 Tv\n").count(), text.matches("0 Tv\n").count()), (1, 1), "{text}");
// The last block ends before its text object does.
assert!(text.contains("(34) Tx\n0 TY\nTO\n"), "{text}");
let read = texts(&crate::import(&out.bytes).unwrap().document);
let flags = |t: &TextObject| -> Vec<(String, bool, bool)> {
let mut out: Vec<(String, bool, bool)> = vec![];
for r in &t.runs {
let key = (r.style.tate_chu_yoko, r.style.standard_vertical_roman);
match out.last_mut() {
Some(last) if (last.1, last.2) == key => last.0.push_str(&r.text),
_ => out.push((r.text.clone(), key.0, key.1)),
}
}
out
};
let s = |x: &str| x.to_string();
assert_eq!(
flags(&read[0].1),
[(s("A"), false, false), (s("12"), true, false), (s("b"), false, true), (s("c"), true, true), (s("34"), true, false)]
);
assert_eq!(flags(&read[1].1), [(s("D"), false, false)]);
// Type with neither mark has neither operator.
let text = String::from_utf8(write(&typed()).bytes).unwrap();
assert!(!text.contains(" Tv\n") && !text.contains(" TY\n"), "{text}");
}
/// A legacy `.ai` text path holds the path and where the type starts on it, and no Align to Path
/// or end bracket: type on a path with either is written as text, with the warning that they are
/// left out. An end bracket at the end of an open path, or once around a closed one, is kept. A
+20 -1
View File
@@ -39,6 +39,10 @@ pub(super) struct Writer<'a> {
in_hidden: bool,
/// The fonts type is set in: PostScript name, and whether it's TrueType.
pub(super) fonts: Vec<(String, bool)>,
/// The Standard Vertical Roman Alignment the last `Tv` set (it lasts into later text objects).
roman: bool,
/// Inside a Kumi block `1 TY` began (Tate-chu-yoko in horizontal type).
kumi: bool,
}
impl<'a> Writer<'a> {
@@ -59,6 +63,8 @@ impl<'a> Writer<'a> {
hidden_art: vec![],
in_hidden: false,
fonts: vec![],
roman: false,
kumi: false,
}
}
@@ -819,6 +825,10 @@ impl<'a> Writer<'a> {
self.line(" Tx");
}
}
if self.kumi {
self.line("0 TY");
self.kumi = false;
}
self.line("TO");
}
@@ -838,7 +848,8 @@ impl<'a> Writer<'a> {
}
/// A run's character attributes and paint style: `Tr`, its fill and stroke, `Tf`, `Ts`, `Tz`,
/// `Tt`, `TA`, and the leading with the space before its paragraph, `Tl`.
/// `Tt`, `TA`, and the leading with the space before its paragraph, `Tl`; then `Tv` and `TY`
/// where Standard Vertical Roman Alignment or Tate-chu-yoko changes.
fn char_style(&mut self, st: &CharStyle, p: &ParaStyle) {
let fill = !st.fill.is_none();
let stroke = st.has_stroke();
@@ -876,6 +887,14 @@ impl<'a> Writer<'a> {
let leading = st.leading.unwrap_or_else(|| p.justification.auto_leading_for(st.size));
ps::push_nums(&mut self.body, &[finite(leading, size * 1.2), finite(p.space_before, 0.0)]);
self.line("Tl");
if st.standard_vertical_roman != self.roman {
self.roman = st.standard_vertical_roman;
self.line(if self.roman { "1 Tv" } else { "0 Tv" });
}
if st.tate_chu_yoko != self.kumi {
self.kumi = st.tate_chu_yoko;
self.line(if self.kumi { "1 TY" } else { "0 TY" });
}
}
/// Type as its glyphs' outlines: a group of a compound path for each run, with the run's fill
+43 -5
View File
@@ -18,6 +18,25 @@ use std::io::{self, Write as _};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
/// Whether the returned write error refuses this location. Recovery errors must still be shown:
/// their message names copies the user may need, even when their kind is PermissionDenied.
pub fn read_only_location(error: &io::Error) -> bool {
matches!(error.kind(), io::ErrorKind::ReadOnlyFilesystem | io::ErrorKind::PermissionDenied)
&& !error.get_ref().is_some_and(|e| e.is::<RecoveryError>())
}
/// Marks the existing recovery message without changing its text or the returned error kind.
#[derive(Debug)]
struct RecoveryError(String);
impl std::fmt::Display for RecoveryError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for RecoveryError {}
/// Write `bytes` to `path` atomically (see the module docs).
pub fn write_atomic(path: &Path, bytes: &[u8]) -> io::Result<()> {
write_atomic_with(path, |f| f.write_all(bytes))
@@ -102,7 +121,7 @@ fn write_over(tmp: &Path, target: &Path, refused: io::Error) -> io::Result<()> {
let _ = std::fs::remove_file(old);
let why =
format!("{refused}, and the file can't be copied aside before it is overwritten ({e}); the new content is kept in {}", tmp.display());
return Err(io::Error::new(refused.kind(), why));
return Err(io::Error::new(refused.kind(), RecoveryError(why)));
}
let copied = to.set_len(0).and_then(|()| io::copy(&mut from, &mut to)).and_then(|_| sync_file(&to));
drop((from, to));
@@ -115,10 +134,11 @@ fn write_over(tmp: &Path, target: &Path, refused: io::Error) -> io::Result<()> {
}
Ok(())
}
(Err(e), Some(old)) => {
Err(io::Error::new(e.kind(), format!("{e} (the new content is kept in {}, the file as it was in {})", tmp.display(), old.display())))
}
(Err(e), None) => Err(io::Error::new(e.kind(), format!("{e} (the new content is kept in {})", tmp.display()))),
(Err(e), Some(old)) => Err(io::Error::new(
e.kind(),
RecoveryError(format!("{e} (the new content is kept in {}, the file as it was in {})", tmp.display(), old.display())),
)),
(Err(e), None) => Err(io::Error::new(e.kind(), RecoveryError(format!("{e} (the new content is kept in {})", tmp.display())))),
}
}
@@ -318,6 +338,24 @@ fn keep_permissions(_: &Path, _: &Path) -> io::Result<()> {
mod tests {
use super::*;
#[test]
fn readonly_classification_uses_the_terminal_kind_and_excludes_recovery() {
for (kind, expected) in [
(io::ErrorKind::PermissionDenied, true),
(io::ErrorKind::ReadOnlyFilesystem, true),
(io::ErrorKind::StorageFull, false),
(io::ErrorKind::QuotaExceeded, false),
(io::ErrorKind::NotFound, false),
(io::ErrorKind::Other, false),
] {
assert_eq!(read_only_location(&io::Error::new(kind, "injected")), expected, "{kind:?}");
let recovery = io::Error::new(kind, RecoveryError("the new content is kept in a.tmp".into()));
assert!(!read_only_location(&recovery), "recovery: {kind:?}");
assert_eq!(recovery.kind(), kind);
assert_eq!(recovery.to_string(), "the new content is kept in a.tmp");
}
}
fn dir(name: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("vc-atomic-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
+1 -1
View File
@@ -55,7 +55,7 @@ use serde::{Deserializer, Serialize};
use vectorcraft_doc::{Document, ImageBlob};
#[cfg(not(target_arch = "wasm32"))]
pub use atomic::{sync_file, write_atomic, write_atomic_with, write_new_with};
pub use atomic::{read_only_location, sync_file, write_atomic, write_atomic_with, write_new_with};
pub use craft_vectorcraft_format::base64::{decode as base64_decode, decoded_len as base64_decoded_len, encode as base64_encode};
pub use craft_vectorcraft_format::{
BLOB_MAGIC, COMPRESSED_SINCE, EXTENSION, ICC_MIME, INLINE_MAX, LEGACY_EXTENSION, MIN_VERSION, PREVIEW_MAX, VERSION, is_compressed, json_part,
+133 -1
View File
@@ -2,7 +2,7 @@
//! distance along it of the point nearest another (type on a path lays its glyphs out and the
//! selection tools drag its brackets by distance along the path).
use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveNearest, PathSeg, Point, Vec2};
use kurbo::{Affine, ParamCurve, ParamCurveArclen, ParamCurveExtrema, ParamCurveNearest, PathSeg, Point, Vec2};
use crate::PathData;
@@ -76,6 +76,78 @@ impl ArcPath {
pub fn fraction_at(&self, p: Point) -> Option<f64> {
(self.len > 0.0).then(|| self.nearest(p)).flatten().map(|s| (s / self.len).clamp(0.0, 1.0))
}
/// The distance along the path of the middle of its topmost points (the least y) where `xf`
/// draws it: the topmost point when there is one, the middle of a level stretch (a
/// rectangle's top edge), and when several points or stretches are topmost, the middle of the
/// shortest part of the path that holds them all. None for a path with no length, or a closed
/// path whose every point is topmost.
pub fn topmost(&self, xf: Affine) -> Option<f64> {
let drawn: Vec<(PathSeg, PathSeg, f64, f64)> = self.segs.iter().map(|&(s, c, l)| (s, xf * s, c, l)).collect();
// The candidates for the least y in each segment: its ends and where it turns.
let turns = |d: &PathSeg| [0.0, 1.0].into_iter().chain(d.extrema()).collect::<Vec<f64>>();
let mut bounds: Option<kurbo::Rect> = None;
let mut top = f64::INFINITY;
for (_, d, _, _) in &drawn {
let b = d.bounding_box();
bounds = Some(bounds.map_or(b, |a| a.union(b)));
top = turns(d).into_iter().map(|t| d.eval(t).y).fold(top, f64::min);
}
let b = bounds?;
if !(top.is_finite() && b.width().is_finite() && b.height().is_finite()) {
return None;
}
// Points this close to the top count as topmost: a part of the drawn size, and no less than
// the rounding error of coordinates this far from the origin.
let tol = (1e-9 * (b.width() + b.height())).max(64.0 * f64::EPSILON * b.y0.abs().max(b.y1.abs()));
// Stretches this close along the path meet.
let near = 1e-9 * self.len;
// The topmost points as stretches of distance along the path, in order.
let mut runs: Vec<(f64, f64)> = vec![];
for (s, d, c, l) in &drawn {
let db = d.bounding_box();
if db.y1 - db.y0 <= tol && db.y0 <= top + tol {
runs.push((*c, c + l));
continue;
}
for t in turns(d) {
if d.eval(t).y <= top + tol {
let at = c + s.subsegment(0.0..t).arclen(ACCURACY).min(*l);
runs.push((at, at));
}
}
}
runs.sort_by(|a, b| a.0.total_cmp(&b.0));
// Stretches that meet or overlap are one.
let mut merged: Vec<(f64, f64)> = vec![];
for (a, z) in runs {
match merged.last_mut() {
Some(last) if a <= last.1 + near => last.1 = last.1.max(z),
_ => merged.push((a, z)),
}
}
let (first, last) = (*merged.first()?, *merged.last()?);
if !self.closed {
return Some((first.0 + last.1) * 0.5);
}
let len = self.len;
// Round a closed path, the shortest part holding every stretch leaves out the longest
// gap between two of them (the gap from the last round to the first included).
let wrap = first.0 + len - last.1;
let (mut gap, mut from, mut to) = (wrap, first.0, last.1);
for w in merged.windows(2) {
if let [a, b] = w
&& b.0 - a.1 > gap
{
(gap, from, to) = (b.0 - a.1, b.0, a.1);
}
}
if gap <= near {
return None;
}
let run = (to - from).rem_euclid(len);
Some((from + run * 0.5).rem_euclid(len))
}
}
#[cfg(test)]
@@ -99,4 +171,64 @@ mod tests {
assert!(sq.at(45.0).0.distance(sq.at(5.0).0) < 1e-6);
assert!(ArcPath::new(&PathData::default()).is_empty());
}
fn polyline(points: &[Point], closed: bool) -> PathData {
PathData::single(crate::SubPath::polyline(points, closed))
}
/// Where `topmost` puts the middle, drawn by `xf`.
fn top_point(a: &ArcPath, xf: Affine) -> Point {
xf * a.at(a.topmost(xf).unwrap()).0
}
#[test]
fn topmost_points_as_drawn() {
// A circle starts at 9 o'clock and runs clockwise (y down): its top is a quarter of the way round, its
// bottom three quarters.
let circle = ArcPath::new(&shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0)));
assert!((circle.topmost(Affine::IDENTITY).unwrap() - circle.len() * 0.25).abs() < 1e-6);
assert!((circle.topmost(Affine::FLIP_Y).unwrap() - circle.len() * 0.75).abs() < 1e-6);
// As the transform draws it: turned a quarter turn the other way, 3 o'clock is at the top.
let turned = Affine::rotate_about(-std::f64::consts::FRAC_PI_2, Point::new(50.0, 50.0));
assert!((circle.topmost(turned).unwrap() - circle.len() * 0.5).abs() < 1e-6);
// Turned part way, the top lies inside a segment.
let tilted = Affine::rotate_about(0.4, Point::new(50.0, 50.0));
assert!(top_point(&circle, tilted).distance(Point::new(50.0, 0.0)) < 0.05, "{:?}", top_point(&circle, tilted));
// An ellipse squashed and skewed by its transform.
let skewed = Affine::skew(0.5, 0.0) * Affine::scale_non_uniform(2.0, 0.5);
let p = top_point(&circle, skewed);
let lowest = (0..3600).map(|i| (skewed * circle.at(circle.len() * i as f64 / 3600.0).0).y).fold(f64::INFINITY, f64::min);
assert!((p.y - lowest).abs() < 1e-3, "{p:?} {lowest}");
// A level top: the middle of the top edge, for a rectangle and a rounded rectangle.
for path in [shapes::rectangle(Rect::new(10.0, 20.0, 110.0, 70.0)), shapes::rounded_rectangle(Rect::new(10.0, 20.0, 110.0, 70.0), 8.0)] {
let a = ArcPath::new(&path);
assert!(top_point(&a, Affine::IDENTITY).distance(Point::new(60.0, 20.0)) < 1e-6, "{:?}", top_point(&a, Affine::IDENTITY));
assert!(top_point(&a, Affine::FLIP_Y).distance(Point::new(60.0, -70.0)) < 1e-6);
}
// Far from the origin the top is still the top edge's middle.
let square = ArcPath::new(&shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)));
let far = Affine::translate((1e12, 1e12));
assert!(top_point(&square, far).distance(Point::new(1e12 + 50.0, 1e12)) < 1e-3, "{:?}", top_point(&square, far));
// A level top across the path's start: the start in the middle of the top edge.
let across = ArcPath::new(&polyline(
&[Point::new(50.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 50.0), Point::new(0.0, 50.0), Point::new(0.0, 0.0)],
true,
));
assert!(top_point(&across, Affine::IDENTITY).distance(Point::new(50.0, 0.0)) < 1e-6);
// Two peaks: the middle of the shortest part that holds both, the dip between them.
let peaks = ArcPath::new(&polyline(
&[Point::new(0.0, 10.0), Point::new(2.0, 0.0), Point::new(4.0, 5.0), Point::new(6.0, 0.0), Point::new(8.0, 10.0)],
true,
));
assert!(top_point(&peaks, Affine::IDENTITY).distance(Point::new(4.0, 5.0)) < 1e-6, "{:?}", top_point(&peaks, Affine::IDENTITY));
// An open path: the middle of its topmost points too.
let open = ArcPath::new(&polyline(&[Point::new(0.0, 10.0), Point::new(5.0, 0.0), Point::new(10.0, 10.0)], false));
assert!(top_point(&open, Affine::IDENTITY).distance(Point::new(5.0, 0.0)) < 1e-6);
// No top: a closed path that is level all round, and a path with no length.
let flat = ArcPath::new(&shapes::ellipse(Rect::new(0.0, 10.0, 100.0, 10.0)));
assert!(!flat.is_empty() && flat.topmost(Affine::IDENTITY).is_none());
assert!(ArcPath::new(&PathData::default()).topmost(Affine::IDENTITY).is_none());
let point = ArcPath::new(&polyline(&[Point::new(5.0, 5.0), Point::new(5.0, 5.0)], true));
assert!(point.topmost(Affine::IDENTITY).is_none());
}
}
+23
View File
@@ -358,6 +358,29 @@ fn save_file_waits_for_the_file_in_the_app() {
}
}
#[test]
fn readonly_save_file_keeps_the_stable_error_prefix() {
struct Refused(bool);
impl Backend for Refused {
fn call(&mut self, method: &str, params: Value) -> Result<Value, String> {
assert_eq!(method, "app.save");
assert_eq!(params.get("wait").and_then(Value::as_bool), self.0.then_some(true));
Err(vectorcraft_engine::EngineError::ReadOnlyLocation("Poster.svg: injected refusal".into()).to_string())
}
fn has_ui(&self) -> bool {
self.0
}
fn describe(&self) -> String {
"injected save refusal".into()
}
}
for desktop in [false, true] {
let r = call_tool(&mut Refused(desktop), "save_file", &json!({}));
assert!(r.is_error);
assert_eq!(r.content[0]["text"], "save_file: READ_ONLY_LOCATION: Poster.svg: injected refusal");
}
}
fn pdf_pages(pdf: &[u8]) -> usize {
let mut h = Headless::new();
h.call("engine.execute", json!({"command": "document.open", "params": {"name": "p.pdf", "dataBase64": vectorcraft_format::base64_encode(pdf)}}))
+1 -1
View File
@@ -39,7 +39,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"file.save",
"Save",
"Cmd+S",
"{path?, format?, options?, svg?: {…SVG options}} = document.save, written through the app (a document saved as SVG, PDF or .ai, or opened from one Save can write back, saves as that again, with the same options); with no path known (never saved, converted) the Save As panel asks first",
"{path?, format?, options?, svg?: {…SVG options}} = document.save, written through the app (a document saved as SVG, PDF or .ai, or opened from one Save can write back, saves as that again, with the same options); with no path known (never saved, converted) the Save As panel asks first; ordinary Save to the document's existing file refused by filesystem permissions or a read-only volume opens Save As in Documents with the same name, format and options; cancelling keeps the original path and modified state. Explicit destinations and Close/Quit keep their existing error dialog. Automation gets READ_ONLY_LOCATION: followed by the reason and no panel",
),
(
"file.place",
+17 -3
View File
@@ -505,17 +505,31 @@ fn glyphs_box(t: &vectorcraft_doc::TextObject, outset: f64) -> Option<Rect> {
/// How far the content of live object `n` (a blend, envelope or repeat) can paint past its visual
/// bounds: for each object in it, how far the effects in a symbol instance's art paint past that
/// art ([`art_effects_reach`]) and how far brush art can paint ([`crate::brush_fx::pad`]), on the
/// farthest side. 0 for any other kind of object.
/// art ([`art_effects_reach`]), how far brush art can paint ([`crate::brush_fx::pad`]) and how far
/// a path's own effects paint past it ([`path_effects_reach`]), on the farthest side. 0 for any
/// other kind of object.
fn live_content_reach(symbols: &SymbolBoxes, n: &Node) -> f64 {
if !vectorcraft_doc::live::is_live(n) {
return 0.0;
}
let mut reach = 0.0f64;
n.walk(&mut |c| reach = reach.max(art_effects_reach(symbols, c) + crate::brush_fx::pad(symbols, c)));
n.walk(&mut |c| reach = reach.max(art_effects_reach(symbols, c).max(path_effects_reach(symbols, c)) + crate::brush_fx::pad(symbols, c)));
reach
}
/// How far the effects of path or compound path `n` (a drop shadow, a glow, a geometry effect)
/// paint past its visual bounds, on its farthest side ([`visual_bounds`]): 0 when it has no
/// visible effects, and for any other kind of object.
fn path_effects_reach(symbols: &SymbolBoxes, n: &Node) -> f64 {
if !has_fx(n) {
return 0.0;
}
match (visual_bounds(symbols, n), n.visual_bounds_with(symbols)) {
(Some(c), Some(v)) => [v.x0 - c.x0, v.y0 - c.y0, c.x1 - v.x1, c.y1 - v.y1].into_iter().fold(0.0, f64::max),
_ => 0.0,
}
}
/// How far the effects in the art of symbol instance `n` (and in the art of the symbols the
/// instances in it show) paint past that art's visual bounds, on its farthest side, measured on the
/// art as the instance places it before its effects run: 0 when the art has no visible effects, and
Loaded 100 of 178 files, more files were not shown because too many files have changed in this diff. Show more