Merge main into #8061

This commit is contained in:
bflatastic committed 2026-11-19 01:20:13 +07:00
commit ea3fc0a6f3
224 files changed
+25400 -1051

No files matched your search

Generated
+16
View File
@@ -1044,6 +1044,20 @@ name = "craft-eps"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=64b181977a0488e4d1e167bc5cc8cfededc2ed4b#64b181977a0488e4d1e167bc5cc8cfededc2ed4b"
[[package]]
name = "craft-font-catalog"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=23acc704933a9a5619a5cd1cddc9bb1fb5a9b2d3#23acc704933a9a5619a5cd1cddc9bb1fb5a9b2d3"
dependencies = [
"harfrust 0.13.3",
"kurbo 0.13.1",
"skrifa 0.47.0",
"thiserror 2.0.21",
"unicode-bidi",
"unicode-segmentation",
"windows-registry",
]
[[package]]
name = "craft-fonts-build"
version = "0.1.0"
@@ -6630,6 +6644,7 @@ dependencies = [
"webbrowser",
"windows",
"winit",
"winreg",
"winresource",
"winsafe",
"wl-clipboard-rs",
@@ -7109,6 +7124,7 @@ dependencies = [
name = "vectorcraft-text"
version = "0.24.1"
dependencies = [
"craft-font-catalog",
"craft-proof",
"harfrust 0.13.3",
"icu_segmenter",
+3
View File
@@ -40,6 +40,9 @@ craft-print = { workspace = true }
[target.'cfg(windows)'.dependencies]
craft-update = { workspace = true }
clipboard-win = { workspace = true }
# Reads a print queue's Standard TCP/IP RAW port for the direct-PDF transport (src/direct_pdf.rs).
# MIT, already in the build through the update client.
winreg = "0.55"
# Which GPU drives which display (EnumDisplayDevices, src/gpu.rs), so the window is drawn on the
# GPU that shows it: drawing on a GPU without a monitor reset the display driver. Safe wrappers over
# Win32 (MIT); the `user` feature is User32.dll only. Only the wgpu renderer chooses an adapter.
+5
View File
@@ -3,6 +3,8 @@
use std::process::Command;
use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
mod direct_pdf;
pub struct SystemPrint;
impl PrintService for SystemPrint {
fn printers(&mut self) -> Vec<Printer> {
@@ -43,6 +45,9 @@ mod system {
craft_print::printers().into_iter().map(|p| Printer { name: p.name, default: p.default }).collect()
}
pub fn print(job: &PrintJob) -> Result<String, String> {
if job.direct_pdf {
return super::direct_pdf::print(job);
}
// Copies, layout, marks and colour management are already in the PDF. Preserve its
// physical sheet size and the queue's duplex default without printing copies twice.
let settings = craft_print::Job { printer: job.printer.map(str::to_string), title: job.title.into(), ..Default::default() };
+127
View File
@@ -0,0 +1,127 @@
//! Send the print-ready PDF to the printer's own PDF interpreter over its RAW TCP port.
//!
//! This is the opt-in escape hatch for large-format PCL drivers that rewrite a custom page
//! (the HP DesignJet Z5200ps V4 driver emits a square PCL page for a 1067 x 480 mm sheet). The
//! PDF already carries the paper size, so the printer's interpreter prints it as laid out.
#[cfg(windows)]
mod imp {
use std::io::Write;
use std::net::{Shutdown, TcpStream, ToSocketAddrs};
use std::time::Duration;
use vectorcraft_ui_egui::print::PrintJob;
use winreg::RegKey;
use winreg::enums::{HKEY_LOCAL_MACHINE, KEY_READ};
/// Submit one composed PDF to the selected printer's Standard TCP/IP RAW port.
pub fn print(job: &PrintJob) -> Result<String, String> {
let printer = job
.printer
.map(str::to_string)
.or_else(|| craft_print::printers().into_iter().find(|p| p.default).map(|p| p.name))
.ok_or("direct PDF needs a selected printer")?;
let (host, port) = tcp_port(&printer)?;
send(&host, port, &pjl(job.title, job.pdf))?;
Ok(format!(" (direct PDF to {host}:{port})"))
}
/// The `HostName` and port of a printer port registered as a Standard TCP/IP RAW port.
fn tcp_port(printer: &str) -> Result<(String, u16), String> {
let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
let printer_key = hklm
.open_subkey_with_flags(format!(r"SYSTEM\CurrentControlSet\Control\Print\Printers\{printer}"), KEY_READ)
.map_err(|e| format!("direct PDF: cannot read the printer settings for {printer}: {e}"))?;
let port_name: String = printer_key.get_value("Port").map_err(|e| format!("direct PDF: {printer} has no port: {e}"))?;
let port_key = hklm
.open_subkey_with_flags(format!(r"SYSTEM\CurrentControlSet\Control\Print\Monitors\Standard TCP/IP Port\Ports\{port_name}"), KEY_READ)
.map_err(|e| format!("direct PDF: {printer} does not use a Standard TCP/IP port ({port_name}): {e}"))?;
let protocol: u32 = port_key.get_value("Protocol").unwrap_or(1);
if protocol != 1 {
return Err(format!("direct PDF: {printer}'s port ({port_name}) is not a RAW TCP/IP port"));
}
let host = port_key
.get_value::<String, _>("HostName")
.ok()
.filter(|h| !h.trim().is_empty())
.or_else(|| port_key.get_value::<String, _>("IPAddress").ok().filter(|h| !h.trim().is_empty()))
.ok_or_else(|| format!("direct PDF: {printer}'s port ({port_name}) has no host address"))?;
let number = port_key.get_value::<u32, _>("PortNumber").unwrap_or(9100);
let port = u16::try_from(number).map_err(|_| format!("direct PDF: invalid port number {number}"))?;
Ok((host.trim().to_string(), port))
}
/// Frame the PDF for the printer's PJL interpreter.
fn pjl(title: &str, pdf: &[u8]) -> Vec<u8> {
let mut name: String = title.chars().map(|c| if (c.is_ascii_graphic() || c == ' ') && c != '"' { c } else { '_' }).take(80).collect();
if name.is_empty() {
name.push_str("VectorCraft");
}
let mut out = Vec::with_capacity(pdf.len() + 96);
out.extend_from_slice(b"\x1b%-12345X@PJL JOB NAME=\"");
out.extend_from_slice(name.as_bytes());
out.extend_from_slice(b"\"\r\n@PJL ENTER LANGUAGE=PDF\r\n");
out.extend_from_slice(pdf);
out.extend_from_slice(b"\r\n\x1b%-12345X@PJL EOJ\r\n");
out
}
/// Stream `data` to the first reachable address of `host:port`.
fn send(host: &str, port: u16, data: &[u8]) -> Result<(), String> {
let addrs = (host, port).to_socket_addrs().map_err(|e| format!("direct PDF: cannot resolve {host}: {e}"))?;
let mut last = None;
for addr in addrs {
match TcpStream::connect_timeout(&addr, Duration::from_secs(10)) {
Ok(mut stream) => {
stream.set_write_timeout(Some(Duration::from_secs(120))).map_err(|e| format!("direct PDF: {e}"))?;
stream.write_all(data).map_err(|e| format!("direct PDF: writing to {host}:{port} failed: {e}"))?;
stream.shutdown(Shutdown::Write).map_err(|e| format!("direct PDF: finishing {host}:{port} failed: {e}"))?;
return Ok(());
}
Err(e) => last = Some(e),
}
}
Err(match last {
Some(e) => format!("direct PDF: cannot connect to {host}:{port}: {e}"),
None => format!("direct PDF: {host}:{port} has no addresses"),
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Read;
use std::net::TcpListener;
#[test]
fn the_pjl_frames_the_pdf() {
let out = pjl("witch hat\"", b"%PDF-1.7");
let text = String::from_utf8_lossy(&out);
assert!(text.starts_with("\u{1b}%-12345X@PJL JOB NAME=\"witch hat_\"\r\n@PJL ENTER LANGUAGE=PDF\r\n"));
assert!(text.contains("%PDF-1.7"));
assert!(text.ends_with("\r\n\u{1b}%-12345X@PJL EOJ\r\n"));
}
#[test]
fn the_pdf_reaches_a_listening_port() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let t = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut got = Vec::new();
stream.read_to_end(&mut got).unwrap();
got
});
send("127.0.0.1", port, b"%PDF-1.7 test").unwrap();
assert_eq!(t.join().unwrap(), b"%PDF-1.7 test");
}
}
}
#[cfg(windows)]
pub use imp::print;
#[cfg(not(windows))]
pub fn print(_: &vectorcraft_ui_egui::print::PrintJob) -> Result<String, String> {
Err("direct PDF printing is only available on Windows".into())
}
+30
View File
@@ -312,6 +312,36 @@ impl Carry {
}
}
/// Undo the actual maps of already placed gradients. Failure only changes this temporary
/// appearance; callers retain the stored row unchanged when a map cannot be inverted.
pub(crate) fn unapply_placed(&self, ap: &mut Appearance) -> Option<()> {
for step in self.0.iter().rev() {
for item in &mut ap.items {
if !matches!(item.paint(), vectorcraft_doc::color::Paint::Gradient(_)) {
continue;
}
let map = match *step {
CarryStep::Affine { m, .. } => m,
CarryStep::Boxes { from, to } => match item {
AppearanceItem::Fill(_) => crate::reshape::box_map(from, to),
AppearanceItem::Stroke(s) => crate::reshape::box_map(s.paint_bounds(from), s.paint_bounds(to)),
},
};
if vectorcraft_doc::node::flattens(map) {
return None;
}
let inverse = map.inverse();
if !inverse.is_finite() {
return None;
}
if let vectorcraft_doc::color::Paint::Gradient(g) = item.paint_mut() {
g.transform(inverse);
}
}
}
Some(())
}
pub(crate) fn push(&mut self, more: Carry) {
self.0.extend(more.0);
self.1.extend(more.1);
+79 -25
View File
@@ -846,23 +846,19 @@ fn take_sublayer_guides(n: &mut Node, out: &mut Vec<Arc<Node>>, is_guide: &impl
take_held_guides(n, held, out, false, false);
}
/// `n`, a group or layer, as plain art: its Pathfinder effects evaluated, its geometry effects
/// reshaping all its members as one piece (the whole art's bounds as their reference box) after
/// the members' own geometry and Pathfinder effects ([`members_as_drawn`]), and its
/// own fills and strokes turned into art painting the members' geometry ([`member_shapes`]) below
/// the members (after a clipping path) or above them, as its contents slot says. Its
/// transparency, opacity mask and raster effects stay. `None` when it has none of these. Live
/// objects among the members are evaluated with the symbols of `doc` (see [`member_shapes`]), and
/// a Pathfinder operation or compound shape takes the symbol instances among its members as their
/// symbols' art from `doc`. A Transform effect that makes copies with raster effects listed before
/// it gives each copy those raster effects ([`copied_container`]).
pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
struct PreparedContainer {
m: Node,
guides: Vec<Arc<Node>>,
paint: bool,
carry: crate::Carry,
}
/// The existing container pass up to its own rows becoming art. Keep its carried appearance for
/// rendering, and retain the same Carry for freezing only missing stored placements separately.
fn prepare_container(doc: Option<&Document>, n: &Node) -> Option<PreparedContainer> {
if !is_container(n) {
return None;
}
if let Some(t) = crate::reshape::copied_container_raster_at(n) {
return Some(copied_container(doc, n, t));
}
let pathfinder = has_pathfinder(n);
let fx = crate::reshape::geometry_effects(n);
let paint = has_own_paint(n);
@@ -870,6 +866,7 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
return None;
}
let mut m = n.clone();
let mut carry = crate::Carry::default();
// Its ruler guides take no part: they go back above the evaluated art at the end. With effects
// that replace or copy the art, so do its guides among the art and those in its sublayers and
// groups, which would otherwise go with that art: they stay on `n`, in order, hidden and
@@ -896,7 +893,7 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
let _later = crate::raster::LaterGroups::enter(&n.appearance.effects);
members_as_drawn(doc, &mut m);
}
let carry = crate::reshape::reshape_leaves_carrying(&mut m, &fx, &n.appearance.effects, doc);
carry = crate::reshape::reshape_leaves_carrying(&mut m, &fx, &n.appearance.effects, doc);
// The group's own fills and strokes paint the members as a whole: their gradients follow
// the effects as the members' do.
if paint && carry.moves(&m.appearance) {
@@ -905,6 +902,27 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
}
m.appearance.effects = crate::raster::without_geometry(&m.appearance.effects);
m.appearance.effects.retain(|e| !is_pathfinder(&e.id));
Some(PreparedContainer { m, guides, paint, carry })
}
/// `n`, a group or layer, as plain art: its Pathfinder effects evaluated, its geometry effects
/// reshaping all its members as one piece (the whole art's bounds as their reference box) after
/// the members' own geometry and Pathfinder effects ([`members_as_drawn`]), and its
/// own fills and strokes turned into art painting the members' geometry ([`member_shapes`]) below
/// the members (after a clipping path) or above them, as its contents slot says. Its
/// transparency, opacity mask and raster effects stay. `None` when it has none of these. Live
/// objects among the members are evaluated with the symbols of `doc` (see [`member_shapes`]), and
/// a Pathfinder operation or compound shape takes the symbol instances among its members as their
/// symbols' art from `doc`. A Transform effect that makes copies with raster effects listed before
/// it gives each copy those raster effects ([`copied_container`]).
pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
if !is_container(n) {
return None;
}
if let Some(t) = crate::reshape::copied_container_raster_at(n) {
return Some(copied_container(doc, n, t));
}
let PreparedContainer { mut m, guides, paint, .. } = prepare_container(doc, n)?;
if paint {
// A clip group whose clipping type paints strokes is now a group of a clip group and those
// strokes ([`crate::reshape::paint_type_clip`]): its own fills and strokes paint inside
@@ -931,16 +949,8 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
Some(m)
}
/// `n`, a group or layer whose own effects split at `t` ([`crate::reshape::copied_container_raster_at`]),
/// as plain art: the effects before the Transform effect at `t` evaluated on its members as one
/// piece ([`evaluate_container`]), with the raster effects among them, and that piece copied by the
/// Transform effect, each copy a group of its own carrying those raster effects moved, turned,
/// reflected and scaled with it ([`crate::reshape::copied_container_art`]). The art keeps the kind,
/// transparency and opacity mask of `n` and the raster effects from `t` on, which paint once around
/// all the copies; a clip group's or clipping layer's copies each clip, and the art itself does not.
/// Its ruler guides, those in its sublayers and groups included, go once above the copies, hidden
/// and locked as their containers were.
fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
/// The exact pre-copy source shared by rendering and stored gradient placement.
fn copied_container_source(doc: Option<&Document>, n: &Node, t: usize) -> (Node, Vec<Arc<Node>>, Node) {
let mut m = n.clone();
let mut guides = vec![];
take_sublayer_guides(&mut m, &mut guides, &Node::is_ruler_guide);
@@ -955,6 +965,20 @@ fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
let _later = crate::raster::LaterGroups::enter(&n.appearance.effects);
members_as_drawn(doc, &mut source);
}
(m, guides, source)
}
/// `n`, a group or layer whose own effects split at `t` ([`crate::reshape::copied_container_raster_at`]),
/// as plain art: the effects before the Transform effect at `t` evaluated on its members as one
/// piece ([`evaluate_container`]), with the raster effects among them, and that piece copied by the
/// Transform effect, each copy a group of its own carrying those raster effects moved, turned,
/// reflected and scaled with it ([`crate::reshape::copied_container_art`]). The art keeps the kind,
/// transparency and opacity mask of `n` and the raster effects from `t` on, which paint once around
/// all the copies; a clip group's or clipping layer's copies each clip, and the art itself does not.
/// Its ruler guides, those in its sublayers and groups included, go once above the copies, hidden
/// and locked as their containers were.
fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
let (mut m, guides, source) = copied_container_source(doc, n, t);
let mut piece = evaluate_container(doc, &source).unwrap_or_else(|| {
let mut p = source.clone();
p.appearance.effects = crate::raster::without_geometry(&p.appearance.effects);
@@ -988,6 +1012,36 @@ fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
m
}
/// Freeze representable fitted own paints to the box the container pass gives them, retaining
/// every live effect and already explicit placement. Hidden-only containers the pass does not
/// evaluate stay unchanged; this does not add a different fallback to `evaluate_container`.
pub fn pinned_container_appearance(doc: &Document, n: &Node) -> Option<Appearance> {
if !n.appearance.has_unplaced_gradient() {
return None;
}
if let Some(t) = crate::reshape::copied_container_raster_at(n) {
let (_, _, source) = copied_container_source(Some(doc), n, t);
let pinned = pinned_container_appearance(doc, &source)?;
let mut out = (*n.appearance).clone();
out.items = pinned.items;
return Some(out);
}
let PreparedContainer { m, carry, .. } = prepare_container(Some(doc), n)?;
let bounds = m.geometric_bounds()?;
let mut out = (*n.appearance).clone();
let mut changed = false;
for (item, original) in out.items.iter_mut().zip(&n.appearance.items) {
if paints(original)
&& matches!(original.paint(), Paint::Gradient(g) if !g.is_placed())
&& let Some(pinned) = crate::pinned_gradient_item(original, bounds, &[&carry])
{
*item = pinned;
changed = true;
}
}
changed.then_some(out)
}
/// Replace each visible member of `n` with geometry or Pathfinder effects of its own, at every
/// depth of its groups and layers, by the art it draws ([`evaluate_container`],
/// [`crate::reshape::own_effects_art`]), so the geometry effects of `n` reshape what its members
+3 -1
View File
@@ -45,6 +45,7 @@ mod lighting_presets;
mod live;
mod marks;
pub mod pixel;
mod placement;
pub mod preview;
mod raster;
mod reshape;
@@ -75,12 +76,13 @@ pub use bake::{
pub use clip::{WarpSeams, clip_outline, knockout_silhouette, reshaped_clip_outline, warp_pieces_translucent};
pub use group::{
OutlineHook, PATHFINDER_EFFECTS, compound_shape_area, compound_shape_art, evaluate_container, has_container_appearance, has_pathfinder,
is_pathfinder, member_leaves, member_shapes, paints, pathfinder_children, shape_art,
is_pathfinder, member_leaves, member_shapes, paints, pathfinder_children, pinned_container_appearance, shape_art,
};
pub use lighting_presets::{LIGHTING_PRESETS, LightingPreset, lighting_preset_params, matching_lighting_preset};
pub use live::{expand_live, expand_live_deep, expanded_live_group, outline_object, text_outliner};
pub use marks::{CROP_MARKS, crop_marks_art, has_crop_marks};
pub use pixel::{PIXEL_EFFECTS, PixelFx, PixelSpace};
pub use placement::pinned_gradient_item;
pub use raster::{
RASTERIZE, RasterFx, Rasterize, color_param, follow_items, item_effects_in, outset, raster_effects, rasterize_stage, stage_maps, staged_effects,
without_geometry,
+74
View File
@@ -0,0 +1,74 @@
//! Conservative stored placements for gradients fitted by the existing effects passes.
use vectorcraft_doc::color::{GradientKind, GradientPaint, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem};
use vectorcraft_geom::Rect;
use crate::Carry;
/// Freeze one fitted gradient at the evaluated row's geometric bounds, before its live effects.
/// `carries` are the actual object and item passes, in rendering order. Only missing placement
/// fields are returned; explicit coordinates and the row's other data stay unchanged. A map or
/// model that cannot reproduce the original resolved row returns `None`, leaving it fitted.
pub fn pinned_gradient_item(item: &AppearanceItem, bounds: Rect, carries: &[&Carry]) -> Option<AppearanceItem> {
if gradient(item)?.is_placed() {
return Some(item.clone());
}
if ![bounds.x0, bounds.y0, bounds.x1, bounds.y1].iter().all(|v| v.is_finite()) {
return None;
}
let resolved = resolve(item, bounds, carries);
if !finite_placement(resolved.items.first()?) {
return None;
}
let mut stored = resolved.clone();
for carry in carries.iter().rev() {
carry.unapply_placed(&mut stored)?;
}
if !finite_placement(stored.items.first()?) {
return None;
}
let candidate = missing_placement(item, stored.items.first()?)?;
let replayed = resolve(&candidate, bounds, carries);
(finite_placement(replayed.items.first()?) && replayed.approx_eq(&resolved)).then_some(candidate)
}
fn gradient(item: &AppearanceItem) -> Option<&GradientPaint> {
match item.paint() {
Paint::Gradient(g) => Some(g),
_ => None,
}
}
fn resolve(item: &AppearanceItem, bounds: Rect, carries: &[&Carry]) -> Appearance {
let mut ap = Appearance { items: vec![item.clone()], ..Default::default() };
for carry in carries {
carry.apply(&mut ap);
}
ap.pin_gradients(bounds);
ap
}
fn missing_placement(item: &AppearanceItem, placed: &AppearanceItem) -> Option<AppearanceItem> {
let original = gradient(item)?;
let placed = gradient(placed)?;
let mut out = item.clone();
let Paint::Gradient(g) = out.paint_mut() else { return None };
if original.geom.is_none() {
g.geom = placed.geom;
}
if original.gradient.kind == GradientKind::Freeform && !original.has_freeform_points() {
let freeform = placed.freeform.as_ref()?;
match &mut g.freeform {
Some(f) => f.points.clone_from(&freeform.points),
None => g.freeform = Some(freeform.clone()),
}
}
Some(out)
}
fn finite_placement(item: &AppearanceItem) -> bool {
let Some(g) = gradient(item) else { return false };
g.geom.is_none_or(|v| v.start.is_finite() && v.end.is_finite() && v.aspect.is_finite() && v.focal.is_none_or(|p| p.is_finite()))
&& g.freeform.as_ref().is_none_or(|f| f.points.iter().all(|p| p.at.is_finite()))
}
+1 -1
View File
@@ -3505,7 +3505,7 @@ pub(crate) fn follow_boxes(ap: &mut Appearance, from: Rect, to: Rect) {
/// The map that takes box `from` onto box `to` along each axis (along an axis `from` has no extent
/// on, a move from its center to `to`'s).
fn box_map(from: Rect, to: Rect) -> vectorcraft_geom::Affine {
pub(crate) fn box_map(from: Rect, to: Rect) -> vectorcraft_geom::Affine {
let axis = |a0: f64, a1: f64, b0: f64, b1: f64| {
if (a1 - a0).abs() > 1e-12 {
let s = (b1 - b0) / (a1 - a0);
+9 -1
View File
@@ -99,12 +99,13 @@ pub(crate) mod symboledit;
pub mod symbollib;
pub(crate) mod tabs;
mod textedit;
mod xmlattrs;
pub use textedit::effective_kerning;
mod retype;
pub mod textstyles;
pub(crate) mod textwrap;
pub(crate) mod threads;
pub mod toast;
pub(crate) mod typecmd;
mod typemenu;
mod variablecmds;
@@ -322,6 +323,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(pathops::specs());
v.extend(compoundshape::specs());
v.extend(typecmd::specs());
v.extend(retype::specs());
v.extend(menucmds::specs());
v.extend(live::specs());
v.extend(colorcmds::specs());
@@ -334,6 +336,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(compositefonts::specs());
v.extend(fontfiles::specs());
v.extend(help::specs());
v.extend(toast::specs());
v.extend(threads::specs());
v.extend(textwrap::specs());
v.extend(graph::specs());
@@ -876,6 +879,9 @@ pub use xform::{AppearanceAttrs, EyedropperAttrs, EyedropperOptions, FillAttrs,
/// The shape modes of the selected compound-shape members (the Pathfinder panel lights theirs).
pub use compoundshape::selected_member_modes;
/// Make Compound Shape's warning when a member is an open path that encloses no area.
pub use compoundshape::OPEN_PATHS_ADD_NO_AREA;
/// Pathfinder Options (`Prefs::pathfinder`).
pub use pathops::{PATHFINDER_PRECISION_RANGE, PathfinderOptions};
@@ -903,6 +909,8 @@ pub(crate) use buildcmds::TracePresetChanges;
/// The shapes a group selected alone gives the Pathfinder panel.
pub use pathops::shape_count;
/// The tile counts Create Object Mosaic would use (the dialog's Use Ratio button sets them).
pub use menucmds::mosaic_counts;
/// The Shape Mode commands' warning when a selected open path encloses no area.
pub use pathops::SHAPE_MODE_OPEN_PATH_NO_AREA;
+1 -1
View File
@@ -38,7 +38,7 @@ mod shape_builder;
mod trace;
pub use live_paint::live_paint_gaps;
pub(crate) use live_paint::{isolated_live_paint, merge_drawn_in_isolation};
pub(crate) use live_paint::{LivePaintMove, check_part_name, clear_part_name, isolated_live_paints, merge_drawn_in_isolation};
use live_paint::{lp_expand, lp_fill, lp_gap_options, lp_info, lp_make, lp_merge, lp_release, lp_stroke_edge};
use shape_builder::{sb_merge, sb_regions};
pub(crate) use trace::TracePresetChanges;
+241 -12
View File
@@ -1,8 +1,8 @@
use super::{
Appearance, AppearanceItem, Arc, Beside, Document, EDGE_NAME, EngineError, FACE_NAME, GapOptions, GapSize, LIVE_PAINT_NAME, Node, NodeId,
PathData, Point, Rect, Result, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite, fit_to_old_edge, ids_json,
is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids, source_nodes, source_shapes,
switch_or,
PathData, Point, Rect, Result, SOURCES_NAME, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite,
fit_to_old_edge, ids_json, is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids,
source_nodes, source_shapes, switch_or,
};
/// `options` as stored on a Live Paint group: none for the defaults.
@@ -74,6 +74,44 @@ fn set_parts(g: &mut Node, mut parts: Vec<Arc<Node>>, gone: &[NodeId]) {
}
}
/// Whether a path named `name` directly in a Live Paint group is one of its faces or edges: the
/// name is [`FACE_NAME`] or [`EDGE_NAME`].
fn part_name(name: Option<&str>) -> bool {
matches!(name, Some(FACE_NAME | EDGE_NAME))
}
/// Whether `n` is a path whose parent `parent` is a Live Paint group.
fn path_in_live_paint(d: &Document, parent: Option<NodeId>, n: &Node) -> bool {
n.path_data().is_some() && parent.and_then(|p| d.node(p)).is_some_and(is_live_paint)
}
/// Clear the name of `n`, put directly in `parent`, when it is a path named like a face or an edge
/// ([`part_name`]) and `parent` is a Live Paint group, so that the group's other children
/// ([`others_in`]) keep it when its faces and edges are made again. Paste uses it.
pub(crate) fn clear_part_name(d: &Document, parent: Option<NodeId>, n: &mut Node) {
if part_name(n.name.as_deref()) && path_in_live_paint(d, parent, n) {
n.name = None;
}
}
/// Refuse naming rows `ids` `name` when it is the name of a face or an edge ([`part_name`]) and one
/// of them is a path directly in a Live Paint group that is not named `name` already. Checked
/// before anything changes.
pub(crate) fn check_part_name(d: &Document, ids: &[NodeId], name: &str) -> Result<()> {
if !part_name(Some(name)) {
return Ok(());
}
for id in ids {
if let Some(n) = d.node(*id)
&& n.name.as_deref() != Some(name)
&& path_in_live_paint(d, d.parent_of(*id), n)
{
return Err(EngineError::Other("`Face` and `Edge` name the faces and edges of a Live Paint group: give the path another name".into()));
}
}
Ok(())
}
/// Select `ids` alone, without an undo step, when they are not selected that way already.
fn select_only(s: &mut Session, ids: &[NodeId]) -> Result<()> {
let st = s.doc()?;
@@ -149,11 +187,16 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
.ok_or_else(|| EngineError::Other("Live Paint Merge: select a Live Paint group and the paths to add".into()))?;
check_live_paint_takes(d, roots)?;
let old = d.node(target).cloned().ok_or(EngineError::NoNode(target))?;
// The rows that join are children of the group already when Merge runs after a drag, and a joining
// path named like a face or an edge is not one of the group's parts.
let mut old_parts = old.clone();
if let Some(ch) = old_parts.children_mut() {
ch.retain(|c| !roots.contains(&c.id));
}
// Paint to carry over: (point inside face, paint) for faces that draw; edges are matched to the
// old edges below.
let keep_faces: Vec<(Point, Carried)> =
b::faces(&old).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
let old_parts = old.clone();
b::faces(&old_parts).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
let mut sources = source_nodes(&old);
// The objects drawn in the other Live Paint groups besides their parts stay in the merged group.
let mut others = vec![];
@@ -227,19 +270,22 @@ pub(super) fn lp_merge(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
}
/// The Live Paint group whose drawn art is added when isolation mode leaves `isolated`: the innermost
/// Live Paint group that is `isolated` or holds it, such as a group drawn in an isolated Live Paint
/// group and then isolated itself. None when `isolated` is not in a Live Paint group.
pub(crate) fn isolated_live_paint(d: &Document, isolated: NodeId) -> Option<NodeId> {
d.ancestry(isolated)?.into_iter().rev().find(|id| d.node(*id).is_some_and(is_live_paint))
/// The Live Paint groups whose drawn art can be added when isolation mode leaves `isolated`, innermost
/// first: every Live Paint group that is `isolated` or holds it, such as a group drawn in an isolated
/// Live Paint group and then isolated itself, and the group it was drawn in. Empty when `isolated` is
/// not in a Live Paint group.
pub(crate) fn isolated_live_paints(d: &Document, isolated: NodeId) -> Vec<NodeId> {
d.ancestry(isolated).unwrap_or_default().into_iter().rev().filter(|id| d.node(*id).is_some_and(is_live_paint)).collect()
}
/// The children of Live Paint group `g` besides its parts ([`others_in`]) that Live Paint takes
/// ([`b::live_paint_takes`]) and that are shown and unlocked with everything in them, back to
/// front: the paths drawn in it in isolation mode.
/// front: the paths drawn in it in isolation mode. A Live Paint group's sources group, which is
/// always hidden, does not count.
fn drawn_in(g: &Node) -> Vec<NodeId> {
fn open(n: &Node) -> bool {
n.visible && !n.locked && n.children().is_none_or(|ch| ch.iter().all(|c| open(c)))
let src = b::sources(n).filter(|_| is_live_paint(n)).map(|s| s.id);
n.visible && !n.locked && n.children().is_none_or(|ch| ch.iter().filter(|c| Some(c.id) != src).all(|c| open(c)))
}
others_in(g).filter(|c| open(c) && b::live_paint_takes(c)).map(|c| c.id).collect()
}
@@ -259,6 +305,189 @@ pub(crate) fn merge_drawn_in_isolation(s: &mut Session, g: NodeId) -> Result<boo
Ok(true)
}
/// Where a row sits for Live Paint: among the paths of a Live Paint group (in its sources group,
/// at any depth), directly in a Live Paint group, or neither.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Spot {
Source(NodeId),
In(NodeId),
Outside,
}
/// The [`Spot`] of a row whose parent is `parent` (None: the top level).
fn spot_in(d: &Document, parent: Option<NodeId>) -> Spot {
let Some(p) = parent else { return Spot::Outside };
for x in d.ancestry(p).unwrap_or_default().into_iter().rev() {
let n = d.node(x);
if n.is_some_and(is_live_paint) {
return if x == p { Spot::In(x) } else { Spot::Outside };
}
if let Some(g) = d.parent_of(x)
&& d.node(g).filter(|n| is_live_paint(n)).and_then(b::sources).is_some_and(|s| s.id == x)
{
return Spot::Source(g);
}
}
Spot::Outside
}
/// The Live Paint groups that hold Live Paint group `g` among their paths (in their sources group,
/// at any depth), innermost first.
fn enclosing_live_paints(d: &Document, g: NodeId) -> Vec<NodeId> {
let mut out = vec![];
let mut at = g;
while let Spot::Source(o) = spot_in(d, d.parent_of(at)) {
if out.contains(&o) {
break;
}
out.push(o);
at = o;
}
out
}
/// What moving rows in the Layers panel (`layer.move`, `node.move`) does to Live Paint groups.
/// Rows that go into a Live Paint group from elsewhere are added to it as `livePaint.merge` adds
/// paths. Rows that go into or leave a group's paths (its sources group) change those paths, and
/// the group's faces and edges are made again from them, keeping the paint of the faces and edges
/// that stay, and so are those of every Live Paint group that holds a changed group among its
/// paths. Rows moved within one group's paths, or among a group's own children, change no faces.
pub(crate) struct LivePaintMove {
/// The Live Paint group the rows go into, and for each row whether it joins the group's paths.
join: Option<(NodeId, Vec<bool>)>,
/// The Live Paint group the rows go among the children of, with its sources group as it is
/// before the move.
keep_sources: Option<(NodeId, NodeId)>,
/// The Live Paint groups whose paths change.
rebuild: Vec<NodeId>,
}
impl LivePaintMove {
/// Plan moving `rows` (with `copy`, copies of them) into `parent`, before anything changes.
/// Refuses rows Live Paint can't take ([`b::live_paint_takes`]) that would go among a group's
/// paths, with the message Make and Merge give.
pub(crate) fn plan(d: &Document, rows: &[NodeId], parent: Option<NodeId>, copy: bool) -> Result<Self> {
let to = spot_in(d, parent);
let from: Vec<Spot> = rows.iter().map(|r| if copy { Spot::Outside } else { spot_in(d, d.parent_of(*r)) }).collect();
let mut rebuild = vec![];
for f in &from {
if let Spot::Source(g) = *f
&& *f != to
&& !rebuild.contains(&g)
{
rebuild.push(g);
}
}
if let Spot::Source(g) = to
&& from.iter().any(|f| *f != to)
&& !rebuild.contains(&g)
{
rebuild.push(g);
}
let entering: Vec<NodeId> = rows.iter().zip(&from).filter(|(_, f)| **f != to).map(|(r, _)| *r).collect();
let join = match to {
Spot::In(g) if !entering.is_empty() => Some((g, from.iter().map(|f| *f != to).collect())),
_ => None,
};
if to != Spot::Outside {
check_live_paint_takes(d, &entering)?;
}
let keep_sources = match to {
Spot::In(g) => d.node(g).and_then(b::sources).map(|s| (g, s.id)),
_ => None,
};
Ok(Self { join, keep_sources, rebuild })
}
/// Whether rows join a Live Paint group, which makes the move a "Merge Live Paint" step.
pub(crate) fn joins(&self) -> bool {
self.join.is_some()
}
/// After the rows were moved, now `moved` (in the order [`LivePaintMove::plan`] took them),
/// make the faces and edges of the groups whose paths changed again, and add the rows that
/// joined a group to it. → `moved` with the joined rows replaced by their group, once, and
/// without the faces and edges that were made again.
pub(crate) fn finish(self, d: &mut Document, sel: &mut Selection, moved: &[NodeId]) -> Result<Vec<NodeId>> {
// A moved object named like the sources group may now sit before it, where a lookup by name
// finds the object first. The group's own sources group goes back in front.
if let Some((g, src)) = self.keep_sources {
let ch = d.children_mut(Some(g))?;
if let Some(at) = ch.iter().position(|c| c.id == src)
&& ch[..at].iter().any(|c| c.name.as_deref() == Some(SOURCES_NAME))
{
let s = ch.remove(at);
ch.insert(0, s);
}
}
if self.join.is_none() && self.rebuild.is_empty() {
return Ok(moved.to_vec());
}
// The group the rows join is made again by the merge below, from its paths as they are now
// and with the paint of its faces and edges as they were before the move.
let join_group = self.join.as_ref().map(|(g, _)| *g);
// A Live Paint group among another group's paths gives that group its faces and edges, so
// the groups holding a changed group among their paths are made again too, innermost first.
let mut groups: Vec<NodeId> = vec![];
for g in self.rebuild.iter().copied().chain(join_group) {
for x in std::iter::once(g).chain(enclosing_live_paints(d, g)) {
if !groups.contains(&x) {
groups.push(x);
}
}
}
groups.sort_by_cached_key(|g| std::cmp::Reverse(d.ancestry(*g).map_or(0, |a| a.len())));
let joined: Vec<NodeId> = match &self.join {
Some((_, mask)) => moved.iter().zip(mask).filter(|(_, j)| **j).map(|(r, _)| *r).collect(),
None => vec![],
};
for g in groups {
if Some(g) == join_group {
let roots: Vec<NodeId> = std::iter::once(g).chain(joined.iter().copied()).collect();
merge_live(d, sel, &roots)?;
} else if d.node(g).is_some() {
rebuild_paths(d, g)?;
}
}
let Some((g, mask)) = self.join else { return Ok(moved.iter().copied().filter(|r| d.node(*r).is_some()).collect()) };
// `moved` holds each row once, so only the group can come twice. Faces and edges of the
// group moved along with the joining rows were made again, so they are left out.
let mut out = vec![];
let mut listed = false;
for (r, j) in moved.iter().zip(&mask) {
if *j {
if !listed {
out.push(g);
listed = true;
}
} else if d.node(*r).is_some() {
out.push(*r);
}
}
Ok(out)
}
}
/// Make Live Paint group `g`'s faces and edges again from the paths its sources group holds now,
/// with its Gap Options, carrying over the paint of the faces and edges that stay. With no path
/// left, the group keeps its sources group and its other children, and has no faces or edges.
fn rebuild_paths(d: &mut Document, g: NodeId) -> Result<()> {
let old = d.node(g).cloned().ok_or(EngineError::NoNode(g))?;
let sources = source_nodes(&old);
let mut n = old.clone();
if source_shapes(&sources).0.is_empty() {
let src = b::sources(&old).cloned().ok_or(EngineError::NoNode(g))?;
set_parts(&mut n, vec![src], &[]);
} else {
let (children, _, _) = build_children(d, sources, old.gap_options().max_gap())?;
set_parts(&mut n, children, &[]);
repaint_from(&mut n, &old);
}
let mut changed = Beside::replacing(d, &[g]);
changed.put(d, g, vec![n])?;
changed.finish(d)
}
fn live_targets(s: &Session, p: &Value) -> Result<Vec<NodeId>> {
let d = &s.doc()?.doc;
let ids = root_ids(s, p)?;
+46 -2
View File
@@ -8,6 +8,8 @@ use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind, ShapeMode};
use vectorcraft_geom::{FillRule, PathData, SubPath};
use vectorcraft_pathops as po;
use vectorcraft_render::effects;
use super::edit::{roots_of, selected_roots};
@@ -16,6 +18,10 @@ use super::{CommandSpec, EngineError, Result, Session, bad, cmd, has_multi};
const MODE_NAMES: [&str; 4] = ["add", "subtract", "intersect", "exclude"];
/// Make Compound Shape's warning, which the status bar shows, when a member holds a line or another
/// open path that encloses no area once closed, and so contributes no area to the shape.
pub const OPEN_PATHS_ADD_NO_AREA: &str = "a line or other open path that encloses no area contributes no area to the compound shape; to include it, apply Object › Path › Outline Stroke to it first";
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
@@ -23,7 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Make Compound Shape",
["Window", "Pathfinder"],
None,
"{ids?: [id…] (selected first; default: the selection), mode?: \"add\"|\"subtract\"|\"intersect\"|\"exclude\" (default add; Alt-clicking a Shape Mode button gives its mode)} the two or more selected objects (paths, compound paths, groups, compound shapes, type, blends, envelopes) become the members of one compound shape, each with the shape mode, in their stacking order where the frontmost was: it draws as the area they make from the backmost up (open paths closed; a blend as its steps, an envelope as its distorted art, an object with a warp or other geometry effect as it draws), painted with the appearance and transparency of the topmost member in Add, Intersect or Exclude mode (with every member in Subtract, the backmost), and the members stay editable (Direct Selection, Layers panel, isolation mode) → {id}",
"{ids?: [id…] (selected first; default: the selection), mode?: \"add\"|\"subtract\"|\"intersect\"|\"exclude\" (default add; Alt-clicking a Shape Mode button gives its mode)} the two or more selected objects (paths, compound paths, groups, compound shapes, type, blends, envelopes) become the members of one compound shape, each with the shape mode, in their stacking order where the frontmost was: it draws as the area they make from the backmost up (open paths closed; a blend as its steps, an envelope as its distorted art, an object with a warp or other geometry effect as it draws), painted with the appearance and transparency of the topmost member in Add, Intersect or Exclude mode (with every member in Subtract, the backmost), and the members stay editable (Direct Selection, Layers panel, isolation mode) → {id, warning?: when a member is or holds a line or another open path that encloses no area once closed, and so contributes no area}",
has_multi,
make
),
@@ -157,6 +163,7 @@ fn make(s: &mut Session, p: &Value) -> Result<Value> {
// all have `mode`, the topmost, or the backmost when they all subtract.
let order: Vec<&Node> = if mode == ShapeMode::Subtract { members } else { members.into_iter().rev().collect() };
let hook = |c: &Node| effects::outline_object(Some(d), c);
let no_area = order.iter().any(|n| adds_no_area(d, n, &hook));
let style = order.into_iter().find_map(|n| top_style(d, n, &hook));
let id = s.edit("Make Compound Shape", |d, sel| {
let gid = d.alloc_id();
@@ -179,7 +186,44 @@ fn make(s: &mut Session, p: &Value) -> Result<Value> {
sel.set([id]);
Ok(id)
})?;
Ok(json!({ "id": id.0 }))
let mut out = json!({ "id": id.0 });
if no_area {
out["warning"] = json!(OPEN_PATHS_ADD_NO_AREA);
}
Ok(out)
}
/// Member `n` holds an open path that adds no area to a compound shape: one of the paths it takes
/// part as ([`effects::member_leaves`]), inside a group or a compound path too, has an open subpath
/// that encloses no area once closed (a straight line, or an evenodd contour traced twice), or it
/// has an open subpath and its subpaths, all closed, enclose no area together (open evenodd
/// subpaths that cancel one another or a closed subpath). The area is the one the path's fill rule
/// gives, which also keeps a self-crossing path whose signed area is zero (a bow tie) from the
/// warning, as Divide measures it. An area that can't be measured gives no warning.
fn adds_no_area(d: &Document, n: &Node, hook: effects::OutlineHook) -> bool {
effects::member_leaves(Some(d), n, Some(hook)).iter().any(|leaf| {
let (paths, rule): (Vec<&PathData>, FillRule) = match &leaf.kind {
NodeKind::Compound { children, rule } => (children.iter().filter_map(|c| c.path_data()).collect(), *rule),
NodeKind::Path { path, rule, .. } => (vec![path], *rule),
_ => return false,
};
let subpaths: Vec<&SubPath> = paths.iter().flat_map(|p| &p.subpaths).collect();
if subpaths.iter().all(|sp| sp.closed) {
return false;
}
let closed = |sp: &SubPath| {
let mut sp = sp.clone();
sp.closed = true;
sp
};
// An area that can't be measured counts as an area, so a failed measurement gives no warning.
let no_area = |p: PathData| po::try_area(&p, rule).is_ok_and(|a| a <= 0.0);
subpaths.iter().filter(|sp| !sp.closed).any(|sp| {
// The signed-area test alone only holds for nonzero: evenodd can fill nothing where
// the signed area is not zero (a contour traced twice).
!(rule == FillRule::NonZero && po::encloses_area(sp)) && no_area(PathData::single(closed(sp)))
}) || (subpaths.len() > 1 && no_area(PathData::new(subpaths.iter().map(|sp| closed(sp)).collect())))
})
}
/// The paint and transparency of the frontmost shape `n` adds to a compound shape's area, from the
+1 -1
View File
@@ -92,7 +92,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Eraser",
[],
None,
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths lose its area, and open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths and filled open paths without a visible painted stroke lose its area, and other open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
has_doc,
erase_region
),
+32 -4
View File
@@ -345,18 +345,46 @@ pub(super) fn target_paths(doc: &Document, sel: &Selection, area: Rect) -> Vec<N
out
}
/// Any visible non-None fill, including one below a topmost None.
pub(super) fn has_fill(n: &Node) -> bool {
n.appearance.items.iter().any(|item| item.is_fill() && item.visible() && !item.paint().is_none())
}
/// A visible painted stroke keeps open paths on the existing outline-erasure route.
pub(super) fn has_painted_stroke(n: &Node) -> bool {
n.appearance.items.iter().any(
|item| matches!(item, vectorcraft_doc::AppearanceItem::Stroke(stroke) if stroke.visible && !stroke.paint.is_none() && stroke.width > 0.0),
)
}
/// A container stroke that paints this target's open geometry. A clipping container's own
/// paint follows its clipping outline, and a compound shape paints its combined area instead.
/// Neither makes its descendants' implicit fill-closing edges into new stroked edges.
pub(super) fn has_painted_ancestor_stroke(doc: &Document, id: NodeId) -> bool {
doc.ancestry(id)
.unwrap_or_default()
.into_iter()
.rev()
.skip(1)
.filter_map(|id| doc.node(id))
.take_while(|node| !node.clips() && !node.is_compound_shape())
.any(|node| matches!(node.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) && has_painted_stroke(node))
}
/// [`target_paths`] for the tools that cut fills, with each target's geometry and fill rule: the
/// members of a compound path whose members are all closed paths give the compound path itself,
/// once, so its fill (holes included) is cut as one shape under its own fill rule.
pub(super) fn fill_targets(doc: &Document, sel: &Selection, area: Rect) -> Result<Vec<(NodeId, PathData, FillRule)>> {
let closed_compound = |n: &Node| {
/// With `open_fills`, an open compound with a visible fill and no painted visible stroke does too.
pub(super) fn fill_targets(doc: &Document, sel: &Selection, area: Rect, open_fills: bool) -> Result<Vec<(NodeId, PathData, FillRule)>> {
let area_compound = |n: &Node| {
let filled = open_fills && has_fill(n) && !has_painted_stroke(n) && !has_painted_ancestor_stroke(doc, n.id);
matches!(&n.kind, NodeKind::Compound { children, .. }
if children.iter().all(|c| matches!(&c.kind, NodeKind::Path { path, .. } if path.is_closed())))
if children.iter().all(|c| matches!(&c.kind, NodeKind::Path { path, .. } if path.is_closed() || filled)))
};
let editable = doc.editable();
let mut out: Vec<(NodeId, PathData, FillRule)> = vec![];
for id in target_paths(doc, sel, area) {
let compound = doc.parent_of(id).and_then(|p| doc.node(p)).filter(|p| closed_compound(p) && editable(p.id));
let compound = doc.parent_of(id).and_then(|p| doc.node(p)).filter(|p| area_compound(p) && editable(p.id));
let target = compound.map_or(id, |c| c.id);
if out.iter().any(|t| t.0 == target) {
continue;
+71 -13
View File
@@ -1,10 +1,11 @@
use super::common::{
PenRecord, SIZE_VARIATIONS, SIZES, Sample, center_strokes, dist_to_polyline, fill_targets, ids_json, path_mut, path_of, points_param,
poly_bounds, pressure_region, ranged, replace_with_pieces, samples_param, sibling_with, size_pressure, target_paths, usize_opt,
PenRecord, SIZE_VARIATIONS, SIZES, Sample, center_strokes, dist_to_polyline, fill_targets, has_fill, has_painted_ancestor_stroke,
has_painted_stroke, ids_json, path_mut, path_of, points_param, poly_bounds, pressure_region, ranged, replace_with_pieces, samples_param,
set_geometry, sibling_with, size_pressure, target_paths, usize_opt,
};
use super::{
Anchor, AnchorKind, Beside, BezPath, BoolOp, Cap, EngineError, FillRule, Join, NodeId, Paint, ParamCurve, PathData, Point, Rect, Result, Session,
SubPath, Value, Vec2, bad, eraser_area, eraser_tip, f64_or, fill_contains, json, number_or, object_param, po,
Anchor, AnchorKind, Beside, BezPath, BoolOp, Cap, Document, EngineError, FillRule, Join, NodeId, NodeKind, Paint, ParamCurve, PathData, Point,
Rect, Result, Session, SubPath, Value, Vec2, bad, eraser_area, eraser_tip, f64_or, fill_contains, json, number_or, object_param, po,
};
use kurbo::{CubicBez, Line, PathSeg};
use vectorcraft_brush::{Brush, BrushKind, Calligraphic, Variation};
@@ -266,7 +267,7 @@ pub(super) fn knife(s: &mut Session, p: &Value) -> Result<Value> {
let st = s.doc()?;
let strip = po::outline_stroke(&PathData::single(SubPath::polyline(&pts, false)), KNIFE_GAP, Cap::Butt, Join::Round, 4.0);
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, 1.0))? {
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, 1.0), false)? {
if !pd.is_closed() {
continue;
}
@@ -340,8 +341,9 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
None => dist_to_polyline(&round, squash * q) <= r,
};
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach))? {
if pd.is_closed() {
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach), true)? {
if erase_as_area(&st.doc, id, &pd) {
let pd = eraser_fill_operand(pd);
if po::area(&po::boolean(&pd, rule, &region, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 {
continue;
}
@@ -353,6 +355,34 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
apply_plan(s, "Eraser", plan)
}
/// Whether the target is erased as filled area rather than as an open outline.
fn erase_as_area(doc: &Document, id: NodeId, pd: &PathData) -> bool {
// An unaggregated compound member keeps the outline route: its own appearance does not
// paint it. Eligible fill-only compounds were collected as one parent target above.
let compound_member =
doc.parent_of(id).and_then(|parent| doc.node(parent)).is_some_and(|parent| matches!(parent.kind, NodeKind::Compound { .. }));
let filled_open =
!compound_member && !has_painted_ancestor_stroke(doc, id) && doc.node(id).is_some_and(|node| has_fill(node) && !has_painted_stroke(node));
pd.is_closed() || filled_open
}
/// Close only Eraser's temporary fill operand, preserving an open path's straight closing edge.
fn eraser_fill_operand(mut pd: PathData) -> PathData {
for sp in &mut pd.subpaths {
if !sp.closed {
// These endpoint handles are unused by an open path. Closing it must not activate them.
if let Some(first) = sp.anchors.first_mut() {
first.h_in = first.p;
}
if let Some(last) = sp.anchors.last_mut() {
last.h_out = last.p;
}
sp.closed = true;
}
}
pd
}
/// `path.eraseRegion`'s `rect: [x, y, width, height]`: four finite numbers, with a width and a
/// height above 0.
fn marquee_param(v: &Value, cmd: &str) -> Result<Rect> {
@@ -369,7 +399,7 @@ fn marquee_param(v: &Value, cmd: &str) -> Result<Rect> {
}
/// `path.eraseRegion` with a marquee: everything inside `r` is erased from the paths (selected, or
/// all). Closed paths lose the rectangle's area, and open paths are cut where they cross its edges.
/// all). Closed paths and fill-only open paths lose the rectangle's area; other open paths are cut where they cross its edges.
fn erase_rect(s: &mut Session, r: Rect) -> Result<Value> {
let region =
PathData::single(SubPath::polyline(&[Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)], true));
@@ -392,8 +422,9 @@ fn erase_rect(s: &mut Session, r: Rect) -> Result<Value> {
};
let st = s.doc()?;
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, r)? {
if pd.is_closed() {
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, r, true)? {
if erase_as_area(&st.doc, id, &pd) {
let pd = eraser_fill_operand(pd);
if po::area(&po::boolean(&pd, rule, &region, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 {
continue;
}
@@ -492,8 +523,9 @@ fn erase_varied(s: &mut Session, samples: &[Sample], tip: [f64; 3], vary: [(Vari
let short = low(2).max(MIN_BRUSH_SIZE) * low(1).clamp(1.0, 100.0) / 100.0;
let reach = (size + sv) / 2.0;
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach))? {
if pd.is_closed() {
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach), true)? {
if erase_as_area(&st.doc, id, &pd) {
let pd = eraser_fill_operand(pd);
if po::area(&po::boolean(&pd, rule, &region, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 {
continue;
}
@@ -510,10 +542,36 @@ fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, Vec<PathData>)>)
return Ok(json!({ "ids": [] }));
}
let ids = s.edit(label, |d, sel| {
// Measure every original painting owner before any geometry or appearance changes.
// This includes a Compound above a Path Eraser target and containers above live art.
let owners: std::collections::BTreeSet<_> = plan.iter().flat_map(|(id, _)| d.ancestry(*id).unwrap_or_default()).collect();
let pinned: Vec<_> = owners
.into_iter()
.filter_map(|id| {
let node = d.node(id)?;
if !node.appearance.has_unplaced_gradient() {
return None;
}
vectorcraft_render::pinned_appearance_for_geometry_edit(d, node).map(|appearance| (id, appearance))
})
.collect();
for (id, appearance) in pinned {
if let Some(node) = d.node_mut(id) {
node.appearance = appearance.into();
}
}
let mut all = vec![];
let mut cut = Beside::replacing(d, &plan.iter().map(|(id, _)| *id).collect::<Vec<_>>());
for (id, pieces) in plan {
all.extend(replace_with_pieces(d, &mut cut, id, pieces)?);
let clipping_path = d.position(id).is_some_and(|(parent, i, _)| i == 0 && parent.and_then(|p| d.node(p)).is_some_and(|p| p.clips()));
if clipping_path {
// Keep every clipping contour in its original first child slot. An empty mask
// must also stay there so the clipped artwork cannot become the new mask.
set_geometry(d, id, PathData::new(pieces.into_iter().flat_map(|p| p.subpaths).collect()))?;
all.push(id);
} else {
all.extend(replace_with_pieces(d, &mut cut, id, pieces)?);
}
}
cut.finish(d)?;
sel.set(all.iter().copied());
+1
View File
@@ -1611,6 +1611,7 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
}
} else {
super::object::keep_pixel_aligned(&mut c, sc);
super::buildcmds::clear_part_name(d, par, &mut c);
new_ids.push(d.insert(par, idx, c)?);
}
}
+17 -1
View File
@@ -19,6 +19,18 @@ pub(super) const OPTIONS: &[FormatOption] = &[super::ARTBOARD, super::ARTBOARDS,
/// Encode `doc` as `kind`: the chosen artboard (default the first), or with `use_artboards` one
/// picture per chosen artboard (default all).
pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kind: Kind) -> Result<Encoded> {
encode_flattening(doc, p, use_artboards, kind, crate::flatten_raster_effects)
}
/// [`encode`] with `flatten` turning raster effects into images. The chosen artboards are checked
/// first, so an export that is refused does not call `flatten`.
pub(super) fn encode_flattening(
doc: &Document,
p: &Value,
use_artboards: Option<bool>,
kind: Kind,
flatten: impl FnOnce(&Document) -> Option<Document>,
) -> Result<Encoded> {
let f = super::format(kind.id()).ok_or_else(|| bad(C, "no metafile format"))?;
let pick: ArtboardPick = super::encode::options(f, p)?;
let n = doc.artboards.len();
@@ -26,12 +38,16 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kin
Some(true) => pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect()),
_ => vec![pick.one(n).map_err(|e| bad(C, e))?],
};
if boards.is_empty() {
return Err(bad(C, "the document has no artboard"));
}
let rects = boards
.iter()
.map(|&b| doc.artboards.get(b).map(|a| a.rect).ok_or_else(|| bad(C, format!("no artboard {}", b + 1))))
.collect::<Result<Vec<_>>>()?;
vectorcraft_metafile::check_regions(&rects).map_err(|e| bad(C, e))?;
// Raster effects (shadows, glows, blurs) as images, as PDF export does.
let flat = crate::flatten_raster_effects(doc);
let flat = flatten(doc);
let src = flat.as_ref().unwrap_or(doc);
let outs = vectorcraft_metafile::export_regions(src, &rects, kind).map_err(|e| bad(C, e))?;
let mut enc = Encoded::default();
@@ -95,6 +95,65 @@ fn raster_effects_are_written_as_images() {
assert!(kinds.contains(&114), "the shadow is an image with transparency");
}
/// An export refused for an empty or non-finite artboard among the chosen ones, or for no
/// artboard, gives the same error as before and turns no raster effect into an image; an export
/// that goes ahead does so once, and writes what `document.export` writes.
#[test]
fn a_refused_export_turns_no_raster_effects_into_images() {
use vectorcraft_geom::Rect;
use vectorcraft_metafile::Kind;
let mut s = two_boards();
let id = s.execute("shape.rectangle", &json!({"x": 50, "y": 50, "width": 30, "height": 30})).unwrap()["id"].clone();
s.execute("effect.apply", &json!({"effect": "stylize.dropShadow", "ids": [id]})).unwrap();
let doc = s.doc().unwrap().doc.as_ref().clone();
let run = |doc: &vectorcraft_doc::Document, p: Value, kind: Kind| {
let mut calls = 0;
let r = super::metafile::encode_flattening(doc, &p, Some(true), kind, |d| {
calls += 1;
crate::flatten_raster_effects(d)
});
(r.map(|e| e.files).map_err(|e| e.to_string()), calls)
};
for kind in [Kind::Emf, Kind::Wmf] {
let (files, calls) = run(&doc, json!({}), kind);
assert_eq!(calls, 1, "{kind:?}");
let files = files.unwrap();
assert_eq!(files.len(), 2, "{kind:?}");
let r = s.execute("document.export", &json!({"format": kind.id(), "useArtboards": true})).unwrap();
let written: Vec<Vec<u8>> = r["files"].as_array().unwrap().iter().map(b64).collect();
assert_eq!(files.into_iter().map(|(_, b)| b).collect::<Vec<_>>(), written, "{kind:?}");
// The first artboard is fine; the second is empty, or has a corner that isn't finite.
let x = doc.artboards[0].rect.x1 + 10.0;
for empty in [Rect::new(x, 0.0, x, 100.0), Rect::new(0.0, 0.0, f64::NAN, 100.0), Rect::new(0.0, 0.0, 100.0, f64::INFINITY)] {
let mut bad_doc = doc.clone();
bad_doc.artboards[1].rect = empty;
for p in [json!({}), json!({"artboards": [0, 1]}), json!({"artboards": [1]})] {
let (files, calls) = run(&bad_doc, p.clone(), kind);
let e = files.err().unwrap_or_default();
assert!(e.contains("the export region is empty"), "{kind:?} {p}: {e}");
assert_eq!(calls, 0, "{kind:?} {p}");
}
}
// Reversed corners are an artboard like any other.
let mut flipped = doc.clone();
let r1 = flipped.artboards[1].rect;
flipped.artboards[1].rect = Rect::new(r1.x1, r1.y1, r1.x0, r1.y0);
let (files, calls) = run(&flipped, json!({}), kind);
assert_eq!((files.map(|f| f.len()), calls), (Ok(2), 1), "{kind:?}");
// No artboard to write.
let mut none = doc.clone();
none.artboards.clear();
let (files, calls) = run(&none, json!({}), kind);
let e = files.err().unwrap_or_default();
assert!(e.contains("the document has no artboard"), "{kind:?}: {e}");
assert_eq!(calls, 0, "{kind:?}");
}
// Through the command, the refusal reads as it did.
std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).artboards[1].rect = Rect::new(0.0, 0.0, 0.0, 100.0);
let e = s.execute("document.export", &json!({"format": "emf", "useArtboards": true})).unwrap_err().to_string();
assert!(e.contains("the export region is empty"), "{e}");
}
/// Two placed images whose pixel data can't be decoded are left out of an EMF or WMF, and
/// `warnings` holds the note raster exports give, once, without naming either image's key.
#[test]
+2 -19
View File
@@ -19,23 +19,6 @@ use crate::DocState;
const MAX_FONTS: usize = 1_000;
/// The longest family or style name listed or given (bytes).
const MAX_NAME: usize = 256;
/// The CSS generic font families (CSS Fonts Module Level 4), which SVG and HTML files name in place
/// of a font and no font file provides; compared in any ASCII case. The list leaves out
/// `fangsong`, which is also the family name of a Chinese font (FangSong).
const GENERIC_FAMILIES: &[&str] = &[
"serif",
"sans-serif",
"monospace",
"cursive",
"fantasy",
"system-ui",
"ui-serif",
"ui-sans-serif",
"ui-monospace",
"ui-rounded",
"math",
"emoji",
];
/// The longest folder path given (bytes).
const MAX_PATH: usize = 4096;
/// The most files one `text.addFontFiles` copies: as many as a search keeps.
@@ -105,10 +88,10 @@ pub struct MissingFont {
/// The fonts the type of `d` uses, in its layers, symbols and patterns, opacity masks included (a composite font's parts, those
/// its characters are drawn in, in place of its name), that aren't available as named (sorted by family and style, each once whatever version its type names; at most 1000). CSS generic families such as `sans-serif`
/// ([`GENERIC_FAMILIES`]) and names longer than 256 bytes are left out.
/// ([`vectorcraft_text::GENERIC_FAMILIES`]) and names longer than 256 bytes are left out.
pub fn missing_fonts(d: &Document) -> Vec<MissingFont> {
let db = FontDb::global();
let generic = |family: &str| GENERIC_FAMILIES.iter().any(|g| g.eq_ignore_ascii_case(family.trim()));
let generic = vectorcraft_text::is_generic_family;
let mut used: Vec<(String, String)> = super::fonts::used_fonts(d).into_iter().map(|(family, style, _)| (family, style)).collect();
// Sorted by family and style: the versions type names of one face are neighbors.
used.dedup();
+34 -7
View File
@@ -13,6 +13,7 @@ use serde_json::{Value, json};
use vectorcraft_doc::{Artboard, ArtboardSide, Document, LAYER_COLORS, LayerColor, Node, NodeId, NodeKind, Scaling};
use vectorcraft_geom::{Affine, Rect};
use super::buildcmds::LivePaintMove;
use super::{
CommandSpec, Result, Session, bad, bool_or, check_numbers, check_switches, checked_id, checked_ids_param, checked_node, checked_nodes_param, cmd,
color_value, f64_or, has_doc, has_selection, ids_param, index, object_param, ok, str_param, switch_or,
@@ -83,7 +84,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Layer Options…",
["Window", "Layers"],
None,
"{ids?|id? (default: the highlighted rows, else the current layer), name? (with prefs.identifyObjectsBy xmlId: a valid XML ID, stored as the object name), visible?, locked?, template?, printable?, preview?, dimImages?: 0..100|false, color?: index 0..26|\"#rrggbb\"|preset name (a hex color with an alpha part, #rrggbbaa or #rgba, is an error)} Layer Options; rows that are not layers take name, visible and locked, and `ids` may name ruler guides (their `guide.list` id), which hide or lock on their own. Template on also locks the layer and dims its images to 50% (unless given); off unlocks it and stops dimming. One undo step",
"{ids?|id? (default: the highlighted rows, else the current layer), name? (with prefs.identifyObjectsBy xmlId: a valid XML ID, stored as the object name), visible?, locked?, template?, printable?, preview?, dimImages?: 0..100|false, color?: index 0..26|\"#rrggbb\"|preset name (a hex color with an alpha part, #rrggbbaa or #rgba, is an error)} Layer Options; rows that are not layers take name, visible and locked, and `ids` may name ruler guides (their `guide.list` id), which hide or lock on their own. Template on also locks the layer and dims its images to 50% (unless given); off unlocks it and stops dimming. A path directly in a Live Paint group can't take the name Face or Edge, which name the group's faces and edges, unless it has it already. One undo step",
has_doc,
set_props
),
@@ -110,7 +111,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Rows",
[],
None,
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies, which may also go above or below a row they copy (the target among `ids`). Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies, which may also go above or below a row they copy (the target among `ids`). A row that goes into a Live Paint group from elsewhere joins its paths as livePaint.merge adds them, and the group is selected (paths, compound paths, groups of them and Live Paint groups; anything else is refused and nothing moves); a row that goes into or leaves a Live Paint group's paths makes the group's faces and edges again, keeping the paint of those that stay. Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids} (a row that joined a Live Paint group is listed as the group)",
has_doc,
move_rows
),
@@ -119,7 +120,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Reorder",
[],
None,
"{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers; an Intertwine group takes and gives up members as layer.move does), deselecting every selected object left hidden or locked (the key object too)",
"{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers; an Intertwine group takes and gives up members as layer.move does), deselecting every selected object left hidden or locked (the key object too); a Live Paint group or its paths take a row as layer.move does",
has_doc,
move_node
),
@@ -625,12 +626,22 @@ fn highlight(s: &mut Session, p: &Value) -> Result<Value> {
"add" | "toggle" => {}
other => return Err(bad(C, format!("mode is set, add or toggle, not `{other}`"))),
}
// `rows` keeps the highlight order. With more than 8 ids, `held` holds the same rows as a set and
// answers each lookup; with fewer, each lookup searches `rows`.
let mut held: Option<HashSet<NodeId>> = (ids.len() > 8).then(|| rows.iter().copied().collect());
let mut last = None;
for id in ids {
if mode == "toggle" && rows.contains(&id) {
let has = held.as_ref().map_or_else(|| rows.contains(&id), |h| h.contains(&id));
if mode == "toggle" && has {
rows.retain(|r| *r != id);
} else if !rows.contains(&id) {
if let Some(h) = &mut held {
h.remove(&id);
}
} else if !has {
rows.push(id);
if let Some(h) = &mut held {
h.insert(id);
}
last = Some(id);
}
}
@@ -651,6 +662,10 @@ fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
if ids.is_empty() {
return Err(bad(C, "no rows"));
}
if let Some(v) = str_param(p, "name").filter(|v| !v.trim().is_empty()) {
let name = if xml_id { vectorcraft_doc::xml_id::to_object_name(v) } else { v.to_string() };
super::buildcmds::check_part_name(&s.doc()?.doc, &ids, &name)?;
}
s.edit("Layer Options", |d, sel| {
for id in &ids {
apply_options(d.node_mut(*id).ok_or(EngineError::NoNode(*id))?, p, xml_id);
@@ -807,7 +822,15 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
if parent.is_some_and(|p| locked_within(d, p)) {
return Err(EngineError::Other("the layer or group is locked".into()));
}
let label = if copy { "Duplicate Rows" } else { "Move Rows" };
// Rows that go into a Live Paint group join its paths, as Live Paint › Merge adds them.
let live_paint = LivePaintMove::plan(d, &ids, parent, copy)?;
let label = if live_paint.joins() {
"Merge Live Paint"
} else if copy {
"Duplicate Rows"
} else {
"Move Rows"
};
// Where each moved row comes from (a copy has a new id, so it comes from nowhere), and the
// Intertwine groups it leaves.
let from: std::collections::HashMap<NodeId, Option<NodeId>> = ids.iter().map(|i| (*i, d.parent_of(*i))).collect();
@@ -848,6 +871,7 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
}
let placed: Vec<(NodeId, Option<NodeId>)> = out.iter().map(|o| (*o, from.get(o).copied().flatten())).collect();
super::intertwine::settle_members(d, &placed, &left)?;
let out = live_paint.finish(d, sel, &out)?;
sel.prune(d);
sel.deselect_uneditable(d);
Ok(out)
@@ -870,11 +894,14 @@ fn move_node(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(what) = super::intertwine::refused_in(d, parent, n) {
return Err(bad(C, format!("{what} can't be intertwined")));
}
let live_paint = LivePaintMove::plan(d, &[id], parent, false)?;
let label = if live_paint.joins() { "Merge Live Paint" } else { "Reorder" };
let from = d.parent_of(id);
let left = super::intertwine::groups_of(d, &[id]);
s.edit("Reorder", |d, sel| {
s.edit(label, |d, sel| {
d.move_node(id, parent, index)?;
super::intertwine::settle_members(d, &[(id, from)], &left)?;
live_paint.finish(d, sel, &[id])?;
sel.prune(d);
sel.deselect_uneditable(d);
Ok(())
+3 -2
View File
@@ -132,7 +132,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Locate Object",
["Window", "Layers"],
None,
"{id?, layersOnly?} (default: the last selected object) highlight the object's row; the Layers panel opens the layers around it and scrolls to it, also when the row was already highlighted →{id, ancestry: [layer…, id]}. layersOnly (default false; the panel sends true while Show Layers Only is on, as Locate Layer) highlights the innermost layer or sublayer holding the object instead, or a layer id itself → {id: layer, objectId, ancestry: [layer…]}",
"{id?, layersOnly?} (default: the frontmost selected object in the stacking order) highlight the object's row; the Layers panel opens the layers around it and scrolls to it, also when the row was already highlighted → {id, ancestry: [layer…, id]}. layersOnly (default false; the panel sends true while Show Layers Only is on, as Locate Layer) highlights the innermost layer or sublayer holding the object instead, or a layer id itself → {id: layer, objectId, ancestry: [layer…]}",
has_doc,
locate
),
@@ -437,7 +437,8 @@ fn locate(s: &mut Session, p: &Value) -> Result<Value> {
let id = object_param(p, "id", "layer.locate")?;
let layers_only = switch_or(p, "layersOnly", false, "layer.locate")?;
let st = s.doc_mut()?;
let id = id.or_else(|| st.selection.objects.last().copied()).ok_or_else(|| bad("layer.locate", "nothing selected"))?;
// With no id, the frontmost selected object in the stacking order, whatever order it was selected in.
let id = id.or_else(|| st.selection.in_paint_order(&st.doc).last().copied()).ok_or_else(|| bad("layer.locate", "nothing selected"))?;
let mut ancestry = st.doc.ancestry(id).ok_or(EngineError::NoNode(id))?;
if layers_only {
// Locate Layer: the innermost layer or sublayer holding the object (a layer locates itself).
+126 -16
View File
@@ -133,7 +133,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Create Object Mosaic…",
["Object"],
None,
"{columns=10, rows=10 (whole numbers, kept within 1..1000), width?, height? (new size in pt; default the image's), spacingX=0, spacingY=0 (pt between tiles), gray?: bool, deleteRaster?: bool} a group of rectangles coloured by the selected image's average tile colours → {id, tiles}",
"{columns=10, rows=10 (whole numbers, kept within 1..1000), width?, height? (new size in pt, 0.1..1000000; default the image's), percentages?: bool (width and height are percentages of the image's size, default 100), constrain?: \"width\"|\"height\"|null (Constrain Ratio: the mosaic keeps the image's proportions, the named side's size leads and the other side's is worked out from it, both growing or shrinking in proportion to keep the sizes within 0.1..1000000), useRatio?: bool|\"width\"|\"height\" (square tiles as drawn, spacing taken off: the count on the side named, or with true on the constrained side, columns by default, stays and the other is the count, 1..1000, whose tiles come closest to square), spacingX=0, spacingY=0 (pt between tiles), gray?: bool, deleteRaster?: bool} a group of rectangles colored by the selected image's average tile colors → {id, tiles, columns, rows}",
has_image,
object_mosaic
),
@@ -970,7 +970,23 @@ pub(crate) fn has_image(s: &Session) -> std::result::Result<(), String> {
}
}
fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
/// What `object.createObjectMosaic` makes from its params: the image, the tile counts, the tiles'
/// placement, their size and spacing in image pixels, and the options.
struct MosaicPlan {
id: NodeId,
im: ImageObject,
cols: u32,
rows: u32,
xf: Affine,
tile: (f64, f64),
gap: (f64, f64),
gray: bool,
delete: bool,
}
/// The mosaic `object.createObjectMosaic` would make from `p`, worked out without decoding the
/// image or changing the document.
fn mosaic_plan(s: &Session, p: &Value) -> Result<MosaicPlan> {
const C: &str = "object.createObjectMosaic";
let st = s.doc()?;
let id = st
@@ -980,28 +996,97 @@ fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
.copied()
.find(|id| matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Image(_))))
.ok_or_else(|| bad(C, "select an image"))?;
let node = st.doc.node(id).cloned().ok_or(EngineError::NoNode(id))?;
let node = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
let NodeKind::Image(im) = &node.kind else { return Err(bad(C, "select an image")) };
let blob = st.doc.images.get(&im.key).filter(|b| !b.bytes.is_empty()).ok_or_else(|| bad(C, "the image has no embedded pixels"))?;
let raster = vectorcraft_trace::Raster::decode(&blob.bytes).map_err(|e| bad(C, e.to_string()))?;
let cols = whole_or(p, "columns", 10, C)?.clamp(1, 1000) as u32;
let rows = whole_or(p, "rows", 10, C)?.clamp(1, 1000) as u32;
if !st.doc.images.get(&im.key).is_some_and(|b| !b.bytes.is_empty()) {
return Err(bad(C, "the image has no embedded pixels"));
}
let mut cols = whole_or(p, "columns", 10, C)?.clamp(1, 1000) as u32;
let mut rows = whole_or(p, "rows", 10, C)?.clamp(1, 1000) as u32;
let gray = switch_or(p, "gray", false, C)?;
let colors = vectorcraft_trace::mosaic(&raster, cols, rows);
let percentages = switch_or(p, "percentages", false, C)?;
// A side named "width" (true) or "height" (false), as `constrain` and `useRatio` take it.
let side = |key: &str, v: &Value, also: &str| match v.as_str() {
Some("width") => Ok(true),
Some("height") => Ok(false),
_ => Err(bad(C, format!("`{key}` must be one of {}", format_args!("\"width\", \"height\"{also} or null")))),
};
let constrain = match p.get("constrain") {
None | Some(Value::Null) => None,
Some(v) => Some(side("constrain", v, "")?),
};
// Use Ratio's kept side: true keeps Constrain Ratio's side (the width when it is left out).
let use_ratio = match p.get("useRatio") {
None | Some(Value::Null | Value::Bool(false)) => None,
Some(Value::Bool(true)) => Some(constrain.unwrap_or(true)),
Some(v) => Some(side("useRatio", v, ", true, false")?),
};
// Tiles in image space, placed by the image transform (scaled to a new size if asked).
let b = node.geometric_bounds().ok_or_else(|| bad(C, "image has no bounds"))?;
check_numbers(p, &["width", "height", "spacingX", "spacingY"], C)?;
let (nw, nh) = (f64_or(p, "width", b.width()).max(0.1), f64_or(p, "height", b.height()).max(0.1));
let resize = Affine::translate(b.origin().to_vec2())
* Affine::scale_non_uniform(nw / b.width().max(1e-9), nh / b.height().max(1e-9))
* Affine::translate(-b.origin().to_vec2());
let (bw, bh) = (b.width().max(1e-9), b.height().max(1e-9));
// A size given (pt, or % of the image's) is from 0.1 to 1,000,000; one left out is the image's.
let size = |key: &str, base: f64| -> Result<f64> {
let Some(x) = p.get(key).and_then(Value::as_f64) else { return Ok(base) };
let (min, max) = (0.1, 1_000_000.0);
if !(min..=max).contains(&x) {
return Err(bad(C, format!("`{key}` must be between {min} and {max} (got {x})")));
}
Ok(if percentages { base * x / 100.0 } else { x })
};
let (mut nw, mut nh) = (size("width", bw)?, size("height", bh)?);
// Constrain Ratio keeps the image's proportions: the named side leads and the other follows.
match constrain {
Some(true) => nh = nw * bh / bw,
Some(false) => nw = nh * bw / bh,
None => {}
}
// A size under 0.1 pt grows to 0.1 pt, in proportion while Constrain Ratio keeps it. A side
// Constrain Ratio works out above 1,000,000 pt shrinks to 1,000,000 pt, the other with it.
let (nw, nh) = match constrain {
Some(_) => {
let k = (0.1 / nw.min(nh)).max(1.0).min(1_000_000.0 / nw.max(nh));
// Proportions over 10,000,000 to 1 leave no size with both sides within the range.
if nw.min(nh) * k < 0.1 * (1.0 - 1e-9) {
return Err(bad(C, "the image's proportions leave no size with both sides between 0.1 and 1000000 pt"));
}
(nw * k, nh * k)
}
None => (nw.max(0.1), nh.max(0.1)),
};
let resize = Affine::translate(b.origin().to_vec2()) * Affine::scale_non_uniform(nw / bw, nh / bh) * Affine::translate(-b.origin().to_vec2());
let xf = resize * im.xf;
let (tw, th) = (im.width as f64 / cols as f64, im.height as f64 / rows as f64);
// Spacing is in points; convert to image pixels along each axis.
// Points per image pixel along each of the image's axes (the image may be turned).
let ppx = (xf * Point::new(1.0, 0.0) - xf * Point::ZERO).hypot().max(1e-9);
let ppy = (xf * Point::new(0.0, 1.0) - xf * Point::ZERO).hypot().max(1e-9);
let (gx, gy) = ((f64_or(p, "spacingX", 0.0).max(0.0) / ppx).min(tw * 0.9), (f64_or(p, "spacingY", 0.0).max(0.0) / ppy).min(th * 0.9));
let (sx, sy) = (f64_or(p, "spacingX", 0.0).max(0.0), f64_or(p, "spacingY", 0.0).max(0.0));
let (iw, ih) = (im.width as f64, im.height as f64);
// Use Ratio: square tiles as drawn, spacing taken off, from the count on the kept side,
// measured along the image's axes.
match use_ratio {
Some(true) => rows = mosaic_square_count(cols, iw * ppx, ih * ppy, sx, sy),
Some(false) => cols = mosaic_square_count(rows, ih * ppy, iw * ppx, sy, sx),
None => {}
}
let (tw, th) = (iw / cols as f64, ih / rows as f64);
// Spacing is in points; convert to image pixels along each axis.
let gap = ((sx / ppx).min(tw * 0.9), (sy / ppy).min(th * 0.9));
let delete = switch_or(p, "deleteRaster", false, C)?;
Ok(MosaicPlan { id, im: im.as_ref().clone(), cols, rows, xf, tile: (tw, th), gap, gray, delete })
}
/// The tile counts (columns, rows) `object.createObjectMosaic` would use with `p`, Use Ratio
/// included, without making the mosaic (the dialog's Use Ratio button shows them).
pub fn mosaic_counts(s: &Session, p: &Value) -> Result<(u32, u32)> {
mosaic_plan(s, p).map(|m| (m.cols, m.rows))
}
fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "object.createObjectMosaic";
let MosaicPlan { id, im, cols, rows, xf, tile: (tw, th), gap: (gx, gy), gray, delete } = mosaic_plan(s, p)?;
let blob = s.doc()?.doc.images.get(&im.key).ok_or_else(|| bad(C, "the image has no embedded pixels"))?;
let raster = vectorcraft_trace::Raster::decode(&blob.bytes).map_err(|e| bad(C, e.to_string()))?;
let colors = vectorcraft_trace::mosaic(&raster, cols, rows);
let (gid, n) = s.edit("Create Object Mosaic", |d, sel| {
let mut tiles = vec![];
for r in 0..rows {
@@ -1039,7 +1124,32 @@ fn object_mosaic(s: &mut Session, p: &Value) -> Result<Value> {
sel.set([gid]);
Ok((gid, n))
})?;
Ok(json!({ "id": gid.0, "tiles": n }))
Ok(json!({ "id": gid.0, "tiles": n, "columns": cols, "rows": rows }))
}
/// The tile count along one side of an Object Mosaic whose tiles, as drawn, come closest to square
/// (Use Ratio): `kept` tiles span `kept_len` on the other side, and this side is `other_len` long.
/// Each tile is its cell less the gap on its side (`kept_gap`, `other_gap`), and a gap takes at
/// most 90% of a cell, as the tiles are drawn. Within 1..1000, the smaller count on a tie; all
/// lengths in points.
pub(crate) fn mosaic_square_count(kept: u32, kept_len: f64, other_len: f64, kept_gap: f64, other_gap: f64) -> u32 {
let drawn = |len: f64, n: u32, gap: f64| {
let cell = len / n.max(1) as f64;
cell - gap.max(0.0).min(cell * 0.9)
};
let side = drawn(kept_len, kept, kept_gap);
if !(side.is_finite() && side > 0.0 && other_len.is_finite() && other_len > 0.0) {
return 1;
}
// A tile on this side shrinks as the count grows: find the first count whose tile is no wider
// than `side`, then take it or the count before it, whichever is closer.
let (mut lo, mut hi) = (1u32, 1000u32);
while lo < hi {
let mid = (lo + hi) / 2;
if drawn(other_len, mid, other_gap) > side { lo = mid + 1 } else { hi = mid }
}
let off = |n: u32| (drawn(other_len, n, other_gap) - side).abs();
if lo > 1 && off(lo - 1) <= off(lo) { lo - 1 } else { lo }
}
fn polygon_path(pts: &[Point]) -> PathData {
+12 -7
View File
@@ -371,16 +371,21 @@ pub(super) fn isolate(s: &mut Session, p: &Value) -> Result<Value> {
}
/// Leaving isolation mode in `isolated` for `next` (None: out of isolation mode) adds the paths drawn
/// in the Live Paint group isolation put new art in to that group, as `livePaint.merge` does, in one
/// undo step ([`crate::cmd::buildcmds::merge_drawn_in_isolation`]), unless `next` is that group or is
/// inside it; → the group when paths were added.
/// in each Live Paint group that is `isolated` or holds it to that group, as `livePaint.merge` does,
/// innermost group first, one undo step per group ([`crate::cmd::buildcmds::merge_drawn_in_isolation`]).
/// A group that `next` is or is inside is skipped, since isolation stays in it. → the outermost group
/// that paths were added to.
fn add_drawn_live_paint(s: &mut Session, isolated: NodeId, next: Option<NodeId>) -> Result<Option<NodeId>> {
let d = &s.doc()?.doc;
let Some(g) = crate::cmd::buildcmds::isolated_live_paint(d, isolated) else { return Ok(None) };
if next.is_some_and(|n| d.ancestry(n).is_some_and(|a| a.contains(&g))) {
return Ok(None);
let stays = next.and_then(|n| d.ancestry(n)).unwrap_or_default();
let left: Vec<NodeId> = crate::cmd::buildcmds::isolated_live_paints(d, isolated).into_iter().filter(|g| !stays.contains(g)).collect();
let mut added = None;
for g in left {
if crate::cmd::buildcmds::merge_drawn_in_isolation(s, g)? {
added = Some(g);
}
}
Ok(crate::cmd::buildcmds::merge_drawn_in_isolation(s, g)?.then_some(g))
Ok(added)
}
pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
+2 -2
View File
@@ -250,7 +250,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Exit Isolation Mode",
[],
None,
"{all?: bool (default false)} leave isolation mode; from an isolated sublayer, go up one level to its parent layer instead (the next call goes up again), unless all is true or the parent layer is hidden or locked; no undo step for the move up; while a symbol is edited, a group isolated in its art goes back to the symbol's layer first, with or without all; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same",
"{all?: bool (default false)} leave isolation mode; from an isolated sublayer, go up one level to its parent layer instead (the next call goes up again), unless all is true or the parent layer is hidden or locked; no undo step for the move up; while a symbol is edited, a group isolated in its art goes back to the symbol's layer first, with or without all; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same. Leaving a Live Paint group drawn in another isolated Live Paint group, and that group too, does this for each, innermost first, one undo step each",
has_doc,
exit_isolation
),
@@ -259,7 +259,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Object Properties",
[],
None,
"{ids?|id?, name?, visible?, locked? (visible: false or locked: true deselects every selected object hidden or locked after the call, the key object included), opacity?: 0..100, blend?: \"Multiply\"…, isolate?, knockout?: \"on\"|\"off\"|\"neutral\"|bool (true = on, false = neutral), knockoutShape?: bool, data?: {key: \"value\" | null (removes it)} (the object's own data, SVG data-* attributes: {pivot: \"100,180\"} is data-pivot; document.node → attrs.data)}. On a path directly in a graph series, the graph also stores the object's opacity and blend mode, and on a series group the group's opacity, blend mode, isolate, knockout and knockoutShape (exceptions: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring, the graph stores that object's opacity and blend mode for every label or line of its kind",
"{ids?|id?, name?, visible?, locked? (visible: false or locked: true deselects every selected object hidden or locked after the call, the key object included), opacity?: 0..100, blend?: \"Multiply\"…, isolate?, knockout?: \"on\"|\"off\"|\"neutral\"|bool (true = on, false = neutral), knockoutShape?: bool, data?: {key: \"value\" | null (removes it)} (the object's own data, SVG data-* attributes: {pivot: \"100,180\"} is data-pivot; document.node → attrs.data)}. On a path directly in a graph series, the graph also stores the object's opacity and blend mode, and on a series group the group's opacity, blend mode, isolate, knockout and knockoutShape (exceptions: docs/mcp.md); on a graph label, or a graph's axis line, tick mark or radar ring, the graph stores that object's opacity and blend mode for every label or line of its kind. A path directly in a Live Paint group can't take the name Face or Edge, which name the group's faces and edges, unless it has it already",
has_doc,
set_props
),
+3
View File
@@ -65,6 +65,9 @@ pub(super) fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
})
};
let d = &s.doc()?.doc;
if let Some(v) = str_param(p, "name") {
crate::cmd::buildcmds::check_part_name(d, &ids, v)?;
}
// A graph keeps the object opacity and blend mode set on a mark of a series for the whole series, and set on a label
// for its kind of label, so a value a mark or label already has still replaces the one another left on the graph.
let transparency = opacity.is_some() || blend.is_some();
-2
View File
@@ -171,8 +171,6 @@ fn parse(xml: &str, name: &str, cmd: &str) -> Result<El> {
craft_xml::Error::TooDeep(_) => bad(cmd, format!("`{name}` in the Word document nests elements more than {MAX_NESTING} deep")),
_ => bad(cmd, format!("`{name}` in the Word document is not well-formed XML: {e}")),
})?;
crate::cmd::xmlattrs::validate(xml.as_bytes(), opts.limits)
.map_err(|e| bad(cmd, format!("`{name}` in the Word document is not well-formed XML: {e}")))?;
Ok(doc)
}
@@ -88,6 +88,7 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.type.textTweaker",
"addon.units.convert",
"addon.units.selectionSize",
"app.toast",
"appearance.addEffect",
"appearance.addFill",
"appearance.addStroke",
@@ -177,6 +178,7 @@ pub(super) const ALLOWED: &[&str] = &[
"edit.duplicate",
"edit.findNext",
"edit.findReplace",
"edit.replaceMatch",
"effect.apply",
"effect.deferredStatus",
"effect.duplicate",
@@ -689,6 +691,7 @@ pub(super) const ALLOWED: &[&str] = &[
"type.pathOptions",
"type.resetHorizontalScale",
"type.resetTracking",
"type.retype",
"type.ruby",
"type.scaleTextAttributes",
"type.size.decrease",
+17 -14
View File
@@ -34,7 +34,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Recolor Artwork",
["Edit", "Edit Colors"],
None,
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex); may be empty: an empty row recolours nothing, adds no library swatch and gives `group` no colour unless `added`], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint), added?: false (an empty row's new color is a color added to `group`)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour | null | \"keep\"] (what `group` is rewritten with, a null removing the group's swatch at its place and \"keep\" leaving that swatch its colour, without the Global Adjust (past the swatches it adds nothing; refused for a swatch that is not a colour); default: the new colors of the rows with current colors, in order, then those of the empty rows with `added`, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke, and on a graph label the new paint of its characters and rows for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex); may be empty: an empty row recolours nothing, adds no library swatch and gives `group` no colour unless `added`], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint), added?: false (an empty row's new color is a color added to `group`)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour | null | \"keep\"] (what the color swatches of `group` are rewritten with, in order: a gradient, pattern or None swatch keeps its place and paint; a null removing the color swatch at its place and \"keep\" leaving that swatch its colour, without the Global Adjust (past the color swatches it adds nothing); default: the new colors of the rows with current colors, in order, then those of the empty rows with `added`, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke, and on a graph label the new paint of its characters and rows for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
has_doc,
apply
),
@@ -1680,12 +1680,18 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
Some(Value::Array(cs)) => Some(cs),
Some(_) => return Err(bad(C, "`groupColors` must be an array")),
};
// A null in groupColors removes the group's swatch at its place, and "keep" leaves the swatch
// at its place its color, without the Global Adjust.
let own: Vec<Option<Color>> = match group {
Some(g) => {
s.doc()?.doc.swatch_groups.iter().find(|x| x.name == g).map(|g| g.swatches.iter().map(|w| w.paint.color()).collect()).unwrap_or_default()
}
// The places of groupColors are those of the group's color swatches: a gradient, pattern or
// None swatch keeps its place and paint. A null removes the color swatch at its place, and
// "keep" leaves it its color, without the Global Adjust.
let own: Vec<Color> = match group {
Some(g) => s
.doc()?
.doc
.swatch_groups
.iter()
.find(|x| x.name == g)
.map(|g| g.swatches.iter().filter_map(|w| w.paint.color()).collect())
.unwrap_or_default(),
None => vec![],
};
let new: Vec<Option<Color>> = match group_colors {
@@ -1694,12 +1700,8 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.enumerate()
.map(|(i, v)| match v {
Value::Null => Ok(None),
// Past the group's swatches it adds nothing.
Value::String(k) if k == "keep" => match own.get(i) {
Some(Some(c)) => Ok(Some(*c)),
Some(None) => Err(bad(C, format!("the swatch at place {i} of groupColors is not a colour to keep"))),
None => Ok(None),
},
// Past the group's color swatches it adds nothing.
Value::String(k) if k == "keep" => Ok(own.get(i).copied()),
v => color_value(v)
.map(|c| adjust.apply(c))
.map(|c| Some(in_doc_model(palette.as_ref().map_or(c, |pl| pl.nearest(c)))))
@@ -1747,6 +1749,7 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.map(|g| {
g.swatches
.iter()
.filter(|w| w.paint.color().is_some())
.zip(&new)
.filter(|(w, _)| w.global && !w.is_reserved())
.filter_map(|(w, c)| Some((w, (*c)?)))
@@ -1766,7 +1769,7 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.collect();
map.converted.set(false);
let changed = keeping_series_paint(d, &ids, |d| Ok(Recolor::with_links(scope, &f, &lf).run(d, &ids)))?;
let edit = group.map(|g| super::swatch::rewrite_group(d, g, &new, rename, C)).transpose()?;
let edit = group.map(|g| super::swatch::rewrite_group(d, g, &new, true, rename, C)).transpose()?;
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(C, e))?;
// Rewriting the group's swatches can change the colors of art linked to them, left out or
// not, and of the patterns it uses. Art that only loses its link keeps its colors and is
+619
View File
@@ -0,0 +1,619 @@
//! Type › Retype (#4934), phase 1: outlined text whose glyph shapes are glyphs of a font the app
//! has becomes live point text again, in that font and size, at the same baseline.
//!
//! Behaviour follows the public description of Illustrator's Retype
//! (<https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/identify-fonts-using-retype.html>,
//! <https://helpx.adobe.com/illustrator/desktop/design-with-text/fonts-and-scripts/apply-retype-suggested-fonts-to-live-text.html>):
//! select outlined text and Retype finds the fonts that match it, from the fonts on the device among
//! others, for use as live text. Illustrator ranks candidate fonts in a panel; this phase is local
//! and exact instead, and sets the text itself, as #4934 asks. Each selected glyph shape (a path or compound
//! path, inside groups too) is compared with the glyphs of the candidate fonts
//! ([`vectorcraft_text::retype`]), the same up to uniform scale, rotation and translation. Matched
//! glyphs map back to characters through the font's cmap and are rebuilt as point text, one object
//! per line of glyphs, with the first glyph's fill and stroke. Shapes that match no font stay as
//! they are and are reported. Near matches (another version of the font, simplified outlines,
//! merged glyphs) and images are phase 2.
use std::f64::consts::{PI, TAU};
use std::sync::Arc;
use kurbo::{BezPath, Point, Vec2};
use serde_json::{Value, json};
use vectorcraft_doc::{Appearance, CharStyle, Document, Node, NodeId, NodeKind, TextObject};
use vectorcraft_text::FontDb;
use vectorcraft_text::retype::{GlyphMatch, RetypeIndex};
use super::edit::selected_roots;
use super::{CommandSpec, EngineError, Result, Session, bad, cmd, has_selected_path};
/// At most this many shapes are compared.
const MAX_PIECES: usize = 2048;
/// Groups deeper than this are not looked into.
const MAX_DEPTH: usize = 16;
/// Extra families named by `fonts`.
const MAX_FONT_PARAMS: usize = 32;
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"type.retype",
"Retype",
["Type"],
None,
"{fonts?: [family…]} turn the selected outlined text (glyph paths and compound paths, inside groups too) back into live point text: each shape is matched against the glyphs of the fonts the app has loaded, the document's fonts and the families in fonts, the same up to uniform scale, rotation and translation (exact matches only); matched glyphs become point text in that font and size at the same baseline, one object per line, with the first glyph's fill, stroke, opacity and blend mode, in one undo step; a line splits where its type would not draw the outlines' glyphs in their places (tracking, manual spacing, font substitutions); shapes that match no font, glyphs type cannot draw as they are, and shapes with their own opacity mask stay as they are → {ids (the new type), texts, fonts: [{family, style, size}], unmatched: [id…], truncated (shapes past the limits of 2048 shapes or 16 nested groups were left out)}; an error when no shape matches",
has_selected_path,
retype
)]
}
/// A shape to match: a path or compound path, in document space.
struct Piece {
id: NodeId,
/// The group or layer holding it: glyphs of different groups, which may composite
/// differently, never share a line.
parent: Option<NodeId>,
/// Other art (not retyped) lies between it and the shape before it, so the type after that
/// art must stay painted after it: the line ends here.
after_barrier: bool,
path: BezPath,
appearance: Appearance,
/// The shape's own transparency, which the new type takes.
opacity: f32,
blend: vectorcraft_color::BlendMode,
/// The shape has what type cannot take (its own opacity mask, more than one fill or stroke,
/// effects, a brush, width profile or arrowheads): it stays an outline.
keeps_outline: bool,
}
/// The shapes in `n` (held by `parent`), in paint order. `barrier` is set when art that is not a
/// shape lies before the next one; it starts set for a root that does not follow the last root.
/// `truncated` is set when shapes past [`MAX_PIECES`] or [`MAX_DEPTH`] were left out.
fn collect(n: &Node, parent: Option<NodeId>, depth: usize, barrier: &mut bool, truncated: &mut bool, out: &mut Vec<Piece>) {
if out.len() >= MAX_PIECES || depth > MAX_DEPTH {
*barrier = true;
*truncated = true;
return;
}
// Hidden and locked art is left as it is: a hidden glyph must not come back as visible type.
if !n.visible || n.locked {
*barrier = true;
return;
}
let piece = |path: BezPath, after_barrier: bool| Piece {
id: n.id,
parent,
after_barrier,
path,
appearance: (*n.appearance).clone(),
opacity: n.opacity,
blend: n.blend,
keeps_outline: n.extras().mask.is_some() || !type_can_paint(&n.appearance),
};
match &n.kind {
NodeKind::Group { children, clip: false } => {
for c in children {
collect(c, Some(n.id), depth + 1, barrier, truncated, out);
}
}
// Only closed shapes can be glyphs: an open path stroked along a glyph's outline is not one.
NodeKind::Path { path, clipping: false, guide: false, .. } if path.is_closed() => out.push(piece(path.to_bezpath(), std::mem::take(barrier))),
NodeKind::Compound { children, .. } => {
let mut path = BezPath::new();
for c in children {
match &c.kind {
// A hidden or locked path keeps its whole compound as it is.
NodeKind::Path { path: p, .. } if p.is_closed() && c.visible && !c.locked => path.extend(p.to_bezpath()),
_ => {
*barrier = true;
return;
}
}
}
out.push(piece(path, std::mem::take(barrier)));
}
// Live type, images, clip groups and the rest stay, and the type after them stays after them.
_ => *barrier = true,
}
}
/// Can type's character style paint `ap` as it is: a basic appearance (at most one fill and one
/// stroke, no effects, no item opacity or blend), with a plain stroke?
fn type_can_paint(ap: &Appearance) -> bool {
ap.is_basic() && ap.stroke().is_none_or(|s| s.start_arrow.is_none() && s.end_arrow.is_none() && s.profile.is_none() && s.brush.is_none())
}
/// The faces to match against: the families in `fonts`, the document's fonts, then every loaded face.
fn candidate_faces(db: &FontDb, d: &Document, fonts: &[String]) -> Vec<Arc<vectorcraft_text::FontFace>> {
let mut families: Vec<String> = fonts.iter().take(MAX_FONT_PARAMS).cloned().collect();
d.walk(|n| {
if let NodeKind::Text(t) = &n.kind {
for r in &t.runs {
if !families.contains(&r.style.font_family) && families.len() < vectorcraft_text::retype::MAX_FACES {
families.push(r.style.font_family.clone());
}
}
}
});
let cap = vectorcraft_text::retype::MAX_FACES;
let mut faces = vec![];
'families: for f in &families {
for style in db.styles(f) {
// No more faces are loaded than the index takes.
if faces.len() >= cap {
break 'families;
}
if let Some(face) = db.face(f, &style)
&& !faces.iter().any(|k: &Arc<vectorcraft_text::FontFace>| k.id() == face.id())
{
faces.push(face);
}
}
}
for face in db.loaded_faces() {
if faces.len() >= cap {
break;
}
if !faces.iter().any(|k| k.id() == face.id()) {
faces.push(face);
}
}
faces
}
/// One line of retyped glyphs.
struct Line {
pieces: Vec<NodeId>,
/// What each piece matched, as `pieces`.
matches: Vec<GlyphMatch>,
/// Every glyph the first piece fits, while the line holds only it: the next glyph may tell
/// which one it is (see [`join`]).
first_cands: Vec<GlyphMatch>,
text: String,
face: Arc<vectorcraft_text::FontFace>,
scale: f64,
angle: f64,
origin: Point,
end: Point,
appearance: Appearance,
parent: Option<NodeId>,
opacity: f32,
blend: vectorcraft_color::BlendMode,
}
impl Line {
fn dir(&self) -> Vec2 {
Vec2::new(self.angle.cos(), self.angle.sin())
}
/// Does glyph `m` of shape `pc` continue this line (same group, paint and transparency, same
/// font, size and turn, on its baseline, after its end)?
fn continues(&self, pc: &Piece, m: &GlyphMatch) -> bool {
let size = self.scale * self.face.units_per_em();
let d = m.origin - self.origin;
let dir = self.dir();
let across = d.cross(dir).abs();
pc.parent == self.parent
&& pc.appearance == self.appearance
&& pc.opacity == self.opacity
&& pc.blend == self.blend
&& m.face.id() == self.face.id()
// One size and turn for the whole line: the type sets every glyph at the first one's.
&& (m.scale - self.scale).abs() <= self.scale * 1e-4
// Wrapped: type turned 180° has angles near +π and −π.
&& ((m.angle - self.angle + PI).rem_euclid(TAU) - PI).abs() < 1e-5
&& across < size * 0.05
&& (m.origin - self.end).dot(dir) > -size * 0.25
}
fn push(&mut self, id: NodeId, m: &GlyphMatch) {
// A gap wider than half a space before the glyph is spaces the outlines left no shape for.
let dir = self.dir();
let gap = (m.origin - self.end).dot(dir);
let space = space_advance(&self.face) * self.scale;
if space > 0.0 && gap > space * 0.5 {
let n = ((gap / space).round() as usize).clamp(1, 64);
self.text.extend(std::iter::repeat_n(' ', n));
}
self.text.push(m.ch);
self.pieces.push(id);
self.matches.push(m.clone());
self.end = m.origin + dir * (m.face.advance(m.gid) * m.scale);
}
/// The line of this one's glyphs `from..to`, with its group, paint and transparency.
fn part(&self, from: usize, to: usize) -> Option<Line> {
let (ids, ms) = (self.pieces.get(from..to)?, self.matches.get(from..to)?);
let (first, m) = (ids.first()?, ms.first()?);
let dir = Vec2::new(m.angle.cos(), m.angle.sin());
let mut l = Line {
pieces: vec![*first],
matches: vec![m.clone()],
first_cands: vec![],
text: m.ch.to_string(),
face: m.face.clone(),
scale: m.scale,
angle: m.angle,
origin: m.origin,
end: m.origin + dir * (m.face.advance(m.gid) * m.scale),
appearance: self.appearance.clone(),
parent: self.parent,
opacity: self.opacity,
blend: self.blend,
};
for (id, m) in ids.iter().zip(ms).skip(1) {
l.push(*id, m);
}
Some(l)
}
/// The point type that sets this line.
fn text_object(&self, system_layout: bool) -> TextObject {
let style = CharStyle {
font_family: self.face.family.clone(),
font_style: self.face.style.clone(),
// The version that matched, when two of the family and style are loaded.
font_version: (!self.face.version.is_empty()).then(|| self.face.version.clone()),
// Each outlined glyph was drawn on its own; a ligature would draw another shape.
features: vec!["-liga".into()],
size: self.scale * self.face.units_per_em(),
fill: self.appearance.fill_paint(),
stroke: self.appearance.stroke_paint(),
stroke_width: self.appearance.stroke_width(),
..Default::default()
};
let mut style = style;
if let Some(st) = self.appearance.stroke() {
style.stroke_cap = st.cap;
style.stroke_join = st.join;
style.stroke_miter_limit = st.miter_limit;
style.stroke_dash = st.dash.clone();
style.stroke_align = st.align;
}
let mut t = TextObject::point(self.origin, &self.text, style);
if self.angle != 0.0 {
t.xf *= kurbo::Affine::rotate(self.angle);
}
t.para = super::create::new_type_para();
t.system_layout = system_layout;
super::typecmd::refresh_bounds(&mut t);
t
}
/// The first of this line's glyphs its type does not draw as the outlines did: another glyph
/// (a substitution the font makes) or the same glyph elsewhere (tracking, manual spacing,
/// more space than whole spaces make); `None` when the type draws every glyph in its place.
fn first_mismatch(&self, t: &TextObject) -> Option<usize> {
let lay = vectorcraft_text::layout(FontDb::global(), t);
let mut drawn = lay.glyphs.iter().filter(|g| !g.outline.elements().is_empty());
let tol = (self.scale * self.face.units_per_em() * 0.01).max(0.01);
for (k, m) in self.matches.iter().enumerate() {
let Some(g) = drawn.next() else { return Some(k) };
let at = t.xf * (g.xf * Point::ORIGIN);
if g.font_id != m.face.id() || g.gid != m.gid || at.distance(m.origin) > tol {
return Some(k);
}
}
// Ink the outlines did not have: the last glyph is where it went wrong.
drawn.next().map(|_| self.matches.len().saturating_sub(1))
}
}
/// `lines` checked against their own layout: a line splits where its type stops drawing the
/// outlines, and a glyph its type cannot draw even on its own stays an outline (`unmatched`).
/// The glyphs laid out are bounded by a multiple of the number of glyphs.
fn verified(lines: Vec<Line>, system_layout: bool, unmatched: &mut Vec<NodeId>) -> Vec<Line> {
// Glyphs laid out in all, at most: past it, the glyphs left unchecked stay outlines.
let mut budget = lines.iter().map(|l| l.pieces.len()).sum::<usize>().saturating_mul(16).saturating_add(256);
let mut todo: std::collections::VecDeque<Line> = lines.into();
let mut out = vec![];
while let Some(l) = todo.pop_front() {
let n = l.pieces.len();
// The line's type is laid out over a window from its start that doubles while the type
// draws the window's glyphs as the outlines do, so finding where it stops costs about
// twice the glyphs before that point, not the whole rest of the line each time.
let mut w = 8usize;
loop {
let e = n.min(w);
let Some(part) = l.part(0, e) else { break };
let Some(left) = budget.checked_sub(e) else {
// Unchecked glyphs stay outlines.
unmatched.extend(l.pieces.iter().copied());
break;
};
budget = left;
match part.first_mismatch(&part.text_object(system_layout)) {
// The whole line is drawn as it was: one object.
None if e == n => {
out.push(part);
break;
}
None => w = w.saturating_mul(2),
// The first glyph on its own may still be drawn as it was (a contextual form
// changed it in the line); else it stays an outline. Checked again either way.
Some(0) if n > 1 => {
todo.extend_front_parts(&l, [(0, 1), (1, n)]);
break;
}
Some(0) => {
unmatched.extend(l.pieces.first().copied());
break;
}
// The glyphs before the mismatch, then the rest, each checked as a line of its
// own: the type before the mismatch may draw otherwise without what follows it (a
// font can place a glyph by the glyph after it).
Some(k) => {
todo.extend_front_parts(&l, [(0, k), (k, n)]);
break;
}
}
}
}
out
}
/// Puts parts of a line at the front of the work list, in order.
trait FrontParts {
fn extend_front_parts<const N: usize>(&mut self, l: &Line, ranges: [(usize, usize); N]);
}
impl FrontParts for std::collections::VecDeque<Line> {
fn extend_front_parts<const N: usize>(&mut self, l: &Line, ranges: [(usize, usize); N]) {
for (a, b) in ranges.into_iter().rev() {
if let Some(p) = l.part(a, b) {
self.push_front(p);
}
}
}
}
fn space_advance(face: &vectorcraft_text::FontFace) -> f64 {
face.mapped_chars().iter().find(|(c, _)| *c == ' ').map(|(_, g)| face.advance(*g)).unwrap_or(0.0)
}
/// Add shape `pc` to line `l` when one of its candidate glyphs `cands`, in one of its poses,
/// continues it (one shape can be several glyphs, and a glyph that looks the same turned fits in
/// more than one pose). A line of one shape may turn to another of that shape's candidates to take
/// the next one: an L or a turned L half round, an I upright or upside down, and the glyph after it
/// tells which. Whether it was added.
fn join(l: &mut Line, pc: &Piece, cands: &[GlyphMatch]) -> bool {
let fits = |l: &Line| cands.iter().flat_map(|c| c.poses()).find(|mp| l.continues(pc, mp));
if let Some(mp) = fits(l) {
l.push(pc.id, &mp);
return true;
}
let (Some(id), [current]) = (l.pieces.first().copied(), l.matches.as_slice()) else { return false };
let current = current.clone();
let others: Vec<GlyphMatch> = l
.first_cands
.iter()
.flat_map(|c| c.poses())
.filter(|fp| !(fp.gid == current.gid && fp.face.id() == current.face.id() && fp.angle == current.angle))
.collect();
for fp in others {
let mut turned = reposed(l, id, &fp);
if let Some(mp) = fits(&turned) {
turned.push(pc.id, &mp);
*l = turned;
return true;
}
}
false
}
/// Line `l`'s group, paint and transparency with glyph `m` (shape `id`) alone on it.
fn reposed(l: &Line, id: NodeId, m: &GlyphMatch) -> Line {
let dir = Vec2::new(m.angle.cos(), m.angle.sin());
Line {
pieces: vec![id],
matches: vec![m.clone()],
first_cands: l.first_cands.clone(),
text: m.ch.to_string(),
face: m.face.clone(),
scale: m.scale,
angle: m.angle,
origin: m.origin,
end: m.origin + dir * (m.face.advance(m.gid) * m.scale),
appearance: l.appearance.clone(),
parent: l.parent,
opacity: l.opacity,
blend: l.blend,
}
}
/// A new line of shape `pc` alone, as the first of its candidate glyphs `cands` (none: `None`).
fn new_line(pc: &Piece, cands: &[GlyphMatch]) -> Option<Line> {
let m = cands.first()?;
let dir = Vec2::new(m.angle.cos(), m.angle.sin());
Some(Line {
pieces: vec![pc.id],
matches: vec![m.clone()],
first_cands: cands.to_vec(),
text: m.ch.to_string(),
face: m.face.clone(),
scale: m.scale,
angle: m.angle,
origin: m.origin,
end: m.origin + dir * (m.face.advance(m.gid) * m.scale),
appearance: pc.appearance.clone(),
parent: pc.parent,
opacity: pc.opacity,
blend: pc.blend,
})
}
fn retype(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "type.retype";
let fonts: Vec<String> = match p.get("fonts") {
None | Some(Value::Null) => vec![],
Some(Value::Array(a)) => {
a.iter().map(|v| v.as_str().map(str::to_owned).ok_or_else(|| bad(C, "fonts must be a list of family names"))).collect::<Result<_>>()?
}
Some(_) => return Err(bad(C, "fonts must be a list of family names")),
};
let roots = selected_roots(s)?;
let db = FontDb::global();
let system_layout = s.doc()?.doc.setup.system_layout;
let (lines, unmatched, truncated) = {
let d = &s.doc()?.doc;
let mut pieces = vec![];
let mut truncated = false;
let mut last: Option<(Option<NodeId>, usize)> = None;
// Carried across roots: a selected root that yields no shape (live type, an open path) still
// ends the line.
let mut barrier = true;
for r in &roots {
let Some(n) = d.node(*r) else { continue };
let parent = d.parent_of(*r);
let idx = d.position(*r).map(|(_, i, _)| i);
// A root right after the last one, in the same parent, continues its lines; unselected
// art between two roots is a barrier.
if !matches!((last, idx), (Some((p, i)), Some(j)) if p == parent && i + 1 == j) {
barrier = true;
}
last = idx.map(|i| (parent, i));
collect(n, parent, 0, &mut barrier, &mut truncated, &mut pieces);
}
if pieces.is_empty() {
return Err(EngineError::Other("Retype: select outlined text (paths or compound paths)".into()));
}
// Only glyphs with a selected shape's key (segments per contour) can match one: the others are
// not sampled.
let wanted: std::collections::BTreeSet<u64> =
pieces.iter().filter(|pc| !pc.keeps_outline).filter_map(|pc| vectorcraft_text::retype::shape_key(&pc.path)).collect();
// Nothing to match (every shape stays an outline): no font is read.
let index = if wanted.is_empty() { RetypeIndex::default() } else { RetypeIndex::build(db, candidate_faces(db, d, &fonts), &wanted) };
let found: Vec<Vec<GlyphMatch>> = pieces.iter().map(|pc| if pc.keeps_outline { vec![] } else { index.matches(&pc.path) }).collect();
// The face most shapes match, so a glyph several fonts share is set in the same font as
// the glyphs around it.
let mut votes: Vec<(u32, usize)> = vec![];
for ms in &found {
// Each shape votes once for each face it fits.
let mut faces: Vec<u32> = ms.iter().map(|m| m.face.id()).collect();
faces.sort_unstable();
faces.dedup();
for f in faces {
match votes.iter_mut().find(|(v, _)| *v == f) {
Some(v) => v.1 += 1,
None => votes.push((f, 1)),
}
}
}
let rank = |face: u32| votes.iter().find(|(f, _)| *f == face).map_or(0, |v| v.1);
let mut lines: Vec<Line> = vec![];
let mut unmatched = vec![];
// An unmatched shape between glyphs ends the line: the type after it is painted after it.
let mut open = false;
for (pc, ms) in pieces.iter().zip(&found) {
if pc.after_barrier {
open = false;
}
// The shape's candidates in the face most shapes fit (the first such face, as the
// matches come upright and closest first).
let face = ms.iter().enumerate().max_by_key(|(i, m)| (rank(m.face.id()), std::cmp::Reverse(*i))).map(|(_, m)| m.face.id());
let cands: Vec<GlyphMatch> = ms.iter().filter(|m| Some(m.face.id()) == face).cloned().collect();
if cands.is_empty() {
unmatched.push(pc.id);
open = false;
continue;
}
let joined = match lines.last_mut() {
Some(l) if open => join(l, pc, &cands),
_ => false,
};
if !joined {
lines.extend(new_line(pc, &cands));
}
open = true;
}
// A lone one-contour glyph (a period, a hyphen, a bullet) is too plain to tell from drawn
// art (a dot, a bar): beside other shapes it stays an outline. Selected on its own, it is
// what was asked for. Lone means alone on its baseline as the outlines lie, before the
// layout check splits lines (tracking and manual kerning split them glyph by glyph).
let lone_pieces: std::collections::HashSet<NodeId> =
lines.iter().filter(|l| matches!(l.matches.as_slice(), [m] if m.contours == 1)).flat_map(|l| l.pieces.iter().copied()).collect();
let mut lines = verified(lines, system_layout, &mut unmatched);
if pieces.len() > 1 {
lines.retain(|l| {
let lone = matches!(l.pieces.as_slice(), [id] if lone_pieces.contains(id));
if lone {
unmatched.extend(l.pieces.iter().copied());
}
!lone
});
}
(lines, unmatched, truncated)
};
if lines.is_empty() {
return Err(EngineError::Other(format!("Retype: no selected shape matches a glyph of an available font ({} checked)", unmatched.len())));
}
let made = s.edit("Retype", |d, sel| {
let mut ids = vec![];
let mut emptied = vec![];
for l in &lines {
let Some(first) = l.pieces.first() else { continue };
let (par, idx, _) = d.position(*first).ok_or(EngineError::NoNode(*first))?;
let t = l.text_object(system_layout);
let id = d.alloc_id();
let mut node = Node::new(id, NodeKind::Text(Box::new(t)));
// The glyphs' own transparency (the group's, kept, still applies over it).
node.opacity = l.opacity;
node.blend = l.blend;
d.insert(par, idx, node)?;
for pc in &l.pieces {
if let Some((Some(parent), _, _)) = d.position(*pc) {
emptied.push(parent);
}
d.remove(*pc)?;
}
ids.push(id);
}
// A group left holding only the new type (Create Outlines' group) gives way to it, unless
// the group has transparency, effects, a mask or a name of its own, which then keep
// applying to the type inside it. A group left empty goes.
emptied.sort_unstable();
emptied.dedup();
for g in emptied {
let Some(n) = d.node(g) else { continue };
let NodeKind::Group { children, clip: false } = &n.kind else { continue };
let plain = n.opacity == 1.0
&& n.blend == vectorcraft_color::BlendMode::Normal
&& *n.appearance == Appearance::default()
&& n.name.is_none()
// Its mask, Attributes note and the rest of what few objects have stay with it.
&& {
let mut ex = n.extras().clone();
ex.type_outlines = false;
ex == vectorcraft_doc::NodeExtras::default()
}
// Isolation and knockout change how the group composites its type.
&& !n.isolate
&& n.knockout == vectorcraft_doc::Knockout::default()
&& !n.knockout_shape;
let only_type = children.iter().all(|c| ids.contains(&c.id));
if children.is_empty() {
d.remove(g)?;
} else if plain && only_type {
let kids: Vec<Arc<Node>> = children.clone();
let (par, idx, _) = d.position(g).ok_or(EngineError::NoNode(g))?;
d.remove(g)?;
for (i, k) in kids.into_iter().enumerate() {
d.insert(par, idx + i, (*k).clone())?;
}
}
}
let mut keep: Vec<NodeId> = roots.iter().copied().filter(|r| d.node(*r).is_some()).collect();
keep.extend(&ids);
sel.set(keep);
Ok(ids)
})?;
Ok(json!({
"ids": made.iter().map(|i| i.0).collect::<Vec<_>>(),
"texts": lines.iter().map(|l| l.text.clone()).collect::<Vec<_>>(),
"fonts": lines.iter().map(|l| json!({"family": l.face.family, "style": l.face.style, "size": l.scale * l.face.units_per_em()})).collect::<Vec<_>>(),
"unmatched": unmatched.iter().map(|i| i.0).collect::<Vec<_>>(),
"truncated": truncated,
}))
}
#[cfg(test)]
#[path = "retype_tests.rs"]
mod tests;
+539
View File
@@ -0,0 +1,539 @@
use serde_json::json;
use vectorcraft_doc::{NodeId, NodeKind, TextObject};
use crate::Session;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 600, "height": 400})).unwrap();
s
}
/// Point text, outlined: the id of the outlines' group.
fn outlined(s: &mut Session, p: serde_json::Value) -> u64 {
let id = s.execute("text.create", &p).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap()
}
fn text_of(s: &Session, id: u64) -> TextObject {
let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind else { panic!("text object") };
(**t).clone()
}
fn near(a: f64, b: f64, tol: f64) -> bool {
(a - b).abs() <= tol
}
#[test]
fn outlined_point_text_retypes_to_the_same_text_font_size_and_place() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Retype me, 42!", "size": 36, "font": "Source Sans 3", "style": "Regular"}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Retype me, 42!"]), "{r}");
assert_eq!(r["unmatched"], json!([]));
let id = r["ids"][0].as_u64().unwrap();
let t = text_of(&s, id);
assert_eq!(t.plain_text(), "Retype me, 42!");
let st = t.first_style();
assert_eq!((st.font_family.as_str(), st.font_style.as_str()), ("Source Sans 3", "Regular"));
assert!(near(st.size, 36.0, 0.01), "size {}", st.size);
let o = t.xf.translation();
assert!(near(o.x, 40.0, 0.01) && near(o.y, 100.0, 0.01), "baseline start {o:?}");
// The outlines are gone, in one undo step that brings them back.
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(g)).is_none(), "the emptied group goes");
s.execute("edit.undo", &json!({})).unwrap();
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(g)).is_some() && d.node(NodeId(id)).is_none());
}
#[test]
fn turned_bold_and_serif_type_keeps_its_font_and_angle() {
let mut s = session();
let a = outlined(&mut s, json!({"x": 100, "y": 200, "text": "Bold", "size": 24, "font": "Source Sans 3", "style": "Bold", "rotation": 30}));
let b = outlined(&mut s, json!({"x": 300, "y": 80, "text": "Serif", "size": 18, "font": "Source Serif 4", "style": "Regular"}));
s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Bold", "Serif"]), "{r}");
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
let bold = text_of(&s, ids[0]);
assert_eq!(bold.first_style().font_style, "Bold");
assert!(near(bold.first_style().size, 24.0, 0.01));
// text.create turns as kurbo does: compare the turn the new type has with the old one's.
let turned = kurbo::Affine::translate((100.0, 200.0)) * vectorcraft_geom::rotate_deg(30.0);
for (x, y) in bold.xf.as_coeffs().iter().zip(turned.as_coeffs()) {
assert!(near(*x, y, 1e-3), "{:?} vs {:?}", bold.xf, turned);
}
let serif = text_of(&s, ids[1]);
assert_eq!(serif.first_style().font_family, "Source Serif 4");
assert!(near(serif.first_style().size, 18.0, 0.01));
}
#[test]
fn a_drawn_shape_is_reported_and_left_alone() {
let mut s = session();
let rect = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 80, "height": 40})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [rect]})).unwrap();
let before = s.doc().unwrap().doc.clone();
let e = s.execute("type.retype", &json!({})).unwrap_err().to_string();
assert!(e.contains("no selected shape matches"), "{e}");
assert!(s.doc().unwrap().doc == before, "nothing changes");
// With outlines that would match, a bad `fonts` is refused for itself, and nothing changes.
let g = outlined(&mut s, json!({"x": 40, "y": 200, "text": "AB", "size": 40}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let before = s.doc().unwrap().doc.clone();
for bad in [json!("Source Sans 3"), json!([1]), json!({"family": "x"})] {
let e = s.execute("type.retype", &json!({"fonts": bad})).unwrap_err().to_string();
assert!(e.contains("fonts must be a list of family names"), "{e}");
}
assert!(s.doc().unwrap().doc == before);
}
#[test]
fn mixed_selection_retypes_the_glyphs_and_keeps_the_rest() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "Mix", "size": 30}));
let rect = s.execute("shape.rectangle", &json!({"x": 10, "y": 200, "width": 80, "height": 40})).unwrap()["id"].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g, rect]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Mix"]));
assert_eq!(r["unmatched"], json!([rect]));
let d = &s.doc().unwrap().doc;
assert!(matches!(d.node(NodeId(rect)).unwrap().kind, NodeKind::Path { .. }), "the rectangle stays");
}
#[test]
fn two_words_keep_their_space() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 20, "y": 60, "text": "two words", "size": 20}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["two words"]));
}
#[test]
fn craft_fonts_glyphs_retype_too() {
let Some(f) = vectorcraft_text::CRAFT_FONTS.iter().find(|f| f.is_japanese()) else {
eprintln!("skipped: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout to run it)");
return;
};
let mut s = session();
let g = outlined(&mut s, json!({"x": 20, "y": 60, "text": "漢字です", "size": 20, "font": f.family, "style": f.style}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({"fonts": [f.family]})).unwrap();
assert_eq!(r["texts"], json!(["漢字です"]), "{r}");
assert_eq!(r["fonts"][0]["family"], json!(f.family));
}
fn children_of(s: &Session, g: u64) -> Vec<u64> {
s.doc().unwrap().doc.node(NodeId(g)).unwrap().children().unwrap().iter().map(|c| c.id.0).collect()
}
#[test]
fn a_shape_between_glyphs_ends_the_line_so_paint_order_holds() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let rect = s.execute("shape.rectangle", &json!({"x": 30, "y": 60, "width": 80, "height": 50})).unwrap()["id"].as_u64().unwrap();
// The rectangle goes between A and B, inside the outlines' group.
s.edit("test", |d, _| {
let n = d.node(NodeId(rect)).unwrap().clone();
d.remove(NodeId(rect))?;
d.insert(Some(NodeId(g)), 1, n)?;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A", "B"]), "{r}");
assert_eq!(r["unmatched"], json!([rect]));
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
assert_eq!(children_of(&s, g), vec![ids[0], rect, ids[1]], "A under the rectangle, B over it");
}
#[test]
fn glyphs_of_different_groups_and_transparency_stay_apart() {
let mut s = session();
let a = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ab", "size": 20}));
let b = outlined(&mut s, json!({"x": 120, "y": 100, "text": "ed", "size": 20}));
let first_d = children_of(&s, b)[1];
s.edit("test", |d, _| {
d.node_mut(NodeId(b)).unwrap().opacity = 0.5;
d.node_mut(NodeId(first_d)).unwrap().opacity = 0.25;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [a, b]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["ab", "e", "d"]), "same baseline, other group; d has its own opacity: {r}");
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(a)).is_none(), "a plain group gives way to its type");
assert_eq!(d.node(NodeId(b)).unwrap().opacity, 0.5, "the half-transparent group stays");
assert_eq!(children_of(&s, b), vec![ids[1], ids[2]]);
assert_eq!(s.doc().unwrap().doc.node(NodeId(ids[2])).unwrap().opacity, 0.25, "the glyph's own opacity carries over");
}
#[test]
fn live_type_between_glyphs_ends_the_line_too() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let live = s.execute("text.create", &json!({"x": 30, "y": 90, "text": "x", "size": 60})).unwrap()["id"].as_u64().unwrap();
s.edit("test", |d, _| {
let n = d.node(NodeId(live)).unwrap().clone();
d.remove(NodeId(live))?;
d.insert(Some(NodeId(g)), 1, n)?;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A", "B"]), "{r}");
let ids: Vec<u64> = r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
assert_eq!(children_of(&s, g), vec![ids[0], live, ids[1]], "B stays over the live type");
let t = text_of(&s, ids[0]);
assert!(t.first_style().features.iter().any(|f| f == "-liga"), "glyphs drawn one by one: no ligatures");
}
#[test]
fn an_open_path_along_a_glyph_is_not_a_glyph() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "I", "size": 40}));
s.edit("test", |d, _| {
let glyph = d.node(NodeId(g)).unwrap().children().unwrap()[0].id;
for sp in &mut d.node_mut(glyph).unwrap().path_data_mut().unwrap().subpaths {
sp.closed = false;
}
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
assert!(s.execute("type.retype", &json!({})).is_err(), "nothing matches");
}
#[test]
fn live_type_selected_between_loose_glyphs_still_ends_the_line() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let live = s.execute("text.create", &json!({"x": 30, "y": 90, "text": "x", "size": 60})).unwrap()["id"].as_u64().unwrap();
let (a, b) = (children_of(&s, g)[0], children_of(&s, g)[1]);
// A, the live type and B as siblings in the layer, as Ungroup leaves them.
s.edit("test", |d, _| {
let (par, idx, _) = d.position(NodeId(g)).unwrap();
let live_n = d.node(NodeId(live)).unwrap().clone();
let (an, bn) = (d.node(NodeId(a)).unwrap().clone(), d.node(NodeId(b)).unwrap().clone());
d.remove(NodeId(live))?;
d.remove(NodeId(g))?;
d.insert(par, idx, an)?;
d.insert(par, idx + 1, live_n)?;
d.insert(par, idx + 2, bn)?;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [a, live, b]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A", "B"]), "the selected live type between them ends the line: {r}");
}
#[test]
fn glyphs_selected_inside_groups_join_only_their_siblings() {
let mut s = session();
let g1 = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ab", "size": 20}));
let g2 = outlined(&mut s, json!({"x": 70, "y": 100, "text": "ed", "size": 20}));
let (a, b, c) = (children_of(&s, g1)[0], children_of(&s, g1)[1], children_of(&s, g2)[0]);
s.execute("select.set", &json!({"ids": [a, b, c]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["ab", "e"]), "a and b are siblings; e is in another group: {r}");
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(g2)).is_some(), "d's group stays with c's type and d in it");
}
#[test]
fn tracked_type_splits_where_its_spacing_cannot_be_set_again() {
let mut s = session();
let id = s.execute("text.create", &json!({"x": 40, "y": 100, "text": "abe", "size": 30})).unwrap()["id"].as_u64().unwrap();
// Less than half a space: no whole number of spaces makes up the gap (0.4 em would be two
// spaces in this font, and the outlines cannot tell those apart from tracking).
s.execute("text.setRangeStyle", &json!({"id": id, "start": 1, "end": 3, "tracking": 50})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let g = s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let texts: Vec<String> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect();
assert_eq!(texts.concat(), "abe", "{r}");
assert!(texts.len() > 1, "the tracked glyphs are set where the outlines are, not where untracked type puts them: {r}");
assert_eq!(r["unmatched"], json!([]));
}
#[test]
fn a_masked_glyph_stays_an_outline() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let a = children_of(&s, g)[0];
s.edit("test", |d, _| {
let art = vectorcraft_doc::Node::path(d.alloc_id(), vectorcraft_geom::PathData::default(), Default::default());
d.node_mut(NodeId(a)).unwrap().extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(art, true)));
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["B"]), "{r}");
assert_eq!(r["unmatched"], json!([a]));
assert!(s.doc().unwrap().doc.node(NodeId(a)).unwrap().extras().mask.is_some(), "A keeps its mask");
}
#[test]
fn shapes_past_the_limits_are_reported_as_left_out() {
let mut s = session();
let top = outlined(&mut s, json!({"x": 40, "y": 100, "text": "A", "size": 40}));
let deep = outlined(&mut s, json!({"x": 40, "y": 200, "text": "B", "size": 40}));
// B, deeper than Retype looks.
s.edit("test", |d, _| {
let (par, idx, _) = d.position(NodeId(deep)).unwrap();
let mut n = d.node(NodeId(deep)).unwrap().clone();
d.remove(NodeId(deep))?;
for _ in 0..20 {
n = vectorcraft_doc::Node::group(d.alloc_id(), vec![std::sync::Arc::new(n)]);
}
let wrapper = n.id.0;
d.insert(par, idx, n)?;
Ok(wrapper)
})
.map(|w| s.execute("select.set", &json!({"ids": [top, w]})).unwrap())
.unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A"]));
assert_eq!(r["truncated"], json!(true), "{r}");
}
#[test]
fn a_glyph_painted_beyond_what_type_takes_stays_an_outline() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let a = children_of(&s, g)[0];
s.edit("test", |d, _| {
let n = d.node_mut(NodeId(a)).unwrap();
let mut ap = (*n.appearance).clone();
let fill = ap.items.iter().find(|i| i.is_fill()).unwrap().clone();
ap.items.push(fill);
n.appearance = ap.into();
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["B"]), "two fills: A stays an outline: {r}");
assert_eq!(r["unmatched"], json!([a]));
}
#[test]
fn a_hidden_or_locked_glyph_stays_an_outline() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "ABD", "size": 40}));
let k = children_of(&s, g);
s.edit("test", |d, _| {
d.node_mut(NodeId(k[0])).unwrap().visible = false;
d.node_mut(NodeId(k[2])).unwrap().locked = true;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["B"]), "{r}");
let d = &s.doc().unwrap().doc;
assert!(!d.node(NodeId(k[0])).unwrap().visible, "A stays a hidden outline");
assert!(d.node(NodeId(k[2])).unwrap().locked, "D stays a locked outline");
}
#[test]
fn an_isolated_or_knockout_group_keeps_its_type_inside() {
for case in ["isolate", "knockout", "knockout_shape"] {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
s.edit("test", |d, _| {
let n = d.node_mut(NodeId(g)).unwrap();
match case {
"isolate" => n.isolate = true,
"knockout" => n.knockout = vectorcraft_doc::Knockout::On,
_ => n.knockout_shape = true,
}
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let id = r["ids"][0].as_u64().unwrap();
assert_eq!(children_of(&s, g), vec![id], "{case}: the group stays, holding the type");
}
}
#[test]
fn type_turned_half_round_stays_one_object() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 300, "y": 200, "text": "Upside", "size": 30, "rotation": 180}));
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["Upside"]), "{r}");
}
#[test]
fn a_drawn_dot_or_bar_beside_type_stays_art() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let dot = s.execute("shape.ellipse", &json!({"x": 300, "y": 60, "width": 8, "height": 8})).unwrap()["id"].as_u64().unwrap();
// A bar that is exactly a hyphen of the font, somewhere else: the worst case.
let bar = outlined(&mut s, json!({"x": 200, "y": 300, "text": "-", "size": 50}));
s.execute("select.set", &json!({"ids": [g, dot, bar]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["AB"]), "{r}");
let un = r["unmatched"].as_array().unwrap();
assert!(un.contains(&json!(dot)) && un.len() == 2, "the dot and the bar stay art: {r}");
// Selected on its own, the hyphen is what was asked for.
s.execute("select.set", &json!({"ids": [bar]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["-"]), "{r}");
}
/// How long Retype takes with a large CJK face to match against (run with `--ignored
/// --nocapture`; skips when no such face is installed). Not a pass/fail budget: it prints.
#[test]
#[ignore = "timing: needs an installed CJK font"]
fn timing_with_a_large_cjk_face() {
let db = vectorcraft_text::FontDb::global();
let Some(family) = ["Microsoft YaHei", "Yu Gothic", "MS Gothic", "Noto Sans CJK JP", "Hiragino Sans"].into_iter().find(|f| db.has_family(f))
else {
eprintln!("skipped: no large CJK font installed");
return;
};
let face = db.resolve(family, "Regular").map(|(f, _)| f).unwrap();
let mut s = session();
let g = outlined(&mut s, json!({"x": 20, "y": 80, "text": "漢字のテスト ABC", "size": 24, "font": family, "style": face.style}));
for run in ["cold", "warm"] {
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let t0 = std::time::Instant::now();
let r = s.execute("type.retype", &json!({"fonts": [family]})).unwrap();
let ms = t0.elapsed().as_secs_f64() * 1000.0;
eprintln!("{run}: Retype with {family} ({} encoded glyphs) loaded: {ms:.0} ms → {}", face.mapped_chars().len(), r["texts"]);
s.execute("edit.undo", &json!({})).unwrap();
}
}
#[test]
fn a_compound_with_a_locked_or_hidden_part_stays_whole() {
let mut s = session();
// "B" outlines as a compound path of three contours.
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
let b = children_of(&s, g)[1];
let part = children_of(&s, b)[1];
s.edit("test", |d, _| {
d.node_mut(NodeId(part)).unwrap().locked = true;
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
assert_eq!(r["texts"], json!(["A"]), "{r}");
let d = &s.doc().unwrap().doc;
assert!(d.node(NodeId(part)).unwrap().locked, "B's locked part, and B, stay as they are");
}
#[test]
fn a_group_with_an_attributes_note_keeps_its_type_inside() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "AB", "size": 40}));
s.execute("attributes.set", &json!({"ids": [g], "note": "logo, keep"})).unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let id = r["ids"][0].as_u64().unwrap();
assert_eq!(children_of(&s, g), vec![id], "the group and its note stay, holding the type");
}
#[test]
fn nothing_retypable_reads_no_font() {
let mut s = session();
let g = outlined(&mut s, json!({"x": 40, "y": 100, "text": "A", "size": 40}));
let a = children_of(&s, g)[0];
s.edit("test", |d, _| {
let art = vectorcraft_doc::Node::path(d.alloc_id(), vectorcraft_geom::PathData::default(), Default::default());
d.node_mut(NodeId(a)).unwrap().extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(art, true)));
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let e = s.execute("type.retype", &json!({})).unwrap_err().to_string();
assert!(e.contains("(1 checked)"), "the masked shape is reported, and no font was indexed: {e}");
}
#[test]
fn tracked_one_contour_letters_still_become_type() {
for text in ["LIT", "HELLO", "LIST"] {
let mut s = session();
let id = s.execute("text.create", &json!({"x": 40, "y": 100, "text": text, "size": 30})).unwrap()["id"].as_u64().unwrap();
let n = text.len() as u64;
s.execute("text.setRangeStyle", &json!({"id": id, "start": 0, "end": n, "tracking": 50})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let g = s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let r = s.execute("type.retype", &json!({})).unwrap();
let texts: Vec<String> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect();
assert_eq!(texts.concat(), text, "split by the tracking, every letter still becomes type: {r}");
assert!(texts.len() > 1, "the tracking splits the line: {r}");
assert_eq!(r["unmatched"], json!([]), "{r}");
}
}
/// How long Retype takes on a few hundred CJK outlines at once (run with `--ignored --nocapture`;
/// skips when no large CJK font is installed). Not a pass/fail budget: it prints.
#[test]
#[ignore = "timing: needs an installed CJK font"]
fn timing_with_hundreds_of_cjk_outlines() {
let db = vectorcraft_text::FontDb::global();
let Some(family) = ["Microsoft YaHei", "Yu Gothic", "MS Gothic", "Noto Sans CJK JP", "Hiragino Sans"].into_iter().find(|f| db.has_family(f))
else {
eprintln!("skipped: no large CJK font installed");
return;
};
let face = db.resolve(family, "Regular").map(|(f, _)| f).unwrap();
// 300 common ideographs, ten lines of thirty.
let chars: Vec<char> = (0x4E00u32..).filter_map(char::from_u32).filter(|c| face.covers(*c)).take(300).collect();
let mut s = session();
let mut groups = vec![];
for (i, line) in chars.chunks(30).enumerate() {
let text: String = line.iter().collect();
groups.push(outlined(&mut s, json!({"x": 20, "y": 40 + 30 * i, "text": text, "size": 20, "font": family, "style": face.style})));
}
for run in ["cold", "warm"] {
s.execute("select.set", &json!({"ids": groups})).unwrap();
let t0 = std::time::Instant::now();
let r = s.execute("type.retype", &json!({"fonts": [family]})).unwrap();
let ms = t0.elapsed().as_secs_f64() * 1000.0;
let typed: usize = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().chars().count()).sum();
eprintln!(
"{run}: Retype of {} {family} outlines: {ms:.0} ms → {typed} characters typed, {} unmatched",
chars.len(),
r["unmatched"].as_array().unwrap().len()
);
s.execute("edit.undo", &json!({})).unwrap();
}
}
#[test]
fn a_long_tracked_line_is_checked_in_time() {
// Tracking splits the line at every glyph: the layout check must not lay out the rest of the
// line again after each split.
let text = "abe".repeat(150);
let mut s = session();
let id = s.execute("text.create", &json!({"x": 10, "y": 100, "text": text, "size": 4})).unwrap()["id"].as_u64().unwrap();
s.execute("text.setRangeStyle", &json!({"id": id, "start": 0, "end": text.len(), "tracking": 50})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let g = s.execute("type.createOutlines", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
let t0 = std::time::Instant::now();
let r = s.execute("type.retype", &json!({})).unwrap();
let texts: Vec<String> = r["texts"].as_array().unwrap().iter().map(|t| t.as_str().unwrap().to_owned()).collect();
assert_eq!(texts.concat(), text);
assert_eq!(r["unmatched"], json!([]));
eprintln!("450 tracked glyphs: {:?}, {} objects", t0.elapsed(), texts.len());
}
+39 -16
View File
@@ -1279,40 +1279,63 @@ impl GroupEdit {
/// Rewrite colour group `group` with `colors`: its swatches take them in order (keeping their
/// names, kinds and global or spot flags), a `None` removes the swatch at its place, extra colors
/// are added as new swatches and swatches past the end are removed. Paints linked to its global
/// are added as new swatches and swatches past the end are removed. With `colors_only`, a swatch
/// that is not a color (a gradient, pattern or None swatch) keeps its place and paint and takes no
/// entry of `colors`, which go to the group's color swatches in order. Paints linked to its global
/// swatches follow (a removed swatch's are unlinked); `rename` renames the group. A built-in swatch
/// (None, Registration) it would change or remove is refused.
pub(super) fn rewrite_group(d: &mut Document, group: &str, colors: &[Option<Color>], rename: Option<&str>, cmd: &str) -> Result<GroupEdit> {
pub(super) fn rewrite_group(
d: &mut Document,
group: &str,
colors: &[Option<Color>],
colors_only: bool,
rename: Option<&str>,
cmd: &str,
) -> Result<GroupEdit> {
let gi = d.swatch_groups.iter().position(|g| g.name == group).ok_or_else(|| bad(cmd, format!("no colour group `{group}`")))?;
let name = match rename.map(str::trim).filter(|n| !n.is_empty() && *n != group) {
Some(n) => d.free_swatch_name(n),
None => group.to_string(),
};
let old = &d.swatch_groups[gi].swatches;
// The place in `colors` of each swatch's new color; none for a swatch kept as it is.
let mut taken = 0;
let places: Vec<Option<usize>> = old
.iter()
.map(|w| {
(!colors_only || w.paint.color().is_some()).then(|| {
taken += 1;
taken - 1
})
})
.collect();
let new_color = |place: Option<usize>| place.and_then(|i| colors.get(i).copied().flatten());
if let Some(w) = old
.iter()
.enumerate()
.find(|(i, w)| w.is_reserved() && colors.get(*i).copied().flatten().is_none_or(|c| w.paint.color() != Some(c)))
.map(|x| x.1)
.zip(&places)
.find(|(w, place)| place.is_some() && w.is_reserved() && new_color(**place).is_none_or(|c| w.paint.color() != Some(c)))
.map(|x| x.0)
{
return Err(bad(cmd, format!("`{}` can't be edited or removed", w.name)));
}
let colorized_ok = super::paint::check_colorized(d).is_ok();
let mut relinks = vec![];
let old = std::mem::take(&mut d.swatch_groups[gi].swatches);
let old_len = old.len();
// The swatches that stay, each with its new color.
let mut kept: Vec<(Swatch, Color)> = vec![];
for (i, w) in old.into_iter().enumerate() {
match colors.get(i).copied().flatten() {
Some(c) => kept.push((w, c)),
None if w.global => relinks.push(Relink { from: w.name.clone(), to: w.name, color: None, keep: false }),
None => {}
// The swatches that stay, each with its new color (none for one kept as it is).
let mut kept: Vec<(Swatch, Option<Color>)> = vec![];
for (w, place) in old.into_iter().zip(places) {
match (place, new_color(place)) {
(None, _) => kept.push((w, None)),
(_, Some(c)) => kept.push((w, Some(c))),
(_, None) if w.global => relinks.push(Relink { from: w.name.clone(), to: w.name, color: None, keep: false }),
(_, None) => {}
}
}
let mut swatches = Vec::with_capacity(kept.len());
for (mut w, c) in kept {
if w.paint.color() != Some(c) {
if let Some(c) = c
&& w.paint.color() != Some(c)
{
// A tint swatch becomes a colour of its own.
w.paint = Paint::solid(c);
if w.global {
@@ -1325,7 +1348,7 @@ pub(super) fn rewrite_group(d: &mut Document, group: &str, colors: &[Option<Colo
let mut free = d.free_swatch_names();
free.insert(&name);
swatches.iter().for_each(|w| free.insert(&w.name));
for c in colors.iter().skip(old_len).flatten() {
for c in colors.iter().skip(taken).flatten() {
let nm = free.take(&color_name(*c));
swatches.push(Swatch { name: nm, paint: Paint::solid(*c), global: false, spot: false });
}
@@ -1379,7 +1402,7 @@ fn swatch_edit_group(s: &mut Session, p: &Value) -> Result<Value> {
{
return Ok(json!({"name": group, "swatches": g.swatches.iter().map(|w| w.name.clone()).collect::<Vec<_>>(), "relinked": 0}));
}
let e = s.edit("Edit Color Group", |d, _| rewrite_group(d, group, &colors, rename, C))?;
let e = s.edit("Edit Color Group", |d, _| rewrite_group(d, group, &colors, false, rename, C))?;
e.defaults(s)?;
Ok(json!({"name": e.name, "swatches": e.swatches, "relinked": e.relinked}))
}
+283
View File
@@ -0,0 +1,283 @@
//! `app.toast`: a short message shown over the window that does not stop work and goes away by
//! itself (a toast). Scripts (`vc.run`), actions (a recorded step), MCP clients and plug-ins raise
//! one with the command, and the app's code can raise one with [`Session::toast`]. The engine
//! queues the messages and the desktop app takes them each frame ([`Session::take_toasts`]) and
//! shows them. A failed script run puts the documents back but keeps the messages it raised.
use std::collections::VecDeque;
use serde_json::{Value, json};
use super::{CommandSpec, Result, always, bad, cmd};
use crate::Session;
const ID: &str = "app.toast";
/// The most characters a message has.
pub const MAX_CHARS: usize = 500;
/// How long a message shows when `seconds` is omitted, and the shortest and longest time it may
/// show.
pub const DEFAULT_SECONDS: f64 = 4.0;
pub const MIN_SECONDS: f64 = 0.5;
pub const MAX_SECONDS: f64 = 60.0;
/// The most messages waiting for the app to take them: past it the oldest one goes. A session
/// without a window (the headless MCP server, `vectorcraft-cli run`) never takes them.
pub const MAX_QUEUED: usize = 32;
/// What kind of news a message is, which sets its color.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Level {
#[default]
Info,
Success,
Warning,
Error,
}
impl Level {
pub const ALL: [Level; 4] = [Level::Info, Level::Success, Level::Warning, Level::Error];
/// Its `level` value.
pub fn param(self) -> &'static str {
match self {
Level::Info => "info",
Level::Success => "success",
Level::Warning => "warning",
Level::Error => "error",
}
}
/// The level whose `level` value is `param`.
pub fn from_param(param: &str) -> Option<Level> {
Level::ALL.into_iter().find(|l| l.param() == param)
}
}
/// A message to show.
#[derive(Clone, Debug, PartialEq)]
pub struct Toast {
pub message: String,
pub level: Level,
/// How long it shows, in seconds.
pub seconds: f64,
}
impl Toast {
/// A message of `level` shown for [`DEFAULT_SECONDS`].
pub fn new(message: impl Into<String>, level: Level) -> Toast {
Toast { message: message.into(), level, seconds: DEFAULT_SECONDS }
}
}
/// The messages waiting for the app to show them.
#[derive(Clone, Debug, Default)]
pub struct Queue(VecDeque<Toast>);
impl Session {
/// Queue `toast` for the app to show. With [`MAX_QUEUED`] waiting, the oldest one goes. Its
/// time is held to [`MIN_SECONDS`] to [`MAX_SECONDS`], and a time that is not a number is
/// [`DEFAULT_SECONDS`].
pub fn toast(&mut self, mut toast: Toast) {
toast.seconds = if toast.seconds.is_nan() { DEFAULT_SECONDS } else { toast.seconds.clamp(MIN_SECONDS, MAX_SECONDS) };
while self.toasts.0.len() >= MAX_QUEUED {
self.toasts.0.pop_front();
}
self.toasts.0.push_back(toast);
}
/// Take the messages queued since the last call, oldest first.
pub fn take_toasts(&mut self) -> Vec<Toast> {
self.toasts.0.drain(..).collect()
}
}
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"app.toast",
"Show Message",
[],
None,
"{message: string (1 to 500 characters, not only whitespace), level?: \"info\" | \"success\" | \"warning\" | \"error\" (default \"info\"), seconds?: number 0.5 to 60 (default 4)} show `message` over the window without stopping work: it goes away after `seconds` or when clicked; messages stack at the window's bottom right, the newest lowest, at most 5 at once; edits no document; an action records it as a step → {message, level, seconds}",
always,
run
)]
}
fn run(s: &mut Session, p: &Value) -> Result<Value> {
let toast = parse(p)?;
let r = json!({"message": &toast.message, "level": toast.level.param(), "seconds": toast.seconds});
s.toast(toast);
Ok(r)
}
/// The message `p` asks for; an invalid value of any key is an error.
fn parse(p: &Value) -> Result<Toast> {
let message = match p.get("message") {
Some(Value::String(m)) => m,
Some(_) => return Err(bad(ID, "`message` must be a string")),
None => return Err(bad(ID, "`message` is required")),
};
if message.trim().is_empty() {
return Err(bad(ID, "`message` must have a character other than whitespace"));
}
let chars = message.chars().count();
if chars > MAX_CHARS {
return Err(bad(ID, format!("`message` has {chars} characters; at most {MAX_CHARS} are allowed")));
}
let level = match p.get("level") {
None => Level::default(),
Some(v) => v.as_str().and_then(Level::from_param).ok_or_else(|| {
let all: Vec<&str> = Level::ALL.iter().map(|l| l.param()).collect();
bad(ID, format!("`level` must be one of {}", all.join(", ")))
})?,
};
let seconds = match p.get("seconds") {
None => DEFAULT_SECONDS,
Some(v) => v
.as_f64()
.filter(|s| (MIN_SECONDS..=MAX_SECONDS).contains(s))
.ok_or_else(|| bad(ID, format!("`seconds` must be a number from {MIN_SECONDS} to {MAX_SECONDS}")))?,
};
Ok(Toast { message: message.clone(), level, seconds })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_message_is_queued_with_its_defaults() {
let mut s = Session::new();
let r = s.execute(ID, &json!({"message": "Saved 3 files"})).unwrap();
assert_eq!(r, json!({"message": "Saved 3 files", "level": "info", "seconds": 4.0}));
assert_eq!(s.take_toasts(), vec![Toast::new("Saved 3 files", Level::Info)]);
// Taken once.
assert_eq!(s.take_toasts(), vec![]);
}
#[test]
fn level_and_seconds_are_kept() {
let mut s = Session::new();
for level in Level::ALL {
s.execute(ID, &json!({"message": "m", "level": level.param(), "seconds": 0.5})).unwrap();
}
s.execute(ID, &json!({"message": "long", "seconds": 60})).unwrap();
let got: Vec<(Level, f64)> = s.take_toasts().iter().map(|t| (t.level, t.seconds)).collect();
assert_eq!(got, vec![(Level::Info, 0.5), (Level::Success, 0.5), (Level::Warning, 0.5), (Level::Error, 0.5), (Level::Info, 60.0)]);
}
#[test]
fn invalid_values_are_errors_and_queue_nothing() {
let mut s = Session::new();
let long = "x".repeat(MAX_CHARS + 1);
for p in [
json!({}),
json!({"message": 3}),
json!({"message": ""}),
json!({"message": " \n\t"}),
json!({"message": long}),
json!({"message": "m", "level": "loud"}),
json!({"message": "m", "level": 1}),
json!({"message": "m", "seconds": 0.4}),
json!({"message": "m", "seconds": 61}),
json!({"message": "m", "seconds": "4"}),
json!({"message": "m", "seconds": null}),
] {
let e = s.execute(ID, &p).unwrap_err().to_string();
assert!(e.contains(ID), "{p}: {e}");
}
assert_eq!(s.take_toasts(), vec![]);
// The longest message is allowed, counted in characters, not bytes.
let most = "é".repeat(MAX_CHARS);
s.execute(ID, &json!({"message": most})).unwrap();
assert_eq!(s.take_toasts().len(), 1);
}
#[test]
fn a_message_queued_by_the_app_shows_for_0_5_to_60_seconds() {
let mut s = Session::new();
for seconds in [f64::INFINITY, 1e9, f64::NEG_INFINITY, 0.0, f64::NAN, 10.0] {
s.toast(Toast { seconds, ..Toast::new("m", Level::Info) });
}
let got: Vec<f64> = s.take_toasts().iter().map(|t| t.seconds).collect();
assert_eq!(got, vec![MAX_SECONDS, MAX_SECONDS, MIN_SECONDS, MIN_SECONDS, DEFAULT_SECONDS, 10.0]);
}
#[test]
fn the_oldest_waiting_message_goes_past_the_limit() {
let mut s = Session::new();
for i in 0..MAX_QUEUED + 2 {
s.toast(Toast::new(format!("{i}"), Level::Info));
}
let left: Vec<String> = s.take_toasts().into_iter().map(|t| t.message).collect();
assert_eq!(left.len(), MAX_QUEUED);
assert_eq!(left.first().map(String::as_str), Some("2"));
assert_eq!(left.last().map(String::as_str), Some("33"));
}
#[test]
fn a_message_is_journaled_without_an_undo_step_or_a_document() {
let mut s = Session::new();
// No document open.
s.execute(ID, &json!({"message": "no document"})).unwrap();
assert_eq!(s.journal.last().unwrap(), &(ID.to_string(), json!({"message": "no document"})));
s.execute("file.new", &json!({})).unwrap();
let undo = s.active().unwrap().history.undo.len();
let revision = s.active().unwrap().revision;
s.execute(ID, &json!({"message": "m", "level": "success"})).unwrap();
assert_eq!(s.journal.last().unwrap(), &(ID.to_string(), json!({"message": "m", "level": "success"})));
assert_eq!(s.active().unwrap().history.undo.len(), undo);
assert_eq!(s.active().unwrap().revision, revision);
}
#[test]
fn a_script_raises_a_message_with_vc_run() {
let mut s = Session::new();
let r = s
.execute(
"script.run",
&json!({"source": "vc.run('app.toast', {message: 'Done: ' + (1 + 1), level: 'success'});", "name": "t.js", "answers": []}),
)
.unwrap();
assert!(r.get("error").is_none_or(Value::is_null), "{r}");
assert_eq!(s.take_toasts(), vec![Toast::new("Done: 2", Level::Success)]);
}
#[test]
fn a_failed_script_run_puts_the_documents_back_and_keeps_its_messages() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
let art = format!("{:?}", s.active().unwrap().doc.layers);
let e = s
.execute(
"script.run",
&json!({
"source": "vc.run('shape.rectangle', {x: 0, y: 0, width: 10, height: 10}); vc.run('app.toast', {message: 'Failed: no artboard'}); throw new Error('stop');",
"name": "t.js",
"answers": [],
}),
)
.unwrap_err()
.to_string();
assert!(e.contains("stop"), "{e}");
assert_eq!(format!("{:?}", s.active().unwrap().doc.layers), art, "the rectangle is put back");
assert_eq!(s.take_toasts(), vec![Toast::new("Failed: no artboard", Level::Info)]);
}
#[test]
fn a_command_batch_raises_its_messages_in_order() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
s.execute(
"command.batch",
&json!({"commands": [
{"command": "app.toast", "params": {"message": "one"}},
{"command": "app.toast", "params": {"message": "two", "level": "warning"}},
]}),
)
.unwrap();
assert_eq!(s.take_toasts(), vec![Toast::new("one", Level::Info), Toast::new("two", Level::Warning)]);
}
}
+200 -64
View File
@@ -10,8 +10,8 @@ use super::object::choice;
use super::threads::ThreadIndex;
use super::typecmd::{area_text, block_gaps, needed_room, refresh_bounds};
use super::{
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, named_ids,
number_or, switch_or, targets, text_param,
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, index_opt,
named_ids, number_or, object_param, switch_or, targets, text_param,
};
pub fn specs() -> Vec<CommandSpec> {
@@ -120,7 +120,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Find and Replace…",
["Edit"],
None,
"{find, replace?: \"\", matchCase?: false, wholeWord?: false, ids?} replace in every text object (or ids) → {count}. Matches never span style runs.",
"{find, replace?: \"\", matchCase?: false, wholeWord?: false, hiddenLayers?: false, lockedLayers?: false, ids?} replace every match in the type the search reaches (or in ids, whatever their layers), as one undo step → {count (every match), replaced (the matches that did not already read as `replace`)}. The search reaches visible, unlocked type on visible, unlocked layers, off locked artboards; hiddenLayers adds the type of hidden layers and sublayers and lockedLayers that of locked ones, while a hidden or locked object or group keeps its type out. Matches never span style runs. When nothing matches, or every match already reads as `replace`, nothing changes and no undo step is recorded.",
has_doc,
find_replace
),
@@ -129,10 +129,19 @@ pub fn specs() -> Vec<CommandSpec> {
"Find Next",
["Edit"],
None,
"{find, matchCase?, wholeWord?} select the next text object (after the selected one, wrapping) containing `find` → {id|null}",
"{find, matchCase?: false, wholeWord?: false, backwards?: false, hiddenLayers?: false, lockedLayers?: false, from?: {id, start, end} (a match this command returned, or the range edit.replaceMatch returned)} find the next match of `find` in the type edit.findReplace reaches and select its type object → {id, start, end (the match's bytes in the object's plain text), index (its place among all the matches, from 1), count, selected} or {id: null, count: 0}. The search visits type objects from the top of the stacking order down and each object's matches in reading order; backwards visits the objects from the bottom up and each object's matches from the last. It goes on after `from` and, past the last match, starts again at the first. Without `from` it goes on after the first selected type object, and with no type selected, or with a null `from`, it starts at the first match. A match on a hidden or locked layer is returned with selected false and the selection stays as it is. Nothing is recorded for undo.",
has_doc,
find_next
),
cmd!(
"edit.replaceMatch",
"Replace",
[],
None,
"{find, replace?: \"\", matchCase?: false, wholeWord?: false, id, start, end} replace one match of `find`, the bytes start..end of type object id as edit.findNext returns them, with `replace`, as one undo step → {id, start, end (the replacement's bytes; pass them to edit.findNext as `from` to go on), replaced}. Bytes that are no match of `find` are refused. When the match already reads as `replace`, nothing changes, no undo step is recorded and replaced is false.",
has_doc,
replace_one
),
cmd!(
"edit.pasteWithoutFormatting",
"Paste without Formatting",
@@ -1657,14 +1666,9 @@ fn is_word(c: char) -> bool {
c.is_alphanumeric() || c == '_'
}
/// Byte ranges of `needle` in `hay`.
pub(crate) fn find_all(hay: &str, needle: &str, match_case: bool, whole_word: bool) -> Vec<(usize, usize)> {
find_all_between(hay, needle, match_case, whole_word, None, None)
}
/// [`find_all`] in run `i` of `runs`: a whole word looks past the run's ends at the characters
/// next to it, so a change of style inside a word is not a word boundary (#5901). Matches stay
/// inside the run.
/// Byte ranges of `needle` in run `i` of `runs`: a whole word looks past the run's ends at the
/// characters next to it, so a change of style inside a word is not a word boundary (#5901).
/// Matches stay inside the run.
fn find_in_run(runs: &[TextRun], i: usize, needle: &str, match_case: bool, whole_word: bool) -> Vec<(usize, usize)> {
let Some(run) = runs.get(i) else { return vec![] };
let before = runs.get(..i).and_then(|r| r.iter().rev().find_map(|r| r.text.chars().next_back()));
@@ -1672,8 +1676,8 @@ fn find_in_run(runs: &[TextRun], i: usize, needle: &str, match_case: bool, whole
find_all_between(&run.text, needle, match_case, whole_word, before, after)
}
/// [`find_all`], with `before` and `after` the characters on either side of `hay` (none at the
/// text's ends), which a whole word must not touch either.
/// Byte ranges of `needle` in `hay`, with `before` and `after` the characters on either side of
/// `hay` (none at the text's ends), which a whole word must not touch either.
fn find_all_between(hay: &str, needle: &str, match_case: bool, whole_word: bool, before: Option<char>, after: Option<char>) -> Vec<(usize, usize)> {
let nc: Vec<char> = needle.chars().collect();
if nc.is_empty() {
@@ -1705,102 +1709,234 @@ fn find_all_between(hay: &str, needle: &str, match_case: bool, whole_word: bool,
/// The visible, unlocked type objects of visible, unlocked layers, off locked artboards, in paint
/// order: the text Find and Replace and Check Spelling go through.
pub(crate) fn all_texts(d: &Document) -> Vec<NodeId> {
fn visit(n: &Node, locks: &LockedArtboards<'_>, v: &mut Vec<NodeId>) {
if !n.visible || n.locked {
searched_texts(d, false, false)
}
/// [`all_texts`], with the type of hidden layers (`hidden_layers`) and of locked layers
/// (`locked_layers`) as well, as Check Hidden Layers and Check Locked Layers of Find and Replace
/// ask. The switches are about layers and sublayers: a hidden or locked object or group keeps its
/// type out, and so does a locked artboard.
fn searched_texts(d: &Document, hidden_layers: bool, locked_layers: bool) -> Vec<NodeId> {
fn visit(n: &Node, locks: &LockedArtboards<'_>, layers: (bool, bool), v: &mut Vec<NodeId>) {
let layer = matches!(n.kind, NodeKind::Layer { .. });
if (!n.visible && !(layer && layers.0)) || (n.locked && !(layer && layers.1)) {
return;
}
if matches!(n.kind, NodeKind::Text(_)) && !locks.holds_id(n.id) {
v.push(n.id);
}
for c in n.children().into_iter().flatten() {
visit(c, locks, v);
visit(c, locks, layers, v);
}
}
let mut v = vec![];
let locks = d.locked_artboards();
for l in &d.layers {
visit(l, &locks, &mut v);
visit(l, &locks, (hidden_layers, locked_layers), &mut v);
}
v
}
/// What Find and Replace looks for: the text, Match Case and Find Whole Word.
struct Query {
find: String,
match_case: bool,
whole_word: bool,
}
impl Query {
/// The `find`, `matchCase` and `wholeWord` params of command `c`. An empty or missing `find`
/// is an error.
fn of(p: &Value, c: &str) -> Result<Self> {
let find = text_param(p, "find", c)?.filter(|f| !f.is_empty()).ok_or_else(|| bad(c, "missing `find`"))?.to_string();
Ok(Self { find, match_case: switch_or(p, "matchCase", false, c)?, whole_word: switch_or(p, "wholeWord", false, c)? })
}
/// The matches in `t`, in reading order, each as (run, start, end) with `start..end` the bytes
/// of the match in the object's plain text. A match stays inside one style run, and an inline
/// graphic is art, not characters to find.
fn matches(&self, t: &TextObject) -> Vec<(usize, usize, usize)> {
let mut hits = vec![];
let mut base = 0;
for (ri, r) in t.runs.iter().enumerate() {
if r.inline.is_none() {
hits.extend(
find_in_run(&t.runs, ri, &self.find, self.match_case, self.whole_word).into_iter().map(|(a, b)| (ri, base + a, base + b)),
);
}
base += r.text.len();
}
hits
}
}
/// Replace bytes `start..end` of the plain text of `t`, which lie inside run `run`, with `rep`.
/// The paragraph styles and the ruby follow the edit, as `text.editRange` moves them. The caller
/// refreshes the bounds.
fn replace_match(t: &mut TextObject, run: usize, start: usize, end: usize, rep: &str) {
let base: usize = t.runs.iter().take(run).map(|r| r.text.len()).sum();
let (Some(a), Some(b)) = (start.checked_sub(base), end.checked_sub(base)) else { return };
if !t.runs.get(run).is_some_and(|r| a <= b && r.text.is_char_boundary(a) && r.text.is_char_boundary(b)) {
return;
}
t.splice_paras(start, end, rep);
if let Some(r) = t.runs.get_mut(run) {
r.text.replace_range(a..b, rep);
}
t.ruby_after_replace(start, end, rep.len());
}
fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.findReplace";
let find = text_param(p, "find", C)?.filter(|f| !f.is_empty()).ok_or_else(|| bad(C, "missing `find`"))?.to_string();
let q = Query::of(p, C)?;
let rep = text_param(p, "replace", C)?.unwrap_or("").to_string();
let (mc, ww) = (switch_or(p, "matchCase", false, C)?, switch_or(p, "wholeWord", false, C)?);
let (hidden, locked) = (switch_or(p, "hiddenLayers", false, C)?, switch_or(p, "lockedLayers", false, C)?);
let ids = match p.get("ids").filter(|v| !v.is_null()) {
Some(_) => text_ids(&s.doc()?.doc, &checked_ids_param(s, p, "ids", C)?),
None => all_texts(&s.doc()?.doc),
None => searched_texts(&s.doc()?.doc, hidden, locked),
};
let st = s.doc()?;
let total: usize = ids
// Every match, and the matches that do not already read as the replacement.
let (total, replaced) = ids
.iter()
.filter_map(|id| match &st.doc.node(*id)?.kind {
NodeKind::Text(t) => Some((0..t.runs.len()).map(|i| find_in_run(&t.runs, i, &find, mc, ww).len()).sum::<usize>()),
NodeKind::Text(t) => {
let plain = t.plain_text();
let hits = q.matches(t);
Some((hits.len(), hits.iter().filter(|(_, a, b)| plain.get(*a..*b) != Some(rep.as_str())).count()))
}
_ => None,
})
.sum();
if total == 0 {
return Ok(json!({ "count": 0 }));
.fold((0, 0), |(n, r), (hn, hr)| (n + hn, r + hr));
if replaced == 0 {
return Ok(json!({ "count": total, "replaced": 0 }));
}
super::overprint::edit_counted(s, "Replace", |d| {
let mut changed = 0;
for id in &ids {
let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
// Matches as (run, start, end) with offsets inside the run. Inline graphics are art, not
// characters to rewrite.
let mut hits = vec![];
let mut base = 0;
for (ri, r) in t.runs.iter().enumerate() {
if r.inline.is_none() {
for (a, b) in find_in_run(&t.runs, ri, &find, mc, ww) {
if r.text.get(a..b) != Some(rep.as_str()) {
hits.push((ri, base + a, base + b, a, b));
}
}
}
base += r.text.len();
}
let plain = t.plain_text();
let hits: Vec<_> = q.matches(t).into_iter().filter(|(_, a, b)| plain.get(*a..*b) != Some(rep.as_str())).collect();
if hits.is_empty() {
continue;
}
// Last match first, so the offsets of earlier ones stay valid. The paragraph styles follow
// each edit, as `text.editRange` does.
for (ri, ta, tb, a, b) in hits.into_iter().rev() {
t.splice_paras(ta, tb, &rep);
if let Some(r) = t.runs.get_mut(ri) {
r.text.replace_range(a..b, &rep);
}
// Last match first, so the offsets of earlier ones stay valid.
for (ri, a, b) in hits.into_iter().rev() {
replace_match(t, ri, a, b, &rep);
}
changed += 1;
refresh_bounds(t);
}
Ok(changed)
})?;
Ok(json!({ "count": total }))
Ok(json!({ "count": total, "replaced": replaced }))
}
/// A match of Find and Replace: bytes `start..end` of the plain text of type object `id`.
#[derive(Clone, Copy)]
struct Match {
id: NodeId,
start: usize,
end: usize,
}
impl Match {
/// The `id`, `start` and `end` that `p` gives for a match, under command `c`: an object id and
/// two byte offsets, put in order as `text.editRange` orders its own.
fn of(p: &Value, c: &str) -> Result<Self> {
let whole = |key: &str| index_opt(p, key, c)?.ok_or_else(|| bad(c, format!("missing `{key}`")));
let id = object_param(p, "id", c)?.ok_or_else(|| bad(c, "missing `id`"))?;
let (start, end) = (whole("start")?, whole("end")?);
Ok(Self { id, start: start.min(end), end: start.max(end) })
}
}
fn find_next(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.findNext";
let find = text_param(p, "find", C)?.filter(|f| !f.is_empty()).ok_or_else(|| bad(C, "missing `find`"))?.to_string();
let (mc, ww) = (switch_or(p, "matchCase", false, C)?, switch_or(p, "wholeWord", false, C)?);
let q = Query::of(p, C)?;
let backwards = switch_or(p, "backwards", false, C)?;
let (hidden, locked) = (switch_or(p, "hiddenLayers", false, C)?, switch_or(p, "lockedLayers", false, C)?);
// A `from` that is no object gives no `id`, and is refused as one without it. A null `from`
// starts at the first match, whatever is selected.
let from = match p.get("from") {
None => None,
Some(Value::Null) => Some(None),
Some(v) => Some(Some(Match::of(v, C)?)),
};
let st = s.doc()?;
let all = all_texts(&st.doc);
let cur = st.selection.objects.first().and_then(|id| all.iter().position(|x| x == id));
let n = all.len();
let start = cur.map(|c| c + 1).unwrap_or(0);
let hit = (0..n).map(|k| all[(start + k) % n.max(1)]).find(|id| match st.doc.node(*id).map(|n| &n.kind) {
Some(NodeKind::Text(t)) => !find_all(&t.plain_text(), &find, mc, ww).is_empty(),
_ => false,
});
match hit {
Some(id) => {
s.select(|_, sel| sel.set([id]))?;
Ok(json!({ "id": id.0 }))
}
None => Ok(json!({ "id": null })),
// The objects in the order the search visits them: from the top of the stacking order down,
// or with Search Backwards from the bottom up.
let mut order = searched_texts(&st.doc, hidden, locked);
if !backwards {
order.reverse();
}
// Every match in that order as (object's place, match): inside an object in reading order, or
// with Search Backwards from its end.
let mut all: Vec<(usize, Match)> = vec![];
for (place, id) in order.iter().enumerate() {
let Some(NodeKind::Text(t)) = st.doc.node(*id).map(|n| &n.kind) else { continue };
let mut hits = q.matches(t);
if backwards {
hits.reverse();
}
all.extend(hits.into_iter().map(|(_, start, end)| (place, Match { id: *id, start, end })));
}
if all.is_empty() {
return Ok(json!({ "id": null, "count": 0 }));
}
// The search goes on from `from`, or from the whole of the first selected type object it
// visits, so that the same call again reaches the next object. From anywhere else it starts
// at the first match.
let from = from.unwrap_or_else(|| {
st.selection.objects.iter().filter(|id| order.contains(id)).find_map(|id| match &st.doc.node(*id)?.kind {
NodeKind::Text(t) => Some(Match { id: *id, start: 0, end: t.runs.iter().map(|r| r.text.len()).sum() }),
_ => None,
})
});
let after = |(place, m): &(usize, Match), at: usize, f: &Match| {
*place > at || (*place == at && if backwards { m.end <= f.start } else { m.start >= f.end })
};
let k = from
.and_then(|f| order.iter().position(|id| *id == f.id).map(|at| (at, f)))
.and_then(|(at, f)| all.iter().position(|hit| after(hit, at, &f)))
.unwrap_or(0);
let Some((_, m)) = all.get(k).copied() else { return Ok(json!({ "id": null, "count": 0 })) };
let count = all.len();
// Type that a selection tool can't reach (on a hidden or locked layer) is found without being
// selected.
let selected = all_texts(&st.doc).contains(&m.id);
if selected && st.selection.objects != [m.id] {
s.select(|_, sel| sel.set([m.id]))?;
}
let index = if backwards { count - k } else { k + 1 };
Ok(json!({ "id": m.id.0, "start": m.start, "end": m.end, "index": index, "count": count, "selected": selected }))
}
fn replace_one(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "edit.replaceMatch";
let q = Query::of(p, C)?;
let rep = text_param(p, "replace", C)?.unwrap_or("").to_string();
let m = Match::of(p, C)?;
let st = s.doc()?;
let t = match st.doc.node(m.id).map(|n| &n.kind) {
Some(NodeKind::Text(t)) => t,
Some(_) => return Err(bad(C, format!("node {} is not text", m.id.0))),
None => return Err(EngineError::NoNode(m.id)),
};
let Some((run, ..)) = q.matches(t).into_iter().find(|(_, a, b)| (*a, *b) == (m.start, m.end)) else {
return Err(bad(C, format!("no match of `find` at bytes {}..{} of object {}", m.start, m.end, m.id.0)));
};
let end = m.start + rep.len();
if t.plain_text().get(m.start..m.end) == Some(rep.as_str()) {
return Ok(json!({ "id": m.id.0, "start": m.start, "end": end, "replaced": false }));
}
s.edit("Replace", |d, _| {
let Some(NodeKind::Text(t)) = d.node_mut(m.id).map(|n| &mut n.kind) else { return Err(EngineError::NoNode(m.id)) };
replace_match(t, run, m.start, m.end, &rep);
refresh_bounds(t);
Ok(())
})?;
Ok(json!({ "id": m.id.0, "start": m.start, "end": end, "replaced": true }))
}
// ---------- Paste without Formatting ----------
@@ -250,7 +250,6 @@ fn parse_library(xml: &str, cmd: &str, text_only: bool) -> Result<Library> {
craft_xml::Error::TooDeep(_) => bad(cmd, format!("the variable library nests elements more than {MAX_LIBRARY_NESTING} deep")),
_ => bad(cmd, format!("the variable library is not well-formed XML: {e}")),
})?;
crate::cmd::xmlattrs::validate(xml.as_bytes(), opts.limits).map_err(|e| bad(cmd, format!("the variable library is not well-formed XML: {e}")))?;
let Some(root) = std::iter::once(&doc).chain(doc.descendants()).find(|n| n.is(craft_xml::Local("variableSets"))) else {
return Err(bad(cmd, "the file holds no `variableSets` element"));
};
-55
View File
@@ -1,55 +0,0 @@
//! Attribute uniqueness checks missing from the pinned shared XML reader's strict mode.
//!
//! Temporary consumer guard: parsing remains in craft-xml. Move this invariant into the
//! shared strict reader and remove this second event pass when that dependency is updated.
/// Check names before canonical/local-name rewriting can collapse distinct attributes.
/// The event reader and namespace scope use the same caller-supplied resource caps.
pub(super) fn validate(xml: &[u8], limits: craft_xml::Limits) -> Result<(), String> {
use std::collections::BTreeSet;
let opts = craft_xml::Options { limits, doctype: craft_xml::Doctype::Reject, ..Default::default() }.strict();
let mut events = opts.events(xml);
let mut bindings: Vec<(String, String)> = Vec::new();
let mut scopes = Vec::new();
while let Some(event) = events.next().map_err(|e| e.to_string())? {
match event {
craft_xml::Event::Start { attrs, .. } => {
scopes.push(bindings.len());
let mut raw = BTreeSet::new();
for (key, value) in &attrs {
if !raw.insert(key.as_str()) {
return Err(format!("duplicate attribute `{key}`"));
}
if let Some(prefix) = key.strip_prefix("xmlns:") {
if bindings.len() >= limits.max_attrs {
return Err("too many in-scope namespace declarations".into());
}
bindings.push((prefix.to_string(), value.clone()));
}
}
let mut expanded = BTreeSet::new();
for (key, _) in &attrs {
if key == "xmlns" || key.starts_with("xmlns:") {
continue;
}
// Default namespaces do not apply to attributes. Preserve undeclared
// prefixes for standalone SVG library fragments, as the importer did.
let name = match key.split_once(':') {
Some(("xml", local)) => ("http://www.w3.org/XML/1998/namespace", local),
Some((prefix, local)) => {
bindings.iter().rev().find(|(p, _)| p == prefix).map_or(("", key.as_str()), |(_, uri)| (uri.as_str(), local))
}
None => ("", key.as_str()),
};
if !expanded.insert(name) {
return Err(format!("duplicate expanded attribute `{key}`"));
}
}
}
craft_xml::Event::End { .. } => bindings.truncate(scopes.pop().unwrap_or(0)),
_ => {}
}
}
Ok(())
}
+2
View File
@@ -360,6 +360,8 @@ pub struct Session {
/// Set while [`Session::tool_typed_text`] passes keyboard input to the active tool
/// ([`vectorcraft_tools::ToolContext::typed_from_keyboard`]).
keyboard_text: bool,
/// The messages `app.toast` and [`Session::toast`] queued for the app to show; not saved.
pub(crate) toasts: cmd::toast::Queue,
}
impl Default for Session {
+33 -15
View File
@@ -1559,12 +1559,14 @@ fn kind_id(kind: &RunErrorKind) -> &'static str {
}
}
/// `message`, with what to do about a failure that comes from a script written for another program.
fn explained(kind: &RunErrorKind, message: &str) -> String {
/// `e`'s message, with what to do about a failure that comes from a script written for another
/// program. A message the script supplied itself ([`RunError::authored`]) is given as it is.
fn explained(e: &RunError) -> String {
const HOST_OBJECTS: &[&str] = &["app", "Window", "BridgeTalk", "activeDocument", "documents"];
let message = &e.message;
let names_host_object =
message.strip_prefix("ReferenceError: ").is_some_and(|m| HOST_OBJECTS.iter().any(|o| m.split_whitespace().next() == Some(o)));
if *kind == RunErrorKind::Thrown && names_host_object {
if e.kind == RunErrorKind::Thrown && !e.authored && names_host_object {
format!("{message} (scripts here use the `vc` object; objects other applications give their scripts are not available)")
} else {
message.to_string()
@@ -1582,7 +1584,7 @@ fn preprocessor_error(f: include::Failure) -> (RunError, Option<Arc<str>>) {
include::FailKind::Limit => (RunErrorKind::Limit(LimitKind::Host), f.message),
};
let file = (f.index > 0).then_some(f.file);
(RunError { kind, message, line: f.line, column: f.column }, file)
(RunError { kind, message, line: f.line, column: f.column, authored: false }, file)
}
/// `e`, the error `realm` raised in the run of `host`, at the line and column of the file it is in,
@@ -1591,20 +1593,20 @@ fn located(host: &Host, realm: &Realm, e: &RunError) -> (RunError, Option<Arc<st
let map = |m: &include::SourceMap| {
let (index, file, line, column) = m.locate(e.line, e.column);
let message = if e.kind == RunErrorKind::Syntax { relocated(&e.message, e.line, e.column, line, column) } else { e.message.clone() };
(RunError { kind: e.kind.clone(), message, line, column }, index, file)
(RunError { kind: e.kind.clone(), message, line, column, authored: e.authored }, index, file)
};
// An error `$.evalFile` raised for a file it could not run, and no script caught, is at that
// file's place.
if let Some((file, line, column)) = realm.error_mark().and_then(|m| host.eval_failures.borrow().get(m as usize).cloned()) {
let message = if e.kind == RunErrorKind::Syntax { relocated(&e.message, e.line, e.column, line, column) } else { e.message.clone() };
return (RunError { kind: e.kind.clone(), message, line, column }, Some(file));
return (RunError { kind: e.kind.clone(), message, line, column, authored: e.authored }, Some(file));
}
if e.line == 0 {
return (e.clone(), None);
}
// An error in code from a source whose map is not at hand, such as code that `eval` compiled,
// is given without a place.
let unplaced = || (RunError { kind: e.kind.clone(), message: e.message.clone(), line: 0, column: 0 }, None);
let unplaced = || (RunError { line: 0, column: 0, ..e.clone() }, None);
match realm.error_source() {
0 => {
let (e, index, file) = map(&host.script_map.borrow());
@@ -1777,6 +1779,15 @@ impl Session {
self.script_report.as_ref().filter(|r| r["ok"] == false).map(failure_text)
}
/// [`Self::script_failure_text`] split around the message when that message is text the script
/// supplied itself (`messageOrigin` `script`): the text before it, the message and the text after
/// it. `None` when the last run did not fail, or failed with one of the app's own errors.
pub fn script_authored_failure(&self) -> Option<(String, &str, String)> {
let r = self.script_report.as_ref().filter(|r| r["ok"] == false && r["messageOrigin"] == "script")?;
let (before, after) = failure_frame(r);
Some((before, r["message"].as_str().unwrap_or_default(), after))
}
/// Has the running script used up its growth allowance, so a person must answer? A run asked
/// to stop no longer waits: the next [`Session::script_pump`] ends it.
pub fn script_waiting(&self) -> bool {
@@ -1873,7 +1884,7 @@ impl Session {
};
drop(key);
let kind = LimitKind::Interrupted;
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0, authored: false };
let _ = self.script_failed(job, &e);
true
}
@@ -2120,14 +2131,14 @@ impl Session {
// A stop while a dialog waits ends the run there; the interpreter cannot go on from the call.
if job.realm.waits() {
let kind = LimitKind::Interrupted;
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line: 0, column: 0, authored: false };
return Some(self.script_failed(job, &e));
}
job.host.calls_this_slice.set(0);
let outcome = run_slice(self, &mut job);
match outcome {
Err(panic) => {
let e = RunError { kind: RunErrorKind::Internal, message: panic, line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Internal, message: panic, line: 0, column: 0, authored: false };
Some(self.script_failed(job, &e))
}
Ok(Err(e)) => Some(self.script_failed(job, &e)),
@@ -2144,7 +2155,7 @@ impl Session {
} else {
format!("`answers` has {n} answers the script did not use")
};
Some(self.script_failed(job, &RunError { kind: RunErrorKind::Limit(kind), message, line: 0, column: 0 }))
Some(self.script_failed(job, &RunError { kind: RunErrorKind::Limit(kind), message, line: 0, column: 0, authored: false }))
}
Ok(Ok(Progress::Done(_))) => {
let r = self.script_commit(job);
@@ -2179,7 +2190,7 @@ impl Session {
let unwritten = job.host.flush_files();
if !unwritten.is_empty() {
let message = format!("{UNWRITTEN_FILES}: {}", unwritten.join(", "));
let e = RunError { kind: RunErrorKind::Thrown, message, line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Thrown, message, line: 0, column: 0, authored: false };
return self.script_failed(job, &e);
}
// The working copy goes into the session; `job.world` holds the state before the run.
@@ -2197,7 +2208,7 @@ impl Session {
if changed && (!crate::sanity::doc_sane(&st.doc, &st.selection) || st.doc.too_deep(None)) {
job.world.docs = start;
job.world.swap(self);
let e = RunError { kind: RunErrorKind::Internal, message: INVALID_RESULT.to_string(), line: 0, column: 0 };
let e = RunError { kind: RunErrorKind::Internal, message: INVALID_RESULT.to_string(), line: 0, column: 0, authored: false };
return self.script_failed(job, &e);
}
}
@@ -2302,7 +2313,8 @@ fn failure_report(name: &str, e: &RunError, file: Option<&str>, host: &Host, fue
let mut report = json!({
"ok": false,
"kind": kind_id(&e.kind),
"message": explained(&e.kind, &e.message),
"message": explained(e),
"messageOrigin": if e.authored { "script" } else { "built-in" },
"name": name,
"line": e.line,
"column": e.column,
@@ -2395,6 +2407,12 @@ fn close_run(s: &mut Session, host: &Host, report: &mut Value, ending: console::
/// The text of a failed run's error.
fn failure_text(report: &Value) -> String {
let (before, after) = failure_frame(report);
format!("{before}{}{after}", report["message"].as_str().unwrap_or_default())
}
/// The text of a failed run's error before its message and after it.
fn failure_frame(report: &Value) -> (String, String) {
let s = |k: &str| report[k].as_str().unwrap_or_default();
let (line, column) = (report["line"].as_u64().unwrap_or(0), report["column"].as_u64().unwrap_or(0));
let at = match report["file"].as_str() {
@@ -2409,7 +2427,7 @@ fn failure_text(report: &Value) -> String {
} else {
String::new()
};
format!("{}{at}: {} ({}){kept}", s("name"), s("message"), s("kind"))
(format!("{}{at}: ", s("name")), format!(" ({}){kept}", s("kind")))
}
/// A run's slice: the working copy in, the real session lent to the host functions, one measured
+2 -2
View File
@@ -149,6 +149,7 @@ impl Session {
global_edit_options: Default::default(),
select_similar: crate::cmd::SIMILAR[0].0,
keyboard_text: false,
toasts: Default::default(),
script_key: None,
script_engines: crate::script::EnginesKey::new(),
script_stop: vectorcraft_js::Interrupt::new(),
@@ -204,8 +205,7 @@ impl Session {
let _ = self.finish_tool_edit_later();
// The switch goes on whatever the lent tool's last actions did, as for the deactivation.
let _ = self.give_back_tool(view);
let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
let _ = self.apply_actions(acts);
let _ = self.deactivate_tool(view);
// A batch leaves its interaction open in the document it leaves, to keep or roll back with
// the rest of the batch; anything else in progress (a drag) is cancelled.
if self.batch_stash.is_none() {
+118
View File
@@ -4329,6 +4329,124 @@ fn object_mosaic_refuses_a_boolean_given_as_text() {
assert_eq!((r["tiles"].clone(), images(&s)), (json!(2), 1));
}
/// The size of the mosaic a call makes from the 100 × 50 pt image selected in `s`, with its column and row counts.
fn mosaic_size(s: &mut Session, p: serde_json::Value) -> (f64, f64, serde_json::Value, serde_json::Value) {
let image = s.doc().unwrap().selection.objects.clone();
let r = s.execute("object.createObjectMosaic", &p).unwrap();
let b = s.doc().unwrap().doc.node(NodeId(r["id"].as_u64().unwrap())).unwrap().geometric_bounds().unwrap();
s.execute("select.set", &json!({ "ids": image })).unwrap();
((b.width() * 1e6).round() / 1e6, (b.height() * 1e6).round() / 1e6, r["columns"].clone(), r["rows"].clone())
}
/// Resize Using Percentages reads the new width and height as percentages of the image's size; Constrain Ratio keeps
/// the image's proportions, the named side leading; Use Ratio makes the tiles square from the count on the
/// constrained side (columns by default), and the call answers the counts it used.
#[test]
fn object_mosaic_resizes_by_percentages_constrains_the_ratio_and_squares_the_tiles() {
let mut s = session();
rect(&mut s, 0.0, 0.0, 100.0, 50.0);
s.execute("paint.setStroke", &json!({"none": true})).unwrap();
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
assert_eq!(mosaic_size(&mut s, json!({"columns": 2, "rows": 1})), (100.0, 50.0, json!(2), json!(1)));
assert_eq!(mosaic_size(&mut s, json!({"width": 50, "height": 200, "percentages": true})), (50.0, 100.0, json!(10), json!(10)));
// A side left out is 100% of the image's.
assert_eq!(mosaic_size(&mut s, json!({"width": 150, "percentages": true})).0, 150.0);
assert_eq!(mosaic_size(&mut s, json!({"width": 200, "height": 10, "constrain": "width"})), (200.0, 100.0, json!(10), json!(10)));
assert_eq!(mosaic_size(&mut s, json!({"width": 10, "height": 25, "constrain": "height"})), (50.0, 25.0, json!(10), json!(10)));
assert_eq!(mosaic_size(&mut s, json!({"width": 50, "constrain": "width", "percentages": true})), (50.0, 25.0, json!(10), json!(10)));
// Square tiles: 10 columns of 10 pt over 50 pt are 5 rows; 4 rows of 12.5 pt over 100 pt are 8 columns.
assert_eq!(mosaic_size(&mut s, json!({"columns": 10, "rows": 3, "useRatio": true})), (100.0, 50.0, json!(10), json!(5)));
assert_eq!(mosaic_size(&mut s, json!({"columns": 3, "rows": 4, "useRatio": true, "constrain": "height"})), (100.0, 50.0, json!(8), json!(4)));
// A side named for Use Ratio is kept without Constrain Ratio: the size stays as given.
assert_eq!(mosaic_size(&mut s, json!({"rows": 4, "height": 100, "useRatio": "height"})), (100.0, 100.0, json!(4), json!(4)));
// On a new size: 30 columns over 300 × 50 pt are 5 rows.
assert_eq!(mosaic_size(&mut s, json!({"columns": 30, "width": 300, "useRatio": true})), (300.0, 50.0, json!(30), json!(5)));
// The count is kept within 1..1000.
assert_eq!(mosaic_size(&mut s, json!({"columns": 1, "width": 1, "height": 5000, "useRatio": true})).3, json!(1000));
assert_eq!(mosaic_size(&mut s, json!({"columns": 1, "width": 5000, "height": 1, "useRatio": true})).3, json!(1));
// A size under 0.1 pt grows in proportion while Constrain Ratio keeps it.
let (w, h, ..) = mosaic_size(&mut s, json!({"width": 0.1, "constrain": "width"}));
assert!((w - 0.2).abs() < 1e-6 && (h - 0.1).abs() < 1e-6, "{w} × {h}");
// A side Constrain Ratio works out above 1,000,000 pt shrinks to it, in proportion: a height of
// 1,000,000 pt over the 100 × 50 pt image would need a width of 2,000,000 pt.
assert_eq!(mosaic_size(&mut s, json!({"height": 1e6, "constrain": "height"})), (1e6, 5e5, json!(10), json!(10)));
// An image 20,000,000 times wider than it is tall has no such size: the call is refused.
s.execute("object.scale", &json!({"sx": 1, "sy": 1e-7})).unwrap();
let r = s.execute("object.createObjectMosaic", &json!({"width": 1e6, "constrain": "width"}));
let msg = "the image's proportions leave no size with both sides between 0.1 and 1000000 pt";
assert!(matches!(&r, Err(EngineError::BadParams { msg: m, .. }) if m == msg), "{r:?}");
}
/// Use Ratio squares the tiles as drawn: with 4 pt between columns, 10 columns of 10 pt cells draw 6 pt wide, so the
/// rows are 6 pt plus their own 4 pt apart (5 rows down 50 pt); on an image turned 90°, the tiles are measured along
/// its own axes.
#[test]
fn object_mosaic_use_ratio_takes_spacing_and_turned_images_into_account() {
let mut s = session();
rect(&mut s, 0.0, 0.0, 100.0, 50.0);
s.execute("paint.setStroke", &json!({"none": true})).unwrap();
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
let image = s.doc().unwrap().selection.objects.clone();
let counts = |s: &Session, p: serde_json::Value| crate::cmd::mosaic_counts(s, &p).unwrap();
assert_eq!(counts(&s, json!({"columns": 10, "useRatio": true, "spacingX": 4, "spacingY": 4})), (10, 5));
assert_eq!(counts(&s, json!({"columns": 10, "useRatio": true, "spacingX": 4})), (10, 8));
assert_eq!(counts(&s, json!({"columns": 10, "rows": 7})), (10, 7), "without Use Ratio the counts are kept");
let r = s.execute("object.createObjectMosaic", &json!({"columns": 10, "useRatio": true, "spacingX": 4})).unwrap();
let g = s.doc().unwrap().doc.node(NodeId(r["id"].as_u64().unwrap())).unwrap().clone();
let t = g.children().unwrap()[0].geometric_bounds().unwrap();
assert!((t.width() - 6.0).abs() < 1e-6 && (t.height() - 6.25).abs() < 1e-6, "{t:?}");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("select.set", &json!({ "ids": image })).unwrap();
// Turned 90°, the image's 100 pt side runs down the page; 10 columns along it are still 5 rows across its 50.
s.execute("object.rotate", &json!({"angle": 90})).unwrap();
assert_eq!(counts(&s, json!({"columns": 10, "useRatio": true})), (10, 5));
}
#[test]
fn object_mosaic_square_count_is_the_nearest_whole_count() {
use crate::cmd::menucmds::mosaic_square_count;
assert_eq!(mosaic_square_count(10, 100.0, 50.0, 0.0, 0.0), 5);
assert_eq!(mosaic_square_count(3, 100.0, 50.0, 0.0, 0.0), 2);
assert_eq!(mosaic_square_count(0, 100.0, 50.0, 0.0, 0.0), 1);
assert_eq!(mosaic_square_count(10, 0.0, 50.0, 0.0, 0.0), 1);
assert_eq!(mosaic_square_count(1000, 1.0, 1000.0, 0.0, 0.0), 1000);
// Spacing wider than a cell leaves 10% of it, on either side.
assert_eq!(mosaic_square_count(10, 100.0, 50.0, 50.0, 0.0), 50);
// 10 columns of 1 pt tiles (9 pt gaps) over 100 pt; rows 100 pt apart are capped too, so 10 rows draw 1 pt.
assert_eq!(mosaic_square_count(10, 100.0, 100.0, 9.0, 100.0), 10);
// 15 pt tiles over 50 pt: 3 rows draw 16.7 pt and 4 rows 12.5 pt, so 3.
assert_eq!(mosaic_square_count(1, 15.0, 50.0, 0.0, 0.0), 3);
}
/// A Constrain Ratio side that is not "width" or "height", a new size of 0 or less, and Use Ratio or Resize Using
/// Percentages given as text are errors naming the key; no mosaic is made.
#[test]
fn object_mosaic_refuses_a_bad_ratio_side_size_or_switch() {
let mut s = session();
rect(&mut s, 0.0, 0.0, 100.0, 50.0);
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
let undo = |s: &Session| s.doc().unwrap().history.undo.len();
let before = undo(&s);
for (p, msg) in [
(json!({"constrain": "both"}), "`constrain` must be one of \"width\", \"height\" or null"),
(json!({"constrain": 1}), "`constrain` must be one of \"width\", \"height\" or null"),
(json!({"width": 0}), "`width` must be between 0.1 and 1000000 (got 0)"),
(json!({"height": -5, "percentages": true}), "`height` must be between 0.1 and 1000000 (got -5)"),
(json!({"width": 2e6, "percentages": true}), "`width` must be between 0.1 and 1000000 (got 2000000)"),
// A side Constrain Ratio works out is not used, but a size given for it is still checked.
(json!({"width": 200, "height": 0, "constrain": "width"}), "`height` must be between 0.1 and 1000000 (got 0)"),
(json!({"useRatio": "true"}), "`useRatio` must be one of \"width\", \"height\", true, false or null"),
(json!({"useRatio": 1}), "`useRatio` must be one of \"width\", \"height\", true, false or null"),
(json!({"percentages": 1}), "`percentages` must be true or false"),
] {
let r = s.execute("object.createObjectMosaic", &p);
assert!(matches!(&r, Err(EngineError::BadParams { msg: m, .. }) if m == msg), "{p}: {r:?}");
assert_eq!(undo(&s), before, "{p}");
}
let r = s.execute("object.createObjectMosaic", &json!({"constrain": null, "useRatio": null, "percentages": null})).unwrap();
assert_eq!(r["tiles"], json!(100));
}
#[test]
fn snap_to_pixel_rounds_drawing_and_moves() {
let mut s = session();
+376
View File
@@ -5027,6 +5027,73 @@ fn live_paint_does_not_count_art_named_like_its_parts() {
}
}
/// A path drawn in an isolated Live Paint group can't be named Face or Edge, the names of the
/// group's faces and edges: `object.setProps` and `layer.setProps` return an error and rename
/// nothing, so Gap Options and a path dragged into the group keep the path. A face keeps its name.
#[test]
fn live_paint_refuses_part_names_for_paths_drawn_in_it() {
use vectorcraft_tools::builder::{EDGE_NAME, FACE_NAME, faces};
let mut s = session();
let g = live(&mut s);
let face = faces(&node(&s, g))[0].id;
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
let a = line_across(&mut s, 50.0);
// Hidden, the path stays in the group as drawn when isolation mode ends.
s.execute("object.setProps", &json!({"id": a.0, "visible": false})).unwrap();
let before = (s.doc().unwrap().doc.clone(), s.doc().unwrap().history.undo.len());
for name in [FACE_NAME, EDGE_NAME] {
let calls = [
("object.setProps", json!({"id": a.0, "name": name})),
("layer.setProps", json!({"id": a.0, "name": name})),
("layer.setProps", json!({"ids": [face.0, a.0], "name": name})),
];
for (c, p) in calls {
let err = s.execute(c, &p).unwrap_err().to_string();
assert!(err.contains("give the path another name"), "{c} {p}: {err}");
}
}
assert!(s.doc().unwrap().doc == before.0, "nothing was renamed");
assert_eq!(s.doc().unwrap().history.undo.len(), before.1);
s.execute("layer.setProps", &json!({"id": face.0, "name": FACE_NAME})).unwrap();
s.execute("object.exitIsolation", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "the hidden path stays in the group");
s.execute("livePaint.gapOptions", &json!({"ids": [g.0], "detect": true})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "Gap Options keeps the path");
let b = line_to_right_face(&mut s, 30.0);
s.execute("layer.move", &json!({"ids": [b.0], "target": g.0, "place": "inside"})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "a path dragged in keeps it");
assert_eq!(faces(&node(&s, g)).len(), 5);
}
/// A path pasted into an isolated Live Paint group under the name of a face or an edge loses the
/// name, so Gap Options keeps it and it joins the group's paths when isolation mode ends.
#[test]
fn live_paint_paste_clears_part_names() {
use vectorcraft_tools::builder::{EDGE_NAME, FACE_NAME, faces, sources};
for name in [FACE_NAME, EDGE_NAME] {
let mut s = session();
let g = live(&mut s);
let r = rect(&mut s, 20.0, 40.0, 60.0, 20.0);
s.execute("object.setProps", &json!({"id": r.0, "name": name})).unwrap();
s.execute("select.set", &json!({"ids": [r.0]})).unwrap();
s.execute("edit.copy", &json!({})).unwrap();
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
s.execute("edit.pasteInPlace", &json!({})).unwrap();
let pasted = s.doc().unwrap().selection.objects.clone();
assert_eq!(pasted.len(), 1);
let d = &s.doc().unwrap().doc;
assert_eq!(d.parent_of(pasted[0]), Some(g), "{name}: the paste goes into the group");
assert_eq!(d.node(pasted[0]).unwrap().name, None, "{name}: the paste loses the name");
assert_eq!(d.node(r).unwrap().name.as_deref(), Some(name), "the path outside keeps its name");
s.execute("livePaint.gapOptions", &json!({"ids": [g.0], "detect": true})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(pasted[0]), Some(g), "{name}: Gap Options keeps the paste");
s.execute("object.exitIsolation", &json!({})).unwrap();
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(pasted[0]), Some(sources(&n).unwrap().id), "{name}: the paste joined");
assert!(faces(&n).len() > 3);
}
}
/// With Real-time Drawing and Editing off, a rectangle still being drawn in a Live Paint group
/// isolated in a pattern tile is drawn first when Exit Isolation Mode leaves pattern editing, and
/// joins the group with the tile saved.
@@ -5098,6 +5165,315 @@ fn live_paint_isolation_adds_a_drawn_group_isolated_inside_it() {
}
}
/// With Live Paint group `inner` made in isolated Live Paint group `outer` and then isolated itself,
/// leaving both levels (`object.exitIsolation`, or `object.isolate` on the layer) adds the path drawn
/// in `inner` to it and then `inner` and the path drawn directly in `outer` to `outer`, one undo step
/// each. Isolating `outer` from `inner` adds only `inner`'s drawn path, and `outer` keeps its own.
#[test]
fn live_paint_isolation_merges_nested_live_paint_groups_it_leaves() {
use vectorcraft_tools::builder::{faces, sources};
for to in ["exit", "layer", "outer"] {
let mut s = session();
let outer = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(outer).unwrap();
s.execute("object.isolate", &json!({"id": outer.0})).unwrap();
let a = line_across(&mut s, 50.0);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(outer));
let inner = live(&mut s);
assert_eq!(s.doc().unwrap().doc.parent_of(inner), Some(outer), "the inner group is drawn in the outer one");
s.execute("object.isolate", &json!({"id": inner.0})).unwrap();
let b = line_across(&mut s, 30.0);
assert_eq!(s.doc().unwrap().doc.parent_of(b), Some(inner));
let steps = s.doc().unwrap().history.undo.len();
match to {
"exit" => s.execute("object.exitIsolation", &json!({})).unwrap(),
"layer" => s.execute("object.isolate", &json!({"id": layer.0})).unwrap(),
_ => s.execute("object.isolate", &json!({"id": outer.0})).unwrap(),
};
let d = &s.doc().unwrap().doc;
if to == "outer" {
assert_eq!(s.doc().unwrap().isolation, Some(outer));
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "only the inner group's path joins");
let n = node(&s, inner);
assert_eq!(d.parent_of(b), Some(sources(&n).unwrap().id), "the path drawn in the inner group joined it");
assert_eq!(d.parent_of(inner), Some(outer), "the inner group stays drawn in the outer one");
assert_eq!(d.parent_of(a), Some(outer), "the path drawn in the outer group stays as drawn");
continue;
}
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 2, "{to}: one undo step for each group");
assert!(d.node(inner).is_none(), "{to}: the inner group joined the outer one");
let n = node(&s, outer);
let src = sources(&n).unwrap().id;
assert_eq!(d.parent_of(a), Some(src), "{to}: the path drawn in the outer group joined it");
assert!(d.ancestry(b).unwrap().contains(&src), "{to}: the path drawn in the inner group is among the outer group's paths");
assert!(n.children().unwrap().iter().all(|c| c.id == src || c.path_data().is_some()), "{to}: only parts are left in the outer group");
assert!(faces(&n).len() > 3, "{to}: the added paths cut the outer group's faces");
if to == "exit" {
assert_eq!(s.doc().unwrap().selection.objects, vec![outer]);
}
}
}
/// A line from left of the [`live`] group to its right face, so it cuts the two faces left of it.
fn line_to_right_face(s: &mut Session, y: f64) -> NodeId {
let r = s.execute("path.create", &json!({"anchors": [{"x": -10, "y": y}, {"x": 105, "y": y}]})).unwrap();
NodeId(r["id"].as_u64().unwrap())
}
fn undo_label(s: &Session) -> Option<String> {
s.doc().unwrap().history.undo.last().map(|e| e.label.clone())
}
/// Paths dragged into a Live Paint group in the Layers panel join its paths as Live Paint › Merge
/// adds them: they go among its sources and cut the faces they cross, a painted face they do not
/// cross keeps its fill, and the drop is one "Merge Live Paint" undo step that selects the group.
#[test]
fn layers_drag_adds_paths_to_a_live_paint_group() {
use vectorcraft_tools::builder::{face_at, faces, sources};
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let mut s = session();
let g = live(&mut s);
s.execute("livePaint.fill", &json!({"group": g.0, "point": [125, 50], "color": "#00ff00"})).unwrap();
let layer = s.doc().unwrap().doc.parent_of(g);
let (a, b) = (line_to_right_face(&mut s, 30.0), line_to_right_face(&mut s, 70.0));
assert_eq!(s.doc().unwrap().doc.parent_of(a), layer);
let steps = s.doc().unwrap().history.undo.len();
let r = s.execute("layer.move", &json!({"ids": [a.0, b.0], "target": g.0, "place": "inside"})).unwrap();
assert_eq!(r["ids"], json!([g.0]), "the rows that joined are listed as the group");
let d = s.doc().unwrap();
assert_eq!(d.history.undo.len(), steps + 1, "both paths join in one undo step");
assert_eq!(undo_label(&s).as_deref(), Some("Merge Live Paint"));
assert_eq!(s.doc().unwrap().selection.objects, vec![g]);
let n = node(&s, g);
let src = sources(&n).unwrap();
assert_eq!(src.children().unwrap().len(), 4);
for id in [a, b] {
assert_eq!(s.doc().unwrap().doc.parent_of(id), Some(src.id), "{id} joined the sources");
}
assert_eq!(faces(&n).len(), 7, "two lines cut each of the two faces they cross in three");
assert_eq!(face_at(&n, Point::new(125.0, 50.0)).unwrap().appearance.fill_paint(), green, "the face the lines do not cross keeps its fill");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 3);
for id in [a, b] {
assert_eq!(s.doc().unwrap().doc.parent_of(id), layer, "Undo puts {id} back where it was");
}
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 7);
}
/// A path named like a Live Paint group's sources group joins the group when it is dragged in, in
/// front of the sources group or behind it: the group keeps its own sources group and the path
/// goes among its paths.
#[test]
fn layers_drag_of_a_path_named_like_the_sources_group_joins_a_live_paint_group() {
use vectorcraft_tools::builder::{SOURCES_NAME, faces, sources};
for index in [0, 99] {
let mut s = session();
let g = live(&mut s);
let a = line_to_right_face(&mut s, 30.0);
s.execute("object.setProps", &json!({"id": a.0, "name": SOURCES_NAME})).unwrap();
s.execute("node.move", &json!({"id": a.0, "parent": g.0, "index": index})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Merge Live Paint"), "index {index}");
let n = node(&s, g);
let src = sources(&n).unwrap();
assert!(src.children().is_some(), "index {index}: the sources group is a group");
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(src.id), "index {index}: the path joined the sources");
assert_eq!(faces(&n).len(), 5, "index {index}");
}
}
/// An object drawn in a Live Paint group and named like its sources group can be moved ahead of the
/// sources group: the group keeps its own sources group and stays a Live Paint group.
#[test]
fn layers_reorder_of_an_object_named_like_the_sources_group_keeps_the_live_paint_group() {
use vectorcraft_tools::builder::{SOURCES_NAME, is_live_paint, sources};
let mut s = session();
let g = live(&mut s);
let real = sources(&node(&s, g)).unwrap().id;
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
let a = line_across(&mut s, 50.0);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g));
s.execute("object.setProps", &json!({"id": a.0, "name": SOURCES_NAME})).unwrap();
s.execute("node.move", &json!({"id": a.0, "parent": g.0, "index": 0})).unwrap();
let n = node(&s, g);
assert!(is_live_paint(&n));
assert_eq!(sources(&n).unwrap().id, real);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(g), "the object stays where it was drawn");
}
/// A path named `Face` that is dragged into a Live Paint group is not one of its faces: the face it
/// covers keeps its own fill.
#[test]
fn layers_drag_of_a_path_named_face_does_not_repaint_the_group() {
use vectorcraft_tools::builder::{face_at, faces};
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let mut s = session();
let g = live(&mut s);
s.execute("livePaint.fill", &json!({"group": g.0, "point": [25, 50], "color": "#00ff00"})).unwrap();
let a = rect(&mut s, 0.0, 0.0, 50.0, 100.0);
set_fill(&mut s, a, Color::rgb(0.0, 0.0, 1.0));
s.execute("object.setProps", &json!({"id": a.0, "name": "Face"})).unwrap();
s.execute("node.move", &json!({"id": a.0, "parent": g.0, "index": 99})).unwrap();
let n = node(&s, g);
assert_eq!(faces(&n).len(), 3);
assert_eq!(face_at(&n, Point::new(25.0, 50.0)).unwrap().appearance.fill_paint(), green);
}
/// An Alt-drag into a Live Paint group adds a copy and leaves the path where it was; a drop above
/// one of the group's faces, and `node.move` into the group, add the path the same way.
#[test]
fn layers_drag_copy_and_drop_beside_a_part_add_to_a_live_paint_group() {
use vectorcraft_tools::builder::{faces, sources};
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g);
let a = line_to_right_face(&mut s, 30.0);
s.execute("layer.move", &json!({"ids": [a.0], "target": g.0, "copy": true})).unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(a), layer, "the path itself stays");
let n = node(&s, g);
assert_eq!(faces(&n).len(), 5);
let src = sources(&n).unwrap().children().unwrap().clone();
assert_eq!(src.len(), 3);
assert!(src.iter().all(|c| c.id != a), "a copy joined");
let (face, other_face) = (faces(&n)[0].id, faces(&n)[1].id);
let b = line_to_right_face(&mut s, 70.0);
// A face dragged along is made again with the others, so only the group is listed.
let r = s.execute("layer.move", &json!({"ids": [b.0, other_face.0], "target": face.0, "place": "above"})).unwrap();
assert_eq!(r["ids"], json!([g.0]));
assert_eq!(s.doc().unwrap().layer_rows, vec![g]);
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(b), Some(sources(&n).unwrap().id), "a drop beside a face joins");
assert_eq!(faces(&n).len(), 7);
let c = line_to_right_face(&mut s, 50.0);
s.execute("node.move", &json!({"id": c.0, "parent": g.0, "index": 0})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Merge Live Paint"));
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(c), Some(sources(&n).unwrap().id), "node.move into the group joins");
assert_eq!(faces(&n).len(), 9);
}
/// Dragging type, or type with a path, into a Live Paint group is refused with Make's message and
/// moves nothing, as Merge refuses it; a drop beside the group is an ordinary move.
#[test]
fn layers_drag_refuses_type_into_a_live_paint_group() {
use vectorcraft_tools::builder::faces;
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g);
let a = line_to_right_face(&mut s, 30.0);
let text = NodeId(s.execute("text.create", &json!({"x": 20, "y": 20, "text": "Hi"})).unwrap()["id"].as_u64().unwrap());
let before = (s.doc().unwrap().doc.clone(), s.doc().unwrap().history.undo.len());
for p in [json!({"ids": [a.0, text.0], "target": g.0}), json!({"ids": [text.0], "target": g.0, "copy": true})] {
let err = s.execute("layer.move", &p).unwrap_err().to_string();
assert!(err.contains("Live Paint takes paths and compound paths"), "{err}");
}
assert!(s.execute("node.move", &json!({"id": text.0, "parent": g.0, "index": 0})).is_err());
assert!(s.doc().unwrap().doc == before.0, "nothing moved");
assert_eq!(s.doc().unwrap().history.undo.len(), before.1);
s.execute("layer.move", &json!({"ids": [a.0, text.0], "target": g.0, "place": "above"})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Move Rows"));
assert_eq!(s.doc().unwrap().doc.parent_of(text), layer);
assert_eq!(faces(&node(&s, g)).len(), 3);
}
/// A path dragged out of a Live Paint group's sources leaves its faces and edges: the group makes
/// them again from the paths left, and with none left it has no faces until a path joins it again.
/// Reordering the sources, or the group's own faces, makes nothing again.
#[test]
fn layers_drag_out_of_a_live_paint_group_makes_its_faces_again() {
use vectorcraft_tools::builder::{faces, sources};
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g).unwrap();
let n = node(&s, g);
let src: Vec<NodeId> = sources(&n).unwrap().children().unwrap().iter().map(|c| c.id).collect();
let face_ids: Vec<NodeId> = faces(&n).iter().map(|f| f.id).collect();
s.execute("layer.move", &json!({"ids": [src[0].0], "target": src[1].0, "place": "above"})).unwrap();
s.execute("layer.move", &json!({"ids": [face_ids[0].0], "target": face_ids[2].0, "place": "above"})).unwrap();
let n = node(&s, g);
assert_eq!(sources(&n).unwrap().children().unwrap().len(), 2, "a reorder keeps the sources");
let mut now: Vec<NodeId> = faces(&n).iter().map(|f| f.id).collect();
now.sort();
let mut was = face_ids.clone();
was.sort();
assert_eq!(now, was, "and the faces");
s.execute("layer.move", &json!({"ids": [src[0].0], "target": layer.0})).unwrap();
assert_eq!(undo_label(&s).as_deref(), Some("Move Rows"));
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(src[0]), Some(layer));
assert_eq!(sources(&n).unwrap().children().unwrap().len(), 1);
assert_eq!(faces(&n).len(), 1, "one rectangle left");
s.execute("node.move", &json!({"id": src[1].0, "parent": layer.0, "index": 0})).unwrap();
let n = node(&s, g);
assert!(vectorcraft_tools::builder::is_live_paint(&n), "the group stays a Live Paint group");
assert!(sources(&n).unwrap().children().unwrap().is_empty());
assert!(faces(&n).is_empty() && vectorcraft_tools::builder::edges(&n).is_empty());
s.execute("layer.move", &json!({"ids": [src[0].0], "target": g.0})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 1, "a path joins the empty group");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(faces(&node(&s, g)).len(), 1);
}
/// A path dragged from a Live Paint group's sources into the group itself stays among its paths,
/// and the faces it bounds keep their paint, also when it is the group's only path.
#[test]
fn layers_drag_a_source_path_into_its_own_live_paint_group_keeps_the_paint() {
use vectorcraft_tools::builder::{face_at, faces, sources};
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let blue = Paint::solid(Color::from_hex("#0000ff").unwrap());
let mut s = session();
let g = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(g).unwrap();
s.execute("livePaint.fill", &json!({"group": g.0, "point": [25, 50], "color": "#00ff00"})).unwrap();
let src: Vec<NodeId> = sources(&node(&s, g)).unwrap().children().unwrap().iter().map(|c| c.id).collect();
s.execute("layer.move", &json!({"ids": [src[0].0], "target": g.0, "place": "inside"})).unwrap();
let n = node(&s, g);
assert_eq!(s.doc().unwrap().doc.parent_of(src[0]), Some(sources(&n).unwrap().id), "the path stays among the group's paths");
assert_eq!(faces(&n).len(), 3);
assert_eq!(face_at(&n, Point::new(25.0, 50.0)).unwrap().appearance.fill_paint(), green, "the face it bounds keeps its fill");
s.execute("layer.move", &json!({"ids": [src[1].0], "target": layer.0})).unwrap();
s.execute("livePaint.fill", &json!({"group": g.0, "point": [50, 50], "color": "#0000ff"})).unwrap();
s.execute("layer.move", &json!({"ids": [src[0].0], "target": g.0, "place": "inside"})).unwrap();
let n = node(&s, g);
assert_eq!(faces(&n).len(), 1);
assert_eq!(face_at(&n, Point::new(50.0, 50.0)).unwrap().appearance.fill_paint(), blue, "the only path's face keeps its fill");
}
/// A Live Paint group among another Live Paint group's paths gives it faces and edges: a path
/// dragged into or out of the inner group's paths, or from the outer group's paths into the inner
/// group's, makes the inner group's faces and edges again and then the outer group's.
#[test]
fn layers_drag_into_a_nested_live_paint_group_makes_the_outer_group_again() {
use vectorcraft_tools::builder::{faces, sources};
let mut s = session();
let outer = live(&mut s);
let inner = live(&mut s);
let layer = s.doc().unwrap().doc.parent_of(outer).unwrap();
let first_source = |s: &Session, g: NodeId| sources(&node(s, g)).unwrap().children().unwrap()[0].id;
let into = |s: &mut Session, row: NodeId, g: NodeId| {
let target = first_source(s, g);
s.execute("layer.move", &json!({"ids": [row.0], "target": target.0, "place": "above"})).unwrap();
};
into(&mut s, inner, outer);
assert_eq!(s.doc().unwrap().doc.parent_of(inner), Some(sources(&node(&s, outer)).unwrap().id));
let plain = faces(&node(&s, outer)).len();
let a = line_to_right_face(&mut s, 30.0);
into(&mut s, a, inner);
assert_eq!(faces(&node(&s, inner)).len(), 5);
let cut = faces(&node(&s, outer)).len();
assert!(cut > plain, "a path joining the inner group cuts the outer group's faces: {cut} faces, {plain} before");
s.execute("layer.move", &json!({"ids": [a.0], "target": layer.0})).unwrap();
assert_eq!(faces(&node(&s, inner)).len(), 3);
assert_eq!(faces(&node(&s, outer)).len(), plain, "a path leaving the inner group leaves the outer group's faces");
into(&mut s, a, outer);
assert_eq!(faces(&node(&s, outer)).len(), cut);
into(&mut s, a, inner);
assert_eq!(s.doc().unwrap().doc.parent_of(a), Some(sources(&node(&s, inner)).unwrap().id));
assert_eq!(faces(&node(&s, inner)).len(), 5);
assert_eq!(faces(&node(&s, outer)).len(), cut, "the outer group is made after the inner one");
}
/// Give Live Paint group `g` a lock, hidden state, appearance, knockout, opacity mask and
/// graphic style link, and return it as it then is.
fn dress_live_group(s: &mut Session, g: NodeId) -> Node {
+105
View File
@@ -696,3 +696,108 @@ fn a_locked_or_hidden_layer_keeps_the_isolated_compound_shape_from_clicks() {
assert!(selected(&s).is_empty(), "{prop}: nor by a marquee");
}
}
/// A straight line, closed as a compound shape closes open paths, encloses no area, so it
/// contributes no area to the shape: Make Compound Shape still makes it, in any mode and at any
/// place in the stack, and its reply carries a warning that names Outline Stroke. The shape draws
/// the area the other members make in that mode: the square alone in Add, or on top in Subtract,
/// and nothing in Intersect or when the line is the backmost member in Subtract. A line in a group,
/// beside a closed path too, an open evenodd square traced twice, and open evenodd subpaths that cancel one another or a closed
/// subpath of the same path are the same. An open path that encloses an area once closed (a bow tie
/// whose lobes cancel in signed area included) and closed shapes alone give no warning (#7849).
#[test]
fn lines_that_add_no_area_are_reported() {
use crate::cmd::OPEN_PATHS_ADD_NO_AREA;
fn line_of(s: &mut Session) -> NodeId {
NodeId(run(s, "shape.line", json!({"x1": 20, "y1": 50, "x2": 180, "y2": 50}))["id"].as_u64().unwrap())
}
fn vee_of(s: &mut Session) -> NodeId {
let anchors = json!([{"x": 20, "y": 50}, {"x": 100, "y": 150}, {"x": 180, "y": 50}]);
NodeId(run(s, "path.create", json!({ "anchors": anchors }))["id"].as_u64().unwrap())
}
fn bow_tie_of(s: &mut Session) -> NodeId {
let anchors = json!([{"x": 20, "y": 0}, {"x": 180, "y": 100}, {"x": 180, "y": 0}, {"x": 20, "y": 100}]);
NodeId(run(s, "path.create", json!({ "anchors": anchors }))["id"].as_u64().unwrap())
}
fn twice_around_of(s: &mut Session) -> NodeId {
let d = "M20 20 L80 20 L80 80 L20 80 L20 20 L80 20 L80 80 L20 80";
let id = NodeId(run(s, "path.create", json!({ "d": d }))["id"].as_u64().unwrap());
run(s, "path.setFillRule", json!({"rule": "evenOdd"}));
id
}
fn evenodd_of(s: &mut Session, d: &str) -> NodeId {
let id = NodeId(run(s, "path.create", json!({ "d": d }))["id"].as_u64().unwrap());
run(s, "path.setFillRule", json!({"rule": "evenOdd"}));
id
}
fn two_open_squares_of(s: &mut Session) -> NodeId {
evenodd_of(s, "M20 20 L80 20 L80 80 L20 80 M20 20 L80 20 L80 80 L20 80")
}
fn open_over_closed_of(s: &mut Session) -> NodeId {
evenodd_of(s, "M20 20 L80 20 L80 80 L20 80 Z M20 20 L80 20 L80 80 L20 80")
}
fn group_of(s: &mut Session, ids: &[NodeId]) -> NodeId {
run(s, "select.set", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()}));
NodeId(run(s, "object.group", json!({}))["id"].as_u64().unwrap())
}
type Build = fn(&mut Session) -> NodeId;
// (case, mode, the other member, whether it goes behind the 100 pt square, warned, area drawn)
type Case = (&'static str, &'static str, Build, bool, bool, Option<f64>);
let cases: [Case; 13] = [
("an open evenodd square traced twice", "add", twice_around_of, false, true, Some(10_000.0)),
("two open evenodd squares on one another", "add", two_open_squares_of, false, true, Some(10_000.0)),
("an open evenodd square on the same closed square", "add", open_over_closed_of, false, true, Some(10_000.0)),
("a line", "add", line_of, false, true, Some(10_000.0)),
("a line, subtracting", "subtract", line_of, false, true, Some(10_000.0)),
("a line, intersecting", "intersect", line_of, false, true, Some(0.0)),
("a line behind, subtracting", "subtract", line_of, true, true, Some(0.0)),
(
"a group of lines",
"add",
|s| {
let ids = [line_of(s), line_of(s)];
group_of(s, &ids)
},
false,
true,
Some(10_000.0),
),
(
"a group of a line and a square",
"add",
|s| {
let ids = [line_of(s), square(s, 200.0, "#00ff00")];
group_of(s, &ids)
},
false,
true,
Some(20_000.0),
),
("an open path that encloses an area", "add", vee_of, false, false, None),
("an open bow tie, whose signed area is zero", "add", bow_tie_of, false, false, None),
("a square", "add", |s| square(s, 50.0, "#0000ff"), false, false, Some(15_000.0)),
("a square, subtracting", "subtract", |s| square(s, 50.0, "#0000ff"), false, false, Some(5_000.0)),
];
for (what, mode, build, behind, warned, want) in cases {
let mut s = Session::new();
run(&mut s, "file.new", json!({"width": 400, "height": 300}));
let (back, front) = if behind {
let other = build(&mut s);
(other, square(&mut s, 0.0, "#ff0000"))
} else {
let sq = square(&mut s, 0.0, "#ff0000");
(sq, build(&mut s))
};
run(&mut s, "select.set", json!({"ids": [back.0, front.0]}));
let r = run(&mut s, "object.compoundShape.make", json!({ "mode": mode }));
let id = NodeId(r["id"].as_u64().unwrap_or_else(|| panic!("{what}: {r}")));
assert_eq!(node(&s, id).children().unwrap().len(), 2, "{what}: both are members");
assert_eq!(r.get("warning").and_then(Value::as_str), warned.then_some(OPEN_PATHS_ADD_NO_AREA), "{what}: {r}");
if let Some(want) = want {
let d = &s.doc().unwrap().doc;
let hook = |c: &Node| effects::outline_object(Some(d), c);
let got = effects::compound_shape_area(None, &node(&s, id), Some(&hook)).map_or(0.0, |p| area(&p));
assert!((got - want).abs() < 0.5, "{what}: draws {got}, not {want}");
}
}
}
@@ -377,7 +377,7 @@ fn ids_cases(d: u64) -> Vec<(&'static str, &'static str, serde_json::Value, Unse
("addon.color.filter", "ids", json!({"effect": "addon.color.invert"}), Selected),
("addon.color.applyNearestSwatch", "ids", json!({}), Selected),
("edit.colors.overprintBlack", "ids", json!({}), Selected),
("edit.findReplace", "ids", json!({"find": "A", "replace": "B"}), Gives(json!({"count": 1}))),
("edit.findReplace", "ids", json!({"find": "A", "replace": "B"}), Gives(json!({"count": 1, "replaced": 1}))),
("layer.highlight", "ids", json!({}), Fails("missing ids")),
("layer.move", "ids", json!({ "target": d }), Fails("missing ids")),
("library.add", "ids", json!({"kind": "graphic"}), Selected),
+214
View File
@@ -167,6 +167,183 @@ fn clicking_rows_at_any_depth_highlights_them_and_sets_the_current_layer() {
assert_eq!(document_rows(&s), vec![g.0, c.0], "document.inspect lists the rows");
}
/// Run `layer.highlight` with `ids` and `mode` → (the rows it returned, the current layer), after
/// checking that the call counted one revision and left the rows it returned highlighted.
fn highlight_rows(s: &mut Session, ids: &[NodeId], mode: &str) -> (Vec<NodeId>, Option<NodeId>) {
let revision = s.doc().unwrap().revision;
let r = run(s, "layer.highlight", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "mode": mode}));
let st = s.doc().unwrap();
assert_eq!(st.revision, revision + 1, "{mode} {ids:?}");
let rows: Vec<NodeId> = r["rows"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
assert_eq!(rows, st.layer_rows, "{mode} {ids:?}");
(rows, st.active_layer)
}
/// `layer.highlight` keeps the rows in highlight order: `set` and `add` take a repeated id once,
/// `toggle` takes an id listed twice off and on again (or on and off, and its layer becomes the
/// current one), unknown ids and ids after the first 100,000 are dropped, rows highlighted twice
/// stay as they are on `add`, and `toggle` takes every copy off.
#[test]
fn highlighting_rows_keeps_their_order_with_repeated_unknown_and_excess_ids() {
let mut s = session();
let (layer, sub, a, g, b, c) = tree(&mut s);
let unknown = NodeId(9999);
assert_eq!(highlight_rows(&mut s, &[a, g, a, unknown, c], "set"), (vec![a, g, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[g, b, a, b], "add"), (vec![a, g, c, b], Some(sub)));
assert_eq!(highlight_rows(&mut s, &[c, c], "toggle"), (vec![a, g, b, c], Some(layer)));
// `sub` goes on and off again; it was the last row added, so its layer is the current one.
assert_eq!(highlight_rows(&mut s, &[sub, sub], "toggle"), (vec![a, g, b, c], Some(sub)));
assert_eq!(highlight_rows(&mut s, &[a, unknown], "toggle"), (vec![g, b, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[], "add"), (vec![g, b, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[], "toggle"), (vec![g, b, c], Some(layer)));
s.doc_mut().unwrap().active_layer = Some(sub);
assert_eq!(highlight_rows(&mut s, &[], "set"), (vec![], Some(sub)), "no rows: the current layer stays");
let mut excess = vec![unknown; 100_000];
excess.push(a);
assert_eq!(highlight_rows(&mut s, &excess, "set"), (vec![], Some(sub)), "only the first 100,000 ids count");
s.doc_mut().unwrap().layer_rows = vec![a, a, g];
assert_eq!(highlight_rows(&mut s, &[a, c], "add"), (vec![a, a, g, c], Some(layer)));
assert_eq!(highlight_rows(&mut s, &[a], "toggle"), (vec![g, c], Some(layer)));
// The same with more than 8 ids.
s.doc_mut().unwrap().layer_rows = vec![a, a, g];
assert_eq!(highlight_rows(&mut s, &[a, c, c, c, c, c, c, c, c], "add"), (vec![a, a, g, c], Some(layer)));
s.doc_mut().unwrap().layer_rows = vec![a, a, g];
assert_eq!(highlight_rows(&mut s, &[a, b, b, b, b, b, b, b, b], "toggle"), (vec![g], Some(sub)), "`b` goes on and off 4 times");
assert_eq!(highlight_rows(&mut s, &[c, g, sub, g, sub, a, unknown, a, c, layer], "toggle"), (vec![g, layer], Some(layer)));
let revision = s.doc().unwrap().revision;
assert!(s.execute("layer.highlight", &json!({"ids": [b.0], "mode": "nope"})).is_err());
let st = s.doc().unwrap();
assert_eq!((st.revision, st.layer_rows.clone()), (revision, vec![g, layer]), "a bad mode changes nothing");
}
/// `layer.highlight`'s rule as a search of the highlighted rows for each id in `p`. The tests
/// compare the command with it.
fn highlight_by_search(st: &mut DocState, p: &Value) -> Value {
let mut ids: Vec<NodeId> = p["ids"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
ids.truncate(crate::cmd::layer::MAX_ROWS);
let mode = p["mode"].as_str().unwrap_or("set");
ids.retain(|id| st.doc.node(*id).is_some());
let mut rows = st.highlighted_rows();
if mode == "set" {
rows.clear();
}
let mut last = None;
for id in ids {
if mode == "toggle" && rows.contains(&id) {
rows.retain(|r| *r != id);
} else if !rows.contains(&id) {
rows.push(id);
last = Some(id);
}
}
if let Some(layer) = last.or(rows.last().copied()).and_then(|id| st.doc.layer_containing(id)) {
st.active_layer = Some(layer);
}
st.layer_rows = rows;
st.revision += 1;
json!({ "rows": st.layer_rows.iter().map(|i| i.0).collect::<Vec<_>>() })
}
/// Two sessions with `n` squares on a layer and a sublayer after them, and the squares' ids.
fn highlight_pair(n: usize) -> (Session, Session, Vec<NodeId>, NodeId) {
let make = || {
let mut s = super::large_edits::session(n, super::large_edits::square);
let sub = id(&run(&mut s, "layer.newSublayer", json!({"name": "Sub"})));
(s, sub)
};
let ((cmd, sub), (search, other)) = (make(), make());
assert_eq!(sub, other);
let squares = super::large_edits::layer(&cmd, 0).into_iter().filter(|i| *i != sub).collect();
(cmd, search, squares, sub)
}
/// `p` for `layer.highlight` with `ids` and `mode`.
fn highlight_params(ids: impl IntoIterator<Item = NodeId>, mode: &str) -> Value {
json!({"ids": ids.into_iter().map(|i| i.0).collect::<Vec<_>>(), "mode": mode})
}
/// On 3,000 rows `layer.highlight` gives what [`highlight_by_search`] gives: the same rows in the
/// same order, the same current layer and the same returned rows, with repeated, unknown and
/// toggled ids.
#[test]
fn layer_highlight_matches_a_search_of_the_rows_for_each_id() {
let (mut cmd, mut search, sq, sub) = highlight_pair(3_000);
let unknown = NodeId(u64::MAX);
let steps = [
highlight_params(sq[..2_000].iter().copied(), "set"),
highlight_params(sq[1_000..].iter().copied().chain([sub, sq[0]]), "add"),
highlight_params([sq[5], sq[5], sub, sq[2_999], unknown, sub, sub], "toggle"),
highlight_params(sq[500..520].iter().chain(&sq[510..515]).copied(), "toggle"),
highlight_params(sq.iter().rev().step_by(7).copied(), "add"),
highlight_params(sq.iter().step_by(3).copied().chain([sub]), "toggle"),
highlight_params(Vec::new(), "add"),
highlight_params(sq.iter().rev().step_by(2).chain(&sq[..10]).copied(), "set"),
highlight_params(Vec::new(), "set"),
];
for p in &steps {
let r = run(&mut cmd, "layer.highlight", p.clone());
let expected = highlight_by_search(search.doc_mut().unwrap(), p);
let (a, b) = (cmd.doc().unwrap(), search.doc().unwrap());
assert_eq!(r, expected, "{}", p["mode"]);
assert_eq!((&a.layer_rows, a.active_layer, a.revision), (&b.layer_rows, b.active_layer, b.revision), "{}", p["mode"]);
}
}
/// Time `layer.highlight` against [`highlight_by_search`] on one layer of 20,000 paths: `set` of
/// all of them, `add` of 10,000 already highlighted and `toggle` of one, 7 runs each, both checked
/// to give the same rows and current layer.
/// Run with `cargo test --release -p vectorcraft-engine --lib layer_highlight_timing -- --ignored --nocapture`.
#[test]
#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
fn layer_highlight_timing() {
let (mut cmd, mut search, sq, _) = highlight_pair(20_000);
let steps = [
("set of 20,000", highlight_params(sq.iter().copied(), "set")),
("add of 10,000", highlight_params(sq[5_000..15_000].iter().copied(), "add")),
("toggle of 1", highlight_params([sq[10_000]], "toggle")),
];
let mut ms = vec![(Vec::new(), Vec::new()); steps.len()];
for run_no in 0..7 {
for (i, (_, p)) in steps.iter().enumerate() {
let mut time_cmd = || {
let start = std::time::Instant::now();
let r = cmd.execute("layer.highlight", p).unwrap();
(start.elapsed().as_secs_f64() * 1000.0, r)
};
let mut time_search = || {
let start = std::time::Instant::now();
let r = highlight_by_search(search.doc_mut().unwrap(), p);
(start.elapsed().as_secs_f64() * 1000.0, r)
};
// Alternate which goes first.
let ((tc, rc), (ts, rs)) = if run_no % 2 == 0 {
let c = time_cmd();
(c, time_search())
} else {
let s = time_search();
(time_cmd(), s)
};
assert_eq!(rc, rs);
let (a, b) = (cmd.doc().unwrap(), search.doc().unwrap());
assert_eq!((&a.layer_rows, a.active_layer), (&b.layer_rows, b.active_layer));
ms[i].0.push(ts);
ms[i].1.push(tc);
}
}
let median = |v: &[f64]| {
let mut v = v.to_vec();
v.sort_by(f64::total_cmp);
v[v.len() / 2]
};
for ((name, _), (search_ms, cmd_ms)) in steps.iter().zip(&ms) {
println!(
"{name}: search {:.3} ms, command {:.3} ms (median of 7); search runs {search_ms:.3?}, command runs {cmd_ms:.3?}",
median(search_ms),
median(cmd_ms)
);
}
}
fn document_rows(s: &Session) -> Vec<u64> {
crate::inspect::document(s)["layerRows"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
}
@@ -1102,6 +1279,43 @@ fn locate_object_highlights_its_row() {
assert!(s.execute("layer.locate", &json!({})).is_err());
}
/// With several objects selected, Locate Object finds the frontmost one in the stacking order,
/// whatever order they were selected in; an `id` still wins.
#[test]
fn locate_object_finds_the_frontmost_selected_object() {
let mut s = session();
let (_, sub, a, g, b, c) = tree(&mut s);
let top = id(&run(&mut s, "layer.new", json!({"top": true})));
let d = rect(&mut s, 400.0);
let locate = |s: &mut Session, ids: &[NodeId]| {
run(s, "select.set", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()}));
assert_eq!(s.doc().unwrap().selection.objects.last(), ids.last(), "selected in this order");
run(s, "layer.locate", json!({}))["id"].clone()
};
// In one sublayer, the group in front of the rectangle selected last.
assert_eq!(locate(&mut s, &[g, a]), json!(g.0));
assert_eq!(s.doc().unwrap().highlighted_rows(), vec![g]);
// The sublayer sits in front of the art directly in its layer.
assert_eq!(locate(&mut s, &[a, c]), json!(a.0));
// A higher layer wins over everything below it.
assert_eq!(locate(&mut s, &[d, b, c]), json!(d.0));
assert_eq!(s.doc().unwrap().highlighted_rows(), vec![d]);
// A group and its member: the member paints after the group it is in.
assert_eq!(locate(&mut s, &[b, g]), json!(b.0));
// Added one at a time, as by Shift-clicks.
run(&mut s, "select.set", json!({"ids": [d.0]}));
run(&mut s, "select.add", json!({"ids": [a.0]}));
assert_eq!(run(&mut s, "layer.locate", json!({}))["id"], d.0);
// An id still locates that object, behind the selection or not.
assert_eq!(run(&mut s, "layer.locate", json!({"id": c.0}))["id"], c.0);
assert_eq!(s.doc().unwrap().highlighted_rows(), vec![c]);
// Locate Layer takes the layer of the frontmost selected object.
run(&mut s, "select.set", json!({"ids": [d.0, a.0]}));
assert_eq!(run(&mut s, "layer.locate", json!({"layersOnly": true})), json!({"id": top.0, "objectId": d.0, "ancestry": [top.0]}));
run(&mut s, "select.set", json!({"ids": [a.0, c.0]}));
assert_eq!(run(&mut s, "layer.locate", json!({"layersOnly": true}))["id"], sub.0);
}
/// Locate Layer (`layersOnly`, sent while Show Layers Only is on) highlights the innermost layer
/// or sublayer holding the object, through any groups; a layer locates itself.
#[test]
+183 -4
View File
@@ -2377,7 +2377,8 @@ fn find_and_replace_leaves_type_on_a_locked_artboard() {
/// Find and Replace that replaces each match with the text it is (`CAT` found in `cat`, ignoring
/// case, and replaced by `cat`) records no undo step: the step to redo stays and the document stays
/// unmodified. It still replies with the count. A replacement that changes the text is one undo step.
/// unmodified. It still replies with the count, and with no match replaced. A replacement that
/// changes the text is one undo step.
#[test]
fn find_and_replace_that_changes_nothing_records_no_undo_step() {
let mut s = session();
@@ -2385,9 +2386,9 @@ fn find_and_replace_that_changes_nothing_records_no_undo_step() {
select_with_a_step_to_redo(&mut s, &[a]);
let before = history(&s);
assert_eq!((before.1, before.2), (1, false), "a step to redo, and nothing unsaved");
assert_eq!(s.execute("edit.findReplace", &json!({"find": "CAT", "replace": "cat"})).unwrap(), json!({"count": 2}));
assert_eq!(s.execute("edit.findReplace", &json!({"find": "CAT", "replace": "cat"})).unwrap(), json!({"count": 2, "replaced": 0}));
assert_eq!((history(&s), plain(&s, a)), (before, "cat cat".to_string()));
assert_eq!(s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog"})).unwrap(), json!({"count": 2}));
assert_eq!(s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog"})).unwrap(), json!({"count": 2, "replaced": 2}));
assert_eq!((history(&s), plain(&s, a)), ((before.0 + 1, 0, true), "dog dog".to_string()));
}
@@ -2424,12 +2425,190 @@ fn find_next_cycles_through_text_objects() {
let _ = text(&mut s, "banana");
let c = text(&mut s, "pineapple");
s.execute("select.none", &json!({})).unwrap();
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "APPLE"})).unwrap()), a);
// From the top of the stacking order down, then round again.
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "APPLE"})).unwrap()), c);
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "apple"})).unwrap()), a);
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "apple"})).unwrap()), c);
// A selection that starts with a shape goes on after its first type object.
let shape = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
sel(&mut s, &[shape, c]);
assert_eq!(id_of(&s.execute("edit.findNext", &json!({"find": "apple"})).unwrap()), a);
assert!(s.execute("edit.findNext", &json!({"find": "zzz"})).unwrap()["id"].is_null());
}
/// The match `r` (an `edit.findNext` result) as (object, start, end, index, count).
fn found(r: &Value) -> (u64, u64, u64, u64, u64) {
let n = |k: &str| r[k].as_u64().unwrap_or_else(|| panic!("no `{k}` in {r}"));
(n("id"), n("start"), n("end"), n("index"), n("count"))
}
/// Find Next steps through the matches one by one when each call is given the match before it:
/// the objects from the top of the stacking order down, each object's matches in reading order,
/// and round again after the last. Search Backwards visits them the other way. Each match is
/// returned with its bytes and its object is selected; nothing is recorded for undo.
#[test]
fn find_next_steps_through_the_matches_in_both_directions() {
let mut s = session();
let bottom = text(&mut s, "cat éa cat");
let _ = text(&mut s, "dog");
let top = text(&mut s, "a cat");
s.execute("select.none", &json!({})).unwrap();
let before = history(&s);
let step = |s: &mut Session, from: &Value, backwards: bool| {
let from = if from.is_null() { Value::Null } else { json!({"id": from["id"], "start": from["start"], "end": from["end"]}) };
s.execute("edit.findNext", &json!({"find": "cat", "from": from, "backwards": backwards})).unwrap()
};
// "é" is two bytes, so the second match of the bottom object is at bytes 8..11.
let forward = [(top.0, 2, 5, 1, 3), (bottom.0, 0, 3, 2, 3), (bottom.0, 8, 11, 3, 3), (top.0, 2, 5, 1, 3)];
let mut at = Value::Null;
for want in forward {
at = step(&mut s, &at, false);
assert_eq!((found(&at), selected(&s), at["selected"].clone()), (want, vec![NodeId(want.0)], json!(true)));
}
let backward = [(bottom.0, 8, 11, 3, 3), (bottom.0, 0, 3, 2, 3), (top.0, 2, 5, 1, 3), (bottom.0, 8, 11, 3, 3)];
s.execute("select.none", &json!({})).unwrap();
let mut at = Value::Null;
for want in backward {
at = step(&mut s, &at, true);
assert_eq!((found(&at), selected(&s)), (want, vec![NodeId(want.0)]));
}
assert_eq!(history(&s), before, "finding is no undo step");
// A `from` in an object the search does not visit starts at the first match.
let r = s.execute("edit.findNext", &json!({"find": "cat", "from": {"id": 999_999, "start": 0, "end": 0}})).unwrap();
assert_eq!(found(&r), (top.0, 2, 5, 1, 3));
// So does a null `from`, with a type object selected.
sel(&mut s, &[top]);
let r = s.execute("edit.findNext", &json!({"find": "cat", "from": null})).unwrap();
assert_eq!(found(&r), (top.0, 2, 5, 1, 3));
// Nothing found: no match, and the selection stays.
let r = s.execute("edit.findNext", &json!({"find": "zebra"})).unwrap();
assert_eq!((r, selected(&s)), (json!({"id": null, "count": 0}), vec![top]));
}
/// Check Hidden Layers and Check Locked Layers: Find Next and Find and Replace leave the type of
/// a hidden layer and of a locked layer alone unless the switch for it is on. A match on such a
/// layer is returned without being selected. A hidden or locked object keeps its type out with
/// the switches on.
#[test]
fn find_and_replace_reach_hidden_and_locked_layers_only_when_asked() {
for (prop, switch, other) in [("visible", "hiddenLayers", "lockedLayers"), ("locked", "lockedLayers", "hiddenLayers")] {
let mut s = session();
let open = text(&mut s, "cat one");
let layer = id_of(&s.execute("layer.new", &json!({})).unwrap());
let closed = text(&mut s, "cat two");
let object = text(&mut s, "cat three");
let off = |id: NodeId| if prop == "visible" { json!({"id": id.0, "visible": false}) } else { json!({"id": id.0, "locked": true}) };
s.execute("object.setProps", &off(object)).unwrap();
s.execute("layer.setProps", &off(layer)).unwrap();
sel(&mut s, &[open]);
// Without the switch, and with only the other one, the one reachable match is found.
for p in [json!({"find": "cat"}), json!({"find": "cat", other: true})] {
let r = s.execute("edit.findNext", &p).unwrap();
assert_eq!(found(&r), (open.0, 0, 3, 1, 1), "{prop} {p}");
}
// With it, the layer's type is searched (it is above, so it comes first) and not selected.
s.execute("select.none", &json!({})).unwrap();
let r = s.execute("edit.findNext", &json!({"find": "cat", switch: true})).unwrap();
assert_eq!((found(&r), r["selected"].clone(), selected(&s)), ((closed.0, 0, 3, 1, 2), json!(false), vec![]), "{prop}");
let r = s.execute("edit.findNext", &json!({"find": "cat", switch: true, "from": {"id": closed.0, "start": 0, "end": 3}})).unwrap();
assert_eq!((found(&r), r["selected"].clone(), selected(&s)), ((open.0, 0, 3, 2, 2), json!(true), vec![open]), "{prop}");
// Replace All: the same reach.
let n = undo_len(&s);
assert_eq!(
s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog", other: true})).unwrap(),
json!({"count": 1, "replaced": 1}),
"{prop}"
);
assert_eq!((plain(&s, open), plain(&s, closed), plain(&s, object)), ("dog one".into(), "cat two".into(), "cat three".into()), "{prop}");
assert_eq!(
s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog", switch: true})).unwrap(),
json!({"count": 1, "replaced": 1}),
"{prop}"
);
assert_eq!((plain(&s, closed), plain(&s, object), undo_len(&s)), ("dog two".into(), "cat three".into(), n + 2), "{prop}");
}
}
/// Replace changes one match, the bytes Find Next returned, as one undo step, and returns the
/// replacement's bytes to go on from. Bytes that are no match are refused, and a match that
/// already reads as the replacement is left with no undo step.
#[test]
fn replace_match_replaces_the_one_match_found() {
let mut s = session();
let t = text(&mut s, "cat cat Cat");
s.execute("select.none", &json!({})).unwrap();
let first = s.execute("edit.findNext", &json!({"find": "cat"})).unwrap();
assert_eq!(found(&first), (t.0, 0, 3, 1, 3));
let n = undo_len(&s);
let r = s.execute("edit.replaceMatch", &json!({"find": "cat", "replace": "horse", "id": t.0, "start": 0, "end": 3})).unwrap();
assert_eq!(r, json!({"id": t.0, "start": 0, "end": 5, "replaced": true}));
assert_eq!((plain(&s, t), undo_len(&s)), ("horse cat Cat".to_string(), n + 1));
// Replace & Find: on from the replacement, so text put in is not searched again.
let r = s.execute("edit.replaceMatch", &json!({"find": "cat", "replace": "a cat", "id": t.0, "start": 6, "end": 9})).unwrap();
let next = s.execute("edit.findNext", &json!({"find": "cat", "from": {"id": r["id"], "start": r["start"], "end": r["end"]}})).unwrap();
assert_eq!((plain(&s, t), found(&next)), ("horse a cat Cat".to_string(), (t.0, 12, 15, 2, 2)));
// Match Case decides what a match is.
let shape = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
s.execute("select.none", &json!({})).unwrap();
let before = (history(&s), plain(&s, t));
for (p, want) in [
(json!({"find": "cat", "replace": "x", "matchCase": true, "id": t.0, "start": 12, "end": 15}), "at bytes 12..15 of object"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": 1, "end": 4}), "at bytes 1..4 of object"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": 4, "end": 1}), "at bytes 1..4 of object"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": 0}), "missing `end`"),
(json!({"find": "cat", "replace": "x", "start": 0, "end": 3}), "missing `id`"),
(json!({"find": "cat", "replace": "x", "id": t.0, "start": "0", "end": 3}), "`start` must be a whole number"),
(json!({"find": "", "replace": "x", "id": t.0, "start": 0, "end": 3}), "missing `find`"),
(json!({"find": "cat", "replace": 5, "id": t.0, "start": 8, "end": 11}), "`replace` must be a string"),
(json!({"find": "cat", "replace": "x", "id": shape.0, "start": 0, "end": 3}), "is not text"),
] {
let r = s.execute("edit.replaceMatch", &p);
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if msg.contains(want)), "{p}: {r:?}");
assert_eq!((history(&s), plain(&s, t)), before, "{p}");
}
let r = s.execute("edit.replaceMatch", &json!({"find": "cat", "replace": "x", "id": 999_999, "start": 0, "end": 3}));
assert!(matches!(r, Err(EngineError::NoNode(NodeId(999_999)))), "{r:?}");
// A match that already reads as the replacement: nothing to undo.
let r = s.execute("edit.replaceMatch", &json!({"find": "CAT", "replace": "Cat", "id": t.0, "start": 12, "end": 15})).unwrap();
assert_eq!((r, history(&s)), (json!({"id": t.0, "start": 12, "end": 15, "replaced": false}), before.0));
// Find Next refuses a `from` that is not a match.
for (from, want) in [
(json!(5), "missing `id`"),
(json!({"id": t.0, "start": 2}), "missing `end`"),
(json!({"id": "x", "start": 0, "end": 1}), "`id` must be a whole number"),
] {
let r = s.execute("edit.findNext", &json!({"find": "cat", "from": from}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if msg.contains(want)), "{from}: {r:?}");
}
for key in ["backwards", "hiddenLayers", "lockedLayers"] {
let r = s.execute("edit.findNext", &json!({"find": "cat", key: "yes"}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if *msg == format!("`{key}` must be true or false")), "{key}: {r:?}");
}
for key in ["hiddenLayers", "lockedLayers"] {
let r = s.execute("edit.findReplace", &json!({"find": "cat", key: 1}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if *msg == format!("`{key}` must be true or false")), "{key}: {r:?}");
}
}
/// Ruby over text after a replaced match moves with the text, for Replace and for Replace All, as
/// it does when the text is typed.
#[test]
fn find_and_replace_moves_the_ruby_after_a_match() {
for all in [false, true] {
let mut s = session();
let t = text(&mut s, "ab 漢字");
sel(&mut s, &[t]);
s.execute("type.ruby", &json!({"text": "かんじ", "start": 3, "end": 9})).unwrap();
if all {
s.execute("edit.findReplace", &json!({"find": "ab", "replace": "abcd"})).unwrap();
} else {
s.execute("edit.replaceMatch", &json!({"find": "ab", "replace": "abcd", "id": t.0, "start": 0, "end": 2})).unwrap();
}
let NodeKind::Text(tt) = &node(&s, t).kind else { panic!() };
assert_eq!((tt.plain_text().as_str(), tt.ruby.first().map(|r| (r.start, r.end))), ("abcd 漢字", Some((5, 11))), "all: {all}");
}
}
/// The Type menu's commands and Find and Replace and Find Next refuse a param of the wrong type, or
/// `ids` that name no object, with an error naming the param, and leave the text, the selection and
/// the undo history as they were, even when Insert Character is also given a source it would use
+9 -4
View File
@@ -326,9 +326,11 @@ fn a_confined_package_names_files_outside_the_read_root_by_name() {
let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
String::from_utf8(zip["poster Folder/poster Report.txt"].clone()).unwrap()
};
// Reopened existing links use native separators; missing links keep their stored path.
let red = dir.0.join("art").join("red.png").to_string_lossy().into_owned();
let person = report(&run(&mut s, "file.package", json!({})));
assert!(person.contains(&format!("From: {}\n", dir.file("poster.vectorcraft"))), "{person}");
assert!(person.contains(&format!("{} → Links/red.png", dir.file("art/red.png"))), "{person}");
assert!(person.contains(&format!("{red} → Links/red.png")), "{person}");
assert!(person.contains(&format!("blue.png: not found ({})", dir.file("art/blue.png"))), "{person}");
let in_root = dir.0.join("in");
@@ -339,16 +341,19 @@ fn a_confined_package_names_files_outside_the_read_root_by_name() {
assert!(text.contains("\nred.png → Links/red.png\n") && text.contains("\nblue.png: not found (blue.png), not copied\n"), "{text}");
let base = dir.0.to_string_lossy().into_owned();
assert!(!text.contains(&base), "{text}");
// Compare serialized JSON with the path encoded the same way, without its outer quotes.
let json_base = serde_json::to_string(&base).unwrap();
let json_base = &json_base[1..json_base.len() - 1];
for key in ["missingLinks", "warnings", "files"] {
assert!(!client[key].to_string().contains(&base), "{key}: {client}");
assert!(!client[key].to_string().contains(json_base), "{key}: {client}");
}
// Document Info, whose report the package holds, gives no link either.
for p in [json!({}), json!({"format": "text"})] {
let info = crate::file_access::confine(roots.as_ref(), || run(&mut s, "document.info", p.clone()));
assert!(!info.to_string().contains(&base), "{p}: {info}");
assert!(!info.to_string().contains(json_base), "{p}: {info}");
}
let info = run(&mut s, "document.info", json!({"format": "text"}));
assert!(info.to_string().contains(&dir.file("art/red.png")), "the person's: {info}");
assert!(info["text"].as_str().unwrap().contains(&red), "the person's: {info}");
}
/// A confined request packages no document that links, or places a native document or a PDF with
+43
View File
@@ -836,6 +836,49 @@ fn a_null_in_group_colors_removes_that_swatch_and_the_ones_after_it_keep_their_p
assert_eq!(link(&s, green), ("#00ff00".into(), Some(names[2].clone())), "art linked to a swatch that stays keeps its link");
}
/// A gradient or pattern swatch of the group keeps its place and its paint when `recolor.apply`
/// rewrites the group: the group's colors, from the rows or from `groupColors`, go to its color
/// swatches in order.
#[test]
fn apply_with_a_group_keeps_its_gradient_swatch() {
let mut s = session();
run(&mut s, "swatch.newGroup", json!({"name": "Brand", "colors": ["#ff0000", "#0000ff"]}));
let fade = vectorcraft_color::Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default())));
s.edit("test", |d, _| {
let w = vectorcraft_color::Swatch { name: "Fade".into(), paint: fade.clone(), global: false, spot: false };
d.swatch_groups.iter_mut().find(|g| g.name == "Brand").unwrap().swatches.insert(1, w);
Ok(())
})
.unwrap();
let group = |s: &Session| -> Vec<(String, Option<String>)> {
let g = s.doc().unwrap().doc.swatch_groups.iter().find(|g| g.name == "Brand").unwrap().swatches.clone();
g.iter().map(|w| (w.name.clone(), w.paint.color().map(|c| c.to_hex()))).collect()
};
let names: Vec<String> = group(&s).into_iter().map(|(n, _)| n).collect();
rect(&mut s, json!("#ff0000"));
rect(&mut s, json!("#0000ff"));
select_all(&mut s);
// The rows' new colors go to the red and blue swatches; the gradient stays between them.
let map = json!([{"from": ["#ff0000"], "to": "#00ff00"}, {"from": ["#0000ff"], "to": "#ffff00"}]);
run(&mut s, "recolor.apply", json!({"map": map, "group": "Brand"}));
let want = |a: &str, b: &str| vec![(names[0].clone(), Some(a.to_string())), (names[1].clone(), None), (names[2].clone(), Some(b.to_string()))];
assert_eq!(group(&s), want("#00ff00", "#ffff00"));
assert_eq!(gradient_at(&s, 1), fade, "the gradient swatch keeps its paint");
// `groupColors` counts the color swatches only: "keep" is the first, and the second color is
// the blue swatch's.
run(&mut s, "recolor.apply", json!({"map": [], "group": "Brand", "groupColors": ["keep", "#123456"]}));
assert_eq!(group(&s), want("#00ff00", "#123456"));
// A null removes the color swatch at its place and leaves the gradient.
run(&mut s, "recolor.apply", json!({"map": [], "group": "Brand", "groupColors": [null, "#123456"]}));
assert_eq!(group(&s), [(names[1].clone(), None), (names[2].clone(), Some("#123456".into()))]);
assert_eq!(gradient_at(&s, 0), fade);
}
/// The paint of the swatch at place `i` of the group "Brand".
fn gradient_at(s: &Session, i: usize) -> vectorcraft_color::Paint {
s.doc().unwrap().doc.swatch_groups.iter().find(|g| g.name == "Brand").unwrap().swatches[i].paint.clone()
}
/// A row whose new color was removed keeps its art's colors: art in it linked to another swatch of
/// the group, which the rewrite gives another color, loses the link instead of following it.
#[test]
+25
View File
@@ -77,6 +77,31 @@ fn script_missing_include_reports_origin() {
assert!(report["message"].as_str().unwrap().contains("include file not found: nope.jsxinc"), "{report}");
assert_eq!(report["log"], json!([]), "nothing ran before the include was read");
assert!(report.get("file").is_none(), "the line is the script's own");
assert_eq!(report["messageOrigin"], "built-in");
let _ = std::fs::remove_dir_all(base);
}
/// An error in an included file keeps where its message came from: a value the file threw is the
/// script's own text, and an error the app raised for it, or for a file `$.evalFile` could not run, is not.
#[test]
fn script_include_errors_keep_their_message_origin() {
let base = folder("origin");
write(&base.join("main/lib.jsxinc"), "var a = 1;\n throw new RangeError('invalid array length');");
write(&base.join("main/native.jsxinc"), "var a = 1;\n new Array(-1);");
for (text, message, origin) in [
("#include \"lib.jsxinc\"", "RangeError: invalid array length", "script"),
("#include \"native.jsxinc\"", "RangeError: invalid array length", "built-in"),
("try {\n#include \"native.jsxinc\"\n} catch (e) { throw e; }", "RangeError: invalid array length", "built-in"),
("try {\n#include \"native.jsxinc\"\n} catch (e) { throw e.message; }", "invalid array length", "script"),
] {
let report = failed(&base, text);
assert_eq!((report["message"].as_str(), report["messageOrigin"].as_str()), (Some(message), Some(origin)), "{text}: {report}");
}
let report = failed(&base, "#include \"lib.jsxinc\"");
let file = report["file"].as_str().map(|f| Path::new(f).ends_with("lib.jsxinc"));
assert_eq!((file, report["line"].as_u64(), report["column"].as_u64()), (Some(true), Some(2), Some(3)), "{report}");
let report = failed(&base, "$.evalFile('nope.jsx');");
assert_eq!(report["messageOrigin"], "built-in", "{report}");
let _ = std::fs::remove_dir_all(base);
}
+52
View File
@@ -170,6 +170,58 @@ fn an_error_names_the_script_its_place_and_kind() {
assert_eq!(s.script_report().unwrap()["line"], 1);
}
/// A failed run's report keeps its message and kind and says where the message came from: text the
/// script supplied, or one of the app's own errors. The status text and the console line read the
/// same either way, and only the app's own errors get advice about other applications' objects.
#[test]
fn failed_script_report_keeps_message_and_adds_origin() {
let mut s = two_docs();
for (source, kind, message, origin) in [
("throw new Error('invalid array length');", "thrown", "Error: invalid array length", "script"),
("throw new RangeError('invalid array length');", "thrown", "RangeError: invalid array length", "script"),
("throw 'invalid array length';", "thrown", "invalid array length", "script"),
("throw 'ReferenceError: app is not defined';", "thrown", "ReferenceError: app is not defined", "script"),
("try { new Array(-1); } catch (e) { throw new Error(e.message); }", "thrown", "Error: invalid array length", "script"),
("new Array(-1);", "thrown", "RangeError: invalid array length", "built-in"),
("try { new Array(-1); } catch (e) { throw e; }", "thrown", "RangeError: invalid array length", "built-in"),
("vc.run();", "thrown", "TypeError: vc.run: give a command id, as a string", "built-in"),
] {
let e = run(&mut s, source).unwrap_err().to_string();
let report = s.script_report().unwrap().clone();
assert_eq!(
(report["kind"].as_str(), report["message"].as_str(), report["messageOrigin"].as_str()),
(Some(kind), Some(message), Some(origin)),
"{source}"
);
let (line, column) = (&report["line"], &report["column"]);
let before = format!("t.js: line {line}, column {column}: ");
assert_eq!(e, format!("{before}{message} ({kind})"), "{source}");
assert_eq!(s.script_failure_text().as_deref(), Some(e.as_str()));
let authored = s.script_authored_failure();
assert_eq!(authored, (origin == "script").then(|| (before.clone(), message, format!(" ({kind})"))), "{source}");
let console = s.execute("script.console", &json!({})).unwrap();
let error = console["lines"].as_array().unwrap().iter().rev().find(|l| l["kind"] == "error").map(|l| l["text"].clone());
assert_eq!(error, Some(json!(format!("t.js:{line}:{column}: {message}"))), "{source}");
}
// The app's own reference error names the `vc` object; the same text a script threw does not.
run(&mut s, "app.activeDocument;").unwrap_err();
assert!(s.script_report().unwrap()["message"].as_str().unwrap().contains("`vc`"));
assert_eq!(s.script_report().unwrap()["messageOrigin"], "built-in");
// An error in code `eval` compiled keeps where its message came from.
let e = run(&mut s, "eval(\"throw new Error('invalid array length')\");").unwrap_err().to_string();
assert_eq!(e, "t.js: Error: invalid array length (thrown)");
assert_eq!(s.script_authored_failure(), Some(("t.js: ".to_string(), "Error: invalid array length", " (thrown)".to_string())));
// Syntax errors and limits are the app's own.
run(&mut s, "var = 1;").unwrap_err();
assert_eq!((s.script_report().unwrap()["kind"].as_str(), s.script_authored_failure()), (Some("syntax"), None));
s.execute("script.run", &json!({"source": "while (true) {}", "name": "t.js", "maxFuel": 100_000})).unwrap_err();
assert_eq!((s.script_report().unwrap()["messageOrigin"].as_str(), s.script_authored_failure()), (Some("built-in"), None));
// A run that completes has no failure to split.
run(&mut s, "throw 'x';").unwrap_err();
run(&mut s, "1").unwrap();
assert_eq!(s.script_authored_failure(), None);
}
/// An error raised where the run has no place for it, such as in code `eval` compiled, is named
/// with the script and its kind alone, with one colon after the script's name.
#[test]
+15 -5
View File
@@ -188,8 +188,7 @@ impl Session {
.then(|| self.tool.options().get("meshPoints").cloned())
.flatten()
.filter(|v| v.as_array().is_some_and(|a| !a.is_empty()));
let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
self.apply_actions(acts)?;
self.deactivate_tool(view)?;
self.keep_tool_settings();
self.tool = self.make_tool(id);
if let Some(selection) = text_selection {
@@ -205,6 +204,18 @@ impl Session {
Ok(())
}
/// Deactivate the tool and apply the actions it returns. In a batch, a Cancel is left out: the
/// batch settled the tool's drag when it began, and the open interaction holds the batch's
/// steps, which the batch keeps or rolls back as a whole.
pub(crate) fn deactivate_tool(&mut self, view: ViewInfo) -> Result<()> {
let mut acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
if self.batch_stash.is_some() {
acts.retain(|a| !matches!(a, Action::Cancel));
}
self.apply_actions(acts)?;
Ok(())
}
/// The selection tools other than Direct Selection pick whole objects: with one of them chosen,
/// an object selected in a symbol instance's art gives way to the instance. The revision
/// changes with it, so panels that cache by revision show the instance.
@@ -297,8 +308,7 @@ impl Session {
// them all (#8090). Group Selection picks no mesh points, so the Eyedropper keeps its own.
let mesh_points =
(lender.id() == "eyedropper" && self.tool.id() != "groupSelection").then(|| self.tool.options().get("meshPoints").cloned()).flatten();
let acts = self.with_tool_cx(view, |t, cx| t.deactivate(cx));
let r = self.apply_actions(acts);
let r = self.deactivate_tool(view);
self.keep_tool_settings();
self.tool = lender;
if let Some(points) = mesh_points {
@@ -311,7 +321,7 @@ impl Session {
self.lent_selection = left;
}
self.after_command(None);
r.map(drop)
r
}
/// A fresh `id` tool with the options it keeps ([`settings`]): its last values, from this
File diff suppressed because it is too large. Load diff
+4 -2
View File
@@ -38,11 +38,13 @@ pub(crate) use blend::{MAX_BLEND_OBJECTS, MAX_KEYS as MAX_BLEND_KEYS, PLUGIN as
pub(crate) use brush::{
BrushesRead, MANAGER_NAME as BRUSH_MANAGER, brushes_kept, plugin_name as brush_plugin_name, read_brush_object, turn_over as turn_brush_art_over,
};
#[cfg(test)]
pub(crate) use envelope::DASH_CHECKS_MADE;
pub(crate) use envelope::DRAWN as ENVELOPE_DRAWN;
pub(crate) use envelope::MAX_CHECKED;
pub(crate) use envelope::TYPE_DRAWN as ENVELOPE_TYPE_DRAWN;
pub(crate) use envelope::{GridPoint as EnvelopeGridPoint, PLUGIN as DEFORM_PLUGIN, outline as envelope_outline, upright as envelope_upright};
pub(crate) use envelope::{MAX_ANY as ENVELOPE_MAX_ANY, MAX_SOLID as ENVELOPE_MAX_SOLID};
pub(crate) use envelope::{MAX_CHECKED, MAX_DASH_CHECKS};
pub(crate) use envelope::{WARPED_TYPE_DRAWN, WarpedType};
#[cfg(test)]
pub(crate) use frames::TEXT_FRAME_SCANS;
@@ -67,7 +69,7 @@ pub use read::{
#[cfg(test)]
pub(crate) use style::ART_STYLE_PARSES;
pub(crate) use read::is_look_slot;
pub(crate) use read::{clip_by_type, is_look_slot};
pub(crate) use style::{MAX_LISTED, MAX_LISTED_NAME, warp_number};
#[cfg(test)]
+2 -1
View File
@@ -10,7 +10,8 @@
//! locally, never committed): the blend's own art on `%_` lines, a group holding the key objects
//! and the spine, each object's `/ArtDictionary` naming its part (`ShapeBlendPathType`: `K` a key,
//! `S` the spine) and a key's id (`ShapeBlendPathID`); then the steps drawn, a group on plain
//! lines; then `(Adobe Path Blends) 1 0 n XP` and `n` bytes as hex on `%` lines. Those bytes
//! lines; then `(Adobe Path Blends) 1 0 n XP` and `n` bytes as hex on `%` lines (`%_%` lines
//! for a blend in hidden art, as an opacity mask's is: all of it is on `%_` lines). Those bytes
//! start `DCBA`. A blend whose spine was never edited has no spine part: only its keys.
//!
//! The reader reads the words after `DCBA` (little endian) this way. Word 1 is the spacing: 0 is
+80 -4
View File
@@ -59,6 +59,16 @@ pub(crate) fn drawn_note(typed: bool) -> &'static str {
pub(super) const MAX_PENDING: usize = 64;
/// The most envelopes and warped text objects one import draws to check; more keep their drawn art.
pub(crate) const MAX_CHECKED: usize = 256;
/// The most strokes with dashes aligned to corners one import draws to check against their drawn
/// looks (apart from [`MAX_CHECKED`]); more keep their drawn looks.
pub(crate) const MAX_DASH_CHECKS: usize = 256;
#[cfg(test)]
thread_local! {
/// How many strokes with dashes aligned to corners have been drawn on this thread to check them
/// against their looks.
pub(crate) static DASH_CHECKS_MADE: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
/// The most rows or columns of a mesh read (Make with Mesh's own limit).
const MAX_GRID: u32 = 50;
/// How far, in points over width and height together, a saved size may lie from the contents'
@@ -692,6 +702,8 @@ pub struct WarpedType {
pub(super) checks: usize,
pub(super) spent: Spent,
pub(super) page: Option<Rect>,
/// [`super::Structure::type_clips`]: type in an envelope's contents clips its clipping group too.
pub(super) type_clips: HashMap<NodeId, NodeId>,
/// The envelopes of type that may open live in layers built without a page, by their place
/// among them ([`Self::open_alone`]): none when `None`.
pub(super) alone: Option<BTreeSet<usize>>,
@@ -811,8 +823,10 @@ impl WarpedType {
texts.insert(slot, text);
hidden.push(id);
}
let typed = |slot: NodeId| texts.get(&slot).map(|t| t.id);
for n in before.iter_mut().chain(inner.iter_mut()) {
put_type(n, &texts);
super::clip_by_type(n, &self.type_clips, &typed, &mut |_| ());
}
// A warp that VectorCraft's own warp doesn't draw as its drawn art may still draw as the
// grid the file saves for it: then it opens as a mesh envelope on that grid.
@@ -980,10 +994,11 @@ pub(super) fn warps(appearance: &Appearance) -> bool {
appearance.effects.iter().any(warp) || appearance.items.iter().any(|i| i.visible() && i.effects().iter().any(warp))
}
/// Do `live` and `drawn` draw alike: few of the pixels either inks differ, and fewer still where a
/// whole patch differs; and, on `page` (when the file has one), do they differ little enough that
/// with the differences in `spent` the page check still takes the layers' art (it is added to
/// `spent` when they do)? Both are drawn on `layer`, a layer id no other node has.
/// Do `live` and `drawn` draw alike? Either neither has any paint ([`paints`]), or few of the
/// pixels either inks differ and fewer still where a whole patch differs, and, on `page` (when the
/// file has one), they differ little enough that with the differences in `spent` the page check
/// still takes the layers' art (it is added to `spent` when they do). Both are drawn on `layer`, a
/// layer id no other node has.
pub(super) fn drawn_alike(live: &Node, drawn: &Node, layer: NodeId, shared: &Shared<'_>, page: Option<Rect>, spent: &mut Spent) -> bool {
alike_within(live, drawn, live.visual_bounds(), layer, shared, page, spent)
}
@@ -997,6 +1012,12 @@ pub(super) fn warped_alike(live: &Node, drawn: &Node, layer: NodeId, shared: &Sh
/// [`drawn_alike`], with `live` measured as `reach`.
fn alike_within(live: &Node, drawn: &Node, reach: Option<Rect>, layer: NodeId, shared: &Shared<'_>, page: Option<Rect>, spent: &mut Spent) -> bool {
// Neither has any paint (type with no fill and no stroke, its drawn art the outlines unpainted):
// both draw nothing, so they draw alike and add nothing to what the page check sees. Their
// shapes aren't compared. Art that paints, however faintly, is compared as before.
if !paints(live, 0) && !paints(drawn, 0) {
return true;
}
let (Some(a), Some(b)) = (reach, drawn.visual_bounds()) else { return false };
let region = a.union(b).inflate(2.0, 2.0);
if !(region.is_finite() && region.width() > 0.0 && region.height() > 0.0) || region.width().max(region.height()) > 1e6 {
@@ -1029,6 +1050,26 @@ fn alike_within(live: &Node, drawn: &Node, reach: Option<Rect>, layer: NodeId, s
true
}
/// Does `n`, shown, paint anything: a fill or stroke of its own or of its type with a paint, an
/// effect, or an object of another kind than a path, type or container (an image, a mesh, a symbol
/// instance…)? Hidden objects paint nothing. Past `depth` 64 it is taken to paint.
fn paints(n: &Node, depth: usize) -> bool {
if depth > 64 {
return true;
}
if !n.visible {
return false;
}
if n.appearance.items.iter().any(|i| i.visible() && !i.paint().is_none()) || n.appearance.effects.iter().any(|e| e.visible) {
return true;
}
match &n.kind {
NodeKind::Path { .. } => false,
NodeKind::Text(t) => t.runs.iter().any(|r| !r.style.fill.is_none() || !r.style.stroke.is_none()),
_ => n.children().is_none_or(|c| c.iter().any(|c| paints(c, depth + 1))),
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -1056,6 +1097,41 @@ mod tests {
}
}
/// A 40 × 40 square at (10, 10) filled black at `opacity`, or with no fill when `None`.
fn square_node(id: u64, opacity: Option<f32>) -> Node {
let mut bp = BezPath::new();
bp.move_to((10.0, 10.0));
bp.line_to((50.0, 10.0));
bp.line_to((50.0, 50.0));
bp.line_to((10.0, 50.0));
bp.close_path();
let mut n = Node::new(
NodeId(id),
NodeKind::Path { path: PathData::from_bezpath(&bp), rule: Default::default(), live: None, clipping: false, guide: false },
);
let mut appearance = (*n.appearance).clone();
appearance.items.clear();
if let Some(o) = opacity {
appearance.items.push(AppearanceItem::Fill(vectorcraft_doc::FillLayer::new(Paint::solid(Color::BLACK))));
n.opacity = o;
}
n.appearance = appearance.into();
n
}
/// Two objects with no paint draw alike; two that paint too faintly to ink a pixel (an alpha of
/// 8 or less) aren't taken as alike, nor is one with paint against one without.
#[test]
fn art_with_no_paint_draws_alike_and_faint_art_is_still_compared() {
let shared = Shared { patterns: &[], images: &BTreeMap::new() };
let alike = |a: &Node, b: &Node| drawn_alike(a, b, NodeId(999), &shared, None, &mut Spent::default());
let (none, other_none) = (square_node(1, None), square_node(2, None));
assert!(alike(&none, &other_none));
let (faint, other_faint) = (square_node(1, Some(0.02)), square_node(2, Some(0.02)));
assert!(!alike(&faint, &other_faint));
assert!(!alike(&none, &square_node(2, Some(1.0))));
}
/// "AVA" at 40 points, at (10, 60).
fn type_node(id: u64, style: CharStyle) -> Node {
Node::new(NodeId(id), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 60.0), "AVA", CharStyle { size: 40.0, ..style }))))
+12 -1
View File
@@ -5,7 +5,8 @@
//! - Any other line starting with `%` is a [`Tok::Comment`] (the section markers).
//! - `%_` later in a line starts tokens too, hidden (a pseudo-comment operator after its
//! operands, as a gradient stop's `… 50 100 %_Bs`: AI7 spec §1.4.3); any other `%` later in a
//! line starts a comment that is skipped.
//! line starts a comment that is skipped, but for a line of hex digits after `%_` (a hidden
//! blend's record), a hidden [`Tok::Comment`].
//! - The binary image data after `%%BeginData:` is one [`Tok::Data`]; the binary preview of a placed
//! file is one [`Tok::Preview`].
//! - A document included whole (`%%BeginDocument:` … `%%EndDocument` lines, DSC 3.0 p. 68, nested
@@ -222,6 +223,12 @@ impl<'a> Lexer<'a> {
if prefixed && PLACE.iter().chain(&NOTES).chain(&RELATIVE).any(|m| line.starts_with(m)) {
return Some(Token { tok: Tok::Comment(line.get(1..).unwrap_or_default()), hidden: true });
}
// And a line of hex digits, as a hidden blend's record is written (`%_%4443…`
// after its `XP`), like the plain one on `%` lines.
let digits = line.get(1..).unwrap_or_default();
if prefixed && !digits.trim_ascii_end().is_empty() && digits.trim_ascii_end().iter().all(u8::is_ascii_hexdigit) {
return Some(Token { tok: Tok::Comment(digits), hidden: true });
}
// A comment later in a line.
continue;
}
@@ -470,6 +477,10 @@ mod tests {
let toks = all(b"1 % a note (\n2 %_Bs\n3 %_ 4\n");
let words: Vec<_> = toks.iter().map(|t| (t.tok.clone(), t.hidden)).collect();
assert_eq!(words, [(Tok::Num(1.0), false), (Tok::Num(2.0), false), (Tok::Word(b"Bs"), true), (Tok::Num(3.0), false)]);
// A hidden line of hex digits (a hidden blend's record) is a comment; other text after
// `%_%` stays skipped.
let toks = all(b"%_%44434241\n%_% not hex\n%_%\n1\n");
assert_eq!(toks, [t(Tok::Comment(b"44434241"), true), t(Tok::Num(1.0), false)]);
}
#[test]
+50
View File
@@ -195,6 +195,10 @@ pub struct Structure {
pub unread_elsewhere: Vec<(NodeId, Rect)>,
/// The names of text objects, by their slot's id.
pub slot_names: HashMap<NodeId, String>,
/// The clipping groups whose type clips them, by the group's id: the text slot of that type,
/// the group's last object ([`Reader::end_container`]). Once the slot holds its type, the type
/// clips the group ([`clip_by_type`]).
pub type_clips: HashMap<NodeId, NodeId>,
/// Where the drawn looks lay that objects read with their art style took the place of (the
/// document's coordinates): the page draws Illustrator's rendering of those styles there.
pub restyled: Vec<Rect>,
@@ -595,6 +599,13 @@ struct Reader<'a> {
envelope_checks: usize,
/// How far the live envelopes read so far draw from their drawn art ([`super::envelope::Spent`]).
envelope_spent: super::envelope::Spent,
/// How many more strokes with dashes aligned to corners this import may draw to check
/// ([`super::MAX_DASH_CHECKS`]).
dash_checks: usize,
/// Whether this reader reads only what comes before the first layer (swatches, brushes, styles,
/// symbols) for a file whose layers another reader reads: it makes no more checks once it
/// reaches the layers, so it spends none of theirs.
defs_only: bool,
/// The text objects read with a Warp ([`super::envelope::WarpedType`]).
warped_type: Vec<super::envelope::WarpedLook>,
/// The envelopes of type read with their drawn art, settled once the type is laid out
@@ -662,6 +673,8 @@ struct Reader<'a> {
obj_hidden: bool,
/// The names of text objects, by their slot's id.
slot_names: HashMap<NodeId, String>,
/// [`Structure::type_clips`].
type_clips: HashMap<NodeId, NodeId>,
/// [`Structure::xml_ids`].
xml_ids: HashMap<String, Option<NodeId>>,
/// The bytes of the ids in `xml_ids`.
@@ -732,6 +745,40 @@ pub(crate) fn is_look_slot(name: Option<&str>) -> bool {
name == Some(document::LOOK_SLOT)
}
/// Make the clipping groups of [`Structure::type_clips`] in `n` and its groups clip by their type,
/// once their slots are filled: where a group's slot became one text object (`typed` gives its id by
/// the slot's) that is still the group's last object, that text object moves to the front as its
/// clipping path, and `clipping` is called on it. Where the slot was left empty or became several
/// objects, the group stays as read, unclipped. How many groups clip.
pub(crate) fn clip_by_type(
n: &mut Node,
clips: &HashMap<NodeId, NodeId>,
typed: &impl Fn(NodeId) -> Option<NodeId>,
clipping: &mut impl FnMut(&mut Node),
) -> usize {
if clips.is_empty() || matches!(n.kind, NodeKind::Compound { .. }) {
return 0;
}
let mut made = 0;
if let Some(children) = n.children_mut() {
for c in children.iter_mut().filter(|c| c.children().is_some_and(|k| !k.is_empty())) {
made += clip_by_type(Arc::make_mut(c), clips, typed, clipping);
}
}
let Some(text) = clips.get(&n.id).and_then(|slot| typed(*slot)) else { return made };
if let NodeKind::Group { children, clip } = &mut n.kind
&& !*clip
&& children.last().is_some_and(|last| last.id == text && matches!(last.kind, NodeKind::Text(_)))
&& let Some(mut last) = children.pop()
{
clipping(Arc::make_mut(&mut last));
children.insert(0, last);
*clip = true;
made += 1;
}
made
}
impl<'a> Reader<'a> {
/// A reader of the editing data `data` as a whole, with the names its gradients and patterns
/// get in the document and its art styles found first ([`swatch_names`]): the symbols defined
@@ -824,6 +871,8 @@ impl<'a> Reader<'a> {
envelopes: Vec::new(),
envelope_checks: super::envelope::MAX_CHECKED,
envelope_spent: super::envelope::Spent::default(),
dash_checks: super::MAX_DASH_CHECKS,
defs_only: false,
warped_type: Vec::new(),
typed_envelopes: Vec::new(),
envelopes_drawn: Vec::new(),
@@ -853,6 +902,7 @@ impl<'a> Reader<'a> {
done: false,
obj_hidden: false,
slot_names: HashMap::new(),
type_clips: HashMap::new(),
xml_ids: HashMap::new(),
xml_id_bytes: 0,
art_size: None,
@@ -16,6 +16,9 @@ impl<'a> Reader<'a> {
if matches!(kind, Kind::Layer(_)) {
self.ensure_space();
self.check_symbols();
if self.defs_only {
(self.envelope_checks, self.dash_checks) = (0, 0);
}
}
let base = if matches!(kind, Kind::Obj(_)) { self.stack.len() } else { self.frames.last().map_or(0, |f| f.base) };
self.frames.push(Frame {
@@ -134,6 +137,15 @@ impl<'a> Reader<'a> {
}
return Ok(());
}
// A clipping group (`q` … `Q`) with no clipping path whose last object is type: that type is
// its clipping path, as Illustrator writes a clipping mask of type made from the text
// document (`/AI11Text`), which has no `W`. The slot is filled later ([`clip_by_type`]).
let type_clip = match kids.last() {
Some(last) if matches!(kind, Kind::Clip) && clips.is_empty() && !super::is_look_slot(last.name.as_deref()) => {
slot_of(last.name.as_deref()).map(|_| last.id)
}
_ => None,
};
// A compound path of clipping paths clips its clipping group.
let clipping = matches!(kind, Kind::Compound) && !clips.is_empty();
self.group_ended = !matches!(kind, Kind::Compound);
@@ -179,6 +191,9 @@ impl<'a> Reader<'a> {
if clipping && let Some(f) = self.frames.last_mut() {
f.clips.push(f.children.len());
}
if let Some(slot) = type_clip {
self.type_clips.insert(node.id, slot);
}
if compound_members {
self.compound_groups.insert(node.id);
}
+4 -1
View File
@@ -837,11 +837,13 @@ impl<'a> Reader<'a> {
}
/// Lend `sub`, a reader of a definition, what this import may still spend on laying out blends
/// and checking envelopes ([`Reader::take_back_budgets`] takes back what is left).
/// and checking envelopes and aligned dashes ([`Reader::take_back_budgets`] takes back what is
/// left).
fn lend_budgets(&mut self, sub: &mut Reader<'_>) {
sub.blend_budget = self.blend_budget;
sub.envelope_checks = self.envelope_checks;
sub.envelope_spent = std::mem::take(&mut self.envelope_spent);
sub.dash_checks = self.dash_checks;
}
/// Take back from `sub` what [`Self::lend_budgets`] lent it, less what it spent.
@@ -849,6 +851,7 @@ impl<'a> Reader<'a> {
self.blend_budget = sub.blend_budget;
self.envelope_checks = sub.envelope_checks;
self.envelope_spent = std::mem::take(&mut sub.envelope_spent);
self.dash_checks = sub.dash_checks;
}
/// In a pattern's definition, the operands of its first operator start with its head,
+61 -2
View File
@@ -336,6 +336,7 @@ fn repoint(n: &mut Node, renamed: &std::collections::BTreeMap<String, String>) {
/// those the swatches take.
pub fn palette(data: &[u8], patterns: &[PatternDef], names: &mut obj::Names) -> Option<PaletteSwatches> {
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
// The palette, the gradients and the patterns it names come before the art, so an error in the
// art leaves them read.
let _ = r.run();
@@ -396,6 +397,7 @@ pub fn brushes(data: &[u8], patterns: &[PatternDef], names: &mut obj::Names) ->
// Brush objects are plug-in objects: data without one isn't read again.
memchr::memmem::find(data, b"BeginPluginObject")?;
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
// The brushes come before the art, so an error in the art leaves them read.
let _ = r.run();
let (mut lib, unread) = r.brush_library()?;
@@ -449,6 +451,7 @@ pub fn graphic_styles(data: &[u8], large_canvas: bool, names: &mut obj::Names) -
return (vec![], 1.0);
}
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
r.large_canvas = large_canvas.then_some(1.0);
// The styles come before the art, so an error in the art leaves them read.
let _ = r.run();
@@ -482,6 +485,7 @@ pub struct Symbols {
pub fn symbols(data: &[u8], names: &mut obj::Names) -> Option<Symbols> {
crate::import::ai::find(data, b"BeginSymbol")?;
let mut r = Reader::with_names(data, names.encoding);
r.defs_only = true;
// The symbols come before the art, so an error in the art leaves them read.
let _ = r.run();
r.check_symbols();
@@ -536,10 +540,20 @@ pub fn symbols(data: &[u8], names: &mut obj::Names) -> Option<Symbols> {
Some(Symbols { symbols, images, swatches, canvas_scale: r.canvas_scale, own_size: r.symbols_own_size })
}
/// A reader of all of `data` for what doesn't depend on how its art draws (its artboards, its
/// variable library): it checks no envelope and no stroke with aligned dashes against its drawn
/// look, so it spends none of the import's checks ([`super::MAX_CHECKED`],
/// [`super::MAX_DASH_CHECKS`]), which are the layers' reader's.
fn reader_aside(data: &[u8]) -> Reader<'_> {
let mut r = Reader::new(data);
(r.envelope_checks, r.dash_checks) = (0, 0);
r
}
/// [`artboards`] as far as reading `data` from its start gets: those read before an error, and
/// those of a `/Document` still open when it stopped (its art can be what stopped it).
fn artboards_read(data: &[u8], names: &mut obj::Names) -> (Vec<(String, Rect)>, Option<usize>) {
let mut r = Reader::new(data);
let mut r = reader_aside(data);
r.names = obj::Names::new(names.encoding);
let _ = r.run();
let open: Vec<Obj> = r.frames.iter().filter_map(|f| if let Kind::Obj(o) = &f.kind { Some((**o).clone()) } else { None }).collect();
@@ -608,7 +622,7 @@ pub fn variables(data: &[u8], names: &mut obj::Names) -> VariableRead {
if crate::import::ai::find(data, b"variableSets").is_none() {
return VariableRead::default();
}
let mut r = Reader::new(data);
let mut r = reader_aside(data);
r.names = obj::Names::new(names.encoding);
let _ = r.run();
if r.variables.present {
@@ -1385,6 +1399,7 @@ impl<'a> Reader<'a> {
unread: self.unread,
unread_elsewhere: self.unread_elsewhere,
slot_names: self.slot_names,
type_clips: self.type_clips.clone(),
restyled: self.restyled,
placeholders: self.placeholders,
placed_elsewhere: self.placed_elsewhere,
@@ -1397,6 +1412,7 @@ impl<'a> Reader<'a> {
spent: self.envelope_spent,
page,
alone: None,
type_clips: self.type_clips,
},
styles_read,
text_patterns,
@@ -1960,6 +1976,20 @@ impl LibraryWalk {
}
}
/// Whether an XML node in `o` or the dictionaries it holds has a value or a type
/// (`xmlnode-nodevalue`, `xmlnode-nodetype`). `seen` counts the dictionaries looked at; past
/// [`MAX_LIBRARY_NODES`] of them, or deeper than [`MAX_DEPTH`], the library is taken to hold some.
fn holds_values(o: &Obj, seen: &mut usize, depth: usize) -> bool {
*seen = seen.saturating_add(1);
if *seen > MAX_LIBRARY_NODES || depth > MAX_DEPTH {
return true;
}
if o.ty == "XMLNode" && (o.get("xmlnode-nodevalue").is_some() || o.get("xmlnode-nodetype").is_some()) {
return true;
}
o.items().any(|c| holds_values(c, seen, depth + 1))
}
/// The library of the `variableSets` element `sets` (see [`variable_library`]).
fn read_variable_sets(sets: &Obj) -> VariableRead {
let mut walk = LibraryWalk::default();
@@ -1979,5 +2009,34 @@ fn read_variable_sets(sets: &Obj) -> VariableRead {
if walk.nodes > MAX_LIBRARY_NODES {
return VariableRead { variables: Variables::default(), bindings: vec![], bindings_skipped: 0, skipped: 1, present: true };
}
if vars == Variables::default() && walk.bindings.is_empty() && !holds_values(sets, &mut 0, 0) {
// The empty library a file can keep: nodes with names and nothing else (no value, no
// type). There is nothing in it to list, so nothing was left out.
walk.skipped = 0;
}
VariableRead { variables: vars, bindings: walk.bindings, bindings_skipped: walk.bindings_skipped, skipped: walk.skipped, present: true }
}
#[cfg(test)]
mod tests {
use super::*;
use std::rc::Rc;
/// An XML node holding `child` (when given) and nothing else: no value, no type.
fn node(child: Option<Obj>) -> Obj {
let children = Obj { ty: "Array".into(), content: child.map(|c| V::Obj(Rc::new(c))).into_iter().collect(), ..Obj::default() };
Obj { ty: "XMLNode".into(), entries: vec![(Some("xmlnode-children".into()), vec![V::Obj(Rc::new(children))])], ..Obj::default() }
}
/// An empty library is taken to hold values past the caps on what is looked at: nested deeper
/// than [`MAX_DEPTH`], or once [`MAX_LIBRARY_NODES`] dictionaries have been looked at.
#[test]
fn an_empty_library_past_the_caps_is_taken_to_hold_values() {
let shallow = node(Some(node(None)));
assert!(!holds_values(&shallow, &mut 0, 0));
let deep = (0..MAX_DEPTH).fold(node(None), |inner, _| node(Some(inner)));
assert!(holds_values(&deep, &mut 0, 0));
let mut seen = MAX_LIBRARY_NODES;
assert!(holds_values(&shallow, &mut seen, 0));
}
}
+233 -20
View File
@@ -832,15 +832,32 @@ impl<'a> Reader<'a> {
})
});
// An image with a Warp is the object only where its live warp draws as its drawn look, and
// while the import has a check left for it; otherwise its drawn look stays.
// while the import has a check left for it; otherwise its drawn look stays. So is a stroke
// with dashes aligned to corners and path ends, whose fitting is VectorCraft's own, within
// checks of its own ([`crate::import::ai::MAX_DASH_CHECKS`]) and without weighing the page:
// the envelopes' checks and share of the page check stay theirs alone. Type with such
// dashes keeps its drawn look, as before.
let appearance = match appearance {
Some(ap) if aligns_dashes(&ap) && slot_of(object.name.as_deref()).is_some() => None,
Some(ap) if matches!(object.kind, NodeKind::Image(_)) && ap.effects.iter().any(|e| e.id.starts_with("warp.")) => {
let alike = self.envelope_checks > 0 && {
self.envelope_checks -= 1;
let layer = self.doc.alloc_id();
let shared = crate::import::ai::envelope::Shared { patterns: &self.doc.patterns, images: &self.doc.images };
let shown = !hidden && object.visible && look.visible;
image_warp_alike(object, &ap, look, &self.hidden_ids, hidden, layer, &shared, page.filter(|_| shown), &mut self.envelope_spent)
look_alike(object, &ap, look, &self.hidden_ids, hidden, layer, &shared, page.filter(|_| shown), &mut self.envelope_spent)
};
alike.then_some(ap)
}
Some(ap) if aligns_dashes(&ap) => {
let alike = self.dash_checks > 0 && {
self.dash_checks -= 1;
#[cfg(test)]
crate::import::ai::DASH_CHECKS_MADE.set(crate::import::ai::DASH_CHECKS_MADE.get() + 1);
let layer = self.doc.alloc_id();
let shared = crate::import::ai::envelope::Shared { patterns: &self.doc.patterns, images: &self.doc.images };
let mut spent = crate::import::ai::envelope::Spent::default();
look_alike(object, &ap, look, &self.hidden_ids, hidden, layer, &shared, None, &mut spent)
};
alike.then_some(ap)
}
@@ -1062,23 +1079,35 @@ fn tick(vals: &[V]) -> Option<(Affine, Rect, String)> {
}
/// The gradients and patterns `look` paints with, placed as it draws them, by their swatch's name
/// (the first of each; a pattern's name after `PATTERN_KEY`).
fn placed_paints(look: &Node, out: &mut HashMap<String, Paint>, depth: usize) {
/// (the first of each; a pattern's name after `PATTERN_KEY`). With `fill_patterns`, a pattern only
/// where the look fills with it: a style's pattern is a fill, so a path's stack takes it from the
/// look's fills alone (type keeps taking it from either). `moved` gets each pattern that the look
/// also places elsewhere than its first placement.
fn placed_paints(look: &Node, out: &mut HashMap<String, Paint>, moved: &mut HashSet<String>, fill_patterns: bool, depth: usize) {
if depth > MAX_DEPTH {
return;
}
for item in &look.appearance.items {
let key = match item.paint() {
Paint::Gradient(g) => g.swatch.clone(),
Paint::Pattern { pattern, .. } => Some(format!("{PATTERN_KEY}{pattern}")),
Paint::Pattern { pattern, .. } if item.is_fill() || !fill_patterns => Some(format!("{PATTERN_KEY}{pattern}")),
_ => None,
};
if let Some(key) = key {
out.entry(key).or_insert_with(|| item.paint().clone());
match out.get(&key) {
Some(first) => {
if matches!(first, Paint::Pattern { .. }) && first != item.paint() {
moved.insert(key);
}
}
None => {
out.insert(key, item.paint().clone());
}
}
}
}
for c in look.children().into_iter().flatten() {
placed_paints(c, out, depth + 1);
placed_paints(c, out, moved, fill_patterns, depth + 1);
}
}
@@ -1224,18 +1253,19 @@ fn moves_with(object: &Node, st: &crate::import::ai::style::ArtStyle) -> bool {
/// Is `object` an image without an opacity mask, and `st` one Warp on it with nothing else that
/// paints ([`crate::import::ai::style::ArtStyle::image_warp`])? Such an image is read with its Warp
/// live where that draws as its drawn look ([`image_warp_alike`]).
/// live where that draws as its drawn look ([`look_alike`]).
fn image_warps(object: &Node, st: &crate::import::ai::style::ArtStyle) -> bool {
matches!(object.kind, NodeKind::Image(_)) && object.extras().mask.is_none() && st.image_warp
}
/// Does image `object` with `appearance` (its style's Warp) draw as `look`, its drawn look, compared
/// over all that the warp draws ([`crate::import::ai::envelope::warped_alike`]) on `layer`, a layer
/// id no other node has? Both are drawn shown, opaque and in the Normal mode; a hidden look is drawn
/// with every object in it shown, as the hidden object's look holds them. Unless the look is on
/// `%_` lines itself (`hidden`), the copies in it that are on `%_` lines (`hidden_ids`) are left out.
/// Does `object` with `appearance` (an image's Warp, or a stroke with dashes aligned to corners)
/// draw as `look`, its drawn look, compared over all that it draws, effects included
/// ([`crate::import::ai::envelope::warped_alike`]), on `layer`, a layer id no other node has? Both
/// are drawn shown, opaque and in the Normal mode; a hidden look is drawn with every object in it
/// shown, as the hidden object's look holds them. Unless the look is on `%_` lines itself
/// (`hidden`), the copies in it that are on `%_` lines (`hidden_ids`) are left out.
#[allow(clippy::too_many_arguments)]
fn image_warp_alike(
fn look_alike(
object: &Node,
appearance: &Appearance,
look: &Node,
@@ -1261,6 +1291,11 @@ fn image_warp_alike(
crate::import::ai::envelope::warped_alike(&live, &plain, layer, shared, page, spent)
}
/// Does `appearance` stroke with dashes aligned to corners and path ends?
fn aligns_dashes(appearance: &Appearance) -> bool {
appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.dash.as_ref().is_some_and(|d| d.align_corners && d.is_dashed())))
}
/// Show every object in container `n`, at any depth.
fn show_members(n: &mut Node) {
for c in n.children_mut().into_iter().flatten() {
@@ -1282,7 +1317,7 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
let slot = slot_of(object.name.as_deref()).is_some();
// Several fills and strokes, on a path or a compound path.
let stacked = !slot && !st.simple && st.stacked && matches!(object.kind, NodeKind::Path { .. } | NodeKind::Compound { .. });
// One Warp on an image, checked against its drawn look by the caller ([`image_warp_alike`]).
// One Warp on an image, checked against its drawn look by the caller ([`look_alike`]).
let image_warp = !st.simple && image_warps(object, st);
// A symbol instance draws its symbol's art: it keeps its drawn look.
if !st.plain
@@ -1301,15 +1336,22 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
let own_gradient = object.appearance.fill().filter(|f| matches!(f.paint, Paint::Gradient(_)));
// A style's gradients are written in a space of the object's bounds that isn't documented; its
// drawn look has each where the app placed it.
let mut placed = HashMap::new();
placed_paints(look, &mut placed, 0);
let (mut placed, mut moved) = (HashMap::new(), HashSet::new());
placed_paints(look, &mut placed, &mut moved, stacked, 0);
// A stack's gradients are each its own swatch, placed where the drawn look has it: one fitted
// to the object's bounds instead could lie elsewhere, so such a stack keeps its drawn look.
// to the object's bounds instead could lie elsewhere, so such a stack keeps its drawn look. So
// are its patterns, each once, and each placed one way in the look: `placed_paints` keeps the
// first placement of each name, and which of several is the style's isn't known. The same
// placement again (a compound path's look fills each subpath) is still one.
if stacked {
let mut seen = HashSet::new();
let (mut seen, mut seen_patterns) = (HashSet::new(), HashSet::new());
let placed_apart = st.items.iter().all(|i| match i {
StyleItem::Gradient { name: Some(n), .. } => seen.insert(n) && placed.contains_key(paints.names.get(Global::Gradient, n)),
StyleItem::Gradient { name: None, .. } => false,
StyleItem::Pattern { name, .. } => {
let key = format!("{PATTERN_KEY}{}", paints.names.get(Global::Pattern, name));
seen_patterns.insert(key.clone()) && placed.contains_key(&key) && !moved.contains(&key)
}
_ => true,
});
if !placed_apart {
@@ -1382,7 +1424,134 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
} else {
object.appearance.contents_index
};
Some(Appearance { items, effects: st.effects.clone(), contents_index })
let appearance = Appearance { items, effects: st.effects.clone(), contents_index };
// Zig Zag's ridges are placed by VectorCraft's own rule: on objects other than type it is kept
// only where they draw the outline the drawn look has.
if !slot && st.effects.iter().any(|e| e.id == "distort.zigZag") && !draws_look_outline(object, &appearance, look) {
return None;
}
Some(appearance)
}
/// How far, in points, an outline drawn with a reshaping effect may lie from its drawn look's
/// ([`draws_look_outline`]): the look's coordinates are written to a few decimals.
const OUTLINE_TOLERANCE: f64 = 0.25;
/// How far, in points, a flattened outline in [`draws_look_outline`] may lie from its curves.
const OUTLINE_FLATNESS: f64 = OUTLINE_TOLERANCE / 10.0;
/// How far apart, in points, [`draws_look_outline`] checks points along each flattened segment.
const OUTLINE_SPACING: f64 = OUTLINE_TOLERANCE / 2.0;
/// How close, in points, each checked point must lie to the other flattened outline: every point
/// between two checked ones is within half the spacing of one, and both outlines are within the
/// flatness of their curves, so the curves are then within [`OUTLINE_TOLERANCE`] of each other.
const OUTLINE_POINT_LIMIT: f64 = OUTLINE_TOLERANCE - 2.0 * OUTLINE_FLATNESS - OUTLINE_SPACING / 2.0;
/// Most point-to-segment distances worked out for one object, over all its look's outlines.
const MAX_OUTLINE_PAIRS: usize = 4_000_000;
/// Does path or compound path `object` with `appearance`'s effects draw every outline of its drawn look
/// `look`, as `look` draws its own (each within [`OUTLINE_TOLERANCE`] of the other)? `false` for
/// anything else: a look holding other than paths, outlines too detailed to compare.
fn draws_look_outline(object: &Node, appearance: &Appearance, look: &Node) -> bool {
fn leaves(n: &Node, out: &mut Vec<vectorcraft_geom::PathData>, depth: usize) -> bool {
match &n.kind {
NodeKind::Path { path, .. } => {
out.push(path.clone());
true
}
NodeKind::Compound { children, .. } => {
out.push(vectorcraft_geom::PathData::new(
children.iter().filter_map(|c| c.path_data()).flat_map(|p| p.subpaths.iter().cloned()).collect(),
));
true
}
NodeKind::Group { clip: false, .. } if depth < MAX_DEPTH => n.children().into_iter().flatten().all(|c| leaves(c, out, depth + 1)),
_ => false,
}
}
/// The segments of `paths` flattened, at most `max` of them.
fn segments(paths: &[vectorcraft_geom::PathData], max: usize) -> Option<Vec<kurbo::Line>> {
let mut out = vec![];
let (mut start, mut last) = (None, None);
let mut over = false;
for p in paths {
vectorcraft_geom::flatten(p.to_bezpath(), OUTLINE_FLATNESS, |el| {
let mut add = |a: kurbo::Point, b: kurbo::Point| {
if out.len() < max {
out.push(kurbo::Line::new(a, b));
} else {
over = true;
}
};
match el {
kurbo::PathEl::MoveTo(q) => (start, last) = (Some(q), Some(q)),
kurbo::PathEl::LineTo(q) => {
if let Some(l) = last {
add(l, q);
}
last = Some(q);
}
kurbo::PathEl::ClosePath => {
if let (Some(l), Some(s)) = (last, start) {
add(l, s);
}
last = start;
}
_ => {}
}
});
}
(!over && !out.is_empty()).then_some(out)
}
/// Does every point of segments `a` lie close enough to segments `b` ([`OUTLINE_POINT_LIMIT`])?
/// Each segment is checked at both ends (the last point of an open outline starts no segment)
/// and at points at most [`OUTLINE_SPACING`] apart between them (two outlines can share their
/// vertices and join them differently). Each point's distance to each segment of `b` (a
/// projection onto it) is taken from `budget`: `false` once that runs out.
fn near(a: &[kurbo::Line], b: &[kurbo::Line], budget: &mut usize) -> bool {
use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveNearest};
let close = |p: kurbo::Point| b.iter().any(|t| t.nearest(p, 1e-6).distance_sq <= OUTLINE_POINT_LIMIT * OUTLINE_POINT_LIMIT);
for s in a {
let steps = (s.arclen(1e-6) / OUTLINE_SPACING).ceil();
let steps = if steps.is_finite() && steps >= 1.0 { steps as usize } else { 1 };
let Some(left) = budget.checked_sub(steps.saturating_add(1).saturating_mul(b.len())) else { return false };
*budget = left;
if !(0..=steps).all(|k| close(s.eval(k as f64 / steps as f64))) {
return false;
}
}
true
}
/// The box round segments `lines` (`None` without any).
fn bounds(lines: &[kurbo::Line]) -> Option<kurbo::Rect> {
let first = lines.first()?.p0;
Some(lines.iter().fold(kurbo::Rect::from_points(first, first), |r, l| r.union_pt(l.p0).union_pt(l.p1)))
}
let (mut ours, mut theirs) = (vec![], vec![]);
if !matches!(object.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) || !leaves(object, &mut ours, 0) || !leaves(look, &mut theirs, 0) {
return false;
}
// The object's outline reshaped as it is drawn: its effects from its own bounds.
for path in &mut ours {
let bounds = kurbo::Shape::bounding_box(&path.to_bezpath());
*path = vectorcraft_effects::apply_geometry(&appearance.effects, path, bounds);
}
let max = MAX_OUTLINE_PAIRS.isqrt();
let Some(ours) = segments(&ours, max) else { return false };
let Some(ours_box) = bounds(&ours) else { return false };
// Two outlines each within the tolerance of the other have boxes as close: the boxes are
// compared first, then the points, from one budget for the object.
let boxed = |t: &[kurbo::Line]| {
let Some(r) = bounds(t) else { return false };
[r.x0 - ours_box.x0, r.y0 - ours_box.y0, r.x1 - ours_box.x1, r.y1 - ours_box.y1].iter().all(|d| d.abs() <= OUTLINE_TOLERANCE)
};
let mut budget = MAX_OUTLINE_PAIRS;
// Each of the look's outlines (a fill and a stroke draw the same one) is the object's.
theirs
.iter()
.all(|t| segments(std::slice::from_ref(t), max).is_some_and(|t| boxed(&t) && near(&t, &ours, &mut budget) && near(&ours, &t, &mut budget)))
}
/// A graphic style's appearance from art style `st`, on no object: `None` when the style isn't one
@@ -1673,6 +1842,50 @@ mod tests {
Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(fill, Paint::None, 0.0)))
}
/// The outline check works from one budget for the object: a look of the outline drawn twice
/// (a fill and a stroke) matches, one drawn thousands of times gives up and keeps the drawn
/// look instead of comparing every copy.
#[test]
fn the_outline_check_has_one_budget_for_the_object() {
let zig = vectorcraft_doc::Effect {
id: "distort.zigZag".into(),
params: serde_json::json!({"size": 3.0, "relative": false, "ridges": 4, "points": "corner"}),
visible: true,
};
let path = shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 60.0));
let appearance = Appearance { effects: vec![zig.clone()], ..Appearance::basic(Paint::None, Paint::None, 0.0) };
let object = Node::path(NodeId(1), path.clone(), appearance.clone());
let outline = vectorcraft_effects::apply_geometry(std::slice::from_ref(&zig), &path, Rect::new(0.0, 0.0, 100.0, 60.0));
let look = |copies: u64| {
let drawn = (0..copies).map(|i| Arc::new(Node::path(NodeId(10 + i), outline.clone(), Appearance::default()))).collect();
Node::group(NodeId(2), drawn)
};
assert!(draws_look_outline(&object, &appearance, &look(2)));
let started = std::time::Instant::now();
assert!(!draws_look_outline(&object, &appearance, &look(5_000)));
assert!(started.elapsed() < std::time::Duration::from_secs(5), "{:?}", started.elapsed());
}
/// The outline check holds for every point of the outlines, not only the points it checks: a
/// 0.25 pt line whose look has only short pieces over its ends, 0.24 pt away, leaves the
/// line's middle about 0.27 pt from the look, so the drawn look stays. The line drawn 0.1 pt
/// away matches.
#[test]
fn the_outline_check_holds_between_the_points_it_checks() {
use kurbo::Point;
use vectorcraft_geom::{PathData, SubPath};
let appearance = Appearance::basic(Paint::None, Paint::None, 0.0);
let line = PathData::new(vec![SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(0.25, 0.0)], false)]);
let object = Node::path(NodeId(1), line, appearance.clone());
let look = |pieces: &[[Point; 2]]| {
let drawn = PathData::new(pieces.iter().map(|p| SubPath::polyline(p, false)).collect());
Node::group(NodeId(2), vec![Arc::new(Node::path(NodeId(3), drawn, Appearance::default()))])
};
let ends = [[Point::new(0.0, 0.24), Point::new(0.01, 0.24)], [Point::new(0.24, 0.24), Point::new(0.25, 0.24)]];
assert!(!draws_look_outline(&object, &appearance, &look(&ends)));
assert!(draws_look_outline(&object, &appearance, &look(&[[Point::new(0.0, 0.1), Point::new(0.25, 0.1)]])));
}
/// An image draws no stroke, so an image with a brush in its art style keeps its drawn look.
#[test]
fn an_image_with_a_brush_keeps_its_drawn_look() {
+23 -15
View File
@@ -188,10 +188,11 @@ pub(super) struct ArtStyle {
/// It would be [`Self::simple`] but for a Stroke Style filter's variable width written as one
/// centered array ([`centered_widths`]): an object whose drawn look is empty takes it with its profile.
pub uneven: bool,
/// It is several fills and strokes in solid colours or gradients (strokes without a brush),
/// each with its own visibility, opacity and blend mode but no effects of its own, under only
/// the effects any object takes that don't move the outline: what a path or compound path is
/// read with when each gradient is placed as its drawn look has it (`read::ops`' `styled`).
/// It is several fills and strokes in solid colours, gradients or patterns (strokes without a
/// brush), each with its own visibility, opacity and blend mode but no effects of its own, under
/// only the effects any object takes that don't move the outline, and under none when a pattern
/// paints: what a path or compound path is read with when each gradient and pattern is placed as
/// its drawn look has it (`read::ops`' `styled`).
pub stacked: bool,
/// It is one Warp on the whole object, under fills and strokes that paint nothing and have no
/// effects of their own: what an image is read with when its live warp draws as its drawn look
@@ -1469,11 +1470,10 @@ fn stroke_item(f: &Filter, align: StrokeAlign) -> Result<Option<StyleItem>, ()>
if !f.paints.0 {
return Ok(None);
}
// Dashes aligned to corners and path ends draw as the look's pieces: a solid end at each end
// and the pattern, fitted, between them.
if f.params.get("BSDashAdj").is_some_and(|v| *v != 0.0) {
return Err(());
}
// Dashes aligned to corners and path ends (the switch in the stroke's dictionary): the look
// draws them fitted between solid ends, which the reader checks the stroke against before it
// takes it.
let aligned = f.params.get("BSDashAdj").is_some_and(|v| *v != 0.0);
match &f.stroke {
Some(p) if !f.gradient && f.pattern.is_none() => Ok(Some(StyleItem::Stroke {
paint: p.clone(),
@@ -1481,7 +1481,7 @@ fn stroke_item(f: &Filter, align: StrokeAlign) -> Result<Option<StyleItem>, ()>
cap: f.cap,
join: f.join,
miter: f.miter,
dash: f.dash.clone(),
dash: f.dash.clone().map(|d| Dash { align_corners: aligned, ..d }),
profile: width_profile(&f.arrays),
align,
brush: None,
@@ -1744,8 +1744,9 @@ impl Builder<'_> {
/// Is `e`, on the whole object, an effect any object is read with? Of the Distort & Transform
/// effects: Transform without copies (Random is never read), Twist, a Tweak that moves nothing,
/// Pucker & Bloat at 0, and Free Distort when its corners make a parallelogram (an affine map).
/// Zig Zag is left to type. Which objects Transform, Twist and Free Distort are read on is
/// Pucker & Bloat at 0, Free Distort when its corners make a parallelogram (an affine map), and Zig
/// Zag (on objects other than type only where it draws its drawn look's outline: `read::ops`'
/// `styled`). Which objects Transform, Twist and Free Distort are read on is
/// `read::ops`' `moves_with`.
fn any_object_takes(e: &Effect) -> bool {
match e.id.as_str() {
@@ -1762,7 +1763,8 @@ fn any_object_takes(e: &Effect) -> bool {
| "path.outlineObject"
| "path.outlineStroke"
| "distort.twist"
| "distort.tweak" => true,
| "distort.tweak"
| "distort.zigZag" => true,
// Copies are drawn as one path, its fills under all its strokes, where the file paints each
// copy's fill and stroke in turn.
"distort.transform" => e.params["copies"].as_i64() == Some(0),
@@ -1861,9 +1863,15 @@ fn style(filters: &[Filter]) -> ArtStyle {
&& st.plain
&& !st.pathfinder
&& !st.moves_outline()
&& st.items.iter().all(|i| matches!(i, StyleItem::Fill(_) | StyleItem::Gradient { .. } | StyleItem::Stroke { brush: None, .. }))
&& st.items.iter().all(|i| {
matches!(i, StyleItem::Fill(_) | StyleItem::Gradient { .. } | StyleItem::Pattern { .. } | StyleItem::Stroke { brush: None, .. })
})
&& st.looks.iter().all(|l| l.effects.is_empty())
&& st.effects.iter().all(any_object_takes);
&& st.effects.iter().all(any_object_takes)
// A pattern fill under the object's effects keeps the drawn look, a conservative rule: in
// one file a Scribble over a pattern fill drew unlike its look, its tiles placed as the
// look's are (why isn't established).
&& (st.effects.is_empty() || !st.items.iter().any(|i| matches!(i, StyleItem::Pattern { .. })));
st.image_warp = st.plain
&& matches!(st.effects.as_slice(), [e] if e.id.starts_with("warp."))
&& st.items.iter().all(|i| matches!(i, StyleItem::Fill(p) | StyleItem::Stroke { paint: p, .. } if p.is_none()))
+9 -4
View File
@@ -61,13 +61,17 @@ fn a_uniform_or_unreadable_width_profile_stays_a_live_stroke() {
}
#[test]
fn dashes_aligned_to_corners_keep_the_drawn_look() {
// GUARDS: the look holds the fitted pattern and the solid ends the style's dash array doesn't.
fn dashes_aligned_to_corners_read_as_aligned_dashes() {
// The look holds the fitted pattern, which the style's dash array doesn't: the reader takes the
// stroke only where VectorCraft's own fitting draws as that look.
let data = b"/KnownStyle :\n(Stitches) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n2 /FillOrStroke ,\n/Dictionary : /NotRecorded ,\n\
/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n\
/StrokeStyle : 0 R\n0 0 0 0 0 0 1 XA\n1 J 0 j 2 w 10 M [5 10 ]0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n;\n";
assert!(!art_styles(data)["Stitches"].plain);
let style = &art_styles(data)["Stitches"];
assert!(style.plain, "{style:?}");
let [StyleItem::Stroke { dash: Some(dash), .. }] = style.items.as_slice() else { panic!("{:?}", style.items) };
assert_eq!((dash.pattern.as_slice(), dash.align_corners), ([5.0, 10.0].as_slice(), true));
}
/// The style `Shade`: a Drop Shadow whose dictionary holds `keys`.
@@ -1023,7 +1027,8 @@ fn any_object_takes_the_distort_effects_that_draw_as_its_drawn_look() {
assert!(simple("Adobe Free Distort", &corners(src, [[0.2, 0.0], [1.2, 0.0], [0.0, -1.0], [1.0, -1.0]])));
assert!(!simple("Adobe Free Distort", &corners(src, [[0.2, 0.0], [1.2, 0.1], [0.0, -1.0], [1.0, -1.0]])));
assert!(!simple("Adobe Punk and Bloat", "-35 /Real (d_factor) ,\n"));
assert!(!simple("Adobe Zigzag", ""));
// Zig Zag: objects other than type check it against their drawn look (`read::ops`).
assert!(simple("Adobe Zigzag", ""));
assert!(!simple("Adobe Transform", &format!("1 /Int (numCopies) ,\n{SWITCHES}")));
// With another effect, only type takes it.
let chain = [basic("Adobe Twirl", "45 /Real (angle) ,\n"), basic("Adobe Offset Path", "4 /Real (ofst) ,\n0 /Int (jntp) ,\n4 /Real (mlim) ,\n")];
+408 -10
View File
@@ -1260,6 +1260,191 @@ fn a_style_pattern_fill_is_placed_as_a_direct_one() {
}
}
/// An art style `Stacked` whose stack holds `filters` (basic filters, top first).
fn stacked_style(filters: &[String]) -> String {
format!(
"%AI9_BeginArtStyles\n/KnownStyle :\n(Stacked) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
/CompoundFilter :\n(Stack Style Filter) 0 0 /Filter ,\n1 /Visible ,\n{}\
/BasicFilter :\n(Conduit Filter) 0 0 /Filter ,\n1 /Visible ,\n;\n /Part ,\n;\n /Part ,\n;\n%AI9_EndArtStyles\n",
filters.concat()
)
}
/// A fill filter painting with `paint` (operators).
fn fill_filter(paint: &str) -> String {
format!(
"/BasicFilter :\n(Fill Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n/FillStyle : 0 O\n{paint}\n0 1 Xd\n/Def ;\n (FillStyle) ,\n; /Dict ;\n /Part ,\n"
)
}
/// A black stroke filter `width` wide.
fn stroke_filter(width: f64) -> String {
format!(
"/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n\
/StrokeStyle : 0 R\n0 0 0 1 0 0 0 XA\n0 J 0 j {width} w 10 M []0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n"
)
}
/// The layers of a file whose object (`own`, on `%_` lines) has the style `Stacked` and the drawn
/// look `look`.
fn stacked_object(look: &str, own: &str) -> String {
let own: String = own.lines().map(|l| format!("%_{l}\n")).collect();
layer(&format!("0 Ae\nu\n{look}U\n{own}1 (Stacked) XW\n"))
}
/// The pattern placement of `n`'s fill painting with a pattern.
fn pattern_xf(n: &Node) -> [f64; 6] {
n.appearance
.items
.iter()
.find_map(|i| match i.paint() {
Paint::Pattern { xf, .. } => Some(xf.as_coeffs()),
_ => None,
})
.unwrap_or_else(|| panic!("no pattern fill: {:?}", n.appearance.items))
}
/// A path or compound path whose art style fills it with a pattern (as a stack of fills and strokes
/// can) comes in as itself with that fill, the pattern placed where the drawn look places it (not
/// where the style's own operands would), among the style's other fills and strokes in their order.
#[test]
fn a_path_with_a_style_pattern_fill_comes_in_as_the_path_with_it() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let hole = rect_path(30.0, 40.0, 50.0, 60.0);
// The style's operands and the look's differ: the look's placement is taken.
let (style_ops, look_ops) = ("0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]", "25 30 1.5 .75 30 1 45 10 0 [.8 .1 -.2 1.1 4 -6]");
let pattern = fill_filter(&format!("(Dots) {style_ops} p"));
let look_xf = |shape: &str| {
let direct = read_ok(&format!("{DOTS}{}", layer(&format!("(Dots) {look_ops} p\n{shape}f\n"))));
pattern_xf(&art(&direct.doc)[0])
};
let close = |a: [f64; 6], b: [f64; 6]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9);
// The style's operands alone would place it elsewhere.
let style_xf = pattern_xf(&art(&read_ok(&format!("{DOTS}{}", layer(&format!("(Dots) {style_ops} p\n{rect}f\n")))).doc)[0]);
assert!(!close(style_xf, look_xf(&rect)), "{style_xf:?}");
// A path filled with the pattern alone.
let look = format!("(Dots) {look_ops} p\n{rect}f\n");
let r = read_ok(&format!("{}{DOTS}{}", stacked_style(std::slice::from_ref(&pattern)), stacked_object(&look, &format!("{rect}n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Path { .. })), "the path: {a:#?} {:?}", r.warnings);
assert!(close(pattern_xf(&a[0]), look_xf(&rect)), "{:?} {:?}", pattern_xf(&a[0]), look_xf(&rect));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
// A compound path, the pattern over a solid fill and under a 3 unit stroke.
let style = stacked_style(&[stroke_filter(3.0), pattern.clone(), fill_filter("0 1 1 0 1 0 0 Xa")]);
let look = format!("{RED}*u\n{rect}f\n{hole}f\n*U\n(Dots) {look_ops} p\n*u\n{rect}f\n{hole}f\n*U\n");
let own = format!("*u\n{rect}n\n{hole}n\n*U");
let r = read_ok(&format!("{style}{DOTS}{}", stacked_object(&look, &own)));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Compound { .. })), "the compound path: {a:#?} {:?}", r.warnings);
let items: Vec<String> = a[0]
.appearance
.items
.iter()
.map(|i| match (i, i.paint()) {
(AppearanceItem::Fill(_), Paint::Pattern { .. }) => "pattern fill".into(),
(AppearanceItem::Fill(_), p) => format!("fill {:?}", p.color()),
(AppearanceItem::Stroke(s), _) => format!("stroke {}", s.width),
})
.collect();
assert_eq!(items, [format!("fill {:?}", Some(Color::rgb(1.0, 0.0, 0.0))), "pattern fill".into(), "stroke 3".into()]);
assert!(close(pattern_xf(&a[0]), look_xf(&format!("*u\n{rect}f\n{hole}f\n*U\n"))));
}
/// A stack's pattern fill keeps the drawn look where the look doesn't fill with that pattern: its
/// placement isn't known. A look that only strokes with it doesn't place the fill either.
#[test]
fn a_style_pattern_fill_the_look_doesnt_paint_keeps_the_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let pattern = fill_filter(&format!("(Dots) {ops} p"));
for (why, look) in
[("a look without the pattern", format!("{RED}{rect}f\n")), ("a look that strokes with it", format!("(Dots) {ops} P\n{rect}S\n"))]
{
let r = read_ok(&format!("{}{DOTS}{}", stacked_style(std::slice::from_ref(&pattern)), stacked_object(&look, &format!("{rect}n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "{why}: the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{why}: {:?}", r.warnings);
}
}
/// A stack that fills with one pattern twice keeps the drawn look: which of the look's placements is
/// whose isn't known.
#[test]
fn a_stack_with_one_pattern_twice_keeps_the_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let pattern = fill_filter(&format!("(Dots) {ops} p"));
let look = format!("(Dots) {ops} p\n{rect}f\n(Dots) {ops} p\n{rect}f\n");
let r = read_ok(&format!("{}{DOTS}{}", stacked_style(&[pattern.clone(), pattern]), stacked_object(&look, &format!("{rect}n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
}
/// A stack that fills with a pattern once, whose drawn look fills with it twice at different
/// placements, keeps the drawn look: which placement is the style's isn't known. A look filling with
/// it twice at the same placement still comes in as the path with that fill.
#[test]
fn a_look_placing_a_stacks_pattern_twice_keeps_the_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let other = "25 30 1.5 .75 30 1 45 10 0 [.8 .1 -.2 1.1 4 -6]";
let pattern = fill_filter(&format!("(Dots) {ops} p"));
let read = |second: &str| {
let look = format!("(Dots) {ops} p\n{rect}f\n(Dots) {second} p\n{rect}f\n");
read_ok(&format!("{}{DOTS}{}", stacked_style(std::slice::from_ref(&pattern)), stacked_object(&look, &format!("{rect}n"))))
};
let r = read(other);
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let r = read(ops);
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Path { .. })), "the path: {a:#?} {:?}", r.warnings);
}
/// A style's pattern fill under an effect on the object keeps the drawn look, a conservative rule
/// (in one file a Scribble over a pattern fill drew unlike its look; why isn't established).
#[test]
fn a_path_with_a_style_pattern_fill_under_an_effect_keeps_its_drawn_look() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let hidden = rect.replace('\n', "\n%_");
let ops = "0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]";
let shadow = "/BasicFilter :\n(Adobe Drop Shadow) 1 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n2 /Int (blnd) ,\n0.43 /Real (opac) ,\n\
37 /Real (dark) ,\n-13 /Real (vert) ,\n11 /Real (horz) ,\n17 /Real (blur) ,\n\
/FillStyle : 0 O\n0 0 0 0 0 1 0 Xa\n0 1 0 0 0 Xy\n0 J 0 j 1 w 10 M []0 d\n0 XR\n0 1 Xd\n/Def ;\n (sclr) ,\n0 /Int (csrc) ,\n; /Dict ;\n /Part ,\n";
let style = tiled_style("Dots", ops);
// After the stack, in the object's chain.
let end = ";\n /Part ,\n;\n%AI9_EndArtStyles";
assert!(style.contains(end));
let style = style.replace(end, &format!(";\n /Part ,\n{shadow};\n%AI9_EndArtStyles"));
// The style reads, with its pattern fill and the shadow: what keeps the look is the rule.
let st = crate::import::ai::style::art_styles(style.as_bytes());
let tiled = &st["Tiled"];
assert!(tiled.plain && tiled.effects.len() == 1, "{tiled:?}");
let look = format!("0 Ae\nu\n(Dots) {ops} p\n{rect}f\nU\n");
let r = read_ok(&format!("{style}{DOTS}{}", layer(&format!("{look}%_{hidden}n\n1 (Tiled) XW\n"))));
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
}
/// Type whose style fills it with a pattern takes the placement from its drawn look wherever the look
/// paints with that pattern, a stroke of it too (as before paths took such styles): the look's
/// fills-only rule is the path stack's.
#[test]
fn type_with_a_style_pattern_fill_takes_a_stroke_only_looks_placement() {
let rect = rect_path(10.0, 20.0, 70.0, 80.0);
let (style_ops, look_ops) = ("0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0]", "25 30 1.5 .75 30 1 45 10 0 [.8 .1 -.2 1.1 4 -6]");
let look = format!("0 Ae\nu\n/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\n(Dots) {look_ops} P\n{rect}S\nU\n");
let own = "%_/AI11Text :\n%_0 /FreeUndo ,\n%_0 /FrameIndex ,\n%_0 /StoryIndex ,\n%_;\n";
let styled = read_ok(&format!("{}{DOTS}{}", tiled_style("Dots", style_ops), layer(&format!("{look}{own}1 (Tiled) XW\n"))));
let stroked = read_ok(&format!("{DOTS}{}", layer(&format!("(Dots) {look_ops} P\n{rect}S\n"))));
let Paint::Pattern { xf: got, .. } = fill(&art(&styled.doc)[0]) else { panic!("{:?} {:?}", art(&styled.doc), styled.warnings) };
let want = pattern_xf(&art(&stroked.doc)[0]);
assert!(got.as_coeffs().iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-9), "{got:?} {want:?}");
}
/// An art style's pattern fill paints with the pattern under the name it is shown with.
#[test]
fn a_style_pattern_fill_paints_with_the_shown_name() {
@@ -2507,6 +2692,37 @@ fn ai_variable_library_edge_cases() {
assert_eq!(notes, ["the file's variable library couldn't be read: the Variables panel doesn't list it"]);
}
/// The empty library a file can keep, its nodes named and nothing else (no value, no type, empty
/// attributes), has nothing to list: it comes in without a note. A node that has a value or a type
/// isn't empty, so the same skeleton with a value, or with a type, still gets the note.
#[test]
fn an_empty_variable_library_gives_no_note() {
// A node with a name and nothing else: its children, then its attributes, as `%_` lines.
fn bare(name: &str, attributes: &[&str], children: &[String]) -> String {
let close = |n: &str, key: &str| format!("{}%_; {key},\n", n.strip_suffix("%_;\n").unwrap_or(n));
let attributes: String = attributes.iter().map(|a| close(&bare(a, &[], &[]), &format!("({a}) "))).collect();
let children: String = children.iter().map(|c| close(c, "")).collect();
format!(
"%_/XMLNode :\n%_/Dictionary :\n{attributes}%_; (xmlnode-attributes) ,\n%_/Array :\n{children}%_; (xmlnode-children) ,\n%_({name}) /String (xmlnode-nodename) ,\n%_;\n"
)
}
let data_sets = bare("v:sampleDataSets", &["xmlns:v", "xmlns"], &[]);
let skeleton = bare("variableSets", &[], &[bare("variableSet", &["varSetName"], std::slice::from_ref(&data_sets))]);
let (vars, notes) = read_library(&skeleton);
assert_eq!(vars, vectorcraft_doc::Variables::default());
assert!(notes.is_empty(), "{notes:?}");
let unread = ["the file's variable library couldn't be read: the Variables panel doesn't list it"];
// The same skeleton but for one entry of the data sets node: a value, then a type.
let with = |entry: &str| {
let data_sets = data_sets.replace("(xmlnode-nodename) ,\n", &format!("(xmlnode-nodename) ,\n{entry}"));
bare("variableSets", &[], &[bare("variableSet", &["varSetName"], &[data_sets])])
};
for entry in ["%_(x) /String (xmlnode-nodevalue) ,\n", "%_1 /Int (xmlnode-nodetype) ,\n"] {
let (_, notes) = read_library(&with(entry));
assert_eq!(notes, unread, "{entry}");
}
}
/// When the layers can't be read, or reading stops before the library, [`variables`] still reads
/// it, for the file read from its PDF part.
#[test]
@@ -3741,6 +3957,70 @@ fn placed_files_are_linked_images_showing_their_preview() {
assert!(read(stream(&layer("~\n")).as_bytes()).unwrap_err().contains("`~`"));
}
/// Type made a clipping mask: a clipping group (`q` … `Q`) with no clipping path, whose last object
/// is a text object, is clipped by that type once its slot holds it, the type first as its
/// clipping path. Anything else stays as it was read.
#[test]
fn type_that_ends_a_clipping_group_without_a_clipping_path_clips_it() {
let text = |story: u32| format!("/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n{story} /StoryIndex ,\n;\n");
let square = format!("{RED}{}f\n", rect_path(0.0, 0.0, 10.0, 10.0));
let clipper = format!("{RED}{}h W n\n", rect_path(2.0, 2.0, 8.0, 8.0));
let r = read_ok(&layer(&format!("q\n{square}{}Q\n", text(4))));
let a = art(&r.doc);
let [group] = a.as_slice() else { panic!("{a:#?}") };
let slot = group.children().and_then(|c| c.last()).map(|n| n.id).unwrap();
assert!(matches!(group.kind, NodeKind::Group { clip: false, .. }), "read as it is, until the slot holds its type");
assert_eq!(r.type_clips.get(&group.id), Some(&slot));
assert_eq!(r.warped_type.type_clips, r.type_clips, "envelopes' contents are clipped by their type too");
// Filled with one text object, the slot's type clips the group.
let typed = |doc: &Document, one: bool| {
let mut layer = (*doc.layers[0]).clone();
let mut n = 0;
let put = |n: &mut Node| {
if let NodeKind::Group { children, .. } = &mut n.kind
&& let Some(last) = children.last_mut()
&& last.id == slot
{
let t = Node::new(
vectorcraft_doc::NodeId(9_000),
NodeKind::Text(Box::new(vectorcraft_doc::TextObject::point(kurbo::Point::ZERO, "M", Default::default()))),
);
if one {
*last = Arc::new(t);
} else {
let mut stroke = t.clone();
stroke.id = vectorcraft_doc::NodeId(9_001);
*last = Arc::new(t);
children.push(Arc::new(stroke));
}
}
};
layer.children_mut().unwrap().iter_mut().for_each(|c| put(Arc::make_mut(c)));
let clipped = clip_by_type(&mut layer, &r.type_clips, &|s| (s == slot).then_some(vectorcraft_doc::NodeId(9_000)), &mut |_| n += 1);
(layer, clipped, n)
};
let (layer_one, clipped, called) = typed(&r.doc, true);
assert_eq!((clipped, called), (1, 1));
let g = &layer_one.children().unwrap()[0];
let NodeKind::Group { children, clip: true } = &g.kind else { panic!("{g:#?}") };
assert!(matches!(children[0].kind, NodeKind::Text(_)) && matches!(children[1].kind, NodeKind::Path { .. }), "{children:#?}");
// Several objects in its place (the type and strokes round it): the group stays unclipped.
let (layer_two, clipped, _) = typed(&r.doc, false);
assert_eq!(clipped, 0);
assert!(matches!(layer_two.children().unwrap()[0].kind, NodeKind::Group { clip: false, .. }));
// A clipping path in the group clips it, not the type; type that isn't last doesn't; nor does a
// group (`u` … `U`) or the type a look draws.
for body in [
format!("q\n{square}{clipper}{}Q\n", text(4)),
format!("q\n{}{square}Q\n", text(4)),
format!("u\n{square}{}U\n", text(4)),
format!("q\n{square}/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\nQ\n"),
] {
let r = read_ok(&layer(&body));
assert!(r.type_clips.is_empty(), "{body}: {:?}", r.type_clips);
}
}
#[test]
fn text_objects_are_slots_named_after_their_story() {
let words = "/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n3 /StoryIndex ,\n;\n%_/ArtDictionary :\n%_/XMLUID : (Title) ; (AI10_ArtUID) ,\n%_;\n";
@@ -6272,21 +6552,13 @@ fn a_stroke_offset_filter_keeps_its_strokes_style() {
}
/// A Stroke Offset stroke this doesn't read as a stroke keeps the object's drawn look: a switch
/// written as another kind, dashes aligned to corners and path ends, a gradient.
/// written as another kind, a gradient.
#[test]
fn a_stroke_offset_filter_with_a_stroke_this_does_not_read_keeps_the_drawn_look() {
let outside = "0 /Bool (StrokeOffsetInside) ,\n";
let gradient = "0 R\nBb\n0 0 0 0 Bh\n2 (Red ramp) 0 0 90 1 1 0 0 1 0 0 1 Bg\n0 BB\n0 J 0 j 2 w 10 M []0 d\n0 XR\n1 0 Xd";
let cases = [
("a switch written as a number", offset_stroke_style_with("Edge", "1 /Int (StrokeOffsetInside) ,\n", OFFSET_STROKE)),
(
"dashes aligned to corners",
offset_stroke_style_with(
"Edge",
&format!("{outside}/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n"),
&OFFSET_STROKE.replace("[]0 d", "[5 10 ]0 d"),
),
),
("a gradient", offset_stroke_style_with("Edge", outside, gradient)),
];
for (why, style) in cases {
@@ -6295,6 +6567,26 @@ fn a_stroke_offset_filter_with_a_stroke_this_does_not_read_keeps_the_drawn_look(
}
}
/// A Stroke Offset stroke with dashes aligned to corners and path ends reads as such a stroke,
/// outside the path; the object takes it only where it draws as its drawn look. Here the look (a
/// filled square) draws otherwise, so the look check keeps the drawn look.
#[test]
fn a_stroke_offset_with_dashes_aligned_to_corners_unlike_its_look_keeps_the_look() {
use crate::import::ai::style::StyleItem;
use vectorcraft_doc::StrokeAlign;
let keys = "0 /Bool (StrokeOffsetInside) ,\n/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n";
let style = offset_stroke_style_with("Edge", keys, &OFFSET_STROKE.replace("[]0 d", "[5 10 ]0 d"));
let styles = crate::import::ai::style::art_styles(style.as_bytes());
let Some(StyleItem::Stroke { dash: Some(dash), align, .. }) = styles["Edge"].items.iter().find(|i| matches!(i, StyleItem::Stroke { .. })) else {
panic!("{:?}", styles["Edge"])
};
assert_eq!((dash.pattern.as_slice(), dash.align_corners, *align), ([5.0, 10.0].as_slice(), true, StrokeAlign::Outside));
let r = read_ok(&format!("%AI9_BeginArtStyles\n{style}%AI9_EndArtStyles\n{}", layer(&styled_square("Edge"))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let a = art(&r.doc);
assert!(matches!(a.as_slice(), [n] if matches!(n.kind, NodeKind::Group { .. })), "the drawn look: {a:#?}");
}
/// A listed `[Default]` style whose stroke is aligned outside comes in as the default graphic
/// style with that stroke.
#[test]
@@ -7338,6 +7630,96 @@ fn an_object_with_a_distort_effect_drawn_another_way_keeps_its_drawn_look() {
}
}
#[test]
fn a_path_with_zig_zag_comes_in_as_itself_where_its_look_has_that_outline() {
// GUARDS: Zig Zag on a path came in as its drawn look even where the live effect draws the same outline.
let keys = "3 /Real (amount) ,\n1 /Real (absoluteness) ,\n2 /Real (ridges) ,\n0 /Real (roundness) ,\n";
let zig = vectorcraft_doc::Effect {
id: "distort.zigZag".into(),
params: serde_json::json!({"size": 3.0, "relative": false, "ridges": 2, "points": "corner"}),
visible: true,
};
// The square as the document has it (y up in the file, down in the document).
let plain = read_ok(&layer(&format!("{RED}{}f\n", rect_path(20.0, 20.0, 60.0, 50.0))));
let square = art(&plain.doc)[0].path_data().unwrap().clone();
let to_file = |p: Point| {
let start = square.subpaths[0].anchors[0].p;
Point::new(p.x - start.x + 20.0, start.y - p.y + 20.0)
};
let outline = vectorcraft_effects::apply_geometry(std::slice::from_ref(&zig), &square, square.bounds().unwrap());
// The look: the outline the effect draws, as straight segments.
let ops = |shift: f64| -> String {
let mut out = String::new();
for sp in &outline.subpaths {
for (i, a) in sp.anchors.iter().enumerate() {
let p = to_file(a.p);
out.push_str(&format!("{:.4} {:.4} {}\n", p.x + shift, p.y, if i == 0 { "m" } else { "L" }));
}
}
out
};
let hidden_rect = rect_path(20.0, 20.0, 60.0, 50.0).replace('\n', "\n%_");
let object = |look: &str| format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{look}f\nU\n%_{hidden_rect}f\n1 (Bent) XW\n");
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(0.0)))));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let a = art(&r.doc);
assert_eq!(a.len(), 1, "{a:#?}");
assert!(matches!(a[0].kind, NodeKind::Path { .. }), "the object, not its look: {a:#?}");
let e = &a[0].appearance.effects;
assert_eq!(e.len(), 1, "{e:?}");
assert_eq!(
(e[0].id.as_str(), &e[0].params),
("distort.zigZag", &serde_json::json!({"size": 3.0, "relative": false, "ridges": 2, "points": "corner"}))
);
// A look whose ridges lie elsewhere (here 1 pt to the right) keeps the drawn look.
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(1.0)))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
assert!(matches!(art(&r.doc)[0].kind, NodeKind::Group { .. }));
// An open path (filled without closing it, `F`): its look's outline matches, and a look whose
// last point lies 3 pt away from where the effect ends it keeps the drawn look.
let open_path = "20 20 m\n60 20 L\n60 50 L\n";
let plain = read_ok(&layer(&format!("{RED}{open_path}F\n")));
let open = art(&plain.doc)[0].path_data().unwrap().clone();
assert!(!open.subpaths[0].closed);
let start = open.subpaths[0].anchors[0].p;
let outline = vectorcraft_effects::apply_geometry(std::slice::from_ref(&zig), &open, open.bounds().unwrap());
let ops = |last_shift: f64| -> String {
let mut out = String::new();
for sp in &outline.subpaths {
for (i, a) in sp.anchors.iter().enumerate() {
let shift = if i + 1 == sp.anchors.len() { last_shift } else { 0.0 };
let p = Point::new(a.p.x - start.x + 20.0 + shift, start.y - a.p.y + 20.0);
out.push_str(&format!("{:.4} {:.4} {}\n", p.x, p.y, if i == 0 { "m" } else { "L" }));
}
}
out
};
let hidden_open = open_path.replace('\n', "\n%_");
let object = |look: &str| format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{look}F\nU\n%_{hidden_open}F\n1 (Bent) XW\n");
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(0.0)))));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", keys, BLUE_FILL), layer(&object(&ops(3.0)))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
// A Zig Zag of no size on an open path through the corners of its look's square, joined
// across it: the vertices match, the segments between them don't, so the drawn look stays.
let flat = "0 /Real (amount) ,\n1 /Real (absoluteness) ,\n0 /Real (ridges) ,\n0 /Real (roundness) ,\n";
let bowtie = "%_20 20 m\n%_60 50 L\n%_60 20 L\n%_20 50 L\n%_F\n";
let crossed = format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{}f\nU\n{bowtie}1 (Bent) XW\n", rect_path(20.0, 20.0, 60.0, 50.0));
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", flat, BLUE_FILL), layer(&crossed)));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
// A look worked out by hand rather than by the effect: Zig Zag of 3 pt with one ridge per
// segment and corner points, on a line from (20, 20) to (60, 20), puts the line's ends 3 pt up
// the page and its middle 3 pt down. The same look mirrored keeps the drawn look.
let one = "3 /Real (amount) ,\n1 /Real (absoluteness) ,\n1 /Real (ridges) ,\n0 /Real (roundness) ,\n";
let line = "20 20 m\n60 20 L\n".replace('\n', "\n%_");
let object = |look: &str| format!("0 Ae\nu\n0 0 0 0 0 0 1 Xa\n{look}F\nU\n%_{line}F\n1 (Bent) XW\n");
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", one, BLUE_FILL), layer(&object("20 23 m\n40 17 L\n60 23 L\n"))));
assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
assert!(matches!(art(&r.doc)[0].kind, NodeKind::Path { .. }), "{:#?}", art(&r.doc));
let r = read_ok(&format!("{}{}", distort_styles("Adobe Zigzag", one, BLUE_FILL), layer(&object("20 17 m\n40 23 L\n60 17 L\n"))));
assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
}
/// The gradient `G`, white to black, defined for a document.
const GRADIENT_G: &str = "%AI5_BeginGradient: (G)\n(G) 0 2 Bd\n[\n%_1 0 50 0 Bs\n%_0 0 50 100 Bs\nBD\n%AI5_EndGradient\n";
@@ -8746,7 +9128,7 @@ fn warped_type_on_the_page_spends_what_is_left_of_the_budget() {
let copy = |w: &super::envelope::WarpedLook| super::envelope::WarpedLook { slot: w.slot, look: w.look.clone(), left_out: None };
let page = Some(Rect::new(0.0, 60.0, 60.0, 100.0));
let settle = |w: &super::envelope::WarpedLook, spent| {
let warped = super::envelope::WarpedType { looks: vec![copy(w)], envelopes: vec![], checks: 1, spent, page, alone: None };
let warped = super::envelope::WarpedType { looks: vec![copy(w)], checks: 1, spent, page, ..Default::default() };
warped.settle(&mut doc.clone(), Some, &Default::default(), &mut vec![])
};
let spent = || super::envelope::Spent { any: MAX_DIFFERENCE / 2.0, solid: MAX_SOLID_DIFFERENCE / 2.0 };
@@ -9519,6 +9901,22 @@ fn a_blend_comes_in_as_a_live_blend() {
assert!(!s.warnings.iter().any(|w| w == super::blend::DRAWN), "{:?}", s.warnings);
}
/// A blend in an opacity mask's art is written on `%_` lines, its record's hex digits on `%_%`
/// lines: it comes in live there too.
#[test]
fn a_blend_in_an_opacity_mask_comes_in_live() {
let body = blend_file("%_10 50 m\n%_110 50 L\n", [Some("A"), Some("B")], &blend_record(&['A', 'B']));
let mask_art: String = body.lines().map(|l| if l.starts_with("%_") { format!("{l}\n") } else { format!("%_{l}\n") }).collect();
assert!(mask_art.contains("\n%_%44434241"), "{mask_art}");
let mask = format!("%_/ArtDictionary :\n%_/Mask :\n%_X=\n%_u\n{mask_art}%_U\n%_X+\n%_(Art) ,\n%_; (AI9_Mask) ,\n%_;\n");
let s = read_ok(&layer(&format!("{RED}0 0 m\n0 80 L\n80 80 L\n80 0 L\nf\n{mask}")));
let m = art(&s.doc)[0].extras().mask.clone().expect("a mask");
let blend = m.art.children().and_then(|c| c.first()).cloned().unwrap_or(m.art.clone());
let NodeKind::Blend { children, spec } = &blend.kind else { panic!("a live blend: {:?} {:?}", blend.kind, s.warnings) };
assert_eq!((children.len(), spec.spacing), (2, vectorcraft_doc::live::BlendSpacing::Steps(3)));
assert!(!s.warnings.iter().any(|w| w == super::blend::DRAWN), "{:?}", s.warnings);
}
/// A blend whose spine was never edited has no spine written, only its keys: its spine is the
/// straight line between the keys' centers, in the record's order, and the blend comes in live.
/// With the record naming the keys in their order (here the left key, named `B`, first) the blend
+36 -22
View File
@@ -1,4 +1,4 @@
use super::paint::is_mesh;
use super::paint::{is_mesh, polygon, shading_extent};
use super::state::{GState, Space};
use super::{
Affine, Color, FillRule, Interp, Key, LineCap, LineJoin, MAX_DASH_ENTRIES, MAX_DASHES, MAX_GSAVE, MAX_PATH, Obj, Op, Paint, Point, PsError, Rc,
@@ -519,29 +519,43 @@ impl Interp<'_> {
}
self.stroke_path(bp)?;
}
ShFill => {
let d = self.pop_dict()?;
if self.g.null {
return Ok(());
}
if is_mesh(&d) {
let m = self.xf();
return self.mesh_fill(&d, m);
}
let m = self.xf();
if let Some(g) = self.gradient(&d, m)? {
let area = self.clip_bounds()?;
let paint = Paint::Gradient(Box::new(g));
let clips = self.g.clips.clone();
self.out.fill(area.to_path(0.1), FillRule::NonZero, paint, self.g.overprint, &clips);
if let Some((_, n)) = self.out.drawn.last() {
let id = n.id;
self.out.shadings.insert(id);
}
}
}
ShFill => self.shfill()?,
_ => self.data_op(op)?,
}
Ok(())
}
/// `shfill`: shading `sh` over the clip, as a gradient mesh or a gradient fill.
fn shfill(&mut self) -> Res {
let d = self.pop_dict()?;
if self.g.null {
return Ok(());
}
if is_mesh(&d) {
let m = self.xf();
return self.mesh_fill(&d, m);
}
let m = self.xf();
if let Some(g) = self.gradient(&d, m)? {
let area = self.clip_bounds()?;
// Not extended, it paints only between its ends.
let extent = shading_extent(&d, m, area);
let path = match &extent {
Some(pts) if pts.len() < 3 => return Ok(()),
Some(pts) => polygon(pts),
None => area.to_path(0.1),
};
let paint = Paint::Gradient(Box::new(g));
let clips = self.g.clips.clone();
self.out.fill(path, FillRule::NonZero, paint, self.g.overprint, &clips);
// Only a fill of the whole clip can stand in for the clip's shape.
if extent.is_none()
&& let Some((_, n)) = self.out.drawn.last()
{
let id = n.id;
self.out.shadings.insert(id);
}
}
Ok(())
}
}
+129
View File
@@ -450,6 +450,135 @@ fn is_gradient(sh: &DictRef) -> bool {
matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))
}
/// How far (points) the sides of the polygon a radial shading's circle is cut to may lie inside it.
const RING_TOLERANCE: f64 = 0.01;
/// Most sides of that polygon.
const MAX_RING: usize = 1024;
/// The part of `area` (in the document) that axial or radial shading `sh`, mapped into the
/// document by `m`, paints, as a convex polygon; `None` when it paints all of it. Without
/// `Extend` an axial shading paints only between the lines through its ends across its axis, and
/// a radial one only over its circles (PLRM 3rd ed. §4.9.3, shading types 2 and 3: `Extend`
/// defaults to `[false false]`). A radial shading extended at one end only, or starting from a
/// circle with a radius, is not bounded here (it paints all of `area`).
pub(super) fn shading_extent(sh: &DictRef, m: Affine, area: Rect) -> Option<Vec<Point>> {
let d = sh.borrow();
let nums = |k: &str| -> Vec<f64> {
d.get(&Key::name(k)).and_then(Obj::items).map(|i| i.borrow().iter().filter_map(Obj::as_num).collect()).unwrap_or_default()
};
let extend: Vec<bool> = d
.get(&Key::name("Extend"))
.and_then(Obj::items)
.map(|i| i.borrow().iter().map(|o| matches!(o, Obj::Bool(true))).collect())
.unwrap_or_default();
let (e0, e1) = (extend.first().copied().unwrap_or(false), extend.get(1).copied().unwrap_or(false));
if (e0 && e1) || area.width() <= 0.0 || area.height() <= 0.0 || m.determinant().abs() < 1e-12 || !m.as_coeffs().iter().all(|v| v.is_finite()) {
return None;
}
let inv = m.inverse();
// `area` in the shading's own space, where its axis and circles are.
let corners: Vec<Point> =
[(area.x0, area.y0), (area.x1, area.y0), (area.x1, area.y1), (area.x0, area.y1)].map(|(x, y)| inv * Point::new(x, y)).to_vec();
let mut poly = corners.clone();
let c = nums("Coords");
let at = |i: usize| c.get(i).copied().filter(|v| v.is_finite()).unwrap_or(0.0);
match d.get(&Key::name("ShadingType")).and_then(Obj::as_num) {
Some(2.0) => {
let (p0, p1) = (Point::new(at(0), at(1)), Point::new(at(2), at(3)));
let axis = p1 - p0;
if axis.hypot2() < 1e-18 {
return None;
}
if !e0 {
poly = clip_half(&poly, |p| (p - p0).dot(axis));
}
if !e1 {
poly = clip_half(&poly, |p| (p1 - p).dot(axis));
}
}
Some(3.0) if !e0 && !e1 && at(2) <= 0.0 && at(5) > 0.0 => {
// The circles from a point to a circle cover the hull of that point and circle.
let (p0, c1, r1) = (Point::new(at(0), at(1)), Point::new(at(3), at(4)), at(5));
// Enough sides that each lies within `RING_TOLERANCE` of the circle in the document
// (the radius scaled by the most `m` stretches any direction), from 64 to `MAX_RING`.
let [a, b, c, d, ..] = m.as_coeffs();
let (sum, det) = (a * a + b * b + c * c + d * d, a * d - b * c);
let stretch = ((sum + (sum * sum - 4.0 * det * det).max(0.0).sqrt()) / 2.0).sqrt();
let r = r1 * stretch;
let sides = (std::f64::consts::PI / (1.0 - RING_TOLERANCE / r).clamp(-1.0, 1.0).acos()).ceil();
let sides = if sides.is_finite() { (sides as usize).clamp(64, MAX_RING) } else { MAX_RING };
let ring: Vec<Point> = (0..sides).map(|i| c1 + Vec2::from_angle(i as f64 * std::f64::consts::TAU / sides as f64) * r1).collect();
for edge in hull(&[ring, vec![p0]].concat()).windows(2) {
if let [a, b] = edge {
let (a, b) = (*a, *b);
poly = clip_half(&poly, |p| (b - a).cross(p - a));
}
}
}
_ => return None,
}
// Nothing cut: it paints the whole area.
if poly.len() == 4 && poly.iter().zip(&corners).all(|(a, b)| (*a - *b).hypot2() < 1e-18) {
return None;
}
Some(poly.into_iter().map(|p| m * p).collect())
}
/// Convex polygon `poly` cut to where `f` (a linear function) is zero or more.
fn clip_half(poly: &[Point], f: impl Fn(Point) -> f64) -> Vec<Point> {
let mut out = Vec::with_capacity(poly.len() + 1);
for (i, &a) in poly.iter().enumerate() {
let Some(&b) = poly.get((i + 1) % poly.len()) else { continue };
let (fa, fb) = (f(a), f(b));
if fa >= 0.0 {
out.push(a);
}
if (fa >= 0.0) != (fb >= 0.0) {
out.push(a.lerp(b, fa / (fa - fb)));
}
}
out
}
/// The convex hull of `pts`, counter-clockwise, its first point repeated at the end.
fn hull(pts: &[Point]) -> Vec<Point> {
let mut p = pts.to_vec();
p.sort_by(|a, b| a.x.total_cmp(&b.x).then(a.y.total_cmp(&b.y)));
let mut h: Vec<Point> = Vec::with_capacity(p.len() * 2);
let turn = |h: &[Point], q: Point| match h {
[.., a, b] => (*b - *a).cross(q - *a) <= 0.0,
_ => false,
};
for &q in &p {
while turn(&h, q) {
h.pop();
}
h.push(q);
}
let lower = h.len() + 1;
for &q in p.iter().rev().skip(1) {
while h.len() >= lower && turn(&h, q) {
h.pop();
}
h.push(q);
}
h
}
/// A closed path through `pts`.
pub(super) fn polygon(pts: &[Point]) -> kurbo::BezPath {
let mut bp = kurbo::BezPath::new();
for (i, p) in pts.iter().enumerate() {
if i == 0 {
bp.move_to(*p);
} else {
bp.line_to(*p);
}
}
bp.close_path();
bp
}
/// Is shading `sh` one [`Interp::mesh_fill`] paints?
pub(super) fn is_mesh(sh: &DictRef) -> bool {
matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))
+26
View File
@@ -329,6 +329,7 @@ pub(super) fn build_weighing(
unread,
unread_elsewhere,
slot_names,
type_clips,
restyled,
placeholders,
placed_elsewhere,
@@ -527,6 +528,7 @@ pub(super) fn build_weighing(
let mut made = vec![];
let mut filled = std::collections::HashMap::new();
fill_slots(&mut doc, &mut layers, &mut content.into_iter(), &slot_names, &mut empty, &mut made, &mut vec![], &mut filled);
clip_by_type(&mut layers, &type_clips, &filled);
doc.layers = layers;
made.sort();
let threaded_frames: BTreeSet<NodeId> =
@@ -2155,6 +2157,30 @@ fn unmark(nodes: &mut [Arc<Node>], shown: bool, prints: bool, found: &mut Vec<(N
}
}
/// Make the clipping groups in `layers` that their type clips ([`Structure::type_clips`]) clip by it,
/// where its slot became one text object (`filled`). The page shows that type by what it clips, so
/// it is never weighed as type the page doesn't draw ([`prune_unseen`]).
fn clip_by_type(
layers: &mut [Arc<Node>],
type_clips: &std::collections::HashMap<NodeId, NodeId>,
filled: &std::collections::HashMap<NodeId, Filled>,
) {
let one = |slot: NodeId| {
filled.get(&slot).and_then(|f| match f.objects.as_slice() {
[id] => Some(*id),
_ => None,
})
};
let mut seen = |n: &mut Node| {
if let Some(name) = n.name.as_deref().and_then(|m| m.strip_prefix(MADE)) {
n.name = (!name.is_empty()).then(|| name.to_string());
}
};
for l in layers {
ai::clip_by_type(Arc::make_mut(l), type_clips, &one, &mut seen);
}
}
/// Take object `id` out of `nodes` (`hide`: leave it, hidden); whether it was there.
fn take_out(nodes: &mut Vec<Arc<Node>>, id: NodeId, hide: bool) -> bool {
if let Some(i) = nodes.iter().position(|n| n.id == id) {
+90
View File
@@ -1180,6 +1180,96 @@ fn filter_output_counts_against_the_memory_budget() {
assert!(err.contains("too much memory"), "{err}");
}
/// A shading painted with `shfill` and not extended paints only between its ends: an axial one
/// between the lines through them across its axis, a radial one from a point over its circles
/// (PLRM 3rd ed. §4.9.3: `Extend` is `[false false]` by default). Extended both ways it paints
/// the whole clip.
#[test]
fn shadings_not_extended_paint_only_between_their_ends() {
let shade = |kind: u8, coords: &str, extend: &str| {
let r = read(&format!(
"<< /ShadingType {kind} /ColorSpace /DeviceRGB /Coords [{coords}] {extend} \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill"
));
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
bounds(&n)
};
// Axial, from x 10 to 90 (and its reflection in y: the document's y runs down).
let b = shade(2, "10 0 90 0", "");
assert!(near(b, Rect::new(10.0, 0.0, 90.0, 100.0)), "{b:?}");
let b = shade(2, "10 0 90 0", "/Extend [false true]");
assert!(near(b, Rect::new(10.0, 0.0, 100.0, 100.0)), "{b:?}");
let b = shade(2, "10 0 90 0", "/Extend [true true]");
assert!(near(b, Rect::new(0.0, 0.0, 100.0, 100.0)), "{b:?}");
// Radial from the centre point to a circle of radius 30.
let b = shade(3, "50 50 0 50 50 30", "");
assert!((b.width() - 60.0).abs() < 0.5 && (b.height() - 60.0).abs() < 0.5 && (b.center().x - 50.0).abs() < 0.5, "{b:?}");
// Its circle is cut to a polygon whose sides lie within 0.01 pt of it, also for a large one.
let r = read(
"<< /ShadingType 3 /ColorSpace /DeviceRGB /Coords [50 50 0 50 50 45] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
let NodeKind::Path { path, .. } = &n.kind else { panic!("{n:?}") };
let ring: Vec<Point> = path.subpaths.iter().flat_map(|s| s.anchors.iter().map(|a| a.p)).collect();
let centre = Point::new(50.0, 50.0);
for (a, b) in ring.iter().zip(ring.iter().cycle().skip(1)) {
assert!((a.distance(centre) - 45.0).abs() < 1e-6, "{a:?}");
assert!(a.midpoint(*b).distance(centre) > 45.0 - 0.01, "{a:?} {b:?}");
}
// Stretched 4 times across and squashed to a quarter down (areas unchanged), the sides still
// lie within 0.01 pt of the ellipse it becomes.
let r = read(
"50 50 translate 4 0.25 scale << /ShadingType 3 /ColorSpace /DeviceRGB /Coords [0 0 0 0 0 10] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
let NodeKind::Path { path, .. } = &n.kind else { panic!("{n:?}") };
let sides = path.subpaths.iter().map(|s| s.anchors.len()).sum::<usize>();
// A side of a regular polygon in the circle lies 1 - cos(pi / sides) of the radius inside it;
// stretched to 40 pt across, that is at most 0.01 pt.
assert!(40.0 * (1.0 - (std::f64::consts::PI / sides as f64).cos()) <= 0.01 + 1e-9, "{sides} sides");
let b = shade(3, "50 50 0 50 50 30", "/Extend [true true]");
assert!(near(b, Rect::new(0.0, 0.0, 100.0, 100.0)), "{b:?}");
// Axial along y, and extended at its start only.
let b = shade(2, "0 20 0 70", "");
assert!(near(b, Rect::new(0.0, 30.0, 100.0, 80.0)), "{b:?}");
let b = shade(2, "10 0 90 0", "/Extend [true false]");
assert!(near(b, Rect::new(0.0, 0.0, 90.0, 100.0)), "{b:?}");
// Diagonal: from (60, 60) to (90, 90) it paints where x + y lies from 120 to 180, a strip
// across the square's top-right corner whose own corners are cut off.
let r = read(
"<< /ShadingType 2 /ColorSpace /DeviceRGB /Coords [60 60 90 90] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
assert!(near(bounds(&n), Rect::new(20.0, 0.0, 100.0, 80.0)), "{:?}", bounds(&n));
let NodeKind::Path { path, .. } = &n.kind else { panic!("{n:?}") };
for a in path.subpaths.iter().flat_map(|s| s.anchors.iter()) {
// Back in PostScript's y-up space.
let s = a.p.x + (100.0 - a.p.y);
assert!((120.0 - 1e-6..=180.0 + 1e-6).contains(&s), "{a:?}");
}
// The current transformation turns the axis: rotated a quarter turn about the centre, an axis
// from -40 to 40 along x runs up the page from y 10 to 90.
let r = read(
"50 50 translate 90 rotate << /ShadingType 2 /ColorSpace /DeviceRGB /Coords [-40 0 40 0] \
/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> >> shfill",
);
let n = all(&r.document).into_iter().find(|n| matches!(fill(n), Some(Paint::Gradient(_)))).expect("a gradient fill");
assert!(near(bounds(&n), Rect::new(0.0, 10.0, 100.0, 90.0)), "{:?}", bounds(&n));
// Radial from a point off the circle's centre covers the hull of that point and the circle.
let b = shade(3, "20 50 0 60 50 30", "");
assert!((b.x0 - 20.0).abs() < 0.5 && (b.x1 - 90.0).abs() < 0.5 && (b.y0 - 20.0).abs() < 0.5 && (b.y1 - 80.0).abs() < 0.5, "{b:?}");
// Radial shadings this doesn't bound (extended at one end, or starting from a circle) still
// paint the whole area.
for (coords, extend) in [("50 50 0 50 50 30", "/Extend [true false]"), ("50 50 0 50 50 30", "/Extend [false true]"), ("50 50 10 50 50 30", "")] {
let b = shade(3, coords, extend);
assert!(near(b, Rect::new(0.0, 0.0, 100.0, 100.0)), "{coords} {extend}: {b:?}");
}
}
/// A sampled function of one input in an axial shading: interpolated linearly, its gradient has a
/// stop at every sample (exact, not sampled evenly); with `Order 3` it is a cubic through the
/// samples (PLRM 3rd ed. §3.10.1, Table 3.36), kept in its range.
+254 -1
View File
@@ -5887,12 +5887,18 @@ fn type_envelope_on(keys: &str, shape: &str, drawn: &str, after: &str) -> String
/// [`type_envelope_on`] around the type of story `story`.
fn type_envelope_on_story(story: u32, keys: &str, shape: &str, drawn: &str, after: &str) -> String {
type_envelope_holding(keys, shape, &format!("{}{after}", text_object(story)), drawn)
}
/// [`type_envelope_on`] whose contents are `contents` (on plain lines, written on `%_` ones), which
/// hold its text objects.
fn type_envelope_holding(keys: &str, shape: &str, contents: &str, drawn: &str) -> String {
let hidden = |s: &str| -> String { s.lines().map(|l| format!("%_{l}\n")).collect() };
format!(
"{}{}%_X=\n{}%_X+\n%_ (AIDeformArtKey) ,\n%_1 /Int (AIDeformStyle) ,\n%_;\n%_\n%_9 () XW\nu\n{drawn}U\n9 () XW\n(Adobe Deform Plugin) 1 0 0 XP\n",
hidden(&format!("u\n{shape}U\n")),
hidden(&format!("/ArtDictionary :\n{keys}")),
hidden(&format!("u\n{}{after}U\n9 () XW\n", text_object(story))),
hidden(&format!("u\n{contents}U\n9 () XW\n")),
)
}
@@ -5998,6 +6004,32 @@ fn an_envelope_of_type_that_draws_as_its_drawn_art_opens_live() {
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
}
/// An envelope of type with no fill and no stroke, its drawn art the bent outlines unpainted, opens
/// live: neither draws a pixel, so they draw alike, and the type stays editable.
#[test]
fn an_envelope_of_unpainted_type_whose_drawn_art_paints_nothing_opens_live() {
let Some(family) = installed_family() else { return };
// The outlines come from the type filled; the file's type has its fill turned off (`/56 false`).
let filled = type_envelope_text(&family, None);
let mut doc = text_document(&[("FLUX\r", 0, (8170.0, 8180.0), (0.0, 0.0), 0.0)])
.replace("(Helvetica)", &format!("({family})"))
.replace("/53 <<", "/56 false /53 <<");
while ascii85(doc.as_bytes()).len() % 60 == 1 {
doc.push('\n');
}
assert_eq!(text_fill(&made_envelope_type(&doc)), None);
let (drawn, _) = drawn_envelope(&arc_envelope(&made_envelope_type(&filled), 30.0));
assert!(drawn.contains("f\n"), "{drawn}");
let unpainted = drawn.replace("f\n", "n\n");
let art = native_with_text(&layer("Art", true, &format!("{}\n{}", square(10, 10), type_envelope(&arc_keys(0.3), &unpainted))), &doc);
let r = import(&eps(&page_square(10, 10), &art)).unwrap();
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
let (envelopes, loose) = envelopes_and_type(&r.document);
assert_eq!(envelopes, [vec!["FLUX".to_string()]], "{:?}", r.warnings);
assert!(loose.is_empty(), "{loose:?}");
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
}
/// An envelope of type whose live envelope draws apart from its drawn art (the file's art bends the
/// other way) keeps its drawn art and its type, hidden, with a note.
#[test]
@@ -6556,6 +6588,86 @@ fn a_warp_of_type_opens_as_a_mesh_on_its_saved_grid_and_keeps_its_shape_when_its
}
}
/// In the layers, type from the text document made a clipping mask (a clipping group with no
/// clipping path, the type last) clips the group's art as the page draws it: the type comes in as
/// the group's clipping path, editable, and the art doesn't paint past it.
#[test]
fn type_made_a_clipping_mask_clips_its_group_in_the_layers() {
use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions, envelope_content_bounds};
let Some(family) = installed_family() else { return };
let doc = type_envelope_text(&family, None);
// The page: the type's glyphs in the yellow of the square they clip, which covers the page, and
// drawn through a flat mesh over their box, which leaves them where they are.
let mut yellow = made_envelope_type(&type_envelope_text(&family, Some("/0 << /0 2 /1 [ 1.0 0.0 0.0 1.0 0.0 ] >>")));
yellow.visible = true;
let content = vec![std::sync::Arc::new(yellow)];
let g = envelope_content_bounds(&content).unwrap();
let points = vec![kurbo::Point::new(g.x0, g.y0), kurbo::Point::new(g.x1, g.y0), kurbo::Point::new(g.x0, g.y1), kurbo::Point::new(g.x1, g.y1)];
let kind = Box::new(EnvelopeKind::Mesh { rows: 1, cols: 1, points, handles: vec![[kurbo::Vec2::ZERO; 4]; 4] });
let options = EnvelopeOptions::NEW;
let flat = Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope { content, kind, fidelity: 50.0, editing: false, options, frame: Box::default() },
);
let (_, page) = drawn_envelope(&flat);
let clipped = format!("q\n0 0 1 0 k\n0 0 m\n100 0 L\n100 100 L\n0 100 L\nf\n{}Q\n", text_object(0));
let art = native_with_text(&layer("Art", true, &clipped), &doc);
let r = import(&eps(&page, &art)).unwrap();
// The layers are used, none of their art replaced with the page's (the note on how the type
// differs from the page is about the edges of its glyphs).
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
assert!(!r.warnings.iter().any(|w| w.contains("came in as its art") || w.contains("weren't read")), "{:?}", r.warnings);
let children = r.document.layers[0].children().unwrap();
let [group] = children.as_slice() else { panic!("{children:#?}") };
let NodeKind::Group { children, clip: true } = &group.kind else { panic!("not clipped: {group:#?}") };
let (NodeKind::Text(t), NodeKind::Path { .. }) = (&children[0].kind, &children[1].kind) else { panic!("{children:#?}") };
assert_eq!(t.plain_text(), "FLUX");
}
/// Type made a clipping mask in an envelope's contents (a clipping group with no clipping path, the
/// type last) clips the art under it there, as the drawn art shows: the envelope opens live, its
/// type editable as the group's clipping path. The art it clips covers the type's glyphs and stays
/// inside their box, so the envelope maps from that box however the art past the type would count.
#[test]
fn an_envelope_whose_type_clips_its_contents_opens_live_with_the_type_clipping_them() {
let Some(family) = installed_family() else { return };
let doc = type_envelope_text(&family, None);
// What it draws: the type in the yellow of the square it clips, which covers it.
let yellow = made_envelope_type(&type_envelope_text(&family, Some("/0 << /0 2 /1 [ 1.0 0.0 0.0 1.0 0.0 ] >>")));
let shaped = |text: Node| {
let mut text = text;
text.visible = true;
let options = vectorcraft_doc::live::EnvelopeOptions::NEW;
let content = vec![std::sync::Arc::new(text)];
Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope { content, kind: Box::new(rising_kind()), fidelity: 50.0, editing: false, options, frame: Box::default() },
)
};
let glyphs = vectorcraft_doc::live::envelope_content_bounds(&[std::sync::Arc::new(yellow.clone())]).unwrap();
let (drawn, page) = drawn_envelope(&shaped(yellow));
// A yellow square over the glyphs' box, just inside it.
let (x0, y0) = to_art(kurbo::Point::new(glyphs.x0 + 0.01, glyphs.y1 - 0.01));
let (x1, y1) = to_art(kurbo::Point::new(glyphs.x1 - 0.01, glyphs.y0 + 0.01));
let contents = format!("q\n0 0 1 0 k\n{x0} {y0} m\n{x1} {y0} L\n{x1} {y1} L\n{x0} {y1} L\nf\n{}Q\n", text_object(0));
let envelope = type_envelope_holding(&arc_keys(0.3), &rising_grid(), &contents, &drawn);
let art = native_with_text(&layer("Art", true, &format!("{}\n{envelope}", square(10, 10))), &doc);
let r = import(&eps(&format!("{}\n{page}", page_square(10, 10)), &art)).unwrap();
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
let mut live = vec![];
r.document.walk(|n| {
if let NodeKind::Envelope { content, .. } = &n.kind {
live.push(content.clone());
}
});
let [content] = live.as_slice() else { panic!("{:?}", r.warnings) };
let [group] = content.as_slice() else { panic!("{content:#?}") };
let NodeKind::Group { children, clip: true } = &group.kind else { panic!("not clipped: {group:#?}") };
let (NodeKind::Text(t), NodeKind::Path { .. }) = (&children[0].kind, &children[1].kind) else { panic!("{children:#?}") };
assert_eq!(t.plain_text(), "FLUX");
}
/// A warp of stroked type with Distort Appearance whose drawn art maps the type's bounds with its
/// strokes onto the grid the file saves (not its glyphs' bounds alone) opens live as a mesh envelope
/// mapping from that box (#3179). The drawn art strokes the bent outlines at the stroke's own weight,
@@ -7198,6 +7310,147 @@ fn warped_type_that_draws_apart_from_its_look_comes_in_as_the_look() {
}
}
/// An art style section with style `Dashed`: a black stroke 2 units wide with butt caps, miter joins
/// and dashes of 6 and gaps of 4, aligned to corners and path ends (`BSDashAdj`).
fn aligned_dash_style() -> String {
"%AI9_BeginArtStyles\n/KnownStyle :\n(Dashed) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
/BasicFilter :\n(Stroke Style Filter) 0 0 /Filter ,\n1 /Visible ,\n2 /FillOrStroke ,\n/Dictionary : /NotRecorded ,\n\
/Dictionary : /NotRecorded ,\n1 /Bool (BSDashAdj) ,\n; (kAIBeautifulStrokesParamsDictKey) ,\n\
/StrokeStyle : 0 R\n0 0 0 1 0 0 0 XA\n0 J 0 j 2 w 10 M [6 4 ]0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n; /Dict ;\n /Part ,\n;\n%AI9_EndArtStyles\n"
.to_string()
}
/// The open path of [`aligned_dash_file`], a corner at (80, 20), in the document's coordinates.
fn aligned_dash_path() -> kurbo::BezPath {
let mut bp = kurbo::BezPath::new();
bp.move_to((20.0, 20.0));
bp.line_to((80.0, 20.0));
bp.line_to((80.0, 70.0));
bp
}
/// What [`aligned_dash_style`] draws along [`aligned_dash_path`], with its dashes aligned to corners
/// and path ends by VectorCraft or (`aligned` false) not, as look operators in black.
fn aligned_dash_look(aligned: bool) -> String {
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Dash, LineCap, LineJoin, StrokeLayer};
let mut stroke = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
(stroke.cap, stroke.join, stroke.miter_limit) = (LineCap::Butt, LineJoin::Miter, 10.0);
stroke.dash = Some(Dash { pattern: vec![6.0, 4.0], offset: 0.0, align_corners: aligned });
let outline = vectorcraft_effects::stroke::line_outline(&aligned_dash_path(), &stroke, 2.0, 0.01);
assert!(!outline.elements().is_empty());
drawn_as_operators(&outline).replace("0 1 1 0 1 0 0 Xa", "0 0 0 1 0 0 0 Xa")
}
/// The editing copy of [`aligned_dash_path`] under [`aligned_dash_style`], with the look `drawing`.
fn aligned_dash_file(drawing: &str) -> String {
aligned_dash_files(drawing, 1)
}
/// [`aligned_dash_file`] with `n` such paths.
fn aligned_dash_files(drawing: &str, n: usize) -> String {
let own = "%_0 0 0 1 0 0 0 XA\n%_2 w\n%_20 80 m\n%_80 80 L\n%_80 30 L\n%_S\n";
let one = format!("u\n{drawing}\nU\n9 () XW\n{own}1 (Dashed) XW\n");
native(&(aligned_dash_style() + &layer("Art", true, &one.repeat(n))))
}
/// The paths of `d` that stroke with dashes, each with whether its dashes are aligned to corners.
fn dashed_paths(d: &Document) -> Vec<bool> {
let mut out = vec![];
d.walk(|n| {
if matches!(n.kind, NodeKind::Path { .. }) {
for i in &n.appearance.items {
if let vectorcraft_doc::AppearanceItem::Stroke(s) = i
&& let Some(dash) = &s.dash
{
out.push(dash.align_corners);
}
}
}
});
out
}
/// A stroke whose dashes are aligned to corners and path ends comes in as the path with that stroke,
/// editable, where VectorCraft's fitting draws as its drawn look.
#[test]
fn dashes_aligned_to_corners_that_draw_as_the_look_come_in_live() {
let (d, notes) = crate::ai_alone(&private(&aligned_dash_file(&aligned_dash_look(true)))).unwrap();
assert_eq!(dashed_paths(&d), [true], "{notes:?}");
assert!(!notes.iter().any(|w| w.contains("drawn look")), "{notes:?}");
}
/// Where the look draws the dashes elsewhere (here, not fitted), the path keeps its drawn look.
#[test]
fn dashes_aligned_to_corners_that_draw_apart_from_the_look_keep_it() {
let (d, notes) = crate::ai_alone(&private(&aligned_dash_file(&aligned_dash_look(false)))).unwrap();
assert!(dashed_paths(&d).is_empty(), "{notes:?}");
let looks = d.layers[0].children().unwrap();
assert!(matches!(looks.as_slice(), [l] if matches!(l.kind, NodeKind::Group { .. }) && l.visual_bounds().is_some()), "{looks:#?}");
}
/// The strokes with aligned dashes one import checks against their looks are limited
/// ([`crate::import::ai::MAX_DASH_CHECKS`]), apart from the envelopes' checks: past the
/// limit, a path that would draw as its look keeps the look.
#[test]
fn dashes_aligned_to_corners_past_their_checks_keep_the_look() {
let n = crate::import::ai::MAX_DASH_CHECKS;
let (d, notes) = crate::ai_alone(&private(&aligned_dash_files(&aligned_dash_look(true), n + 1))).unwrap();
assert_eq!(dashed_paths(&d).len(), n, "{notes:?}");
let looks = d.layers[0].children().unwrap().iter().filter(|c| matches!(c.kind, NodeKind::Group { .. })).count();
assert_eq!(looks, 1);
}
/// The reads of a file apart from its layers check no stroke with dashes aligned to corners in its
/// layers against its look: the import's checks ([`crate::import::ai::MAX_DASH_CHECKS`]) are its
/// layers' reader's, though those reads go over all of the data. Its artboards and variable library
/// are read with no checks at all, and its swatches (and so its brushes, styles and symbols, read
/// the same way) with none once their reader reaches the layers. The layers' reader still checks
/// the one such stroke.
#[test]
fn the_reads_apart_from_the_layers_check_no_aligned_dashes() {
use vectorcraft_testkit::ai::{sample_variable_sets, variable_library_data};
let library = variable_library_data(&sample_variable_sets("variableAndTypes", &[]));
let own = "%_0 0 0 1 0 0 0 XA\n%_2 w\n%_20 80 m\n%_80 80 L\n%_80 30 L\n%_S\n";
let one = format!("u\n{}\nU\n9 () XW\n{own}1 (Dashed) XW\n", aligned_dash_look(true));
let data = native(&(library + &aligned_dash_style() + &layer("Art", true, &one)));
let checks = |f: &dyn Fn()| {
crate::import::ai::DASH_CHECKS_MADE.set(0);
f();
crate::import::ai::DASH_CHECKS_MADE.get()
};
let names = crate::import::ai::Names::default;
assert_eq!(checks(&|| drop(crate::ai_alone(&private(&data)))), 1);
assert_eq!(checks(&|| drop(crate::import::ai::artboards(data.as_bytes(), &mut names()))), 0);
assert_eq!(checks(&|| assert!(crate::import::ai::variables(data.as_bytes(), &mut names()).present)), 0);
assert_eq!(checks(&|| drop(crate::import::ai::palette(data.as_bytes(), &[], &mut names()))), 0);
}
/// Type under a style with dashes aligned to corners keeps its drawn look, as before, and takes no
/// such stroke: the look check isn't made for type.
#[test]
fn type_with_dashes_aligned_to_corners_keeps_its_drawn_look() {
let doc = text_document(&[("TILT\r", 0, (8200.0, 8180.0), (0.0, 0.0), 0.0)]);
let own: String = text_object(0).lines().map(|l| format!("%_{l}\n")).collect();
let look = format!("u\n{}\nU\n9 () XW\n", aligned_dash_look(true));
let file = native_with_text(&(aligned_dash_style() + &layer("Art", true, &format!("{look}{own}1 (Dashed) XW\n"))), &doc);
let (d, notes) = crate::ai_alone(&private(&file)).unwrap();
// The look stays, and the type takes no stroke with aligned dashes.
let kids = d.layers[0].children().unwrap();
assert!(kids.iter().any(|c| matches!(c.kind, NodeKind::Group { .. }) && c.visual_bounds().is_some()), "{notes:?}");
let mut aligned = false;
d.walk(|n| {
if matches!(n.kind, NodeKind::Text(_)) {
aligned |= n
.appearance
.items
.iter()
.any(|i| matches!(i, vectorcraft_doc::AppearanceItem::Stroke(s) if s.dash.as_ref().is_some_and(|d| d.align_corners)));
}
});
assert!(!aligned, "{notes:?}");
}
/// Warped type that a text variable binds stays type with the effect live and keeps its binding,
/// though its live warp draws apart from its look.
#[test]
+1 -1
View File
@@ -70,7 +70,7 @@ fn sheet(p: &PrintPage, job: &PrintJob) -> Result<(String, Vec<Page>), String> {
}
let opts = |region: Rect| EpsOptions { level: job.level, region, ..EpsOptions::default() };
let art_opts = opts(r);
let art = Scene::new(p.doc, &art_opts).run();
let art = Scene::new(p.doc, &art_opts).on_plate(p.ink.is_some()).run();
// The marks' area: the drawing space the page shows (within the tile).
let paper = Rect::new(0.0, 0.0, w, h);
let shown = if p.view.determinant().abs() > 1e-12 { p.view.inverse().transform_rect_bbox(paper) } else { paper };
+222 -3
View File
@@ -1,9 +1,12 @@
//! PostScript print jobs: DSC page comments, the setup of each sheet, and a file the PostScript
//! reader reads back.
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Document, Node, NodeId};
use vectorcraft_geom::{Affine, Rect, shapes};
use vectorcraft_color::{
Color, Freeform, FreeformPoint, Gradient, GradientGeom, GradientKind, GradientPaint, GradientSpread, GradientStop, Paint, Swatch,
};
use vectorcraft_doc::{Appearance, CharStyle, Document, Node, NodeId, NodeKind, StrokeGradientMode, TextObject};
use vectorcraft_geom::{Affine, Point, Rect, Vec2, shapes};
use vectorcraft_testkit::raster::{Image, render_region};
use super::*;
@@ -110,3 +113,219 @@ fn separations_screens_flatness_negatives_and_tiles() {
assert!(print(&[], &[], &job).is_err());
assert!(print(&[PrintPage { size: (f64::NAN, 1.0), ..page(&d, None) }], &[0], &job).is_err());
}
/// A 200 × 100 pt CMYK document with spot swatch `Ink` (100% K): a rectangle over the whole page
/// painted `under`, when there is one, then `art`.
fn over(under: Option<Paint>, art: &[Node]) -> Document {
let mut d = Document::new(200.0, 100.0);
d.color_mode = vectorcraft_doc::ColorMode::Cmyk;
d.swatches.push(Swatch { name: "Ink".into(), paint: Paint::solid(Color::cmyk(0.0, 0.0, 0.0, 1.0)), global: true, spot: true });
let layer = d.layers[0].id;
let under = under.map(|p| Node::path(NodeId(0), shapes::rectangle(Rect::new(0.0, 0.0, 200.0, 100.0)), Appearance::basic(p, Paint::None, 0.0)));
for mut n in under.into_iter().chain(art.iter().cloned()) {
n.id = d.alloc_id();
d.insert(Some(layer), usize::MAX, n).unwrap();
}
d
}
/// Ink `ink`'s plate of `d` as the print plan separates it for PostScript, and as a PostScript
/// separation at `level` read back, both drawn at 1 px a point.
fn plate_of(d: &Document, ink: &str, level: Level) -> (Image, Image) {
let area = Rect::new(0.0, 0.0, 200.0, 100.0);
let settings = serde_json::from_value(serde_json::json!({"output": {"mode": "separations"}})).unwrap();
let plan = vectorcraft_pdf::plan(d, &vectorcraft_pdf::PrintOptions { settings, postscript: true, ..Default::default() }).unwrap();
let i = plan.sheets.iter().find(|s| s.ink.as_ref().is_some_and(|p| p.name == ink)).and_then(|s| s.plate).unwrap();
let plate = &plan.plates[i];
let page = PrintPage {
doc: plate,
size: (200.0, 100.0),
view: Affine::IDENTITY,
window: None,
place: Affine::IDENTITY,
copies: &[],
area,
marks: None,
negative: false,
ink: Some((ink, 85.0, 15.0)),
};
let out = print(&[page], &[0], &PrintJob { level, ..PrintJob::default() }).unwrap();
assert!(level == Level::Three || !text(&out).contains("shfill"), "Level 2 has no smooth shadings");
let back = crate::import(&out.bytes).unwrap().document;
(render_region(plate, area, 1.0), render_region(&back, area, 1.0))
}
/// Ink `ink`'s PostScript plate of `art` over a page of 100% `ink` (`under`), checked against the
/// plate of `art` alone (drawn from the print plan, or with `postscript` from its PostScript
/// plate): where `art` puts none of the ink down, the ink under it prints, and where it puts ink
/// down, its own amount prints. The pixels of the page where `art` alone puts no ink, those of
/// them where the ink under it does not print, and the pixels where `art` puts ink down that do
/// not print its amount.
fn keeps_the_ink_below(art: &[Node], under: &Paint, ink: &str, level: Level, postscript: bool) -> (usize, usize, usize) {
let (plan, own) = plate_of(&over(None, art), ink, level);
let alone = if postscript { own } else { plan };
let (_, printed) = plate_of(&over(Some(under.clone()), art), ink, level);
// Pixels whose neighbors all have paper (or all have ink) on the plate of `art` alone: an
// edge falls on either side of a pixel's center, and the edge of the inked part is lightest.
let around = |x: u32, y: u32, paper: bool| {
(x.saturating_sub(1)..=(x + 1).min(alone.width - 1))
.all(|i| (y.saturating_sub(1)..=(y + 1).min(alone.height - 1)).all(|j| (alone.over_white(i, j)[0] >= 254) == paper))
};
let (mut paper, mut knocked_out, mut wrong) = (0, 0, 0);
for y in 0..alone.height {
for x in 0..alone.width {
let (a, p) = (alone.over_white(x, y)[0], printed.over_white(x, y)[0]);
if around(x, y, true) {
paper += 1;
knocked_out += usize::from(p > 60);
} else if around(x, y, false) {
wrong += usize::from(a.abs_diff(p) > 48);
}
}
}
(paper, knocked_out, wrong)
}
/// A rectangle from (20, 10) to (180, 90) with `fill` and `stroke` (16 pt), each set to
/// overprint.
fn overprinting(fill: Paint, stroke: Paint) -> Node {
let mut n = Node::path(NodeId(0), shapes::rectangle(Rect::new(20.0, 10.0, 180.0, 90.0)), Appearance::basic(fill, stroke, 16.0));
for it in &mut n.appearance.items {
*it.overprint_mut() = true;
}
n
}
/// `stops` (offset, color) as a `kind` gradient placed at `geom`, spreading as `spread`.
fn gradient(kind: GradientKind, stops: &[(f32, Color)], geom: GradientGeom, spread: GradientSpread) -> Paint {
let stops = stops.iter().map(|(o, c)| GradientStop::new(*o, *c)).collect();
let mut g = GradientPaint::new(Gradient { spread, repeats: 2, ..Gradient::new(kind, stops) });
g.geom = Some(geom);
Paint::Gradient(Box::new(g))
}
#[test]
fn an_overprinting_gradient_keeps_the_ink_below_where_it_puts_none_on_a_postscript_plate() {
// Cyan in the outer stops, none from 0.3 to 0.6 (magenta only there).
let (inked, none) = (Color::cmyk(0.6, 0.3, 0.0, 0.0), Color::cmyk(0.0, 0.3, 0.0, 0.0));
let stops = [(0.0, inked), (0.3, none), (0.6, none), (1.0, inked)];
let c = Point::new(100.0, 50.0);
let around = GradientGeom { start: c, end: c + Vec2::new(70.0, -20.0), aspect: 0.7, focal: None };
let across = GradientGeom { start: Point::new(30.0, 40.0), end: Point::new(170.0, 60.0), aspect: 1.0, focal: None };
let pad = GradientSpread::Pad;
let fills = [
("linear", gradient(GradientKind::Linear, &stops, across, pad)),
("radial", gradient(GradientKind::Radial, &stops, around, pad)),
("off-center radial", gradient(GradientKind::Radial, &stops, GradientGeom { focal: Some(c + Vec2::new(-20.0, 10.0)), ..around }, pad)),
("conic", gradient(GradientKind::Conic, &stops, around, pad)),
("diamond", gradient(GradientKind::Diamond, &stops, around, pad)),
("repeating linear", gradient(GradientKind::Linear, &stops, across, GradientSpread::Repeat)),
("reflecting radial", gradient(GradientKind::Radial, &stops, around, GradientSpread::Reflect)),
// A hard edge: two stops at 0.5, the inked half first.
("hard edge", gradient(GradientKind::Linear, &[(0.0, inked), (0.5, inked), (0.5, none), (1.0, none)], across, pad)),
// Starting and ending with no cyan, padding past both ends.
("none at the ends", gradient(GradientKind::Linear, &[(0.2, none), (0.4, none), (0.5, inked), (0.8, none)], across, pad)),
];
// Many stretches with no cyan.
let many: Vec<(f32, Color)> = (0..16).map(|i| (i as f32 / 15.0, if i % 4 < 2 { inked } else { none })).collect();
let fills = fills.into_iter().chain([("many stops", gradient(GradientKind::Linear, &many, across, pad))]);
let cyan = Paint::solid(Color::cmyk(1.0, 0.0, 0.0, 0.0));
let cases: Vec<_> = fills.map(|(name, fill)| (name, overprinting(fill, Paint::None), cyan.clone(), "Cyan")).collect();
assert_keeps_the_ink_below(&cases);
}
#[test]
fn an_overprinting_gradient_with_a_hard_stop_at_an_end_keeps_the_ink_below_on_a_postscript_plate() {
// Two stops at an end, one with cyan and one without: Level 2's bands pad with the end stop,
// Level 3's shading with the stretch next to it, so each level is checked against its own
// plate of the gradient alone.
let (inked, none) = (Color::cmyk(0.6, 0.3, 0.0, 0.0), Color::cmyk(0.0, 0.3, 0.0, 0.0));
let ends = [
("none then cyan at 0", [(0.0, none), (0.0, inked), (1.0, inked)]),
("cyan then none at 1", [(0.0, inked), (1.0, inked), (1.0, none)]),
("cyan then none at 0", [(0.0, inked), (0.0, none), (1.0, none)]),
("none then cyan at 1", [(0.0, none), (1.0, none), (1.0, inked)]),
];
let c = Point::new(100.0, 50.0);
let around = GradientGeom { start: c, end: c + Vec2::new(50.0, -10.0), aspect: 0.7, focal: None };
let across = GradientGeom { start: Point::new(40.0, 40.0), end: Point::new(160.0, 60.0), aspect: 1.0, focal: None };
let pad = GradientSpread::Pad;
let cyan = Paint::solid(Color::cmyk(1.0, 0.0, 0.0, 0.0));
let shapes = [(GradientKind::Linear, across, "linear"), (GradientKind::Radial, around, "radial"), (GradientKind::Diamond, around, "diamond")];
let mut cases = vec![];
for (name, stops) in &ends {
for (kind, geom, shape) in shapes {
let fill = gradient(kind, stops, geom, pad);
cases.push((format!("{shape}, {name}"), overprinting(fill, Paint::None), cyan.clone(), "Cyan"));
}
}
let cases: Vec<_> = cases.iter().map(|(name, art, under, ink)| (name.as_str(), art.clone(), under.clone(), *ink)).collect();
assert_keeps_the_ink_below_of(&cases, true);
}
/// [`keeps_the_ink_below`] for each of `cases` (a name, the art, the paint under it and the ink
/// of the plate) at Level 3 and Level 2, with every case that fails named.
fn assert_keeps_the_ink_below(cases: &[(&str, Node, Paint, &str)]) {
assert_keeps_the_ink_below_of(cases, false);
}
/// [`assert_keeps_the_ink_below`], checked against the PostScript plate of each case's art alone
/// with `postscript`.
fn assert_keeps_the_ink_below_of(cases: &[(&str, Node, Paint, &str)], postscript: bool) {
let mut failed = vec![];
for (name, art, under, ink) in cases {
for level in [Level::Three, Level::Two] {
let (paper, knocked_out, wrong) = keeps_the_ink_below(std::slice::from_ref(art), under, ink, level, postscript);
if knocked_out + wrong >= 100 {
failed.push(format!("{name} at level {level:?}: {knocked_out} of {paper} knocked out, {wrong} of the others differ"));
}
}
}
assert!(failed.is_empty(), "{failed:#?}");
}
#[test]
fn overprinting_gradient_strokes_type_freeforms_and_spot_inks_keep_the_ink_below_on_postscript_plates() {
let (inked, none) = (Color::cmyk(0.6, 0.3, 0.0, 0.0), Color::cmyk(0.0, 0.3, 0.0, 0.0));
let stops = [(0.0, inked), (0.3, none), (0.6, none), (1.0, inked)];
let across = GradientGeom { start: Point::new(30.0, 40.0), end: Point::new(170.0, 60.0), aspect: 1.0, focal: None };
let linear = gradient(GradientKind::Linear, &stops, across, GradientSpread::Pad);
let stroked = |mode: StrokeGradientMode| {
let mut n = overprinting(Paint::None, linear.clone());
if let Some(st) = n.appearance.stroke_mut() {
st.gradient_mode = mode;
}
n
};
// Type: a gradient placed on the characters' bounds.
let on_type = GradientPaint::new(Gradient::new(GradientKind::Linear, stops.iter().map(|(o, c)| GradientStop::new(*o, *c)).collect()));
let style = CharStyle { fill: Paint::Gradient(Box::new(on_type)), overprint_fill: true, size: 80.0, ..Default::default() };
let text = Node::new(NodeId(0), NodeKind::Text(Box::new(TextObject::point(Point::new(20.0, 85.0), "HIM", style))));
// A freeform gradient with wide spreads of pure color around its points: none of the cyan
// around the left one.
let mut freeform = GradientPaint::new(Gradient::new(GradientKind::Freeform, vec![GradientStop::new(0.0, none), GradientStop::new(1.0, inked)]));
let pure = |at: Point, c: Color| FreeformPoint { spread: 0.9, ..FreeformPoint::new(at, c) };
let points = vec![pure(Point::new(50.0, 50.0), none), pure(Point::new(150.0, 50.0), inked)];
freeform.freeform = Some(Freeform { points, ..Default::default() });
// A spot ink's own plate: its tints in the outer stops, none of it from 0.3 to 0.6.
let tint = |t: f32| GradientStop { swatch: Some("Ink".into()), tint: t, ..GradientStop::new(0.0, Color::cmyk(0.0, 0.0, 0.0, t)) };
let spot = [
GradientStop { offset: 0.0, ..tint(0.8) },
GradientStop::new(0.3, none),
GradientStop::new(0.6, none),
GradientStop { offset: 1.0, ..tint(0.5) },
];
let mut on_spot = GradientPaint::new(Gradient::new(GradientKind::Linear, spot.to_vec()));
on_spot.geom = Some(across);
let cyan = Paint::solid(Color::cmyk(1.0, 0.0, 0.0, 0.0));
let full = Paint::Solid { color: Color::cmyk(0.0, 0.0, 0.0, 1.0), swatch: Some("Ink".into()), tint: 1.0 };
let cases = [
("stroke within", stroked(StrokeGradientMode::Within), cyan.clone(), "Cyan"),
("stroke along", stroked(StrokeGradientMode::Along), cyan.clone(), "Cyan"),
("stroke across", stroked(StrokeGradientMode::Across), cyan.clone(), "Cyan"),
("type", text, cyan.clone(), "Cyan"),
("freeform", overprinting(Paint::Gradient(Box::new(freeform)), Paint::None), cyan, "Cyan"),
("spot", overprinting(Paint::Gradient(Box::new(on_spot)), Paint::None), full, "Ink"),
];
assert_keeps_the_ink_below(&cases);
}
+264 -16
View File
@@ -8,6 +8,7 @@ use std::sync::Arc;
use kurbo::Shape;
use vectorcraft_color::{BlendMode, Color, GradientKind, GradientPaint, Paint};
use vectorcraft_doc::overprint::is_white;
use vectorcraft_doc::{
AppearanceItem, ColorMode, Document, Effect, ImageBlob, LineCap, LineJoin, Node, NodeKind, StrokeAlign, StrokeLayer, SymbolBoxes, TextObject,
};
@@ -213,6 +214,14 @@ impl GradientSpace {
GradientSpace::Inks(_, n) => *n,
}
}
/// Whether components `c` in this space are paper white: no ink, or full light.
fn paper(&self, c: &[f32]) -> bool {
match self {
GradientSpace::Process(Space::Gray | Space::Rgb) => c.iter().all(|v| *v >= 1.0),
GradientSpace::Process(Space::Cmyk) | GradientSpace::Inks(..) => c.iter().all(|v| *v <= 0.0),
}
}
}
/// A gradient's stops as written: offsets from 0 to 1 and the components in its space.
@@ -287,6 +296,12 @@ pub(crate) struct Scene<'a> {
max_body: usize,
/// Symbols and brush art being written inside one another.
nest: u32,
/// The document is a separation's plate: every color is the gray of one ink's coverage
/// ([`Self::on_plate`]).
plate: bool,
/// The gradient being painted overprints on a plate: where it is paper white it puts none of
/// the plate's ink down, and the plate below it is left as it is ([`Self::inked_spans`]).
keep_below: bool,
}
impl<'a> Scene<'a> {
@@ -315,9 +330,19 @@ impl<'a> Scene<'a> {
pending: 0,
max_body: MAX_BODY,
nest: 0,
plate: false,
keep_below: false,
}
}
/// This scene drawing a separation's plate when `plate` is true: an overprinting gradient
/// paints only where it puts the plate's ink down, as an overprinting solid color that puts
/// none down is drawn as nothing on it.
pub fn on_plate(mut self, plate: bool) -> Self {
self.plate = plate;
self
}
/// This scene with a page body of at most `max` bytes.
#[cfg(test)]
pub fn with_max_body(mut self, max: usize) -> Self {
@@ -689,13 +714,20 @@ impl<'a> Scene<'a> {
self.line("q");
push_path(&mut self.body, bp);
self.body.push_str(clip_op(rule));
self.paint_area(p, bounds, bp.bounding_box());
self.paint_overprinting(overprint, p, bounds, bp.bounding_box());
self.line("Q");
}
}
self.overprint_off(on);
}
/// [`Self::paint_area`] for a fill or stroke that overprints when `overprint` is true.
fn paint_overprinting(&mut self, overprint: bool, p: &Paint, bounds: Rect, area: Rect) {
let keep = std::mem::replace(&mut self.keep_below, self.plate && overprint);
self.paint_area(p, bounds, area);
self.keep_below = keep;
}
/// Paint all of `area` (inside the current clip) with gradient or pattern `p`, placed on
/// `bounds`.
fn paint_area(&mut self, p: &Paint, bounds: Rect, area: Rect) {
@@ -786,7 +818,7 @@ impl<'a> Scene<'a> {
self.line("q");
push_path(&mut self.body, bp);
self.line("strokepath W");
self.paint_area(p, paint_bounds, w.reach(st, bounds));
self.paint_overprinting(st.overprint, p, paint_bounds, w.reach(st, bounds));
self.line("Q");
}
}
@@ -1152,7 +1184,8 @@ impl<'a> Scene<'a> {
/// Paint all of `area` (inside the current clip) with linear, radial, conic or diamond gradient
/// `g`, placed on `bounds`: a smooth shading at Level 3, else stepped fills (a conic: wedges at
/// both levels; a diamond: four linear gradients, [`Self::diamond_quadrants`]).
/// both levels; a diamond: four linear gradients, [`Self::diamond_quadrants`]). Overprinting
/// on a plate, it is clipped to the levels where it puts ink down ([`Self::inked_spans`]).
fn gradient(&mut self, g: &GradientPaint, bounds: Rect, area: Rect) {
let geom = g.resolve(bounds);
// One mixed around the hue wheel that reflects is repeated from its curve's stops, which
@@ -1185,7 +1218,7 @@ impl<'a> Scene<'a> {
}
let (space, stops) = self.gradient_stops(&g.gradient);
if !stops.windows(2).any(|w| w[1].0 > w[0].0) {
if let Some((_, c)) = stops.first() {
if let Some((_, c)) = stops.first().filter(|(_, c)| !(self.keep_below && space.paper(c))) {
self.set_comps(&space, c);
self.rect_fill(area);
}
@@ -1193,20 +1226,47 @@ impl<'a> Scene<'a> {
}
let space = &space;
let smooth = self.o.level == Level::Three && !self.o.compatible_gradients;
let spans = if g.gradient.kind == GradientKind::Conic { None } else { self.inked_spans(space, &stops, smooth) };
match g.gradient.kind {
GradientKind::Conic => self.conic_steps(&geom, area, space, &stops, &g.gradient),
GradientKind::Diamond => self.diamond_quadrants(&geom, area, space, &stops, smooth),
GradientKind::Diamond => {
// Its levels are diamonds about the center, the square's edge at 1.
let frame = geom.diamond_frame();
if let Some(spans) = &spans {
let Some(frame) = frame else {
// Without a frame it is its last stop everywhere.
if stops.last().is_some_and(|(_, c)| !space.paper(c)) {
self.diamond_quadrants(&geom, area, space, &stops, smooth);
}
return;
};
let level = |t: f64| (t > 0.0).then(|| frame * BezPath::from_vec(diamond(t)));
self.line("q");
let clipped = self.clip_rings(spans, area.inflate(1.0, 1.0), level);
if clipped {
self.diamond_quadrants(&geom, area, space, &stops, smooth);
}
self.line("Q");
return;
}
self.diamond_quadrants(&geom, area, space, &stops, smooth);
}
GradientKind::Radial => {
let r = geom.length().max(1e-6);
let squash = geom.radial_squash();
let inv = squash.inverse();
let (f, c) = (inv * geom.focal_point(), geom.start);
let local = inv.transform_rect_bbox(area);
self.line("q");
let _ = writeln!(self.body, "{} cm", ps::matrix(squash));
if smooth {
self.shading(3, space, &[f.x, f.y, 0.0, c.x, c.y, r], &stops);
} else {
self.radial_steps(f, c, r, inv.transform_rect_bbox(area), space, &stops);
// Its levels are circles from the focal point, at 1 the circle of radius `r`.
let level = |t: f64| (t > 0.0).then(|| kurbo::Circle::new(f + (c - f) * t, r * t).to_path(0.01));
if spans.as_ref().is_none_or(|spans| self.clip_rings(spans, local.inflate(1.0, 1.0), level)) {
if smooth {
self.shading(3, space, &[f.x, f.y, 0.0, c.x, c.y, r], &stops);
} else {
self.radial_steps(f, c, r, local, space, &stops);
}
}
self.line("Q");
}
@@ -1215,15 +1275,122 @@ impl<'a> Scene<'a> {
if s.distance(e) < 1e-9 {
e = s + Vec2::new(1.0, 0.0);
}
if smooth {
self.shading(2, space, &[s.x, s.y, e.x, e.y], &stops);
if let Some(spans) = &spans {
self.line("q");
if self.clip_strips(spans, s, e, area) {
self.linear(s, e, area, space, &stops, smooth);
}
self.line("Q");
} else {
self.linear_steps(s, e, area, space, &stops);
self.linear(s, e, area, space, &stops, smooth);
}
}
}
}
/// A linear gradient from `s` to `e` over `area`: a smooth shading, else stepped fills.
fn linear(&mut self, s: Point, e: Point, area: Rect, space: &GradientSpace, stops: &[(f64, Vec<f32>)], smooth: bool) {
if smooth {
self.shading(2, space, &[s.x, s.y, e.x, e.y], stops);
} else {
self.linear_steps(s, e, area, space, stops);
}
}
/// Where an overprinting gradient with `stops` in `space` puts ink on a plate
/// ([`Self::keep_below`]): the spans of its levels outside every stretch between two stops of
/// paper white and outside the padding past an end painted paper white, in order, an end
/// padding with ink unbounded. The padding takes the end stop's color when stepped and the
/// end stretch's color when `smooth` ([`Self::shading`]); the two differ when two stops share
/// the end's offset. `None` when the gradient puts ink everywhere or does not overprint on a
/// plate; empty when it puts none down.
fn inked_spans(&self, space: &GradientSpace, stops: &[(f64, Vec<f32>)], smooth: bool) -> Option<Vec<(f64, f64)>> {
if !self.keep_below {
return None;
}
let stretches: Vec<_> = stops.windows(2).filter(|w| w[1].0 > w[0].0).collect();
let (first, last) = (stretches.first()?, stretches.last()?);
let (start, end) = if smooth { (&first[0].1, &last[1].1) } else { (&stops.first()?.1, &stops.last()?.1) };
let (before, after) = (space.paper(start), space.paper(end));
let mut blank: Vec<(f64, f64)> = vec![];
let mut add = |a: f64, b: f64| match blank.last_mut() {
Some(l) if l.1 >= a => l.1 = l.1.max(b),
_ => blank.push((a, b)),
};
if before {
add(f64::NEG_INFINITY, first[0].0);
}
for w in &stretches {
if space.paper(&w[0].1) && space.paper(&w[1].1) {
add(w[0].0, w[1].0);
}
}
if after {
add(last[1].0, f64::INFINITY);
}
if blank.is_empty() {
return None;
}
let mut inked = vec![];
let mut from = f64::NEG_INFINITY;
for (a, b) in blank {
if a > from {
inked.push((from, a));
}
from = b;
}
if from < f64::INFINITY {
inked.push((from, f64::INFINITY));
}
Some(inked)
}
/// Clip to the parts of `area` where a linear gradient from `s` to `e` has a level in `spans`:
/// a strip across the gradient for each. False, with nothing written, when no span reaches
/// into `area`.
fn clip_strips(&mut self, spans: &[(f64, f64)], s: Point, e: Point, area: Rect) -> bool {
let d = e - s;
let len = d.hypot();
// Gradient space: x along the gradient (0 to 1), y across it in points.
let frame = Affine::new([d.x, d.y, -d.y / len, d.x / len, s.x, s.y]);
let local = frame.inverse().transform_rect_bbox(area.inflate(1.0, 1.0));
let mut bp = BezPath::new();
for &(a, b) in spans {
let (a, b) = (a.max(local.x0), b.min(local.x1));
if a < b {
bp.extend((frame * Rect::new(a, local.y0, b, local.y1).to_path(0.1)).iter());
}
}
self.clip_path(&bp, FillRule::NonZero)
}
/// Clip to the levels in `spans` of a gradient whose level `t` is bounded by `level(t)` (a
/// closed path holding every lower level; `None` for a level without area): for each span
/// the ring between its levels, an unbounded end at `outer`, even-odd. False, with nothing
/// written, when no span has area.
fn clip_rings(&mut self, spans: &[(f64, f64)], outer: Rect, level: impl Fn(f64) -> Option<BezPath>) -> bool {
let mut bp = BezPath::new();
for &(a, b) in spans {
let edge = if b.is_finite() { level(b) } else { Some(outer.to_path(0.1)) };
let Some(edge) = edge else { continue };
bp.extend(edge.iter());
if let Some(inner) = level(a).filter(|_| a.is_finite()) {
bp.extend(inner.iter());
}
}
self.clip_path(&bp, FillRule::EvenOdd)
}
/// Clip to `bp` by `rule`. False, with nothing written, when `bp` is empty.
fn clip_path(&mut self, bp: &BezPath, rule: FillRule) -> bool {
if bp.elements().is_empty() {
return false;
}
push_path(&mut self.body, bp);
self.body.push_str(clip_op(rule));
true
}
/// A conic gradient as [`CONIC_WEDGE_COUNT`] solid wedges about its center covering `area`
/// (PostScript has no conic shading), each running on to the seam under the next, so no
/// hairline shows between neighbors ([`vectorcraft_color::GradientGeom::conic_wedges`]).
@@ -1243,7 +1410,24 @@ impl<'a> Scene<'a> {
Some(w) => w[1].1.clone(),
None => stops.last().map_or_else(Vec::new, |s| s.1.clone()),
};
for (pts, t) in geom.conic_wedges(area, g.conic_wedge_count(CONIC_WEDGE_COUNT), true) {
let count = g.conic_wedge_count(CONIC_WEDGE_COUNT);
// Overprinting on a plate: clipped to the wedges that put ink down, each up to the next.
let clipped = self.keep_below && {
let wedges = geom.conic_wedges(area, count, false);
let inked: Vec<_> = wedges.iter().filter(|(_, t)| !space.paper(&at(spread(*t)))).collect();
if inked.is_empty() {
return;
}
inked.len() < wedges.len() && {
let mut bp = BezPath::new();
for (pts, _) in inked {
bp.extend(BezPath::from_vec(polygon(pts)).iter());
}
self.line("q");
self.clip_path(&bp, FillRule::NonZero)
}
};
for (pts, t) in geom.conic_wedges(area, count, true) {
self.set_comps(space, &at(spread(t)));
for (i, p) in pts.iter().enumerate() {
push_nums(&mut self.body, &[p.x, p.y]);
@@ -1251,6 +1435,9 @@ impl<'a> Scene<'a> {
}
self.line("closepath fill");
}
if clipped {
self.line("Q");
}
}
/// A diamond gradient over `area` as four linear gradients, each clipped to a quadrant of its
@@ -1442,20 +1629,68 @@ impl<'a> Scene<'a> {
let field = g.freeform_on(b).model_field(spread_scale(b));
let q = |v: f32| (unit(v) * 255.0).round() as u8;
let (w, h) = (u32::from(cols), u32::from(rows));
// Overprinting on a plate: the cells of paper white put none of the ink down, so they are
// left out, as clear pixels at Level 3 and outside a clip of the other cells at Level 2.
let blank: Option<Vec<bool>> = self.keep_below.then(|| field.grid(area, cols, rows).map(|(c, _)| is_white(&Paint::solid(c))).collect());
let blank = blank.filter(|b| b.contains(&true));
if blank.as_ref().is_some_and(|b| !b.contains(&false)) {
return;
}
let keyed = self.o.level == Level::Three;
let clear = |i: usize, a: u8| if keyed && blank.as_ref().is_some_and(|b| b[i]) { 0 } else { a };
let image = if field.model() == Some(Model::Cmyk) || (self.cmyk && field.model() == Some(Model::Gray)) {
let inks: Vec<u8> = field
.grid(area, cols, rows)
.flat_map(|(color, a)| {
.enumerate()
.flat_map(|(i, (color, a))| {
let [c, m, y, k] = color.to_cmyk();
[q(c), q(m), q(y), q(k), q(a)]
[q(c), q(m), q(y), q(k), clear(i, q(a))]
})
.collect();
self.encode_inks(&inks, w, h)
} else {
let rgba: Vec<u8> = field.display_grid(area, cols, rows).flat_map(|(c, a)| [q(c[0]), q(c[1]), q(c[2]), q(a)]).collect();
let rgba: Vec<u8> =
field.display_grid(area, cols, rows).enumerate().flat_map(|(i, (c, a))| [q(c[0]), q(c[1]), q(c[2]), clear(i, q(a))]).collect();
self.encode_image(&rgba, w, h)
};
let Some(image) = image else { return };
let cells = blank.filter(|_| !keyed).map(|b| {
let (cw, ch) = (area.width() / f64::from(cols), area.height() / f64::from(rows));
let mut bp = BezPath::new();
for (row, line) in b.chunks(usize::from(cols)).enumerate() {
let mut col = 0;
while col < line.len() {
let start = col;
while col < line.len() && !line[col] {
col += 1;
}
if col > start {
let (y0, y1) = (area.y0 + row as f64 * ch, area.y0 + (row + 1) as f64 * ch);
bp.extend(Rect::new(area.x0 + start as f64 * cw, y0, area.x0 + col as f64 * cw, y1).to_path(0.1).iter());
}
col += 1;
}
}
bp
});
if let Some(bp) = &cells {
// Each row's run of cells is a rectangle of five path elements, about 60 bytes.
if self.size().saturating_add(bp.elements().len().saturating_mul(12)).saturating_add(image.inline_len) > self.max_body {
self.warn(TOO_LARGE);
return;
}
self.line("q");
self.clip_path(bp, FillRule::NonZero);
}
self.place_field(image, place);
if cells.is_some() {
self.line("Q");
}
}
/// Place freeform gradient image `image` on the unit square mapped by `place`, drawn from an
/// image already kept when one is encoded the same.
fn place_field(&mut self, image: ImageCode, place: Affine) {
let key = image.content_key();
let found =
self.fields.get(&key).and_then(|bucket| bucket.iter().copied().find(|&i| self.codes.get(i).is_some_and(|c| c.same_image(&image))));
@@ -1849,6 +2084,19 @@ fn image_code(prelude: String, dict: String, filter: &'static str, op: &'static
code
}
/// The closed polygon through `pts`.
fn polygon(pts: &[Point]) -> Vec<kurbo::PathEl> {
let mut els: Vec<kurbo::PathEl> =
pts.iter().enumerate().map(|(i, p)| if i == 0 { kurbo::PathEl::MoveTo(*p) } else { kurbo::PathEl::LineTo(*p) }).collect();
els.push(kurbo::PathEl::ClosePath);
els
}
/// The square with corners (±`t`, 0) and (0, ±`t`).
fn diamond(t: f64) -> Vec<kurbo::PathEl> {
polygon(&[Point::new(t, 0.0), Point::new(0.0, t), Point::new(-t, 0.0), Point::new(0.0, -t)])
}
/// `a` to `b` at `t`.
fn mix(a: &[f32], b: &[f32], t: f32) -> Vec<f32> {
a.iter().zip(b).map(|(x, y)| x + (y - x) * t).collect()
+1 -1
View File
@@ -327,7 +327,7 @@ fn install_errors(interp: &mut Interp, object_proto: ObjId) -> JsResult<()> {
for (i, (name, f)) in kinds.into_iter().enumerate() {
// Error.prototype and each NativeError prototype are Error objects (sections 15.11.4 and
// 15.11.7.7).
let proto = alloc(interp, Class::Error, Some(if i == 0 { object_proto } else { error_proto }));
let proto = alloc(interp, Class::Error(None), Some(if i == 0 { object_proto } else { error_proto }));
if i == 0 {
error_proto = proto;
method(interp, proto, "toString", error_to_string, 0)?;
+4 -2
View File
@@ -215,7 +215,9 @@ pub(crate) enum Class {
length_writable: bool,
},
Function(Func),
Error,
/// An error object. One the interpreter threw itself holds a hash of the description it had
/// then ([`crate::interp::Interp::describe`]); one a script made holds `None`.
Error(Option<u64>),
Arguments(Box<ArgMap>),
/// A `Boolean` object made by ToObject, with its primitive value.
Boolean(bool),
@@ -313,7 +315,7 @@ impl Class {
Class::Ordinary | Class::ForIn(_) => "Object",
Class::Array { .. } => "Array",
Class::Function(_) => "Function",
Class::Error => "Error",
Class::Error(_) => "Error",
Class::Arguments(_) => "Arguments",
Class::Boolean(_) => "Boolean",
Class::Number(_) => "Number",
+45 -3
View File
@@ -48,6 +48,14 @@ fn internal<T>(message: &str) -> JsResult<T> {
Err(Abrupt::Internal(message.into()))
}
/// The hash an error the interpreter throws keeps of its description ([`Interp::throw`]).
fn description_hash(text: &str) -> u64 {
use std::hash::{Hash, Hasher};
let mut h = std::hash::DefaultHasher::new();
text.hash(&mut h);
h.finish()
}
/// The kinds of error object the engine throws.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ErrorType {
@@ -60,6 +68,21 @@ pub(crate) enum ErrorType {
Uri,
}
impl ErrorType {
/// The `name` the prototype of this kind of error has before a script changes it.
pub(crate) fn name(self) -> &'static str {
match self {
ErrorType::Error => "Error",
ErrorType::Eval => "EvalError",
ErrorType::Range => "RangeError",
ErrorType::Reference => "ReferenceError",
ErrorType::Syntax => "SyntaxError",
ErrorType::Type => "TypeError",
ErrorType::Uri => "URIError",
}
}
}
/// The objects the interpreter itself refers to.
#[derive(Clone, Copy, Debug)]
pub(crate) struct Intrinsics {
@@ -538,15 +561,34 @@ impl Interp {
pub(crate) fn error_object(&mut self, t: ErrorType, message: &str) -> ObjId {
let proto = self.intrinsics.error_proto(t);
let mut o = Object::new(Class::Error, Some(proto));
let mut o = Object::new(Class::Error(None), Some(proto));
if !message.is_empty() {
o.props.insert(key("message"), Prop::Data { value: Value::str(message), flags: HIDDEN });
}
self.heap.alloc_object(o)
}
/// An error of the interpreter's or a host function's own, marked as such with a hash of the
/// description it has with its kind's own name ([`Self::thrown_by_script`]), so a name a script
/// gave the kind's prototype before the error was made counts as the script's text.
pub(crate) fn throw(&mut self, t: ErrorType, message: &str) -> Abrupt {
Abrupt::Throw(Value::Object(self.error_object(t, message)))
let o = self.error_object(t, message);
let own = if message.is_empty() { t.name().to_string() } else { format!("{}: {message}", t.name()) };
if let Some(object) = self.heap.object_mut(o) {
object.class = Class::Error(Some(description_hash(&own)));
}
Abrupt::Throw(Value::Object(o))
}
/// Is the text [`Self::describe`] gives for the thrown value `v` the script's own? It is unless
/// `v` is an error the interpreter or a host function threw, with its name and message as they
/// were then: a value the script threw, an error it made, and an error whose name or message it
/// changed all hold its own text.
pub(crate) fn thrown_by_script(&mut self, v: &Value) -> bool {
let Value::Object(o) = v else { return true };
let Some(Class::Error(Some(hash))) = self.heap.object(*o).map(|o| &o.class) else { return true };
let hash = *hash;
description_hash(&self.describe(v)) != hash
}
pub(crate) fn type_error(&mut self, message: &str) -> Abrupt {
@@ -819,7 +861,7 @@ impl Interp {
let passed = matches!((&v, std::mem::replace(&mut self.passing, Value::Undefined)), (Value::Object(a), Value::Object(b)) if *a == b);
if !passed
&& let Value::Object(o) = v
&& self.heap.object(o).is_some_and(|o| matches!(o.class, Class::Error))
&& self.heap.object(o).is_some_and(|o| matches!(o.class, Class::Error(_)))
{
self.last_error = v.clone();
}
+38
View File
@@ -239,6 +239,44 @@ fn errors_carry_line_and_column() {
assert_eq!(e.message, "42");
}
/// A run error says whether its message is the script's own text, whatever that text reads: an
/// error the interpreter or a host function threw is not, even when a script caught it and threw
/// it again, and a value or error the script made, or an error whose name or message it changed,
/// is.
#[test]
fn script_error_origin_distinguishes_native_and_authored_values() {
let native = "RangeError: invalid array length";
for (src, message, authored) in [
("new Array(-1)", native, false),
("try { new Array(-1); } catch (e) { throw e; }", native, false),
("try { new Array(-1); } catch (e) { e.message = 'invalid array length'; throw e; }", native, false),
("nope()", "ReferenceError: nope is not defined", false),
("throw new RangeError('invalid array length')", native, true),
("throw new Error('invalid array length')", "Error: invalid array length", true),
("throw 'invalid array length'", "invalid array length", true),
("throw 17", "17", true),
("throw {}", "[object Object]", true),
("throw new Error()", "Error", true),
("try { new Array(-1); } catch (e) { throw e.message; }", "invalid array length", true),
("try { new Array(-1); } catch (e) { throw new RangeError(e.message); }", native, true),
("try { new Array(-1); } catch (e) { e.message = 'mine'; throw e; }", "RangeError: mine", true),
("try { nope(); } catch (e) { e.name = 'TypeError'; throw e; }", "TypeError: nope is not defined", true),
("try { new Array(-1); } catch (e) { RangeError.prototype.name = 'Mine'; throw e; }", "Mine: invalid array length", true),
("RangeError.prototype.name = 'Mine'; new Array(-1)", "Mine: invalid array length", true),
("RangeError.prototype.name = 'RangeError'; new Array(-1)", native, false),
] {
let e = fail(src);
assert_eq!((e.kind, e.message.as_str(), e.authored), (RunErrorKind::Thrown, message, authored), "{src}");
}
assert!(!fail("var x = ;").authored, "a syntax error");
let mut realm = Realm::new();
realm.define_function("add", |_| Err("add takes two numbers".into()));
let e = realm.run("add()").unwrap_err();
assert_eq!((e.message.as_str(), e.authored), ("Error: add takes two numbers", false), "a host function's error");
let e = realm.run("throw new Error('add takes two numbers')").unwrap_err();
assert_eq!((e.message.as_str(), e.authored), ("Error: add takes two numbers", true));
}
/// An error about a property of `null` or `undefined` names a computed property whose name is a
/// primitive, and says whether the script read or set it, never naming an empty property; a
/// member assignment, an object key and a long name leave the name out.
+29 -10
View File
@@ -139,6 +139,10 @@ pub struct RunError {
pub message: String,
pub line: u32,
pub column: u32,
/// `message` is text the script supplied: a value it threw, or an error object it made or whose
/// name or message it changed. False for the interpreter's and host functions' own errors,
/// syntax errors and limits, even when a script caught one and threw it again.
pub authored: bool,
}
impl std::fmt::Display for RunError {
@@ -151,7 +155,7 @@ impl std::error::Error for RunError {}
impl From<SyntaxError> for RunError {
fn from(e: SyntaxError) -> Self {
RunError { kind: RunErrorKind::Syntax, message: e.to_string(), line: e.line, column: e.column }
RunError { kind: RunErrorKind::Syntax, message: e.to_string(), line: e.line, column: e.column, authored: false }
}
}
@@ -241,7 +245,7 @@ impl Realm {
self.script_tag = UNKNOWN_SOURCE;
let interp = &mut self.interp;
if let Some(message) = &interp.install_error {
return Err(RunError { kind: RunErrorKind::Internal, message: message.clone(), line: 0, column: 0 });
return Err(RunError { kind: RunErrorKind::Internal, message: message.clone(), line: 0, column: 0, authored: false });
}
interp.fuel = interp.limits.fuel;
interp.flattened_fuel.set(0);
@@ -269,7 +273,7 @@ impl Realm {
interp.error_tag = self.script_tag;
Err(e.into())
}
Err(CompileError::Internal(m)) => Err(RunError { kind: RunErrorKind::Internal, message: m, line: 0, column: 0 }),
Err(CompileError::Internal(m)) => Err(RunError { kind: RunErrorKind::Internal, message: m, line: 0, column: 0, authored: false }),
}
}
@@ -293,15 +297,18 @@ impl Realm {
Ok(v) => Ok(interp.to_js_value(&v)),
Err(Abrupt::Throw(v)) => {
let message = interp.describe(&v);
let authored = interp.thrown_by_script(&v);
interp.last_thrown = v;
Err(RunError { kind: RunErrorKind::Thrown, message, line, column })
Err(RunError { kind: RunErrorKind::Thrown, message, line, column, authored })
}
Err(Abrupt::Limit(LimitKind::Host)) => {
let message = interp.host_abort.take().unwrap_or_else(|| format!("limit reached: {:?}", LimitKind::Host));
Err(RunError { kind: RunErrorKind::Limit(LimitKind::Host), message, line, column })
Err(RunError { kind: RunErrorKind::Limit(LimitKind::Host), message, line, column, authored: false })
}
Err(Abrupt::Limit(kind)) => Err(RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line, column }),
Err(Abrupt::Internal(message)) => Err(RunError { kind: RunErrorKind::Internal, message, line, column }),
Err(Abrupt::Limit(kind)) => {
Err(RunError { kind: RunErrorKind::Limit(kind), message: format!("limit reached: {kind:?}"), line, column, authored: false })
}
Err(Abrupt::Internal(message)) => Err(RunError { kind: RunErrorKind::Internal, message, line, column, authored: false }),
}
}
@@ -323,10 +330,16 @@ impl Realm {
pub fn advance(&mut self, slice: u64) -> Result<Progress, RunError> {
let interp = &mut self.interp;
if interp.frames.is_empty() {
return Err(RunError { kind: RunErrorKind::Internal, message: "no run to advance".into(), line: 0, column: 0 });
return Err(RunError { kind: RunErrorKind::Internal, message: "no run to advance".into(), line: 0, column: 0, authored: false });
}
if interp.waiting {
return Err(RunError { kind: RunErrorKind::Internal, message: "the run waits for a host function's result".into(), line: 0, column: 0 });
return Err(RunError {
kind: RunErrorKind::Internal,
message: "the run waits for a host function's result".into(),
line: 0,
column: 0,
authored: false,
});
}
let total = interp.fuel;
let cap = slice.saturating_add(self.unbroken_fuel).min(total);
@@ -384,7 +397,13 @@ impl Realm {
pub fn answer(&mut self, d: crate::Data) -> Result<(), RunError> {
let interp = &mut self.interp;
if !interp.waiting {
return Err(RunError { kind: RunErrorKind::Internal, message: "no host function waits for a result".into(), line: 0, column: 0 });
return Err(RunError {
kind: RunErrorKind::Internal,
message: "no host function waits for a result".into(),
line: 0,
column: 0,
authored: false,
});
}
interp.waiting = false;
// The value on top of the stack stood in for the result.
+8
View File
@@ -1692,6 +1692,14 @@ fn transform_rejects_a_mistyped_reflect_copy_or_origin_before_editing() {
assert_eq!(applied["isError"], false, "{applied}");
let applied: Value = serde_json::from_str(&text_of(&applied)).unwrap();
assert_eq!(applied["applied"], json!(["move"]));
let applied = call(&mut s, 21, "transform", json!({"ids": [second], "rotate": 90, "origin": null}));
assert_eq!(applied["isError"], false, "{applied}");
// The schema allows null for every argument but `ids`.
let tools = tool_definitions();
let props = &tools.iter().find(|t| t["name"] == "transform").unwrap()["inputSchema"]["properties"];
for key in ["dx", "dy", "rotate", "scale", "scaleX", "scaleY", "shear", "reflect", "copy", "origin"] {
assert!(props[key]["anyOf"].as_array().is_some_and(|a| a.contains(&json!({"type": "null"}))), "{key}: {}", props[key]);
}
}
#[test]
+74 -2
View File
@@ -1,5 +1,6 @@
//! A shape tool's double-click on a selected live shape's corner widget through MCP: the
//! gesture's `requests` carry the Transform panel.
//! Live shape widgets through MCP: a shape tool's double-click on a selected live shape's corner
//! widget, whose gesture's `requests` carry the Transform panel, and a drag on a live polygon's
//! side widget.
use serde_json::{Value, json};
use vectorcraft_tools::corners::CornerWidgets;
@@ -28,3 +29,74 @@ fn a_corner_widget_double_click_with_a_shape_tool_requests_the_transform_panel()
let off = ok(&mut h, "pointer_gesture", json!({"events": [{"kind": "doubleclick", "x": 280, "y": 280}]}));
assert_eq!(off["requests"], json!([]), "{off}");
}
/// The selected live polygon's sides, radius and transform.
fn polygon(h: &mut Headless) -> (u32, f64, vectorcraft_geom::Affine) {
let st = h.session.doc().unwrap();
let id = st.selection.objects[0];
let vectorcraft_doc::NodeKind::Path { live, .. } = &st.doc.node(id).unwrap().kind else { panic!("not a path") };
let Some(vectorcraft_doc::LiveShape::Polygon { sides, radius, xf, .. }) = live.as_deref() else { panic!("not a live polygon: {live:?}") };
(*sides, *radius, *xf)
}
/// A drag down on a live polygon's side widget with the Selection tool gives it more sides in one
/// undo step, keeping its radius and transform; undo puts the count back.
#[test]
fn a_side_widget_drag_changes_a_polygons_sides_in_one_undo_step() {
let mut h = Headless::new();
h.call("engine.execute", json!({"command": "file.new", "params": {"width": 300, "height": 300}})).unwrap();
h.call("engine.execute", json!({"command": "shape.polygon", "params": {"cx": 150, "cy": 150, "radius": 60, "sides": 5}})).unwrap();
let st = h.session.doc().unwrap();
let id = st.selection.objects[0];
let b = st.doc.node(id).unwrap().geometric_bounds_with(&st.doc.symbol_boxes()).expect("bounds");
let bx = vectorcraft_doc::OrientedBox::aligned(b);
let w = vectorcraft_tools::sidewidget::SideWidget::of(&st.doc, &st.selection, &bx, h.view.zoom).expect("a side widget");
let steps = st.history.undo.len();
let before = polygon(&mut h);
assert_eq!(before.0, 5);
let zoom = h.view.zoom;
let ev = |kind: &str, dy: f64| json!({"kind": kind, "x": w.at.x, "y": w.at.y + dy / zoom});
ok(&mut h, "pointer_gesture", json!({"tool": "selection", "events": [ev("down", 0.0), ev("drag", 13.0), ev("drag", 25.0), ev("up", 25.0)]}));
let after = polygon(&mut h);
assert_eq!((after.0, after.1, after.2), (7, before.1, before.2));
assert_eq!(h.session.doc().unwrap().history.undo.len(), steps + 1, "one undo step");
h.call("engine.execute", json!({"command": "edit.undo", "params": {}})).unwrap();
assert_eq!(polygon(&mut h), before);
// A drag that comes back to the start leaves no undo step.
ok(&mut h, "pointer_gesture", json!({"tool": "selection", "events": [ev("down", 0.0), ev("drag", 25.0), ev("drag", 0.0), ev("up", 0.0)]}));
assert_eq!(polygon(&mut h), before);
assert_eq!(h.session.doc().unwrap().history.undo.len(), steps);
}
/// A batch run during a side widget drag settles the drag first. A batch step that switches
/// documents then ends the drag without undoing the batch's own steps in the document it leaves.
#[test]
fn a_batch_that_switches_documents_during_a_side_widget_drag_keeps_its_steps() {
let mut h = Headless::new();
for _ in 0..2 {
h.call("engine.execute", json!({"command": "file.new", "params": {"width": 300, "height": 300}})).unwrap();
}
h.call("engine.execute", json!({"command": "shape.polygon", "params": {"cx": 150, "cy": 150, "radius": 60, "sides": 5}})).unwrap();
let st = h.session.doc().unwrap();
let (uid, id) = (st.uid, st.selection.objects[0]);
let b = st.doc.node(id).unwrap().geometric_bounds_with(&st.doc.symbol_boxes()).expect("bounds");
let bx = vectorcraft_doc::OrientedBox::aligned(b);
let w = vectorcraft_tools::sidewidget::SideWidget::of(&st.doc, &st.selection, &bx, h.view.zoom).expect("a side widget");
let steps = st.history.undo.len();
let zoom = h.view.zoom;
let ev = |kind: &str, dy: f64| json!({"kind": kind, "x": w.at.x, "y": w.at.y + dy / zoom});
// The drag stays held: no `up`.
ok(&mut h, "pointer_gesture", json!({"tool": "selection", "events": [ev("down", 0.0), ev("drag", 13.0), ev("drag", 25.0)]}));
let batch = json!({"commands": [
{"command": "shape.rectangle", "params": {"x": 10, "y": 10, "width": 20, "height": 20}},
{"command": "document.activate", "params": {"index": 0}}
]});
h.call("engine.execute", json!({"command": "command.batch", "params": batch})).unwrap();
let st = h.session.documents().iter().find(|d| d.uid == uid).expect("the polygon's document");
let vectorcraft_doc::NodeKind::Path { live, .. } = &st.doc.node(id).unwrap().kind else { panic!("not a path") };
assert!(matches!(live.as_deref(), Some(vectorcraft_doc::LiveShape::Polygon { sides: 7, .. })), "the settled drag: {live:?}");
assert_eq!(st.history.undo.len(), steps + 2, "the drag and the batch, each one undo step");
let rect = st.selection.objects[0];
assert_ne!(rect, id, "the batch's rectangle is selected");
assert!(st.doc.node(rect).is_some(), "the batch's rectangle stays");
}
+15 -10
View File
@@ -8,6 +8,11 @@ fn num(desc: &str) -> Value {
json!({"type": "number", "description": desc})
}
/// A number or null.
fn num_or_null(desc: &str) -> Value {
json!({"description": desc, "anyOf": [{"type": "number"}, {"type": "null"}]})
}
fn string(desc: &str) -> Value {
json!({"type": "string", "description": desc})
}
@@ -470,16 +475,16 @@ pub fn tool_definitions() -> Vec<Value> {
obj(
json!({
"ids": {"type": "array", "items": {"type": "integer"}},
"dx": num("Move right"),
"dy": num("Move down"),
"rotate": num("Rotation in degrees counter-clockwise"),
"scale": num("Uniform scale in %"),
"scaleX": num("Horizontal scale in %"),
"scaleY": num("Vertical scale in %"),
"reflect": {"type": "string", "enum": ["vertical", "horizontal"]},
"shear": num("Shear angle in degrees (horizontal axis: positive moves the top to the right, turning the vertical edges clockwise)"),
"origin": {"type": "array", "items": {"type": "number"}, "minItems": 2, "maxItems": 2},
"copy": {"type": "boolean"},
"dx": num_or_null("Move right (null: 0)"),
"dy": num_or_null("Move down (null: 0)"),
"rotate": num_or_null("Rotation in degrees counter-clockwise"),
"scale": num_or_null("Uniform scale in %"),
"scaleX": num_or_null("Horizontal scale in %"),
"scaleY": num_or_null("Vertical scale in %"),
"reflect": {"anyOf": [{"type": "string", "enum": ["vertical", "horizontal"]}, {"type": "null"}]},
"shear": num_or_null("Shear angle in degrees (horizontal axis: positive moves the top to the right, turning the vertical edges clockwise)"),
"origin": {"anyOf": [{"type": "array", "items": {"type": "number"}, "minItems": 2, "maxItems": 2}, {"type": "null"}]},
"copy": {"anyOf": [{"type": "boolean"}, {"type": "null"}]},
}),
&[],
),
+13 -2
View File
@@ -143,6 +143,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"",
"{} opens SVG Options; with params = document.export {path?, svg?: {…SVG options}, range?…} (a .svgz path writes it gzipped)",
),
(
"file.export.svg.browser",
"Show in Browser",
"",
"{svg?: {…SVG options}, exportSelection?} SVG Options' Show in Browser: write the SVG of one page (with exportSelection the selection's crop, else the first artboard the options choose) and its linked images to a new temporary folder and open it in the default browser (desktop; refused for control and MCP requests) → {path, warnings}",
),
(
"file.export.png",
"Export As PNG…",
@@ -871,7 +877,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"",
"{effect: id, index?: int (edit that applied effect in place, prefilled; OK runs effect.setParams), item?: appearance item index|null (the fill/stroke whose effects, null the object's; default: the Appearance panel's active item), aligned?: bool (index and item are rows of the first selected object's stack, which OK edits in each object where it has them, as effect.setParams does)} open the effect's dialog with live preview; without `index`, an effect already in that list first opens `effectExists` (confirm edits it, discard adds another) → {pending: \"effectExists\"}",
),
("ui.paramDialog", "Command Dialog", "", "{command, label?, params} open a parameter dialog for any command"),
(
"ui.paramDialog",
"Command Dialog",
"",
"{command, label?, params} open a parameter dialog for any command. For edit.findReplace it opens Find and Replace (dialog `findReplace`), which stays open: fields find, replace, matchCase, wholeWord, backwards, hiddenLayers, lockedLayers, and action, which ui.dialog.confirm runs: find (the next match, edit.findNext, shown in the dialog with its place among the matches), replace (the match found, edit.replaceMatch), replaceFind (both), replaceAll (edit.findReplace) or done (close). After each one action is find again. Replace and Replace & Find change a match that find reached with the find text and options as they are now, and find one otherwise. The dialog opens on the last search, with the fields params gives in its place (a null field gives none; a field of the wrong type is an error, and ui.dialog.confirm then runs no action), and Edit › Find Next goes on from it in the same document while the dialog is closed",
),
(
"ui.recolorDialog",
"Recolor Artwork…",
@@ -1443,7 +1454,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"ui.colorWheel",
"Color Wheel Options",
"",
"{view?: wheel|box, channel?: hue|saturation|brightness|red|green|blue} show the Color Wheel panel's wheel or its box, as the panel menu's Wheel View and Box View do, and pick the box's channel, as Box Channel does: the box is a color field with the channel's strip at its right, and the field shows the other two components (hue: saturation across and brightness up; saturation: hue across and brightness up; brightness: hue across and saturation up; red: blue across and green up; green: blue across and red up; blue: red across and green up); keys left out keep their values, params that are not an object, another key or a value off the list are an error and change nothing, both are kept with the preferences, and the command does not open the panel (window.panel {panel: \"colorWheel\"} does) (ui.inspect: ui.color_wheel) → {view, channel}",
"{view?: wheel|box, channel?: hue|saturation|brightness|red|green|blue, vision?: bool} show the Color Wheel panel's wheel or its box, as the panel menu's Wheel View and Box View do, and pick the box's channel, as Box Channel does: the box is a color field with the channel's strip at its right, and the field shows the other two components (hue: saturation across and brightness up; saturation: hue across and brightness up; brightness: hue across and saturation up; red: blue across and green up; green: blue across and red up; blue: red across and green up); vision shows Show Color Vision Preview's row under the wheel or the box, four chips with the current color as simulated for protanopia, deuteranopia and tritanopia (the simulations of view.proofSetup's protanopia, deuteranopia and tritanopia targets) and for achromatopsia (the gray with the color's CIE L*), each named with its hex value in its tooltip and to screen readers, and taking the keyboard focus; a click or a key on a chip does not apply its color; keys left out or null keep their values ({} reads them), params that are not an object, another key or a value off the list are an error and change nothing, the settings are kept with the preferences, and the command does not open the panel (window.panel {panel: \"colorWheel\"} does) (ui.inspect: ui.color_wheel) → {view, channel, vision}",
),
(
"ui.savePdfDialog",
+12 -3
View File
@@ -85,14 +85,23 @@ pub fn export(doc: &Document, region: Rect, kind: Kind) -> Result<Output, String
Ok(export_regions(doc, &[region], kind)?.pop().unwrap_or_default())
}
/// The error [`export_regions`] returns for `regions`, without writing anything: a region whose
/// corners are not all finite, or that has no width or no height, is empty. Corners in either
/// order are allowed.
pub fn check_regions(regions: &[Rect]) -> Result<(), String> {
let empty = |r: Rect| ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0;
if regions.iter().any(|r| empty(r.abs())) {
return Err("the export region is empty".into());
}
Ok(())
}
/// Write the visible art of `doc` over each of `regions` as `kind`, one metafile per region in the
/// same order, each as [`export`] writes it over that region. The live effects are applied once
/// for all of them. When any region is empty, nothing is written and the result is an error.
pub fn export_regions(doc: &Document, regions: &[Rect], kind: Kind) -> Result<Vec<Output>, String> {
check_regions(regions)?;
let regions: Vec<Rect> = regions.iter().map(|r| r.abs()).collect();
if regions.iter().any(|r| ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0) {
return Err("the export region is empty".into());
}
if regions.is_empty() {
return Ok(Vec::new());
}
+32 -10
View File
@@ -1,6 +1,6 @@
//! Bounded ownership of authored replacement text (ISO 32000-1, 14.9.4).
use super::state::Builder;
use super::state::{Builder, HeldStroke};
use super::{Affine, Look, Placement, Shape, TextLine, Upright};
use crate::import_text::TextContent;
@@ -21,13 +21,16 @@ impl ActualText {
self.depth = self.depth.saturating_add(1);
}
pub(super) fn end(&mut self) {
if self.owner == Some(self.depth) {
/// `true`: the owner's span ended.
pub(super) fn end(&mut self) -> bool {
let ended = self.owner == Some(self.depth);
if ended {
self.owner = None;
self.pending = None;
self.empty = false;
}
self.depth = self.depth.saturating_sub(1);
ended
}
pub(super) fn active(&self) -> bool {
@@ -62,13 +65,32 @@ impl Builder<'_> {
/// against the glyph's original Unicode, not against this replacement's characters.
pub(super) fn actual_glyph(&mut self, o: &craft_pdf::interpret::font::OutlineGlyph, m: Affine, at: Placement, look: Look, opacity: f32) -> bool {
let key = o.font_cache_key();
self.flush_glyphs();
// A fill and stroke callback for the same glyph consumes its text only once.
if let (Some(stroke), Some(line)) = (&look.stroke, &mut self.text)
&& look.fill.is_none()
&& line.stroke_actual(key, at, stroke.clone(), look.overprint_stroke)
// A fill and stroke callback for the same glyph consumes its text only once: the stroke
// goes over the glyph of the span filled, matched as the stroke pass ends as any other
// (`Builder::hold_stroke`), on a line the operator's kerning finished too.
let stroking = look.fill.is_none() && look.stroke.is_some();
if let Some(stroke) = &look.stroke
&& stroking
{
return true;
let h = HeldStroke {
font: key,
at,
opacity,
text: String::new(),
stroke: stroke.clone(),
overprint: look.overprint_stroke,
glyph: None,
actual: true,
first: (0, 0),
};
if self.hold_stroke(h) {
return true;
}
}
self.flush_glyphs();
// Stroked type of its own ends the stroke pass of the glyphs filled before it.
if stroking {
self.end_fills();
}
let width = o.advance_width().filter(|w| w.is_finite());
let advance = width.map_or(at.size * 0.5, |w| w as f64 / 1000.0 * at.size * at.h_scale / 100.0);
@@ -87,7 +109,7 @@ impl Builder<'_> {
None => line.push_content(&look, at, opacity, advance, content),
};
if !self.text.as_mut().is_some_and(place) {
self.flush_text();
self.park_text(!stroking);
let mut line = TextLine::new(at, opacity);
if !place(&mut line) {
self.actual.pending = pending;
+341 -12
View File
@@ -4,7 +4,9 @@ use super::entry::{
UNNAMED_CHARACTERS_NOTE, max_objects,
};
use super::reshaped;
use super::state::{Builder, Frame, FrameKind, GlyphRun, Saved, bounds, grouped, mean_scale, paints, round3, same_stroke, stroke_layer, type_stroke};
use super::state::{
Builder, Frame, FrameKind, GlyphRun, HeldStroke, Saved, bounds, grouped, mean_scale, paints, round3, same_stroke, stroke_layer, type_stroke,
};
use super::{
Affine, Appearance, AppearanceItem, Arc, BezPath, BfString, BlendMode, CacheKey, Color, Colors, Families, FillLayer, FillRule, FunctionBudget,
FunctionPaint, HashMap, HashSet, ImageBlob, ImageObject, Knockout, Look, MaskSpec, MaskType, Native, Node, NodeId, NodeKind, OpacityMask, Paint,
@@ -12,6 +14,30 @@ use super::{
Upright, Walked, clipped, contains, fold_stop_opacity, function_paint, gradient_shape, is_rectangle, luminance, mask_spec, shading_gradient,
};
/// The most lines of type kept for a text-showing operator's stroke pass ([`Builder::park_text`]):
/// beyond them the oldest is finished, and strokes over its glyphs come in as type of their own.
/// They are the lines its fill pass finished, besides the open one: a `TJ` over up to 65 lines is
/// filled and stroked, one over more is a filled object and a stroked one for each part. The
/// pass's first stroke goes over a glyph finished so, which can match a glyph kept (a `TJ` that
/// draws it again where it began): a first stroke that may go over one of them is type of its own
/// too, and ends the pass ([`Builder::hold_stroke`]).
const MAX_PARKED: usize = 64;
/// The most strokes of a stroke pass held to be matched to the glyphs they go over
/// ([`Builder::hold_stroke`]): beyond them, those held are matched to the last glyphs filled one
/// after another that they go over, with as many glyphs filled from there on as strokes held
/// ([`Builder::replayed`]), and the pass goes on from there. The reader tells no operator's
/// start, so the last such run is taken: the operator's fill pass is the one right before its
/// stroke pass. An operator that fills the same run of more than this many glyphs twice at the
/// same places may have its first strokes matched to its second copy; such a pass is matched as
/// well as it can be, not exactly.
const MAX_HELD: usize = 4096;
/// The most glyphs [`Builder::replayed`] compares to the strokes held, for bounded work on
/// hostile input: beyond them, each stroke goes over the first glyph it may go over after the one
/// the stroke before it goes over.
const MAX_REPLAY_WORK: usize = 1 << 20;
fn is_colour_face(face: &vectorcraft_text::FontFace) -> bool {
use skrifa::Tag;
use skrifa::raw::TableProvider;
@@ -37,6 +63,9 @@ impl<'p> Builder<'p> {
type3_run: None,
text: None,
text_glyphs: vec![],
parked: vec![],
held: vec![],
lost: None,
text_as,
actual: Default::default(),
images: HashMap::new(),
@@ -119,6 +148,9 @@ impl<'p> Builder<'p> {
self.type3_run = None;
self.text = None;
self.text_glyphs.clear();
self.parked.clear();
self.held.clear();
self.lost = None;
self.mask = None;
self.masked.clear();
self.marked.clear();
@@ -420,7 +452,10 @@ impl<'p> Builder<'p> {
}
}
/// Finish the open run of glyphs kept as outlines, once the strokes held are matched
/// ([`Self::settle_strokes`]): whatever is drawn next ends their stroke pass.
pub(super) fn flush_glyphs(&mut self) {
self.settle_strokes();
let Some(run) = self.glyphs.take() else { return };
if run.path.elements().is_empty() {
return;
@@ -450,11 +485,274 @@ impl<'p> Builder<'p> {
}
}
/// Finish the open line of type. `true`: it was kept as outlines instead ([`reshaped`]), which
/// are left open as the glyph run for an outline drawn next to join.
/// Finish the open line of type, after the lines parked before it ([`Self::park_text`]).
/// `true`: the open line was kept as outlines instead ([`reshaped`]), which are left open as
/// the glyph run for an outline drawn next to join.
pub(super) fn end_text(&mut self) -> bool {
self.settle_strokes();
self.release_parked(usize::MAX);
let glyphs = std::mem::take(&mut self.text_glyphs);
let Some(mut line) = self.text.take() else { return false };
let Some(line) = self.text.take() else { return false };
self.end_line(line, glyphs)
}
/// Finish the first `n` parked lines ([`Self::park_text`]), in the order they were drawn.
pub(super) fn release_parked(&mut self, n: usize) {
let n = n.min(self.parked.len());
if n == 0 {
return;
}
let lines: Vec<_> = self.parked.drain(..n).collect();
for (line, glyphs) in lines {
if self.end_line(line, glyphs) {
self.flush_glyphs();
}
}
}
/// The open line ends where glyph drawn next starts another. The reader fills every glyph of
/// a text-showing operator before it strokes them (fill and stroke rendering): a line that a
/// stroke may still be drawn over is parked instead of finished, so that the operator's
/// stroke pass still finds the glyphs it filled when its kerning started a new line part way
/// through (#8543). Any other line, or with `park` false, is finished with the lines parked
/// before it.
///
/// Parked lines are finished, oldest first, when the stroke pass goes past them (a stroke is
/// drawn over a later line or the open one: [`Self::settle_strokes`]; or over none of them:
/// [`Self::end_fills`]), when anything else ends the open line ([`Self::end_text`]), and
/// beyond [`MAX_PARKED`] lines: the glyphs of those are kept for the stroke after them
/// ([`Self::hold_stroke`]).
pub(super) fn park_text(&mut self, park: bool) {
match self.text.take() {
Some(line) if park && line.awaits_stroke() => {
let glyphs = std::mem::take(&mut self.text_glyphs);
self.parked.push((line, glyphs));
let over = self.parked.len().saturating_sub(MAX_PARKED);
if over > 0 {
let lost = self.lost.get_or_insert_default();
for (line, _) in self.parked.iter().take(over) {
lost.add(line);
}
}
self.release_parked(over);
}
line => {
self.text = line;
self.flush_text();
}
}
}
/// A boundary of stroke passes: no stroke drawn from now on goes over a glyph filled before
/// it. The strokes held are matched ([`Self::settle_strokes`]), the parked lines finished, and
/// the open line's glyphs filled so far closed to strokes ([`TextLine::end_fills`]). A stroke
/// that goes over no glyph filled (stroked type of its own) is one: a stroke pass replays the
/// glyphs its operator filled last, so a stroke after it isn't part of a pass over glyphs
/// filled before it, and stroking those would draw it under the type of its own. The start
/// and end of an ActualText span are too: a span's glyphs are stroked within it (#8543).
pub(super) fn end_fills(&mut self) {
self.lost = None;
self.settle_strokes();
self.release_parked(usize::MAX);
if let Some(line) = &mut self.text {
line.end_fills();
}
}
/// The parked line at `slot` ([`Self::park_text`]), or the open line at the slot after them.
fn line_at(&self, slot: usize) -> Option<&TextLine> {
match self.parked.get(slot) {
Some((line, _)) => Some(line),
None if slot == self.parked.len() => self.text.as_ref(),
None => None,
}
}
/// The glyph filled right after the one at `at` (a line's slot and its index among the line's
/// filled glyphs, as [`Self::next_fill`]): the next on its line, else the first of the line
/// after it.
fn after_fill(&self, (slot, i): (usize, usize)) -> (usize, usize) {
match self.line_at(slot) {
Some(line) if i.saturating_add(1) < line.filled_len() => (slot, i.saturating_add(1)),
_ => (slot.saturating_add(1), 0),
}
}
/// The first glyph filled after `after` that stroke `h` may go over
/// ([`TextLine::next_filled`]), as its line's slot ([`Self::line_at`]) and its index among
/// the line's filled glyphs: the lines in the order they were drawn, each line's glyphs in
/// the order they were filled. From the first glyph with no `after`.
fn next_fill(&self, after: Option<(usize, usize)>, h: &HeldStroke) -> Option<(usize, usize)> {
let first = after.map_or(0, |(slot, _)| slot);
(first..=self.parked.len()).find_map(|slot| {
let from = match after {
Some((s, i)) if s == slot => i.saturating_add(1),
_ => 0,
};
let i = self.line_at(slot)?.next_filled(from, h.font, h.at, h.opacity, &h.text, h.actual)?;
Some((slot, i))
})
}
/// The last glyph filled before `before` that stroke `h` may go over ([`Self::next_fill`]).
/// From the last glyph with no `before`.
fn last_fill(&self, before: Option<(usize, usize)>, h: &HeldStroke) -> Option<(usize, usize)> {
let last = before.map_or(self.parked.len(), |(slot, _)| slot);
(0..=last).rev().find_map(|slot| {
let until = match before {
Some((s, i)) if s == slot => i,
_ => usize::MAX,
};
let i = self.line_at(slot)?.last_filled(until, h.font, h.at, h.opacity, &h.text, h.actual)?;
Some((slot, i))
})
}
/// Hold stroke `h`, over a glyph filled on the open line or a parked one, until its stroke
/// pass ends ([`Self::settle_strokes`]). `false`: no glyph filled after those the strokes
/// held go over is one it may go over (the strokes held are matched first, and if it may go
/// over none then, it isn't held either: it goes over the line as it stands).
///
/// The reader fills all the glyphs of a text-showing operator, then strokes the same glyphs
/// in the same order (fill and stroke rendering, #8015). Which glyph a stroke goes over is
/// only told once the pass has ended: a `TJ` can draw the same glyph at the same place twice
/// (its kerning goes back), and an operator can fill and stroke a glyph where one filled
/// before it stands, which the device can't tell from a glyph the operator filled (#8543).
///
/// The first stroke after lines were finished beyond [`MAX_PARKED`] ([`Self::park_text`])
/// that may go over a glyph of theirs may be the start of their stroke pass, which no longer
/// finds its first glyphs: it ends the pass ([`Self::end_fills`]) and is type of its own, as
/// are the pass's strokes after it. Any other first stroke there is matched as ever: no
/// stroke pass is due over those lines once another stroke is drawn.
pub(super) fn hold_stroke(&mut self, mut h: HeldStroke) -> bool {
if self.lost.take().is_some_and(|lost| lost.may_stroke(h.font, h.at, h.opacity, &h.text, h.actual)) {
self.end_fills();
return false;
}
if self.held.len() >= MAX_HELD {
self.settle(false);
}
let mut first = self.next_fill(self.held.last().map(|l| l.first), &h);
if first.is_none() && !self.held.is_empty() {
self.settle_strokes();
first = self.next_fill(None, &h);
}
let Some(first) = first else { return false };
h.first = first;
self.held.push(h);
true
}
/// Match the strokes held ([`Self::hold_stroke`]) to the glyphs they go over, now that their
/// stroke pass has ended, and stroke them. The pass strokes the glyphs filled last, in the
/// order they were filled: each stroke goes over the last glyph it may go over that is filled
/// before the one the stroke after it goes over. So a `TJ` that draws a glyph twice at the
/// same place strokes each where it filled it, and a glyph filled and stroked where one
/// filled before it stands strokes the one filled last (#8015, #8543).
pub(super) fn settle_strokes(&mut self) {
self.settle(true);
}
/// The glyphs the strokes `held` go over when they are the start of a stroke pass that goes
/// on after them ([`MAX_HELD`]): the last glyphs filled one right after another that they
/// may go over, in order, with at least as many glyphs filled from the first of them on as
/// there are strokes held. The pass replays its operator's fill pass, the glyphs filled
/// last, one right after another, right before the pass, so the strokes don't go over a
/// glyph filled before those, nor skip one. The device isn't told where an operator starts:
/// an operator before it that filled the same glyphs at the same places stays unstroked, as
/// the first glyphs of the pass are the last such run the pass still has room for. `None`
/// when there are none, or beyond [`MAX_REPLAY_WORK`].
fn replayed(&self, held: &[HeldStroke]) -> Option<Vec<(usize, usize)>> {
let (head, rest) = held.split_first()?;
let mut work = 0usize;
// The glyphs filled from `at` on, up to as many as there are strokes held.
let left = |(slot, i): (usize, usize)| {
(slot..=self.parked.len())
.filter_map(|s| self.line_at(s).map(|line| line.filled_len().saturating_sub(if s == slot { i } else { 0 })))
.fold(0usize, |n, len| n.saturating_add(len).min(held.len()))
};
let mut start = self.last_fill(None, head);
while let Some(first) = start {
start = self.last_fill(Some(first), head);
work = work.saturating_add(1);
if work > MAX_REPLAY_WORK {
return None;
}
// Too few glyphs filled after it for the strokes held: not where the pass starts.
if left(first) < held.len() {
continue;
}
let mut places = Vec::with_capacity(held.len());
places.push(first);
let mut at = first;
for h in rest {
work = work.saturating_add(1);
if work > MAX_REPLAY_WORK {
return None;
}
at = self.after_fill(at);
if !self.line_at(at.0).is_some_and(|line| line.fills_at(at.1, h.font, h.at, h.opacity, &h.text, h.actual)) {
break;
}
places.push(at);
}
if places.len() == held.len() {
return Some(places);
}
}
None
}
/// [`Self::settle_strokes`], each stroke matched to the last glyph it may go over (`last`),
/// or, when too many are held ([`Self::hold_stroke`]), as the start of a pass that goes on
/// ([`Self::replayed`]).
fn settle(&mut self, last: bool) {
if self.held.is_empty() {
return;
}
let held = std::mem::take(&mut self.held);
let mut places = vec![];
if last {
let mut before = None;
for h in held.iter().rev() {
let Some(p) = self.last_fill(before, h) else { break };
places.push(p);
before = Some(p);
}
places.reverse();
} else if let Some(p) = self.replayed(&held) {
places = p;
}
// Each held stroke goes over the first glyph it may go over after the one before it
// does ([`Self::hold_stroke`]), so the last ones are found too: this is only a guard.
if places.len() != held.len() {
places = held.iter().map(|h| h.first).collect();
}
// The slots of the parked lines finished so far, which the later places count in.
let mut finished = 0usize;
for (h, (slot, index)) in held.into_iter().zip(places) {
let slot = slot.saturating_sub(finished);
let parked = self.parked.len();
// The lines before the one stroked are past the stroke pass: they are finished.
self.release_parked(slot);
finished = finished.saturating_add(slot.min(parked));
let target = match self.parked.first_mut() {
Some((line, glyphs)) if slot < parked => Some((line, glyphs)),
_ => self.text.as_mut().map(|line| (line, &mut self.text_glyphs)),
};
if let Some((line, glyphs)) = target
&& line.stroke_filled_at(index, h.stroke, h.overprint)
{
// Upright glyphs aren't kept as outlines (nor are those filled only): a vertical
// line that came in as its outlines would lose the ones filled only.
glyphs.extend(h.glyph);
}
}
}
/// Finish `line` of type, whose `glyphs` are its outlines ([`Self::keep_glyph`]). `true`:
/// it was kept as them ([`Self::end_text`]).
fn end_line(&mut self, mut line: TextLine, glyphs: Vec<GlyphRun>) -> bool {
let held = std::mem::take(&mut line.held);
// Type the file names itself (ActualText) is in reading order as it stands.
let checked = !glyphs.is_empty() && line.mapped() && !line.has_type3;
@@ -880,13 +1178,9 @@ impl<'p> Builder<'p> {
scale: f64,
overprint: bool,
) {
let Some((paint, stroke)) = drawn else { return };
let mut path = o.outline();
if path.elements().is_empty() {
return;
if let Some(g) = glyph_run(o, m, drawn, opacity, scale, overprint) {
self.text_glyphs.push(g);
}
path.apply_affine(m);
self.text_glyphs.push(GlyphRun { path, paint, opacity, stroke, scale, overprint });
}
fn type3_font_name(&mut self, key: u128) -> FontInfo {
@@ -1150,10 +1444,22 @@ impl<'p> Builder<'p> {
Some(top) => line.push_upright(&look, at, opacity, Upright { top }, &text),
None => line.push(&look, at, opacity, advance, &text),
};
let stroking = look.fill.is_none() && look.stroke.is_some();
// A stroke over a glyph filled before it, on the open line or one the same operator's
// kerning finished: matched once its stroke pass ends.
if let Some(s) = &look.stroke
&& stroking
{
let glyph = if top.is_none() { glyph_run(o, m, drawn.clone(), opacity, scale, overprint) } else { None };
let h = HeldStroke { font: key, at, opacity, text: text.clone(), stroke: s.clone(), overprint, glyph, actual: false, first: (0, 0) };
if self.hold_stroke(h) {
return true;
}
}
self.flush_glyphs();
// A stroke over the glyph just filled (fill and stroke rendering).
if let (Some(s), Some(line)) = (&look.stroke, &mut self.text)
&& look.fill.is_none()
&& stroking
&& line.stroke_filled(key, at, opacity, &text, s.clone(), overprint)
{
// Upright glyphs aren't kept as outlines (nor, below, are those filled only): a
@@ -1163,8 +1469,12 @@ impl<'p> Builder<'p> {
}
return true;
}
// Stroked type of its own ends the stroke pass of the glyphs filled before it.
if stroking {
self.end_fills();
}
if !self.text.as_mut().is_some_and(place) {
self.flush_text();
self.park_text(!stroking);
let mut line = TextLine::new(at, opacity);
place(&mut line);
self.text = Some(line);
@@ -1184,6 +1494,25 @@ impl<'p> Builder<'p> {
}
}
/// Glyph `o` placed by `m` and drawn with `drawn` as the outline it is kept as
/// ([`Builder::keep_glyph`]). Nothing for a glyph that shows nothing.
fn glyph_run(
o: &craft_pdf::interpret::font::OutlineGlyph,
m: Affine,
drawn: Option<(Paint, Option<StrokeProps>)>,
opacity: f32,
scale: f64,
overprint: bool,
) -> Option<GlyphRun> {
let (paint, stroke) = drawn?;
let mut path = o.outline();
if path.elements().is_empty() {
return None;
}
path.apply_affine(m);
Some(GlyphRun { path, paint, opacity, stroke, scale, overprint })
}
/// The characters of one glyph in the order they are drawn: a PDF names a ligature's characters
/// in logical order (lam then alef for لا), while a horizontal line of type is gathered glyph by
/// glyph in visual order and only then put back in logical order. Right-to-left characters are
+9 -1
View File
@@ -453,12 +453,20 @@ impl<'a> Device<'a> for Builder<'_> {
self.flush();
}
self.marked.pop();
self.actual.end();
// A span's glyphs are stroked within it: a stroke after it goes over none of them.
if self.actual.end() {
self.end_fills();
}
}
fn actual_text(&mut self, text: &[u8]) {
let active = self.actual.active();
if self.nested == 0 && self.text_as == crate::TextAs::Text && !self.actual.set(text) {
self.warn("ActualText beyond the import size or nesting limit was left to glyph mappings");
}
// Nor does a stroke in a span go over a glyph filled before it.
if !active && self.actual.active() {
self.end_fills();
}
}
}
+31
View File
@@ -58,6 +58,24 @@ pub(super) struct GlyphRun {
pub(super) overprint: bool,
}
/// A stroke over a glyph filled before it (fill and stroke rendering), held with the stroke pass
/// it is part of ([`Builder::hold_stroke`]): the glyph's font, placement, opacity and text, the
/// stroke, whether it overprints, the glyph's outline as drawn (kept as for a line of type kept
/// as outlines; none for a glyph set upright or one of an ActualText span), whether it is one of
/// an ActualText span, and the first glyph filled so it may go over, as its line's place among
/// the parked lines and the open one and its index in the line's filled glyphs.
pub(super) struct HeldStroke {
pub(super) font: u128,
pub(super) at: super::Placement,
pub(super) opacity: f32,
pub(super) text: String,
pub(super) stroke: TypeStroke,
pub(super) overprint: bool,
pub(super) glyph: Option<GlyphRun>,
pub(super) actual: bool,
pub(super) first: (usize, usize),
}
/// How often a tiling pattern was read, and the art (as its paints) each reading drew with the
/// swatch made for it.
pub(super) type PatternReadings = (u32, Vec<(Vec<Paint>, String)>);
@@ -94,6 +112,19 @@ pub(super) struct Builder<'p> {
/// kept as: what the line becomes when its type wouldn't draw as the file does
/// ([`super::reshaped`]).
pub(super) text_glyphs: Vec<GlyphRun>,
/// Lines of type a text-showing operator's fill pass finished (a `TJ`'s kerning starts a new
/// line part way through) that its stroke pass may still go over, oldest first, each with
/// its [`text_glyphs`](Self::text_glyphs): written before the open line, in this order
/// ([`Builder::park_text`]).
pub(super) parked: Vec<(TextLine, Vec<GlyphRun>)>,
/// The strokes of a text-showing operator's stroke pass over glyphs it filled on the
/// [`parked`](Self::parked) lines and the open one, held until the pass ends to be matched to
/// the glyphs it strokes ([`Builder::settle_strokes`]).
pub(super) held: Vec<HeldStroke>,
/// The glyphs of the lines a fill pass finished beyond the most kept for their stroke pass that
/// a stroke may still have gone over, until the first stroke after them
/// ([`Builder::hold_stroke`]) or a boundary of stroke passes ([`Builder::end_fills`]).
pub(super) lost: Option<crate::import_text::LostFills>,
pub(super) text_as: TextAs,
pub(super) actual: super::actual_text::ActualText,
pub(super) images: HashMap<String, ImageBlob>,
+171 -40
View File
@@ -233,10 +233,8 @@ pub(crate) struct TextLine {
slots: Vec<Option<Slot>>,
/// Per character: authored logical order must survive visual-to-logical reconstruction.
authored: Vec<bool>,
/// Fill callbacks in an authored span, for the reader's later stroke pass.
actual_fills: HashMap<(u128, u64, u64), Option<usize>>,
/// The glyphs filled without a stroke, in drawing order, for a stroke drawn over them later
/// ([`stroke_filled`](Self::stroke_filled)).
/// ([`stroke_filled`](Self::stroke_filled)), those of an ActualText span among them.
filled: Vec<Filled>,
/// The first of [`filled`](Self::filled) a stroke may still be drawn over: a stroke matches
/// glyphs in the order they were filled, and each at most once.
@@ -246,6 +244,10 @@ pub(crate) struct TextLine {
pending: Option<PendingStroke>,
/// The last glyph's placement.
last_at: Placement,
/// The last glyph was drawn before a boundary of stroke passes ([`end_fills`](Self::end_fills)):
/// no stroke drawn since goes over it, not even as the glyph just drawn
/// ([`stroke_last`](Self::stroke_last)).
last_closed: bool,
/// The first glyph was set vertically ([`Upright`]).
upright: Option<Upright>,
/// The glyphs make a column (vertical type), each below the last.
@@ -279,7 +281,9 @@ struct Slot {
}
/// A glyph filled without a stroke: its font and placement, and where its text is in the line's
/// runs (the run's index, the text's byte offset in it and its length).
/// runs (the run's index, the text's byte offset in it and its length). A glyph of an ActualText
/// span has `actual`: `Some(true)` for the glyph whose run holds the replacement text,
/// `Some(false)` for the glyphs after it, which add no text (`len` 0 for both).
#[derive(Clone, Copy, Debug)]
struct Filled {
font: u128,
@@ -287,6 +291,57 @@ struct Filled {
run: usize,
start: usize,
len: usize,
actual: Option<bool>,
}
/// Whether a stroke over glyph `text` drawn at `at` in `font` at `opacity` may be drawn over a
/// glyph `fill` filled (its font, placement, whether it is a glyph of an ActualText span, and its
/// text) on a line that is `opaque` or not ([`TextLine::fills_at`]).
fn may_stroke(fill: (u128, Placement, bool, Option<&str>), opaque: bool, font: u128, at: Placement, opacity: f32, text: &str, actual: bool) -> bool {
let (g_font, g_at, g_actual, g_text) = fill;
if actual {
let same = |a: f64, b: f64| a.to_bits() == b.to_bits();
return g_actual && g_font == font && same(g_at.origin.x, at.origin.x) && same(g_at.origin.y, at.origin.y);
}
!g_actual && opacity >= 0.999 && opaque && g_font == font && g_at.same_as(&at) && g_text == Some(text)
}
/// The glyphs a stroke could still go over on lines of type finished before their stroke pass
/// could end: lines beyond the most a fill pass keeps for its stroke pass. The device isn't told
/// where an operator starts, so a stroke pass over such a line can't be told from one over the
/// glyphs kept: its first stroke, over a glyph finished so, may match one of them instead. Kept up
/// to [`MAX_LOST_FILLS`](Self::MAX_LOST_FILLS), beyond which any stroke may be over one.
#[derive(Clone, Debug, Default)]
pub(crate) struct LostFills {
/// Each glyph's font, placement, whether it is a glyph of an ActualText span, its text and
/// whether its line is opaque.
fills: Vec<(u128, Placement, bool, Option<String>, bool)>,
/// More glyphs than [`MAX_LOST_FILLS`](Self::MAX_LOST_FILLS) were finished so.
overflowed: bool,
}
impl LostFills {
/// The most glyphs kept, for bounded work and memory on hostile input.
pub const MAX_LOST_FILLS: usize = 4096;
/// Add the glyphs `line` filled that a stroke may still go over.
pub fn add(&mut self, line: &TextLine) {
let opaque = line.opacity >= 0.999;
for g in line.filled.get(line.stroked..).unwrap_or_default() {
if self.fills.len() >= Self::MAX_LOST_FILLS {
self.overflowed = true;
return;
}
self.fills.push((g.font, g.at, g.actual.is_some(), line.glyph_text(g).map(str::to_string), opaque));
}
}
/// Whether a stroke over glyph `text` drawn at `at` in `font` at `opacity` may be drawn over
/// one of the glyphs ([`TextLine::fills_at`]).
pub fn may_stroke(&self, font: u128, at: Placement, opacity: f32, text: &str, actual: bool) -> bool {
self.overflowed
|| self.fills.iter().any(|(f, a, act, t, opaque)| may_stroke((*f, *a, *act, t.as_deref()), *opaque, font, at, opacity, text, actual))
}
}
/// Glyphs next to each other in one run that a stroke is drawn over, not yet restyled
@@ -331,11 +386,11 @@ impl TextLine {
text_bytes: 0,
slots: vec![],
authored: vec![],
actual_fills: HashMap::new(),
filled: vec![],
stroked: 0,
pending: None,
last_at: at,
last_closed: false,
upright: None,
column: false,
ink: vec![],
@@ -382,10 +437,10 @@ impl TextLine {
let Some((last, _, run)) = self.runs.last_mut() else {
self.runs.push((look.clone(), 0.0, text.to_string()));
self.last_start = 0;
self.record_actual_fill(look, at, content);
self.record_filled(look, at, content);
self.authored.extend(text.chars().map(|_| content.authored()));
(self.upright, self.next, self.last, self.last_at) = (Some(upright), at.origin + down * at.size, at.origin, at);
self.last_closed = false;
return true;
};
let across = (at.origin - self.at.origin).dot(self.at.dir);
@@ -420,12 +475,12 @@ impl TextLine {
self.runs.push((look.clone(), 0.0, text.to_string()));
self.last_start = 0;
}
self.record_actual_fill(look, at, content);
self.record_filled(look, at, content);
self.authored.extend(text.chars().map(|_| content.authored()));
self.next = at.origin + down * at.size;
self.last = at.origin;
self.last_at = at;
self.last_closed = false;
true
}
@@ -522,7 +577,6 @@ impl TextLine {
self.runs.push((look.clone(), 0.0, text.to_string()));
self.last_start = 0;
}
self.record_actual_fill(look, at, content);
self.record_filled(look, at, content);
self.text_bytes = self.text_bytes.saturating_add(text.len());
if !pen {
@@ -539,41 +593,38 @@ impl TextLine {
}
self.last = at.origin;
self.last_at = at;
self.last_closed = false;
self.last_dir = at.dir;
self.last_size = at.size;
self.baseline.push(at.origin);
true
}
fn record_actual_fill(&mut self, look: &Look, at: Placement, content: TextContent<'_>) {
if content.authored() && look.fill.is_some() {
let run = matches!(content, TextContent::Actual(_)).then(|| self.runs.len().saturating_sub(1));
self.actual_fills.insert((look.font, at.origin.x.to_bits(), at.origin.y.to_bits()), run);
}
}
/// Note glyph `content` just added to the last run, filled without a stroke, for a stroke
/// drawn over it later.
/// drawn over it later: a glyph of an ActualText span too, whose text is the replacement's
/// (the first glyph's) or none.
fn record_filled(&mut self, look: &Look, at: Placement, content: TextContent<'_>) {
let len = content.text().len();
if content.authored() || len == 0 || look.fill.is_none() || look.stroke.is_some() {
if look.fill.is_none() || look.stroke.is_some() {
return;
}
let run = self.runs.len().saturating_sub(1);
self.filled.push(Filled { font: look.font, at, run, start: self.last_start, len });
let (run, start) = (self.runs.len().saturating_sub(1), self.last_start);
let (start, len, actual) = match content {
TextContent::Mapped(text) if !text.is_empty() => (start, text.len(), None),
TextContent::Mapped(_) => return,
TextContent::Actual(_) => (0, 0, Some(true)),
TextContent::Pen => (0, 0, Some(false)),
};
self.filled.push(Filled { font: look.font, at, run, start, len, actual });
}
/// The reader fills a whole Tj/TJ before replaying its glyphs as strokes. A replay
/// must neither consume the replacement nor rewind the pen. Only the first glyph's
/// style belongs to the replacement; suppressed glyphs have no text to restyle.
/// style belongs to the replacement; suppressed glyphs have no text to restyle. The stroke
/// goes over the next glyph of the span filled in `font` at `at`, not stroked yet
/// ([`stroke_filled_at`](Self::stroke_filled_at)).
pub fn stroke_actual(&mut self, font: u128, at: Placement, stroke: TypeStroke, overprint: bool) -> bool {
self.flush_stroke();
let key = (font, at.origin.x.to_bits(), at.origin.y.to_bits());
let Some(run) = self.actual_fills.remove(&key) else { return false };
if let Some((look, ..)) = run.and_then(|i| self.runs.get_mut(i)) {
(look.stroke, look.overprint_stroke) = (Some(stroke), overprint);
}
true
let Some(index) = self.next_filled(0, font, at, 1.0, "", true) else { return false };
self.stroke_filled_at(index, stroke, overprint)
}
/// Has the baseline turned (more than about 3° from the first glyph to the last)?
@@ -625,21 +676,35 @@ impl TextLine {
// A stroke at another opacity than the fill's (`CA` and `ca` differ), or over a
// translucent fill, is type of its own.
let opaque = opacity >= 0.999 && self.opacity >= 0.999;
let rest = if opaque { self.filled.get(self.stroked..) } else { None };
let found = rest.and_then(|rest| {
rest.iter().position(|g| {
g.font == font
&& g.at.same_as(&at)
&& self.runs.get(g.run).and_then(|(.., t)| t.get(g.start..g.start.saturating_add(g.len))) == Some(text)
})
});
let Some(index) = found.map(|i| self.stroked.saturating_add(i)) else {
let Some(index) = self.next_filled(0, font, at, opacity, text, false) else {
// Stroked text of its own (stroke rendering): no later stroke goes back over the
// glyphs filled before it, so no stroke looks through them again.
self.stroked = self.filled.len();
// Nor does a translucent stroke join the glyph just filled.
return opaque && self.stroke_last(font, at, text, stroke, overprint);
};
self.stroke_filled_at(index, stroke, overprint)
}
/// A stroke over the glyph filled at `index` in [`filled`](Self::filled), not stroked yet
/// ([`next_filled`](Self::next_filled), [`last_filled`](Self::last_filled)): that glyph is
/// stroked as [`stroke_filled`](Self::stroke_filled) strokes the glyph it finds, and no later
/// stroke goes over the glyphs filled before it. `false`: there is no such glyph.
/// A glyph of an ActualText span restyles its replacement's run at once, if it holds it.
pub fn stroke_filled_at(&mut self, index: usize, stroke: TypeStroke, overprint: bool) -> bool {
if index < self.stroked || index >= self.filled.len() {
return false;
}
if let Some(g) = self.filled.get(index).copied()
&& let Some(owner) = g.actual
{
self.flush_stroke();
if let Some((look, ..)) = self.runs.get_mut(g.run).filter(|_| owner) {
(look.stroke, look.overprint_stroke) = (Some(stroke), overprint);
}
self.stroked = index.saturating_add(1);
return true;
}
let continues = self
.pending
.as_ref()
@@ -661,6 +726,68 @@ impl TextLine {
true
}
/// The first glyph from index `from` of [`filled`](Self::filled) on, not stroked yet, that a
/// stroke over glyph `text` drawn at `at` in `font` at `opacity` may be drawn over
/// ([`fills_at`](Self::fills_at)). `None` for a translucent fill or stroke.
pub fn next_filled(&self, from: usize, font: u128, at: Placement, opacity: f32, text: &str, actual: bool) -> Option<usize> {
let from = from.max(self.stroked);
let i = self.filled.get(from..)?.iter().position(|g| self.fills(g, font, at, opacity, text, actual))?;
Some(from.saturating_add(i))
}
/// The last glyph before index `before` of [`filled`](Self::filled), not stroked yet, that a
/// stroke over glyph `text` drawn at `at` in `font` at `opacity` may be drawn over
/// ([`fills_at`](Self::fills_at)).
pub fn last_filled(&self, before: usize, font: u128, at: Placement, opacity: f32, text: &str, actual: bool) -> Option<usize> {
let rest = self.filled.get(self.stroked..before.min(self.filled.len()))?;
let i = rest.iter().rposition(|g| self.fills(g, font, at, opacity, text, actual))?;
Some(self.stroked.saturating_add(i))
}
/// Whether the glyph filled at `index` in [`filled`](Self::filled), not stroked yet, is one a
/// stroke over glyph `text` drawn at `at` in `font` at `opacity` may be drawn over: opaque,
/// in the same font, with the same placement and text. With `actual`, a stroke over a glyph
/// of an ActualText span instead: a glyph of the span filled in the same font at the same
/// origin, at any opacity ([`stroke_actual`](Self::stroke_actual)): the span's replacement
/// text goes with the glyph filled first, so a translucent stroke kept apart from its fill
/// would be type with no text, and come in as nothing.
pub fn fills_at(&self, index: usize, font: u128, at: Placement, opacity: f32, text: &str, actual: bool) -> bool {
index >= self.stroked && self.filled.get(index).is_some_and(|g| self.fills(g, font, at, opacity, text, actual))
}
/// How many glyphs the line filled for a stroke drawn over them later, stroked or not
/// ([`filled`](Self::filled)).
pub fn filled_len(&self) -> usize {
self.filled.len()
}
/// [`fills_at`](Self::fills_at) for glyph `g`.
fn fills(&self, g: &Filled, font: u128, at: Placement, opacity: f32, text: &str, actual: bool) -> bool {
let (fill, opaque) = ((g.font, g.at, g.actual.is_some(), self.glyph_text(g)), self.opacity >= 0.999);
may_stroke(fill, opaque, font, at, opacity, text, actual)
}
/// The text of filled glyph `g` in the line's runs.
fn glyph_text(&self, g: &Filled) -> Option<&str> {
self.runs.get(g.run).and_then(|(.., t)| t.get(g.start..g.start.saturating_add(g.len)))
}
/// Whether a stroke drawn later may still be drawn over a glyph of the line (fill and stroke
/// rendering): an opaque glyph filled and not stroked yet, or a filled glyph of an
/// ActualText span ([`stroke_actual`](Self::stroke_actual)).
pub fn awaits_stroke(&self) -> bool {
self.filled.get(self.stroked..).is_some_and(|rest| rest.iter().any(|g| g.actual.is_some() || self.opacity >= 0.999))
}
/// No stroke drawn from now on goes over a glyph the line filled so far: a stroke pass does
/// not go back past a stroke of its own (one over no glyph filled) or the start or end of an
/// ActualText span ([`stroke_filled`](Self::stroke_filled)). Nor does one restyle the glyph
/// drawn last ([`stroke_last`](Self::stroke_last)).
pub fn end_fills(&mut self) {
self.stroked = self.filled.len();
self.last_closed = true;
}
/// Restyle the glyphs gathered for a stroke ([`stroke_filled`](Self::stroke_filled)): their
/// text becomes a run of its own with the stroke, unless the run is stroked so already, and the
/// text before and after it in the run keeps its stroke. Text that comes right after a run
@@ -729,9 +856,6 @@ impl TextLine {
for g in self.filled.iter_mut().skip(from) {
(g.run, g.start) = moved(g.run, g.start);
}
for i in self.actual_fills.values_mut().flatten() {
*i = moved(*i, 0).0;
}
if last {
self.last_start = moved(run, self.last_start).1;
}
@@ -744,7 +868,14 @@ impl TextLine {
/// ([`Look::takes`]): then the glyph's text becomes a run of its own with this stroke, and
/// the glyphs before it stay unstroked (#7741). The line's text is the same either way, so
/// the characters' slots, gaps and authored flags, kept along the whole line, still line up.
///
/// Not a glyph drawn before a boundary of stroke passes ([`end_fills`](Self::end_fills)):
/// a stroke after the end of an ActualText span would otherwise stroke the span's replacement
/// text, and one after its start a glyph filled before the span (#8543).
fn stroke_last(&mut self, font: u128, at: Placement, glyph: &str, stroke: TypeStroke, overprint: bool) -> bool {
if self.last_closed {
return false;
}
self.flush_stroke();
let start = self.last_start;
let last_at = self.last_at;
+60 -13
View File
@@ -7,7 +7,7 @@ use std::sync::Arc;
use vectorcraft_color::cms::{self, Cms, Model, ProfileKind};
use vectorcraft_color::swatch::REGISTRATION;
use vectorcraft_color::{BlendMode, Color, GradientKind, Paint};
use vectorcraft_color::{BlendMode, Color, GradientKind, GradientStop, Paint};
use vectorcraft_doc::inks::{Link, StopPlates, inks, plates, spot_color, stop_inks, visit_node_colors};
use vectorcraft_doc::overprint::{darken_overprints, is_black_ink, is_white};
use vectorcraft_doc::{AppearanceItem, ColorMode, Document, ImageBlob, Node, NodeKind};
@@ -175,33 +175,74 @@ impl<'a> Separator<'a> {
/// carry counts as none. A link to a swatch the document lacks separates as the color's own
/// values, so such a black counts as unlinked.
fn no_ink(&self, plate: &str, p: &Paint) -> bool {
let process = |swatch: Option<&str>| swatch.is_none_or(|n| n != REGISTRATION && self.doc.swatch(n).is_none_or(|w| !w.spot));
let none = |c: &Color, process: bool, ink: f32| ink <= 0.0 || (self.postscript && process && ink <= 0.005 && is_black_ink(c, 1.0, false));
match p {
Paint::Solid { color, swatch, tint } => {
none(color, process(swatch.as_deref()), self.ink(plate, color, swatch.as_deref().map(|s| (s, *tint))))
self.none(color, self.process(swatch.as_deref()), self.ink(plate, color, swatch.as_deref().map(|s| (s, *tint))))
}
Paint::Gradient(g) => match g.freeform.as_ref().filter(|f| g.gradient.kind == GradientKind::Freeform && !f.points.is_empty()) {
Some(f) => f.points.iter().all(|pt| none(&pt.color, true, self.ink(plate, &pt.color, None))),
None => {
!g.gradient.stops.is_empty()
&& g.gradient.stops.iter().all(|s| {
let ink = self.stop_ink(plate, &s.color, s.swatch.as_deref().map(|n| (n, s.tint)), s.plates);
none(&s.color, s.plates.is_none() && process(s.swatch.as_deref()), ink)
})
}
Some(f) => f.points.iter().all(|pt| self.point_none(plate, &pt.color)),
None => !g.gradient.stops.is_empty() && g.gradient.stops.iter().all(|s| self.stop_none(plate, s)),
},
_ => false,
}
}
/// Whether a color linked to swatch `swatch` separates as process inks: no link, or a link
/// to a process swatch or to one the document lacks, other than Registration.
fn process(&self, swatch: Option<&str>) -> bool {
swatch.is_none_or(|n| n != REGISTRATION && self.doc.swatch(n).is_none_or(|w| !w.spot))
}
/// Whether `ink` of color `c` (separating as process inks when `process` is true) counts as
/// none, as [`Self::no_ink`] says.
fn none(&self, c: &Color, process: bool, ink: f32) -> bool {
ink <= 0.0 || (self.postscript && process && ink <= 0.005 && is_black_ink(c, 1.0, false))
}
/// Whether gradient stop `s` puts none of ink `plate` down, as [`Self::no_ink`] says.
fn stop_none(&self, plate: &str, s: &GradientStop) -> bool {
let ink = self.stop_ink(plate, &s.color, s.swatch.as_deref().map(|n| (n, s.tint)), s.plates);
self.none(&s.color, s.plates.is_none() && self.process(s.swatch.as_deref()), ink)
}
/// Whether a freeform gradient's point of color `c` puts none of ink `plate` down, as
/// [`Self::no_ink`] says.
fn point_none(&self, plate: &str, c: &Color) -> bool {
self.none(c, true, self.ink(plate, c, None))
}
/// On a PostScript plate, make paper white the stops and points of overprinting gradient `p`
/// that put none of ink `plate` down while others do ([`Self::no_ink`]'s rule for each): the
/// writer leaves the plate below as it is where the gradient is paper white.
fn clear_inkless_stops(&self, plate: &str, p: &mut Paint) {
let Paint::Gradient(g) = p else { return };
if !self.postscript {
return;
}
let paper = Color::Gray { k: 0.0 };
match g.freeform.as_mut().filter(|f| g.gradient.kind == GradientKind::Freeform && !f.points.is_empty()) {
Some(f) => {
for pt in f.points.iter_mut().filter(|pt| self.point_none(plate, &pt.color)) {
pt.color = paper;
}
}
None => {
for s in g.gradient.stops.iter_mut().filter(|s| self.stop_none(plate, s)) {
*s = GradientStop { color: paper, swatch: None, tint: 1.0, plates: None, ..s.clone() };
}
}
}
}
/// Overprinting fills and strokes of `a`'s subtree with a Normal blending mode, and
/// overprinting character fills and strokes, that put none of ink `plate` down leave its plate
/// as it is: they are drawn as nothing on it (white ones with `discard_white` aside, which
/// knock out). A writer without blending modes (PostScript) then keeps the ink below them,
/// where it would draw their Darken as a knockout. One that puts any ink down is drawn, and on
/// a PostScript plate its ink replaces the ink below, as a nonzero component of an overprinting
/// color replaces the backdrop's with overprint mode 1 (ISO 32000-1, 11.7.4.2).
/// color replaces the backdrop's with overprint mode 1 (ISO 32000-1, 11.7.4.2). On a
/// PostScript plate, the stops and points of such a gradient that put none of the ink down
/// become paper white ([`Self::clear_inkless_stops`]), which the writer leaves out there.
fn clear_inkless_overprints(&self, plate: &str, a: &mut Arc<Node>, discard_white: bool) {
let inkless = |overprint: bool, p: &Paint| overprint && !p.is_none() && !(discard_white && is_white(p)) && self.no_ink(plate, p);
let n = Arc::make_mut(a);
@@ -212,15 +253,21 @@ impl<'a> Separator<'a> {
};
if normal && inkless(it.overprint(), it.paint()) {
*it.paint_mut() = Paint::None;
} else if normal && it.overprint() {
self.clear_inkless_stops(plate, it.paint_mut());
}
}
if let NodeKind::Text(t) = &mut n.kind {
for r in &mut t.runs {
if inkless(r.style.overprint_fill, &r.style.fill) {
r.style.fill = Paint::None;
} else if r.style.overprint_fill {
self.clear_inkless_stops(plate, &mut r.style.fill);
}
if inkless(r.style.overprint_stroke, &r.style.stroke) {
r.style.stroke = Paint::None;
} else if r.style.overprint_stroke {
self.clear_inkless_stops(plate, &mut r.style.stroke);
}
}
}
+36
View File
@@ -999,6 +999,42 @@ fn overprinting_paints_keep_their_faint_ink_on_postscript_plates() {
}
}
#[test]
fn a_near_black_stop_of_an_overprinting_gradient_puts_no_cyan_on_postscript_plates() {
// 0.4% cyan beside 100% K counts as black on a PostScript plate stop by stop, as a solid fill
// of it does: the cyan plate draws that stop of an overprinting gradient as paper white. A
// PDF plate and a gradient that does not overprint keep the 0.4%.
let stops = vec![GradientStop::new(0.0, Color::cmyk(0.004, 0.0, 0.0, 1.0)), GradientStop::new(1.0, Color::cmyk(0.5, 0.0, 0.0, 0.0))];
let fade = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
let square = |x: f64, overprint: bool| {
let r = shapes::rectangle(Rect::new(x, 15.0, x + 20.0, 35.0));
let mut n = Node::path(vectorcraft_doc::NodeId(0), r, Appearance::basic(fade.clone(), Paint::None, 0.0));
if let Some(f) = n.appearance.fill_mut() {
f.overprint = overprint;
}
n
};
let d = over_cyan(vec![square(10.0, true), square(40.0, false)]);
// The cyan plate's stops of each gradient, in thousandths of the ink.
let stops = |postscript: bool| {
let opts = PrintOptions { settings: settings(json!({"output": {"mode": "separations"}})), postscript, ..Default::default() };
let p = plan(&d, &opts).unwrap();
let mut all = vec![];
p.plates[0].walk(|n| {
if let Some(Paint::Gradient(g)) = n.appearance.fill().map(|f| &f.paint) {
let gray = |s: &GradientStop| match s.color {
Color::Gray { k } if s.swatch.is_none() => (k * 1000.0).round(),
c => panic!("{c:?}"),
};
all.push(g.gradient.stops.iter().map(gray).collect::<Vec<_>>());
}
});
all
};
assert_eq!(stops(true), [[0.0, 500.0], [4.0, 500.0]], "PostScript: the overprinting gradient, the other");
assert_eq!(stops(false), [[4.0, 500.0], [4.0, 500.0]], "PDF");
}
#[test]
fn overprinting_type_leaves_the_inks_below_on_separations() {
let style = vectorcraft_doc::CharStyle { fill: Paint::solid(Color::cmyk(0.0, 0.0, 0.0, 1.0)), ..Default::default() };
+222
View File
@@ -346,3 +346,225 @@ fn glyphs_filled_and_stroked_one_by_one_stay_one_run() {
assert_eq!(type_runs(content), [vec![("ABC".to_string(), true, true)]], "{content}");
}
}
/// Fill and stroke rendering of a `TJ` whose kerning starts a new line part way through: the
/// reader fills every glyph of the operator before it strokes them, and each part comes in as
/// type filled and stroked, in the order drawn, not as each part filled and then each part
/// stroked over it (#8543). So too a `TJ` that jumps back to start a line before it and one whose
/// kerning starts two new lines. In a span with replacement text (`ActualText`) it stays one type
/// object, on the first glyph's line and in its style, filled and stroked; small kerning keeps
/// one line as before.
#[test]
fn a_tj_whose_kerning_starts_a_new_line_is_filled_and_stroked() {
// Each type object as its text, and whether all of it is filled and all of it stroked.
let objects = |content: &str| -> Vec<(String, bool, bool)> {
type_runs(content)
.into_iter()
.map(|runs| (runs.iter().map(|r| r.0.as_str()).collect(), runs.iter().all(|r| r.1), runs.iter().all(|r| r.2)))
.collect()
};
let both = |text: &str| (text.to_string(), true, true);
for mode in ["2", "6"] {
let cases = [
("/F1 48 Tf 20 80 Td [(AB) -3500 (CD)] TJ", vec![both("AB"), both("CD")]),
("/F1 24 Tf 20 80 Td [(AB) -3500 (CD) -3500 (EF)] TJ", vec![both("AB"), both("CD"), both("EF")]),
("/F1 24 Tf 200 80 Td [(AB) 6000 (CD)] TJ", vec![both("AB"), both("CD")]),
("/F1 48 Tf 20 80 Td [(AB) -100 (CD)] TJ", vec![both("ABCD")]),
// In a span with replacement text, which places all of its text with the first glyph.
("/F1 48 Tf 20 80 Td /Span << /ActualText (ABCD) >> BDC [(AB) -3500 (CD)] TJ EMC", vec![both("ABCD")]),
];
for (show, want) in cases {
let content = format!("BT {mode} Tr {show} 0 Tr ET");
assert_eq!(objects(&content), want, "{content}: {:?}", type_runs(&content));
}
}
}
/// Stroke rendering (modes 1 and 5) of a `TJ` whose kerning starts a new line stays stroke only,
/// one type object per line (#8543).
#[test]
fn a_stroked_tj_whose_kerning_starts_a_new_line_stays_stroke_only() {
for mode in ["1", "5"] {
let content = format!("BT {mode} Tr /F1 48 Tf 20 80 Td [(AB) -3500 (CD)] TJ 0 Tr ET");
let want = [vec![("AB".to_string(), false, true)], vec![("CD".to_string(), false, true)]];
assert_eq!(type_runs(&content), want, "{content}");
}
}
/// Translucent type filled and stroked by a `TJ` whose kerning starts a new line stays a filled
/// object and a stroked one for each part, in the order the file draws them (#8015, #8543).
#[test]
fn a_translucent_tj_whose_kerning_starts_a_new_line_stays_fill_and_stroke_apart() {
use vectorcraft_testkit::pdf::{PdfPage, pdf};
let resources = "/Font << /F1 << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> >> /ExtGState << /G << /ca 0.5 /CA 0.5 >> >>";
let content = "/G gs 0 0 0 RG 1 1 0.8 rg 3 w BT 2 Tr /F1 48 Tf 20 80 Td [(AB) -3500 (CD)] TJ 0 Tr ET";
let bytes = pdf(&[PdfPage { resources: resources.into(), ..PdfPage::new(300.0, 200.0, content) }], None);
let d = import(&bytes).unwrap();
let mut types = vec![];
d.walk(|n| {
if let NodeKind::Text(t) = &n.kind {
let st = t.first_style();
types.push((t.plain_text(), n.opacity < 1.0, !st.fill.is_none(), !st.stroke.is_none()));
}
});
let part = |text: &str, fill: bool| (text.to_string(), true, fill, !fill);
assert_eq!(types, [part("AB", true), part("CD", true), part("AB", false), part("CD", false)], "{content}");
}
/// Fill and stroke rendering of a `TJ` whose kerning goes back to draw a glyph again where it
/// drew one before, on a line of its own: the reader strokes the glyphs in the order it filled
/// them, so each copy is filled and stroked, whether the copy drawn last ends the operator (the
/// open line) or a line after it does (a finished one), and however often it comes back
/// (#8543). A glyph filled and stroked by an operator of its own where one filled before stands
/// still strokes only the one filled last (#8015).
#[test]
fn a_tj_that_draws_a_glyph_again_where_it_drew_one_strokes_each_copy() {
let both = |text: &str| vec![(text.to_string(), true, true)];
// Helvetica at 48 points: A and B are 667 units wide, so 4834 back after B (3500 on from A)
// draws A again where the first A stands.
for mode in ["2", "6"] {
let cases = [
("[(A) -3500 (B) 4834 (A)] TJ", vec![both("A"), both("B"), both("A")]),
("[(A) -3500 (B) 4834 (A) -6000 (C)] TJ", vec![both("A"), both("B"), both("A"), both("C")]),
("[(A) -3500 (B) 4834 (A) -3500 (B)] TJ", vec![both("A"), both("B"), both("A"), both("B")]),
("[(A) -3500 (B) 4834 (A) -3500 (B) 4834 (A)] TJ", vec![both("A"), both("B"), both("A"), both("B"), both("A")]),
];
for (show, want) in cases {
let content = format!("BT {mode} Tr /F1 48 Tf 20 80 Td {show} 0 Tr ET");
assert_eq!(type_runs(&content), want, "{content}");
}
}
let content = "BT 0 Tr /F1 48 Tf 20 80 Td [(A) -3500 (B) 4834] TJ 2 Tr (A) Tj 0 Tr ET";
let want = [vec![("A".to_string(), true, false)], vec![("B".to_string(), true, false)], both("A")];
assert_eq!(type_runs(content), want, "{content}");
}
/// A stroke pass longer than the importer holds at once ([`MAX_HELD`] strokes) is matched to its
/// own operator's glyphs, in the order filled: an `A` filled by an operator of its own, then `A`
/// and 4,096 `B`s filled and stroked from the same place, strokes the second `A`, not the first
/// (#8543).
#[test]
fn a_long_stroke_pass_strokes_its_own_glyphs_not_one_filled_before() {
let bs = "B".repeat(4096);
let content = format!("BT /F1 2 Tf 1 0 0 1 20 80 Tm 0 Tr (A) Tj 1 0 0 1 20 80 Tm 2 Tr (A{bs}) Tj 0 Tr ET");
let looks: Vec<Vec<(String, bool, bool)>> = type_runs(&content);
let want = [vec![("A".to_string(), true, false)], vec![(format!("A{bs}"), true, true)]];
assert!(looks == want, "{:?}", looks.iter().map(|t| t.iter().map(|r| (r.0.len(), r.1, r.2)).collect::<Vec<_>>()).collect::<Vec<_>>());
}
/// Stroked type of its own (a stroke over no glyph filled) ends the stroke pass of the glyphs
/// filled before it: an `A` filled, a `B` filled on a line of its own, a `C` stroked after the
/// `B`, then a stroke over the `A` is type of its own, drawn last, not a stroke joined to the
/// `A` drawn under the `B` and `C` (#8543).
#[test]
fn a_stroke_after_stroked_type_of_its_own_does_not_join_a_glyph_filled_before() {
let content = "BT /F1 48 Tf 1 0 0 1 20 80 Tm 0 Tr (A) Tj 1 0 0 1 20 140 Tm (B) Tj 1 Tr (C) Tj 1 0 0 1 20 80 Tm (A) Tj 0 Tr ET";
let run = |text: &str, fill: bool, stroke: bool| (text.to_string(), fill, stroke);
let want = [vec![run("A", true, false)], vec![run("B", true, false), run("C", false, true)], vec![run("A", false, true)]];
assert_eq!(type_runs(content), want, "{content}");
}
/// A stroke in an ActualText span goes over a glyph that span filled, not one an earlier span
/// filled at the same place: each span's replacement text comes in (#8543).
#[test]
fn a_stroke_in_an_actual_text_span_does_not_take_an_earlier_spans_glyph() {
let content = "BT /F1 48 Tf 0 Tr /Span << /ActualText (First) >> BDC 1 0 0 1 20 80 Tm (A) Tj EMC 1 0 0 1 20 140 Tm (B) Tj \
/Span << /ActualText (Second) >> BDC 1 Tr 1 0 0 1 20 80 Tm (A) Tj EMC 0 Tr ET";
let run = |text: &str, fill: bool, stroke: bool| vec![(text.to_string(), fill, stroke)];
assert_eq!(type_runs(content), [run("First", true, false), run("B", true, false), run("Second", false, true)], "{content}");
}
/// Fill and stroke rendering of a `TJ` that draws a glyph again where it drew one, in an
/// ActualText span: the strokes go over the glyphs in the order filled, so the replacement text,
/// on the first glyph's line and in its style, is filled and stroked, not left to the copy drawn
/// last, which shows no text (#8543).
#[test]
fn a_tj_that_draws_a_glyph_again_in_an_actual_text_span_strokes_the_replacement() {
for mode in ["2", "6"] {
for show in ["[(A) 667 (A)] TJ", "[(A) -500 (B) 1834 (A)] TJ", "[(A) -3500 (B) 4834 (A)] TJ"] {
let content = format!("BT {mode} Tr /F1 48 Tf 20 80 Td /Span << /ActualText (ABA) >> BDC {show} EMC 0 Tr ET");
assert_eq!(type_runs(&content), [vec![("ABA".to_string(), true, true)]], "{content}");
}
}
}
/// The lines of type one operator's fill pass finishes are kept for its stroke pass up to 64 at
/// a time: a `TJ` whose kerning starts 65 lines comes in as 65 type objects filled and stroked,
/// and one that starts 66 as a filled object and a stroked one for each part, the fills first,
/// as the file draws them (#8543).
#[test]
fn a_tj_over_more_lines_than_are_kept_comes_in_as_fill_and_stroke_apart() {
let content = |n: usize| format!("BT 2 Tr /F1 4 Tf 20 80 Td [{}] TJ 0 Tr ET", vec!["(A)"; n].join(" -3500 "));
let both = vec![("A".to_string(), true, true)];
assert_eq!(type_runs(&content(65)), vec![both; 65]);
let (fill, stroke) = (vec![("A".to_string(), true, false)], vec![("A".to_string(), false, true)]);
let want: Vec<_> = std::iter::repeat_n(fill, 66).chain(std::iter::repeat_n(stroke, 66)).collect();
assert_eq!(type_runs(&content(66)), want);
}
/// A `TJ` over more lines than are kept whose last part draws its first glyph again at the first
/// glyph's origin still comes in as a filled object and a stroked one for each part: the stroke
/// over the first glyph, whose line was finished, doesn't take the last part's fill (#8543).
#[test]
fn a_tj_over_more_lines_than_are_kept_that_ends_where_it_began_stays_fill_and_stroke_apart() {
// Helvetica's A is 667 units wide: 65 As and 64 kerns of 3,500 back to the first A's origin.
let parts = vec!["(A)"; 65].join(" -3500 ");
let content = format!("BT 2 Tr /F1 4 Tf 20 80 Td [{parts} 267355 (A)] TJ 0 Tr ET");
let (fill, stroke) = (vec![("A".to_string(), true, false)], vec![("A".to_string(), false, true)]);
let want: Vec<_> = std::iter::repeat_n(fill, 66).chain(std::iter::repeat_n(stroke, 66)).collect();
assert_eq!(type_runs(&content), want);
}
/// Type filled and stroked right after a `TJ` over more lines than are kept is filled and
/// stroked as before, whether the `TJ` was filled and stroked or filled only (#8543).
#[test]
fn type_after_a_tj_over_more_lines_than_are_kept_is_filled_and_stroked() {
let parts = vec!["(A)"; 66].join(" -3500 ");
for mode in ["2", "0"] {
let content = format!("BT /F1 4 Tf 20 80 Td {mode} Tr [{parts}] TJ 2 Tr /F1 48 Tf 1 0 0 1 40 150 Tm (B) Tj 0 Tr ET");
let types = type_runs(&content);
assert_eq!(types.len(), if mode == "2" { 133 } else { 67 }, "{content}");
assert_eq!(types.last(), Some(&vec![("B".to_string(), true, true)]), "{content}");
}
}
/// The start and end of an ActualText span end the stroke pass of the glyphs filled before them,
/// for the stroke over the glyph filled last too: a stroke after the span over the glyph its
/// replacement text came with, or over a glyph filled before an empty span, is type of its own,
/// and the glyph keeps its fill only (#8543).
#[test]
fn a_stroke_after_an_actual_text_span_does_not_take_a_glyph_filled_before_it() {
let run = |text: &str, fill: bool, stroke: bool| vec![(text.to_string(), fill, stroke)];
let cases = [
"/Span << /ActualText (A) >> BDC 1 0 0 1 20 80 Tm (A) Tj EMC 1 Tr 1 0 0 1 20 80 Tm (A) Tj",
"1 0 0 1 20 80 Tm (A) Tj /Span << /ActualText (B) >> BDC EMC 1 Tr 1 0 0 1 20 80 Tm (A) Tj",
];
for show in cases {
let content = format!("BT /F1 48 Tf 0 Tr {show} 0 Tr ET");
assert_eq!(type_runs(&content), [run("A", true, false), run("A", false, true)], "{content}");
}
}
/// A glyph stroked twice where it was drawn, by stroke rendering or by fill and stroke rendering
/// then stroke rendering, is one type object, as before: a stroke over the glyph drawn last
/// restyles it when nothing ended its stroke pass (#7741, #8015).
#[test]
fn a_glyph_stroked_again_where_it_was_drawn_stays_one_type_object() {
for (show, fill) in [("1 Tr (A) Tj", false), ("2 Tr (A) Tj", true)] {
let content = format!("BT /F1 48 Tf {show} 1 Tr 1 0 0 1 20 80 Tm (A) Tj 0 Tr ET").replace("Tf ", "Tf 1 0 0 1 20 80 Tm ");
assert_eq!(type_runs(&content), [vec![("A".to_string(), fill, true)]], "{content}");
}
}
/// A stroke pass longer than the importer holds at once ([`MAX_HELD`] strokes) goes over its own
/// operator's glyphs, filled right before it, also when an operator before it filled the same
/// glyphs at the same places: `A` and 4,095 `B`s filled, then `A` and 4,096 `B`s filled and
/// stroked from the same place strokes the second operator's glyphs, not the first one's (#8543).
#[test]
fn a_long_stroke_pass_does_not_take_the_same_glyphs_filled_by_an_operator_before() {
let (before, now) = ("B".repeat(4095), "B".repeat(4096));
let content = format!("BT /F1 2 Tf 1 0 0 1 20 80 Tm 0 Tr (A{before}) Tj 1 0 0 1 20 80 Tm 2 Tr (A{now}) Tj 0 Tr ET");
let looks: Vec<Vec<(String, bool, bool)>> = type_runs(&content);
let want = [vec![(format!("A{before}"), true, false)], vec![(format!("A{now}"), true, true)]];
assert!(looks == want, "{:?}", looks.iter().map(|t| t.iter().map(|r| (r.0.len(), r.1, r.2)).collect::<Vec<_>>()).collect::<Vec<_>>());
}
+3
View File
@@ -64,10 +64,13 @@ use crate::{Frame, Renderer, blend_mode, fill_rule, paint};
mod bounds;
mod entries;
mod pixels;
mod placement;
mod predicates;
mod raster;
mod renderer;
pub use placement::pinned_appearance_for_geometry_edit;
#[cfg(test)]
pub(crate) use bounds::visual_bounds;
pub(crate) use bounds::{
+94
View File
@@ -0,0 +1,94 @@
//! Stored gradient fits for geometry edits on the renderer's ordinary shape/container paths.
use vectorcraft_color::Paint;
use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, Node, NodeKind};
use vectorcraft_effects::{self as effects, GeomContext};
use vectorcraft_geom::{BezPath, Rect, Shape};
use super::bounds::{apply_carrying, effected_path_carrying, item_effects, node_bezpath};
use super::predicates::has_non_container_art_fx;
use super::renderer::carried;
/// Store the current renderer fit of gradients that can be represented by the existing appearance.
///
/// Alternate materialized art, visible plug-ins, Rasterize and path-coordinate stroke gradients
/// keep their existing fit behavior. An unsupported or non-roundtripping carry also leaves its row
/// unchanged; this neither flattens art nor changes persisted effects. `None` makes no change.
pub fn pinned_appearance_for_geometry_edit(doc: &Document, n: &Node) -> Option<Appearance> {
if !n.appearance.has_unplaced_gradient() || unsupported(n) || has_non_container_art_fx(n) {
return None;
}
// Enclosing geometry effects change the fit outside this node-local pass.
// Without that context, leave the paint fitted rather than storing a false frame.
if doc.ancestry(n.id)?.into_iter().filter(|&id| id != n.id).any(|id| {
doc.node(id).is_some_and(|ancestor| {
matches!(ancestor.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) && effects::has_geometry(&ancestor.appearance.effects)
})
}) {
return None;
}
match &n.kind {
NodeKind::Group { .. } | NodeKind::Layer { .. } => effects::pinned_container_appearance(doc, n),
NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => pinned_shape(doc, n),
_ => None,
}
}
fn rasterizes(fx: &[Effect]) -> bool {
fx.iter().any(|effect| effect.visible && effect.id == effects::RASTERIZE)
}
fn unsupported(n: &Node) -> bool {
effects::has_plugin_effect(n)
|| rasterizes(&n.appearance.effects)
|| n.appearance.items.iter().any(|item| {
item.visible() && (rasterizes(item.effects()) || matches!(item, AppearanceItem::Stroke(stroke) if stroke.path_gradient().is_some()))
})
}
fn unplaced(item: &AppearanceItem) -> bool {
item.visible() && matches!(item.paint(), Paint::Gradient(gradient) if !gradient.is_placed())
}
fn pinned_shape(doc: &Document, n: &Node) -> Option<Appearance> {
let bp = node_bezpath(n)?;
let (geometry, object_carry) = effected_path_carrying(doc, n, &bp);
if geometry.elements().is_empty() {
return None;
}
// Share the renderer's actual temporary object carry and skipped-effect flags.
let temporary = carried(n, &object_carry);
let paints = temporary.as_deref().unwrap_or(n);
let context = GeomContext { doc: Some(doc), ..GeomContext::of(paints) };
let mut appearance = (*n.appearance).clone();
let mut changed = false;
for (index, original) in n.appearance.items.iter().enumerate().filter(|(_, item)| unplaced(item)) {
// `item` must belong to the same temporary appearance borrowed by `context.item`:
// that lookup uses pointer identity to recover the actual row index/seed.
let item = paints.appearance.items.get(index)?;
let (item_geometry, item_carry) = apply_carrying(item_effects(item), &geometry, &context.item(item));
let bounds = item_bounds(item, &geometry, &item_geometry, &item_carry)?;
if let Some(pinned) = effects::pinned_gradient_item(original, bounds, &[&object_carry, &item_carry]) {
*appearance.items.get_mut(index)? = pinned;
changed = true;
}
}
changed.then_some(appearance)
}
/// The same temporary item carry/skipped flags and `ib` choice as `Renderer::paint_items`.
fn item_bounds(item: &AppearanceItem, geometry: &BezPath, item_geometry: &BezPath, carry: &effects::Carry) -> Option<Rect> {
let mut appearance = Appearance { items: vec![item.clone()], ..Default::default() };
if !carry.is_empty() && matches!(item.paint(), Paint::Gradient(_)) {
carry.apply(&mut appearance);
}
let mut item = appearance.items.pop()?;
if carry.skipped() {
carry.hide_skipped(item.effects_mut());
}
Some(if effects::has_geometry(item_effects(&item)) && !item_geometry.elements().is_empty() {
item_geometry.bounding_box()
} else {
geometry.bounding_box()
})
}
+10 -1
View File
@@ -25,11 +25,20 @@ pub(crate) fn has_fx(n: &Node) -> bool {
/// effect copies it with a gradient or changes its fills and strokes ([`effects::has_transform_art`]),
/// or is it a group or layer with an appearance of its own (see [`Renderer::draw_object_fx`])?
pub(crate) fn has_object_fx(n: &Node) -> bool {
object_fx(n, true)
}
/// The alternate-art dispatches other than a group or layer's own container appearance.
pub(super) fn has_non_container_art_fx(n: &Node) -> bool {
object_fx(n, false)
}
fn object_fx(n: &Node, containers: bool) -> bool {
(effects::needs_outline(n) && (visible(&n.appearance.effects) || n.projection().is_some()))
|| effects::has_item_geometry(n)
|| effects::has_instance_row_raster(n)
|| effects::has_transform_art(n)
|| effects::has_container_appearance(n)
|| (containers && effects::has_container_appearance(n))
|| effects::has_crop_marks(n)
|| effects::addons::halftone::has_halftone(n)
|| effects::has_adjustment(n)
+1 -1
View File
@@ -1029,7 +1029,7 @@ impl Renderer {
/// the Transform effects the geometry pass left out hidden ([`effects::Carry::hide_skipped`]), so
/// its raster effects and those of its fills and strokes stay with its art; `None` when it stays
/// as it is.
fn carried(n: &Node, carry: &effects::Carry) -> Option<Arc<Node>> {
pub(super) fn carried(n: &Node, carry: &effects::Carry) -> Option<Arc<Node>> {
let moves = carry.moves(&n.appearance);
(moves || carry.skipped()).then(|| {
let mut m = n.clone();
+1
View File
@@ -43,6 +43,7 @@ use lru::FrameCache;
pub use brush_fx::instance_art;
pub use changed::{Changed, changed, placed_area, view_pixels};
pub use effects::stroke::width_outline;
pub use fx::pinned_appearance_for_geometry_edit;
pub use images::{IMAGE_CACHE_MAX, image_cache_bytes, installed_memory, newly_undecodable, set_image_cache_budget};
pub use live::expand_live;
pub use pattern::render_pattern_swatch;
+2
View File
@@ -9,6 +9,8 @@ description = "VectorCraft text: font database, shaping, layout, glyph outlines"
workspace = true
[dependencies]
# The shared font catalog from craft-libs main (it has the outline, bidi and caret helpers used here).
craft-font-catalog = { git = "https://github.com/storytold/craft-libs", rev = "23acc704933a9a5619a5cd1cddc9bb1fb5a9b2d3", default-features = false }
vectorcraft-geom = { workspace = true }
vectorcraft-doc = { workspace = true }
kurbo = { workspace = true }
+2 -2
View File
@@ -8,7 +8,7 @@ use std::sync::{Arc, Mutex, RwLock};
use kurbo::BezPath;
use skrifa::instance::{Location, LocationRef, Size};
use skrifa::outline::{DrawSettings, OutlinePen};
use skrifa::outline::OutlinePen;
use skrifa::raw::FileRef;
use skrifa::string::StringId;
use skrifa::{GlyphId, MetadataProvider, Tag};
@@ -74,7 +74,7 @@ pub use stylistic_sets::StylisticSet;
use traits::Alias;
#[cfg(test)]
use traits::{FaceKeys, face_names};
pub use traits::{FontClass, FontLikeness, FontMatch, FontTraits};
pub use traits::{FontClass, FontLikeness, FontMatch, FontTraits, GENERIC_FAMILIES, is_generic_family};
#[cfg(test)]
pub(crate) use traits::{alias_lists, face_styles, on_faces_published};
pub use wanted::{WantedFont, WantedFonts};
+19
View File
@@ -53,6 +53,25 @@ impl OutlinePen for FlipPen {
}
}
// Share font decoding while preserving the app's existing y-down geometry and resource budget.
impl craft_font_catalog::GlyphPen for FlipPen {
fn move_to(&mut self, x: f32, y: f32) {
OutlinePen::move_to(self, x, y);
}
fn line_to(&mut self, x: f32, y: f32) {
OutlinePen::line_to(self, x, y);
}
fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
OutlinePen::quad_to(self, x1, y1, x, y);
}
fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
OutlinePen::curve_to(self, x1, y1, x2, y2, x, y);
}
fn close(&mut self) {
OutlinePen::close(self);
}
}
#[cfg(test)]
mod tests {
use super::*;
+105 -11
View File
@@ -10,10 +10,7 @@ use super::names::{norm, norm_chars, script_families};
#[cfg(not(target_arch = "wasm32"))]
use super::scan::{enumerate_faces, font_files};
use super::traits::{Alias, FontMatch, FontTraits, regular_rank};
use super::{
Arc, BezPath, CANONICAL_CACHE_MAX, Color, ColourContent, DrawSettings, FontDb, GlyphId, GlyphImage, MetadataProvider, NEXT_ID, OUTLINE_CACHE_MAX,
Ordering, Size,
};
use super::{Arc, BezPath, CANONICAL_CACHE_MAX, Color, ColourContent, FontDb, GlyphImage, MetadataProvider, NEXT_ID, OUTLINE_CACHE_MAX, Ordering};
/// The most faces [`FontDb::postscript_faces`] gives, and the most families it loads.
const MAX_POSTSCRIPT_FACES: usize = 16;
@@ -368,6 +365,12 @@ impl FontDb {
loaded.or_else(|| self.instance_by_id(id))
}
/// The faces loaded so far (the bundled fonts and the installed ones type has used), in load
/// order. Installed fonts that nothing has asked for yet are not among them.
pub fn loaded_faces(&self) -> Vec<Arc<FontFace>> {
self.read_faces().clone()
}
/// The face of character style `st`: [`Self::face_version`] of its font, instanced at its
/// Variable Font settings ([`Self::instance`]).
pub fn style_face(&self, st: &vectorcraft_doc::CharStyle) -> Option<Arc<FontFace>> {
@@ -654,13 +657,7 @@ impl FontDb {
if let Some(p) = self.outlines.lock().unwrap_or_else(|e| e.into_inner()).get(&key) {
return p.clone();
}
let mut pen = FlipPen(BezPath::new());
if let Some(f) = face.skrifa()
&& let Some(g) = f.outline_glyphs().get(GlyphId::new(gid))
{
let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), face.location()), &mut pen);
}
let p = Arc::new(pen.0);
let p = Arc::new(self.outline_uncached(face, gid));
let mut cache = self.outlines.lock().unwrap_or_else(|e| e.into_inner());
if cache.len() >= OUTLINE_CACHE_MAX {
cache.clear();
@@ -669,6 +666,17 @@ impl FontDb {
p
}
/// [`Self::outline`] without the cache: for reading many glyphs once (Retype's index), which
/// would otherwise push out the outlines the canvas keeps there.
pub fn outline_uncached(&self, face: &FontFace, gid: u32) -> BezPath {
let mut pen = FlipPen(BezPath::new());
if let Ok(font) = craft_font_catalog::FontOutline::from_bytes(face.data(), face.index(), face.variations()) {
// As before, keep the prefix emitted before a malformed glyph reports an error.
let _ = font.draw_to(gid, &mut pen);
}
pen.0
}
/// Glyph `gid`'s colour bitmap (`sbix`, `CBDT`) in `face`, cached per (face, glyph).
pub fn glyph_image(&self, face: &FontFace, gid: u32) -> Option<Arc<GlyphImage>> {
if !face.colour_bitmaps {
@@ -722,3 +730,89 @@ impl FontDb {
content
}
}
#[cfg(test)]
mod shared_outline_tests {
use super::super::glyph_pen::FlipPen;
use super::*;
use skrifa::instance::Size;
use skrifa::outline::DrawSettings;
use skrifa::{GlyphId, MetadataProvider};
#[test]
fn shared_outlines_match_original_pen_for_variable_instances() {
let db = FontDb::with_font_dirs(vec![]);
let Some(bytes) = crate::test_fonts::variable_font() else { return };
assert!(db.add_font(bytes) > 0);
let face = db.face(crate::test_fonts::VARIABLE_FAMILY, "Bold").expect("named instance is registered");
let f = face.skrifa().expect("font parses");
for ch in ['A', 'V', ' ', 'a'] {
let Some(glyph) = f.charmap().map(ch) else { continue };
let mut old = FlipPen(BezPath::new());
if let Some(outline) = f.outline_glyphs().get(GlyphId::new(glyph.to_u32())) {
// Match the prior production behavior, including a partial path on error.
let _ = outline.draw(DrawSettings::unhinted(Size::unscaled(), face.location()), &mut old);
}
assert_eq!(*db.outline(&face, glyph.to_u32()), old.0, "glyph {ch}");
}
}
// Generated CFF keeps the differential tests independent of installed fonts.
fn cff_font(program: &[u8]) -> Vec<u8> {
let mut cff = vec![1, 0, 4, 4, 0, 1, 1, 1, 2, b'X', 0, 1, 1, 1, 7, 29, 0, 0, 0, 25, 17, 0, 0, 0, 0];
cff.extend_from_slice(&[0, 1, 4]);
cff.extend_from_slice(&1u32.to_be_bytes());
cff.extend_from_slice(&((program.len() as u32) + 1).to_be_bytes());
cff.extend_from_slice(program);
let mut builder = write_fonts::FontBuilder::new();
let mut head = vec![0; 54];
head[18..20].copy_from_slice(&1000u16.to_be_bytes());
let mut hhea = vec![0; 36];
hhea[34..36].copy_from_slice(&1u16.to_be_bytes());
for (tag, data) in [(b"head", head), (b"hhea", hhea), (b"hmtx", vec![0, 100, 0, 0]), (b"maxp", vec![0, 0, 0x50, 0, 0, 1]), (b"CFF ", cff)] {
builder.add_raw(write_fonts::types::Tag::new(tag), data);
}
builder.build()
}
#[test]
fn malformed_cff_prefix_matches_original_pen() {
let bytes = cff_font(&[139, 139, 21, 239, 139, 5, 10, 14]);
let gid = 0;
let f = skrifa::FontRef::new(&bytes).unwrap();
let mut old = FlipPen(BezPath::new());
let result = f
.outline_glyphs()
.get(GlyphId::new(gid))
.unwrap()
.draw(DrawSettings::unhinted(Size::unscaled(), skrifa::instance::LocationRef::default()), &mut old);
assert!(result.is_err());
assert!(!old.0.elements().is_empty());
let shared = craft_font_catalog::FontOutline::from_bytes(&bytes, 0, &[]).unwrap();
let mut streamed = FlipPen(BezPath::new());
assert!(shared.draw_to(gid, &mut streamed).is_err());
assert_eq!(streamed.0, old.0);
}
#[test]
fn large_valid_outline_matches_original_pen() {
let mut program = vec![139, 139, 21];
for _ in 0..100_001 {
program.extend_from_slice(&[140, 6]);
}
program.push(14);
let bytes = cff_font(&program);
let f = skrifa::FontRef::new(&bytes).unwrap();
let mut old = FlipPen(BezPath::new());
f.outline_glyphs()
.get(GlyphId::new(0))
.unwrap()
.draw(DrawSettings::unhinted(Size::unscaled(), skrifa::instance::LocationRef::default()), &mut old)
.unwrap();
assert!(old.0.elements().len() > 100_000);
let shared = craft_font_catalog::FontOutline::from_bytes(&bytes, 0, &[]).unwrap();
let mut streamed = FlipPen(BezPath::new());
shared.draw_to(0, &mut streamed).unwrap();
assert_eq!(streamed.0, old.0);
}
}
+23
View File
@@ -433,6 +433,29 @@ impl FontMatch {
}
}
/// The CSS generic font families (CSS Fonts Module Level 4), which SVG and HTML files name in place
/// of a font and no font file provides; compared in any ASCII case ([`is_generic_family`]). The
/// list leaves out `fangsong`, which is also the family name of a Chinese font (FangSong).
pub const GENERIC_FAMILIES: &[&str] = &[
"serif",
"sans-serif",
"monospace",
"cursive",
"fantasy",
"system-ui",
"ui-serif",
"ui-sans-serif",
"ui-monospace",
"ui-rounded",
"math",
"emoji",
];
/// Whether `family` (surrounding spaces ignored) is one of the [`GENERIC_FAMILIES`], in any ASCII case.
pub fn is_generic_family(family: &str) -> bool {
GENERIC_FAMILIES.iter().any(|g| g.eq_ignore_ascii_case(family.trim()))
}
/// A face's (family, style) names.
pub(super) fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {
let family = name(f, &[StringId::TYPOGRAPHIC_FAMILY_NAME, StringId::FAMILY_NAME])?;
+16 -24
View File
@@ -62,30 +62,22 @@ fn continues_cluster(prev: Option<&SGlyph>, g: Option<&SGlyph>) -> bool {
/// ([`upright_extent`]) as a share of `upright`, the length in font units its own width runs down.
/// Empty for a glyph of one character.
fn ligature_carets(text: &str, g: &SGlyph, rtl: bool, upright: Option<f64>) -> Vec<(usize, f64)> {
use unicode_segmentation::UnicodeSegmentation;
let Some(s) = text.get(g.byte..g.byte + g.len).filter(|_| g.len > 1) else { return Vec::new() };
let starts: Vec<usize> = s.grapheme_indices(true).skip(1).map(|(i, _)| g.byte + i).collect();
if starts.is_empty() {
return Vec::new();
}
let parts = starts.len() + 1;
let from_font = if let Some(length) = upright {
let (cell, top) = upright_extent(g);
g.face
.vertical_ligature_carets(g.gid, starts.len(), top, cell)
.filter(|c| c.len() == starts.len() && length > 0.0)
.map(|c| c.into_iter().map(|d| d / length).collect::<Vec<f64>>())
.filter(|c| c.iter().all(|f| *f > 0.0 && *f < 1.0))
} else {
let advance = g.face.advance(g.gid);
g.face
.ligature_carets(g.gid, starts.len())
.filter(|c| c.len() == starts.len() && advance > 0.0)
.map(|c| c.into_iter().map(|x| if rtl { 1.0 - x / advance } else { x / advance }).collect::<Vec<f64>>())
};
let mut at = from_font.unwrap_or_else(|| (1..parts).map(|j| j as f64 / parts as f64).collect());
at.sort_by(f64::total_cmp);
starts.into_iter().zip(at).collect()
craft_font_catalog::ligature_caret_stops(text, g.byte, g.len, |count| {
if let Some(length) = upright {
let (cell, top) = upright_extent(g);
g.face
.vertical_ligature_carets(g.gid, count, top, cell)
.filter(|c| c.len() == count && length > 0.0)
.map(|c| c.into_iter().map(|d| d / length).collect::<Vec<f64>>())
.filter(|c| c.iter().all(|f| *f > 0.0 && *f < 1.0))
} else {
let advance = g.face.advance(g.gid);
g.face
.ligature_carets(g.gid, count)
.filter(|c| c.len() == count && advance > 0.0)
.map(|c| c.into_iter().map(|x| if rtl { 1.0 - x / advance } else { x / advance }).collect::<Vec<f64>>())
}
})
}
/// Does glyph `g`, standing upright in vertical type, take a cell of its own down the column? Every
Loaded 100 of 224 files, more files were not shown because too many files have changed in this diff. Show more