Merge upstream/main into fix/6865-ai-oversized-artboard

This commit is contained in:
makesomethingshit committed 2026-11-13 02:19:20 +09:00
commit 777fb2fa42
239 files changed
+15975 -1321

No files matched your search

Generated
+1
View File
@@ -6326,6 +6326,7 @@ dependencies = [
"craft-window",
"eframe",
"egui",
"futures-lite",
"image",
"log",
"muda",
+3
View File
@@ -107,6 +107,9 @@ wayland-protocols = { version = "0.32", features = ["client", "unstable"] }
# wayland-protocols' `unstable` set) made on the window's own connection. MIT, already in the build
# through winit and rfd.
wayland-backend = { version = "0.3", features = ["client_system"] }
# Waits for the screen color sampler's portal answer and for the portal leaving the bus at the same
# time (src/linux_screen_color/request.rs). Apache-2.0 OR MIT, already in the build through zbus.
futures-lite = "2"
# The save dialog's file type (src/portal_save.rs, #2679): the desktop portal over D-Bus, on the
# systems where rfd shows the portal's dialog. MIT, already in the build through accesskit. Pinned
+7 -3
View File
@@ -1,10 +1,10 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))]
use super::portal_save;
#[cfg(target_os = "linux")]
use super::tablet;
#[cfg(all(windows, not(target_vendor = "win7")))]
use super::windows_stylus;
use super::{ClipboardProbeFactory, FilePick, PickRequest, Services, clipboard, cursor_theme, fileio, printing};
#[cfg(target_os = "linux")]
use super::{linux_screen_color, tablet};
#[cfg(target_os = "macos")]
use super::{mac_save_format, mac_screen_color, mac_tablet};
@@ -354,8 +354,10 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
.is_some_and(|h| matches!(h.as_raw(), RawWindowHandle::Xlib(_) | RawWindowHandle::Xcb(_)));
let (clip, clip_probe) = (parent.clone(), parent.clone());
let (p1, p2, p3, p4, p5) = (parent.clone(), parent.clone(), parent.clone(), parent.clone(), parent);
#[cfg(target_os = "macos")]
#[cfg(any(target_os = "macos", target_os = "linux"))]
let sampled_ui = ui.clone();
#[cfg(target_os = "linux")]
let sampled_parent = p1.clone();
Services {
pick_open: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::Open(pick.clone()), &p1).into_iter().next())),
pick_open_multi: Some(Box::new(move || pick_now(PickRequest::OpenMany, &p2))),
@@ -408,6 +410,8 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
// Sample Color from Screen: the system's color sampler.
#[cfg(target_os = "macos")]
screen_color: Some(mac_screen_color::sampler(sampled_ui)),
#[cfg(target_os = "linux")]
screen_color: Some(linux_screen_color::sampler(sampled_ui, sampled_parent)),
// File → Print: the system's printers and print queue.
print: Some(Box::new(printing::SystemPrint)),
..Default::default()
@@ -0,0 +1,42 @@
//! Linux: Sample Color from Screen (`vectorcraft_ui_egui::screen_color`) through the XDG desktop
//! portal's color sampler ([`portal`]). A thread of its own asks the portal and waits for the
//! person, so the UI keeps drawing; it sends the color to the UI and wakes the window. The dialog's
//! parent is the window, named on that thread as for the portal's save dialog (`portal_save`).
mod portal;
mod request;
/// The portal's color sampler over the window `parent` holds; `ui` is woken when it answers.
pub fn sampler(ui: egui::Context, parent: super::host_services::Parent) -> vectorcraft_ui_egui::screen_color::StartSampler {
Box::new(move || {
let (tx, rx) = std::sync::mpsc::channel();
let (ui, window) = (ui.clone(), parent.clone());
std::thread::Builder::new()
.name("screen-color".into())
.spawn(move || {
// The thread names the window and holds it until the export that names it is dropped.
let (handle, export) = match window.as_deref() {
Some(window) => {
let (handle, export) = super::portal_save::exported_parent(window);
(handle, Some(export))
}
None => (String::new(), None),
};
let picked = portal::connect(zbus::blocking::connection::Builder::session()).and_then(|conn| portal::pick(&conn, &handle));
drop(export);
drop(window);
let answer = picked.map_err(|failure| {
log::warn!("the portal's screen color sampler gave no color: {}", failure.detail());
failure.message().to_string()
});
// The UI may be gone (the app quitting): nothing waits for the color then.
let _ = tx.send(answer);
ui.request_repaint();
})
.map_err(|e| {
log::warn!("could not start the screen color sampler's thread: {e}");
"the screen color sampler failed".to_string()
})?;
Ok(rx)
})
}
@@ -0,0 +1,319 @@
//! The XDG desktop portal's `Screenshot.PickColor`
//! (<https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.portal.Screenshot.html>):
//! the call returns a request path at once, and the request's `Response` signal later carries the
//! color the person picked, as sRGB components from 0 to 1, or a code for a cancel or another end.
use std::collections::HashMap;
use zbus::blocking::{Connection, Proxy};
use zbus::zvariant::{OwnedValue, Value};
/// How long the portal has to return a request path for `PickColor`. VectorCraft's own limit,
/// 25 seconds as libdbus's default for a method call. The portal returns the path before it shows
/// the sampler, so the person's time with the sampler does not count.
const CALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(25);
/// Why no color came back, as the status bar shows it.
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum Failure {
/// No session bus, no portal, or a portal without the Screenshot interface's `PickColor`.
Unavailable(String),
/// The portal did not return a request path in time, or it left the bus before it answered.
NoAnswer(String),
/// The portal ended the request without a color, or its answer can't be read.
Failed(String),
}
impl Failure {
/// The status bar's message (English; the status bar translates it).
pub(super) fn message(&self) -> &'static str {
match self {
Failure::Unavailable(_) => "this system has no screen color sampler",
Failure::NoAnswer(_) => "the screen color sampler did not answer",
Failure::Failed(_) => "the screen color sampler failed",
}
}
/// What went wrong, for the log.
pub(super) fn detail(&self) -> &str {
match self {
Failure::Unavailable(d) | Failure::NoAnswer(d) | Failure::Failed(d) => d,
}
}
}
/// D-Bus errors that mean the session has no portal, or none that answers `PickColor`.
const UNAVAILABLE: &[&str] = &[
"org.freedesktop.DBus.Error.ServiceUnknown",
"org.freedesktop.DBus.Error.NameHasNoOwner",
"org.freedesktop.DBus.Error.UnknownMethod",
"org.freedesktop.DBus.Error.UnknownInterface",
"org.freedesktop.DBus.Error.UnknownObject",
];
/// The connection `builder` makes, with [`CALL_TIMEOUT`] for its method calls.
pub(super) fn connect(builder: zbus::Result<zbus::blocking::connection::Builder<'_>>) -> Result<Connection, Failure> {
builder.and_then(|b| b.method_timeout(CALL_TIMEOUT).build()).map_err(|e| Failure::Unavailable(e.to_string()))
}
/// Shows the portal's color sampler over the window `parent` names and waits for the color, `None`
/// when the person canceled it. `conn`'s method timeout bounds the call; the wait for the person
/// after it has no bound, and ends when the portal answers or leaves the bus.
pub(super) fn pick(conn: &Connection, parent: &str) -> Result<Option<[f32; 3]>, Failure> {
const DESKTOP: &str = "org.freedesktop.portal.Desktop";
let token = super::request::token("vectorcraft_color").map_err(Failure::Failed)?;
// Made before the call: a portal can send its answer before the call returns.
let replies = super::request::Responses::new(conn).map_err(Failure::Failed)?;
let proxy = Proxy::new(conn, DESKTOP, "/org/freedesktop/portal/desktop", "org.freedesktop.portal.Screenshot")
.map_err(|e| Failure::Failed(e.to_string()))?;
let options = HashMap::from([("handle_token", Value::from(token.as_str()))]);
let call = proxy.call_method("PickColor", &(parent, options)).map_err(|e| call_failure(&e))?;
let reply = replies.wait(&call).map_err(Failure::NoAnswer)?;
let (code, results): (u32, HashMap<String, OwnedValue>) = reply.body().deserialize().map_err(|e| Failure::Failed(e.to_string()))?;
answer(code, &results)
}
/// The [`Failure`] for an error the `PickColor` call returned. zbus reports a call that outlives
/// the connection's method timeout as an `InputOutput` error of kind `TimedOut`.
fn call_failure(e: &zbus::Error) -> Failure {
match e {
zbus::Error::MethodError(name, ..) if UNAVAILABLE.contains(&name.as_str()) => Failure::Unavailable(e.to_string()),
zbus::Error::InputOutput(io) if io.kind() == std::io::ErrorKind::TimedOut => Failure::NoAnswer(e.to_string()),
_ => Failure::Failed(e.to_string()),
}
}
/// The color in a `Response` with `code` and `results`: response 0 carries it, 1 is a cancel, and
/// any other code ends the request without one. The components are passed on as given;
/// `screen_color::sampled` clamps them to 0 to 1, as for the other systems' samplers.
fn answer(code: u32, results: &HashMap<String, OwnedValue>) -> Result<Option<[f32; 3]>, Failure> {
match code {
0 => {}
1 => return Ok(None),
_ => return Err(Failure::Failed(format!("the portal ended the request (response {code})"))),
}
let color = results.get("color").ok_or_else(|| Failure::Failed("no color in the portal's answer".into()))?;
// Matched field by field: zvariant's tuple conversion panics on a structure with fewer fields.
match &**color {
Value::Structure(s) => match s.fields() {
[Value::F64(r), Value::F64(g), Value::F64(b)] => Ok(Some([*r, *g, *b].map(|v| v as f32))),
_ => Err(Failure::Failed(format!("the portal's color is not three numbers: {color:?}"))),
},
_ => Err(Failure::Failed(format!("the portal's color is not three numbers: {color:?}"))),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn color(rgb: (f64, f64, f64)) -> HashMap<String, OwnedValue> {
HashMap::from([("color".into(), OwnedValue::try_from(Value::from(rgb)).unwrap())])
}
fn failed<T: std::fmt::Debug>(r: Result<T, Failure>) -> bool {
matches!(r, Err(Failure::Failed(_)))
}
#[test]
fn a_picked_color_keeps_its_srgb_values() {
assert_eq!(answer(0, &color((0.25, 0.5, 0.75))), Ok(Some([0.25, 0.5, 0.75])));
assert_eq!(answer(0, &color((0.0, 1.0, 0.0))), Ok(Some([0.0, 1.0, 0.0])));
// Outside 0 to 1: passed on for `screen_color::sampled` to clamp.
assert_eq!(answer(0, &color((-0.5, 1.5, 1.0))), Ok(Some([-0.5, 1.5, 1.0])));
}
#[test]
fn a_cancel_needs_no_color() {
assert_eq!(answer(1, &HashMap::new()), Ok(None));
assert_eq!(answer(1, &color((0.25, 0.5, 0.75))), Ok(None));
}
#[test]
fn other_response_codes_are_failures() {
for code in [2, 3, u32::MAX] {
assert!(failed(answer(code, &color((0.25, 0.5, 0.75)))), "{code}");
}
}
#[test]
fn a_success_without_a_valid_color_is_a_failure() {
assert!(failed(answer(0, &HashMap::new())));
let wrong = HashMap::from([("color".into(), OwnedValue::from(1_u32))]);
assert!(failed(answer(0, &wrong)));
// Fewer fields, more fields, and fields of another type: an error, not a panic.
for wrong in [Value::from((0.5, 0.5)), Value::from((0.5, 0.5, 0.5, 0.5)), Value::from((1_u32, 0.5, 0.5)), Value::from(vec![0.5, 0.5, 0.5])] {
let wrong = HashMap::from([("color".into(), OwnedValue::try_from(wrong).unwrap())]);
assert!(failed(answer(0, &wrong)));
}
}
#[test]
fn call_errors_say_whether_the_system_has_a_sampler() {
let reply = |name: &str| {
let call = zbus::Message::method_call("/org/freedesktop/portal/desktop", "PickColor").unwrap().build(&()).unwrap();
let error = zbus::Message::error(&call.header(), name).unwrap().build(&("detail",)).unwrap();
zbus::Error::from(error)
};
for name in UNAVAILABLE {
assert!(matches!(call_failure(&reply(name)), Failure::Unavailable(_)), "{name}");
}
assert!(matches!(call_failure(&reply("org.freedesktop.portal.Error.NotAllowed")), Failure::Failed(_)));
let timed_out = zbus::Error::InputOutput(std::sync::Arc::new(std::io::ErrorKind::TimedOut.into()));
assert!(matches!(call_failure(&timed_out), Failure::NoAnswer(_)));
let broken = zbus::Error::InputOutput(std::sync::Arc::new(std::io::ErrorKind::BrokenPipe.into()));
assert!(matches!(call_failure(&broken), Failure::Failed(_)));
let messages = [Failure::Unavailable(String::new()), Failure::NoAnswer(String::new()), Failure::Failed(String::new())].map(|f| f.message());
assert_eq!(
messages,
["this system has no screen color sampler", "the screen color sampler did not answer", "the screen color sampler failed"]
);
assert_eq!(call_failure(&broken).detail(), broken.to_string());
}
/// Every language that translates the sampler's other messages translates these too. The
/// i18n tests of `vectorcraft-ui-egui` do not read this crate's messages.
#[test]
fn the_messages_are_translated_where_the_sampler_is() {
use vectorcraft_ui_egui::i18n::{Lang, message};
const OPEN: &str = "the screen color sampler is already open";
let langs: Vec<Lang> = Lang::all().filter(|&lang| message(lang, OPEN) != OPEN).collect();
assert!(!langs.is_empty(), "no language translates {OPEN:?}");
for lang in langs {
for failure in [Failure::Unavailable(String::new()), Failure::NoAnswer(String::new()), Failure::Failed(String::new())] {
assert_ne!(message(lang, failure.message()), failure.message(), "{}", lang.code());
}
}
}
/// A session bus of its own (`dbus-daemon`), `None` when there is none to run.
fn private_bus() -> Option<(Daemon, String)> {
use std::io::BufRead as _;
let spawning = crate::spawning();
let daemon = std::process::Command::new("dbus-daemon")
.args(["--session", "--nofork", "--print-address=1"])
.stdout(std::process::Stdio::piped())
.spawn();
drop(spawning);
let Ok(daemon) = daemon else {
eprintln!("no dbus-daemon: skipped");
return None;
};
let mut daemon = Daemon(daemon);
let mut address = String::new();
std::io::BufReader::new(daemon.0.stdout.take().unwrap()).read_line(&mut address).unwrap();
Some((daemon, address.trim().to_string()))
}
/// Stops the private bus when the test ends, unwinding included.
struct Daemon(std::process::Child);
impl Drop for Daemon {
fn drop(&mut self) {
let _ = self.0.kill();
let _ = self.0.wait();
}
}
/// The client's connection to the private bus at `address`, made as the sampler makes its own.
fn client(address: &str) -> Connection {
connect(zbus::blocking::connection::Builder::address(address)).unwrap()
}
/// The portal's name, owned on the private bus at `address` before any call, so the bus never
/// starts an installed portal in its place.
fn portal(address: &str) -> Connection {
zbus::blocking::connection::Builder::address(address).unwrap().name("org.freedesktop.portal.Desktop").unwrap().build().unwrap()
}
/// Through a real D-Bus: an answer that comes before the call returns is kept; answers on
/// other request paths or from other connections are ignored; a cancel gives no color; and a
/// portal that leaves the bus while the person picks ends the wait.
#[test]
fn the_answer_is_the_portals_response_on_the_returned_path() {
use zbus::blocking::MessageIterator;
use zbus::zvariant::OwnedObjectPath;
let Some((_daemon, address)) = private_bus() else { return };
let address = address.as_str();
let server = portal(address);
let impostor = zbus::blocking::connection::Builder::address(address).unwrap().build().unwrap();
let incoming = MessageIterator::from(&server);
let worker = std::thread::spawn(move || {
let mut calls = Vec::new();
for msg in incoming {
let msg = msg.unwrap();
let header = msg.header();
if header.message_type() != zbus::message::Type::MethodCall || header.member().map(|m| m.as_str()) != Some("PickColor") {
continue;
}
let (parent, options): (String, HashMap<String, OwnedValue>) = msg.body().deserialize().unwrap();
let token = String::try_from(options.get("handle_token").unwrap().try_clone().unwrap()).unwrap();
assert!(token.starts_with("vectorcraft_color_"));
assert!(token.bytes().all(|c| c.is_ascii_alphanumeric() || c == b'_'));
assert!(!calls.iter().any(|(_, old)| old == &token));
calls.push((parent, token));
// A portal older than version 0.9 answers on a path of its own, not the token's.
let path = format!("/org/freedesktop/portal/desktop/request/independent/pick_{}", calls.len());
let handle = OwnedObjectPath::try_from(path.as_str()).unwrap();
if calls.len() == 4 {
server.reply(&header, &handle).unwrap();
assert!(server.release_name("org.freedesktop.portal.Desktop").unwrap());
break;
}
let to = header.sender().cloned().map(zbus::names::BusName::from);
// Another connection can't end the wait by claiming the portal left.
impostor
.emit_signal(
to.clone(),
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"NameOwnerChanged",
&("org.freedesktop.portal.Desktop", server.unique_name().unwrap().as_str(), ""),
)
.unwrap();
let wrong = color((1.0, 0.0, 0.0));
impostor.emit_signal(to.clone(), path.as_str(), "org.freedesktop.portal.Request", "Response", &(0_u32, &wrong)).unwrap();
let unrelated = "/org/freedesktop/portal/desktop/request/unrelated";
server.emit_signal(to.clone(), unrelated, "org.freedesktop.portal.Request", "Response", &(0_u32, &wrong)).unwrap();
let code = if calls.len() == 2 { 1_u32 } else { 0_u32 };
server.emit_signal(to, path.as_str(), "org.freedesktop.portal.Request", "Response", &(code, &color((0.25, 0.5, 0.75)))).unwrap();
// The reply that names the path goes last: every answer above came before it.
server.reply(&header, &handle).unwrap();
}
calls
});
let client = client(address);
assert_eq!(pick(&client, "x11:12"), Ok(Some([0.25, 0.5, 0.75])));
assert_eq!(pick(&client, "wayland:example"), Ok(None));
assert_eq!(pick(&client, ""), Ok(Some([0.25, 0.5, 0.75])));
assert!(matches!(pick(&client, ""), Err(Failure::NoAnswer(_))));
let calls = worker.join().unwrap();
assert_eq!(calls.iter().map(|(parent, _)| parent.as_str()).collect::<Vec<_>>(), ["x11:12", "wayland:example", "", ""]);
}
/// Through a real D-Bus: a portal without `PickColor` ends the request as a system without a
/// sampler, and the sampler's connection gives the call [`CALL_TIMEOUT`].
#[test]
fn a_portal_without_pick_color_ends_the_request() {
let Some((_daemon, address)) = private_bus() else { return };
let address = address.as_str();
let server = portal(address);
let incoming = zbus::blocking::MessageIterator::from(&server);
let worker = std::thread::spawn(move || {
for msg in incoming {
let msg = msg.unwrap();
let header = msg.header();
if header.member().map(|m| m.as_str()) == Some("PickColor") {
server.reply_error(&header, "org.freedesktop.DBus.Error.UnknownMethod", &("no PickColor",)).unwrap();
break;
}
}
});
let client = client(address);
assert_eq!(client.method_timeout(), Some(CALL_TIMEOUT));
let failure = pick(&client, "");
assert!(matches!(failure, Err(Failure::Unavailable(_))), "{failure:?}");
worker.join().unwrap();
}
}
@@ -0,0 +1,127 @@
//! The answer to the color sampler's XDG desktop portal request
//! (<https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.portal.Request.html>).
//! The wait ends with the request's `Response`, or with an error when the portal leaves the bus
//! first.
use std::io::Read as _;
use futures_lite::{StreamExt as _, future};
use zbus::blocking::{Connection, MessageIterator};
use zbus::zvariant::OwnedObjectPath;
const DESKTOP: &str = "org.freedesktop.portal.Desktop";
/// A request token: `prefix`, then 128 bits from the operating system's random device, so the
/// token is unique and can't be guessed, as the Request documentation asks.
pub(super) fn token(prefix: &str) -> Result<String, String> {
let mut bytes = [0; 16];
std::fs::File::open("/dev/urandom")
.and_then(|mut file| file.read_exact(&mut bytes))
.map_err(|e| format!("could not create a portal request token: {e}"))?;
let random: String = bytes.iter().map(|byte| format!("{byte:02x}")).collect();
Ok(format!("{prefix}_{random}"))
}
/// Subscriptions made before a portal method call, on every request path: a portal older than
/// version 0.9 ignores `handle_token` and answers on the request path it returns, and its answer
/// can come before the call's reply. Each stream keeps every signal from the time it is made.
pub(super) struct Responses {
replies: MessageIterator,
owners: MessageIterator,
}
impl Responses {
pub(super) fn new(conn: &Connection) -> Result<Self, String> {
let reply_rule = zbus::MatchRule::builder()
.msg_type(zbus::message::Type::Signal)
.sender(DESKTOP)
.and_then(|b| b.interface("org.freedesktop.portal.Request"))
.and_then(|b| b.member("Response"))
.map_err(|e| e.to_string())?
.build();
let owner_rule = zbus::MatchRule::builder()
.msg_type(zbus::message::Type::Signal)
.sender("org.freedesktop.DBus")
.and_then(|b| b.path("/org/freedesktop/DBus"))
.and_then(|b| b.interface("org.freedesktop.DBus"))
.and_then(|b| b.member("NameOwnerChanged"))
.and_then(|b| b.arg(0, DESKTOP))
.map_err(|e| e.to_string())?
.build();
Ok(Self {
replies: MessageIterator::for_match_rule(reply_rule, conn, None).map_err(|e| e.to_string())?,
owners: MessageIterator::for_match_rule(owner_rule, conn, None).map_err(|e| e.to_string())?,
})
}
/// The `Response` on the request path `call` returned, from the connection that returned it.
/// An error when that connection leaves the bus first, or the bus connection closes.
pub(super) fn wait(self, call: &zbus::Message) -> Result<zbus::Message, String> {
enum Event {
Reply(Option<zbus::Result<zbus::Message>>),
Owner(Option<zbus::Result<zbus::Message>>),
}
let handle: OwnedObjectPath = call.body().deserialize().map_err(|e| e.to_string())?;
let portal = call.header().sender().map(|s| s.as_str().to_string()).ok_or("the portal answered without a sender")?;
let mut replies = self.replies.into_inner();
let mut owners = self.owners.into_inner();
future::block_on(async {
loop {
let event = future::or(async { Event::Reply(replies.next().await) }, async { Event::Owner(owners.next().await) }).await;
match event {
Event::Reply(reply) => {
let reply = reply.ok_or("the portal closed without an answer")?.map_err(|e| e.to_string())?;
let header = reply.header();
if header.path().map(|p| p.as_str()) == Some(handle.as_str()) && header.sender().map(|s| s.as_str()) == Some(portal.as_str())
{
return Ok(reply);
}
}
Event::Owner(message) => {
let message = message.ok_or("the portal connection closed")?.map_err(|e| e.to_string())?;
if owner_disappeared(&message, &portal)? {
return Err("the desktop portal disappeared while waiting for its answer".into());
}
}
}
}
})
}
}
/// Whether `message` is the bus's `NameOwnerChanged` saying that the connection `portal` no longer
/// owns the portal's name. The bus itself must send it: another connection can't end the wait.
fn owner_disappeared(message: &zbus::Message, portal: &str) -> Result<bool, String> {
if message.header().sender().map(|s| s.as_str()) != Some("org.freedesktop.DBus") {
return Ok(false);
}
let (name, old, new): (String, String, String) = message.body().deserialize().map_err(|e| e.to_string())?;
Ok(name == DESKTOP && old == portal && new != portal)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_the_bus_can_report_portal_owner_loss() {
let changed = |sender, name, old, new| {
zbus::Message::signal("/org/freedesktop/DBus", "org.freedesktop.DBus", "NameOwnerChanged")
.unwrap()
.sender(sender)
.unwrap()
.build(&(name, old, new))
.unwrap()
};
let forged = changed(":1.42", DESKTOP, ":1.7", "");
assert!(!owner_disappeared(&forged, ":1.7").unwrap());
let real = changed("org.freedesktop.DBus", DESKTOP, ":1.7", "");
assert!(owner_disappeared(&real, ":1.7").unwrap());
let other = changed("org.freedesktop.DBus", "org.example.Other", ":1.7", "");
assert!(!owner_disappeared(&other, ":1.7").unwrap());
let old = changed("org.freedesktop.DBus", DESKTOP, ":1.8", "");
assert!(!owner_disappeared(&old, ":1.7").unwrap());
let acquired = changed("org.freedesktop.DBus", DESKTOP, "", ":1.7");
assert!(!owner_disappeared(&acquired, ":1.7").unwrap());
}
}
+4 -7
View File
@@ -35,7 +35,6 @@ trait Backend {
fn suspend(&mut self, window: &Self::Window);
fn restore(&mut self, window: &Self::Window);
fn build(&mut self, request: &Request) -> Option<Self::Cursor>;
fn current(&self) -> Option<Self::Cursor>;
fn set(&mut self, cursor: &Self::Cursor);
}
@@ -73,9 +72,10 @@ impl<B: Backend> State<B> {
&& *key == request.key
&& *owned == window
{
if self.backend.current().as_ref() != Some(cursor) {
self.backend.set(cursor);
}
// AppKit can show the system arrow when the pointer moves while
// `NSCursor.currentCursor` (the app's last set cursor) still reads as ours, so a
// comparison would keep the arrow. Setting the cursor again costs nothing.
self.backend.set(cursor);
return;
}
self.release();
@@ -135,9 +135,6 @@ impl Backend for AppKit {
fn build(&mut self, request: &Request) -> Option<Self::Cursor> {
build(&request.bitmap)
}
fn current(&self) -> Option<Self::Cursor> {
Some(NSCursor::currentCursor())
}
fn set(&mut self, cursor: &Self::Cursor) {
cursor.set();
}
+5 -14
View File
@@ -6,7 +6,6 @@ use std::cell::Cell;
struct Fake {
window: Option<u8>,
suspended: Vec<u8>,
current: Option<Key>,
sets: usize,
builds: usize,
restores: Vec<u8>,
@@ -27,17 +26,12 @@ impl Backend for Fake {
fn restore(&mut self, w: &u8) {
self.suspended.retain(|v| v != w);
self.restores.push(*w);
self.current = None;
}
fn build(&mut self, r: &Request) -> Option<Key> {
self.builds += 1;
(!self.fail).then_some(r.key)
}
fn current(&self) -> Option<Key> {
self.current
}
fn set(&mut self, cursor: &Key) {
self.current = Some(*cursor);
fn set(&mut self, _: &Key) {
self.sets += 1;
}
}
@@ -66,19 +60,16 @@ fn deliver(state: &mut State<Fake>, request: Option<Request>) {
}
#[test]
fn mac_cursor_ownership_deduplicates_reasserts_and_restores() {
fn mac_cursor_ownership_reasserts_every_pass_and_restores() {
let req = request(1.0);
let mut state = fake_state();
deliver(&mut state, Some(req.clone()));
assert_eq!(state.backend.suspended, [1]);
assert_eq!((state.backend.builds, state.backend.sets), (1, 1));
// The pointer moves and AppKit shows the system arrow, but the app's current cursor
// still reads as ours. The next pass sets it again without rebuilding or re-suspending.
deliver(&mut state, Some(req.clone()));
assert_eq!(state.backend.sets, 1);
// Simulate a platform fallback replacing the cursor after finalization. The next pass
// reasserts; this proves the protocol, not AppKit timing or absence of transient flicker.
state.backend.current = None;
deliver(&mut state, Some(req.clone()));
assert_eq!(state.backend.sets, 2);
assert_eq!((state.backend.builds, state.backend.sets, state.backend.suspended.len()), (1, 2, 1));
deliver(&mut state, None);
assert_eq!(state.backend.restores, [1]);
deliver(&mut state, Some(req.clone()));
+2
View File
@@ -32,6 +32,8 @@ mod cursor_theme;
mod gpu;
mod hang_watch;
#[cfg(target_os = "linux")]
mod linux_screen_color;
#[cfg(target_os = "linux")]
mod linux_stylus;
mod logging;
#[cfg(all(target_os = "macos", feature = "wgpu"))]
+7
View File
@@ -242,6 +242,13 @@ fn parent(window: &winit::window::Window) -> (String, Option<wayland::Export>) {
}
}
/// [`parent`] for another dialog of the portal (the screen color sampler, `linux_screen_color`):
/// the identifier stays valid until the second value is dropped.
#[cfg(target_os = "linux")]
pub(crate) fn exported_parent(window: &winit::window::Window) -> (String, impl Send + 'static) {
parent(window)
}
/// The portal's identifier of `window`: its X11 id, else empty (no Wayland export is made off
/// Linux).
#[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))]
+12 -9
View File
@@ -370,11 +370,14 @@ pub struct ArtBrush {
pub scale: ArtScale,
/// Width in percent.
pub width: f64,
/// How the width varies along a stroke: `None` (Fixed) always `width`; Pressure goes from
/// `width` at the lightest pen pressure to [`Self::width_max`] at the heaviest.
/// How the width varies along a stroke: `None` (Fixed) always `width`; a mode that follows the
/// pen goes from `width` to [`Self::width_max`] over the ranges [`Variation`] gives: Pressure
/// from the lightest pressure to the heaviest, Tilt from the pen lying flat to upright, Bearing
/// and Rotation from −180° to 180° (half way at 0°).
#[serde(skip_serializing_if = "Option::is_none")]
pub width_mode: Option<Variation>,
/// The width at the heaviest pen pressure (%), for Pressure (`width` without one).
/// The second width (%) of a mode that follows the pen: at the heaviest pressure, upright, or
/// at 180° (`width` without one).
#[serde(skip_serializing_if = "Option::is_none")]
pub width_max: Option<f64>,
pub flip_along: bool,
@@ -388,11 +391,11 @@ impl ArtBrush {
/// The range of the width (%).
pub const WIDTH_RANGE: (f64, f64) = (1.0, 1000.0);
/// The widths (%) at the lightest and the heaviest pen pressure: `width` for both unless the
/// width follows the pressure.
/// The widths (%) where the pen reads 0 and 1 for the width's mode (the lightest and the
/// heaviest pressure, for Pressure): `width` for both unless the width follows the pen.
pub fn width_range(&self) -> (f64, f64) {
match self.width_mode {
Some(Variation::Pressure) => (self.width, self.width_max.unwrap_or(self.width)),
Some(m) if m.follows_pen() => (self.width, self.width_max.unwrap_or(self.width)),
_ => (self.width, self.width),
}
}
@@ -713,8 +716,8 @@ impl Brush {
}
BrushKind::Art(a) => {
a.width = within(a.width, ArtBrush::WIDTH_RANGE, 100.0);
// The width follows the pen's pressure or stays fixed.
if a.width_mode != Some(Variation::Pressure) {
// The width follows the pen (its pressure, tilt, bearing or rotation) or stays fixed.
if !a.width_mode.is_some_and(Variation::follows_pen) {
a.width_mode = None;
}
a.width_max = a.width_max.map(|w| within(w, ArtBrush::WIDTH_RANGE, a.width));
@@ -806,7 +809,7 @@ pub fn stroke_pieces(doc: &Document, brush: &Brush, bp: &BezPath, stroke: &Strok
let mut out = match &brush.kind {
BrushKind::Calligraphic(c) => calli::calligraphic(c, bp, w, stroke, &brush.name),
BrushKind::Bristle(b) => calli::bristle(b, bp, w, &stroke.paint, &brush.name),
BrushKind::Art(a) => warp::art(a, bp, w, stroke.pressure.as_ref()),
BrushKind::Art(a) => warp::art(a, bp, w, stroke),
BrushKind::Scatter(s) => warp::scatter(s, bp, w, stroke, &brush.name),
BrushKind::Pattern(p) => warp::pattern(p, bp, w),
};
+56
View File
@@ -1371,6 +1371,62 @@ fn art_brush_width_follows_the_pressure() {
assert!(plain.get("width_mode").is_none() && plain.get("width_max").is_none(), "{plain}");
}
/// Art Brush Options: Width on Tilt goes from Width with the pen lying flat to the second width
/// upright, and on Bearing or Rotation from Width at −180° to the second width at 180°, along the
/// stroke as the pen recorded it; each mode reads only its own input.
#[test]
fn art_brush_width_follows_tilt_bearing_and_rotation() {
let brush = |mode: Variation| {
let mut b = art_brush(rect_art(10.0, 4.0), ArtScale::Stretch);
if let BrushKind::Art(a) = &mut b.kind {
(a.width, a.width_mode, a.width_max) = (50.0, Some(mode), Some(300.0));
}
b
};
let bp = line(0.0, 0.0, 100.0, 0.0);
let draw = |b: &Brush, st: &StrokeLayer| stroke_pieces(&Document::new(1.0, 1.0), b, &bp, st);
// Tilt, upright at the start (300 %: 6 pt either side of 4 pt art) to flat at the end (50 %: 1 pt).
let upright_to_flat = StrokeLayer { tilt: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] }), ..stroke(1.0) };
let out = draw(&brush(Variation::Tilt), &upright_to_flat);
assert!(near(half_width(&out, 0.0, 1.0), 6.0, 0.1), "{}", half_width(&out, 0.0, 1.0));
assert!(near(half_width(&out, 99.0, 100.0), 1.0, 0.1), "{}", half_width(&out, 99.0, 100.0));
assert!(near(half_width(&out, 49.0, 51.0), 3.5, 0.15), "{}", half_width(&out, 49.0, 51.0));
// Bearing and Rotation: half way at 0°, a quarter of the way at −90°, three quarters at 90°.
for (mode, angle, half) in [
(Variation::Bearing, 0.0, 3.5),
(Variation::Bearing, -90.0, 2.25),
(Variation::Bearing, 90.0, 4.75),
(Variation::Rotation, -90.0, 2.25),
(Variation::Rotation, 90.0, 4.75),
] {
let st = if mode == Variation::Bearing { posed(Some(0.5), Some(angle), None) } else { posed(None, None, Some(angle)) };
let h = bounds(&draw(&brush(mode), &st)).height();
assert!(near(h, 2.0 * half, 1e-6), "{mode:?} {angle}: {h}");
}
// Each mode reads its own input: without it (the pressure, or another of the pen's values
// recorded instead), the art is half way between the two widths.
let others = [
(Variation::Tilt, posed(None, Some(90.0), Some(90.0))),
(Variation::Tilt, pressed(vec![(0.0, 0.0), (1.0, 1.0)])),
(Variation::Bearing, posed(Some(0.0), None, Some(90.0))),
(Variation::Rotation, posed(Some(0.0), Some(90.0), None)),
(Variation::Pressure, posed(Some(0.0), Some(90.0), Some(90.0))),
];
for (mode, st) in others {
let h = bounds(&draw(&brush(mode), &st)).height();
assert!(near(h, 7.0, 1e-6), "{mode:?}: {h}");
}
// The pen's modes are kept when a definition is read, and Random is read as Fixed.
let lib = parse_library(&serde_json::json!([
{"name": "t", "type": "art", "art": rect_art(10.0, 4.0), "width_mode": "tilt", "width_max": 300.0},
{"name": "b", "type": "art", "art": rect_art(10.0, 4.0), "width_mode": "bearing", "width_max": 300.0},
{"name": "r", "type": "art", "art": rect_art(10.0, 4.0), "width_mode": "rotation", "width_max": 300.0},
{"name": "x", "type": "art", "art": rect_art(10.0, 4.0), "width_mode": "random", "width_max": 300.0},
]));
let modes: Vec<_> = lib.iter().map(|b| if let BrushKind::Art(a) = &b.kind { a.width_mode } else { None }).collect();
assert_eq!(modes, [Some(Variation::Tilt), Some(Variation::Bearing), Some(Variation::Rotation), None]);
}
/// Definitions from files and commands are kept within their ranges.
#[test]
fn sanitize_keeps_values_within_their_ranges() {
+6 -5
View File
@@ -8,7 +8,7 @@
use std::sync::Arc;
use kurbo::ParamCurveNearest;
use vectorcraft_doc::{Appearance, Node, NodeId, NodeKind, PressureProfile, StrokeLayer};
use vectorcraft_doc::{Appearance, Node, NodeId, NodeKind, StrokeLayer};
use vectorcraft_geom::{Affine, BezPath, CubicBez, ParamCurve, PathData, PathEl, Point, Rect, SubPath, Vec2};
use crate::track::{Rng, Track, normal, seed_of, tracks};
@@ -503,9 +503,10 @@ fn art_on_run(
bend_widened(t, art, b, along, cross, widen)
}
/// An art brush's art along `bp`. With a width that follows the pen's pressure, the art is as
/// wide as the pressure recorded at each point of the stroke gives (half way without a recording).
pub(crate) fn art(a: &ArtBrush, bp: &BezPath, weight: f64, pressure: Option<&PressureProfile>) -> Vec<Node> {
/// An art brush's art along `bp`. With a width that follows the pen (its pressure, tilt, bearing
/// or rotation), the art is as wide as what `stroke` recorded at each point gives (half way
/// without a recording).
pub(crate) fn art(a: &ArtBrush, bp: &BezPath, weight: f64, stroke: &StrokeLayer) -> Vec<Node> {
let Some((art, b)) = oriented(&a.art, a.direction, a.flip_along, a.flip_across) else { return vec![] };
let (light, heavy) = a.width_range();
let width = light.max(heavy);
@@ -522,7 +523,7 @@ pub(crate) fn art(a: &ArtBrush, bp: &BezPath, weight: f64, pressure: Option<&Pre
}
// A run past the start of a closed track wraps round to it.
let at = if s > l { s - l } else { s };
let p = pressure.map_or(PressureProfile::MID, |p| p.at(at / l)).clamp(0.0, 1.0);
let p = a.width_mode.and_then(|m| PenAt::of(stroke, at / l).control(m)).unwrap_or(0.5);
(light + (heavy - light) * p) / width
};
let runs = if a.overlap { art_runs(&t) } else { vec![(0.0, l)] };
+178 -4
View File
@@ -8,6 +8,9 @@ use serde::{Deserialize, Serialize};
use crate::Color;
use crate::freeform::Freeform;
mod spread;
pub use spread::{MAX_SPREAD_LEVEL, MAX_SPREAD_RUNS, MAX_SPREAD_STOPS, Padded};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum GradientKind {
#[default]
@@ -94,6 +97,82 @@ impl GradientMethod {
}
}
/// What a linear, radial, conic or diamond gradient paints past the ends of its stops (the
/// Gradient panel's Spread). With Repeat and Reflect, the stops run [`Gradient::repeats`] times
/// along the vector (around the circle, for a conic), and keep going past both of its ends.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize)]
pub enum GradientSpread {
/// The first and last stops' colors carry on past the ends, as gradients always did.
#[default]
Pad,
/// The stops start again at each end.
Repeat,
/// The stops run back the other way at each end, so every other run is mirrored.
Reflect,
}
impl GradientSpread {
/// Every spread, in the order the Gradient panel lists them.
pub const ALL: [GradientSpread; 3] = [GradientSpread::Pad, GradientSpread::Repeat, GradientSpread::Reflect];
/// Parse a spread name (`pad`, `repeat`, `reflect`; any case).
pub fn parse(s: &str) -> Option<Self> {
Self::ALL.into_iter().find(|m| m.label().eq_ignore_ascii_case(s))
}
pub fn label(self) -> &'static str {
match self {
Self::Pad => "Pad",
Self::Repeat => "Repeat",
Self::Reflect => "Reflect",
}
}
pub fn is_pad(&self) -> bool {
*self == Self::Pad
}
}
impl<'de> Deserialize<'de> for GradientSpread {
/// A spread name; a file's unknown name or other value reads as Pad.
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(untagged)]
enum Raw {
Name(String),
Other(serde::de::IgnoredAny),
}
Ok(match Raw::deserialize(d)? {
Raw::Name(s) => Self::parse(&s).unwrap_or_default(),
Raw::Other(_) => Self::Pad,
})
}
}
/// Most times a gradient's stops run along its vector ([`Gradient::repeats`]): VectorCraft's own
/// limit.
pub const MAX_REPEATS: u32 = 100;
fn one_repeat() -> u32 {
1
}
fn is_one_repeat(n: &u32) -> bool {
*n == 1
}
/// A file's repeat count: a number, rounded and kept within 1 to [`MAX_REPEATS`]; anything else
/// reads as 1.
fn lenient_repeats<'de, D: serde::Deserializer<'de>>(d: D) -> Result<u32, D::Error> {
#[derive(Deserialize)]
#[serde(untagged)]
enum Raw {
Number(f64),
Other(serde::de::IgnoredAny),
}
Ok(match Raw::deserialize(d)? {
Raw::Number(n) if n.is_finite() => n.round().clamp(1.0, f64::from(MAX_REPEATS)) as u32,
_ => 1,
})
}
/// How far (display RGB, 0..1) the straight line between a Perceptual gradient's neighbouring
/// expanded stops may stray from the perceptual mix: under half a colour level.
const PERCEPTUAL_TOLERANCE: f32 = 0.4 / 255.0;
@@ -259,6 +338,15 @@ pub struct Gradient {
/// How the colours between the stops are mixed (Classic unless set; written only when not).
#[serde(default, skip_serializing_if = "GradientMethod::is_classic")]
pub method: GradientMethod,
/// What it paints past the ends of its stops (Pad unless set; written only when not). A
/// freeform gradient has no ends and ignores it.
#[serde(default, skip_serializing_if = "GradientSpread::is_pad")]
pub spread: GradientSpread,
/// How many times the stops run along the vector with Repeat and Reflect, 1 to
/// [`MAX_REPEATS`] (use [`Self::repeat_count`]: a value set in code may be out of range); Pad
/// ignores it. Written only when it is not 1.
#[serde(default = "one_repeat", skip_serializing_if = "is_one_repeat", deserialize_with = "lenient_repeats")]
pub repeats: u32,
}
impl Default for Gradient {
@@ -271,7 +359,55 @@ impl Default for Gradient {
impl Gradient {
/// A gradient of `kind` through `stops`, with the default options.
pub fn new(kind: GradientKind, stops: Vec<GradientStop>) -> Self {
Self { kind, stops, dither: false, method: GradientMethod::Classic }
Self { kind, stops, dither: false, method: GradientMethod::Classic, spread: GradientSpread::Pad, repeats: 1 }
}
/// [`Self::repeats`] kept within 1 to [`MAX_REPEATS`].
pub fn repeat_count(&self) -> u32 {
self.repeats.clamp(1, MAX_REPEATS)
}
/// Does it paint something other than its end colors past the ends of its stops, or run its
/// stops more than once: a linear, radial, conic or diamond gradient that repeats or reflects?
pub fn is_spread(&self) -> bool {
!self.spread.is_pad() && self.kind != GradientKind::Freeform
}
/// The spread and count as the gradient paints them: Pad and 1 for one that pads (whatever
/// count it keeps) and for a freeform one, else its spread and [`Self::repeat_count`]. Equal
/// for two gradients whose spreads paint alike.
pub fn painted_spread(&self) -> (GradientSpread, u32) {
if self.is_spread() { (self.spread, self.repeat_count()) } else { (GradientSpread::Pad, 1) }
}
/// The position (0..1) along the stops that gradient parameter `t` (0 at the start of the
/// vector, 1 at its end; [`GradientGeom::param_at`]) samples: `t` itself with Pad (the stops
/// clamp it), else `t` × [`Self::repeat_count`] wrapped back into 0..1, every other run
/// mirrored with Reflect. A `t` that is not finite is returned as it is.
pub fn spread_param(&self, t: f64) -> f64 {
self.spreader()(t)
}
/// How many wedges a conic gradient is written as ([`GradientGeom::conic_wedges`]) where
/// `per_turn` would do for stops that run once around: that many for each time the stops run
/// around, at most [`MAX_CONIC_WEDGES`]. Sample each wedge at [`Self::spread_param`] of its
/// turn.
pub fn conic_wedge_count(&self, per_turn: usize) -> usize {
let runs = if self.is_spread() { self.repeat_count() as usize } else { 1 };
per_turn.saturating_mul(runs).clamp(1, MAX_CONIC_WEDGES)
}
/// [`Self::spread_param`] as a function that holds no borrow of the gradient.
pub fn spreader(&self) -> impl Fn(f64) -> f64 + Copy + use<> {
let spread = if self.is_spread() { self.spread } else { GradientSpread::Pad };
let n = f64::from(self.repeat_count());
move |t: f64| {
if !t.is_finite() {
return t;
}
match spread {
GradientSpread::Pad => t,
GradientSpread::Repeat => (t * n).rem_euclid(1.0),
GradientSpread::Reflect => {
let w = (t * n).rem_euclid(2.0);
if w > 1.0 { 2.0 - w } else { w }
}
}
}
}
/// Colour and opacity at `t` (honours midpoints and the method).
pub fn sample(&self, t: f32) -> (Color, f32) {
@@ -544,10 +680,18 @@ impl Gradient {
GradientStop { opacity, ..GradientStop::new(offset, color) }
};
let d = to - from;
let mut stops = vec![stop(0.0, from)];
let expanded = self.expanded_stops();
// Where stops share the offset `from` (a sharp step, as where the runs of a repeating
// gradient meet), the piece starts with the color after the step; sampling gives the one
// before it.
let first = match expanded.iter().rev().find(|(t, ..)| *t == from) {
Some(&(_, color, opacity)) if d > 1e-6 => GradientStop { opacity, ..GradientStop::new(0.0, color) },
_ => stop(0.0, from),
};
let mut stops = vec![first];
if d > 1e-6 {
stops.extend(
self.expanded_stops()
expanded
.into_iter()
.filter(|(t, ..)| *t > from && *t < to)
.map(|(t, color, opacity)| GradientStop { opacity, ..GradientStop::new((t - from) / d, color) }),
@@ -954,6 +1098,35 @@ impl GradientGeom {
self.set_focal(Some(m * q));
}
}
/// The placement whose level `t` is this one's level `k`·`t` (`k` > 0), for a linear, radial or
/// diamond gradient: the vector `k` times as long from the same start, and for an off-center
/// radial the extent ellipse scaled `k` times about the focal point, which stays. A conic keeps
/// its placement (its level is a turn).
pub fn levels_scaled(&self, kind: GradientKind, k: f64) -> GradientGeom {
if kind == GradientKind::Conic || !(k.is_finite() && k > 0.0) {
return *self;
}
let u = self.end - self.start;
let mut out = *self;
if kind == GradientKind::Radial
&& let (Some(f), Some(frame)) = (self.focal, self.unit_frame())
{
// Level t of an off-center radial is the extent ellipse scaled by t about the line
// from the focal point to the center: the new center sits on that line, `k` times as
// far from the focal point.
let f = (frame.inverse() * f).to_vec2();
out.start = frame * (f * (1.0 - k)).to_point();
}
out.end = out.start + u * k;
out
}
/// The placement over which one run of the stops of a gradient that repeats `n` times along
/// its vector lies ([`Self::levels_scaled`] by 1/`n`).
pub fn period(&self, kind: GradientKind, n: u32) -> GradientGeom {
self.levels_scaled(kind, 1.0 / f64::from(n.max(1)))
}
pub fn angle_deg(&self) -> f64 {
let v = self.end - self.start;
(-v.y).atan2(v.x).to_degrees()
@@ -1148,12 +1321,13 @@ impl GradientPaint {
inks: bool,
) -> impl Iterator<Item = [u8; N]> + use<N> {
let (kind, geom, dither) = (self.gradient.kind, self.resolve(bounds), fill && self.gradient.dither);
let spread = self.gradient.spreader();
let (cw, ch) = (area.width() / f64::from(cols.max(1)), area.height() / f64::from(rows.max(1)));
let (x0, y0) = (area.x0, area.y0);
let [across, down] = cells.map(|r| u32::from(r.start)..u32::from(r.end));
down.flat_map(move |j| across.clone().map(move |i| (i, j))).map(move |(i, j)| {
let p = Point::new(x0 + (f64::from(i) + 0.5) * cw, y0 + (f64::from(j) + 0.5) * ch);
let c = ramp.at(geom.param_at(kind, p) as f32);
let c = ramp.at(spread(geom.param_at(kind, p)) as f32);
std::array::from_fn(|k| {
if k + 1 == N {
return (c[k].clamp(0.0, 1.0) * 255.0).round() as u8;
+268
View File
@@ -0,0 +1,268 @@
//! A repeating or reflecting gradient as one that pads, for formats whose gradients only pad
//! past their ends: the stops repeated (every other run mirrored, for Reflect) as many times as
//! the painted area needs, and the vector stretched over those runs.
use kurbo::{Point, Rect, Vec2};
use super::{Gradient, GradientGeom, GradientKind, GradientSpread, GradientStop};
/// Most runs of the stops [`Gradient::padded_over`] writes.
pub const MAX_SPREAD_RUNS: usize = 256;
/// Most stops [`Gradient::padded_over`] writes, all runs together.
pub const MAX_SPREAD_STOPS: usize = 16384;
/// The farthest level from its center a radial or diamond gradient's runs are written out to by
/// [`Gradient::padded_over`] (its stops' offsets, single-precision fractions of it, stay apart),
/// nearer for stops closer together than a run ([`MIN_OFFSET_GAP`]).
pub const MAX_SPREAD_LEVEL: f64 = 65536.0;
/// The least difference between two stops' offsets [`Gradient::padded_over`] writes as
/// different: sixteen times single precision's step just below 1.
const MIN_OFFSET_GAP: f64 = 1e-6;
/// A repeating or reflecting gradient written as one that pads ([`Gradient::padded_over`]).
#[derive(Clone, Debug, PartialEq)]
pub struct Padded {
/// The gradient with its stops repeated, padding past its ends.
pub gradient: Gradient,
/// Where those runs lie.
pub geom: GradientGeom,
/// Where along `geom` (0 to 1) the first run written starts: 0 for a linear gradient, the
/// first run's level over the last one's outer level for a radial or diamond one.
pub first: f64,
/// How many runs are written, evenly spaced from [`Self::first`] to 1.
pub runs: usize,
/// The area needed more runs than [`MAX_SPREAD_RUNS`] (or than [`MAX_SPREAD_STOPS`] allows),
/// or runs past [`MAX_SPREAD_LEVEL`]: the gradient pads past the runs written.
pub capped: bool,
}
impl Gradient {
/// A linear, radial or diamond gradient that repeats or reflects, placed at `geom`, as a
/// gradient that pads and paints `area` the same way: its stops repeated, each run's
/// placement [`GradientGeom::period`] of `geom`, as many runs as the area reaches (a radial or
/// diamond from its first level, 0, the first stop's color inside the area's innermost run).
/// `None` for a gradient that pads, a conic or
/// freeform one, one without stops, and a placement whose levels at the corners are not
/// finite.
pub fn padded_over(&self, geom: &GradientGeom, area: Rect) -> Option<Padded> {
self.padded_within(geom, area, MAX_SPREAD_STOPS)
}
/// [`Self::padded_over`] with at most `max_stops` stops (and at least one run).
pub fn padded_within(&self, geom: &GradientGeom, area: Rect, max_stops: usize) -> Option<Padded> {
let kind = self.kind;
if !self.is_spread() || matches!(kind, GradientKind::Conic | GradientKind::Freeform) || self.stops.is_empty() {
return None;
}
let period = geom.period(kind, self.repeat_count());
let corners = [Point::new(area.x0, area.y0), Point::new(area.x1, area.y0), Point::new(area.x1, area.y1), Point::new(area.x0, area.y1)];
let ts = corners.map(|p| period.param_at(kind, p));
if ts.iter().any(|t| !t.is_finite()) {
return None;
}
let centered = kind.is_centered();
// The level's range over the area. A linear gradient's extremes lie at corners. Radial and
// diamond levels are nested convex rings from level 0: the largest at a corner, the
// smallest 0 when the area holds the rings' center, else on its edge.
let lo = if centered { inner_level(&period, kind, area).floor() } else { ts.iter().copied().fold(f64::INFINITY, f64::min).floor() };
let hi = ts.iter().copied().fold(f64::NEG_INFINITY, f64::max).ceil().max(lo + 1.0);
let one = whole_run(&self.stops);
let most = MAX_SPREAD_RUNS.min(max_stops.min(MAX_SPREAD_STOPS) / one.len().max(1)).max(1);
let capped = hi - lo > most as f64;
// Capped, the runs kept are the area's innermost ones (radial and diamond), or (linear)
// those around the vector's start where the area reaches it, else the area's runs nearest
// to it.
let lo = match capped {
true if !centered => (-((most / 2) as f64)).clamp(lo, hi - most as f64),
_ => lo,
};
let n = (hi - lo).min(most as f64).max(1.0);
// A radial or diamond writes its runs among the levels from 0, which its stops' offsets
// (single-precision fractions of the outermost level) tell apart only so far out, the
// nearer the closer its stops lie: past that, the runs end there and the gradient pads.
let gap = one.windows(2).map(|w| f64::from(w[1].offset - w[0].offset)).filter(|d| *d > 0.0).fold(1.0, f64::min);
// A whole level, so the runs keep their places (and Reflect its mirrored ones).
let farthest = MAX_SPREAD_LEVEL.min(gap / MIN_OFFSET_GAP).floor().max(n);
let far = centered && lo + n > farthest;
let (lo, capped) = if far { ((farthest - n).max(0.0), true) } else { (lo, capped) };
// `lo` is a whole number, possibly past what an integer holds: its parity in floating point.
let first_odd = lo.rem_euclid(2.0) >= 1.0;
let (stops, geom) = if centered {
// The levels from 0, the runs from level `lo` (the first stop's color inside it).
(self.runs(&one, first_odd, lo, n as usize, lo + n), period.levels_scaled(kind, lo + n))
} else {
let u = period.end - period.start;
(
self.runs(&one, first_odd, 0.0, n as usize, n),
GradientGeom { start: period.start + u * lo, end: period.start + u * (lo + n), ..period },
)
};
let gradient = Gradient { stops, spread: GradientSpread::Pad, repeats: 1, ..self.clone() };
let first = if centered { lo / (lo + n) } else { 0.0 };
Some(Padded { gradient, geom, first, runs: n as usize, capped })
}
/// The gradient as it runs from the start of its vector (0) to its end (1), as one that
/// pads: a gradient that repeats or reflects with its stops repeated [`Self::repeat_count`]
/// times between 0 and 1 (every other run mirrored, for Reflect), for what only shows that
/// stretch (a gradient along or across a stroke, a swatch's preview). Others as they are.
pub fn unrolled(&self) -> std::borrow::Cow<'_, Gradient> {
self.unrolled_within(MAX_SPREAD_STOPS)
}
/// [`Self::unrolled`] with at most `max_stops` stops (and at least one run): past the runs
/// that fit, the last one pads.
pub fn unrolled_within(&self, max_stops: usize) -> std::borrow::Cow<'_, Gradient> {
use std::borrow::Cow;
if !self.is_spread() {
return Cow::Borrowed(self);
}
// Without stops there is nothing to repeat: it pads all the same.
if self.stops.is_empty() {
return Cow::Owned(Gradient { spread: GradientSpread::Pad, repeats: 1, ..self.clone() });
}
let one = whole_run(&self.stops);
let n = self.repeat_count() as usize;
let kept = n.min(max_stops.min(MAX_SPREAD_STOPS) / one.len().max(1)).max(1);
let stops = self.runs(&one, false, 0.0, kept, n as f64);
Cow::Owned(Gradient { stops, spread: GradientSpread::Pad, repeats: 1, ..self.clone() })
}
/// One cycle of a gradient that repeats or reflects, which repeated end to end paints it, as
/// a gradient that pads: one run of the stops (Repeat), or a run and its mirror (Reflect),
/// between 0 and 1, and how many runs that is (1 or 2). `None` for a gradient that pads and
/// one without stops.
pub fn cycle(&self) -> Option<(Gradient, u32)> {
if !self.is_spread() || self.stops.is_empty() {
return None;
}
let one = whole_run(&self.stops);
let runs = if self.spread == GradientSpread::Reflect { 2 } else { 1 };
let stops = self.runs(&one, false, 0.0, runs, runs as f64);
Some((Gradient { stops, spread: GradientSpread::Pad, repeats: 1, ..self.clone() }, runs as u32))
}
/// `n` runs of `one` (one run of the stops, [`whole_run`]) on a line of `of` runs from 0 to 1,
/// the first of them `start` runs along it and an odd-numbered run when `first_odd` (with
/// Reflect, the odd-numbered runs are mirrored).
fn runs(&self, one: &[GradientStop], first_odd: bool, start: f64, n: usize, of: f64) -> Vec<GradientStop> {
let mirrored_run = (self.spread == GradientSpread::Reflect).then(|| mirror(one));
let mut stops = Vec::with_capacity(one.len() * n);
for j in 0..n {
let run = match &mirrored_run {
Some(m) if (j % 2 == 1) != first_odd => m.as_slice(),
_ => one,
};
stops.extend(run.iter().map(|s| GradientStop { offset: ((start + j as f64 + f64::from(s.offset)) / of) as f32, ..s.clone() }));
}
stops
}
}
/// The smallest level of radial or diamond gradient `geom` over `area`, less a run (for rounding):
/// 0 when the area holds the rings' center (a radial's focal point, a diamond's center), else the
/// smallest along its sides, worked out in the gradient's unit frame from the sides' ends rather
/// than from samples along them, so a long side does not hide a run near it. 0 for a placement
/// without a frame.
fn inner_level(geom: &GradientGeom, kind: GradientKind, area: Rect) -> f64 {
let center = if kind == GradientKind::Radial { geom.focal_point() } else { geom.start };
if area.contains(center) {
return 0.0;
}
let frame = if kind == GradientKind::Diamond { geom.diamond_frame() } else { geom.unit_frame() };
let Some(to_unit) = frame.map(|m| m.inverse()) else { return 0.0 };
let focal = geom.focal.filter(|_| kind == GradientKind::Radial).map(|f| (to_unit * f).to_vec2());
let corners = [Point::new(area.x0, area.y0), Point::new(area.x1, area.y0), Point::new(area.x1, area.y1), Point::new(area.x0, area.y1)]
.map(|p| (to_unit * p).to_vec2());
let mut least = f64::INFINITY;
for (&a, &b) in corners.iter().zip(corners.iter().cycle().skip(1)) {
let side = if kind == GradientKind::Diamond { diamond_least(a, b) } else { radial_least(a, b, focal) };
least = least.min(side);
}
if least.is_finite() { (least - 1.0).max(0.0) } else { 0.0 }
}
/// The smallest diamond level, |x| + |y| in its unit frame, on the segment from `a` to `b`: the
/// level is linear between the points where the segment crosses an axis, so the smallest is at
/// an end or at one of those crossings.
fn diamond_least(a: Vec2, b: Vec2) -> f64 {
let d = b - a;
let crossings = [(d.x != 0.0).then(|| -a.x / d.x), (d.y != 0.0).then(|| -a.y / d.y)];
[Some(0.0), Some(1.0), crossings[0], crossings[1]]
.into_iter()
.flatten()
.filter(|u| (0.0..=1.0).contains(u))
.map(|u| {
let p = a + d * u;
p.x.abs() + p.y.abs()
})
.fold(f64::INFINITY, f64::min)
}
/// Halvings at most in [`radial_least`]: enough to bring any finite span below a quarter level.
const RADIAL_HALVINGS: usize = 1100;
/// The smallest radial level on the segment from `a` to `b` in the unit frame, at most a quarter
/// level under it: the distance to the center for a centered radial. An off-center radial's level
/// `t` is the circle of radius `t` about `f`(1 − `t`), `f` its focal point; the segment's distance
/// from that center less `t` falls as `t` grows (the center moves |`f`| < 1 per level), and the
/// smallest level is where it reaches 0, found by halving. 0 for a focal point not inside the
/// extent ellipse.
fn radial_least(a: Vec2, b: Vec2, focal: Option<Vec2>) -> f64 {
let Some(f) = focal else { return distance_to_segment(a, b, Vec2::ZERO) };
let reach = f.hypot();
if reach.is_nan() || reach >= 1.0 {
return 0.0;
}
let past = |t: f64| distance_to_segment(a, b, f * (1.0 - t)) <= t;
// At this level the circle reaches the segment's nearest point to the ellipse's center.
let mut hi = (distance_to_segment(a, b, Vec2::ZERO) / (1.0 - reach)).max(1.0);
let mut lo = 0.0;
if !hi.is_finite() || past(lo) {
return 0.0;
}
for _ in 0..RADIAL_HALVINGS {
let mid = lo + (hi - lo) / 2.0;
if hi - lo <= 0.25 || mid <= lo || mid >= hi {
break;
}
if past(mid) { hi = mid } else { lo = mid }
}
lo
}
/// How far `c` is from the segment from `a` to `b`.
fn distance_to_segment(a: Vec2, b: Vec2, c: Vec2) -> f64 {
let d = b - a;
let along = (c - a).dot(d) / d.hypot2();
let u = if along.is_finite() { along.clamp(0.0, 1.0) } else { 0.0 };
(a + d * u - c).hypot()
}
/// The stops of one run, from offset 0 to 1: the end colors held out to the ends.
fn whole_run(stops: &[GradientStop]) -> Vec<GradientStop> {
let mut out = stops.to_vec();
if let Some(first) = out.first().filter(|s| s.offset > 0.0).cloned() {
out.insert(0, GradientStop { offset: 0.0, ..first });
}
if let Some(last) = out.last_mut() {
// The last stop's midpoint leads nowhere; the copy at 1 takes over.
if last.offset < 1.0 {
let end = GradientStop { offset: 1.0, ..last.clone() };
out.push(end);
}
}
out
}
/// A run mirrored: the stops in reverse, each midpoint measured from the other side.
fn mirror(run: &[GradientStop]) -> Vec<GradientStop> {
let mut g = Gradient::new(GradientKind::Linear, run.to_vec());
g.reverse();
g.stops
}
#[cfg(test)]
mod tests;
+368
View File
@@ -0,0 +1,368 @@
use kurbo::Vec2;
use super::*;
use crate::gradient::{GradientPaint, MAX_REPEATS};
use crate::{Color, GradientMethod};
fn spread(kind: GradientKind, spread: GradientSpread, repeats: u32) -> Gradient {
Gradient { spread, repeats, ..Gradient::new(kind, Gradient::default().stops) }
}
fn black_white() -> Vec<GradientStop> {
let mut a = GradientStop::new(0.0, Color::BLACK);
a.midpoint = 0.3;
vec![a, GradientStop::new(1.0, Color::WHITE)]
}
fn close(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-9
}
/// Repeat wraps the parameter, `repeats` times along the vector and on past both ends; Reflect
/// runs every other run backwards; Pad leaves it to the stops to clamp; a freeform gradient has
/// no ends to spread past.
#[test]
fn spread_maps_the_parameter_to_a_place_along_the_stops() {
let repeat = spread(GradientKind::Linear, GradientSpread::Repeat, 3);
for (t, want) in [(0.0, 0.0), (0.1, 0.3), (0.5, 0.5), (1.0 / 3.0 + 0.1, 0.3), (1.1, 0.3), (-0.1, 0.7)] {
assert!(close(repeat.spread_param(t), want), "repeat {t}: {}", repeat.spread_param(t));
}
let reflect = spread(GradientKind::Radial, GradientSpread::Reflect, 3);
for (t, want) in [(0.0, 0.0), (0.1, 0.3), (1.0 / 3.0 + 0.1, 0.7), (2.0 / 3.0 + 0.1, 0.3), (1.0, 1.0), (-0.1, 0.3)] {
assert!(close(reflect.spread_param(t), want), "reflect {t}: {}", reflect.spread_param(t));
}
let pad = spread(GradientKind::Linear, GradientSpread::Pad, 3);
assert_eq!((pad.spread_param(1.7), pad.spread_param(-0.2)), (1.7, -0.2));
let free = spread(GradientKind::Freeform, GradientSpread::Repeat, 3);
assert_eq!(free.spread_param(0.7), 0.7);
assert!(!free.is_spread() && !pad.is_spread() && repeat.is_spread());
assert!(repeat.spread_param(f64::NAN).is_nan());
// A count out of range (set in code) counts as the nearest one in range.
assert_eq!(spread(GradientKind::Linear, GradientSpread::Repeat, 0).repeat_count(), 1);
assert_eq!(spread(GradientKind::Linear, GradientSpread::Repeat, 5000).repeat_count(), MAX_REPEATS);
}
/// The native format writes the spread and count only when they are not Pad and 1, reads a file
/// without them as Pad and 1, and reads an unknown spread or a count out of range as the nearest
/// one it can hold.
#[test]
fn the_file_keeps_the_spread_and_reads_bad_values_leniently() {
let plain = serde_json::to_value(Gradient::default()).unwrap();
assert!(plain.get("spread").is_none() && plain.get("repeats").is_none(), "{plain}");
let g = spread(GradientKind::Conic, GradientSpread::Reflect, 4);
let v = serde_json::to_value(&g).unwrap();
assert_eq!((v["spread"].as_str(), v["repeats"].as_u64()), (Some("Reflect"), Some(4)));
assert_eq!(serde_json::from_value::<Gradient>(v).unwrap(), g);
let read = |spread: serde_json::Value, repeats: serde_json::Value| {
let mut v = serde_json::to_value(Gradient::default()).unwrap();
v["spread"] = spread;
v["repeats"] = repeats;
let g: Gradient = serde_json::from_value(v).unwrap();
(g.spread, g.repeats)
};
assert_eq!(read("Repeat".into(), 3.4.into()), (GradientSpread::Repeat, 3));
assert_eq!(read("Spiral".into(), (-5).into()), (GradientSpread::Pad, 1));
assert_eq!(read(7.into(), 1e12.into()), (GradientSpread::Pad, MAX_REPEATS));
assert_eq!(read(serde_json::Value::Null, "many".into()), (GradientSpread::Pad, 1));
let missing: Gradient = serde_json::from_value(serde_json::json!({"kind": "Linear", "stops": []})).unwrap();
assert_eq!((missing.spread, missing.repeats), (GradientSpread::Pad, 1));
}
/// One run's placement: a level of the period is the gradient's level times the count, for
/// linear, diamond and off-center radial gradients; a conic keeps its placement.
#[test]
fn a_period_holds_one_run_of_the_stops() {
let p = Point::new(72.0, 61.0);
let linear = GradientGeom { start: Point::new(10.0, 20.0), end: Point::new(60.0, 40.0), aspect: 1.0, focal: None };
let radial = GradientGeom { start: Point::new(50.0, 50.0), end: Point::new(60.0, 50.0), aspect: 0.6, focal: Some(Point::new(55.0, 52.0)) };
let diamond = GradientGeom { end: Point::new(58.0, 56.0), focal: None, ..radial };
for (kind, geom) in [(GradientKind::Linear, linear), (GradientKind::Radial, radial), (GradientKind::Diamond, diamond)] {
let period = geom.period(kind, 4);
assert!(close(period.param_at(kind, p), 4.0 * geom.param_at(kind, p)), "{kind:?}");
assert_eq!(period.focal, geom.focal, "{kind:?}");
}
assert_eq!(radial.period(GradientKind::Conic, 4), radial);
assert_eq!(linear.period(GradientKind::Linear, 0), linear, "a count of 0 counts as 1");
}
/// The stops repeated over the area: as many runs as its corners reach, each in place.
#[test]
fn a_linear_gradient_pads_with_its_stops_repeated_over_the_area() {
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(20.0, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Repeat, repeats: 2, ..Gradient::new(GradientKind::Linear, black_white()) };
let p = g.padded_over(&geom, Rect::new(-5.0, 0.0, 25.0, 10.0)).unwrap();
assert!(!p.capped);
// Runs of 10 from -10 to 30: four of them.
assert_eq!((p.geom.start, p.geom.end), (Point::new(-10.0, 0.0), Point::new(30.0, 0.0)));
let offsets: Vec<f32> = p.gradient.stops.iter().map(|s| s.offset).collect();
assert_eq!(offsets, [0.0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1.0]);
assert!(p.gradient.stops.iter().step_by(2).all(|s| s.color == Color::BLACK && (s.midpoint - 0.3).abs() < 1e-6));
assert_eq!((p.gradient.spread, p.gradient.repeats), (GradientSpread::Pad, 1));
// Every point gets the color the gradient gives it.
for x in [-4.0, 1.0, 7.5, 13.0, 24.0] {
let q = Point::new(x, 5.0);
let want = g.sample(g.spread_param(geom.param_at(GradientKind::Linear, q)) as f32).0;
let got = p.gradient.sample(p.geom.param_at(GradientKind::Linear, q) as f32).0;
assert!(want.to_rgb().iter().zip(got.to_rgb()).all(|(a, b)| (a - b).abs() < 1e-4), "{x}: {want:?} vs {got:?}");
}
}
#[test]
fn reflect_mirrors_every_other_run_and_its_midpoints() {
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(10.0, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Reflect, ..Gradient::new(GradientKind::Linear, black_white()) };
let p = g.padded_over(&geom, Rect::new(0.0, 0.0, 20.0, 10.0)).unwrap();
let colors: Vec<Color> = p.gradient.stops.iter().map(|s| s.color).collect();
assert_eq!(colors, [Color::BLACK, Color::WHITE, Color::WHITE, Color::BLACK]);
// Black → white with the midpoint at 0.3 mirrors to white → black with it at 0.7.
assert!((p.gradient.stops[2].midpoint - 0.7).abs() < 1e-6, "{:?}", p.gradient.stops);
}
#[test]
fn stops_inside_a_run_hold_their_colors_to_its_ends() {
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(10.0, 0.0), aspect: 1.0, focal: None };
let stops = vec![GradientStop::new(0.25, Color::BLACK), GradientStop::new(0.75, Color::WHITE)];
let g = Gradient { spread: GradientSpread::Repeat, ..Gradient::new(GradientKind::Linear, stops) };
let p = g.padded_over(&geom, Rect::new(0.0, 0.0, 20.0, 10.0)).unwrap();
let offsets: Vec<f32> = p.gradient.stops.iter().map(|s| s.offset).collect();
assert_eq!(offsets, [0.0, 0.125, 0.375, 0.5, 0.5, 0.625, 0.875, 1.0]);
}
/// An off-center radial grows about its focal point, a diamond about its center; every point
/// keeps its color.
#[test]
fn radial_and_diamond_gradients_pad_in_rings_from_their_first_level() {
let c = Point::new(50.0, 50.0);
let radial = GradientGeom { start: c, end: Point::new(60.0, 50.0), aspect: 1.0, focal: Some(Point::new(55.0, 50.0)) };
let diamond = GradientGeom { focal: None, ..radial };
for (kind, geom) in [(GradientKind::Radial, radial), (GradientKind::Diamond, diamond)] {
let g = Gradient { spread: GradientSpread::Reflect, repeats: 2, ..Gradient::new(kind, black_white()) };
let p = g.padded_over(&geom, Rect::new(0.0, 0.0, 100.0, 100.0)).unwrap();
assert!(p.gradient.stops.len() / 2 >= 10, "{kind:?}: {}", p.gradient.stops.len());
assert_eq!(p.geom.focal, geom.focal);
for q in [Point::new(72.0, 61.0), Point::new(10.0, 95.0), Point::new(52.0, 49.0)] {
let want = g.sample(g.spread_param(geom.param_at(kind, q)) as f32).0.to_rgb();
let got = p.gradient.sample(p.geom.param_at(kind, q) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 1e-4), "{kind:?} {q:?}: {want:?} vs {got:?}");
}
}
}
/// A run of the stops far too short for the area, or a gradient of many stops, is written with at
/// most so many runs and stops, and pads past them; a conic, a padding gradient and one without
/// stops have nothing to pad.
#[test]
fn far_repeats_and_many_stops_are_capped() {
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(0.01, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Repeat, repeats: MAX_REPEATS, ..Gradient::new(GradientKind::Linear, black_white()) };
let p = g.padded_over(&geom, Rect::new(0.0, 0.0, 100.0, 1.0)).unwrap();
assert!(p.capped);
assert_eq!(p.gradient.stops.len(), 2 * MAX_SPREAD_RUNS);
let many: Vec<GradientStop> = (0..=4000).map(|i| GradientStop::new(i as f32 / 4000.0, Color::gray(i as f32 / 4000.0))).collect();
let g = Gradient { spread: GradientSpread::Reflect, repeats: 50, ..Gradient::new(GradientKind::Linear, many) };
let wide = GradientGeom { end: Point::new(100.0, 0.0), ..geom };
let p = g.padded_over(&wide, Rect::new(0.0, 0.0, 100.0, 1.0)).unwrap();
assert!(p.capped && p.gradient.stops.len() <= MAX_SPREAD_STOPS, "{}", p.gradient.stops.len());
assert!(g.unrolled().stops.len() <= MAX_SPREAD_STOPS);
assert!(p.gradient.padded_over(&p.geom, Rect::new(0.0, 0.0, 1.0, 1.0)).is_none(), "it pads");
assert!(spread(GradientKind::Conic, GradientSpread::Repeat, 3).padded_over(&wide, Rect::new(0.0, 0.0, 1.0, 1.0)).is_none());
let empty = Gradient { spread: GradientSpread::Repeat, ..Gradient::new(GradientKind::Linear, vec![]) };
assert!(empty.padded_over(&wide, Rect::new(0.0, 0.0, 1.0, 1.0)).is_none());
}
/// The runs written are the ones the area shows: a radial or diamond centered a thousand runs
/// from the area writes the hundred it crosses, not the first 256 from the center; a linear
/// gradient over an area of 1,100 runs far before its start, capped, keeps the runs nearest it.
/// Every point checked gets the color the gradient gives it.
#[test]
fn the_runs_written_cover_a_distant_area() {
let centered = GradientGeom { start: Point::new(0.0, 50.0), end: Point::new(1.0, 50.0), aspect: 1.0, focal: None };
let before = GradientGeom { start: Point::new(5000.0, 0.0), end: Point::new(5001.0, 0.0), aspect: 1.0, focal: None };
for (kind, geom, area) in [
(GradientKind::Radial, centered, Rect::new(1000.0, 0.0, 1100.0, 100.0)),
(GradientKind::Diamond, centered, Rect::new(1000.0, 0.0, 1100.0, 100.0)),
(GradientKind::Linear, before, Rect::new(0.0, 0.0, 1100.0, 100.0)),
] {
let g = Gradient { spread: GradientSpread::Reflect, repeats: 1, ..Gradient::new(kind, black_white()) };
let p = g.padded_over(&geom, area).unwrap();
assert_eq!(p.capped, kind == GradientKind::Linear, "{kind:?}");
assert!(p.gradient.stops.len() <= MAX_SPREAD_STOPS);
for q in [Point::new(1000.5, 0.5), Point::new(1050.25, 50.0), Point::new(1099.5, 99.5), Point::new(1010.75, 90.0)] {
let want = g.sample(g.spread_param(geom.param_at(kind, q)) as f32).0.to_rgb();
let got = p.gradient.sample(p.geom.param_at(kind, q) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 2e-3), "{kind:?} {q:?}: {want:?} vs {got:?}");
}
}
}
/// A tiny radial centered just outside the area, beside a side between any evenly spaced
/// samples of it: the runs written start from the area's true innermost level.
#[test]
fn the_innermost_level_is_found_between_samples() {
let c = Point::new(-0.0005, 7.8125);
let geom = GradientGeom { start: c, end: c + Vec2::new(0.001, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Reflect, repeats: 1, ..Gradient::new(GradientKind::Radial, black_white()) };
let p = g.padded_over(&geom, Rect::new(0.0, 0.0, 1000.0, 1000.0)).unwrap();
for q in [Point::new(0.05, 7.8125), Point::new(0.1, 7.9)] {
let want = g.sample(g.spread_param(geom.param_at(GradientKind::Radial, q)) as f32).0.to_rgb();
let got = p.gradient.sample(p.geom.param_at(GradientKind::Radial, q) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 2e-3), "{q:?}: {want:?} vs {got:?}");
}
}
/// An area four billion units wide whose long side passes 50 runs from a tiny radial or diamond's
/// center: the runs written start from that side's true innermost level, so the runs beside it
/// keep their colors.
#[test]
fn the_innermost_level_is_found_along_a_very_long_side() {
let area = Rect::new(-1.3e9, 0.0, 2.9e9, 1.0);
for x in [0.3, 12345.678, -7777.25, 98765.4321] {
let c = Point::new(x, -0.00005);
let run = GradientGeom { start: c, end: c + Vec2::new(1e-6, 0.0), aspect: 1.0, focal: None };
let off_center = GradientGeom { focal: Some(c + Vec2::new(0.5e-6, 0.0)), ..run };
for (kind, geom) in [(GradientKind::Diamond, run), (GradientKind::Radial, run), (GradientKind::Radial, off_center)] {
let g = Gradient { spread: GradientSpread::Reflect, repeats: 1, ..Gradient::new(kind, black_white()) };
let p = g.padded_over(&geom, area).unwrap();
assert!(p.capped, "{kind:?}");
for q in [Point::new(x, 1e-5), Point::new(x + 2e-5, 2e-5), Point::new(x - 1e-5, 0.0001)] {
let level = geom.param_at(kind, q);
assert!((40.0..200.0).contains(&level), "{kind:?} {q:?}: level {level}");
let want = g.sample(g.spread_param(level) as f32).0.to_rgb();
let got = p.gradient.sample(p.geom.param_at(kind, q) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 2e-3), "{kind:?} {q:?}: {want:?} vs {got:?}");
}
}
}
}
/// Runs a billion levels from a radial's center are past what the stops' offsets can tell apart:
/// the gradient is written capped, its stops still apart and in order.
#[test]
fn runs_too_far_from_the_center_are_capped() {
let c = Point::new(0.0, 0.0);
let geom = GradientGeom { start: c, end: c + Vec2::new(1e-6, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Reflect, repeats: 1, ..Gradient::new(GradientKind::Radial, black_white()) };
let p = g.padded_over(&geom, Rect::new(1000.0, 0.0, 1000.0001, 0.0001)).unwrap();
assert!(p.capped);
assert!(p.gradient.stops.windows(2).all(|w| w[0].offset <= w[1].offset), "in order");
let distinct = p.gradient.stops.windows(2).filter(|w| w[1].offset > w[0].offset).count();
assert!(distinct * 2 + 2 >= p.gradient.stops.len(), "the runs stay apart: {distinct} of {}", p.gradient.stops.len());
}
/// A run of 1,000 close stops is written only as far out as their offsets stay apart: around
/// level 50,000 it is capped, every stop written apart from the next.
#[test]
fn close_stops_are_written_only_where_they_stay_apart() {
let many: Vec<GradientStop> = (0..=1000).map(|i| GradientStop::new(i as f32 / 1000.0, Color::gray(i as f32 / 1000.0))).collect();
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(0.001, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Repeat, repeats: 1, ..Gradient::new(GradientKind::Diamond, many) };
let p = g.padded_over(&geom, Rect::new(50.0, 0.0, 50.002, 0.002)).unwrap();
assert!(p.capped);
// Only where one run meets the next do two stops share an offset.
let runs = p.gradient.stops.len() / 1001;
let shared = p.gradient.stops.windows(2).filter(|w| w[1].offset <= w[0].offset).count();
assert!(shared < runs, "{shared} stops share an offset in {runs} runs");
// Stops 0.0001234 of a run apart are written out to level 123, on whole runs: an area within
// it gets the gradient's colors, Reflect's mirrored runs included.
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(0.0001234, Color::gray(0.5)), GradientStop::new(1.0, Color::WHITE)];
let g = Gradient { spread: GradientSpread::Reflect, repeats: 1, ..Gradient::new(GradientKind::Diamond, stops) };
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(1.0, 0.0), aspect: 1.0, focal: None };
let p = g.padded_over(&geom, Rect::new(121.0, 0.0, 123.9, 0.2)).unwrap();
assert!(p.capped, "past level 123 it pads");
for x in [121.3, 121.9, 122.5] {
let q = Point::new(x, 0.1);
let want = g.sample(g.spread_param(geom.param_at(GradientKind::Diamond, q)) as f32).0.to_rgb();
let got = p.gradient.sample(p.geom.param_at(GradientKind::Diamond, q) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 2e-3), "{x}: {want:?} vs {got:?}");
}
}
/// A piece of a gradient that starts where two runs meet (a gradient along a stroke, sliced at a
/// corner there) starts with the new run's first color, not the old run's last.
#[test]
fn a_piece_starting_at_a_sharp_step_takes_the_color_after_it() {
let g = Gradient { spread: GradientSpread::Repeat, repeats: 2, ..Gradient::new(GradientKind::Linear, Gradient::default().stops) };
let piece = g.unrolled().span(0.5, 1.0);
assert_eq!(piece.stops.first().map(|s| s.color), Some(Color::WHITE), "{:?}", piece.stops);
assert_eq!(piece.stops.last().map(|s| s.color), Some(Color::BLACK));
let before = g.unrolled().span(0.0, 0.5);
assert_eq!((before.stops[0].color, before.stops.last().unwrap().color), (Color::WHITE, Color::BLACK));
}
/// An area very far past a very short reflecting vector (a file's numbers) is padded without the
/// run count overflowing.
#[test]
fn a_far_area_pads_without_overflowing() {
let geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(1e-300, 0.0), aspect: 1.0, focal: None };
let g = Gradient { spread: GradientSpread::Reflect, repeats: MAX_REPEATS, ..Gradient::new(GradientKind::Linear, black_white()) };
let p = g.padded_over(&geom, Rect::new(1e3, 0.0, 2e3, 1.0));
assert!(p.is_none_or(|p| p.gradient.stops.len() <= MAX_SPREAD_STOPS));
// Runs of 1e-8: the area's levels lie past 1e19, more than an integer holds.
let geom = GradientGeom { end: Point::new(1e-6, 0.0), ..geom };
let p = g.padded_over(&geom, Rect::new(1e11, 0.0, 1e11 + 1.0, 1.0)).unwrap();
assert!(p.capped && p.gradient.stops.len() <= MAX_SPREAD_STOPS, "{} {} {:?}", p.capped, p.gradient.stops.len(), p.geom);
}
/// Unrolled, the stops run `repeats` times between 0 and 1 (every other run mirrored with
/// Reflect); one cycle is a run, or a run and its mirror.
#[test]
fn unrolled_and_cycle_stops() {
let g = Gradient { spread: GradientSpread::Reflect, repeats: 3, ..Gradient::new(GradientKind::Linear, black_white()) };
let u = g.unrolled();
let offsets: Vec<f32> = u.stops.iter().map(|s| (s.offset * 3.0).round()).collect();
assert_eq!(offsets, [0.0, 1.0, 1.0, 2.0, 2.0, 3.0]);
let colors: Vec<Color> = u.stops.iter().map(|s| s.color).collect();
assert_eq!(colors, [Color::BLACK, Color::WHITE, Color::WHITE, Color::BLACK, Color::BLACK, Color::WHITE]);
for t in [0.05, 0.4, 0.71, 0.99] {
let (a, b) = (g.sample(g.spread_param(t) as f32).0.to_rgb(), u.sample(t as f32).0.to_rgb());
assert!(a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-4), "{t}");
}
let (cycle, runs) = g.cycle().unwrap();
assert_eq!((runs, cycle.stops.len()), (2, 4));
let repeat = Gradient { spread: GradientSpread::Repeat, ..g.clone() };
assert_eq!(repeat.cycle().unwrap().1, 1);
assert!(Gradient::default().cycle().is_none());
assert!(matches!(Gradient::default().unrolled(), std::borrow::Cow::Borrowed(_)));
}
/// Pixels (what the canvas draws a diamond, dithered or Perceptual gradient as, and what SVG and
/// PDF write as images) repeat with the stops, for each kind.
#[test]
fn pixels_repeat_and_reflect_for_every_kind() {
let b = Rect::new(0.0, 0.0, 40.0, 40.0);
let c = Point::new(20.0, 20.0);
for kind in [GradientKind::Linear, GradientKind::Radial, GradientKind::Conic, GradientKind::Diamond] {
for sp in [GradientSpread::Repeat, GradientSpread::Reflect] {
for method in [GradientMethod::Classic, GradientMethod::Perceptual] {
let mut g = GradientPaint::new(Gradient { spread: sp, repeats: 3, method, ..Gradient::new(kind, Gradient::default().stops) });
let geom = if kind == GradientKind::Linear {
GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(40.0, 10.0), aspect: 1.0, focal: None }
} else {
GradientGeom { start: c, end: c + Vec2::new(18.0, 4.0), aspect: 0.8, focal: None }
};
g.geom = Some(geom);
let px: Vec<[u8; 4]> = g.pixels(b, b, 40, 40, false, &Color::to_rgb).collect();
for (i, got) in px.iter().enumerate().step_by(37) {
let p = Point::new((i % 40) as f64 + 0.5, (i / 40) as f64 + 0.5);
let t = g.gradient.spread_param(geom.param_at(kind, p));
// Not where Repeat jumps from the last stop back to the first.
if sp == GradientSpread::Repeat && !(0.03..0.97).contains(&t) {
continue;
}
let want = g.gradient.sample(t as f32).0.to_rgba8(1.0);
assert!(got[0].abs_diff(want[0]) <= 2, "{kind:?} {sp:?} {method:?} {p:?}: {got:?} vs {want:?}");
}
}
}
}
}
/// A conic gradient's wedges: as many for each time the stops run around as for one turn, at most
/// so many.
#[test]
fn conic_wedges_count_each_run() {
let g = spread(GradientKind::Conic, GradientSpread::Repeat, 4);
assert_eq!(g.conic_wedge_count(360), 1440);
assert_eq!(spread(GradientKind::Conic, GradientSpread::Pad, 4).conic_wedge_count(360), 360);
assert_eq!(spread(GradientKind::Conic, GradientSpread::Reflect, MAX_REPEATS).conic_wedge_count(360), crate::gradient::MAX_CONIC_WEDGES);
}
+1 -1
View File
@@ -16,7 +16,7 @@ pub mod swatch;
pub use blend::BlendMode;
pub use freeform::{Freeform, FreeformMode, FreeformPoint};
pub use gradient::{Gradient, GradientGeom, GradientKind, GradientMethod, GradientPaint, GradientStop};
pub use gradient::{Gradient, GradientGeom, GradientKind, GradientMethod, GradientPaint, GradientSpread, GradientStop};
pub use libraries::SwatchLibrary;
pub use swatch::{Swatch, SwatchGroup, default_swatches};
+3 -1
View File
@@ -196,8 +196,10 @@ fn write_css(lib: &SwatchLibrary, keep: impl Fn(&&Swatch) -> bool) -> String {
let at = if mirrored { 1.0 - s.offset } else { s.offset };
format!("{} {}%", css_color(&s.color, s.opacity), at * 100.0)
};
// Stops that repeat or reflect run that many times across the box.
let unrolled = g.gradient.unrolled();
let stops: Vec<String> =
if mirrored { g.gradient.stops.iter().rev().map(stop).collect() } else { g.gradient.stops.iter().map(stop).collect() };
if mirrored { unrolled.stops.iter().rev().map(stop).collect() } else { unrolled.stops.iter().map(stop).collect() };
match g.gradient.kind {
GradientKind::Radial => format!("radial-gradient(circle, {})", stops.join(", ")),
// CSS sweeps clockwise from straight up; the angle is counted counterclockwise
+23
View File
@@ -261,6 +261,29 @@ fn css_preserves_fractional_gradient_stop_positions() {
}
}
/// A gradient swatch that repeats or reflects has its stops written that many times across the
/// box, every other run backwards for Reflect.
#[test]
fn css_writes_spread_gradient_swatches_with_their_stops_repeated() {
for (spread, want) in [
(crate::GradientSpread::Repeat, "#ffffff 0%, #000000 50%, #ffffff 50%, #000000 100%"),
(crate::GradientSpread::Reflect, "#ffffff 0%, #000000 50%, #000000 50%, #ffffff 100%"),
] {
let lib = SwatchLibrary {
name: "x".into(),
swatches: vec![Swatch {
name: "Bands".into(),
paint: Paint::Gradient(Box::new(GradientPaint::new(Gradient { spread, repeats: 2, ..Gradient::default() }))),
global: false,
spot: false,
}],
groups: vec![],
};
let text = written(&lib, PaletteFormat::Css);
assert!(text.contains(&format!("--bands: linear-gradient(90deg, {want});")), "{spread:?}: {text}");
}
}
#[test]
fn holds_counts_the_swatches_each_format_writes() {
// `sample()` holds the spot color Ink, the linear gradient Fade, the pattern Tiles and two solid colors in a group.
+24
View File
@@ -152,6 +152,11 @@ fn lerp_gradient(a: &GradientPaint, b: &GradientPaint, t: f32) -> Option<Gradien
}
})
.collect();
// Two gradients that repeat (or reflect) step their count from one to the other; a spread
// that differs switches halfway, as the method does.
if a.gradient.is_spread() && a.gradient.spread == b.gradient.spread {
out.gradient.repeats = lerp_f32(a.gradient.repeat_count() as f32, b.gradient.repeat_count() as f32, t).round() as u32;
}
out.angle = a.angle + (b.angle - a.angle) * t as f64;
out.swatch = None;
if let (Some(ga), Some(gb)) = (a.geom, b.geom) {
@@ -1656,6 +1661,25 @@ mod tests {
assert!(pair.at(0.5).bounds().unwrap().height() < 1e-6, "the clicked anchors pair up");
}
/// A blend between two gradients that repeat steps the count; one between a gradient that
/// pads and one that repeats switches halfway, as the method does.
#[test]
fn blend_between_repeating_gradients_steps_the_count() {
use vectorcraft_color::GradientSpread;
let spread = |spread, repeats| Paint::Gradient(Box::new(GradientPaint::new(Gradient { spread, repeats, ..Gradient::default() })));
let at = |a: &Paint, b: &Paint, t: f32| match lerp_paint(a, b, t) {
Paint::Gradient(g) => (g.gradient.spread, g.gradient.repeat_count()),
p => panic!("a gradient, not {p:?}"),
};
let (two, twenty) = (spread(GradientSpread::Repeat, 2), spread(GradientSpread::Repeat, 20));
assert_eq!(at(&two, &twenty, 0.25), (GradientSpread::Repeat, 7));
assert_eq!(at(&two, &twenty, 0.5), (GradientSpread::Repeat, 11));
assert_eq!(at(&two, &twenty, 1.0), (GradientSpread::Repeat, 20));
let pad = spread(GradientSpread::Pad, 1);
assert_eq!(at(&pad, &twenty, 0.25), (GradientSpread::Pad, 1));
assert_eq!(at(&pad, &twenty, 0.75), (GradientSpread::Repeat, 20));
}
#[test]
fn blend_between_tints_of_one_swatch_keeps_the_link() {
let tinted = |tint: f32| Paint::Solid { color: Color::cmyk(1.0, 0.7, 0.0, 0.4).tinted(tint), swatch: Some("Spot".into()), tint };
+2 -1
View File
@@ -119,7 +119,8 @@ pub(super) fn map_node(n: &Node, w: &Warper) -> Node {
{
out.appearance.warp_linear_gradients(b, &|p| affine_near(w.f, p, w.eps));
}
if let Some(m) = out.extras_if_any().and_then(|e| e.mask.as_mut()) {
// A linked opacity mask bends with the object it masks; an unlinked one stays where it is.
if let Some(m) = out.extras_if_any().and_then(|e| e.mask.as_mut()).filter(|m| m.linked) {
m.art = Arc::new(map_node(&m.art, w));
}
match &mut out.kind {
+3 -1
View File
@@ -57,7 +57,9 @@ pub struct CharStyle {
#[serde(default)]
pub all_caps: bool,
/// OpenType features that differ from the defaults (OpenType panel), as tags: `"dlig"` turns
/// a feature on, `"-liga"` off.
/// a feature on, `"-liga"` off, and `"salt=2"` turns a feature with alternates on at the font's
/// alternate number 2 (the value the shaper gets; a plain `"salt"` is value 1). Runs that
/// differ only in this list are shaped together, each with its own features.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub features: Vec<String>,
/// Character style (Character Styles panel) these attributes come from; None = Normal.
+519
View File
@@ -690,6 +690,525 @@ fn a_transform_on_a_group_paints_each_copy_with_its_own_gradient() {
}
}
/// A white 10 pt square with id `id` at the origin.
fn white_square(id: u64) -> Node {
Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(Paint::solid(Color::WHITE), Paint::None, 0.0))
}
/// `n` masked by `art`, linked or not.
fn masked_by(mut n: Node, art: Node, linked: bool) -> Node {
let mut mask = vectorcraft_doc::OpacityMask::new(art, true);
mask.linked = linked;
n.extras_mut().mask = Some(Box::new(mask));
n
}
/// The geometry effects that reshape a group's members, one at a time.
fn reshaping_effects() -> Vec<Effect> {
let fx = |id: &str, params: serde_json::Value| Effect { id: id.into(), params, visible: true };
let corners = serde_json::json!({"corners": [[1.0 / 3.0, 0.0], [4.0 / 3.0, 0.0], [1.0, 1.0], [0.0, 1.0]]});
vec![
fx("distort.transform", serde_json::json!({"moveH": 30})),
fx("distort.transform", serde_json::json!({"rotate": 90})),
fx("distort.twist", serde_json::json!({"angle": 90})),
fx("distort.freeDistort", corners),
fx("warp.arc", serde_json::json!({})),
fx("distort.roughen", serde_json::json!({"size": 5, "seed": 3})),
fx("distort.zigZag", serde_json::json!({})),
fx("distort.puckerBloat", serde_json::json!({"amount": 50})),
fx("distort.tweak", serde_json::json!({})),
fx("path.offsetPath", serde_json::json!({"offset": 3})),
fx("stylize.roundCorners", serde_json::json!({"radius": 3})),
]
}
/// A group's geometry effect reshapes the art of a member's linked opacity mask as it reshapes the
/// member: a mask drawn over the member still covers it. An unlinked mask stays where it is.
#[test]
fn a_groups_geometry_effects_reshape_a_members_linked_mask_with_it() {
let square = white_square(1);
let original = square.path_data().cloned();
for e in reshaping_effects() {
for linked in [true, false] {
let member = masked_by(square.clone(), white_square(4), linked);
let mut g = Node::group(NodeId(10), vec![Arc::new(member), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(e.clone());
let art = evaluate_container(None, &g).unwrap();
let member = &art.children().unwrap()[0];
let mask = member.extras().mask.as_deref().unwrap();
assert!(member.path_data().cloned() != original, "{}: the member is reshaped", e.id);
let want = if linked { member.path_data().cloned() } else { original.clone() };
assert_eq!(mask.art.path_data().cloned(), want, "{} (linked: {linked})", e.id);
assert_eq!(mask.linked, linked);
}
}
}
/// The mask of a group inside the group, the mask of a path in it, a mask inside that mask's art and
/// an inverted mask all take the outer group's effect with the paths they mask.
#[test]
fn a_groups_geometry_effects_reshape_nested_and_inverted_masks() {
for e in reshaping_effects() {
let innermost = masked_by(white_square(7), white_square(8), true);
let path = masked_by(white_square(1), masked_by(white_square(6), innermost, true), true);
let mut inner = masked_by(Node::group(NodeId(5), vec![Arc::new(path)]), white_square(4), true);
if let Some(m) = inner.extras_if_any().and_then(|x| x.mask.as_mut()) {
m.invert = true;
}
let mut g = Node::group(NodeId(10), vec![Arc::new(inner), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(e.clone());
let art = evaluate_container(None, &g).unwrap();
let inner = &art.children().unwrap()[0];
let path = &inner.children().unwrap()[0];
let want = path.path_data().cloned();
let mask_of = |n: &Node| n.extras().mask.as_deref().map(|m| (*m.art).clone()).unwrap();
let (outer_mask, path_mask) = (mask_of(inner), mask_of(path));
assert!(inner.extras().mask.as_deref().is_some_and(|m| m.invert));
assert_eq!(outer_mask.path_data().cloned(), want, "{}: the inner group's inverted mask", e.id);
assert_eq!(path_mask.path_data().cloned(), want, "{}: the path's mask", e.id);
assert_eq!(mask_of(&path_mask).path_data().cloned(), want, "{}: the mask inside the mask's art", e.id);
assert_eq!(mask_of(&mask_of(&path_mask)).path_data().cloned(), want, "{}: one level deeper", e.id);
}
}
/// A Transform effect's copies of a path with a linked mask are objects of their own, each with the
/// mask moved with it; the original keeps its mask where it was.
#[test]
fn each_transform_copy_of_a_masked_member_carries_its_mask() {
let member = masked_by(white_square(1), white_square(4), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(member)]);
let params = serde_json::json!({"moveH": 30, "copies": 2});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let copies = art.children().unwrap()[0].children().expect("the object and its copies are objects of their own");
assert_eq!(copies.len(), 3);
for c in copies {
let mask = c.extras().mask.as_deref().unwrap();
assert_eq!(mask.art.geometric_bounds(), c.geometric_bounds());
}
}
/// A Transform effect's copies of the paths of a member group give the group's linked mask the same
/// copies: the mask covers each copy.
#[test]
fn a_member_groups_mask_takes_the_transform_copies_of_its_paths() {
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), white_square(4), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(inner)]);
let params = serde_json::json!({"moveH": 30, "copies": 1});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let inner = &art.children().unwrap()[0];
let want = inner.geometric_bounds();
assert_eq!(want, Some(Rect::new(0.0, 0.0, 40.0, 10.0)), "the path and its copy");
assert_eq!(inner.extras().mask.as_deref().unwrap().art.geometric_bounds(), want);
}
/// A mask's art of several objects takes Transform copies whole, as the art it masks does: each copy
/// of the mask's art is a group of its objects, so the copies do not interleave object by object.
#[test]
fn a_masks_art_of_several_objects_is_copied_whole() {
let mask_art = Node::group(NodeId(3), vec![Arc::new(white_square(4)), sq(5, 5.0, Color::WHITE)]);
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), mask_art, true);
let mut g = Node::group(NodeId(10), vec![Arc::new(inner)]);
let params = serde_json::json!({"moveH": 30, "copies": 1});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let mask = &art.children().unwrap()[0].extras().mask.as_deref().unwrap().art;
let copies = mask.children().unwrap();
assert_eq!(copies.len(), 2, "the mask's art and its copy");
for c in copies {
let ids: Vec<NodeId> = c.children().into_iter().flatten().map(|m| m.id).collect();
assert_eq!(ids, [NodeId(4), NodeId(5)], "each copy holds the mask's objects");
}
assert_eq!(mask.geometric_bounds(), Some(Rect::new(0.0, 0.0, 45.0, 10.0)));
}
/// The linked mask of a mask's art that is copied whole takes the same Transform copies.
#[test]
fn the_mask_of_a_masks_art_copied_whole_takes_its_copies() {
let parts = Node::group(NodeId(3), vec![Arc::new(white_square(4)), sq(5, 5.0, Color::WHITE)]);
let mask_art = masked_by(parts, white_square(6), true);
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), mask_art, true);
let mut g = Node::group(NodeId(10), vec![Arc::new(inner)]);
let params = serde_json::json!({"moveH": 30, "copies": 1});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let mask = &art.children().unwrap()[0].extras().mask.as_deref().unwrap().art;
assert_eq!(mask.geometric_bounds(), Some(Rect::new(0.0, 0.0, 45.0, 10.0)), "the mask's art and its copy");
let own = &mask.extras().mask.as_deref().expect("the mask's art keeps its own mask").art;
assert_eq!(own.geometric_bounds(), Some(Rect::new(0.0, 0.0, 40.0, 10.0)), "its mask covers the copy too");
}
/// The mask of a mask's art copied whole stays in the budget while that art is copied: when the
/// budget has no room for that mask's copy, the art keeps its shape with its masks.
#[test]
fn the_mask_of_a_masks_art_copied_whole_counts_against_the_budget() {
let transform = Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 30, "copies": 1}), visible: true };
let parts = Node::group(NodeId(3), vec![Arc::new(white_square(4)), sq(5, 5.0, Color::WHITE)]);
let mask_art = masked_by(parts, white_square(6), true);
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), mask_art, true);
let mut art = Node::group(NodeId(10), vec![Arc::new(inner)]);
let one = crate::Budget::of(white_square(1).path_data().unwrap()).lines;
// Room for the four squares and the copies of three of them, not for the copy of the fourth.
let budget = crate::Budget { anchors: usize::MAX / 4, lines: 7 * one };
crate::reshape::reshape_leaves_within(&mut art, &[&transform], budget, None);
let inner = &art.children().unwrap()[0];
let square = Some(Rect::new(0.0, 0.0, 10.0, 10.0));
assert_eq!(inner.geometric_bounds(), square, "the path keeps its shape");
let mask = &inner.extras().mask.as_deref().unwrap().art;
assert_eq!(mask.geometric_bounds(), Some(Rect::new(0.0, 0.0, 15.0, 10.0)), "and so does its mask");
}
/// When a member group's linked mask can't take all the Transform copies its paths take (past the
/// budget), the art keeps its shape under the effect, so the mask still covers the paths.
#[test]
fn art_whose_mask_would_take_fewer_copies_keeps_its_shape() {
let transform = Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 30, "copies": 1}), visible: true };
let member = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), white_square(4), true);
let mut art = Node::group(NodeId(10), vec![Arc::new(member)]);
let one = crate::Budget::of(white_square(1).path_data().unwrap()).lines;
// Room for the path, its mask and a copy of the path, not for a copy of the mask.
let budget = crate::Budget { anchors: usize::MAX / 4, lines: 3 * one };
crate::reshape::reshape_leaves_within(&mut art, &[&transform], budget, None);
let member = &art.children().unwrap()[0];
let square = Some(Rect::new(0.0, 0.0, 10.0, 10.0));
assert_eq!(member.geometric_bounds(), square, "the path keeps its shape");
assert_eq!(member.extras().mask.as_deref().unwrap().art.geometric_bounds(), square, "and so does its mask");
}
/// The copies of a path with a linked mask count the art of the mask each copy carries against the
/// budget: they stop where the masks would pass it.
#[test]
fn transform_copies_count_the_art_of_their_masks() {
let transform = Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 30, "copies": 2}), visible: true };
let member = masked_by(white_square(1), white_square(4), true);
let mut art = Node::group(NodeId(10), vec![Arc::new(member)]);
let one = crate::Budget::of(white_square(1).path_data().unwrap()).lines;
// Room for the path, its mask and one copy of both, not for a second copy.
let budget = crate::Budget { anchors: usize::MAX / 4, lines: 4 * one };
crate::reshape::reshape_leaves_within(&mut art, &[&transform], budget, None);
let copies = art.children().unwrap()[0].children().expect("the object and its copy are objects of their own");
assert_eq!(copies.len(), 2);
for c in copies {
assert_eq!(c.extras().mask.as_deref().unwrap().art.geometric_bounds(), c.geometric_bounds());
}
}
/// A Transform effect that scales strokes moves a group's paths as objects, their masks with them.
/// The mask of a member group, whose art holds a path with a mask of its own, moves with the group's
/// paths too.
#[test]
fn a_transform_that_moves_paths_as_objects_moves_a_member_groups_nested_mask() {
let mask_art = masked_by(white_square(4), white_square(5), true);
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), mask_art, true);
let mut g = Node::group(NodeId(10), vec![Arc::new(inner), sq(3, 20.0, Color::BLACK)]);
let params = serde_json::json!({"moveH": 30, "strokes": true});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let inner = &art.children().unwrap()[0];
let want = inner.children().unwrap()[0].geometric_bounds();
assert_eq!(want, Some(Rect::new(30.0, 0.0, 40.0, 10.0)));
let mask = &inner.extras().mask.as_deref().unwrap().art;
assert_eq!(mask.geometric_bounds(), want, "the group's mask");
assert_eq!(mask.extras().mask.as_deref().unwrap().art.geometric_bounds(), want, "the mask inside its art");
}
/// A group's Transform effect moves an image member's linked opacity mask with the image, and its
/// copies' masks with the copies; an unlinked mask stays.
#[test]
fn a_groups_transform_moves_an_image_members_linked_mask() {
for linked in [true, false] {
for copies in [0, 2] {
let im = vectorcraft_doc::ImageObject {
key: "k".into(),
width: 10,
height: 10,
xf: vectorcraft_geom::Affine::IDENTITY,
link: None,
placement: Default::default(),
pixels: None,
};
let image = masked_by(Node::new(NodeId(1), NodeKind::Image(Box::new(im))), white_square(4), linked);
let mut g = Node::group(NodeId(10), vec![Arc::new(image)]);
let params = serde_json::json!({"moveH": 30, "copies": copies});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let first = &art.children().unwrap()[0];
let images: Vec<&Node> = match first.children() {
Some(ch) => ch.iter().map(|c| &**c).collect(),
None => vec![first],
};
assert_eq!(images.len(), copies + 1);
for im in images {
let mask = im.extras().mask.as_deref().unwrap();
let want = if linked { im.geometric_bounds() } else { Some(Rect::new(0.0, 0.0, 10.0, 10.0)) };
assert_eq!(mask.art.geometric_bounds(), want, "linked {linked}, copies {copies}");
}
}
}
}
/// When a path in a member's mask art would pass the effects' budget, the whole mask stays as it
/// was, rather than part of its art moving with the member, and the member keeps its shape with it.
#[test]
fn a_mask_whose_art_passes_the_budget_stays_whole() {
// Bloat bends a path's sides into curves drawn with more lines the larger they are: many more
// on the mask's large square.
let bloat = Effect { id: "distort.puckerBloat".into(), params: serde_json::json!({"amount": 50}), visible: true };
let large = Node::path(NodeId(5), shapes::rectangle(Rect::new(0.0, 0.0, 1000.0, 1000.0)), Appearance::default());
let mask_art = Node::group(NodeId(3), vec![Arc::new(white_square(4)), Arc::new(large.clone())]);
let member = masked_by(white_square(1), mask_art.clone(), true);
let mut art = Node::group(NodeId(10), vec![Arc::new(member)]);
// Room for the member and the mask's small square to take the effect, not for the large one.
let bounds = art.geometric_bounds().unwrap();
let ctx = crate::GeomContext { seed: 10, ..crate::GeomContext::of(&art) };
let square = white_square(1).path_data().cloned().unwrap();
let made = crate::Budget::of(&crate::apply_geometry_with(std::slice::from_ref(&bloat), &square, bounds, &ctx)).lines;
let budget = crate::Budget { anchors: usize::MAX / 4, lines: 2 * made + crate::Budget::of(large.path_data().unwrap()).lines };
let large_made = crate::Budget::of(&crate::apply_geometry_with(std::slice::from_ref(&bloat), large.path_data().unwrap(), bounds, &ctx)).lines;
assert!(large_made > crate::Budget::of(large.path_data().unwrap()).lines, "the large square's curves cost more lines");
crate::reshape::reshape_leaves_within(&mut art, &[&bloat], budget, None);
let member = &art.children().unwrap()[0];
assert_eq!(member.path_data(), Some(&square), "the member keeps its shape with its mask");
assert_eq!(*member.extras().mask.as_deref().unwrap().art, mask_art, "the mask stays whole");
}
/// Live objects in a member's linked mask are evaluated before the group's geometry effects run
/// over the mask's art, so the mask still covers the member: a Repeat in it moves and bends with
/// the member.
#[test]
fn a_groups_effects_reshape_a_live_object_in_a_members_mask() {
let mut grid = vectorcraft_doc::RepeatSpec::grid(vec![Arc::new(white_square(5))], 0.0, 0.0);
if let vectorcraft_doc::RepeatKind::Grid { rows, cols, .. } = &mut grid.kind {
(*rows, *cols) = (1, 1);
}
let repeat = Node::new(NodeId(4), NodeKind::Repeat(grid));
let drawn: Vec<Node> = crate::expand_live(None, &repeat);
let leaf = |n: &Node| {
let mut found = None;
n.walk(&mut |c| found = found.take().or_else(|| c.path_data().cloned()));
found
};
assert_eq!(drawn.iter().find_map(leaf), white_square(1).path_data().cloned(), "the Repeat draws one square over the member");
for e in [reshaping_effects()[0].clone(), reshaping_effects()[4].clone()] {
let member = masked_by(white_square(1), repeat.clone(), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(member), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(e.clone());
let art = evaluate_container(None, &g).unwrap();
let member = &art.children().unwrap()[0];
let mask = &member.extras().mask.as_deref().unwrap().art;
assert!(member.path_data() != white_square(1).path_data(), "{}: the member is reshaped", e.id);
assert_eq!(leaf(mask), member.path_data().cloned(), "{}: the mask's square takes the effect with it", e.id);
}
}
/// Type in a member's linked mask is outlined before the group's Transform effect moves the mask's
/// art with the member.
#[test]
fn a_groups_transform_moves_type_in_a_members_mask() {
if skip_without_craft_fonts() {
return;
}
let member = masked_by(white_square(1), type_h(), true);
let before = crate::reshape::outline_text(&type_h()).unwrap().geometric_bounds().unwrap();
let mut g = Node::group(NodeId(10), vec![Arc::new(member)]);
g.appearance.effects.push(reshaping_effects()[0].clone());
let art = evaluate_container(None, &g).unwrap();
let mask = &art.children().unwrap()[0].extras().mask.as_deref().unwrap().art;
let mut text = false;
mask.walk(&mut |c| text |= matches!(c.kind, NodeKind::Text(_)));
assert!(!text, "the type is outlined");
let after = mask.geometric_bounds().unwrap();
assert!((after.x0 - before.x0 - 30.0).abs() < 0.5 && (after.y0 - before.y0).abs() < 0.5, "{before:?} -> {after:?}");
}
/// The linked mask of a compound path in a group, and of a path in a layer, takes the geometry
/// effects with the art it masks.
#[test]
fn a_compound_paths_and_a_layers_members_masks_take_the_effects() {
let geometry = |n: &Node| crate::reshape::leaf_geometry(n).map(|(p, _)| p);
for e in reshaping_effects() {
let square = white_square(1);
let compound = Node::new(NodeId(1), NodeKind::Compound { children: vec![Arc::new(square.clone())], rule: FillRule::NonZero });
let compound = masked_by(compound, white_square(4), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(compound), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(e.clone());
let art = evaluate_container(None, &g).unwrap();
let member = &art.children().unwrap()[0];
assert!(geometry(member) != square.path_data().cloned(), "{}: the compound path is reshaped", e.id);
assert_eq!(geometry(&member.extras().mask.as_deref().unwrap().art), geometry(member), "{}: compound path", e.id);
let mut layer = Node::layer(NodeId(10), "Layer", vectorcraft_doc::LayerColor::Preset(0));
if let Some(ch) = layer.children_mut() {
ch.extend([Arc::new(masked_by(square.clone(), white_square(4), true)), sq(2, 20.0, Color::BLACK)]);
}
layer.appearance.effects.push(e.clone());
let art = evaluate_container(None, &layer).unwrap();
let member = &art.children().unwrap()[0];
assert!(member.path_data() != square.path_data(), "{}: the layer's path is reshaped", e.id);
assert_eq!(member.extras().mask.as_deref().unwrap().art.path_data(), member.path_data(), "{}: layer", e.id);
}
}
/// A group's Transform effect moves a symbol instance member's linked mask with the instance.
#[test]
fn a_groups_transform_moves_a_symbol_instance_members_linked_mask() {
let instance = Node::new(NodeId(1), NodeKind::SymbolInstance { symbol: "s".into(), xf: vectorcraft_geom::Affine::IDENTITY });
let mut g = Node::group(NodeId(10), vec![Arc::new(masked_by(instance, white_square(4), true)), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(reshaping_effects()[0].clone());
let art = evaluate_container(None, &g).unwrap();
let instance = &art.children().unwrap()[0];
let NodeKind::SymbolInstance { xf, .. } = &instance.kind else { panic!("an instance: {instance:?}") };
assert!((xf.translation().x - 30.0).abs() < 1e-9, "the instance moves: {xf:?}");
let mask = instance.extras().mask.as_deref().unwrap().art.geometric_bounds().unwrap();
assert!((mask.x0 - 30.0).abs() < 1e-9 && (mask.x1 - 40.0).abs() < 1e-9, "its mask moves with it: {mask:?}");
}
/// With Scale Strokes & Effects on, a group's Transform effect scales the stroke of an image
/// member's linked mask as it scales that of a path member's mask.
#[test]
fn a_transform_with_scale_strokes_scales_the_masks_of_images_and_paths_alike() {
let stroked =
Node::path(NodeId(4), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(Paint::None, Paint::solid(Color::WHITE), 2.0));
let im = vectorcraft_doc::ImageObject {
key: "k".into(),
width: 10,
height: 10,
xf: vectorcraft_geom::Affine::IDENTITY,
link: None,
placement: Default::default(),
pixels: None,
};
let image = masked_by(Node::new(NodeId(1), NodeKind::Image(Box::new(im))), stroked.clone(), true);
let path = masked_by(white_square(2), stroked, true);
let mut g = Node::group(NodeId(10), vec![Arc::new(image), Arc::new(path)]);
let params = serde_json::json!({"scaleH": 200, "scaleV": 200, "strokes": true});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let width = |n: &Node| n.extras().mask.as_deref().unwrap().art.appearance.stroke().map(|s| s.width);
let ch = art.children().unwrap();
assert_eq!(width(&ch[1]), Some(4.0), "the path's mask");
assert_eq!(width(&ch[0]), width(&ch[1]), "the image's mask");
}
/// With Transform Objects off and Scale Strokes & Effects on, a group's Transform effect scales the
/// strokes of a member's linked mask as it scales the member's, and moves neither.
#[test]
fn a_transform_of_strokes_only_scales_a_members_mask_strokes() {
let stroked = |id: u64| {
Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(Paint::None, Paint::solid(Color::WHITE), 2.0))
};
let mut g = Node::group(NodeId(10), vec![Arc::new(masked_by(stroked(1), stroked(4), true))]);
let params = serde_json::json!({"scaleH": 200, "scaleV": 200, "objects": false, "strokes": true});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let member = &art.children().unwrap()[0];
let mask = &member.extras().mask.as_deref().unwrap().art;
assert_eq!(member.appearance.stroke().map(|s| s.width), Some(4.0), "the member's stroke");
assert_eq!(mask.appearance.stroke().map(|s| s.width), Some(4.0), "the mask's stroke");
assert_eq!(mask.geometric_bounds(), member.geometric_bounds());
}
/// The art of a member group's mask is copied as it was before the first effect: a mask of one
/// path takes a second Transform effect's copies path by path, as the path it masks does, though
/// the first effect (with Scale Strokes & Effects) made it a group of copies.
#[test]
fn a_masks_art_is_copied_as_it_was_before_the_first_effect() {
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), white_square(4), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(inner)]);
for strokes in [true, false] {
let params = serde_json::json!({"moveH": 30, "copies": 2, "strokes": strokes});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
}
let art = evaluate_container(None, &g).unwrap();
let inner = &art.children().unwrap()[0];
let mask = &inner.extras().mask.as_deref().unwrap().art;
assert_eq!(mask.geometric_bounds(), inner.geometric_bounds());
let kinds = |n: &Node| n.children().unwrap().iter().map(|c| std::mem::discriminant(&c.kind)).collect::<Vec<_>>();
let paths = &inner.children().unwrap()[0];
assert_eq!(kinds(paths).len(), 3, "the first effect's three paths");
assert!(paths.children().unwrap().iter().all(|c| matches!(c.kind, NodeKind::Compound { .. })), "each with its copies");
assert_eq!(kinds(mask), kinds(paths), "the mask's art takes the copies as the paths do");
}
/// A 10 × 10 image with id `id` at the origin.
fn image_node(id: u64) -> Node {
let im = vectorcraft_doc::ImageObject {
key: "k".into(),
width: 10,
height: 10,
xf: vectorcraft_geom::Affine::IDENTITY,
link: None,
placement: Default::default(),
pixels: None,
};
Node::new(NodeId(id), NodeKind::Image(Box::new(im)))
}
/// A linked mask whose art is an image moves with the path it masks under a group's Transform
/// effect, and a member group's image mask takes the copies its paths take.
#[test]
fn a_groups_transform_moves_a_linked_mask_whose_art_is_an_image() {
let mut g = Node::group(NodeId(10), vec![Arc::new(masked_by(white_square(1), image_node(4), true)), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(reshaping_effects()[0].clone());
let art = evaluate_container(None, &g).unwrap();
let member = &art.children().unwrap()[0];
assert_eq!(member.geometric_bounds(), Some(Rect::new(30.0, 0.0, 40.0, 10.0)));
assert_eq!(member.extras().mask.as_deref().unwrap().art.geometric_bounds(), member.geometric_bounds());
let inner = masked_by(Node::group(NodeId(2), vec![Arc::new(white_square(1))]), image_node(4), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(inner)]);
let params = serde_json::json!({"moveH": 30, "copies": 2});
g.appearance.effects.push(Effect { id: "distort.transform".into(), params, visible: true });
let art = evaluate_container(None, &g).unwrap();
let inner = &art.children().unwrap()[0];
assert_eq!(inner.geometric_bounds(), Some(Rect::new(0.0, 0.0, 70.0, 10.0)));
let mask = &inner.extras().mask.as_deref().unwrap().art;
assert_eq!(mask.geometric_bounds(), inner.geometric_bounds(), "the image and its copies");
}
/// An image in a linked mask's art takes no geometry effect but Transform, so under a Warp effect
/// the art keeps its shape with its mask.
#[test]
fn art_whose_mask_holds_an_image_keeps_its_shape_under_a_warp() {
let member = masked_by(white_square(1), Node::group(NodeId(3), vec![Arc::new(image_node(4))]), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(member), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(reshaping_effects()[4].clone());
let art = evaluate_container(None, &g).unwrap();
let member = &art.children().unwrap()[0];
assert_eq!(member.path_data(), white_square(1).path_data(), "the path keeps its shape");
assert_eq!(member.extras().mask.as_deref().unwrap().art.geometric_bounds(), Some(Rect::new(0.0, 0.0, 10.0, 10.0)));
}
/// A Warp effect bends an image's pixels but not the art of its linked mask, so art with such an
/// image keeps its shape under the warp, with the image and its mask.
#[test]
fn art_with_a_masked_image_keeps_its_shape_under_a_warp() {
let image = masked_by(image_node(1), white_square(4), true);
let mut g = Node::group(NodeId(10), vec![Arc::new(image.clone()), sq(2, 20.0, Color::BLACK)]);
g.appearance.effects.push(reshaping_effects()[4].clone());
let art = evaluate_container(None, &g).unwrap();
let ch = art.children().unwrap();
assert_eq!(*ch[0], image, "the image and its mask");
assert_eq!(ch[1].path_data(), sq(2, 20.0, Color::BLACK).path_data(), "the path keeps its shape");
}
/// A symbol instance in perspective projects the linked masks of the objects in its art with them.
#[test]
fn perspective_projects_the_masks_in_a_symbols_art() {
let art = Node::group(NodeId(20), vec![Arc::new(masked_by(white_square(21), white_square(22), true))]);
let mut instance = Node::new(NodeId(1), NodeKind::SymbolInstance { symbol: "s".into(), xf: vectorcraft_geom::Affine::IDENTITY });
let mut at = vectorcraft_doc::PerspectiveAttachment::new("left", 0.0);
at.projection = Some([1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.01, 0.0, 1.0]);
instance.extras_mut().perspective = Some(Box::new(at));
let out = crate::reshape::reshape(None, &instance, Some(&art)).unwrap();
let mut masked = vec![];
out.walk(&mut |c| masked.extend(c.extras().mask.as_deref().map(|m| (c.path_data().cloned(), m.art.path_data().cloned()))));
let [(path, mask)] = masked.as_slice() else { panic!("one masked path: {masked:?}") };
assert!(path != &white_square(21).path_data().cloned(), "the path is projected");
assert_eq!(mask, path, "and so is its mask");
}
/// A group with `effect` holding `n` vertical then `n` horizontal bars, 2 wide on a 4-unit
/// pitch, each crossing every bar of the other direction: n² crossings.
fn crossing_bars(n: usize, effect: &str) -> Node {
+427 -59
View File
@@ -12,7 +12,7 @@
//! strokes paint only the shape that a Convert to Shape or Outline Object effect on them gives
//! them ([`image_rows`]).
use std::collections::HashSet;
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
@@ -590,7 +590,7 @@ fn as_art_opts(
transform_items(&mut art, paint_doc);
// Type and symbols in perspective: the art projected onto their plane.
if let Some(h) = n.projection() {
project_leaves(&mut art, &h);
project_leaves(&mut art, &h, paint_doc);
}
// The art is a group with `n`'s id (for an image without fills or strokes that paint, a clip
// group).
@@ -608,9 +608,29 @@ fn as_art_opts(
Some(out)
}
/// Map every path under `art` (and its gradients) through the projective map `h`, curves split
/// finely enough to follow it.
fn project_leaves(art: &mut Node, h: &vectorcraft_geom::Homography) {
/// Map every path under `art` (and its gradients), and every path in the art of the linked opacity
/// masks of the objects under it, through the projective map `h`, curves split finely enough to
/// follow it. The type and live objects in the art of those masks are outlined and evaluated
/// first ([`outlined_members`], with the symbols of `doc`).
fn project_leaves(art: &mut Node, h: &vectorcraft_geom::Homography, doc: Option<&Document>) {
project_paths(art, h);
each_linked_mask_mut(art, false, 0, &mut |m| {
*m = outlined_mask_art(doc, m);
project_paths(m, h);
});
}
/// `art`, the art of an opacity mask, with type and live objects in it outlined and evaluated
/// ([`outlined_members`]), and as art that keeps its look ([`as_art`]) when it is type itself.
fn outlined_mask_art(doc: Option<&Document>, art: &Node) -> Node {
match art.kind {
NodeKind::Text(_) => as_art(doc, art, None).unwrap_or_else(|| art.clone()),
_ => outlined_members(doc, art),
}
}
/// The paths of [`project_leaves`] outside the art of masks.
fn project_paths(art: &mut Node, h: &vectorcraft_geom::Homography) {
let f = |p: vectorcraft_geom::Point| h.apply(p).unwrap_or(p);
let piece = art.geometric_bounds().map_or(1.0, |b| (b.width().max(b.height()) / 64.0).max(0.25));
let project = |path: &mut PathData| *path = vectorcraft_doc::live::map_nonlinear(path, piece, f);
@@ -687,58 +707,151 @@ fn hoist_copies(art: &mut Node) {
/// whose swatches and patterns must be in `doc` (without one, pieces that name one are refused).
/// Returns how gradients that paint the art as a whole follow the effects. A deferred live-effect
/// plug-in is listed by its index in `owner`, the effect list `fx` was taken from, or in `fx` when
/// `owner` does not hold it.
/// `owner` does not hold it. The art of the linked opacity masks of the objects in `art` (not of
/// `art` itself) takes each effect as the paths it masks do ([`Step::reshape_masks`]), with the
/// type and live objects in it outlined and evaluated first ([`outlined_members`]). When a mask
/// stays as it was, or a Transform effect makes fewer copies than it asks for, art with linked
/// masks keeps its shape under that effect.
fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget: Budget, apart: bool, doc: Option<&Document>) -> crate::Carry {
let mut whole = crate::Carry::default();
if fx.is_empty() {
return whole;
}
let mut leaves_safe = true;
for_each_leaf(art, &mut |leaf| {
if !leaves_safe {
return;
}
if let Some((_, rule)) = leaf_geometry(leaf) {
let has_stroke = leaf.appearance.stroke().is_some_and(|s| !s.paint.is_none() && s.width > 0.0);
if rule != FillRule::NonZero || has_stroke {
leaves_safe = false;
}
}
});
let masked = has_linked_mask(art, false);
if masked {
each_linked_mask_mut(art, false, 0, &mut |m| *m = outlined_mask_art(doc, m));
}
let mut masks_safe = true;
each_linked_mask(art, false, 0, &mut |_, m| masks_safe &= leaves_safe(m));
let art_stroke = art.appearance.stroke().is_some_and(|s| !s.paint.is_none() && s.width > 0.0);
let style_safe = leaves_safe && !art_stroke;
let style_safe = leaves_safe(art) && masks_safe && !art_stroke;
let listed = fx;
let opt_fx = crate::geometry::optimize_geometry_effects(fx, style_safe);
let fx = opt_fx.as_slice();
let seed = art.id.0;
let mut used = art_cost(art);
each_linked_mask(art, false, 0, &mut |_, m| used = used.plus(art_cost(m)));
let max = budget.at_least(used);
// Read before the effects run: a path's own copies don't make it art of several objects.
// Read before the effects run: a path's own copies don't make it art of several objects. The
// same holds for the art of each mask, listed by the object it masks.
let copy_whole = copies_whole(art);
let mut wholes = HashMap::new();
each_linked_mask(art, false, 0, &mut |id, m| {
wholes.entry(id).or_insert_with(|| copies_whole(m));
});
let mut warped = WarpedImages::new();
for e in fx {
let Some(bounds) = warped.bounds(art) else { break };
let params = merged_params(&e.id, &e.params);
// Where a live-effect plug-in sits, which it is listed by when it is deferred.
let effect = owner.iter().position(|x| std::ptr::eq(x, *e)).or_else(|| listed.iter().position(|x| std::ptr::eq(*x, *e)));
let step = Step { e, params: &params, bounds, seed, effect, apart, doc, wholes: &wholes };
// Art with linked masks keeps its shape under an effect that a mask in it could not take
// as the art it masks did, so no mask is left apart from its art.
let before = masked.then(|| (art.clone(), used));
let ran = step.run(art, max, &mut used, copy_whole, Some(&mut warped), false, 0);
if (ran.masks || ran.short)
&& let Some((was, cost)) = before
{
*art = was;
used = cost;
continue;
}
if let Some(carry) = ran.whole {
whole.push(carry);
}
}
cut_warped_images(art, &warped);
whole
}
/// One geometry effect of an object run over its art ([`reshape_leaves_apart`]): the effect, its
/// merged params, the reference box and seed of the object's art, where a deferred live-effect
/// plug-in is listed, whether each Transform copy becomes an object, the document that the
/// swatches and patterns of painted pieces are looked up in, and [`copies_whole`] of the art of
/// each linked mask before the first effect, by the id of the object it masks.
struct Step<'a> {
e: &'a Effect,
params: &'a serde_json::Value,
bounds: Rect,
seed: u64,
effect: Option<usize>,
apart: bool,
doc: Option<&'a Document>,
wholes: &'a HashMap<NodeId, bool>,
}
/// What [`Step::run`] did to a piece of art.
struct Ran {
/// A path in the art kept its shape (past the budget).
kept: bool,
/// The linked opacity mask of an object in the art stayed as it was while the paths it masks
/// took the effect, or could have ([`Step::reshape_masks`]).
masks: bool,
/// A Transform effect made fewer copies of a path, image or symbol instance than it asks for
/// (past the budget or out of reach), where a linked mask could take a different number.
short: bool,
/// How what paints the art as a whole follows the effect, when it does.
whole: Option<crate::Carry>,
}
impl Ran {
/// Nothing in the art kept its shape or made fewer copies, and every linked mask in it moved.
fn complete(&self) -> bool {
!self.kept && !self.masks && !self.short
}
}
impl Step<'_> {
/// Run the effect over `art`, whose paths and those of the linked opacity masks in it keep to
/// `max` together with what they cost so far (`used`). `copy_whole` is [`copies_whole`] of the
/// art, or of a mask's art, before the first effect. `warped` lists the images Warp effects
/// bend in the art ([`WarpedImages`]); a mask's art has none. With `own`, `art` is the art of a
/// mask, and its own linked mask takes the effect too. `depth` counts the masks `art` is in. A
/// live-effect plug-in that paints its pieces leaves a mask's art, and art that holds objects
/// with linked masks, as they are and reports the masks as stayed: a mask can't take the
/// pieces as the art it masks does. So does a Warp effect that bends an image with a linked
/// mask.
#[allow(clippy::too_many_arguments)]
fn run(
&self,
art: &mut Node,
max: Budget,
used: &mut Budget,
copy_whole: bool,
mut warped: Option<&mut WarpedImages>,
own: bool,
depth: usize,
) -> Ran {
let (e, params, bounds, seed) = (self.e, self.params, self.bounds, self.seed);
let stayed = Ran { kept: false, masks: true, short: false, whole: None };
if let Some(plugin) = painted_plugin(e) {
let at = effect.map(|effect| vectorcraft_plugins::deferred::Stage { object: seed, effect, item: None });
if own || has_linked_mask(art, false) {
return stayed;
}
let at = self.effect.map(|effect| vectorcraft_plugins::deferred::Stage { object: seed, effect, item: None });
for_each_leaf(art, &mut |leaf| {
let Some((path, _)) = leaf_geometry(leaf) else { return };
let before = Budget::of(&path);
let room = max.minus(used.minus(before));
if let Some(made) = paint_leaf(leaf, plugin, &params, bounds, room, doc, at) {
used = used.minus(before).plus(made);
if let Some(made) = paint_leaf(leaf, plugin, params, bounds, room, self.doc, at) {
*used = used.minus(before).plus(made);
}
});
continue;
return Ran { kept: false, masks: false, short: false, whole: None };
}
// A Warp effect that bends images ([`mark_warped_images`]) bends an image's pixels, not the
// art of its linked mask.
let warp = e.id.strip_prefix("warp.").and_then(crate::warp::WarpStyle::from_id).filter(|_| crate::warp::bends(&e.id, params));
if warp.is_some() && has_masked_image(art) {
return stayed;
}
// Placed gradients follow a Transform effect, Free Distort and the Warp effects
// ([`crate::Carry`]): under Free Distort and Warp (`boxes`) each path's move and scale from
// its bounds before the effect to its bounds after it. Under those and the other effects,
// the placed gradients of type's outlines in `art` (`outline_text`) move and scale with
// the outlines' bounds.
let follows = crate::Carry::follows(&e.id, &params, bounds, seed);
let follows = crate::Carry::follows(&e.id, params, bounds, seed);
let boxes = follows && crate::Carry::by_bounds(&e.id);
let mut outlines = vec![];
if !follows || boxes {
@@ -754,30 +867,61 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
// The images earlier Warps bend are measured by their pieces only when a group's
// gradient needs the bounds.
if !groups.is_empty()
&& let Some(images) = warped.when_cut(art)
&& let Some(images) = warped.as_deref().and_then(|w| w.when_cut(art))
{
groups.clear();
group_marks(art, &mut vec![], &HashSet::new(), Some(images), &mut groups);
}
}
// The ids of the paths that kept their shape (past the budget), and their places in the
// order [`for_each_leaf`] visits the paths.
// order [`for_each_leaf`] visits the paths; and the ids of the paths whose linked masks
// moved with them as they were transformed as objects.
let mut kept_ids = HashSet::new();
let mut kept_leaves = HashSet::new();
let mut leaf_at = 0usize;
let mut moved_ids = HashSet::new();
let transform = (e.id == "distort.transform").then(|| {
let (m, copies) = crate::distort::transform_map(bounds, &params, seed);
let options = crate::distort::TransformOptions::of(&params);
(m, copies, options, crate::distort::transform_affine(bounds, &params, seed))
let (m, copies) = crate::distort::transform_map(bounds, params, seed);
let options = crate::distort::TransformOptions::of(params);
(m, copies, options, crate::distort::transform_affine(bounds, params, seed))
});
// In a mask's art, images and symbol instances take only a Transform effect
// ([`transform_placed`]): a mask's art that holds one can't take another effect as the art
// it masks does.
if own && transform.is_none() && (is_placed(art) || placed_count(art) > 0) {
return Ran { kept: false, masks: true, short: false, whole: None };
}
// Art of several objects is copied whole, so the copies don't interleave member by member.
// The copies of its members carry their linked masks, moved with them.
if let Some((m, copies, options, _)) = transform
&& copies > 0
&& copy_whole
{
used = copy_art(art, m, copies, copy_scaling(options), max);
continue;
if !own {
*used = copy_art(art, m, copies, copy_scaling(options), max);
return Ran { kept: false, masks: false, short: false, whole: None };
}
// A mask's art: its copies keep to what the rest of the art leaves of `max`, and the
// linked mask of the art itself takes them too. That mask's art stays in `used`, as
// [`copy_art`] counts only the members.
let before = copy_cost(art);
let rest = used.minus(before).plus(art.extras().mask.as_deref().map_or(Budget { anchors: 0, lines: 0 }, |k| copy_cost(&k.art)));
let made = copy_art(art, m, copies, copy_scaling(options), max.minus(rest));
*used = rest.plus(made);
let short = art.children().is_some_and(|c| c.iter().filter(|c| !c.is_guide()).count() <= copies);
let none = HashSet::new();
let masks = self.reshape_own_mask(art, &Skip { moved: &none, kept: &none }, max, used, depth);
return Ran { kept: false, masks, short, whole: None };
}
// A shortfall in the copies matters for the objects a linked mask above them covers, which
// the mask would take a different number of copies than, and anywhere in a mask's art.
let watch = transform.is_some_and(|(_, copies, options, _)| copies > 0 && options.objects) && (own || has_linked_mask(art, false));
let mut covered = HashSet::new();
if watch && !own {
masked_ids(art, false, &mut covered);
}
let counts = |id: NodeId| watch && (own || covered.contains(&id));
let mut short = false;
for_each_leaf(art, &mut |leaf| {
let at = leaf_at;
leaf_at += 1;
@@ -790,15 +934,26 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
// strokes; a gradient paints each copy by itself, not the one piece the copies
// make together; and Expand Appearance (`apart`) makes each copy an object.
// Fills and strokes that stack paint each copy below the one before (#5920, #6316).
// Each copy of a path with a linked mask carries the mask, moved with it.
let separate = copies > 0
&& (apart
&& (self.apart
|| leaf.appearance.has_unplaced_gradient()
|| leaf.appearance.has_placed_gradient()
|| paints_copies_apart(&leaf.appearance, rule));
|| paints_copies_apart(&leaf.appearance, rule)
|| leaf.extras().mask.as_ref().is_some_and(|m| m.linked));
// The copies of a path replace it by a group of them, the path included.
let copied = |leaf: &Node| leaf.children().map_or(0, Vec::len);
if options.reach_appearance() {
let (made, moved) = transform_leaf(leaf, &path, map, copies, options, room);
used = used.minus(before).plus(made);
if !moved {
*used = used.minus(before).plus(made);
if moved {
// With Transform Objects off the path stays, and its mask takes the
// effect's stroke and pattern changes as its own art.
if options.objects {
moved_ids.insert(leaf.id);
}
short |= counts(leaf.id) && copied(leaf) <= copies;
} else {
kept_ids.insert(leaf.id);
}
return;
@@ -806,20 +961,28 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
if separate {
let scaling = vectorcraft_doc::Scaling { keep_fit_when_flat: true, ..Default::default() };
let made = copy_leaf(leaf, &path, m, copies, scaling, room);
used = used.minus(before).plus(made);
*used = used.minus(before).plus(made);
moved_ids.insert(leaf.id);
short |= counts(leaf.id) && copied(leaf) <= copies;
return;
}
}
let stage = effect.map(|effect| vectorcraft_plugins::deferred::Stage { object: seed, effect, item: None });
let Some(out) = apply_one(&e.id, &params, &path, bounds, &GeomContext { seed, stage, ..GeomContext::of(leaf) }, room) else {
let stage = self.effect.map(|effect| vectorcraft_plugins::deferred::Stage { object: seed, effect, item: None });
let Some(out) = apply_one(&e.id, params, &path, bounds, &GeomContext { seed, stage, ..GeomContext::of(leaf) }, room) else {
kept_ids.insert(leaf.id);
kept_leaves.insert(at);
return;
};
used = used.minus(before).plus(Budget::of(&out));
// A Transform effect's copies of a path are subpaths of it, each with the path's anchors.
if counts(leaf.id)
&& let Some((_, copies, _, _)) = transform
{
short |= out.anchor_count() < path.anchor_count().saturating_mul(copies.saturating_add(1));
}
*used = used.minus(before).plus(Budget::of(&out));
if follows && !boxes {
// A gradient fitted to the path fits the path's own bounds.
let carry = crate::Carry::of(&e.id, &params, bounds, path.bounds(), None, seed);
let carry = crate::Carry::of(&e.id, params, bounds, path.bounds(), None, seed);
if carry.moves(&leaf.appearance) {
carry.apply(&mut leaf.appearance);
}
@@ -832,36 +995,230 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
// Warp bends images too: each one's pixels follow the warp's map over the same box. The
// images are cut into pieces once, after the last effect ([`cut_warped_images`]). An image
// whose clipping frame kept its shape (past the budget) keeps its pixels as they are.
if let Some(style) = e.id.strip_prefix("warp.").and_then(crate::warp::WarpStyle::from_id)
&& crate::warp::bends(&e.id, &params)
if let Some(style) = warp
&& let Some(warped) = warped.as_deref_mut()
{
let f: WarpMap = Rc::from(crate::warp::warp_map(bounds, style, &params));
let f: WarpMap = Rc::from(crate::warp::warp_map(bounds, style, params));
warped.reserve(art);
mark_warped_images(art, &f, &kept_leaves, false, &mut 0, &mut warped);
mark_warped_images(art, &f, &kept_leaves, false, &mut 0, warped);
}
if let Some((m, copies, options, _)) = transform
&& options.objects
{
transform_placed(art, m, copies);
// A mask's art that is one image or symbol instance is placed as the only member of a
// group of it.
let root = is_placed(art);
if root {
let id = art.id;
let one = std::mem::replace(art, Node::group(id, vec![]));
*art = Node::group(id, vec![Arc::new(one)]);
}
let placed = if watch { masked_placed(art, own) } else { 0 };
transform_placed(art, m, copies, copy_scaling(options));
short |= watch && masked_placed(art, own) < placed.saturating_mul(copies.saturating_add(1));
if root && let Some([one]) = art.children().map(Vec::as_slice) {
*art = (**one).clone();
}
}
if outlines.iter().any(Option::is_some) {
rebase_type_outlines(art, &mut outlines.into_iter());
}
// Under Transform copies, a mask takes the copies as the paths it masks do; the copies of a
// path with a mask of its own each carry it ([`copy_leaf`]).
let masks = self.reshape_masks(art, own, &Skip { moved: &moved_ids, kept: &kept_ids }, max, used, depth);
// What paints the art as a whole, and the own fills and strokes of the groups inside it,
// follow their bounds under Free Distort and Warp (they stay when no path changed them).
// Each stays when a path under it that its bounds measure kept its shape (past the budget).
let mut after = vec![];
let images = if groups.is_empty() { None } else { warped.when_cut(art) };
let images = if groups.is_empty() { None } else { warped.as_deref().and_then(|w| w.when_cut(art)) };
let held = (!groups.is_empty() || !kept_ids.is_empty()) && group_marks(art, &mut vec![], &kept_ids, images, &mut after).1;
if !groups.is_empty() {
carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, &params, bounds, from, to, seed));
carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, params, bounds, from, to, seed));
}
if follows && !held {
whole.push(crate::Carry::of(&e.id, &params, bounds, Some(bounds), warped.bounds(art), seed));
let drawn = warped.as_deref().map_or_else(|| art.geometric_bounds(), |w| w.bounds(art));
let whole = (follows && !held).then(|| crate::Carry::of(&e.id, params, bounds, Some(bounds), drawn, seed));
Ran { kept: !kept_ids.is_empty(), masks, short, whole }
}
/// Run the effect over the art of the linked opacity mask of `n` (with `own`) and of each path,
/// compound path, group and layer under it, with the art's reference box, as the paths the mask
/// covers take it: the mask moves and bends with what it masks. The mask of an object
/// transformed as an object moved with it already and is left as it is. A mask stays as it was
/// past [`vectorcraft_doc::depth::MAX_DEPTH`] masks inside masks, and for the reasons
/// [`Step::reshape_own_mask`] gives. Returns whether a mask stayed for one of those reasons.
fn reshape_masks(&self, n: &mut Node, own: bool, skip: &Skip, max: Budget, used: &mut Budget, depth: usize) -> bool {
if depth >= vectorcraft_doc::depth::MAX_DEPTH || !has_linked_mask(n, own) {
return false;
}
let mut stayed = own && self.reshape_own_mask(n, skip, max, used, depth);
if let NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } = &mut n.kind {
for c in children.iter_mut() {
if has_linked_mask(c, true) {
stayed |= self.reshape_masks(Arc::make_mut(c), true, skip, max, used, depth);
}
}
}
stayed
}
/// Run the effect over the art of the linked opacity mask of `n` itself, when `n` is a path,
/// compound path, group or layer that `skip` does not list as moved. The mask stays as it was
/// when a path it masks kept its shape, and when its own art could not take the effect whole: a
/// path in it would keep its shape, its copies would stop short, or a mask inside it would stay
/// (no mask is left half moved). Returns whether the mask stayed for one of those reasons.
fn reshape_own_mask(&self, n: &mut Node, skip: &Skip, max: Budget, used: &mut Budget, depth: usize) -> bool {
if depth >= vectorcraft_doc::depth::MAX_DEPTH || !reshapes_mask_of(n) || skip.moved.contains(&n.id) {
return false;
}
let stays = holds_any(n, skip.kept);
let id = n.id;
let Some(m) = n.extras_if_any().and_then(|x| x.mask.as_mut()).filter(|m| m.linked) else { return false };
let before = *used;
let mut art = (*m.art).clone();
let whole = self.wholes.get(&id).copied().unwrap_or_else(|| copies_whole(&art));
let ran = (!stays).then(|| self.run(&mut art, max, used, whole, None, true, depth + 1));
match ran {
Some(ran) if ran.complete() => {
// What paints the mask's art as a whole follows the effect as the art does.
if let Some(carry) = ran.whole
&& carry.moves(&art.appearance)
{
carry.apply(&mut art.appearance);
}
m.art = Arc::new(art);
false
}
_ => {
*used = before;
true
}
}
}
cut_warped_images(art, &warped);
whole
}
/// The objects whose linked masks [`Step::reshape_masks`] leaves as they are: those transformed
/// as objects (`moved`), and those holding a path that kept its shape (`kept`).
struct Skip<'a> {
moved: &'a HashSet<NodeId>,
kept: &'a HashSet<NodeId>,
}
/// Is `n` an object whose linked opacity mask a geometry effect on the art it is in reshapes with
/// it: a path, compound path, group or layer? An image or symbol instance moves its mask only
/// with the map a Transform effect places it by ([`transform_placed`]).
fn reshapes_mask_of(n: &Node) -> bool {
matches!(n.kind, NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } | NodeKind::Group { .. } | NodeKind::Layer { .. })
}
/// Does `n` (with `own`) or a path, compound path, group or layer under it carry a linked opacity
/// mask that [`Step::reshape_masks`] reshapes?
fn has_linked_mask(n: &Node, own: bool) -> bool {
let mine = own && reshapes_mask_of(n) && n.extras().mask.as_ref().is_some_and(|m| m.linked);
mine || match &n.kind {
NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => children.iter().any(|c| has_linked_mask(c, true)),
_ => false,
}
}
/// Run `f` on the id of `n` (with `own`) and of each path, compound path, group and layer under it
/// that carries a linked opacity mask, with the art of that mask, and on the masks inside that
/// art, as [`Step::reshape_masks`] reaches them: `depth` masks deep already, up to
/// [`vectorcraft_doc::depth::MAX_DEPTH`].
fn each_linked_mask(n: &Node, own: bool, depth: usize, f: &mut dyn FnMut(NodeId, &Node)) {
if depth >= vectorcraft_doc::depth::MAX_DEPTH {
return;
}
if own
&& reshapes_mask_of(n)
&& let Some(m) = n.extras().mask.as_deref().filter(|m| m.linked)
{
f(n.id, &m.art);
each_linked_mask(&m.art, true, depth + 1, f);
}
if let NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } = &n.kind {
for c in children {
each_linked_mask(c, true, depth, f);
}
}
}
/// [`each_linked_mask`] that changes the art of each mask: `f` runs on a mask's art before the
/// masks inside it are reached.
fn each_linked_mask_mut(n: &mut Node, own: bool, depth: usize, f: &mut dyn FnMut(&mut Node)) {
if depth >= vectorcraft_doc::depth::MAX_DEPTH || !has_linked_mask(n, own) {
return;
}
if own
&& reshapes_mask_of(n)
&& let Some(m) = n.extras_if_any().and_then(|x| x.mask.as_mut()).filter(|m| m.linked)
{
let art = Arc::make_mut(&mut m.art);
f(art);
each_linked_mask_mut(art, true, depth + 1, f);
}
if let NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } = &mut n.kind {
for c in children.iter_mut() {
if has_linked_mask(c, true) {
each_linked_mask_mut(Arc::make_mut(c), true, depth, f);
}
}
}
}
/// Does [`Step::reshape_masks`] reshape the linked opacity mask of `n` itself?
fn has_own_linked_mask(n: &Node) -> bool {
reshapes_mask_of(n) && n.extras().mask.as_ref().is_some_and(|m| m.linked)
}
/// Add to `out` the ids of the objects under `n` that the linked opacity mask of an object above
/// them covers (every one of them with `under`).
fn masked_ids(n: &Node, under: bool, out: &mut HashSet<NodeId>) {
for c in n.children().into_iter().flatten() {
if under {
out.insert(c.id);
}
masked_ids(c, under || has_own_linked_mask(c), out);
}
}
/// How many images and symbol instances under `n` the linked opacity mask of an object above them
/// covers (every one of them with `under`).
fn masked_placed(n: &Node, under: bool) -> usize {
n.children().into_iter().flatten().map(|c| usize::from(under && is_placed(c)) + masked_placed(c, under || has_own_linked_mask(c))).sum()
}
/// Is `n`, or anything under it, one of `ids`?
fn holds_any(n: &Node, ids: &HashSet<NodeId>) -> bool {
if ids.is_empty() {
return false;
}
let mut any = false;
n.walk(&mut |c| any |= ids.contains(&c.id));
any
}
/// Do the paths under `n` that [`for_each_leaf`] visits all fill by the non-zero rule without a
/// stroke that paints? Effects then reshape their outlines alike in any order that the
/// optimization of [`crate::geometry::optimize_geometry_effects`] takes.
fn leaves_safe(n: &Node) -> bool {
match &n.kind {
NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } => {
let has_stroke = n.appearance.stroke().is_some_and(|s| !s.paint.is_none() && s.width > 0.0);
leaf_geometry(n).is_none_or(|(_, rule)| rule == FillRule::NonZero && !has_stroke)
}
NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => children.iter().all(|c| leaves_safe(c)),
_ => true,
}
}
/// Is there an image with a linked opacity mask among the members of `n`, or among its groups'
/// and layers' members, which [`mark_warped_images`] walks?
fn has_masked_image(n: &Node) -> bool {
let (NodeKind::Group { children, .. } | NodeKind::Layer { children, .. }) = &n.kind else { return false };
children.iter().any(|c| match c.kind {
NodeKind::Image(_) => c.extras().mask.as_ref().is_some_and(|m| m.linked),
_ => has_masked_image(c),
})
}
/// Largest factor a Transform effect's Scale Strokes & Effects scales one object's strokes by
@@ -1082,7 +1439,9 @@ fn copy_leaf(leaf: &mut Node, path: &PathData, m: Affine, copies: usize, scaling
let mut copy = leaf.clone();
copy.transform(xf, scaling);
// Each copy's own geometry effects make a different amount, as the copy and its effects scale.
let cost = Budget::of(&moved).plus(effects_cost(&copy, &moved));
let mut cost = Budget::of(&moved).plus(effects_cost(&copy, &moved));
// Each copy carries the art of its linked masks, moved with it.
each_linked_mask(&copy, true, 0, &mut |_, m| cost = cost.plus(art_cost(m)));
if !budget.fits(made.plus(cost)) || !copy.geometric_bounds().is_some_and(crate::distort::within_reach) {
break;
}
@@ -1622,17 +1981,20 @@ fn box_map(from: Rect, to: Rect) -> vectorcraft_geom::Affine {
/// Apply the Transform effect's map `m` to every image and symbol instance under `n`, as
/// [`for_each_leaf`] does to paths: the map goes into the object's placement, and `copies` more
/// follow, each mapped once more than the last. Without copies the object itself takes the map,
/// as a path does.
fn transform_placed(n: &mut Node, m: Affine, copies: usize) {
transform_placed_within(n, m, copies, crate::distort::MAX_COPY_OBJECTS)
/// as a path does. The art of each one's linked opacity mask takes the map with `scaling`, as a
/// path's mask does.
fn transform_placed(n: &mut Node, m: Affine, copies: usize, scaling: vectorcraft_doc::Scaling) {
let mut room = crate::distort::MAX_COPY_OBJECTS.saturating_sub(placed_count(n));
copy_placed(n, m, copies, scaling, &mut room);
}
/// [`transform_placed`] whose copies make at most `max` image and symbol instance nodes of the art,
/// the originals included: each copy adds the object once more, and a Transform after this one
/// copies the lot again, so copies stop where the result would pass `max` (#2042).
#[cfg(test)]
pub(crate) fn transform_placed_within(n: &mut Node, m: Affine, copies: usize, max: usize) {
let mut room = max.saturating_sub(placed_count(n));
copy_placed(n, m, copies, &mut room);
copy_placed(n, m, copies, vectorcraft_doc::Scaling::default(), &mut room);
}
/// Rows and columns of the pieces a Warp effect cuts an image into (VectorCraft's own number).
@@ -1864,11 +2226,11 @@ fn is_placed(n: &Node) -> bool {
/// document order, each copy taking one from `room` (what the art can still grow by), until the
/// budget is full. As with a path, the copies stop before one reaches past
/// [`crate::distort::within_reach`].
fn copy_placed(n: &mut Node, m: Affine, copies: usize, room: &mut usize) {
fn copy_placed(n: &mut Node, m: Affine, copies: usize, scaling: vectorcraft_doc::Scaling, room: &mut usize) {
let Some(children) = n.children_mut() else { return };
for c in children.iter_mut() {
if !is_placed(c) {
copy_placed(Arc::make_mut(c), m, copies, room);
copy_placed(Arc::make_mut(c), m, copies, scaling, room);
continue;
}
let src = (**c).clone();
@@ -1887,6 +2249,12 @@ fn copy_placed(n: &mut Node, m: Affine, copies: usize, room: &mut usize) {
if xf != Affine::IDENTITY && one.appearance.has_positioned_gradient() {
one.appearance.transform_gradients(xf);
}
// So does the art of its linked opacity mask.
if xf != Affine::IDENTITY
&& let Some(m) = one.extras_if_any().and_then(|x| x.mask.as_mut()).filter(|m| m.linked)
{
Arc::make_mut(&mut m.art).transform(xf, scaling);
}
one
};
if copies == 0 {
+38 -10
View File
@@ -367,9 +367,12 @@ pub struct Slice {
}
impl Slice {
/// The slice's paint: its piece of `g` as a linear gradient placed from `from` to `to`.
pub fn paint(&self, g: &Gradient) -> Paint {
let gradient = g.span(self.span.0 as f32, self.span.1 as f32);
/// The slice's paint: its piece of `unrolled` as a linear gradient placed from `from` to `to`.
/// `unrolled` is the stroke's gradient as [`Gradient::unrolled`] gives it (unrolled once for
/// all the slices), so one that repeats or reflects runs its stops that many times along (or
/// across) the stroke.
pub fn paint(&self, unrolled: &Gradient) -> Paint {
let gradient = unrolled.span(self.span.0 as f32, self.span.1 as f32);
let end = if self.from.distance(self.to) > 1e-9 { self.to } else { self.from + Vec2::new(1.0, 0.0) };
let geom = GradientGeom { start: self.from, end, aspect: 1.0, focal: None };
Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), angle: geom.angle_deg(), ..GradientPaint::new(gradient) }))
@@ -471,35 +474,60 @@ pub fn written_slices(bp: &BezPath, rule: FillRule, st: &StrokeLayer, outlines:
_ => vectorcraft_pathops::stroke_region(outlines).to_bezpath(),
};
let grow = if g.stops.iter().all(|s| s.opacity >= 1.0) { SLICE_GROW } else { 0.0 };
let unrolled = g.unrolled();
let slices = gradient_slices(bp, rule, st, SLICE_TOL, SLICE_MARGIN, grow)
.into_iter()
.map(|s| {
let paint = s.paint(g);
let paint = s.paint(&unrolled);
(s.shape, paint)
})
.collect();
Some(WrittenSlices { clip, slices })
}
/// How far before and after a sharp step between two colors (two stops at one offset, as a
/// gradient that repeats has where one run meets the next) [`mesh_marks`] puts a mesh row or
/// column, as a fraction of the gradient's length.
const STEP_GAP: f64 = 1e-4;
/// Where along gradient `g` (0 to 1) Outline Stroke's mesh puts a row or column for its stops
/// ([`Gradient::expanded_stops`]): at each stop, and for two stops at one offset (a sharp step,
/// or where a reflecting gradient turns back) also [`STEP_GAP`] before and after it, so the mesh
/// takes the color on each side.
fn mesh_marks(g: &Gradient) -> Vec<f64> {
let offsets: Vec<f64> = g.expanded_stops().iter().map(|s| f64::from(s.0)).collect();
let shared = |i: usize| {
let t = offsets.get(i).copied().unwrap_or(0.0);
let near = |j: Option<usize>| j.and_then(|j| offsets.get(j)).is_some_and(|&u| (u - t).abs() < 1e-6);
near(i.checked_sub(1)) || near(i.checked_add(1))
};
let mut out = Vec::with_capacity(offsets.len() + 2);
for (i, &t) in offsets.iter().enumerate() {
out.push(t);
if shared(i) {
out.extend([(t - STEP_GAP).max(0.0), (t + STEP_GAP).min(1.0)]);
}
}
out
}
/// Outline Stroke of stroke `st` of `bp` (filled with `rule`) whose gradient `g` runs along or
/// across it: a gradient mesh per subpath over all the stroke can paint there (clip it to the
/// stroke's outline), coloured as [`gradient_slices`] paint it.
pub fn gradient_meshes(bp: &BezPath, rule: FillRule, st: &StrokeLayer, g: &Gradient) -> Vec<GradientMesh> {
let g = &*g.unrolled();
let across = st.gradient_mode == StrokeGradientMode::Across;
let color = |t: f64| g.sample_keep_model(t.clamp(0.0, 1.0) as f32);
let at_stops = mesh_marks(g);
// Along: a column at each stop (colours are linear between columns), close enough to look smooth.
let marks: Vec<f64> = if across { vec![] } else { g.expanded_stops().iter().map(|s| s.0 as f64).collect() };
let marks: Vec<f64> = if across { vec![] } else { at_stops.clone() };
let max_dt = match (across, st.profile.is_some()) {
(false, _) => MESH_STEP,
(true, true) => PROFILE_STEP,
(true, false) => 1.0,
};
// Rows across: the strip's edges, then (across) the band's left edge to its right edge with a row at each stop.
let mut us: Vec<f64> = if across {
(0..=MESH_ROWS).map(|i| i as f64 / MESH_ROWS as f64).chain(g.expanded_stops().iter().map(|s| s.0 as f64)).collect()
} else {
vec![0.5]
};
let mut us: Vec<f64> = if across { (0..=MESH_ROWS).map(|i| i as f64 / MESH_ROWS as f64).chain(at_stops).collect() } else { vec![0.5] };
us.sort_by(f64::total_cmp);
us.dedup_by(|a, b| (*a - *b).abs() < 1e-6);
strips(bp, rule, st, SLICE_TOL, SLICE_MARGIN, &marks, max_dt)
@@ -286,6 +286,65 @@ fn a_narrow_pass_beside_a_wide_one_leaves_its_edge_alone() {
assert_covered(&hairpin, &st);
}
/// A gradient along or across a stroke that repeats or reflects runs its stops that many times
/// along (or across) it: a slice's paint, and Outline Stroke's meshes, give each point the color
/// the spread gives its place.
#[test]
fn a_spread_gradient_runs_its_stops_along_the_stroke_that_many_times() {
use vectorcraft_color::GradientSpread;
let bp = poly(&[(0.0, 0.0), (120.0, 0.0)], false);
for (mode, spread) in [StrokeGradientMode::Along, StrokeGradientMode::Across]
.into_iter()
.flat_map(|m| [GradientSpread::Reflect, GradientSpread::Repeat].map(|s| (m, s)))
{
let mut st = stroke(10.0, mode);
let g = Gradient { spread, repeats: 3, ..Gradient::default() };
st.paint = Paint::Gradient(Box::new(GradientPaint::new(g.clone())));
for s in slices(&bp, &st) {
let Paint::Gradient(p) = s.paint(&g.unrolled()) else { panic!("a gradient slice") };
let geom = p.geom.unwrap();
for u in [0.1, 0.5, 0.9] {
let at = s.from + (s.to - s.from) * u;
let t = s.span.0 + (s.span.1 - s.span.0) * u;
// Where two runs meet, Repeat's color is the next run's start or the last one's end.
if (t * 3.0 - (t * 3.0).round()).abs() < 1e-9 {
continue;
}
let want = g.sample(g.spread_param(t) as f32).0.to_rgb();
let got = p.gradient.sample(geom.param_at(vectorcraft_color::GradientKind::Linear, at) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 1e-3), "{mode:?} at {t}: {want:?} vs {got:?}");
}
}
// Outline Stroke: the mesh comes back to white where each run starts again, and reaches
// black where each run ends, on both sides of a sharp step between runs.
let count = |g: &Gradient, hex: &str| {
gradient_meshes(&bp, FillRule::NonZero, &st, g).iter().flat_map(|m| m.points.iter()).filter(|p| p.color.to_hex() == hex).count()
};
for hex in ["#ffffff", "#000000"] {
let (spread, pad) = (count(&g, hex), count(&Gradient::default(), hex));
assert!(spread > pad, "{mode:?} {:?} {hex}: {spread} vs {pad}", g.spread);
}
}
}
/// Where a reflecting gradient turns back past a narrow last stop, Outline Stroke's mesh keeps that
/// stop's color.
#[test]
fn a_narrow_peak_where_a_reflecting_gradient_turns_back_stays_in_the_mesh() {
use vectorcraft_color::GradientSpread;
let bp = poly(&[(0.0, 0.0), (120.0, 0.0)], false);
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(0.995, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
let mut st = stroke(10.0, mode);
let g = Gradient { spread: GradientSpread::Reflect, repeats: 100, ..Gradient::new(vectorcraft_color::GradientKind::Linear, stops.clone()) };
st.paint = Paint::Gradient(Box::new(GradientPaint::new(g.clone())));
let whites =
gradient_meshes(&bp, FillRule::NonZero, &st, &g).iter().flat_map(|m| m.points.iter()).filter(|p| p.color.to_hex() == "#ffffff").count();
// The gradient turns back at white 50 times.
assert!(whites >= 50, "{mode:?}: {whites}");
}
}
/// #5960: with dashes, the ribs reach as far as the stroke gets wide within a cap's length along
/// the path, however many points lie that far: not as far as it is wide anywhere when more than
/// 256 do.
+1
View File
@@ -771,6 +771,7 @@ pub use docmenu::guide_indexes;
pub(crate) use edit::{settle_interaction, typing_in_progress};
pub(crate) use object::bounds_rewrite;
pub(crate) use object::{keep_aligned_in, refresh_pixel_aligned};
pub use plugin_call::{Location, key_location, location_in, location_keys};
pub(crate) use vectorcraft_doc::range::parse_range;
/// A date param in Unix seconds that defaults to the clock: `None` when absent (now, see
+7 -2
View File
@@ -1,11 +1,16 @@
//! Cutting Tools (`addon.cutting.*`), a built-in add-on that prepares art for cutting. Stencil
//! Bridges cuts bridges out of the selected art so that a stencil cut from it holds together
//! ([`stencil`]). Its submenu (Object › Plug-ins › Cutting Tools) and dialog are the UI's.
//! ([`stencil`]), and Weed Box and Lines adds a weed box and weeding lines around the selected art
//! for vinyl cutting ([`weed`]). Its submenu (Object › Plug-ins › Cutting Tools) and dialogs are
//! the UI's.
mod stencil;
mod weed;
use super::super::CommandSpec;
pub fn specs() -> Vec<CommandSpec> {
stencil::specs()
let mut v = stencil::specs();
v.extend(weed::specs());
v
}
@@ -89,7 +89,12 @@ fn bridges(s: &mut Session, p: &Value) -> Result<Value> {
};
let refs: Vec<(&PathData, FillRule)> = parts.iter().map(|(p, r)| (p, *r)).collect();
let spec = BridgeSpec { width, count: count as usize, direction };
let bridged = stencil_bridges(&refs, spec).map_err(|e| EngineError::Other(e.to_string()))?;
let bridged = stencil_bridges(&refs, spec).map_err(|e| match e {
vectorcraft_pathops::PathOpsError::TooComplex => {
EngineError::Other("Stencil Bridges: the selected art is too large or too detailed to bridge".into())
}
e => EngineError::Other(e.to_string()),
})?;
(bridged, style_of(&top), roots)
};
let summary = |id: Option<NodeId>, original: Option<NodeId>| {
@@ -277,6 +277,34 @@ fn bad_params_are_refused() {
assert!(s.execute("addon.cutting.bridges", &json!({"width": 4})).is_ok(), "good params run");
}
#[test]
fn art_too_detailed_to_bridge_is_refused_with_a_message_that_says_so() {
let mut s = session();
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("dense", |d, sel| {
// More anchors than Stencil Bridges measures.
let mut zigzag = kurbo::BezPath::new();
zigzag.move_to((100.0, 100.0));
for i in 1..=vectorcraft_pathops::addons::stencil::MAX_STENCIL_SEGMENTS {
zigzag.line_to((100.0 + i as f64 * 0.001, if i % 2 == 0 { 100.0 } else { 101.0 }));
}
zigzag.close_path();
let huge = vectorcraft_geom::PathData::from_bezpath(&zigzag);
let n = vectorcraft_doc::Node::path(d.alloc_id(), huge, vectorcraft_doc::Appearance::default());
let id = n.id;
d.insert(parent, usize::MAX, n)?;
sel.set([id]);
Ok(id)
})
.unwrap();
select(&mut s, &[id]);
let steps = undo_steps(&s);
let e = s.execute("addon.cutting.bridges", &json!({"width": 4})).unwrap_err().to_string();
assert!(e.contains("Stencil Bridges: the selected art is too large or too detailed to bridge"), "{e}");
assert_eq!(undo_steps(&s), steps);
}
#[test]
fn selected_objects_without_outlines_stay_where_they_are() {
for keep in [true, false] {
@@ -0,0 +1,160 @@
//! Weed Box and Lines (`addon.cutting.weed`), a command of the built-in Cutting Tools add-on for
//! vinyl cutting: around the selected art it adds a weed box (a rectangle at a margin around the
//! art) and weeding lines across it that stop at the art, so the waste vinyl around the art lifts
//! off in pieces (<https://help.arlon.com/what-is-a-weeding-border>). The art is measured by the
//! outlines a cutter cuts ([`geometry`]).
mod geometry;
#[cfg(test)]
mod tests;
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_color::Paint;
use vectorcraft_color::swatch::REGISTRATION;
use vectorcraft_doc::{Appearance, Document, Node, NodeId, NodeKind};
use vectorcraft_geom::{Rect, shapes};
use super::super::super::edit::selected_roots;
use super::super::super::object::choice;
use super::super::super::paint::swatch_solid;
use super::super::super::pathops::{length_given, number_given};
use super::super::super::{CommandSpec, bad, cmd, has_selection, switch_or, text_param};
use crate::{EngineError, Result, Session};
/// Weed Box and Lines' command.
pub const WEED: &str = "addon.cutting.weed";
/// Which way the weeding lines run.
pub const DIRECTIONS: [&str; 3] = ["horizontal", "vertical", "both"];
/// The largest margin, gap or spacing, in points.
const MAX_DISTANCE: f64 = 100_000.0;
/// The most weeding lines each way.
const MAX_COUNT: usize = 1000;
/// The most pieces of weeding line one run adds.
const MAX_PIECES: usize = 100_000;
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"addon.cutting.weed",
"Weed Box and Lines…",
["Object", "Plug-ins", "Cutting Tools"],
None,
"{margin?: pt 0..100000 (9: from the art to the weed box), box?: true (false: the weeding lines only), direction?: \"horizontal\" | \"vertical\" | \"both\" (\"both\"), count?: whole number 0..1000 of lines each way (1), spacing?: pt (instead of count: as few lines as keep them at most this far apart), gap?: pt 0..100000 (0: the lines stop at the art's outlines), weight?: pt 0.01..1000 (0.3), swatch?: a color swatch the lines are stroked in (\"[Registration]\")} add a weed box around the selected art and weeding lines across it that divide it evenly, each running from one side of the box to the other and left out over the art and within `gap` of its outlines, so the waste lifts off in pieces. The art is measured by the outlines a cutter cuts: closed paths enclose their area by their fill rule and open paths are lines, compound paths by all their subpaths, type by its glyph outlines, a clip group by what shows inside its clipping path, images by their frames, placed files by the art they show (by their boxes when the file can't be read), symbol instances by their art and live objects by the art they draw; strokes, effects and hidden objects are left out. One group named Weeding, stroked with no fill, on top of the current layer (outside the clip groups around a group edited in isolation), selected, as one undo step → {id: the group, box: its weed box or null, lines (pieces of weeding line)}",
has_selection,
weed
)]
}
/// The distance `p` gives for `key` (0..[`MAX_DISTANCE`]), or `default`.
fn distance(p: &Value, key: &str, default: f64) -> Result<f64> {
match length_given(p, key, WEED)? {
None => Ok(default),
Some(v) if (0.0..=MAX_DISTANCE).contains(&v) => Ok(v),
Some(_) => Err(bad(WEED, format!("`{key}` must be from 0 to {MAX_DISTANCE} pt"))),
}
}
/// How many lines divide a side `length` long: `count`, or as few as keep them at most `spacing`
/// apart.
fn lines_across(length: f64, count: Option<usize>, spacing: Option<f64>) -> Result<usize> {
let n = match spacing {
// `length / spacing` strips, rounded up, need one line fewer.
Some(s) => ((length / s - 1e-9).ceil() - 1.0).max(0.0),
None => return Ok(count.unwrap_or(1)),
};
if n > MAX_COUNT as f64 {
return Err(bad(WEED, format!("`spacing` makes more than {MAX_COUNT} lines across the box")));
}
Ok(n as usize)
}
/// Where the Weeding group goes: `parent`, or, when `parent` is inside a clip group or clipping
/// sublayer (a group edited in isolation), the container around the outermost of them. A clipping
/// path would hide the lines and the box, which lie outside the art.
fn outside_clips(d: &Document, parent: Option<NodeId>) -> Option<NodeId> {
let clips = |id: NodeId| d.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Group { clip: true, .. } | NodeKind::Layer { clip: true, .. }));
let (mut at, mut out) = (parent, parent);
while let Some(p) = at {
let up = d.parent_of(p);
if clips(p) {
match up {
Some(up) if d.is_editable(up) => out = Some(up),
_ => break,
}
}
at = up;
}
out
}
fn weed(s: &mut Session, p: &Value) -> Result<Value> {
let margin = distance(p, "margin", 9.0)?;
let gap = distance(p, "gap", 0.0)?;
let with_box = switch_or(p, "box", true, WEED)?;
let direction = choice(p, WEED, "direction", &DIRECTIONS)?.unwrap_or("both");
let count = match number_given(p, "count", WEED)? {
None => None,
Some(n) if n.fract() == 0.0 && (0.0..=MAX_COUNT as f64).contains(&n) => Some(n as usize),
Some(_) => return Err(bad(WEED, format!("`count` must be a whole number from 0 to {MAX_COUNT}"))),
};
let spacing = match length_given(p, "spacing", WEED)? {
None => None,
Some(v) if v > 0.0 && v <= MAX_DISTANCE => Some(v),
Some(_) => return Err(bad(WEED, format!("`spacing` must be more than 0 and at most {MAX_DISTANCE} pt"))),
};
if count.is_some() && spacing.is_some() {
return Err(bad(WEED, "give `count` or `spacing`, not both"));
}
let weight = match length_given(p, "weight", WEED)? {
None => 0.3,
Some(v) if (0.01..=1000.0).contains(&v) => v,
Some(_) => return Err(bad(WEED, "`weight` must be from 0.01 to 1000 pt")),
};
let swatch = text_param(p, "swatch", WEED)?.unwrap_or(REGISTRATION);
let stroke = swatch_solid(&s.doc()?.doc, swatch, None).map_err(|e| bad(WEED, e))?;
let roots = selected_roots(s)?;
if roots.is_empty() {
return Err(bad(WEED, "select the art to weed"));
}
let d = &s.doc()?.doc;
let parent = outside_clips(d, s.doc()?.target_parent()?);
// Placed files' art uses their resources (symbols) under names of their own.
let placed = d.with_placed_art();
let region = geometry::Reader::new(&placed).read_ids(&roots).map_err(|e| bad(WEED, e))?;
let region = region.ok_or_else(|| bad(WEED, "the selection has no outlines to weed around"))?;
let outline = region.outline().map_err(|e| bad(WEED, e))?;
let art = outline.iter().fold(None, |r: Option<Rect>, &(a, b)| Some(r.map_or(Rect::from_points(a, b), |r| r.union_pt(a).union_pt(b))));
let frame = art.ok_or_else(|| bad(WEED, "the selection has no outlines to weed around"))?.inflate(margin, margin);
if !(frame.width().is_finite() && frame.height().is_finite()) {
return Err(bad(WEED, "the selected art is too large to measure"));
}
let each = |on: bool, length: f64| if on { lines_across(length, count, spacing) } else { Ok(0) };
let counts =
geometry::Counts { horizontal: each(direction != "vertical", frame.height())?, vertical: each(direction != "horizontal", frame.width())? };
let pieces = geometry::lines(&region, &outline, frame, counts, gap, MAX_PIECES).map_err(|e| bad(WEED, e))?;
if pieces.is_empty() && !with_box {
return Err(EngineError::Other("Weed Box and Lines: no weeding line fits outside the art, and the weed box is off".into()));
}
let ap = Appearance::basic(Paint::None, stroke, weight);
let (group, weed_box, lines) = s.edit("Weed Box and Lines", |d, sel| {
let mut children = vec![];
let mut weed_box = None;
if with_box {
let mut b = Node::path(d.alloc_id(), shapes::rectangle(frame), ap.clone());
b.name = Some("Weed Box".into());
weed_box = Some(b.id);
children.push(Arc::new(b));
}
for (a, b) in &pieces {
children.push(Arc::new(Node::path(d.alloc_id(), shapes::line(*a, *b), ap.clone())));
}
let mut g = Node::group(d.alloc_id(), children);
g.name = Some("Weeding".into());
let id = g.id;
d.insert(parent, usize::MAX, g)?;
sel.set([id]);
Ok((id, weed_box, pieces.len()))
})?;
Ok(json!({ "id": group.0, "box": weed_box.map(|b| b.0), "lines": lines }))
}
@@ -0,0 +1,769 @@
//! The geometry of Weed Box and Lines: the selected art as the outlines a cutter cuts ([`Region`]),
//! and the weeding lines across a box that stop at those outlines or at a gap from them
//! ([`lines`]).
//!
//! A region is measured along one straight line at a time. A closed outline encloses its area by
//! its fill rule, an open one is a line with no area, a group is the union of its members and a
//! clip group is what its members draw inside its clipping path. Along a weeding line the region
//! gives the stretches inside its area ([`Region::spans`]), and its outline pieces
//! ([`Region::outline`]) give the stretches within the gap of an outline.
use std::cell::Cell;
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use vectorcraft_geom::{BezPath, FillRule, PathEl, Point, Rect};
use super::super::super::super::pathops::node_path;
/// How closely curves are followed, in points.
const TOLERANCE: f64 = 0.02;
/// The most points the outlines of one selection are measured by, once curves are followed in
/// straight segments (each subpath's points, its first one included).
pub(super) const MAX_POINTS: usize = 200_000;
/// The most tests of a segment against another one measuring a clip group's outlines takes.
const MAX_PAIRS: usize = 40_000_000;
/// The deepest groups, symbol instances and live objects are opened inside one another: as deep
/// as any object is drawn.
pub(super) const MAX_DEPTH: usize = vectorcraft_doc::depth::MAX_DRAWN_DEPTH;
/// The most pairs of an outline segment and a weeding line it comes near that one run measures.
const MAX_NEAR: usize = 10_000_000;
/// Pieces of weeding line shorter than this, in points, are left out.
const MIN_PIECE: f64 = 0.01;
/// A straight segment.
pub(super) type Segment = (Point, Point);
/// One subpath followed in straight segments.
#[derive(Clone, Debug)]
pub(super) struct Poly {
points: Vec<Point>,
closed: bool,
/// The box around `points`.
bounds: Rect,
}
impl Poly {
/// The segments, with the closing one of a closed subpath.
fn segments(&self) -> impl Iterator<Item = Segment> + '_ {
let closing = self.closed.then(|| (self.points.last().copied(), self.points.first().copied()));
self.points.windows(2).map(|w| (w[0], w[1])).chain(closing.and_then(|(a, b)| Some((a?, b?))))
}
}
/// The selected art as the outlines a cutter cuts.
#[derive(Clone, Debug)]
pub(super) enum Region {
/// A path, compound path or type: its subpaths with the rule its closed ones fill by.
Shape { polys: Vec<Poly>, rule: FillRule },
/// Everything its members draw.
Union(Vec<Region>),
/// What `content` draws inside `clip`.
Clip { clip: Box<Region>, content: Box<Region> },
}
/// Reads the selected objects into a [`Region`], keeping count of the outline points.
pub(super) struct Reader<'a> {
doc: &'a Document,
points: usize,
}
impl<'a> Reader<'a> {
pub(super) fn new(doc: &'a Document) -> Self {
Self { doc, points: 0 }
}
/// The region of `nodes` together, `None` when they hold no outlines.
pub(super) fn read(&mut self, nodes: &[&Node]) -> Result<Option<Region>, String> {
let mut parts = vec![];
for n in nodes {
parts.extend(self.node(n, 0)?);
}
Ok(union(parts))
}
fn node(&mut self, n: &Node, depth: usize) -> Result<Option<Region>, String> {
if depth > MAX_DEPTH {
return Err(format!("the selected art is nested more than {MAX_DEPTH} levels deep"));
}
if !n.visible {
return Ok(None);
}
match &n.kind {
NodeKind::Path { guide: true, .. } | NodeKind::RulerGuide { .. } => Ok(None),
NodeKind::Path { .. } | NodeKind::Compound { .. } | NodeKind::Text(_) => self.shape(n),
NodeKind::Group { clip, .. } | NodeKind::Layer { clip, .. } => {
let members = n.editing_children();
if *clip {
let Some((first, rest)) = members.split_first() else { return Ok(None) };
let Some(clip) = self.clip_region(first)? else { return Ok(None) };
let mut parts = vec![];
for c in rest {
parts.extend(self.node(c, depth + 1)?);
}
Ok(union(parts).map(|content| Region::Clip { clip: Box::new(clip), content: Box::new(content) }))
} else {
let mut parts = vec![];
for c in members {
parts.extend(self.node(c, depth + 1)?);
}
Ok(union(parts))
}
}
NodeKind::Image(im) => {
let (w, h) = (f64::from(im.width), f64::from(im.height));
let corners = [Point::new(0.0, 0.0), Point::new(w, 0.0), Point::new(w, h), Point::new(0.0, h)].map(|p| im.xf * p);
self.polygon(&corners)
}
// An instance of a symbol the document doesn't have draws nothing.
NodeKind::SymbolInstance { .. } => match vectorcraft_render::effects::outline_object(Some(self.doc), n) {
Some(art) => self.node(&art, depth + 1),
None => Ok(None),
},
NodeKind::PlacedDocument(p) => {
// The art of the file it shows; a file that can't be read shows its preview in its
// box, which may be rotated.
if vectorcraft_doc::placed_document::read_cached(p).is_none() {
return self.polygon(&p.corners());
}
let art = vectorcraft_render::effects::expand_live_deep(Some(self.doc), n);
if std::mem::discriminant(&art.kind) == std::mem::discriminant(&n.kind) {
self.polygon(&p.corners())
} else {
self.node(&art, depth + 1)
}
}
NodeKind::Blend { .. } | NodeKind::Envelope { .. } | NodeKind::Mesh(_) | NodeKind::Repeat(_) | NodeKind::Intertwine { .. } => {
// The art a live object draws, as the exporters write it; an object that stays
// as it is is measured by its box.
let art = vectorcraft_render::effects::expand_live_deep(Some(self.doc), n);
if std::mem::discriminant(&art.kind) == std::mem::discriminant(&n.kind) { self.frame(n) } else { self.node(&art, depth + 1) }
}
}
}
/// The region a clipping path `first` clips to, whatever its own visibility: the region the
/// renderer clips to (a path, a compound path, type by its glyphs, a group's visible members,
/// an image's frame). `None` when it clips to nothing, and the clipped art is hidden.
fn clip_region(&mut self, first: &Node) -> Result<Option<Region>, String> {
let Some((outline, rule)) = vectorcraft_render::effects::clip_outline(first) else { return Ok(None) };
let mut polys = self.polys(outline)?;
// A region is filled: an open subpath clips as if closed.
polys.iter_mut().for_each(|p| p.closed = true);
Ok((!polys.is_empty()).then_some(Region::Shape { polys, rule }))
}
/// The region of the objects `ids` together, each within the clipping paths of the clip groups
/// and layers around it (an object selected inside a clip group shows only within its clipping
/// path, and not at all inside a hidden group or layer; a clipping path is measured as its clip
/// group), `None` when they show no outlines.
pub(super) fn read_ids(&mut self, ids: &[NodeId]) -> Result<Option<Region>, String> {
let doc = self.doc;
let clips = |n: &Node| matches!(n.kind, NodeKind::Group { clip: true, .. } | NodeKind::Layer { clip: true, .. });
// Every object's place in the tree, found in one walk.
let places = doc.index_paths(ids.iter().copied());
let mut paths = vec![];
for id in ids {
let Some(mut path) = places.get(id).cloned() else { continue };
// A clipping path selected on its own stands for the art it shows: its clip group.
while let (Some(n), Some(up)) = (doc.node_at(&path), path.split_last().map(|(_, up)| up).and_then(|up| doc.node_at(up))) {
if !(clips(up) && up.editing_children().first().is_some_and(|f| f.id == n.id)) {
break;
}
path.pop();
}
paths.push(path);
}
// An object selected twice, or inside another selected object, is measured once, with it.
paths.sort();
paths.dedup();
let mut kept: Vec<Vec<usize>> = vec![];
for path in paths {
if !kept.last().is_some_and(|k| path.starts_with(k)) {
kept.push(path);
}
}
let mut parts = vec![];
'ids: for path in &kept {
let Some(n) = doc.node_at(path) else { continue };
// Art in a hidden group or layer isn't shown, and isn't measured.
if (1..path.len()).any(|depth| path.get(..depth).and_then(|p| doc.node_at(p)).is_some_and(|c| !c.visible)) {
continue;
}
let Some(mut region) = self.read(&[n])? else { continue };
// The containers around the object, innermost first.
let mut child = n.id;
for depth in (1..path.len()).rev() {
let Some(container) = path.get(..depth).and_then(|p| doc.node_at(p)) else { break };
if clips(container)
&& let Some(first) = container.editing_children().first().filter(|f| f.id != child)
{
let Some(clip) = self.clip_region(first)? else { continue 'ids };
region = Region::Clip { clip: Box::new(clip), content: Box::new(region) };
}
child = container.id;
}
parts.push(region);
}
Ok(union(parts))
}
/// A path, compound path or type as its outlines.
fn shape(&mut self, n: &Node) -> Result<Option<Region>, String> {
// Each anchor is at least one point, so a path past the budget errs before it is copied.
if anchors(n) > MAX_POINTS.saturating_sub(self.points) {
return Err(too_many());
}
let Some((path, rule)) = node_path(n) else { return Ok(None) };
let polys = self.polys(path.to_bezpath())?;
Ok((!polys.is_empty()).then_some(Region::Shape { polys, rule }))
}
/// The box of an object whose outlines can't be read.
fn frame(&mut self, n: &Node) -> Result<Option<Region>, String> {
match n.geometric_bounds_with(&self.doc.symbol_boxes()) {
Some(r) => self.polygon(&[Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)]),
None => Ok(None),
}
}
/// A closed polygon through `points`.
fn polygon(&mut self, points: &[Point]) -> Result<Option<Region>, String> {
let poly = poly(points.to_vec(), true);
self.count(poly.iter().map(|p| p.points.len()).sum())?;
Ok(poly.map(|p| Region::Shape { polys: vec![p], rule: FillRule::NonZero }))
}
fn count(&mut self, n: usize) -> Result<(), String> {
self.points = self.points.saturating_add(n);
if self.points > MAX_POINTS { Err(too_many()) } else { Ok(()) }
}
/// The subpaths of `path` followed in straight segments.
fn polys(&mut self, path: BezPath) -> Result<Vec<Poly>, String> {
let (mut out, mut current, points) = (vec![], vec![], Cell::new(0usize));
let left = MAX_POINTS.saturating_sub(self.points);
// Past the budget no further curve is followed (one curve gives at most
// `MAX_FLATTEN_PER_CURVE` points), and the read fails below.
let elements = path.into_iter().take_while(|_| points.get() <= left);
vectorcraft_geom::flatten(elements, TOLERANCE, |el| {
points.set(points.get() + 1);
if points.get() > left {
return;
}
match el {
PathEl::MoveTo(p) => {
out.extend(poly(std::mem::take(&mut current), false));
current.push(p);
}
PathEl::LineTo(p) => current.push(p),
PathEl::ClosePath => out.extend(poly(std::mem::take(&mut current), true)),
PathEl::QuadTo(..) | PathEl::CurveTo(..) => {}
}
});
if points.get() > left {
return Err(too_many());
}
out.extend(poly(current, false));
self.count(out.iter().map(|p: &Poly| p.points.len()).sum())?;
Ok(out)
}
}
fn too_many() -> String {
format!("the selected art has too many outline points to measure (more than {MAX_POINTS})")
}
/// The anchors of a path or compound path node, read without copying its path; 0 for type.
fn anchors(n: &Node) -> usize {
match &n.kind {
NodeKind::Path { path, .. } => path.anchor_count(),
NodeKind::Compound { children, .. } => children.iter().fold(0, |sum, c| sum.saturating_add(anchors(c))),
_ => 0,
}
}
/// A subpath through `points`, `None` for fewer than two points or one that isn't finite.
fn poly(points: Vec<Point>, closed: bool) -> Option<Poly> {
if points.len() < 2 || points.iter().any(|p| !p.x.is_finite() || !p.y.is_finite()) {
return None;
}
let first = *points.first()?;
let bounds = points.iter().fold(Rect::from_points(first, first), |r, p| r.union_pt(*p));
Some(Poly { points, closed, bounds })
}
/// One region of `parts`, `None` when there are none.
fn union(mut parts: Vec<Region>) -> Option<Region> {
match parts.len() {
0 => None,
1 => parts.pop(),
_ => Some(Region::Union(parts)),
}
}
/// `p` as (along, across) a weeding line: horizontal lines run along x, vertical ones along y.
fn uv(p: Point, vertical: bool) -> (f64, f64) {
if vertical { (p.y, p.x) } else { (p.x, p.y) }
}
/// Sorts `spans` and joins those that overlap or touch.
fn merged(mut spans: Vec<(f64, f64)>) -> Vec<(f64, f64)> {
spans.sort_by(|a, b| a.0.total_cmp(&b.0));
let mut out: Vec<(f64, f64)> = Vec::with_capacity(spans.len());
for (a, b) in spans {
match out.last_mut() {
Some(last) if a <= last.1 => last.1 = last.1.max(b),
_ => out.push((a, b)),
}
}
out
}
/// Where sorted, joined spans `a` and `b` overlap.
fn intersected(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
let (mut i, mut j, mut out) = (0, 0, vec![]);
while let (Some(&(a0, a1)), Some(&(b0, b1))) = (a.get(i), b.get(j)) {
let (lo, hi) = (a0.max(b0), a1.min(b1));
if lo <= hi {
out.push((lo, hi));
}
if a1 < b1 {
i += 1;
} else {
j += 1;
}
}
out
}
/// Where segment a→b crosses the line `across` = `c`, along it, and which way (1 when `across`
/// grows from a to b), `None` when it doesn't. Each crossing counts once: an end exactly on the
/// line counts as past it.
fn crosses(a: Point, b: Point, vertical: bool, c: f64) -> Option<(f64, i32)> {
let ((u0, v0), (u1, v1)) = (uv(a, vertical), uv(b, vertical));
((v0 <= c && v1 > c) || (v1 <= c && v0 > c)).then(|| (u0 + (c - v0) * (u1 - u0) / (v1 - v0), if v1 > v0 { 1 } else { -1 }))
}
/// The stretches inside an area filled by `rule`, from where its outlines cross a line, sorted
/// along it.
fn filled(crossings: impl IntoIterator<Item = (f64, i32)>, rule: FillRule) -> Vec<(f64, f64)> {
let (mut winding, mut start, mut out) = (0, 0.0, vec![]);
let inside = |w: i32| match rule {
FillRule::NonZero => w != 0,
FillRule::EvenOdd => w % 2 != 0,
};
for (u, dir) in crossings {
let was = inside(winding);
winding += dir;
match (was, inside(winding)) {
(false, true) => start = u,
(true, false) => out.push((start, u)),
_ => {}
}
}
merged(out)
}
/// Where the closed outlines of a region's shapes cross a set of weeding lines: for each line, the
/// crossings as (shape, place along the line, direction), sorted by shape and then by place. Shapes
/// are numbered in the order [`Region::shapes`] lists them.
pub(super) type Crossings = Vec<Vec<(usize, f64, i32)>>;
/// Where the shapes of each part of a region are numbered among its [`Crossings`].
#[derive(Debug)]
pub(super) enum Layout {
Shape,
/// The number of each part's first shape, from the union's first, and the parts' layouts.
Union {
starts: Vec<usize>,
parts: Vec<Layout>,
},
/// The clipping path's shapes come first.
Clip {
clip_shapes: usize,
clip: Box<Layout>,
content: Box<Layout>,
},
}
impl Layout {
/// The layout of `region` and how many shapes it has.
pub(super) fn of(region: &Region) -> (Layout, usize) {
match region {
Region::Shape { .. } => (Layout::Shape, 1),
Region::Union(parts) => {
let (mut starts, mut layouts, mut n) = (vec![], vec![], 0);
for r in parts {
let (l, k) = Layout::of(r);
starts.push(n);
layouts.push(l);
n += k;
}
(Layout::Union { starts, parts: layouts }, n)
}
Region::Clip { clip, content } => {
let ((lc, a), (lt, b)) = (Layout::of(clip), Layout::of(content));
(Layout::Clip { clip_shapes: a, clip: Box::new(lc), content: Box::new(lt) }, a + b)
}
}
}
}
/// The [`Crossings`] of `region` with the lines `across` = v0 + (k + 1)·step, k < `count`. Errs
/// past [`MAX_NEAR`] crossings in all.
pub(super) fn crossings(region: &Region, vertical: bool, v0: f64, step: f64, count: usize) -> Result<Crossings, String> {
let mut shapes = vec![];
region.shapes(&mut shapes);
let at = |k: usize| v0 + step * (k as f64 + 1.0);
// The lines a segment may cross: those from just below its lower end to its higher end.
let candidates = |(a, b): Segment| {
let (va, vb) = (uv(a, vertical).1, uv(b, vertical).1);
if step <= 0.0 || va == vb {
return 0..0;
}
let first = (((va.min(vb) - v0) / step).floor() - 1.0).clamp(0.0, count as f64);
let end = ((va.max(vb) - v0) / step).ceil().clamp(0.0, count as f64);
(first as usize)..(end as usize)
};
let closed = |polys: &[Poly]| polys.iter().filter(|p| p.closed).flat_map(Poly::segments).collect::<Vec<_>>();
let total = shapes.iter().flat_map(|(polys, _)| closed(polys)).fold(0usize, |n, s| n.saturating_add(candidates(s).len()));
if total > MAX_NEAR {
return Err("the weeding lines cross the art's outlines too many times to measure; use fewer lines".into());
}
let mut out: Crossings = vec![vec![]; count];
for (i, (polys, _)) in shapes.iter().enumerate() {
for (a, b) in closed(polys) {
for k in candidates((a, b)) {
if let (Some((u, dir)), Some(line)) = (crosses(a, b, vertical, at(k)), out.get_mut(k)) {
line.push((i, u, dir));
}
}
}
}
for line in &mut out {
line.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1)));
}
Ok(out)
}
impl Region {
/// The stretches of the line `across` = `c` (horizontal: y = c, along x; vertical: x = c,
/// along y) inside the region's area, sorted and joined.
pub(super) fn spans(&self, vertical: bool, c: f64) -> Vec<(f64, f64)> {
match self {
Region::Shape { polys, rule } => {
let mut crossings: Vec<(f64, i32)> = vec![];
for p in polys.iter().filter(|p| p.closed) {
let (lo, hi) = if vertical { (p.bounds.x0, p.bounds.x1) } else { (p.bounds.y0, p.bounds.y1) };
if c >= lo && c <= hi {
crossings.extend(p.segments().filter_map(|(a, b)| crosses(a, b, vertical, c)));
}
}
crossings.sort_by(|a, b| a.0.total_cmp(&b.0));
filled(crossings, *rule)
}
Region::Union(parts) => merged(parts.iter().flat_map(|r| r.spans(vertical, c)).collect()),
Region::Clip { clip, content } => intersected(&clip.spans(vertical, c), &content.spans(vertical, c)),
}
}
/// The region's shapes with their fill rules, in a fixed order.
fn shapes<'a>(&'a self, out: &mut Vec<(&'a [Poly], FillRule)>) {
match self {
Region::Shape { polys, rule } => out.push((polys, *rule)),
Region::Union(parts) => parts.iter().for_each(|r| r.shapes(out)),
Region::Clip { clip, content } => {
clip.shapes(out);
content.shapes(out);
}
}
}
/// [`Region::spans`] on a weeding line, from `line`, the line's [`Crossings`] with the
/// region's shapes, numbered from `base` (`layout` is the region's [`Layout`]). Only the parts
/// the line crosses are visited: a part it doesn't cross has no stretch inside its area.
pub(super) fn spans_on(&self, layout: &Layout, line: &[(usize, f64, i32)], base: usize) -> Vec<(f64, f64)> {
if line.is_empty() {
return vec![];
}
match (self, layout) {
(Region::Shape { rule, .. }, Layout::Shape) => filled(line.iter().map(|&(_, u, dir)| (u, dir)), *rule),
(Region::Union(parts), Layout::Union { starts, parts: layouts }) => {
let (mut out, mut rest) = (vec![], line);
while let Some(&(id, ..)) = rest.first() {
// The part whose shapes the next crossing is on, and its crossings.
let j = starts.partition_point(|&s| base + s <= id).saturating_sub(1);
let (Some(r), Some(l), Some(&start)) = (parts.get(j), layouts.get(j), starts.get(j)) else { break };
let end = starts.get(j + 1).map_or(usize::MAX, |&s| base + s);
let n = rest.partition_point(|c| c.0 < end);
if n == 0 {
break;
}
let (mine, after) = rest.split_at(n);
out.extend(r.spans_on(l, mine, base + start));
rest = after;
}
merged(out)
}
(Region::Clip { clip, content }, Layout::Clip { clip_shapes, clip: lc, content: lt }) => {
let (a, b) = line.split_at(line.partition_point(|c| c.0 < base + clip_shapes));
if a.is_empty() || b.is_empty() {
return vec![];
}
intersected(&clip.spans_on(lc, a, base), &content.spans_on(lt, b, base + clip_shapes))
}
_ => vec![],
}
}
/// Is `p` inside the region's area or on one of `segments`, the outlines it shows?
fn contains(&self, p: Point, segments: &[Segment]) -> bool {
const EPS: f64 = 1e-7;
self.spans(false, p.y).iter().any(|&(a, b)| p.x >= a - EPS && p.x <= b + EPS) || segments.iter().any(|&(a, b)| distance(p, a, b) <= EPS)
}
/// The pieces of outline the region shows: every outline of a shape and of a group's members,
/// and in a clip group the members' outlines inside the clipping path and the clipping path's
/// outline where the members' area or outlines are. Errs past [`MAX_PAIRS`], counted over
/// every clip group in the region together.
pub(super) fn outline(&self) -> Result<Vec<Segment>, String> {
self.outline_counted(&mut 0)
}
/// [`Region::outline`], adding the measure's work to `work`.
fn outline_counted(&self, work: &mut usize) -> Result<Vec<Segment>, String> {
match self {
Region::Shape { polys, .. } => Ok(polys.iter().flat_map(Poly::segments).collect()),
Region::Union(parts) => {
let mut out = vec![];
for r in parts {
out.extend(r.outline_counted(work)?);
}
Ok(out)
}
Region::Clip { clip, content } => {
// Each side's area is bounded by the outlines it shows, so the pieces are cut and
// tested against those, never against art a nested clip hides.
let (clip_shown, content_shown) = (clip.outline_counted(work)?, content.outline_counted(work)?);
let mut out = within(&content_shown, clip, &clip_shown, work)?;
out.extend(within(&clip_shown, content, &content_shown, work)?);
Ok(out)
}
}
}
/// The points of the region's closed outlines, those a nested clip hides included: what one
/// [`Region::spans`] looks at, at most.
fn closed_points(&self) -> usize {
match self {
Region::Shape { polys, .. } => polys.iter().filter(|p| p.closed).map(|p| p.points.len()).sum(),
Region::Union(parts) => parts.iter().map(Region::closed_points).sum(),
Region::Clip { clip, content } => clip.closed_points().saturating_add(content.closed_points()),
}
}
}
fn too_complex_clip() -> String {
"a clip group in the selection has too many outline segments to measure".into()
}
/// The pieces of `segments` inside `region` (or on its outlines), cut where they cross
/// `region_segments`, the outlines the region shows. Each segment, and each piece of one tested
/// for being inside, adds the region's closed outline points (hidden ones included) and its
/// shown segment count to `work`, and the measure errs past [`MAX_PAIRS`].
fn within(segments: &[Segment], region: &Region, region_segments: &[Segment], work: &mut usize) -> Result<Vec<Segment>, String> {
let mut out = vec![];
let cost = region.closed_points().saturating_add(region_segments.len()).max(1);
let charge = |work: &mut usize| {
*work = work.saturating_add(cost);
if *work > MAX_PAIRS { Err(too_complex_clip()) } else { Ok(()) }
};
for &(a, b) in segments {
charge(work)?;
let mut cuts = vec![0.0, 1.0];
let seg_box = Rect::from_points(a, b);
for &(c, d) in region_segments {
if touches(seg_box, Rect::from_points(c, d)) {
cuts.extend(crossing(a, b, c, d));
}
}
cuts.sort_by(f64::total_cmp);
cuts.dedup_by(|x, y| (*x - *y).abs() < 1e-12);
let at = |t: f64| a + (b - a) * t;
for w in cuts.windows(2) {
let (t0, t1) = (w[0], w[1]);
if t1 - t0 < 1e-12 {
continue;
}
charge(work)?;
if region.contains(at((t0 + t1) / 2.0), region_segments) {
out.push((at(t0), at(t1)));
}
}
}
Ok(out)
}
/// Do boxes `a` and `b` overlap or touch?
fn touches(a: Rect, b: Rect) -> bool {
a.x0 <= b.x1 && b.x0 <= a.x1 && a.y0 <= b.y1 && b.y0 <= a.y1
}
/// Where along a→b (0 to 1) segment c→d crosses or touches it: one place, or the ends of the
/// shared stretch when the two lie on one line.
fn crossing(a: Point, b: Point, c: Point, d: Point) -> Vec<f64> {
let (r, s) = (b - a, d - c);
let denom = r.cross(s);
let qp = c - a;
let len2 = r.hypot2();
if len2 == 0.0 {
return vec![];
}
if denom.abs() <= 1e-12 * len2.sqrt() * s.hypot().max(1e-300) {
// Parallel: the ends of c→d on a→b when the two lie on one line.
if qp.cross(r).abs() > 1e-9 * len2.sqrt() {
return vec![];
}
return [c, d].iter().map(|p| (*p - a).dot(r) / len2).filter(|t| (0.0..=1.0).contains(t)).collect();
}
let t = qp.cross(s) / denom;
let u = qp.cross(r) / denom;
if (0.0..=1.0).contains(&t) && (0.0..=1.0).contains(&u) { vec![t] } else { vec![] }
}
/// The distance from `p` to segment a→b.
fn distance(p: Point, a: Point, b: Point) -> f64 {
let ab = b - a;
let len2 = ab.hypot2();
let t = if len2 > 0.0 { ((p - a).dot(ab) / len2).clamp(0.0, 1.0) } else { 0.0 };
(p - (a + ab * t)).hypot()
}
/// The stretch of the line `across` = `c` within `gap` of segment a→b, `None` when the line
/// passes farther away. With no gap it is where the segment meets the line.
fn near(a: Point, b: Point, vertical: bool, c: f64, gap: f64) -> Option<(f64, f64)> {
let ((u0, v0), (u1, v1)) = (uv(a, vertical), uv(b, vertical));
if gap <= 0.0 {
if v0 == v1 {
return (v0 == c).then_some((u0.min(u1), u0.max(u1)));
}
if c < v0.min(v1) || c > v0.max(v1) {
return None;
}
let u = u0 + (c - v0) * (u1 - u0) / (v1 - v0);
return Some((u, u));
}
let mut lo = f64::INFINITY;
let mut hi = f64::NEG_INFINITY;
let mut take = |x: f64, y: f64| {
lo = lo.min(x);
hi = hi.max(y);
};
// The round ends.
for (u, v) in [(u0, v0), (u1, v1)] {
let dv = (c - v).abs();
if dv <= gap {
let h = (gap * gap - dv * dv).max(0.0).sqrt();
take(u - h, u + h);
}
}
// The band along the segment: points whose foot falls on it, within the gap of it.
let (du, dv) = (u1 - u0, v1 - v0);
let len = du.hypot(dv);
if len > 0.0 {
// Each condition is linear in the position x along the line: k·x + m ≥ 0.
let mut range = (f64::NEG_INFINITY, f64::INFINITY);
let mut keep = |k: f64, m: f64| {
if k == 0.0 {
if m < 0.0 {
range = (1.0, 0.0);
}
} else if k > 0.0 {
range.0 = range.0.max(-m / k);
} else {
range.1 = range.1.min(-m / k);
}
};
// The foot at or after a: (x - u0)·du + (c - v0)·dv ≥ 0.
keep(du, -u0 * du + (c - v0) * dv);
// The foot at or before b.
keep(-du, u0 * du - (c - v0) * dv + len * len);
// Within the gap on either side: |(x - u0)·dv - (c - v0)·du| ≤ gap·len.
let cross0 = -u0 * dv - (c - v0) * du;
keep(-dv, -cross0 + gap * len);
keep(dv, cross0 + gap * len);
if range.0 <= range.1 {
take(range.0, range.1);
}
}
(lo <= hi).then_some((lo, hi))
}
/// How many weeding lines run each way.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct Counts {
pub horizontal: usize,
pub vertical: usize,
}
/// The weeding lines across `frame`: `n.horizontal` horizontal and `n.vertical` vertical lines that
/// divide it evenly, each from one side of the frame to the other, left out where it is inside the
/// region's area or within `gap` of one of its outlines (`outline`). Pieces are in order along each
/// line, the horizontal lines first, top to bottom. Errs past [`MAX_NEAR`] pairs of an outline
/// segment and a line it comes within `gap` of, past [`MAX_NEAR`] crossings of the region's
/// outlines with the lines one way, or past `max_pieces` pieces.
pub(super) fn lines(region: &Region, outline: &[Segment], frame: Rect, n: Counts, gap: f64, max_pieces: usize) -> Result<Vec<Segment>, String> {
let mut out = vec![];
let (layout, _) = Layout::of(region);
for (vertical, count) in [(false, n.horizontal), (true, n.vertical)] {
let ((u0, v0), (u1, v1)) = (uv(Point::new(frame.x0, frame.y0), vertical), uv(Point::new(frame.x1, frame.y1), vertical));
let step = (v1 - v0) / (count as f64 + 1.0);
// A frame with no height (for horizontal lines) or no width has no waste to divide.
if step <= 0.0 {
continue;
}
// The lines (0-based) each outline segment comes within `gap` of: lines k (1-based) lie at
// v0 + k·step.
let reach = |&(a, b): &Segment| {
let (va, vb) = (uv(a, vertical).1, uv(b, vertical).1);
let (lo, hi) = (va.min(vb) - gap, va.max(vb) + gap);
let first = ((lo - v0) / step).ceil().max(1.0);
let last = ((hi - v0) / step).floor().min(count as f64);
if step > 0.0 && first <= last { (first as usize - 1)..(last as usize) } else { 0..0 }
};
// The outlines near each line, found once for all of them, by index into `outline`.
let pairs = outline.iter().fold(0usize, |sum, s| sum.saturating_add(reach(s).len()));
if pairs > MAX_NEAR {
return Err("the weeding lines pass too close to too many outline segments to measure; use fewer lines or a smaller gap".into());
}
let mut near_line: Vec<Vec<usize>> = vec![vec![]; count];
for (j, s) in outline.iter().enumerate() {
for k in reach(s) {
if let Some(list) = near_line.get_mut(k) {
list.push(j);
}
}
}
let crossed = crossings(region, vertical, v0, step, count)?;
for (i, segments) in near_line.iter().enumerate() {
let c = v0 + step * (i as f64 + 1.0);
let mut blocked = region.spans_on(&layout, crossed.get(i).map(Vec::as_slice).unwrap_or_default(), 0);
blocked.extend(segments.iter().filter_map(|&j| outline.get(j)).filter_map(|&(a, b)| near(a, b, vertical, c, gap)));
let mut from = u0;
let point = |u: f64| if vertical { Point::new(c, u) } else { Point::new(u, c) };
for (a, b) in merged(blocked) {
if a - from >= MIN_PIECE && a <= u1 {
out.push((point(from), point(a.min(u1))));
}
from = from.max(b);
}
if u1 - from >= MIN_PIECE {
out.push((point(from), point(u1)));
}
if out.len() > max_pieces {
return Err(format!("the weeding lines would be more than {max_pieces} pieces"));
}
}
}
Ok(out)
}
@@ -0,0 +1,915 @@
//! Tests for `addon.cutting.weed`: a weed box around the selected art and weeding lines across it
//! that stop at the art's outlines.
use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_color::Paint;
use vectorcraft_doc::{Appearance, Node, NodeKind};
use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Shape, shapes};
use super::super::super::super::pathops::text_outline;
use crate::*;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
s
}
fn id_of(v: &Value) -> NodeId {
NodeId(v["id"].as_u64().unwrap())
}
fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64) -> NodeId {
id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap())
}
fn line(s: &mut Session, pts: &[(f64, f64)]) -> NodeId {
let anchors: Vec<Value> = pts.iter().map(|(x, y)| json!({"x": x, "y": y})).collect();
id_of(&s.execute("path.create", &json!({"anchors": anchors, "closed": false})).unwrap())
}
fn select(s: &mut Session, ids: &[NodeId]) {
s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap();
}
fn node(s: &Session, id: NodeId) -> Node {
s.doc().unwrap().doc.node(id).cloned().unwrap()
}
/// Runs Weed Box and Lines with `p` and gives the group it made.
fn weed(s: &mut Session, p: Value) -> (Value, Node) {
let r = s.execute("addon.cutting.weed", &p).unwrap();
let g = node(s, id_of(&r));
(r, g)
}
/// The weed box's rectangle in group `g`, if it has one.
fn weed_box(g: &Node) -> Option<Rect> {
g.children().unwrap().iter().find(|c| c.name.as_deref() == Some("Weed Box")).map(|c| c.geometric_bounds().unwrap())
}
/// The weeding lines in group `g` as their two ends, rounded to 1/1000 pt.
fn lines(g: &Node) -> Vec<((f64, f64), (f64, f64))> {
let r = |v: f64| (v * 1000.0).round() / 1000.0;
g.children()
.unwrap()
.iter()
.filter(|c| c.name.is_none())
.map(|c| match &c.kind {
NodeKind::Path { path, .. } => {
let a: Vec<Point> = path.anchors().map(|(_, _, a)| a.p).collect();
assert_eq!(a.len(), 2, "a weeding line is one straight segment");
((r(a[0].x), r(a[0].y)), (r(a[1].x), r(a[1].y)))
}
other => panic!("not a path: {other:?}"),
})
.collect()
}
#[test]
fn a_weed_box_and_lines_go_around_a_rectangle() {
let mut s = session();
rect(&mut s, 100.0, 100.0, 50.0, 40.0);
let undo = s.doc().unwrap().history.undo.len();
let (r, g) = weed(&mut s, json!({"margin": 10}));
assert_eq!(g.name.as_deref(), Some("Weeding"));
assert_eq!(weed_box(&g), Some(Rect::new(90.0, 90.0, 160.0, 150.0)));
// One line each way through the middle, left out over the art.
assert_eq!(
lines(&g),
[((90.0, 120.0), (100.0, 120.0)), ((150.0, 120.0), (160.0, 120.0)), ((125.0, 90.0), (125.0, 100.0)), ((125.0, 140.0), (125.0, 150.0))]
);
assert_eq!(r["lines"], json!(4));
assert_eq!(r["box"], json!(weed_box_id(&g)));
// Stroked in Registration with no fill, selected, as one undo step that takes it all away.
for c in g.children().unwrap() {
assert_eq!(c.appearance.fill_paint(), Paint::None, "no fill");
assert!(c.appearance.stroke_paint().is_registration());
}
assert_eq!(s.doc().unwrap().selection.objects, [g.id]);
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
s.execute("edit.undo", &json!({})).unwrap();
assert!(s.doc().unwrap().doc.node(g.id).is_none());
}
fn weed_box_id(g: &Node) -> u64 {
g.children().unwrap().iter().find(|c| c.name.as_deref() == Some("Weed Box")).unwrap().id.0
}
#[test]
fn lines_stop_at_the_outline_and_cross_the_hole_of_a_compound_path() {
let mut s = session();
let outer = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
let inner = rect(&mut s, 130.0, 130.0, 40.0, 40.0);
select(&mut s, &[outer, inner]);
let c = id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap());
// Both subpaths wind the same way, so the fill rule alone decides whether the inner one is a
// hole.
let same_way = |rule: FillRule| {
move |d: &mut vectorcraft_doc::Document, _: &mut vectorcraft_doc::Selection| -> Result<()> {
let Some(NodeKind::Compound { children, rule: r }) = d.node_mut(c).map(|n| &mut n.kind) else { panic!("not a compound path") };
*r = rule;
let area = |n: &Node| match &n.kind {
NodeKind::Path { path, .. } => path.subpaths[0].signed_area(),
_ => panic!("not a path"),
};
let outer = area(&children[0]).signum();
for child in children.iter_mut() {
if area(child).signum() != outer
&& let NodeKind::Path { path, .. } = &mut std::sync::Arc::make_mut(child).kind
{
path.reverse();
}
}
Ok(())
}
};
s.edit("even-odd", same_way(FillRule::EvenOdd)).unwrap();
select(&mut s, &[c]);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The waste in the hole is cut too; the ring itself is not.
assert_eq!(lines(&g), [((90.0, 150.0), (100.0, 150.0)), ((130.0, 150.0), (170.0, 150.0)), ((200.0, 150.0), (210.0, 150.0))]);
// With the non-zero rule the inner subpath fills, and no line crosses it.
s.edit("non-zero", same_way(FillRule::NonZero)).unwrap();
select(&mut s, &[c]);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
assert_eq!(lines(&g), [((90.0, 150.0), (100.0, 150.0)), ((200.0, 150.0), (210.0, 150.0))]);
}
#[test]
fn a_gap_keeps_the_lines_away_from_the_outline() {
let mut s = session();
rect(&mut s, 100.0, 100.0, 50.0, 40.0);
let (_, g) = weed(&mut s, json!({"margin": 20, "gap": 5, "direction": "horizontal"}));
assert_eq!(weed_box(&g), Some(Rect::new(80.0, 80.0, 170.0, 160.0)));
assert_eq!(lines(&g), [((80.0, 120.0), (95.0, 120.0)), ((155.0, 120.0), (170.0, 120.0))]);
// The gap is a distance from the outline: a line passing 5 pt beside a corner, with a gap of
// 6, stops √11 pt short of the corner's height.
let mut s = session();
let a = rect(&mut s, 100.0, 100.0, 50.0, 40.0);
let b = rect(&mut s, 200.0, 60.0, 10.0, 120.0);
select(&mut s, &[a, b]);
let (_, g) = weed(&mut s, json!({"margin": 0, "gap": 6, "direction": "vertical"}));
assert_eq!(weed_box(&g), Some(Rect::new(100.0, 60.0, 210.0, 180.0)));
assert_eq!(lines(&g), [((155.0, 60.0), (155.0, 96.683)), ((155.0, 143.317), (155.0, 180.0))]);
}
#[test]
fn a_box_with_no_height_gets_no_lines_across_it() {
// A horizontal line with no margin: the box is as flat as the line, and no weeding line runs
// along it.
let mut s = session();
let l = line(&mut s, &[(100.0, 150.0), (200.0, 150.0)]);
let n = s.doc().unwrap().doc.node_count();
assert!(s.execute("addon.cutting.weed", &json!({"margin": 0, "direction": "horizontal", "box": false})).is_err());
assert_eq!(s.doc().unwrap().doc.node_count(), n, "nothing to add");
select(&mut s, &[l]);
let (_, g) = weed(&mut s, json!({"margin": 0, "direction": "horizontal"}));
assert_eq!(weed_box(&g), Some(Rect::new(100.0, 150.0, 200.0, 150.0)));
assert_eq!(lines(&g), []);
}
#[test]
fn an_open_path_stops_a_line_where_it_crosses() {
let mut s = session();
line(&mut s, &[(100.0, 100.0), (100.0, 200.0)]);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal", "gap": 2}));
assert_eq!(lines(&g), [((90.0, 150.0), (98.0, 150.0)), ((102.0, 150.0), (110.0, 150.0))]);
}
#[test]
fn type_is_measured_by_its_glyph_outlines() {
let mut s = session();
let t = id_of(&s.execute("text.create", &json!({"x": 100, "y": 200, "text": "OHO", "size": 72})).unwrap());
let glyphs = match &node(&s, t).kind {
NodeKind::Text(t) => text_outline(t),
_ => panic!("not type"),
};
let ink = glyphs.bounds().unwrap();
let (_, g) = weed(&mut s, json!({"margin": 10, "count": 3, "direction": "horizontal"}));
let b = weed_box(&g).unwrap();
for (got, want) in [(b.x0, ink.x0 - 10.0), (b.y0, ink.y0 - 10.0), (b.x1, ink.x1 + 10.0), (b.y1, ink.y1 + 10.0)] {
assert!((got - want).abs() < 0.05, "the box is 10 pt around the glyphs: {b:?} vs {ink:?}");
}
// No piece of line runs over a glyph: each piece's middle is outside the ink.
let shape = glyphs.to_bezpath();
let pieces = lines(&g);
assert!(pieces.len() > 3, "the letters break the lines: {pieces:?}");
for ((x0, y0), (x1, y1)) in pieces {
let mid = Point::new((x0 + x1) / 2.0, (y0 + y1) / 2.0);
assert_eq!(shape.winding(mid), 0, "{mid:?} is outside the glyphs");
}
}
#[test]
fn a_clip_group_is_measured_by_what_shows() {
let mut s = session();
let big = rect(&mut s, 0.0, 0.0, 400.0, 300.0);
let clip = rect(&mut s, 100.0, 100.0, 50.0, 40.0);
select(&mut s, &[big, clip]);
s.execute("object.clippingMask.make", &json!({})).unwrap();
let (_, g) = weed(&mut s, json!({"margin": 10}));
assert_eq!(weed_box(&g), Some(Rect::new(90.0, 90.0, 160.0, 150.0)));
assert_eq!(lines(&g).len(), 4);
// Art that shows only partly: the clip path's edge where the art is, and the art's edge
// inside the clip.
let mut s = session();
let art = rect(&mut s, 120.0, 0.0, 100.0, 300.0);
let clip = rect(&mut s, 100.0, 100.0, 50.0, 40.0);
select(&mut s, &[art, clip]);
s.execute("object.clippingMask.make", &json!({})).unwrap();
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
assert_eq!(weed_box(&g), Some(Rect::new(110.0, 90.0, 160.0, 150.0)));
assert_eq!(lines(&g), [((110.0, 120.0), (120.0, 120.0)), ((150.0, 120.0), (160.0, 120.0))]);
}
#[test]
fn a_group_as_the_clipping_path_clips_by_its_members() {
// Make Clipping Mask takes a path, a compound path or type; an opened file can clip by a
// group, as this one does.
let mut s = session();
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("clip group", |d, sel| {
let mut r = |x: f64, w: f64, y: f64, h: f64| {
Arc::new(Node::path(d.alloc_id(), shapes::rectangle(Rect::new(x, y, x + w, y + h)), Appearance::default()))
};
let (a, b, art) = (r(100.0, 50.0, 100.0, 40.0), r(250.0, 50.0, 100.0, 40.0), r(0.0, 400.0, 0.0, 300.0));
let clip = Arc::new(Node::group(d.alloc_id(), vec![a, b]));
let mut g = Node::group(d.alloc_id(), vec![clip, art]);
if let NodeKind::Group { clip, .. } = &mut g.kind {
*clip = true;
}
let id = g.id;
d.insert(parent, usize::MAX, g)?;
sel.set([id]);
Ok(id)
})
.unwrap();
select(&mut s, &[id]);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The art shows through both rectangles, and the line is cut between them too.
assert_eq!(weed_box(&g), Some(Rect::new(90.0, 90.0, 310.0, 150.0)));
assert_eq!(lines(&g), [((90.0, 120.0), (100.0, 120.0)), ((150.0, 120.0), (250.0, 120.0)), ((300.0, 120.0), (310.0, 120.0))]);
}
#[test]
fn lines_near_too_many_outline_segments_are_refused() {
let mut s = session();
// A zigzag of 12,000 segments; with a gap as tall as the box, each of 1,000 lines comes near
// every segment.
let mut zigzag = BezPath::new();
zigzag.move_to((100.0, 100.0));
for i in 1..=12_000 {
zigzag.line_to((100.0 + f64::from(i) * 0.01, if i % 2 == 0 { 100.0 } else { 101.0 }));
}
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("zigzag", |d, sel| {
let n = Node::path(d.alloc_id(), PathData::from_bezpath(&zigzag), Appearance::default());
let id = n.id;
d.insert(parent, usize::MAX, n)?;
sel.set([id]);
Ok(id)
})
.unwrap();
select(&mut s, &[id]);
let n = s.doc().unwrap().doc.node_count();
let e = s.execute("addon.cutting.weed", &json!({"count": 1000, "gap": 50, "direction": "horizontal"})).unwrap_err();
assert!(e.to_string().contains("too many outline segments"), "{e}");
assert_eq!(s.doc().unwrap().doc.node_count(), n);
// Fewer lines measure.
s.execute("addon.cutting.weed", &json!({"count": 10, "gap": 50, "direction": "horizontal"})).unwrap();
}
/// Adds a clip group, clipping path `clip` over `art` (both unpainted), and selects it.
fn clip_group(s: &mut Session, clip: PathData, art: PathData) -> NodeId {
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("clip group", |d, sel| {
let clip = Arc::new(Node::path(d.alloc_id(), clip, Appearance::default()));
let art = Arc::new(Node::path(d.alloc_id(), art, Appearance::default()));
let mut g = Node::group(d.alloc_id(), vec![clip, art]);
if let NodeKind::Group { clip, .. } = &mut g.kind {
*clip = true;
}
let id = g.id;
d.insert(parent, usize::MAX, g)?;
sel.set([id]);
Ok(id)
})
.unwrap();
select(s, &[id]);
id
}
#[test]
fn an_open_clipping_path_clips_as_if_closed() {
let mut s = session();
let mut v = BezPath::new();
v.move_to((100.0, 100.0));
v.line_to((150.0, 200.0));
v.line_to((200.0, 100.0));
clip_group(&mut s, PathData::from_bezpath(&v), shapes::rectangle(Rect::new(0.0, 0.0, 400.0, 300.0)));
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The art shows inside the triangle the V closes; the line stops at its sides.
assert_eq!(weed_box(&g), Some(Rect::new(90.0, 90.0, 210.0, 210.0)));
assert_eq!(lines(&g), [((90.0, 150.0), (125.0, 150.0)), ((175.0, 150.0), (210.0, 150.0))]);
}
#[test]
fn art_a_nested_clip_hides_adds_no_outline() {
// A clip group, clipping path A, holding a clip group whose clipping path B shows a small
// rectangle and hides a line that runs along A's bottom edge.
let mut s = session();
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("nested clips", |d, sel| {
let mut path = |p: PathData| Arc::new(Node::path(d.alloc_id(), p, Appearance::default()));
let mut l = BezPath::new();
l.move_to((0.0, 200.0));
l.line_to((400.0, 200.0));
let (b, shown, hidden) = (
path(shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0))),
path(shapes::rectangle(Rect::new(110.0, 110.0, 140.0, 130.0))),
path(PathData::from_bezpath(&l)),
);
let a = path(shapes::rectangle(Rect::new(50.0, 50.0, 300.0, 200.0)));
let clipped = |mut g: Node| {
if let NodeKind::Group { clip, .. } = &mut g.kind {
*clip = true;
}
g
};
let inner = Arc::new(clipped(Node::group(d.alloc_id(), vec![b, shown, hidden])));
let outer = clipped(Node::group(d.alloc_id(), vec![a, inner]));
let id = outer.id;
d.insert(parent, usize::MAX, outer)?;
sel.set([id]);
Ok(id)
})
.unwrap();
select(&mut s, &[id]);
let (_, g) = weed(&mut s, json!({"margin": 10, "count": 0}));
assert_eq!(weed_box(&g), Some(Rect::new(100.0, 100.0, 150.0, 140.0)), "only the shown rectangle is measured");
}
#[test]
fn art_a_nested_clip_hides_counts_toward_the_clip_limit() {
// A clip group, clipping path A of 20,000 segments, holding a clip group whose small clipping
// path B shows a rectangle and hides a closed zigzag C of 20,000 points across every row of A.
// The inner group shows four outline pieces, but testing each piece of A for being inside it
// looks at all of C.
let mut s = session();
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("nested clips", |d, sel| {
let mut path = |p: BezPath| Arc::new(Node::path(d.alloc_id(), PathData::from_bezpath(&p), Appearance::default()));
let mut a = BezPath::new();
a.move_to((0.0, 0.0));
for i in 1..=20_000 {
a.line_to((f64::from(i) * 0.02, if i % 2 == 0 { 0.0 } else { 0.5 }));
}
a.line_to((400.0, 300.0));
a.line_to((0.0, 300.0));
a.close_path();
let mut c = BezPath::new();
c.move_to((300.0, 0.0));
for i in 1..=20_000 {
c.line_to((300.0 + f64::from(i) * 0.002, if i % 2 == 0 { 0.0 } else { 300.0 }));
}
c.close_path();
let b = path(shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0)).to_bezpath());
let shown = path(shapes::rectangle(Rect::new(110.0, 110.0, 140.0, 130.0)).to_bezpath());
let (a, c) = (path(a), path(c));
let clipped = |mut g: Node| {
if let NodeKind::Group { clip, .. } = &mut g.kind {
*clip = true;
}
g
};
let inner = Arc::new(clipped(Node::group(d.alloc_id(), vec![b, shown, c])));
let outer = clipped(Node::group(d.alloc_id(), vec![a, inner]));
let id = outer.id;
d.insert(parent, usize::MAX, outer)?;
sel.set([id]);
Ok(id)
})
.unwrap();
select(&mut s, &[id]);
let n = s.doc().unwrap().doc.node_count();
let e = s.execute("addon.cutting.weed", &json!({"margin": 10, "count": 0})).unwrap_err();
assert!(e.to_string().contains("too many outline segments"), "{e}");
assert_eq!(s.doc().unwrap().doc.node_count(), n);
}
#[test]
fn art_selected_inside_a_clip_group_is_measured_by_what_shows() {
// The rectangle runs far outside the clipping path; selected on its own, it still shows only
// inside it.
let mut s = session();
let clip = shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0));
let g = clip_group(&mut s, clip, shapes::rectangle(Rect::new(120.0, 0.0, 220.0, 300.0)));
let art = node(&s, g).children().unwrap()[1].id;
select(&mut s, &[art]);
let (_, w) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
assert_eq!(weed_box(&w), Some(Rect::new(110.0, 90.0, 160.0, 150.0)));
assert_eq!(lines(&w), [((110.0, 120.0), (120.0, 120.0)), ((150.0, 120.0), (160.0, 120.0))]);
// The clipping path selected on its own is measured by the art it shows.
let clip_path = node(&s, g).children().unwrap()[0].id;
select(&mut s, &[clip_path]);
let (_, w) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
assert_eq!(weed_box(&w), Some(Rect::new(110.0, 90.0, 160.0, 150.0)));
// With the art selected too, or the group, the group is measured once.
let d = &s.doc().unwrap().doc;
let outline = |ids: &[NodeId]| super::geometry::Reader::new(d).read_ids(ids).unwrap().unwrap().outline().unwrap().len();
assert_eq!(outline(&[clip_path, art]), outline(&[g]));
assert_eq!(outline(&[g, art, g]), outline(&[g]));
}
#[test]
fn art_in_a_hidden_group_is_left_out() {
let mut s = session();
let shown = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
let a = rect(&mut s, 100.0, 100.0, 50.0, 40.0);
let b = rect(&mut s, 200.0, 100.0, 50.0, 40.0);
select(&mut s, &[a, b]);
let g = id_of(&s.execute("object.group", &json!({})).unwrap());
s.edit("hide", |d, _| {
if let Some(n) = d.node_mut(g) {
n.visible = false;
}
Ok(())
})
.unwrap();
select(&mut s, &[a]);
assert!(s.execute("addon.cutting.weed", &json!({})).is_err(), "nothing selected shows");
select(&mut s, &[a, shown]);
let (_, w) = weed(&mut s, json!({"margin": 10}));
assert_eq!(weed_box(&w), Some(Rect::new(290.0, 290.0, 330.0, 330.0)));
}
#[test]
fn art_in_a_hidden_group_is_not_measured() {
// Selected art in a hidden group with more outline points than the limit doesn't count toward
// it.
let mut s = session();
let shown = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
let mut p = BezPath::new();
p.move_to((100.0, 100.0));
for i in 1..=super::geometry::MAX_POINTS as u32 {
p.line_to((100.0 + f64::from(i) * 0.001, if i % 2 == 0 { 100.0 } else { 101.0 }));
}
let dense = insert(&mut s, |id| Node::path(id, PathData::from_bezpath(&p), Appearance::default()));
let g = id_of(&s.execute("object.group", &json!({})).unwrap());
s.edit("hide", |d, _| {
if let Some(n) = d.node_mut(g) {
n.visible = false;
}
Ok(())
})
.unwrap();
select(&mut s, &[dense, shown]);
let (_, w) = weed(&mut s, json!({"margin": 10}));
assert_eq!(weed_box(&w), Some(Rect::new(290.0, 290.0, 330.0, 330.0)));
}
#[test]
fn clip_outlines_crossing_too_often_are_refused() {
// A clipping path whose 700 edges each run across the art, and open art whose 700 segments
// each run down across the clipping path: every pair crosses, and each of the 490,000 pieces
// of art between crossings would be tested against all 700 edges.
let zigzag = |across: bool| {
let mut p = BezPath::new();
for i in 0..=700 {
let (along, side) = (100.0 + f64::from(i) * 0.25, if i % 2 == 0 { 100.0 } else { 300.0 });
let pt = if across { (side, along) } else { (along, side) };
if i == 0 { p.move_to(pt) } else { p.line_to(pt) }
}
p
};
let mut clip = zigzag(true);
clip.close_path();
let mut s = session();
clip_group(&mut s, PathData::from_bezpath(&clip), PathData::from_bezpath(&zigzag(false)));
let n = s.doc().unwrap().doc.node_count();
let e = s.execute("addon.cutting.weed", &json!({})).unwrap_err();
assert!(e.to_string().contains("too many outline segments"), "{e}");
assert_eq!(s.doc().unwrap().doc.node_count(), n);
}
/// Each weeding line's stretches inside the art, found from the crossings indexed once for all the
/// lines, match those found by measuring the whole art along that line.
#[test]
fn indexed_crossings_find_the_same_stretches() {
let mut s = session();
let mut ids = vec![];
let outer = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
let inner = rect(&mut s, 130.0, 130.0, 40.0, 40.0);
select(&mut s, &[outer, inner]);
ids.push(id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap()));
let big = rect(&mut s, 220.0, 50.0, 200.0, 200.0);
let window = id_of(&s.execute("shape.ellipse", &json!({"x": 260, "y": 80, "width": 90, "height": 120})).unwrap());
select(&mut s, &[big, window]);
ids.push(id_of(&s.execute("object.clippingMask.make", &json!({})).unwrap()));
ids.push(id_of(&s.execute("text.create", &json!({"x": 100, "y": 320, "text": "WEED 8", "size": 60})).unwrap()));
ids.push(line(&mut s, &[(90.0, 40.0), (450.0, 380.0)]));
let a = rect(&mut s, 300.0, 300.0, 30.0, 30.0);
let b = id_of(&s.execute("shape.ellipse", &json!({"x": 320, "y": 310, "width": 60, "height": 40})).unwrap());
select(&mut s, &[a, b]);
ids.push(id_of(&s.execute("object.group", &json!({})).unwrap()));
let d = &s.doc().unwrap().doc;
let nodes: Vec<&Node> = ids.iter().filter_map(|id| d.node(*id)).collect();
let region = super::geometry::Reader::new(d).read(&nodes).unwrap().unwrap();
let (layout, _) = super::geometry::Layout::of(&region);
let count = 97;
for vertical in [false, true] {
let (v0, v1) = (30.0, 400.0);
let step = (v1 - v0) / (count as f64 + 1.0);
let crossed = super::geometry::crossings(&region, vertical, v0, step, count).unwrap();
assert_eq!(crossed.len(), count);
let mut hit = 0;
for (k, line) in crossed.iter().enumerate() {
let c = v0 + step * (k as f64 + 1.0);
let want = region.spans(vertical, c);
hit += usize::from(!want.is_empty());
assert_eq!(region.spans_on(&layout, line, 0), want, "line {k}, vertical {vertical}");
}
assert!(hit > count / 2, "most lines cross the art ({hit})");
}
}
#[test]
fn art_nested_too_deep_is_refused() {
// A rectangle inside `levels` groups, each holding the next. A document keeps none this deep,
// but the art symbol instances and live objects draw nests further.
let doc = vectorcraft_doc::Document::new(800.0, 600.0);
let nested = |levels: usize| {
let mut n = Node::path(NodeId(1), shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0)), Appearance::default());
for i in 0..levels {
n = Node::group(NodeId(i as u64 + 2), vec![Arc::new(n)]);
}
n
};
let read = |n: &Node| super::geometry::Reader::new(&doc).read(&[n]);
assert!(read(&nested(super::geometry::MAX_DEPTH)).unwrap().is_some());
let e = read(&nested(super::geometry::MAX_DEPTH + 1)).unwrap_err();
assert!(e.contains("nested more than"), "{e}");
}
#[test]
fn spacing_divides_the_box_into_strips_no_wider() {
let mut s = session();
rect(&mut s, 100.0, 100.0, 10.0, 40.0);
// The box is 60 pt tall: three strips of 20 pt.
let (_, g) = weed(&mut s, json!({"margin": 10, "spacing": 25, "direction": "horizontal", "box": false}));
assert_eq!(weed_box(&g), None);
let ys: Vec<f64> = lines(&g).iter().map(|l| l.0.1).collect();
assert_eq!(ys, [110.0, 110.0, 130.0, 130.0]);
let mut s = session();
rect(&mut s, 100.0, 100.0, 10.0, 40.0);
assert!(s.execute("addon.cutting.weed", &json!({"spacing": 0.01})).is_err(), "too many lines");
}
#[test]
fn the_lines_take_a_swatch() {
let mut s = session();
s.execute("swatch.new", &json!({"name": "Cut", "color": "cmyk 0 100 0 0", "spot": true})).unwrap();
rect(&mut s, 100.0, 100.0, 50.0, 40.0);
let (_, g) = weed(&mut s, json!({"swatch": "Cut", "weight": 1}));
for c in g.children().unwrap() {
match c.appearance.stroke_paint() {
Paint::Solid { swatch, .. } => assert_eq!(swatch.as_deref(), Some("Cut")),
other => panic!("stroke {other:?}"),
}
assert_eq!(c.appearance.stroke_width(), 1.0);
}
}
/// Adds the object `make` makes with a new id to the current layer, selects it and gives its id.
fn insert(s: &mut Session, make: impl FnOnce(NodeId) -> Node) -> NodeId {
let parent = s.doc().unwrap().target_parent().unwrap();
let id = s
.edit("insert", |d, _| {
let n = make(d.alloc_id());
let id = n.id;
d.insert(parent, usize::MAX, n)?;
Ok(id)
})
.unwrap();
select(s, &[id]);
id
}
/// A 100 pt square turned 45° about (300, 300): a diamond 141.42 pt across.
fn diamond_xf() -> Affine {
Affine::translate((300.0, 300.0)) * Affine::rotate(std::f64::consts::FRAC_PI_4) * Affine::translate((-50.0, -50.0))
}
/// The weeding lines of `g` at height `y` (to 1/1000 pt).
fn at(g: &Node, y: f64) -> Vec<(f64, f64)> {
lines(g).into_iter().filter(|((_, y0), (_, y1))| *y0 == y && *y1 == y).map(|((x0, _), (x1, _))| (x0, x1)).collect()
}
/// The diamond's weeding with three horizontal lines and a margin of 10: the box, and where the
/// first line's left piece ends.
fn diamond_weeding(s: &mut Session) -> (Rect, f64) {
let (_, g) = weed(s, json!({"margin": 10, "count": 3, "direction": "horizontal"}));
let b = weed_box(&g).unwrap();
let y = ((b.y0 + b.height() / 4.0) * 1000.0).round() / 1000.0;
let first = at(&g, y);
assert_eq!(first.len(), 2, "{first:?}");
(b, first[0].1)
}
#[test]
fn an_image_is_measured_by_its_frame_as_turned() {
let mut s = session();
let im = vectorcraft_doc::ImageObject {
key: "image".into(),
width: 100,
height: 100,
xf: diamond_xf(),
link: None,
placement: Default::default(),
pixels: None,
};
insert(&mut s, |id| Node::new(id, NodeKind::Image(Box::new(im))));
let (b, end) = diamond_weeding(&mut s);
let half = 50.0 * std::f64::consts::SQRT_2;
assert!((b.x0 - (290.0 - half)).abs() < 1e-3 && (b.y1 - (310.0 + half)).abs() < 1e-3, "{b:?}");
// A quarter of the box down, the line meets the diamond's upper left edge, not its bounds.
let y = b.y0 + b.height() / 4.0;
assert!((end - (300.0 - (y - (300.0 - half)))).abs() < 0.01, "{end} at {y}");
}
#[test]
fn a_placed_file_is_measured_by_the_art_it_shows() {
let dir = crate::tests_links::Folder::new("weed-placed");
// A file with a 60 × 40 artboard and a 20 pt wide rectangle at each side (hidden when
// `hidden`), placed centered on (200, 150) and selected.
let place = |s: &mut Session, name: &str, hidden: bool| {
let src = dir.file(name);
let mut d = vectorcraft_doc::Document::new(60.0, 40.0);
let layer = d.layers[0].id;
for x in [0.0, 40.0] {
let id = d.alloc_id();
let look = Appearance::basic(Paint::solid(vectorcraft_color::Color::BLACK), Paint::None, 0.0);
let mut n = Node::path(id, shapes::rectangle(Rect::new(x, 0.0, x + 20.0, 40.0)), look);
n.visible = !hidden;
d.insert(Some(layer), 0, n).unwrap();
}
crate::tests_links::write(&src, &vectorcraft_format::save_file(&d));
let r = s.execute("file.place", &json!({"path": src, "at": [200, 150]})).unwrap();
select(s, &[NodeId(r["ids"][0].as_u64().unwrap())]);
};
let mut s = session();
place(&mut s, "pair.vectorcraft", false);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The rectangles lie at 170..190 and 210..230; the line runs between them too.
assert_eq!(at(&g, 150.0), [(160.0, 170.0), (190.0, 210.0), (230.0, 240.0)]);
// A file read but shown in a box with no size shows nothing, and its box isn't measured.
let id = NodeId(s.execute("file.place", &json!({"path": dir.file("pair.vectorcraft"), "at": [400, 150]})).unwrap()["ids"][0].as_u64().unwrap());
s.edit("no size", |d, _| {
if let Some(NodeKind::PlacedDocument(p)) = d.node_mut(id).map(|n| &mut n.kind) {
(p.width, p.height) = (0.0, 0.0);
}
Ok(())
})
.unwrap();
select(&mut s, &[id]);
let e = s.execute("addon.cutting.weed", &json!({})).unwrap_err();
assert!(e.to_string().contains("has no outlines"), "{e}");
// A file read with nothing showing has no outlines, and its box isn't measured instead.
let mut s = session();
place(&mut s, "hidden.vectorcraft", true);
let e = s.execute("addon.cutting.weed", &json!({})).unwrap_err();
assert!(e.to_string().contains("has no outlines"), "{e}");
// A file whose art is an instance of a symbol of its own: the instance's art is measured.
let src = dir.file("symbol.vectorcraft");
let mut d = vectorcraft_doc::Document::new(60.0, 40.0);
let look = Appearance::basic(Paint::solid(vectorcraft_color::Color::BLACK), Paint::None, 0.0);
let art = Node::path(NodeId(900), shapes::rectangle(Rect::new(0.0, 0.0, 20.0, 40.0)), look);
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Bar".into(), art: Arc::new(art) });
let (layer, id) = (d.layers[0].id, d.alloc_id());
d.insert(Some(layer), 0, Node::new(id, NodeKind::SymbolInstance { symbol: "Bar".into(), xf: Affine::IDENTITY })).unwrap();
crate::tests_links::write(&src, &vectorcraft_format::save_file(&d));
let mut s = session();
let r = s.execute("file.place", &json!({"path": src, "at": [200, 150]})).unwrap();
select(&mut s, &[NodeId(r["ids"][0].as_u64().unwrap())]);
let (_, g) = weed(&mut s, json!({"margin": 10}));
let b = weed_box(&g).unwrap();
assert!(b.x0 >= 160.0 - 1e-6 && b.x1 <= 240.0 + 1e-6 && b.width() < 41.0, "the bar, not the whole box: {b:?}");
}
#[test]
fn a_placed_file_that_cant_be_read_is_measured_by_its_box_as_turned() {
let mut s = session();
let p = vectorcraft_doc::PlacedDocument {
link: vectorcraft_doc::LinkInfo::new("/no/such/file.pdf"),
key: "missing".into(),
bounding: false,
page_box: Default::default(),
width: 100.0,
height: 100.0,
xf: diamond_xf(),
placement: Default::default(),
};
insert(&mut s, |id| Node::new(id, NodeKind::PlacedDocument(Box::new(p))));
let (b, end) = diamond_weeding(&mut s);
let half = 50.0 * std::f64::consts::SQRT_2;
let y = b.y0 + b.height() / 4.0;
assert!((end - (300.0 - (y - (300.0 - half)))).abs() < 0.01, "{end} at {y}");
}
#[test]
fn a_symbol_instance_is_measured_by_its_art() {
let mut s = session();
let a = rect(&mut s, 100.0, 100.0, 20.0, 40.0);
let b = rect(&mut s, 140.0, 100.0, 20.0, 40.0);
select(&mut s, &[a, b]);
let inst = id_of(&s.execute("symbol.new", &json!({"name": "Pair"})).unwrap());
select(&mut s, &[inst]);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The line runs between the two rectangles too.
assert_eq!(at(&g, 120.0), [(90.0, 100.0), (120.0, 140.0), (160.0, 170.0)]);
// An instance of a symbol the document doesn't have draws nothing, and has no outlines.
s.edit("lose the symbol", |d, _| {
if let Some(NodeKind::SymbolInstance { symbol, .. }) = d.node_mut(inst).map(|n| &mut n.kind) {
*symbol = "Missing".into();
}
Ok(())
})
.unwrap();
select(&mut s, &[inst]);
let n = s.doc().unwrap().doc.node_count();
let e = s.execute("addon.cutting.weed", &json!({})).unwrap_err();
assert!(e.to_string().contains("has no outlines"), "{e}");
assert_eq!(s.doc().unwrap().doc.node_count(), n);
let shown = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
select(&mut s, &[inst, shown]);
let (_, g) = weed(&mut s, json!({"margin": 10}));
assert_eq!(weed_box(&g), Some(Rect::new(290.0, 290.0, 330.0, 330.0)));
}
#[test]
fn a_blend_is_measured_by_the_art_it_draws() {
let mut s = session();
let a = rect(&mut s, 100.0, 100.0, 20.0, 40.0);
let b = rect(&mut s, 200.0, 100.0, 20.0, 40.0);
let blend = id_of(&s.execute("object.blend.make", &json!({"ids": [a.0, b.0], "steps": 1})).unwrap());
select(&mut s, &[blend]);
let (_, g) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The step halfway between the two rectangles stops the line too.
assert_eq!(at(&g, 120.0), [(90.0, 100.0), (120.0, 150.0), (170.0, 200.0), (220.0, 230.0)]);
}
#[test]
fn the_group_goes_on_top_of_the_current_layer_and_hidden_layers_are_left_out() {
let mut s = session();
let first = s.doc().unwrap().doc.layers[0].id;
let hidden = rect(&mut s, 100.0, 100.0, 50.0, 40.0);
let art = id_of(&s.execute("layer.new", &json!({"name": "Art"})).unwrap());
let shown = rect(&mut s, 300.0, 300.0, 20.0, 20.0);
let below = rect(&mut s, 400.0, 400.0, 20.0, 20.0);
s.edit("hide", |d, _| {
if let Some(n) = d.node_mut(first) {
n.visible = false;
}
Ok(())
})
.unwrap();
select(&mut s, &[hidden]);
assert!(s.execute("addon.cutting.weed", &json!({})).is_err(), "art in a hidden layer doesn't show");
select(&mut s, &[hidden, shown]);
let (_, g) = weed(&mut s, json!({"margin": 10}));
assert_eq!(weed_box(&g), Some(Rect::new(290.0, 290.0, 330.0, 330.0)));
let d = &s.doc().unwrap().doc;
assert_eq!(d.parent_of(g.id), Some(art));
assert_eq!(d.node(art).unwrap().children().unwrap().last().map(|c| c.id), Some(g.id), "on top");
// A hidden object selected on its own shows nothing.
s.edit("hide", |d, _| {
if let Some(n) = d.node_mut(below) {
n.visible = false;
}
Ok(())
})
.unwrap();
select(&mut s, &[below]);
assert!(s.execute("addon.cutting.weed", &json!({})).is_err(), "a hidden object doesn't show");
}
#[test]
fn the_group_goes_outside_a_clip_group_edited_in_isolation() {
let mut s = session();
let layer = s.doc().unwrap().doc.layers[0].id;
let g = clip_group(&mut s, shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0)), shapes::rectangle(Rect::new(120.0, 0.0, 220.0, 300.0)));
s.execute("object.isolate", &json!({"id": g.0})).unwrap();
let art = node(&s, g).children().unwrap()[1].id;
select(&mut s, &[art]);
let (_, w) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
// The clipping path would hide the lines and the box around the art inside it.
let d = &s.doc().unwrap().doc;
assert_eq!(d.parent_of(w.id), Some(layer));
assert_eq!(weed_box(&w), Some(Rect::new(110.0, 90.0, 160.0, 150.0)));
// A plain group edited in isolation inside a clip group: the group goes outside the clip group.
let mut s = session();
let parent = s.doc().unwrap().target_parent().unwrap();
let (inner, art) = s
.edit("clip group around a group", |d, _| {
let clip = Arc::new(Node::path(d.alloc_id(), shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0)), Appearance::default()));
let art = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(120.0, 0.0, 220.0, 300.0)), Appearance::default());
let art_id = art.id;
let inner = Node::group(d.alloc_id(), vec![Arc::new(art)]);
let inner_id = inner.id;
let mut g = Node::group(d.alloc_id(), vec![clip, Arc::new(inner)]);
if let NodeKind::Group { clip, .. } = &mut g.kind {
*clip = true;
}
d.insert(parent, usize::MAX, g)?;
Ok((inner_id, art_id))
})
.unwrap();
s.execute("object.isolate", &json!({"id": inner.0})).unwrap();
select(&mut s, &[art]);
let (_, w) = weed(&mut s, json!({"margin": 10, "direction": "horizontal"}));
assert_eq!(s.doc().unwrap().doc.parent_of(w.id), parent);
assert_eq!(weed_box(&w), Some(Rect::new(110.0, 90.0, 160.0, 150.0)));
}
/// Adds one path of `count` open vertical subpaths 2 pt apart, from (100, 100) down to y = 200.
fn bars(s: &mut Session, count: u32) -> NodeId {
let mut p = BezPath::new();
for i in 0..count {
let x = 100.0 + f64::from(i) * 2.0;
p.move_to((x, 100.0));
p.line_to((x, 200.0));
}
insert(s, |id| Node::path(id, PathData::from_bezpath(&p), Appearance::default()))
}
#[test]
fn more_than_the_most_pieces_of_line_is_refused() {
// 1,000 lines each cut into 100 pieces by 101 bars: as many as one run adds.
let mut s = session();
bars(&mut s, 101);
let r = s.execute("addon.cutting.weed", &json!({"margin": 0, "count": 1000, "direction": "horizontal"})).unwrap();
assert_eq!(r["lines"], json!(super::MAX_PIECES));
// One bar more makes 1,000 pieces more.
let mut s = session();
bars(&mut s, 102);
let n = s.doc().unwrap().doc.node_count();
let e = s.execute("addon.cutting.weed", &json!({"margin": 0, "count": 1000, "direction": "horizontal"})).unwrap_err();
assert!(e.to_string().contains("more than 100000 pieces"), "{e}");
assert_eq!(s.doc().unwrap().doc.node_count(), n);
}
#[test]
fn art_with_more_than_the_most_outline_points_is_refused() {
// An open zigzag of `points` points: one subpath, measured by its points.
let zigzag = |s: &mut Session, points: u32| {
let mut p = BezPath::new();
p.move_to((100.0, 100.0));
for i in 1..points {
p.line_to((100.0 + f64::from(i) * 0.001, if i % 2 == 0 { 100.0 } else { 101.0 }));
}
insert(s, |id| Node::path(id, PathData::from_bezpath(&p), Appearance::default()));
};
let mut s = session();
zigzag(&mut s, super::geometry::MAX_POINTS as u32);
s.execute("addon.cutting.weed", &json!({"count": 0})).unwrap();
let mut s = session();
zigzag(&mut s, super::geometry::MAX_POINTS as u32 + 1);
let e = s.execute("addon.cutting.weed", &json!({"count": 0})).unwrap_err();
assert!(e.to_string().contains("too many outline points"), "{e}");
}
#[test]
fn bad_params_and_an_empty_selection_are_refused() {
let mut s = session();
rect(&mut s, 100.0, 100.0, 50.0, 40.0);
for p in [
json!({"margin": -1}),
json!({"gap": "x"}),
json!({"count": 1.5}),
json!({"count": 1001}),
json!({"count": 2, "spacing": 10}),
json!({"spacing": 0}),
json!({"direction": "diagonal"}),
json!({"box": "yes"}),
json!({"weight": 0}),
json!({"swatch": "no such swatch"}),
json!({"swatch": 3}),
json!({"box": false, "count": 0}),
] {
let n = s.doc().unwrap().doc.node_count();
assert!(s.execute("addon.cutting.weed", &p).is_err(), "{p}");
assert_eq!(s.doc().unwrap().doc.node_count(), n, "nothing added for {p}");
}
// The same art with good params is weeded; with nothing selected it is refused.
s.execute("addon.cutting.weed", &json!({"count": 2, "gap": "1 mm"})).unwrap();
s.execute("select.set", &json!({"ids": []})).unwrap();
assert!(s.execute("addon.cutting.weed", &json!({})).is_err());
}
+1 -1
View File
@@ -162,7 +162,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Brush Options…",
[],
None,
"{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180° (counter-clockwise from level), roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure|tilt|bearing|rotation for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest; tilt from value − variation with the pen lying flat to value + variation with it upright; bearing and rotation add variation × the pen's bearing (which way it leans, counter-clockwise from leaning right) or its barrel's counter-clockwise rotation over 180°; the angle turns on past ±180°). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180° (counter-clockwise), modes: [fixed|random|pressure|tilt|bearing|rotation for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest; tilt: a with the pen lying flat to b upright; bearing and rotation: a at −180° to b at 180°), rotation_relative_to_path. art: width 1..1000%, width_mode: null (fixed)|pressure, width_max 1..1000% (pressure: width at the lightest pen pressure to width_max at the heaviest, half way on a stroke drawn without pressure), scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across, overlap. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across, outer_corner and inner_corner: corner tile art (drawn as the corner that joins a side tile on its right to one below it) or null, outer_source and inner_source: what that kind of corner draws without its art: none|autoCentered|autoBetween|autoSliced|autoOverlap (a tile made from the side tile), or null (the other kind of corner's art); side_tile, outer_corner_tile, inner_corner_tile, start_tile, end_tile: a document pattern name, original, or none (side refuses none); corner tiles also take autoCentered|autoBetween|autoSliced|autoOverlap. Each tile also accepts {pattern: name} to select a swatch whose name is a reserved choice. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour; without a key: the solid color the art's fills and strokes use most, black when they use none)}; colorization and the art brush's scale change only the fields given}, newName? (trimmed; blank: the name is kept; a new bristle brush name has at most 31 characters, and a longer name the brush has is kept)} edit a brush definition (strokes using it update) → {name}",
"{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180° (counter-clockwise from level), roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure|tilt|bearing|rotation for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest; tilt from value − variation with the pen lying flat to value + variation with it upright; bearing and rotation add variation × the pen's bearing (which way it leans, counter-clockwise from leaning right) or its barrel's counter-clockwise rotation over 180°; the angle turns on past ±180°). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180° (counter-clockwise), modes: [fixed|random|pressure|tilt|bearing|rotation for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest; tilt: a with the pen lying flat to b upright; bearing and rotation: a at −180° to b at 180°), rotation_relative_to_path. art: width 1..1000%, width_mode: null (fixed)|pressure|tilt|bearing|rotation, width_max 1..1000% (pressure: width at the lightest pen pressure to width_max at the heaviest; tilt: width with the pen lying flat to width_max upright; bearing and rotation: width at −180° to width_max at 180°; half way on a stroke drawn without that input), scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across, overlap. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across, outer_corner and inner_corner: corner tile art (drawn as the corner that joins a side tile on its right to one below it) or null, outer_source and inner_source: what that kind of corner draws without its art: none|autoCentered|autoBetween|autoSliced|autoOverlap (a tile made from the side tile), or null (the other kind of corner's art); side_tile, outer_corner_tile, inner_corner_tile, start_tile, end_tile: a document pattern name, original, or none (side refuses none); corner tiles also take autoCentered|autoBetween|autoSliced|autoOverlap. Each tile also accepts {pattern: name} to select a swatch whose name is a reserved choice. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour; without a key: the solid color the art's fills and strokes use most, black when they use none)}; colorization and the art brush's scale change only the fields given}, newName? (trimmed; blank: the name is kept; a new bristle brush name has at most 31 characters, and a longer name the brush has is kept)} edit a brush definition (strokes using it update) → {name}",
has_doc,
brush_options
),
+281 -50
View File
@@ -18,7 +18,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Document Info",
["Window", "Document Info"],
None,
"{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts, images, swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the Brushes panel's brushes; with selectionOnly: the brushes the selected objects' strokes use), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else Linear gradient, Radial gradient or Freeform gradient; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone",
"{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts, images, swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the Brushes panel's brushes; with selectionOnly: the brushes the selected objects' strokes use), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient with a stop above opacity 0, at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else Linear gradient, Radial gradient or Freeform gradient; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone",
has_doc,
info
),
@@ -40,7 +40,7 @@ pub const CATEGORIES: [(&str, &str); 13] = [
("objects", "Objects"),
("graphicStyles", "Graphic Styles"),
("brushes", "Brushes"),
("spotColors", "Spot Colors"),
("spotColors", "Spot Color Objects"),
("patterns", "Pattern Objects"),
("gradients", "Gradient Objects"),
("symbols", "Symbols"),
@@ -52,7 +52,7 @@ pub const CATEGORIES: [(&str, &str); 13] = [
];
/// The object counts of `document.info` and their labels.
const OBJECT_LABELS: [(&str, &str); 18] = [
const OBJECT_LABELS: [(&str, &str); 19] = [
("paths", "Paths"),
("compoundPaths", "Compound Paths"),
("groups", "Groups"),
@@ -63,6 +63,7 @@ const OBJECT_LABELS: [(&str, &str); 18] = [
("symbolInstances", "Symbol Instances"),
("gradients", "Gradient Objects"),
("patterns", "Pattern Objects"),
("spots", "Spot Color Objects"),
("meshes", "Gradient Meshes"),
("blends", "Blends"),
("envelopes", "Envelopes"),
@@ -131,7 +132,7 @@ fn repeat_entry(d: &Document, n: &Node, spec: &RepeatSpec) -> (Value, (String, S
/// The Document Info categories of `d` (only `category` when given) from `info` (what
/// `document.info` reports), its fonts, its image objects, the rows of its Repeat objects and the
/// rows of its objects filled or stroked with a pattern and with a gradient.
/// rows of its objects filled or stroked with a spot color, with a pattern and with a gradient.
#[allow(clippy::too_many_arguments)]
fn sections(
d: &Document,
@@ -139,6 +140,7 @@ fn sections(
fonts: &BTreeSet<super::fonts::UsedFont>,
images: &[ImageRow],
repeats: &[(String, String)],
spot_objects: &[(String, String)],
pattern_objects: &[(String, String)],
gradient_objects: &[(String, String)],
category: Option<&str>,
@@ -183,7 +185,7 @@ fn sections(
}
"graphicStyles" => names("graphicStyleNames"),
"brushes" => names("brushNames"),
"spotColors" => names("spotColors"),
"spotColors" => spot_objects.to_vec(),
"patterns" => pattern_objects.to_vec(),
"gradients" => gradient_objects.to_vec(),
"symbols" => names("symbols"),
@@ -273,15 +275,50 @@ fn gradient_label(p: &Paint) -> Option<String> {
}
}
/// The type object `n` holds and the runs its layout draws, when it uses a pattern or a gradient:
/// the runs with a glyph outline (list markers and ruby included) or an underline or strikethrough
/// bar. Spaces and line breaks draw no outline. A type object's characters carry their own fill and
/// stroke, and the type object's own fills and strokes paint on its characters, so only those runs
/// paint. The type is laid out with its inline graphics' bounds resolved from `d`'s symbols, as the
/// renderer lays it out.
fn painted_runs<'a>(d: &Document, n: &'a Node) -> Option<(&'a vectorcraft_doc::TextObject, BTreeSet<usize>)> {
/// The names of `d`'s spot color swatches: the swatches whose prints go to a plate of their own
/// ([`vectorcraft_doc::inks::inks`]). A name held by several swatches is the first one's, as
/// [`Document::swatch`] finds it, and the Registration swatch prints on every plate, so it is not
/// one.
fn spot_swatches(d: &Document) -> HashSet<&str> {
let mut first: BTreeMap<&str, bool> = BTreeMap::new();
for s in d.swatches_iter() {
first.entry(s.name.as_str()).or_insert(s.spot && s.paint.color().is_some());
}
first.into_iter().filter(|&(name, spot)| spot && name != vectorcraft_color::swatch::REGISTRATION).map(|(name, _)| name).collect()
}
/// The spot colors paint `p` prints (`spots`: [`spot_swatches`]): the spot swatch a solid color is
/// linked to, or those a gradient's stops are linked to, each once, in the order of the stops. A
/// link at a tint of 0 prints no ink, a gradient whose stops are all at an opacity of 0 draws
/// nothing, and a color that only looks like a spot color is not linked to one.
fn spot_labels(spots: &HashSet<&str>, p: &Paint) -> Vec<String> {
let mut out: Vec<String> = vec![];
let mut add = |swatch: &Option<String>, tint: f32| {
if let Some(name) = swatch
&& tint > 0.0
&& spots.contains(name.as_str())
&& !out.contains(name)
{
out.push(name.clone());
}
};
match p {
Paint::Solid { swatch, tint, .. } => add(swatch, *tint),
Paint::Gradient(g) if g.gradient.stops.iter().any(|s| s.opacity > 0.0) => g.gradient.stops.iter().for_each(|s| add(&s.swatch, s.tint)),
_ => {}
}
out
}
/// The type object `n` holds and the runs its layout draws, when it uses a spot color, a pattern or
/// a gradient (`spots`: [`spot_swatches`]): the runs with a glyph outline (list markers and ruby
/// included) or an underline or strikethrough bar. Spaces and line breaks draw no outline. A type
/// object's characters carry their own fill and stroke, and the type object's own fills and strokes
/// paint on its characters, so only those runs paint. The type is laid out with its inline
/// graphics' bounds resolved from `d`'s symbols, as the renderer lays it out.
fn painted_runs<'a>(d: &Document, spots: &HashSet<&str>, n: &'a Node) -> Option<(&'a vectorcraft_doc::TextObject, BTreeSet<usize>)> {
let NodeKind::Text(t) = &n.kind else { return None };
let is_listed = |p: &Paint| matches!(p, Paint::Pattern { .. } | Paint::Gradient(_));
let is_listed = |p: &Paint| matches!(p, Paint::Pattern { .. } | Paint::Gradient(_)) || !spot_labels(spots, p).is_empty();
let own = n.appearance.items.iter().any(|i| match i {
vectorcraft_doc::AppearanceItem::Fill(f) => is_listed(&f.paint),
vectorcraft_doc::AppearanceItem::Stroke(s) => is_listed(&s.paint),
@@ -297,43 +334,53 @@ fn painted_runs<'a>(d: &Document, n: &'a Node) -> Option<(&'a vectorcraft_doc::T
Some((t, painted))
}
/// The patterns or gradients (`label`: [`pattern_label`] or [`gradient_label`]) that `n`'s own
/// fills and strokes paint, each once. A hidden fill or stroke and a stroke with no width paint
/// nothing, and neither does any fill or stroke of a guide (drawn in the guide color), of a compound
/// path's member (`members`: the compound path's own fills and strokes paint it) or of type whose
/// layout draws nothing (`painted_runs`). An image's fills and strokes paint only where an effect
/// gives them a shape.
/// The names a paint is listed by in a Document Info category: its spot colors, its pattern or its
/// gradient.
type PaintNames<'a> = dyn Fn(&Paint) -> Vec<String> + 'a;
/// The spot colors, patterns or gradients (`label`: [`spot_labels`], [`pattern_label`] or
/// [`gradient_label`], each paint's names) that `n`'s own fills and strokes paint, each once. A
/// hidden fill or stroke and a stroke with no width paint nothing, and neither does any fill or
/// stroke of a guide (drawn in the guide color), of a compound path's member (`members`: the
/// compound path's own fills and strokes paint it) or of type whose layout draws nothing
/// (`painted_runs`). An image's fills and strokes paint only where an effect gives them a shape.
fn own_paints(
d: &Document,
n: &Node,
members: &HashSet<*const Node>,
painted_runs: Option<&(&vectorcraft_doc::TextObject, BTreeSet<usize>)>,
label: fn(&Paint) -> Option<String>,
label: &PaintNames<'_>,
) -> Vec<String> {
if matches!(n.kind, NodeKind::Path { guide: true, .. })
|| members.contains(&std::ptr::from_ref(n))
|| painted_runs.is_some_and(|(_, r)| r.is_empty())
|| !n.appearance.items.iter().any(|i| label(i.paint()).is_some())
|| n.appearance.items.iter().all(|i| label(i.paint()).is_empty())
{
return vec![];
}
// The patterns or gradients an image's shaped fills and strokes paint (their effects can
// transform the paint, so they are matched by label).
// The names an image's shaped fills and strokes paint (their effects can transform the paint,
// so they are matched by name).
let shaped: Option<Vec<String>> = matches!(n.kind, NodeKind::Image(_))
.then(|| vectorcraft_render::effects::image_paint(Some(d), n).into_iter().filter_map(|(_, _, item)| label(item.paint())).collect());
.then(|| vectorcraft_render::effects::image_paint(Some(d), n).into_iter().flat_map(|(_, _, item)| label(item.paint())).collect());
let mut out: Vec<String> = vec![];
for item in &n.appearance.items {
let Some(name) = label(item.paint()) else { continue };
let paints = item.visible()
&& !matches!(item, vectorcraft_doc::AppearanceItem::Stroke(s) if s.width <= 0.0)
&& shaped.as_ref().is_none_or(|s| s.contains(&name));
if paints && !out.contains(&name) {
out.push(name);
if !item.visible() || matches!(item, vectorcraft_doc::AppearanceItem::Stroke(s) if s.width <= 0.0) {
continue;
}
for name in label(item.paint()) {
if shaped.as_ref().is_none_or(|s| s.contains(&name)) && !out.contains(&name) {
out.push(name);
}
}
}
out
}
/// [`pattern_label`] or [`gradient_label`] as the names [`own_paints`] takes.
fn one_label(label: fn(&Paint) -> Option<String>) -> impl Fn(&Paint) -> Vec<String> {
move |p| label(p).into_iter().collect()
}
fn info(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "document.info";
let category = str_param(p, "category");
@@ -370,7 +417,13 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
};
let mut patterns = BTreeSet::new();
let mut symbols = BTreeSet::new();
// `spot_objects`, `spot_rows` and `spot` hold the `spotObjects` entries, the rows of the objects filled or stroked with a spot
// color, in walk order, and the spot colors they use. `spot_swatches` names the document's spot colors once, for every paint.
let spot_swatches = spot_swatches(d);
let mut spot_objects: Vec<Value> = vec![];
let mut spot_rows: Vec<(String, String)> = vec![];
let mut spot = BTreeSet::new();
let (spot_label, pattern, gradient) = (|p: &Paint| spot_labels(&spot_swatches, p), one_label(pattern_label), one_label(gradient_label));
let mut styles: Vec<&str> = if selection_only { vec![] } else { d.graphic_styles.iter().map(|g| g.name.as_str()).collect() };
// `brushes` holds the Brushes panel's brushes, or with selectionOnly it holds the brushes that the selected objects' strokes use.
let mut brushes: Vec<String> = if selection_only { vec![] } else { vectorcraft_brush::library(d).into_iter().map(|b| b.name).collect() };
@@ -446,17 +499,11 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(k) = k {
*counts.entry(k).or_default() += 1;
}
for item in &n.appearance.items {
if let Paint::Solid { swatch: Some(name), .. } = item.paint()
&& d.swatch(name).is_some_and(|s| s.spot)
{
spot.insert(name.clone());
}
}
// The patterns and the gradients this object's fills and strokes paint, each once.
let painted_runs = painted_runs(d, n);
let mut used_patterns = own_paints(d, n, &members, painted_runs.as_ref(), pattern_label);
let mut used_gradients = own_paints(d, n, &members, painted_runs.as_ref(), gradient_label);
// The spot colors, the patterns and the gradients this object's fills and strokes paint, each once.
let painted_runs = painted_runs(d, &spot_swatches, n);
let mut used_spots = own_paints(d, n, &members, painted_runs.as_ref(), &spot_label);
let mut used_patterns = own_paints(d, n, &members, painted_runs.as_ref(), &pattern);
let mut used_gradients = own_paints(d, n, &members, painted_runs.as_ref(), &gradient);
// The characters' own paints: an inline graphic draws no outline and does not take its
// run's paint (a list marker set in its run does), and a stroke with no width paints
// nothing.
@@ -464,19 +511,38 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
for run in painted.iter().filter_map(|i| t.runs.get(*i)) {
let stroke = (run.style.stroke_width > 0.0).then_some(&run.style.stroke);
for paint in std::iter::once(&run.style.fill).chain(stroke) {
for (used, label) in
[(&mut used_patterns, pattern_label as fn(&Paint) -> Option<String>), (&mut used_gradients, gradient_label)]
{
if let Some(name) = label(paint)
&& !used.contains(&name)
{
used.push(name);
let labels: [(&mut Vec<String>, &PaintNames<'_>); 3] =
[(&mut used_spots, &spot_label), (&mut used_patterns, &pattern), (&mut used_gradients, &gradient)];
for (used, label) in labels {
for name in label(paint) {
if !used.contains(&name) {
used.push(name);
}
}
}
}
}
}
// Objects counts the objects that Pattern Objects and Gradient Objects list.
// A grayscale or 1-bit image colorized with a spot color prints it, while its pixels take
// the color, as the renderer draws it.
if let NodeKind::Image(im) = &n.kind
&& let Some(colorize) = n.extras().colorize.as_deref()
&& d.image_blob(im).is_some_and(|b| b.takes_colorize())
{
for name in spot_label(colorize) {
if !used_spots.contains(&name) {
used_spots.insert(0, name);
}
}
}
// Objects counts the objects that Spot Color Objects, Pattern Objects and Gradient Objects list.
if !used_spots.is_empty() {
let name = n.display_name();
spot.extend(used_spots.iter().cloned());
spot_rows.push((name.clone(), used_spots.join(", ")));
spot_objects.push(json!({ "id": n.id.0, "name": name, "spotColors": used_spots }));
*counts.entry("spots").or_default() += 1;
}
if !used_patterns.is_empty() {
let name = n.display_name();
patterns.extend(used_patterns.iter().cloned());
@@ -529,6 +595,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
"images": images,
"symbols": symbols,
"spotColors": spot,
"spotColorNames": spot,
"spotObjects": spot_objects,
"swatches": d.swatches_iter().count(),
"graphicStyles": d.graphic_styles.len(),
"graphicStyleNames": styles,
@@ -544,7 +612,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
});
// The document's name: its file's, else its title.
out["document"]["name"] = json!(st.title());
let sections = sections(d, &out, &fonts, &image_rows, &repeat_rows, &pattern_rows, &gradient_rows, category);
let sections = sections(d, &out, &fonts, &image_rows, &repeat_rows, &spot_rows, &pattern_rows, &gradient_rows, category);
if text {
return Ok(json!({ "text": report_text(&st.title(), selection_only, &sections) }));
}
@@ -997,6 +1065,169 @@ mod tests {
assert!(!text.contains("Spare"), "{text}");
}
/// Document Info › Spot Color Objects lists each object filled or stroked with a spot color once,
/// with the spot colors it uses, as a solid color or in a gradient's stops, one in a group and a
/// type object whose characters use one included. A spot swatch no art uses adds no row; a
/// process color that looks the same, Registration and a tint of 0 are not spot colors; paint
/// that draws nothing is left out by the rules Pattern Objects follows; and Objects counts the
/// listed objects. With Selection Only it lists the objects in the selection, each once, and the
/// report writes the same rows.
#[test]
fn info_lists_the_spot_color_objects() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
// An empty document lists none.
let i = s.execute("document.info", &json!({"category": "spotColors"})).unwrap();
assert_eq!((i["spotObjects"].clone(), i["spotColorNames"].clone(), i["spotColors"].clone()), (json!([]), json!([]), json!([])));
assert!(i["objects"]["spots"].is_null() && i["sections"][0]["rows"] == json!([]), "{i}");
let text = s.execute("document.info", &json!({"category": "spotColors", "format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
assert!(text.contains("\nSPOT COLOR OBJECTS\nNone\n"), "{text}");
let ink = |c: f64| json!({"model": "cmyk", "c": c, "m": 0.5, "y": 0.0, "k": 0.0});
s.execute("swatch.new", &json!({"name": "Ink", "color": ink(1.0), "spot": true})).unwrap();
s.execute("swatch.new", &json!({"name": "Gold", "color": ink(0.2), "spot": true})).unwrap();
s.execute("swatch.new", &json!({"name": "Spare", "color": ink(0.4), "spot": true})).unwrap();
// A global process color of the same color as Ink.
s.execute("swatch.new", &json!({"name": "Look", "color": ink(1.0), "global": true})).unwrap();
let square =
|s: &mut Session, x: f64| s.execute("shape.rectangle", &json!({"x": x, "y": 0, "width": 10, "height": 10})).unwrap()["id"].clone();
let ramp = |a: &str, b: &str| json!({"kind": "linear", "stops": [{"offset": 0, "color": "#000", "swatch": a}, {"offset": 1, "color": "#fff", "swatch": b}]});
let (a, b, c, f, g, h) =
(square(&mut s, 0.0), square(&mut s, 20.0), square(&mut s, 40.0), square(&mut s, 60.0), square(&mut s, 80.0), square(&mut s, 100.0));
s.execute("paint.setFill", &json!({"ids": [a], "swatch": "Ink"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [a], "swatch": "Gold", "tint": 40})).unwrap();
s.execute("layer.setProps", &json!({"id": a, "name": "Both"})).unwrap();
s.execute("paint.setFill", &json!({"ids": [b], "swatch": "Look"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [b], "swatch": "Ink", "tint": 50})).unwrap();
s.execute("paint.setFill", &json!({"ids": [c], "swatch": "Ink", "tint": 0})).unwrap();
s.execute("paint.setFill", &json!({"ids": [f], "gradient": ramp("Gold", "Look")})).unwrap();
s.execute("paint.setFill", &json!({"ids": [g], "gradient": ramp("Look", "Look")})).unwrap();
s.execute("paint.setFill", &json!({"ids": [h], "swatch": "[Registration]"})).unwrap();
for id in [&c, &g, &h] {
s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap();
}
s.execute("select.set", &json!({"ids": [b, c]})).unwrap();
let group = s.execute("object.group", &json!({})).unwrap()["id"].clone();
// A type object whose characters are filled with a spot color.
let t = s.execute("text.create", &json!({"x": 0, "y": 200, "text": "Hi"})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [t], "swatch": "Ink"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [t], "none": true})).unwrap();
s.execute("layer.setProps", &json!({"id": t, "name": "Type"})).unwrap();
// A hidden spot fill and a spot stroke with no width paint nothing, so neither object is listed.
let (d, e) = (square(&mut s, 120.0), square(&mut s, 140.0));
s.execute("paint.setStroke", &json!({"ids": [d], "none": true})).unwrap();
s.execute("paint.setFill", &json!({"ids": [d], "swatch": "Ink"})).unwrap();
s.execute("appearance.setItem", &json!({"ids": [d], "index": 0, "visible": false})).unwrap();
s.execute("paint.setFill", &json!({"ids": [e], "none": true})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [e], "swatch": "Ink"})).unwrap();
s.execute("appearance.setItem", &json!({"ids": [e], "index": 1, "weight": 0})).unwrap();
// Type with no characters, or of only spaces and a line break, paints nothing, and neither
// does a guide made from a path with a spot color.
let empty = s.execute("text.create", &json!({"x": 0, "y": 300, "text": ""})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [empty], "swatch": "Ink"})).unwrap();
s.execute("appearance.addFill", &json!({"ids": [empty]})).unwrap();
let blank = s.execute("text.create", &json!({"x": 0, "y": 320, "text": " \n"})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [blank], "swatch": "Ink"})).unwrap();
let guide = square(&mut s, 300.0);
s.execute("paint.setFill", &json!({"ids": [guide], "swatch": "Ink"})).unwrap();
s.execute("select.set", &json!({"ids": [guide]})).unwrap();
s.execute("view.guides.make", &json!({})).unwrap();
// Nor does a compound path's member's own spot fill, or an image's spot fill without an
// effect that gives it a shape.
let (m1, m2) = (square(&mut s, 320.0), square(&mut s, 340.0));
s.execute("select.set", &json!({"ids": [m1, m2]})).unwrap();
let compound = s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"ids": [compound], "color": "#000000"})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [compound], "none": true})).unwrap();
let node = |s: &Session, id: &Value| s.doc().unwrap().doc.node(vectorcraft_doc::NodeId(id.as_u64().unwrap())).unwrap().clone();
let (member, paint) = (node(&s, &compound).children().unwrap()[0].id, node(&s, &a).appearance);
let pic = square(&mut s, 360.0);
s.execute("select.set", &json!({"ids": [pic]})).unwrap();
s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
let image = s.doc().unwrap().selection.objects[0];
s.edit("own paint", |d, _| {
d.node_mut(member).unwrap().appearance = paint.clone();
d.node_mut(image).unwrap().appearance = paint;
Ok(())
})
.unwrap();
let i = s.execute("document.info", &json!({})).unwrap();
assert_eq!(
i["spotObjects"],
json!([
{"id": a, "name": "Both", "spotColors": ["Ink", "Gold"]},
{"id": b, "name": "<Rectangle>", "spotColors": ["Ink"]},
{"id": f, "name": "<Rectangle>", "spotColors": ["Gold"]},
{"id": t, "name": "Type", "spotColors": ["Ink"]},
])
);
assert_eq!((i["spotColorNames"].clone(), i["spotColors"].clone()), (json!(["Gold", "Ink"]), json!(["Gold", "Ink"])));
// Objects counts the objects that Spot Color Objects lists.
assert_eq!(i["objects"]["spots"].as_u64(), Some(4), "{}", i["objects"]);
let objects = s.execute("document.info", &json!({"category": "objects"})).unwrap()["sections"][0]["rows"].clone();
assert!(objects.as_array().unwrap().contains(&json!(["Spot Color Objects", "4"])), "{objects}");
s.execute("select.set", &json!({"ids": [c, g, h, d, e, empty, blank, guide, compound, image.0]})).unwrap();
let i = s.execute("document.info", &json!({"selectionOnly": true})).unwrap();
assert!(i["objects"]["spots"].is_null() && i["spotObjects"] == json!([]) && i["spotColors"] == json!([]), "{i}");
let i = s.execute("document.info", &json!({"category": "spotColors"})).unwrap();
assert_eq!((i["sections"][0]["id"].as_str(), i["sections"][0]["title"].as_str()), (Some("spotColors"), Some("Spot Color Objects")));
assert_eq!(i["sections"][0]["rows"], json!([["Both", "Ink, Gold"], ["<Rectangle>", "Ink"], ["<Rectangle>", "Gold"], ["Type", "Ink"]]));
// A selection that holds the group and the object inside it lists that object once.
for ids in [json!([group, b]), json!([b, group])] {
s.execute("select.set", &json!({"ids": ids})).unwrap();
let i = s.execute("document.info", &json!({"selectionOnly": true, "category": "spotColors"})).unwrap();
assert_eq!(i["sections"][0]["rows"], json!([["<Rectangle>", "Ink"]]), "{ids}");
assert_eq!((i["objects"]["spots"].as_u64(), i["spotColorNames"].clone()), (Some(1), json!(["Ink"])), "{ids}");
}
s.execute("select.set", &json!({"ids": [t]})).unwrap();
let i = s.execute("document.info", &json!({"selectionOnly": true, "category": "spotColors"})).unwrap();
assert_eq!((i["sections"][0]["rows"].clone(), i["spotColors"].clone()), (json!([["Type", "Ink"]]), json!(["Ink"])));
let text = s.execute("document.info", &json!({"category": "spotColors", "format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
assert!(text.contains("\nSPOT COLOR OBJECTS\nBoth: Ink, Gold\n<Rectangle>: Ink\n<Rectangle>: Gold\nType: Ink\n"), "{text}");
assert!(!text.contains("Spare") && !text.contains("Look"), "{text}");
}
/// Spot Color Objects lists a grayscale image colorized with a spot color, and leaves out a
/// gradient whose stops are all at an opacity of 0, which draws nothing.
#[test]
fn spot_color_objects_take_colorized_images_and_skip_clear_gradients() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
s.execute("swatch.new", &json!({"name": "Ink", "color": {"model": "cmyk", "c": 0, "m": 1, "y": 1, "k": 0}, "spot": true})).unwrap();
let mut bytes = Vec::new();
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(2, 1, vec![0, 255]).unwrap())
.write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png)
.unwrap();
let image = s
.edit("Place", |d, sel| {
d.images.insert("gray".into(), vectorcraft_doc::ImageBlob::png(bytes));
let id = d.alloc_id();
let im = vectorcraft_doc::ImageObject {
key: "gray".into(),
width: 2,
height: 1,
xf: Default::default(),
link: None,
placement: Default::default(),
pixels: None,
};
d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
sel.set([id]);
Ok(id)
})
.unwrap();
s.execute("paint.setFill", &json!({"swatch": "Ink"})).unwrap();
assert!(s.doc().unwrap().doc.node(image).unwrap().extras().colorize.is_some());
let clear = s.execute("shape.rectangle", &json!({"x": 0, "y": 50, "width": 10, "height": 10})).unwrap()["id"].clone();
let stops =
json!([{"offset": 0, "color": "#000", "swatch": "Ink", "opacity": 0}, {"offset": 1, "color": "#fff", "swatch": "Ink", "opacity": 0}]);
s.execute("paint.setFill", &json!({"ids": [clear], "gradient": {"kind": "linear", "stops": stops}})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [clear], "none": true})).unwrap();
let i = s.execute("document.info", &json!({})).unwrap();
let name = s.doc().unwrap().doc.node(image).unwrap().display_name();
assert_eq!(i["spotObjects"], json!([{"id": image.0, "name": name, "spotColors": ["Ink"]}]), "{i}");
assert_eq!(i["objects"]["spots"].as_u64(), Some(1), "{}", i["objects"]);
}
/// Document Info › Objects counts an object with a gradient or a pattern on both its fill and
/// its stroke once, and with Selection Only a selection that holds a group and an object inside
/// it counts that object once.
+1 -1
View File
@@ -23,7 +23,7 @@ pub fn specs() -> Vec<CommandSpec> {
"New…",
["File"],
None,
"{preset?: a name from file.newPresets (start from it; the other params change it), name?|title?: document name (default Untitled-N), width?: pt=612|\"210 mm\", height?: pt=792, units?: \"Pixels\"|\"Points\"|\"Picas\"|\"Inches\"|\"Millimeters\"|\"Centimeters\"|\"Feet\"|\"Yards\"|\"Meters\"|\"Feet & Inches\" (default: prefs unitsGeneral, as print presets; screen presets: Pixels), orientation?: \"portrait\"|\"landscape\" (swaps width and height to match), artboards?: n (1–1000), artboardLayout?: {layout?: \"gridByRow\"|\"gridByColumn\"|\"row\"|\"column\", columns?: n (default: all in one row), spacing?: pt=20, rightToLeft?: bool}, bleed?: pt|[top, bottom, left, right]|{top?, …} (0–72 pt), backgroundContents?: \"transparent\"|\"white\" (a white artboard background, not an object), colorMode?: \"rgb\"|\"cmyk\" (a CMYK document starts with CMYK swatches and stores the colours applied to it as CMYK), rasterEffectsPpi?: 72|150|300 (1–2400), previewMode?: \"default\"|\"pixel\"|\"overprint\" (overprint turns Overprint Preview on, pixel Pixel Preview in the app; default leaves both), alignNewObjectsToPixelGrid?: bool (Advanced Options › Align New Objects to Pixel Grid: paths drawn in the document are pixel-aligned; default on for the Mobile and Web presets, else off; document.setup changes it later), created?: Unix seconds|null (File Info's created date; default now, recorded in the journal so a replay matches), size?: a preset's size label (a preset file.newPresets lists can be passed back; ignored)} → {index, previewMode}; the size is remembered in file.newPresets' Recent",
"{preset?: a name from file.newPresets (start from it; the other params change it), name?|title?: document name (default Untitled-N), width?: pt=612|\"210 mm\", height?: pt=792 (each more than 0 and at most 3,999,856 pt, as artboard.new takes them), units?: \"Pixels\"|\"Points\"|\"Picas\"|\"Inches\"|\"Millimeters\"|\"Centimeters\"|\"Feet\"|\"Yards\"|\"Meters\"|\"Feet & Inches\" (default: prefs unitsGeneral, as print presets; screen presets: Pixels), orientation?: \"portrait\"|\"landscape\" (swaps width and height to match), artboards?: n (1–1000), artboardLayout?: {layout?: \"gridByRow\"|\"gridByColumn\"|\"row\"|\"column\", columns?: n (default: all in one row), spacing?: pt=20, rightToLeft?: bool}, bleed?: pt|[top, bottom, left, right]|{top?, …} (0–72 pt), backgroundContents?: \"transparent\"|\"white\" (a white artboard background, not an object), colorMode?: \"rgb\"|\"cmyk\" (a CMYK document starts with CMYK swatches and stores the colours applied to it as CMYK), rasterEffectsPpi?: 72|150|300 (1–2400), previewMode?: \"default\"|\"pixel\"|\"overprint\" (overprint turns Overprint Preview on, pixel Pixel Preview in the app; default leaves both), alignNewObjectsToPixelGrid?: bool (Advanced Options › Align New Objects to Pixel Grid: paths drawn in the document are pixel-aligned; default on for the Mobile and Web presets, else off; document.setup changes it later), created?: Unix seconds|null (File Info's created date; default now, recorded in the journal so a replay matches), size?: a preset's size label (a preset file.newPresets lists can be passed back; ignored)} → {index, previewMode}; the size is remembered in file.newPresets' Recent",
always,
super::newdoc::file_new
),
+87 -20
View File
@@ -47,7 +47,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Expand…",
["Object"],
None,
"{object?: true (symbol instances without effects (their fills' and strokes' included) and not in perspective → their art, as Break Link to Symbol places it (the instances that art holds stay instances), type → outlines, live shapes → paths, effects baked, blends → groups of their steps, repeats → groups of their instances, Intertwine groups → groups of their objects and of the parts drawn over the others (clip groups), envelopes → their distorted content, placed documents → editable copies of their art, as placing the file without link gives, its symbols, patterns, swatches and images joining the document), fill?: true (gradient fills → `gradient` art, pattern fills → their tiles in a clip group shaped like the object), stroke?: true (strokes → filled outlines, the stroked paths that baking effects leaves included), gradient?: \"objects\" (default: `steps` solid strips, concentric ellipses for radial gradients, wedges around the center for conic ones, nested squares for diamond ones) | \"mesh\" (a gradient mesh); both in a clip group shaped like the object (freeform gradients always become a mesh shaped like it), steps?: 1..1000 (255)} one undo step; a dimension whose art an option changes becomes a plain group of its art, except one selected with art it measures, directly or in groups without fills, strokes or effects of their own: its lines and label stay as they are, and if the new art no longer fits its link it stays where it was, no longer linked → {ids}",
"{object?: true (symbol instances without effects (their fills' and strokes' included) and not in perspective → their art, as Break Link to Symbol places it (the instances that art holds stay instances), type → outlines, live shapes → paths, effects baked, blends → groups of their steps, repeats → groups of their instances, Intertwine groups → groups of their objects and of the parts drawn over the others (clip groups), envelopes → their distorted content, placed documents → editable copies of their art, as placing the file without link gives, its symbols, patterns, swatches and images joining the document), fill?: true (gradient fills → `gradient` art, pattern fills → their tiles in a clip group shaped like the object), stroke?: true (strokes → filled outlines, the stroked paths that baking effects leaves included), gradient?: \"objects\" (default: `steps` solid strips, concentric ellipses for radial gradients, wedges around the center for conic ones, nested squares for diamond ones) | \"mesh\" (a gradient mesh); both in a clip group shaped like the object (freeform gradients always become a mesh shaped like it), steps?: 1..1000 (255; a gradient that repeats or reflects gets the same whole number of them in each run, at least one, so a run starts on an object's edge)} one undo step; a dimension whose art an option changes becomes a plain group of its art, except one selected with art it measures, directly or in groups without fills, strokes or effects of their own: its lines and label stay as they are, and if the new art no longer fits its link it stays where it was, no longer linked → {ids}",
has_selection,
expand
),
@@ -476,11 +476,14 @@ fn gradient_art(d: &mut Document, l: &Node, path: &PathData, bounds: Rect, f: &F
let m = GradientMesh::for_path_with(path, FREEFORM_MESH, FREEFORM_MESH, &*gradient_sampler(g, bounds, d.color_mode.model()))?;
vec![Node::new(d.alloc_id(), NodeKind::Mesh(m))]
} else {
// A gradient that repeats or reflects expands as its stops repeated over the box.
let (g, runs) = padded_on(g, bounds);
let g = &*g;
let frame = Frame::new(g, bounds);
match to {
GradientTo::Mesh => vec![Node::new(d.alloc_id(), NodeKind::Mesh(frame.mesh(&g.gradient)))],
GradientTo::Objects(n) => frame
.pieces(&g.gradient, n as usize)
.pieces(&g.gradient, n as usize, runs)
.into_iter()
.map(|(shape, (color, opacity))| {
let fill = FillLayer { opacity, overprint: f.overprint, ..FillLayer::new(Paint::solid(color)) };
@@ -1234,8 +1237,64 @@ pub(crate) fn gradient_sampler(g: &GradientPaint, bounds: Rect, doc_model: Model
(super::paint::stored_color(store_in, c), a)
});
}
let (geom, spread) = (g.resolve(bounds), g.gradient.spreader());
Box::new(move |p| g.gradient.sample_keep_model(spread(geom.param_at(g.gradient.kind, p)) as f32))
}
/// `g` placed on box `bounds` as a gradient that pads past its ends: a linear, radial or diamond
/// gradient that repeats or reflects with its stops repeated as many times as the box needs
/// ([`vectorcraft_color::Gradient::padded_over`]), a conic one with its stops repeated around the
/// turn ([`vectorcraft_color::Gradient::unrolled`]); others as they are. With it, for the repeated
/// stops, where along the vector (0 to 1) their first run starts and how many runs lie evenly from
/// there to 1.
fn padded_on(g: &GradientPaint, bounds: Rect) -> (std::borrow::Cow<'_, GradientPaint>, Option<(f64, usize)>) {
use std::borrow::Cow;
if !g.gradient.is_spread() {
return (Cow::Borrowed(g), None);
}
let geom = g.resolve(bounds);
Box::new(move |p| g.gradient.sample_keep_model(geom.param_at(g.gradient.kind, p) as f32))
match g.gradient.padded_over(&geom, bounds) {
Some(p) => {
let runs = Some((p.first, p.runs));
(Cow::Owned(GradientPaint { gradient: p.gradient, geom: Some(p.geom), angle: p.geom.angle_deg(), ..g.clone() }), runs)
}
None => {
let runs = Some((0.0, g.gradient.repeat_count() as usize));
(Cow::Owned(GradientPaint { gradient: g.gradient.unrolled().into_owned(), geom: Some(geom), ..g.clone() }), runs)
}
}
}
/// The edges (gradient parameters, from `lo` to `hi`) of about `n` bands [`Frame::pieces`] cuts:
/// evenly spaced, or for stops repeated in `runs` ([`padded_on`]: where the first run starts and
/// how many runs lie evenly from there to 1) the same whole number of bands in each run between
/// `lo` and `hi` (at least one, about `n` in all), so every run starts on an edge and no band
/// holds two runs' colors.
fn band_edges(lo: f64, hi: f64, n: usize, runs: Option<(f64, usize)>) -> Vec<f64> {
let n = n.max(1);
let even = || {
let step = (hi - lo) / n as f64;
(0..=n).map(|k| lo + k as f64 * step).collect()
};
let Some((first, count)) = runs.filter(|&(first, count)| count > 0 && (0.0..1.0).contains(&first)) else { return even() };
let run = (1.0 - first) / count as f64;
let (from, to) = (lo.max(first), hi.min(1.0));
let shown = (to - from) / run;
if !(shown > 0.0 && shown.is_finite()) {
return even();
}
let step = run / (n as f64 / shown).round().max(1.0);
// Both whole numbers of steps from `first`, at most `n` plus the runs shown, plus one.
let (k0, k1) = (((from - first) / step).ceil(), ((to - first) / step).floor());
let mut edges = vec![lo];
for k in (k0 as usize)..(k1 as usize).saturating_add(1) {
let t = first + k as f64 * step;
if t > edges.last().copied().unwrap_or(lo) + 1e-12 && t < hi - 1e-12 {
edges.push(t);
}
}
edges.push(hi);
edges
}
/// Where the colour changes along a gradient between parameters `t0` and `t1`: both ends, every
@@ -1404,10 +1463,17 @@ impl Frame {
/// end, for a radial one, nested ellipses (largest first), for a conic one, wedges around the
/// center from each band's start to the seam, for a diamond one, nested squares (largest
/// first). Each paints over the ones below except its band, so no seam shows between bands.
/// With translucent stops each shape is just its band, so nothing doubles up.
fn pieces(&self, g: &Gradient, n: usize) -> Vec<(PathData, (Color, f32))> {
/// With translucent stops each shape is just its band, so nothing doubles up. Stops repeated
/// in `runs` ([`padded_on`]) get the same whole number of bands in each run ([`band_edges`]).
fn pieces(&self, g: &Gradient, n: usize, runs: Option<(f64, usize)>) -> Vec<(PathData, (Color, f32))> {
let opaque = g.stops.iter().all(|s| s.opacity >= 1.0);
let color = |e: &[f64], k: usize| {
let (a, b) = (e.get(k).copied().unwrap_or(0.0), e.get(k + 1).copied().unwrap_or(1.0));
g.sample_keep_model(((a + b) / 2.0) as f32)
};
if let Some((geom, b, _)) = &self.conic {
// Evenly spaced around the turn, as the wedges are.
let n = band_edges(0.0, 1.0, n, runs).len().saturating_sub(1);
return geom
.conic_wedges(*b, n, opaque)
.into_iter()
@@ -1419,51 +1485,52 @@ impl Frame {
return vec![(shapes::rectangle(*b), g.sample_keep_model(1.0))];
};
// Nested squares about the center, largest first, as a radial gradient's ellipses.
let step = reach / n as f64;
let edges = band_edges(0.0, *reach, n, runs);
let square = |t: f64| -> SubPath {
let pts: Vec<Point> = [0.0, 0.25, 0.5, 0.75].iter().map(|&u| *frame * (diamond_perimeter(u).to_vec2() * t).to_point()).collect();
SubPath::polyline(&pts, true)
};
return (0..n)
return (0..edges.len().saturating_sub(1))
.rev()
.map(|k| {
let mut shape = PathData::single(square((k + 1) as f64 * step));
let mut shape = PathData::single(square(edges.get(k + 1).copied().unwrap_or(*reach)));
if !opaque && k > 0 {
let mut hole = square(k as f64 * step);
let mut hole = square(edges.get(k).copied().unwrap_or(0.0));
hole.reverse();
shape.subpaths.push(hole);
}
(shape, g.sample_keep_model(((k as f64 + 0.5) * step) as f32))
(shape, color(&edges, k))
})
.collect();
}
let step = (self.t1 - self.t0) / n as f64;
let color = |k: usize| g.sample_keep_model((self.t0 + (k as f64 + 0.5) * step) as f32);
let edges = band_edges(self.t0, self.t1, n, runs);
let bands = edges.len().saturating_sub(1);
let edge = |k: usize| edges.get(k).copied().unwrap_or(self.t1);
if self.radial {
let ellipse = |t: f64| {
let c = self.focal + (self.start - self.focal) * t;
let m = Affine::new([self.along.x * t, self.along.y * t, self.across.x * t, self.across.y * t, c.x, c.y]);
shapes::ellipse(Rect::new(-1.0, -1.0, 1.0, 1.0)).transformed(m)
};
return (0..n)
return (0..bands)
.rev()
.map(|k| {
let mut shape = ellipse((k + 1) as f64 * step);
let mut shape = ellipse(edge(k + 1));
if !opaque && k > 0 {
let mut hole = ellipse(k as f64 * step).subpaths.remove(0);
let mut hole = ellipse(edge(k)).subpaths.remove(0);
hole.reverse();
shape.subpaths.push(hole);
}
(shape, color(k))
(shape, color(&edges, k))
})
.collect();
}
(0..n)
(0..bands)
.map(|k| {
let a = self.t0 + k as f64 * step;
let b = if opaque { self.t1 } else { a + step };
let a = edge(k);
let b = if opaque { self.t1 } else { edge(k + 1) };
let pts = [self.at(a, self.s0), self.at(b, self.s0), self.at(b, self.s1), self.at(a, self.s1)];
(PathData::single(SubPath::polyline(&pts, true)), color(k))
(PathData::single(SubPath::polyline(&pts, true)), color(&edges, k))
})
.collect()
}
+49 -8
View File
@@ -653,6 +653,11 @@ pub(super) fn export_for_screens(s: &mut Session, p: &Value) -> Result<Value> {
None => e,
})?;
remember(s, &p);
// A prepared export is written later, maybe on another thread: it names the folder as this
// request may see it.
if let (Some(folder), Some(Some(export))) = (hidden, s.screens_hand_off.as_mut()) {
export.hidden = Some((folder.to_string(), super::access::shown_path(folder).into_owned()));
}
if !given && let Some(folder) = str_param(&p, "folder").filter(|f| !f.is_empty()) {
leave_out_unreadable_folder(&mut r, folder);
}
@@ -663,10 +668,14 @@ pub(super) fn export_for_screens(s: &mut Session, p: &Value) -> Result<Value> {
/// give: `folder` as the path the error is about names it by its own name
/// ([`super::access::shown_path`]), and the rest of the message stays.
fn leave_out_folder_from_error(e: EngineError, folder: &str) -> EngineError {
let name = super::access::shown_path(folder);
leave_out_folder_named(e, folder, &super::access::shown_path(folder))
}
/// [`leave_out_folder_from_error`] with `folder` named `name`.
fn leave_out_folder_named(e: EngineError, folder: &str, name: &str) -> EngineError {
match e {
EngineError::Other(msg) => EngineError::Other(leave_out_folder_from_message(&msg, folder, &name)),
EngineError::BadParams { cmd, msg } => EngineError::BadParams { cmd, msg: leave_out_folder_from_message(&msg, folder, &name) },
EngineError::Other(msg) => EngineError::Other(leave_out_folder_from_message(&msg, folder, name)),
EngineError::BadParams { cmd, msg } => EngineError::BadParams { cmd, msg: leave_out_folder_from_message(&msg, folder, name) },
e => e,
}
}
@@ -699,9 +708,14 @@ fn leave_out_folder_from_message(msg: &str, folder: &str, name: &str) -> String
/// `path` is left out and `files` names each file written relative to `folder` (`2x/Logo@2x.png`),
/// as the reply of an export to a ZIP names them.
fn leave_out_unreadable_folder(r: &mut Value, folder: &str) {
if super::access::shown(folder) {
return;
if !super::access::shown(folder) {
leave_out_folder(r, folder);
}
}
/// The reply `r` of an export into `folder` with the ZIP's `path` left out and `files` named
/// relative to `folder` ([`leave_out_unreadable_folder`]).
fn leave_out_folder(r: &mut Value, folder: &str) {
let Some(o) = r.as_object_mut() else { return };
o.remove("path");
let inside = format!("{folder}/");
@@ -1074,7 +1088,7 @@ pub(crate) fn export(s: &mut Session, p: &Value) -> Result<Value> {
// Include Artboard Fill off: the encoders leave the background colors out.
let fill = if o.include_artboard_fill == Some(false) { json!({ "includeArtboardFill": false }) } else { json!({}) };
let rows = rows.into_iter().map(|r| Row { options: merge(with_black_output(s, &r.options), fill.clone()), ..r }).collect();
let export = ScreenExport { cmd: C, o, rows, naming, items };
let export = ScreenExport { cmd: C, o, rows, naming, items, hidden: None };
match &mut s.screens_hand_off {
Some(slot) => {
*slot = Some(export);
@@ -1095,9 +1109,27 @@ pub struct ScreenExport {
rows: Vec<Row>,
naming: Naming,
items: Vec<Item>,
/// The export folder and the name the request that prepared the export may see it by, when the
/// folder came from the `exportPreset` and is outside that request's read roots: the reply and
/// the errors of [`ScreenExport::write`] name it as [`export_for_screens`] does.
hidden: Option<(String, String)>,
}
impl Session {
/// The folder `document.exportForScreens` (`id`) with `params` writes into, the client's
/// `folder` or else the one its `exportPreset` keeps, with the name the request being served may
/// see it by when the reply leaves it out: a preset's folder outside the read roots, named by
/// its own name ([`super::access::shown_path`]). `assets.export` takes no preset, so for it the
/// folder is the client's. → `None` without a folder (the files come back in the reply) or for
/// an unknown preset, which the export itself refuses.
pub fn screen_export_folder(&self, id: &str, params: &Value) -> Option<(String, Option<String>)> {
let given = params.get("folder").is_some();
let p = if given || id == ASSETS { params.clone() } else { with_preset(self, params).ok()? };
let folder = str_param(&p, "folder").filter(|f| !f.is_empty())?.to_string();
let hidden = (!given && !super::access::shown(&folder)).then(|| super::access::shown_path(&folder).into_owned());
Some((folder, hidden))
}
/// Run `assets.export` when `id` names it, else `document.exportForScreens`, with `params` as
/// a command (checked and journaled as any other; Export for Screens remembers its settings)
/// that encodes and writes nothing → the export it prepared, which [`ScreenExport::write`]
@@ -1123,10 +1155,19 @@ impl ScreenExport {
/// return → the reply of `document.exportForScreens`. It reports one progress step per file
/// ([`vectorcraft_doc::cancel::progress`]), and a cancel stops it before it encodes or writes
/// another file.
pub fn write(self, writer: &mut dyn FnMut(&str, &[u8]) -> Result<()>) -> Result<Value> {
pub fn write(mut self, writer: &mut dyn FnMut(&str, &[u8]) -> Result<()>) -> Result<Value> {
let cmd = self.cmd;
let hidden = self.hidden.take();
// A refusal names `assets.export` when that command prepared the export, as its reply does.
encode_and_write(self, writer).map_err(|e| if cmd == C { e } else { crate::cmd::assets::of_cmd(cmd, e) })
let r = encode_and_write(self, writer).map_err(|e| if cmd == C { e } else { crate::cmd::assets::of_cmd(cmd, e) });
match hidden {
Some((folder, name)) => {
let mut r = r.map_err(|e| leave_out_folder_named(e, &folder, &name))?;
leave_out_folder(&mut r, &folder);
Ok(r)
}
None => r,
}
}
}
@@ -735,6 +735,81 @@ fn a_refused_export_into_a_presets_folder_outside_the_read_root_names_it_by_its_
assert!(e.contains(&format!("root {root}: {name}")), "{e}");
}
/// A prepared export into the folder an export preset keeps, prepared for a client whose read roots
/// don't hold that folder and written later outside that client's scope (as on the background
/// thread): its reply leaves out the ZIP's path and names the files relative to the folder, and a
/// refused write names the folder by its name. A folder inside the read roots, and one the client
/// gives, stay whole.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_prepared_export_into_a_presets_folder_outside_the_read_root_leaves_it_out() {
use crate::file_access::{AutomationRoots, confine};
let mut s = session(1);
let tmp = Folder::new("prepared-roots");
let (inside, out) = (tmp.0.join("in"), tmp.0.join("kept-out"));
for f in [&inside, &out] {
std::fs::create_dir_all(f).unwrap();
}
let folder = out.to_string_lossy().replace('\\', "/");
let settings = json!({"formats": [{"format": "png", "folder": "1x"}], "subfolders": true, "folder": folder});
s.execute("document.exportPresets.save", &json!({"name": "Kept", "settings": settings})).unwrap();
let write_only = AutomationRoots::new(&[inside.as_path()], &[out.as_path()]).unwrap();
let both = AutomationRoots::new(&[inside.as_path(), out.as_path()], &[out.as_path()]).unwrap();
let prepare = |s: &mut Session, roots: &Option<std::sync::Arc<AutomationRoots>>, p: Value| {
confine(roots.as_ref(), || s.prepare_screen_export("document.exportForScreens", &p)).unwrap()
};
let (r, files) = write_prepared(prepare(&mut s, &write_only, json!({"exportPreset": "Kept"})));
assert_eq!(r["files"], json!(["1x/Artboard-1.png"]), "{r}");
assert!(files.contains_key(&format!("{folder}/1x/Artboard-1.png")), "the files are written into the folder");
let (r, _) = write_prepared(prepare(&mut s, &write_only, json!({"exportPreset": "Kept", "zip": true})));
assert_eq!((r.get("path"), &r["files"]), (None, &json!(["1x/Artboard-1.png"])), "{r}");
assert!(!r.to_string().contains(&folder), "{r}");
// A refused write names the folder by its name.
let refused = prepare(&mut s, &write_only, json!({"exportPreset": "Kept"}));
let e = refused.write(&mut |path, _| Err(crate::EngineError::Other(format!("{path}: access denied")))).unwrap_err().to_string();
assert!(e.contains("kept-out/1x/Artboard-1.png: access denied") && !e.contains(&folder), "{e}");
// Inside the read roots, or given by the client: whole.
let (r, _) = write_prepared(prepare(&mut s, &both, json!({"exportPreset": "Kept"})));
assert_eq!(r["files"], json!([format!("{folder}/1x/Artboard-1.png")]), "{r}");
let (r, _) = write_prepared(prepare(&mut s, &write_only, json!({"exportPreset": "Kept", "folder": folder, "zip": true})));
assert!(r["path"].as_str().is_some_and(|p| p.starts_with(&format!("{folder}/")) && p.ends_with(".zip")), "{r}");
let given = prepare(&mut s, &write_only, json!({"exportPreset": "Kept", "folder": folder}));
let e = given.write(&mut |path, _| Err(crate::EngineError::Other(format!("{path}: access denied")))).unwrap_err().to_string();
assert!(e.contains(&folder), "{e}");
}
/// [`Session::screen_export_folder`]: the client's folder, else the one the export preset keeps,
/// with its own name when the request's read roots don't hold it; none without a folder, for an
/// unknown preset or for `assets.export`, which takes no preset.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn the_export_folder_is_the_clients_else_the_presets() {
use crate::file_access::{AutomationRoots, confine};
let mut s = session(1);
let tmp = Folder::new("export-folder");
let (inside, out) = (tmp.0.join("in"), tmp.0.join("kept-out"));
for f in [&inside, &out] {
std::fs::create_dir_all(f).unwrap();
}
let folder = out.to_string_lossy().replace('\\', "/");
let settings = json!({"formats": [{"format": "png"}], "folder": folder});
s.execute("document.exportPresets.save", &json!({"name": "Kept", "settings": settings})).unwrap();
let confined = AutomationRoots::new(&[inside.as_path()], &[inside.as_path()]).unwrap();
let ask = |id: &str, p: Value| confine(confined.as_ref(), || s.screen_export_folder(id, &p));
let screens = "document.exportForScreens";
assert_eq!(ask(screens, json!({"exportPreset": "Kept"})), Some((folder.clone(), Some("kept-out".to_string()))));
assert_eq!(ask(screens, json!({"exportPreset": "Kept", "folder": "/x/y"})), Some(("/x/y".to_string(), None)));
assert_eq!(ask(screens, json!({"exportPreset": "Kept", "folder": ""})), None);
assert_eq!(ask(screens, json!({"exportPreset": "Nope"})), None);
assert_eq!(ask(screens, json!({})), None);
assert_eq!(ask("assets.export", json!({"exportPreset": "Kept"})), None);
assert_eq!(s.screen_export_folder(screens, &json!({"exportPreset": "Kept"})), Some((folder, None)), "unconfined: whole");
}
/// The export settings the document keeps and the saved presets, read by a client whose read roots
/// don't hold their folder: `document.exportSettings`, `document.exportPresets.list` and
/// `document.exportPresets.export` (as data and as a file) leave out that folder and keep the rest.
+45 -7
View File
@@ -20,6 +20,9 @@
//! and they lie the same way relative to each other: the group as a whole is moved or scaled.
//! With Appearance on, each of those objects must have the same fill and stroke too; with Size,
//! the groups the same width and height.
//! - Selecting one of the repeated objects with the Selection tool highlights the similar objects
//! at once, before Global Edit starts. Here they are the objects Start Global Edit would take
//! with the current Global Edit Options ([`similar`]).
//! - While Global Edit is on, an edit made to one of the found objects is made to all of them,
//! each in proportion to its own size: halving the height of a 100 pt object halves a 20 pt
//! match to 10 pt. Stop Global Edit (or Escape) ends it.
@@ -780,18 +783,55 @@ pub(crate) fn propagate(before: &Document, d: &mut Document, ge: &GlobalEdit, se
/// The outlines of the members of the active document's Global Edit that are not selected, hold
/// no selected object and sit inside no selected object, in their layer's colour: the canvas
/// highlights them while Global Edit is on.
/// highlights them while Global Edit is on. While it is off, with one supported object selected,
/// they are the outlines of the objects Start Global Edit would take with the Global Edit Options
/// ([`similar`]).
pub fn highlights(s: &Session) -> Outlines {
let Some(st) = s.active() else { return vec![] };
let Some(ge) = &st.global_edit else { return vec![] };
let Some(ge) = &st.global_edit else { return similar(s) };
if let Some((rev, out)) = &*ge.outlines.borrow()
&& *rev == st.revision
{
return out.clone();
}
let out = outlines(st, &ge.members);
*ge.outlines.borrow_mut() = Some((st.revision, out.clone()));
out
}
/// [`similar`]'s outlines as of a document revision and the options they were found with.
pub type SimilarCache = std::cell::RefCell<Option<(u64, Options, Outlines)>>;
/// Before Global Edit starts: with one supported object selected, the outlines of the other
/// objects Start Global Edit would take now with the session's Global Edit Options, so the canvas
/// shows them as soon as the object is selected. None while an interaction (a drag) is in
/// progress, or when fewer than two objects would be taken. Kept per document revision and
/// options, as finding them walks the whole document.
pub fn similar(s: &Session) -> Outlines {
let Some(st) = s.active() else { return vec![] };
if st.global_edit.is_some() || st.interaction.is_some() || st.selection.objects.len() != 1 {
return vec![];
}
let o = &s.global_edit_options;
if let Some((rev, opts, out)) = &*st.similar_outlines.borrow()
&& *rev == st.revision
&& opts == o
{
return out.clone();
}
let out = match matches(s, o) {
Ok(m) if m.len() >= 2 => outlines(st, &m),
_ => vec![],
};
*st.similar_outlines.borrow_mut() = Some((st.revision, o.clone(), out.clone()));
out
}
/// The outlines of `members` that are not selected, hold no selected object and sit inside no
/// selected object, in their layer's color.
fn outlines(st: &crate::DocState, members: &[(NodeId, Affine)]) -> Outlines {
let symbols = st.doc.symbol_boxes();
let out: Vec<_> = ge
.members
members
.iter()
.filter_map(|(id, _)| {
let n = st.doc.node(*id).filter(|n| !holds(n, &st.selection.objects))?;
@@ -804,9 +844,7 @@ pub fn highlights(s: &Session) -> Outlines {
};
Some((path, st.doc.layer_color(*id)))
})
.collect();
*ge.outlines.borrow_mut() = Some((st.revision, out.clone()));
out
.collect()
}
#[cfg(test)]
+55 -2
View File
@@ -1,7 +1,8 @@
//! The Gradient panel and the Gradient tool: in-place gradient edits and the gradient vector.
use serde_json::{Value, json};
use vectorcraft_color::{Gradient, GradientGeom, GradientKind, GradientMethod, GradientPaint, GradientStop, Paint};
use vectorcraft_color::gradient::MAX_REPEATS;
use vectorcraft_color::{Gradient, GradientGeom, GradientKind, GradientMethod, GradientPaint, GradientSpread, GradientStop, Paint};
use vectorcraft_doc::appearance::stroke_paint_bounds;
use vectorcraft_doc::{Document, Node, NodeKind, StrokeGradientMode};
use vectorcraft_geom::{Affine, Point, Rect};
@@ -23,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Gradient",
["Window", "Gradient"],
None,
"{stroke?: bool (default: the targeted item's kind, else the active proxy), kind?: linear|radial|conic|diamond|freeform (conic, also accepted as angle or conical, sweeps the stops once around the center, clockwise from the vector, with a seam where the last stop meets the first; diamond runs the stops from the center out to a square with a corner at the end of the vector; freeform places points on each object, coloured along the stops), mode?: points|lines (freeform: how the Gradient tool adds points), method?: classic|perceptual (how the colours between the stops mix: in display RGB, or perceptually (OKLab) so the steps look even; SVG exports draw a Perceptual gradient as an image, and PDF exports do too unless it is linear, radial, conic or diamond, has spot color stops, every other stop is paper white or written in CMYK or gray (an export that converts colors to a CMYK destination profile writes RGB and Lab stops in CMYK, and so does a CMYK document unless the export converts colors to an RGB destination profile), it is not a dithered fill and its curve does not have too many stops: then PDF writes tints of one spot ink as a Separation shading in that ink, and spot inks mixed with other spot, CMYK or gray inks as a DeviceN shading; freeform gradients mix their own way), stops?: [{offset 0..1, color? (needed without swatch; #rrggbbaa and #rgba are refused), opacity? 0..1 (or 0..100), midpoint? 0.13..0.87, swatch?: colour swatch name (a global or spot colour or tint swatch links the stop, so swatch edits recolour it and a spot stop prints on its plate; a process colour just gives its colour), tint?: 0..100 (% of the linked swatch; default 100, or a tint swatch's own)}] (at least 2; a freeform gradient's points are recoloured along them), keepModel?: bool (as paint.setFill; a stop color the gradient already has keeps its model), angle?: deg counter-clockwise (0: the gradient runs left to right; radial, conic and diamond: the vector turns about the center), aspect?: % (radial, conic and diamond; a negative one mirrors a conic's sweep and is an error for the other kinds), reverse?: bool, dither?: bool (fills only: a linear, radial, conic or diamond gradient fill is drawn with fine noise that hides banding, and as pixels in SVG and PDF exports), item?: fill/stroke item index|null (omitted: the Appearance panel's active item when it is of the edited kind), ids?|id?, strokeMode?: within|along|across (strokes only: the gradient lies on the page and shows through the stroke, runs from the start of each subpath to its end, or runs from the stroke's left edge to its right all along it; with nothing selected, for the next object drawn; type characters' own strokes always paint within), target?: \"object\"|\"contents\"} edit the gradient in place (keeps its placement); solid/none paints become the default gradient",
"{stroke?: bool (default: the targeted item's kind, else the active proxy), kind?: linear|radial|conic|diamond|freeform (conic, also accepted as angle or conical, sweeps the stops once around the center, clockwise from the vector, with a seam where the last stop meets the first; diamond runs the stops from the center out to a square with a corner at the end of the vector; freeform places points on each object, coloured along the stops), mode?: points|lines (freeform: how the Gradient tool adds points), method?: classic|perceptual (how the colours between the stops mix: in display RGB, or perceptually (OKLab) so the steps look even; SVG exports draw a Perceptual gradient as an image, and PDF exports do too unless it is linear, radial, conic or diamond, has spot color stops, every other stop is paper white or written in CMYK or gray (an export that converts colors to a CMYK destination profile writes RGB and Lab stops in CMYK, and so does a CMYK document unless the export converts colors to an RGB destination profile), it is not a dithered fill and its curve does not have too many stops: then PDF writes tints of one spot ink as a Separation shading in that ink, and spot inks mixed with other spot, CMYK or gray inks as a DeviceN shading; freeform gradients mix their own way), spread?: pad|repeat|reflect (linear, radial, conic and diamond: what the gradient paints past the ends of its stops: pad carries the end colors on; repeat and reflect run the stops `repeats` times along the vector (around the circle, for a conic) and on past both ends, reflect mirroring every other run; an error on a freeform gradient), repeats?: 1..100 (a whole number: how many times repeat and reflect run the stops along the vector; VectorCraft's own limit; pad keeps it unused), stops?: [{offset 0..1, color? (needed without swatch; #rrggbbaa and #rgba are refused), opacity? 0..1 (or 0..100), midpoint? 0.13..0.87, swatch?: colour swatch name (a global or spot colour or tint swatch links the stop, so swatch edits recolour it and a spot stop prints on its plate; a process colour just gives its colour), tint?: 0..100 (% of the linked swatch; default 100, or a tint swatch's own)}] (at least 2; a freeform gradient's points are recoloured along them), keepModel?: bool (as paint.setFill; a stop color the gradient already has keeps its model), angle?: deg counter-clockwise (0: the gradient runs left to right; radial, conic and diamond: the vector turns about the center), aspect?: % (radial, conic and diamond; a negative one mirrors a conic's sweep and is an error for the other kinds), reverse?: bool, dither?: bool (fills only: a linear, radial, conic or diamond gradient fill is drawn with fine noise that hides banding, and as pixels in SVG and PDF exports), item?: fill/stroke item index|null (omitted: the Appearance panel's active item when it is of the edited kind), ids?|id?, strokeMode?: within|along|across (strokes only: the gradient lies on the page and shows through the stroke, runs from the start of each subpath to its end, or runs from the stroke's left edge to its right all along it; with nothing selected, for the next object drawn; type characters' own strokes always paint within), target?: \"object\"|\"contents\"} edit the gradient in place (keeps its placement); solid/none paints become the default gradient",
has_doc,
edit_gradient
),
@@ -129,6 +130,36 @@ fn method_param(p: &Value) -> Parsed<Option<GradientMethod>> {
}
}
/// The `spread` param of `p`, if given: what the gradient paints past the ends of its stops.
fn spread_param(p: &Value) -> Parsed<Option<GradientSpread>> {
match p.get("spread") {
None | Some(Value::Null) => Ok(None),
Some(v) => v.as_str().and_then(GradientSpread::parse).map(Some).ok_or_else(|| "`spread` must be pad, repeat or reflect".into()),
}
}
/// The `repeats` param of `p`, if given: how many times the stops run along the vector with
/// Repeat and Reflect, a whole number from 1 to [`MAX_REPEATS`].
fn repeats_param(p: &Value) -> Parsed<Option<u32>> {
match p.get("repeats") {
None | Some(Value::Null) => Ok(None),
Some(v) => v
.as_f64()
.filter(|n| n.fract() == 0.0 && (1.0..=f64::from(MAX_REPEATS)).contains(n))
.map(|n| Some(n as u32))
.ok_or_else(|| format!("`repeats` must be a whole number from 1 to {MAX_REPEATS}")),
}
}
/// An error when `p` gives a spread other than pad for a gradient of `kind` that has no ends to
/// spread past (freeform).
fn spread_for(kind: GradientKind, p: &Value) -> Parsed<()> {
match spread_param(p)? {
Some(s) if !s.is_pad() && kind == GradientKind::Freeform => Err("`spread` applies to linear, radial, conic and diamond gradients".into()),
_ => Ok(()),
}
}
/// `v` (params holding `stops`) with each stop that names a `swatch` resolved through `d`
/// ([`swatch_solid`]): a global or spot colour or a tint swatch gives the stop its colour, link and
/// tint, a process colour just its colour. A stop linked to a swatch that no longer exists keeps
@@ -271,6 +302,9 @@ pub(crate) fn parse_gradient(g: &Value) -> Parsed<GradientPaint> {
Some(v) => v.as_bool().ok_or("`dither` must be true or false")?,
};
gp.gradient.method = method_param(g)?.unwrap_or_default();
spread_for(kind, g)?;
gp.gradient.spread = spread_param(g)?.unwrap_or_default();
gp.gradient.repeats = repeats_param(g)?.unwrap_or(1);
gp.angle = f64_or(g, "angle", 0.0);
gp.swatch = str_param(g, "swatch").map(str::to_string);
let geom = GeomEdit::parse(g)?;
@@ -422,6 +456,13 @@ fn apply_gradient_edit_in_model(
if let Some(m) = method_param(p)? {
gp.gradient.method = m;
}
spread_for(gp.gradient.kind, p)?;
if let Some(sp) = spread_param(p)? {
gp.gradient.spread = sp;
}
if let Some(n) = repeats_param(p)? {
gp.gradient.repeats = n;
}
// Angle and aspect edits keep the focal point in its place in the extent ellipse.
let before = gp.geom;
if let Some(a) = p.get("angle").and_then(Value::as_f64) {
@@ -516,6 +557,18 @@ fn edit_gradient(s: &mut Session, p: &Value) -> Result<Value> {
}
_ => std::borrow::Cow::Borrowed(p),
};
// A spread for selected gradients leaves a freeform default (which has no ends) as it is.
let spreads = matches!(spread_param(p), Ok(Some(sp)) if !sp.is_pad());
let for_default = match for_default {
q if spreads && !ids.is_empty() && default_kind == Some(GradientKind::Freeform) => {
let mut q = q.into_owned();
if let Some(o) = q.as_object_mut() {
o.remove("spread");
}
std::borrow::Cow::Owned(q)
}
q => q,
};
let new_default = apply_gradient_edit_in_model(&default_paint, &with_stored_stops(&for_default, &default_paint, &stored), None, &|_| true, model)
.map_err(|e| bad(C, e))?;
let freeform = str_param(p, "kind").and_then(GradientKind::parse) == Some(GradientKind::Freeform);
+12 -6
View File
@@ -4,7 +4,7 @@
//! The built-in presets are the gradient swatches of the built-in swatch libraries
//! ([`vectorcraft_color::libraries`]: the app's own computed palettes), each listed under its
//! library's name. Saved presets are kept with the preferences ([`crate::Prefs::gradient_presets`]),
//! so every document has them. A preset is the colour ramp (type, stops, method, dither), not a
//! so every document has them. A preset is the color ramp (type, stops, method, dither, spread), not a
//! placement: applying one edits the gradient in place, as `paint.editGradient` does.
use serde::{Deserialize, Serialize};
@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Gradient Presets",
[],
None,
"{} → {presets: [{name, library: the built-in library (theme) it comes from, null for a saved one, builtIn, gradient: {kind, stops, method?, dither?} (as paint.setFill's `gradient`)}]} the Gradient panel's presets: the built-in ones by library, then the saved ones; names are unique",
"{} → {presets: [{name, library: the built-in library (theme) it comes from, null for a saved one, builtIn, gradient: {kind, stops, method?, dither?, spread?, repeats?} (as paint.setFill's `gradient`)}]} the Gradient panel's presets: the built-in ones by library, then the saved ones; names are unique",
always,
list
),
@@ -33,7 +33,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Apply Gradient Preset",
[],
None,
"{name: a preset's name (gradient.presets.list), stroke?, item?, ids?|id?, target? (as paint.editGradient)} give the gradient behind the active proxy (or the targeted fill or stroke) the preset's type, stops and method, and a fill its dither, keeping its placement; a solid or no paint becomes the gradient. One undo step, as paint.editGradient → {name, ids: the objects painted (none: only the default changed)}",
"{name: a preset's name (gradient.presets.list), stroke?, item?, ids?|id?, target? (as paint.editGradient)} give the gradient behind the active proxy (or the targeted fill or stroke) the preset's type, stops, method, spread and repeats (a freeform preset's: the first three), and a fill its dither, keeping its placement; a solid or no paint becomes the gradient. One undo step, as paint.editGradient → {name, ids: the objects painted (none: only the default changed)}",
has_doc,
apply
),
@@ -42,7 +42,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Save Gradient Preset",
[],
None,
"{name?: (default: a new \"Gradient Preset N\"; unique, any case, and not a built-in preset's)} save the gradient behind the active proxy (paint.toggleActive picks Fill or Stroke) as a preset, kept with the preferences: its type, stops, method and dither (stops linked to a swatch keep their colour, unlinked) → {name}",
"{name?: (default: a new \"Gradient Preset N\"; unique, any case, and not a built-in preset's)} save the gradient behind the active proxy (paint.toggleActive picks Fill or Stroke) as a preset, kept with the preferences: its type, stops, method, dither, spread and repeats (stops linked to a swatch keep their colour, unlinked) → {name}",
can_save,
save
),
@@ -90,12 +90,13 @@ fn builtin_presets() -> impl Iterator<Item = GradientPresetEntry> {
})
}
/// Do `a` and `b` have the same colour ramp (type, method, dither and stops), swatch links aside?
/// Do `a` and `b` have the same color ramp (type, method, dither, spread as it paints and stops),
/// swatch links aside?
fn same_ramp(a: &Gradient, b: &Gradient) -> bool {
let stop = |x: &vectorcraft_color::GradientStop, y: &vectorcraft_color::GradientStop| {
(x.offset, x.color, x.opacity, x.midpoint) == (y.offset, y.color, y.opacity, y.midpoint)
};
(a.kind, a.method, a.dither) == (b.kind, b.method, b.dither)
(a.kind, a.method, a.dither, a.painted_spread()) == (b.kind, b.method, b.dither, b.painted_spread())
&& a.stops.len() == b.stops.len()
&& a.stops.iter().zip(&b.stops).all(|(x, y)| stop(x, y))
}
@@ -215,6 +216,11 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
o.insert("kind".into(), json!(g.kind.label().to_lowercase()));
o.insert("stops".into(), stops_json(&g.stops));
o.insert("method".into(), json!(g.method.label().to_lowercase()));
// A freeform preset takes no spread (paint.editGradient refuses one).
if g.kind != vectorcraft_color::GradientKind::Freeform {
o.insert("spread".into(), json!(g.spread.label().to_lowercase()));
o.insert("repeats".into(), json!(g.repeat_count()));
}
// Dither is a fill's (paint.editGradient refuses it on a stroke).
if !stroke {
o.insert("dither".into(), json!(g.dither));
+8 -1
View File
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
"New Artboard",
["Window", "Artboards"],
None,
"{x?, y?, width?, height?, name?, color?: color (its background color, as artboard.setProps takes it, #rrggbbaa and #rgba refused; default: none), guideLabel?: name | \"#rrggbb\" | null (its guide label, as artboard.setProps takes it; default: none), showCenterMark?: bool, showCrossHairs?: bool, showVideoSafeAreas?: bool (as artboard.setProps takes them; default false), videoRulerPixelAspectRatio?: number 0.1–10 (as artboard.setProps takes it; default 1), side?: \"left\"|\"right\"|\"top\"|\"bottom\" (the size of artboard `beside`, 20 pt from that side of it; refused with x, y, width or height), beside?: n (the artboard `side` places it by; default the last)} (default place: right of the last)",
"{x?, y?, width?, height? (each more than 0 and at most 3,999,856 pt, as file.new takes them), name?, color?: color (its background color, as artboard.setProps takes it, #rrggbbaa and #rgba refused; default: none), guideLabel?: name | \"#rrggbb\" | null (its guide label, as artboard.setProps takes it; default: none), showCenterMark?: bool, showCrossHairs?: bool, showVideoSafeAreas?: bool (as artboard.setProps takes them; default false), videoRulerPixelAspectRatio?: number 0.1–10 (as artboard.setProps takes it; default 1), side?: \"left\"|\"right\"|\"top\"|\"bottom\" (the size of artboard `beside`, 20 pt from that side of it; refused with x, y, width or height), beside?: n (the artboard `side` places it by; default the last)} (default place: right of the last)",
has_doc,
artboard_new
),
@@ -926,6 +926,9 @@ fn artboard_new(s: &mut Session, p: &Value) -> Result<Value> {
let guide_label = artboard_guide_label(p, "artboard.new")?.flatten();
check_switches(p, &["showCenterMark", "showCrossHairs", "showVideoSafeAreas"], "artboard.new")?;
check_numbers(p, &["x", "y", "width", "height"], "artboard.new")?;
if ["width", "height"].iter().filter_map(|k| p.get(*k).and_then(Value::as_f64)).any(|side| !super::newdoc::side_in_range(side)) {
return Err(super::newdoc::side_error("artboard.new", d0.units));
}
let r = match artboard_side(p, "artboard.new")? {
Some(side) => {
if ["x", "y", "width", "height"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null())) {
@@ -941,6 +944,10 @@ fn artboard_new(s: &mut Session, p: &Value) -> Result<Value> {
None if p.get("beside").is_some_and(|v| !v.is_null()) => return Err(bad("artboard.new", "`beside` needs `side`")),
None => rect_from(p, def),
};
// A size taken from another artboard (`side`, or width or height left out) keeps to the limit too.
if !super::newdoc::side_in_range(r.width()) || !super::newdoc::side_in_range(r.height()) {
return Err(super::newdoc::side_error("artboard.new", d0.units));
}
let given = artboard_str(p, "name", "artboard.new")?.map(str::trim).filter(|n| !n.is_empty());
let (show_center_mark, show_cross_hairs) = (bool_or(p, "showCenterMark", false), bool_or(p, "showCrossHairs", false));
let show_video_safe_areas = bool_or(p, "showVideoSafeAreas", false);
+25 -4
View File
@@ -241,8 +241,8 @@ impl DocSettings {
if let Some(h) = length("height", self.units)? {
self.height = h;
}
if !(self.width > 0.0 && self.height > 0.0) || self.width > MAX_SIDE || self.height > MAX_SIDE {
return Err(bad(cmd, "width/height must be positive and within the canvas"));
if !side_in_range(self.width) || !side_in_range(self.height) {
return Err(side_error(cmd, self.units));
}
match p.get("orientation").and_then(Value::as_str) {
None => {}
@@ -359,8 +359,29 @@ impl DocSettings {
}
}
/// Largest artboard side `file.new` accepts, points.
const MAX_SIDE: f64 = 16383.0 * 10.0;
/// Largest artboard side `file.new` and `artboard.new` accept, points: the span of the canvas
/// ([`crate::MAX_COORD`] from the origin) less the largest bleed on both sides, 3,999,856 pt.
pub(crate) const MAX_SIDE: f64 = crate::MAX_COORD - 2.0 * vectorcraft_doc::setup::MAX_BLEED;
/// Is `side` an artboard side `file.new` and `artboard.new` accept: more than 0 and at most [`MAX_SIDE`]?
pub(crate) fn side_in_range(side: f64) -> bool {
side > 0.0 && side <= MAX_SIDE
}
/// The error of an artboard side outside [`side_in_range`]: the limit in points, and in `units` as
/// well when they aren't points, rounded down to the decimals [`Unit::number`] shows so the value
/// shown is one the commands take.
pub(crate) fn side_error(cmd: &str, units: Unit) -> crate::EngineError {
let limit = match units {
Unit::Points => format!("{MAX_SIDE} pt"),
u => {
let step = if matches!(u, Unit::Pixels | Unit::Picas | Unit::Q | Unit::Ha) { 1e3 } else { 1e4 };
let shown = (u.from_pt(MAX_SIDE) * step).floor() / step;
format!("{MAX_SIDE} pt ({} {})", u.number(u.to_pt(shown)), u.suffix())
}
};
bad(cmd, format!("width and height must be more than 0 and at most {limit}"))
}
/// Largest artboard spacing, points.
const MAX_SPACING: f64 = 1.0e5;
+1 -1
View File
@@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Fill",
[],
None,
"{color?: \"#rrggbb\"|[r,g,b]|{c,m,y,k}|{gray}|{l,a,b} (CIE Lab; #rrggbbaa and #rgba are refused), none?: true, swatch?: name (a global or spot colour stays linked, so swatch edits recolour it; a tint swatch links to its base at its tint; a gradient swatch is recorded as the gradient's swatch and fits each object, keeping its aspect; the built-in \"[Registration]\" prints on every plate), tint?: 0..100 (% of a global or spot `swatch`; default 100, or a tint swatch's own), gradient?: {kind?: linear|radial|conic|diamond|freeform (conic, also accepted as angle or conical: the stops sweep once around the center `start`, clockwise from the vector; diamond: the stops run from the center `start` out to a square with a corner at `end`), method?: classic|perceptual (as paint.editGradient; default classic), stops?: [{offset 0..1, color, opacity? 0..1 (or 0..100), midpoint? 0.13..0.87, swatch?: global or spot colour (or tint) swatch the stop links to (its colour comes from the swatch), tint?: 0..100}] (at least 2; default white→black), angle?: deg counter-clockwise (0: the gradient runs left to right), start?: [x,y], end?: [x,y] (the vector in document coordinates, both or neither; type objects keep it in text space), aspect?: % (radial, conic and diamond; a negative one mirrors a conic's sweep, counterclockwise, and is an error for the other kinds; without start/end the gradient is placed on each object's bounds), focal?: [x,y] (radial, with start/end: the focal point, where the first stop sits; an error with a conic or diamond), dither?: bool (linear, radial, conic and diamond fills: drawn with fine noise that hides banding, and as pixels in SVG and PDF exports; strokes ignore it), swatch?: linked gradient swatch name}, item?: appearance item index|null (omitted: the Appearance panel's active item if it is a fill, else the top fill), ids?|id?, focus?: true (false keeps the active proxy), keepModel?: false (in a CMYK document, RGB colours and gradient stops are stored as CMYK unless true; Gray stays Gray), target?: \"object\"|\"contents\", span?: \"object\" (default: each target fits a gradient to its own bounds)|\"selection\" (a linear, radial, conic or diamond `gradient` without start/end is placed once on the union of the targets' bounds, so it runs across them)} sets the selection's fill and the default (new art fits a gradient to itself); a solid colour recolours only the gradient mesh point last clicked with the Mesh tool or Direct Selection; while the Type tool has characters selected (and no ids or item are given), the paint goes to those characters only; without `item`, a grayscale or 1-bit image takes a solid color as the color it is drawn in (white pixels transparent; `none` takes it off; an image with an alpha channel takes only a spot color, black or white); with an object of a dynamic symbol instance selected by Direct Selection and no ids, id or item, that object's fill changes for this instance only (solid, none, gradient or pattern) → {objects: how many objects took the paint (the objects inside a group, unless an appearance item of the group's own is targeted; 0 when only the default changed)}",
"{color?: \"#rrggbb\"|[r,g,b]|{c,m,y,k}|{gray}|{l,a,b} (CIE Lab; #rrggbbaa and #rgba are refused), none?: true, swatch?: name (a global or spot colour stays linked, so swatch edits recolour it; a tint swatch links to its base at its tint; a gradient swatch is recorded as the gradient's swatch and fits each object, keeping its aspect; the built-in \"[Registration]\" prints on every plate), tint?: 0..100 (% of a global or spot `swatch`; default 100, or a tint swatch's own), gradient?: {kind?: linear|radial|conic|diamond|freeform (conic, also accepted as angle or conical: the stops sweep once around the center `start`, clockwise from the vector; diamond: the stops run from the center `start` out to a square with a corner at `end`), method?: classic|perceptual (as paint.editGradient; default classic), spread?: pad|repeat|reflect (as paint.editGradient; default pad), repeats?: 1..100 (as paint.editGradient; default 1), stops?: [{offset 0..1, color, opacity? 0..1 (or 0..100), midpoint? 0.13..0.87, swatch?: global or spot colour (or tint) swatch the stop links to (its colour comes from the swatch), tint?: 0..100}] (at least 2; default white→black), angle?: deg counter-clockwise (0: the gradient runs left to right), start?: [x,y], end?: [x,y] (the vector in document coordinates, both or neither; type objects keep it in text space), aspect?: % (radial, conic and diamond; a negative one mirrors a conic's sweep, counterclockwise, and is an error for the other kinds; without start/end the gradient is placed on each object's bounds), focal?: [x,y] (radial, with start/end: the focal point, where the first stop sits; an error with a conic or diamond), dither?: bool (linear, radial, conic and diamond fills: drawn with fine noise that hides banding, and as pixels in SVG and PDF exports; strokes ignore it), swatch?: linked gradient swatch name}, item?: appearance item index|null (omitted: the Appearance panel's active item if it is a fill, else the top fill), ids?|id?, focus?: true (false keeps the active proxy), keepModel?: false (in a CMYK document, RGB colours and gradient stops are stored as CMYK unless true; Gray stays Gray), target?: \"object\"|\"contents\", span?: \"object\" (default: each target fits a gradient to its own bounds)|\"selection\" (a linear, radial, conic or diamond `gradient` without start/end is placed once on the union of the targets' bounds, so it runs across them)} sets the selection's fill and the default (new art fits a gradient to itself); a solid colour recolours only the gradient mesh point last clicked with the Mesh tool or Direct Selection; while the Type tool has characters selected (and no ids or item are given), the paint goes to those characters only; without `item`, a grayscale or 1-bit image takes a solid color as the color it is drawn in (white pixels transparent; `none` takes it off; an image with an alpha channel takes only a spot color, black or white); with an object of a dynamic symbol instance selected by Direct Selection and no ids, id or item, that object's fill changes for this instance only (solid, none, gradient or pattern) → {objects: how many objects took the paint (the objects inside a group, unless an appearance item of the group's own is targeted; 0 when only the default changed)}",
has_doc,
|s, p| set_paint(s, p, true)
),
+85 -2
View File
@@ -102,7 +102,53 @@ const FILE_WORDS: &[&str] = &[
];
/// Param keys that name a file or a folder.
const FILE_KEYS: &[&str] = &["path", "paths", "file", "files", "folder", "folders", "dir", "directory", "destinationFolder", "sourceFolder", "url"];
const FILE_KEYS: &[&str] =
&["path", "paths", "file", "files", "folder", "folders", "dir", "directory", "destinationFolder", "sourceFolder", "url", "diffPath"];
/// The keys in [`FILE_KEYS`] that name a folder.
const FOLDER_KEYS: &[&str] = &["folder", "folders", "dir", "directory", "destinationFolder", "sourceFolder"];
/// What a param key that names a place on disk names there.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Location {
/// A file (or a list of files).
File,
/// A folder (or a list of folders).
Folder,
}
/// What `key` names on disk when a command takes it ([`FILE_KEYS`]), or `None` when it never
/// names a file or a folder.
pub fn key_location(key: &str) -> Option<Location> {
if FOLDER_KEYS.contains(&key) {
Some(Location::Folder)
} else if FILE_KEYS.contains(&key) {
Some(Location::File)
} else {
None
}
}
/// What `key` names on disk in command `spec`: [`key_location`], or `None` when [`NOT_FILES`]
/// names it for `spec` (it names part of the document there).
pub fn location_in(spec: &CommandSpec, key: &str) -> Option<Location> {
if NOT_FILES.contains(&(spec.id, key)) { None } else { key_location(key) }
}
/// The param keys of `spec` that name a file or a folder, with what they name: the keys in
/// [`FILE_KEYS`] that its params description names ([`super::params::doc_keys`]), with those of the
/// commands its `…` entries name ([`super::params::takes_key`]), and its schema's params, less those
/// [`NOT_FILES`] names for it. Sorted, each key once.
pub fn location_keys(spec: &CommandSpec) -> Vec<(&'static str, Location)> {
let described = super::params::doc_keys(spec.params).map(|p| p.keys).unwrap_or_default();
let in_schema = spec.schema.map(|s| s.params.iter().map(|p| p.name)).into_iter().flatten();
let taken = FILE_KEYS.iter().copied().filter(|k| super::params::takes_key(spec.params, k));
let mut keys: Vec<(&'static str, Location)> =
described.into_iter().chain(in_schema).chain(taken).filter_map(|k| Some((k, location_in(spec, k)?))).collect();
keys.sort_unstable_by_key(|(k, _)| *k);
keys.dedup();
keys
}
/// Commands and the param key in [`FILE_KEYS`] that, in them, names part of the document (a path of
/// its art, a setting, an attribute it stores or a result field), not a file.
@@ -119,6 +165,8 @@ pub(crate) const NOT_FILES: &[(&str, &str)] = &[
("attributes.set", "url"),
("svgInteractivity.info", "files"),
("addon.cleanup.rejoin", "paths"),
("object.slice.options", "url"),
("document.exportForScreens", "folders"),
];
/// Is command id `id` one a plug-in may never call, from its id alone ([`DENIED_PREFIXES`],
@@ -466,7 +514,8 @@ mod tests {
}
for (id, key) in NOT_FILES {
let Some(spec) = crate::cmd::find_command(id) else { panic!("no command {id}") };
assert!(names_key(spec.params, key), "{id} has no `{key}` param");
let described = crate::cmd::params::doc_keys(spec.params).is_ok_and(|p| p.keys.contains(key));
assert!(names_key(spec.params, key) || described, "{id} has no `{key}` param");
}
let leaks: Vec<&str> = specs
.iter()
@@ -565,6 +614,40 @@ mod tests {
read.unwrap();
}
/// [`location_keys`] names every key in [`FILE_KEYS`] that a command's params description or
/// schema names, in every way a description writes one (`path | name`, `folder? (…)`), less
/// those [`NOT_FILES`] names for it; folder keys name folders. No command a plug-in may call
/// has one.
#[test]
fn location_keys_come_from_the_command_catalog() {
let find = |id: &str| crate::cmd::find_command(id).unwrap_or_else(|| panic!("no command {id}"));
let keys = |id: &str| location_keys(find(id));
assert!(keys("document.open").contains(&("path", Location::File)), "{:?}", keys("document.open"));
assert!(keys("document.compare").contains(&("diffPath", Location::File)), "{:?}", keys("document.compare"));
assert!(keys("addon.document.saveTimestampedCopy").contains(&("folder", Location::Folder)));
let relink = keys("links.relink");
for k in [("path", Location::File), ("paths", Location::File), ("folder", Location::Folder)] {
assert!(relink.contains(&k), "{relink:?}");
}
assert!(keys("action.batch").contains(&("destinationFolder", Location::Folder)));
for (id, key) in NOT_FILES {
assert!(!keys(id).iter().any(|(k, _)| k == key), "{id} `{key}` names a file");
}
for spec in crate::cmd::command_specs() {
let found = location_keys(spec);
let described = crate::cmd::params::doc_keys(spec.params).map(|p| p.keys).unwrap_or_default();
let in_schema = spec.schema.map(|s| s.params.iter().map(|p| p.name).collect::<Vec<_>>()).unwrap_or_default();
for k in described.into_iter().chain(in_schema).filter(|k| FILE_KEYS.contains(k) && !NOT_FILES.contains(&(spec.id, *k))) {
assert!(found.iter().any(|(f, _)| *f == k), "{}: `{k}` is missing from {found:?}", spec.id);
}
assert!(found.iter().all(|(k, l)| (*l == Location::Folder) == FOLDER_KEYS.contains(k)), "{}: {found:?}", spec.id);
assert!(denied(spec).is_some() || found.is_empty(), "{} names {found:?} but a plug-in may call it", spec.id);
}
assert_eq!(key_location("url"), Some(Location::File));
assert_eq!(key_location("sourceFolder"), Some(Location::Folder));
assert_eq!(key_location("pathData"), None);
}
#[test]
fn keys_are_found_as_whole_keys() {
assert!(names_key("{path: a .wasm file}", "path"));
@@ -33,6 +33,7 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.color.swatchLegend",
"addon.contour.set",
"addon.cutting.bridges",
"addon.cutting.weed",
"addon.image.removeBackground",
"addon.pathtools.addPoints",
"addon.pathtools.close",
+6 -5
View File
@@ -393,11 +393,12 @@ fn float_key(v: f32) -> Option<u32> {
/// keys.
type StopKey<'a> = (u32, ColorKey, u32, u32, Option<&'a str>, u32, Option<[u32; 4]>);
/// A gradient's kind, method, dither and stops, as keys.
type GradientKey<'a> = (u8, u8, bool, Vec<StopKey<'a>>);
/// A gradient's kind, method, dither, spread and count as it paints them, and stops, as keys.
type GradientKey<'a> = (u8, u8, bool, (vectorcraft_color::GradientSpread, u32), Vec<StopKey<'a>>);
/// A key that is equal for two gradients exactly when the gradients are equal (`==`); `None` when
/// any of its numbers is NaN, so the gradient equals no gradient.
/// A key that is equal for two gradients exactly when the gradients are equal (`==`), apart from
/// a count that a gradient which pads does not use ([`Gradient::painted_spread`]); `None` when any
/// of its numbers is NaN, so the gradient equals no gradient.
fn gradient_key(g: &Gradient) -> Option<GradientKey<'_>> {
let kind = match g.kind {
GradientKind::Linear => 0,
@@ -410,7 +411,7 @@ fn gradient_key(g: &Gradient) -> Option<GradientKey<'_>> {
GradientMethod::Classic => 0,
GradientMethod::Perceptual => 1,
};
Some((kind, method, g.dither, g.stops.iter().map(stop_key).collect::<Option<_>>()?))
Some((kind, method, g.dither, g.painted_spread(), g.stops.iter().map(stop_key).collect::<Option<_>>()?))
}
/// A stop's key for [`gradient_key`]; `None` when any of its numbers is NaN.
+42 -8
View File
@@ -40,7 +40,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Character",
[],
None,
"{id? (default: the one selected type object), start?: byte, end?: byte (default: all text), story?: bool = false (all the text of every frame of the threaded story `id` is a frame of, in one undo step; no `start` or `end`), font?, style?, size?: pt, leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\"|\"optical\" (the space after each character), kerningBefore?: 1/1000 em -1000..10000 (the space before a character that starts a line by itself: the first character of the text, of a paragraph or after a forced line break; no effect elsewhere; 0 by default), baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), fill?: colour|\"none\", stroke?: colour|\"none\" (#rrggbbaa and #rgba are refused in both), keepModel?: bool (fill and stroke, as paint.setFill), strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, align?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", …], featureChanges?: [\"tnum\", \"-onum\", …] (OpenType features turned on, or with - off, on top of each character's own; its other features are kept), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\", proportionalMetrics?: bool (full-width glyphs on the font's proportional widths: `palt` in horizontal type, `vpal` in vertical type), tateChuYoko?: bool (Character panel menu › Tate-chu-yoko, with Show East Asian Options: in vertical type those characters stand side by side across one em of the column; kept on the characters and ignored in horizontal type), tcyUpDown?, tcyLeftRight?: pt -1296..1296 (Character panel menu › Tate-chu-yoko Settings: in vertical type a block of tate-chu-yoko characters moves up by a positive Up/Down and down by a negative one, right by a positive Left/Right and left by a negative one, as one piece with the values of its first character; on a vertical path a positive Up/Down moves it toward the path's start and a positive Left/Right to the path's left; 0 by default; automatic digit blocks and horizontal type do not move; neither turns tateChuYoko on), standardVerticalRoman?: bool (Character panel menu › Standard Vertical Roman Alignment, with Show East Asian Options: in vertical type those half-width characters, such as Latin letters and digits, stand upright one below the other instead of being rotated; spaces and tate-chu-yoko blocks are not changed; kept on the characters and ignored in horizontal type; off by default), noBreak?: bool (Character panel menu › No Break: these characters stay on one line, including across a space inside the run), kashidas?: bool (Character panel menu › Kashidas: selected characters allow insertion only when both joined neighbors have it on; on by default), charDirection?: \"default\"|\"leftToRight\"|\"rightToLeft\" (Character panel menu › Character Direction: the characters are set left to right or right to left inside their paragraph, as a Unicode bidi embedding; default: as the bidi algorithm sets them), digits?: \"default\"|\"arabic\"|\"hindi\"|\"farsi\"|\"devanagari\"|\"bengali\"|\"gurmukhi\"|\"gujarati\"|\"odia\"|\"tamil\"|\"telugu\"|\"kannada\"|\"malayalam\" (Character panel menu › Digits: the numeral system every digit is drawn in, whatever was typed: Western, Arabic-Indic (hindi), Eastern Arabic-Indic (farsi) or an Indic script's own digits), fontHeightReference?: \"emBox\"|\"capHeight\"|\"xHeight\"|\"icfBox\" (Character panel › Set Font Height Reference: the height of the font that size measures, the em box by default; with a font that has no such height, or one outside 0.1 to 2 em, the em box), language?: name|tag (Character panel › Language: one of Document Setup's languages by name or BCP 47 tag, case-insensitive, such as \"Turkish\" or \"tr\"; the characters are shaped in it, so the font uses that language's forms (OpenType `locl`); saved as the tag, English: USA, the default, as none; new type takes the document's language), fontAxes?: {\"wght\": 650, …} (Character panel › Variable Font: the setting of each variation axis named, in the axis's units and clamped to its range; null: back to the style's own setting; other axes keep theirs; tags the font has no axis for are left out; a font or style change clears them; text.fontList {family, style} lists the axes)} style a character range (size/leading/baselineShift are document points and hScale includes the object transform; runs are split at the range ends) → {id, runs, warning?: text (the font or style set isn't available: its type is drawn in the fallback font or the family's closest style)}",
"{id? (default: the one selected type object), start?: byte, end?: byte (default: all text), story?: bool = false (all the text of every frame of the threaded story `id` is a frame of, in one undo step; no `start` or `end`), font?, style?, size?: pt, leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\"|\"optical\" (the space after each character), kerningBefore?: 1/1000 em -1000..10000 (the space before a character that starts a line by itself: the first character of the text, of a paragraph or after a forced line break; no effect elsewhere; 0 by default), baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), fill?: colour|\"none\", stroke?: colour|\"none\" (#rrggbbaa and #rgba are refused in both), keepModel?: bool (fill and stroke, as paint.setFill), strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, align?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", \"salt=2\", …] (swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom and aalt take the font's alternate number as `tag=N`, N 0–65535: \"salt=2\" draws the second alternate of each glyph that has one, \"salt\" is \"salt=1\", \"-salt\" and \"salt=0\" are off; the range is shaped with its word, so a letter's alternate keeps it joined to its neighbours), featureChanges?: [\"tnum\", \"-onum\", \"salt=2\", …] (OpenType features turned on, or with - off, on top of each character's own, a value replacing the feature's last one; its other features are kept), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\", proportionalMetrics?: bool (full-width glyphs on the font's proportional widths: `palt` in horizontal type, `vpal` in vertical type), tateChuYoko?: bool (Character panel menu › Tate-chu-yoko, with Show East Asian Options: in vertical type those characters stand side by side across one em of the column; kept on the characters and ignored in horizontal type), tcyUpDown?, tcyLeftRight?: pt -1296..1296 (Character panel menu › Tate-chu-yoko Settings: in vertical type a block of tate-chu-yoko characters moves up by a positive Up/Down and down by a negative one, right by a positive Left/Right and left by a negative one, as one piece with the values of its first character; on a vertical path a positive Up/Down moves it toward the path's start and a positive Left/Right to the path's left; 0 by default; automatic digit blocks and horizontal type do not move; neither turns tateChuYoko on), standardVerticalRoman?: bool (Character panel menu › Standard Vertical Roman Alignment, with Show East Asian Options: in vertical type those half-width characters, such as Latin letters and digits, stand upright one below the other instead of being rotated; spaces and tate-chu-yoko blocks are not changed; kept on the characters and ignored in horizontal type; off by default), noBreak?: bool (Character panel menu › No Break: these characters stay on one line, including across a space inside the run), kashidas?: bool (Character panel menu › Kashidas: selected characters allow insertion only when both joined neighbors have it on; on by default), charDirection?: \"default\"|\"leftToRight\"|\"rightToLeft\" (Character panel menu › Character Direction: the characters are set left to right or right to left inside their paragraph, as a Unicode bidi embedding; default: as the bidi algorithm sets them), digits?: \"default\"|\"arabic\"|\"hindi\"|\"farsi\"|\"devanagari\"|\"bengali\"|\"gurmukhi\"|\"gujarati\"|\"odia\"|\"tamil\"|\"telugu\"|\"kannada\"|\"malayalam\" (Character panel menu › Digits: the numeral system every digit is drawn in, whatever was typed: Western, Arabic-Indic (hindi), Eastern Arabic-Indic (farsi) or an Indic script's own digits), fontHeightReference?: \"emBox\"|\"capHeight\"|\"xHeight\"|\"icfBox\" (Character panel › Set Font Height Reference: the height of the font that size measures, the em box by default; with a font that has no such height, or one outside 0.1 to 2 em, the em box), language?: name|tag (Character panel › Language: one of Document Setup's languages by name or BCP 47 tag, case-insensitive, such as \"Turkish\" or \"tr\"; the characters are shaped in it, so the font uses that language's forms (OpenType `locl`); saved as the tag, English: USA, the default, as none; new type takes the document's language), fontAxes?: {\"wght\": 650, …} (Character panel › Variable Font: the setting of each variation axis named, in the axis's units and clamped to its range; null: back to the style's own setting; other axes keep theirs; tags the font has no axis for are left out; a font or style change clears them; text.fontList {family, style} lists the axes), glyphAlternate?: null (takes away the glyph choice text.setGl Line truncated
has_doc,
set_range_style
),
@@ -58,7 +58,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Glyphs",
[],
None,
"{id, start: byte (a character of it), gid: glyph id|null} draw that one character with another glyph of its font as one undo step, what a double-click in the Glyphs panel's Show › Alternates for Current Selection does: gid is one of the glyphs text.glyphAlternates lists for it; its own default glyph, or null, puts the default glyph back. The text keeps the character, and its other attributes do not change. The choice is saved with the character's style and names the face it was made in (PostScript name and version): set in another font or version, or after the font goes missing, the character takes its default glyph; typed characters take their default glyphs. Choosing the glyph the character already draws is not an edit. An error when the character's font is not available, the glyph is not one of its alternates, or the character's style does not draw it (All Caps, Small Caps, another numeral system) → {id, start, end (the character's bytes), gid (the glyph drawn)}",
"{id, start: byte (a character of it), gid: glyph id|null} draw that one character with another glyph of its font as one undo step, what a double-click in the Glyphs panel's Show › Alternates for Current Selection does: gid is one of the glyphs text.glyphAlternates lists for it, a glyph no character maps and no feature reaches whose name is not another letter's (`a.salt` for a), its own default glyph, or null, puts the default glyph back. The text keeps the character, and its other attributes do not change. The choice is saved with the character's style and names the face it was made in (PostScript name and version): set in another font or version, or after the font goes missing, the character takes its default glyph; typed characters take their default glyphs. Choosing the glyph the character already draws is not an edit. An error when the character's font is not available, the glyph is not one of those, or the character's style does not draw it (All Caps, Small Caps, another numeral system) → {id, start, end (the character's bytes), gid (the glyph drawn)}",
has_doc,
set_glyph_alternate
),
@@ -466,6 +466,8 @@ pub(crate) struct CharChange {
language: Option<Option<String>>,
font_axes: Option<AxisChange>,
font_height_reference: Option<vectorcraft_doc::FontHeightReference>,
/// Take away the glyph choice ([`CharStyle::glyph_alternate`]) of the characters (`glyphAlternate: null`).
clear_glyph_alternate: bool,
}
/// `charDirection: "default"|"leftToRight"|"rightToLeft"` → the Character Direction to set (`None`
@@ -567,7 +569,8 @@ pub(crate) fn change_font_axes(st: &mut CharStyle, change: &AxisChange) {
}
}
/// `features: ["dlig", "-liga", …]` → the canonical tag list (differences from the defaults).
/// `features: ["dlig", "-liga", "salt=2", …]` → the canonical tag list (differences from the
/// defaults; `salt=1` is written `salt`, `salt=0` and `-salt` leave it out).
pub(crate) fn features_param(p: &Value, cmd: &str) -> Result<Option<Vec<String>>> {
let Some(v) = p.get("features").filter(|v| !v.is_null()) else { return Ok(None) };
let not_tags = || bad(cmd, "features must be a list of tags");
@@ -576,7 +579,8 @@ pub(crate) fn features_param(p: &Value, cmd: &str) -> Result<Option<Vec<String>>
return Err(bad(
cmd,
format!(
"unknown OpenType feature `{t}` (liga, calt, dlig, smcp, frac, onum, tnum, ordn, swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom; prefix - to turn off)"
"unknown OpenType feature `{t}` (liga, calt, dlig, smcp, frac, onum, tnum, ordn, swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom, aalt; prefix - to turn off; swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom and aalt take an alternate's number as `tag=N` with N from 0 to {}, as `salt=2`)",
vectorcraft_text::MAX_FEATURE_VALUE
),
));
}
@@ -586,9 +590,9 @@ pub(crate) fn features_param(p: &Value, cmd: &str) -> Result<Option<Vec<String>>
/// The most entries a `featureChanges` list may have.
const MAX_FEATURE_CHANGES: usize = 256;
/// A feature tag without its `-` or `+` prefix.
/// A feature tag without its `-` or `+` prefix and its `=N` value.
fn feature_name(tag: &str) -> &str {
tag.strip_prefix(['-', '+']).unwrap_or(tag)
vectorcraft_text::OtFeatures::tag_name(tag)
}
/// `featureChanges: ["tnum", "-onum", …]` → the features to turn on (or, with `-`, off) on top of
@@ -756,6 +760,13 @@ impl CharChange {
language: language_param(p, cmd)?,
font_axes: font_axes_param(p, cmd)?,
font_height_reference: font_height_reference_param(p, cmd)?,
clear_glyph_alternate: match p.get("glyphAlternate") {
None => false,
Some(Value::Null) => true,
Some(_) => {
return Err(bad(cmd, "`glyphAlternate` takes only null, which takes a glyph choice away (text.setGlyphAlternate makes one)"));
}
},
};
if c.size.is_some_and(|v| v <= 0.0) {
return Err(bad(cmd, "size must be positive"));
@@ -809,6 +820,7 @@ impl CharChange {
&& self.language.is_none()
&& self.font_axes.is_none()
&& self.font_height_reference.is_none()
&& !self.clear_glyph_alternate
}
pub(crate) fn localize(&mut self, t: &TextObject, cmd: &str) -> Result<()> {
@@ -951,6 +963,9 @@ impl CharChange {
if let Some(v) = &self.language {
st.language.clone_from(v);
}
if self.clear_glyph_alternate {
st.glyph_alternate = None;
}
}
}
@@ -1269,7 +1284,9 @@ fn set_glyph_alternate(s: &mut Session, p: &Value) -> Result<Value> {
};
let t = text_ref(s, id)?;
let (ch, bytes, face) = glyph_target(&t, p, C)?;
let default = face.glyph_for(ch);
let db = vectorcraft_text::FontDb::global();
let context = std::cell::OnceCell::new();
let contextual = || context.get_or_init(|| vectorcraft_text::alternates_in_context(db, &t, bytes.start));
let holder = t
.runs
.iter()
@@ -1290,6 +1307,16 @@ fn set_glyph_alternate(s: &mut Session, p: &Value) -> Result<Value> {
let mut probe = t.clone();
edit::style_range(&mut probe.runs, bytes.start, bytes.end, |st| st.glyph_alternate = None);
let probe_lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &probe);
// Choices belong to the supplying face, including fallback for a missing grapheme. When the
// character overflows, the contextual probe finds that face in an unconstrained frame.
let face = probe_lay
.glyphs
.iter()
.find(|g| g.byte <= bytes.start && bytes.start < g.byte.saturating_add(g.len))
.and_then(|g| db.face_by_id(g.font_id))
.or_else(|| contextual().as_ref().and_then(|f| db.face_by_id(f.font_id)))
.unwrap_or(face);
let default = face.glyph_for(ch);
let unchosen = holder
.as_ref()
.filter(|_| !styled)
@@ -1297,7 +1324,14 @@ fn set_glyph_alternate(s: &mut Session, p: &Value) -> Result<Value> {
let substituted = unchosen.is_some_and(|g| g != default);
let choice = match gid.filter(|g| *g != default || substituted) {
None => None,
Some(g) if g == default || face.alternates(ch).iter().any(|a| a.gid == g) => Some(face.choice(ch, g)),
Some(g)
if g == default
|| face.alternates(ch).iter().any(|a| a.gid == g)
|| face.is_unlisted_alternate(ch, g)
|| contextual().as_ref().is_some_and(|f| f.font_id == face.id() && f.alternates.iter().any(|a| a.gid == g)) =>
{
Some(face.choice(ch, g))
}
Some(g) => return Err(bad(C, format!("glyph {g} is not an alternate of {ch} in {} {}", face.family, face.style))),
};
// Without a choice, the glyph drawn in whatever face draws the character, as
+4 -2
View File
@@ -309,12 +309,12 @@ fn character_style_color_and_features_reach_text_and_follow_swatch_edits() {
// The command takes the color of the link at the tint, whatever color is sent.
tinted["tint"] = json!(0.4);
let attrs = json!({"fill": brand, "stroke": tinted, "stroke_width": 2.0, "overprint_fill": true, "overprint_stroke": false,
"features": ["dlig", "-liga", "tnum", "lnum", "-onum", "-pnum", "ss02", "-ss01"]});
"features": ["dlig", "-liga", "tnum", "lnum", "-onum", "-pnum", "ss02", "-ss01", "salt=2"]});
s.execute("charStyle.new", &json!({"name": "Ink", "attrs": attrs})).unwrap();
s.execute("charStyle.apply", &json!({"name": "Ink", "id": id})).unwrap();
let want_stroke = s.doc().unwrap().doc.tint_paint("Brand", 0.4).unwrap();
assert_eq!(run_paints(&s, id), (brand, want_stroke.clone(), 2.0, true, false));
assert_eq!(runs(&s, id)[0].style.features, ["dlig", "-liga", "tnum", "lnum", "-onum", "-pnum", "ss02", "-ss01"]);
assert_eq!(runs(&s, id)[0].style.features, ["dlig", "-liga", "tnum", "lnum", "-onum", "-pnum", "ss02", "-ss01", "salt=2"]);
let def = |s: &Session| s.doc().unwrap().doc.char_styles.iter().find(|d| d.name == "Ink").unwrap().attrs.clone();
assert_eq!(def(&s)["stroke"], serde_json::to_value(&want_stroke).unwrap());
let saved = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
@@ -355,6 +355,8 @@ fn character_style_color_and_features_are_checked() {
(json!({"stroke_width": 5.0e6}), "`stroke_width` must be from 0 to 4000000"),
(json!({"features": ["dlig", "zzzz"]}), "unknown OpenType feature `zzzz`"),
(json!({"features": ["--liga"]}), "unknown OpenType feature `--liga`"),
(json!({"features": ["salt=x"]}), "unknown OpenType feature `salt=x`"),
(json!({"features": ["-salt=2"]}), "unknown OpenType feature `-salt=2`"),
(json!({"features": many}), "features lists at most 256 tags"),
(json!({"fill": {"type": "solid"}}), "missing field"),
] {
+1 -1
View File
@@ -138,7 +138,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Character",
[],
None,
"{ids?|id?, font?, style? (font alone: the style is kept when the new family has it, else its closest), size?: pt, leading?: pt|\"auto\", tracking?: 1/1000 em, justify?: \"auto\" (the start of each paragraph's direction)|\"left\"|\"center\"|\"right\"|\"justifyAll\", fill?: colour|\"none\", stroke?: colour|\"none\" (characters without a stroke weight get 1 pt; #rrggbbaa and #rgba are refused in both), keepModel?: bool (fill and stroke, as paint.setFill), strokeWidth?: pt (the character stroke's weight, in document points as stroke.set), features?: [\"dlig\", \"-liga\", …] OpenType, featureChanges?: [\"tnum\", \"-onum\", …] (OpenType features turned on, or with - off, on top of each character's own; its other features are kept), start?: byte, end?: byte} (size/leading are document points after object scaling; with a range: the character attributes style that range and justify the paragraphs it touches; without: all the text) → {ids, overflow?: [id…] (area type and type on a path whose text no longer fits; left out when all fits), warning?: text (the font or style set isn't available: its type is drawn in the fallback font or the family's closest style)}",
"{ids?|id?, font?, style? (font alone: the style is kept when the new family has it, else its closest), size?: pt, leading?: pt|\"auto\", tracking?: 1/1000 em, justify?: \"auto\" (the start of each paragraph's direction)|\"left\"|\"center\"|\"right\"|\"justifyAll\", fill?: colour|\"none\", stroke?: colour|\"none\" (characters without a stroke weight get 1 pt; #rrggbbaa and #rgba are refused in both), keepModel?: bool (fill and stroke, as paint.setFill), strokeWidth?: pt (the character stroke's weight, in document points as stroke.set), features?: [\"dlig\", \"-liga\", \"salt=2\", …] OpenType (swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom and aalt take the font's alternate number as `tag=N`, N 0–65535: \"salt=2\" draws the second alternate of each glyph that has one, \"salt\" is \"salt=1\", \"-salt\" and \"salt=0\" are off), featureChanges?: [\"tnum\", \"-onum\", \"salt=2\", …] (OpenType features turned on, or with - off, on top of each character's own, a value replacing the feature's last one; its other features are kept), start?: byte, end?: byte} (size/leading are document points after object scaling; with a range: the character attributes style that range and justify the paragraphs it touches; without: all the text) → {ids, overflow?: [id…] (area type and type on a path whose text no longer fits; left out when all fits), warning?: text (the font or style set isn't available: its type is drawn in the fallback font or the family's closest style)}",
has_doc,
set_style
),
+6 -2
View File
@@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Free Distort",
[],
None,
"{corners: [[x,y]×4] (TL, TR, BR, BL), from?: [x0,y0,x1,y1] (default: selection bounds), ids?} projective warp of anchors and handles",
"{corners: [[x,y]×4] (TL, TR, BR, BL), from?: [x0,y0,x1,y1] (default: selection bounds), ids?} projective warp of anchors and handles; a linked opacity mask's art is warped with its object, an unlinked one stays",
has_doc,
distort
),
@@ -104,7 +104,8 @@ impl Projective {
}
/// Warp `n`'s anchors and handles; gradients (pinned first if unplaced) follow the warp's affine
/// approximation at their centre.
/// approximation at their center. The art of a linked opacity mask is warped with the object it
/// masks; an unlinked one stays where it is.
fn warp_node(n: &mut Node, pr: &Projective) {
n.pin_gradients();
match &mut n.kind {
@@ -131,6 +132,9 @@ fn warp_node(n: &mut Node, pr: &Projective) {
return;
}
}
if let Some(m) = n.extras_if_any().and_then(|x| x.mask.as_mut()).filter(|m| m.linked) {
warp_node(Arc::make_mut(&mut m.art), pr);
}
n.appearance.warp_gradients(&|p| pr.affine_near(p));
}
+4
View File
@@ -34,6 +34,9 @@ pub struct DocState {
/// Select › Start Global Edit: the objects edited together until Stop Global Edit or Escape
/// ([`cmd::globaledit`]). Editing state: not saved, not undoable.
pub global_edit: Option<cmd::globaledit::GlobalEdit>,
/// The objects Start Global Edit would take, highlighted before it starts
/// ([`cmd::globaledit::similar`]), as of a revision. Not saved, not undoable.
pub(crate) similar_outlines: cmd::globaledit::SimilarCache,
/// What leaving symbol editing mode goes back to ([`cmd::symboledit`]).
pub(crate) symbol_edit_return: cmd::symboledit::Return,
pub interaction: Option<Interaction>,
@@ -302,6 +305,7 @@ impl DocState {
variables_highlight: None,
isolation: None,
global_edit: None,
similar_outlines: Default::default(),
symbol_edit_return: Default::default(),
interaction: None,
undo_group: None,
@@ -631,6 +631,32 @@ fn an_opacity_mask_on_type_bends_as_other_art() {
assert_eq!(kept, 1, "the type's stroke stays a stroke");
}
/// An envelope bends the art of a linked opacity mask on its contents with them; an unlinked mask
/// stays where it is.
#[test]
fn an_envelope_bends_a_linked_opacity_mask_and_leaves_an_unlinked_one() {
for linked in [true, false] {
let mut s = session();
let a = rect(&mut s);
let m = rect(&mut s);
sel(&mut s, &[a, m]);
s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
if !linked {
s.execute("transparency.unlinkOpacityMask", &json!({})).unwrap();
}
let before = node(&s, a).extras().mask.as_ref().unwrap().art.path_data().cloned();
sel(&mut s, &[a]);
let e = arch(&mut s, 60.0, json!({}));
let mut found = vec![];
for n in &evaluated(&s, e) {
n.walk(&mut |c| found.extend(c.extras().mask.as_ref().map(|k| (c.path_data().cloned(), k.art.path_data().cloned()))));
}
let [(bent, mask)] = found.as_slice() else { panic!("one masked object: {found:?}") };
assert!(bent != &before, "the contents bend");
assert_eq!(mask, if linked { bent } else { &before }, "linked: {linked}");
}
}
/// Expand turns an envelope of stroked type into its bent glyph outlines with the stroke on them,
/// at its own weight, as it draws (#6644).
#[test]
+45 -1
View File
@@ -92,7 +92,50 @@ fn start_global_edit_takes_the_objects_of_the_same_shape_at_any_place_and_size()
assert_eq!(crate::cmd::globaledit::highlights(&s).len(), 2);
let r = s.execute("select.globalEdit", &json!({})).unwrap();
assert_eq!(r["active"], false, "the second run is Stop Global Edit");
assert!(s.doc().unwrap().global_edit.is_none() && crate::cmd::globaledit::highlights(&s).is_empty());
assert!(s.doc().unwrap().global_edit.is_none());
assert_eq!(crate::cmd::globaledit::highlights(&s).len(), 2, "with the square still selected, the objects it would take are highlighted again");
}
#[test]
fn selecting_one_object_highlights_the_similar_objects_before_global_edit_starts() {
use crate::cmd::globaledit::highlights;
let mut s = session();
let [a, b, _, wide, _] = squares(&mut s);
assert!(highlights(&s).is_empty(), "nothing selected");
sel(&mut s, &[a]);
assert_eq!(members(&s), None, "Global Edit has not started");
assert_eq!(highlights(&s).len(), 2, "the copy and the smaller square");
s.execute("select.globalEditOptions", &json!({"size": true})).unwrap();
assert_eq!(highlights(&s).len(), 1, "the options narrow them: the copy only");
s.execute("select.globalEditOptions", &json!({"size": false})).unwrap();
assert_eq!(highlights(&s).len(), 2);
sel(&mut s, &[b]);
s.execute("edit.clear", &json!({})).unwrap();
sel(&mut s, &[a]);
assert_eq!(highlights(&s).len(), 1, "a deleted copy is no longer highlighted");
sel(&mut s, &[wide]);
assert!(highlights(&s).is_empty(), "the rectangle has no similar object");
sel(&mut s, &[a, wide]);
assert!(highlights(&s).is_empty(), "two objects selected");
}
#[test]
fn the_canvas_highlights_similar_objects_before_the_start_with_the_selection_tool_only() {
let mut s = session();
let [a, b, ..] = squares(&mut s);
let outline = node(&s, b).stroke_path().unwrap();
let shown = |s: &mut Session| {
s.overlays(ViewInfo::default())
.iter()
.any(|o| matches!(o, vectorcraft_tools::Overlay::Path { path, width, .. } if *path == outline && *width == 1.0))
};
sel(&mut s, &[a]);
s.select_tool("selection", ViewInfo::default()).unwrap();
assert!(shown(&mut s), "the copy is highlighted with the Selection tool");
s.select_tool("directSelection", ViewInfo::default()).unwrap();
assert!(!shown(&mut s), "not with another tool before Global Edit starts");
s.execute("select.globalEdit", &json!({})).unwrap();
assert!(shown(&mut s), "while Global Edit is on, with any tool");
}
#[test]
@@ -506,6 +549,7 @@ fn leaving_out_all_but_one_ends_global_edit_and_the_first_object_stays() {
let r = s.execute("select.globalEditExclude", &json!({"id": b.0})).unwrap();
assert_eq!(r, json!({"active": false, "count": 0, "ids": []}));
assert_eq!(members(&s), None, "one object left: Global Edit ends");
sel(&mut s, &[wide]);
assert!(crate::cmd::globaledit::highlights(&s).is_empty());
}
+131
View File
@@ -881,3 +881,134 @@ fn making_a_gradient_diamond_is_one_undo_step() {
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(fill_gradient(&s, id), before);
}
/// `paint.setFill` and `paint.editGradient` take a spread and a count for each kind of gradient
/// that has ends; the params give them back, the native format keeps them, and a change is one
/// undo step while an edit that changes nothing records none.
#[test]
fn a_gradient_takes_a_spread_and_a_count() {
use vectorcraft_color::GradientSpread;
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 200.0, 100.0);
for kind in ["linear", "radial", "conic", "diamond"] {
s.execute("paint.setFill", &json!({"gradient": {"kind": kind, "spread": "Reflect", "repeats": 4}})).unwrap();
let g = fill_gradient(&s, id);
assert_eq!((g.gradient.spread, g.gradient.repeats), (GradientSpread::Reflect, 4), "{kind}");
let params = vectorcraft_tools::params::gradient_params(&g);
assert_eq!((params["spread"].as_str(), params["repeats"].as_u64()), (Some("reflect"), Some(4)), "{kind}");
s.execute("paint.setFill", &json!({"gradient": {"kind": "linear"}})).unwrap();
assert_eq!(fill_gradient(&s, id).gradient.spread, GradientSpread::Pad, "a new gradient pads");
s.execute("paint.setFill", &json!({ "gradient": params })).unwrap();
assert_eq!(fill_gradient(&s, id).gradient, g.gradient, "{kind}");
}
let steps = s.doc().unwrap().history.undo.len();
s.execute("paint.editGradient", &json!({"spread": "repeat", "repeats": 2})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "one step");
let g = fill_gradient(&s, id);
assert_eq!((g.gradient.spread, g.gradient.repeats), (GradientSpread::Repeat, 2));
s.execute("paint.editGradient", &json!({"spread": "repeat", "repeats": 2})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "nothing changed: no step");
s.execute("paint.editGradient", &json!({"spread": "pad"})).unwrap();
assert_eq!(fill_gradient(&s, id).gradient.repeats, 2, "Pad keeps the count for later");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(fill_gradient(&s, id), g);
let back = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
let Paint::Gradient(saved) = back.node(id).unwrap().appearance.fill_paint() else { panic!("the gradient is lost") };
assert_eq!((saved.gradient.spread, saved.gradient.repeats), (GradientSpread::Repeat, 2));
// The params of a gradient that pads give back the count it keeps.
s.execute("paint.editGradient", &json!({"spread": "pad"})).unwrap();
let params = vectorcraft_tools::params::gradient_params(&fill_gradient(&s, id));
s.execute("paint.setFill", &json!({"gradient": {"kind": "linear"}})).unwrap();
s.execute("paint.setFill", &json!({ "gradient": params })).unwrap();
assert_eq!((fill_gradient(&s, id).gradient.spread, fill_gradient(&s, id).gradient.repeats), (GradientSpread::Pad, 2), "{params}");
}
/// A spread or count a gradient can't take is an error, from every command that sets one, and the
/// gradient stays as it was: an unknown spread, a count that is not a whole number from 1 to 100,
/// and a spread other than pad on a freeform gradient.
#[test]
fn a_bad_spread_or_count_is_refused() {
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 200.0, 100.0);
s.execute("paint.setFill", &json!({"gradient": {"kind": "radial", "spread": "repeat", "repeats": 3}})).unwrap();
let before = fill_gradient(&s, id);
let steps = s.doc().unwrap().history.undo.len();
for bad in [json!({"spread": "mirror"}), json!({"spread": 1}), json!({"spread": true})] {
let e = s.execute("paint.editGradient", &bad).unwrap_err().to_string();
assert!(e.contains("`spread` must be pad, repeat or reflect"), "{bad}: {e}");
}
for n in [json!(0), json!(-2), json!(1.5), json!(101), json!(1e9), json!("3"), json!(f64::MAX)] {
let e = s.execute("paint.editGradient", &json!({ "repeats": n })).unwrap_err().to_string();
assert!(e.contains("`repeats` must be a whole number from 1 to 100"), "{n}: {e}");
let e = s.execute("paint.setFill", &json!({"gradient": {"kind": "linear", "repeats": n}})).unwrap_err().to_string();
assert!(e.contains("`repeats`"), "{n}: {e}");
}
let freeform = json!({"kind": "freeform", "spread": "reflect"});
let e = s.execute("paint.editGradient", &freeform).unwrap_err().to_string();
assert!(e.contains("`spread` applies to linear, radial, conic and diamond gradients"), "{e}");
let e = s.execute("paint.setFill", &json!({ "gradient": freeform })).unwrap_err().to_string();
assert!(e.contains("`spread` applies to"), "{e}");
assert_eq!(fill_gradient(&s, id), before);
assert_eq!(s.doc().unwrap().history.undo.len(), steps);
// Pad on a freeform gradient is allowed (it has nothing to spread), and 100 is the most.
s.execute("paint.editGradient", &json!({"repeats": 100})).unwrap();
s.execute("paint.editGradient", &json!({"kind": "freeform", "spread": "pad"})).unwrap();
// A repeating gradient turned freeform: its params, which carry no spread, set it again.
s.execute("paint.editGradient", &json!({"kind": "radial", "spread": "reflect"})).unwrap();
s.execute("paint.editGradient", &json!({"kind": "freeform"})).unwrap();
let params = vectorcraft_tools::params::gradient_params(&fill_gradient(&s, id));
assert!(params.get("spread").is_none(), "{params}");
s.execute("paint.setFill", &json!({ "gradient": params })).unwrap();
}
/// A spread for a selected gradient applies while the gradient used last, the default, is a
/// freeform one, which keeps no spread.
#[test]
fn a_spread_for_a_selected_gradient_leaves_a_freeform_default_alone() {
use vectorcraft_color::GradientSpread;
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
s.execute("paint.setFill", &json!({"gradient": {"kind": "linear"}})).unwrap();
rect(&mut s, 200.0, 0.0, 100.0, 100.0);
s.execute("paint.setFill", &json!({"gradient": {"kind": "freeform"}})).unwrap();
s.execute("paint.editGradient", &json!({"ids": [a.0], "spread": "repeat", "repeats": 3})).unwrap();
let g = fill_gradient(&s, a);
assert_eq!((g.gradient.spread, g.gradient.repeats), (GradientSpread::Repeat, 3));
}
/// A preset keeps its spread and count: saved from a gradient, applied to another object.
#[test]
fn a_gradient_preset_keeps_its_spread() {
use vectorcraft_color::GradientSpread;
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
s.execute("paint.setFill", &json!({"gradient": {"kind": "conic", "spread": "reflect", "repeats": 5}})).unwrap();
s.execute("gradient.presets.save", &json!({"name": "Fan"})).unwrap();
let b = rect(&mut s, 200.0, 0.0, 100.0, 100.0);
s.execute("paint.setFill", &json!({"gradient": {"kind": "linear"}})).unwrap();
s.execute("gradient.presets.apply", &json!({"name": "Fan"})).unwrap();
let g = fill_gradient(&s, b);
assert_eq!((g.gradient.kind, g.gradient.spread, g.gradient.repeats), (GradientKind::Conic, GradientSpread::Reflect, 5));
assert_eq!(fill_gradient(&s, a).gradient.repeats, 5);
}
/// A gradient set back to Pad keeps its count for later, and still matches a saved preset and a
/// swatch of the same gradient; while it repeats, the spread tells them apart.
#[test]
fn a_padding_gradient_matches_whatever_count_it_keeps() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
let ramp = json!({"kind": "linear", "stops": [{"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"}]});
s.execute("paint.setFill", &json!({ "gradient": ramp })).unwrap();
s.execute("gradient.presets.save", &json!({"name": "Plain"})).unwrap();
s.execute("swatch.new", &json!({"name": "Plain", "paint": {"gradient": ramp}})).unwrap();
let unused = |s: &mut Session| s.execute("swatch.unused", &json!({})).unwrap()["names"].as_array().unwrap().contains(&json!("Plain"));
assert!(!unused(&mut s));
s.execute("paint.editGradient", &json!({"spread": "repeat", "repeats": 5})).unwrap();
assert_eq!(s.active_saved_gradient_preset(), None, "a repeating gradient is another ramp");
assert!(unused(&mut s), "nothing paints the swatch's gradient");
s.execute("paint.editGradient", &json!({"spread": "pad"})).unwrap();
assert_eq!(fill_gradient(&s, a).gradient.repeats, 5);
assert_eq!(s.active_saved_gradient_preset(), Some("Plain"));
assert!(!unused(&mut s), "the gradient paints as the swatch does");
}
+45 -2
View File
@@ -233,7 +233,7 @@ fn a_saved_preset_with_values_out_of_range_reads_in_range() {
saved,
[
(1.0, 1.0, 1.0, 0.0, vec![0.0, 0.0, 0.0, 9.0]),
(163830.0, 163830.0, 1.0, 1.0e5, vec![72.0, 72.0, 72.0, 0.0]),
(3_999_856.0, 200000.0, 1.0, 1.0e5, vec![72.0, 72.0, 72.0, 0.0]),
(10.0, 10.0, 1000.0, 0.0, vec![0.0; 4]),
]
);
@@ -242,7 +242,7 @@ fn a_saved_preset_with_values_out_of_range_reads_in_range() {
s.execute("file.new", &json!({"preset": "Low"})).unwrap();
assert_eq!((boards(&s), s.doc().unwrap().doc.setup.bleed), (vec![Rect::new(0.0, 0.0, 1.0, 1.0)], [0.0, 0.0, 0.0, 9.0]));
s.execute("file.new", &json!({"preset": "High"})).unwrap();
assert_eq!((boards(&s), s.doc().unwrap().doc.setup.bleed), (vec![Rect::new(0.0, 0.0, 163830.0, 163830.0)], [72.0, 72.0, 72.0, 0.0]));
assert_eq!((boards(&s), s.doc().unwrap().doc.setup.bleed), (vec![Rect::new(0.0, 0.0, 3_999_856.0, 200000.0)], [72.0, 72.0, 72.0, 0.0]));
s.execute("file.new", &json!({"preset": "Many"})).unwrap();
assert_eq!(boards(&s).len(), 1000);
let custom = presets(&mut s, "Recent").into_iter().find(|p| p["name"] == "Custom").unwrap();
@@ -250,6 +250,49 @@ fn a_saved_preset_with_values_out_of_range_reads_in_range() {
assert_eq!(boards(&s).iter().map(|r| r.x0).collect::<Vec<_>>(), [0.0, 100.0, 200.0], "side by side, not overlapping");
}
/// `file.new` and `artboard.new` take the same largest artboard side (the canvas less the largest
/// bleed on both sides) and refuse a side just past it, or of 0 or less, with an error that names
/// the limit in points and, when the document's units aren't points, in those units too.
#[test]
fn file_new_and_artboard_new_take_the_same_largest_side() {
let max = 3_999_856.0;
let in_meters = "at most 3999856 pt (1411.0603 m)";
let s = new_doc(json!({"width": max, "height": 170078}));
assert_eq!(boards(&s), [Rect::new(0.0, 0.0, max, 170078.0)]);
let mut s = Session::new();
let err = s.execute("file.new", &json!({"width": max + 1.0, "height": 100})).unwrap_err().to_string();
assert!(err.contains("width and height must be more than 0 and at most 3999856 pt") && !err.contains('('), "{err}");
let err = s.execute("file.new", &json!({"width": 100, "height": "1412 m", "units": "Meters"})).unwrap_err().to_string();
assert!(err.contains(in_meters), "{err}");
// The value in other units is rounded down, so it is one file.new takes.
let err = s.execute("file.new", &json!({"width": 100, "height": "56000 in", "units": "Inches"})).unwrap_err().to_string();
assert!(err.contains("at most 3999856 pt (55553.5555 in)"), "{err}");
assert!(s.execute("file.new", &json!({"width": 0, "height": 100})).is_err());
assert!(s.doc().is_err(), "no document was made");
s.execute("file.new", &json!({"width": "55553.5555 in", "height": 100, "units": "Inches"})).unwrap();
let mut s = new_doc(json!({"units": "Meters"}));
s.execute("artboard.new", &json!({"x": -2_000_000, "y": 0, "width": max, "height": 100})).unwrap();
assert_eq!(boards(&s)[1], Rect::new(-2_000_000.0, 0.0, max - 2_000_000.0, 100.0));
for p in [
json!({"x": -2_000_000, "y": 0, "width": max + 1.0, "height": 100}),
json!({"x": 0, "y": 2000, "width": 100, "height": max + 1.0}),
json!({"width": 0}),
json!({"height": -1}),
] {
let err = s.execute("artboard.new", &p).unwrap_err().to_string();
assert!(err.contains(in_meters), "{p}: {err}");
}
assert_eq!(boards(&s).len(), 2, "the refused artboards were not added");
// A size taken from a wider artboard is refused too.
s.execute("artboard.setProps", &json!({"index": 1, "x": -2_000_000, "y": 0, "width": max + 1.0, "height": 100})).unwrap();
for p in [json!({}), json!({"x": 0, "y": 5000, "height": 100}), json!({"side": "bottom", "beside": 1})] {
let err = s.execute("artboard.new", &p).unwrap_err().to_string();
assert!(err.contains(in_meters), "{p}: {err}");
}
assert_eq!(boards(&s).len(), 2);
}
#[test]
fn saved_presets_live_in_the_preferences() {
let mut s = Session::new();
+44
View File
@@ -464,6 +464,50 @@ fn a_turned_or_flat_diamond_expands_as_the_canvas_draws_it() {
}
}
/// A gradient that repeats or reflects expands, into objects or a mesh, as the canvas paints it:
/// its stops repeated across the box, for each kind.
#[test]
fn a_spread_gradient_expands_as_the_canvas_paints_it() {
for kind in ["linear", "radial", "conic", "diamond"] {
for spread in ["repeat", "reflect"] {
for to in [json!({"steps": 240}), json!({"gradient": "mesh"})] {
let mut s = session();
let gr = json!({"kind": kind, "spread": spread, "repeats": 3, "stops": [{"offset": 0, "color": "#ffff00"}, {"offset": 1, "color": "#004080"}]});
gradient_rect(&mut s, Rect::new(30.0, 40.0, 170.0, 160.0), gr, false);
let before = render(&s);
run(&mut s, "object.expand", to.clone());
let after = render(&s);
// Where Repeat starts the stops again, the hard edge may land a pixel off.
assert!(mean_diff(&before, &after) < 4.0, "{kind} {spread} {to}: {}", mean_diff(&before, &after));
}
}
}
}
/// A gradient that repeats or reflects expands into the same whole number of objects in each run,
/// so each run starts on an object's edge: a sharp step in the middle of each of 7 runs, expanded
/// into about 15 objects (2 a run), lands where the canvas paints it.
#[test]
fn a_spread_gradient_expands_into_whole_bands_for_each_run() {
let stops = json!([
{"offset": 0, "color": "#ffff00"}, {"offset": 0.5, "color": "#ffff00"},
{"offset": 0.5, "color": "#004080"}, {"offset": 1, "color": "#004080"}
]);
for kind in ["linear", "conic"] {
for spread in ["repeat", "reflect"] {
let mut s = session();
// A conic gradient turns about the box's center.
let start = if kind == "conic" { [100, 100] } else { [30, 100] };
let gr = json!({"kind": kind, "spread": spread, "repeats": 7, "start": start, "end": [170, 100], "stops": stops});
gradient_rect(&mut s, Rect::new(30.0, 40.0, 170.0, 160.0), gr, false);
let before = render(&s);
run(&mut s, "object.expand", json!({"steps": 15}));
let after = render(&s);
assert!(mean_diff(&before, &after) < 2.0, "{kind} {spread}: {}", mean_diff(&before, &after));
}
}
}
#[test]
fn the_mesh_option_makes_a_mesh_that_paints_the_gradient() {
for gradient in [
+1 -1
View File
@@ -515,7 +515,7 @@ fn the_document_info_report_has_every_category() {
"OBJECTS",
"GRAPHIC STYLES",
"BRUSHES",
"SPOT COLORS",
"SPOT COLOR OBJECTS",
"PATTERN OBJECTS",
"GRADIENT OBJECTS",
"SYMBOLS",
+24
View File
@@ -505,6 +505,30 @@ fn a_painted_group_effect_links_to_the_document_s_swatches() {
assert_eq!((img.pixel(50, 50), img.pixel(15, 15)), (GREEN, WHITE), "the group's piece, green");
}
/// A painted effect on a group leaves the group's art as it is when a path in it has a linked
/// opacity mask, which can't take the pieces as the path does: the mask still covers the path.
#[test]
fn a_painted_group_effect_leaves_art_with_a_linked_mask_as_it_is() {
let mut s = session();
let a = rect(&mut s, 10.0, "#ff0000");
let m = rect(&mut s, 10.0, "#ffffff");
run(&mut s, "select.set", json!({"ids": [a.0, m.0]}));
run(&mut s, "transparency.makeOpacityMask", json!({}));
rect(&mut s, 100.0, "#0000ff");
run(&mut s, "select.all", json!({}));
let g = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
let out = json!({"objects": [{"path": square_at(40.0), "fills": [solid("#00ff00")]}]}).to_string();
install_wat(&mut s, &tpl::returning(&painting("test.engine.maskedpaint", true), &out));
run(&mut s, "effect.apply", json!({"ids": [g.0], "effect": "plugin.test.engine.maskedpaint"}));
let art = vectorcraft_render::effects::evaluate_container(Some(&s.doc().unwrap().doc), &node(&s, g)).unwrap();
let mut masked = vec![];
art.walk(&mut |c| masked.extend(c.extras().mask.as_ref().map(|k| (c.geometric_bounds(), k.art.geometric_bounds()))));
assert!(!masked.is_empty(), "the masked path");
for (path, mask) in masked {
assert_eq!(path, mask, "the mask covers the path");
}
}
/// The output of a painted effect that returns one green square linked to swatch `Leaf`.
fn leaf_square() -> String {
let mut leaf = solid("#00ff00");
+166
View File
@@ -139,6 +139,54 @@ fn feature_changes_keep_each_runs_other_features() {
assert_eq!(features(&s), [vec!["smcp", "numr", "liga", "dnom"], vec!["swsh", "numr", "liga", "dnom"], vec!["-onum", "swsh", "dnom"]]);
}
/// A feature with a value (`salt=2`): `features` and `featureChanges` take it, the next value
/// replaces it, `salt=1` is a plain `salt` and `salt=0` and `-salt` are off, a value this build
/// does not know is an error, one undo step each, and the native format keeps the plain string.
#[test]
fn feature_values_are_set_replaced_and_saved() {
let mut s = session();
let id = text(&mut s, "abcd");
let features = |s: &Session| obj(s, id).runs.iter().map(|r| (r.text.clone(), r.style.features.clone())).collect::<Vec<_>>();
let range = |s: &mut Session, p: Value| {
let mut p = p;
p["id"] = json!(id.0);
p["start"] = json!(1);
p["end"] = json!(2);
s.execute("text.setRangeStyle", &p).map(|_| ())
};
let undo = s.doc().unwrap().history.undo.len();
range(&mut s, json!({"features": ["salt=2"]})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
assert_eq!(features(&s), [("a".into(), vec![]), ("b".into(), vec!["salt=2".to_string()]), ("cd".into(), vec![])]);
range(&mut s, json!({"features": ["salt=3"]})).unwrap();
assert_eq!(features(&s)[1].1, ["salt=3"], "the next value replaces it");
range(&mut s, json!({"featureChanges": ["salt=2", "ss01"]})).unwrap();
assert_eq!(features(&s)[1].1, ["ss01", "salt=2"], "written in the canonical order");
range(&mut s, json!({"featureChanges": ["salt=1"]})).unwrap();
assert_eq!(features(&s)[1].1, ["ss01", "salt"], "salt=1 is a plain salt");
range(&mut s, json!({"featureChanges": ["salt=2"]})).unwrap();
let saved = vectorcraft_format::save(&s.doc().unwrap().doc, false);
let back = vectorcraft_format::load(&saved).unwrap();
let Some(NodeKind::Text(t)) = back.node(id).map(|n| &n.kind) else { panic!("the text survives") };
assert_eq!(t.runs[1].style.features, ["ss01", "salt=2"], "the native format keeps the string");
assert!(String::from_utf8_lossy(&saved).contains("\"salt=2\""));
range(&mut s, json!({"featureChanges": ["-salt"]})).unwrap();
assert_eq!(features(&s)[1].1, ["ss01"], "-salt turns it off");
range(&mut s, json!({"featureChanges": ["salt=2"], "features": null})).unwrap();
range(&mut s, json!({"featureChanges": ["salt=0"]})).unwrap();
assert_eq!(features(&s)[1].1, ["ss01"], "salt=0 turns it off");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(features(&s)[1].1, ["ss01", "salt=2"], "undo takes it back");
let before = features(&s);
for tag in ["salt=", "salt=x", "salt=65536", "-salt=2", "liga=2", "salt=2=3", "zzzz=2"] {
for key in ["features", "featureChanges"] {
let e = range(&mut s, json!({ key: [tag] })).unwrap_err().to_string();
assert!(e.contains(&format!("`{tag}`")), "{key} {tag}: {e}");
}
}
assert_eq!(features(&s), before, "the refused commands change nothing");
}
/// `text.setStyle {stroke, strokeWidth}` sets the character stroke of all the text or of a range, as
/// `text.setRangeStyle` does, and a call with `fill` and `stroke` sets both in one undo step.
#[test]
@@ -3166,6 +3214,41 @@ fn a_glyph_alternate_replaces_one_character_through_undo_and_reopen() {
assert!(s.execute("text.glyphAlternates", &json!({"id": id.0, "start": 2})).unwrap_err().to_string().contains("is not available"));
}
/// `glyphAlternate: null` in `text.setRangeStyle` takes a glyph choice away in the same undo step
/// as the other style it sets (a feature: what the Glyphs panel does for a variant a feature
/// draws); anything but null is refused.
#[test]
fn set_range_style_takes_a_glyph_choice_away_with_a_feature() {
use vectorcraft_text::test_fonts::{alternates_family, alternates_font, unencoded_glyphs};
let _fonts = crate::adding_fonts();
let db = vectorcraft_text::FontDb::global();
db.add_font(alternates_font(true).expect("the test font builds"));
let [u1, ..] = unencoded_glyphs().expect("unencoded glyphs");
let face = db.face(alternates_family(true), "Regular").expect("the test face");
let mut s = session();
let r = s.execute("text.create", &json!({"x": 100, "y": 100, "text": "xay", "size": 20, "font": alternates_family(true)})).unwrap();
let id = NodeId(r["id"].as_u64().unwrap());
s.execute("text.setGlyphAlternate", &json!({"id": id.0, "start": 1, "gid": u1})).unwrap();
let gids = |s: &Session| vectorcraft_text::layout(db, &obj(s, id)).glyphs.iter().map(|g| g.gid).collect::<Vec<_>>();
assert_eq!(gids(&s)[1], u1);
let undo = s.doc().unwrap().history.undo.len();
let e = s.execute("text.setRangeStyle", &json!({"id": id.0, "start": 1, "end": 2, "glyphAlternate": 5})).unwrap_err().to_string();
assert!(e.contains("takes only null"), "{e}");
s.execute("text.setRangeStyle", &json!({"id": id.0, "start": 1, "end": 2, "glyphAlternate": null, "featureChanges": ["ss01"]})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
assert!(obj(&s, id).runs.iter().all(|r| r.style.glyph_alternate.is_none()), "the choice is gone");
assert_eq!(
gids(&s)[1],
face.substitutions(face.glyph_for('a')).iter().find(|x| &x.feature == b"ss01").map(|x| x.glyphs[0]).unwrap(),
"ss01 draws its glyph"
);
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(gids(&s)[1], u1, "undone: the choice again");
// With nothing else to set it is still a change.
s.execute("text.setRangeStyle", &json!({"id": id.0, "start": 1, "end": 2, "glyphAlternate": null})).unwrap();
assert_eq!(gids(&s)[1], face.glyph_for('a'));
}
/// The glyph already drawn, chosen again, and null for a character drawn with its default glyph
/// leave the document and its undo history as they are. An empty run before the character does
/// not stand in for the character's own choice.
@@ -3558,6 +3641,89 @@ fn an_overflowing_grapheme_keeps_the_styles_of_its_characters() {
assert_eq!(r["gid"], json!(g('b')), "the overflowing Ka is shaped apart from the nukta of another size");
}
/// A contextual alternate with no feature must name the fallback face that supplies the glyph,
/// including when the character is outside its frame. Neither another face's glyph nor an
/// out-of-range id becomes a choice.
#[test]
fn a_contextual_fallback_glyph_choice_draws_through_undo_and_reopen() {
use vectorcraft_text::test_fonts::{
CONTEXTUAL_FALLBACK_CHAR as CH, CONTEXTUAL_FALLBACK_FAMILY, alternates_family, alternates_font, contextual_fallback_font, source_sans_gid,
};
let _fonts = crate::adding_fonts();
let db = vectorcraft_text::FontDb::global();
db.add_font(alternates_font(true).expect("the primary test font builds"));
db.add_font(contextual_fallback_font().expect("the fallback test font builds"));
let primary = db.face(alternates_family(true), "Regular").expect("the primary face");
let fallback = db.face(CONTEXTUAL_FALLBACK_FAMILY, "Regular").expect("the supplying face");
let g = |c| u32::from(source_sans_gid(c).expect("a Source Sans glyph"));
let (default, alternate) = (g('m'), g('d'));
assert_eq!(primary.glyph_for(CH), 0);
assert_eq!(db.face_covering(CH).unwrap().id(), fallback.id(), "only the fixture supplies the private-use character");
assert!(!fallback.alternates(CH).iter().any(|a| a.gid == alternate), "the alternate belongs to its shaped, not nominal, glyph");
assert!(!fallback.is_unlisted_alternate(CH, alternate), "the contextual validation path is required");
let text = format!("a{CH}a");
let start = 1;
let end = start + CH.len_utf8();
let drawn = |t: &TextObject| {
let mut open = t.clone();
open.kind = TextKind::Point;
vectorcraft_text::layout(db, &open).glyphs.into_iter().find(|g| g.byte == start).map(|g| (g.font_id, g.gid))
};
let state = |s: &Session| (s.doc().unwrap().history.undo.len(), s.doc().unwrap().revision);
for overflow in [false, true] {
let mut s = session();
let mut spec = json!({"x": 0, "y": 0, "text": text, "size": 20, "font": alternates_family(true)});
if overflow {
spec["area"] = json!({"width": 200, "height": 2});
}
let id = NodeId(s.execute("text.create", &spec).unwrap()["id"].as_u64().unwrap());
let before = obj(&s, id);
assert_eq!(drawn(&before), Some((fallback.id(), default)));
if overflow {
assert!(vectorcraft_text::layout(db, &before).glyphs.is_empty(), "the original frame overflows");
}
let contextual = vectorcraft_text::alternates_in_context(db, &before, start).expect("the panel's contextual alternates");
assert_eq!((contextual.font_id, contextual.default), (fallback.id(), default));
assert!(contextual.alternates.iter().any(|a| a.gid == alternate && a.apply.is_none()));
let unchanged = state(&s);
for gid in [primary.glyph_for('a'), fallback.glyph_count()] {
let err = s.execute("text.setGlyphAlternate", &json!({"id": id.0, "start": start, "gid": gid})).unwrap_err();
assert!(err.to_string().contains("is not an alternate"), "{err}");
assert_eq!(state(&s), unchanged, "a refused choice makes no edit");
assert_eq!(obj(&s, id).runs, before.runs);
}
let result = s.execute("text.setGlyphAlternate", &json!({"id": id.0, "start": start, "gid": alternate})).unwrap();
assert_eq!(result, json!({"id": id.0, "start": start, "end": end, "gid": alternate}));
assert_eq!(state(&s).0, unchanged.0 + 1, "one undo step");
let chosen = obj(&s, id);
assert_eq!(chosen.plain_text(), text);
assert_eq!(drawn(&chosen), Some((fallback.id(), alternate)));
let choice = chosen.runs.iter().find_map(|r| r.style.glyph_alternate.as_ref()).expect("the stored choice");
assert_eq!(choice, &fallback.choice(CH, alternate), "the choice keeps the supplying face's identity");
let mut wrong_face = chosen.clone();
wrong_face.runs.iter_mut().find(|r| r.style.glyph_alternate.is_some()).unwrap().style.glyph_alternate = Some(primary.choice(CH, alternate));
assert_eq!(drawn(&wrong_face), Some((fallback.id(), default)), "another face's choice is not drawn");
let bytes = vectorcraft_format::save_file(&s.doc().unwrap().doc);
let reopened = vectorcraft_format::load(&bytes).unwrap();
let NodeKind::Text(reopened) = &reopened.node(id).unwrap().kind else { panic!("text missing") };
assert_eq!(drawn(reopened), Some((fallback.id(), alternate)), "native restore retains the face and glyph");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(obj(&s, id).runs, before.runs, "Undo restores the original runs");
assert_eq!(drawn(&obj(&s, id)), Some((fallback.id(), default)));
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(drawn(&obj(&s, id)), Some((fallback.id(), alternate)), "Redo restores the choice");
let result = s.execute("text.setGlyphAlternate", &json!({"id": id.0, "start": start, "gid": null})).unwrap();
assert_eq!(result["gid"], json!(default), "clearing reports the fallback's shaped glyph");
assert_eq!(drawn(&obj(&s, id)), Some((fallback.id(), default)));
assert!(obj(&s, id).runs.iter().all(|r| r.style.glyph_alternate.is_none()));
}
}
#[test]
fn glyph_alternates_query_reports_the_fallback_glyph_that_is_drawn() {
use vectorcraft_text::test_fonts::{alternates_family, alternates_font};
+45
View File
@@ -526,6 +526,51 @@ fn distort_command_maps_corners() {
assert!(close(bounds(&s, a), Rect::new(0.0, 0.0, 100.0, 100.0)));
}
/// Free Distort warps the art of a linked opacity mask with the object it masks, and one undo puts
/// both back; an unlinked mask stays where it is.
#[test]
fn distort_command_warps_a_linked_opacity_mask_with_its_object() {
for linked in [true, false] {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
let b = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
if !linked {
s.execute("transparency.unlinkOpacityMask", &json!({})).unwrap();
}
let mask_path = |s: &Session| s.doc().unwrap().doc.node(a).unwrap().extras().mask.as_ref().unwrap().art.path_data().cloned();
let path = |s: &Session| s.doc().unwrap().doc.node(a).unwrap().path_data().cloned();
let before = (path(&s), mask_path(&s));
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
s.execute("object.distort", &json!({"corners": [[10, 0], [90, 0], [100, 100], [0, 100]]})).unwrap();
assert!(path(&s) != before.0);
let want = if linked { path(&s) } else { before.1.clone() };
assert_eq!(mask_path(&s), want, "linked: {linked}");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!((path(&s), mask_path(&s)), before);
}
}
/// Free Distort of a group warps the linked opacity mask of a path inside it with the path.
#[test]
fn distort_command_warps_the_linked_mask_of_a_path_in_a_group() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
let b = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
let c = rect(&mut s, 150.0, 0.0, 50.0, 50.0);
s.execute("select.set", &json!({"ids": [a.0, c.0]})).unwrap();
let g = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
let before = s.doc().unwrap().doc.node(a).unwrap().path_data().cloned();
s.execute("select.set", &json!({"ids": [g]})).unwrap();
s.execute("object.distort", &json!({"corners": [[10, 0], [190, 0], [200, 100], [0, 100]]})).unwrap();
let a = s.doc().unwrap().doc.node(a).unwrap();
assert!(a.path_data().cloned() != before, "the path is warped");
assert_eq!(a.extras().mask.as_ref().unwrap().art.path_data(), a.path_data(), "and so is its mask");
}
#[test]
fn distort_perspective_midpoint_is_projective() {
// Distort a tiny probe at the centre of a 100×100 source box into a trapezoid: with a real
+5 -2
View File
@@ -1142,8 +1142,11 @@ impl Session {
let place = w.show.then_some(WidgetPlace { screen: view.screen.as_ref(), corner: w.position });
v.splice(0..0, vectorcraft_tools::distort::perspective::grid_overlays_in(&d.doc, 1.0 / view.zoom.max(1e-9), place));
}
// Global Edit: the objects edited with the selected one are highlighted.
for (path, color) in crate::cmd::globaledit::highlights(self) {
// Global Edit: the objects edited with the selected one are highlighted; before it starts,
// with the Selection tool, the objects it would take.
let ge_on = self.active().is_some_and(|d| d.global_edit.is_some());
let shown = if ge_on || self.tool.id() == "selection" { crate::cmd::globaledit::highlights(self) } else { vec![] };
for (path, color) in shown {
v.push(Overlay::Path { path, color, width: 1.0, dashed: false });
}
if let Some((cmd, p)) = deferred_preview {
+152 -43
View File
@@ -9,11 +9,11 @@ use vectorcraft_engine::{Session, command_specs};
use vectorcraft_testkit::catch_quiet;
use vectorcraft_testkit::fixtures::Fixture;
use vectorcraft_testkit::invariants::{check_all, check_session, doc_json};
use vectorcraft_testkit::strategies::{junk_params, junk_values, param_keys, safe_value};
use vectorcraft_testkit::strategies::{command_param_keys, junk_params_for_command, junk_values, param_keys, safe_value_for_command};
/// Commands that replace/close the active document or touch the filesystem are fine to call, but a
/// few need their file and folder params redirected into a temp dir (`safe_value`, which
/// `junk_params` applies).
/// Commands that replace/close the active document or touch the filesystem are fine to call, but
/// their file and folder params are redirected into a temp dir (`safe_value_for_command`, which
/// `junk_params_for_command` applies, by the keys the command catalog names as files and folders).
fn safe_path() -> String {
vectorcraft_testkit::temp_dir("sweep").join("out.bin").to_string_lossy().to_string()
}
@@ -190,6 +190,33 @@ fn heavy(id: &str) -> bool {
id.starts_with("document.serialize") || id.starts_with("document.export") || id == "document.open"
}
/// Is `p` a params object with `k` as its only key?
fn sends_alone(p: &Value, k: &str) -> bool {
p.as_object().is_some_and(|o| o.len() == 1 && o.contains_key(k))
}
/// The junk params the sweeps send `c`: all of them, or for a [`heavy`] command the first 12 and,
/// for each key the command catalog names as a file or folder that no case among those sends alone
/// ([`sends_alone`]), the first case that sends a string under it alone (or any value when none
/// does).
fn junk_cases(c: &vectorcraft_engine::CommandSpec, path: &str) -> Vec<Value> {
let mut cases = junk_params_for_command(c, path);
if heavy(c.id) {
let rest = cases.split_off(cases.len().min(12));
for (k, _) in vectorcraft_engine::cmd::location_keys(c) {
if cases.iter().any(|p| sends_alone(p, k)) {
continue;
}
let alone = || rest.iter().filter(|p| sends_alone(p, k));
let found = alone().find(|p| p.get(k).is_some_and(Value::is_string)).or_else(|| alone().next());
if let Some(p) = found {
cases.push(p.clone());
}
}
}
cases
}
#[test]
fn every_command_with_junk_params() {
let path = safe_path();
@@ -197,10 +224,7 @@ fn every_command_with_junk_params() {
let mut calls = 0usize;
for fx in Fixture::ALL {
for c in command_specs() {
let mut cases = junk_params(c.params, &path);
if heavy(c.id) {
cases.truncate(12);
}
let cases = junk_cases(c, &path);
for p in &cases {
calls += 1;
if let Some(f) = probe(fx, c.id, p) {
@@ -234,13 +258,10 @@ fn tool_edit_state(s: &Session) -> ToolEditState {
/// The params the tool-edit sweep sends `c`: junk params, then each documented key turned on and
/// off, with a string under a file or folder key replaced by a location inside `path`'s folder.
fn tool_edit_cases(c: &vectorcraft_engine::CommandSpec, path: &str) -> Vec<Value> {
let mut cases = junk_params(c.params, path);
if heavy(c.id) {
cases.truncate(12);
}
for k in param_keys(c.params) {
let mut cases = junk_cases(c, path);
for k in command_param_keys(c) {
for v in [json!(true), json!(false), json!(1), json!("on")] {
cases.push(json!({ k.as_str(): safe_value(&k, &v, path) }));
cases.push(json!({ k.as_str(): safe_value_for_command(c, &k, &v, path) }));
}
}
// Find Objects selects only with a filter, which one key at a time does not give it.
@@ -250,35 +271,109 @@ fn tool_edit_cases(c: &vectorcraft_engine::CommandSpec, path: &str) -> Vec<Value
cases
}
/// Every string the sweeps send under a key that names a file or folder to write is inside the
/// sweep's temp folder, so no run writes into the working directory.
/// The strings in `v`, the value at `at` in a case of command `id`, that name a place on disk
/// outside `dir`, as `id at: value`: `v` itself and the members of arrays in it when `named` (it is
/// under a key that names a file or folder), and in objects at any depth, the values under such
/// keys ([`names_location`]).
fn outside_locations(id: &str, at: &str, v: &Value, named: bool, dir: &std::path::Path, out: &mut std::collections::BTreeSet<String>) {
match v {
Value::String(s) if named && !std::path::Path::new(s).starts_with(dir) => {
out.insert(format!("{id} {at}: {v}"));
}
Value::Array(a) => {
for (i, x) in a.iter().enumerate() {
outside_locations(id, &format!("{at}[{i}]"), x, named, dir, out);
}
}
Value::Object(o) => {
for (k, x) in o {
outside_locations(id, &format!("{at}.{k}"), x, names_location(None, k), dir, out);
}
}
_ => {}
}
}
/// Does `key` name a file or folder, in command `spec` when given: a key in
/// `vectorcraft_engine::cmd::key_location`'s list that `vectorcraft_engine::cmd::location_in` keeps
/// for `spec`.
fn names_location(spec: Option<&vectorcraft_engine::CommandSpec>, key: &str) -> bool {
match spec {
Some(spec) => vectorcraft_engine::cmd::location_in(spec, key).is_some(),
None => vectorcraft_engine::cmd::key_location(key).is_some(),
}
}
/// Every string the sweeps send under a key that names a file or folder, in the command catalog
/// (`vectorcraft_engine::cmd::location_keys`, so a command added later is checked too) or inside
/// an object or an array at any depth, is inside the sweep's temp folder, so no run reads or
/// writes in the working directory. `every_command_with_junk_params` sends every such key of every
/// command alone in at least one case ([`junk_cases`]).
#[test]
fn sweep_cases_name_files_only_inside_the_temp_folder() {
let path = safe_path();
let dir = vectorcraft_testkit::temp_dir("sweep");
let keys = ["path", "diffPath", "folder", "destinationFolder"];
let mut seen = std::collections::BTreeSet::new();
let mut unsent = vec![];
let mut outside = std::collections::BTreeSet::new();
for c in command_specs() {
let mut cases = junk_params(c.params, &path);
let keys = vectorcraft_engine::cmd::location_keys(c);
let run = junk_cases(c, &path);
for (k, _) in &keys {
if !run.iter().any(|p| sends_alone(p, k)) {
unsent.push(format!("{} {k}", c.id));
}
}
let mut cases = junk_params_for_command(c, &path);
cases.extend(tool_edit_cases(c, &path));
cases.extend(serializable_cases(c, &path));
for p in &cases {
let Some(o) = p.as_object() else { continue };
for (k, v) in o.iter().filter(|(k, _)| keys.contains(&k.as_str())) {
seen.insert(k.clone());
if let Some(s) = v.as_str()
&& !std::path::Path::new(s).starts_with(&dir)
{
outside.insert(format!("{} {{\"{k}\": {v}}}", c.id));
}
for (k, v) in o {
outside_locations(c.id, k, v, names_location(Some(c), k), &dir, &mut outside);
}
}
}
assert_eq!(seen.len(), keys.len(), "the sweeps send only {seen:?}");
assert!(unsent.is_empty(), "every_command_with_junk_params sends no case for {unsent:?}");
let outside: Vec<String> = outside.into_iter().collect();
assert!(outside.is_empty(), "{} cases name a location outside {}:\n{}", outside.len(), dir.display(), outside.join("\n"));
}
/// The cases sweep keys the command catalog names as files and folders: `document.open`'s
/// `{path | name …}`, `addon.document.saveTimestampedCopy`'s `{folder? (…)}`, `document.compare`'s
/// `diffPath`, `file.saveAs`'s `path` after `{…as document.save}` and `links.relink`'s
/// `paths: [{ids, path}]`, each with a string in the temp folder, and a folder key a folder there.
#[test]
fn sweep_cases_send_the_file_keys_of_the_command_catalog() {
let path = safe_path();
let dir = vectorcraft_testkit::temp_dir("sweep");
let spec = |id: &str| command_specs().iter().find(|c| c.id == id).unwrap();
let inside = |v: &Value| v.as_str().is_some_and(|s| std::path::Path::new(s).starts_with(&dir));
for (id, key) in [
("document.open", "path"),
("addon.document.saveTimestampedCopy", "folder"),
("document.compare", "diffPath"),
("text.addFontFiles", "files"),
("file.saveAs", "path"),
] {
let cases = junk_params_for_command(spec(id), &path);
let sent: Vec<&Value> = cases.iter().filter_map(|p| p.get(key)).collect();
assert!(sent.iter().any(|v| inside(v) || v.as_array().is_some_and(|a| a.iter().any(inside))), "{id} sends no `{key}` in the temp folder");
}
for (id, key) in
[("document.open", "path"), ("document.open", "name"), ("addon.document.saveTimestampedCopy", "folder"), ("links.relink", "folder")]
{
assert!(param_keys(spec(id).params).iter().any(|k| k == key), "{id} has no `{key}` key");
}
let folder = junk_params_for_command(spec("addon.document.saveTimestampedCopy"), &path);
assert!(folder.iter().filter_map(|p| p.get("folder")?.as_str()).all(|s| s != path && std::path::Path::new(s).starts_with(&dir)));
let relink = junk_params_for_command(spec("links.relink"), &path);
let nested = relink.iter().filter_map(|p| p.get("paths")?.as_array()).flatten().filter_map(|e| e.get("path")).filter(|v| v.is_string());
assert!(nested.clone().count() > 0 && nested.clone().all(inside), "links.relink sends no `paths[].path` in the temp folder");
// A key that names part of the document in a command keeps its junk there.
let on_path = junk_params_for_command(spec("text.createInPath"), &path);
assert!(on_path.iter().any(|p| p.get("path") == Some(&json!("junk"))));
}
/// Every command that runs at once while the active tool computes an edit on another thread (a
/// Shape Builder merge), rather than applying the edit first (`waits_for_tool_edit`), leaves the
/// documents' revisions and selections, the active document and the current paint as they were,
@@ -798,6 +893,12 @@ fn structured_junk() {
("addon.pen.reshape", json!({"id": 2, "segment": 0, "t": "x", "dx": 1, "dy": 1, "mode": "symmetric"})),
("addon.pen.nextSegment", json!({"curved": "yes"})),
("addon.pen.closeJoin", json!({"ids": [u64::MAX]})),
// Cutting Tools add-on.
("addon.cutting.weed", json!({"margin": 1e5, "count": 1000, "gap": 1e5, "direction": "both"})),
("addon.cutting.weed", json!({"margin": -1, "count": 1.5, "spacing": 0, "gap": f64::MAX, "weight": 1e308})),
("addon.cutting.weed", json!({"spacing": 1e-300, "box": "no", "direction": ["both"], "swatch": 5})),
("addon.cutting.weed", json!({"spacing": "1 mm", "box": false, "direction": "vertical", "swatch": "no such swatch"})),
("addon.cutting.weed", json!({"count": u64::MAX, "margin": "x", "gap": null, "weight": 0})),
// Type Tools add-on.
("addon.type.textTweaker", json!({"attribute": "size", "from": 1296, "to": 0.1, "shape": "random", "seed": u64::MAX})),
("addon.type.textTweaker", json!({"attribute": "tracking", "from": f64::MAX, "to": -1e308, "shape": "spike"})),
@@ -1007,28 +1108,36 @@ fn polygon_properties_junk() {
assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.join("\n"));
}
/// The params `fuzzed_calls_keep_documents_serializable` sends `c`: each key with each of the
/// first junk values, a string under a file or folder key replaced by a location inside `path`'s
/// folder.
fn serializable_cases(c: &vectorcraft_engine::CommandSpec, path: &str) -> Vec<Value> {
if heavy(c.id) || c.id.starts_with("file.") {
return vec![];
}
let mut cases = vec![];
for v in junk_values().iter().take(8) {
for k in command_param_keys(c) {
cases.push(json!({ k.as_str(): safe_value_for_command(c, &k, v, path) }));
}
}
cases
}
/// After a successful fuzzed call, the document still round-trips and exports.
#[test]
fn fuzzed_calls_keep_documents_serializable() {
let path = safe_path();
let mut failures = vec![];
for c in command_specs() {
if heavy(c.id) || c.id.starts_with("file.") {
continue;
}
for v in junk_values().iter().take(8) {
for k in param_keys(c.params) {
let k = if k == "path" { continue } else { k };
let mut s = Fixture::Multi.session();
let p = json!({ k.clone(): v });
let ok = catch_quiet(|| s.execute(c.id, &p)).map(|r| r.is_ok()).unwrap_or(false);
if ok && let Err(e) = catch_quiet(|| check_all(&mut s)).unwrap_or_else(|m| Err(format!("panic in checks: {m}"))) {
failures.push(format!("{} {p}: {e}", c.id));
}
for p in serializable_cases(c, &path) {
let mut s = Fixture::Multi.session();
let ok = catch_quiet(|| s.execute(c.id, &p)).map(|r| r.is_ok()).unwrap_or(false);
if ok && let Err(e) = catch_quiet(|| check_all(&mut s)).unwrap_or_else(|m| Err(format!("panic in checks: {m}"))) {
failures.push(format!("{} {p}: {e}", c.id));
}
}
}
let _ = path;
failures.sort();
failures.dedup();
assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.iter().take(40).cloned().collect::<Vec<_>>().join("\n"));
@@ -1091,7 +1200,7 @@ fn recovery_commands_with_a_damaged_store_and_junk_params() {
for fx in Fixture::ALL {
for id in ["file.recovery.save", "file.recovery.list", "file.recovery.restore", "file.recovery.discard"] {
let spec = command_specs().iter().find(|c| c.id == id).unwrap();
for p in std::iter::once(json!({})).chain(junk_params(spec.params, &path)) {
for p in std::iter::once(json!({})).chain(junk_params_for_command(spec, &path)) {
let mut s = fx.session();
s.recovery.set_store(store.clone());
let r = catch_quiet(|| no_panic(s.execute(id, &p)));
@@ -1120,7 +1229,7 @@ fn envelope_commands_with_junk_params_on_envelopes() {
command_specs().iter().map(|c| c.id).filter(|id| id.starts_with("object.envelope.") || id.starts_with("object.mesh.")).collect();
for id in ids {
let spec = command_specs().iter().find(|c| c.id == id).unwrap();
for p in std::iter::once(json!({})).chain(junk_params(spec.params, &path)) {
for p in std::iter::once(json!({})).chain(junk_params_for_command(spec, &path)) {
let mut s = Fixture::Multi.session();
if s.execute(make, mp).is_err() {
failures.push(format!("{make} failed on the Multi fixture"));
@@ -1217,7 +1326,7 @@ fn text_commands_with_junk_params_on_inline_graphics() {
}
for id in ["text.insertInline", "text.editRange", "text.getRange", "text.setRangeStyle", "type.insert"] {
let spec = command_specs().iter().find(|c| c.id == id).unwrap();
for p in std::iter::once(json!({})).chain(junk_params(spec.params, &path)) {
for p in std::iter::once(json!({})).chain(junk_params_for_command(spec, &path)) {
run(id, &p);
}
}
+77
View File
@@ -4330,6 +4330,17 @@ proptest! {
survive("mutated .ai art styles", || Some(vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, false, 1.0).0))?;
survive("mutated .ai art styles, trusted", || Some(vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, true, 1.0).0))?;
}
/// A `.ai` whose brushes, as the writer writes them, are damaged: the brush art with its frame,
/// the brush manager's order, the brushes' parameters, a brushed path's style and its object, cut
/// short or edited.
#[test]
fn ai_written_brushes_never_panic(cut in 0usize..BRUSHES_FUZZ_CHARS, edits in prop::collection::vec((0usize..BRUSHES_FUZZ_CHARS, prop::sample::select(vec!['0', '1', '9', '-', '.', ' ', '\n', '(', ')', '/', ':', ';', ',', '%', '_', 'u', 'U', 'n', 'X', 'W'])), 0..12)) {
let text = mutate_text(brushes_text(), cut, &edits);
let private = [b"%AI24_ZStandard_Data".as_slice(), &zstd(&text)].concat();
survive("mutated .ai brushes", || Some(vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, false, 1.0).0))?;
survive("mutated .ai brushes, trusted", || Some(vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, true, 1.0).0))?;
}
}
/// The range of [`ai_written_styles_never_panic`]'s cuts and edits: past the end of [`styles_text`].
@@ -4442,6 +4453,72 @@ fn the_symbol_library_fuzz_data_opens_with_its_symbols() {
assert_eq!(names, ["S2", "S1"], "{warnings:?}");
}
/// The range of [`ai_written_brushes_never_panic`]'s cuts and edits: past the end of [`brushes_text`].
const BRUSHES_FUZZ_CHARS: usize = 48_000;
/// The editing data VectorCraft writes for a document whose brushes are a Calligraphic brush, a
/// Scatter brush in Tints and an Art brush in Tints (each art a wide block over a narrow one), with a
/// path drawn with the Calligraphic brush and one with the Art brush.
fn brushes_text() -> &'static str {
static TEXT: std::sync::OnceLock<String> = std::sync::OnceLock::new();
TEXT.get_or_init(|| {
use std::sync::Arc;
use vectorcraft_brush::{ArtBrush, Brush, BrushKind, Calligraphic, Colorization, Scatter, Variation};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Node, NodeId};
use vectorcraft_geom::{Rect, shapes};
let block = |id: u64, r: Rect| {
Arc::new(Node::path(NodeId(id), shapes::rectangle(r), Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0)))
};
let art = || Node::group(NodeId(1), vec![block(2, Rect::new(0.0, 0.0, 40.0, 4.0)), block(3, Rect::new(0.0, 4.0, 10.0, 8.0))]);
let nib = Calligraphic {
angle: 30.0,
roundness: 40.0,
size: 6.0,
variation: [20.0, 10.0, 2.0],
modes: Some([Variation::Rotation, Variation::Fixed, Variation::Pressure]),
};
let lib = [
Brush { name: "Nib".into(), kind: BrushKind::Calligraphic(nib) },
Brush { name: "Spray".into(), kind: BrushKind::Scatter(Scatter { art: art(), colorization: Colorization::Tints, ..Scatter::default() }) },
Brush { name: "Ribbon".into(), kind: BrushKind::Art(ArtBrush { art: art(), colorization: Colorization::Tints, ..ArtBrush::default() }) },
];
let mut doc = Document::new(200.0, 100.0);
vectorcraft_brush::store(&mut doc, &lib);
let layer = doc.layers[0].id;
for (brush, y) in [("Nib", 30.0), ("Ribbon", 70.0)] {
let mut line = Node::path(
doc.alloc_id(),
shapes::line((10.0, y).into(), (190.0, y).into()),
Appearance::basic(Paint::None, Paint::solid(Color::rgb(1.0, 0.0, 0.0)), 1.0),
);
line.appearance.stroke_mut().unwrap().brush = Some(brush.into());
doc.insert(Some(layer), usize::MAX, line).unwrap();
}
let out = vectorcraft_eps::export_ai_editing(&doc, &vectorcraft_eps::AiEditingOptions::default()).unwrap();
String::from_utf8(out.program).unwrap()
})
}
/// The data [`ai_written_brushes_never_panic`] damages, as it is, opens with its brushes and its
/// brushed paths live, and the property's cuts and edits reach all of it.
#[test]
fn the_written_brushes_fuzz_data_opens_live() {
let text = brushes_text();
assert!(text.chars().count() < BRUSHES_FUZZ_CHARS, "{}", text.chars().count());
for mark in ["%AI8_BeginBrushPattern", "%AI8_BeginPluginObject", "%AI9_BeginArtStyles", "/GObjRef :", "%AI5_BeginLayer", "\n1 (Anon"] {
assert!(text.replace("\r\n", "\n").contains(mark), "{mark}");
}
let private = [b"%AI24_ZStandard_Data".as_slice(), &zstd(text)].concat();
let (d, warnings, layered) = vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, true, 1.0);
assert!(layered, "{warnings:?}");
let names: Vec<String> = vectorcraft_brush::library(&d).into_iter().map(|b| b.name).collect();
assert_eq!(names, ["Nib", "Spray", "Ribbon"]);
let art = d.layers[0].children().unwrap();
let brushes: Vec<Option<&str>> = art.iter().map(|n| n.appearance.stroke().and_then(|s| s.brush.as_deref())).collect();
assert_eq!(brushes, [Some("Nib"), Some("Ribbon")]);
}
/// Editing data with symbols (S2's art holds an instance of S1, F's holds non-native art), the
/// symbol list and a layer of instances, as the format writes them.
fn symbols_text() -> String {
+19 -3
View File
@@ -133,6 +133,16 @@
//! A fill filter fills by the non-zero rule (`0 /Bool (UseEvenOdd)`), so a filled object that
//! fills by the even-odd rule is written as its drawn look. A style is written only when the
//! reader reads it back as the object's appearance (or the graphic style's).
//! - Brushes, as the reader reads them (`brush.rs`, `style.rs`): the Brushes panel's brushes as
//! plug-in objects in a non-printing block after the symbols (`%AI8_BeginPluginObject`, the
//! plug-in's name, the brush's name, its parameters in strings that `-` continues and `.` ends),
//! after the brush manager's order of them; the art of Scatter and Art brushes in a non-printing
//! block before the symbols (`%AI8_BeginBrushPattern`, its name, a group of an unpainted frame at
//! the art's bounds and the art, or the art alone when it has no width or height), when the
//! document has brushes of its own or an object is written with one.
//! A path or compound path with a brush the reader reads live is written with an art style whose
//! stroke is the brush's filter (`writer::brushes`). A brush is written only when the reader reads
//! it back with its settings.
//!
//! Lines end in CR LF. Strings are written in UTF-8. Art space is ruler space: y up, its origin at
//! the first artboard's top-left corner. On the canvas ([`CANVAS_SIZE`] points square, y down) the
@@ -168,9 +178,10 @@
//! tiles and the placement of pattern swatches that move, turn or scale their pattern, the opacity and blending modes of single fills and strokes, opacity masks on
//! layers and opacity masks nested too deep, and, on objects written without an art style, live
//! effects other than geometry effects left out; graphic styles the reader wouldn't read, links to
//! graphic styles on objects not written with them, and every art style on a large canvas, are left
//! out; art past [`crate::import::MAX_EDITING_OBJECTS`] objects in all (the most the reader reads),
//! counted as the reader counts them, is left out.
//! graphic styles on objects not written with them, brushes the reader wouldn't read back, and every
//! art style and brush on a large canvas, are left out; art past
//! [`crate::import::MAX_EDITING_OBJECTS`] objects in all (the most the reader reads), counted as the
//! reader counts them, is left out.
//!
//! The data streams hold the program compressed with Zstandard after `%AI24_ZStandard_Data`, with
//! the version numbers of the newest files users sent ([`private_data`]).
@@ -288,6 +299,7 @@ fn export_within(doc: &Document, o: &AiEditingOptions, max_objects: usize) -> Re
let mut w = Writer::new(doc, to_art, origin);
// On a large canvas the layers' symbol instances are written as their art.
w.symbols_live = scale == 1.0;
w.brushes_live = scale == 1.0;
w.symbol_doc = symbol_doc;
w.max_objects = max_objects;
w.reserve_swatch_gradients();
@@ -305,6 +317,8 @@ fn export_within(doc: &Document, o: &AiEditingOptions, max_objects: usize) -> Re
}
// The symbols no instance uses too; their art adds definitions.
w.symbols();
// The brushes, once the layers have said whether an object is written with one.
let (brush_art, brush_objects) = w.brush_blocks();
// The palette first: its gradient and pattern swatches add definitions.
let mut palette = String::new();
w.palette(&mut palette);
@@ -323,7 +337,9 @@ fn export_within(doc: &Document, o: &AiEditingOptions, max_objects: usize) -> Re
let mut s = header.clone();
s.push_str("%%BeginProlog\n%%EndProlog\n%%BeginSetup\n");
w.definitions(&mut s);
s.push_str(&brush_art);
w.symbol_definitions(&mut s);
s.push_str(&brush_objects);
w.art_styles(&mut s);
s.push_str(&palette);
w.art_style_list(&mut s);
+933 -2
View File
@@ -747,6 +747,7 @@ fn art_the_slice_does_not_cover_is_written_as_plain_paths() {
assert_eq!(layer[2].visual_bounds().map(|b| (r3(b.x0), r3(b.y0), r3(b.x1), r3(b.y1))), Some((r3(100.0), r3(10.0), r3(120.0), r3(20.0))));
}
/// A brushed stroke the reader reads as its drawn look (a Scatter brush's) is written as its brush's art.
#[test]
fn brushed_strokes_are_written_as_their_brush_art() {
let mut doc = Document::new(200.0, 100.0);
@@ -756,11 +757,11 @@ fn brushed_strokes_are_written_as_their_brush_art() {
shapes::line((20.0, 50.0).into(), (180.0, 50.0).into()),
Appearance::basic(Paint::None, solid(Color::rgb(1.0, 0.0, 0.0)), 4.0),
);
line.appearance.stroke_mut().unwrap().brush = Some("3 pt. Round".into());
line.appearance.stroke_mut().unwrap().brush = Some("Dots".into());
doc.insert(Some(layer), usize::MAX, line).unwrap();
let pieces = vectorcraft_brush::stroke_pieces(
&doc,
&vectorcraft_brush::find(&doc, "3 pt. Round").unwrap(),
&vectorcraft_brush::find(&doc, "Dots").unwrap(),
&shapes::line((20.0, 50.0).into(), (180.0, 50.0).into()).to_bezpath(),
doc.layers[0].children().unwrap()[0].appearance.stroke().unwrap(),
);
@@ -895,6 +896,7 @@ fn counted() -> Vec<(&'static str, Document)> {
("styles", styles_document()),
("painted clips", painted_clips()),
("blend", blend_doc()),
("brushes", brushes_document()),
]
}
@@ -6911,6 +6913,28 @@ fn a_link_to_a_style_that_moves_the_outline_is_kept_where_the_reader_reads_it()
assert!(n.extras().mask.is_some(), "{n:?}");
}
/// An object linked to a graphic style that doesn't fit within the object limit is left out with
/// the limit's warning and the warning about links left out.
#[test]
fn a_linked_object_past_the_object_limit_warns_that_its_link_is_left_out() {
let mut doc = Document::new(200.0, 100.0);
let ap = Appearance { effects: vec![drop_shadow()], ..Appearance::basic(black_fill(), Paint::None, 0.0) };
let mut g = vectorcraft_doc::GraphicStyle::new("Shadowed", ap.clone());
g.id = 9;
doc.graphic_styles.push(g);
// Room for everything but the object.
let room = crate::import::objects_read(&export_ai_editing(&doc, &opts()).unwrap().program).unwrap();
let mut n = Node::path(doc.alloc_id(), shapes::rectangle(Rect::new(10.0, 10.0, 50.0, 40.0)), ap);
n.extras_mut().graphic_style = Some(9);
put(&mut doc, n);
let all = export_ai_editing(&doc, &opts()).unwrap();
assert!(!all.warnings.iter().any(|w| w == writer::OBJECT_LIMIT || w == writer::STYLE_LINKS), "{:?}", all.warnings);
let out = export_within(&doc, &opts(), room).unwrap();
for w in [writer::OBJECT_LIMIT, writer::STYLE_LINKS] {
assert!(out.warnings.iter().any(|x| x == w), "{w}: {:?}", out.warnings);
}
}
/// Twist and Transform on an object that isn't linked to a graphic style are not written as a style
/// of its own: the object reads back without live effects.
#[test]
@@ -7258,6 +7282,772 @@ fn a_large_canvas_writes_every_object_as_its_look() {
assert!((p.x - 10.0).abs() < 1e-2 && (p.y - 10.0).abs() < 1e-2, "{p:?}");
}
// ---------- brushes ----------
/// Brush art: a wide block with a narrow one below it (y down), filled black.
fn brush_art_node() -> Node {
let block =
|id: u64, r: Rect| Arc::new(Node::path(vectorcraft_doc::NodeId(id), shapes::rectangle(r), Appearance::basic(black_fill(), Paint::None, 0.0)));
Node::group(vectorcraft_doc::NodeId(1), vec![block(2, Rect::new(0.0, 0.0, 40.0, 4.0)), block(3, Rect::new(0.0, 4.0, 10.0, 8.0))])
}
/// A Calligraphic brush varying with the barrel's rotation and the pen's pressure, a Scatter brush in
/// Tints, an Art brush in Tints and one that keeps its art's colors.
fn brush_library() -> Vec<vectorcraft_brush::Brush> {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind, Calligraphic, Colorization, Scatter, Variation};
let art = |colorization| BrushKind::Art(ArtBrush { art: brush_art_node(), colorization, ..ArtBrush::default() });
vec![
Brush {
name: "Nib".into(),
kind: BrushKind::Calligraphic(Calligraphic {
angle: 30.0,
roundness: 40.0,
size: 6.0,
variation: [20.0, 10.0, 2.0],
modes: Some([Variation::Rotation, Variation::Fixed, Variation::Pressure]),
}),
},
Brush {
name: "Spray".into(),
kind: BrushKind::Scatter(Scatter {
art: brush_art_node(),
size: (50.0, 150.0),
spacing: (120.0, 200.0),
scatter: (-25.0, 25.0),
rotation: (-45.0, 30.0),
rotation_relative_to_path: true,
colorization: Colorization::Tints,
modes: Some([Variation::Random, Variation::Fixed, Variation::Pressure, Variation::Random]),
}),
},
Brush { name: "Ribbon".into(), kind: art(Colorization::Tints) },
Brush { name: "Plain ribbon".into(), kind: art(Colorization::None) },
]
}
/// A path stroked red at `width` with the brush `brush`, on the first layer of `doc`.
fn brushed(doc: &mut Document, brush: &str, from: (f64, f64), to: (f64, f64), width: f64) {
let mut line =
Node::path(doc.alloc_id(), shapes::line(from.into(), to.into()), Appearance::basic(Paint::None, solid(Color::rgb(1.0, 0.0, 0.0)), width));
line.appearance.stroke_mut().unwrap().brush = Some(brush.into());
put(doc, line);
}
/// [`brush_library`] and a path with the Calligraphic brush and one with the Art brush in Tints.
fn brushes_document() -> Document {
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &brush_library());
brushed(&mut doc, "Nib", (20.0, 50.0), (280.0, 60.0), 2.0);
brushed(&mut doc, "Ribbon", (20.0, 120.0), (280.0, 150.0), 1.5);
doc
}
/// Brush art `n` as a tree to compare with [`same_tree`]: each object's kind, its anchors and handles,
/// the fills and strokes that paint (a stroke with its width), and its members in order.
fn art_tree(n: &Node) -> serde_json::Value {
let kind = match &n.kind {
NodeKind::Path { .. } => "path",
NodeKind::Compound { .. } => "compound",
NodeKind::Group { clip: false, .. } => "group",
_ => "other",
};
let anchors: Vec<[f64; 6]> = match &n.kind {
NodeKind::Path { path, .. } => {
path.subpaths.iter().flat_map(|sp| sp.anchors.iter().map(|a| [a.h_in.x, a.h_in.y, a.p.x, a.p.y, a.h_out.x, a.h_out.y])).collect()
}
_ => vec![],
};
let paints: Vec<serde_json::Value> = n
.appearance
.items
.iter()
.filter(|i| !i.paint().is_none())
.map(|i| match i {
AppearanceItem::Fill(f) => serde_json::json!(["fill", f.paint]),
AppearanceItem::Stroke(s) => serde_json::json!(["stroke", s.paint, s.width]),
})
.collect();
let members: Vec<serde_json::Value> = n.children().map(|c| c.iter().map(|m| art_tree(m)).collect()).unwrap_or_default();
serde_json::json!({"kind": kind, "anchors": anchors, "paints": paints, "members": members})
}
/// Are trees `a` and `b` ([`art_tree`]) the same but for numbers within the written numbers'
/// precision (1/1000)?
fn same_tree(a: &serde_json::Value, b: &serde_json::Value) -> bool {
use serde_json::Value;
match (a, b) {
(Value::Number(x), Value::Number(y)) => (x.as_f64().unwrap() - y.as_f64().unwrap()).abs() <= 1e-3,
(Value::Array(x), Value::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| same_tree(p, q)),
(Value::Object(x), Value::Object(y)) => x.len() == y.len() && x.iter().all(|(k, v)| y.get(k).is_some_and(|w| same_tree(v, w))),
_ => a == b,
}
}
/// The document's brushes come back in the Brushes panel's order with their settings and art: the
/// Calligraphic brush's channels, the Scatter brush's ranges, modes and Tints, the Art brushes'
/// colorizations.
#[test]
fn brushes_are_read_back_with_their_settings() {
use vectorcraft_brush::BrushKind;
let doc = brushes_document();
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let text = program(&doc);
assert_eq!(text.matches("%AI8_BeginPluginObject").count(), 5, "the manager's order and four brushes");
assert_eq!(text.matches("%AI8_BeginBrushPattern").count(), 3);
let back = vectorcraft_brush::library(&read_back(&doc));
let lib = brush_library();
assert_eq!(back.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), ["Nib", "Spray", "Ribbon", "Plain ribbon"]);
assert_eq!(back[0], lib[0]);
let (BrushKind::Scatter(got), BrushKind::Scatter(want)) = (&back[1].kind, &lib[1].kind) else { panic!("scatter") };
let near = |a: (f64, f64), b: (f64, f64)| (a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3;
assert!(
near(got.size, want.size) && near(got.spacing, want.spacing) && near(got.scatter, want.scatter) && near(got.rotation, want.rotation),
"{got:?}"
);
assert_eq!((got.modes, got.colorization, got.rotation_relative_to_path), (want.modes, want.colorization, true));
let (g, w) = (art_tree(&got.art), art_tree(&want.art));
assert!(same_tree(&g, &w), "the art without its frame, with its paint and members in order: {g:#} for {w:#}");
for (i, colorization) in [(2, vectorcraft_brush::Colorization::Tints), (3, vectorcraft_brush::Colorization::None)] {
let BrushKind::Art(a) = &back[i].kind else { panic!("art") };
assert_eq!(a.colorization, colorization);
let (g, w) = (art_tree(&a.art), art_tree(&brush_art_node()));
assert!(same_tree(&g, &w), "the narrow block stays below the wide one, and no frame stays: {g:#} for {w:#}");
let BrushKind::Art(want) = &lib[i].kind else { panic!("art") };
assert_eq!(ArtBrushOptions::of(a), ArtBrushOptions::of(want));
}
}
/// An Art brush's options, without its art.
#[derive(Debug, PartialEq)]
struct ArtBrushOptions(serde_json::Value);
impl ArtBrushOptions {
fn of(a: &vectorcraft_brush::ArtBrush) -> Self {
let mut v = serde_json::to_value(a).unwrap();
v.as_object_mut().unwrap().remove("art");
Self(v)
}
}
/// A path with the Calligraphic brush, and one with an Art brush in Tints whose art bends along the
/// path, come back as those paths with the brush on their stroke at its weight, not as their drawn
/// look; a path with the Art brush that keeps its art's colors comes back as its drawn look.
#[test]
fn brushed_paths_are_read_back_brushed() {
let mut doc = brushes_document();
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::STROKES), "{:?}", out.warnings);
let back = read_back(&doc);
let art = back.layers[0].children().unwrap();
assert_eq!(art.len(), 2);
for (n, (brush, width)) in art.iter().zip([("Nib", 2.0), ("Ribbon", 1.5)]) {
assert!(matches!(n.kind, NodeKind::Path { .. }), "{brush}: the path, not its look: {n:#?}");
let st = n.appearance.stroke().unwrap();
assert_eq!((st.brush.as_deref(), st.width, st.paint.color()), (Some(brush), width, Some(Color::rgb(1.0, 0.0, 0.0))));
assert!(n.appearance.fill().is_none_or(|f| f.paint.is_none()));
}
let ours = doc.layers[0].children().unwrap();
assert_eq!(art[0].path_data(), ours[0].path_data());
assert_eq!(art[1].path_data(), ours[1].path_data());
brushed(&mut doc, "Plain ribbon", (20.0, 180.0), (280.0, 180.0), 1.0);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::STROKES), "{:?}", out.warnings);
assert!(matches!(read_back(&doc).layers[0].children().unwrap()[2].kind, NodeKind::Group { .. }));
}
/// A compound path with the Calligraphic brush comes back as that compound path with the brush on its
/// stroke; a filled ellipse with it comes back with its fill and the brush.
#[test]
fn brushed_compound_and_filled_paths_are_read_back_brushed() {
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &brush_library());
let mut stroke = StrokeLayer::new(solid(Color::rgb(1.0, 0.0, 0.0)), 2.0);
stroke.brush = Some("Nib".into());
let ring = ring(&mut doc, Appearance { items: vec![AppearanceItem::Stroke(stroke.clone())], effects: vec![], contents_index: None });
put(&mut doc, ring);
let fill = vectorcraft_doc::FillLayer::new(solid(Color::rgb(0.2, 0.6, 0.3)));
let ap = Appearance { items: vec![AppearanceItem::Fill(fill), AppearanceItem::Stroke(stroke)], effects: vec![], contents_index: None };
let ellipse = Node::path(doc.alloc_id(), shapes::ellipse(Rect::new(20.0, 120.0, 140.0, 180.0)), ap);
put(&mut doc, ellipse);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::STROKES || w == writer::BRUSHES), "{:?}", out.warnings);
let back = read_back(&doc);
let (art, ours) = (back.layers[0].children().unwrap(), doc.layers[0].children().unwrap());
assert!(matches!(art[0].kind, NodeKind::Compound { .. }), "the compound path, not its look: {:#?}", art[0]);
assert!(same_tree(&art_tree(&art[0])["members"], &art_tree(&ours[0])["members"]), "{:#?}", art[0]);
assert!(matches!(art[1].kind, NodeKind::Path { .. }), "the ellipse, not its look: {:#?}", art[1]);
assert!(same_tree(&art_tree(&art[1])["anchors"], &art_tree(&ours[1])["anchors"]), "{:#?}", art[1]);
assert_eq!(art[1].appearance.fill().and_then(|f| f.paint.color()), Some(Color::rgb(0.2, 0.6, 0.3)));
for n in art {
let st = n.appearance.stroke().unwrap();
assert_eq!((st.brush.as_deref(), st.width), (Some("Nib"), 2.0));
}
}
/// A path with an Art brush in Tints whose art doesn't bend along the path (its art has a painted
/// stroke) comes back as its drawn look, with the stroke warning; the brush itself comes back.
#[test]
fn an_art_brush_whose_art_doesnt_bend_keeps_its_paths_look() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind, Colorization};
let mut art = brush_art_node();
if let Some(c) = art.children_mut() {
for m in c.iter_mut() {
Arc::make_mut(m).appearance = Appearance::basic(black_fill(), black_fill(), 1.0).into();
}
}
let brush =
Brush { name: "Stroked ribbon".into(), kind: BrushKind::Art(ArtBrush { art, colorization: Colorization::Tints, ..ArtBrush::default() }) };
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, std::slice::from_ref(&brush));
brushed(&mut doc, "Stroked ribbon", (20.0, 120.0), (280.0, 150.0), 1.0);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::STROKES), "{:?}", out.warnings);
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = read_back(&doc);
assert!(matches!(back.layers[0].children().unwrap()[0].kind, NodeKind::Group { .. }));
let lib = vectorcraft_brush::library(&back);
let (BrushKind::Art(got), BrushKind::Art(want)) = (&lib[0].kind, &brush.kind) else { panic!("art") };
assert!(same_tree(&art_tree(&got.art), &art_tree(&want.art)), "{:#?}", got.art);
}
/// Settings the other tests don't use come back: a Calligraphic brush varying with tilt and bearing,
/// a Scatter brush keeping its art's colors whose rotation doesn't follow the path, and brushes whose
/// modes aren't given (the reader gives them, the same ones).
#[test]
fn more_brush_settings_are_read_back() {
use vectorcraft_brush::{Brush, BrushKind, Calligraphic, Colorization, Scatter, Variation};
let tilted = Calligraphic {
angle: -40.0,
roundness: 75.0,
size: 9.0,
variation: [10.0, 5.0, 3.0],
modes: Some([Variation::Tilt, Variation::Bearing, Variation::Random]),
};
let scatter = Scatter {
art: brush_art_node(),
size: (80.0, 80.0),
spacing: (100.0, 100.0),
scatter: (0.0, 0.0),
rotation: (15.0, 15.0),
rotation_relative_to_path: false,
colorization: Colorization::None,
modes: Some([Variation::Tilt, Variation::Bearing, Variation::Fixed, Variation::Rotation]),
};
let lib = vec![
Brush { name: "Tilted".into(), kind: BrushKind::Calligraphic(tilted.clone()) },
Brush { name: "Still".into(), kind: BrushKind::Scatter(scatter.clone()) },
Brush { name: "Unset nib".into(), kind: BrushKind::Calligraphic(Calligraphic { modes: None, ..tilted }) },
Brush { name: "Unset spray".into(), kind: BrushKind::Scatter(Scatter { modes: None, ..scatter }) },
];
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &lib);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = vectorcraft_brush::library(&read_back(&doc));
assert_eq!(back.len(), lib.len());
let near = |a: (f64, f64), b: (f64, f64)| (a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3;
for (got, want) in back.iter().zip(&lib) {
assert_eq!(got.name, want.name);
match (&got.kind, &want.kind) {
(BrushKind::Calligraphic(g), BrushKind::Calligraphic(w)) => {
assert_eq!(g.modes(), w.modes(), "{}", want.name);
assert_eq!(Calligraphic { modes: None, ..g.clone() }, Calligraphic { modes: None, ..w.clone() }, "{}", want.name);
}
(BrushKind::Scatter(g), BrushKind::Scatter(w)) => {
assert_eq!(g.modes(), w.modes(), "{}", want.name);
assert!(near(g.size, w.size) && near(g.spacing, w.spacing) && near(g.scatter, w.scatter) && near(g.rotation, w.rotation), "{g:?}");
assert_eq!((g.colorization, g.rotation_relative_to_path), (Colorization::None, false), "{}", want.name);
assert!(same_tree(&art_tree(&g.art), &art_tree(&w.art)), "{}: {:#?}", want.name, g.art);
}
_ => panic!("{}: {got:?}", want.name),
}
}
}
/// Brush art without width or height, a straight stroked line, comes back as that line, without a
/// frame or a group around it: a Scatter brush's horizontal line and an Art brush's vertical one.
#[test]
fn brush_art_of_a_straight_line_comes_back_as_the_line() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind, Scatter};
let line = |id: u64, to: (f64, f64)| {
Node::path(vectorcraft_doc::NodeId(id), shapes::line((0.0, 0.0).into(), to.into()), Appearance::basic(Paint::None, black_fill(), 2.0))
};
let lib = vec![
Brush { name: "Dash".into(), kind: BrushKind::Scatter(Scatter { art: line(1, (40.0, 0.0)), ..Scatter::default() }) },
Brush { name: "Post".into(), kind: BrushKind::Art(ArtBrush { art: line(2, (0.0, 40.0)), ..ArtBrush::default() }) },
];
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &lib);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = vectorcraft_brush::library(&read_back(&doc));
assert_eq!(back.len(), 2);
for (got, want) in back.iter().zip(&lib) {
let art = |b: &Brush| match &b.kind {
BrushKind::Scatter(s) => s.art.clone(),
BrushKind::Art(a) => a.art.clone(),
_ => panic!("{}", b.name),
};
let (g, w) = (art_tree(&art(got)), art_tree(&art(want)));
assert!(same_tree(&g, &w), "{}: {g:#} for {w:#}", want.name);
}
}
/// Brush art of a path with several subpaths is written as a compound path, which the reader reads as
/// a compound path of one path for each subpath, and is weighed as the reader weighs that against the
/// art it copies into one file's brushes: of two Art brushes whose art is a path of 30,000 squares,
/// the second is left out with a warning, so that what is written is what comes back.
#[test]
fn brush_art_of_a_path_with_subpaths_is_weighed_as_it_is_read() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind};
let squares = |n: u32| {
let mut path = PathData::default();
for i in 0..n {
let x = f64::from(i % 200) * 2.0;
let y = f64::from(i / 200) * 2.0;
path.subpaths.extend(shapes::rectangle(Rect::new(x, y, x + 1.0, y + 1.0)).subpaths);
}
Node::path(vectorcraft_doc::NodeId(1), path, Appearance::basic(black_fill(), Paint::None, 0.0))
};
let brush = |name: &str, n: u32| Brush { name: name.into(), kind: BrushKind::Art(ArtBrush { art: squares(n), ..ArtBrush::default() }) };
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &[brush("Two", 2)]);
let back = vectorcraft_brush::library(&read_back(&doc));
let BrushKind::Art(a) = &back[0].kind else { panic!("art") };
let tree = art_tree(&a.art);
assert_eq!(tree["kind"], "compound", "{tree:#}");
assert_eq!(tree["members"].as_array().map(Vec::len), Some(2), "{tree:#}");
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &[brush("Many 1", 30_000), brush("Many 2", 30_000)]);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let names: Vec<String> = vectorcraft_brush::library(&read_back(&doc)).into_iter().map(|b| b.name).collect();
assert_eq!(names, ["Many 1"]);
assert_eq!(program(&doc).matches("%AI8_BeginBrushPattern").count(), 1);
}
/// Brush art that is a compound path is written as one path of all its members' subpaths, and is
/// weighed as the reader reads that back: a compound path of 24,000 members of two squares each is
/// read as 48,000 paths, within what the reader copies into one file's brushes, so the brush is
/// written without a warning; a compound path with one square comes back as one path.
#[test]
fn brush_art_of_a_compound_path_is_weighed_as_it_is_read() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind};
let square = |i: u32| {
let x = f64::from(i % 400) * 2.0;
let y = f64::from(i / 400) * 2.0;
shapes::rectangle(Rect::new(x, y, x + 1.0, y + 1.0)).subpaths
};
let compound = |members: u32, per: u32| {
let children = (0..members)
.map(|m| {
let path = PathData::new((0..per).flat_map(|k| square(m * per + k)).collect());
Arc::new(Node::path(vectorcraft_doc::NodeId(2), path, Appearance::basic(black_fill(), Paint::None, 0.0)))
})
.collect();
let mut n = Node::path(vectorcraft_doc::NodeId(1), PathData::default(), Appearance::basic(black_fill(), Paint::None, 0.0));
n.kind = NodeKind::Compound { children, rule: FillRule::NonZero };
n
};
let brush = |name: &str, art: Node| Brush { name: name.into(), kind: BrushKind::Art(ArtBrush { art, ..ArtBrush::default() }) };
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &[brush("One", compound(1, 1))]);
let back = vectorcraft_brush::library(&read_back(&doc));
let BrushKind::Art(a) = &back[0].kind else { panic!("art") };
assert_eq!(art_tree(&a.art)["kind"], "path", "{:#}", art_tree(&a.art));
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &[brush("Many", compound(24_000, 2))]);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = vectorcraft_brush::library(&read_back(&doc));
assert_eq!(back.len(), 1);
let BrushKind::Art(a) = &back[0].kind else { panic!("art") };
assert_eq!(a.art.children().map(Vec::len), Some(48_000));
}
/// A path with a drop shadow and the Calligraphic brush keeps the brush and the effect, and its drawn
/// look doesn't warn about the brushed stroke; a group with a drop shadow whose member has the Scatter
/// brush still warns, as the member is written as its brush's art.
#[test]
fn a_brushed_path_with_effects_keeps_its_brush_without_the_stroke_warning() {
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &brush_library());
let mut line = Node::path(
doc.alloc_id(),
shapes::line((20.0, 50.0).into(), (280.0, 60.0).into()),
Appearance::basic(Paint::None, solid(Color::rgb(1.0, 0.0, 0.0)), 2.0),
);
line.appearance.stroke_mut().unwrap().brush = Some("Nib".into());
line.appearance.effects = vec![drop_shadow()];
put(&mut doc, line);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::STROKES), "{:?}", out.warnings);
let back = read_back(&doc);
let n = &back.layers[0].children().unwrap()[0];
assert!(matches!(n.kind, NodeKind::Path { .. }), "the path, not its look: {n:#?}");
assert_eq!(n.appearance.stroke().and_then(|s| s.brush.as_deref()), Some("Nib"));
assert_eq!(n.appearance.effects.len(), 1);
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &brush_library());
let mut member = Node::path(
doc.alloc_id(),
shapes::line((20.0, 50.0).into(), (280.0, 60.0).into()),
Appearance::basic(Paint::None, solid(Color::rgb(1.0, 0.0, 0.0)), 2.0),
);
member.appearance.stroke_mut().unwrap().brush = Some("Spray".into());
let mut g = group(&mut doc, vec![member], false);
g.appearance.effects = vec![drop_shadow()];
put(&mut doc, g);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::STROKES), "{:?}", out.warnings);
}
/// A brushed stroke that paints nothing isn't kept by an art style: a path with only such a stroke is
/// written without a style, and a document whose brushes are a new document's writes no brushes.
#[test]
fn a_brushed_stroke_that_paints_nothing_writes_no_brushes() {
let mut doc = Document::new(300.0, 200.0);
let mut line =
Node::path(doc.alloc_id(), shapes::line((20.0, 50.0).into(), (280.0, 60.0).into()), Appearance::basic(Paint::None, Paint::None, 1.0));
line.appearance.stroke_mut().unwrap().brush = Some("3 pt. Round".into());
put(&mut doc, line);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let text = program(&doc);
assert!(!text.contains("%AI8_BeginPluginObject"), "no brushes");
assert!(!text.contains("/KnownStyle"), "no art style");
}
/// The lines of `program` that hold brushes and what is drawn with them: the brush art, the plug-in
/// objects, the art styles and the layers.
fn brush_lines(program: &str) -> Vec<&str> {
let mut out = vec![];
let mut inside = false;
for line in program.lines() {
if ["%AI8_BeginBrushPattern", "%AI8_BeginPluginObject", "%AI9_BeginArtStyles", "%%EndSetup"].iter().any(|m| line.starts_with(m)) {
inside = true;
}
if inside {
out.push(line);
}
if ["%AI8_EndBrushPattern", "%AI8_EndPluginObject", "%AI9_EndArtStyles"].iter().any(|m| line.starts_with(m)) {
inside = false;
}
}
out
}
/// A document with brushes and brushed paths is written as the same bytes again, and what the reader
/// reads back is written with the same brushes, art styles and layers.
#[test]
fn brushes_write_the_same_bytes_again() {
let doc = brushes_document();
let first = export_ai_editing(&doc, &opts()).unwrap();
assert_eq!(first.program, export_ai_editing(&doc, &opts()).unwrap().program);
let again = String::from_utf8(export_ai_editing(&read_back(&doc), &opts()).unwrap().program).unwrap();
let first = String::from_utf8(first.program).unwrap();
let (again, first) = (brush_lines(&again), brush_lines(&first));
let differ = again.iter().zip(&first).enumerate().find(|(_, (a, b))| a != b);
assert_eq!(differ, None, "the first line that differs");
assert_eq!(again.len(), first.len());
}
/// Brushes the reader wouldn't read back as they are are left out with a warning, each on its own
/// beside a brush that comes back, and each changed from a brush that comes back by the one setting
/// that leaves it out: an Art brush whose art is a group with a fill of its own, a Scatter brush whose
/// art is a path without points, an Art brush whose art is a group without members, Pattern and Bristle
/// brushes, Art brushes flipped along or across, overlapping, at another width, with a width that
/// varies, in another direction or scale, Art and Scatter brushes in Tints and Shades or Hue Shift, a
/// brush whose name holds a slash and a second brush of a name. A brush left out doesn't take its
/// name from a later one.
#[test]
fn brushes_the_reader_cant_read_are_left_out() {
use vectorcraft_brush::{ArtBrush, ArtScale, Bristle, Brush, BrushKind, Colorization, Direction, PatternBrush, Variation};
let lib = brush_library();
let keep = lib[0].clone();
let (BrushKind::Scatter(scatter), BrushKind::Art(art)) = (&lib[1].kind, &lib[2].kind) else { panic!("library") };
let hue = Colorization::HueShift { key: Color::rgb(1.0, 0.0, 0.0) };
let art_with = |f: &dyn Fn(&mut ArtBrush)| {
let mut a = art.clone();
f(&mut a);
BrushKind::Art(a)
};
let mut painted_group = brush_art_node();
painted_group.appearance = Appearance::basic(black_fill(), Paint::None, 0.0).into();
let empty_path = Node::path(vectorcraft_doc::NodeId(1), PathData::new(vec![]), Appearance::basic(black_fill(), Paint::None, 0.0));
let cases: Vec<(&str, BrushKind)> = vec![
("painted group", art_with(&|a| a.art = painted_group.clone())),
("empty path", BrushKind::Scatter(vectorcraft_brush::Scatter { art: empty_path.clone(), ..scatter.clone() })),
("empty group", art_with(&|a| a.art = Node::group(vectorcraft_doc::NodeId(1), vec![]))),
("pattern", BrushKind::Pattern(PatternBrush::default())),
("bristle", BrushKind::Bristle(Bristle::default())),
("flipped along", art_with(&|a| a.flip_along = true)),
("flipped across", art_with(&|a| a.flip_across = true)),
("overlap", art_with(&|a| a.overlap = true)),
("width", art_with(&|a| a.width = 50.0)),
("width varies", art_with(&|a| a.width_mode = Some(Variation::Pressure))),
("direction", art_with(&|a| a.direction = Direction::RightToLeft)),
("proportional", art_with(&|a| a.scale = ArtScale::Proportional)),
("art tints and shades", art_with(&|a| a.colorization = Colorization::TintsAndShades)),
("art hue shift", art_with(&|a| a.colorization = hue)),
(
"scatter tints and shades",
BrushKind::Scatter(vectorcraft_brush::Scatter { colorization: Colorization::TintsAndShades, ..scatter.clone() }),
),
("scatter hue shift", BrushKind::Scatter(vectorcraft_brush::Scatter { colorization: hue, ..scatter.clone() })),
];
let left_out = |extra: Vec<Brush>, why: &str| {
let mut doc = Document::new(300.0, 200.0);
let mut lib = vec![keep.clone()];
lib.extend(extra);
vectorcraft_brush::store(&mut doc, &lib);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{why}: {:?}", out.warnings);
assert_eq!(vectorcraft_brush::library(&read_back(&doc)), std::slice::from_ref(&keep), "{why}");
};
for (why, kind) in cases {
left_out(vec![Brush { name: "Other".into(), kind }], why);
}
left_out(vec![Brush { name: "A/B".into(), ..keep.clone() }], "slash");
left_out(vec![Brush { kind: BrushKind::Bristle(Bristle::default()), ..keep.clone() }], "a second brush of the name");
// A Pattern brush named "X" is left out, so a Calligraphic brush named "X" after it comes back. A
// path with "X" is drawn with the Pattern brush, so it comes back as its drawn look.
let mut doc = Document::new(300.0, 200.0);
let x = Brush { name: "X".into(), ..keep.clone() };
vectorcraft_brush::store(&mut doc, &[Brush { name: "X".into(), kind: BrushKind::Pattern(PatternBrush::default()) }, x.clone()]);
brushed(&mut doc, "X", (20.0, 50.0), (280.0, 60.0), 2.0);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = read_back(&doc);
assert_eq!(vectorcraft_brush::library(&back), [x]);
let n = &back.layers[0].children().unwrap()[0];
assert!(n.appearance.stroke().is_none_or(|s| s.brush.is_none()), "not with the other brush of the name: {n:#?}");
}
/// Brushes past the most the reader reads from one file are left out with a warning: of 4,097
/// Calligraphic brushes, the first 4,096 come back.
#[test]
fn brushes_past_the_readers_count_are_left_out() {
let nib = brush_library().remove(0);
let lib: Vec<vectorcraft_brush::Brush> = (0..4097).map(|i| vectorcraft_brush::Brush { name: format!("Nib {i}"), ..nib.clone() }).collect();
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &lib);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = vectorcraft_brush::library(&read_back(&doc));
assert_eq!(back.len(), 4096);
assert_eq!(back.last().map(|b| b.name.as_str()), Some("Nib 4095"));
}
/// A brush whose art the editing data would change (a stroke inside the path, written as its
/// outline) is left out, also after an object on the layers was already written with that change.
#[test]
fn a_brush_whose_art_would_change_is_left_out() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind};
let inside = |doc: &mut Document| {
let mut n = Node::path(doc.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 8.0)), Appearance::basic(Paint::None, black_fill(), 2.0));
n.appearance.stroke_mut().unwrap().align = vectorcraft_doc::StrokeAlign::Inside;
n
};
let mut doc = Document::new(300.0, 200.0);
let on_layer = inside(&mut doc);
put(&mut doc, on_layer);
let keep = brush_library().remove(0);
let art = inside(&mut doc);
vectorcraft_brush::store(
&mut doc,
&[keep.clone(), Brush { name: "Outlined".into(), kind: BrushKind::Art(ArtBrush { art, ..ArtBrush::default() }) }],
);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::STROKES), "{:?}", out.warnings);
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
assert_eq!(vectorcraft_brush::library(&read_back(&doc)), [keep]);
}
/// Brushes past the art the reader copies into one file's brushes are left out with a warning, so
/// that what is written is what comes back: three Art brushes of 100,000 anchors each, of which the
/// reader keeps two.
#[test]
fn brushes_past_the_readers_art_limit_are_left_out() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind};
let heavy = |id: u64| {
let points: Vec<vectorcraft_geom::Point> =
(0..100_000).map(|i| vectorcraft_geom::Point::new(f64::from(i) / 1000.0, if i % 2 == 0 { 0.0 } else { 4.0 })).collect();
let path = PathData::single(vectorcraft_geom::SubPath::polyline(&points, true));
Node::path(vectorcraft_doc::NodeId(id), path, Appearance::basic(black_fill(), Paint::None, 0.0))
};
let lib: Vec<Brush> =
(1..=3).map(|i| Brush { name: format!("Heavy {i}"), kind: BrushKind::Art(ArtBrush { art: heavy(i), ..ArtBrush::default() }) }).collect();
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &lib);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back: Vec<String> = vectorcraft_brush::library(&read_back(&doc)).into_iter().map(|b| b.name).collect();
assert_eq!(back, ["Heavy 1", "Heavy 2"]);
assert_eq!(program(&doc).matches("%AI8_BeginBrushPattern").count(), 2);
// The art of the brush left out isn't counted: there is room for it all with room for what is read.
let read = crate::import::objects_read(&out.program).unwrap();
let room = export_within(&doc, &opts(), read).unwrap();
assert!(!room.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{read}: {:?}", room.warnings);
}
/// A brush whose art doesn't fit within the object limit is left out with the limit's warning, and
/// what its art took is given back: a later brush whose art fits comes back.
#[test]
fn a_brush_whose_art_passes_the_object_limit_leaves_room_for_the_next() {
use vectorcraft_brush::{ArtBrush, Brush, BrushKind};
let squares = |n: u64| {
let block = |i: u64| {
let x = i as f64 * 10.0;
Arc::new(Node::path(
vectorcraft_doc::NodeId(i + 1),
shapes::rectangle(Rect::new(x, 0.0, x + 5.0, 5.0)),
Appearance::basic(black_fill(), Paint::None, 0.0),
))
};
Node::group(vectorcraft_doc::NodeId(100), (0..n).map(block).collect())
};
let art = |name: &str, n: u64| Brush { name: name.into(), kind: BrushKind::Art(ArtBrush { art: squares(n), ..ArtBrush::default() }) };
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, &[art("Big", 6), art("Small", 2)]);
let all = export_ai_editing(&doc, &opts()).unwrap();
assert!(!all.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{:?}", all.warnings);
let mut small = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut small, &[art("Small", 2)]);
let room = crate::import::objects_read(&export_ai_editing(&small, &opts()).unwrap().program).unwrap();
let out = export_within(&doc, &opts(), room).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{:?}", out.warnings);
assert!(crate::import::objects_read(&out.program).unwrap() <= room);
let mut data = ZSTD_MARKER.to_vec();
data.extend(ruzstd::encoding::compress_to_vec(out.program.as_slice(), ruzstd::encoding::CompressionLevel::Fastest));
let back = crate::ai_alone(&data).unwrap().0;
let names: Vec<String> = vectorcraft_brush::library(&back).into_iter().map(|b| b.name).collect();
assert_eq!(names, ["Small"]);
}
/// A graphic style with a brushed stroke, which is left out, takes no room from the layers' objects:
/// a document with a new document's brushes and no brushed path writes no brush art, so with room for
/// what its layers write, every object comes back.
#[test]
fn a_graphic_style_with_a_brush_takes_no_room_from_the_layers() {
let mut doc = Document::new(300.0, 200.0);
for i in 0..3 {
let x = 20.0 + f64::from(i) * 40.0;
let square =
Node::path(doc.alloc_id(), shapes::rectangle(Rect::new(x, 20.0, x + 30.0, 50.0)), Appearance::basic(black_fill(), Paint::None, 0.0));
put(&mut doc, square);
}
let room = crate::import::objects_read(&export_ai_editing(&doc, &opts()).unwrap().program).unwrap();
let mut stroke = StrokeLayer::new(solid(Color::rgb(1.0, 0.0, 0.0)), 1.0);
stroke.brush = Some("3 pt. Round".into());
let ap = Appearance { items: vec![AppearanceItem::Stroke(stroke)], effects: vec![], contents_index: None };
doc.graphic_styles.push(vectorcraft_doc::GraphicStyle::new("Brushed", ap));
let out = export_within(&doc, &opts(), room).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{room}: {:?}", out.warnings);
let program = String::from_utf8(out.program).unwrap();
assert!(!program.contains("%AI8_BeginBrushPattern"), "no brush art");
}
/// A graphic style whose brushed stroke paints nothing comes back in the Graphic Styles panel.
#[test]
fn a_graphic_style_with_an_unpainted_brushed_stroke_comes_back() {
let mut doc = Document::new(300.0, 200.0);
let mut ap = Appearance::basic(black_fill(), Paint::None, 1.0);
ap.stroke_mut().unwrap().brush = Some("3 pt. Round".into());
doc.graphic_styles.push(vectorcraft_doc::GraphicStyle::new("Unpainted brush", ap));
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::PANEL_STYLES), "{:?}", out.warnings);
assert!(read_back(&doc).graphic_style("Unpainted brush").is_some());
}
/// A brush whose art doesn't fit within the object limit after a path was written with it on its
/// stroke is left out with both warnings, and the path comes back as its drawn look.
#[test]
fn a_brushed_path_whose_brush_art_doesnt_fit_comes_back_as_its_look() {
let ribbon = brush_library().remove(2);
let mut doc = Document::new(300.0, 200.0);
vectorcraft_brush::store(&mut doc, std::slice::from_ref(&ribbon));
brushed(&mut doc, "Ribbon", (20.0, 120.0), (280.0, 150.0), 1.5);
let all = export_ai_editing(&doc, &opts()).unwrap();
assert!(!all.warnings.iter().any(|w| w == writer::OBJECT_LIMIT || w == writer::BRUSHES), "{:?}", all.warnings);
let room = crate::import::objects_read(&all.program).unwrap() - 1;
let out = export_within(&doc, &opts(), room).unwrap();
for w in [writer::OBJECT_LIMIT, writer::BRUSHES] {
assert!(out.warnings.iter().any(|x| x == w), "{w}: {:?}", out.warnings);
}
assert!(crate::import::objects_read(&out.program).unwrap() <= room);
let mut data = ZSTD_MARKER.to_vec();
data.extend(ruzstd::encoding::compress_to_vec(out.program.as_slice(), ruzstd::encoding::CompressionLevel::Fastest));
let back = crate::ai_alone(&data).unwrap().0;
assert!(vectorcraft_brush::library(&back).is_empty());
let n = &back.layers[0].children().unwrap()[0];
assert!(matches!(n.kind, NodeKind::Group { .. }), "the path's drawn look: {n:#?}");
}
/// An empty Brushes panel comes back empty, and a document with a new document's brushes and no
/// brushed path writes no brushes (the reader gives such a file a new document's).
#[test]
fn an_empty_brushes_panel_comes_back_empty() {
let mut doc = Document::new(300.0, 200.0);
assert!(!program(&doc).contains("%AI8_BeginPluginObject"));
assert_eq!(vectorcraft_brush::library(&read_back(&doc)), vectorcraft_brush::library(&doc));
vectorcraft_brush::store(&mut doc, &[]);
assert!(vectorcraft_brush::library(&read_back(&doc)).is_empty());
}
/// A path with one of a new document's brushes writes the brushes the reader reads, and keeps its
/// brush. The new document's Art brush with other options, its Pattern brushes and its Bristle
/// brushes are left out with a warning, so the file opens without them.
#[test]
fn a_new_documents_brush_on_a_path_writes_the_brushes() {
let mut doc = Document::new(300.0, 200.0);
brushed(&mut doc, "3 pt. Round", (20.0, 50.0), (280.0, 60.0), 1.0);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
let back = read_back(&doc);
let n = &back.layers[0].children().unwrap()[0];
assert_eq!(n.appearance.stroke().and_then(|s| s.brush.as_deref()), Some("3 pt. Round"));
let left_out = ["Arrow", "Chain", "Stitches", "Diamonds", "Bristle Round", "Bristle Flat Fan"];
let want: Vec<&str> = vectorcraft_brush::defaults().iter().map(|b| b.name.as_str()).filter(|n| !left_out.contains(n)).collect();
let lib = vectorcraft_brush::library(&back);
assert_eq!(lib.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), want);
assert_eq!(vectorcraft_brush::defaults().len(), want.len() + left_out.len());
}
/// A path with one of a new document's brushes that doesn't fit within the object limit is left
/// out, and no brushes are written: the file opens with a new document's brushes, all of them.
#[test]
fn a_new_documents_brush_on_a_path_past_the_object_limit_writes_no_brushes() {
let empty = Document::new(300.0, 200.0);
let room = crate::import::objects_read(&export_ai_editing(&empty, &opts()).unwrap().program).unwrap();
let mut doc = Document::new(300.0, 200.0);
brushed(&mut doc, "3 pt. Round", (20.0, 50.0), (280.0, 60.0), 1.0);
let out = export_within(&doc, &opts(), room).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::OBJECT_LIMIT), "{:?}", out.warnings);
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
assert!(!String::from_utf8(out.program).unwrap().contains("%AI8_BeginPluginObject"));
}
/// On a large canvas the brushes are left out with a warning, and brushed paths come back as their
/// drawn look.
#[test]
fn a_large_canvas_leaves_the_brushes_out() {
let mut doc = Document::new(20000.0, 100.0);
vectorcraft_brush::store(&mut doc, &brush_library());
brushed(&mut doc, "Nib", (20.0, 50.0), (280.0, 60.0), 2.0);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
assert!(!program(&doc).contains("%AI8_BeginPluginObject"));
assert!(matches!(read_back(&doc).layers[0].children().unwrap()[0].kind, NodeKind::Group { .. }));
// An empty panel is kept, without a warning.
let mut doc = Document::new(20000.0, 100.0);
vectorcraft_brush::store(&mut doc, &[]);
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(!out.warnings.iter().any(|w| w == writer::BRUSHES), "{:?}", out.warnings);
assert!(vectorcraft_brush::library(&read_back(&doc)).is_empty());
}
// ---------- variables ----------
/// A 200 × 100 document with variables: a text variable `name` bound to point type, a visibility
@@ -7676,3 +8466,144 @@ fn diamond_gradients_are_written_as_radial_gradients_through_their_corners() {
let Some(Paint::Gradient(swatch)) = back.swatch("Gem").map(|s| &s.paint) else { panic!("the swatch is lost") };
assert_eq!(swatch.gradient.kind, GradientKind::Radial);
}
/// The data has no spread: a fill that repeats or reflects holds its stops repeated across the
/// shape and reads back looking as the canvas paints it; a swatch holds its stops repeated along
/// its vector; both with a warning.
#[test]
fn spread_gradients_are_written_with_their_stops_repeated() {
use vectorcraft_color::GradientSpread;
for kind in [GradientKind::Linear, GradientKind::Radial] {
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Reflect, repeats: 2, ..Gradient::new(kind, stops) });
let (start, end) = (vectorcraft_geom::Point::new(60.0, 50.0), vectorcraft_geom::Point::new(120.0, 50.0));
g.geom = Some(vectorcraft_color::GradientGeom { start, end, aspect: 1.0, focal: None });
let mut doc = Document::new(200.0, 100.0);
let id = doc.alloc_id();
let l = doc.layers[0].id;
let fill = Paint::Gradient(Box::new(g.clone()));
doc.insert(Some(l), 0, Node::path(id, shapes::rectangle(Rect::new(20.0, 10.0, 180.0, 90.0)), Appearance::basic(fill, Paint::None, 0.0)))
.unwrap();
let mut swatches: Vec<Swatch> = doc.swatches.iter().cloned().collect();
swatches.push(Swatch {
name: "Bands".into(),
paint: Paint::Gradient(Box::new(GradientPaint { geom: None, ..g })),
global: false,
spot: false,
});
doc.swatches = swatches.into();
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(
out.warnings.iter().any(|w| w.contains("gradients that repeat or reflect are written with their stops repeated")),
"{:?}",
out.warnings
);
let back = read_back(&doc);
let st = vectorcraft_testkit::raster::perceptual_diff(
&vectorcraft_testkit::raster::render_artboard(&doc),
&vectorcraft_testkit::raster::render_artboard(&back),
8.0,
);
assert!((st.bad_pixels as f64) < 0.02 * st.pixels as f64, "{kind:?}: {} of {} pixels differ", st.bad_pixels, st.pixels);
let Some(Paint::Gradient(swatch)) = back.swatch("Bands").map(|s| &s.paint) else { panic!("the swatch is lost") };
let colors: Vec<String> = swatch.gradient.stops.iter().map(|s| s.color.to_hex()).collect();
assert_eq!(colors, ["#ff0000", "#0000ff", "#0000ff", "#ff0000"], "{kind:?}");
}
}
/// A stroke's gradient that repeats is written with its stops repeated as far as the stroke's
/// miter joins reach, past the box the gradient is placed on, so a sharp join's tip shows the next
/// run rather than the color the gradient pads with; a straight line, which has no joins, keeps
/// every run within the stops the reader reads.
#[test]
fn a_stroke_spread_gradient_runs_on_into_its_miter_tips() {
use vectorcraft_color::GradientSpread;
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 3, ..Gradient::new(GradientKind::Linear, stops) });
// From the top of the box the gradient is placed on (the path's box grown by half the width).
let (start, end) = (vectorcraft_geom::Point::new(100.0, 15.0), vectorcraft_geom::Point::new(100.0, 85.0));
g.geom = Some(vectorcraft_color::GradientGeom { start, end, aspect: 1.0, focal: None });
let mut app = Appearance::basic(Paint::None, Paint::Gradient(Box::new(g)), 10.0);
for item in &mut app.items {
if let AppearanceItem::Stroke(s) = item {
(s.join, s.miter_limit) = (LineJoin::Miter, 10.0);
}
}
// A V whose apex's miter reaches about 10 pt above it, to y = 9.9.
let pts = [vectorcraft_geom::Point::new(60.0, 90.0), vectorcraft_geom::Point::new(100.0, 20.0), vectorcraft_geom::Point::new(140.0, 90.0)];
let mut doc = Document::new(200.0, 100.0);
let id = doc.alloc_id();
let l = doc.layers[0].id;
doc.insert(Some(l), 0, Node::path(id, PathData::new(vec![vectorcraft_geom::SubPath::polyline(&pts, false)]), app)).unwrap();
let back = read_back(&doc);
let mut geom = None;
back.walk(|n| {
if let Paint::Gradient(g) = n.appearance.stroke_paint() {
geom = g.geom;
}
});
let geom = geom.expect("the stroke keeps a gradient");
assert!(geom.start.y.min(geom.end.y) < 9.9, "the runs start at {:?}", geom);
// A straight line has no joins: its 100 runs, 200 stops, fit the 256 the reader reads.
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 100, ..Gradient::new(GradientKind::Linear, stops) });
let (start, end) = (vectorcraft_geom::Point::new(50.0, 50.0), vectorcraft_geom::Point::new(150.0, 50.0));
g.geom = Some(vectorcraft_color::GradientGeom { start, end, aspect: 1.0, focal: None });
let line = PathData::new(vec![vectorcraft_geom::SubPath::polyline(&[start, end], false)]);
let mut doc = Document::new(200.0, 100.0);
let id = doc.alloc_id();
let l = doc.layers[0].id;
doc.insert(Some(l), 0, Node::path(id, line, Appearance::basic(Paint::None, Paint::Gradient(Box::new(g)), 10.0))).unwrap();
let mut stops = None;
read_back(&doc).walk(|n| {
if let Paint::Gradient(g) = n.appearance.stroke_paint() {
stops = Some(g.gradient.stops.len());
}
});
assert_eq!(stops, Some(200));
}
/// A conic fill (written linear, its stops repeated around its turn), a diamond fill (written
/// radial) and a swatch whose stops repeat more times than the 256 stops the reader reads stay
/// gradients: each holds its stops repeated as far as 256 stops go.
#[test]
fn spread_gradients_past_the_stops_the_reader_reads_stay_gradients() {
use vectorcraft_color::GradientSpread;
let three = || {
vec![
GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)),
GradientStop::new(0.5, Color::rgb(0.0, 1.0, 0.0)),
GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0)),
]
};
for kind in [GradientKind::Conic, GradientKind::Diamond] {
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 100, ..Gradient::new(kind, three()) });
let c = vectorcraft_geom::Point::new(100.0, 50.0);
g.geom = Some(vectorcraft_color::GradientGeom { start: c, end: c + vectorcraft_geom::Vec2::new(40.0, 0.0), aspect: 1.0, focal: None });
let mut doc = Document::new(200.0, 100.0);
let id = doc.alloc_id();
let l = doc.layers[0].id;
let fill = Paint::Gradient(Box::new(g));
doc.insert(Some(l), 0, Node::path(id, shapes::rectangle(Rect::new(20.0, 10.0, 180.0, 90.0)), Appearance::basic(fill, Paint::None, 0.0)))
.unwrap();
let back = read_back(&doc);
let mut stops = None;
back.walk(|n| {
if let Paint::Gradient(g) = n.appearance.fill_paint() {
stops = Some(g.gradient.stops.len());
}
});
let stops = stops.unwrap_or_else(|| panic!("{kind:?}: the gradient is written as a solid color"));
assert!((200..=crate::import::MAX_GRADIENT_STOPS).contains(&stops), "{kind:?}: {stops} stops");
}
// Stops at 0.1 and 0.9 run from 0 to 1 as four: 70 runs are 280 stops.
let stops = vec![GradientStop::new(0.1, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(0.9, Color::rgb(0.0, 0.0, 1.0))];
let g = GradientPaint::new(Gradient { spread: GradientSpread::Reflect, repeats: 70, ..Gradient::new(GradientKind::Linear, stops) });
let mut doc = Document::new(200.0, 100.0);
let mut swatches: Vec<Swatch> = doc.swatches.iter().cloned().collect();
swatches.push(Swatch { name: "Bands".into(), paint: Paint::Gradient(Box::new(g)), global: false, spot: false });
doc.swatches = swatches.into();
let back = read_back(&doc);
let Some(Paint::Gradient(swatch)) = back.swatch("Bands").map(|s| &s.paint) else { panic!("the swatch is lost") };
assert!((200..=crate::import::MAX_GRADIENT_STOPS).contains(&swatch.gradient.stops.len()), "{} stops", swatch.gradient.stops.len());
}
+18 -4
View File
@@ -15,6 +15,7 @@ use vectorcraft_pathops::BoolOp;
use crate::ai_ops::{self, unit};
use crate::ps;
mod brushes;
mod images;
mod paints;
mod styles;
@@ -22,6 +23,8 @@ mod symbols;
mod texts;
mod variables;
#[cfg(test)]
pub(super) use brushes::BRUSHES;
pub(super) use styles::{LARGE_CANVAS_STYLES, style_links, styled_objects};
#[cfg(test)]
pub(super) use styles::{PANEL_EMPTY, PANEL_STYLES, STYLE_LINKS, same_appearance};
@@ -51,7 +54,7 @@ pub(super) const CLIP_PAINT: &str = "the fills and strokes of clipping paths tha
pub(super) const CLIP_PAINT_MASKS: &str = "the opacity masks of clipping paths whose fills and strokes are written as paths of their own stay on the clipping path, not on those paths, in the editing data for other apps";
pub(super) const LIVE: &str =
"blends, envelopes, meshes, repeats, placed documents and intertwines are written as their art in the editing data for other apps";
const STROKES: &str = "strokes a plain line can't draw (inside or outside the path, variable width, dots, dashes fitted to corners, gradients, patterns, arrowheads) are written as filled outlines, and brushed strokes as their brush's art, in the editing data for other apps";
pub(super) const STROKES: &str = "strokes a plain line can't draw (inside or outside the path, variable width, dots, dashes fitted to corners, gradients, patterns, arrowheads) are written as filled outlines, and brushed strokes as their brush's art, in the editing data for other apps";
pub(super) const ITEM_TRANSPARENCY: &str =
"the opacity and blending modes of single fills and strokes are left out of the editing data for other apps";
pub(super) const LAYER_MASKS: &str = "opacity masks on layers are left out of the editing data for other apps";
@@ -255,6 +258,10 @@ pub(super) struct Writer<'a> {
/// An object's drawn look is being written: no object in it is written with a style, and its
/// effects are the style's.
in_look: bool,
/// The brushes written ([`brushes`]).
brush_set: brushes::Brushes,
/// Brushes may be written; false on a large canvas, where they are left out.
pub(super) brushes_live: bool,
}
impl<'a> Writer<'a> {
@@ -310,6 +317,8 @@ impl<'a> Writer<'a> {
styled: HashMap::new(),
styles: styles::Styles::default(),
in_look: false,
brush_set: brushes::Brushes::default(),
brushes_live: true,
objects: 0,
left_out: 0,
definition_objects: 0,
@@ -896,7 +905,7 @@ impl<'a> Writer<'a> {
self.warn_cut(Some(first));
return self.clip_contents(children);
};
let items = self.items(first, path.to_bezpath().bounding_box());
let items = self.items(first, &path.to_bezpath());
let painted = self.plain_paint(&items);
// The clipping path goes after the others, so its objects are counted first.
let subpaths: Vec<&SubPath> = path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()).collect();
@@ -1004,7 +1013,7 @@ impl<'a> Writer<'a> {
if path.is_empty() {
return;
}
let items = self.items(n, path.to_bezpath().bounding_box());
let items = self.items(n, &path.to_bezpath());
if items.iter().any(|i| i.opacity() < 1.0 || i.blend() != BlendMode::Normal) {
self.warn(ITEM_TRANSPARENCY);
}
@@ -1028,7 +1037,12 @@ impl<'a> Writer<'a> {
AppearanceItem::Fill(f) => self.fill_object(path, rule, f, xy),
AppearanceItem::Stroke(s) if self.direct_stroke(s) => self.path_object(path, rule, None, Some(s), xy),
AppearanceItem::Stroke(s) => {
self.warn(STROKES);
// In a drawn look a brushed stroke is kept by the object's art style, which is written
// only when the reader reads the brush back from it; a styled group's members are
// written again after the look, and warn there.
if !(self.in_look && s.brush.is_some()) {
self.warn(STROKES);
}
self.wrote_fixed = true;
if self.brush_art(path, s, xy) {
return;
+558
View File
@@ -0,0 +1,558 @@
//! Brushes: the document's brushes as the `.ai` reader reads them ([`crate::import`]'s `.ai` reader,
//! `brush.rs`), and the brush filter of a brushed stroke in an art style (`style.rs`).
//!
//! Each brush is a plug-in object (`%AI8_BeginPluginObject`, the plug-in's name, the brush's name,
//! its parameters as strings that `-` continues and `.` ends, `%AI8_EndPluginObject`), after the
//! brush manager's order of them all, in a non-printing block after the symbols. The art of a
//! Scatter or Art brush is a `%AI8_BeginBrushPattern` section (its name; a group of the art's frame,
//! an unpainted rectangle at the art's geometric bounds, and the art, or the art alone when it has no
//! width or height; its end) in a non-printing block before the symbols. Each brush is checked with
//! the reader's own reading ([`crate::import::read_brush_object`]) before it is written: one the
//! reader would read as another brush is left out.
use std::collections::HashSet;
use std::fmt::Write;
use std::sync::Arc;
use vectorcraft_brush::{ArtBrush, ArtScale, Brush, BrushKind, Calligraphic, Colorization, Direction, Scatter, Variation};
use vectorcraft_color::{BlendMode, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, Node, NodeId, NodeKind, StrokeLayer};
use vectorcraft_geom::{Affine, PathData, SubPath};
use super::{Writer, Xy};
use crate::ai_ops;
use crate::ps;
pub(in crate::ai_editing) const BRUSHES: &str = "Pattern and Bristle brushes, Art brushes that don't stretch their art along the path from left to right at 100% unflipped without overlap, Scatter and Art brushes in Tints and Shades or Hue Shift, brushes whose art holds an empty path or group or more than paths, compound paths and groups with one solid fill and one plain stroke each, brushes whose names hold a slash or repeat an earlier brush's name, brushes that would open with other settings, brushes past the number or the amount of art one file's brushes can hold, and every brush on a large canvas are left out of the Brushes panel in the editing data for other apps";
/// Most brushes written (the reader's limit).
const MAX_BRUSHES: usize = 4096;
/// Most bytes of a plug-in object's parameters in one of its strings.
const CHUNK: usize = 60;
/// A brush written as a plug-in object.
pub(super) struct BrushOut {
pub brush: Brush,
pub plugin: &'static str,
pub params: String,
/// The art its parameters name, as the reader reads it.
pub art: Option<Node>,
/// Its art section to write ([`Writer::brush_blocks`] writes it).
section: Option<SectionArt>,
/// A path whose art style names it at its own settings is read with the brush on its stroke.
pub live: bool,
}
/// A brush's art section to write: its name, the art and the space it is written in
/// ([`Writer::brush_art_section`]).
type SectionArt = (String, Node, Affine);
/// The brushes written and their art.
#[derive(Default)]
pub(super) struct Brushes {
/// The document's brushes have been worked out.
done: bool,
pub written: Vec<BrushOut>,
/// The art sections named so far.
sections: usize,
/// A brush of the document was left out.
left_out: bool,
/// How many objects were written with a brush on their stroke.
pub live_written: usize,
/// The brushes written as the reader reads them, for checking art styles; made once, when
/// the first style is checked ([`Writer::brushed_style_reads`]).
read: Option<crate::import::BrushesRead>,
}
/// A number with at most six decimals, as brush parameters hold factors.
fn num6(s: &mut String, v: f64) {
let v = if v.is_finite() { (v * 1e6).round() / 1e6 } else { 0.0 };
if v == v.trunc() && v.abs() < 1e15 {
let _ = write!(s, "{}", v as i64);
return;
}
let start = s.len();
let _ = write!(s, "{v:.6}");
let keep = s[start..].trim_end_matches('0').trim_end_matches('.').len();
s.truncate(start + keep);
}
/// `vs` as [`num6`] numbers separated by spaces.
fn nums6(vs: &[f64]) -> String {
let mut s = String::new();
for (i, v) in vs.iter().enumerate() {
if i > 0 {
s.push(' ');
}
num6(&mut s, *v);
}
s
}
/// The code a brush's parameters give how a value varies, in the order of the Brush Options menu.
fn code(v: Variation) -> f64 {
match v {
Variation::Fixed => 0.0,
Variation::Random => 1.0,
Variation::Pressure => 2.0,
Variation::Tilt => 4.0,
Variation::Bearing => 5.0,
Variation::Rotation => 6.0,
}
}
/// The colorization code of Scatter and Art brushes' parameters: `None` for one the reader doesn't read.
fn colorization_code(c: Colorization) -> Option<f64> {
match c {
Colorization::None => Some(0.0),
Colorization::Tints => Some(1.0),
Colorization::TintsAndShades | Colorization::HueShift { .. } => None,
}
}
/// A Calligraphic brush's parameters: 1, the diameter, roundness and angle as (low, high) pairs,
/// the codes of how the diameter, roundness and angle vary, and 0.
fn calligraphic_params(c: &Calligraphic) -> String {
let [angle, roundness, size] = [c.angle, c.roundness, c.size];
let [av, rv, dv] = c.variation;
let [am, rm, dm] = c.modes().map(code);
nums6(&[1.0, size - dv, size + dv, roundness - rv, roundness + rv, angle - av, angle + av, dm, rm, am, 0.0])
}
/// A Scatter brush's parameters, its art the section `art`: `None` for a colorization the reader
/// doesn't read.
fn scatter_params(s: &Scatter, art: &str) -> Option<String> {
let f = |v: f64| v / 100.0;
let m = s.modes().map(code);
let numbers = [
colorization_code(s.colorization)?,
f(s.size.0),
f(s.size.1),
m[0],
f(s.spacing.0),
f(s.spacing.1),
m[1],
f(s.scatter.0),
f(s.scatter.1),
m[2],
s.rotation.0,
s.rotation.1,
m[3],
f64::from(u8::from(s.rotation_relative_to_path)),
0.0,
];
Some(format!("2 /{art}/ 5 0 0 0 / {}", nums6(&numbers)))
}
/// An Art brush's parameters, its art the section `art`: `None` for options the reader doesn't read
/// (it reads an Art brush that stretches its art along the path from left to right at 100%,
/// unflipped, without overlap, in Tints or keeping its colors).
fn art_params(a: &ArtBrush, art: &str) -> Option<String> {
let plain = a.direction == Direction::LeftToRight
&& matches!(a.scale, ArtScale::Stretch)
&& a.width == 100.0
&& a.width_mode.is_none()
&& !a.flip_along
&& !a.flip_across
&& !a.overlap;
if !plain {
return None;
}
let c = colorization_code(a.colorization)?;
let numbers = [1.0, c, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0];
Some(format!("2 / {art}/ / / / / 0 0/ 5 0 0 0 / {}", nums6(&numbers)))
}
/// Is `art` written as the reader reads it back, within a brush: paths and compound paths with
/// points and groups with members (not clipping, without paint of their own), each opaque in the
/// normal blending mode, without effects or opacity masks, with at most one fill and one plain
/// stroke (no brush, width profile, arrowheads, alignment off the path or dashes fitted to corners)
/// over it, each in a color or none? A path without points isn't written ([`Writer::plain_object`]).
fn plain_art(art: &Node) -> bool {
let mut plain = true;
art.walk(&mut |n| {
let kind = match &n.kind {
NodeKind::Path { path, guide: false, clipping: false, .. } => path.subpaths.iter().any(|sp| !sp.anchors.is_empty()),
NodeKind::Compound { .. } => super::compound_path(n).subpaths.iter().any(|sp| !sp.anchors.is_empty()),
NodeKind::Group { children, clip: false } => !children.is_empty(),
_ => false,
};
let items = &n.appearance.items;
let fills = items.iter().filter(|i| matches!(i, AppearanceItem::Fill(_))).count();
let strokes = items.iter().filter(|i| matches!(i, AppearanceItem::Stroke(_))).count();
let order = !matches!(items.as_slice(), [AppearanceItem::Stroke(_), AppearanceItem::Fill(_)]);
let quiet = items.iter().all(|i| {
i.effects().is_empty()
&& i.opacity() >= 1.0
&& i.blend() == BlendMode::Normal
&& matches!(i.paint(), Paint::Solid { .. } | Paint::None)
&& !matches!(i, AppearanceItem::Stroke(s) if !vectorcraft_effects::stroke::is_plain(s))
});
// A group's own fills and strokes aren't written.
let group_paint = matches!(n.kind, NodeKind::Group { .. }) && items.iter().any(|i| !i.paint().is_none());
plain &= kind
&& !group_paint
&& fills <= 1
&& strokes <= 1
&& order
&& quiet
&& n.appearance.effects.is_empty()
&& n.extras().mask.is_none()
&& n.opacity >= 1.0
&& n.blend == BlendMode::Normal;
});
plain
}
/// `art` (checked by [`plain_art`]) with its structure as the reader reads it back. A path, or a
/// compound path with the subpaths of all its members as one path ([`super::compound_path`]), is
/// written as one path when it has one subpath with points and as a compound path when it has more
/// ([`Writer::plain_object`]); the reader reads that compound path as one path for each subpath,
/// each with the object's paint.
fn as_read(art: &mut Node) {
let (subpaths, rule) = match &art.kind {
NodeKind::Path { path, rule, .. } => (path.subpaths.clone(), *rule),
NodeKind::Compound { rule, .. } => (super::compound_path(art).subpaths, *rule),
_ => {
if let Some(children) = art.children_mut() {
for c in children.iter_mut() {
as_read(Arc::make_mut(c));
}
}
return;
}
};
let mut subpaths: Vec<SubPath> = subpaths.into_iter().filter(|sp| !sp.anchors.is_empty()).collect();
let path = |sp: SubPath| {
let mut p = Node::path(art.id, PathData::single(sp), Appearance::default());
p.appearance = art.appearance.clone();
p
};
match subpaths.len() {
0 => {}
1 => {
let Some(sp) = subpaths.pop() else { return };
art.kind = path(sp).kind;
if let NodeKind::Path { rule: r, .. } = &mut art.kind {
*r = rule;
}
}
_ => {
let children = subpaths.into_iter().map(|sp| Arc::new(path(sp))).collect();
art.kind = NodeKind::Compound { children, rule };
}
}
}
/// Do brushes `a` and `b` have the same settings, within the written numbers' precision, whatever
/// their art and however their modes are given?
fn same_settings(a: &Brush, b: &Brush) -> bool {
let norm = |b: &Brush| -> serde_json::Value {
let mut b = b.clone();
let none = || Node::group(NodeId(0), vec![]);
match &mut b.kind {
BrushKind::Calligraphic(c) => c.modes = Some(c.modes()),
BrushKind::Scatter(s) => {
s.modes = Some(s.modes());
s.art = none();
}
BrushKind::Art(a) => a.art = none(),
BrushKind::Pattern(_) | BrushKind::Bristle(_) => {}
}
serde_json::to_value(&b).unwrap_or(serde_json::Value::Null)
};
super::styles::near(&norm(a), &norm(b))
}
/// A plug-in object: its plug-in's name, its name, and `params` in strings of at most [`CHUNK`] bytes.
fn plugin_object(plugin: &str, name: &str, params: &str) -> String {
let mut s = format!("%AI8_BeginPluginObject\n{}\n{}\n", ps::bytes(plugin.as_bytes()), ps::bytes(name.as_bytes()));
let chunks: Vec<&[u8]> = params.as_bytes().chunks(CHUNK).collect();
if chunks.is_empty() {
s.push_str("() .\n");
}
for (i, c) in chunks.iter().enumerate() {
let _ = writeln!(s, "{} {}", ps::bytes(c), if i + 1 == chunks.len() { "." } else { "-" });
}
s.push_str("%AI8_EndPluginObject\n");
s
}
impl Writer<'_> {
/// Work out, once, which of the document's brushes are written: each one the reader reads back
/// with its settings. Their art is written with the brushes ([`Self::brush_blocks`]).
pub(super) fn brush_set(&mut self) {
if self.brush_set.done {
return;
}
self.brush_set.done = true;
let doc = self.doc;
let lib = self.brushes.get_or_insert_with(|| vectorcraft_brush::library(doc)).clone();
if !self.brushes_live {
self.brush_set.left_out = !lib.is_empty();
return;
}
// A name is taken by a brush written, as the reader takes it by a brush it keeps. A brush after
// another of its name isn't the one a path of that name is drawn with, so no path is written
// with it on its stroke.
let mut names: HashSet<String> = HashSet::new();
let mut seen: HashSet<String> = HashSet::new();
for b in lib {
let fits = !b.name.contains('/') && !names.contains(&b.name) && self.brush_set.written.len() < MAX_BRUSHES;
let first = seen.insert(b.name.clone());
match fits.then(|| self.brush_out(&b)).flatten() {
Some(mut out) => {
names.insert(b.name.clone());
out.live &= first;
self.brush_set.written.push(out);
}
None => self.brush_set.left_out = true,
}
}
// Read together, as one file's: the reader copies only so much art into one file's brushes.
let objects: Vec<(&str, &str, &str, Option<&Node>)> =
self.brush_set.written.iter().map(|b| (b.plugin, b.brush.name.as_str(), b.params.as_str(), b.art.as_ref())).collect();
let kept = crate::import::brushes_kept(&objects);
if kept.iter().any(|k| !k) {
self.brush_set.left_out = true;
let mut keep = kept.into_iter();
self.brush_set.written.retain(|_| keep.next().unwrap_or(false));
}
}
/// Brush `b` as it is written, with its art section's name, art and placement
/// ([`Self::brush_art_section`] writes it): `None` when the reader wouldn't read it back.
fn brush_out(&mut self, b: &Brush) -> Option<BrushOut> {
let plugin = crate::import::brush_plugin_name(&b.kind);
let section = format!("Brush Art {}", self.brush_set.sections + 1);
// The art as the reader reads it: a section is read with y down, and an Art brush's art is
// turned over after that (its section's y up is the right of the path).
let (params, art) = match &b.kind {
BrushKind::Calligraphic(c) => (calligraphic_params(c), None),
BrushKind::Scatter(s) => (scatter_params(s, &section)?, Some((s.art.clone(), Affine::FLIP_Y))),
BrushKind::Art(a) => (art_params(a, &section)?, Some((a.art.clone(), Affine::IDENTITY))),
BrushKind::Pattern(_) | BrushKind::Bristle(_) => return None,
};
let read_art = match &art {
Some((a, to_section)) => {
if !plain_art(a) {
return None;
}
let mut read = a.clone();
if *to_section == Affine::IDENTITY {
read.transform(Affine::FLIP_Y, false);
}
as_read(&mut read);
Some(read)
}
None => None,
};
let read = crate::import::read_brush_object(plugin, &b.name, &params, read_art.as_ref())?;
if !same_settings(&read.brush, b) {
return None;
}
if art.is_some() {
self.brush_set.sections += 1;
}
let section = art.map(|(a, to_section)| (section, a, to_section));
Some(BrushOut { brush: b.clone(), plugin, params, art: read_art, section, live: read.live })
}
/// A brush's art section `name`: `art` written with `to_section` taking the document's space to
/// the section's (y up), from the state a definition starts in. Its objects are counted as the
/// reader counts them ([`Self::take_objects`]: the group, the frame and the art). `None` when
/// writing it warns: what it took is given back, and when it didn't fit within the object limit,
/// the limit's warning is kept.
fn brush_art_section(&mut self, name: &str, art: &Node, to_section: Affine) -> Option<String> {
let before = self.charges();
// The art's own warnings, apart from those the document already has (a warning is kept once).
let warnings = std::mem::take(&mut self.warnings);
let saved = (
std::mem::take(&mut self.body),
(self.to_art, self.grad_space, self.canvas),
self.state.take(),
self.gs.replace(Xy::OPAQUE),
self.clip.take(),
(self.block_start, self.block_end),
// The art is the brush's own: not on `%_` lines, in a drawn look or in a symbol that
// first uses the brush.
(std::mem::take(&mut self.hidden), std::mem::take(&mut self.in_look), std::mem::take(&mut self.in_symbol)),
);
(self.to_art, self.grad_space, self.canvas, self.block_end) = (to_section, to_section, to_section, usize::MAX);
self.state(false, false);
// The art in a group after its frame, an unpainted rectangle around it. Art without width or
// height (a straight line) is written alone: the reader keeps a frame of no area as art.
let frame = art
.geometric_bounds()
.filter(|b| b.width() > 0.0 && b.height() > 0.0)
.and_then(|b| vectorcraft_geom::shapes::rectangle(b).subpaths.first().cloned());
match frame {
Some(frame) if self.take_objects(2) => {
self.line("u\n0 XR");
ai_ops::subpath(&mut self.body, to_section, &frame);
self.line("n");
self.nest += 1;
self.node(art);
self.nest -= 1;
self.line("U");
}
Some(_) => {}
None => {
self.nest += 1;
self.node(art);
self.nest -= 1;
}
}
let body;
(
body,
(self.to_art, self.grad_space, self.canvas),
self.state,
self.gs,
self.clip,
(self.block_start, self.block_end),
(self.hidden, self.in_look, self.in_symbol),
) = saved;
let text = std::mem::replace(&mut self.body, body);
if !std::mem::replace(&mut self.warnings, warnings).is_empty() {
self.give_back(before, &text);
if self.left_out_since(before) {
self.warn(super::OBJECT_LIMIT);
}
return None;
}
self.keep_since(before);
Some(format!("%AI8_BeginBrushPattern\n{}\n{text}%AI8_EndBrushPattern\n", ps::bytes(name.as_bytes())))
}
/// The written brush named `name` that a path can be written with live.
pub(super) fn live_brush(&self, name: &str) -> Option<&BrushOut> {
self.brush_set.written.iter().find(|b| b.live && b.brush.name == name)
}
/// The basic filter of stroke `st` with the brush it names: the brush's plug-in as the filter,
/// its settings for the object, the stroke's style and the brush by name. `None` when the brush
/// isn't written live.
pub(super) fn brush_filter(&mut self, s: &mut String, st: &StrokeLayer, visible: bool) -> Option<()> {
let name = st.brush.as_deref()?;
self.brush_set();
let (plugin, kind) = self.live_brush(name).map(|b| (b.plugin, b.brush.kind.clone()))?;
if !matches!(st.paint, Paint::Solid { .. }) || st.overprint {
return None;
}
let ops = self.color_ops(&st.paint, true);
let mut d = String::new();
let title = match &kind {
BrushKind::Calligraphic(c) => {
let modes = c.modes().map(code);
for (key, value, variation, mode) in [
("Diameter", c.size, c.variation[2], modes[2]),
("Roundness", c.roundness, c.variation[1], modes[1]),
("Angle", c.angle, c.variation[0], modes[0]),
] {
let _ = writeln!(d, "{} /Real ({key}) ,", ps::num(value));
let _ = writeln!(d, "{} /Real ({key}Variation) ,", ps::num(variation));
let _ = writeln!(d, "{} /Int ({key}DependsOn) ,", mode as i64);
}
d.push_str("0 /Int (AngleRelativeTo) ,\n");
"(Calligraphic Brush) /Title ,\n"
}
BrushKind::Art(_) => {
d.push_str("15 /Int (Adobe Effect Expand Before Version) ,\n"); // brand-ok: the entry's name in the files
for (key, value, kind) in [
("StartSegmentLength", "0", "Real"),
("EndSegmentLength", "0", "Real"),
("Counterclockwise", "0", "Int"),
("MinScaling", "1", "Real"),
("MaxScaling", "1", "Real"),
("Colorization", "1", "Int"),
("Spacing", "0", "Real"),
("Adjustment", "1", "Int"),
("Proportional", "0", "Bool"),
("Segmented", "0", "Bool"),
("UpsideDown", "0", "Int"),
("FoldAdjustment", "1", "Bool"),
("ScaleYDependsOn", "0", "Int"),
("Scaling", "1", "Real"),
] {
let _ = writeln!(d, "{value} /{kind} ({key}) ,");
}
"(Art Brush) /Title ,\n"
}
_ => return None,
};
super::styles::basic(s, plugin, true, visible);
s.push_str(title);
s.push_str("2 /FillOrStroke ,\n/Dictionary : /NotRecorded ,\n");
s.push_str(&d);
s.push_str("/StrokeStyle : 0 R\n");
s.push_str(&ops);
s.push_str("0 1 0 0 0 Xy\n");
ai_ops::line_style(s, st);
s.push_str("0 XR\n1 0 Xd\n/Def ; \n (StrokeStyle) ,\n");
let quoted = ps::bytes(name.as_bytes());
let _ =
write!(s, "/GObjRef : {quoted} {} /PluginObject ; (Brush) ,\n{quoted} /UnicodeString (DisplayString) ,\n", ps::bytes(plugin.as_bytes()));
s.push_str(super::styles::END_BASIC);
Some(())
}
/// Does the reader read the brushed strokes of style text `text` with their brushes on them?
pub(super) fn brushed_style_reads(&mut self, text: &str) -> bool {
self.brush_set();
let section = super::styles::known_style("x", text);
let written = &self.brush_set.written;
let read = self.brush_set.read.get_or_insert_with(|| {
let brushes: Vec<(&str, &str, &str, Option<&Node>)> =
written.iter().map(|b| (b.plugin, b.brush.name.as_str(), b.params.as_str(), b.art.as_ref())).collect();
crate::import::BrushesRead::new(&brushes)
});
read.style_reads(section.as_bytes(), "x")
}
/// The brushes' art in a non-printing block, then the brush manager's order and the brushes in
/// two more, when the document has brushes of its own or an object is written with a brush on
/// its stroke (a file without brushes opens with a new document's). Warns when a brush is left
/// out.
pub(in crate::ai_editing) fn brush_blocks(&mut self) -> (String, String) {
let stored = self.doc.unknown.contains_key(vectorcraft_brush::DOC_KEY);
if !stored && self.brush_set.live_written == 0 {
return (String::new(), String::new());
}
self.brush_set();
// The art is written now that the file holds it, after the layers' objects. A brush whose art
// doesn't fit is left out; a path written with it on its stroke opens as its drawn look.
let mut sections = String::new();
for mut b in std::mem::take(&mut self.brush_set.written) {
if let Some((name, art, to_section)) = b.section.take() {
let Some(text) = self.brush_art_section(&name, &art, to_section) else {
self.brush_set.left_out = true;
continue;
};
sections.push_str(&text);
}
self.brush_set.written.push(b);
}
if self.brush_set.left_out {
self.warn(BRUSHES);
}
// On a large canvas an empty panel is still written: the manager alone, with no art to scale.
let empty = self.brushes.as_ref().is_some_and(|l| l.is_empty());
if !self.brushes_live && !(stored && empty) {
return (String::new(), String::new());
}
let art = if sections.is_empty() { String::new() } else { format!("%AI5_Begin_NonPrinting\nNp\n{sections}%AI5_End_NonPrinting--\n") };
let manager = crate::import::BRUSH_MANAGER;
let order: String = self.brush_set.written.iter().map(|b| format!(" {}/ {}/", b.plugin, b.brush.name)).collect();
let mut objects = format!("%AI5_Begin_NonPrinting\nNp\n{}%AI5_End_NonPrinting--\n", plugin_object(manager, manager, &order));
if !self.brush_set.written.is_empty() {
objects.push_str("%AI5_Begin_NonPrinting\nNp\n");
for b in &self.brush_set.written {
objects.push_str(&plugin_object(b.plugin, &b.brush.name, &b.params));
}
objects.push_str("%AI5_End_NonPrinting--\n");
}
(art, objects)
}
}
+49 -11
View File
@@ -47,6 +47,7 @@ pub(super) struct PatternOut {
pub(in crate::ai_editing) const DIAMOND: &str =
"diamond gradients are written as radial gradients through their corners, with the same stops, in the editing data for other apps";
pub(in crate::ai_editing) const SPREAD: &str = "gradients that repeat or reflect are written with their stops repeated across the shape (at most 256 stops, padding past them) in the editing data for other apps";
/// Can `g` be written as a gradient (a linear, radial, conic or diamond one with stops, no more
/// than the `.ai` reader reads; a conic is written linear, [`CONIC`], and a diamond radial,
@@ -85,11 +86,13 @@ impl Writer<'_> {
pub(in crate::ai_editing) fn reserve_swatch_gradients(&mut self) {
let doc = self.doc;
for sw in doc.swatches_iter() {
// As `swatch_paint` writes it: the stops of one that repeats or reflects repeated.
if let Paint::Gradient(g) = &sw.paint
&& writable_gradient(&g.gradient)
&& let gradient = g.gradient.unrolled_within(crate::import::MAX_GRADIENT_STOPS)
&& writable_gradient(&gradient)
&& !self.gradients.iter().any(|d| d.name == sw.name)
{
self.gradients.push(GradientDef { name: sw.name.clone(), gradient: g.gradient.clone(), swatch: true, used: false });
self.gradients.push(GradientDef { name: sw.name.clone(), gradient: gradient.into_owned(), swatch: true, used: false });
}
}
}
@@ -135,8 +138,27 @@ impl Writer<'_> {
/// placed there (it then no longer depends on the shape it paints, which may be cut); one the
/// data can't hold is its average color, with a warning.
pub(super) fn placed(&mut self, p: &Paint, bounds: Rect) -> Paint {
self.placed_over(p, bounds, bounds)
}
/// [`Self::placed`] for paint that reaches `area`: a gradient that repeats or reflects is
/// written with its stops repeated over `area`.
fn placed_over(&mut self, p: &Paint, bounds: Rect, area: Rect) -> Paint {
let Paint::Gradient(g) = p else { return p.clone() };
let geom = g.resolve(bounds);
let mut geom = g.resolve(bounds);
// The data has no spread: a gradient that repeats or reflects is written with its stops
// repeated over `area` (a conic one, written linear, around its turn).
let mut g: GradientPaint = (**g).clone();
if g.gradient.is_spread() {
self.warn(SPREAD);
match g.gradient.padded_within(&geom, area, crate::import::MAX_GRADIENT_STOPS) {
Some(padded) => {
g.gradient = padded.gradient;
geom = padded.geom;
}
None => g.gradient = g.gradient.unrolled_within(crate::import::MAX_GRADIENT_STOPS).into_owned(),
}
}
let finite = [geom.start.x, geom.start.y, geom.end.x, geom.end.y, geom.aspect].iter().all(|v| v.is_finite());
let radial = written_radial(g.gradient.kind);
if g.gradient.kind == GradientKind::Freeform {
@@ -147,13 +169,16 @@ impl Writer<'_> {
self.warn(GRADIENT_SHAPES);
return Paint::solid(average(&g.gradient));
}
Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), ..(**g).clone() }))
Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), ..g }))
}
/// The fills and strokes of `n` that paint (outline `bounds`), their gradients placed
/// ([`Self::placed`]): a fill's on the shape's bounds, a stroke's on what it paints. A gradient
/// along or across a stroke is its average color (the stroke is written as its outline).
pub(super) fn items(&mut self, n: &vectorcraft_doc::Node, bounds: Rect) -> Vec<AppearanceItem> {
/// The fills and strokes of `n` that paint (outline `bp`), their gradients placed
/// ([`Self::placed`]): a fill's on the shape's bounds, a stroke's on what it paints, the stops
/// of one that repeats or reflects repeated over the box the stroke paints, miter spikes
/// included ([`StrokeLayer::bounds_on`]). A gradient along or across a stroke is its average
/// color (the stroke is written as its outline).
pub(super) fn items(&mut self, n: &vectorcraft_doc::Node, bp: &BezPath) -> Vec<AppearanceItem> {
let bounds = bp.bounding_box();
super::visible_items(n)
.into_iter()
.map(|i| match i {
@@ -164,7 +189,11 @@ impl Writer<'_> {
self.warn(GRADIENTS);
Paint::solid(average(&g.gradient))
}
None => self.placed(&s.paint, s.paint_bounds(bounds)),
None => {
let spread = matches!(&s.paint, Paint::Gradient(g) if g.gradient.is_spread());
let reach = if spread { s.bounds_on(bp, bounds) } else { bounds };
self.placed_over(&s.paint, s.paint_bounds(bounds), reach)
}
};
AppearanceItem::Stroke(StrokeLayer { paint, ..s.clone() })
}
@@ -521,10 +550,19 @@ impl Writer<'_> {
/// `(name) 0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0] p`. False for other paint, and for paint that can't
/// be written.
pub(super) fn swatch_paint(&mut self, s: &mut String, sw: &vectorcraft_color::swatch::Swatch) -> bool {
// A swatch has no placement: one that repeats or reflects holds its stops repeated along
// its vector.
let unrolled = match &sw.paint {
Paint::Gradient(g) => Some(g.gradient.unrolled_within(crate::import::MAX_GRADIENT_STOPS)),
_ => None,
};
match &sw.paint {
Paint::Gradient(g) if writable_gradient(&g.gradient) => {
Paint::Gradient(g) if unrolled.as_deref().is_some_and(writable_gradient) => {
if g.gradient.is_spread() {
self.warn(SPREAD);
}
let swatch = Some(sw.name.as_str());
let name = self.define_gradient(&g.gradient, swatch);
let name = self.define_gradient(unrolled.as_deref().unwrap_or(&g.gradient), swatch);
s.push_str("Bb\n");
if written_radial(g.gradient.kind) {
s.push_str("0 0 0 0 Bh\n");
+39 -15
View File
@@ -40,8 +40,9 @@ pub(in crate::ai_editing) fn style_links(doc: &Document) -> usize {
}
/// The objects of `doc`'s layers that may be written with an art style ([`Writer::styled_object`]),
/// by id: paths and compound paths with points and groups, with live effects or linked to a graphic
/// style, without Opacity & Mask Define Knockout Shape (the reader takes an object's transparency
/// by id: paths and compound paths with points and groups, with live effects, linked to a graphic
/// style or (paths and compound paths) with a brush on a stroke, without Opacity & Mask Define
/// Knockout Shape (the reader takes an object's transparency
/// from its look, which doesn't carry it). A group's members are paths, compound paths or such
/// groups, none with effects or anything baking changes.
pub(in crate::ai_editing) fn styled_objects(doc: &Document) -> HashMap<NodeId, Arc<Node>> {
@@ -76,7 +77,8 @@ fn bakes_members(n: &Node) -> bool {
/// Whether `n` may be written with an art style ([`styled_objects`]).
fn candidate(n: &Node) -> bool {
let styled = !n.appearance.effects.is_empty() || n.extras().graphic_style.is_some();
let brushed = brushed(n) && matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. });
let styled = !n.appearance.effects.is_empty() || n.extras().graphic_style.is_some() || brushed;
if !styled || n.knockout_shape {
return false;
}
@@ -88,6 +90,12 @@ fn candidate(n: &Node) -> bool {
}
}
/// Does `n` have a stroke with a brush that paints, one that its art style holds ([`Writer::style_text`]
/// leaves out what paints nothing)?
fn brushed(n: &Node) -> bool {
n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.brush.is_some() && !s.paint.is_none()))
}
/// Does `path` write anything ([`Writer::plain_object`] skips subpaths without points)?
fn has_points(path: &vectorcraft_geom::PathData) -> bool {
path.subpaths.iter().any(|sp| !sp.anchors.is_empty())
@@ -144,7 +152,7 @@ impl Styles {
}
/// One style as the reader's section holds it: `/KnownStyle :`, `(name) /Name ,`, its text.
fn known_style(name: &str, text: &str) -> String {
pub(super) fn known_style(name: &str, text: &str) -> String {
format!("/KnownStyle :\n{} /Name ,\n{text}", ps::bytes(name.as_bytes()))
}
@@ -172,7 +180,7 @@ const NO_LINE: &str = "0 J 0 j 1 w 10 M []0 d\n";
/// A basic filter's start: its name and kind numbers (`1 0` for an effect, `0 0` for the
/// style's own filters), `/Visible` and the dictionary's start.
fn basic(s: &mut String, name: &str, effect: bool, visible: bool) {
pub(super) fn basic(s: &mut String, name: &str, effect: bool, visible: bool) {
let _ = write!(s, "/BasicFilter :\n{} {} 0 /Filter ,\n{} /Visible ,\n", ps::bytes(name.as_bytes()), u8::from(effect), u8::from(visible));
}
@@ -180,7 +188,7 @@ fn basic(s: &mut String, name: &str, effect: bool, visible: bool) {
const CONDUIT: &str = "/BasicFilter :\n(Conduit Filter) 0 0 /Filter ,\n1 /Visible ,\n;\n /Part ,\n";
/// A basic filter's end.
const END_BASIC: &str = "; /Dict ;\n /Part ,\n";
pub(super) const END_BASIC: &str = "; /Dict ;\n /Part ,\n";
/// The blend filter of transparency `xy`.
fn blend_filter(s: &mut String, xy: Xy) {
@@ -228,7 +236,7 @@ fn flag(p: &Value, key: &str) -> Option<bool> {
impl Writer<'_> {
/// What `paint` writes with [`Self::color`] (a color, a spot or global color), as a string.
fn color_ops(&mut self, paint: &Paint, stroke: bool) -> String {
pub(super) fn color_ops(&mut self, paint: &Paint, stroke: bool) -> String {
let saved = std::mem::take(&mut self.body);
self.color(paint, stroke);
std::mem::replace(&mut self.body, saved)
@@ -267,9 +275,12 @@ impl Writer<'_> {
}
/// A stroke's basic filter: a color, its line style, and its width profile as the arrays
/// `BSVariableWidthTValuesArray`, `BSLeftWidthsArray` and `BSRightWidthsArray`. `None` for
/// other paint.
/// `BSVariableWidthTValuesArray`, `BSLeftWidthsArray` and `BSRightWidthsArray`; a stroke with a
/// brush, the brush's filter ([`Self::brush_filter`]). `None` for other paint.
fn stroke_filter(&mut self, s: &mut String, st: &StrokeLayer, visible: bool) -> Option<()> {
if st.brush.is_some() {
return self.brush_filter(s, st, visible);
}
if !matches!(st.paint, Paint::Solid { .. }) || st.overprint {
return None;
}
@@ -652,17 +663,19 @@ impl Writer<'_> {
&& let Some(text) = self.styles.known.iter().find(|(n, _)| *n == name).map(|(_, t)| t.clone())
&& object_reads(orig, &text)
{
self.styles.links_written += 1;
return Some(name);
}
if orig.appearance.effects.is_empty() || !own_style_holds(&orig.appearance) {
let brushed = brushed(orig);
if (orig.appearance.effects.is_empty() && !brushed) || !own_style_holds(&orig.appearance) {
return None;
}
let graded = orig.appearance.items.iter().any(|i| matches!(i.paint(), Paint::Gradient(_)));
let saved = (graded.then(|| self.gradient_mark()), self.warnings.len());
let path = drawn_outline(n, orig);
let rule = object_rule(orig);
let text = self.style_text(&orig.appearance, Xy::of(orig), path.as_ref().map(|p| (p, rule))).filter(|t| object_reads(orig, t));
let text = self
.style_text(&orig.appearance, Xy::of(orig), path.as_ref().map(|p| (p, rule)))
.filter(|t| object_reads(orig, t) && (!brushed || self.brushed_style_reads(t)));
let Some(text) = text else {
if let Some(mark) = saved.0 {
self.gradient_rollback(mark);
@@ -693,7 +706,8 @@ impl Writer<'_> {
/// compound path's points painted with nothing, or with its gradient fill when its style has
/// one; a group with its members), its name and opacity mask; then `1 (name) XW`.
/// The look's group and the object itself are counted first ([`Self::take_objects`]): without
/// room for them, nothing is written.
/// room for them, nothing is written, and the object counts neither as written with its graphic
/// style nor as written with a brush on its stroke.
pub(super) fn styled_object(&mut self, n: &Node, orig: &Node, name: &str) {
let own = match &orig.kind {
NodeKind::Path { path, .. } => super::object_count(path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()).count()),
@@ -704,6 +718,12 @@ impl Writer<'_> {
if !self.take_objects(1 + own) {
return;
}
let linked = orig.extras().graphic_style.and_then(|id| self.styles.panel.get(&id)).is_some_and(|p| p == name);
if linked {
self.styles.links_written += 1;
} else if brushed(orig) {
self.brush_set.live_written += 1;
}
self.state(orig.locked, !orig.visible);
let xy = Xy::of(orig);
let was = self.in_look;
@@ -834,8 +854,12 @@ fn own_style_holds(ap: &Appearance) -> bool {
ap.items.iter().filter(|i| !i.paint().is_none()).all(plain) && !ap.effects.iter().any(panel_only)
}
/// Does the reader read graphic style `g` from style text `text` as it is?
/// Does the reader read graphic style `g` from style text `text` as it is? It leaves out a graphic
/// style with a brush on a stroke that paints.
fn panel_reads(g: &GraphicStyle, text: &str) -> bool {
if g.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.brush.is_some() && !s.paint.is_none())) {
return false;
}
let section = known_style("x", text);
let Some(read) = crate::import::read_art_style(section.as_bytes(), "x", None) else { return false };
// The opacity within the written number's precision.
@@ -918,7 +942,7 @@ fn normalized_params(e: &Effect) -> Value {
const NEAR: f64 = 6e-3;
/// JSON values equal but for numbers within the written numbers' precision.
fn near(a: &Value, b: &Value) -> bool {
pub(super) fn near(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Number(x), Value::Number(y)) => match (x.as_f64(), y.as_f64()) {
(Some(x), Some(y)) => (x - y).abs() <= NEAR,
+2 -2
View File
@@ -86,8 +86,8 @@ pub use ai::NameEncoding;
#[cfg(test)]
pub(crate) use ai::objects_read;
pub(crate) use ai::{
MAX_EDITING_OBJECTS, MAX_GRADIENT_STOPS, MAX_LISTED, MAX_LISTED_NAME, MAX_SYMBOLS, read_art_style, read_style_list, style_moves_with,
symbol_art_member, warp_number,
BRUSH_MANAGER, BrushesRead, MAX_EDITING_OBJECTS, MAX_GRADIENT_STOPS, MAX_LISTED, MAX_LISTED_NAME, MAX_SYMBOLS, brush_plugin_name, brushes_kept,
read_art_style, read_brush_object, read_style_list, style_moves_with, symbol_art_member, warp_number,
};
pub(crate) use ate::{MAX_BYTES as MAX_TEXT_DOCUMENT, MAX_FRAMES, MAX_SEGMENTS, MAX_STORY, MAX_VALUES as MAX_TEXT_VALUES};
pub use native::{AiLayers, ai_alone, ai_alone_on_page, ai_alone_with, ai_layers_alone, ai_opened_artboard, is_loss, layered_ai, layered_ai_from};
+1
View File
@@ -34,6 +34,7 @@ use std::io::Read as _;
use super::lex::find;
use crate::ps;
pub(crate) use brush::{BrushesRead, MANAGER_NAME as BRUSH_MANAGER, brushes_kept, plugin_name as brush_plugin_name, read_brush_object};
pub(crate) use envelope::DRAWN as ENVELOPE_DRAWN;
#[cfg(test)]
pub(crate) use envelope::MAX_CHECKED;
+124
View File
@@ -563,3 +563,127 @@ pub(super) fn without_frame(art: Node) -> Node {
}
out
}
/// The plug-in name the objects of brushes of kind `kind` have, for writers.
pub(crate) fn plugin_name(kind: &BrushKind) -> &'static str {
let tool = match kind {
BrushKind::Calligraphic(_) => Tool::Calligraphic,
BrushKind::Scatter(_) => Tool::Scatter,
BrushKind::Art(_) => Tool::Art,
BrushKind::Pattern(_) => Tool::Pattern,
BrushKind::Bristle(_) => Tool::Bristle,
};
TOOLS.iter().find(|(_, t)| *t == tool).map_or("", |(n, _)| *n)
}
/// The plug-in name of the brush manager's order, for writers.
pub(crate) const MANAGER_NAME: &str = MANAGER;
/// A brush object as the reader reads it, for writers that check a brush before they write it.
#[derive(Clone, Debug)]
pub(crate) struct BrushRead {
/// The brush the Brushes panel gets.
pub brush: Brush,
/// A path whose art style names the brush, at the brush's own settings, opens with the brush on
/// its stroke: a Calligraphic brush, or an Art brush whose art an Art brush draws as the file
/// does ([`art_bends`]) and whose numbers are those of a brush that stretches its art along the
/// path, unflipped, at 100% in Tints.
pub live: bool,
}
/// The brush named `name` whose object has the plug-in name `plugin` and the parameters `params`,
/// with `art` as the art its parameters name (as the reader reads that art), as the reader reads
/// it: `None` when the reader doesn't make a brush of it.
pub(crate) fn read_brush_object(plugin: &str, name: &str, params: &str, art: Option<&Node>) -> Option<BrushRead> {
let draft = parse_tool_object(tool(plugin)?, name, params).ok()?;
let mut sections = HashMap::new();
if let (DraftKind::Scatter { art: section, .. } | DraftKind::Art { art: section, .. }, Some(a)) = (&draft.kind, art) {
sections.insert(section.clone(), a.clone());
}
let drafts = [draft];
let live = kept(&drafts, &sections).first().copied().unwrap_or(false)
&& match &drafts[0].kind {
DraftKind::Calligraphic(_) => true,
DraftKind::Art { plain: true, art: section, .. } => bending_art(&drafts, &sections).contains(section),
_ => false,
};
let [draft] = drafts;
let (mut brushes, _) = finish_brushes(vec![draft], &sections, None);
Some(BrushRead { brush: brushes.pop()?, live })
}
/// Which of the brush objects `brushes` (plug-in name, name, parameters, the art each names as the
/// reader reads it) the reader makes into brushes when one file holds them all: not one it can't read,
/// nor one past the art the reader copies into one file's brushes ([`kept`]).
pub(crate) fn brushes_kept(brushes: &[(&str, &str, &str, Option<&Node>)]) -> Vec<bool> {
let mut drafts = vec![];
let mut at = vec![];
let mut sections = HashMap::new();
for (i, (plugin, name, params, art)) in brushes.iter().enumerate() {
let Some(d) = tool(plugin).and_then(|t| parse_tool_object(t, name, params).ok()) else { continue };
if let (DraftKind::Scatter { art: s, .. } | DraftKind::Art { art: s, .. }, Some(a)) = (&d.kind, art) {
sections.insert(s.clone(), (*a).clone());
}
drafts.push(d);
at.push(i);
}
let mut out = vec![false; brushes.len()];
for (i, k) in at.into_iter().zip(kept(&drafts, &sections)) {
if let Some(slot) = out.get_mut(i) {
*slot = k;
}
}
out
}
/// Brush objects a writer writes, as the reader reads them together from one file, for checking
/// the art styles that name them ([`Self::style_reads`]).
pub(crate) struct BrushesRead {
drafts: Vec<BrushDraft>,
/// The brush a stroke that names a brush is drawn with, by name: the first one kept
/// ([`kept`]), as an index in [`Self::drafts`].
by_name: HashMap<String, usize>,
/// The art an Art brush draws as the file does ([`bending_art`]).
bending: HashSet<String>,
}
impl BrushesRead {
/// `brushes`: the brush objects written (plug-in name, name, parameters) and the art each names,
/// as the reader reads it.
pub(crate) fn new(brushes: &[(&str, &str, &str, Option<&Node>)]) -> Self {
let mut drafts = vec![];
let mut sections = HashMap::new();
for (plugin, name, params, art) in brushes {
let Some(d) = tool(plugin).and_then(|t| parse_tool_object(t, name, params).ok()) else { continue };
if let (DraftKind::Scatter { art: s, .. } | DraftKind::Art { art: s, .. }, Some(a)) = (&d.kind, art) {
sections.insert(s.clone(), (*a).clone());
}
drafts.push(d);
}
let mut by_name = HashMap::new();
for (i, (d, k)) in drafts.iter().zip(kept(&drafts, &sections)).enumerate() {
if k {
by_name.entry(d.name.clone()).or_insert(i);
}
}
let bending = bending_art(&drafts, &sections);
Self { drafts, by_name, bending }
}
/// Does the reader read every stroke of art style `style` in `section` (the text between
/// `%AI9_BeginArtStyles` and its end) that names a brush with that brush on it, at the brush's
/// own settings? A style the reader doesn't read, or that names a brush no object gives, or an
/// Art brush in a style with effects, isn't read so.
pub(crate) fn style_reads(&self, section: &[u8], style: &str) -> bool {
use super::style::StyleItem;
let styles = super::style::art_styles(section);
let Some(st) = styles.get(style).filter(|st| st.plain) else { return false };
st.items.iter().all(|item| match item {
StyleItem::Stroke { brush: Some((name, settings)), .. } => {
let Some(draft) = self.by_name.get(name).and_then(|i| self.drafts.get(*i)) else { return false };
draws_as(draft, settings, &self.bending) && !(matches!(settings, PathBrush::Art) && !st.effects.is_empty())
}
_ => true,
})
}
}
+20 -3
View File
@@ -1237,8 +1237,11 @@ pub(crate) fn read_style_list(section: &[u8]) -> Vec<String> {
/// Art style `name` of `section` as the reader reads it ([`StyleRead`]): [`appearance_from_art_style`],
/// with a style's one gradient fill as `own_gradient`, the object's own gradient, as [`styled`] reads
/// it on objects other than type. `None` when the section doesn't define it, the reader doesn't read
/// it, or it paints with a pattern, a brush or a gradient that isn't the object's own.
/// it on objects other than type. A stroke that names a brush is read with that brush's name, as
/// [`styled`] reads it on a path or compound path when the Brushes panel keeps that brush at those
/// settings, which [`crate::import::ai::brush::BrushesRead::style_reads`] checks. `None` when the section
/// doesn't define it, the reader doesn't read it, or it paints with a pattern or a gradient that
/// isn't the object's own.
pub(crate) fn read_art_style(section: &[u8], name: &str, own_gradient: Option<&Paint>) -> Option<StyleRead> {
use crate::import::ai::style::StyleItem;
let mut st = crate::import::ai::style::art_styles(section).remove(name)?;
@@ -1250,7 +1253,21 @@ pub(crate) fn read_art_style(section: &[u8], name: &str, own_gradient: Option<&P
}
}
}
let appearance = appearance_from_art_style(&st)?;
// The brush names, by item; `appearance_from_art_style` reads a style's items in order.
let brushes: Vec<Option<String>> = st
.items
.iter_mut()
.map(|item| match item {
StyleItem::Stroke { brush, .. } => brush.take().map(|(name, _)| name),
_ => None,
})
.collect();
let mut appearance = appearance_from_art_style(&st)?;
for (item, brush) in appearance.items.iter_mut().zip(brushes) {
if let (AppearanceItem::Stroke(s), Some(brush)) = (item, brush) {
s.brush = Some(brush);
}
}
Some(StyleRead { appearance, simple: st.simple, pathfinder: st.pathfinder, transparency: st.transparency })
}
+3 -32
View File
@@ -18,7 +18,6 @@ use vectorcraft_geom::BezPath;
use super::interp::{Interp, matrix_obj};
use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
use super::predefined_cmap::Unicode;
/// Most codespace ranges, character and notdef mappings a CMap may hold.
const MAX_RANGES: usize = 1 << 16;
@@ -211,32 +210,6 @@ fn number(data: &[u8], at: usize, n: usize) -> Option<u64> {
(n <= 8).then(|| bytes.iter().fold(0u64, |v, b| v << 8 | u64::from(*b)))
}
/// The encoding of predefined Unicode CMap `name` and whether it is vertical: one of Adobe's
/// public CMap resources whose name says its codes are Unicode: `Uni` and a character
/// collection, then `-UCS2`, `-UTF8`, `-UTF16` or `-UTF32` (and `-HW` for half-width forms),
/// then `-H` or `-V` (`UniJIS-UCS2-H`, `UniGB-UTF16-V`:
/// <https://github.com/adobe-type-tools/cmap-resources>).
pub(super) fn unicode_cmap(name: &str) -> Option<(Unicode, bool)> {
let (rest, dir) = name.rsplit_once('-')?;
let vertical = match dir {
"H" => false,
"V" => true,
_ => return None,
};
let rest = rest.strip_suffix("-HW").unwrap_or(rest);
let (collection, form) = rest.rsplit_once('-')?;
if !(collection.len() > 3 && collection.starts_with("Uni") && !collection.contains('-')) {
return None;
}
let form = match form {
"UCS2" | "UTF16" => Unicode::Utf16,
"UTF8" => Unicode::Utf8,
"UTF32" => Unicode::Utf32,
_ => return None,
};
Some((form, vertical))
}
/// A predefined Identity CMap: two-byte codes, each the CID of its own value; vertical for
/// `Identity-V`.
pub(super) fn identity(name: &str, vertical: bool) -> Obj {
@@ -396,11 +369,9 @@ impl Interp<'_> {
return Ok(d.clone());
}
let text = name.text().map(|t| t.to_string()).unwrap_or_default();
// Another predefined CMap the file doesn't define, without its mappings: its codes are
// read by its name when type is set (see `text`).
let predefined = unicode_cmap(&text)
.map(|(_, vertical)| vertical)
.or_else(|| super::predefined_cmap::known(&text).then(|| super::predefined_cmap::vertical(&text)));
// A predefined CMap the file doesn't define, without its mappings: its codes are read by
// its name when type is set (see `text`).
let predefined = super::predefined_cmap::known(&text).then(|| super::predefined_cmap::vertical(&text));
match predefined {
Some(vertical) => {
let mut d = Dict::new();
+4
View File
@@ -95,6 +95,9 @@ pub(crate) struct Interp<'a> {
/// The predefined CMaps type was set in so far, by name, with how their strings decode
/// (`None` when one can't be read; see `text`).
pub predefined_cmaps: Vec<(Rc<str>, Option<Rc<super::predefined_cmap::CMapCodes>>)>,
/// The font a `kshow` procedure sees as current while type in a CIDFont only named is set in
/// a font of its own (see `text`).
pub kshow_font: Option<DictRef>,
pub g: GState,
pub saved: Vec<GState>,
pub out: Out,
@@ -236,6 +239,7 @@ impl<'a> Interp<'a> {
cid_subrs: vec![],
cmap_font: 0,
predefined_cmaps: vec![],
kshow_font: None,
type42_counted: HashSet::new(),
g,
saved: vec![],
+23 -1
View File
@@ -157,7 +157,7 @@ pub(super) enum Unicode {
/// The encoding of predefined Unicode CMap `name`: `Uni` and a character collection, then `-UCS2`,
/// `-UTF8`, `-UTF16` or `-UTF32` (and `-HW` for half-width forms), then `-H` or `-V`
/// (`UniJIS-UCS2-H`, `UniGB-UTF16-V`: <https://github.com/adobe-type-tools/cmap-resources>).
fn unicode_cmap(name: &str) -> Option<Unicode> {
pub(super) fn unicode_cmap(name: &str) -> Option<Unicode> {
let rest = name.strip_suffix("-H").or_else(|| name.strip_suffix("-V"))?;
let rest = rest.strip_suffix("-HW").unwrap_or(rest);
let (collection, form) = rest.rsplit_once('-')?;
@@ -325,6 +325,28 @@ pub(super) fn known(cmap: &str) -> bool {
unicode_cmap(cmap).is_some() || predefined(cmap).is_some() || vertical_of_predefined() || other()
}
/// The codes of string `bytes` in predefined CMap `cmap` when its mappings can't be read, each
/// standing for no character: as long as the code space range it falls in ([`code_space`]; a byte
/// that starts no code is a code of its own), or two bytes when the code space isn't listed (the
/// row-and-cell codes of `GBT-H` and `CNS2-H`). A 0x0D or 0x09 byte is always a code of its own.
pub(super) fn unread_codes(cmap: &str, bytes: &[u8]) -> Decoded {
let space = code_space(cmap);
let mut out = Decoded::default();
let mut at = 0;
while let Some(rest) = bytes.get(at..).filter(|r| !r.is_empty()) {
let len = match space {
// A 0x0D or 0x09 byte is a code of its own, as [`CMapCodes::each_code`] reads it.
_ if rest.first().and_then(|&b| control(b)).is_some() => 1,
Some(space) => code_len(space, rest).map_or(1, usize::from),
None => 2,
};
let code = rest.get(..len).unwrap_or(rest);
out.push(code.iter().fold(0u32, |c, &b| c << 8 | u32::from(b)), None);
at += code.len();
}
out
}
/// Whether predefined CMap `cmap` is a vertical CMap (`-V`, or the row-and-cell `V`).
pub(super) fn vertical(cmap: &str) -> bool {
cmap == "V" || cmap.ends_with("-V")
+103 -11
View File
@@ -426,8 +426,6 @@ fn named_cidfonts_over_predefined_cmaps_set_their_characters_as_type() {
("83pv-RKSJ-H", "93fa967b41", "日本A"),
("90ms-RKSJ-H", "93fa", "日"),
("EUC-H", "c6fc", "日"),
// JIS row and cell: 日 is 0x467C.
("H", "467c", "日"),
("GBK-EUC-H", "d6d0", "中"),
("B5pc-H", "a4a4", "中"),
("ETen-B5-H", "a4a4", "中"),
@@ -448,6 +446,9 @@ fn named_cidfonts_over_predefined_cmaps_set_their_characters_as_type() {
}
let r = super::tests::read("/X /GBK-EUC-H [/NotInFile] composefont 20 scalefont setfont 10 20 moveto <d6d041> show");
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<String>(), "中A");
// JIS row and cell: 日 is 0x467C.
let r = super::tests::read("/X /H [/Ryumin-Light] composefont 20 scalefont setfont 10 20 moveto <467c> show");
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<String>(), "日");
// The point moves past the type, along the line.
check("/Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont <93fa967b> stringwidth abs 0.01 lt exch dup 5 gt exch 60 lt and and");
}
@@ -478,8 +479,34 @@ fn named_cidfonts_over_predefined_cmaps_take_the_show_operators_spacing() {
measured(&format!(
"{gb} 10 20 moveto <56505650> show currentpoint pop 10 20 moveto 7 0 16#5650 <56505650> widthshow currentpoint pop sub -14 sub abs 0.01 lt"
));
// `xshow` moves 30 a code.
// `awidthshow` adds 5 to each code and 7 more to the space.
measured(&format!(
"{set} 10 20 moveto <93fa20967b> show currentpoint pop 10 20 moveto 7 0 32 5 0 <93fa20967b> awidthshow currentpoint pop sub -22 sub abs 0.01 lt"
));
// `xshow` moves 30 a code, `yshow` 10 up a code, `xyshow` both.
measured(&format!("{set} 10 20 moveto <93fa967b> [30 30] xshow currentpoint pop 70 sub abs 0.01 lt"));
measured(&format!("{set} 10 20 moveto <93fa967b> [10 10] yshow currentpoint 40 sub abs 0.01 lt exch 10 sub abs 0.01 lt and"));
measured(&format!("{set} 10 20 moveto <93fa967b> [30 10 30 10] xyshow currentpoint 40 sub abs 0.01 lt exch 70 sub abs 0.01 lt and"));
// `kshow` runs its procedure between each two codes: it moves the point 100 more here, and a
// font it sets stays current.
measured(&format!(
"{set} 10 20 moveto <93fa967b> show currentpoint 10 20 moveto {{pop pop 100 0 rmoveto}} <93fa967b> kshow currentpoint \
3 -1 roll sub abs 0.01 lt 3 1 roll sub -100 sub abs 0.01 lt and"
));
measured(&format!(
"{set} 10 20 moveto {{pop pop /Helvetica findfont 10 scalefont setfont}} <93fa967b> kshow currentfont /FontName get /Helvetica eq"
));
// The procedure sees the font the file set as current, and the next one the font an earlier
// one set.
measured(&format!("{set} 10 20 moveto {{pop pop currentfont /FontName get /seen exch def}} <93fa967b> kshow seen /Ryumin-Light-90ms-RKSJ-H eq"));
measured(&format!(
"{set} 10 20 moveto /n 0 def {{pop pop /n n 1 add def n 1 eq {{/Helvetica findfont 10 scalefont setfont}} {{currentfont /FontName get /seen exch def}} ifelse}} \
<93fa967b41> kshow seen /Helvetica eq"
));
// The procedure gets the two codes' values (left on the stack here).
measured(&format!(
"{set} 10 20 moveto [ {{}} <93fa967b41> kshow ] dup length 4 eq exch aload pop 65 eq exch 16#967b eq and exch 16#967b eq and exch 16#93fa eq and and"
));
// Down the column: `ashow`'s 5 down each code.
let set = "/Ryumin-Light-90ms-RKSJ-V findfont 20 scalefont setfont";
measured(&format!(
@@ -530,10 +557,15 @@ fn named_cid_type_is_set_alike_by_every_show_operator() {
let r = super::tests::read(&format!("{set} <00660069> {show}"));
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["fi"], "{show}");
t[0].runs.iter().map(|r| r.style.features.clone()).collect::<Vec<_>>()
// Spacing that differs from the advances splits the type into runs of the same features.
let mut features = t[0].runs.iter().map(|r| r.style.features.clone()).collect::<Vec<_>>();
features.dedup();
features
};
let plain = features("show");
assert_eq!(plain, features("0 0 3 -1 roll ashow"));
for show in ["0 0 3 -1 roll ashow", "0 0 32 4 -1 roll widthshow", "0 0 32 0 0 6 -1 roll awidthshow", "[25 25] xshow", "{pop pop} exch kshow"] {
assert_eq!(plain, features(show), "{show}");
}
assert!(plain.iter().all(|f| f.iter().any(|f| f == "-liga")), "{plain:?}");
check(&format!(
"gsave nulldevice {set} <00660069> stringwidth 10 20 moveto 0 0 <00660069> ashow currentpoint grestore \
@@ -541,17 +573,77 @@ fn named_cid_type_is_set_alike_by_every_show_operator() {
));
}
/// A font name ending in the row-and-cell CMap `H` after a name without a hyphen stays a font of
/// the whole name, its strings read byte by byte. Type in a predefined CMap whose mappings aren't
/// available is left out with a warning, and a long string in a CID-keyed font over a predefined
/// CMap shown in a loop runs out of the budget.
/// `charpath`, `cshow` and `glyphshow` in a CID-keyed font over a predefined CMap, its CIDFont only
/// named: `charpath` adds the outlines of the characters the codes stand for and moves the point
/// as `show` does; `cshow`'s procedure gets each code (two bytes for a two-byte code) with its
/// width; `glyphshow` sets the named character itself.
#[test]
fn named_cid_type_in_charpath_cshow_and_glyphshow() {
let set = "/Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont";
let r = super::tests::read(&format!("{set} 10 20 moveto <4142> true charpath fill"));
assert!(texts(&r).is_empty(), "{:?}", all(&r.document));
assert!(all(&r.document).iter().any(|n| matches!(n.kind, NodeKind::Path { .. })), "{:?}", all(&r.document));
check(&format!(
"gsave nulldevice {set} 10 20 moveto <93fa41> show currentpoint newpath 10 20 moveto <93fa41> false charpath currentpoint grestore \
3 -1 roll sub abs 0.01 lt 3 1 roll sub abs 0.01 lt and"
));
// Down a column a code that stands for no character (0xFD) moves the outlines one em, as it
// moves the type `show` sets.
let top = |s: &str| format!("newpath 10 100 moveto <{s}> false charpath pathbbox 4 1 roll pop pop pop");
check(&format!(
"gsave nulldevice /Ryumin-Light-90ms-RKSJ-V findfont 20 scalefont setfont {} {} grestore sub -20 sub abs 0.5 lt",
top("fd41"),
top("41")
));
// The procedure leaves each code: 日 (0x93FA), then A.
check(&format!("{set} [ {{pop pop}} <93fa41> cshow ] dup length 2 eq exch dup 0 get 16#93fa eq exch 1 get 65 eq and and"));
check(&format!("{set} 0 {{pop exch pop add}} <93fa967b41> cshow <93fa967b41> stringwidth pop sub abs 0.01 lt"));
let r = super::tests::read(&format!("{set} 10 20 moveto /uni00E9 glyphshow"));
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["é"]);
}
/// A font name ending in the row-and-cell CMap `H` or `V` stays a font of the whole name, its
/// strings read byte by byte, unless the part before the CMap names a CIDFont the file defines (or
/// an installed face that covers Japanese). Type in a predefined CMap whose mappings aren't
/// available is left out with a warning, each code moving the point one em, and a long string in a
/// CID-keyed font over a predefined CMap shown in a loop runs out of the budget.
#[test]
fn latin_names_ending_in_h_and_cmaps_that_cannot_be_read() {
let r = super::tests::read("/Futura-H findfont 20 scalefont setfont 10 20 moveto (AB) show");
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["AB"]);
for (font, family, style) in [("Futura-H", "Futura", "H"), ("Foo-Bold-H", "Foo", "Bold-H"), ("Foo-Condensed-V", "Foo", "Condensed-V")] {
let r = super::tests::read(&format!("/{font} findfont 20 scalefont setfont 10 20 moveto (AB) show"));
let t = texts(&r);
assert_eq!(t.iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["AB"], "{font}");
let s = &t[0].runs[0].style;
assert_eq!((s.font_family.as_str(), s.font_style.as_str()), (family, style), "{font}");
assert!(!t[0].vertical, "{font}");
}
// The file defines the CIDFont `Ryumin-Light`, as a resource or as a font: `Ryumin-Light-H` is
// it over the CMap `H`.
// A CIDFont name without a hyphen too, when the file defines it.
let cid_font = |name: &str| format!("/{name} << /CIDFontName /{name} /CIDFontType 0 /FontType 9 /FontMatrix [0.001 0 0 0.001 0 0] >>");
let defines = [
format!("{} /CIDFont defineresource pop /Ryumin-Light-H", cid_font("Ryumin-Light")),
format!("{} definefont pop /Ryumin-Light-H", cid_font("Ryumin-Light")),
format!("{} /CIDFont defineresource pop /Foo-H", cid_font("Foo")),
];
for define in defines {
let r = super::tests::read(&format!("{define} findfont 20 scalefont setfont 10 20 moveto <467c> show"));
assert_eq!(texts(&r).iter().map(|t| t.plain_text()).collect::<Vec<_>>(), ["日"], "{define}: {:?}", r.warnings);
}
let r = super::tests::read("/Ryumin-Light-GBT-H findfont 20 scalefont setfont 10 20 moveto (AB) show 0 0 10 10 rectfill");
assert!(texts(&r).is_empty(), "{:?}", all(&r.document));
assert_eq!(super::tests::program_warnings(&r.warnings), [super::text::UNREAD_CMAP], "{:?}", r.warnings);
// Two two-byte codes: two ems along the line, or down the column (a square drawn when the
// point moved that far).
for cond in [
"/Ryumin-Light-GBT-H findfont 20 scalefont setfont <21212121> stringwidth abs 0.01 lt exch 40 sub abs 0.01 lt and",
"/Ryumin-Light-GBT-V findfont 20 scalefont setfont 10 100 moveto <21212121> show currentpoint 60 sub abs 0.01 lt exch 10 sub abs 0.01 lt and",
// A tab is a code of its own: three codes.
"/Ryumin-Light-GBT-H findfont 20 scalefont setfont <09092121> stringwidth abs 0.01 lt exch 60 sub abs 0.01 lt and",
] {
let r = super::tests::read(&format!("{cond} {{ 0 0 10 10 rectfill }} if"));
assert!(all(&r.document).iter().any(|n| matches!(n.kind, NodeKind::Path { .. })), "{cond}");
}
super::tests::runs_out_of_budget("/Ryumin-Light-90ms-RKSJ-H findfont 20 scalefont setfont { 100000 string stringwidth pop pop } loop");
}
+213 -79
View File
@@ -171,8 +171,8 @@ impl Interp<'_> {
ResourceForAll => self.resource_for_all()?,
Show | AShow | WidthShow | AWidthShow | XShow | YShow | XYShow | KShow => {
let (s, spacing) = self.show_operands(op)?;
if let Some((codes, font, vertical)) = self.named_cid_type(&s)? {
self.show_named_cid(&codes, &font, vertical, &spacing)?;
if let Some(named) = self.named_cid_type(&s)? {
self.show_named_cid(&named, &spacing, Draw::Fill)?;
} else if let Some(glyphs) = self.composite_glyphs(&s)? {
self.show_composite(&glyphs, &spacing)?;
} else {
@@ -186,6 +186,23 @@ impl Interp<'_> {
// The procedure shows or places each character: it gets its code and width.
let s = self.pop_str()?.to_vec();
let proc = self.pop_proc()?;
// In a CIDFont only named, a code may be several bytes: the procedure gets each
// code's value.
if let Some(named) = self.named_cid_type(&s)? {
let mut chars = named.codes.text.chars();
for &(code, n) in &named.codes.codes {
let mut one = Decoded::default();
one.push(code, chars.by_ref().take(n));
let v = self.named_cid_width(&named, &one)?;
self.push(Obj::Int(i64::from(code)))?;
self.push_num(v.x)?;
self.push_num(v.y)?;
if !self.body(&proc)? {
break;
}
}
return Ok(());
}
for b in s {
let v = self.width_of(&[b])?;
self.push(Obj::Int(i64::from(b)))?;
@@ -208,7 +225,14 @@ impl Interp<'_> {
}
None => {
let ch = glyph_char(&name);
self.show(ch.encode_utf8(&mut [0; 4]).as_bytes())?;
// In a CIDFont only named, the character is set as it is, not read through
// the CMap.
if let Some(mut named) = self.named_cid_font()? {
named.codes.push(0, Some(ch).filter(|c| !c.is_control()));
self.show_named_cid(&named, &Spacing::Plain, Draw::Fill)?;
} else {
self.show(ch.encode_utf8(&mut [0; 4]).as_bytes())?;
}
}
}
}
@@ -283,11 +307,8 @@ impl Interp<'_> {
/// How far `s` moves the current point (user space).
fn width_of(&mut self, s: &[u8]) -> Res<Vec2> {
if let Some((codes, font, vertical)) = self.named_cid_type(s)? {
let saved = self.g.font.replace(font);
let r = self.named_cid_width(&codes, vertical);
self.g.font = saved;
return r;
if let Some(named) = self.named_cid_type(s)? {
return self.named_cid_width(&named, &named.codes);
}
if let Some(glyphs) = self.composite_glyphs(s)? {
let mut w = Vec2::ZERO;
@@ -399,25 +420,23 @@ impl Interp<'_> {
/// is a predefined CMap, the CID-keyed font of those two (the usual name of a CID-keyed font,
/// as `composefont` makes them: PLRM 3rd ed., chapter 8; the CMaps are Adobe's public CMap
/// resources, <https://github.com/adobe-type-tools/cmap-resources>); else a font of that name.
/// A name an installed face has is that face's, and a name split at a bare `H` or `V` (the
/// row-and-cell CMaps) needs a CIDFont name with a hyphen in it (`Ryumin-Light-H`), so
/// `Futura-H` stays a font of that name.
/// A name that ends in a predefined CMap other than a Unicode CMap and that an installed face
/// has is that face's ([`Self::predefined_split`]).
fn find_font(&mut self, k: &Obj) -> Res<DictRef> {
let key = k.key().ok_or(PsError::Ps("typecheck", "findfont".into()))?;
if let Some(Obj::Dict(d)) = self.fonts.borrow().get(&key) {
return Ok(d.clone());
}
let text = k.text().map(|t| t.to_string()).unwrap_or_default();
let split = text
let unicode = text
.match_indices('-')
.map(|(i, _)| i)
.find(|&i| i > 0 && super::cid::unicode_cmap(text.get(i + 1..).unwrap_or_default()).is_some())
.and_then(|i| Some((text.get(..i)?, text.get(i + 1..)?)))
.or_else(|| {
let (cid_font, cmap) = super::predefined_cmap::composite_font(&text)?;
let installed = vectorcraft_text::FontDb::global().find_postscript(&text).is_some();
(!installed && !(matches!(cmap, "H" | "V") && !cid_font.contains('-'))).then_some((cid_font, cmap))
});
.find(|&i| i > 0 && super::predefined_cmap::unicode_cmap(text.get(i + 1..).unwrap_or_default()).is_some())
.and_then(|i| Some((text.get(..i)?, text.get(i + 1..)?)));
let split = match unicode {
Some(split) => Some(split),
None => self.predefined_split(&text),
};
if let Some((cid_font, cmap)) = split {
let cmap = self.find_cmap(&Obj::name(cmap))?;
let dep = self.find_cid_font(&Obj::name(cid_font))?;
@@ -434,6 +453,32 @@ impl Interp<'_> {
Ok(font)
}
/// Font name `name` as a CIDFont's name and the name of a predefined CMap other than a Unicode
/// CMap ([`super::predefined_cmap::composite_font`]), unless an installed face has the whole
/// name. A name that ends in the row-and-cell CMap `H` or `V` splits only when the part before
/// it names a CIDFont the file defines, or has a hyphen and names an installed face that covers
/// Japanese; otherwise it stays a font of the whole name (`Futura-H`, `Foo-Bold-H`), its
/// strings read byte by byte.
fn predefined_split<'a>(&mut self, name: &'a str) -> Option<(&'a str, &'a str)> {
let (cid_font, cmap) = super::predefined_cmap::composite_font(name)?;
let db = vectorcraft_text::FontDb::global();
if db.find_postscript(name).is_some() {
return None;
}
if matches!(cmap, "H" | "V") {
let key = Key::name(cid_font);
// As a CIDFont resource, or as a font (`definefont`), as `composefont` finds it.
let cid_font_in = |d: &DictRef| matches!(d.borrow().get(&key), Some(Obj::Dict(f)) if f.borrow().contains_key(&Key::name("CIDFontType")));
let defined = self.instances(&Obj::name("CIDFont")).is_ok_and(|d| d.borrow().contains_key(&key)) || cid_font_in(&self.fonts);
// 日 is in the row-and-cell CMaps' character set (JIS X 0208).
let installed = || db.find_postscript(cid_font).is_some_and(|face| face.covers('日'));
if !(defined || (cid_font.contains('-') && installed())) {
return None;
}
}
Some((cid_font, cmap))
}
/// The current font's name and its matrix for a font of one unit (user space).
fn font(&mut self) -> Res<(String, Affine)> {
let font = match self.g.font.clone() {
@@ -575,15 +620,25 @@ impl Interp<'_> {
codes.push(u32::from(code), c.filter(|c| !c.is_control()));
}
let widths: Option<Vec<f64>> = plain.map(|(_, glyphs)| glyphs.iter().map(|g| g.width).collect());
self.show_codes(&codes, widths.as_deref(), spacing, false, s)
self.show_codes(&codes, widths.as_deref(), spacing, false, s, Draw::Fill)
}
/// The codes `codes` (each standing for some of its characters, or none) shown in the current
/// font as [`Self::show_plain`] shows a string's, spaced as `spacing` says, each code `widths`
/// wide when given (in glyph space, one unit an em), else as wide as its characters' advances;
/// as vertical type when `vertical`, the codes moving the point down the column. `kern` is the
/// string `kshow` gives its procedure the codes of.
fn show_codes(&mut self, codes: &Decoded, widths: Option<&[f64]>, spacing: &Spacing, vertical: bool, kern: &[u8]) -> Res {
/// as vertical type when `vertical`, the codes moving the point down the column. `kern` holds
/// the codes `kshow` gives its procedure, one for each code. With `draw` [`Draw::Path`] the
/// type's glyph outlines are added to the current path, placed as the type would be
/// (`charpath`).
fn show_codes<C: Copy + Into<i64>>(
&mut self,
codes: &Decoded,
widths: Option<&[f64]>,
spacing: &Spacing,
vertical: bool,
kern: &[C],
draw: Draw,
) -> Res {
let at = self.user_point()?;
let (_, f1) = self.font()?;
let text = &codes.text;
@@ -627,8 +682,9 @@ impl Interp<'_> {
return ps_err("undefinedresult", "a show");
}
let across = moves.iter().any(|m| m.2.abs() > size * 1e-3);
// Nothing shows on the null device (`nulldevice`, a Type 3 glyph only measured).
let painted = !self.g.paint.is_none() && !self.g.null;
// Nothing shows on the null device (`nulldevice`, a Type 3 glyph only measured);
// `charpath` adds the outlines there too.
let painted = draw == Draw::Path || (!self.g.paint.is_none() && !self.g.null);
if across {
// Moves across the baseline (`yshow`, `xyshow`): each character where the file puts it.
let mut pen = at;
@@ -637,8 +693,12 @@ impl Interp<'_> {
let c: String = chars.by_ref().take(n).collect();
if painted && !c.trim().is_empty() {
let (t, ..) = self.set_text_in(&c, pen, vertical)?;
let clips = self.g.clips.clone();
self.out.push(Node::new(NodeId(0), NodeKind::Text(Box::new(t))), &clips);
if draw == Draw::Path {
self.type_path(&t)?;
} else {
let clips = self.g.clips.clone();
self.out.push(Node::new(NodeId(0), NodeKind::Text(Box::new(t))), &clips);
}
}
pen += *d;
}
@@ -686,27 +746,64 @@ impl Interp<'_> {
if lead != Vec2::ZERO {
t.xf = Affine::translate(self.xf() * Point::new(lead.x, lead.y) - self.xf() * Point::ZERO) * t.xf;
}
let clips = self.g.clips.clone();
if self.out.push(Node::new(NodeId(0), NodeKind::Text(Box::new(t))), &clips).is_some()
&& let Some(after) = self.out.drawn.get_mut(start..)
{
after.rotate_right(1);
if draw == Draw::Path {
self.type_path(&t)?;
} else {
let clips = self.g.clips.clone();
if self.out.push(Node::new(NodeId(0), NodeKind::Text(Box::new(t))), &clips).is_some()
&& let Some(after) = self.out.drawn.get_mut(start..)
{
after.rotate_right(1);
}
}
}
self.g.cur = Some(self.xf() * (at + total));
Ok(())
}
/// `kshow` between character `i` of `s` and the next: its procedure run with the two codes
/// and the current point at user point `pen` (PLRM 3rd ed., `kshow`: the procedure may
/// change the current point, as kerning does) → how far it moved the point (user space).
/// The glyph outlines of point type `t` added to the current path (`charpath`).
fn type_path(&mut self, t: &TextObject) -> Res {
let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
for g in &layout.glyphs {
let mut o = g.outline.clone();
o.apply_affine(t.xf);
self.extend_path(o)?;
}
Ok(())
}
/// Glyph outline `o` added to the current path, unless the path would pass its most points.
fn extend_path(&mut self, o: vectorcraft_geom::BezPath) -> Res {
if self.g.path.elements().len().saturating_add(o.elements().len()) > super::graphics::MAX_PATH {
return Err(PsError::Limit("a path has too many points"));
}
self.g.path.extend(o);
Ok(())
}
/// `kshow` between character `i` of `s` (its codes) and the next: its procedure run with the
/// two codes and the current point at user point `pen` (PLRM 3rd ed., `kshow`: the procedure
/// may change the current point, as kerning does) → how far it moved the point (user space).
/// Nothing for other show operators or after the last character.
fn kern(&mut self, spacing: &Spacing, s: &[u8], i: usize, pen: Point) -> Res<Vec2> {
fn kern<C: Copy + Into<i64>>(&mut self, spacing: &Spacing, s: &[C], i: usize, pen: Point) -> Res<Vec2> {
let (Spacing::Kern(p), Some(&code), Some(&next)) = (spacing, s.get(i), s.get(i + 1)) else { return Ok(Vec2::ZERO) };
self.g.cur = Some(self.xf() * pen);
self.push(Obj::Int(i64::from(code)))?;
self.push(Obj::Int(i64::from(next)))?;
self.call(p.clone())?;
self.push(Obj::Int(code.into()))?;
self.push(Obj::Int(next.into()))?;
// The procedure sees the font the file set, not the one type in a CIDFont only named is
// set in; a font it sets stays current.
let Some(outer) = self.kshow_font.take() else {
self.call(p.clone())?;
return Ok(self.user_point()? - pen);
};
let inner = self.g.font.replace(outer.clone());
let r = self.call(p.clone());
// Once the procedure sets a font, it and the later procedures see that one.
if self.g.font.as_ref().is_some_and(|f| f.same(&outer)) {
self.g.font = inner;
self.kshow_font = Some(outer);
}
r?;
Ok(self.user_point()? - pen)
}
@@ -757,15 +854,14 @@ impl Interp<'_> {
if paint == Draw::Fill {
return self.fill_path(outline, vectorcraft_geom::FillRule::NonZero);
}
if self.g.path.elements().len().saturating_add(outline.elements().len()) > super::graphics::MAX_PATH {
return Err(PsError::Limit("a path has too many points"));
}
self.g.path.extend(outline);
Ok(())
self.extend_path(outline)
}
/// `charpath`: the glyph outlines of `s` added to the path.
fn char_path(&mut self, s: &[u8]) -> Res {
if let Some(named) = self.named_cid_type(s)? {
return self.show_named_cid(&named, &Spacing::Plain, Draw::Path);
}
if let Some(glyphs) = self.composite_glyphs(s)? {
for g in &glyphs {
let at = self.user_point()?;
@@ -791,10 +887,9 @@ impl Interp<'_> {
let at = self.user_point()?;
let (t, layout, adv) = self.set_type(s, at)?;
for g in &layout.glyphs {
self.grow()?;
let mut o = g.outline.clone();
o.apply_affine(t.xf);
self.g.path.extend(o);
self.extend_path(o)?;
}
self.g.cur = Some(self.xf() * (at + adv));
Ok(())
@@ -855,6 +950,16 @@ struct Mapped {
vertical: bool,
}
/// Type in a CIDFont only named, over a predefined CMap ([`Interp::named_cid_type`]): its codes
/// with their characters, the font it is set in, whether it runs down a column, and whether each
/// code moves the point one em (down a column, or in a CMap VectorCraft can't read).
struct NamedCid {
codes: Decoded,
font: DictRef,
vertical: bool,
ems: bool,
}
/// What drawing a glyph does with it.
#[derive(Clone, Copy, PartialEq)]
enum Draw {
@@ -986,9 +1091,9 @@ impl Interp<'_> {
/// of that name and its character collection's CID → Unicode CMap (a code it doesn't map
/// stands for none), set as type in the font of its CIDFont's name, vertical over a vertical
/// CMap (`WMode` 1). Control codes stand for no character. Type in a CMap VectorCraft can't
/// read is left out, with a warning.
fn named_cid_type(&mut self, s: &[u8]) -> Res<Option<(Decoded, DictRef, bool)>> {
let Some((cmap, font, name, vertical)) = self.named_cid_parts() else { return Ok(None) };
/// read is left out, with a warning, each of its codes moving the point one em.
fn named_cid_type(&mut self, s: &[u8]) -> Res<Option<NamedCid>> {
let Some(cmap) = self.named_cid_parts().map(|(cmap, ..)| cmap) else { return Ok(None) };
// Each code is looked up in the CMap's mappings.
self.spend(s.len() as u64)?;
// The decoded codes and characters are held while the string is shown: checked against
@@ -996,25 +1101,33 @@ impl Interp<'_> {
let held = s.len().saturating_mul(DECODED_BYTES);
self.alloc(held)?;
self.unalloc(held);
let decoded = match self.predefined_codes(&cmap) {
Some(codes) => codes.codes(s),
let (decoded, read) = match self.predefined_codes(&cmap) {
Some(codes) => (codes.codes(s), true),
None => {
self.out.warn(UNREAD_CMAP);
Decoded::default()
(super::predefined_cmap::unread_codes(&cmap, s), false)
}
};
let mut codes = Decoded::default();
let Some(mut named) = self.named_cid_font()? else { return Ok(None) };
let mut chars = decoded.text.chars();
for &(code, n) in &decoded.codes {
codes.push(code, chars.by_ref().take(n).filter(|c| !c.is_control()));
named.codes.push(code, chars.by_ref().take(n).filter(|c| !c.is_control()));
}
named.ems |= !read;
Ok(Some(named))
}
/// The font [`Self::named_cid_type`] sets type in, with no codes yet, when the current font is
/// a CID-keyed font over a predefined CMap the file doesn't define.
fn named_cid_font(&mut self) -> Res<Option<NamedCid>> {
let Some((_, font, name, vertical)) = self.named_cid_parts() else { return Ok(None) };
// The composite font is copied under the CIDFont's name for every string: charged by
// its size, so a huge font dictionary shown in a loop runs out of the budget.
let entries = font.borrow().len();
self.spend(entries as u64)?;
let mut named = font.borrow().clone();
named.insert(Key::name("FontName"), name);
Ok(Some((codes, DictRef::new(named), vertical)))
Ok(Some(NamedCid { codes: Decoded::default(), font: DictRef::new(named), vertical, ems: vertical }))
}
/// The CMap's name, the composite font, the CIDFont's name and the writing mode of
@@ -1032,7 +1145,7 @@ impl Interp<'_> {
return None;
}
let cmap_name = cmap.get(&Key::name("CMapName")).and_then(Obj::text)?.to_string();
if super::cid::unicode_cmap(&cmap_name).is_none() && !super::predefined_cmap::known(&cmap_name) {
if !super::predefined_cmap::known(&cmap_name) {
return None;
}
let wmode = f.get(&Key::name("WMode")).or_else(|| cmap.get(&Key::name("WMode"))).and_then(Obj::as_num);
@@ -1047,7 +1160,7 @@ impl Interp<'_> {
/// How strings in predefined CMap `cmap` decode (a CMap other than a Unicode CMap read once a
/// file); `None` when VectorCraft can't read it.
fn predefined_codes(&mut self, cmap: &str) -> Option<Rc<super::predefined_cmap::CMapCodes>> {
if let Some((form, _)) = super::cid::unicode_cmap(cmap) {
if let Some(form) = super::predefined_cmap::unicode_cmap(cmap) {
return Some(Rc::new(super::predefined_cmap::CMapCodes::Unicode(form)));
}
if let Some((_, codes)) = self.predefined_cmaps.iter().find(|(n, _)| **n == *cmap) {
@@ -1060,32 +1173,53 @@ impl Interp<'_> {
codes
}
/// The codes `codes` (with their characters) set as point type at the current point in font
/// `font` (see [`Self::named_cid_type`]), running down a column when `vertical`, which moves
/// past them, spaced as `spacing` says, as [`Self::show_codes`] shows them. `widthshow` and
/// `awidthshow` match a code by its value (font number 0 times 256 plus the code: PLRM 3rd ed.,
/// `widthshow` in chapter 8); `kshow`'s procedure isn't run between them (a composite font's
/// codes aren't single bytes). Down a column each code moves the point one em, the default
/// vertical displacement of a CIDFont whose metrics the file doesn't give (PDF Reference 1.7,
/// §5.6.3, `DW2`).
fn show_named_cid(&mut self, codes: &Decoded, font: &DictRef, vertical: bool, spacing: &Spacing) -> Res {
let widths = vertical.then(|| vec![1.0; codes.codes.len()]);
let saved = self.g.font.replace(font.clone());
let r = self.show_codes(codes, widths.as_deref(), spacing, vertical, &[]);
/// Type `named` (see [`Self::named_cid_type`]) set as point type at the current point in its
/// font, running down a column when it is vertical, which moves past it, spaced as `spacing`
/// says, as [`Self::show_codes`] shows codes. `widthshow` and `awidthshow` match a code by its
/// value (font number 0 times 256 plus the code: PLRM 3rd ed., `widthshow` in chapter 8), and
/// `kshow`'s procedure gets the values of the two codes it runs between. Down a column, and in
/// a CMap VectorCraft can't read, each code moves the point one em, the default displacement
/// of a CIDFont whose metrics the file doesn't give (PDF Reference 1.7, §5.6.3, `DW` and
/// `DW2`). With `draw` [`Draw::Path`] the outlines go on the current path (`charpath`).
fn show_named_cid(&mut self, named: &NamedCid, spacing: &Spacing, draw: Draw) -> Res {
let widths = named.ems.then(|| vec![1.0; named.codes.codes.len()]);
let kern: Vec<u32> = match spacing {
Spacing::Kern(_) => named.codes.codes.iter().map(|&(code, _)| code).collect(),
_ => Vec::new(),
};
let saved = self.g.font.replace(named.font.clone());
let before = std::mem::replace(&mut self.kshow_font, saved.clone());
let r = self.show_codes(&named.codes, widths.as_deref(), spacing, named.vertical, &kern, draw);
self.kshow_font = before;
// A font the `kshow` procedure set stays current.
if self.g.font.as_ref().is_none_or(|f| f.same(&named.font)) {
self.g.font = saved;
}
r
}
/// How far codes `codes` of type `named` move the current point (user space) when
/// [`Self::show_named_cid`] shows them with no extra spacing.
fn named_cid_width(&mut self, named: &NamedCid, codes: &Decoded) -> Res<Vec2> {
let saved = self.g.font.replace(named.font.clone());
let r = self.named_cid_moved(codes, named.vertical, named.ems);
self.g.font = saved;
r
}
/// How far the codes `codes` move the current point (user space) when [`Self::show_named_cid`]
/// shows them with no extra spacing.
fn named_cid_width(&mut self, codes: &Decoded, vertical: bool) -> Res<Vec2> {
/// [`Self::named_cid_width`] in the current font: codes `codes`, vertical when `vertical`,
/// each one em when `ems`.
fn named_cid_moved(&mut self, codes: &Decoded, vertical: bool, ems: bool) -> Res<Vec2> {
let (_, f1) = self.font()?;
let moved = if vertical {
Point::new(0.0, -(codes.codes.len() as f64))
} else {
let (t, layout) = self.set_placed_text(&codes.text, Point::ZERO, false)?;
let size = t.runs.first().map_or(1.0, |r| r.style.size);
Point::new(layout.glyphs.iter().map(|g| g.advance).sum::<f64>() / size, 0.0)
let n = codes.codes.len() as f64;
let moved = match (vertical, ems) {
(true, _) => Point::new(0.0, -n),
(false, true) => Point::new(n, 0.0),
(false, false) => {
let (t, layout) = self.set_placed_text(&codes.text, Point::ZERO, false)?;
let size = t.runs.first().map_or(1.0, |r| r.style.size);
Point::new(layout.glyphs.iter().map(|g| g.advance).sum::<f64>() / size, 0.0)
}
};
Ok(f1 * moved - f1 * Point::ZERO)
}
@@ -1393,7 +1527,7 @@ const MISSING_CID_FONT: &str = "CID-keyed type in a font the file doesn't carry
const DECODED_BYTES: usize = 64;
/// The warning for type in a predefined CMap whose mappings VectorCraft doesn't have.
pub(super) const UNREAD_CMAP: &str = "Type in a CMap that couldn't be read was left out";
pub(super) const UNREAD_CMAP: &str = "type in a CMap that couldn't be read was left out";
/// Most Type 42 fonts whose TrueType data is kept between glyphs.
const MAX_TYPE42: usize = 16;
+2
View File
@@ -113,6 +113,8 @@ const PATTERNS: &str = "pattern fills are written as their tiles, clipped to the
const FREEFORM: &str = "freeform gradients are written as their average colour";
const CONIC: &str = "conic gradients are written as solid wedges clipped to the shape (legacy .ai files have no conic gradient)";
const DIAMOND: &str = "diamond gradients are written as four linear gradients clipped to the shape (legacy .ai files have no diamond gradient)";
const SPREAD: &str = "gradients that repeat or reflect are written with their stops repeated across the shape (legacy .ai gradients only pad)";
const SPREAD_CAPPED: &str = "gradients that repeat or reflect are written with at most 256 stops; they pad past those";
/// Wedges a conic gradient is written as: one a degree.
const CONIC_WEDGES: usize = 360;
const STROKES: &str =
+6 -2
View File
@@ -41,8 +41,12 @@ pub(super) fn gradient_def(s: &mut String, w: &Writer, name: &str, g: &Gradient)
s.push_str(" 3 ");
}
}
ps::push_nums(s, &[f64::from(stop.midpoint) * 100.0, f64::from(stop.offset) * 100.0]);
s.push_str("%_Bs\n");
// The ramp point to five decimals of its percent: a gradient's stops repeated many times
// keep their places in each run.
ps::push_num(s, f64::from(stop.midpoint) * 100.0);
s.push(' ');
ps::push_num_places(s, f64::from(stop.offset) * 100.0, 5);
s.push_str(" %_Bs\n");
}
s.push_str("BD\n%AI5_EndGradient\n");
}
+139
View File
@@ -110,6 +110,119 @@ fn conic_gradients_are_written_as_wedges_clipped_to_the_shape() {
}
}
/// The format's gradients pad past their ends: a linear gradient that repeats or reflects is
/// written with its stops repeated across the shape (a definition of its own, not named after the
/// swatch), and a conic one as wedges that repeat with the stops (which print as the canvas
/// draws them), with a warning.
#[test]
fn spread_gradients_are_written_with_their_stops_repeated() {
use vectorcraft_color::{GradientGeom, GradientSpread};
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let linear = |spread| {
let mut g = GradientPaint::new(Gradient { spread, repeats: 3, ..Gradient::new(GradientKind::Linear, stops.clone()) });
// Across the shape: three runs.
g.geom = Some(GradientGeom {
start: vectorcraft_geom::Point::new(20.0, 50.0),
end: vectorcraft_geom::Point::new(180.0, 50.0),
aspect: 1.0,
focal: None,
});
g.swatch = Some("Bands".into());
Paint::Gradient(Box::new(g))
};
for (spread, colors) in [
(GradientSpread::Repeat, ["0 0 1", "1 0 0", "0 0 1", "1 0 0", "0 0 1", "1 0 0"]),
(GradientSpread::Reflect, ["0 0 1", "1 0 0", "1 0 0", "0 0 1", "0 0 1", "1 0 0"]),
] {
let mut doc = Document::new(200.0, 100.0);
let n = shape(&mut doc, shapes::rectangle(Rect::new(20.0, 10.0, 180.0, 90.0)), linear(spread), Paint::None);
let l = doc.layers[0].id;
doc.insert(Some(l), 0, n).unwrap();
let out = write(&doc);
assert!(out.warnings.iter().any(|w| w == SPREAD), "{:?}", out.warnings);
let text = String::from_utf8_lossy(&out.bytes);
assert!(text.contains("(Gradient) 0 6 Bd") && !text.contains("(Bands)"), "{text}");
// A linear definition lists its stops from the last to the first, each RGB stop as
// `c m y k r g b 2 …`.
let def = text.split("(Gradient) 0 6 Bd\n[\n").nth(1).unwrap();
for (line, rgb) in def.lines().take(6).zip(colors) {
assert!(line.contains(&format!(" {rgb} 2 ")), "{spread:?}: {line} lacks {rgb}\n{def}");
}
}
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Reflect, repeats: 3, ..Gradient::new(GradientKind::Conic, stops) });
g.geom = Some(GradientGeom {
start: vectorcraft_geom::Point::new(100.0, 50.0),
end: vectorcraft_geom::Point::new(140.0, 30.0),
aspect: 1.0,
focal: None,
});
let mut doc = Document::new(200.0, 100.0);
let n = shape(&mut doc, shapes::ellipse(Rect::new(20.0, 10.0, 180.0, 90.0)), Paint::Gradient(Box::new(g)), Paint::None);
let l = doc.layers[0].id;
doc.insert(Some(l), 0, n).unwrap();
let text = String::from_utf8_lossy(&write(&doc).bytes).into_owned();
assert!(text.matches("\nf\n").count() >= 3 * CONIC_WEDGES, "a wedge a degree for each run");
}
/// A gradient repeated more times than the reader keeps stops for is written with no more stops
/// than it reads, with a warning, so it opens with every stop that was written.
#[test]
fn many_repeats_are_written_within_the_stops_the_reader_reads() {
use vectorcraft_color::{GradientGeom, GradientSpread};
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
// A run of 0.4 pt across a shape 160 pt wide: 400 runs.
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 100, ..Gradient::new(GradientKind::Linear, stops) });
g.geom = Some(GradientGeom {
start: vectorcraft_geom::Point::new(20.0, 50.0),
end: vectorcraft_geom::Point::new(60.0, 50.0),
aspect: 1.0,
focal: None,
});
let mut doc = Document::new(200.0, 100.0);
let n = shape(&mut doc, shapes::rectangle(Rect::new(20.0, 10.0, 180.0, 90.0)), Paint::Gradient(Box::new(g)), Paint::None);
let l = doc.layers[0].id;
doc.insert(Some(l), 0, n).unwrap();
let out = write(&doc);
assert!(out.warnings.iter().any(|w| w == SPREAD_CAPPED), "{:?}", out.warnings);
let text = String::from_utf8_lossy(&out.bytes).into_owned();
let def = text.split("%AI5_BeginGradient: (Gradient)\n").nth(1).and_then(|d| d.split("%AI5_EndGradient").next()).unwrap();
let written = def.matches(" %_Bs\n").count();
assert!((2..=crate::import::MAX_GRADIENT_STOPS).contains(&written), "{written} stops");
let read = crate::import(&out.bytes).unwrap().document;
let mut stops = None;
read.walk(|n| {
if let (None, Paint::Gradient(g)) = (&stops, n.appearance.fill_paint()) {
stops = Some(g.gradient.stops.len());
}
});
assert_eq!(stops, Some(written), "every stop written is read");
}
/// A radial gradient repeated out from a center far from the shape is written with its ramp points
/// (percent) to five decimals, so its runs keep their places hundreds of runs out.
#[test]
fn far_runs_keep_their_places() {
use vectorcraft_color::{GradientGeom, GradientSpread};
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, ..Gradient::new(GradientKind::Radial, stops) });
// Runs 0.25 pt apart, the shape 480 runs and more from the center.
let c = vectorcraft_geom::Point::new(-100.0, 50.0);
g.geom = Some(GradientGeom { start: c, end: c + vectorcraft_geom::Vec2::new(0.25, 0.0), aspect: 1.0, focal: None });
let bounds = Rect::new(20.0, 10.0, 180.0, 90.0);
let padded = g.gradient.padded_within(&g.geom.unwrap(), bounds, crate::import::MAX_GRADIENT_STOPS).unwrap();
let mut doc = Document::new(200.0, 100.0);
let n = shape(&mut doc, shapes::rectangle(bounds), Paint::Gradient(Box::new(g)), Paint::None);
let l = doc.layers[0].id;
doc.insert(Some(l), 0, n).unwrap();
let text = String::from_utf8_lossy(&write(&doc).bytes).into_owned();
let def = text.split("%AI5_BeginGradient: (Gradient)\n").nth(1).and_then(|d| d.split("%AI5_EndGradient").next()).unwrap();
let ramps: Vec<f64> = def.lines().filter_map(|l| l.strip_suffix(" %_Bs")).map(|l| l.rsplit(' ').next().unwrap().parse().unwrap()).collect();
assert_eq!(ramps.len(), padded.gradient.stops.len());
for (ramp, stop) in ramps.iter().zip(&padded.gradient.stops) {
assert!((ramp / 100.0 - f64::from(stop.offset)).abs() < 2e-7, "{ramp} for {}", stop.offset);
}
}
/// The format has no diamond gradient: a diamond fill, and a diamond stroke (written as its filled
/// outline), are four path objects clipped to the shape, each a linear gradient over a quadrant
/// of the diamond's frame, with a warning; the definition is not named after the swatch.
@@ -139,6 +252,32 @@ fn diamond_gradients_are_written_as_four_linear_gradients_clipped_to_the_shape()
}
}
/// A diamond gradient that repeats is four linear gradients over the quadrants of its frame, each
/// with its stops repeated out to the shape's edge, with a warning.
#[test]
fn a_spread_diamond_repeats_in_each_quadrant() {
use vectorcraft_color::GradientSpread;
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 3, ..Gradient::new(GradientKind::Diamond, stops) });
g.geom = Some(vectorcraft_color::GradientGeom {
start: vectorcraft_geom::Point::new(100.0, 50.0),
end: vectorcraft_geom::Point::new(140.0, 30.0),
aspect: 0.7,
focal: None,
});
let mut doc = Document::new(200.0, 100.0);
let n = shape(&mut doc, shapes::ellipse(Rect::new(20.0, 10.0, 180.0, 90.0)), Paint::Gradient(Box::new(g)), Paint::None);
let l = doc.layers[0].id;
doc.insert(Some(l), 0, n).unwrap();
let out = write(&doc);
assert!(out.warnings.iter().any(|w| w == DIAMOND) && out.warnings.iter().any(|w| w == SPREAD), "{:?}", out.warnings);
let text = String::from_utf8_lossy(&out.bytes).into_owned();
assert_eq!(text.matches(" Bg\n").count(), 4, "a gradient a quadrant");
let defs: Vec<usize> =
text.split("%AI5_BeginGradient: ").skip(1).map(|d| d.split("%AI5_EndGradient").next().unwrap_or("").matches(" %_Bs\n").count()).collect();
assert!(!defs.is_empty() && defs.iter().all(|&n| n >= 6), "stops in each definition: {defs:?}");
}
/// `doc` written with options `o`. Every file the tests write is also run as a PostScript program
/// ([`prints_as`]) and must draw what `doc` draws.
fn write_with(doc: &Document, o: LegacyAiOptions) -> LegacyAiOutput {
+20 -3
View File
@@ -9,7 +9,7 @@ use super::{
ROTATED_TYPE, Rect, STROKES, SUBLAYERS, Shape, StrokeLayer, SubPath, TITLE_AND_COLOR_NAMES, TRANSPARENCY, TYPE, TYPE_ATTRIBUTES, TextKind,
TextObject, UNDECODED, Vec2, Write, ai_ops, latin, ps, stroke,
};
use super::{CONIC, CONIC_WEDGES, DIAMOND};
use super::{CONIC, CONIC_WEDGES, DIAMOND, SPREAD, SPREAD_CAPPED};
pub(super) struct Writer<'a> {
doc: &'a Document,
@@ -487,7 +487,8 @@ impl<'a> Writer<'a> {
self.warn(TRANSPARENCY);
}
let area = path.to_bezpath().bounding_box();
let wedges = g.resolve(area).conic_wedges(area, CONIC_WEDGES, true);
let wedges = g.resolve(area).conic_wedges(area, g.gradient.conic_wedge_count(CONIC_WEDGES), true);
let spread = g.gradient.spreader();
self.line("q");
self.fill_rule(rule);
let several = path.subpaths.len() > 1;
@@ -501,7 +502,7 @@ impl<'a> Writer<'a> {
self.line("*U");
}
for (pts, t) in wedges {
let (color, _) = g.gradient.sample_keep_model(t as f32);
let (color, _) = g.gradient.sample_keep_model(spread(t) as f32);
let wedge = FillLayer { paint: Paint::solid(color), ..f.clone() };
self.path_object(&PathData::single(SubPath::polyline(&pts, true)), FillRule::NonZero, Some(&wedge), None);
}
@@ -678,6 +679,22 @@ impl<'a> Writer<'a> {
/// (its distance a fraction of the radius, at most 1, §3.5.5; `0 0 0 0 Bh` at the center,
/// §3.5.6), `1 (name) x y angle length 1 0 0 1 0 0 Bg`.
fn gradient(&mut self, g: &GradientPaint, bounds: Rect) -> String {
// A gradient that repeats or reflects (the format's gradients pad past their ends): its
// stops repeated as many times as `bounds` needs, in a definition of its own, no more
// stops than the reader reads.
if let Some(padded) = g.gradient.padded_within(&g.resolve(bounds), bounds, crate::import::MAX_GRADIENT_STOPS) {
self.warn(if padded.capped { SPREAD_CAPPED } else { SPREAD });
let geom = padded.geom;
let p = GradientPaint { gradient: padded.gradient, geom: Some(geom), angle: geom.angle_deg(), swatch: None, ..g.clone() };
return self.gradient(&p, bounds);
}
// One whose levels over `bounds` are not finite (a vector of no length): its stops
// repeated along the vector, padding past it.
if g.gradient.is_spread() {
self.warn(SPREAD_CAPPED);
let p = GradientPaint { gradient: g.gradient.unrolled_within(crate::import::MAX_GRADIENT_STOPS).into_owned(), swatch: None, ..g.clone() };
return self.gradient(&p, bounds);
}
let name = self.define(&g.gradient, g.swatch.as_deref());
for stop in &g.gradient.stops {
if stop.opacity < 1.0 {
+27 -5
View File
@@ -33,11 +33,19 @@ pub(crate) fn num(v: f64) -> String {
/// Append [`num`]`(v)` to `s`.
pub(crate) fn push_num(s: &mut String, v: f64) {
// Beyond ~1.8e304 the scaling overflows; such values have no fractional digits to round.
push_num_places(s, v, 4);
}
/// Append `v` to `s` with at most `places` decimals (up to 9), no trailing zeros (0 when not
/// finite).
pub(crate) fn push_num_places(s: &mut String, v: f64, places: u32) {
let places = places.min(9);
let scale = 10f64.powi(places as i32);
// Past where the scaling overflows, values have no fractional digits to round.
let v = if !v.is_finite() {
0.0
} else if (v * 10_000.0).is_finite() {
(v * 10_000.0).round() / 10_000.0
} else if (v * scale).is_finite() {
(v * scale).round() / scale
} else {
v
};
@@ -46,7 +54,7 @@ pub(crate) fn push_num(s: &mut String, v: f64) {
return;
}
let start = s.len();
let _ = write!(s, "{v:.4}");
let _ = write!(s, "{v:.*}", places as usize);
let keep = s[start..].trim_end_matches('0').trim_end_matches('.').len();
s.truncate(start + keep);
}
@@ -291,7 +299,7 @@ pub(crate) fn inflate(data: &[u8], max: u64) -> Option<Vec<u8>> {
#[cfg(test)]
mod tests {
use super::{ascii85, ascii85_decode, num};
use super::{ascii85, ascii85_decode, num, push_num_places};
#[test]
fn ascii85_first_line_never_starts_with_percent() {
@@ -308,4 +316,18 @@ mod tests {
assert!(!s.is_empty() && s.chars().all(|c| c.is_ascii_digit() || c == '-' || c == '.'), "{v}: got {s:?}");
}
}
#[test]
fn numbers_keep_the_decimals_asked_for() {
let places = |v: f64, n: u32| {
let mut s = String::new();
push_num_places(&mut s, v, n);
s
};
assert_eq!(num(0.123_456_78), "0.1235");
assert_eq!(places(0.123_456_78, 7), "0.1234568");
assert_eq!(places(f64::from(0.4f32), 7), "0.4");
assert_eq!(places(2.5, 7), "2.5");
assert_eq!(places(f64::NAN, 7), "0");
}
}
+40 -6
View File
@@ -44,8 +44,12 @@ const SPOT_GRADIENTS_SHARED: &str = "gradients whose spot inks can't share a Dev
const SPOT_GRADIENTS_PERCEPTUAL: &str = "Perceptual gradients of spot colors are written in process colors";
const CONIC_WEDGES: &str = "conic gradients are written as solid wedges (EPS has no conic shading)";
const DIAMOND_QUADRANTS: &str = "diamond gradients are written as four linear gradients (EPS has no diamond shading)";
const SPREAD_CAPPED: &str =
"gradients that repeat or reflect are written with at most 256 runs of their stops (at most 16384 stops); they pad past those";
/// Wedges a conic gradient is written as: one a degree.
const CONIC_WEDGE_COUNT: usize = 360;
/// Decimals of a smooth shading's stitching function bounds (stop offsets, 0 to 1).
const BOUNDS_PLACES: u32 = 7;
/// The most colorants a DeviceN color space may have (PostScript's limit).
const MAX_DEVICE_N: usize = 32;
const MISSING_PATTERN: &str = "missing patterns are written as mid-grey";
@@ -940,6 +944,23 @@ impl<'a> Scene<'a> {
/// both levels; a diamond: four linear gradients, [`Self::diamond_quadrants`]).
fn gradient(&mut self, g: &GradientPaint, bounds: Rect, area: Rect) {
let geom = g.resolve(bounds);
// A linear, radial or diamond gradient that repeats or reflects: PostScript's shadings
// pad past their ends, so its stops are repeated as many times as the area needs.
if let Some(padded) = g.gradient.padded_over(&geom, area) {
if padded.capped {
self.warn(SPREAD_CAPPED);
}
let geom = padded.geom;
let paint = GradientPaint { gradient: padded.gradient, geom: Some(geom), angle: geom.angle_deg(), ..g.clone() };
return self.gradient(&paint, bounds, area);
}
// One whose levels over the area are not finite (a vector of no length): its stops
// repeated along the vector, padding past it.
if g.gradient.is_spread() && g.gradient.kind != GradientKind::Conic {
self.warn(SPREAD_CAPPED);
let paint = GradientPaint { gradient: g.gradient.unrolled().into_owned(), ..g.clone() };
return self.gradient(&paint, bounds, area);
}
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() {
@@ -951,7 +972,7 @@ impl<'a> Scene<'a> {
let space = &space;
let smooth = self.o.level == Level::Three && !self.o.compatible_gradients;
match g.gradient.kind {
GradientKind::Conic => self.conic_steps(&geom, area, space, &stops),
GradientKind::Conic => self.conic_steps(&geom, area, space, &stops, &g.gradient),
GradientKind::Diamond => self.diamond_quadrants(&geom, area, space, &stops, smooth),
GradientKind::Radial => {
let r = geom.length().max(1e-6);
@@ -984,15 +1005,24 @@ impl<'a> Scene<'a> {
/// 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`]).
fn conic_steps(&mut self, geom: &vectorcraft_color::GradientGeom, area: Rect, space: &GradientSpace, stops: &[(f64, Vec<f32>)]) {
/// Stops of `g` that repeat or reflect get that many wedges for each time they run around.
fn conic_steps(
&mut self,
geom: &vectorcraft_color::GradientGeom,
area: Rect,
space: &GradientSpace,
stops: &[(f64, Vec<f32>)],
g: &vectorcraft_color::Gradient,
) {
self.warn(CONIC_WEDGES);
let spread = g.spreader();
let at = |t: f64| match stops.windows(2).find(|w| t <= w[1].0) {
Some(w) if w[1].0 > w[0].0 => mix(&w[0].1, &w[1].1, ((t - w[0].0) / (w[1].0 - w[0].0)).clamp(0.0, 1.0) as f32),
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, CONIC_WEDGE_COUNT, true) {
self.set_comps(space, &at(t));
for (pts, t) in geom.conic_wedges(area, g.conic_wedge_count(CONIC_WEDGE_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]);
self.line(if i == 0 { "newpath moveto" } else { "lineto" });
@@ -1059,8 +1089,12 @@ impl<'a> Scene<'a> {
f.push('\n');
}
f.push_str("] /Bounds [");
let bounds: Vec<f64> = many.iter().skip(1).map(|w| w[0].0).collect();
push_nums(&mut f, &bounds);
// Seven decimals: a gradient's stops repeated hundreds or thousands of times
// (`Gradient::padded_over`) keep their places in each run.
for w in many.iter().skip(1) {
ps::push_num_places(&mut f, w[0].0, BOUNDS_PLACES);
f.push(' ');
}
f.push_str("] /Encode [");
f.push_str(&"0 1 ".repeat(many.len()));
f.push_str("] >>");
+76
View File
@@ -244,6 +244,82 @@ fn diamond_gradients_are_four_linear_gradients_clipped_to_quadrants() {
);
}
/// PostScript's shadings pad past their ends: a linear, radial or diamond gradient that repeats or
/// reflects is written with its stops repeated over the shape, a conic one as wedges that repeat
/// with the stops; read back from the PostScript, each looks as the canvas paints it, at Level 3
/// and Level 2.
#[test]
fn spread_gradients_are_written_with_their_stops_repeated() {
use vectorcraft_color::{GradientGeom, GradientSpread};
let c = Point::new(100.0, 100.0);
let around = GradientGeom { start: c, end: c + vectorcraft_geom::Vec2::new(60.0, -25.0), aspect: 0.7, focal: None };
let cases = [
(GradientKind::Linear, GradientGeom { start: Point::new(70.0, 80.0), end: Point::new(150.0, 110.0), aspect: 1.0, focal: None }),
(GradientKind::Radial, around),
(GradientKind::Radial, GradientGeom { focal: Some(c + vectorcraft_geom::Vec2::new(-15.0, 12.0)), ..around }),
(GradientKind::Conic, around),
(GradientKind::Diamond, around),
];
for (kind, geom) in cases {
for spread in [GradientSpread::Repeat, GradientSpread::Reflect] {
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
let mut g = GradientPaint::new(Gradient { spread, repeats: 3, ..Gradient::new(kind, stops) });
g.geom = Some(geom);
let paint = Paint::Gradient(Box::new(g));
let d = doc_with(|d| vec![path(d, shapes::rectangle(Rect::new(20.0, 20.0, 180.0, 180.0)), paint, Paint::None, 0.0)]);
for o in [opts(&d), EpsOptions { level: Level::Two, ..opts(&d) }] {
let out = export(&d, &o, None, None).unwrap();
let back = import_with(&out.bytes, false).unwrap().document;
let (a, b) = (vectorcraft_testkit::raster::render_artboard(&d), vectorcraft_testkit::raster::render_artboard(&back));
let st = vectorcraft_testkit::raster::perceptual_diff(&a, &b, 12.0);
assert!(
(st.bad_pixels as f64) < 0.03 * st.pixels as f64,
"{kind:?} {spread:?} level {:?}: {} of {} pixels differ",
o.level,
st.bad_pixels,
st.pixels
);
}
}
}
}
/// A gradient that repeats with no stops (a file can hold one) is written as one that pads, to
/// EPS, legacy `.ai` and the `.ai` editing data.
#[test]
fn a_spread_gradient_without_stops_is_written() {
use vectorcraft_color::GradientSpread;
for kind in [GradientKind::Linear, GradientKind::Radial, GradientKind::Conic, GradientKind::Diamond] {
let g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 3, ..Gradient::new(kind, vec![]) });
let paint = Paint::Gradient(Box::new(g));
let d = doc_with(|d| vec![path(d, shapes::rectangle(Rect::new(20.0, 20.0, 180.0, 180.0)), paint.clone(), paint, 4.0)]);
export(&d, &opts(&d), None, None).unwrap();
export_legacy_ai(&d, &LegacyAiOptions::default()).unwrap();
crate::export_ai_editing(&d, &crate::AiEditingOptions::default()).unwrap();
}
}
/// A gradient repeated 256 times across the shape keeps each run's place: the smooth shading's
/// stitching bounds lie where the runs meet, to well under a run's thousandth.
#[test]
fn many_repeats_keep_their_places_in_a_smooth_shading() {
use vectorcraft_color::{GradientGeom, GradientSpread};
let stops = vec![GradientStop::new(0.0, Color::rgb(1.0, 0.0, 0.0)), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))];
// A run of 0.4 pt across a shape 160 pt wide: capped at 256 runs.
let mut g = GradientPaint::new(Gradient { spread: GradientSpread::Repeat, repeats: 100, ..Gradient::new(GradientKind::Linear, stops) });
g.geom = Some(GradientGeom { start: Point::new(20.0, 100.0), end: Point::new(60.0, 100.0), aspect: 1.0, focal: None });
let paint = Paint::Gradient(Box::new(g));
let d = doc_with(|d| vec![path(d, shapes::rectangle(Rect::new(20.0, 20.0, 180.0, 180.0)), paint, Paint::None, 0.0)]);
let page = page_of(&d, &opts(&d));
let bounds: Vec<f64> =
page.split("/Bounds [").nth(1).and_then(|s| s.split(']').next()).unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();
let runs = (bounds.len() + 1) as f64;
assert_eq!(runs, 256.0, "{bounds:?}");
for b in bounds {
assert!((b * runs - (b * runs).round()).abs() < 1e-3, "bound {b} is {} runs along", b * runs);
}
}
#[test]
fn strokes_keep_their_caps_joins_and_dashes() {
let d = doc_with(|d| {
+2 -2
View File
@@ -404,7 +404,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"view.actualSize",
"Actual Size",
"Cmd+1",
"{} 100%: with Display Print Size at 100% Zoom off, one document point per screen point; on, one document inch fills 96 screen points (an inch at the system's reference density, whatever the display scaling)",
"{} 100%: with Display Print Size at 100% Zoom off, one document point per screen point; on, one document inch fills 96 screen points (an inch at the system's reference density, whatever the display scaling); the same at every UI Scaling",
),
("view.setZoom", "Set Zoom", "", "{zoom: percent, center?: [x,y]}"),
(
@@ -801,7 +801,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"ui.sampleScreenColor",
"Sample Color from Screen",
"",
"{} or {stroke?: bool (default: the active proxy), picker?: bool (the open Color Picker instead)} show the system's color sampler (macOS; browsers with an EyeDropper) and answer at once; the color the person picks anywhere on the screen then runs paint.setFill / paint.setStroke (one undo step) or becomes the Color Picker's color (field `color`), converted from display sRGB into the working RGB space; Escape cancels it and the colors stay as they were. ui.inspect reports `screenSampler: true` until it answers. An error without a sampler, while one is open, or with `picker` and no Color Picker open",
"{} or {stroke?: bool (default: the active proxy), picker?: bool (the open Color Picker instead)} show the system's color sampler (macOS; Linux through the XDG desktop portal's PickColor; browsers with an EyeDropper) and answer at once; the color the person picks anywhere on the screen then runs paint.setFill / paint.setStroke (one undo step) or becomes the Color Picker's color (field `color`), converted from display sRGB into the working RGB space; a cancel (Escape on macOS and in browsers) leaves the colors as they were. ui.inspect reports `screenSampler: true` until it answers; on Linux, a session without a portal that has PickColor, a portal that does not return from the call within 25 seconds (VectorCraft's own limit) or leaves the bus before it answers, and a portal that ends the request another way end the wait with a status message. An error without a sampler, while one is open, or with `picker` and no Color Picker open",
),
(
"ui.newBrush",
+2 -2
View File
@@ -415,13 +415,13 @@ impl<'a> Scene<'a> {
field.display_grid(area, cols, rows).flat_map(|(c, a)| [q(c[0]), q(c[1]), q(c[2]), q(a)]).collect()
} else {
let geom = g.resolve(bounds);
let sample = g.gradient.sampler();
let (sample, spread) = (g.gradient.sampler(), g.gradient.spreader());
let (cw, ch) = (area.width() / f64::from(cols), area.height() / f64::from(rows));
(0..usize::from(rows) * usize::from(cols))
.flat_map(|i| {
let (x, y) = (i % usize::from(cols), i / usize::from(cols));
let p = Point::new(area.x0 + (x as f64 + 0.5) * cw, area.y0 + (y as f64 + 0.5) * ch);
let t = geom.param_at(g.gradient.kind, p);
let t = spread(geom.param_at(g.gradient.kind, p));
let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
let (c, a) = sample(t as f32);
c.to_rgba8(a)
+1 -1
View File
@@ -146,7 +146,7 @@ fn choose(contours: &[Contour], spec: BridgeSpec, work: usize) -> Result<(Vec<Br
}
let mut picker = Picker::new(contours, &views, spec.width);
picker.connect();
if views.iter().any(View::exhausted) {
if views.iter().any(View::exhausted) && picker.unjoined() > 0 {
return Err(PathOpsError::TooComplex);
}
picker.spread(spec.count);
@@ -210,6 +210,37 @@ fn bridges_found_before_the_budget_runs_out_are_kept() {
assert!(matches!(choose(&found, spec(4.0, 1, BridgeDirection::Vertical), least - 1), Err(PathOpsError::TooComplex)));
}
#[test]
fn joined_art_is_kept_when_lines_in_one_direction_run_out() {
// A ring whose thin left bar has edges of many short zigzag segments: lines across it in the
// horizontal direction look at many more segments than vertical lines across the top bar.
let zigzag = |x: f64, from: f64, to: f64, out: &mut Vec<Point>| {
let n = ((to - from).abs() / 0.05) as usize;
out.extend((1..n).map(|i| Point::new(x + if i % 2 == 1 { 0.02 } else { 0.0 }, from + (to - from) * i as f64 / n as f64)));
};
let mut outer = vec![Point::new(0.0, 0.0), Point::new(200.0, 0.0), Point::new(200.0, 100.0), Point::new(0.0, 100.0)];
zigzag(0.0, 100.0, 0.0, &mut outer);
let mut hole = vec![Point::new(10.0, 20.0), Point::new(170.0, 20.0), Point::new(170.0, 80.0), Point::new(10.0, 80.0)];
zigzag(9.98, 80.0, 20.0, &mut hole);
let art = PathData::new(vec![SubPath::polyline(&outer, true), SubPath::polyline(&hole, true)]);
let found = contours(&art, 4.0).unwrap();
let shortest = spec(4.0, 1, BridgeDirection::Shortest);
let views = (0..180).step_by(SHORTEST_STEP_DEG).count();
// A share of the work that runs out in the horizontal direction while another direction joins
// the island.
let share = (1..5000)
.find(|&budget| {
let all: Vec<View> =
(0..180).step_by(SHORTEST_STEP_DEG).map(|d| View::new(&found, (d as f64).to_radians(), 4.0, budget).unwrap()).collect();
let mut picker = Picker::new(&found, &all, 4.0);
picker.connect();
all.iter().any(View::exhausted) && picker.unjoined() == 0
})
.expect("a share of the work that runs out with the island joined");
let (bridges, unjoined) = choose(&found, shortest, share * views).unwrap();
assert_eq!((bridges.len(), unjoined), (1, 0));
}
#[test]
fn curves_are_followed_within_a_twentieth_of_the_width() {
let circle = PathData::from_bezpath(&kurbo::Circle::new((0.0, 0.0), 100.0).to_path(0.001));
+9 -4
View File
@@ -434,8 +434,9 @@ impl Exporter<'_> {
/// [`Self::area`] draws as art: a pattern swatch or a gradient drawn as pixels
/// ([`vectorcraft_color::GradientPaint::draws_as_pixels`]), but not a Perceptual one of spot
/// inks ([`Self::perceptual_spot`]), a conic gradient that can't be a sweep shading (in
/// PDF/A, or with more than [`super::paint::MAX_SWEEP_STOPS`] stops), or a diamond gradient
/// (four linear gradients, [`Self::diamond`])?
/// PDF/A, or with more than [`super::paint::MAX_SWEEP_STOPS`] stops), a diamond gradient
/// (four linear gradients, [`Self::diamond`]), or a linear or radial gradient that repeats or
/// reflects (its stops repeated over the area, [`Self::padded`])?
pub(super) fn area_paint(&self, p: &Paint, fill: bool) -> bool {
match p {
Paint::Pattern { pattern, .. } => self.doc.pattern(pattern).is_some(),
@@ -444,6 +445,7 @@ impl Exporter<'_> {
(g.draws_as_pixels(fill) && !self.perceptual_spot(g, fill))
|| (g.gradient.kind == GradientKind::Conic && sweep_unwritable())
|| g.gradient.kind == GradientKind::Diamond
|| (g.gradient.is_spread() && matches!(g.gradient.kind, GradientKind::Linear | GradientKind::Radial))
}
_ => false,
}
@@ -452,7 +454,8 @@ impl Exporter<'_> {
/// Paint the area `clip` (filled by `rule`; bounds `area`) with `p` at `transparency` (opacity,
/// blend mode) when it is an [area paint](Self::area_paint) of a fill (`fill`) or a stroke: a
/// pattern's [tiling pattern](Self::tiling) (else its tile instances covering it), a diamond
/// gradient's four linear gradients, or an image of a gradient drawn as pixels, placed on
/// gradient's four linear gradients, a repeating or reflecting linear or radial gradient's
/// stops repeated over `area`, or an image of a gradient drawn as pixels, placed on
/// `bounds` (the painted object's box, as on the canvas), clipped to it. False (nothing drawn)
/// for other paints.
#[allow(clippy::too_many_arguments)]
@@ -504,7 +507,9 @@ impl Exporter<'_> {
}
Paint::Gradient(g) => {
let pixels = g.draws_as_pixels(fill) && !self.perceptual_spot(g, fill);
if pixels || g.gradient.kind != GradientKind::Diamond || !self.diamond(s, g, bounds, area) {
// A linear or radial gradient that repeats or reflects is drawn by `padded`.
let drawn = !pixels && self.padded(s, g, bounds, area);
if !drawn && (pixels || g.gradient.kind != GradientKind::Diamond || !self.diamond(s, g, bounds, area)) {
self.field_image(s, g, bounds, area, fill);
}
}
+101 -13
View File
@@ -236,6 +236,24 @@ impl Exporter<'_> {
Paint::Solid { color: c, swatch, tint } => Some(self.solid(c, swatch.as_deref(), *tint).into()),
Paint::Gradient(g) => {
let geom = g.resolve(bounds);
// A linear or radial gradient that repeats or reflects, where it isn't an area
// paint ([`Self::padded`]): its stops repeated over `bounds`, padding past them.
if matches!(g.gradient.kind, GradientKind::Linear | GradientKind::Radial) && g.gradient.is_spread() {
let paint = match g.gradient.padded_over(&geom, bounds) {
Some(padded) => {
self.warn_capped(padded.capped);
padded_paint(g, padded)
}
// Levels over `bounds` that are not finite (a vector of no length): the
// stops repeated along the vector, padding past it.
None => {
self.warn_capped(true);
let gradient = g.gradient.unrolled().into_owned();
Paint::Gradient(Box::new(vectorcraft_color::GradientPaint { gradient, ..(**g).clone() }))
}
};
return self.paint_in(s, &paint, bounds, space);
}
let spot = match g.gradient.kind {
GradientKind::Freeform => None,
_ => self.perceptual_spot_stops(&g.gradient).or_else(|| self.spot_stops(&g.gradient)),
@@ -318,20 +336,27 @@ impl Exporter<'_> {
}
// A function-based shading (ISO 32000-1, 8.7.4.5.2) whose calculator function
// turns the angle about the origin into the ramp, once around (0 to 360
// degrees), carried onto the extent ellipse by its frame.
// degrees), carried onto the extent ellipse by its frame. Stops that repeat
// or reflect `n` times run over 360/`n` degrees, the function repeating or
// reflecting them past it.
GradientKind::Conic => {
let frame = geom.conic_frame();
if !writable(s, space * frame, Rect::new(-1.0, -1.0, 1.0, 1.0)) {
return None;
}
let (end_angle, spread_method) = match g.gradient.spread {
_ if !g.gradient.is_spread() => (360.0, SpreadMethod::Pad),
vectorcraft_color::GradientSpread::Reflect => (360.0 / g.gradient.repeat_count() as f32, SpreadMethod::Reflect),
_ => (360.0 / g.gradient.repeat_count() as f32, SpreadMethod::Repeat),
};
Some(
SweepGradient {
cx: 0.0,
cy: 0.0,
start_angle: 0.0,
end_angle: 360.0,
end_angle,
transform: xf(space * frame),
spread_method: SpreadMethod::Pad,
spread_method,
stops,
anti_alias: false,
}
@@ -484,15 +509,27 @@ impl Exporter<'_> {
/// linear gradients, one for each quadrant of its frame, each equal to the diamond there (PDF
/// has no diamond shading; [`vectorcraft_color::GradientGeom::diamond_quadrants`]). The
/// quadrants overlap so no hairline shows between them, which needs opaque stops. False
/// (nothing drawn) for a diamond with translucent stops or without a frame, which
/// (nothing drawn) for a diamond with translucent stops or without a frame, for one with a
/// quadrant whose shading or outline PDF can't hold, and for a Perceptual one of spot inks
/// whose ink curve has too many tints once its stops are repeated, which
/// [`Self::field_image`] draws instead.
pub(super) fn diamond(&mut self, s: &mut Surface, g: &vectorcraft_color::GradientPaint, bounds: Rect, area: Rect) -> bool {
if g.gradient.stops.iter().any(|st| st.opacity < 1.0) {
return false;
}
let Some(quadrants) = g.resolve(bounds).diamond_quadrants(area.abs()) else { return false };
self.warn("diamond gradients are exported as four linear gradients");
let gradient = vectorcraft_color::Gradient { kind: GradientKind::Linear, ..g.gradient.clone() };
// A diamond that repeats or reflects: its stops repeated over the levels the area reaches
// from the center, then split into quadrants, each of which runs those levels.
let (diamond, geom, capped) = match g.gradient.padded_over(&g.resolve(bounds), area.abs()) {
Some(padded) => (padded.gradient, padded.geom, padded.capped),
None => (g.gradient.clone(), g.resolve(bounds), false),
};
// A Perceptual one of spot inks whose ink curve no longer fits with its stops repeated.
if !diamond.method.is_classic() && !diamond.fits_ink_tints() {
return false;
}
let Some(quadrants) = geom.diamond_quadrants(area.abs()) else { return false };
let gradient = vectorcraft_color::Gradient { kind: GradientKind::Linear, ..diamond };
let mut drawn = Vec::with_capacity(4);
for (outline, geom) in quadrants {
let linear = Paint::Gradient(Box::new(vectorcraft_color::GradientPaint { gradient: gradient.clone(), geom: Some(geom), ..g.clone() }));
let quadrant = kurbo::BezPath::from_vec(
@@ -503,16 +540,61 @@ impl Exporter<'_> {
.chain([kurbo::PathEl::ClosePath])
.collect(),
);
if let (Some(paint), Some(path)) = (self.paint(s, &linear, bounds), to_path(s, &quadrant)) {
s.set_stroke(None);
s.set_fill(Some(krilla::paint::Fill { paint, opacity: krilla::num::NormalizedF32::ONE, rule: krilla::paint::FillRule::NonZero }));
s.draw_path(&path);
s.set_fill(None);
}
let (Some(paint), Some(path)) = (self.paint(s, &linear, bounds), to_path(s, &quadrant)) else { return false };
drawn.push((paint, path));
}
self.warn("diamond gradients are exported as four linear gradients");
self.warn_capped(capped);
for (paint, path) in drawn {
s.set_stroke(None);
s.set_fill(Some(krilla::paint::Fill { paint, opacity: krilla::num::NormalizedF32::ONE, rule: krilla::paint::FillRule::NonZero }));
s.draw_path(&path);
s.set_fill(None);
}
true
}
/// Draw linear or radial gradient `g`, placed on `bounds`, that repeats or reflects, over
/// `area` (inside the current clip): PDF's axial and radial shadings pad past their ends, so
/// its stops are repeated as many times as the area needs
/// ([`vectorcraft_color::Gradient::padded_over`]). False (nothing drawn) for another gradient,
/// for one whose shading or area PDF can't hold, and for a Perceptual one of spot inks whose
/// ink curve has too many tints once repeated, which [`Self::field_image`] draws instead.
pub(super) fn padded(&mut self, s: &mut Surface, g: &vectorcraft_color::GradientPaint, bounds: Rect, area: Rect) -> bool {
if !matches!(g.gradient.kind, GradientKind::Linear | GradientKind::Radial) {
return false;
}
let Some(padded) = g.gradient.padded_over(&g.resolve(bounds), area.abs()) else { return false };
// A Perceptual gradient of spot inks whose ink curve no longer fits once its stops are
// repeated is an image, as one with too many stops is.
if !g.gradient.method.is_classic() && !padded.gradient.fits_ink_tints() {
return false;
}
let capped = padded.capped;
let paint = padded_paint(g, padded);
let (Some(paint), Some(path)) = (self.paint(s, &paint, bounds), to_path(s, &kurbo::Shape::to_path(&area.abs(), 0.1))) else {
return false;
};
self.warn_capped(capped);
s.set_stroke(None);
s.set_fill(Some(krilla::paint::Fill { paint, opacity: krilla::num::NormalizedF32::ONE, rule: krilla::paint::FillRule::NonZero }));
s.draw_path(&path);
s.set_fill(None);
true
}
/// Warn when a gradient that repeats or reflects needed more runs of its stops than were
/// written.
fn warn_capped(&mut self, capped: bool) {
if capped {
self.warn(format!(
"gradients that repeat or reflect are exported with at most {} runs of their stops (at most {} stops); they pad past those",
vectorcraft_color::gradient::MAX_SPREAD_RUNS,
vectorcraft_color::gradient::MAX_SPREAD_STOPS
));
}
}
/// Draw gradient `g`, placed on `bounds`, as an image over `area`, sampled at the document's
/// raster effects resolution where it is drawn (`area` as the current transform sizes it, so
/// scaled type gets its pixels too): a freeform gradient's colour field (at most
@@ -588,6 +670,12 @@ impl Exporter<'_> {
}
}
/// `g` written as `padded` gives it: its stops repeated, placed there.
fn padded_paint(g: &vectorcraft_color::GradientPaint, padded: vectorcraft_color::gradient::Padded) -> Paint {
let geom = padded.geom;
Paint::Gradient(Box::new(vectorcraft_color::GradientPaint { gradient: padded.gradient, geom: Some(geom), angle: geom.angle_deg(), ..g.clone() }))
}
/// Is `c` paper white: no ink in CMYK or gray, white in RGB or Lab?
fn paper(c: &Color) -> bool {
match *c {
+3 -2
View File
@@ -35,6 +35,7 @@ mod builder;
mod cid;
mod device;
mod entry;
mod reshaped;
mod state;
#[cfg(test)]
@@ -42,8 +43,8 @@ pub(crate) use cid::{CidText, font_chars, identify_glyph, unify_radical};
#[cfg(any(test, feature = "read-count"))]
pub use entry::imports_of;
pub use entry::{
INVISIBLE_TEXT_NOTE, OFF_ARTBOARD_NOTE, OUTLINED_TEXT_NOTE, PAST_PAGE_NOTE, UNMATCHED_GLYPHS_NOTE, UNNAMED_CHARACTERS_NOTE, holds_outlines,
import, import_opened, import_with_report, is_glyph_outlines, is_outlines_note,
INVISIBLE_TEXT_NOTE, OFF_ARTBOARD_NOTE, OUTLINED_TEXT_NOTE, PAST_PAGE_NOTE, RESHAPED_TEXT_NOTE, UNMATCHED_GLYPHS_NOTE, UNNAMED_CHARACTERS_NOTE,
holds_outlines, import, import_opened, import_with_report, is_glyph_outlines, is_outlines_note,
};
#[cfg(test)]
pub(crate) use entry::{TEST_MAX_OBJECTS, import_with_reader_options, read};
+80 -9
View File
@@ -1,9 +1,10 @@
use super::cid::{CidText, FontInfo, comparable, font_chars, identify_glyph, matching_face, replacement, unify_radical};
use super::entry::{
MAX_NESTED, OVERPRINT_UNREAD, OVERPRINT_ZERO_MODE, PATTERN_REUSE, TEXT_OUTLINES, TOO_MANY_OBJECTS, UNMATCHED_GLYPHS_NOTE,
MAX_NESTED, OVERPRINT_UNREAD, OVERPRINT_ZERO_MODE, PATTERN_REUSE, RESHAPED_TEXT_NOTE, TEXT_OUTLINES, TOO_MANY_OBJECTS, UNMATCHED_GLYPHS_NOTE,
UNNAMED_CHARACTERS_NOTE, max_objects,
};
use super::state::{Builder, Frame, FrameKind, Saved, bounds, grouped, line_width, mean_scale, paints, round3, stroke_layer};
use super::reshaped;
use super::state::{Builder, Frame, FrameKind, GlyphRun, Saved, bounds, grouped, line_width, mean_scale, paints, round3, stroke_layer};
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,
@@ -22,6 +23,7 @@ impl<'p> Builder<'p> {
page: Rect::ZERO,
glyphs: None,
text: None,
text_glyphs: vec![],
text_as,
actual: Default::default(),
images: HashMap::new(),
@@ -101,6 +103,7 @@ impl<'p> Builder<'p> {
self.blend = BlendMode::Normal;
self.glyphs = None;
self.text = None;
self.text_glyphs.clear();
self.mask = None;
self.masked.clear();
self.marked.clear();
@@ -376,18 +379,56 @@ impl<'p> Builder<'p> {
}
pub(super) fn flush_text(&mut self) {
let Some(mut line) = self.text.take() else { return };
if self.end_text() {
self.flush_glyphs();
}
}
/// 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.
pub(super) fn end_text(&mut self) -> bool {
let glyphs = std::mem::take(&mut self.text_glyphs);
let Some(mut line) = self.text.take() else { return false };
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();
let mut outlined = false;
if let Some((t, opacity, facts)) = line.finish() {
let mut n = Node::new(self.id(), NodeKind::Text(Box::new(t)));
n.opacity = opacity;
self.lines.insert(n.id, facts);
self.push_node(n);
if checked && reshaped::reshapes(&t.plain_text()) && !reshaped::draws_as(&t, &facts.ink) {
outlined = true;
for g in glyphs {
let same = self.glyphs.as_ref().is_some_and(|r| {
r.paint == g.paint
&& r.opacity == g.opacity
&& r.overprint == g.overprint
&& r.stroke.is_some() == g.stroke.is_some()
&& r.stroke.as_ref().map(|s| s.line_width) == g.stroke.as_ref().map(|s| s.line_width)
&& (r.scale - g.scale).abs() < 1e-9
});
match &mut self.glyphs {
Some(r) if same => r.path.extend(g.path.iter()),
_ => {
self.flush_glyphs();
self.glyphs = Some(g);
}
}
}
self.warn(RESHAPED_TEXT_NOTE);
} else {
let mut n = Node::new(self.id(), NodeKind::Text(Box::new(t)));
n.opacity = opacity;
self.lines.insert(n.id, facts);
self.push_node(n);
}
}
if outlined && !held.is_empty() {
self.flush_glyphs();
}
// The strokes of its glyphs' outlines, right after it ([`import_lines`] makes them its stroke).
for n in held {
self.push_node(n);
}
outlined
}
/// A stroke of the outline of the glyph just drawn, in the glyph's own paint, while every glyph
@@ -737,6 +778,27 @@ impl<'p> Builder<'p> {
n
}
/// Glyph `o` of the open line of type, placed by `m` and drawn with `drawn` (its paint, and its
/// stroke when it is stroked), as the outline it is kept as if the line is
/// ([`Self::end_text`]). Nothing for a glyph that shows nothing.
fn keep_glyph(
&mut self,
o: &craft_pdf::interpret::font::OutlineGlyph,
m: Affine,
drawn: Option<(Paint, Option<StrokeProps>)>,
opacity: f32,
scale: f64,
overprint: bool,
) {
let Some((paint, stroke)) = drawn else { return };
let mut path = o.outline();
if path.elements().is_empty() {
return;
}
path.apply_affine(m);
self.text_glyphs.push(GlyphRun { path, paint, opacity, stroke, scale, overprint });
}
/// Glyph `o` as type: added to the line being gathered (or starting one). `false`: it keeps
/// its outline (no Unicode text, mirrored, or not type mode). No `paint`: invisible text,
/// type with neither fill nor stroke.
@@ -794,8 +856,11 @@ impl<'p> Builder<'p> {
return false;
}
let width = o.advance_width().filter(|w| w.is_finite());
// Set vertically (WMode 1): no horizontal advance.
let upright = width.is_some_and(|w| w.abs() <= 1.0);
// Set vertically (WMode 1): no horizontal advance. Not in a font the file says is written
// horizontally: there a glyph without an advance is a mark over the letter before it (a
// vowel sign, an anusvara), which stays on its line (#5235).
let horizontal = self.fonts.get(&key).is_some_and(|f| f.vertical.is_none());
let upright = !horizontal && width.is_some_and(|w| w.abs() <= 1.0);
let mut info = self.font_name(key, o);
// A font the file doesn't carry is drawn with a stand-in: its glyphs can't tell which
// style of the installed family it is, so the name decides.
@@ -841,6 +906,8 @@ impl<'p> Builder<'p> {
}
None => (None, 1.0),
};
// What the glyph is drawn with as an outline, should its line be kept so.
let drawn = paint.clone().map(|p| (p, stroke.cloned()));
let stroke = stroke.zip(paint.clone()).map(|(p, paint)| (paint, line_width(p, scale)));
let look = Look {
font: key,
@@ -879,6 +946,7 @@ impl<'p> Builder<'p> {
&& look.fill.is_none()
&& line.stroke_last(key, at, s.clone(), overprint)
{
self.keep_glyph(o, m, drawn, opacity, scale, overprint);
return true;
}
if !self.text.as_mut().is_some_and(place) {
@@ -889,6 +957,9 @@ impl<'p> Builder<'p> {
}
// Its ink: a stroke the file draws as outlines of the glyphs is told by it.
let mut ink = o.outline();
if top.is_none() {
self.keep_glyph(o, m, drawn, opacity, scale, overprint);
}
if let Some(line) = &mut self.text
&& !ink.elements().is_empty()
{
+2 -1
View File
@@ -191,7 +191,8 @@ impl<'a> Device<'a> for Builder<'_> {
if self.type_glyph(o, transform * glyph_transform, scale, Some(paint), stroke.as_ref(), overprint) {
return;
}
self.flush_text();
// A line kept as outlines leaves them open: this glyph joins them.
self.end_text();
let mut bp = o.outline();
bp.apply_affine(transform * glyph_transform);
let (paint, opacity) = self.paint(paint, stroke.is_some(), self.walked(true));
+10 -2
View File
@@ -171,14 +171,22 @@ pub const INVISIBLE_TEXT_NOTE: &str = "invisible text (such as a scanned page's
/// Warning: glyphs that differ from the installed font of their name were kept as outlines.
pub const UNMATCHED_GLYPHS_NOTE: &str = "text whose glyphs differ from the installed font of the same name was kept as outlines";
/// Warning: type in a script whose letters reorder and join (Indic scripts) that, set again from
/// its characters, wouldn't draw the glyphs where the file drew them was kept as outlines (#5235).
pub const RESHAPED_TEXT_NOTE: &str =
"text that would not look as it does in the file if set as type (a script whose letters join) was kept as outlines";
/// The end of the warning that glyphs whose characters the file doesn't name were kept as
/// outlines, after "text in" and the font's name.
pub const UNNAMED_CHARACTERS_NOTE: &str = "whose characters the file doesn't name (U+FFFD) was kept as outlines";
/// Is `note` one of the warnings that glyphs were kept as outlines ([`OUTLINED_TEXT_NOTE`],
/// [`UNMATCHED_GLYPHS_NOTE`], [`UNNAMED_CHARACTERS_NOTE`])?
/// [`UNMATCHED_GLYPHS_NOTE`], [`RESHAPED_TEXT_NOTE`], [`UNNAMED_CHARACTERS_NOTE`])?
pub fn is_outlines_note(note: &str) -> bool {
note == OUTLINED_TEXT_NOTE || note == UNMATCHED_GLYPHS_NOTE || note.starts_with("text in ") && note.ends_with(UNNAMED_CHARACTERS_NOTE)
note == OUTLINED_TEXT_NOTE
|| note == UNMATCHED_GLYPHS_NOTE
|| note == RESHAPED_TEXT_NOTE
|| note.starts_with("text in ") && note.ends_with(UNNAMED_CHARACTERS_NOTE)
}
/// Is `n` glyphs kept as outlines (a path the import names `<Text Outlines>`)?
+53
View File
@@ -0,0 +1,53 @@
//! Type in a script whose letters reorder and join as they are set (#5235). A PDF draws such text
//! as glyphs already shaped: a vowel sign before the consonant it follows in reading order, a
//! conjunct as one glyph that the file may not name, a mark placed over its base. Read glyph by
//! glyph, the characters don't always make the text that was set, and type made from them draws
//! other glyphs in other places. A line of such type is therefore set again and compared with what
//! the file drew; one that would look different keeps the file's glyphs as outlines.
use kurbo::{Rect, Shape};
use vectorcraft_doc::TextObject;
/// Does `text` have a character of a script whose letters reorder and join into conjuncts: the
/// Brahmic scripts of U+0900 to U+0DFF (Devanagari, Bengali, Gurmukhi, Gujarati, Oriya, Tamil,
/// Telugu, Kannada, Malayalam, Sinhala)?
pub(super) fn reshapes(text: &str) -> bool {
text.chars().any(|c| ('\u{0900}'..='\u{0DFF}').contains(&c))
}
/// Would type `t` draw its glyphs where the file drew them (`ink`: each glyph's ink box in
/// document space)? As many glyphs with ink, each within 3 % of the type's size of one of the
/// file's.
pub(super) fn draws_as(t: &TextObject, ink: &[Rect]) -> bool {
let laid = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
let mut set: Vec<Rect> =
laid.glyphs.iter().filter(|g| !g.outline.elements().is_empty()).map(|g| (t.xf * g.outline.clone()).bounding_box()).collect();
if set.len() != ink.len() {
return false;
}
let size = t.runs.iter().map(|r| r.style.size).fold(0.0, f64::max);
let tol = size * 0.03;
if !tol.is_finite() || set.iter().chain(ink).any(|r| !(r.x0.is_finite() && r.y0.is_finite() && r.x1.is_finite() && r.y1.is_finite())) {
return false;
}
set.sort_by(|a, b| a.x0.total_cmp(&b.x0));
let mut used = vec![false; set.len()];
// Each of the file's glyphs takes one the type draws in its place: looked for among those
// whose left edge is as near.
ink.iter().all(|r| {
let from = set.partition_point(|s| s.x0 < r.x0 - tol);
let found = set
.iter()
.zip(used.iter_mut())
.skip(from)
.take_while(|(s, _)| s.x0 <= r.x0 + tol)
.find(|(s, used)| !**used && (s.y0 - r.y0).abs() <= tol && (s.x1 - r.x1).abs() <= tol && (s.y1 - r.y1).abs() <= tol);
match found {
Some((_, used)) => {
*used = true;
true
}
None => false,
}
})
}
+4
View File
@@ -81,6 +81,10 @@ pub(super) struct Builder<'p> {
pub(super) page: Rect,
pub(super) glyphs: Option<GlyphRun>,
pub(super) text: Option<TextLine>,
/// The glyphs of the open line of type (`text`) that show, each as the outline it would be
/// kept as: what the line becomes when its type wouldn't draw as the file does
/// ([`super::reshaped`]).
pub(super) text_glyphs: Vec<GlyphRun>,
pub(super) text_as: TextAs,
pub(super) actual: super::actual_text::ActualText,
pub(super) images: HashMap<String, ImageBlob>,
+44 -4
View File
@@ -1,5 +1,6 @@
//! Shadings: axial and radial ones become gradients (their stops sampled from the shading
//! function in its own colour model; an end that doesn't extend clips the painted area), a
//! function in its own color model, sharp steps between colors kept where they are; an end that
//! doesn't extend clips the painted area), a
//! function-based one whose color changes along one axis a linear gradient, one whose color
//! turns around the origin of its space a conic gradient, and one whose color is the same along
//! each square about that origin a diamond gradient (else its average color; all of them
@@ -41,13 +42,21 @@ pub(crate) fn shading_gradient(sp: &ShadingPattern, colors: &mut Colors<'_>, ink
let [r, g, b, _] = cs.to_rgba(&at(t)?, 1.0, false).components();
Some(Color::rgb(round3(r), round3(g), round3(b)))
};
// Sample densely, then drop samples that linear interpolation reproduces.
// Sample densely, halving each span between samples where its middle strays from the line
// between them (so a sharp step between two colors, as repeated stops make, is found to
// within [`EDGE_DEPTH`] halvings), then drop samples that linear interpolation reproduces.
const N: usize = 64;
let mut pts: Vec<(f32, [f32; 3])> = Vec::with_capacity(N + 1);
for i in 0..=N {
let t = i as f32 / N as f32;
pts.push((t, sample(t)?.to_rgb()));
// An ink that paints only at samples dropped below is still a spot swatch.
let rgb = sample(t)?.to_rgb();
if let Some(&(t0, c0)) = pts.last() {
refine(&sample, (t0, c0), (t, rgb), 0, &mut pts);
}
pts.push((t, rgb));
}
// An ink that paints only at samples dropped below is still a spot swatch.
for &(t, _) in &pts {
if let Some(v) = at(t) {
colors.mark_inks(space, &v);
}
@@ -92,6 +101,37 @@ fn shading_stop(colors: &mut Colors<'_>, space: Space, comps: Option<&[f32]>, of
}
}
/// How many times [`refine`] halves a span of an axial or radial shading's samples: to 1/64 ×
/// 2^-14 of the axis.
const EDGE_DEPTH: u32 = 14;
/// The most samples of one axial or radial shading [`refine`] takes.
const MAX_EDGE_SAMPLES: usize = 16_384;
/// Where in a span [`refine`] looks a second time when the span's middle lies on the line: at
/// the golden section, which no whole number of repeated steps across the span puts on the same
/// place in a step as the ends.
const SECOND_LOOK: f32 = 0.381_966;
/// Samples of `sample` between `a` and `b` (offset, RGB), pushed onto `out` in order: the span's
/// middle where it, or the point [`SECOND_LOOK`] along the span, strays from the line between
/// them by more than 1.5 levels, and the samples of each half the same way, at most
/// [`EDGE_DEPTH`] halvings deep and [`MAX_EDGE_SAMPLES`] in all. The second look finds steps that
/// repeat a whole number of times across the span, which put its ends and its middle at the same
/// place in a step.
fn refine(sample: &dyn Fn(f32) -> Option<Color>, a: (f32, [f32; 3]), b: (f32, [f32; 3]), depth: u32, out: &mut Vec<(f32, [f32; 3])>) {
if depth >= EDGE_DEPTH || out.len() >= MAX_EDGE_SAMPLES {
return;
}
let on_line = |u: f32, c: [f32; 3]| (0..3).all(|k| (a.1[k] + (b.1[k] - a.1[k]) * u - c[k]).abs() <= 1.5 / 255.0);
let t = (a.0 + b.0) / 2.0;
let Some(c) = sample(t).map(|c| c.to_rgb()) else { return };
if on_line(0.5, c) && sample(a.0 + (b.0 - a.0) * SECOND_LOOK).is_none_or(|p| on_line(SECOND_LOOK, p.to_rgb())) {
return;
}
refine(sample, a, (t, c), depth + 1, out);
out.push((t, c));
refine(sample, (t, c), b, depth + 1, out);
}
/// The samples of `pts` (offset, RGB; at least one) a gradient keeps as stops: the first, the
/// last, and each one that linear interpolation between its neighbouring stops doesn't reproduce.
fn linear_keep(pts: &[(f32, [f32; 3])]) -> Vec<usize> {
Loaded 100 of 239 files, more files were not shown because too many files have changed in this diff. Show more