Merge main into feat/color-wheel-harmony

This commit is contained in:
dotCooCoo committed 2026-11-17 22:16:53 -08:00
commit b838b9036e
401 files changed
+28646 -1802

No files matched your search

+1
View File
@@ -129,6 +129,7 @@ Generated-in-code art is original and has no file to list. This covers the defau
| `assets/icons/dc-cap-square.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-center-hide.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-center-show.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-circle-points.svg` | VectorCraft contributors | Original work, drawn for VectorCraft (a circle with three dots on its edge) | MIT OR Apache-2.0 | |
| `assets/icons/dc-clear.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-color-guide.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-contour.svg` | VectorCraft contributors | Original work, drawn for VectorCraft (a solid rounded square inside four corner arcs, its offset outline); not derived from any other application's icon | MIT OR Apache-2.0 | |
Generated
+1
View File
@@ -6775,6 +6775,7 @@ dependencies = [
"craft-stream-codecs",
"craft-xml",
"crc32fast",
"encoding_rs",
"flate2",
"hayro-ccitt",
"heic-rs",
+2
View File
@@ -138,8 +138,10 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 2026-11-04: New Document: the units chosen in Preset Details now belong to the chosen document, as the pane's options are listed for the selected preset; the chosen card shows them, every other Recent and Saved card keeps the units its document or preset was made in, and the built-in tabs still follow the chosen units, so switching between inches and millimetres no longer restyles every recent template. Scores and estimates unchanged.
- 2026-11-14: Packaging Tools add-on (Object › Plug-ins › Packaging Tools): fold line roles for dielines (Cut, Crease, Partial Cut, Perforation), each carried by the swatch on a path's top stroke through a per-document role table that native files keep; PDF prints a role line on its swatch's separation when that swatch is a spot color, as the default role swatches are, and SVG, DXF and HP-GL keep the stroke's color. Make Cut Line, Make Crease Line, Make Partial Cut Line and Make Perforation Line give the selected paths a role, overprinting by default, and make a missing role swatch; the Fold Lines panel counts each role in the selection or the document, and its Role Swatches… picks another swatch for a role (`addon.packaging.setRole`, `addon.packaging.roles`, `addon.packaging.setRoleSwatch`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-16: Check Fold Lines in the Packaging Tools add-on (Object › Plug-ins › Packaging Tools, and the Fold Lines panel's Check button): the fold lines of the selection or the document are split into blanks, panels and hinges (cut lines bound the material, and creases, partial cuts and perforations divide it into panels), and 15 kinds of issue are listed, errors and warnings, each naming its lines: cut lines that enclose nothing or end loose, gaps closed within a tolerance, a cut on top of a crease, duplicate lines, creases that end inside a panel, divide nothing, lie outside the blank or are not straight, gaps too narrow to map, fold lines in a hole, panels joined by no crease, and fold lines on a non-printing layer. The panel lists the issues in the interface language; clicking one selects its lines (`addon.packaging.check`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-16: Fold Preview in the Packaging Tools add-on (Object › Plug-ins › Packaging Tools, and the Fold Lines panel's Fold Preview button): a window that folds the document's blank into its 3D shape about its largest panel, or the panel double-clicked, with the printed art on the outside of each panel (fold lines and non-printing layers left out, unless Show Fold Lines is on) and the board's inside color on the back. Creases and perforations fold 90° away from the print and partial cuts 90° toward it; a Fold slider goes from flat to folded, and the view turns by dragging and the arrow keys, zooms, moves and takes a perspective and seven view presets. The status line says when a joint does not close or two panels pass through each other (`addon.packaging.fold`, `ui.foldPreview`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-02: Mouse wheel over a closed font-family field in Character, Properties or Control changes selected text through the family list using saved font filters (excluding search text), one undo step per notch, stopping at the ends (#5253). Scores and estimates unchanged.
- 2026-11-15: Circle through three points: three Shift-clicks with the Ellipse tool, or `shape.circleThroughPoints` with three points or three selected anchor points, draw the circle whose edge passes through them, with the current paint, in one undo step; after two points the tool previews the circle through the pointer, and two points that are the same or three on one line are refused with a message. Scores and estimates unchanged.
- 2026-11-17: Circle tool (after the Ellipse tool in its group): two clicks or a drag draw the circle on that diameter, and a click followed by a drag from a second point to a third draws the circle through the three; Shift keeps the diameter at 45° steps, Alt rounds a two-point circle's diameter to the rulers' ticks at the current zoom, points snap to Smart Guides, and the tool shows the circle, its center, its radii and its diameter until the release, or "Circle too large" for points on one line or a circle past the canvas. `shape.circleThroughPoints` also takes two points or two selected anchor points as the ends of a diameter. One undo step per circle. A VectorCraft addition: headline numbers unchanged.
- 2026-10-31: Pattern libraries: Window › Swatch Libraries › Patterns and the Swatches panel's library menu open Geometric Patterns, a built-in library of eleven pattern swatches (dots, stripes, checks, a grid and shapes); clicking one adds its pattern and swatch to the document, once, and applies it to the active fill or stroke (`swatch.library.add`).
- 2026-11-11: Pattern libraries: Patterns › Grit Textures, a second built-in pattern library, holds eight seamless black textures (Fine Grain, Coarse Grit, Sand, Speckle, Stipple, Scratches, Sparse Flecks and Dense Flecks) on tiles of 18 to 36 pt, each drawn the same way every time; marks that reach past a tile edge continue on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
- 2026-11-11: Pattern libraries: Patterns › Optical Effects, a third built-in pattern library, of VectorCraft's own designs, holds eight black wave, moiré and op-art tiles (Sine Bands, Ripple Lines, Interference Rings, Offset Rings, Warped Checks, Pinched Stripes, Chevron Pulse and Radiating Lenses) of 32 to 48 pt, each drawn the same way every time; each tile is one period of its design, and art that reaches past a tile edge continues on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
+3 -1
View File
@@ -238,10 +238,12 @@ fn main() -> ExitCode {
/// A headless session that remembers what the user keeps between runs: the PDF presets saved, the
/// ICC profiles loaded, the plug-ins installed (#2168, #2174, #2541), the custom dictionary's words (#4936) and the Color Settings (#6335), in the folders
/// and files next to the preferences that the desktop app uses too, and lists the scripts of the Scripts folder there
/// (`script.listInstalled`), keeps File Info's metadata templates there and starts new documents from the New Document profiles there. `VECTORCRAFT_NO_PREFS` and
/// (`script.listInstalled`), keeps each script's `Folder.userData` in the Script Data folder there, keeps File Info's
/// metadata templates there and starts new documents from the New Document profiles there. `VECTORCRAFT_NO_PREFS` and
/// `VECTORCRAFT_CONFIG_DIR` apply as they do there.
fn with_stores(mut h: Headless) -> Headless {
prefs_dir::attach_scripts_dir(&mut h.session);
prefs_dir::attach_script_data(&mut h.session);
prefs_dir::attach_metadata_templates_dir(&mut h.session);
prefs_dir::attach_new_doc_profiles(&mut h.session);
prefs_dir::attach_profile_store(&mut h.session);
+1 -1
View File
@@ -142,7 +142,7 @@ fn send(method: &str, params: Value) -> Pin<Box<dyn Future<Output = Value>>> {
})
}
async fn sleep(ms: i32) {
pub(crate) async fn sleep(ms: i32) {
let promise = js_sys::Promise::new(&mut |resolve, _| {
if let Some(window) = web_sys::window() {
let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms);
+139
View File
@@ -0,0 +1,139 @@
//! Which `demand` web faces (`crates/text/web-fonts.txt`) to fetch: each face is fetched at most
//! once at a time and never again once it loaded. A face whose fetch failed is fetched again after
//! a wait that doubles with each failure, and not after [`MAX_TRIES`] failures.
/// The wait after a face's first failed fetch before it is fetched again (ms).
const RETRY_MS: i32 = 30_000;
/// Failed fetches of a face after which it is not fetched again this session.
pub(crate) const MAX_TRIES: u32 = 5;
#[derive(Clone, Copy, Debug, PartialEq)]
enum State {
Idle,
/// Being fetched, after `tries` failed fetches.
Loading {
tries: u32,
},
Loaded,
/// `tries` fetches failed, the last at `failed_at` (ms); the next may start at `retry_at`, or
/// at once when the clock reads earlier than `failed_at`.
Failed {
tries: u32,
failed_at: f64,
retry_at: f64,
},
}
/// The fetch state of each face of a web font list, by index.
#[derive(Debug, Default)]
pub(crate) struct Demand {
states: Vec<State>,
}
impl Demand {
/// Of the faces `wanted` (indexes into the list), the ones to fetch at time `now` (ms): not
/// loaded, not being fetched, and not waiting to be fetched again. They are marked as being
/// fetched.
pub(crate) fn start(&mut self, wanted: &[usize], now: f64) -> Vec<usize> {
let mut out = Vec::new();
for &i in wanted {
if self.states.len() <= i {
self.states.resize(i + 1, State::Idle);
}
let Some(state) = self.states.get_mut(i) else { continue };
let tries = match *state {
State::Idle => Some(0),
State::Loading { .. } | State::Loaded => None,
State::Failed { tries, failed_at, retry_at } => (tries < MAX_TRIES && (now >= retry_at || now < failed_at)).then_some(tries),
};
if let Some(tries) = tries {
*state = State::Loading { tries };
out.push(i);
}
}
out
}
/// The fetch of face `i` started by [`Demand::start`] ended at `now` (ms): loaded when `ok`.
/// Returns the wait (ms) after which a failed face may be fetched again, or `None` when it
/// loaded or has failed [`MAX_TRIES`] times.
pub(crate) fn finished(&mut self, i: usize, ok: bool, now: f64) -> Option<i32> {
let state = self.states.get_mut(i)?;
let State::Loading { tries } = *state else { return None };
if ok {
*state = State::Loaded;
return None;
}
let tries = tries + 1;
let wait = RETRY_MS << (tries - 1).min(4);
*state = State::Failed { tries, failed_at: now, retry_at: now + f64::from(wait) };
(tries < MAX_TRIES).then_some(wait)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_face_is_fetched_once_and_kept() {
let mut d = Demand::default();
assert_eq!(d.start(&[2], 0.0), [2]);
assert!(d.start(&[2], 1.0).is_empty(), "already being fetched");
assert_eq!(d.finished(2, true, 2.0), None, "loaded: no retry");
assert!(d.start(&[2], 1e9).is_empty(), "loaded: never fetched again");
assert_eq!(d.start(&[0, 2, 1], 3.0), [0, 1], "other faces start on their own");
assert_eq!(d.finished(7, false, 4.0), None, "a face never started");
}
#[test]
fn a_failed_face_waits_longer_after_each_failure_and_then_stops() {
let mut d = Demand::default();
let mut now = 0.0;
// The wait after the 1st, 2nd, ... failure: doubling, up to 16 times the first.
for wait in [1, 2, 4, 8].map(|k| k * RETRY_MS) {
assert_eq!(d.start(&[0], now), [0], "at {now}");
assert_eq!(d.finished(0, false, now), Some(wait), "the wait after the failure at {now}");
assert!(d.start(&[0], now + f64::from(wait) - 1.0).is_empty(), "waits {wait} ms after the failure at {now}");
now += f64::from(wait);
}
// The fifth fetch, and after it fails, none.
assert_eq!(d.start(&[0], now), [0]);
assert_eq!(d.finished(0, false, now), None, "no retry after {MAX_TRIES} failures");
assert!(d.start(&[0], now + 1e12).is_empty(), "no fetch after {MAX_TRIES} failures");
// A later success after failures keeps the face.
let mut d = Demand::default();
d.start(&[1], 0.0);
assert_eq!(d.finished(1, false, 0.0), Some(RETRY_MS));
assert_eq!(d.start(&[1], f64::from(RETRY_MS)), [1]);
assert_eq!(d.finished(1, true, f64::from(RETRY_MS)), None);
assert!(d.start(&[1], 1e12).is_empty());
}
/// While a face is fetched again after a failure, neither the interface asking for its script
/// again nor the retry timer starts a second fetch of it.
#[test]
fn a_face_being_fetched_again_is_not_fetched_twice_at_once() {
let mut d = Demand::default();
d.start(&[0], 0.0);
assert_eq!(d.finished(0, false, 0.0), Some(RETRY_MS));
let retry = f64::from(RETRY_MS);
assert_eq!(d.start(&[0, 0], retry), [0], "one fetch for a face wanted twice");
assert!(d.start(&[0], retry + 1.0).is_empty(), "the interface asking again");
assert!(d.start(&[0], retry + 1_000.0).is_empty(), "the retry timer");
assert_eq!(d.finished(0, true, retry + 2_000.0), None);
assert!(d.start(&[0], 1e12).is_empty(), "loaded");
}
/// A clock that reads earlier than the failure (one set back meanwhile) does not hold the
/// retry back: the timer that asks for it has waited already.
#[test]
fn a_clock_set_back_after_a_failure_does_not_stop_the_retry() {
let mut d = Demand::default();
let failed_at = 1e12;
d.start(&[0], failed_at);
assert_eq!(d.finished(0, false, failed_at), Some(RETRY_MS));
assert!(d.start(&[0], failed_at + 1.0).is_empty(), "still waiting");
assert_eq!(d.start(&[0], failed_at - 3_600_000.0), [0], "the clock went back an hour");
}
}
+51 -8
View File
@@ -1,17 +1,22 @@
//! Craft-fonts faces served beside the wasm (`fonts/<sha16>/…`, copied by
//! `cargo xtask web-fonts`) instead of embedded: [`load_startup_fonts`] fetches the `startup`
//! ones before the app starts, [`spawn_background_fonts`] the rest once it runs. The browser checks
//! each file against its SHA-256 (Subresource Integrity). A face that fails is logged and skipped:
//! the app runs without it. With `WEB_FONTS` empty (built without craft-fonts) both do nothing.
//! ones before the app starts, [`spawn_background_fonts`] the `background` ones once it runs, and
//! [`want_chars`] a `demand` face (Korean, Devanagari) when the interface language or the
//! interface's own text needs its script. The browser checks each file against its SHA-256
//! (Subresource Integrity). A face that fails is logged and skipped: the app runs without it. With
//! `WEB_FONTS` empty (built without craft-fonts) these do nothing.
use std::cell::Cell;
use std::cell::{Cell, RefCell};
use std::rc::Rc;
use vectorcraft_text::craft_fonts::demand_fonts;
use vectorcraft_text::{FontDb, WEB_FONTS, WebFont};
use wasm_bindgen::JsCast as _;
use wasm_bindgen::closure::Closure;
use wasm_bindgen_futures::JsFuture;
use crate::demand::Demand;
/// Per startup face: the page shows its loading text meanwhile.
const STARTUP_TIMEOUT_MS: i32 = 20_000;
/// Per background face.
@@ -22,12 +27,49 @@ const BACKGROUND_PARALLEL: usize = 4;
thread_local! {
/// The background fetch runs once per page, though a graphics restart creates the app again.
static BACKGROUND_STARTED: Cell<bool> = const { Cell::new(false) };
/// The `demand` faces' fetches.
static DEMAND: RefCell<Demand> = RefCell::new(Demand::default());
/// The running app's context, asked for a frame when a `demand` face arrives (none before the
/// app starts: its first frame looks through the faces loaded by then).
static REPAINT: RefCell<Option<egui::Context>> = const { RefCell::new(None) };
}
/// Fetch, in the background, the `demand` faces for the scripts of `chars` that are not loaded or
/// being fetched. Each one that arrives asks the app for a frame, and the interface draws those
/// characters with it from then on. Set as the interface's missing-glyph handler
/// (`vectorcraft_ui_egui::on_missing_glyphs`), and called with the interface language's name
/// before the app starts.
pub fn want_chars(chars: &[char]) {
let wanted = demand_fonts(WEB_FONTS, chars.iter().copied());
if !wanted.is_empty() {
fetch_demand(&wanted);
}
}
/// Fetch the `demand` faces `wanted` (indexes into `WEB_FONTS`) that [`Demand::start`] lets start.
/// A face whose fetch fails is fetched again after the wait [`Demand::finished`] gives.
fn fetch_demand(wanted: &[usize]) {
for i in DEMAND.with(|d| d.borrow_mut().start(wanted, vectorcraft_ui_egui::now_ms())) {
let Some(f) = WEB_FONTS.get(i) else { continue };
wasm_bindgen_futures::spawn_local(async move {
let ok = load(f, BACKGROUND_TIMEOUT_MS).await;
let retry = DEMAND.with(|d| d.borrow_mut().finished(i, ok, vectorcraft_ui_egui::now_ms()));
if ok && let Some(ctx) = REPAINT.with(|r| r.borrow().clone()) {
ctx.request_repaint();
}
if let Some(wait) = retry {
// A second longer, so a clock the browser coarsens still reads the wait as over.
crate::api::sleep(wait.saturating_add(1_000)).await;
fetch_demand(&[i]);
}
});
}
}
/// Fetch and register the `startup` faces (one after the other). Returns how many loaded.
pub async fn load_startup_fonts() -> usize {
let mut loaded = 0;
for f in WEB_FONTS.iter().filter(|f| f.startup) {
for f in WEB_FONTS.iter().filter(|f| f.startup && !f.demand) {
if load(f, STARTUP_TIMEOUT_MS).await {
loaded += 1;
}
@@ -36,13 +78,14 @@ pub async fn load_startup_fonts() -> usize {
}
/// Fetch and register the `background` faces, [`BACKGROUND_PARALLEL`] at a time, asking `ctx` for
/// a frame after each so the font menus and the canvas pick it up. Only the first call does
/// anything.
/// a frame after each so the font menus and the canvas pick it up. Only the first call fetches
/// anything; each call makes `ctx` the context a `demand` face asks for a frame.
pub fn spawn_background_fonts(ctx: egui::Context) {
REPAINT.with(|r| *r.borrow_mut() = Some(ctx.clone()));
if BACKGROUND_STARTED.with(|s| s.replace(true)) {
return;
}
let queue: Rc<Vec<&'static WebFont>> = Rc::new(WEB_FONTS.iter().filter(|f| !f.startup).collect());
let queue: Rc<Vec<&'static WebFont>> = Rc::new(WEB_FONTS.iter().filter(|f| !f.startup && !f.demand).collect());
let next = Rc::new(Cell::new(0usize));
for _ in 0..BACKGROUND_PARALLEL.min(queue.len()) {
let (queue, next, ctx) = (queue.clone(), next.clone(), ctx.clone());
+2
View File
@@ -21,6 +21,8 @@
#[cfg(target_arch = "wasm32")]
mod api;
#[cfg(any(target_arch = "wasm32", test))]
mod demand;
#[cfg(target_arch = "wasm32")]
mod fonts;
#[cfg(any(target_arch = "wasm32", test))]
+5
View File
@@ -81,6 +81,11 @@ pub fn start() {
return;
};
detect_language();
// The face for a Korean or Hindi browser language (or `?lang=`) starts loading now, beside the
// startup fonts, without holding up the start. Text in those scripts painted later (a saved
// interface language, another one chosen, a layer or file name) has its face fetched then.
vectorcraft_ui_egui::on_missing_glyphs(crate::fonts::want_chars);
crate::fonts::want_chars(&i18n::system_lang().name().chars().collect::<Vec<_>>());
wasm_bindgen_futures::spawn_local(async move {
// Before the first frame, which looks for copies a crash left behind.
let locks = WebLocks::start(RECOVERY_PREFIX).await;
+41 -7
View File
@@ -73,7 +73,7 @@ fn open_extensions(exts: &[impl AsRef<str>], any_case: bool) -> Vec<String> {
/// `d` set up for `request`: its title, file types, folder and suggested name.
fn dialog_for<D: DialogSettings>(d: D, request: &PickRequest) -> D {
let pick = match request {
PickRequest::Open(pick) | PickRequest::Save(pick) => pick,
PickRequest::Open(pick) | PickRequest::Save(pick) | PickRequest::OpenFiles(pick) => pick,
PickRequest::OpenMany => {
return fileio::place_filters().fold(d.title(vectorcraft_ui_egui::i18n::t("Place")), |d, (name, exts)| {
d.filter(
@@ -83,8 +83,9 @@ fn dialog_for<D: DialogSettings>(d: D, request: &PickRequest) -> D {
});
}
PickRequest::Folder => return d,
PickRequest::FolderAt(folder) => return d.folder(folder),
};
let any_case = CASE_SENSITIVE_FILTERS && matches!(request, PickRequest::Open(_));
let any_case = CASE_SENSITIVE_FILTERS && matches!(request, PickRequest::Open(_) | PickRequest::OpenFiles(_));
let d = pick.filters.iter().fold(d, |d, (name, exts)| {
d.filter(
vectorcraft_ui_egui::i18n::tr_ctx(vectorcraft_ui_egui::i18n::current(), "file-filter", name.as_str()),
@@ -98,6 +99,37 @@ fn dialog_for<D: DialogSettings>(d: D, request: &PickRequest) -> D {
if pick.name.is_empty() { d } else { d.file_name(&pick.name) }
}
#[cfg(test)]
#[test]
fn a_folder_picker_asked_for_a_folder_starts_there() {
/// The settings a dialog was given, by name.
#[derive(Default)]
struct Recorded(Vec<String>);
impl DialogSettings for Recorded {
fn parent(self, _: &winit::window::Window) -> Self {
self
}
fn title(mut self, title: &str) -> Self {
self.0.push(format!("title {title}"));
self
}
fn filter(mut self, name: &str, _: &[impl ToString]) -> Self {
self.0.push(format!("filter {name}"));
self
}
fn folder(mut self, folder: &str) -> Self {
self.0.push(format!("folder {folder}"));
self
}
fn file_name(mut self, name: &str) -> Self {
self.0.push(format!("name {name}"));
self
}
}
assert_eq!(dialog_for(Recorded::default(), &PickRequest::FolderAt("/a/b".into())).0, ["folder /a/b"]);
assert!(dialog_for(Recorded::default(), &PickRequest::Folder).0.is_empty());
}
/// A native file dialog for `request` over `parent` (on Linux the portal then shows it over the
/// window and keeps it in front).
#[cfg(not(target_os = "macos"))]
@@ -130,9 +162,9 @@ fn show_dialog(dialog: rfd::FileDialog, request: &PickRequest, parent: &Parent)
}
let paths = match request {
PickRequest::Open(_) => dialog.pick_file().into_iter().collect(),
PickRequest::OpenMany => dialog.pick_files().unwrap_or_default(),
PickRequest::OpenMany | PickRequest::OpenFiles(_) => dialog.pick_files().unwrap_or_default(),
PickRequest::Save(_) => dialog.save_file().into_iter().collect(),
PickRequest::Folder => dialog.pick_folder().into_iter().collect(),
PickRequest::Folder | PickRequest::FolderAt(_) => dialog.pick_folder().into_iter().collect(),
};
paths.into_iter().map(|p| p.to_string_lossy().to_string()).collect()
}
@@ -315,7 +347,7 @@ fn start_pick(request: PickRequest, parent: &Parent, ui: &egui::Context) -> Opti
let picked = dialog.pick_file();
Box::pin(async move { picked.await.iter().map(path).collect() })
}
PickRequest::OpenMany => {
PickRequest::OpenMany | PickRequest::OpenFiles(_) => {
let picked = dialog.pick_files();
Box::pin(async move { picked.await.unwrap_or_default().iter().map(path).collect() })
}
@@ -334,7 +366,7 @@ fn start_pick(request: PickRequest, parent: &Parent, ui: &egui::Context) -> Opti
// on that nil; treat the pick as cancelled instead (#5980).
Err(()) => Box::pin(async move { Vec::new() }),
},
PickRequest::Folder => {
PickRequest::Folder | PickRequest::FolderAt(_) => {
let picked = dialog.pick_folder();
Box::pin(async move { picked.await.iter().map(path).collect() })
}
@@ -355,7 +387,7 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
.and_then(|w| w.window_handle().ok())
.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);
let (p1, p2, p3, p4, p5, p6, p7) = (parent.clone(), parent.clone(), parent.clone(), parent.clone(), parent.clone(), parent.clone(), parent);
#[cfg(any(target_os = "macos", target_os = "linux", windows))]
let sampled_ui = ui.clone();
#[cfg(target_os = "linux")]
@@ -363,6 +395,7 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
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))),
pick_open_files: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::OpenFiles(pick.clone()), &p6))),
pick_save: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::Save(pick.clone()), &p3).into_iter().next())),
// Linux shows dialogs on a thread of their own (#592), macOS as sheets (#867); Windows
// dialogs run the window's events while they are open.
@@ -410,6 +443,7 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
// Edit Original of a raster image with Use System Defaults for Edit Original off (#5236).
open_in_photocraft: Some(Box::new(open_in_photocraft)),
pick_folder: Some(Box::new(move || pick_now(PickRequest::Folder, &p4).into_iter().next())),
pick_folder_at: Some(Box::new(move |start: &str| pick_now(PickRequest::FolderAt(start.to_string()), &p7).into_iter().next())),
// Sample Color from Screen: the system's color sampler.
#[cfg(target_os = "macos")]
screen_color: Some(mac_screen_color::sampler(sampled_ui)),
+1
View File
@@ -554,6 +554,7 @@ fn main() -> std::process::ExitCode {
// File Info's metadata templates live in their own folder next to the preferences.
prefs_dir::attach_metadata_templates_dir(&mut session);
prefs_dir::attach_new_doc_profiles(&mut session);
prefs_dir::attach_script_data(&mut session);
let mut app = VectorcraftApp::new(session, services(cc.winit_window().cloned(), cc.egui_ctx.clone()));
app.set_startup_update_check(true);
load_prefs(&mut app, saved);
+9
View File
@@ -81,6 +81,15 @@ pub fn attach_new_doc_profiles(session: &mut vectorcraft_engine::Session) {
}
}
/// Keep each script's `Folder.userData` in the `Script Data` folder, and the file access people
/// allow scripts with Always in `Script Grants.json` beside it. Both are made when a script first
/// needs them.
pub fn attach_script_data(session: &mut vectorcraft_engine::Session) {
if let Some(dir) = store_dir("Script Data") {
session.attach_script_data(dir);
}
}
/// Take the saved PDF presets from the `PDF Presets` folder (#2168), and keep the ones saved from
/// now on there. After the preferences were restored: the folder is the one place the presets live.
pub fn attach_pdf_preset_store(session: &mut vectorcraft_engine::Session) {
+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="7.5"/><circle cx="4.5" cy="12" r="1.6" fill="currentColor"/><circle cx="19.5" cy="12" r="1.6" fill="currentColor"/><circle cx="12" cy="4.5" r="1.6" fill="currentColor"/></svg>

After

Width:  |  Height:  |  Size: 386 B

+98 -6
View File
@@ -9,7 +9,6 @@
//! the stroke with what the pen recorded on it (`StrokeLayer::pressure`, `tilt`, `bearing` and
//! `rotation`): the sweep is sampled densely and each sample takes the nib for the pen there.
use vectorcraft_color::Paint;
use vectorcraft_doc::{Node, StrokeLayer};
use vectorcraft_geom::{BezPath, PathData, Point, SubPath, Vec2};
@@ -198,7 +197,70 @@ fn offset_track(t: &Track, d: f64, trim0: f64, trim1: f64) -> Option<BezPath> {
Some(bp)
}
pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, paint: &Paint, name: &str) -> Vec<Node> {
/// A strand that follows the recorded pen pose. Pressure and tilt change its spread; bearing and
/// barrel rotation turn that spread in the path's local frame. Original path corners are included
/// in the samples so a turn is not rounded away by the pose sampling interval.
fn posed_bristle_track(
t: &Track,
d: f64,
trim0: f64,
trim1: f64,
size: f64,
stroke: &StrokeLayer,
varies: bool,
) -> Option<(BezPath, Vec<(f64, f64)>)> {
let l = t.len();
let (s0, s1) = (trim0.clamp(0.0, l), (l - trim1).clamp(0.0, l));
if s1 - s0 < 1e-6 {
return None;
}
let steps = if varies { ((s1 - s0) / (size * 0.2).max(0.25)).ceil().clamp(1.0, MAX_STEPS) as usize } else { 1 };
let mut positions: Vec<f64> = (0..=steps).map(|i| s0 + (s1 - s0) * i as f64 / steps as f64).collect();
positions.extend(t.cum.iter().copied().filter(|&s| s > s0 && s < s1));
positions.sort_by(f64::total_cmp);
positions.dedup_by(|a, b| (*a - *b).abs() < 1e-6);
let mut path = BezPath::new();
// Distance along the posed strand -> fraction along the original, untrimmed path.
let mut source = Vec::with_capacity(positions.len());
let mut previous: Option<Point> = None;
let mut distance = 0.0;
for (i, s) in positions.into_iter().enumerate() {
let pen = PenAt::of(stroke, s / l);
let pressure = pen.control(Variation::Pressure).unwrap_or(0.5);
let tilt = pen.control(Variation::Tilt).unwrap_or(0.5);
let bearing = pen.control(Variation::Bearing).unwrap_or(0.5);
let rotation = pen.control(Variation::Rotation).unwrap_or(0.5);
let spread = d * (0.5 + pressure) * (1.25 - 0.5 * tilt);
let angle = std::f64::consts::TAU * (bearing + rotation - 1.0);
let p = t.map(s + spread * angle.sin(), spread * angle.cos());
if i == 0 {
path.move_to(p)
} else {
path.line_to(p)
}
if let Some(previous) = previous {
distance += previous.distance(p);
}
source.push((distance, s / l));
previous = Some(p);
}
Some((path, source))
}
fn source_fraction(source: &[(f64, f64)], distance: f64) -> f64 {
let next = source.partition_point(|(d, _)| *d < distance);
if next == 0 {
return source.first().map_or(0.0, |(_, f)| *f);
}
if next >= source.len() {
return source.last().map_or(1.0, |(_, f)| *f);
}
let (d0, f0) = source[next - 1];
let (d1, f1) = source[next];
if d1 - d0 < 1e-9 { f1 } else { f0 + (f1 - f0) * ((distance - d0) / (d1 - d0)) }
}
pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, stroke: &StrokeLayer, name: &str) -> Vec<Node> {
let mut rng = Rng::new(seed_of(bp, name));
let size = b.size.max(0.1) * weight;
let strands = (3.0 + b.density.clamp(1.0, 100.0) / 100.0 * 13.0).round() as usize;
@@ -210,6 +272,13 @@ pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, paint: &Paint, nam
let wobble = (100.0 - b.stiffness.clamp(1.0, 100.0)) / 100.0;
let ragged = b.length.clamp(25.0, 300.0) / 100.0;
let opacity = (b.opacity.clamp(1.0, 100.0) / 100.0) as f32;
let posed = stroke.pressure.is_some() || stroke.tilt.is_some() || stroke.bearing.is_some() || stroke.rotation.is_some();
let varies = |points: &[(f64, f64)]| points.first().is_some_and(|(_, first)| points.iter().any(|(_, value)| (value - first).abs() > 1e-6));
let pressure_varies = stroke.pressure.as_ref().is_some_and(|p| varies(&p.points));
let pose_varies = pressure_varies
|| stroke.tilt.as_ref().is_some_and(|p| varies(&p.points))
|| stroke.bearing.as_ref().is_some_and(|p| varies(&p.points))
|| stroke.rotation.as_ref().is_some_and(|p| varies(&p.points));
let mut out = vec![];
for t in tracks(bp, tolerance(size)) {
let l = t.len();
@@ -220,14 +289,37 @@ pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, paint: &Paint, nam
let edge = 1.0 - lane.abs();
let trim = |r: &mut Rng| r.unit() * ragged * size * (1.2 - edge) * 0.8;
let (t0, t1) = (trim(&mut rng), trim(&mut rng));
let Some(sp) = offset_track(&t, off, t0.min(l * 0.3), t1.min(l * 0.3)) else { continue };
let (t0, t1) = (t0.min(l * 0.3), t1.min(l * 0.3));
let sp = if posed {
posed_bristle_track(&t, off, t0, t1, size, stroke, pose_varies)
} else {
offset_track(&t, off, t0, t1).map(|path| (path, Vec::new()))
};
let Some((sp, source)) = sp else { continue };
let w = thick * (0.6 + 0.4 * edge) * rng.range(0.8, 1.2);
let nib = Nib::new(0.0, 1.0, w);
let subs: Vec<SubPath> = tracks(&sp, tolerance(w)).iter().flat_map(|tt| sweep(tt, &|_| nib, None)).collect();
let subs: Vec<SubPath> = tracks(&sp, tolerance(w))
.iter()
.flat_map(|tt| {
if posed {
sweep(
tt,
&|f| {
let original_fraction = source_fraction(&source, f * tt.len());
let pressure = PenAt::of(stroke, original_fraction).control(Variation::Pressure).unwrap_or(0.5);
Nib::new(0.0, 1.0, w * (0.5 + pressure))
},
pressure_varies.then_some((tt.len() / MAX_STEPS).max(0.25)),
)
} else {
let nib = Nib::new(0.0, 1.0, w);
sweep(tt, &|_| nib, None)
}
})
.collect();
if subs.is_empty() {
continue;
}
let mut n = filled(PathData::new(subs), paint);
let mut n = filled(PathData::new(subs), &stroke.paint);
n.opacity = (opacity * rng.range(0.7, 1.0) as f32).clamp(0.0, 1.0);
out.push(n);
}
+9 -1
View File
@@ -1084,7 +1084,7 @@ pub fn stroke_pieces(doc: &Document, brush: &Brush, bp: &BezPath, stroke: &Strok
let w = if stroke.width > 0.0 { stroke.width } else { 1.0 };
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::Bristle(b) => calli::bristle(b, bp, w, stroke, &brush.name),
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),
@@ -1245,6 +1245,14 @@ pub fn has_brush(n: &Node) -> bool {
n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.brush.is_some() && s.visible))
}
/// Does `stroke` draw with a brush of `lib` (the document's [`library`])? [`stroke_pieces`] sizes
/// brush art from the brush and the stroke weight and does not read the stroke's width profile, so
/// the profile does not change what such a stroke draws. A stroke without a brush, or one that
/// names a brush `lib` lacks, draws a plain stroke, which follows the profile.
pub fn keeps_brush_size(lib: &[Brush], stroke: &StrokeLayer) -> bool {
stroke.brush.as_deref().is_some_and(|name| lib.iter().any(|b| b.name == name))
}
/// How far brush art can paint past the visual box of `n`: `16 × w + 8`, where `w` is the widest
/// stroke of `n` (at least 1), when `n` has a visible brushed stroke with a paint; 0 when it has
/// none, as a brushed stroke without a paint draws no brush art. This is the room the renderer and
+80
View File
@@ -827,6 +827,86 @@ fn bristle_makes_translucent_strands() {
assert!(bb.height() <= 6.0 * 1.3 && bb.height() >= 3.0, "{bb:?}");
}
#[test]
fn bristle_pen_pressure_changes_its_footprint() {
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle::default()) };
let render = |pressure| {
let s = StrokeLayer { pressure: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, pressure), (1.0, pressure)] }), ..stroke(1.0) };
stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 200.0, 0.0), &s)
};
let light = render(0.0);
let heavy = render(1.0);
assert_eq!(light.len(), heavy.len());
assert!(bounds(&heavy).height() > bounds(&light).height() * 1.8);
}
#[test]
fn bristle_pen_pressure_is_sampled_along_the_stroke() {
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle::default()) };
let s = StrokeLayer { pressure: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] }), ..stroke(1.0) };
let out = stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 200.0, 0.0), &s);
let mut points = Vec::new();
for n in &out {
all_points(n, &mut points);
}
let early = points.iter().filter(|p| p.x > 20.0 && p.x < 60.0).map(|p| p.y.abs()).fold(0.0_f64, f64::max);
let late = points.iter().filter(|p| p.x > 140.0 && p.x < 180.0).map(|p| p.y.abs()).fold(0.0_f64, f64::max);
assert!(late > early * 1.4, "spread along stroke: {early} -> {late}");
}
#[test]
fn trimmed_bristle_strands_read_pressure_where_they_begin() {
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle { size: 20.0, length: 300.0, ..Default::default() }) };
let render = |points| {
let s = StrokeLayer { pressure: Some(vectorcraft_doc::PressureProfile { points }), ..stroke(1.0) };
stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 80.0, 0.0), &s)
};
let ramp = render(vec![(0.0, 0.0), (1.0, 1.0)]);
let neutral = render(vec![(0.0, 0.5), (1.0, 0.5)]);
assert_eq!(ramp.len(), neutral.len());
let start = |n: &Node| {
let anchors = &n.path_data().unwrap().subpaths[0].anchors;
let first = anchors[0].p;
let opposite = anchors[anchors.len() - 16].p;
(first.x, (first.y - opposite.y).abs())
};
let mut checked = false;
for (ramp, neutral) in ramp.iter().zip(&neutral) {
let (x, width) = start(ramp);
if x < 12.0 {
continue;
}
let (_, neutral_width) = start(neutral);
let expected = 0.5 + x / 80.0;
assert!(width / neutral_width > expected - 0.08, "strand at {x}: {width} vs {neutral_width}, expected ratio {expected}");
checked = true;
}
assert!(checked, "at least one strand begins past the pressure ramp's first eighth");
}
#[test]
fn bristle_pen_orientation_changes_its_footprint() {
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle::default()) };
let render = |tilt, bearing, rotation| {
let flat = |x| vec![(0.0, x), (1.0, x)];
let s = StrokeLayer {
tilt: Some(vectorcraft_doc::PressureProfile { points: flat(tilt) }),
bearing: Some(vectorcraft_doc::AngleProfile { points: flat(bearing) }),
rotation: Some(vectorcraft_doc::AngleProfile { points: flat(rotation) }),
..stroke(1.0)
};
stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 200.0, 0.0), &s)
};
let neutral = bounds(&render(0.5, 0.0, 0.0)).height();
let flat = bounds(&render(1.0, 0.0, 0.0)).height();
let upright = bounds(&render(0.0, 0.0, 0.0)).height();
let bearing = bounds(&render(0.5, 90.0, 0.0)).height();
let rotation = bounds(&render(0.5, 0.0, 90.0)).height();
assert!(flat > neutral && neutral > upright, "tilt: {flat} > {neutral} > {upright}");
assert!(bearing < neutral * 0.7, "bearing: {bearing} vs {neutral}");
assert!(rotation < neutral * 0.7, "rotation: {rotation} vs {neutral}");
}
#[test]
fn tints_colorization_uses_stroke_colour() {
let b = art_brush(rect_art(10.0, 4.0), ArtScale::Stretch);
+33 -6
View File
@@ -7,6 +7,8 @@
//! hatches, type text entities or glyph outlines, and placed images image entities linked to PNG
//! or JPEG files the caller writes next to the drawing. Coordinates are y-up, in drawing units: `scale` units per
//! `unit` of the art, with the origin at the bottom-left corner of [`DxfOptions::region`].
//! [`export_drawings`] writes one such drawing for each of several regions, applying the live
//! effects once for all of them.
//!
//! What DXF can't hold (blending modes, opacity masks, raster effects, gradients, patterns,
//! clipping) is approximated or left out, and each such loss comes back as a warning.
@@ -436,18 +438,43 @@ pub const SCALE_RANGE: std::ops::RangeInclusive<f64> = 1e-6..=1e6;
/// Write `doc` as a DXF drawing with `opts`. Live geometry effects are applied first; template
/// layers, guides and hidden objects are left out.
pub fn export(doc: &Document, opts: &DxfOptions) -> Result<DxfOutput, String> {
Ok(export_drawings(doc, opts, &[(opts.region, opts.crop)])?.pop().unwrap_or_default())
}
/// Write `doc` as one DXF drawing for each `(region, crop)` of `drawings`, in order, each as
/// [`export`] writes it with `opts` and that region and crop. Live geometry effects are applied
/// once for all the drawings.
pub fn export_drawings(doc: &Document, opts: &DxfOptions, drawings: &[(Rect, bool)]) -> Result<Vec<DxfOutput>, String> {
export_drawings_with(doc, opts, drawings, bake_for_drawings)
}
/// `doc` with its live geometry effects applied and its symbols' art placed, or `None` when
/// nothing changes.
fn bake_for_drawings(doc: &Document) -> Option<Document> {
// Symbols' art is placed without clipping, as the scene places it.
let layers = vectorcraft_effects::WrittenLayers { hidden: true, non_printing: true, hidden_objects: false };
vectorcraft_effects::bake_document_placing_symbols(doc, false, layers)
}
/// [`export_drawings`] with `bake` applying the live effects.
fn export_drawings_with(
doc: &Document,
opts: &DxfOptions,
drawings: &[(Rect, bool)],
bake: impl Fn(&Document) -> Option<Document>,
) -> Result<Vec<DxfOutput>, String> {
if !(opts.scale.is_finite() && SCALE_RANGE.contains(&opts.scale)) {
return Err(format!("scale must be a number from {} to {}, not {}", SCALE_RANGE.start(), SCALE_RANGE.end(), opts.scale));
}
let r = opts.region;
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) {
if drawings.iter().any(|(r, _)| ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite())) {
return Err("the export region is not finite".into());
}
// Symbols' art is placed without clipping, as the scene places it.
let layers = vectorcraft_effects::WrittenLayers { hidden: true, non_printing: true, hidden_objects: false };
let baked = vectorcraft_effects::bake_document_placing_symbols(doc, false, layers);
if drawings.is_empty() {
return Ok(vec![]);
}
let baked = bake(doc);
let doc = baked.as_ref().unwrap_or(doc);
Ok(scene::Scene::new(doc, opts).run())
Ok(drawings.iter().map(|&(region, crop)| scene::Scene::new(doc, &DxfOptions { region, crop, ..opts.clone() }).run()).collect())
}
#[cfg(test)]
+198
View File
@@ -1493,3 +1493,201 @@ fn export_bytes_match_shared_writer_goldens() {
assert_eq!(got, expected, "DXF bytes changed versus {}", path.display());
}
}
/// One drawing written by applying the live effects for it alone and walking the result, as each
/// drawing of a multi-drawing export was written before [`export_drawings`].
fn export_baking_alone(doc: &Document, opts: &DxfOptions) -> DxfOutput {
let baked = crate::bake_for_drawings(doc);
crate::scene::Scene::new(baked.as_ref().unwrap_or(doc), opts).run()
}
/// A written drawing's bytes, linked images (name and bytes), warnings and setting notes.
type Written = (Vec<u8>, Vec<(String, Vec<u8>)>, Vec<String>, Vec<String>);
/// Every field of a written drawing, for comparing two.
fn written(out: &DxfOutput) -> Written {
let images = out.images.iter().map(|i| (i.name.clone(), i.bytes.clone())).collect();
(out.bytes.clone(), images, out.warnings.clone(), out.setting_notes.clone())
}
/// A Transform effect that moves its object `x` pt right.
fn moved_by(mut n: Node, x: f64) -> Node {
n.appearance.effects.push(vectorcraft_doc::Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": x}), visible: true });
n
}
/// A line moved by a Transform effect, an instance of a symbol whose art carries the same effect
/// stained by its fill, a semi-transparent line in a blending mode, and a placed PNG image.
fn drawings_doc() -> Document {
let png = craft_image_codecs::encode(
&craft_image_codecs::Image::from_raw(
2,
2,
craft_image_codecs::ChannelLayout::Rgba,
craft_image_codecs::SampleType::U8,
[0u8, 128, 255, 255].repeat(4),
)
.unwrap(),
craft_image_codecs::Format::Png,
&craft_image_codecs::EncodeOptions::default(),
)
.unwrap();
let mut d = doc_with(|d| {
let line = path(d, shapes::line((10.0, 10.0).into(), (20.0, 10.0).into()), Paint::None, Paint::solid(Color::BLACK), 1.0);
let mut instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Moved".into(), xf: Affine::IDENTITY });
instance.appearance = Appearance::basic(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), Paint::None, 0.0).into();
let mut faint = path(d, shapes::line((10.0, 90.0).into(), (190.0, 90.0).into()), Paint::None, Paint::solid(Color::BLACK), 1.0);
faint.opacity = 0.5;
faint.blend = vectorcraft_color::BlendMode::Multiply;
let im = ImageObject {
key: "raster-1".into(),
width: 2,
height: 2,
xf: Affine::translate((150.0, 20.0)) * Affine::scale(10.0),
link: None,
placement: Default::default(),
pixels: None,
};
vec![moved_by(line, 100.0), instance, faint, Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)))]
});
let art = path(&mut d, shapes::rectangle(Rect::new(10.0, 40.0, 30.0, 60.0)), Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::None, 0.0);
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Moved".into(), art: Arc::new(moved_by(art, 20.0)) });
d.images.insert("raster-1".into(), ImageBlob { mime: "image/png".into(), bytes: Arc::new(png), proxy: None });
d
}
#[test]
fn drawings_apply_the_live_effects_once_and_match_drawings_written_alone() {
let d = drawings_doc();
assert!(crate::bake_for_drawings(&d).is_some(), "the document has live effects to apply");
// The left and right halves cropped, the whole page uncropped, and a region off the page.
let drawings = [
(Rect::new(0.0, 0.0, 100.0, 100.0), true),
(Rect::new(100.0, 0.0, 200.0, 100.0), true),
(Rect::new(0.0, 0.0, 200.0, 100.0), false),
(Rect::new(300.0, 0.0, 400.0, 100.0), true),
];
// With every option, and with images and hatches left out (which adds setting notes).
let all_in = opts(&d);
for o in [all_in.clone(), DxfOptions { include_images: false, include_hatches: false, ..all_in }] {
let bakes = std::cell::Cell::new(0);
let outs = crate::export_drawings_with(&d, &o, &drawings, |doc| {
bakes.set(bakes.get() + 1);
crate::bake_for_drawings(doc)
})
.unwrap();
assert_eq!(bakes.get(), 1, "the live effects are applied once for every drawing");
assert_eq!(outs.len(), drawings.len());
for ((region, crop), out) in drawings.iter().zip(&outs) {
let alone = export_baking_alone(&d, &DxfOptions { region: *region, crop: *crop, ..o.clone() });
assert_eq!(written(out), written(&alone), "the drawing over {region:?}, crop {crop}");
let one = export(&d, &DxfOptions { region: *region, crop: *crop, ..o.clone() }).unwrap();
assert_eq!(written(&one), written(&alone), "export over {region:?}, crop {crop}");
}
let public: Vec<_> = export_drawings(&d, &o, &drawings).unwrap().iter().map(written).collect();
assert_eq!(public, outs.iter().map(written).collect::<Vec<_>>());
// The halves hold different art, the left half a line with losses, and the region off the
// page nothing.
assert!(!entities(&outs[0]).is_empty() && !entities(&outs[1]).is_empty() && !outs[0].warnings.is_empty());
assert_ne!(outs[0].bytes, outs[1].bytes);
assert!(entities(&outs[3]).is_empty() && outs[3].images.is_empty());
if o.include_images {
assert_eq!(outs[2].images.len(), 1);
} else {
assert!(!outs[2].setting_notes.is_empty() && outs[2].images.is_empty());
}
}
}
#[test]
fn drawings_are_checked_before_the_live_effects_are_applied() {
let d = drawings_doc();
let o = opts(&d);
let bakes = std::cell::Cell::new(0);
let count = |doc: &Document| {
bakes.set(bakes.get() + 1);
crate::bake_for_drawings(doc)
};
let page = (d.artboards[0].rect, false);
let off = (Rect::new(0.0, 0.0, f64::NAN, 100.0), false);
assert_eq!(crate::export_drawings_with(&d, &o, &[page, off], count).unwrap_err(), "the export region is not finite");
let e = crate::export_drawings_with(&d, &DxfOptions { scale: 0.0, ..o.clone() }, &[page], count).unwrap_err();
assert!(e.starts_with("scale must be a number"), "{e}");
assert!(crate::export_drawings_with(&d, &o, &[], count).unwrap().is_empty());
assert_eq!(bakes.get(), 0, "nothing is applied for drawings that are refused or for none");
}
/// The thread's time on the CPU in nanoseconds where Linux reports it, otherwise `None`.
fn thread_cpu_ns() -> Option<u64> {
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
}
/// Time a Use Artboards export of eight artboards whose art has live effects, written drawing by
/// drawing with the effects applied for each (as before [`export_drawings`]) and with
/// [`export_drawings`], alternating, seven times each, and check that both write the same
/// drawings. Prints the median of each in milliseconds of the thread's CPU time (on Linux) and of
/// wall-clock time.
/// Run with `cargo test --release -p vectorcraft-cad --lib dxf_artboards_bake_perf -- --ignored --nocapture`.
#[test]
#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
fn dxf_artboards_bake_perf() {
const BOARDS: usize = 8;
let mut d = Document::new(200.0 * BOARDS as f64, 200.0);
let layer = d.layers[0].id;
let effect = |id: &str, params: serde_json::Value| vectorcraft_doc::Effect { id: id.into(), params, visible: true };
let mut art = vec![];
for i in 0..50 {
let (x, y) = (f64::from(i % 10) * 5.0, f64::from(i / 10) * 5.0);
art.push(Arc::new(path(&mut d, shapes::rectangle(Rect::new(x, y, x + 4.0, y + 4.0)), Paint::None, Paint::solid(Color::BLACK), 0.5)));
}
let mut cell = Node::group(d.alloc_id(), art);
cell.appearance.effects.push(effect("distort.zigZag", serde_json::json!({"size": 1.0, "relative": false, "ridges": 4, "points": "smooth"})));
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Cell".into(), art: Arc::new(cell) });
for b in 0..BOARDS {
let x0 = 200.0 * b as f64;
for i in 0..250 {
let (x, y) = (x0 + f64::from(i % 25) * 8.0, f64::from(i / 25) * 8.0);
let mut n = path(&mut d, shapes::ellipse(Rect::new(x, y, x + 6.0, y + 6.0)), Paint::None, Paint::solid(Color::BLACK), 0.5);
let params = serde_json::json!({"size": 1.0, "relative": false, "detail": 10.0, "points": "smooth", "seed": i});
n.appearance.effects.push(effect("distort.roughen", params));
d.insert(Some(layer), usize::MAX, n).unwrap();
}
for i in 0..20 {
let xf = Affine::translate((x0 + f64::from(i % 5) * 40.0, 100.0 + f64::from(i / 5) * 25.0));
let instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Cell".into(), xf });
d.insert(Some(layer), usize::MAX, instance).unwrap();
}
}
let o = DxfOptions { unit: Unit::Points, ..DxfOptions::default() };
let drawings: Vec<(Rect, bool)> = (0..BOARDS).map(|b| (Rect::new(200.0 * b as f64, 0.0, 200.0 * (b + 1) as f64, 200.0), true)).collect();
let before = || drawings.iter().map(|&(region, crop)| export_baking_alone(&d, &DxfOptions { region, crop, ..o.clone() })).collect::<Vec<_>>();
let after = || export_drawings(&d, &o, &drawings).unwrap();
let time = |f: &dyn Fn() -> Vec<DxfOutput>| {
let (cpu, wall) = (thread_cpu_ns(), std::time::Instant::now());
let outs = f();
let wall = wall.elapsed().as_secs_f64() * 1000.0;
let cpu = cpu.zip(thread_cpu_ns()).map(|(a, b)| (b - a) as f64 / 1e6);
(outs, cpu, wall)
};
let (mut runs_before, mut runs_after) = (vec![], vec![]);
for _ in 0..7 {
let (a, cpu_a, wall_a) = time(&before);
let (b, cpu_b, wall_b) = time(&after);
assert_eq!(a.len(), BOARDS);
assert_eq!(a.iter().map(written).collect::<Vec<_>>(), b.iter().map(written).collect::<Vec<_>>(), "both write the same drawings");
runs_before.push((cpu_a, wall_a));
runs_after.push((cpu_b, wall_b));
}
let median = |runs: &[(Option<f64>, f64)], cpu: bool| {
let mut v: Vec<f64> = runs.iter().filter_map(|r| if cpu { r.0 } else { Some(r.1) }).collect();
v.sort_by(f64::total_cmp);
v.get(v.len() / 2).copied()
};
for (name, runs) in [("drawing by drawing", &runs_before), ("export_drawings", &runs_after)] {
println!(
"{name}: {BOARDS} artboards, median CPU {:?} ms, median wall {:?} ms; runs (CPU ms, wall ms) {runs:?}",
median(runs, true),
median(runs, false)
);
}
}
+14 -3
View File
@@ -347,7 +347,9 @@ pub fn profiles_generation() -> u64 {
/// Profile `name` as an ICC file to embed in an export: any RGB or CMYK profile of [`profiles`]
/// (by its current or legacy name), or [`GRAY`]. Built-in profiles are written in code from the
/// CMS: the RGB spaces from their primaries, the CMYK spaces as lookup tables sampled from their
/// model (both directions, perceptual and relative colorimetric, Lab PCS); a profile the user
/// model (both directions, perceptual and relative colorimetric, Lab PCS, with the model's paper
/// as the media white point; the colorimetric Lab → CMYK table without black-point
/// compensation, the perceptual and saturation ones with it); a profile the user
/// loaded is the file it came from. Cached.
pub fn icc_bytes(name: &str) -> Result<Arc<[u8]>, CmsError> {
static CACHE: Mutex<Vec<(String, Arc<[u8]>)>> = Mutex::new(Vec::new());
@@ -361,8 +363,17 @@ pub fn icc_bytes(name: &str) -> Result<Arc<[u8]>, CmsError> {
let bytes: Arc<[u8]> = if name == GRAY {
icc::encode(&icc::gray_profile(name))?
} else if BUILTIN_CMYK.contains(&name) {
let cms = Cms::new(&ColorSettings { cmyk: name.into(), ..ColorSettings::default() })?;
icc::encode(&icc::cmyk_profile(name, |c| cms.cmyk_to_lab(c), |l| cms.lab_to_cmyk(l, Intent::RelativeColorimetric)))?
// The perceptual and saturation tables map the shadows with black-point compensation; the
// colorimetric table is the inverse of the CMYK → Lab table, without it.
let mapped = Cms::new(&ColorSettings { cmyk: name.into(), bpc: true, ..ColorSettings::default() })?;
let cms = Cms::new(&ColorSettings { cmyk: name.into(), bpc: false, ..ColorSettings::default() })?;
let paper = match &cms.cmyk {
CmykSpace::Generic(g) => g.paper_xyz(),
CmykSpace::Device | CmykSpace::Icc(_) => lab::D50,
};
let to_lab = |c| cms.cmyk_to_lab(c);
let shadows = |l| mapped.lab_to_cmyk(l, Intent::RelativeColorimetric);
icc::encode(&icc::cmyk_profile(name, paper, to_lab, shadows, |l| cms.lab_to_cmyk(l, Intent::RelativeColorimetric)))?
} else {
icc::builtin_rgb_bytes(name)?
}
+5
View File
@@ -133,6 +133,11 @@ pub struct GenericCmyk {
}
impl GenericCmyk {
/// Absolute XYZ (D50) of the paper.
pub fn paper_xyz(&self) -> [f32; 3] {
self.paper_xyz
}
pub fn new(params: GenericCmykParams) -> Self {
let paper_xyz = lab_to_xyz(params.paper);
let mut prim = [D50; 16];
+26 -12
View File
@@ -446,11 +446,20 @@ const B2A_GRID: usize = 17;
const GAMUT_GRID: usize = 9;
/// A CMYK output profile sampled from a conversion: `to_lab` (CMYK → media-relative Lab) in a
/// 9⁴ table, `from_lab` (Lab → CMYK, gamut-mapped) in a 17³ table, Lab PCS (ICC v4 encoding).
/// 9⁴ table, and Lab → CMYK in 17³ tables, Lab PCS (ICC v4 encoding): `mapped` (gamut-mapped,
/// with black-point compensation) for the perceptual and saturation intents, `colorimetric` (the
/// colorimetric inverse of `to_lab`) for the colorimetric intents and the gamut tag.
/// It carries every tag ICC.1 requires of an output profile: the tables for all three intents
/// and the gamut tag (Windows rejects a CMYK profile without them, so Photos couldn't show a CMYK
/// TIFF that embedded one, #2707).
pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, from_lab: impl Fn(lab::Lab) -> [f32; 4]) -> ColorProfile {
/// TIFF that embedded one, #2707). The media white point is `paper` (absolute XYZ, D50), which
/// the ICC-absolute colorimetric intent reproduces.
pub(super) fn cmyk_profile(
name: &str,
paper: [f32; 3],
to_lab: impl Fn([f32; 4]) -> lab::Lab,
mapped: impl Fn(lab::Lab) -> [f32; 4],
colorimetric: impl Fn(lab::Lab) -> [f32; 4],
) -> ColorProfile {
let unit = |i: usize, n: usize| i as f32 / (n - 1) as f32;
let q = |v: f32| (v.clamp(0.0, 1.0) * 65535.0).round() as u16;
let mut a2b = Vec::with_capacity(A2B_GRID.pow(4) * 3);
@@ -459,17 +468,21 @@ pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, fr
let l = to_lab(cmyk);
a2b.extend([l.l / 100.0, (l.a + 128.0) / 255.0, (l.b + 128.0) / 255.0].map(q));
}
let mut b2a = Vec::with_capacity(B2A_GRID.pow(3) * 4);
for i in 0..B2A_GRID.pow(3) {
let [l, a, b] = [2, 1, 0].map(|d| unit(i / B2A_GRID.pow(d) % B2A_GRID, B2A_GRID));
b2a.extend(from_lab(lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0)).map(q));
}
let b2a_of = |from_lab: &dyn Fn(lab::Lab) -> [f32; 4]| {
let mut b2a = Vec::with_capacity(B2A_GRID.pow(3) * 4);
for i in 0..B2A_GRID.pow(3) {
let [l, a, b] = [2, 1, 0].map(|d| unit(i / B2A_GRID.pow(d) % B2A_GRID, B2A_GRID));
b2a.extend(from_lab(lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0)).map(q));
}
b2a
};
let (b2a_mapped, b2a) = (b2a_of(&mapped), b2a_of(&colorimetric));
// Gamut: 0 where a colour separates and comes back within a ΔE of 3, else out of gamut.
let mut gamut = Vec::with_capacity(GAMUT_GRID.pow(3));
for i in 0..GAMUT_GRID.pow(3) {
let [l, a, b] = [2, 1, 0].map(|d| unit(i / GAMUT_GRID.pow(d) % GAMUT_GRID, GAMUT_GRID));
let want = lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0);
gamut.push(if lab::delta_e2000(want, to_lab(from_lab(want))) <= 3.0 { 0 } else { u16::MAX });
gamut.push(if lab::delta_e2000(want, to_lab(colorimetric(want))) <= 3.0 { 0 } else { u16::MAX });
}
let identity = |n: usize| vec![ToneReprCurve::Parametric(vec![1.0]); n];
let table = |inputs: usize, outputs: usize, grid: usize, clut: Vec<u16>| {
@@ -490,6 +503,7 @@ pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, fr
})
};
let a2b = table(4, 3, A2B_GRID, a2b);
let b2a_mapped = table(3, 4, B2A_GRID, b2a_mapped);
let b2a = table(3, 4, B2A_GRID, b2a);
let gamut = table(3, 1, GAMUT_GRID, gamut);
let mut p = ColorProfile::default();
@@ -498,12 +512,12 @@ pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, fr
p.pcs = DataColorSpace::Lab;
p.rendering_intent = RenderingIntent::RelativeColorimetric;
p.white_point = moxcms::WHITE_POINT_D50.to_xyzd();
p.media_white_point = Some(p.white_point);
p.media_white_point = Some(moxcms::Xyzd::new(f64::from(paper[0]), f64::from(paper[1]), f64::from(paper[2])));
p.lut_a_to_b_perceptual = Some(a2b.clone());
p.lut_a_to_b_saturation = Some(a2b.clone());
p.lut_a_to_b_colorimetric = Some(a2b);
p.lut_b_to_a_perceptual = Some(b2a.clone());
p.lut_b_to_a_saturation = Some(b2a.clone());
p.lut_b_to_a_perceptual = Some(b2a_mapped.clone());
p.lut_b_to_a_saturation = Some(b2a_mapped);
p.lut_b_to_a_colorimetric = Some(b2a);
p.gamut = Some(gamut);
labelled(p, name)
+59 -7
View File
@@ -30,11 +30,62 @@ fn cmyk_profiles_convert_like_the_cms() {
let de = delta_e2000(lab::srgb_to_lab(want), lab::srgb_to_lab(got));
assert!(de < 2.5, "{name} {cmyk:?}: {want:?} vs {got:?} (ΔE {de})");
}
// And back: an in-gamut colour separates to about the same inks.
let srgb = cms.cmyk_to_srgb([0.1, 0.6, 0.8, 0.0], false);
let back = p.from_srgb(srgb, Intent::RelativeColorimetric).unwrap();
let again = cms.cmyk_to_srgb([back[0], back[1], back[2], back[3]], false);
assert!(delta_e2000(lab::srgb_to_lab(srgb), lab::srgb_to_lab(again)) < 3.0, "{back:?}");
// And back: in-gamut colours separate to inks that print them. The Lab → CMYK table is
// the colorimetric inverse of the CMYK → Lab table, with no black-point compensation.
for inks in [
[0.1, 0.6, 0.8, 0.0],
[0.5, 0.1, 0.3, 0.1],
[0.3, 0.3, 0.3, 0.2],
[0.05, 0.05, 0.4, 0.0],
[0.4, 0.3, 0.3, 0.6],
[0.6, 0.5, 0.5, 0.4],
[0.2, 0.2, 0.2, 0.8],
[0.0, 0.0, 0.0, 0.5],
] {
let srgb = cms.cmyk_to_srgb(inks, false);
let back = p.from_srgb(srgb, Intent::RelativeColorimetric).unwrap();
let again = cms.cmyk_to_srgb([back[0], back[1], back[2], back[3]], false);
let de = delta_e2000(lab::srgb_to_lab(srgb), lab::srgb_to_lab(again));
assert!(de < 1.5, "{name} {inks:?}: {srgb:?} -> {back:?} -> {again:?} (ΔE {de})");
}
// The perceptual table keeps black-point compensation: source black separates to inks
// that print the press's black point, as the CMS separates it with compensation.
let compensated = Cms::new(&ColorSettings { cmyk: name.into(), bpc: true, ..Default::default() }).unwrap();
let want = compensated.srgb_to_cmyk([0.0; 3], Intent::RelativeColorimetric);
let got = p.from_srgb([0.0; 3], Intent::Perceptual).unwrap();
let printed = |inks: &[f32]| cms.cmyk_to_lab([inks[0], inks[1], inks[2], inks[3]]);
let de = delta_e2000(printed(&want), printed(&got));
assert!(de < 1.5, "{name}: perceptual black {got:?} prints {:?}, want {want:?} ({:?})", printed(&got), printed(&want));
}
}
#[test]
fn cmyk_profiles_separate_saturated_inks_back_without_clipping_to_srgb() {
// CMYK → PCS → CMYK through the profile's own colorimetric tables, by way of linear ProPhoto
// RGB, which holds every color these profiles print, so no display gamut clips the inks.
// Inks that print outside sRGB come back to inks that print the same color.
for name in BUILTIN_CMYK {
let p = IccProfile::from_bytes(None, &icc_bytes(name).unwrap()).unwrap();
let cms = Cms::new(&ColorSettings { cmyk: name.into(), bpc: false, ..Default::default() }).unwrap();
for inks in
[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 0.0]]
{
let back = p.to_same_model_of(&p, &inks, Intent::RelativeColorimetric, false).unwrap();
let de = delta_e2000(cms.cmyk_to_lab(inks), cms.cmyk_to_lab([back[0], back[1], back[2], back[3]]));
// Within the ΔE of 3 that the gamut tag counts as reproduced.
assert!(de <= 3.0, "{name} {inks:?} -> {back:?} (ΔE {de})");
}
}
}
#[test]
fn cmyk_profiles_carry_their_paper_as_the_media_white() {
let generic = generic::swop_like();
let p = parse(&icc_bytes(GENERIC_CMYK).unwrap());
let white = p.media_white_point.unwrap();
let paper = lab::lab_to_xyz(generic.paper);
for (got, want) in [white.x, white.y, white.z].iter().zip(paper) {
assert!((*got - f64::from(want)).abs() < 2e-3, "{white:?} vs {paper:?}");
}
}
@@ -116,9 +167,10 @@ fn black_point_compensation_maps_the_darkest_ink_to_rgb_black() {
let rich = [0.75, 0.68, 0.67, 0.9];
let (on, off) = (icc_cmyk(true).cmyk_to_rgb(rich, Intent::RelativeColorimetric), icc_cmyk(false).cmyk_to_rgb(rich, Intent::RelativeColorimetric));
// Without compensation the profile's black is a dark grey; with it, rich black goes most of
// the way to RGB black (not all: it isn't quite the darkest ink the profile prints).
// the way to RGB black (not all: it isn't quite the darkest ink the profile prints, and the
// profile's Lab → CMYK table carries no compensation of its own).
assert!(off.iter().all(|v| *v > 0.1), "without: {off:?}");
assert!(on.iter().zip(off).all(|(a, b)| *a < 0.08 && *a < b * 0.5), "with: {on:?}, without: {off:?}");
assert!(on.iter().zip(off).all(|(a, b)| *a < 0.09 && *a < b * 0.55), "with: {on:?}, without: {off:?}");
// The screen shows what an sRGB conversion writes, compensated alike.
let srgb = |bpc| {
let c = icc_cmyk(bpc);
+5
View File
@@ -143,6 +143,11 @@ impl Appearance {
pub fn fill_paint(&self) -> Paint {
self.fill().map(|f| f.paint.clone()).unwrap_or(Paint::None)
}
/// Whether any visible fill has non-None paint. Unlike [`Self::fill`], this
/// includes lower fills in the stack; zero opacity still counts for selecting its geometry.
pub fn has_visible_fill(&self) -> bool {
self.items.iter().any(|item| matches!(item, AppearanceItem::Fill(fill) if fill.visible && !fill.paint.is_none()))
}
pub fn stroke_paint(&self) -> Paint {
self.stroke().map(|s| s.paint.clone()).unwrap_or(Paint::None)
}
+156 -79
View File
@@ -82,8 +82,9 @@ impl Default for HitOptions {
}
}
/// The shapes that an image's own fills and strokes paint, each with its fill rule and the fill or
/// stroke that paints it (none for fills and strokes that paint nothing). Effects are evaluated
/// The shapes that an image's own fills and strokes paint, or the fills and strokes of the art of a
/// symbol instance whose own fill or stroke has a geometry effect, each with its fill rule and the
/// fill or stroke that paints it (none for fills and strokes that paint nothing). Effects are evaluated
/// above this crate, so the engine registers one with [`set_image_paint`]. It looks up swatches and
/// patterns in the document it is given.
pub type ImagePaint = fn(Option<&Document>, &Node) -> Vec<(BezPath, FillRule, AppearanceItem)>;
@@ -97,10 +98,58 @@ pub fn set_image_paint(f: ImagePaint) {
let _ = IMAGE_PAINT.set(f);
}
/// The shapes that the image `n`'s own fills and strokes paint ([`set_image_paint`]), none while
/// nothing is registered.
pub(crate) fn image_paint(doc: Option<&Document>, n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
IMAGE_PAINT.get().map_or_else(Vec::new, |f| f(doc, n))
/// The shapes that [`ImagePaint`] gives for one object.
type Painted = Vec<(BezPath, FillRule, AppearanceItem)>;
/// The shapes that the image or symbol instance `n` paints with its geometry effects
/// ([`set_image_paint`]), none while nothing is registered. The shapes of a symbol instance of
/// `doc` with an effect on a fill or stroke are kept on this thread ([`PAINT_KEPT`]) and measured
/// again when `n`, a symbol of `doc` or its 9-slice guides or natural size, a pattern of `doc`,
/// its swatches or color groups, or the
/// [`LiveInputs`] have changed since, and on every call while `n` or the document's symbols or
/// patterns hold a placed document or the symbols hold an image ([`symbols_hold_images`]).
pub(crate) fn image_paint(doc: Option<&Document>, n: &Node) -> Rc<Painted> {
let Some(f) = IMAGE_PAINT.get() else { return Rc::default() };
let row_effects = || n.appearance.items.iter().any(|i| !i.effects().is_empty());
let Some(d) = doc.filter(|_| matches!(n.kind, NodeKind::SymbolInstance { .. }) && row_effects()) else {
return Rc::new(f(doc, n));
};
let inputs = live_inputs();
if let Some(painted) = kept(&PAINTED, d, n, inputs) {
return painted;
}
#[cfg(test)]
PAINT_EVALUATED.with(|c| c.set(c.get() + 1));
let painted = Rc::new(f(doc, n));
if !symbols_hold_images(d) {
let size = painted.iter().fold(0usize, |s, (bp, _, _)| s.saturating_add(1 + bp.elements().len()));
keep(&PAINTED, d, n, inputs, &painted, size, PAINT_KEPT);
}
painted
}
/// Does the art of a symbol of `doc` hold an image? The shapes its fills and strokes paint can
/// follow its pixels, which change when its file is read again, so [`image_paint`] does not keep
/// the shapes of an instance then.
fn symbols_hold_images(doc: &Document) -> bool {
let mut image = false;
doc.symbols.iter().for_each(|s| s.art.walk(&mut |c| image |= matches!(c.kind, NodeKind::Image(_))));
image
}
/// How many symbol instances' shapes [`image_paint`] keeps on each thread: every click and every
/// hover measures each instance whose fill or stroke has a geometry effect.
const PAINT_KEPT: usize = 64;
thread_local! {
/// The shapes [`image_paint`] keeps, the latest first.
static PAINTED: RefCell<Vec<Evaluated<Painted>>> = const { RefCell::new(Vec::new()) };
}
#[cfg(test)]
thread_local! {
/// How many symbol instances [`image_paint`] measured on this thread.
static PAINT_EVALUATED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// One level of evaluation of a live object in a document, as the canvas draws it: type in an
@@ -127,21 +176,72 @@ fn live_inputs() -> u64 {
LIVE_ART.get().map_or(0, |(_, inputs)| inputs())
}
/// A live object evaluated by [`live_art`] on this thread: the object, its document's symbols (by
/// name and art), patterns, swatches and color groups and the [`LiveInputs`] as they were, the art
/// and its [`art_size`].
struct EvaluatedLive {
/// An object evaluated by [`live_art`] or [`image_paint`] on this thread: the object, its
/// document's symbols (by name and art), patterns, swatches and color groups, the document data
/// that symbols' 9-slice guides and natural sizes are kept in, and the [`LiveInputs`] as they
/// were, the result and its size.
struct Evaluated<T> {
node: Node,
symbols: Vec<(String, Arc<Node>)>,
patterns: Vec<crate::PatternDef>,
swatches: crate::Shared<Vec<vectorcraft_color::Swatch>>,
swatch_groups: crate::Shared<Vec<vectorcraft_color::SwatchGroup>>,
unknown: crate::Shared<serde_json::Map<String, serde_json::Value>>,
inputs: u64,
art: Rc<Vec<Node>>,
art: Rc<T>,
size: usize,
}
impl EvaluatedLive {
/// The evaluations kept on this thread in one store, the latest first.
type Store<T> = std::thread::LocalKey<RefCell<Vec<Evaluated<T>>>>;
/// The evaluation of `n` in `doc` with inputs `inputs` that `store` keeps, moved to the front.
fn kept<T>(store: &'static Store<T>, doc: &Document, n: &Node, inputs: u64) -> Option<Rc<T>> {
store.with_borrow_mut(|kept| {
let i = kept.iter().position(|e| e.is_of(doc, n, inputs))?;
let e = kept.remove(i);
let art = e.art.clone();
kept.insert(0, e);
Some(art)
})
}
/// Keep `art`, of size `size`, the evaluation of `n` in `doc` with inputs `inputs`, at the front
/// of `store`, which keeps `most` evaluations whose sizes add up to [`LIVE_KEPT_SIZE`] at most.
/// Nothing is kept when `art` alone is larger, or when `n` or the document's symbols or patterns
/// hold a placed document ([`holds_placed`]).
fn keep<T>(store: &'static Store<T>, doc: &Document, n: &Node, inputs: u64, art: &Rc<T>, size: usize, most: usize) {
if size > LIVE_KEPT_SIZE || holds_placed(doc, n) {
return;
}
let e = Evaluated::new(doc, n, inputs, art, size);
store.with_borrow_mut(|kept| {
kept.insert(0, e);
kept.truncate(most);
let mut total = 0usize;
kept.retain(|e| {
total = total.saturating_add(e.size);
total <= LIVE_KEPT_SIZE
});
});
}
impl<T> Evaluated<T> {
/// `art`, of size `size`, the evaluation of `n` in `doc` with inputs `inputs`, as they are now.
fn new(doc: &Document, n: &Node, inputs: u64, art: &Rc<T>, size: usize) -> Self {
Self {
node: n.clone(),
symbols: doc.symbols.iter().map(|s| (s.name.clone(), s.art.clone())).collect(),
patterns: doc.patterns.clone(),
swatches: doc.swatches.clone(),
swatch_groups: doc.swatch_groups.clone(),
unknown: doc.unknown.clone(),
inputs,
art: art.clone(),
size,
}
}
/// Is this the evaluation of `n` in `doc`, with inputs `inputs`, as they are now?
fn is_of(&self, doc: &Document, n: &Node, inputs: u64) -> bool {
self.inputs == inputs
@@ -151,6 +251,7 @@ impl EvaluatedLive {
&& self.patterns == doc.patterns
&& self.swatches == doc.swatches
&& self.swatch_groups == doc.swatch_groups
&& self.unknown == doc.unknown
}
}
@@ -158,8 +259,9 @@ impl EvaluatedLive {
/// envelope's stroke band hits it again and again, and an envelope can hold a blend.
const LIVE_KEPT: usize = 4;
/// Most [`art_size`] the evaluations [`live_art`] keeps on one thread add up to. Art larger than
/// this is not kept.
/// Most size the evaluations [`live_art`] keeps on one thread add up to ([`art_size`]), and the
/// shapes [`image_paint`] keeps (each shape and its path elements). Art larger than this is not
/// kept.
const LIVE_KEPT_SIZE: usize = 250_000;
/// The size of `art` for [`LIVE_KEPT_SIZE`]: its objects and the anchors of their paths.
@@ -184,52 +286,23 @@ fn holds_placed(doc: &Document, n: &Node) -> bool {
thread_local! {
/// The evaluations [`live_art`] keeps, the latest first.
static EVALUATED: RefCell<Vec<EvaluatedLive>> = const { RefCell::new(Vec::new()) };
static EVALUATED: RefCell<Vec<Evaluated<Vec<Node>>>> = const { RefCell::new(Vec::new()) };
}
/// The art live object `n` of `doc` draws ([`set_live_art`]); [`crate::live::expand_live`] while
/// nothing is registered. The art is evaluated again when `n`, a symbol of `doc`, a pattern of
/// `doc`, its swatches or color groups, or the [`LiveInputs`] have changed since, and on every
/// nothing is registered. The art is evaluated again when `n`, a symbol of `doc` or its 9-slice
/// guides or natural size, a pattern of `doc`, its swatches or color groups, or the
/// [`LiveInputs`] have changed since, and on every
/// click while it or the document's symbols or patterns hold a placed document ([`holds_placed`]).
fn live_art(doc: &Document, n: &Node) -> Rc<Vec<Node>> {
let inputs = live_inputs();
let kept = EVALUATED.with_borrow_mut(|kept| {
let i = kept.iter().position(|e| e.is_of(doc, n, inputs))?;
let e = kept.remove(i);
let art = e.art.clone();
kept.insert(0, e);
Some(art)
});
if let Some(art) = kept {
if let Some(art) = kept(&EVALUATED, doc, n, inputs) {
return art;
}
#[cfg(test)]
LIVE_EVALUATED.with(|c| c.set(c.get() + 1));
let art = Rc::new(LIVE_ART.get().map_or_else(|| crate::live::expand_live(n), |(f, _)| f(Some(doc), n)));
let size = art_size(&art);
if size > LIVE_KEPT_SIZE || holds_placed(doc, n) {
return art;
}
let symbols = doc.symbols.iter().map(|s| (s.name.clone(), s.art.clone())).collect();
let e = EvaluatedLive {
node: n.clone(),
symbols,
patterns: doc.patterns.clone(),
swatches: doc.swatches.clone(),
swatch_groups: doc.swatch_groups.clone(),
inputs,
art: art.clone(),
size,
};
EVALUATED.with_borrow_mut(|kept| {
kept.insert(0, e);
kept.truncate(LIVE_KEPT);
let mut total = 0usize;
kept.retain(|e| {
total = total.saturating_add(e.size);
total <= LIVE_KEPT_SIZE
});
});
keep(&EVALUATED, doc, n, inputs, &art, art_size(&art), LIVE_KEPT);
art
}
@@ -257,7 +330,7 @@ pub fn set_drawn_art(f: DrawnArt) {
/// The art of an object found by [`drawn`] (none, or one object), with what it was found from, and
/// the box round everything that art can paint.
struct EvaluatedDrawn {
of: EvaluatedLive,
of: Evaluated<Vec<Node>>,
reach: Option<Rect>,
}
@@ -310,7 +383,8 @@ fn plain<T>(mask: bool, f: impl FnOnce() -> T) -> T {
/// nothing is registered, while a [`DrawnOff`] guard lives, for objects whose art is not evaluated
/// ([`evaluates`]), and when nothing in `n`, nor the art of a symbol an instance in it shows, has a
/// visible effect ([`draws_effects`]). The art is evaluated again when `n`, a symbol of the
/// document, its patterns, swatches or color groups, or the [`LiveInputs`] have changed since, and
/// document or its 9-slice guides or natural size, its patterns, swatches or color groups, or the
/// [`LiveInputs`] have changed since, and
/// on every call while it holds a placed document ([`holds_placed`]). When the art kept is full, new
/// art replaces as much other art as it needs room for, and art larger than [`LIVE_KEPT_SIZE`] is
/// kept alone.
@@ -332,16 +406,7 @@ fn drawn(symbols: &SymbolBoxes, n: &Node) -> Option<(Rc<Vec<Node>>, Option<Rect>
let art = Rc::new(art.into_iter().collect::<Vec<_>>());
let size = art_size(&art).saturating_add(art_size(std::slice::from_ref(n)));
if !holds_placed(doc, n) {
let of = EvaluatedLive {
node: n.clone(),
symbols: doc.symbols.iter().map(|s| (s.name.clone(), s.art.clone())).collect(),
patterns: doc.patterns.clone(),
swatches: doc.swatches.clone(),
swatch_groups: doc.swatch_groups.clone(),
inputs,
art: art.clone(),
size,
};
let of = Evaluated::new(doc, n, inputs, &art, size);
DRAWN.with_borrow_mut(|(kept, total)| {
if let Some(old) = kept.remove(&n.id) {
*total = total.saturating_sub(old.of.size);
@@ -607,9 +672,11 @@ fn objects_at_repeated(doc: &Document, p: Point, opt: HitOptions, scope: Option<
/// [`objects_at_repeated`] after `tops`, the topmost objects under `p` already found.
fn objects_at_repeated_after(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>, mut tops: Vec<NodeId>) -> Vec<NodeId> {
// Each round leaves out the objects found so far (and everything inside them).
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id), true).map(|h| h.top_object(scope)) {
if tops.contains(&top) {
// Each round leaves out the objects found so far (and everything inside them). `found` holds
// the same ids as `tops`, which keeps their order.
let mut found: HashSet<NodeId> = tops.iter().copied().collect();
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| found.contains(&id), true).map(|h| h.top_object(scope)) {
if !found.insert(top) {
break;
}
tops.push(top);
@@ -1290,8 +1357,9 @@ fn hit_stroke(n: &Node, bp: &vectorcraft_geom::BezPath, rule: vectorcraft_geom::
stroke_contains(bp, 0.0, opt.tol, p).then_some(HitKind::Outline)
}
/// Check the body without assembling a `BezPath`. A miss near a joint or cap may still hit a
/// miter or square cap, so the caller falls back to the full stroke check there.
/// Check the body without assembling a `BezPath`. Near an end or joint, the caller uses the
/// full stroke check for non-round caps or joins: Butt and Bevel can reject a radial body hit,
/// while Miter and Square can extend beyond it.
fn near_path_body(path: &PathData, p: Point, radius: f64, decoration_reach: f64) -> Option<(bool, bool)> {
if !radius.is_finite() || radius < 0.0 || !decoration_reach.is_finite() || decoration_reach < 0.0 {
return None;
@@ -1349,6 +1417,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
}
match &n.kind {
NodeKind::Path { path, rule, .. } => {
let has_fill = n.appearance.has_visible_fill();
if opt.outline
&& let Some((hit, needs_full_check)) = near_path_body(path, p, opt.tol, 0.0)
{
@@ -1361,7 +1430,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
}
let mut strokes = n.appearance.painted_strokes();
if !opt.outline
&& n.appearance.fill().is_none_or(|f| f.paint.is_none())
&& !has_fill
&& let Some(s) = strokes.next()
&& strokes.next().is_none()
&& s.align == StrokeAlign::Center
@@ -1376,10 +1445,10 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
path,
p,
s.width / 2.0 + opt.tol,
if s.join == crate::LineJoin::Miter || s.cap == crate::LineCap::Square { s.reach() + opt.tol } else { 0.0 },
if s.join != crate::LineJoin::Round || s.cap != crate::LineCap::Round { s.reach() + opt.tol } else { 0.0 },
)
{
if hit {
if hit && !near_decoration {
return Some(HitKind::Stroke);
}
if !near_decoration {
@@ -1390,8 +1459,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
if let Some(k) = hit_stroke(n, &bp, *rule, p, opt) {
return Some(k);
}
let filled = !n.appearance.fill_paint().is_none();
if !opt.outline && !opt.path_only && filled && fill_contains(&bp, *rule, p) {
if !opt.outline && !opt.path_only && has_fill && fill_contains(&bp, *rule, p) {
return Some(HitKind::Fill);
}
None
@@ -1412,7 +1480,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
if vectorcraft_geom::hit::distance_to_outline(&near, p) <= opt.tol {
return Some(HitKind::Outline);
}
(!opt.outline && !opt.path_only && fill_contains(&near, *rule, p)).then_some(HitKind::Fill)
(!opt.outline && !opt.path_only && n.appearance.has_visible_fill() && fill_contains(&near, *rule, p)).then_some(HitKind::Fill)
}
// The type path lies within the bounds: they rule out the rest before it is measured.
NodeKind::Text(t) if opt.type_path_only => {
@@ -1436,22 +1504,21 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
if opt.outline {
return None;
}
image_paint(Some(symbols.document()), n).iter().rev().find_map(|(bp, rule, item)| match item {
AppearanceItem::Stroke(s) => s.hits(bp, *rule, p, opt.tol).then_some(HitKind::Stroke),
AppearanceItem::Fill(_) => (!opt.path_only && fill_contains(bp, *rule, p)).then_some(HitKind::Fill),
})
hit_painted(n, p, opt, symbols)
}
NodeKind::Text(_) | NodeKind::PlacedDocument(_) => {
n.geometric_bounds_with(symbols).filter(|b| b.inflate(opt.tol, opt.tol).contains(p)).map(|_| HitKind::Bounds)
}
// A symbol instance is hit within its bounds, and outside them where its art paints
// ([`instance_art_hit`]). In the art of another instance walked outside that instance's
// bounds, it is hit only where its own art paints ([`ArtOnly`]).
// ([`instance_art_hit`]) or where the geometry effects of its active fill or stroke reshape
// the art it draws ([`image_paint`]) except in outline mode. In the art of another instance
// walked outside that instance's bounds, it is hit only where its own art paints
// ([`ArtOnly`]).
NodeKind::SymbolInstance { .. } => {
if !ArtOnly::on() && n.geometric_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
return Some(HitKind::Bounds);
}
instance_art_hit(n, p, opt, symbols)
instance_art_hit(n, p, opt, symbols).or_else(|| if opt.outline { None } else { hit_painted(n, p, opt, symbols) })
}
// A blend or an envelope is hit within its bounds, and outside them where its evaluated
// art paints: a blend's keys and steps on a spine can reach past the keys and the spine,
@@ -1478,6 +1545,16 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
}
}
/// What a click at `p` hits among the shapes that the fills and strokes of `n` (an image or a
/// symbol instance) paint with their geometry effects ([`image_paint`]), the frontmost first: a
/// stroke along its shape, a fill inside it except with Selection by Path Only.
fn hit_painted(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Option<HitKind> {
image_paint(Some(symbols.document()), n).iter().rev().find_map(|(bp, rule, item)| match item {
AppearanceItem::Stroke(s) => s.hits(bp, *rule, p, opt.tol).then_some(HitKind::Stroke),
AppearanceItem::Fill(_) => (!opt.path_only && fill_contains(bp, *rule, p)).then_some(HitKind::Fill),
})
}
/// Is `p` within `tol` of the type path of `t` (in `n`), what "Type Object Selection by Path
/// Only" picks type by: its baselines ([`crate::TextObject::baselines`]), area type's frame and
/// type on a path's path, drawn through `n`'s perspective projection if it has one.
+279 -2
View File
@@ -1262,6 +1262,60 @@ fn evaluated_art_is_not_kept_while_a_placed_document_may_show_in_it() {
assert_eq!(evaluated(), before + 2);
}
/// For instances of the symbol "Painted", a fill that paints the square from (300, 0) to
/// (320, 20); nothing for anything else.
fn painted_far_away(_: Option<&Document>, n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
match &n.kind {
NodeKind::SymbolInstance { symbol, .. } if symbol == "Painted" => {
let square = shapes::rectangle(Rect::new(300.0, 0.0, 320.0, 20.0)).to_bezpath();
vec![(square, FillRule::NonZero, AppearanceItem::Fill(crate::FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)))))]
}
_ => vec![],
}
}
/// Clicks and hovers measure the shapes a symbol instance's fill and stroke effects paint once,
/// and again only after the instance or the symbols change.
#[test]
fn clicks_measure_a_symbol_instances_painted_shapes_once_until_it_changes() {
set_image_paint(painted_far_away);
let mut d = Document::new(1000.0, 1000.0);
let l = d.layers[0].id;
let art = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 20.0, 20.0)), Appearance::default_art());
d.symbols.push(crate::Symbol { dynamic: false, name: "Painted".into(), art: Arc::new(art) });
let inst = d.alloc_id();
let mut n = Node::new(inst, NodeKind::SymbolInstance { symbol: "Painted".into(), xf: vectorcraft_geom::Affine::IDENTITY });
n.appearance = Appearance::default_art().into();
let offset = crate::Effect { id: "path.offsetPath".into(), params: serde_json::json!({"offset": 10}), visible: true };
n.appearance.items[0].effects_mut().push(offset);
d.insert(Some(l), 0, n).unwrap();
let measured = || PAINT_EVALUATED.with(std::cell::Cell::get);
let before = measured();
let at = |d: &Document, x: f64| hit_test(d, Point::new(x, 10.0), HitOptions::default()).map(|h| h.leaf);
assert_eq!(at(&d, 310.0), Some(inst), "a click where the instance's fill paints");
assert_eq!(at(&d, 500.0), None);
assert_eq!(at(&d, 10.0), Some(inst));
assert_eq!(measured(), before + 1);
d.node_mut(inst).unwrap().appearance.items[0].effects_mut()[0].params = serde_json::json!({"offset": 12});
assert_eq!(at(&d, 310.0), Some(inst));
assert_eq!(measured(), before + 2, "a changed instance is measured again");
let other = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 5.0, 5.0)), Appearance::default_art());
d.symbols.push(crate::Symbol { dynamic: false, name: "Other".into(), art: Arc::new(other) });
assert_eq!(at(&d, 310.0), Some(inst));
assert_eq!(measured(), before + 3, "changed symbols measure it again");
assert_eq!(at(&d, 310.0), Some(inst));
assert_eq!(measured(), before + 3);
// An image's pixels change when its file is read again, so with one in a symbol's art every
// click measures the instance.
let xf = vectorcraft_geom::Affine::IDENTITY;
let im = crate::ImageObject { key: "k".into(), width: 10, height: 10, xf, link: None, placement: Default::default(), pixels: None };
let image = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)));
d.symbols.push(crate::Symbol { dynamic: false, name: "Photo".into(), art: Arc::new(image) });
assert_eq!(at(&d, 310.0), Some(inst));
assert_eq!(at(&d, 310.0), Some(inst));
assert!(measured() >= before + 5, "each click measures it: {}", measured() - before);
}
/// A kept evaluation is the evaluation of the object only while the fonts and plug-ins
/// ([`LiveInputs`]) are as they were.
#[test]
@@ -1274,19 +1328,32 @@ fn a_kept_evaluation_is_stale_after_the_live_inputs_change() {
}
/// An evaluation of `n` in `d`, with inputs 7, holding no symbols, patterns or art.
fn kept_evaluation(d: &Document, n: &Node) -> EvaluatedLive {
EvaluatedLive {
fn kept_evaluation(d: &Document, n: &Node) -> Evaluated<Vec<Node>> {
Evaluated {
node: n.clone(),
symbols: vec![],
patterns: vec![],
swatches: d.swatches.clone(),
swatch_groups: d.swatch_groups.clone(),
unknown: d.unknown.clone(),
inputs: 7,
art: std::rc::Rc::new(vec![]),
size: 0,
}
}
/// A kept evaluation is stale once a symbol's 9-slice guides or natural size change: they place
/// the symbol's art, and the document keeps them apart from the symbols.
#[test]
fn a_kept_evaluation_is_stale_after_a_symbols_placement_changes() {
let mut d = Document::new(100.0, 100.0);
let n = Node::path(NodeId(3), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default_art());
let e = kept_evaluation(&d, &n);
assert!(e.is_of(&d, &n, 7));
d.unknown.insert(crate::SYMBOL_SIZES.into(), serde_json::json!({"Logo": [40.0, 20.0]}));
assert!(!e.is_of(&d, &n, 7));
}
/// A kept evaluation is stale once a swatch changes, in a color group too: a painted live effect's
/// pieces name swatches.
#[test]
@@ -1823,6 +1890,216 @@ fn objects_at_matches_repeated_hits_on_random_documents() {
}
}
/// [`objects_at_repeated_after`] with each found object looked up in the ordered list itself: the
/// reference the tests below hold the set lookup to, and the base that `select_behind_isolation_timing` times.
fn objects_at_repeated_after_by_list(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>, mut tops: Vec<NodeId>) -> Vec<NodeId> {
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id), true).map(|h| h.top_object(scope)) {
if tops.contains(&top) {
break;
}
tops.push(top);
}
tops
}
/// A layer holding a group of `count` overlapping 50 × 50 squares, member `i` at x = 5 × (`i` mod
/// 10), with a square at x = 0 below the group and above it, and one at x = 100 above it: the
/// document, the group and its members, topmost first.
fn isolated_stack(count: u32) -> (Document, NodeId, Vec<NodeId>) {
let mut d = Document::new(200.0, 200.0);
let l = d.layers[0].id;
let square = |d: &mut Document, x: f64| Node::path(d.alloc_id(), shapes::rectangle(Rect::new(x, 0.0, x + 50.0, 50.0)), Appearance::default_art());
let below = square(&mut d, 0.0);
d.insert(Some(l), usize::MAX, below).unwrap();
let members: Vec<Node> = (0..count).map(|i| square(&mut d, f64::from(i % 10) * 5.0)).collect();
let mut ids: Vec<NodeId> = members.iter().map(|n| n.id).collect();
let g = d.alloc_id();
d.insert(Some(l), usize::MAX, Node::group(g, members.into_iter().map(Arc::new).collect())).unwrap();
for x in [0.0, 100.0] {
let above = square(&mut d, x);
d.insert(Some(l), usize::MAX, above).unwrap();
}
ids.reverse();
(d, g, ids)
}
/// Select Behind in an isolated group of 40 overlapping squares, with art around the group above
/// and below them: each member once, front to back, over 41 rounds of hit tests, and nothing where
/// only the art around the group lies.
#[test]
fn select_behind_in_isolation_lists_a_large_stack_once() {
let (d, g, ids) = isolated_stack(40);
let at = |x: f64, scope| objects_at(&d, Point::new(x, 25.0), HitOptions::default(), scope);
assert_eq!(at(47.5, Some(g)), ids);
assert_eq!(at(47.5, Some(g)).iter().collect::<HashSet<_>>().len(), 40, "no object twice");
assert_eq!(at(47.5, None).len(), 3, "not isolated: the square above, the group and the square below");
// At x = 17.5 only the members at x = 0 to 20 are hit (the one at 20 on its stroke, within
// the tolerance): `ids[k]` is member 39 - k.
let left: Vec<NodeId> = ids.iter().enumerate().filter(|(k, _)| (39 - k) % 10 <= 4).map(|(_, id)| *id).collect();
assert_eq!(left.len(), 20);
assert_eq!(at(17.5, Some(g)), left);
assert!(at(125.0, Some(g)).is_empty(), "only the square around the group");
assert_eq!(at(125.0, None).len(), 1);
let isolated = HitOptions { scope: Some(g), ..HitOptions::default() };
let p = Point::new(47.5, 25.0);
assert_eq!(objects_at_repeated_after(&d, p, isolated, Some(g), ids[..15].to_vec()), ids, "the objects passed in stay first");
let (d, g, clip, art) = masked_square(false);
let isolated = HitOptions { scope: Some(g), ..SELECTING };
for p in [Point::new(140.0, 90.0), Point::new(170.0, 90.0), Point::new(100.0, 90.0)] {
let want = objects_at_repeated_after_by_list(&d, p, isolated, Some(g), vec![]);
assert_eq!(objects_at(&d, p, SELECTING, Some(g)), want, "clip group isolated, {p:?}");
}
assert_eq!(objects_at(&d, Point::new(170.0, 90.0), SELECTING, Some(g)), vec![art], "the art its mask hides");
assert!(objects_at(&d, Point::new(140.0, 90.0), SELECTING, Some(g)).contains(&clip), "the mask on its outline");
}
/// Documents built at random (nested groups, clipping groups, envelopes in Edit Contents, hidden
/// and locked objects), each object in turn isolated, and each list started with some of the
/// objects already found: the set lookup returns what the ordered-list lookup returns, field for
/// field.
#[test]
fn select_behind_in_isolation_matches_the_list_lookup_on_random_documents() {
let mut seed = 0x2545_f491_u32;
let mut next = move |n: u32| {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
seed % n
};
fn fill(d: &mut Document, parent: NodeId, depth: u32, next: &mut impl FnMut(u32) -> u32) {
for _ in 0..2 + next(5) {
let id = d.alloc_id();
let rect = |next: &mut dyn FnMut(u32) -> u32| {
let (x, y) = (f64::from(next(60)), f64::from(next(60)));
Rect::new(x, y, x + 10.0 + f64::from(next(50)), y + 10.0 + f64::from(next(50)))
};
let mut n = match next(if depth < 3 { 9 } else { 4 }) {
4 | 5 => Node::group(id, Vec::new()),
6 => {
let mut g = Node::group(id, Vec::new());
g.set_clips(true);
g
}
7 => {
let content =
(0..2).map(|_| Arc::new(Node::path(d.alloc_id(), shapes::rectangle(rect(next)), Appearance::default_art()))).collect();
Node::new(
id,
NodeKind::Envelope {
content,
kind: Box::new(crate::live::EnvelopeKind::Warp {
style: "arc".to_string(),
bend: 0.0,
h: 0.0,
v: 0.0,
horizontal: true,
version: 0,
}),
fidelity: 100.0,
editing: next(2) == 0,
options: Default::default(),
frame: Box::new(vectorcraft_geom::Affine::IDENTITY),
},
)
}
_ => Node::path(id, shapes::rectangle(rect(next)), if next(4) == 0 { Appearance::default() } else { Appearance::default_art() }),
};
n.visible = next(8) != 0;
n.locked = next(8) == 0;
let group = matches!(n.kind, NodeKind::Group { .. });
d.insert(Some(parent), usize::MAX, n).unwrap();
if group {
fill(d, id, depth + 1, next);
}
}
}
let mut compared = 0;
for round in 0..60 {
let mut d = Document::new(120.0, 120.0);
let layer = d.layers[0].id;
fill(&mut d, layer, 0, &mut next);
let mut scopes = vec![None];
d.walk(|n| {
if n.id != layer {
scopes.push(Some(n.id));
}
});
for _ in 0..6 {
let p = Point::new(f64::from(next(120)), f64::from(next(120)));
let opt = HitOptions { outline: next(5) == 0, path_only: next(5) == 0, clip_outlines: next(2) == 0, ..Default::default() };
for &scope in &scopes {
let opt = HitOptions { scope, ..opt };
let want = objects_at_repeated_after_by_list(&d, p, opt, scope, vec![]);
let context = format!("round {round}, {p:?}, {opt:?}");
assert_eq!(objects_at_repeated_after(&d, p, opt, scope, vec![]), want, "{context}");
if scope.is_some() {
assert_eq!(objects_at(&d, p, opt, scope), want, "{context}");
}
for found in 1..want.len() {
let start = want[..found].to_vec();
assert_eq!(objects_at_repeated_after(&d, p, opt, scope, start.clone()), want, "{context}, {found} found");
assert_eq!(objects_at_repeated_after_by_list(&d, p, opt, scope, start), want, "{context}, {found} found");
}
compared += usize::from(!want.is_empty());
}
}
}
assert!(compared > 500, "only {compared} non-empty lists compared");
}
/// Times Select Behind in an isolated group of 200 and of 1,000 overlapping squares, the set lookup
/// against the ordered-list lookup, alternating the two in one process:
/// `cargo test --release -p vectorcraft-doc --lib -- --ignored --nocapture select_behind_isolation_timing`.
#[test]
#[ignore = "a timing, not a check"]
fn select_behind_isolation_timing() {
/// This thread's CPU time in nanoseconds on Linux; the elapsed time since `start` elsewhere.
fn clock(start: std::time::Instant) -> u128 {
let cpu = std::fs::read_to_string("/proc/thread-self/schedstat").ok();
cpu.and_then(|s| s.split_whitespace().next()?.parse().ok()).unwrap_or_else(|| start.elapsed().as_nanos())
}
type Lookup = fn(&Document, Point, HitOptions, Option<NodeId>, Vec<NodeId>) -> Vec<NodeId>;
let start = std::time::Instant::now();
println!("clock: {}", if std::fs::metadata("/proc/thread-self/schedstat").is_ok() { "thread CPU time" } else { "wall clock" });
let p = Point::new(47.5, 25.0);
for count in [200, 1_000] {
let (d, g, ids) = isolated_stack(count);
let opt = HitOptions { scope: Some(g), ..HitOptions::default() };
assert_eq!(objects_at_repeated_after(&d, p, opt, Some(g), vec![]), ids);
assert_eq!(objects_at_repeated_after_by_list(&d, p, opt, Some(g), vec![]), ids);
// The time per call of `f`: batches of calls double until one takes at least 100 ms.
let per_call = |f: Lookup| {
let mut calls = 1u32;
loop {
let t = clock(start);
for _ in 0..calls {
std::hint::black_box(f(&d, std::hint::black_box(p), opt, Some(g), vec![]));
}
let spent = clock(start) - t;
if spent >= 100_000_000 || calls >= 1 << 20 {
return (spent as f64 / f64::from(calls), calls);
}
calls *= 2;
}
};
let (mut old, mut new) = (vec![], vec![]);
for _ in 0..7 {
old.push(per_call(objects_at_repeated_after_by_list));
new.push(per_call(objects_at_repeated_after));
}
old.sort_by(|a, b| a.0.total_cmp(&b.0));
new.sort_by(|a, b| a.0.total_cmp(&b.0));
let (o, n) = (old[3], new[3]);
println!(
"{count} objects: list lookup {:.2} ms per call ({} calls), set lookup {:.2} ms per call ({} calls), median of 7 runs",
o.0 / 1e6,
o.1,
n.0 / 1e6,
n.1
);
}
}
/// Select Behind finds a symbol instance by its symbol's art, as a click does: art from
/// (100, 60) to (140, 80), outside the 20 × 20 square around the origin, drawn where it lies by
/// one instance and 100 pt lower by an instance in a group.
+218 -10
View File
@@ -117,6 +117,29 @@ impl Document {
/// symbol that shows itself inline ([`Self::inline_art_bounds`]) is shown as an empty slot.
/// Returns the ids of the texts in the layers that changed.
pub fn resolve_inline_art_with(&mut self, layout: &mut dyn FnMut(&mut TextObject)) -> Vec<NodeId> {
self.resolve_inline_art_since(None, layout).changed
}
/// [`Self::resolve_inline_art_with`], given `last`: a document an earlier pass left resolved,
/// with the bounds that pass measured ([`InlinePass::measured`]). When this document has the
/// same symbols, graph designs, pattern tiles and foreign data (`unknown`, which holds the
/// symbols' natural sizes and 9-slice guides) as `last`, and each symbol name measured then
/// still measures the same, the type in the layer trees that are the same nodes as `last`'s
/// already has these bounds: only the other layer trees are checked, in the same order, and
/// the document and the ids returned are those of the full pass. Otherwise, or without `last`,
/// the full pass runs.
pub fn resolve_inline_art_since(&mut self, last: Option<(&Document, &InlineMeasured)>, layout: &mut dyn FnMut(&mut TextObject)) -> InlinePass {
if let Some((last, kept)) = last
&& self.same_inline_inputs(last, kept)
{
let measured = Measured(RefCell::new(kept.0.clone()));
let mut changed = vec![];
let layers = resolve_kids(Some(&last.layers), &self.layers, &|n| measured.get(n, || self.inline_art_bounds(n)), layout, &mut changed);
for (i, layer) in layers {
self.layers[i] = layer;
}
return InlinePass { changed, measured: InlineMeasured(measured.0.into_inner()), partial: true };
}
let mut out = vec![];
let mut unused = vec![];
let graph = InlineGraph::of(self);
@@ -147,10 +170,44 @@ impl Document {
}
}
}
out
InlinePass { changed: out, measured: InlineMeasured(measured.0.into_inner()), partial: false }
}
/// Whether the type in this document's layer trees that are the same nodes as `last`'s already
/// has the bounds a full pass would give it (see [`Self::resolve_inline_art_since`]).
fn same_inline_inputs(&self, last: &Document, kept: &InlineMeasured) -> bool {
self.symbols.len() == last.symbols.len()
&& self.symbols.iter().zip(&last.symbols).all(|(a, b)| a.name == b.name && Arc::ptr_eq(&a.art, &b.art))
&& self.graph_designs.len() == last.graph_designs.len()
&& self.graph_designs.iter().zip(&last.graph_designs).all(|(a, b)| a.name == b.name && Arc::ptr_eq(&a.art, &b.art))
&& self.patterns.len() == last.patterns.len()
&& self
.patterns
.iter()
.zip(&last.patterns)
.all(|(a, b)| a.name == b.name && a.art.len() == b.art.len() && a.art.iter().zip(&b.art).all(|(x, y)| Arc::ptr_eq(x, y)))
&& crate::Shared::ptr_eq(&self.unknown, &last.unknown)
&& kept.0.iter().all(|(name, b)| self.inline_art_bounds(name) == *b)
}
}
/// What a pass of [`Document::resolve_inline_art_since`] did.
#[derive(Debug)]
pub struct InlinePass {
/// The ids of the texts in the layers that changed, in the order the full pass finds them.
pub changed: Vec<NodeId>,
/// The bounds the pass gave the inline graphics of each symbol name, for the next pass.
pub measured: InlineMeasured,
/// Whether only the layer trees that differ from the last resolved document's were checked.
pub partial: bool,
}
/// The art bounds a pass of [`Document::resolve_inline_art_since`] gave the inline graphics of each
/// symbol name it was asked for. A pass that checks only some layer trees keeps the names the
/// pass before it measured, so the names of all the type in the document stay listed.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct InlineMeasured(HashMap<String, Option<Rect>>);
/// Whether `t` has inline graphics whose bounds differ from what `bounds` gives their symbols.
fn stale_by(t: &TextObject, bounds: &dyn Fn(&str) -> Option<Rect>) -> bool {
t.runs.iter().filter_map(|r| r.inline.as_ref()).any(|a| a.bounds != bounds(&a.symbol))
@@ -185,6 +242,22 @@ fn resolve_tree(
layout: &mut dyn FnMut(&mut TextObject),
changed: &mut Vec<NodeId>,
) -> bool {
resolve_since(None, n, bounds, layout, changed)
}
/// [`resolve_tree`], given `old`: the node `n` was before an edit, in a document whose type was
/// resolved with the same `bounds`. The opacity mask art and children of `n` that are the same
/// nodes as `old`'s are skipped: their type already has these bounds. Without `old`, every node
/// of the tree is visited.
fn resolve_since(
old: Option<&Node>,
n: &mut Arc<Node>,
bounds: &dyn Fn(&str) -> Option<Rect>,
layout: &mut dyn FnMut(&mut TextObject),
changed: &mut Vec<NodeId>,
) -> bool {
#[cfg(test)]
tests::VISITS.with(|v| v.set(v.get() + 1));
let mut copied = false;
if matches!(&n.kind, NodeKind::Text(t) if stale_by(t, bounds)) {
let node = Arc::make_mut(n);
@@ -196,17 +269,17 @@ fn resolve_tree(
}
copied = true;
}
let old_mask = old.and_then(|o| o.extras().mask.as_deref()).map(|m| &m.art);
let mask = n.extras().mask.as_deref().and_then(|m| {
let mut art = m.art.clone();
resolve_tree(&mut art, bounds, layout, changed).then_some(art)
});
let mut kids = vec![];
for (i, c) in n.children().into_iter().flatten().enumerate() {
let mut c = c.clone();
if resolve_tree(&mut c, bounds, layout, changed) {
kids.push((i, c));
if old_mask.is_some_and(|o| Arc::ptr_eq(o, &m.art)) {
return None;
}
}
let mut art = m.art.clone();
let old_art = old_mask.filter(|o| o.id == art.id).map(|o| &**o);
resolve_since(old_art, &mut art, bounds, layout, changed).then_some(art)
});
let old_kids = old.map(|o| o.children().map_or(&[][..], Vec::as_slice));
let kids = resolve_kids(old_kids, n.children().map_or(&[][..], Vec::as_slice), bounds, layout, changed);
if mask.is_none() && kids.is_empty() {
return copied;
}
@@ -224,6 +297,35 @@ fn resolve_tree(
true
}
/// Resolves the trees `kids` as [`resolve_since`] does, each with the node of `old` (the same list
/// before an edit) that has its id, found at the same position or else by id, and skips those that
/// are the same nodes as theirs. Without `old`, every tree is visited. Returns the position and new
/// node of each tree that changed.
fn resolve_kids(
old: Option<&[Arc<Node>]>,
kids: &[Arc<Node>],
bounds: &dyn Fn(&str) -> Option<Rect>,
layout: &mut dyn FnMut(&mut TextObject),
changed: &mut Vec<NodeId>,
) -> Vec<(usize, Arc<Node>)> {
let mut by_id: Option<HashMap<NodeId, &Arc<Node>>> = None;
let mut out = vec![];
for (i, c) in kids.iter().enumerate() {
let o = old.and_then(|old| match old.get(i) {
Some(b) if b.id == c.id => Some(b),
_ => by_id.get_or_insert_with(|| old.iter().map(|b| (b.id, b)).collect()).get(&c.id).copied(),
});
if o.is_some_and(|o| Arc::ptr_eq(o, c)) {
continue;
}
let mut c = c.clone();
if resolve_since(o.map(|o| &**o), &mut c, bounds, layout, changed) {
out.push((i, c));
}
}
out
}
/// The art bounds of each symbol, measured once in a pass of [`Document::resolve_inline_art_with`].
/// A symbol is first asked for after its own type is resolved (the pass goes in
/// [`InlineGraph::order`]), so its measurement stays current for the rest of the pass.
@@ -436,6 +538,112 @@ impl std::fmt::Debug for InlineCycles {
mod tests {
use super::*;
thread_local! {
/// How many nodes [`resolve_since`] has visited on this thread.
pub(super) static VISITS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// The nodes visited since the last call.
fn visits() -> usize {
VISITS.with(|v| v.replace(0))
}
/// A copy of `d` resolved by the full pass, and the ids that pass returns.
fn fully_resolved(d: &Document) -> (Document, Vec<NodeId>) {
let mut full = d.clone();
let ids = full.resolve_inline_art_with(&mut |_| {});
(full, ids)
}
/// The children of the layer at `i`, for an edit.
fn layer_kids(d: &mut Document, i: usize) -> &mut Vec<Arc<Node>> {
match Arc::make_mut(&mut d.layers[i]).children_mut() {
Some(kids) => kids,
None => panic!("layer {i} is a group"),
}
}
/// 50 groups of 20 squares, symbol `S`, type showing `S` in the first group, and type showing
/// `S` in the opacity mask of the second.
fn many_groups() -> Document {
let mut d = Document::new(500.0, 500.0);
let square = stroked(&mut d, Rect::new(0.0, 0.0, 10.0, 10.0));
symbol(&mut d, "S", vec![square]);
for _ in 0..50 {
let kids = (0..20).map(|_| stroked(&mut d, Rect::new(0.0, 0.0, 5.0, 5.0))).collect();
let group = Node::group(d.alloc_id(), kids);
d.layers.push(Arc::new(group));
}
let t = showing(&mut d, "S");
layer_kids(&mut d, 0).push(t);
let masked = showing(&mut d, "S");
Arc::make_mut(&mut d.layers[1]).extras_mut().mask = Some(Box::new(crate::OpacityMask::new((*masked).clone(), true)));
d
}
#[test]
fn a_pass_after_an_edit_checks_only_the_trees_the_edit_changed() {
let mut d = many_groups();
let first = d.resolve_inline_art_since(None, &mut |_| {});
assert!(!first.partial);
assert_eq!(first.changed.len(), 2);
let last = d.clone();
visits();
let _ = fully_resolved(&d);
let full_visits = visits();
// The edit moves a square in the 31st group, adds type showing S to the 41st, and gives the
// second group's opacity mask new type: its 20 squares stay the same nodes.
let moved = stroked(&mut d, Rect::new(1.0, 1.0, 6.0, 6.0));
layer_kids(&mut d, 30)[5] = moved;
let added = showing(&mut d, "S");
layer_kids(&mut d, 40).push(added.clone());
let mask_type = showing(&mut d, "S");
if let Some(m) = Arc::make_mut(&mut d.layers[1]).extras_if_any().and_then(|e| e.mask.as_deref_mut()) {
m.art = mask_type.clone();
}
let (want, ids) = fully_resolved(&d);
assert_eq!(ids, [mask_type.id, added.id]);
visits();
let pass = d.resolve_inline_art_since(Some((&last, &first.measured)), &mut |_| {});
let partial_visits = visits();
assert!(pass.partial);
assert_eq!(pass.changed, ids);
assert_eq!(d, want);
// The three changed groups, the mask's new type, the moved square and the added type.
assert_eq!(partial_visits, 6);
assert!(full_visits > 1000, "{full_visits}");
assert_eq!(pass.measured, first.measured);
}
#[test]
fn changed_symbols_or_symbol_sizes_take_the_full_pass() {
let mut d = many_groups();
let mut pass = d.resolve_inline_art_since(None, &mut |_| {});
// A natural size for S, its art unchanged.
let last = d.clone();
d.unknown.insert(SYMBOL_SIZES.into(), serde_json::json!({ "S": [40.0, 20.0] }));
let (want, ids) = fully_resolved(&d);
assert_eq!(ids.len(), 2);
pass = d.resolve_inline_art_since(Some((&last, &pass.measured)), &mut |_| {});
assert!(!pass.partial);
assert_eq!((&d, &pass.changed), (&want, &ids));
// New art for S.
let last = d.clone();
let bigger = stroked(&mut d, Rect::new(0.0, 0.0, 30.0, 30.0));
d.symbols[0].art = Arc::new(Node::group(d.alloc_id(), vec![bigger]));
let (want, ids) = fully_resolved(&d);
assert_eq!(ids.len(), 2);
pass = d.resolve_inline_art_since(Some((&last, &pass.measured)), &mut |_| {});
assert!(!pass.partial);
assert_eq!((&d, &pass.changed), (&want, &ids));
// A measurement that no longer holds, with the same symbols and foreign data.
let last = d.clone();
let stale = InlineMeasured(HashMap::from([("S".to_owned(), Some(Rect::new(0.0, 0.0, 1.0, 1.0)))]));
pass = d.resolve_inline_art_since(Some((&last, &stale)), &mut |_| {});
assert!(!pass.partial);
assert!(pass.changed.is_empty());
}
/// The position of each node in `order`.
fn positions(order: &[usize]) -> Vec<usize> {
let mut at = vec![0; order.len()];
+1 -1
View File
@@ -31,7 +31,7 @@ mod symbol_nine_slice;
pub mod symbol_overrides;
mod symbol_pixel_aligned;
mod symbol_registration;
pub use inline::{SYMBOL_HALF, SYMBOL_SIZES};
pub use inline::{InlineMeasured, InlinePass, SYMBOL_HALF, SYMBOL_SIZES};
pub use shared::Shared;
pub use symbol_export_type::{SYMBOL_EXPORT_TYPE, SymbolExportType};
pub use symbol_nine_slice::{
+2 -1
View File
@@ -66,7 +66,8 @@ pub use expand::{
use mesh::grid_eval;
pub use mesh::{Coons, GradientMesh, MeshAppearance, MeshPiece, MeshPoint, MeshQuad, default_fidelity, grid_points, nodes_bounds};
pub use warp::{
WARP_NET, WarpNet, WarpStyle, fit_piece, map_nonlinear, map_nonlinear_within, map_smooth_within, pieces, uses_net, warp_point, warp_version,
WARP_NET, WarpNet, WarpStyle, fit_piece, map_handles_within, map_nonlinear, map_nonlinear_within, map_smooth_within, pieces, uses_net,
warp_point, warp_version,
};
#[cfg(test)]
+63 -1
View File
@@ -508,6 +508,17 @@ pub fn map_smooth_within(path: &PathData, max_piece: f64, max: usize, f: impl Fn
map_pieces_within(path, max_piece, max, &f, |p, h| mapped_handle(&f, p, h))
}
/// [`map_nonlinear_within`] with `handle(point, handle)` supplying each mapped handle position.
pub fn map_handles_within(
path: &PathData,
max_piece: f64,
max: usize,
f: impl Fn(Point) -> Point,
handle: impl Fn(Point, Point) -> Point,
) -> PathData {
map_pieces_within(path, max_piece, max, &f, handle)
}
/// Handle `h` of point `p` mapped through `f`: `f(p)` plus `f`'s derivative at `p` along `h - p`
/// (a central difference), so the image curve leaves `f(p)` the way `f` takes the curve.
fn mapped_handle(f: &impl Fn(Point) -> Point, p: Point, h: Point) -> Point {
@@ -553,7 +564,8 @@ fn map_pieces_within(path: &PathData, max_piece: f64, max: usize, f: &impl Fn(Po
let c = seg_cubic(sp, i);
let k = pieces(poly_len(&c), max_piece, MAX_PIECES);
for j in 0..k {
let sub = c.subsegment((j as f64 / k as f64)..((j + 1) as f64 / k as f64));
// Evaluating an unchanged curve can overflow even when its control points are finite.
let sub = if k == 1 { c } else { c.subsegment((j as f64 / k as f64)..((j + 1) as f64 / k as f64)) };
if let Some(last) = res.last_mut() {
last.h_out = handle(sub.p0, sub.p1);
}
@@ -613,3 +625,53 @@ pub(super) fn resample(poly: &[Point], m: usize) -> Vec<Point> {
}
out
}
#[cfg(test)]
mod handle_tests {
use super::*;
#[test]
fn an_unsplit_curve_keeps_its_finite_control_points() {
let start = Point::new(1e308, 0.0);
let end = Point::new(1.03e308, 0.0);
let path = PathData::new(vec![SubPath::new(
vec![Anchor::with_handles(start, start, Point::new(1.01e308, 1.0)), Anchor::with_handles(end, Point::new(1.02e308, 1.0), end)],
false,
)]);
assert_eq!(map_handles_within(&path, 1.0, 2, |p| p, |_, h| h), path);
}
#[test]
fn rounded_samples_preserve_a_smooth_interior_join() {
let center = Point::new(1e16, 0.0);
let path = PathData::new(vec![SubPath::new(
vec![
Anchor::corner(center + vectorcraft_geom::kurbo::Vec2::new(-18.0, 0.0)),
Anchor::with_handles(
center,
center + vectorcraft_geom::kurbo::Vec2::new(-6.0, 0.0),
center + vectorcraft_geom::kurbo::Vec2::new(6.0, 0.0),
),
Anchor::corner(center + vectorcraft_geom::kurbo::Vec2::new(18.0, 0.0)),
],
false,
)]);
let mapped = map_smooth_within(&path, f64::INFINITY, 3, |p| Point::new(p.x, p.y + (p.x - center.x).powi(2) * 0.1));
let join = &mapped.subpaths[0].anchors[1];
let incoming = join.p - join.h_in;
let outgoing = join.h_out - join.p;
assert!(incoming.cross(outgoing).abs() < 1e-9, "{incoming:?} {outgoing:?}");
assert!(incoming.dot(outgoing) > 0.0);
}
#[test]
fn a_midpoint_rounded_to_an_endpoint_keeps_the_handle_direction() {
for x in [1e16, 1e16 + 2.0, -1e16] {
for offset in [-6.0, -2.0, 2.0, 6.0] {
let p = Point::new(x, 0.0);
let h = Point::new(x + offset, 0.0);
assert_eq!(mapped_handle(&|point| point, p, h), h);
}
}
}
}
+42
View File
@@ -179,6 +179,48 @@ impl LiveShape {
*xf = Affine::rotate_about((now - angle).to_radians(), centre) * *xf;
}
}
/// A line's length in the document, from its first end to its second. None for other shapes.
pub fn line_length(&self) -> Option<f64> {
let LiveShape::Line { a, b } = self else { return None };
Some((*b - *a).hypot())
}
/// A line's angle: the counterclockwise degrees in [0, 360) from the page's horizontal to the
/// direction from its first end to its second (the Rotate field's sense). 0 for a line whose
/// ends meet. None for other shapes.
pub fn line_angle(&self) -> Option<f64> {
let LiveShape::Line { a, b } = self else { return None };
if a == b {
return Some(0.0);
}
// No −0° or 360° from rounding: a line drawn left to right reads 0°.
let a = (-self.angle_deg()).rem_euclid(360.0);
Some(if a > 360.0 - 1e-9 { 0.0 } else { a + 0.0 })
}
/// Make a line `len` long (0 or more), keeping its first end in place and its direction, or
/// pointing it to the right when its ends meet.
pub fn set_line_length(&mut self, len: f64) {
let LiveShape::Line { a, b } = self else { return };
if !len.is_finite() || len < 0.0 {
return;
}
let now = (*b - *a).hypot();
*b = if now > 0.0 { *a + (*b - *a) * (len / now) } else { Point::new(a.x + len, a.y) };
}
/// Turn a line about its midpoint to `angle` (degrees, as [`LiveShape::line_angle`]). A line
/// whose ends meet stays as it is.
pub fn set_line_angle(&mut self, angle: f64) {
let LiveShape::Line { a, b } = self else { return };
let half = (*b - *a).hypot() / 2.0;
if !angle.is_finite() || half <= 0.0 {
return;
}
let mid = a.midpoint(*b);
let t = angle.to_radians();
// The page's y axis points down, so a counterclockwise angle goes up the page.
let (dx, dy) = (half * t.cos(), -half * t.sin());
*a = Point::new(mid.x - dx, mid.y - dy);
*b = Point::new(mid.x + dx, mid.y + dy);
}
/// Make a polygon's sides equal (Make Sides Equal): drop the uneven scale and the shear from
/// `xf`, keeping its centre, angle, reflection and [`LiveShape::polygon_radius`].
pub fn make_sides_equal(&mut self) {
+21 -13
View File
@@ -216,8 +216,10 @@ impl Node {
/// path give it ([`crate::hit::set_clip_region`]). An image's box takes in
/// the shapes its own fills and strokes paint ([`crate::hit::set_image_paint`]). Groups, layers
/// without a clipping mask and Intertwine groups take in their members' boxes, grown by their
/// own strokes. Symbol instances are measured as in [`Node::visual_bounds`]. A blend's box
/// takes in where its spine can put its keys and steps.
/// own strokes. Symbol instances are measured as in [`Node::visual_bounds`], taking in the
/// shapes their art paints with the geometry effects of their own fill or stroke
/// ([`crate::hit::set_image_paint`]). A blend's box takes in where its spine can put its keys
/// and steps.
pub fn reach_bounds(&self) -> Option<Rect> {
self.reach(None)
}
@@ -254,14 +256,8 @@ impl Node {
.map(|b| b.inflate(o, o))
}
NodeKind::Intertwine { children } => children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.reach(symbols))),
// The frame and each shape the image's own fills and strokes paint, a stroke's grown by
// the farthest it can reach from its shape.
NodeKind::Image(_) => {
crate::hit::image_paint(symbols.map(SymbolBoxes::document), self).iter().fold(self.geometric(symbols), |acc, (bp, _, item)| {
let o = if let crate::AppearanceItem::Stroke(s) = item { s.reach() } else { 0.0 };
vectorcraft_geom::union_opt(acc, (!bp.elements().is_empty()).then(|| bp.bounding_box().inflate(o, o)))
})
}
// The frame and each shape the image's own fills and strokes paint.
NodeKind::Image(_) => self.with_own_paint(self.geometric(symbols), symbols),
// Keys and steps placed on a spine, turned to it with Align to Path, can reach past the
// keys and the spine.
NodeKind::Blend { children, spec } => {
@@ -272,13 +268,15 @@ impl Node {
NodeKind::Layer { children, clip: true, .. } | NodeKind::Group { children, clip: true } => {
vectorcraft_geom::union_opt(self.visual(symbols), children.first().and_then(|c| crate::hit::reshaped_clip_box(c)))
}
// The live geometry effects of the clipping paths in the art can draw it past its box.
// The live geometry effects of the clipping paths in the art can draw it past its box,
// and the box takes in each shape the art paints with the geometry effects of the
// instance's own fill or stroke.
NodeKind::SymbolInstance { symbol, xf } => {
let Some((s, art, region)) = symbols.and_then(|s| {
let a = s.art(symbol)?;
Some((s, a, a.reshaped?))
}) else {
return self.visual(symbols);
return self.with_own_paint(self.visual(symbols), symbols);
};
let map = s.document().symbol_slice_map_of(symbol, art.geometric, *xf);
let placed = if moves_only(*xf) && map.is_none() {
@@ -294,12 +292,22 @@ impl Node {
map.map_or_else(|| xf.transform_rect_bbox(all), |m| m.placement_bounds(all)).inflate(grow, grow)
};
let o = self.appearance.outset();
vectorcraft_geom::union_opt(self.visual(symbols), self.projected(Some(placed)).map(|b| b.inflate(o, o)))
self.with_own_paint(vectorcraft_geom::union_opt(self.visual(symbols), self.projected(Some(placed)).map(|b| b.inflate(o, o))), symbols)
}
_ => self.visual(symbols),
}
}
/// `start` grown by each shape the node's own fills and strokes paint
/// ([`crate::hit::set_image_paint`]), a stroke's grown by the farthest it can reach from its
/// shape.
fn with_own_paint(&self, start: Option<Rect>, symbols: Option<&SymbolBoxes>) -> Option<Rect> {
crate::hit::image_paint(symbols.map(SymbolBoxes::document), self).iter().fold(start, |acc, (bp, _, item)| {
let o = if let crate::AppearanceItem::Stroke(s) = item { s.reach() } else { 0.0 };
vectorcraft_geom::union_opt(acc, (!bp.elements().is_empty()).then(|| bp.bounding_box().inflate(o, o)))
})
}
/// Geometric bounds (no stroke), recursively. Clip groups are bounded by their clip path. A
/// symbol instance is measured as its transform applied to the 20 × 20 square around the origin
/// that symbols made in the app keep their art in ([`Node::geometric_bounds_with`] measures
+73 -1
View File
@@ -187,8 +187,9 @@ impl Document {
/// [`Document::map_solid_paints`] limited to the art in the subtrees of `ids` (each paint
/// visited once even when an id is inside another).
pub fn map_solid_paints_in(&mut self, ids: &[NodeId], f: &mut LinkFn) -> usize {
let listed: HashSet<NodeId> = ids.iter().copied().collect();
let roots: Vec<NodeId> =
ids.iter().copied().filter(|id| !self.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| ids.contains(p)))).collect();
ids.iter().copied().filter(|id| !self.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| listed.contains(p)))).collect();
let mut n = 0;
let mut g = relink(f);
for id in roots {
@@ -844,6 +845,77 @@ mod tests {
assert_eq!(colors, [(Color::rgb(1.0, 0.0, 0.0), None)]);
}
/// [`Document::map_solid_paints_in`] with each ancestor searched for in `ids` rather than looked up in a set.
fn map_solid_paints_in_by_search(d: &mut Document, ids: &[NodeId], f: &mut LinkFn) -> usize {
let roots: Vec<NodeId> =
ids.iter().copied().filter(|id| !d.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| ids.contains(p)))).collect();
let mut n = 0;
let mut g = relink(f);
for id in roots {
let Some(node) = d.node(id) else { continue };
if let Some((new, count)) = map_node(node, &mut g)
&& let Some(slot) = d.node_mut(id)
{
*slot = new;
n += count;
}
}
n
}
#[test]
fn mapping_within_ids_matches_a_search_of_the_ids() {
// Two layers: the first holds group `outer` (group `inner` with two rectangles, and a
// rectangle) and a rectangle; the second holds a rectangle. Each rectangle has its own color.
let mut d = Document::new(100.0, 100.0);
let first = d.layers[0].id;
let second = d.alloc_id();
d.insert(None, usize::MAX, Node::layer(second, "Second", crate::LayerColor::Preset(1))).unwrap();
let rect = |d: &mut Document, i: u8| {
let id = d.alloc_id();
let r = shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0));
let color = Color::rgb(f32::from(i) / 8.0, 0.0, 0.0);
(id, Arc::new(Node::path(id, r, Appearance::basic(Paint::solid(color), Paint::solid(color), 1.0))))
};
let (r1, n1) = rect(&mut d, 1);
let (r2, n2) = rect(&mut d, 2);
let (r3, n3) = rect(&mut d, 3);
let (r4, n4) = rect(&mut d, 4);
let (r5, n5) = rect(&mut d, 5);
let (inner, outer) = (d.alloc_id(), d.alloc_id());
let outer_node = Node::group(outer, vec![Arc::new(Node::group(inner, vec![n1, n2])), n3]);
d.insert(Some(first), usize::MAX, outer_node).unwrap();
d.insert(Some(first), usize::MAX, Arc::unwrap_or_clone(n4)).unwrap();
d.insert(Some(second), usize::MAX, Arc::unwrap_or_clone(n5)).unwrap();
let missing = NodeId(u64::MAX);
let all = [first, second, outer, inner, r1, r2, r3, r4, r5, missing];
// Every list of up to three of them: nested ids in both orders, duplicates, a missing id and none.
let mut lists: Vec<Vec<NodeId>> = vec![vec![]];
let mut shorter: Vec<Vec<NodeId>> = vec![vec![]];
for _ in 0..3 {
shorter = shorter.iter().flat_map(|l| all.map(|id| [l.as_slice(), &[id]].concat())).collect();
lists.extend(shorter.iter().cloned());
}
assert_eq!(lists.len(), 1 + 10 + 100 + 1000);
for ids in &lists {
// A callback that changes every paint it visits, so a paint visited twice counts twice.
let run = |map: &dyn Fn(&mut Document, &[NodeId], &mut LinkFn) -> usize| {
let mut d = d.clone();
let mut visits = vec![];
let n = map(&mut d, ids, &mut |c, s, t| {
visits.push((*c, s.clone(), *t));
*s = Some(format!("{}", visits.len()));
*t *= 0.5;
true
});
(n, visits, d.layers)
};
let by_set = run(&|d, ids, f| d.map_solid_paints_in(ids, f));
let by_search = run(&|d, ids, f| map_solid_paints_in_by_search(d, ids, f));
assert_eq!(by_set, by_search, "{ids:?}");
}
}
/// The colors [`node_colors`] visits, in its order, by a [`Node::walk`] that reads the whole subtree.
fn full_walk(n: &Node, f: &mut dyn FnMut(&Color, Option<&str>)) {
n.walk(&mut |m| {
+2
View File
@@ -631,6 +631,8 @@ pub enum FirstBaseline {
XHeight,
/// The first line's leading.
Leading,
/// The top of the first line's ideographic em box touches the frame top.
EmBoxHeight,
/// Exactly `first_baseline_min` below the top.
Fixed,
}
+14
View File
@@ -647,6 +647,20 @@ fn text_flow_is_saved_only_when_by_rows() {
assert!(serde_json::from_value::<AreaOptions>(serde_json::json!({"flow": "diagonal"})).is_err());
}
/// First Baseline Em Box Height saves as `emBoxHeight` with its minimum and reads back; files from
/// before it read their own first baseline as they did, Ascent when they have none.
#[test]
fn em_box_height_first_baseline_is_saved_and_read_back() {
let set = AreaOptions { first_baseline: FirstBaseline::EmBoxHeight, first_baseline_min: 9.0, ..AreaOptions::default() };
let saved = serde_json::to_value(&set).unwrap();
assert_eq!((saved["firstBaseline"].as_str(), saved["firstBaselineMin"].as_f64()), (Some("emBoxHeight"), Some(9.0)));
assert_eq!(serde_json::from_value::<AreaOptions>(saved).unwrap(), set);
let old = serde_json::json!({"firstBaseline": "leading", "firstBaselineMin": 3.0});
assert_eq!(serde_json::from_value::<AreaOptions>(old).unwrap().first_baseline, FirstBaseline::Leading);
assert_eq!(serde_json::from_value::<AreaOptions>(serde_json::json!({})).unwrap().first_baseline, FirstBaseline::Ascent);
assert!(serde_json::from_value::<AreaOptions>(serde_json::json!({"firstBaseline": "emBox"})).is_err());
}
/// 120 × 40 area type at (40, 40), its text drawn at twice its size.
fn area_type() -> TextObject {
let mut t = TextObject::point(Point::ZERO, "Some text", CharStyle::default());
+5 -9
View File
@@ -28,7 +28,8 @@ use vectorcraft_geom::{Affine, FillRule, PathData, Rect, Vec2};
use crate::distort::{transform_move, transform_offsets};
use crate::group::{has_own_paint, paints};
use crate::reshape::{
as_art, clipping_text_outline, dressed, geometry_effects, glyph_outlines, outline_nested_text, paint_type_clip, reshape_leaves,
as_art, clip_region_path, clipping_text_outline, dressed, geometry_effects, glyph_outlines, knockout_inside, outline_nested_text,
paint_type_clip, reshape_leaves,
};
use crate::{
GeomContext, adjust_in_document, apply_geometry_carrying, crop_marks_art, evaluate_container, has_adjustment, has_crop_marks, has_geometry,
@@ -502,13 +503,7 @@ fn clip_group_with_type_clip(d: &mut Document, n: &Node) -> Option<Node> {
{
return None;
}
let (bp, rule) = crate::clip_outline(first)?;
let mut clip = Node::path(first.id, PathData::from_bezpath(&bp), Appearance::default());
if let NodeKind::Path { rule: r, clipping, .. } = &mut clip.kind {
(*r, *clipping) = (rule, true);
}
clip.name = first.name.clone();
clip.visible = first.visible;
let clip = clip_region_path(first)?;
let paint = first.clip_paint();
// The type's fills and strokes as art: baked with the type's id, as the renderer draws them,
// then given ids of their own.
@@ -532,7 +527,8 @@ fn clip_group_with_type_clip(d: &mut Document, n: &Node) -> Option<Node> {
return Some(m);
};
// `n` keeps its id, name and transparency, and holds the clip group and the strokes over it.
let inner = Node::new(d.alloc_id(), NodeKind::Group { children: members, clip: true });
let mut inner = Node::new(d.alloc_id(), NodeKind::Group { children: members, clip: true });
knockout_inside(&mut m, &mut inner);
match &mut m.kind {
NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } => {
*children = vec![Arc::new(inner), stroke];
+5 -2
View File
@@ -776,7 +776,7 @@ fn type_outlined_next_to_type_that_stays_type_keeps_its_look() {
let mut shadowed = type_node(55);
shadowed.opacity = 0.5;
shadowed.appearance.effects.push(fx("stylize.dropShadow", json!({})));
// Type that clips a group is outlined as the plain outlines it clips by.
// Type that clips a group is outlined as a plain path of the region it clips by.
let square = Node::path(NodeId(57), shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::default_art());
let clip = Node::new(NodeId(58), NodeKind::Group { children: vec![Arc::new(type_node(56)), Arc::new(square)], clip: true });
g.children_mut().unwrap().extend([Arc::new(shadowed), Arc::new(clip)]);
@@ -789,7 +789,10 @@ fn type_outlined_next_to_type_that_stays_type_keeps_its_look() {
let b = o.geometric_bounds().unwrap();
assert!(b.x0 < 30.0 && b.x1 > 220.0, "{b:?}");
let clipped = d.node(NodeId(58)).and_then(|n| n.children()).and_then(|c| c.first()).unwrap();
assert!(matches!(clipped.kind, NodeKind::Group { .. }) && clipped.opacity == 1.0, "{clipped:?}");
assert!(matches!(clipped.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) && clipped.opacity == 1.0, "{clipped:?}");
// The region is copied with the type.
let b = clipped.geometric_bounds().unwrap();
assert!(b.x0 < 30.0 && b.x1 > 220.0, "{b:?}");
}
#[test]
+7 -1
View File
@@ -277,7 +277,13 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
"{h: amount (10), v: amount (10), relative: bool (true: % of size), anchors: bool (true), in: bool (true), out: bool (true), seed: int (0)}",
json!({"h": 10.0, "v": 10.0, "relative": true, "anchors": true, "in": true, "out": true, "seed": 0}),
),
g("distort.twist", "Twist…", DT, "{angle: deg (-3600..3600, 10)}", json!({"angle": 10.0})),
g(
"distort.twist",
"Twist…",
DT,
"{angle: deg (-3600..3600, 10)} Outer-circle anchors stay fixed; their handles follow the inward tangent.",
json!({"angle": 10.0}),
),
g(
"distort.zigZag",
"Zig Zag…",
+34 -4
View File
@@ -6,7 +6,7 @@ use vectorcraft_geom::{Affine, Anchor, ParamCurve, PathData, Point, Rect, SubPat
use vectorcraft_pathops::addons::pathtools::insert_at;
use crate::util::{
catmull_rom, fit_piece, flag, map_nonlinear_within, map_smooth_within, mean_size, noise, normal_at, num, pieces, seed, seg_cubic, smooth_points,
catmull_rom, fit_piece, flag, map_handles_within, map_nonlinear_within, mean_size, noise, normal_at, num, pieces, seed, seg_cubic, smooth_points,
};
fn diag(b: Rect) -> f64 {
@@ -328,7 +328,7 @@ pub fn tweak(path: &PathData, b: Rect, p: &Value) -> PathData {
/// Twist: rotation that is strongest at the centre and fades to zero at the bounding circle,
/// clockwise on the page for a positive `angle`, making at most `max` anchors. Its handles follow
/// the rotation's derivative ([`map_smooth_within`]), so the pieces join without kinks (#7069).
/// the rotation's directional derivative, including each side of the outer circle.
pub fn twist(path: &PathData, b: Rect, angle: f64, max: usize) -> PathData {
let ang = angle.clamp(-3600.0, 3600.0).to_radians();
if ang == 0.0 {
@@ -336,16 +336,46 @@ pub fn twist(path: &PathData, b: Rect, angle: f64, max: usize) -> PathData {
}
let c = b.center();
let r = diag(b) / 2.0;
let half = Vec2::new(b.width() * 0.5, b.height() * 0.5);
let boundary = move |p: Point, length: f64| {
if length == r {
return true;
}
if !r.is_finite() || (length - r).abs() > 8.0 * f64::EPSILON * r {
return false;
}
// A bounds-relative distance identifies boundary points affected by center rounding.
(Vec2::new(p.x - b.x0, p.y - b.y0) - half).hypot() == r
};
let f = move |q: Point| {
let d = q - c;
let t = (1.0 - d.hypot() / r).max(0.0);
let length = d.hypot();
let t = (1.0 - length / r).max(0.0);
// y runs down, so a positive turn is clockwise on the page.
let a = ang * t;
if a == 0.0 {
return q;
}
let (s, co) = a.sin_cos();
c + Vec2::new(d.x * co - d.y * s, d.x * s + d.y * co)
};
let piece = (r / 8.0).min(r / (1.0 + ang.abs() * 2.0));
map_smooth_within(path, piece, max, f)
map_handles_within(path, piece, max, f, |p, h| {
let v = h - p;
if !v.hypot().is_finite() {
return f(p);
}
let d = p - c;
let length = d.hypot();
let radial = if length > 0.0 { (d / length).dot(v) } else { 0.0 };
// The clamped rotation has different inward and outward derivatives at the circle.
let inside = if boundary(p, length) { radial < 0.0 } else { length < r };
let gradient = if inside { -ang / r * radial } else { 0.0 };
let tangent = if gradient == 0.0 { v } else { v + Vec2::new(-d.y, d.x) * gradient };
let a = ang * (1.0 - length / r).max(0.0);
let (s, co) = a.sin_cos();
f(p) + Vec2::new(tangent.x * co - tangent.y * s, tangent.x * s + tangent.y * co)
})
}
const ZIGZAG_ARCLEN_ACCURACY: f64 = 1e-4;
+34 -8
View File
@@ -110,13 +110,15 @@ fn leaves(doc: Option<&Document>, n: &Node, hook: Option<OutlineHook>, nodes: &S
// Every path of the outline art, at any depth, is drawn inside the object's opacity
// and blend mode. A symbol's art comes with the live objects and the instances of
// other symbols inside it given as their art, and the type inside it outlined, so the
// art has nothing left for `hook` to give.
// art has nothing left for `hook` to give. Its fills and strokes carry the geometry
// effects of the instance's active fill and stroke, as the canvas draws them.
if let Some(h) = hook
&& let Some(art) = h(n)
{
let art = match &n.kind {
NodeKind::SymbolInstance { symbol, .. } if nodes.charge(&art) => {
let mut art = crate::reshape::symbol_art_with(&art, h, nodes, symbol);
let mut art = instance_art(doc, &art, h, nodes, symbol);
crate::reshape::add_instance_row_effects(doc, n, &mut art);
crate::reshape::outline_nested_text(doc, &mut art, false);
transparency_into_members(&mut art);
art
@@ -134,6 +136,19 @@ fn leaves(doc: Option<&Document>, n: &Node, hook: Option<OutlineHook>, nodes: &S
}
}
/// `art`, the art `hook` gave an instance of the symbol named `symbol`, with the live objects and
/// the instances of other symbols inside it given as their art
/// ([`crate::reshape::symbol_art_with`]). The art of each of those instances carries the geometry
/// effects of its own active fill and stroke ([`crate::reshape::add_instance_row_effects`]).
fn instance_art(doc: Option<&Document>, art: &Node, hook: OutlineHook, nodes: &SymbolNodes, symbol: &str) -> Node {
let drawn = |m: &Node| {
let mut a = hook(m)?;
crate::reshape::add_instance_row_effects(doc, m, &mut a);
Some(a)
};
crate::reshape::symbol_art_with(art, &drawn, nodes, symbol)
}
/// `l`, a path drawn inside `n`: its opacity multiplied by `n`'s, and `n`'s blend mode when it is
/// not Normal.
fn within(l: &mut Node, n: &Node) {
@@ -221,13 +236,15 @@ fn reshaped_art(doc: Option<&Document>, n: &Node, hook: Option<OutlineHook>, nod
}
},
// A symbol instance with a warp: its symbol's art placed by the instance, with the type
// inside it outlined, reshaped as one piece, as the renderer draws it.
// inside it outlined, reshaped as one piece, as the renderer draws it. The fills and strokes
// of the art then carry the geometry effects of the instance's active fill and stroke.
NodeKind::SymbolInstance { symbol, .. } if !fx.is_empty() => {
let h = hook?;
let art = h(n).filter(|art| nodes.charge(art))?;
let mut art = crate::reshape::symbol_art_with(&art, h, nodes, symbol);
let mut art = instance_art(doc, &art, h, nodes, symbol);
crate::reshape::outline_nested_text(doc, &mut art, false);
members_as_drawn(doc, &mut art);
crate::reshape::add_instance_row_effects(doc, n, &mut art);
let carry = crate::reshape::reshape_leaves_carrying(&mut art, &fx, &n.appearance.effects, doc);
// The art's own fills and strokes follow the effects as its members do.
if carry.moves(&art.appearance) {
@@ -703,6 +720,11 @@ pub fn member_shapes(doc: Option<&Document>, n: &Node) -> Vec<(PathData, FillRul
}
}
fn members(doc: Option<&Document>, n: &Node, out: &mut Vec<(PathData, FillRule)>) {
// A clip group whose clipping type's strokes paint around it is outlined as that clip
// group: the strokes outside the clip add nothing.
if let Some(inner) = crate::reshape::painted_clip_inner(n) {
return members(doc, inner, out);
}
// A clip group shows its members only inside its clipping path: its outline is that
// region, not the clipped members' own shapes, which may reach far outside it (#7289).
if n.clips() {
@@ -884,14 +906,18 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
m.appearance.effects = crate::raster::without_geometry(&m.appearance.effects);
m.appearance.effects.retain(|e| !is_pathfinder(&e.id));
if paint {
let shapes = member_shapes(doc, &m);
let bounds = m.geometric_bounds();
// A clip group whose clipping type paints strokes is now a group of a clip group and those
// strokes ([`crate::reshape::paint_type_clip`]): its own fills and strokes paint inside
// that clip group. Such groups among the members are measured as their clip groups.
let wrapped = n.clips() && crate::reshape::painted_clip_inner(&m).is_some();
let (shapes, bounds) = (member_shapes(doc, &m), crate::reshape::clip_bounds(&m));
let art =
|items: &[AppearanceItem]| -> Vec<Arc<Node>> { items.iter().filter_map(|i| item_art(n.id, i, &shapes, bounds)).map(Arc::new).collect() };
let (below, above) = m.appearance.split_contents();
let (below, above) = (art(below), art(above));
let at = usize::from(m.clips());
if let Some(ch) = m.children_mut() {
let at = usize::from(wrapped || m.clips());
let target = if wrapped { m.children_mut().and_then(|ch| ch.first_mut()).map(Arc::make_mut) } else { Some(&mut m) };
if let Some(ch) = target.and_then(Node::children_mut) {
let at = at.min(ch.len());
ch.splice(at..at, below);
ch.extend(above);
+194 -44
View File
@@ -387,7 +387,7 @@ fn row_effects_of(fx: &[Effect]) -> Vec<Effect> {
/// of a symbol whose art (in `doc`) holds an instance of `n`'s symbol, at any depth, keeps its
/// appearance, so the effects never pass round a symbol that holds itself. Without `doc`, no
/// instance in the art takes them.
fn add_instance_row_effects(doc: Option<&Document>, n: &Node, art: &mut Node) {
pub(crate) fn add_instance_row_effects(doc: Option<&Document>, n: &Node, art: &mut Node) {
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return };
let fill = active_fill(n).map_or(vec![], |f| row_effects_of(&f.effects));
let stroke = active_stroke(n).map_or(vec![], |s| row_effects_of(&s.effects));
@@ -613,32 +613,101 @@ fn traced_opaque_area(bytes: &[u8]) -> Traced {
/// rule and the fill or stroke that paints it: the paths (or compound paths) that [`reshape`]
/// makes along its frame or, for those whose first effect is Outline Object, along the outline of
/// its opaque area ([`opaque_area`]), with each fill's or stroke's geometry effects applied as the
/// renderer applies them. Empty for anything but an image with such fills or strokes. The swatches
/// and patterns that live-effect plug-ins painting their pieces name are looked up in `doc`, and
/// the image's pixels in `doc` when the image does not hold them.
/// renderer applies them. For a symbol instance whose active fill or stroke has a visible geometry
/// effect ([`has_item_geometry`]), the shapes that the fills and strokes of the art it draws paint
/// ([`instance_paint`]). Empty for anything else. The swatches and patterns that live-effect
/// plug-ins painting their pieces name are looked up in `doc`, and the image's pixels in `doc` when
/// the image does not hold them.
pub fn image_paint(doc: Option<&Document>, n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
if !matches!(n.kind, NodeKind::Image(_)) || !has_item_geometry(n) {
return vec![];
}
let Some(art) = reshape(doc, n, None) else { return vec![] };
let mut out = vec![];
art.walk(&mut |c| {
let (NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. }) = &c.kind else { return };
let Some(g) = c.stroke_path() else { return };
let ctx = GeomContext { doc, ..GeomContext::of(c) };
for item in c.appearance.items.iter().filter(|i| crate::paints(i)) {
let fx = item.effects();
let shape = if crate::has_geometry(fx) && !g.elements().is_empty() {
crate::apply_geometry_bez(fx, &g, g.bounding_box(), &ctx.item(item))
} else {
g.clone()
};
out.push((shape, *rule, item.clone()));
}
});
if matches!(n.kind, NodeKind::SymbolInstance { .. }) {
let mut budget = SYMBOL_ART_MAX_NODES;
instance_paint(doc, n, 1, &mut budget, &mut out);
return out;
}
if !matches!(n.kind, NodeKind::Image(_)) || !has_item_geometry(n) {
return out;
}
let Some(art) = reshape(doc, n, None) else { return out };
art.walk(&mut |c| push_painted(doc, c, &mut out));
out
}
/// The shapes that the fills and strokes of path or compound path `c` paint, each with the
/// geometry effects of that fill or stroke applied ([`image_paint`]); nothing for other objects.
fn push_painted(doc: Option<&Document>, c: &Node, out: &mut Vec<(BezPath, FillRule, AppearanceItem)>) {
let (NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. }) = &c.kind else { return };
let Some(g) = c.stroke_path() else { return };
let ctx = GeomContext { doc, ..GeomContext::of(c) };
for item in c.appearance.items.iter().filter(|i| crate::paints(i)) {
let fx = item.effects();
let shape = if crate::has_geometry(fx) && !g.elements().is_empty() {
crate::apply_geometry_bez(fx, &g, g.bounding_box(), &ctx.item(item))
} else {
g.clone()
};
out.push((shape, *rule, item.clone()));
}
}
/// The shapes that symbol instance `n`, `depth` instances deep, paints with the geometry effects of
/// its active fill and stroke ([`has_item_geometry`]): the paths of the art [`reshape`] makes of it,
/// each with its own geometry effects and those of each fill and stroke applied
/// ([`crate::bake_type_appearance`], [`push_painted`]), the paths that the own fills and strokes of
/// the groups and layers in the art paint and the results of their Pathfinder effects
/// ([`crate::evaluate_container`]), the shapes that the own fills and strokes of the images in the
/// art paint ([`image_paint`]), and the instances in that art that took those effects, in turn.
/// Hidden objects, clipping paths, guides, the members of clip groups and the original shapes of
/// Shaper groups add nothing, and neither does an instance more than
/// [`vectorcraft_doc::depth::MAX_DEPTH`] deep or whose symbol's art would take the objects measured
/// so far past `budget`.
fn instance_paint(doc: Option<&Document>, n: &Node, depth: usize, budget: &mut u64, out: &mut Vec<(BezPath, FillRule, AppearanceItem)>) {
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return };
if depth >= vectorcraft_doc::depth::MAX_DEPTH || !has_item_geometry(n) {
return;
}
let Some(sym) = doc.and_then(|d| d.symbols.iter().find(|s| s.name == *symbol)) else { return };
let count = sym.art.count() as u64;
if count > *budget {
return;
}
*budget -= count;
let Some(art) = reshape(doc, n, Some(&vectorcraft_doc::symbol_overrides::dynamic_art(&sym.art, n))) else { return };
painted_in(doc, &art, depth, budget, out);
}
/// [`instance_paint`] of the objects in `n`, art of an instance `depth` instances deep.
fn painted_in(doc: Option<&Document>, n: &Node, depth: usize, budget: &mut u64, out: &mut Vec<(BezPath, FillRule, AppearanceItem)>) {
if !n.visible {
return;
}
match &n.kind {
NodeKind::Path { clipping: false, guide: false, .. } | NodeKind::Compound { .. } => match crate::bake_type_appearance(doc, n) {
// One path for each fill and stroke, its effects applied.
Some(pieces) => painted_in(doc, &pieces, depth, budget, out),
None => push_painted(doc, n, out),
},
NodeKind::Path { .. } => {}
NodeKind::Image(_) => out.extend(image_paint(doc, n)),
NodeKind::SymbolInstance { .. } => instance_paint(doc, n, depth + 1, budget, out),
_ if n.clips() => {}
_ => {
// A Pathfinder effect paints its result, not the members it combines.
let evaluated = (crate::has_container_appearance(n) || crate::has_pathfinder(n)).then(|| crate::evaluate_container(doc, n)).flatten();
let g = evaluated.as_ref().unwrap_or(n);
if g.clips() {
return;
}
// A Shaper group's first member holds its original shapes, which are not drawn. The
// group's own fills and strokes can be painted before it, so it is found by its id.
let sources = n.extras().shaper.is_some().then(|| n.children().and_then(|c| c.first()).map(|c| c.id)).flatten();
for c in g.children().into_iter().flatten().filter(|c| Some(c.id) != sources) {
painted_in(doc, c, depth, budget, out);
}
}
}
}
/// The glyph outlines of type `t` in text space with its underline and strikethrough bars: one
/// path per run, and all of them as one.
pub(crate) fn glyph_outlines(t: &vectorcraft_doc::TextObject) -> (Vec<kurbo::BezPath>, kurbo::BezPath) {
@@ -954,6 +1023,74 @@ pub(crate) fn clipping_text_outline(t: &Node) -> Option<Node> {
Some(Node { visible: t.visible, ..o })
}
/// Clipping path `clip` of a clip group as a clipping path of the region it clips to
/// ([`crate::clip_outline`]), with its id, name and visibility. For type that paints, the geometry
/// effects of its fills and strokes reshape what they paint and leave that region as it is.
/// `None` when it has nothing to clip by.
pub(crate) fn clip_region_path(clip: &Node) -> Option<Node> {
let (bp, rule) = crate::clip_outline(clip)?;
let mut p = Node::path(clip.id, PathData::from_bezpath(&bp), Appearance::default());
if let NodeKind::Path { rule: r, clipping, .. } = &mut p.kind {
(*r, *clipping) = (rule, true);
}
p.name = clip.name.clone();
p.visible = clip.visible;
Some(p)
}
/// Knockout Group for clip group `m` turned into a group around `inner`, a clip group of its
/// members, and its clipping path's strokes: `inner` takes `m`'s setting, so the clipped art knocks
/// out as before, and `m` is set Off so the strokes paint over it, as the renderer draws them. A
/// neutral `m` stays neutral, so both take the setting of the groups around them.
pub(crate) fn knockout_inside(m: &mut Node, inner: &mut Node) {
inner.knockout = m.knockout;
if m.knockout != vectorcraft_doc::Knockout::Neutral {
m.knockout = vectorcraft_doc::Knockout::Off;
}
}
/// The clip group in `n` when `n` is a group or layer that [`paint_type_clip`] made of a clip
/// group and its clipping type's strokes: a group that does not clip whose first member is a clip
/// group with `n`'s id and whose second member has the id of that clip group's clipping path. The
/// clip group's region is what `n` stands for, as the clip group it was made from: the strokes
/// paint outside it and add nothing to its outline ([`crate::member_shapes`]) or its bounds
/// ([`clip_bounds`]).
pub(crate) fn painted_clip_inner(n: &Node) -> Option<&Node> {
if n.clips() || !matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) {
return None;
}
let [inner, stroke, ..] = n.children()?.as_slice() else { return None };
let clip = inner.children()?.first()?;
(inner.clips() && inner.id == n.id && stroke.id == clip.id && !stroke.clips()).then_some(&**inner)
}
/// The geometric bounds of `n` ([`Node::geometric_bounds`]) with each group or layer in it that
/// [`painted_clip_inner`] finds measured as its clip group, so the strokes of a clipping type
/// outside the clip do not widen them.
pub(crate) fn clip_bounds(n: &Node) -> Option<Rect> {
fn holds(n: &Node) -> bool {
painted_clip_inner(n).is_some() || n.children().into_iter().flatten().any(|c| holds(c))
}
fn unwrap(n: &mut Node) {
if let Some(inner) = painted_clip_inner(n) {
let mut inner = inner.clone();
inner.visible = n.visible;
*n = inner;
}
for c in n.children_mut().into_iter().flatten() {
if holds(c) {
unwrap(Arc::make_mut(c));
}
}
}
if !holds(n) {
return n.geometric_bounds();
}
let mut probe = n.clone();
unwrap(&mut probe);
probe.geometric_bounds()
}
/// Replace type anywhere inside `n` by its outlines, as art that keeps the type's look
/// ([`as_art`]). Type in a clip group's clipping path (all of `n` when `clipping` is set) becomes
/// its outlines with its visibility and effects ([`clipping_text_outline`]), and its fills and
@@ -981,32 +1118,41 @@ pub(crate) fn outline_nested_text(doc: Option<&Document>, n: &mut Node, clipping
}
/// When `n` is a clip group or clipping layer whose clipping path is type that paints
/// ([`Node::clip_paint`]), make it the art the canvas draws for it: the type's outlines clip
/// ([`clipping_text_outline`]), its fills as art ([`as_art`]) paint behind the clipped art inside
/// the clip, and its strokes as art paint over it, outside the clip, in a group that `n` becomes
/// (keeping its id, name and transparency) with the clip group inside. The other members stay as
/// they are. Hidden type paints nothing.
/// ([`Node::clip_paint`]), make it the art the canvas draws for it: a path of the region the type
/// clips to clips ([`clip_region_path`]), its fills as art ([`as_art`]) paint behind the clipped
/// art inside the clip, and its strokes as art paint over it, outside the clip. Each part is the
/// type's art with only those fills or strokes, their own geometry effects applied. With strokes,
/// `n` becomes a group (keeping its id, name, visibility and transparency) that holds a clip group
/// of the clipping path, the fills and the other members, with `n`'s id, then the strokes; a
/// clipping layer keeps its ruler guides last. [`knockout_inside`] sets the Knockout Group of both,
/// and [`painted_clip_inner`] finds that clip group. The other members stay as they are. Hidden
/// type paints nothing.
pub(crate) fn paint_type_clip(doc: Option<&Document>, n: &mut Node) {
let Some((first, rest)) = n.children().and_then(|ch| ch.split_first()) else { return };
if !n.clips() || !matches!(first.kind, NodeKind::Text(_)) || !first.visible {
let Some(first) = n.children().and_then(|ch| ch.first()).filter(|_| n.clips()) else { return };
if !matches!(first.kind, NodeKind::Text(_)) || !first.visible {
return;
}
let paint = first.clip_paint();
if paint.fill.is_none() && paint.stroke.is_none() {
return;
}
let Some(clip) = clipping_text_outline(first) else { return };
let Some(clip) = clip_region_path(first) else { return };
let art = |part: Option<Node>| part.and_then(|p| as_art(doc, &p, None)).map(Arc::new);
let members: Vec<Arc<Node>> = std::iter::once(Arc::new(clip)).chain(art(paint.fill)).chain(rest.iter().cloned()).collect();
let stroke = art(paint.stroke);
let (fill, stroke) = (art(paint.fill), art(paint.stroke));
let id = n.id;
match (&mut n.kind, stroke) {
(NodeKind::Group { children, .. } | NodeKind::Layer { children, .. }, None) => *children = members,
(NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. }, Some(stroke)) => {
*children = vec![Arc::new(Node::new(id, NodeKind::Group { children: members, clip: true })), stroke];
*clip = false;
}
_ => {}
let Some(ch) = n.children_mut() else { return };
let Some(slot) = ch.first_mut() else { return };
*slot = Arc::new(clip);
if let Some(fill) = fill {
ch.insert(1, fill);
}
let Some(stroke) = stroke else { return };
let guides = ch.split_off(Node::guide_run_start(ch));
let mut inner = Node::new(id, NodeKind::Group { children: std::mem::take(ch), clip: true });
knockout_inside(n, &mut inner);
if let NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } = &mut n.kind {
*children = [Arc::new(inner), stroke].into_iter().chain(guides).collect();
*clip = false;
}
}
@@ -1822,7 +1968,7 @@ impl Step<'_> {
if !groups.is_empty() {
carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, params, bounds, from, to, seed));
}
let drawn = warped.as_deref().map_or_else(|| art.geometric_bounds(), |w| w.bounds(art));
let drawn = warped.as_deref().map_or_else(|| clip_bounds(art), |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(), took, masks, short, whole }
}
@@ -3247,6 +3393,9 @@ fn group_marks(
NodeKind::Image(_) => (images.map_or_else(|| n.geometric_bounds(), |w| w.image_bounds(n)), false),
NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } if !n.extras().type_outlines => {
let layer = matches!(n.kind, NodeKind::Layer { .. });
// A clip group whose clipping type's strokes paint around it is measured as that clip
// group: the strokes outside the clip do not widen it ([`clip_bounds`]).
let clip = *clip || painted_clip_inner(n).is_some();
let skip = children.len().saturating_sub(n.editing_children().len());
let (mut bounds, mut held) = (None, false);
for (i, c) in children.iter().enumerate() {
@@ -3257,7 +3406,7 @@ fn group_marks(
}
at.pop();
// Only members measured in the bounds hold the group's gradients in place.
let counts = if *clip { i == 0 } else { i >= skip && (c.visible || !layer) };
let counts = if clip { i == 0 } else { i >= skip && (c.visible || !layer) };
if counts {
bounds = vectorcraft_geom::union_opt(bounds, b);
held |= h;
@@ -3473,16 +3622,17 @@ impl WarpedImages {
/// The geometric bounds of `art` as it draws after the effects so far: each image this table
/// lists measured by the pieces the warps and moves it took would cut it into, when the art
/// has room for them ([`cut_warped_images`]).
/// has room for them ([`cut_warped_images`]). The strokes of clipping type outside its clip
/// are left out ([`clip_bounds`]).
pub(crate) fn bounds(&self, art: &Node) -> Option<Rect> {
if self.images.is_empty() || !self.fits(art, crate::distort::MAX_COPY_OBJECTS) {
return art.geometric_bounds();
return clip_bounds(art);
}
// The pieces the images would be cut into now: each group of pieces is shown or hidden as
// its image is, and hidden objects are left out of a layer's bounds.
let mut probe = art.clone();
restore_warped_images(&mut probe, self, true);
probe.geometric_bounds()
clip_bounds(&probe)
}
/// The geometric bounds of image `n`: when this table lists it, measured by the pieces the
+109
View File
@@ -1708,6 +1708,115 @@ fn twist_joins_its_pieces_smoothly() {
}
}
#[test]
fn twist_boundary_handles_follow_the_inward_tangent() {
let line = PathData::single(SubPath::polyline(&[Point::new(40.0, 30.0), Point::new(60.0, 30.0)], false));
let bounds = Rect::new(40.0, 30.0, 60.0, 30.0);
for angle in [90.0_f64, 400.0, -720.0] {
let out = apply_geometry(&[fx("distort.twist", json!({"angle": angle}))], &line, bounds);
let anchors = &out.subpaths[0].anchors;
let start = anchors.first().unwrap();
let end = anchors.last().unwrap();
assert_eq!(start.p, Point::new(40.0, 30.0));
assert_eq!(end.p, Point::new(60.0, 30.0));
for (actual, expected) in [
(start.h_out - start.p, vectorcraft_geom::Vec2::new(1.0, -angle.to_radians())),
(end.h_in - end.p, vectorcraft_geom::Vec2::new(-1.0, angle.to_radians())),
] {
assert!(actual.hypot() > 1e-9);
let error = (actual.x * expected.y - actual.y * expected.x).atan2(actual.dot(expected)).to_degrees().abs();
assert!(error < 0.05, "{angle} degrees: boundary tangent differs by {error} degrees");
}
}
}
#[test]
fn twist_large_coordinate_joins_preserve_boundary_sides() {
use vectorcraft_geom::Anchor;
let center = 1e16;
for offset in [32.0, 64.0] {
let p = Point::new(center + offset, 0.0);
let line = PathData::single(SubPath::new(
vec![
Anchor::corner(Point::new(p.x - 18.0, 0.0)),
Anchor::with_handles(p, Point::new(p.x - 6.0, 0.0), Point::new(p.x + 6.0, 0.0)),
Anchor::corner(Point::new(p.x + 18.0, 0.0)),
],
false,
));
let out = crate::distort::twist(&line, Rect::new(center - 64.0, 0.0, center + 64.0, 0.0), 90.0, 3);
let join = &out.subpaths[0].anchors[1];
if offset == 64.0 {
assert_eq!(join.h_out, Point::new(p.x + 6.0, 0.0));
let actual = join.h_in - join.p;
let expected = vectorcraft_geom::Vec2::new(-1.0, std::f64::consts::FRAC_PI_2);
let error = actual.cross(expected).atan2(actual.dot(expected)).abs();
assert!(error < 1e-9, "{actual:?}");
} else {
let incoming = join.p - join.h_in;
let outgoing = join.h_out - join.p;
assert!(incoming.cross(outgoing).abs() < 1e-9, "{incoming:?} {outgoing:?}");
assert!(incoming.dot(outgoing) > 0.0);
}
}
}
#[test]
fn twist_fractional_boundary_handles_use_each_sides_derivative() {
use vectorcraft_geom::Anchor;
for (bounds, step) in [(Rect::new(40.1, 30.0, 60.3, 30.0), 1.0), (Rect::new(-60.3, 30.0, -40.1, 30.0), 1.0)] {
for x in [bounds.x0, bounds.x1] {
for angle in [90.0_f64, 400.0, -720.0] {
let p = Point::new(x, 30.0);
let line = PathData::single(SubPath::new(
vec![
Anchor::corner(Point::new(x - 3.0 * step, 30.0)),
Anchor::with_handles(p, Point::new(x - step, 30.0), Point::new(x + step, 30.0)),
Anchor::corner(Point::new(x + 3.0 * step, 30.0)),
],
false,
));
let out = crate::distort::twist(&line, bounds, angle, 3);
assert!(
out.subpaths[0].anchors.iter().all(|a| a.p.is_finite() && a.h_in.is_finite() && a.h_out.is_finite()),
"x={x} angle={angle}: {:?}",
out.subpaths[0].anchors
);
let join = &out.subpaths[0].anchors[1];
assert!(join.p.distance(p) < 1e-10, "{:?}", join.p);
let a = angle.to_radians();
let expected = if x == bounds.x0 { [(-1.0, 0.0), (1.0, -a)] } else { [(-1.0, a), (1.0, 0.0)] };
for (actual, (dx, dy)) in [join.h_in - join.p, join.h_out - join.p].into_iter().zip(expected) {
let expected = vectorcraft_geom::Vec2::new(dx, dy);
let error = actual.cross(expected).atan2(actual.dot(expected)).abs();
assert!(error < 1e-9, "x={x} angle={angle}: {actual:?}, join={join:?}, source={:?}", line.subpaths[0].anchors[1]);
}
}
}
}
let bounds = Rect::new(1e16, 30.0, 1e16 + 18.0, 30.0);
let center = bounds.center();
let line = PathData::single(SubPath::polyline(&[Point::new(center.x - 4.0, center.y), center, Point::new(center.x + 4.0, center.y)], false));
let out = crate::distort::twist(&line, bounds, 90.0, 3);
assert_eq!(out.subpaths[0].anchors[1].p, center);
let bounds = Rect::new(0.0, 30.0, 2e16, 30.0);
let p = Point::new(bounds.x1 - 8.0, 30.0);
let line = PathData::single(SubPath::new(
vec![
Anchor::corner(Point::new(p.x - 12.0, p.y)),
Anchor::with_handles(p, Point::new(p.x - 4.0, p.y), Point::new(p.x + 4.0, p.y)),
Anchor::corner(Point::new(p.x + 12.0, p.y)),
],
false,
));
let out = crate::distort::twist(&line, bounds, 90.0, 3);
let join = &out.subpaths[0].anchors[1];
assert!(join.p.y - p.y > 10.0, "{:?}", join.p);
assert!(join.h_out.y - join.p.y < -4.0, "{join:?}");
}
#[test]
fn twist_fixes_the_outer_circle_and_rotates_inside() {
let out = run("distort.twist", json!({"angle": 0}), &square());
+334
View File
@@ -543,3 +543,337 @@ fn raster_and_hidden_effects_leave_the_clip_as_it_is() {
assert_eq!(bounds(&clipping_path(1, effects)), Rect::new(50.0, 50.0, 150.0, 150.0));
}
}
fn blue() -> Paint {
Paint::solid(Color::rgb(0.0, 0.0, 1.0))
}
fn green() -> Paint {
Paint::solid(Color::rgb(0.0, 1.0, 0.0))
}
/// "IIII" at 40 pt from (5, 60) in a test font built from the bundled Source Sans 3
/// ([`vectorcraft_text::test_fonts::height_font`]), its characters filled blue when `fill` and
/// stroked green 2 pt wide when `stroke`.
fn painted_type(id: u64, fill: bool, stroke: bool) -> Node {
use vectorcraft_doc::text::{CharStyle, TextObject};
use vectorcraft_text::test_fonts::{HEIGHT_FAMILY, height_font};
static FONT: std::sync::Once = std::sync::Once::new();
FONT.call_once(|| {
vectorcraft_text::FontDb::global().add_font(height_font(true).expect("the test font builds"));
});
let style = CharStyle {
font_family: HEIGHT_FAMILY.into(),
size: 40.0,
fill: if fill { blue() } else { Paint::None },
stroke: if stroke { green() } else { Paint::None },
stroke_width: 2.0,
..Default::default()
};
Node::new(NodeId(id), NodeKind::Text(Box::new(TextObject::point(vectorcraft_geom::Point::new(5.0, 60.0), "IIII", style))))
}
/// Does `n` or an object in it have a blue fill (`fill`) or a green stroke?
fn paints(n: &Node, fill: bool) -> bool {
use vectorcraft_doc::AppearanceItem;
let own = n.appearance.items.iter().any(|i| match i {
AppearanceItem::Fill(f) => fill && f.paint == blue(),
AppearanceItem::Stroke(s) => !fill && s.paint == green() && s.width > 0.0,
});
own || n.children().into_iter().flatten().any(|c| paints(c, fill))
}
/// What the first clip group in `n` paints: the bounds of the region it clips to, the bounds of
/// the blue fill art right after its clipping path (behind the clipped art), the bounds of the
/// green stroke art right after the clip group (over it, outside the clip), and whether a green
/// stroke paints inside the clip group.
type Painted = (Rect, Option<Rect>, Option<Rect>, bool);
fn painted_clip(n: &Node) -> Option<Painted> {
let ch = n.children()?;
for (i, c) in ch.iter().enumerate() {
if let NodeKind::Group { children, clip: true } = &c.kind {
let region = clip_outline(children.first()?)?.0.bounding_box();
let fill = children.get(1).filter(|f| paints(f, true)).and_then(|f| f.geometric_bounds());
let stroke = ch.get(i + 1).filter(|s| paints(s, false)).and_then(|s| s.geometric_bounds());
let inside = children.iter().skip(1).any(|m| paints(m, false));
return Some((region, fill, stroke, inside));
}
if let Some(found) = painted_clip(c) {
return Some(found);
}
}
None
}
fn near_rect(a: Rect, b: Rect) -> bool {
(a.x0 - b.x0).abs() < 0.5 && (a.y0 - b.y0).abs() < 0.5 && (a.x1 - b.x1).abs() < 0.5 && (a.y1 - b.y1).abs() < 0.5
}
#[test]
fn painted_clipping_type_survives_enclosing_geometry_effect() {
// Type that paints a fill, a stroke, both or neither clips a red square, in a group whose
// Transform (moving everything 10 pt down, beside other type that stays type in the export) or
// Offset Path reshapes its members: the canvas and the export keep the type's fill as art
// behind the square inside the clip and its stroke as art over the clip group, both reshaped
// with the clip.
let plain = clip_outline(&painted_type(3, false, false)).expect("the type clips").0.bounding_box();
assert!(plain.width() > 10.0 && plain.height() > 10.0, "the type has glyph outlines: {plain:?}");
let effects = [fx("distort.transform", json!({"moveV": 10})), fx("path.offsetPath", json!({"offset": 1}))];
for effect in effects {
for (fill, stroke) in [(true, false), (false, true), (true, true), (false, false)] {
let clipped = clip_group(2, painted_type(3, fill, stroke));
let mut outer = Node::group(NodeId(1), vec![Arc::new(clipped), Arc::new(painted_type(5, true, false))]);
outer.appearance.effects.push(effect.clone());
let canvas = crate::evaluate_container(None, &outer).unwrap();
let mut d = Document::new(400.0, 400.0);
let layer = d.layers[0].id;
d.insert(Some(layer), 0, outer).unwrap();
let baked = bake_document(&d).unwrap();
let exported = baked.layers.iter().find_map(|l| painted_clip(l));
for (what, found) in [("canvas", painted_clip(&canvas)), ("export", exported)] {
let case = format!("{what}, {}, fill {fill}, stroke {stroke}", effect.id);
let (region, fills, strokes, inside) = found.unwrap_or_else(|| panic!("{case}: no clip group"));
if effect.id == "distort.transform" {
assert!((region.y0 - plain.y0 - 10.0).abs() < 0.5 && (region.x0 - plain.x0).abs() < 0.5, "{case}: {region:?} from {plain:?}");
} else {
let grown = Rect::new(plain.x0 - 1.0, plain.y0 - 1.0, plain.x1 + 1.0, plain.y1 + 1.0);
assert!(near_rect(region, grown), "{case}: {region:?} is {plain:?} offset by 1 pt");
}
assert_eq!(fills.is_some(), fill, "{case}: fill art {fills:?}");
assert_eq!(strokes.is_some(), stroke, "{case}: stroke art {strokes:?}");
assert!(!inside, "{case}: the stroke paints outside the clip");
for art in fills.into_iter().chain(strokes) {
assert!(near_rect(art, region), "{case}: the paint {art:?} follows the clip {region:?}");
}
}
}
}
}
/// The group in `n` that holds a clip group and then the green stroke art of its clipping type,
/// with that clip group.
fn stroke_wrapper(n: &Node) -> Option<(&Node, &Node)> {
let ch = n.children()?;
if let [inner, stroke, ..] = ch.as_slice()
&& matches!(inner.kind, NodeKind::Group { clip: true, .. })
&& !n.clips()
&& paints(stroke, false)
{
return Some((n, inner));
}
ch.iter().find_map(|c| stroke_wrapper(c))
}
#[test]
fn clipping_type_strokes_paint_over_a_knockout_clip_group() {
// A clip group set to Knockout Group On, Off or neutral, clipped by type that strokes: its
// clipped art knocks out as the clip group says, and the type's stroke paints over it without
// knocking it out, as the canvas draws the live clip group. The type is reshaped by a group's
// Transform around it, or by its own Offset Path.
use vectorcraft_doc::Knockout;
for (knockout, around) in [(Knockout::On, Knockout::Off), (Knockout::Off, Knockout::Off), (Knockout::Neutral, Knockout::Neutral)] {
for own in [false, true] {
let mut ty = painted_type(3, true, true);
if own {
ty.appearance.effects.push(fx("path.offsetPath", json!({"offset": 1})));
}
let mut clipped = clip_group(2, ty);
clipped.knockout = knockout;
let mut outer = Node::group(NodeId(1), vec![Arc::new(clipped)]);
if !own {
outer.appearance.effects.push(fx("distort.transform", json!({"moveV": 10})));
}
let mut d = Document::new(400.0, 400.0);
let layer = d.layers[0].id;
d.insert(Some(layer), 0, outer.clone()).unwrap();
let baked = bake_document(&d).unwrap();
let canvas = if own { None } else { crate::evaluate_container(None, &outer) };
let exported = baked.layers.iter().find_map(|l| stroke_wrapper(l));
for (what, found) in [("canvas", canvas.as_ref().and_then(stroke_wrapper)), ("export", exported)] {
if own && what == "canvas" {
continue;
}
let case = format!("{what}, own effect {own}, knockout {knockout:?}");
let (wrapper, inner) = found.unwrap_or_else(|| panic!("{case}: no group around the clip"));
assert_eq!(inner.knockout, knockout, "{case}: the clipped art knocks out as before");
assert_eq!(wrapper.knockout, around, "{case}: the stroke does not knock out the clipped art");
}
}
}
}
#[test]
fn a_clip_groups_own_fill_stays_in_the_clip_when_its_clipping_type_strokes() {
// A clip group with a yellow fill of its own and an Offset Path effect, clipped by type that
// strokes: the group's fill still paints inside the clip, and the type's stroke over it.
let yellow = Paint::solid(Color::rgb(1.0, 1.0, 0.0));
let mut group = clip_group(2, painted_type(3, false, true));
group.appearance =
Appearance { effects: vec![fx("path.offsetPath", json!({"offset": 0}))], ..Appearance::basic(yellow.clone(), Paint::None, 0.0) }.into();
let canvas = crate::evaluate_container(None, &group).unwrap();
let (_, _, strokes, inside) = painted_clip(&Node::group(NodeId(9), vec![Arc::new(canvas.clone())])).unwrap();
assert!(strokes.is_some() && !inside, "{canvas:?}");
let NodeKind::Group { children, clip: false } = &canvas.kind else { panic!("not a group around the clip: {canvas:?}") };
let NodeKind::Group { children: clipped, clip: true } = &children[0].kind else { panic!("no clip group first: {children:?}") };
let yellow_in = |n: &Node| n.appearance.items.iter().any(|i| matches!(i, vectorcraft_doc::AppearanceItem::Fill(f) if f.paint == yellow));
assert!(clipped.iter().skip(1).any(|c| yellow_in(c)), "the group's fill paints inside the clip: {clipped:?}");
assert!(!children.iter().skip(1).any(|c| yellow_in(c)), "{children:?}");
}
#[test]
fn a_clip_groups_own_gradient_spans_the_clip_when_its_clipping_type_strokes() {
// A clip group with an unplaced linear gradient fill of its own and an Offset Path effect,
// clipped by type with a stroke whose Transform effect moves it 60 pt right: the gradient
// spans the region the clipping path clips to.
use vectorcraft_color::{Gradient, GradientKind, GradientPaint, GradientStop};
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
let unplaced = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
let mut ty = painted_type(3, false, false);
ty.appearance = Appearance::basic(Paint::None, green(), 2.0).into();
for item in &mut ty.appearance.items {
if let vectorcraft_doc::AppearanceItem::Stroke(s) = item {
s.effects.push(fx("distort.transform", json!({"moveH": 60})));
}
}
let mut group = clip_group(2, ty);
group.appearance =
Appearance { effects: vec![fx("path.offsetPath", json!({"offset": 0}))], ..Appearance::basic(unplaced, Paint::None, 0.0) }.into();
let canvas = crate::evaluate_container(None, &group).unwrap();
let NodeKind::Group { children, clip: false } = &canvas.kind else { panic!("not a group around the clip: {canvas:?}") };
let NodeKind::Group { children: clipped, clip: true } = &children[0].kind else { panic!("no clip group first: {children:?}") };
let region = clip_outline(&clipped[0]).expect("the type clips").0.bounding_box();
let fill = clipped.iter().skip(1).find_map(|c| match c.appearance.fill_paint() {
Paint::Gradient(g) => g.geom,
_ => None,
});
let geom = fill.unwrap_or_else(|| panic!("no gradient fill inside the clip: {clipped:?}"));
let (left, right) = (geom.start.x.min(geom.end.x), geom.start.x.max(geom.end.x));
assert!((left - region.x0).abs() < 0.5 && (right - region.x1).abs() < 0.5, "the gradient {geom:?} spans the clip {region:?}");
}
#[test]
fn a_groups_own_fill_paints_only_the_clip_of_clipping_type_whose_stroke_moves() {
// A group with a fill of its own (solid, or an unplaced linear gradient) and a Transform effect
// (moving everything 10 pt down, or scaling it to half its width around its middle) holds a
// clip group clipped by type whose stroke has a Transform effect moving it 60 pt right,
// outside the clip. On the canvas and in the export, the clip region is the type's glyphs
// reshaped by the group's effect, and the group's fill paints that region alone, its gradient
// spanning it: the moved stroke adds nothing to the region, the fill or the box the group's
// effect scales around.
use vectorcraft_color::{Gradient, GradientKind, GradientPaint, GradientStop};
let yellow = Paint::solid(Color::rgb(1.0, 1.0, 0.0));
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
let unplaced = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
let mut ty = painted_type(3, false, false);
ty.appearance = Appearance::basic(Paint::None, green(), 2.0).into();
for item in &mut ty.appearance.items {
if let vectorcraft_doc::AppearanceItem::Stroke(s) = item {
s.effects.push(fx("distort.transform", json!({"moveH": 60})));
}
}
let live = clip_outline(&ty).expect("the type clips").0.bounding_box();
let moved = Rect::new(live.x0, live.y0 + 10.0, live.x1, live.y1 + 10.0);
// Scaled to half its width around the middle of the clip, which the stroke does not move.
let (mid, quarter) = ((live.x0 + live.x1) / 2.0, live.width() / 4.0);
let narrowed = Rect::new(mid - quarter, live.y0, mid + quarter, live.y1);
// The group's own fill art: every object outside the clip groups whose own fill is `paint`.
fn own_fills<'a>(n: &'a Node, paint: &Paint, out: &mut Vec<&'a Node>) {
let mine = n.appearance.items.iter().any(|i| match (i, paint) {
(vectorcraft_doc::AppearanceItem::Fill(f), Paint::Gradient(_)) => matches!(f.paint, Paint::Gradient(_)),
(vectorcraft_doc::AppearanceItem::Fill(f), p) => f.paint == *p,
_ => false,
});
if mine {
out.push(n);
}
for c in n.children().into_iter().flatten().filter(|c| !c.clips()) {
own_fills(c, paint, out);
}
}
let cases = [(json!({"moveV": 10}), moved), (json!({"scaleH": 50, "scaleV": 100}), narrowed)];
for ((params, region), paint) in cases.iter().flat_map(|c| [yellow.clone(), unplaced.clone()].map(|p| (c.clone(), p))) {
let mut outer = Node::group(NodeId(1), vec![Arc::new(clip_group(2, ty.clone()))]);
outer.appearance =
Appearance { effects: vec![fx("distort.transform", params.clone())], ..Appearance::basic(paint.clone(), Paint::None, 0.0) }.into();
let canvas = crate::evaluate_container(None, &outer).unwrap();
let mut d = Document::new(400.0, 400.0);
let layer = d.layers[0].id;
d.insert(Some(layer), 0, outer).unwrap();
let baked = bake_document(&d).unwrap();
let exported = baked.layers[0].children().and_then(|ch| ch.first()).cloned().expect("the export holds the group");
for (what, art) in [("canvas", &canvas), ("export", &*exported)] {
let case = format!("{what}, {params}, {}", if matches!(paint, Paint::Gradient(_)) { "gradient" } else { "solid" });
let (clip, _, strokes, _) = painted_clip(art).unwrap_or_else(|| panic!("{case}: no clip group in {art:?}"));
assert!(near_rect(clip, region), "{case}: the clip {clip:?} is the type's glyphs reshaped {region:?}");
let strokes = strokes.unwrap_or_else(|| panic!("{case}: no stroke art"));
assert!(strokes.x1 > region.x1 + 25.0, "{case}: the stroke {strokes:?} moves outside the clip {region:?}");
let mut fills = vec![];
own_fills(art, &paint, &mut fills);
assert!(!fills.is_empty(), "{case}: no fill art of the group in {art:?}");
let painted = fills.iter().filter_map(|f| f.geometric_bounds()).reduce(|a, b| a.union(b)).unwrap();
assert!(near_rect(painted, region), "{case}: the group's fill {painted:?} paints the clip {region:?}");
if let Paint::Gradient(_) = paint {
for fill in fills {
let geom = match fill.appearance.fill_paint() {
Paint::Gradient(g) => g.geom,
_ => None,
};
let geom = geom.unwrap_or_else(|| panic!("{case}: the gradient is not placed: {fill:?}"));
let (left, right) = (geom.start.x.min(geom.end.x), geom.start.x.max(geom.end.x));
assert!(
(left - region.x0).abs() < 0.5 && (right - region.x1).abs() < 0.5,
"{case}: the gradient {geom:?} spans the clip {region:?}"
);
}
}
}
}
}
#[test]
fn a_clip_groups_placed_gradient_follows_free_distort_by_the_clip_when_its_clipping_type_strokes() {
// A clip group with a placed linear gradient fill of its own, in a group with Free Distort,
// clipped by type whose stroke has a Transform effect moving it 60 pt right, outside the clip:
// the gradient moves and scales from the clip's bounds, as for the same clip group whose type
// does not stroke. The moved stroke adds nothing to those bounds.
use vectorcraft_color::{Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop};
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
let ramp = GradientPaint::new(Gradient::new(GradientKind::Linear, stops));
let geom = GradientGeom { start: (10.0, 45.0).into(), end: (30.0, 45.0).into(), aspect: 1.0, focal: None };
let placed = Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), ..ramp }));
fn placed_geom(n: &Node) -> Option<vectorcraft_color::GradientGeom> {
if let Paint::Gradient(g) = n.appearance.fill_paint()
&& g.geom.is_some()
{
return g.geom;
}
n.children().into_iter().flatten().find_map(|c| placed_geom(c))
}
let ends = |stroke: bool| {
let mut ty = painted_type(3, false, false);
if stroke {
ty.appearance = Appearance::basic(Paint::None, green(), 2.0).into();
for item in &mut ty.appearance.items {
if let vectorcraft_doc::AppearanceItem::Stroke(s) = item {
s.effects.push(fx("distort.transform", json!({"moveH": 60})));
}
}
}
let mut group = clip_group(2, ty);
group.appearance = Appearance::basic(placed.clone(), Paint::None, 0.0).into();
let mut outer = Node::group(NodeId(1), vec![Arc::new(group)]);
let corners = json!({"corners": [[1.0 / 3.0, 0.0], [4.0 / 3.0, 0.0], [1.0, 1.0], [0.0, 1.0]]});
outer.appearance.effects.push(fx("distort.freeDistort", corners));
let canvas = crate::evaluate_container(None, &outer).unwrap();
if stroke {
assert!(stroke_wrapper(&canvas).is_some(), "the type's stroke paints around the clip: {canvas:?}");
}
placed_geom(&canvas).unwrap_or_else(|| panic!("no placed gradient: {canvas:?}"))
};
let (plain, stroked) = (ends(false), ends(true));
assert!(
plain.start.distance(stroked.start) < 0.5 && plain.end.distance(stroked.end) < 0.5,
"the gradient {stroked:?} follows the clip as {plain:?} does"
);
}
+1 -1
View File
@@ -71,7 +71,7 @@ pub fn seg_cubic(sp: &SubPath, i: usize) -> CubicBez {
/// Non-linear path mapping (shared with live envelopes in `vectorcraft-doc`), and the split of
/// segments into pieces within an anchor budget.
pub use vectorcraft_doc::live::{fit_piece, map_nonlinear_within, map_smooth_within, pieces};
pub use vectorcraft_doc::live::{fit_piece, map_handles_within, map_nonlinear_within, pieces};
/// About how many lines the renderer flattens `path` into at 1 px/pt: one for a straight
/// segment, and for a curve the count Wang's formula gives at vello's tolerance of 0.25 px,
+6 -2
View File
@@ -59,6 +59,9 @@ chrono = { workspace = true }
craft-xml = { workspace = true }
# The compound file that holds a Word 97-2003 document placed as type (place/doc.rs).
cfb = "0.15"
# The Text Import Options character sets other than Unicode and ANSI (place/text.rs). Already in
# Cargo.lock (vectorcraft-eps), so this adds no new crate.
encoding_rs = { workspace = true }
kurbo = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
@@ -70,8 +73,9 @@ log = { workspace = true }
[target.'cfg(unix)'.dependencies]
rustix = { workspace = true, features = ["std", "process"] }
# Whether a recovery area's lock file is still the one that was opened (`FolderStore::still_named`).
# Already in Cargo.lock (walkdir), so this adds no new crate.
# Whether a recovery area's lock file is still the one that was opened (`FolderStore::still_named`),
# and whether two paths a script names are one file (`script::files`). Already in Cargo.lock
# (walkdir), so this adds no new crate.
[target.'cfg(windows)'.dependencies]
same-file = "1.0.6"
@@ -0,0 +1,154 @@
//! `cargo run --release -p vectorcraft-engine --example layer_select_bench` prints the time of a
//! Shift-click in the Layers panel's selection column (`layer.selectAll {id, add: true}`) on a layer of
//! 2,000, 20,000 and 50,000 rectangles, with all of its art selected (the click removes it) and with
//! every other object selected (the click adds the rest). Each case is timed one id at a time (`old`,
//! the loop the command used before, copied here) and in one pass (`new`), side by side in one
//! process: first the whole command, then the selection step alone. Each case checks that both give
//! the same selection and reply before it is timed.
//! `ITERS` sets the runs per case (default 7); each row is the median wall time in ms, followed by
//! every run of `old` and of `new`.
// Example (dev tool): unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::HashSet;
use std::hint::black_box;
use std::time::Instant;
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Document, Node, NodeId, Selection};
use vectorcraft_engine::Session;
use vectorcraft_geom::{Anchor, PathData, Point, SubPath};
fn iters() -> usize {
std::env::var("ITERS").ok().and_then(|v| v.parse().ok()).unwrap_or(7).max(1)
}
fn median(ms: &[f64]) -> f64 {
let mut ms = ms.to_vec();
ms.sort_by(f64::total_cmp);
ms[ms.len() / 2]
}
/// A document whose first layer holds `n` 10 pt squares in a row → (document, layer, squares).
fn squares(n: usize) -> (Document, NodeId, Vec<NodeId>) {
let mut doc = Document::new(1600.0, 1200.0);
let layer = doc.layers[0].id;
let ids = (0..n)
.map(|i| {
let (x, y) = ((i % 100) as f64 * 12.0, (i / 100) as f64 * 12.0);
let corners = [(x, y), (x + 10.0, y), (x + 10.0, y + 10.0), (x, y + 10.0)];
let path = PathData::single(SubPath::new(corners.iter().map(|&(x, y)| Anchor::corner(Point::new(x, y))).collect(), true));
let id = doc.alloc_id();
doc.insert(Some(layer), usize::MAX, Node::path(id, path, Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 1.0))).unwrap();
id
})
.collect();
(doc, layer, ids)
}
/// `layer.selectAll {id: layer, add: true}` before the change: the layer's art checked, removed or
/// added one id at a time with [`Selection::contains`], [`Selection::remove`] and [`Selection::add`].
fn old_command(s: &mut Session, layer: NodeId) -> Value {
let st = s.doc().unwrap();
let ids = st.doc.node(layer).unwrap().layer_art(true);
let all_selected = !ids.is_empty() && ids.iter().all(|i| st.selection.contains(*i));
let rows = st.layer_rows.clone();
s.select(|_, sel| old_step(sel, &ids, all_selected)).unwrap();
let st = s.doc_mut().unwrap();
st.layer_rows = rows;
json!({ "selected": st.selection.objects.iter().map(|i| i.0).collect::<Vec<_>>() })
}
fn old_step(sel: &mut Selection, ids: &[NodeId], all_selected: bool) {
for i in ids {
if all_selected { sel.remove(*i) } else { sel.add(*i) }
}
}
fn new_command(s: &mut Session, layer: NodeId) -> Value {
s.execute("layer.selectAll", &json!({"id": layer.0, "add": true})).unwrap()
}
/// Every run of `old` and of `new`, run in turn, each from `prepare`'s state.
fn time<S>(mut prepare: impl FnMut() -> S, old: impl Fn(&mut S), new: impl Fn(&mut S)) -> (Vec<f64>, Vec<f64>) {
let run = |s: &mut S, f: &dyn Fn(&mut S)| {
let t = Instant::now();
f(s);
t.elapsed().as_secs_f64() * 1000.0
};
let (mut olds, mut news) = (Vec::new(), Vec::new());
for _ in 0..iters() {
let mut s = prepare();
olds.push(run(&mut s, &old));
black_box(&s);
let mut s = prepare();
news.push(run(&mut s, &new));
black_box(&s);
}
(olds, news)
}
fn row(name: &str, (old, new): (Vec<f64>, Vec<f64>)) {
let (o, n) = (median(&old), median(&new));
let list = |ms: &[f64]| ms.iter().map(|m| format!("{m:.2}")).collect::<Vec<_>>().join(" ");
println!(" {name:<40} {o:>12.3} ms {n:>12.3} ms {:>9.1}x", o / n.max(1e-9));
println!(" old runs: {}", list(&old));
println!(" new runs: {}", list(&new));
}
fn main() {
println!(" {:<40} {:>15} {:>15} {:>10}", "case", "old", "new", "speedup");
for n in [2_000usize, 20_000, 50_000] {
println!("{n} objects");
let (doc, layer, ids) = squares(n);
let mut s = Session::new();
s.add_document(doc, None);
let mut all = Selection::default();
all.set(ids.iter().copied());
let mut half = Selection::default();
half.set(ids.iter().copied().step_by(2));
for (name, start) in [("all selected (removes)", &all), ("half selected (adds)", &half)] {
let reset = |s: &mut Session| {
let st = s.doc_mut().unwrap();
st.selection = start.clone();
st.layer_rows.clear();
};
// Both ways give the same selection and reply.
reset(&mut s);
let old_reply = old_command(&mut s, layer);
let old_sel = s.doc().unwrap().selection.clone();
reset(&mut s);
let new_reply = new_command(&mut s, layer);
assert_eq!(s.doc().unwrap().selection, old_sel, "{name}: the same selection");
assert_eq!(new_reply, old_reply, "{name}: the same reply");
let (mut olds, mut news) = (Vec::new(), Vec::new());
for _ in 0..iters() {
for (f, ms) in [(old_command as fn(&mut Session, NodeId) -> Value, &mut olds), (new_command, &mut news)] {
reset(&mut s);
let t = Instant::now();
black_box(f(&mut s, layer));
ms.push(t.elapsed().as_secs_f64() * 1000.0);
}
}
row(&format!("command, {name}"), (olds, news));
// The selection step alone, on a copy of the starting selection.
let art = s.doc().unwrap().doc.node(layer).unwrap().layer_art(true);
let selected: HashSet<NodeId> = start.objects.iter().copied().collect();
let all_selected = art.iter().all(|i| selected.contains(i));
let new_step = |sel: &mut Selection| {
if all_selected {
sel.remove_all(art.iter().copied());
} else {
sel.add_all(art.iter().copied());
}
};
let (mut a, mut b) = (start.clone(), start.clone());
old_step(&mut a, &art, all_selected);
new_step(&mut b);
assert_eq!(a, b, "{name}: the same selection step");
row(&format!("selection step, {name}"), time(|| start.clone(), |sel| old_step(sel, &art, all_selected), new_step));
}
}
}
+217
View File
@@ -0,0 +1,217 @@
//! `cargo run --release -p vectorcraft-engine --example link_colors_bench` prints the time
//! `Document::map_solid_paints_in` takes to link the paints of selected objects to swatches, as Add Used
//! Colors and New Color Group do for the selection with global swatches, on synthetic documents: 2,000 and
//! 20,000 rectangles in one layer, and 5,000 rectangles in 1,000 groups of groups, selected with and
//! without the groups that hold them. The fills and strokes use 50 colors, each with a swatch to link to.
//! For each it times two ways of finding the selected objects that no other selected object holds: a
//! search of the id list for each ancestor of each id, and a lookup of each ancestor in a set of the ids
//! (as `map_solid_paints_in` does). Both then link the same paints in the same loop. It checks that both
//! give the same count, visit the same paints in the same order and leave the same document as
//! `map_solid_paints_in` before it times them.
//! `ITERS` sets the runs per row (default 7); the two ways run in alternating order, each run links 10
//! fresh copies of the document, and each row is the median time of one call. On Linux the times are the CPU time of the main thread, which runs
//! everything, in ms; elsewhere they are wall times.
// Example (dev tool): unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::{HashMap, HashSet};
use std::hint::black_box;
use std::sync::Arc;
use std::time::Instant;
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::swatches::{LinkFn, map_node_solid_paints};
use vectorcraft_doc::{Appearance, Document, Node, NodeId};
use vectorcraft_geom::{Rect, shapes};
/// The colors the rectangles use, each with a swatch to link to.
const COLORS: usize = 50;
/// The calls in each timed run; a row gives the time of one call.
const REPS: usize = 10;
/// A way of finding the ids that no other listed id holds.
type Roots = fn(&Document, &[NodeId]) -> Vec<NodeId>;
/// A way of applying a link function to the paints of the listed ids, returning the count changed.
type Map<'a> = dyn FnMut(&mut Document, &[NodeId], &mut LinkFn) -> usize + 'a;
fn iters() -> usize {
std::env::var("ITERS").ok().and_then(|v| v.parse().ok()).unwrap_or(7).max(1)
}
fn median(mut ms: Vec<f64>) -> f64 {
ms.sort_by(f64::total_cmp);
ms[ms.len() / 2]
}
/// The CPU time of the calling thread in ns, from `/proc/thread-self/schedstat` (Linux only).
fn thread_cpu_ns() -> Option<u64> {
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
}
/// The time `f` takes, in ms: CPU time where the system reports it, wall time otherwise.
fn measure(f: impl FnOnce()) -> f64 {
match thread_cpu_ns() {
Some(start) => {
f();
thread_cpu_ns().map_or(f64::NAN, |end| end.saturating_sub(start) as f64 / 1e6)
}
None => {
let t = Instant::now();
f();
t.elapsed().as_secs_f64() * 1000.0
}
}
}
/// Color `i` of [`COLORS`]: each has its own red value.
fn color(i: usize) -> Color {
Color::rgb(i as f32 / COLORS as f32, 0.5, 0.25)
}
/// The bits of a color's red value, which tell the colors of [`color`] apart; `u32::MAX` for other color models.
fn red_bits(c: &Color) -> u32 {
match c {
Color::Rgb { r, .. } => r.to_bits(),
_ => u32::MAX,
}
}
/// The ids in the order given, less those with an ancestor in the list: a search of the list for each ancestor.
fn roots_by_search(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
ids.iter().copied().filter(|id| !d.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| ids.contains(p)))).collect()
}
/// [`roots_by_search`] with each ancestor looked up in a set of the ids.
fn roots_by_set(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
let listed: HashSet<NodeId> = ids.iter().copied().collect();
ids.iter().copied().filter(|id| !d.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| listed.contains(p)))).collect()
}
/// `f` applied to the paints of the subtrees of the ids `roots` finds, each node holding a changed
/// paint put in place: the work of `map_solid_paints_in`.
fn map_in(d: &mut Document, ids: &[NodeId], roots: Roots, f: &mut LinkFn) -> usize {
let mut n = 0;
for id in roots(d, ids) {
let Some(mut node) = d.node(id).cloned() else { continue };
let count = map_node_solid_paints(&mut node, f);
if count > 0
&& let Some(slot) = d.node_mut(id)
{
*slot = node;
n += count;
}
}
n
}
/// Link every paint whose color has a swatch to that swatch, as Add Used Colors does for global
/// swatches, recording each paint visited. Returns the count and the visits.
fn link(d: &mut Document, ids: &[NodeId], map: &mut Map) -> (usize, Vec<(Color, Option<String>)>) {
let names: HashMap<u32, String> = (0..COLORS).map(|i| (red_bits(&color(i)), format!("Swatch {i}"))).collect();
let mut visits = vec![];
let n = map(d, ids, &mut |c, s, _| {
visits.push((*c, s.clone()));
match names.get(&red_bits(c)) {
Some(name) if s.is_none() => {
*s = Some(name.clone());
true
}
_ => false,
}
});
(n, visits)
}
fn rect(d: &mut Document, i: usize) -> Arc<Node> {
let id = d.alloc_id();
let (x, y) = ((i % 100) as f64 * 12.0, (i / 100) as f64 * 12.0);
let r = shapes::rectangle(Rect::new(x, y, x + 10.0, y + 10.0));
let a = Appearance::basic(Paint::solid(color(i % COLORS)), Paint::solid(color((i + 7) % COLORS)), 1.0);
Arc::new(Node::path(id, r, a))
}
/// `n` rectangles in the first layer, all selected.
fn flat(n: usize) -> (Document, Vec<NodeId>) {
let mut d = Document::new(1600.0, 1200.0);
let l = d.layers[0].id;
let mut ids = vec![];
for i in 0..n {
let node = rect(&mut d, i);
ids.push(node.id);
d.insert(Some(l), usize::MAX, Arc::unwrap_or_clone(node)).unwrap();
}
(d, ids)
}
/// 1,000 groups in the first layer, each holding a group of 5 rectangles: the rectangles, and with
/// `groups` the two groups above each of them too, listed first.
fn nested(groups: bool) -> (Document, Vec<NodeId>) {
let mut d = Document::new(1600.0, 1200.0);
let l = d.layers[0].id;
let (mut outer_ids, mut leaves) = (vec![], vec![]);
for g in 0..1_000 {
let rects: Vec<Arc<Node>> = (0..5).map(|i| rect(&mut d, g * 5 + i)).collect();
leaves.extend(rects.iter().map(|r| r.id));
let inner = Node::group(d.alloc_id(), rects);
let outer = Node::group(d.alloc_id(), vec![Arc::new(inner.clone())]);
if groups {
outer_ids.extend([outer.id, inner.id]);
}
d.insert(Some(l), usize::MAX, outer).unwrap();
}
outer_ids.extend(leaves);
(d, outer_ids)
}
fn bench(name: &str, (doc, ids): (Document, Vec<NodeId>)) {
let mut shipped = doc.clone();
let want = link(&mut shipped, &ids, &mut |d, ids, f| d.map_solid_paints_in(ids, f));
for roots in [roots_by_search as Roots, roots_by_set] {
let mut d = doc.clone();
let got = link(&mut d, &ids, &mut |d, ids, f| map_in(d, ids, roots, f));
assert_eq!(got, want, "{name}: the same count and visits");
assert_eq!(d.layers, shipped.layers, "{name}: the same document");
}
let (mut old, mut new, mut real) = (vec![], vec![], vec![]);
let timed = |map: &mut Map| {
let mut docs = vec![doc.clone(); REPS];
measure(|| {
for d in &mut docs {
black_box(link(d, black_box(&ids), &mut *map));
}
}) / REPS as f64
};
for i in 0..iters() {
let run = |roots: Roots, out: &mut Vec<f64>| out.push(timed(&mut |d, ids, f| map_in(d, ids, roots, f)));
if i % 2 == 0 {
run(roots_by_search, &mut old);
run(roots_by_set, &mut new);
} else {
run(roots_by_set, &mut new);
run(roots_by_search, &mut old);
}
real.push(timed(&mut |d, ids, f| d.map_solid_paints_in(ids, f)));
}
let (old, new, real) = (median(old), median(new), median(real));
println!(" {name:<46} {:>7} {:>7} {old:>12.3} {new:>12.3} {real:>12.3} {:>8.1}x", ids.len(), want.0, old / new);
}
fn main() {
let unit = if thread_cpu_ns().is_some() { "CPU ms" } else { "wall ms" };
println!(
" {:<46} {:>7} {:>7} {:>12} {:>12} {:>12} {:>9}",
"document",
"ids",
"linked",
format!("search, {unit}"),
format!("set, {unit}"),
format!("shipped, {unit}"),
"speedup"
);
bench("2,000 rectangles in one layer", flat(2_000));
bench("20,000 rectangles in one layer", flat(20_000));
bench("5,000 rectangles in 1,000 groups of groups", nested(false));
bench("the same with the 2,000 groups listed first", nested(true));
}
@@ -0,0 +1,146 @@
//! `cargo run --release -p vectorcraft-engine --example stroke_targets_bench` prints the time `stroke.set`
//! takes to list its targets on documents of 2,000, 10,000 and 20,000 rectangles, all in one group. For
//! each size it times, on the same leaves, the merge that checks each leaf against the growing list and
//! the merge that checks it against a set, checks that the two lists are equal, and then times the whole
//! `stroke.set {weight: 3}` command twice: once with the group named and once with every rectangle named.
//! The whole-command rows include the document copy the command makes for undo; each run is undone
//! before the next, outside the timed part.
//! On Linux each row is the thread's CPU time, read from `/proc/thread-self/schedstat`; elsewhere
//! it is wall time, and the first line says which. `ITERS` sets the runs per row (default 7); each
//! row is the median in ms. A run of the two merge rows repeats the merge 1,000,000 / paths times
//! and gives the time of one.
// Example (dev tool): unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::HashSet;
use std::hint::black_box;
use std::time::Instant;
use serde_json::{Value, json};
use vectorcraft_color::Color;
use vectorcraft_doc::{Document, NodeId};
use vectorcraft_engine::Session;
use vectorcraft_geom::Rect;
use vectorcraft_testkit::fixtures::DocBuilder;
fn iters() -> usize {
std::env::var("ITERS").ok().and_then(|v| v.parse().ok()).unwrap_or(7).max(1)
}
/// The thread's CPU time in ns, or `None` where `/proc/thread-self/schedstat` cannot be read.
fn cpu_ns() -> Option<u64> {
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
}
/// The time `f` takes in ms: CPU time when [`cpu_ns`] reads, wall time otherwise.
fn ms(f: impl FnOnce()) -> f64 {
let (cpu, wall) = (cpu_ns(), Instant::now());
f();
match (cpu, cpu_ns()) {
(Some(a), Some(b)) => (b - a) as f64 / 1e6,
_ => wall.elapsed().as_secs_f64() * 1000.0,
}
}
fn median(mut v: Vec<f64>) -> f64 {
v.sort_by(f64::total_cmp);
v[v.len() / 2]
}
/// `n` 10 pt squares in one group, and the squares' ids in stacking order.
fn document(n: usize) -> (Document, NodeId, Vec<NodeId>) {
let mut b = DocBuilder::new(4000.0, 4000.0);
let kids: Vec<_> = (0..n)
.map(|i| {
let (x, y) = ((i % 200) as f64 * 12.0, (i / 200) as f64 * 12.0);
b.rect_node(Rect::new(x, y, x + 10.0, y + 10.0), Color::rgb(0.2, 0.4, 0.6))
})
.collect();
let leaves = kids.iter().map(|k| k.id).collect();
let group = b.group(kids, false);
(b.build(), group, leaves)
}
/// The merge that checks each leaf against the growing list.
fn listed(mut out: Vec<NodeId>, leaves: Vec<NodeId>) -> Vec<NodeId> {
for id in leaves {
if !out.contains(&id) {
out.push(id);
}
}
out
}
/// The merge that checks each leaf against a set seeded with `out`.
fn with_set(mut out: Vec<NodeId>, leaves: Vec<NodeId>) -> Vec<NodeId> {
let mut seen: HashSet<NodeId> = out.iter().copied().collect();
for id in leaves {
if seen.insert(id) {
out.push(id);
}
}
out
}
fn row(name: &str, ms: f64) {
println!(" {name:<52} {ms:>10.3} ms");
}
/// The median time of `stroke.set {weight: 3}` on `ids`, each run undone outside the timed part.
fn whole_command(s: &mut Session, ids: &[NodeId], n: usize) -> f64 {
let p: Value = json!({"ids": ids.iter().map(|id| id.0).collect::<Vec<_>>(), "weight": 3});
let runs = (0..iters())
.map(|_| {
let mut r = Value::Null;
let t = ms(|| r = black_box(s.execute("stroke.set", &p).unwrap()));
assert_eq!(r["objects"], n, "{r}");
s.execute("edit.undo", &json!({})).unwrap();
t
})
.collect();
median(runs)
}
fn bench(n: usize) {
println!("{n} paths in one group");
let (doc, group, leaves) = document(n);
// Each run merges `reps` times, on copies made before the clock starts, and gives the time of one.
let reps = (1_000_000 / n).max(1);
let time = |f: fn(Vec<NodeId>, Vec<NodeId>) -> Vec<NodeId>| -> (f64, Vec<NodeId>) {
let mut last = Vec::new();
let runs = (0..iters())
.map(|_| {
let mut work: Vec<Vec<NodeId>> = (0..reps).map(|_| leaves.clone()).collect();
let mut done = Vec::with_capacity(reps);
let t = ms(|| {
for input in &mut work {
done.push(f(Vec::new(), black_box(std::mem::take(input))));
}
});
last = done.pop().unwrap();
t / reps as f64
})
.collect();
(median(runs), last)
};
let (old, a) = time(listed);
let (new, b) = time(with_set);
assert_eq!(a, b, "both merges give the same list");
assert_eq!(a, leaves);
row("target merge, list search", old);
row("target merge, set", new);
println!(" {:<52} {:>10.1}x", "ratio", old / new);
let mut s = Session::new();
s.add_document(doc, None);
row("stroke.set, whole command, the group named", whole_command(&mut s, &[group], n));
row("stroke.set, whole command, every path named", whole_command(&mut s, &leaves, n));
}
fn main() {
println!("{}", if cpu_ns().is_some() { "thread CPU time, median of runs" } else { "wall time, median of runs" });
for n in [2_000, 10_000, 20_000] {
bench(n);
}
}
+3 -1
View File
@@ -821,10 +821,12 @@ pub(crate) fn unique_name_from(base: &str, next: &mut std::collections::HashMap<
pub(crate) const MAX_IMPORTED_PRESETS: usize = 1000;
pub(crate) use addons::{DecodedImages, refresh_color_masks};
/// Packaging Tools' blanks and the objects their print leaves out, for the Fold Preview window.
pub use addons::{fold_source, print_hidden};
/// Document Info's category titles and the Objects category's count labels.
pub use docinfo::{CATEGORIES, OBJECT_LABELS};
pub use docmenu::guide_indexes;
pub(crate) use edit::{settle_interaction, typing_in_progress};
pub(crate) use edit::{Unrecorded, 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, ParamsPlace, key_location, location_in, location_keys};
+1
View File
@@ -17,6 +17,7 @@ mod typetools;
mod units;
pub(crate) use image::{DecodedImages, refresh_color_masks};
pub use packaging::{fold_source, print_hidden};
pub(crate) use packaging::{role_swatch_edited, role_swatches_merged};
use super::CommandSpec;
@@ -6,8 +6,10 @@
//! (Object › Plug-ins › Packaging Tools) and its Fold Lines panel are the UI's.
mod check;
mod fold;
mod roles;
pub use fold::{fold_source, print_hidden};
pub(crate) use roles::{role_swatch_edited, role_swatches_merged};
use super::super::CommandSpec;
@@ -15,6 +17,7 @@ use super::super::CommandSpec;
pub fn specs() -> Vec<CommandSpec> {
let mut v = roles::specs();
v.extend(check::specs());
v.extend(fold::specs());
v
}
+63 -22
View File
@@ -4,7 +4,7 @@
use serde_json::{Value, json};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use vectorcraft_geom::PathData;
use vectorcraft_three_d::fold::{FoldLine, IssueCode, LineKind, MAX_SEGMENTS, blanks};
use vectorcraft_three_d::fold::{Blank, FoldLine, Issue, IssueCode, LineKind, MAX_SEGMENTS, blanks};
use super::super::super::pathops::length_given;
use super::super::super::{CommandSpec, bad, checked_ids_or_selection, cmd, has_doc, switch_or};
@@ -14,7 +14,7 @@ use crate::{Result, Session};
const CHECK: &str = "addon.packaging.check";
/// How far apart the ends of two lines may be and still be joined, in points.
const TOLERANCE: (f64, f64, f64) = (0.01, 0.1, 10.0);
pub(super) const TOLERANCE: (f64, f64, f64) = (0.01, 0.1, 10.0);
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
@@ -101,23 +101,44 @@ fn kind(role: Role) -> LineKind {
}
}
fn check(s: &mut Session, p: &Value) -> Result<Value> {
let select = switch_or(p, "select", false, CHECK)?;
let tolerance = match length_given(p, "tolerance", CHECK)? {
None => TOLERANCE.1,
Some(t) if (TOLERANCE.0..=TOLERANCE.2).contains(&t) => t,
Some(_) => return Err(bad(CHECK, format!("`tolerance` must be from {} to {} pt", TOLERANCE.0, TOLERANCE.2))),
};
/// The fold lines a check or a fold reads: where they came from (`ids`, `selection` or
/// `document`), the lines, and the ids of those on a non-printing layer.
pub(super) struct Lines {
pub scope: &'static str,
pub lines: Vec<FoldLine>,
pub non_printing: Vec<u64>,
}
/// The tolerance `p` gives for `cmd`, or the default.
pub(super) fn tolerance(p: &Value, cmd: &str) -> Result<f64> {
match length_given(p, "tolerance", cmd)? {
None => Ok(TOLERANCE.1),
Some(t) if (TOLERANCE.0..=TOLERANCE.2).contains(&t) => Ok(t),
Some(_) => Err(bad(cmd, format!("`tolerance` must be from {} to {} pt", TOLERANCE.0, TOLERANCE.2))),
}
}
/// The fold lines among the objects `p` names for `cmd` (`ids`, else the selection), or, while
/// nothing is selected and `ids` is left out, every shown fold line of the document. Hidden lines
/// are left out in every scope, members of a selected group included.
pub(super) fn lines(s: &Session, p: &Value, cmd: &str) -> Result<Lines> {
let given = p.get("ids").is_some_and(|v| !v.is_null());
let roots = checked_ids_or_selection(s, p, CHECK)?;
let roots = checked_ids_or_selection(s, p, cmd)?;
let d = &s.doc()?.doc;
// Hidden lines are left out in every scope, members of a selected group included.
let shown = |ids: Vec<NodeId>| ids.into_iter().filter(|id| d.is_visible(*id)).collect::<Vec<_>>();
let (scope, targets) = match (given, roots.is_empty()) {
(true, _) => ("ids", shown(role_targets(d, &roots, false).0)),
(false, false) => ("selection", shown(role_targets(d, &roots, false).0)),
(false, true) => ("document", shown_targets(d)),
};
Ok(match (given, roots.is_empty()) {
(true, _) => lines_of(d, "ids", shown(role_targets(d, &roots, false).0)),
(false, false) => lines_of(d, "selection", shown(role_targets(d, &roots, false).0)),
(false, true) => document_lines(d),
})
}
/// Every shown fold line of `d`.
pub(super) fn document_lines(d: &Document) -> Lines {
lines_of(d, "document", shown_targets(d))
}
fn lines_of(d: &Document, scope: &'static str, targets: Vec<NodeId>) -> Lines {
let table = RoleTable::of(d);
let mut lines = vec![];
let mut non_printing = vec![];
@@ -136,12 +157,21 @@ fn check(s: &mut Session, p: &Value) -> Result<Value> {
segments = segments.saturating_add(path.subpaths.iter().map(|sp| sp.segment_count()).sum());
lines.push(FoldLine { path, kind: kind(role), key: id.0 });
}
let (found, mut issues) = blanks(&lines, tolerance);
if !non_printing.is_empty() {
issues.push(vectorcraft_three_d::fold::Issue { code: IssueCode::NonPrinting, keys: non_printing, at: None });
Lines { scope, lines, non_printing }
}
/// The blanks `lines` make and their issues, the non-printing one last.
pub(super) fn found(lines: &Lines, tolerance: f64) -> (Vec<Blank>, Vec<Issue>) {
let (found, mut issues) = blanks(&lines.lines, tolerance);
if !lines.non_printing.is_empty() {
issues.push(Issue { code: IssueCode::NonPrinting, keys: lines.non_printing.clone(), at: None });
}
let ok = !issues.iter().any(|i| i.code.is_error());
let rows: Vec<Value> = issues
(found, issues)
}
/// `issues` as the rows `addon.packaging.check` and `addon.packaging.fold` answer with.
pub(super) fn issue_rows(issues: &[Issue], scope: &str) -> Vec<Value> {
issues
.iter()
.map(|i| {
let mut row = json!({
@@ -155,7 +185,18 @@ fn check(s: &mut Session, p: &Value) -> Result<Value> {
}
row
})
.collect();
.collect()
}
fn check(s: &mut Session, p: &Value) -> Result<Value> {
let select = switch_or(p, "select", false, CHECK)?;
let tolerance = tolerance(p, CHECK)?;
let lines = lines(s, p, CHECK)?;
let scope = lines.scope;
let (found, issues) = found(&lines, tolerance);
let d = &s.doc()?.doc;
let ok = !issues.iter().any(|i| i.code.is_error());
let rows = issue_rows(&issues, scope);
if select {
let mut ids: Vec<NodeId> = issues.iter().flat_map(|i| i.keys.iter().map(|k| NodeId(*k))).filter(|id| d.node(*id).is_some()).collect();
ids.sort_unstable_by_key(|id| id.0);
@@ -0,0 +1,110 @@
//! Fold Preview's model (`addon.packaging.fold`): a blank folded into its 3D shape by
//! [`vectorcraft_three_d::fold::fold`], and what the Fold Preview window needs to draw it: the
//! document's blanks ([`fold_source`]) and the objects its print leaves out ([`print_hidden`]).
use serde_json::{Value, json};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use vectorcraft_three_d::fold::{Blank, Issue, fold, pick};
use super::super::super::{CommandSpec, bad, cmd, finite_numbers, has_doc, number_or};
use super::check::{TOLERANCE, document_lines, found, issue_rows, lines, tolerance};
use super::roles::{RoleTable, can_carry};
use crate::{Result, Session};
const FOLD: &str = "addon.packaging.fold";
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
query "addon.packaging.fold",
"Fold",
[],
None,
"{ids?: [id…] (default: the selection), base?: [x, y] (the panel under this point; default: the largest panel), amount?: 0..1 (1), tolerance?: pt 0.01..10 (0.1)} fold the blank that the fold lines among the objects make (as addon.packaging.check finds them; while nothing is selected and ids is left out, every fold line of the document) into its 3D shape. The base panel stays in place; every other panel turns about the hinges that join it to the base, each by its angle times amount: a Crease or a Perforation by 90° away from the printed side, a Partial Cut by 90° toward it. Hinges that close a loop of panels are not turned about: gap is how far apart their two placements end up when every hinge is folded all the way, whatever amount is, and closes is true within tolerance or 0.5% of the hinge's length. Changes nothing in the document → {ok (no error), blank (the index of the blank folded, or null when none is), blanks, base, panels: [{outline (SVG path data, document coordinates), frame: {x, y, z, origin} (where the flat blank's x and y directions, its printed side and its origin go, in points: x right, y up, z toward the printed side of the flat blank), parent (null for the base and loose panels), depth}], hinges: [{a, b, angle (degrees), kind: tree|closing, closes, gap}], collisions: [[a, b]] (panels that pass through each other; panels stacked in one plane do not), issues (as addon.packaging.check)}. Errors: a base point in no panel",
has_doc,
fold_command
)]
}
/// The blanks the shown fold lines of `d` make, and their issues (`addon.packaging.check` on the
/// whole document): what the Fold Preview window folds.
pub fn fold_source(d: &Document) -> (Vec<Blank>, Vec<Issue>) {
found(&document_lines(d), TOLERANCE.1)
}
/// The objects the print on a folded blank leaves out: the layers that do not print and, unless
/// `fold_lines`, every object with a line role.
pub fn print_hidden(d: &Document, fold_lines: bool) -> Vec<NodeId> {
fn walk(n: &Node, table: &RoleTable, fold_lines: bool, out: &mut Vec<NodeId>) {
match &n.kind {
NodeKind::Layer { printable: false, .. } => out.push(n.id),
NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } => children.iter().for_each(|c| walk(c, table, fold_lines, out)),
_ if !fold_lines && can_carry(n) && table.role_of(n).is_some() => out.push(n.id),
_ => {}
}
}
let table = RoleTable::of(d);
let mut out = vec![];
d.layers.iter().for_each(|l| walk(l, &table, fold_lines, &mut out));
out
}
fn fold_command(s: &mut Session, p: &Value) -> Result<Value> {
let tolerance = tolerance(p, FOLD)?;
let amount = number_or(p, "amount", 1.0, FOLD)?;
if !(0.0..=1.0).contains(&amount) {
return Err(bad(FOLD, "`amount` must be from 0 to 1"));
}
let base = match p.get("base") {
None | Some(Value::Null) => None,
Some(v) => {
let [x, y] = finite_numbers::<2>(v).ok_or_else(|| bad(FOLD, "`base` must be a point: [x, y]"))?;
Some(vectorcraft_geom::Point::new(x, y))
}
};
let lines = lines(s, p, FOLD)?;
let (blanks, issues) = found(&lines, tolerance);
let ok = !issues.iter().any(|i| i.code.is_error());
let picked = pick(&blanks, base);
if base.is_some() && picked.is_none() {
return Err(bad(FOLD, "`base` is in no panel"));
}
let folded = picked.and_then(|(b, panel)| Some((b, blanks.get(b)?, fold(blanks.get(b)?, Some(panel), amount, tolerance)?)));
let Some((index, blank, f)) = folded else {
return Ok(json!({
"ok": ok, "blank": null, "blanks": blanks.len(), "base": null, "panels": [], "hinges": [], "collisions": [],
"issues": issue_rows(&issues, lines.scope),
}));
};
let column = |m: &[[f64; 3]; 3], k: usize| json!([m[0][k], m[1][k], m[2][k]]);
let panels: Vec<Value> = blank
.panels
.iter()
.zip(&f.panels)
.map(|(panel, placed)| {
json!({
"outline": panel.outline.to_bezpath().to_svg(),
"frame": {"x": column(&placed.pose.m, 0), "y": column(&placed.pose.m, 1), "z": column(&placed.pose.m, 2), "origin": placed.pose.t},
"parent": placed.parent,
"depth": placed.depth,
})
})
.collect();
let hinges: Vec<Value> = f
.hinges
.iter()
.map(|h| json!({"a": h.a, "b": h.b, "angle": h.angle, "kind": if h.tree { "tree" } else { "closing" }, "closes": h.closes, "gap": h.gap}))
.collect();
Ok(json!({
"ok": ok,
"blank": index,
"blanks": blanks.len(),
"base": f.base,
"panels": panels,
"hinges": hinges,
"collisions": f.collisions.iter().map(|(a, b)| [a, b]).collect::<Vec<_>>(),
"issues": issue_rows(&issues, lines.scope),
}))
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,157 @@
//! Tests for the Fold Preview's model: a blank drawn in a document folded into its 3D shape.
use serde_json::{Value, json};
use crate::*;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 600, "height": 600})).unwrap();
s
}
fn path(s: &mut Session, d: &str) -> u64 {
s.execute("path.create", &json!({ "d": d })).unwrap()["id"].as_u64().unwrap()
}
fn role(s: &mut Session, role: &str, ids: &[u64]) {
s.execute("addon.packaging.setRole", &json!({ "role": role, "ids": ids })).unwrap();
}
fn fold(s: &mut Session, p: Value) -> Value {
s.execute("addon.packaging.fold", &p).unwrap()
}
/// A tray blank: a 100 pt base (x 140 to 240, y 140 to 240) with a 40 pt wall on each side →
/// (outline, creases).
fn tray(s: &mut Session) -> (u64, Vec<u64>) {
let outline = path(s, "M140 100 L240 100 L240 140 L280 140 L280 240 L240 240 L240 280 L140 280 L140 240 L100 240 L100 140 L140 140 Z");
let creases = vec![path(s, "M140 140 L240 140"), path(s, "M240 140 L240 240"), path(s, "M240 240 L140 240"), path(s, "M140 240 L140 140")];
role(s, "cut", &[outline]);
role(s, "crease", &creases);
s.execute("select.none", &json!({})).unwrap();
(outline, creases)
}
fn vector(v: &Value) -> [f64; 3] {
let a = v.as_array().unwrap();
[a[0].as_f64().unwrap(), a[1].as_f64().unwrap(), a[2].as_f64().unwrap()]
}
/// The middle of the bounds of the points of SVG path data `d` (absolute moves and lines only).
fn middle(d: &str) -> [f64; 2] {
let n: Vec<f64> = d.split(|c: char| !(c.is_ascii_digit() || c == '.' || c == '-')).filter_map(|t| t.parse().ok()).collect();
let span = |k: usize| n.iter().skip(k).step_by(2).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), &t| (lo.min(t), hi.max(t)));
let ((x0, x1), (y0, y1)) = (span(0), span(1));
[(x0 + x1) / 2.0, (y0 + y1) / 2.0]
}
fn near(a: [f64; 3], b: [f64; 3]) -> bool {
a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9)
}
#[test]
fn a_tray_folds_its_walls_up_round_the_base() {
let mut s = session();
tray(&mut s);
let steps = s.doc().unwrap().history.undo.len();
let r = fold(&mut s, json!({}));
assert_eq!((r["ok"].as_bool(), r["blank"].as_u64(), r["blanks"].as_u64()), (Some(true), Some(0), Some(1)), "{r}");
let panels = r["panels"].as_array().unwrap();
assert_eq!(panels.len(), 5);
let base = r["base"].as_u64().unwrap() as usize;
let frame = &panels[base]["frame"];
assert!(
near(vector(&frame["x"]), [1.0, 0.0, 0.0]) && near(vector(&frame["z"]), [0.0, 0.0, 1.0]) && near(vector(&frame["origin"]), [0.0; 3]),
"{frame}"
);
assert!(panels[base]["parent"].is_null());
assert!(panels[base]["outline"].as_str().unwrap().starts_with('M'), "SVG path data");
for (i, p) in panels.iter().enumerate().filter(|(i, _)| *i != base) {
assert_eq!((p["parent"].as_u64(), p["depth"].as_u64()), (Some(base as u64), Some(1)), "{p}");
// Each wall stands square to the base, below it (away from the print), its print facing out:
// away from the base's middle (190, 190), toward the side the wall lies on.
let [cx, cy] = middle(p["outline"].as_str().unwrap());
let (x, y, o) = (vector(&p["frame"]["x"]), vector(&p["frame"]["y"]), vector(&p["frame"]["origin"]));
let placed: [f64; 3] = std::array::from_fn(|k| o[k] + x[k] * cx - y[k] * cy);
let (dx, dy) = (cx - 190.0, 190.0 - cy);
let out = if dx.abs() > dy.abs() { [dx.signum(), 0.0, 0.0] } else { [0.0, dy.signum(), 0.0] };
assert!(near(vector(&p["frame"]["z"]), out), "wall {i}: {p}");
assert!((placed[2] + 20.0).abs() < 1e-9, "wall {i}'s middle is 20 pt below the base: {placed:?}");
}
let hinges = r["hinges"].as_array().unwrap();
assert_eq!(hinges.len(), 4);
assert!(hinges.iter().all(|h| h["kind"] == "tree" && h["angle"] == 90.0 && h["closes"] == true), "{r}");
assert_eq!(r["collisions"], json!([]));
assert_eq!(s.doc().unwrap().history.undo.len(), steps, "a fold records no undo step");
// Flat, every frame is the flat blank's own.
let r = fold(&mut s, json!({ "amount": 0 }));
for p in r["panels"].as_array().unwrap() {
assert!(near(vector(&p["frame"]["z"]), [0.0, 0.0, 1.0]) && near(vector(&p["frame"]["origin"]), [0.0; 3]), "{p}");
}
}
#[test]
fn the_base_is_the_panel_under_a_point() {
let mut s = session();
tray(&mut s);
// The left wall: x 100 to 140, y 140 to 240.
let r = fold(&mut s, json!({ "base": [120, 190] }));
let base = r["base"].as_u64().unwrap() as usize;
let panels = r["panels"].as_array().unwrap();
assert!(near(vector(&panels[base]["frame"]["z"]), [0.0, 0.0, 1.0]));
// The tray's base is now a child of the wall, and the other walls its children.
let depths: Vec<u64> = panels.iter().map(|p| p["depth"].as_u64().unwrap()).collect();
let mut sorted = depths.clone();
sorted.sort_unstable();
assert_eq!(sorted, [0, 1, 2, 2, 2], "{depths:?}");
let e = s.execute("addon.packaging.fold", &json!({ "base": [10, 10] })).unwrap_err().to_string();
assert!(e.contains("`base` is in no panel"), "{e}");
}
#[test]
fn bad_values_are_refused() {
let mut s = session();
tray(&mut s);
for (p, want) in [
(json!({ "amount": 1.5 }), "`amount` must be from 0 to 1"),
(json!({ "amount": -0.1 }), "`amount` must be from 0 to 1"),
(json!({ "amount": "1" }), "`amount` must be a number"),
(json!({ "base": [1] }), "`base` must be a point"),
(json!({ "base": "middle" }), "`base` must be a point"),
(json!({ "tolerance": 50 }), "`tolerance` must be from"),
] {
let e = s.execute("addon.packaging.fold", &p).unwrap_err().to_string();
assert!(e.contains(want), "{p}: {e}");
}
}
#[test]
fn without_a_blank_nothing_is_folded_and_the_issues_say_why() {
let mut s = session();
let r = fold(&mut s, json!({}));
assert_eq!((r["ok"].as_bool(), r["blank"].is_null(), r["blanks"].as_u64()), (Some(false), true, Some(0)), "{r}");
assert_eq!(r["panels"], json!([]));
assert_eq!(r["issues"][0]["code"], "noCut");
}
#[test]
fn the_print_leaves_out_fold_lines_and_layers_that_do_not_print() {
let mut s = session();
let (outline, creases) = tray(&mut s);
let art = path(&mut s, "M150 150 L200 150 L200 200 Z");
let notes = s.execute("layer.new", &json!({})).unwrap()["id"].as_u64().unwrap();
s.execute("layer.setProps", &json!({"id": notes, "printable": false})).unwrap();
let d = &s.doc().unwrap().doc;
let hidden: Vec<u64> = cmd::print_hidden(d, false).into_iter().map(|id| id.0).collect();
for id in creases.iter().chain([&outline, &notes]) {
assert!(hidden.contains(id), "{id} in {hidden:?}");
}
assert!(!hidden.contains(&art));
let shown: Vec<u64> = cmd::print_hidden(d, true).into_iter().map(|id| id.0).collect();
assert_eq!(shown, vec![notes], "with the fold lines shown, only the layer is left out");
let (blanks, issues) = cmd::fold_source(d);
assert_eq!((blanks.len(), blanks[0].panels.len()), (1, 5));
assert!(issues.is_empty(), "{issues:?}");
}
+8 -1
View File
@@ -121,7 +121,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Separations Preview",
[],
None,
"{on?: bool, plates?: [names], toggle?: plate, only?: plate} Separations Preview: show the chosen plates (one plate = greyscale ink coverage) → {on, plates: [{name, spot, visible, rgb}]}",
"{on?: bool, plates?: [names], toggle?: plate, only?: plate, soloToggle?: plate (only that plate, or every plate when it is the only one shown)} Separations Preview: show the chosen plates (one plate = grayscale ink coverage) → {on, plates: [{name, spot, visible, rgb}]}",
always,
separations
),
@@ -1055,6 +1055,13 @@ fn separations(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(n) = text_param(p, "only", C)? {
v.separations = Some(vec![check(n)?]);
}
// The panel's Alt-click on a plate's eye: that plate alone, or every plate when it already
// shows alone among the active document's plates.
if let Some(n) = text_param(p, "soloToggle", C)? {
let n = check(n)?;
let alone = v.separations.as_ref().is_some_and(|vis| all.iter().filter(|a| vis.contains(a)).eq([&n]));
v.separations = Some(if alone { all.clone() } else { vec![n] });
}
if let Some(n) = text_param(p, "toggle", C)? {
let n = check(n)?;
let vis = v.separations.get_or_insert_with(|| all.clone());
+15 -17
View File
@@ -62,7 +62,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Circle Through Points",
[],
None,
"{points?: [[x, y], [x, y], [x, y]] (left out: the three selected anchor points, where a path selected whole counts all its anchors and selected segments' ends do not count)} → {id, cx, cy, radius}: a circle with the current paint whose edge passes through the three points, not pixel-aligned even while Align New Objects to Pixel Grid is on; two points that are the same or three on one line are an error, and nothing is drawn",
"{points?: [[x, y], [x, y]] or [[x, y], [x, y], [x, y]] (two: the ends of a diameter; left out: the two or three selected anchor points, where a path selected whole counts all its anchors and selected segments' ends do not count)} → {id, cx, cy, radius}: a circle with the current paint whose edge passes through the points, not pixel-aligned even while Align New Objects to Pixel Grid is on; two points that are the same, three on one line, or a circle reaching past the canvas are an error, and nothing is drawn",
has_doc,
circle_through_points
),
@@ -413,16 +413,16 @@ fn ellipse(s: &mut Session, p: &Value) -> Result<Value> {
add_art_turned(s, "Ellipse", path_kind(live.to_path(), Some(live)), rotation)
}
/// A live ellipse whose edge passes through three points: `points`, or the three selected anchor
/// points ([`selected_anchor_points`]). One undo step, named as an Ellipse tool drag is.
/// A live ellipse whose edge passes through two or three points: `points`, or the two or three
/// selected anchor points ([`selected_anchor_points`]). Two points are the ends of a diameter. One
/// undo step, named as an Ellipse tool drag is.
fn circle_through_points(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "shape.circleThroughPoints";
let points = match p.get("points").filter(|v| !v.is_null()) {
Some(v) => three_points(v).ok_or_else(|| bad(C, "`points` must be three [x, y] pairs of numbers"))?,
None => selected_anchor_points(s)?.ok_or_else(|| bad(C, "direct-select three anchor points, or give `points`"))?,
Some(v) => two_or_three_points(v).ok_or_else(|| bad(C, "`points` must be two or three [x, y] pairs of numbers"))?,
None => selected_anchor_points(s)?.ok_or_else(|| bad(C, "direct-select two or three anchor points, or give `points`"))?,
};
let [a, b, c] = points;
let (center, radius) = shapes::circle_through(a, b, c)
let (center, radius) = shapes::circle_through_points(&points)
.ok_or_else(|| bad(C, "no circle passes through these points: two are the same or all three lie on one line"))?;
let r = Rect::new(center.x - radius, center.y - radius, center.x + radius, center.y + radius);
let live = LiveShape::Ellipse { w: r.width(), h: r.height(), pie: (0.0, 360.0), xf: Affine::translate(r.origin().to_vec2()) };
@@ -434,24 +434,25 @@ fn circle_through_points(s: &mut Session, p: &Value) -> Result<Value> {
Ok(out)
}
/// The three points `[[x, y], [x, y], [x, y]]` holds, each pair two finite numbers.
fn three_points(v: &Value) -> Option<[Point; 3]> {
/// The two or three points `[[x, y], [x, y]]` or `[[x, y], [x, y], [x, y]]` holds, each pair two
/// finite numbers.
fn two_or_three_points(v: &Value) -> Option<Vec<Point>> {
let pair = |v: &Value| match v.as_array().map(Vec::as_slice) {
Some([x, y]) => x.as_f64().zip(y.as_f64()).filter(|(x, y)| x.is_finite() && y.is_finite()).map(|(x, y)| Point::new(x, y)),
_ => None,
};
match v.as_array().map(Vec::as_slice) {
Some([a, b, c]) => Some([pair(a)?, pair(b)?, pair(c)?]),
match v.as_array() {
Some(pairs) if matches!(pairs.len(), 2 | 3) => pairs.iter().map(pair).collect(),
_ => None,
}
}
/// The positions of the selected anchor points, when there are exactly three. They are counted as
/// The positions of the selected anchor points, when there are two or three. They are counted as
/// the other anchor commands count them ([`super::path::anchor_targets`]): a selected path with
/// anchors picked by Direct Selection gives those, and a path selected whole gives all of its own.
/// A selected segment's ends are not selected anchor points, so a selection with segments gives
/// none; so does a selection holding an object that is not a path, or an anchor that is gone.
fn selected_anchor_points(s: &Session) -> Result<Option<[Point; 3]>> {
fn selected_anchor_points(s: &Session) -> Result<Option<Vec<Point>>> {
let st = s.doc()?;
if st.selection.segments.values().any(|set| !set.is_empty()) {
return Ok(None);
@@ -472,10 +473,7 @@ fn selected_anchor_points(s: &Session) -> Result<Option<[Point; 3]>> {
return Ok(None);
}
}
Ok(match points.as_slice() {
&[a, b, c] => Some([a, b, c]),
_ => None,
})
Ok(matches!(points.len(), 2 | 3).then_some(points))
}
/// The whole-number count `p` gives for `key` (`5` or `5.0`), or `default` when it is left out or
+88 -12
View File
@@ -16,7 +16,7 @@ use vectorcraft_tools::distort::{PinSet, arap, collect_points, mesh_for, project
use super::edit::{duplicate_in, outermost, refuse_symbol_part, selected_roots};
use super::{
CommandSpec, Result, Session, bad, check_numbers, check_switches, cmd, f64_or, f64_req, finite_numbers, has_doc, has_selection, matrix_param,
named_id, named_ids, number_or, object_param, ok, point_indices, point_param, str_param, switch_or, targets,
named_id, named_ids, number_or, object_param, ok, point_indices, point_param, str_param, switch_or, targets, text_param, u64_req,
};
use crate::EngineError;
@@ -35,7 +35,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Width Point",
[],
None,
"{id, t: 0..1 (fraction of the path length), left, right: side widths in pt, index?: width point to edit or move, adjustAdjoining?: bool (the nearest points either side change their widths in proportion, using the sampled widths for a new point)} → {index}. Without index a point already at t is replaced; a point moved onto another one's t joins it as a discontinuous point (on the side it came from), so the width steps there. Creates a uniform profile first if needed",
"{id, t: 0..1 (fraction of the path length), left, right: side widths in pt, index?: width point to edit or move, adjustAdjoining?: bool (the nearest points either side change their widths in proportion, using the sampled widths for a new point), outIndex?, outLeft, outRight: the outgoing half of the discontinuous point whose incoming half is index, single?: \"incoming\" | \"outgoing\"} → {index}. Without index a point already at t is replaced; a point moved onto another one's t joins it as a discontinuous point (on the side it came from), so the width steps there. With outIndex both halves change in one step and keep their place (t must be theirs); adjustAdjoining then changes the nearest point before from the incoming half and the nearest point after from the outgoing half. single keeps only that half's widths, leaving one continuous point. Creates a uniform profile first if needed",
has_doc,
width_point_set
),
@@ -214,6 +214,15 @@ fn uniform() -> WidthProfile {
/// Width points closer than this (in t) are at the same place: a discontinuous point.
const SAME_T: f64 = 1e-6;
/// The outgoing half of the discontinuous width point whose incoming half is point `a`: point `a`
/// and the next one are the two halves when they are the only points within 1e-6 (in t) of `a`'s
/// place. None when `a` is out of range or not such an incoming half.
pub fn width_point_pair(points: &[(f64, f64, f64)], a: usize) -> Option<usize> {
let t = points.get(a)?.0;
let at: Vec<usize> = (0..points.len()).filter(|i| (points[*i].0 - t).abs() <= SAME_T).collect();
(at == [a, a + 1]).then_some(a + 1)
}
/// The stroke of `id` that width point commands edit (a compound path's for its members).
fn stroke_mut(d: &mut Document, id: NodeId) -> Result<&mut vectorcraft_doc::StrokeLayer> {
let id = stroke_owner(d, id);
@@ -265,9 +274,9 @@ fn place(points: &mut Vec<(f64, f64, f64)>, mut pt: (f64, f64, f64), from_below:
}
/// Adjust Adjoining Width Points: point `i` changes from `old` to `new` widths, and the nearest
/// points at other positions either side change in proportion (by the same amount from zero).
fn adjust_adjoining(points: &mut [(f64, f64, f64)], i: usize, old: (f64, f64, f64), new: (f64, f64, f64)) {
let t = points[i].0;
/// points farther than [`SAME_T`] from place `t` on the sides `sides` names (before, after)
/// change in proportion (by the same amount from zero).
fn adjust_adjoining(points: &mut [(f64, f64, f64)], i: usize, t: f64, old: (f64, f64, f64), new: (f64, f64, f64), sides: [bool; 2]) {
let scale = |v: f64, o: f64, n: f64| {
let width = if o > 1e-9 {
let product = v * n;
@@ -284,8 +293,8 @@ fn adjust_adjoining(points: &mut [(f64, f64, f64)], i: usize, old: (f64, f64, f6
};
width.max(0.0)
};
let before = (0..i).rev().find(|j| (points[*j].0 - t).abs() > SAME_T);
let after = (i + 1..points.len()).find(|j| (points[*j].0 - t).abs() > SAME_T);
let before = (0..i).rev().find(|j| (points[*j].0 - t).abs() > SAME_T).filter(|_| sides[0]);
let after = (i + 1..points.len()).find(|j| (points[*j].0 - t).abs() > SAME_T).filter(|_| sides[1]);
for j in before.into_iter().chain(after) {
let q = &mut points[j];
(q.1, q.2) = (scale(q.1, old.1, new.1), scale(q.2, old.2, new.2));
@@ -303,6 +312,46 @@ fn same_points(a: Option<&WidthProfile>, b: Option<&WidthProfile>) -> bool {
}
}
/// Set both halves of the discontinuous point whose incoming half is `i` and outgoing half `j` to
/// the widths of `inc` and `out` (their places are ignored: the point keeps its place). With
/// `single` (`true` for the outgoing half) only that half's widths remain, as one continuous point.
/// With `adjust`, the nearest point before changes with the incoming half and the nearest point after
/// with the outgoing half, once each. → the index of the point (its incoming half).
fn set_pair(
points: &mut Vec<(f64, f64, f64)>,
(i, inc): (usize, (f64, f64, f64)),
(j, out): (usize, (f64, f64, f64)),
adjust: bool,
single: Option<bool>,
) -> Result<usize> {
const C: &str = "stroke.widthPoint.set";
if width_point_pair(points, i) != Some(j) {
return Err(bad(C, "`index` and `outIndex` must be the two halves of one discontinuous width point"));
}
let at = points[i].0;
let (old_in, old_out) = (points[i], points[j]);
if (old_in.0 - inc.0).abs() > SAME_T {
return Err(bad(C, "a discontinuous width point keeps its place"));
}
let (new_in, new_out) = match single {
None => ((old_in.0, inc.1, inc.2), (old_out.0, out.1, out.2)),
Some(false) => ((old_in.0, inc.1, inc.2), (old_in.0, inc.1, inc.2)),
Some(true) => ((old_in.0, out.1, out.2), (old_in.0, out.1, out.2)),
};
// Both halves measure their neighbors from the point's place, so a point within SAME_T of the
// outgoing half but not of that place is the point after the pair.
if adjust {
adjust_adjoining(points, i, at, old_in, new_in, [true, false]);
adjust_adjoining(points, j, at, old_out, new_out, [false, true]);
}
points[i] = new_in;
points[j] = new_out;
if single.is_some() {
points.remove(j);
}
Ok(i)
}
fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "stroke.widthPoint.set";
let id = object_param(p, "id", C)?.ok_or_else(|| bad(C, "missing id"))?;
@@ -312,6 +361,25 @@ fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad(C, "left/right must be non-negative widths"));
}
let adjust = switch_or(p, "adjustAdjoining", false, C)?;
let single = match text_param(p, "single", C)? {
None => None,
Some(side @ ("incoming" | "outgoing")) => Some(side == "outgoing"),
Some(_) => return Err(bad(C, "`single` must be `incoming` or `outgoing`")),
};
// The outgoing half of a discontinuous point: its index and side widths (points).
// `single`, `outLeft` or `outRight` without `outIndex` is refused as a missing `outIndex`.
let out_widths = ["outLeft", "outRight"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null()));
let out = match p.get("outIndex") {
None | Some(Value::Null) if single.is_none() && !out_widths => None,
_ => {
let j = usize::try_from(u64_req(p, "outIndex", C)?).map_err(|_| bad(C, "no such width point"))?;
let (l, r) = (f64_req(p, "outLeft", C)?, f64_req(p, "outRight", C)?);
if !(l.is_finite() && r.is_finite()) || l < 0.0 || r < 0.0 || l.max(r) > 1.0e5 {
return Err(bad(C, "left/right must be non-negative widths"));
}
Some((j, l, r))
}
};
// When the profile comes out as it was, within a rounding error (1e-9), the document and its undo
// history stay as they are.
let mut pos = 0;
@@ -324,11 +392,19 @@ fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad(C, "width factors must be finite"));
}
let mut prof = st.profile.take().unwrap_or_else(uniform);
pos = match point_index(p, &prof, C)? {
Some(i) => {
pos = match (point_index(p, &prof, C)?, out) {
(None, Some(_)) => return Err(bad(C, "missing index")),
(Some(i), Some((j, l, r))) => {
let out = (t, l / half, r / half);
if !out.1.is_finite() || !out.2.is_finite() {
return Err(bad(C, "width factors must be finite"));
}
set_pair(&mut prof.points, (i, pt), (j, out), adjust, single)?
}
(Some(i), None) => {
let old = prof.points[i];
if adjust {
adjust_adjoining(&mut prof.points, i, old, pt);
adjust_adjoining(&mut prof.points, i, old.0, old, pt, [true, true]);
}
if (old.0 - t).abs() <= SAME_T {
// Widths only: it keeps its place (and its side of a discontinuous point).
@@ -339,12 +415,12 @@ fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
place(&mut prof.points, pt, old.0 < t)
}
}
None => {
(None, None) => {
let old = adjust.then(|| prof.at(t));
prof.points.retain(|q| (q.0 - t).abs() > SAME_T);
let i = place(&mut prof.points, pt, true);
if let Some((left, right)) = old {
adjust_adjoining(&mut prof.points, i, (t, left, right), pt);
adjust_adjoining(&mut prof.points, i, pt.0, (t, left, right), pt, [true, true]);
}
i
}
+1 -1
View File
@@ -11,7 +11,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Pencil",
[],
None,
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1: the stroke keeps it, for Calligraphic and Scatter brushes with Pressure variation; a point without one presses fully. Pen tilt in degrees, each −90..90, x positive leaning right and y leaning down the page, and barrel rotation in degrees clockwise, 0..360: the stroke keeps how far the pen leaned, which way and how far its barrel turned, for brushes with Tilt, Bearing and Rotation variation; null for what a point lacks. A pressure, tilt or rotation outside its range, or a point array of more than six numbers, is an error), fidelity?: pt (1.5; from 0.000015625 (0.01 / 640) to 100 / 0.0313 (about 3194.89), the Pencil's and the Paintbrush's 0.01 to 100 px Fidelity at the highest and the lowest zoom; a value outside that range is an error. The tools send their Fidelity in pixels divided by the zoom, kept within the range), fit?: bool (true; false: the points are joined by straight segments, as the Pencil previews a stroke with Live curve fitting off), closed?, style?: \"pencil\" (default) | \"brush\", fill?: bool, keepSelected?: bool (true: the drawn or continued path is selected; false: a new path leaves nothing selected, and a continued or redrawn one is deselected while the rest of the selection stays), extend?: {id, end?: \"end\" (default) | \"start\"}, connect?: {id, end: \"start\"|\"end\"}, redraw?: {id, within?: pt (12)}} fit a freehand stroke → {id}. extend continues the path from that end, and closes it when `closed` is true (left out, when the stroke ends within four Fidelities of the path's other end, 6 to 400 pt); with connect, the stroke ends on that end of another path's last open subpath and joins it on, in one path with the extended path's appearance (the other path is removed when nothing of it is left); redraw (Edit Selected Paths) replaces the section of the path between where the stroke starts and ends, each within `within` of one subpath (the shorter way round a closed one), and draws a new path when the stroke doesn't end on it. Any other style, extend end or connect end is an error, and nothing changes",
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1: the stroke keeps it, for Calligraphic and Scatter brushes with Pressure variation; a point without one presses fully. Pen tilt in degrees, each −90..90, x positive leaning right and y leaning down the page, and barrel rotation in degrees clockwise, 0..360: the stroke keeps how far the pen leaned, which way and how far its barrel turned, for brushes with Tilt, Bearing and Rotation variation; null for what a point lacks. A pressure, tilt or rotation outside its range, or a point array of more than six numbers, is an error), fidelity?: pt (1.5; from 0.000015625 (0.01 / 640) to 100 / 0.0313 (about 3194.89), the Pencil's and the Paintbrush's 0.01 to 100 px Fidelity at the highest and the lowest zoom; a value outside that range is an error. The tools send their Fidelity in pixels divided by the zoom, kept within the range), fit?: bool (true; false: the points are joined by straight segments, as the Pencil previews a stroke with Live curve fitting off), closed?, style?: \"pencil\" (default) | \"brush\", fill?: bool, keepSelected?: bool (true: the drawn or continued path is selected; false: a new path leaves nothing selected, and a continued or redrawn one is deselected while the rest of the selection stays), extend?: {id, end?: \"end\" (default) | \"start\"}, connect?: {id, end: \"start\"|\"end\"} (only with extend), redraw?: {id, within?: pt (12)}} fit a freehand stroke → {id}. extend continues the path from that end, and closes it when `closed` is true (left out, when the stroke ends within four Fidelities of the path's other end, 6 to 400 pt); with connect, the stroke ends on that end of another path's last open subpath and joins it on, in one path with the extended path's appearance (the other path is removed when nothing of it is left); redraw (Edit Selected Paths) replaces the section of the path between where the stroke starts and ends, each within `within` of one subpath (the shorter way round a closed one), and draws a new path when the stroke doesn't end on it. Any other style, extend end or connect end, connect without extend, and a connect that names no other path with an open end are errors, a stroke of one point included, and nothing changes",
has_doc,
freehand
),
+24 -19
View File
@@ -213,7 +213,11 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
let label = if brush || brush_name.is_some() { "Paintbrush" } else { "Pencil" };
let keep_selected = switch_or(p, "keepSelected", true, C)?;
let filled = switch_or(p, "fill", false, C)?;
if let Some(ext) = p.get("extend").filter(|v| !v.is_null()) {
let extend = p.get("extend").filter(|v| !v.is_null());
if extend.is_none() && p.get("connect").is_some_and(|v| !v.is_null()) {
return Err(bad(C, "connect needs extend"));
}
if let Some(ext) = extend {
let id = object_param(ext, "id", C)?.ok_or_else(|| bad(C, "extend needs id"))?;
let at_start = match ext.get("end").filter(|v| !v.is_null()).map(Value::as_str) {
None | Some(Some("end")) => false,
@@ -238,26 +242,9 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
};
let Some(p0) = pts.first_mut() else { return Err(bad(C, "needs points")) };
*p0 = end;
if pts.len() < 2 {
// No stroke to add: the brush alone changes, when it is not the path's already, and the
// path is selected or deselected as a longer continuation leaves it.
if let Some(name) = brush_name
&& s.doc()?.doc.node(target).and_then(|n| n.appearance.stroke()).is_some_and(|st| st.brush.as_deref() != Some(name))
{
s.edit("Paintbrush", |d, sel| {
set_brush(d, target, name);
if keep_selected {
sel.set([id]);
} else {
sel.remove(id);
}
Ok(())
})?;
}
return Ok(json!({ "id": id.0 }));
}
// A stroke that ends on an open end of another path connects the two: (that path, its last
// open subpath, that subpath starting at the end the stroke ends on, it ends at its end).
// It is checked before a stroke of one point returns, so a bad `connect` is refused there too.
let connect = match p.get("connect").filter(|v| !v.is_null()) {
Some(cn) => {
let other = object_param(cn, "id", C)?.ok_or_else(|| bad(C, "connect needs id"))?;
@@ -280,6 +267,24 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
}
None => None,
};
if pts.len() < 2 {
// No stroke to add: the brush alone changes, when it is not the path's already, and the
// path is selected or deselected as a longer continuation leaves it.
if let Some(name) = brush_name
&& s.doc()?.doc.node(target).and_then(|n| n.appearance.stroke()).is_some_and(|st| st.brush.as_deref() != Some(name))
{
s.edit("Paintbrush", |d, sel| {
set_brush(d, target, name);
if keep_selected {
sel.set([id]);
} else {
sel.remove(id);
}
Ok(())
})?;
}
return Ok(json!({ "id": id.0 }));
}
// `closed`, when given, says whether the stroke closes the path: the Pencil and the
// Paintbrush send it, by their Close Paths When Ends Are Within and Alt at the release.
// Left out, an extending stroke that ends within four Fidelities of the path's other end
+98 -17
View File
@@ -6,6 +6,7 @@ use std::sync::Arc;
use serde_json::{Value, json};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind, RulerMode, Unit};
use vectorcraft_geom::{Affine, Point, Vec2};
use vectorcraft_tools::distort::perspective::{PerspectiveGrid, Plane};
use super::clipboard::SwatchChoices;
use super::{
@@ -713,6 +714,85 @@ pub(crate) fn settle_interaction(s: &mut Session) -> Result<()> {
Ok(())
}
/// The document state that commands also change without an undo step: the perspective grid's view
/// options (whether it shows, Lock Grid, Lock Station Point, Snap to Grid and Show Rulers), its
/// active plane, the grid preferences, the export settings, and the current brush and symbol. Each
/// undo and redo step keeps it as the document on its other side had it
/// ([`crate::HistoryEntry::unrecorded`]).
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct Unrecorded {
grid: vectorcraft_doc::GridPrefs,
export_settings: serde_json::Map<String, Value>,
brush: Option<Value>,
symbol: Option<Value>,
options: [bool; 5],
plane: Plane,
}
impl Unrecorded {
pub(crate) fn of(d: &Document) -> Self {
let g = PerspectiveGrid::current(d);
Unrecorded {
grid: d.grid.clone(),
export_settings: d.export_settings.clone(),
brush: d.unknown.get(vectorcraft_brush::CURRENT_KEY).cloned(),
symbol: d.unknown.get(super::brushsym::CURRENT_SYMBOL).cloned(),
options: [g.visible, g.locked, g.lock_station, g.snap, g.rulers],
plane: g.plane,
}
}
}
/// Undo and redo bring back `d`; `step` is that state as the document on the step's other side had
/// it. A part the step did not change (`d` has it as `step` does) stays as it is in `now`, the
/// document before the undo or redo, since it changed after the step without an undo step. A part
/// the step changed comes back with `d`. A current brush or symbol that `d` does not hold also
/// comes back with `d`. The point Automatic Plane Positioning holds comes back with `d`, and is let go when the
/// active plane kept is not the one it holds.
fn keep_unrecorded(now: &Document, step: &Unrecorded, d: &mut Arc<Document>) {
fn pick<T: Clone + PartialEq>(back: &T, step: &T, now: &T) -> T {
if back == step { now.clone() } else { back.clone() }
}
let back = Unrecorded::of(d);
let cur = Unrecorded::of(now);
let mut want = Unrecorded {
grid: pick(&back.grid, &step.grid, &cur.grid),
export_settings: pick(&back.export_settings, &step.export_settings, &cur.export_settings),
brush: pick(&back.brush, &step.brush, &cur.brush),
symbol: pick(&back.symbol, &step.symbol, &cur.symbol),
options: std::array::from_fn(|i| pick(&back.options[i], &step.options[i], &cur.options[i])),
plane: pick(&back.plane, &step.plane, &cur.plane),
};
if want.brush != back.brush && want.brush.as_ref().and_then(Value::as_str).is_some_and(|n| vectorcraft_brush::find(d, n).is_none()) {
want.brush = back.brush.clone();
}
if want.symbol != back.symbol && want.symbol.as_ref().and_then(Value::as_str).is_some_and(|n| !d.symbols.iter().any(|s| s.name == n)) {
want.symbol = back.symbol.clone();
}
if want == back {
return;
}
let m = Arc::make_mut(d);
for (key, v) in [(vectorcraft_brush::CURRENT_KEY, &want.brush), (super::brushsym::CURRENT_SYMBOL, &want.symbol)] {
match v {
Some(v) => m.unknown.insert(key.into(), v.clone()),
None => m.unknown.remove(key),
};
}
if (want.options, want.plane) != (back.options, back.plane) {
let mut g = PerspectiveGrid::current(m);
[g.visible, g.locked, g.lock_station, g.snap, g.rulers] = want.options;
if g.plane != want.plane {
g.plane = want.plane;
g.inferred = None;
}
g.keep_positioning_valid();
super::distortcmds::store_grid(m, &g);
}
m.grid = want.grid;
m.export_settings = want.export_settings;
}
fn undo(s: &mut Session, _: &Value) -> Result<Value> {
settle_interaction(s)?;
let menu = s.menu.clone();
@@ -723,6 +803,7 @@ fn undo(s: &mut Session, _: &Value) -> Result<Value> {
let editing = st.doc.mask_edit.map(|m| m.layer);
let editing_symbol = st.doc.symbol_edit.clone();
let doc = std::mem::replace(&mut st.doc, e.doc);
keep_unrecorded(&doc, &e.unrecorded, &mut st.doc);
let selection = std::mem::replace(&mut st.selection, Arc::unwrap_or_clone(e.selection));
let selection = shared_selection(selection, st.history.redo.last());
let mut turned = crate::HistoryEntry::turned(e.label, doc, selection, &st.doc, costs);
@@ -758,6 +839,7 @@ fn redo(s: &mut Session, _: &Value) -> Result<Value> {
let editing = st.doc.mask_edit.map(|m| m.layer);
let editing_symbol = st.doc.symbol_edit.clone();
let doc = std::mem::replace(&mut st.doc, e.doc);
keep_unrecorded(&doc, &e.unrecorded, &mut st.doc);
let selection = std::mem::replace(&mut st.selection, Arc::unwrap_or_clone(e.selection));
let selection = shared_selection(selection, st.history.undo.last());
let mut turned = crate::HistoryEntry::turned(e.label, doc, selection, &st.doc, costs);
@@ -1076,8 +1158,10 @@ fn cut(s: &mut Session, p: &Value) -> Result<Value> {
/// Select every surviving piece while retaining intentional compound-path structure.
/// `roots` contains the copied targets: whole-object roots are removed in full, while partial paths
/// lose only the copied geometry. An exhausted partial path is removed, along with its compound
/// parent if now empty; layers remain. Returns JSON `null` on success, replacing direct-selection
/// references with surviving object IDs.
/// parent if now empty; a compound left with one member stays a compound path, as after Clear;
/// layers remain. Removed and replaced roots go through one [`super::pathops::Beside`], which
/// rebuilds each parent's children once when the roots are separate. Returns JSON `null` on
/// success, replacing direct-selection references with surviving object IDs.
fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
let st = s.doc()?;
let sel = st.selection.clone();
@@ -1085,13 +1169,18 @@ fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
// The selected ruler guides were copied too (#3226): they go in the same undo step.
let gone = selection.guides.clone();
d.retain_guides(selection, |g| !g.id.is_some_and(|id| gone.contains(&id)));
// The compound paths that hold a root; one left with no members goes too.
let compounds: BTreeSet<NodeId> = roots
.iter()
.filter_map(|id| d.parent_of(*id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. }))))
.collect();
let mut survivors = vec![];
let mut pieces = super::pathops::Beside::replacing(d, roots);
for id in roots {
let Some(node) = d.node(*id) else { continue };
let has_direct = sel.anchors.contains_key(id) || sel.segments.contains_key(id);
if !has_direct || node.path_data().is_none() {
remove_leaving_no_empty_compound(d, *id)?;
pieces.put(d, *id, vec![])?;
continue;
}
let original = super::path::deletion_source(d, *id)?;
@@ -1114,12 +1203,14 @@ fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
}
subpaths.retain(|sp| sp.anchors.len() >= 2);
if subpaths.is_empty() {
remove_leaving_no_empty_compound(d, *id)?;
pieces.put(d, *id, vec![])?;
} else {
survivors.extend(super::path::replace_deleted_pieces(d, &mut pieces, original, subpaths)?);
}
}
pieces.finish(d)?;
let emptied: Vec<NodeId> = compounds.into_iter().filter(|p| d.node(*p).is_some_and(|n| n.children().is_some_and(|c| c.is_empty()))).collect();
super::pathops::remove_each(d, &emptied)?;
selection.set(survivors);
selection.anchors.clear();
selection.segments.clear();
@@ -1128,19 +1219,6 @@ fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
ok()
}
/// Remove object `id`, and the compound path that held it when it was the compound's last member.
/// A compound left with one member stays a compound path, as after Clear.
fn remove_leaving_no_empty_compound(d: &mut Document, id: NodeId) -> Result<()> {
let parent = d.parent_of(id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. })));
d.remove(id)?;
if let Some(p) = parent
&& d.node(p).is_some_and(|n| n.children().is_some_and(|c| c.is_empty()))
{
d.remove(p)?;
}
Ok(())
}
fn clear(s: &mut Session, p: &Value) -> Result<Value> {
let guides = switch_or(p, "guides", false, "edit.clear")?;
let explicit = if p.get("ids").is_some() { Some(checked_ids_param(s, p, "ids", "edit.clear")?) } else { None };
@@ -1751,3 +1829,6 @@ pub(crate) fn copy_above(d: &mut Document, roots: &[NodeId], mut change: impl Fn
pub(crate) fn arc_nodes(v: Vec<Node>) -> Vec<Arc<Node>> {
v.into_iter().map(Arc::new).collect()
}
#[cfg(test)]
mod tests;
+343
View File
@@ -0,0 +1,343 @@
//! Cut with direct-selected anchors removes the objects selected whole and the paths it empties
//! through one [`Beside`](super::super::pathops::Beside), and leaves the document, the selection,
//! the clipboard and the undo history exactly as removing each of them on its own does.
use std::collections::BTreeSet;
use std::time::{Duration, Instant};
use serde_json::{Value, json};
use vectorcraft_doc::{Document, NodeId, NodeKind, tree_walks};
use super::*;
use crate::tests_large_edits::{session, square};
/// Cut's removal with every root selected whole or emptied taken out by its own
/// [`Document::remove`], and its compound path removed right after when that left it empty. The
/// tests compare [`cut_direct_selection`] with it.
fn cut_one_at_a_time(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
let st = s.doc()?;
let sel = st.selection.clone();
s.edit("Cut", |d, selection| {
let gone = selection.guides.clone();
d.retain_guides(selection, |g| !g.id.is_some_and(|id| gone.contains(&id)));
let mut survivors = vec![];
let mut pieces = super::super::pathops::Beside::replacing(d, roots);
for id in roots {
let Some(node) = d.node(*id) else { continue };
let has_direct = sel.anchors.contains_key(id) || sel.segments.contains_key(id);
if !has_direct || node.path_data().is_none() {
remove_one(d, *id)?;
continue;
}
let original = super::super::path::deletion_source(d, *id)?;
let seg_refs = sel.segments.get(id);
let anchor_refs = sel.anchors.get(id);
let mut subpaths = Vec::new();
let owned = std::mem::take(&mut super::super::path::path_mut(d, *id)?.subpaths);
for (si, sp) in owned.into_iter().enumerate() {
let cuts = super::super::clipboard::subpath_selected_segments(&sp, si, seg_refs, anchor_refs);
if cuts.is_empty() {
subpaths.push(sp);
} else if seg_refs.is_some_and(|segments| !segments.is_empty()) {
subpaths.extend(super::super::path::without_segments(sp, &cuts));
} else {
let gone: BTreeSet<usize> = anchor_refs.into_iter().flat_map(|refs| super::super::path::subpath_refs(refs, si)).collect();
subpaths.extend(super::super::path::without_anchors(sp, &gone));
}
}
subpaths.retain(|sp| sp.anchors.len() >= 2);
if subpaths.is_empty() {
remove_one(d, *id)?;
} else {
survivors.extend(super::super::path::replace_deleted_pieces(d, &mut pieces, original, subpaths)?);
}
}
pieces.finish(d)?;
selection.set(survivors);
selection.anchors.clear();
selection.segments.clear();
Ok(())
})?;
ok()
}
/// Removes object `id`, and the compound path that held it when it was the compound's last member.
fn remove_one(d: &mut Document, id: NodeId) -> Result<()> {
let parent = d.parent_of(id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. })));
d.remove(id)?;
if let Some(p) = parent
&& d.node(p).is_some_and(|n| n.children().is_some_and(|c| c.is_empty()))
{
d.remove(p)?;
}
Ok(())
}
/// Cut as `edit.cut` runs it for a direct selection, with [`cut_one_at_a_time`] in place of
/// [`cut_direct_selection`].
fn reference_cut(s: &mut Session) {
let (direct, roots) = copy_cut_targets(s).unwrap();
assert!(direct, "the selection is a direct selection");
copy(s, &json!({})).unwrap();
cut_one_at_a_time(s, &roots).unwrap();
}
fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
}
/// Selects `whole` as objects, then anchors `anchors` of each path in `partial`.
fn select_direct(s: &mut Session, whole: &[NodeId], partial: &[(NodeId, Value)]) {
run(s, "select.set", json!({"ids": whole.iter().map(|id| id.0).collect::<Vec<_>>()}));
for (id, anchors) in partial {
run(s, "select.anchors", json!({"id": id.0, "anchors": anchors, "mode": "add"}));
}
}
/// The ids of every node of the document, depth first, with the depth of each.
fn tree(d: &Document) -> Vec<(usize, NodeId)> {
fn walk(n: &vectorcraft_doc::Node, depth: usize, out: &mut Vec<(usize, NodeId)>) {
out.push((depth, n.id));
for c in n.children().into_iter().flatten() {
walk(c, depth + 1, out);
}
}
let mut out = vec![];
for l in &d.layers {
walk(l, 0, &mut out);
}
out
}
/// Whether `a` and `b` hold the same document, selection, clipboard and number of undo and redo
/// steps.
fn assert_same(a: &Session, b: &Session, when: &str) {
let (x, y) = (a.doc().unwrap(), b.doc().unwrap());
assert_eq!(tree(&x.doc), tree(&y.doc), "{when}: the tree");
assert!(*x.doc == *y.doc, "{when}: the document");
assert_eq!(x.selection, y.selection, "{when}: the selection");
// Each session's document has its own uid; the clipboard names the one it came from.
assert_eq!(a.clipboard.source_doc.is_some(), b.clipboard.source_doc.is_some(), "{when}: the clipboard's source");
let unsourced = |c: &Clipboard| Clipboard { source_doc: None, ..c.clone() };
assert!(unsourced(&a.clipboard) == unsourced(&b.clipboard), "{when}: the clipboard");
assert_eq!(x.history.undo.len(), y.history.undo.len(), "{when}: the undo steps");
assert_eq!(x.history.redo.len(), y.history.redo.len(), "{when}: the redo steps");
}
/// Runs `edit.cut` on one session that `make` builds and [`reference_cut`] on another, and checks
/// that both hold the same after the Cut, after Undo and after Redo. Returns the first session after
/// the Cut.
fn same_as_one_at_a_time(make: impl Fn() -> Session) -> Session {
let (mut a, mut b) = (make(), make());
let before = a.doc().unwrap().doc.clone();
assert_same(&a, &b, "before");
run(&mut a, "edit.cut", json!({}));
reference_cut(&mut b);
assert_same(&a, &b, "Cut");
let after = a.doc().unwrap().doc.clone();
run(&mut a, "edit.undo", json!({}));
run(&mut b, "edit.undo", json!({}));
assert_same(&a, &b, "Undo");
assert!(*a.doc().unwrap().doc == *before, "Undo gives back the document");
run(&mut a, "edit.redo", json!({}));
run(&mut b, "edit.redo", json!({}));
assert_same(&a, &b, "Redo");
assert!(*a.doc().unwrap().doc == *after, "Redo gives back the Cut");
run(&mut a, "edit.undo", json!({}));
run(&mut a, "edit.redo", json!({}));
a
}
/// A new document; [`rect`] adds squares to it.
fn new_doc() -> Session {
let mut s = Session::new();
run(&mut s, "file.new", json!({"width": 800, "height": 600}));
s
}
/// Adds a 10 pt square to the current layer, 20 pt right of the last one.
fn rect(s: &mut Session) -> NodeId {
let x = 20.0 * s.doc().unwrap().doc.node_count() as f64;
NodeId(run(s, "shape.rectangle", json!({"x": x, "y": 10, "width": 10, "height": 10}))["id"].as_u64().unwrap())
}
/// Makes a compound path of `ids` and returns it with its members in order.
fn compound(s: &mut Session, ids: &[NodeId]) -> (NodeId, Vec<NodeId>) {
run(s, "select.set", json!({"ids": ids.iter().map(|id| id.0).collect::<Vec<_>>()}));
let c = NodeId(run(s, "object.compoundPath.make", json!({}))["id"].as_u64().unwrap());
let members = s.doc().unwrap().doc.node(c).unwrap().children().unwrap().iter().map(|m| m.id).collect();
(c, members)
}
/// Anchors 0 to 2 of a square: Cut leaves it no segment, so it is removed.
fn three_anchors() -> Value {
json!([[0, 0], [0, 1], [0, 2]])
}
/// Anchors 0 and 1 of a square: Cut keeps its other three sides.
fn two_anchors() -> Value {
json!([[0, 0], [0, 1]])
}
/// The compound path whose members are cut one whole and one emptied goes with them; the other
/// compound path keeps its one member left, as a compound path.
#[test]
fn cut_removes_a_compound_whose_members_all_go_and_keeps_one_with_one_member_left() {
let make = || {
let mut s = new_doc();
let first = [(); 2].map(|()| rect(&mut s));
let (gone, gone_members) = compound(&mut s, &first);
let second = [(); 3].map(|()| rect(&mut s));
let (kept, kept_members) = compound(&mut s, &second);
let other = rect(&mut s);
select_direct(
&mut s,
&[gone_members[0], kept_members[0]],
&[(gone_members[1], three_anchors()), (kept_members[1], three_anchors()), (other, two_anchors())],
);
(s, gone, kept, kept_members[2], other)
};
let s = same_as_one_at_a_time(|| make().0);
let (_, gone, kept, left, other) = make();
let d = &s.doc().unwrap().doc;
assert!(d.node(gone).is_none(), "the compound path whose members all went is removed");
let kept = d.node(kept).expect("the compound path with a member left stays");
assert!(matches!(kept.kind, NodeKind::Compound { .. }));
assert_eq!(kept.children().unwrap().iter().map(|m| m.id).collect::<Vec<_>>(), [left]);
assert_eq!(s.doc().unwrap().selection.objects, [other], "the cut square's other sides stay selected");
}
/// Objects inside two groups and on the layer, removed whole, emptied or cut apart between kept
/// siblings, keep the order and ids that removing them one at a time leaves.
#[test]
fn cut_inside_groups_keeps_the_order_and_ids_of_removing_one_at_a_time() {
let make = || {
let mut s = new_doc();
let a = [(); 4].map(|()| rect(&mut s));
run(&mut s, "select.set", json!({"ids": a.iter().map(|id| id.0).collect::<Vec<_>>()}));
run(&mut s, "object.group", json!({}));
let b = [(); 4].map(|()| rect(&mut s));
run(&mut s, "select.set", json!({"ids": b.iter().map(|id| id.0).collect::<Vec<_>>()}));
run(&mut s, "object.group", json!({}));
let c = [(); 4].map(|()| rect(&mut s));
select_direct(
&mut s,
&[a[0], a[2], b[3], c[1]],
&[(a[1], two_anchors()), (b[0], three_anchors()), (b[2], two_anchors()), (c[3], three_anchors())],
);
s
};
let s = same_as_one_at_a_time(make);
assert_eq!(s.doc().unwrap().selection.objects.len(), 2, "the two squares cut apart stay selected");
}
/// Selected ruler guides go with the objects, in the Cut's undo step.
#[test]
fn cut_removes_the_selected_guides_with_the_objects() {
let make = || {
let mut s = new_doc();
let [a, b, c] = [(); 3].map(|()| rect(&mut s));
run(&mut s, "guide.add", json!({"vertical": true, "pos": 30}));
run(&mut s, "guide.add", json!({"vertical": false, "pos": 40}));
select_direct(&mut s, &[a, c], &[(b, two_anchors())]);
run(&mut s, "guide.select", json!({"indexes": [1], "toggle": true}));
s
};
let s = same_as_one_at_a_time(make);
assert_eq!(s.doc().unwrap().doc.ruler_guides().len(), 1, "the selected guide is removed");
assert_eq!(s.clipboard.guides.len(), 1, "the selected guide is on the clipboard");
}
/// Roots that are not separate (one inside another) are removed one at a time, as before.
#[test]
fn cut_of_roots_inside_another_root_matches_removing_one_at_a_time() {
let make = || {
let mut s = new_doc();
let a = [(); 3].map(|()| rect(&mut s));
run(&mut s, "select.set", json!({"ids": a.iter().map(|id| id.0).collect::<Vec<_>>()}));
let group = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
let b = rect(&mut s);
select_direct(&mut s, &[group, b], &[(a[1], two_anchors())]);
(s, vec![a[1], group, b])
};
let (mut x, roots) = make();
let (mut y, _) = make();
copy(&mut x, &json!({})).unwrap();
copy(&mut y, &json!({})).unwrap();
cut_direct_selection(&mut x, &roots).unwrap();
cut_one_at_a_time(&mut y, &roots).unwrap();
assert_same(&x, &y, "Cut");
}
/// One layer of 10,000 squares with every fifth of the first 10,000 selected whole (2,000) and
/// anchors 0 and 1 of the square after them picked.
fn many() -> Session {
let mut s = session(10_001, square);
let ids = crate::tests_large_edits::layer(&s, 0);
let whole: Vec<NodeId> = ids.iter().take(10_000).step_by(5).copied().collect();
select_direct(&mut s, &whole, &[(ids[10_000], two_anchors())]);
s
}
/// The tree walks [`tree_walks`] counts while `f` runs on `s`.
fn walks(s: &mut Session, f: impl FnOnce(&mut Session)) -> u64 {
let before = tree_walks();
f(s);
tree_walks() - before
}
/// Cut of 2,000 objects selected whole among 10,000, with a direct selection, walks the document's
/// tree a few times, where removing them one at a time walks it several times for each object.
#[test]
fn direct_selection_cut_of_2000_of_10000_objects_takes_few_tree_walks() {
let s = same_as_one_at_a_time(many);
assert_eq!(crate::tests_large_edits::layer(&s, 0).len(), 8_001);
let (mut a, mut b) = (many(), many());
let batched = walks(&mut a, |s| {
run(s, "edit.cut", json!({}));
});
let one_at_a_time = walks(&mut b, reference_cut);
println!("tree walks: Cut {batched}, one at a time {one_at_a_time}");
assert!(batched <= 64, "Cut walked the document's tree {batched} times");
assert!(one_at_a_time >= 4 * batched.max(1), "one at a time walked it {one_at_a_time} times, Cut {batched}");
}
/// This thread's CPU time, where the system reports it (`/proc/thread-self/schedstat` on Linux).
fn cpu_time() -> Option<Duration> {
let stat = std::fs::read_to_string("/proc/thread-self/schedstat").ok()?;
stat.split_whitespace().next()?.parse().ok().map(Duration::from_nanos)
}
/// The middle of `v`.
fn median(mut v: Vec<Duration>) -> Duration {
v.sort_unstable();
v[v.len() / 2]
}
/// Times Cut of [`many`] and [`reference_cut`] seven times each, in turn, and prints every run's
/// CPU and wall-clock time with the medians. Run it with
/// `cargo test --release -p vectorcraft-engine --lib -- --ignored --nocapture direct_selection_cut_timing`.
#[test]
#[ignore = "timing; prints the numbers"]
fn direct_selection_cut_timing() {
let mut runs: [(Vec<Duration>, Vec<Duration>); 2] = Default::default();
for round in 0..7 {
for (k, (cpu, wall)) in runs.iter_mut().enumerate() {
let mut s = many();
let (c0, w0) = (cpu_time(), Instant::now());
if k == 0 {
reference_cut(&mut s);
} else {
run(&mut s, "edit.cut", json!({}));
}
let w = w0.elapsed();
let c = c0.zip(cpu_time()).map(|(a, b)| b.saturating_sub(a)).unwrap_or(w);
println!("round {round} {}: cpu {c:?}, wall {w:?}", ["one at a time", "Cut"][k]);
cpu.push(c);
wall.push(w);
}
}
for (k, (cpu, wall)) in runs.into_iter().enumerate() {
println!("median {}: cpu {:?}, wall {:?}", ["one at a time", "Cut"][k], median(cpu), median(wall));
}
}
+2 -1
View File
@@ -65,6 +65,7 @@ pub mod zip;
use serde_json::{Value, json};
pub(crate) use action_batch::action_step;
pub use action_batch::batch_overwrites_one_file;
pub use dxf::{UNSUPPORTED, Unsupported, unsupported};
pub use encode::{
@@ -95,7 +96,7 @@ pub use naming::{NameParts as FileNameParts, parse_date as parse_file_date, rend
pub(crate) use native::preview_png;
pub use native::with_compression_pref;
pub(crate) use pdfimport::opened_page_document;
pub use pdfimport::{LoadOptions, page_document};
pub use pdfimport::{LoadOptions, page_document, pages_can_link};
pub(crate) use psdlayers::import_active as psd_layers;
pub use psdlayers::{PsdInfo, info as psd_info};
pub(crate) use psdslices::over as psd_slices;
+117 -32
View File
@@ -54,24 +54,19 @@ pub(super) fn action_batch(s: &mut Session, p: &Value) -> Result<Value> {
}
for (i, c) in cmds.iter().enumerate() {
let id = c.get("command").and_then(Value::as_str).unwrap_or("");
let refuse = |reason: &str| bad(C, action_step(i, id, reason));
if id.is_empty() {
return Err(bad(C, format!("commands[{i}]: missing `command`")));
return Err(refuse("missing `command`"));
}
if id == "command.batch" || id == "action.batch" {
return Err(bad(C, "batches cannot nest"));
return Err(refuse("batches cannot nest"));
}
// `command.batch` refuses the batch when it reaches this step, which would fail every file or data set it plays.
if id == "prefs.import" {
return Err(bad(C, format!("commands[{i}]: `prefs.import` runs on its own, not as a batch step")));
return Err(refuse("`prefs.import` runs on its own, not as a batch step"));
}
if find_command(id).is_none() {
return Err(bad(
C,
match super::super::params::nearest_command(id) {
Some(near) => format!("commands[{i}]: unknown command `{id}`; did you mean `{near}`?"),
None => format!("commands[{i}]: unknown command `{id}`"),
},
));
return Err(refuse(&super::super::params::unknown_command(id).to_string()));
}
}
// Every option is checked before the destination folder is made.
@@ -160,7 +155,7 @@ pub fn batch_overwrites_one_file(s: &Session, p: &Value) -> bool {
Some(f) => own_format.is_some_and(|own| super::format(f).is_some_and(|f| f.id == own)),
};
match c.get("command").and_then(Value::as_str).unwrap_or("") {
"document.save" | "file.save" => !save && (path || own_file()),
"document.save" => !save && (path || own_file()),
"file.saveAs" => !save && path,
"file.saveCopy" | "file.saveAsTemplate" => path,
"document.export" | "document.exportSelection" => !export && path,
@@ -184,7 +179,7 @@ fn saves_move_to_each_file(steps: &[Value], redirected: bool) -> bool {
/// in the destination folder when `redirected`) and makes that file the document's own: a save in
/// the native template format writes a copy and leaves the document's file as it was.
fn retargeting_save(c: &Value, redirected: bool) -> bool {
if !matches!(c.get("command").and_then(Value::as_str), Some("document.save" | "file.save" | "file.saveAs")) {
if !matches!(c.get("command").and_then(Value::as_str), Some("document.save" | "file.saveAs")) {
return false;
}
let params = c.get("params");
@@ -219,7 +214,7 @@ fn batch_folder(s: &mut Session, cmd: &str, p: &Value, override_open: bool, run:
// open, so its artboard files count ([`dataset_output_paths`]). No output takes the name of a
// source file in the destination folder, other than that file's own output, or of a subfolder
// of the destination folder that holds source files.
let (steps, places) = filter_steps(run.steps, override_open, false);
let (steps, places) = filter_steps(run.steps, override_open);
let run = Run { steps: &steps, ..*run };
let in_dest: Vec<Option<(String, bool)>> = files.iter().map(|path| name_in_folder(path, run.dest_folder)).collect();
let mut picker =
@@ -272,7 +267,7 @@ fn batch_datasets(s: &mut Session, cmd: &str, run: &Run<'_>) -> Result<Value> {
}
let doc_stem = st.path.as_deref().and_then(|p| std::path::Path::new(p).file_stem().and_then(|s| s.to_str())).unwrap_or("Untitled").to_string();
let stems = dataset_stems(&names, &doc_stem, run.dataset_file_naming, run, &st.doc)?;
let (steps, places) = filter_steps(run.steps, true, false);
let (steps, places) = filter_steps(run.steps, true);
let run = Run { steps: &steps, ..*run };
let mut processed = Vec::new();
let mut failed = 0usize;
@@ -353,22 +348,13 @@ impl StemPicker {
}
}
/// Drop Open (and optionally Close) steps when the batch supplies the file itself → the steps that
/// stay, and the index of each in `cmds`.
/// Drop the `document.open` steps when `drop_open` (the batch opens each source file itself) → the
/// steps that stay, and the index of each in `cmds`.
#[cfg(not(target_arch = "wasm32"))]
fn filter_steps(cmds: &[Value], drop_open: bool, drop_close: bool) -> (Vec<Value>, Vec<usize>) {
fn filter_steps(cmds: &[Value], drop_open: bool) -> (Vec<Value>, Vec<usize>) {
cmds.iter()
.enumerate()
.filter(|(_, c)| {
let id = c.get("command").and_then(Value::as_str).unwrap_or("");
if drop_open && matches!(id, "document.open" | "file.open") {
return false;
}
if drop_close && matches!(id, "file.close" | "document.close") {
return false;
}
true
})
.filter(|(_, c)| !(drop_open && c.get("command").and_then(Value::as_str) == Some("document.open")))
.map(|(i, c)| (c.clone(), i))
.unzip()
}
@@ -385,12 +371,24 @@ fn play_steps(s: &mut Session, run: &Run<'_>, places: &[usize], commands: Vec<Va
let Some((n, id, reason)) = batch_step_failure(&text) else { return e };
let same = run.steps.get(n).and_then(|c| c.get("command")).and_then(Value::as_str) == Some(id);
match places.get(n) {
Some(place) if same => EngineError::Other(format!("action step {} (`{id}`) failed: {reason}", place + 1)),
Some(&place) if same => EngineError::Other(action_step(place, id, reason)),
_ => e,
}
})
}
/// The text naming the member at `index` of an `action.batch`'s `commands`, counted from 1, with
/// its command id when it has one, and `reason`: ``action step 2 (`object.move`) failed: …``. The
/// checks before a batch runs and the errors of its steps as they run give the same text.
pub(crate) fn action_step(index: usize, id: &str, reason: &str) -> String {
let n = index.saturating_add(1);
if id.is_empty() {
format!("action step {n} failed: {reason}")
} else {
format!("action step {n} (`{}`) failed: {reason}", vectorcraft_apischema::shown_key(id))
}
}
/// The step number, command id and reason in the error `command.batch` gives when one of its steps
/// fails (``batch step 2 (`object.move`) failed: …``); none for any other error.
#[cfg(not(target_arch = "wasm32"))]
@@ -540,7 +538,7 @@ fn dataset_output_extensions(run: &Run<'_>, doc: &vectorcraft_doc::Document, def
outputs.push(DatasetOutput { ext: String::new(), artboards: false, joiner: "-", folder: true });
continue;
}
let writes = (run.override_save && matches!(id, "document.save" | "file.save" | "file.saveAs"))
let writes = (run.override_save && matches!(id, "document.save" | "file.saveAs"))
|| (run.override_export && matches!(id, "document.export" | "document.exportSelection"));
if writes {
let format = step.get("params").and_then(|p| p.get("format")).and_then(Value::as_str).filter(|f| !f.is_empty());
@@ -551,7 +549,7 @@ fn dataset_output_extensions(run: &Run<'_>, doc: &vectorcraft_doc::Document, def
};
if safe_extension(&ext) {
let format_id = super::format(format.unwrap_or(default_ext)).map(|f| f.id).unwrap_or("vectorcraft");
let is_save = matches!(id, "document.save" | "file.save" | "file.saveAs");
let is_save = matches!(id, "document.save" | "file.saveAs");
let artboards = if is_save {
!doc.artboards.is_empty() && matches!(format_id, "vectorcraft" | "template" | "ai" | "ait")
} else {
@@ -693,7 +691,7 @@ fn rewrite_paths(
.map(|c| {
let id = c.get("command").and_then(Value::as_str).unwrap_or("");
let mut c = c.clone();
let rewrite = (override_save && matches!(id, "document.save" | "file.save" | "file.saveAs"))
let rewrite = (override_save && matches!(id, "document.save" | "file.saveAs"))
|| (override_export && matches!(id, "document.export" | "document.exportForScreens" | "document.exportSelection" | "assets.export"));
if !rewrite {
return c;
@@ -2385,10 +2383,97 @@ mod tests {
let mut s = Session::new();
let p = json!({"folder": src.to_string_lossy(), "commands": [{"command": "object.unlockAll"}, {"command": "prefs.import", "params": {}}]});
let e = s.execute("action.batch", &p).unwrap_err().to_string();
assert!(e.contains("commands[1]: `prefs.import` runs on its own, not as a batch step"), "{e}");
assert!(e.contains("action step 2 (`prefs.import`) failed: `prefs.import` runs on its own, not as a batch step"), "{e}");
assert!(s.active().is_none(), "no file was opened");
}
/// Each step the checks before the batch refuse is named by its place in `commands`, from 1,
/// as a step that fails as it runs is, and no source file is opened.
#[test]
fn a_refused_step_is_named_by_its_place_from_1() {
let src = tmp("step-number-refused-src");
write_svg(&src, "a.svg", "#f00");
let prefix = "invalid parameters for `action.batch`: ";
let cases = [
(json!({"params": {}}), "action step 2 failed: missing `command`"),
(json!({"command": "select.al"}), "action step 2 (`select.al`) failed: unknown command `select.al`; did you mean `select.all`?"),
(json!({"command": "command.batch", "params": {"commands": []}}), "action step 2 (`command.batch`) failed: batches cannot nest"),
(json!({"command": "action.batch", "params": {}}), "action step 2 (`action.batch`) failed: batches cannot nest"),
(
json!({"command": "view.saved.new", "params": {"center": [0, 0], "zoom": 0}}),
"action step 2 (`view.saved.new`) failed: invalid parameters for `view.saved.new`: `zoom` must be a number > 0, not 0",
),
];
for (step, want) in cases {
let mut s = Session::new();
let p = json!({"folder": src.to_string_lossy(), "commands": [{"command": "object.unlockAll"}, step]});
let e = s.execute("action.batch", &p).unwrap_err().to_string();
assert_eq!(e, format!("{prefix}{want}"), "{step}");
assert!(s.active().is_none(), "{step}: a file was opened");
assert!(s.journal.is_empty(), "{step}: a step ran");
}
}
/// The parameter check of an `action.batch` names the step whose params it refuses, from 1;
/// that of a `command.batch` passes the step's error on as it is.
#[test]
fn the_parameter_check_names_the_refused_step() {
let bad_view = json!({"command": "view.saved.new", "params": {"center": [0, 0], "zoom": 0}});
let commands = json!([{"command": "object.unlockAll"}, {"command": "select.all"}, bad_view]);
let own = "invalid parameters for `view.saved.new`: `zoom` must be a number > 0, not 0";
let e = crate::cmd::params::check_params("action.batch", &json!({"commands": commands})).unwrap_err().to_string();
assert_eq!(e, format!("invalid parameters for `action.batch`: action step 3 (`view.saved.new`) failed: {own}"));
let e = crate::cmd::params::check_params("command.batch", &json!({"commands": commands})).unwrap_err().to_string();
assert_eq!(e, own);
}
/// The ids of the File menu's Open… and Save in the app (`file.open`, `file.save`) and
/// `document.close` are not engine commands, so a step with one is refused before the batch
/// starts, with Override Open and Override Save on or off.
#[test]
fn steps_with_ids_that_are_not_engine_commands_are_refused() {
let src = tmp("step-number-aliases-src");
write_svg(&src, "a.svg", "#f00");
for id in ["file.open", "file.save", "document.close"] {
for overrides in [true, false] {
let mut s = Session::new();
let p = json!({
"folder": src.to_string_lossy(),
"overrideOpen": overrides,
"overrideSave": overrides,
"commands": [{"command": "object.unlockAll"}, {"command": id, "params": {}}],
});
let e = s.execute("action.batch", &p).unwrap_err().to_string();
assert!(
e.starts_with(&format!("invalid parameters for `action.batch`: action step 2 (`{id}`) failed: unknown command `{id}`")),
"{e}"
);
assert!(s.active().is_none(), "{id}: a file was opened");
}
}
}
/// `command.batch` keeps its own numbering, from 0, for a step that fails.
#[test]
fn command_batch_keeps_its_own_step_numbers() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
let e = s
.execute("command.batch", &json!({"commands": [{"command": "object.unlockAll"}, {"command": "object.align", "params": {}}]}))
.unwrap_err();
assert!(e.to_string().starts_with("batch step 1 (`object.align`) failed: "), "{e}");
}
/// A step's id in the error is cut short, as an unknown key's is.
#[test]
fn a_long_step_id_is_cut_short() {
let id = "x".repeat(10_000);
let shown = action_step(0, &id, "why");
assert!(shown.len() < 1_000, "{}", shown.len());
assert!(shown.starts_with("action step 1 (`xxx") && shown.ends_with("…`) failed: why"), "{shown}");
assert_eq!(action_step(usize::MAX, "", "why"), format!("action step {} failed: why", usize::MAX));
}
/// Only the error `command.batch` gives for a failed step is read as one.
#[test]
fn batch_step_failure_reads_only_a_step_error() {
+1 -1
View File
@@ -117,7 +117,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Batch…",
[],
None,
"{commands: [{command, params}] (the action's steps), source?: folder (default) | datasets, folder? (required for folder: the source folder), includeSubdirs?: false, destination?: none (default: leave each file open) | saveAndClose (save over the source and close; for source datasets, save the open document over its own file after each data set, and refuse a document that was never saved, was converted from an older version or was restored by Data Recovery, unless a recorded Save or Save As step writes a file first; a Save or Save As step that overrideSave points into destinationFolder makes each data set's file the document's own) | folder (save or export into destinationFolder and close), destinationFolder? (required when destination is folder; also the folder Override Save/Export write into), datasetFileNaming?: fileNumber | fileDataSetName (default) | dataSetName (used only for source datasets; ignored for folder), overrideOpen?: true (skip document.open / file.open steps: the batch opens each source file), overrideSave?: true (point document.save / file.save / file.saveAs at destinationFolder/{stem}.{ext}), overrideExport?: true (point document.export / document.exportSelection the same way, and give document.exportForScreens / assets.export the folder destinationFolder/{stem}, one for each source file or data set, in which the export names its files as it does outside Batch), stopOnError?: true, label?} play the commands on every readable file in folder (and its subfolders when includeSubdirs; {stem} is the file's name without its extension and without trailing periods and spaces, with `-2`, `-3`… added to a name an earlier file used or whose file or folder has the name of one an earlier file wrote or of another source file or a folder of source files in destinationFolder), or on every data set of the open document. Data set names use the document stem plus a three-digit ordinal, the document stem and an underscore plus the data set name, or the data set name alone. Invalid file name characters become `-` and trailing periods and spaces are dropped; a name already used in the batch or whose output file or folder already exists in a destination folder the batch may read and write gets the next free `-2`, `-3` suffix before the format-derived extension. Caps: 500 files or data sets, 8 folder levels, 256 steps. Batches cannot nest, and a prefs.import step is refused (commands[i], from 0) before any file is opened. A switch (includeSubdirs, overrideOpen, overrideSave, overrideExport, stopOnError) that is not true or false, or a source, folder, destination, destinationFolder, datasetFileNaming or label that is not a string, is an error before any folder is made or file opened; null reads as left out. A step that fails is named in the error by its place in commands, from 1, counting the Open steps the batch skips (action step 3 (`object.align`) failed: …); the batch's own opening of a file, choosing of a data set and destination save, export or close give their errors without a step number. → {processed: [{path|dataset, result|error}…], count, failed, stopped, warning?} (warning: for source datasets, when Save and Close without such a step, or a Save, Save a Copy, Save as Template or export step (document.export, exportSelection, exportForScreens, exportPdf, exportEps, exportDxf, exportForWeb, exportForOffice) that writes a file and is not pointed into destinationFolder, saves every data set over the same file)",
"{commands: [{command, params}] (the action's steps), source?: folder (default) | datasets, folder? (required for folder: the source folder), includeSubdirs?: false, destination?: none (default: leave each file open) | saveAndClose (save over the source and close; for source datasets, save the open document over its own file after each data set, and refuse a document that was never saved, was converted from an older version or was restored by Data Recovery, unless a recorded Save or Save As step writes a file first; a Save or Save As step that overrideSave points into destinationFolder makes each data set's file the document's own) | folder (save or export into destinationFolder and close), destinationFolder? (required when destination is folder; also the folder Override Save/Export write into), datasetFileNaming?: fileNumber | fileDataSetName (default) | dataSetName (used only for source datasets; ignored for folder), overrideOpen?: true (skip document.open steps: the batch opens each source file), overrideSave?: true (point document.save / file.saveAs at destinationFolder/{stem}.{ext}), overrideExport?: true (point document.export / document.exportSelection the same way, and give document.exportForScreens / assets.export the folder destinationFolder/{stem}, one for each source file or data set, in which the export names its files as it does outside Batch), stopOnError?: true, label?} play the commands on every readable file in folder (and its subfolders when includeSubdirs; {stem} is the file's name without its extension and without trailing periods and spaces, with `-2`, `-3`… added to a name an earlier file used or whose file or folder has the name of one an earlier file wrote or of another source file or a folder of source files in destinationFolder), or on every data set of the open document. Data set names use the document stem plus a three-digit ordinal, the document stem and an underscore plus the data set name, or the data set name alone. Invalid file name characters become `-` and trailing periods and spaces are dropped; a name already used in the batch or whose output file or folder already exists in a destination folder the batch may read and write gets the next free `-2`, `-3` suffix before the format-derived extension. Caps: 500 files or data sets, 8 folder levels, 256 steps. A step without a command, with a command the engine doesn't have, with params its command refuses, or with command.batch, action.batch or prefs.import (batches cannot nest) is refused before any file is opened, named by its place in commands, from 1 (action step 2 (`select.al`) failed: unknown command `select.al`; did you mean `select.all`?). A switch (includeSubdirs, overrideOpen, overrideSave, overrideExport, stopOnError) that is not true or false, or a source, folder, destination, destinationFolder, datasetFileNaming or label that is not a string, is an error before any folder is made or file opened; null reads as left out. A step that fails as it runs is named the same way, counting the Open steps the batch skips (action step 3 (`object.align`) failed: …); the batch's own opening of a file, choosing of a data set and destination save, export or close give their errors without a step number. → {processed: [{path|dataset, result|error}…], count, failed, stopped, warning?} (warning: for source datasets, when Save and Close without such a step, or a Save, Save a Copy, Save as Template or export step (document.export, exportSelection, exportForScreens, exportPdf, exportEps, exportDxf, exportForWeb, exportForOffice) that writes a file and is not pointed into destinationFolder, saves every data set over the same file)",
always,
action_batch::action_batch
),
+3 -2
View File
@@ -226,9 +226,10 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) ->
vec![(Some(b), rect(b)?, false)]
}
};
let regions: Vec<(Rect, bool)> = drawings.iter().map(|&(_, region, crop)| (region, crop)).collect();
let outs = vectorcraft_cad::export_drawings(doc, &opts, &regions).map_err(|e| bad(C, e))?;
let mut enc = Encoded::default();
for (board, region, crop) in drawings {
let out = vectorcraft_cad::export(doc, &DxfOptions { region, crop, ..opts.clone() }).map_err(|e| bad(C, e))?;
for ((board, _, _), out) in drawings.into_iter().zip(outs) {
enc.files.push((board, out.bytes));
for w in out.warnings {
if !enc.warnings.contains(&w) {
+6 -3
View File
@@ -26,13 +26,16 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kin
Some(true) => pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect()),
_ => vec![pick.one(n).map_err(|e| bad(C, e))?],
};
let rects = boards
.iter()
.map(|&b| doc.artboards.get(b).map(|a| a.rect).ok_or_else(|| bad(C, format!("no artboard {}", b + 1))))
.collect::<Result<Vec<_>>>()?;
// Raster effects (shadows, glows, blurs) as images, as PDF export does.
let flat = crate::flatten_raster_effects(doc);
let src = flat.as_ref().unwrap_or(doc);
let outs = vectorcraft_metafile::export_regions(src, &rects, kind).map_err(|e| bad(C, e))?;
let mut enc = Encoded::default();
for b in boards {
let region = doc.artboards.get(b).ok_or_else(|| bad(C, format!("no artboard {}", b + 1)))?.rect;
let out = vectorcraft_metafile::export(src, region, kind).map_err(|e| bad(C, e))?;
for (b, out) in boards.into_iter().zip(outs) {
enc.files.push((Some(b), out.bytes));
for w in out.warnings {
if !enc.warnings.contains(&w) {
+1 -1
View File
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export PDF",
[],
None,
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged with an ICC profile is converted from it and written untagged; with destination and a CMYK destinatio Line truncated
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged Line truncated
has_doc,
export_pdf
),
@@ -222,6 +222,13 @@ fn page_options(page: usize, o: &LoadOptions) -> ImportOptions {
ImportOptions { pages: Some(vec![page]), crop: o.crop, password: o.password.clone(), text_as: o.text_as, layers: false, ..Default::default() }
}
/// Whether `document.open`'s `linkPages` takes the file `name` holding `bytes`: a PDF or a
/// PDF-compatible `.ai` or `.ait` of at most [`document::MAX_FILE`] bytes. Its path, a password
/// and `textAs` are checked apart ([`linked_pages`]).
pub fn pages_can_link(name: &str, bytes: &[u8]) -> bool {
bytes.len() <= document::MAX_FILE && document::is_pdf(name, bytes)
}
/// `document.open` with `linkPages`: the pages `o` picks of the PDF (or PDF-compatible `.ai` or
/// `.ait`) `name`, read from `path`, as a document holding one placed document per page, linked to
/// that page of the file as File › Place with Link places one ([`document::source`]). Each page
+18
View File
@@ -116,6 +116,24 @@ fn use_artboards_writes_one_drawing_per_artboard() {
assert!(e.contains("useArtboards"), "{e}");
}
#[test]
fn each_artboard_s_drawing_is_the_drawing_of_that_artboard_alone() {
let mut s = two_boards();
// A second rectangle on the second artboard, so the two drawings differ.
let second = s.doc().unwrap().doc.artboards[1].rect.x0;
s.execute("shape.rectangle", &json!({"x": second + 50.0, "y": 50, "width": 20, "height": 20})).unwrap();
let r = s.execute("document.export", &json!({"format": "dxf", "useArtboards": true, "unit": "pt"})).unwrap();
let files = r["files"].as_array().unwrap();
let doc = &s.doc().unwrap().doc;
let o = dxf::options(&json!({"unit": "pt"})).unwrap();
assert_eq!(files.len(), doc.artboards.len());
assert_ne!(b64(&files[0]), b64(&files[1]));
for (f, board) in files.iter().zip(&doc.artboards) {
let alone = vectorcraft_cad::export(doc, &vectorcraft_cad::DxfOptions { region: board.rect, crop: true, ..o.clone() }).unwrap();
assert_eq!(b64(f), alone.bytes, "{}", f["name"]);
}
}
#[test]
fn selected_only_exports_the_selection_in_its_layers() {
let mut s = two_boards();
@@ -410,3 +410,16 @@ fn a_placeholder_only_pdf_part_is_detected() {
assert!(open(&mut s, &two, json!({"pages": "1"})).is_err());
open(&mut s, &two, json!({})).unwrap();
}
/// `linkPages` takes a PDF up to the largest file placed, and nothing else.
#[test]
fn pages_can_link_a_pdf_up_to_the_largest_file_placed() {
let small = three_pages();
assert!(pages_can_link("pages.pdf", &small));
assert!(!pages_can_link("pages.svg", b"<svg xmlns=\"http://www.w3.org/2000/svg\"/>"));
let mut big = vec![0u8; crate::cmd::place::document::MAX_FILE + 1];
big[..small.len()].copy_from_slice(&small);
assert!(!pages_can_link("pages.pdf", &big), "over the limit");
big.pop();
assert!(pages_can_link("pages.pdf", &big), "at the limit");
}
+26 -5
View File
@@ -3,7 +3,7 @@
use serde_json::{Value, json};
use vectorcraft_doc::text::INLINE_MAX_SCALE;
use vectorcraft_doc::{Document, InlineArt, NodeId, NodeKind, TextRun};
use vectorcraft_doc::{Document, InlineArt, InlineMeasured, NodeId, NodeKind, TextRun};
use vectorcraft_text::edit;
use super::brushsym::current_symbol;
@@ -25,12 +25,33 @@ pub fn specs() -> Vec<CommandSpec> {
/// Inline graphics follow their symbols: after an edit of a document that has (or had) symbols,
/// resolve the inline art of every text again, in the layers and in the art of symbols, graph
/// designs, pattern tiles and opacity masks, and lay out again the texts whose art changed (a
/// symbol's type before the type that shows that symbol inline).
pub(crate) fn refresh(before: &Document, d: &mut Document) {
/// symbol's type before the type that shows that symbol inline). `last` is the document the last
/// refresh left resolved, with what it measured: when nothing the inline art depends on changed
/// since, only the layer trees that differ from its own are checked
/// ([`Document::resolve_inline_art_since`]). Returns what this refresh measured, or `None` when
/// neither document has symbols and nothing was checked.
pub(crate) fn refresh(last: Option<&Resolved>, before: &Document, d: &mut Document) -> Option<InlineMeasured> {
if before.symbols.is_empty() && d.symbols.is_empty() {
return;
return None;
}
d.resolve_inline_art_with(&mut refresh_bounds);
#[cfg(test)]
let last = last.filter(|_| !FULL_PASS.get());
let pass = d.resolve_inline_art_since(last.map(|(doc, m)| (&**doc, m)), &mut refresh_bounds);
#[cfg(test)]
PASSES.with(|p| p.borrow_mut().push((pass.partial, pass.changed.clone())));
Some(pass.measured)
}
/// A document a [`refresh`] left resolved, and what that refresh measured.
pub(crate) type Resolved = (std::sync::Arc<Document>, InlineMeasured);
#[cfg(test)]
thread_local! {
/// Each [`refresh`] on this thread that checked the document: whether it checked only the
/// changed layer trees, and the ids of the texts in the layers that changed.
pub(crate) static PASSES: std::cell::RefCell<Vec<(bool, Vec<NodeId>)>> = const { std::cell::RefCell::new(vec![]) };
/// Set: every [`refresh`] on this thread takes the full pass.
pub(crate) static FULL_PASS: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
fn insert_inline(s: &mut Session, p: &Value) -> Result<Value> {
+22 -13
View File
@@ -29,7 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {
"New Layer…",
["Window", "Layers"],
Some("Cmd+L"),
"{name?, top?: bool, below?: bool, color?, template?, locked?, visible?, printable?, preview?, dimImages?} a layer directly above the current layer, at its level (a sublayer beside a current sublayer); `top`: above all layers (Ctrl/Cmd-click the button); `below`: directly below the current layer, at its level (Ctrl/Cmd+Alt-click the button), not with `top`. Options as layer.setProps; refused while an opacity mask is edited (the Layers panel lists only the mask) → {id}",
"{name?, top?: bool, below?: bool, color?, template?, locked?, visible?, printable?, preview?, dimImages?} a layer directly above the current layer, at its level (a sublayer beside a current sublayer), or directly below it in Draw Behind; `top`: above all layers (Ctrl/Cmd-click the button); `below`: directly below the current layer, at its level (Ctrl/Cmd+Alt-click the button), not with `top`. Options as layer.setProps; refused while an opacity mask is edited (the Layers panel lists only the mask) → {id}",
super::maskedit::outside_mask_editing,
new_layer
),
@@ -110,7 +110,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Rows",
[],
None,
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies. Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies, which may also go above or below a row they copy (the target among `ids`). Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
has_doc,
move_rows
),
@@ -526,12 +526,15 @@ fn add_layer(s: &mut Session, p: &Value, cmd: &str, label: &str, place: impl FnO
fn new_layer(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "layer.new";
let below = switch_or(p, "below", false, C)?;
if below && bool_or(p, "top", false) {
let top = bool_or(p, "top", false);
if below && top {
return Err(bad(C, "`top` and `below` can't both be true"));
}
// In Draw Behind a layer given neither `top` nor `below` goes below the current layer.
let below = below || (!top && s.draw_mode == crate::DrawMode::Behind);
let st = s.doc()?;
// Above the current layer, at its level; below it with `below`; on top of everything with `top`.
let cur = st.current_layer().filter(|_| !bool_or(p, "top", false));
let cur = st.current_layer().filter(|_| !top);
add_layer(s, p, C, "New Layer", |d| match cur.and_then(|c| d.position(c)) {
Some((parent, i, _)) => Ok((parent, if below { i } else { i + 1 })),
None => Ok((None, if below { 0 } else { usize::MAX })),
@@ -723,19 +726,18 @@ fn select_art(s: &mut Session, p: &Value) -> Result<Value> {
} else {
vec![id]
};
let all_selected = !ids.is_empty() && ids.iter().all(|i| st.selection.contains(*i));
let all_selected = add && !ids.is_empty() && {
let selected: HashSet<NodeId> = st.selection.objects.iter().copied().collect();
ids.iter().all(|i| selected.contains(i))
};
let rows = st.layer_rows.clone();
s.select(|_, sel| {
if !add {
sel.set(ids.iter().copied());
} else if all_selected {
for i in &ids {
sel.remove(*i);
}
sel.remove_all(ids.iter().copied());
} else {
for i in &ids {
sel.add(*i);
}
sel.add_all(ids.iter().copied());
}
})?;
let st = s.doc_mut()?;
@@ -774,9 +776,11 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
if ids.is_empty() {
return Err(bad(C, "no such rows"));
}
// Never into itself or a row inside it.
// Never into itself or a row inside it. A copy may go above or below one of the rows it
// copies, which a move there would leave where it is (#8237).
let beside_itself = copy && place != Place::Inside && ids.contains(&target);
let around = d.ancestry(target).unwrap_or_default();
if ids.iter().any(|i| around.contains(i)) {
if ids.iter().any(|i| around.contains(i) && !(beside_itself && *i == target)) {
return Err(bad(C, "a row can't go into itself"));
}
let nodes: Vec<&Node> = ids.iter().filter_map(|i| d.node(*i)).collect();
@@ -788,6 +792,11 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
parent => (parent, Some(target)),
},
};
// A copy beside a top-level layer it copies, with objects among the rows, would go inside
// that layer: into itself.
if parent.is_some_and(|p| ids.contains(&p)) {
return Err(bad(C, "a row can't go into itself"));
}
if let Some(n) = nodes.iter().find(|n| !accepts(d, parent, n)) {
let into = parent.and_then(|p| d.node(p)).map_or("the top level", |p| if p.is_layer() { "a layer" } else { p.kind_label() });
return Err(bad(C, format!("{} can't go into {into}", n.display_name())));
+13 -4
View File
@@ -132,7 +132,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Locate Object",
["Window", "Layers"],
None,
"{id?} (default: the last selected object) highlight the object's row; the Layers panel opens the layers around it and scrolls to it → {id, ancestry: [layer…, id]}",
"{id?, layersOnly?} (default: the last selected object) highlight the object's row; the Layers panel opens the layers around it and scrolls to it, also when the row was already highlighted →{id, ancestry: [layer…, id]}. layersOnly (default false; the panel sends true while Show Layers Only is on, as Locate Layer) highlights the innermost layer or sublayer holding the object instead, or a layer id itself → {id: layer, objectId, ancestry: [layer…]}",
has_doc,
locate
),
@@ -435,10 +435,19 @@ fn reverse(s: &mut Session, p: &Value) -> Result<Value> {
fn locate(s: &mut Session, p: &Value) -> Result<Value> {
let id = object_param(p, "id", "layer.locate")?;
let layers_only = switch_or(p, "layersOnly", false, "layer.locate")?;
let st = s.doc_mut()?;
let id = id.or_else(|| st.selection.objects.last().copied()).ok_or_else(|| bad("layer.locate", "nothing selected"))?;
let ancestry = st.doc.ancestry(id).ok_or(EngineError::NoNode(id))?;
st.layer_rows = vec![id];
let mut ancestry = st.doc.ancestry(id).ok_or(EngineError::NoNode(id))?;
if layers_only {
// Locate Layer: the innermost layer or sublayer holding the object (a layer locates itself).
let at = ancestry.iter().rposition(|a| st.doc.node(*a).is_some_and(Node::is_layer)).ok_or(EngineError::NoNode(id))?;
ancestry.truncate(at + 1);
}
let row = ancestry.last().copied().ok_or(EngineError::NoNode(id))?;
st.layer_rows = vec![row];
st.locate_reveal = Some(row);
st.revision += 1;
Ok(json!({ "id": id.0, "ancestry": ancestry.iter().map(|i| i.0).collect::<Vec<_>>() }))
let ancestry: Vec<u64> = ancestry.iter().map(|i| i.0).collect();
Ok(if layers_only { json!({ "id": row.0, "objectId": id.0, "ancestry": ancestry }) } else { json!({ "id": id.0, "ancestry": ancestry }) })
}
+34 -2
View File
@@ -7,12 +7,16 @@
//! panel's New Art Has Basic Appearance off, the whole appearance of the last selection. With the
//! option on (the default) an inherited appearance gives new art its top stroke's options only,
//! and a change of selection loads only the proxies. `paint.default` resets it.
//!
//! A document whose Default Graphic Style no longer has the shipped look (a New Document profile
//! redefined it) gives the reset that style's fills, strokes and effects instead, and `file.new`
//! resets new art when it opens such a document.
use std::borrow::Cow;
use serde_json::{Value, json};
use vectorcraft_color::{BlendMode, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, FillLayer, GraphicStyle, Node, NodeKind, StrokeLayer};
use vectorcraft_doc::{Appearance, AppearanceItem, ColorMode, DEFAULT_GRAPHIC_STYLE, Document, FillLayer, GraphicStyle, Node, NodeKind, StrokeLayer};
use vectorcraft_tools::PaintDefaults;
use super::gradient::unplaced;
@@ -263,7 +267,35 @@ fn describe(s: &mut Session, _: &Value) -> Result<Value> {
}))
}
/// The defaults for new art reset (`paint.default`): white fill, 1 pt black stroke, no template.
/// The defaults for new art reset (`paint.default`): white fill, 1 pt black stroke, no template;
/// in a document whose Default Graphic Style was redefined, that style's fills, strokes and effects
/// at full opacity, not linked to the style.
pub(crate) fn reset(s: &mut Session) {
s.paint = PaintDefaults::default();
let style = s.doc().ok().and_then(|st| redefined_default_style(&st.doc)).cloned();
if let Some(g) = style {
let ap = if g.unit_box { g.appearance } else { unplace_all(g.appearance) };
s.take_new_art(ap, 1.0, BlendMode::Normal, None, false);
}
}
/// `d`'s Default Graphic Style when its fills, strokes, effects or transparency differ from the
/// shipped style's (white fill, 1 pt black stroke), the shipped colors converted to `d`'s color mode
/// as a New Document profile's are.
pub(crate) fn redefined_default_style(d: &Document) -> Option<&GraphicStyle> {
let g = d.graphic_styles.iter().find(|g| g.name == DEFAULT_GRAPHIC_STYLE)?;
let same =
|o: &GraphicStyle| (&o.appearance, o.opacity, o.blend, o.isolate, o.knockout) == (&g.appearance, g.opacity, g.blend, g.isolate, g.knockout);
if same(&GraphicStyle::new(DEFAULT_GRAPHIC_STYLE, Appearance::default_art())) {
return None;
}
if d.color_mode != ColorMode::Rgb {
let mut shipped = Document::new_with_mode(1.0, 1.0, ColorMode::Rgb);
shipped.graphic_styles.retain(|o| o.name == DEFAULT_GRAPHIC_STYLE);
super::colormgmt::set_color_mode(&mut shipped, d.color_mode, true, None, super::colormgmt::Grays::Profile);
if shipped.graphic_styles.first().is_some_and(same) {
return None;
}
}
Some(g)
}
+4
View File
@@ -814,6 +814,10 @@ pub(crate) fn file_new(s: &mut Session, p: &Value) -> Result<Value> {
// The profile's links keep their relative paths, which name places from the profile's file, as
// a new document from a history state keeps its source's.
s.doc_mut()?.links_from = links_from;
// A profile whose Default Graphic Style was redefined gives new art in the document that style.
if super::newart::redefined_default_style(&s.doc()?.doc).is_some() {
super::newart::reset(s);
}
// Overprint Preview is the engine's (the UI turns Pixel Preview on from `previewMode`). Both
// are views of the whole app, so Default leaves them as they are.
if settings.preview_mode == PreviewMode::Overprint {
+14 -3
View File
@@ -384,6 +384,11 @@ fn add_drawn_live_paint(s: &mut Session, isolated: NodeId, next: Option<NodeId>)
}
pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
let key = "all";
let all = match p.get(key) {
None => false,
Some(v) => v.as_bool().ok_or_else(|| bad("object.exitIsolation", format!("`{key}` must be true or false")))?,
};
// Opacity mask editing, pattern editing and symbol editing isolate their editing layer. Leaving
// isolation mode then leaves that mode, as Stop Editing Opacity Mask and the isolation bar's
// Done do. A group isolated inside the symbol's art goes back to the symbol's layer.
@@ -419,12 +424,18 @@ pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
return ok();
}
let menu = s.menu.clone();
let prev = s.active().and_then(|d| d.isolation);
let prev = st.isolation;
// An isolated sublayer goes up to its parent layer, which stays isolated, unless `all` is true or
// that layer is hidden or locked; anything else leaves isolation mode.
let up = prev
.filter(|i| !all && st.doc.node(*i).is_some_and(Node::is_layer))
.and_then(|i| st.doc.parent_of(i))
.filter(|parent| st.doc.is_editable(*parent));
if let Some(i) = prev {
crate::cmd::settle_interaction(s)?;
let left = add_drawn_live_paint(s, i, None)?.unwrap_or(i);
let left = add_drawn_live_paint(s, i, up)?.unwrap_or(i);
let st = s.doc_mut()?;
st.isolation = None;
st.isolation = up;
crate::cmd::distortcmds::finish_edit_text(st, i);
let target = st.doc.parent_of(left).filter(|p| st.doc.node(*p).is_some_and(|n| n.extras().shaper.is_some())).unwrap_or(left);
st.selection.set([target]);
+2 -2
View File
@@ -250,7 +250,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Exit Isolation Mode",
[],
None,
"{} leave isolation mode; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same",
"{all?: bool (default false)} leave isolation mode; from an isolated sublayer, go up one level to its parent layer instead (the next call goes up again), unless all is true or the parent layer is hidden or locked; no undo step for the move up; while a symbol is edited, a group isolated in its art goes back to the symbol's layer first, with or without all; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same",
has_doc,
exit_isolation
),
@@ -305,7 +305,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Live Shape Properties",
[],
None,
"{id?, ids?, radius?: pt (or % of each corner's maximum when `relativeRadii` is true), kind?: \"round\"|\"invertedRound\"|\"chamfer\", relativeRadii?: bool (Relative rounding, as in the reference app: store radii as fractions of each corner's maximum so they scale with the shape), corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counter-clockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counter-clockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse)} (Live Corners on any path: radius and kind set its corners (anchors that aren't smooth, where two sides, straight or curved (#1144), meet at an angle): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius)",
"{id?, ids?, radius?: pt (or % of each corner's maximum when `relativeRadii` is true), kind?: \"round\"|\"invertedRound\"|\"chamfer\", relativeRadii?: bool (Relative rounding, as in the reference app: store radii as fractions of each corner's maximum so they scale with the shape), corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counter-clockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counter-clockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse), lineLength?: pt (a live line's length, above 0; its first end stays), lineAngle?: degrees (a live line's angle, counter-clockwise from 3 o'clock, from its first end to its second; it turns about its midpoint)} (Live Corners on any path: radius and kind set its corners (anchors that aren't smooth, where two sides, straight or curved (#1144), meet at an angle): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius; a line's lineLength applies before its lineAngle)",
has_selection,
set_live_shape
),
+54 -1
View File
@@ -6,6 +6,7 @@ use super::{
BTreeSet, CornerKind, EngineError, LiveCorners, LiveShape, NodeId, NodeKind, Result, Session, Value, bad, check_numbers, check_switches,
convert_radii_relative, ok, selected_roots, set_corners, targets,
};
use crate::MAX_COORD;
/// The largest scale of 0 or more at which `spans`, with the margins that scale grown by `k`,
/// reach across `size` together. Returns 1 when their geometric boxes reach 1e-9 or less across
@@ -98,6 +99,30 @@ fn corners_param(p: &Value) -> Result<Option<BTreeSet<usize>>> {
list.iter().map(|k| k.as_u64().and_then(|k| usize::try_from(k).ok()).ok_or_else(err)).collect::<Result<_>>().map(Some)
}
/// Live line `l` with Line Length `len` (its first end stays) and then Line Angle `angle` (about
/// its midpoint; a line whose ends meet has none to turn), or None when neither changes it.
fn line_edit(l: &LiveShape, len: Option<f64>, angle: Option<f64>) -> Option<LiveShape> {
let now = l.line_length()?;
let mut new = l.clone();
let mut changed = false;
if let Some(len) = len
&& (len - now).abs() > 1e-9 * len.max(now)
{
new.set_line_length(len);
changed = true;
}
if let Some(a) = angle
&& new.line_length().is_some_and(|n| n > 0.0)
&& let Some(turn) = new.line_angle().map(|now| (a - now).rem_euclid(360.0))
&& turn > 1e-9
&& turn < 360.0 - 1e-9
{
new.set_line_angle(a);
changed = true;
}
(changed && new != *l).then_some(new)
}
pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
check_switches(p, &["invertPie", "makeSidesEqual", "relativeRadii"], "object.setLiveShape")?;
check_numbers(p, &["radius", "sides"], "object.setLiveShape")?;
@@ -148,7 +173,7 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
}
};
let angle = |k: &str| Ok::<_, EngineError>(number(k, |_| true, "an angle in degrees")?.map(|a| a.rem_euclid(360.0)));
let length = |k: &str| number(k, |x| x > 0.0 && x <= crate::MAX_COORD, "a length in points above 0");
let length = |k: &str| number(k, |x| x > 0.0 && x <= MAX_COORD, "a length in points above 0");
// Saved steps ([`Session::replay`]) can hold values a direct call refuses, recorded before these
// checks: a negative radius is 0, a whole side count of 0 or more is brought into 3 to 1000, and
// a fractional or negative one is ignored. A whole number written as 5.0 counts as 5, as in a
@@ -171,6 +196,10 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
// A polygon's Polygon Properties: its angle, radius or side length, Make Sides Equal.
let (polygon_angle, polygon_radius, side) = (angle("polygonAngle")?, length("polygonRadius")?, length("sideLength")?);
let equal = p.get("makeSidesEqual").and_then(Value::as_bool) == Some(true);
// A line's Line Properties: its length (its first end stays) and its angle (about its midpoint).
// A line's length can reach across the whole canvas, past `MAX_COORD`: its ends are checked below.
let line_length = number("lineLength", |x| x > 0.0, "a length in points above 0")?;
let line_angle = angle("lineAngle")?;
// An ellipse's pie becomes `pie_of(pie)`. An end of 0 is a full turn (Illustrator shows a whole
// ellipse as 0° to 360°).
let end_of = |a: f64| if a == 0.0 { 360.0 } else { a };
@@ -181,8 +210,26 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
// When every value given is the current one, the document and its undo history stay as they
// are.
let st = s.doc()?;
// The lines that Line Length or Line Angle changes, as they become. A line that would reach
// past the document's coordinate limit is an error before anything changes.
let mut lines = std::collections::BTreeMap::new();
if line_length.is_some() || line_angle.is_some() {
for id in &ids {
let Some(NodeKind::Path { live: Some(l), .. }) = st.doc.node(*id).map(|n| &n.kind) else { continue };
if let Some(new) = line_edit(l, line_length, line_angle) {
let LiveShape::Line { a, b } = &new else { continue };
if ![a.x, a.y, b.x, b.y].iter().all(|c| c.abs() <= MAX_COORD) {
return Err(bad("object.setLiveShape", format!("coordinate out of range (limit ±{MAX_COORD} pt)")));
}
lines.insert(*id, new);
}
}
}
let has_values = |id: &NodeId| {
let Some(NodeKind::Path { path, live, .. }) = st.doc.node(*id).map(|n| &n.kind) else { return true };
if lines.contains_key(id) {
return false;
}
match live.as_deref() {
Some(l @ LiveShape::Polygon { sides: now, .. })
if !(sides.is_none_or(|n| n.clamp(3, 1000) == u64::from(*now))
@@ -244,6 +291,12 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
}
*path = l.to_path();
}
if let Some(new) = lines.get(id)
&& let Some(l) = live.as_deref_mut()
{
*l = new.clone();
*path = l.to_path();
}
if let Some(on) = relative_radii
&& let Some(l) = live.as_deref_mut()
{
+9 -2
View File
@@ -48,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Default Fill and Stroke",
[],
Some("D"),
"{ids?|id?} white fill and 1 pt black stroke for the selection and the defaults; type gets black fill and no stroke. On a path directly in a graph series, the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke, and on a graph label the black fill and no stroke of its characters for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (exceptions: docs/mcp.md)",
"{ids?|id?} white fill and 1 pt black stroke for the selection and the defaults (in a document whose Default Graphic Style differs from the shipped one, as a New Document profile can redefine it: that style's fills, strokes and effects, without its opacity or a link to it); type gets black fill and no stroke. On a path directly in a graph series, the graph also stores the paint, weight, opacity and blend mode of the topmost visible fill and stroke, and on a graph label the black fill and no stroke of its characters for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (exceptions: docs/mcp.md)",
has_doc,
default_paint
),
@@ -1035,6 +1035,8 @@ fn default_paint(s: &mut Session, p: &Value) -> Result<Value> {
if !ids.is_empty() {
// When every object comes out as it was, the document and its undo history stay as they are.
let before = s.doc()?.doc.clone();
// A redefined Default Graphic Style gives other art its fills, strokes and effects, placed on each object.
let style = super::newart::redefined_default_style(&before).cloned();
super::overprint::edit_counted(s, "Default Fill and Stroke", |d| {
for id in &ids {
let Some(n) = d.node_mut(*id) else { continue };
@@ -1045,7 +1047,12 @@ fn default_paint(s: &mut Session, p: &Value) -> Result<Value> {
r.style.stroke = Paint::None;
}
}
_ => n.appearance = Appearance::default_art().into(),
_ => {
n.appearance = match &style {
Some(g) => g.appearance_on(n).into_owned().into(),
None => Appearance::default_art().into(),
}
}
}
}
let kept = super::appearance::capture_series_writes(&before, d, &ids, (true, true), (true, true), false, false);
+137 -11
View File
@@ -36,6 +36,9 @@
//! `channel` that the effect doesn't have are refused by `effect.apply` and `effect.setParams`
//! themselves ([`check_effect_color`], [`check_effect_channel`]).
use std::collections::HashMap;
use std::sync::OnceLock;
use serde_json::Value;
use vectorcraft_apischema::shown_key;
@@ -43,7 +46,7 @@ use super::{bad, command_specs, find_command};
use crate::Result;
/// What a params description says about the keys of the params object.
#[derive(Debug, Default, PartialEq)]
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ParamKeys<'a> {
/// The keys it names.
pub keys: Vec<&'a str>,
@@ -107,6 +110,8 @@ pub(crate) fn is_key(s: &str) -> bool {
/// The keys a params description names, or what in it doesn't read as one.
pub fn doc_keys(doc: &str) -> std::result::Result<ParamKeys<'_>, String> {
#[cfg(test)]
PARSES.with(|n| n.set(n.get() + 1));
let mut out = ParamKeys::default();
let (mut body, mut rest) = object_body(doc)?;
let mut entries = split_top(body, ',');
@@ -155,7 +160,12 @@ fn named_commands(more: &str) -> impl Iterator<Item = &'static super::CommandSpe
/// `None`: any key (a `…` entry naming no command, or a description that doesn't parse, which
/// the tests rule out).
fn accepted(doc: &'static str, depth: usize) -> Option<Vec<&'static str>> {
let parsed = doc_keys(doc).ok()?;
resolve(doc, depth, &mut |doc| doc_keys(doc).ok())
}
/// [`accepted`], with `parse` reading each description it reaches.
fn resolve(doc: &'static str, depth: usize, parse: &mut dyn FnMut(&'static str) -> Option<ParamKeys<'static>>) -> Option<Vec<&'static str>> {
let parsed = parse(doc)?;
let mut keys = parsed.keys;
for more in parsed.more {
let mut named = named_commands(more).peekable();
@@ -168,22 +178,120 @@ fn accepted(doc: &'static str, depth: usize) -> Option<Vec<&'static str>> {
if UNCHECKED.contains(&spec.id) {
return None;
}
keys.extend(accepted(spec.params, depth + 1)?);
keys.extend(resolve(spec.params, depth + 1, parse)?);
}
}
Some(keys)
}
/// What the params description of a built-in command says about its keys, read once per process
/// ([`known`]).
#[derive(Debug)]
struct Known {
/// The keys it names itself; none when it doesn't parse.
own: Vec<&'static str>,
/// [`accepted`] of it.
accepted: Option<Vec<&'static str>>,
/// [`id_stands_for_ids`] of it.
id_stands_for_ids: bool,
}
impl Known {
/// [`takes_key`] of the description.
fn takes(&self, key: &str) -> bool {
self.own.contains(&key) || self.accepted.as_ref().is_some_and(|keys| keys.contains(&key))
}
}
/// The place and length of `doc`'s text: a description with the same words elsewhere (a plug-in's)
/// has another place.
fn text_key(doc: &str) -> (usize, usize) {
(doc.as_ptr().addr(), doc.len())
}
/// [`Known`] of each description in `docs`, each one and each one its `…` entries name parsed once.
/// A description is left out when one it reaches has a `…` entry naming a plug-in command, whose
/// keys change as plug-ins are installed and removed.
fn read_descriptions(docs: impl IntoIterator<Item = &'static str>) -> HashMap<(usize, usize), Known> {
let names_plugin =
|more: &str| more.split_whitespace().any(|w| w.trim_matches(|c: char| !c.is_ascii_alphanumeric()).starts_with(vectorcraft_plugins::PREFIX));
let mut parsed: HashMap<(usize, usize), (Option<ParamKeys<'static>>, bool)> = HashMap::new();
let mut table = HashMap::new();
for doc in docs {
if table.contains_key(&text_key(doc)) {
continue;
}
let mut live = false;
let mut parse = |doc: &'static str| {
let (keys, plugin) = parsed.entry(text_key(doc)).or_insert_with(|| {
let keys = doc_keys(doc).ok();
let plugin = keys.as_ref().is_some_and(|k| k.more.iter().any(|m| names_plugin(m)));
(keys, plugin)
});
live |= *plugin;
keys.clone()
};
let own = parse(doc).map(|p| p.keys).unwrap_or_default();
let accepted = resolve(doc, 0, &mut parse);
if live {
continue;
}
let mut known = Known { own, accepted, id_stands_for_ids: false };
known.id_stands_for_ids = known.takes("ids") && known.takes("id") && no_required_id_beside_ids(doc);
table.insert(text_key(doc), known);
}
table
}
/// [`Known`] of `doc` when it is the params description of a built-in command.
fn known(doc: &str) -> Option<&'static Known> {
#[cfg(test)]
if UNCACHED.get() {
return None;
}
static TABLE: OnceLock<HashMap<(usize, usize), Known>> = OnceLock::new();
TABLE.get_or_init(|| read_descriptions(command_specs().iter().map(|c| c.params))).get(&text_key(doc))
}
#[cfg(test)]
thread_local! {
/// The times [`doc_keys`] parsed a description on this thread.
pub(crate) static PARSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
/// Whether [`known`] is skipped on this thread ([`uncached`]).
static UNCACHED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
/// Whether [`read_descriptions`] keeps what `doc` says.
#[cfg(test)]
pub(crate) fn read_once(doc: &'static str) -> bool {
read_descriptions([doc]).contains_key(&text_key(doc))
}
/// `f`'s result with every description parsed again where it is used, as without [`known`].
#[cfg(test)]
pub(crate) fn uncached<T>(f: impl FnOnce() -> T) -> T {
let before = UNCACHED.replace(true);
let out = f();
UNCACHED.set(before);
out
}
/// Every key the description `doc` takes, those of the commands its `…` entries name included, or
/// `None` when that isn't known: it doesn't parse, a `…` entry names no command, or one names a
/// command in [`UNCHECKED`].
pub(crate) fn accepted_keys(doc: &'static str) -> Option<Vec<&'static str>> {
accepted(doc, 0)
match known(doc) {
Some(known) => known.accepted.clone(),
None => accepted(doc, 0),
}
}
/// Does the description `doc` name `key` as a parameter (its own keys, and those of the commands
/// its `…` entries name)?
pub fn takes_key(doc: &'static str, key: &str) -> bool {
if let Some(known) = known(doc) {
return known.takes(key);
}
doc_keys(doc).is_ok_and(|parsed| parsed.keys.contains(&key)) || accepted(doc, 0).is_some_and(|keys| keys.contains(&key))
}
@@ -191,12 +299,17 @@ pub fn takes_key(doc: &'static str, key: &str) -> bool {
/// (instead of id)}`, `{id} or {ids: […]}`): it names both keys, and no params object of it names
/// `ids` beside a required `id`, which is something else (`plugin.run {id, ids?}`: the plug-in's)?
pub(crate) fn id_stands_for_ids(doc: &'static str) -> bool {
if let Some(known) = known(doc) {
return known.id_stands_for_ids;
}
takes_key(doc, "ids") && takes_key(doc, "id") && no_required_id_beside_ids(doc)
}
/// No params object of `doc` names `ids` beside a required `id`.
fn no_required_id_beside_ids(doc: &str) -> bool {
fn head(alternative: &str) -> &str {
alternative.split([':', '=', '(']).next().unwrap_or_default().trim()
}
if !takes_key(doc, "ids") || !takes_key(doc, "id") {
return false;
}
let mut rest = doc;
while let Ok((body, after)) = object_body(rest) {
let entries = split_top(body, ',');
@@ -249,9 +362,17 @@ pub fn check_keys(id: &str, doc: &'static str, params: &Value) -> Result<()> {
if given.is_empty() {
return Ok(());
}
let Some(keys) = accepted(doc, 0) else { return Ok(()) };
let live;
let keys = match known(doc) {
Some(known) => known.accepted.as_deref(),
None => {
live = accepted(doc, 0);
live.as_deref()
}
};
let Some(keys) = keys else { return Ok(()) };
match given.keys().find(|k| !keys.contains(&k.as_str())) {
Some(key) => Err(unknown(id, key, &keys)),
Some(key) => Err(unknown(id, key, keys)),
None => Ok(()),
}
}
@@ -933,9 +1054,14 @@ fn check_params_in(id: &str, params: &Value, in_batch: bool) -> Result<()> {
crate::schemas::check(spec, params, false)?;
}
if matches!(id, "command.batch" | "action.batch") && !in_batch {
for step in params.get("commands").and_then(Value::as_array).into_iter().flatten() {
for (i, step) in params.get("commands").and_then(Value::as_array).into_iter().flatten().enumerate() {
if let Some(step_id) = step.get("command").and_then(Value::as_str) {
check_params_in(step_id, step.get("params").unwrap_or(&Value::Null), true)?;
let checked = check_params_in(step_id, step.get("params").unwrap_or(&Value::Null), true);
// An `action.batch` names the step it refuses by its place, from 1, as its own checks and its steps' errors do.
match checked {
Err(e) if id == "action.batch" => return Err(bad(id, super::fileio::action_step(i, step_id, &e.to_string()))),
checked => checked?,
}
}
}
}
+1 -1
View File
@@ -82,7 +82,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Place…",
["File"],
Some("Cmd+Shift+P"),
"{path | name | dataBase64 (a file's path, or its name with its bytes), link?: true (a raster image keeps its file's path; a VectorCraft document at path becomes one locked placed document showing artboard `page`, linked to the file and read again when it changes (links.update; saving it in this app updates it at once), drawn as vectors in every output; so does a PDF/.ai page at path, showing its `crop` box, unless password or textAs: \"outlines\" is given, and an EPS file, a PostScript file or a PostScript .ai at path, showing the art false gives; false: an editable copy of its art, as from dataBase64; other files are embedded), text?: {characterSet?: \"unicode\" (UTF-8, or UTF-16 with a byte-order mark, or without one by dataset.import's rule: an even length, at least half of its two-byte units holding a NUL byte, the byte order that reads a line break, valid UTF-16 with no NUL character; other bytes as the platform's 8-bit set) | \"ansi\" (the platform's 8-bit set), platform?: \"windows\" (Windows-1252) | \"mac\" (Mac Roman), removeLineReturns?: false (each block of lines becomes one paragraph; blank lines end paragraphs), removeParagraphReturns?: false (drop blank lines), replaceSpaces?: n (runs of n ≥ 2 spaces become a tab)} (a .txt file, placed as area type filling rect, the replaced object's bounds, or else the artboard less a 36 pt margin), template?: false (onto a new locked template layer below the current layer), replace?: false (swap the one selected object, keeping its stacking place and transform; no at/rect; refused while an object of a symbol instance's art is selected), at?: [x, y] centre (default: the first artboard's centre), rect?: [x, y, width, height] fit inside; aspect kept (wins over at), page?: 1 (PDF/.ai page, or a native document's artboard), crop?: \"crop\" (clipped to that page or artboard, default; an SVG, only when given: framed and clipped by its viewBox, else by its art's bounds) | \"bounding\" (the bounds of the art that shows, with its strokes and effects, as an export measures them: hidden objects and guides left out) | \"art\" | \"trim\" | \"bleed\" | \"media\" (a PDF page's boxes), password? (an encrypted PDF), layers?: false (a PSD or PSB file: true embeds its layers as one group named after the file, read as document.open reads them: an image for each layer and a group for each layer group, with the layer's name, visibility, opacity, blend mode and opacity mask, at the place its merged image would take and clipped to the canvas when layers, hidden ones included, reach past it; never linked: link is then false unless given, and link: true is refused; a file without layers is embedded as its merged image, and so are one whose layers are all left out and one whose layers can't be read, with a warning), hiddenLayers?: false (with layers: true, the hidden layers come in hidden instead of being left out; refused without it), importSlices?: bool (a PSD or PSB file: its slices become user slices, moved and scaled with the placed art, in the same undo step; default true when the file is embedded, false when it is linked, and true with link is refused; slices the file generated automatically are left out), dxf?: {…the DXF options of document.open} (a .dxf drawing: fit fills the artboard under at, else the first; fitted or uncentred art lands with its drawing's artboard on that artboard, else it is centred on at), showImportOptions?: true (in the app, a text file without text, a DXF drawing without dxf, a PSD or PSB file embedded without layers (with two layers or more, or with slices) and a PDF with several pages or a password and no page ask for those options first, and an encrypted PDF given page and no password asks for its password; false places them with the options last confirmed, a PDF on page 1 (or page), and asks only an encrypted PDF's password)} → {ids, name, format, linked, width, height, warnings, image?: the id of the image of a DCS file or PSD/PSB file placed in a clip group, which the Links commands take, slices?: [the ids of the user slices a PSD file brought in]}. A PSD or PSB file that names a clipping path places in a clip group of that path (even-odd), as does its merged image in document.open. Raster images come in at 100% of their physical size (the file's ppi, else 72); SVG, DXF, HP-GL (.plt, .hpgl, .hgl, .hpg), PDF/.ai, EMF/WMF and PICT (.pct, .pic, .pict; clipped to the picture's frame), EPS (clipped to its bounding box; as document.open reads it), a .ai saved without PDF compatibility (from its editing data, as document.open reads it: the art of the layers that show on artboard `page`, clipped to that artboard unless crop is \"bounding\") and native documents as one group, with the images, symbols, patterns, swatches and brushes they use. A DCS file (an EPS file with one program per printing plate, DCS 1.0 or 2.0) is placed only from its path with link (else an error, as are document.open and links.embed): one linked image of its pl Line truncated
"{path | name | dataBase64 (a file's path, or its name with its bytes), link?: true (a raster image keeps its file's path; a VectorCraft document at path becomes one locked placed document showing artboard `page`, linked to the file and read again when it changes (links.update; saving it in this app updates it at once), drawn as vectors in every output; so does a PDF/.ai page at path, showing its `crop` box, unless password or textAs: \"outlines\" is given, and an EPS file, a PostScript file or a PostScript .ai at path, showing the art false gives; false: an editable copy of its art, as from dataBase64; other files are embedded), text?: {characterSet?: \"unicode\" (UTF-8, or UTF-16 with a byte-order mark, or without one by dataset.import's rule: an even length, at least half of its two-byte units holding a NUL byte, the byte order that reads a line break, valid UTF-16 with no NUL character; other bytes as the platform's 8-bit set) | \"ansi\" (the platform's 8-bit set) | \"shiftJis\" | \"gb2312\" (read as GBK) | \"chineseBig5\" | \"cyrillic\" (windows-1251, x-mac-cyrillic on mac) | \"gb18030\" | \"greek\" (windows-1253) | \"turkish\" (windows-1254) | \"baltic\" (windows-1257) | \"centralEuropean\" (windows-1250) (the WHATWG Encoding Standard's decoders: a byte-order mark is read as ordinary bytes, a malformed sequence as U+FFFD), platform?: \"windows\" (ANSI is Windows-1252) | \"mac\" (ANSI is Mac Roman), removeLineReturns?: false (each block of lines becomes one paragraph; blank lines end paragraphs), removeParagraphReturns?: false (drop blank lines), replaceSpaces?: n (runs of n ≥ 2 spaces become a tab)} (a .txt file, placed as area type filling rect, the replaced object's bounds, or else the artboard less a 36 pt margin), template?: false (onto a new locked template layer below the current layer), replace?: false (swap the one selected object, keeping its stacking place and transform; no at/rect; refused while an object of a symbol instance's art is selected), at?: [x, y] centre (default: the first artboard's centre), rect?: [x, y, width, height] fit inside; aspect kept (wins over at), page?: 1 (PDF/.ai page, or a native document's artboard), crop?: \"crop\" (clipped to that page or artboard, default; an SVG, only when given: framed and clipped by its viewBox, else by its art's bounds) | \"bounding\" (the bounds of the art that shows, with its strokes and effects, as an export measures them: hidden objects and guides left out) | \"art\" | \"trim\" | \"bleed\" | \"media\" (a PDF page's boxes), password? (an encrypted PDF), layers?: false (a PSD or PSB file: true embeds its layers as one group named after the file, read as document.open reads them: an image for each layer and a group for each layer group, with the layer's name, visibility, opacity, blend mode and opacity mask, at the place its merged image would take and clipped to the canvas when layers, hidden ones included, reach past it; never linked: link is then false unless given, and link: true is refused; a file without layers is embedded as its merged image, and so are one whose layers are all left out and one whose layers can't be read, with a warning), hiddenLayers?: false (with layers: true, the hidden layers come in hidden instead of being left out; refused without it), importSlices?: bool (a PSD or PSB file: its slices become user slices, moved and scaled with the placed art, in the same undo step; default true when the file is embedded, false when it is linked, and true with link is refused; slices the file generated automatically are left out), dxf?: {…the DXF options of document.open} (a .dxf drawing: fit fills the artboard under at, else the first; fitted or uncentred art lands with its drawing's artboard on that artboard, else it is centred on at), showImportOptions?: true (in the app, a text file without text, a DXF drawing without dxf, a PSD or PSB file embedded without layers (with two layers or more, or with slices) and a PDF with several pages or a password and no page ask for those options first, and an encrypted PDF given page and no password asks for its password; false places them with the options last confirmed, a PDF on page 1 (or page), and asks only an encrypted PDF's password)} → {ids, name, format, linked, width, height, warnings, image?: the id of the image of a DCS file or PSD/PSB file placed in a clip group, which the Links commands take, slices?: [the ids of the user slices a PSD file brought in]}. A PSD or PSB file that names a clipping path places in a clip group of that path (even-odd), as does its merged image in document.open. Raster images come in at 100% of their physical size (the file's ppi, else 72); SVG, DXF, HP-GL (.plt, .hpgl, .hgl, .hpg), PDF/.ai, EMF/WMF and PICT (.pct, .pic, .pict; clipped to the picture's frame), EPS (clipped to its bounding box; as document.open reads it), a .ai saved without PDF compatibility (from its editing data, as document.open reads it: the art of the layers Line truncated
has_doc,
place
),
+140 -23
View File
@@ -3,8 +3,8 @@
use serde_json::Value;
use super::super::utf16_order_without_mark;
use super::{Point, Rect, Result, bad, bool_or, fileio, shapes, str_param};
use super::super::{text_param, utf16_order_without_mark};
use super::{Point, Rect, Result, bad, fileio, shapes, switch_or};
/// Text files as `file.place` reports them (not a format `document.open` reads).
pub(super) const FORMAT: fileio::Format = fileio::Format {
@@ -22,13 +22,68 @@ pub(super) const FORMAT: fileio::Format = fileio::Format {
/// document may give.
pub(super) const MAX_TEXT: usize = 4 << 20;
/// A character set of Text Import Options (`text.characterSet`).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
enum CharacterSet {
/// UTF-8, or UTF-16 with or without a byte-order mark ([`decode`]).
#[default]
Unicode,
/// The platform's 8-bit character set: Windows-1252, or Mac Roman on a Mac.
Ansi,
ShiftJis,
Gb2312,
ChineseBig5,
Cyrillic,
Gb18030,
Greek,
Turkish,
Baltic,
CentralEuropean,
}
/// Each character set by its `text.characterSet` value.
const CHARACTER_SETS: [(&str, CharacterSet); 11] = [
("unicode", CharacterSet::Unicode),
("ansi", CharacterSet::Ansi),
("shiftJis", CharacterSet::ShiftJis),
("gb2312", CharacterSet::Gb2312),
("chineseBig5", CharacterSet::ChineseBig5),
("cyrillic", CharacterSet::Cyrillic),
("gb18030", CharacterSet::Gb18030),
("greek", CharacterSet::Greek),
("turkish", CharacterSet::Turkish),
("baltic", CharacterSet::Baltic),
("centralEuropean", CharacterSet::CentralEuropean),
];
impl CharacterSet {
/// The Encoding Standard decoder of a set other than Unicode and ANSI, for a file from a Mac
/// when `mac`: GB2312 reads as GBK, Cyrillic as windows-1251 (x-mac-cyrillic on a Mac), and
/// Greek, Turkish, Baltic and Central European as windows-1253, 1254, 1257 and 1250 on both
/// platforms.
fn encoding(self, mac: bool) -> Option<&'static encoding_rs::Encoding> {
Some(match self {
Self::Unicode | Self::Ansi => return None,
Self::ShiftJis => encoding_rs::SHIFT_JIS,
Self::Gb2312 => encoding_rs::GBK,
Self::ChineseBig5 => encoding_rs::BIG5,
Self::Cyrillic if mac => encoding_rs::X_MAC_CYRILLIC,
Self::Cyrillic => encoding_rs::WINDOWS_1251,
Self::Gb18030 => encoding_rs::GB18030,
Self::Greek => encoding_rs::WINDOWS_1253,
Self::Turkish => encoding_rs::WINDOWS_1254,
Self::Baltic => encoding_rs::WINDOWS_1257,
Self::CentralEuropean => encoding_rs::WINDOWS_1250,
})
}
}
/// Text Import Options (`file.place`'s `text` param).
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub(super) struct TextOptions {
/// Decode as the platform's 8-bit character set (Windows-1252 or Mac Roman) instead of
/// Unicode.
ansi: bool,
/// The file comes from a Mac (its 8-bit character set is Mac Roman).
/// The character set the file's bytes are decoded as.
character_set: CharacterSet,
/// The file comes from a Mac (its ANSI set is Mac Roman, its Cyrillic set x-mac-cyrillic).
mac: bool,
/// Join the lines of each block of text (blank lines end paragraphs).
remove_line_returns: bool,
@@ -45,11 +100,13 @@ impl TextOptions {
if !t.is_object() {
return Err(bad(cmd, "text must be {characterSet?, platform?, removeLineReturns?, removeParagraphReturns?, replaceSpaces?}"));
}
let choice = |key: &str, values: [&str; 2]| match str_param(t, key) {
None => Ok(false),
Some(v) if v == values[0] => Ok(false),
Some(v) if v == values[1] => Ok(true),
Some(v) => Err(bad(cmd, format!("text.{key} `{v}`: use \"{}\" or \"{}\"", values[0], values[1]))),
// The index of `text[key]` in `values`; 0 when it is omitted or null.
let choice = |key: &str, values: &[&str]| -> Result<usize> {
let Some(v) = text_param(t, key, cmd)? else { return Ok(0) };
values.iter().position(|x| *x == v).ok_or_else(|| {
let (last, rest) = values.split_last().map_or(("", &[][..]), |(last, rest)| (*last, rest));
bad(cmd, format!("text.{key} `{v}`: use \"{}\" or \"{}\"", rest.join("\", \""), last))
})
};
let spaces_to_tab = match t.get("replaceSpaces") {
None | Some(Value::Null) => None,
@@ -58,11 +115,12 @@ impl TextOptions {
as usize,
),
};
let set = choice("characterSet", &CHARACTER_SETS.map(|(name, _)| name))?;
Ok(Self {
ansi: choice("characterSet", ["unicode", "ansi"])?,
mac: choice("platform", ["windows", "mac"])?,
remove_line_returns: bool_or(t, "removeLineReturns", false),
remove_paragraph_returns: bool_or(t, "removeParagraphReturns", false),
character_set: CHARACTER_SETS.get(set).map_or(CharacterSet::Unicode, |(_, s)| *s),
mac: choice("platform", &["windows", "mac"])? == 1,
remove_line_returns: switch_or(t, "removeLineReturns", false, cmd)?,
remove_paragraph_returns: switch_or(t, "removeParagraphReturns", false, cmd)?,
spaces_to_tab,
})
}
@@ -80,10 +138,15 @@ pub(super) fn import(bytes: &[u8], o: TextOptions, cmd: &str) -> Result<String>
/// `bytes` as text: Unicode (UTF-8, or UTF-16 with a byte-order mark, or without one when the
/// file has an even length, reads as valid UTF-16 with no NUL character in the byte order
/// [`utf16_order_without_mark`] gives; bytes that aren't UTF-8 are read as the platform's 8-bit
/// set), or the platform's 8-bit character set.
/// set), the platform's 8-bit character set, or another set's decoder
/// ([`CharacterSet::encoding`]), which reads a byte-order mark as ordinary bytes and a malformed
/// sequence as U+FFFD.
fn decode(bytes: &[u8], o: TextOptions) -> String {
if let Some(encoding) = o.character_set.encoding(o.mac) {
return encoding.decode_without_bom_handling(bytes).0.into_owned();
}
let eight_bit = |b: &[u8]| -> String { b.iter().map(|&c| if o.mac { mac_roman(c) } else { windows_1252(c) }).collect() };
if o.ansi {
if o.character_set == CharacterSet::Ansi {
return eight_bit(bytes);
}
let utf16 = |rest: &[u8], le: bool| {
@@ -278,22 +341,76 @@ mod tests {
assert_eq!(decode(&[0xFF, 0xFE, b'h', 0, 0xE9, 0], unicode), "hé", "UTF-16 LE");
assert_eq!(decode(&[0xFE, 0xFF, 0, b'h', 0x20, 0xAC], unicode), "h€", "UTF-16 BE");
assert_eq!(decode(&[b'c', b'a', b'f', 0xE9, 0x80], unicode), "café€", "not UTF-8: Windows-1252");
let ansi = TextOptions { ansi: true, ..TextOptions::default() };
let ansi = TextOptions { character_set: CharacterSet::Ansi, ..TextOptions::default() };
assert_eq!(decode(&[0x93, b'q', 0x94, 0xE9], ansi), "“q”é");
let mac = TextOptions { ansi: true, mac: true, ..TextOptions::default() };
let mac = TextOptions { character_set: CharacterSet::Ansi, mac: true, ..TextOptions::default() };
assert_eq!(decode(&[0xD2, b'q', 0xD3, 0x8E, 0xA5, 0xDB], mac), "“q”é•€");
}
/// The other character sets decode by their Encoding Standard decoders: the platform matters
/// for Cyrillic alone, a byte-order mark is read as ordinary bytes, and a malformed sequence
/// reads as U+FFFD.
#[test]
fn decodes_the_other_character_sets() {
let cases: [(CharacterSet, &[u8], &str); 9] = [
(CharacterSet::ShiftJis, &[0x93, 0xFA, 0x96, 0x7B], "日本"),
(CharacterSet::Gb2312, &[0xD6, 0xD0, 0xCE, 0xC4], "中文"),
(CharacterSet::ChineseBig5, &[0xA4, 0xA4, 0xA4, 0xE5], "中文"),
(CharacterSet::Cyrillic, &[0xCF, 0xF0, 0xE8, 0xE2, 0xE5, 0xF2], "Привет"),
(CharacterSet::Gb18030, &[0x95, 0x32, 0x82, 0x36], "\u{20000}"),
(CharacterSet::Greek, &[0xC5, 0xEB, 0xEB, 0xDC, 0xE4, 0xE1], "Ελλάδα"),
(CharacterSet::Turkish, &[0xDD, 0x73, 0x74], "İst"),
(CharacterSet::Baltic, &[0x52, 0xEE, 0x67, 0x61], "Rīga"),
(CharacterSet::CentralEuropean, &[0xA3, 0xF3, 0x64, 0x9F], "Łódź"),
];
for (set, bytes, text) in cases {
let windows = TextOptions { character_set: set, ..TextOptions::default() };
assert_eq!(decode(bytes, windows), text, "{set:?}");
if set != CharacterSet::Cyrillic {
assert_eq!(decode(bytes, TextOptions { mac: true, ..windows }), text, "{set:?} from a Mac");
}
}
let mac_cyrillic = TextOptions { character_set: CharacterSet::Cyrillic, mac: true, ..TextOptions::default() };
assert_eq!(decode(&[0x8F, 0xF0, 0xE8, 0xE2, 0xE5, 0xF2], mac_cyrillic), "Привет");
let shift_jis = TextOptions { character_set: CharacterSet::ShiftJis, ..TextOptions::default() };
assert_eq!(decode(&[0x82, 0x22], shift_jis), "\u{FFFD}\"", "a lead byte before ASCII");
assert_eq!(decode(&[b'a', 0x82], shift_jis), "a\u{FFFD}", "a lead byte at the end");
let central = TextOptions { character_set: CharacterSet::CentralEuropean, ..TextOptions::default() };
assert_eq!(decode(&[0xEF, 0xBB, 0xBF, b'A'], central), "A", "a UTF-8 byte-order mark is read as windows-1250");
assert_eq!(decode(&[0xFF, 0xFE, b'A', 0], shift_jis), "\u{FFFD}\u{FFFD}A\0", "a UTF-16 byte-order mark is read as Shift JIS");
}
#[test]
fn options_parse_and_reject_bad_values() {
let p = serde_json::json!({"text": {"characterSet": "ansi", "platform": "mac", "removeLineReturns": true, "replaceSpaces": 4}});
let o = TextOptions::parse(&p, "file.place").unwrap();
assert_eq!(o, TextOptions { ansi: true, mac: true, remove_line_returns: true, remove_paragraph_returns: false, spaces_to_tab: Some(4) });
assert_eq!(
o,
TextOptions {
character_set: CharacterSet::Ansi,
mac: true,
remove_line_returns: true,
remove_paragraph_returns: false,
spaces_to_tab: Some(4)
}
);
for (name, set) in CHARACTER_SETS {
let o = TextOptions::parse(&serde_json::json!({"text": {"characterSet": name}}), "file.place").unwrap();
assert_eq!(o.character_set, set, "{name}");
}
assert_eq!(TextOptions::parse(&serde_json::json!({}), "file.place").unwrap(), TextOptions::default());
for bad in
[serde_json::json!({"text": 3}), serde_json::json!({"text": {"platform": "amiga"}}), serde_json::json!({"text": {"replaceSpaces": 1}})]
{
for bad in [
serde_json::json!({"text": 3}),
serde_json::json!({"text": {"platform": "amiga"}}),
serde_json::json!({"text": {"replaceSpaces": 1}}),
serde_json::json!({"text": {"characterSet": 3}}),
serde_json::json!({"text": {"platform": true}}),
serde_json::json!({"text": {"removeLineReturns": "yes"}}),
serde_json::json!({"text": {"removeParagraphReturns": 1}}),
] {
assert!(TextOptions::parse(&bad, "file.place").is_err(), "{bad}");
}
let null = serde_json::json!({"text": {"characterSet": null, "platform": null, "removeLineReturns": null}});
assert_eq!(TextOptions::parse(&null, "file.place").unwrap(), TextOptions::default(), "null leaves the default");
}
}
+1
View File
@@ -64,6 +64,7 @@ const DENIED_PREFIXES: &[&str] = &[
"edit.newDocument",
"edit.colorSettings",
"edit.dropSelection",
"symbol.placeFromDocument",
"artboard.copy",
"artboard.cut",
"text.rescanFonts",
@@ -41,6 +41,7 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.image.removeBackground",
"addon.image.removeColorMask",
"addon.packaging.check",
"addon.packaging.fold",
"addon.packaging.roles",
"addon.packaging.setRole",
"addon.packaging.setRoleSwatch",
+80 -1
View File
@@ -32,7 +32,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Run Script",
[],
None,
"{path?: a .js or .jsx file | source?: the script's text (exactly one of the two), installed?: true or false (default false; true with a path that script.listInstalled gave: the file is read once, checked as File › Scripts checks it, and that text runs, its #include lines and $.evalFile reading in the folder that read found; a file that is no longer a listed script ends with \"the script is no longer in the Scripts folder\" and nothing runs), name?: the name errors and the report use (default: the script's #script line, else the path's file name, or \"script\"), args?: {…} (at most 1 MiB as JSON; vc.args in the script), answers?: [{kind: alert|confirm|prompt, value: \"ok\" (alert) | true or false (confirm) | text or null (prompt)}] (for a run with nobody to ask: the answers to its dialogs, in order; at most 10000 and 1 MiB as JSON; refused in the app, where the person answers; an empty object is an empty list), maxFuel?: whole number from 1 to 100000000000 (instructions in all; default 1000000000)} run a JavaScript file against the open documents, through the vc object: vc.run(id, params) runs a command and returns its result, a failed command throws an error the script can catch and puts back the documents and the session state it changed, while any file it wrote stays written and is named; vc.document is a snapshot of the active document or null; vc.commands lists the commands a script may run; vc.log(value) adds to the report and the Script Console (script.console); $.write(...values) writes the values to the Script Console as String(value) gives them, and $.writeln(...values) does the same and ends the line; $.evalFile(path, timeout?) runs a file with the same globals and returns its last value (timeout, in milliseconds from 0, is taken and not waited on), $.fileName is the file of the code that reads it (the file being run for code that eval or Function compiled; empty for code compiled from a script given as text), $.includePath the #includepath list and $.engineName the engine's name (VectorCraft without #targetengine); alert(message[, title, errorIcon]), confirm(message[, noAsDflt, title]) and prompt(message, preset[, title]) open a dialog with a Stop button (default title \"Script Alert\"; message and preset as String(value) gives them; errorIcon and noAsDflt as Boolean(value) gives them; No is the default with noAsDflt): alert returns undefined, confirm true for Yes and false for No, prompt the field's text for OK and null for Cancel; in the app the run waits at the call for the person's answer and Stop ends it as script.stop does, a dialog cannot open inside a callback of a built-in, a getter, a conversion or a file $.evalFile runs and throws there (an #include file's code is the script's own and can), and a run with nobody to ask takes the next of answers, and ends when none is left or the next is for another kind of dialog, or when the script ends with answers unused; vc.args is args. Before anything runs, the script's preprocessor lines (# or //@ at the start of a line, outside strings and comments) are read: #include \"file\" and //@include put that file's text in place of the line, looked for beside the file that includes it, then in each #includepath folder in turn (separated by ;, relative to that file's folder; a later #includepath replaces the list), then in each JSINCLUDE folder; #script names the run; #target takes any value and changes nothing; #strict on makes an assignment to a read-only or getter-only property, or a new property on an object that is not extensible (preventExtensions, seal, freeze, vc, $), throw a TypeError, without the rest of ES5 strict mode, and #strict off turns that off (the last #strict line of the script and its includes sets the run; off without one; a $.evalFile file's own line holds for its code); #targetengine name runs the script in the named engine, whose globals and functions stay for the next run that names it until script.engine.drop drops it or the session ends (script.engines lists them; a name of letters, digits and _ not starting with a digit, or a quoted one of 1 to 64 bytes without control characters, matched as written; only in the script itself, once, before its code and #include lines; main, and a script without the line, get a new engine each run; a session keeps 8 named engines, a ninth name is refused, each has 64 MiB of heap, and an uncaught error, a limit or script.stop keeps the globals the run set while the documents go back; host functions kept in a global act for the run that calls them; an error in code an earlier run compiled is at that run's file, line and column, within 8 MiB of source maps kept for each engine, the oldest going first; not on the web); #engine is refused as unsupported, any other #name as unknown, and another //@name is a comment. A script run from a file reads its includes and $.evalFile's files only in that file's folder and the folders below it, refusing a path with a .. name or a link that l Line truncated
"{path?: a .js or .jsx file | source?: the script's text (exactly one of the two), installed?: true or false (default false; true with a path that script.listInstalled gave: the file is read once, checked as File › Scripts checks it, and that text runs, its #include lines and $.evalFile reading in the folder that read found; a file that is no longer a listed script ends with \"the script is no longer in the Scripts folder\" and nothing runs), name?: the name errors and the report use (default: the script's #script line, else the path's file name, or \"script\"), args?: {…} (at most 1 MiB as JSON; vc.args in the script), answers?: [{kind: alert|confirm|prompt, value: \"ok\" (alert) | true or false (confirm) | text or null (prompt)}] (for a run with nobody to ask: the answers to its dialogs, in order; at most 10000 and 1 MiB as JSON; refused in the app, where the person answers; an empty object is an empty list), maxFuel?: whole number from 1 to 100000000000 (instructions in all; default 1000000000)} run a JavaScript file against the open documents, through the vc object: vc.run(id, params) runs a command and returns its result, a failed command throws an error the script can catch and puts back the documents and the session state it changed, while any file it wrote stays written and is named; vc.document is a snapshot of the active document or null; vc.commands lists the commands a script may run; vc.log(value) adds to the report and the Script Console (script.console); $.write(...values) writes the values to the Script Console as String(value) gives them, and $.writeln(...values) does the same and ends the line; $.evalFile(path, timeout?) runs a file with the same globals and returns its last value (timeout, in milliseconds from 0, is taken and not waited on), $.fileName is the file of the code that reads it (the file being run for code that eval or Function compiled; empty for code compiled from a script given as text), $.includePath the #includepath list and $.engineName the engine's name (VectorCraft without #targetengine); alert(message[, title, errorIcon]), confirm(message[, noAsDflt, title]) and prompt(message, preset[, title]) open a dialog with a Stop button (default title \"Script Alert\"; message and preset as String(value) gives them; errorIcon and noAsDflt as Boolean(value) gives them; No is the default with noAsDflt): alert returns undefined, confirm true for Yes and false for No, prompt the field's text for OK and null for Cancel; in the app the run waits at the call for the person's answer and Stop ends it as script.stop does, a dialog cannot open inside a callback of a built-in, a getter, a conversion or a file $.evalFile runs and throws there (an #include file's code is the script's own and can), and a run with nobody to ask takes the next of answers, and ends when none is left or the next is for another kind of dialog, or when the script ends with answers unused; vc.args is args. Before anything runs, the script's preprocessor lines (# or //@ at the start of a line, outside strings and comments) are read: #include \"file\" and //@include put that file's text in place of the line, looked for beside the file that includes it, then in each #includepath folder in turn (separated by ;, relative to that file's folder; a later #includepath replaces the list), then in each JSINCLUDE folder; #script names the run; #target takes any value and changes nothing; #strict on makes an assignment to a read-only or getter-only property, or a new property on an object that is not extensible (preventExtensions, seal, freeze, vc, $), throw a TypeError, without the rest of ES5 strict mode, and #strict off turns that off (the last #strict line of the script and its includes sets the run; off without one; a $.evalFile file's own line holds for its code); #targetengine name runs the script in the named engine, whose globals and functions stay for the next run that names it until script.engine.drop drops it or the session ends (script.engines lists them; a name of letters, digits and _ not starting with a digit, or a quoted one of 1 to 64 bytes without control characters, matched as written; only in the script itself, once, before its code and #include lines; main, and a script without the line, get a new engine each run; a session keeps 8 named engines, a ninth name is refused, each has 64 MiB of heap, and an uncaught error, a limit or script.stop keeps the globals the run set while the documents go back; host functions kept in a global act for the run that calls them; an error in code an earlier run compiled is at that run's file, line and column, within 8 MiB of source maps kept for each engine, the oldest going first; not on the web); #engine is refused as unsupported, any other #name as unknown, and another //@name is a comment. A script run from a file reads its includes and $.evalFile's files only in that file's folder and the folders below it, refusing a path with a .. name or a link that l Line truncated
always,
run
),
@@ -90,6 +90,24 @@ pub fn specs() -> Vec<CommandSpec> {
always,
list_installed
),
cmd!(
query "script.grants",
"List Script File Permissions",
[],
None,
"{} the file access people allowed scripts with Always in a file dialog, kept in Script Grants.json next to the settings: each for one script file with one text and the files it includes (their SHA-256), so a changed or moved script, or a changed included file, has none, and with the SHA-256 of each source the run that kept it evaluated (files $.evalFile ran, strings given to eval and Function; at most 256), so a run loses it before it evaluates other code, or when its named engine holds code the grant was not kept for; at most 4096 → {grants: [{script: the script file's path, sha256, code: [SHA-256 of each evaluated source, of its UTF-16 code units in little-endian order], path: the file or folder allowed, write: it may be written, folder: the grant is a folder's, with everything in it (a file's grant is its own path only)}], file: the grants file's path | null (a session without a settings folder, and the web)}",
always,
grants
),
cmd!(
query "script.grants.revoke",
"Revoke Script File Permissions",
[],
None,
"{script?: a script file's path, path?: an allowed file or folder's path, all?: true (exactly one of all and the other two)} remove the kept file access of that script, of that path, of both together, or every one; a path is matched as script.grants lists it, after its links are followed (a path outside the automation read roots is matched as given); refused with the busy error while a script runs, as the run keeps the grants it started with → {removed: how many}",
always,
grants_revoke
),
cmd!(
query "script.check",
"Check Script",
@@ -246,6 +264,18 @@ impl Session {
self.scripts_dir = Some(dir);
}
/// Keep each script's data folder (`Folder.userData`) in the folder `dir`, and the file access
/// people allow scripts with Always in [`script::files::GRANTS_FILE`] beside it. The folders are
/// made when a script first needs them.
pub fn attach_script_data(&mut self, dir: std::path::PathBuf) {
self.script_data_dir = Some(dir);
}
/// The folder of the scripts' data folders ([`Session::attach_script_data`]); none on the web.
pub fn script_data_dir(&self) -> Option<&std::path::Path> {
self.script_data_dir.as_deref().filter(|_| !cfg!(target_arch = "wasm32"))
}
/// The Scripts folder ([`Session::attach_scripts_dir`]); none on the web, which has no folders.
pub fn scripts_dir(&self) -> Option<&std::path::Path> {
self.scripts_dir.as_deref().filter(|_| !cfg!(target_arch = "wasm32"))
@@ -335,6 +365,55 @@ fn list_installed(s: &mut Session, _: &Value) -> Result<Value> {
Ok(json!({"folder": folder, "scripts": scripts, "truncated": listing.truncated, "unreadable": listing.unreadable}))
}
fn grants(s: &mut Session, _: &Value) -> Result<Value> {
let Some(dir) = s.script_data_dir() else { return Ok(json!({"grants": [], "file": null})) };
let file = dir.with_file_name(script::files::GRANTS_FILE);
// A script or a granted path outside the automation read roots is named by its file name alone.
let mut grants = script::files::stored_grants(dir);
for g in &mut grants {
for key in ["script", "path"] {
if let Some(name) = g[key].as_str().and_then(hidden_name) {
g[key] = json!(name);
}
}
}
let file = file.to_string_lossy();
Ok(json!({"grants": grants, "file": super::fileio::shown_path(&file)}))
}
fn grants_revoke(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "script.grants.revoke";
let path_of = |key: &str| match p.get(key) {
None => Ok(None),
// A path the request may not read (outside the automation read roots, a network path among
// them) is compared as written, without looking it up.
Some(Value::String(t)) if !t.is_empty() => Ok(Some(
crate::file_access::check_read(t)
.ok()
.and_then(|()| std::fs::canonicalize(t).ok())
.map_or_else(|| t.clone(), |real| crate::cmd::findfiles::plain(real).to_string_lossy().into_owned()),
)),
Some(_) => Err(bad(C, format!("`{key}` must be a path"))),
};
let (script_path, path) = (path_of("script")?, path_of("path")?);
let all = match p.get("all") {
None => false,
Some(Value::Bool(true)) => true,
Some(_) => return Err(bad(C, "`all` must be true")),
};
if all == (script_path.is_some() || path.is_some()) {
return Err(bad(C, "give `all`, or `script` and `path` or one of them"));
}
// A running script holds the grants it started with until it ends.
if s.script_running() {
return Err(EngineError::Busy);
}
let Some(dir) = s.script_data_dir() else { return Ok(json!({"removed": 0})) };
let removed = script::files::revoke_grants(dir, script_path.as_deref(), path.as_deref())
.map_err(|e| EngineError::Other(format!("the script file permissions could not be saved: {e}")))?;
Ok(json!({"removed": removed}))
}
/// The folder a script is in, which its included files are read from.
struct Folder {
dir: std::path::PathBuf,
+139 -1
View File
@@ -220,8 +220,10 @@ fn own_stroke_or_leaves(s: &Session, p: &Value) -> Result<Vec<vectorcraft_doc::N
})
};
let (mut out, rest): (Vec<_>, Vec<_>) = picked.into_iter().partition(own);
// A leaf already listed is skipped; a set keeps this linear in the number of leaves.
let mut seen: std::collections::HashSet<vectorcraft_doc::NodeId> = out.iter().copied().collect();
for id in super::leaf_targets(s, &rest)? {
if !out.contains(&id) {
if seen.insert(id) {
out.push(id);
}
}
@@ -429,6 +431,52 @@ impl Session {
painted(first, true, &mut nodes);
node_stroke(nodes.first()?)
}
/// Do all the strokes that `stroke.set` edits without `ids` or `item` draw with a brush
/// ([`vectorcraft_brush::keeps_brush_size`])? If they do, a width profile changes none of
/// them, and the result is `Some`, holding whether any of them has a width profile. The result
/// is `None` when a profile changes at least one of them.
///
/// The strokes are the ones `stroke.set` edits:
/// - the Appearance panel's active stroke row in each target that has an equal row
/// ([`ItemTarget::per_target`]), and the top stroke in the others;
/// - else a selected group's own stroke;
/// - else the top strokes of the objects it paints ([`own_stroke_or_leaves`]).
///
/// The art of graph designs is left out, and so are images and symbol instances without an
/// active row. The result is also `None` with nothing selected, with an object inside a symbol
/// instance selected, with type among the targets while no Appearance row is active for it,
/// and with a target that has no stroke row, since `stroke.set` gives such a target a plain
/// stroke.
pub fn brushed_strokes_profiled(&self) -> Option<bool> {
const C: &str = "stroke.set";
let st = self.active()?;
if st.selected_symbol_part().is_some() {
return None;
}
let p = json!({});
let item = item_target(self, &p, C).ok()?.of_kind(self, false);
let ids = if item == ItemTarget::Top { own_stroke_or_leaves(self, &p).ok()? } else { item.targets(self, &p).ok()? };
let mut ids = super::appearance::drop_design_art_rows(self, ids, item, false, C).ok()?;
if item == ItemTarget::Top {
ids.retain(|id| !matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Image(_) | NodeKind::SymbolInstance { .. })));
}
let mut strokes = vec![];
for (id, each) in ids.iter().zip(item.per_target(self, &ids)) {
let n = st.doc.node(*id)?;
let row = each?.resolve(&n.appearance, false, C).ok()?;
if row.is_none() && matches!(n.kind, NodeKind::Text(_)) {
return None;
}
strokes.push(n.appearance.stroke_at(row).filter(|s| s.brush.is_some())?);
}
if strokes.is_empty() {
return None;
}
// The library is read only when every stroke names a brush.
let lib = vectorcraft_brush::library(&st.doc);
strokes.iter().all(|s| vectorcraft_brush::keeps_brush_size(&lib, s)).then(|| strokes.iter().any(|s| s.profile.is_some()))
}
}
impl DocState {
@@ -678,6 +726,7 @@ fn profile_list(s: &mut Session, _: &Value) -> Result<Value> {
#[cfg(test)]
mod tests {
use super::*;
use vectorcraft_doc::NodeId;
#[test]
fn weight_steps_follow_units_and_stop_at_their_bounds() {
@@ -693,4 +742,93 @@ mod tests {
assert!((step_weight(mm, Unit::Millimeters, true) - 2.0 * mm).abs() < 1e-9);
assert!((step_weight(mm, Unit::Millimeters, false) - 0.75 * mm).abs() < 1e-9);
}
fn run(s: &mut Session, id: &str, p: Value) -> Value {
s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"))
}
fn made(v: Value) -> NodeId {
NodeId(v["id"].as_u64().unwrap_or_else(|| panic!("no id in {v}")))
}
/// The targets of [`own_stroke_or_leaves`] merged by a linear search of the growing list.
fn listed_merge(s: &Session, p: &Value) -> Vec<NodeId> {
let d = &s.doc().unwrap().doc;
let own = |id: &NodeId| {
d.node(*id).is_some_and(|n| {
matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) && !n.is_compound_shape() && n.appearance.stroke().is_some()
})
};
let (mut out, rest): (Vec<_>, Vec<_>) = super::super::targets(s, p).unwrap().into_iter().partition(own);
for id in super::super::leaf_targets(s, &rest).unwrap() {
if !out.contains(&id) {
out.push(id);
}
}
out
}
/// `stroke.set` with no `item` lists the same targets in the same order as a linear merge:
/// groups and layers with a stroke of their own (repeats kept), the leaves of plain groups and
/// layers, compound paths and compound shapes for their members, and each leaf once, also
/// when it is named both directly and through its group.
#[test]
fn stroke_targets_match_the_listed_merge() {
let mut s = Session::new();
run(&mut s, "file.new", json!({"width": 2000, "height": 400}));
let base = s.doc().unwrap().doc.layers[0].id;
let mut x = 0.0;
let mut rect = |s: &mut Session| {
x += 120.0;
made(run(s, "shape.rectangle", json!({"x": x, "y": 100, "width": 100, "height": 100})))
};
let (a, b) = (rect(&mut s), rect(&mut s));
let plain = made(run(&mut s, "object.group", json!({"ids": [a.0, b.0]})));
let (c, d) = (rect(&mut s), rect(&mut s));
let owned = made(run(&mut s, "object.group", json!({"ids": [c.0, d.0]})));
run(&mut s, "appearance.addStroke", json!({"ids": [owned.0]}));
let (e, f) = (rect(&mut s), rect(&mut s));
run(&mut s, "select.set", json!({"ids": [e.0, f.0]}));
let compound = made(run(&mut s, "object.compoundPath.make", json!({})));
let (g, h) = (rect(&mut s), rect(&mut s));
run(&mut s, "select.set", json!({"ids": [g.0, h.0]}));
let shape = made(run(&mut s, "object.compoundShape.make", json!({})));
let lone = rect(&mut s);
let layer = made(run(&mut s, "layer.new", json!({})));
let (j, k) = (rect(&mut s), rect(&mut s));
run(&mut s, "appearance.addStroke", json!({"ids": [layer.0]}));
{
let doc = &s.doc().unwrap().doc;
assert_eq!((doc.parent_of(j), doc.parent_of(k)), (Some(layer), Some(layer)), "the new layer holds the last two");
assert_eq!((doc.parent_of(e), doc.parent_of(g)), (Some(compound), Some(shape)));
assert!(doc.node(owned).unwrap().appearance.stroke().is_some() && doc.node(layer).unwrap().appearance.stroke().is_some());
}
let named = json!({"ids": [plain.0, a.0, owned.0, owned.0, c.0, e.0, compound.0, g.0, lone.0, layer.0, j.0]});
let cases = [
named.clone(),
json!({"ids": [j.0, h.0, f.0, b.0, plain.0, layer.0, owned.0, k.0, shape.0]}),
json!({"ids": [base.0, layer.0, base.0]}),
json!({"ids": [d.0, owned.0, base.0]}),
json!({"ids": []}),
];
for p in &cases {
assert_eq!(own_stroke_or_leaves(&s, p).unwrap(), listed_merge(&s, p), "{p}");
}
run(&mut s, "select.set", json!({"ids": [lone.0, owned.0, f.0, plain.0, b.0, layer.0]}));
assert_eq!(own_stroke_or_leaves(&s, &json!({})).unwrap(), listed_merge(&s, &json!({})), "the selection");
// The edit reaches every listed target, counting a repeated one once, and leaves the other
// member of the group with its own stroke alone.
let want = listed_merge(&s, &named);
assert_eq!(want.iter().filter(|id| **id == owned).count(), 2, "{want:?}");
let distinct: std::collections::HashSet<_> = want.iter().collect();
let before = s.doc().unwrap().doc.node(d).unwrap().clone();
let r = run(&mut s, "stroke.set", json!({"ids": named["ids"], "weight": 3}));
let doc = &s.doc().unwrap().doc;
assert_eq!(r["objects"], distinct.len(), "{r} {want:?}");
for id in &want {
assert_eq!(doc.node(*id).unwrap().appearance.stroke().map(|st| st.width), Some(3.0), "{id:?}");
}
assert_eq!(doc.node(d), Some(&before), "a member reached only through its group's own stroke is left alone");
}
}
+7 -1
View File
@@ -318,8 +318,14 @@ impl Session {
/// it is still linked (still has that style's look). A graph series group that holds nothing of its own stands
/// for the topmost path directly inside it, which a style applied to the group links.
pub fn selection_graphic_style(&self) -> Option<(&GraphicStyle, bool)> {
self.graphic_style_of(*self.active()?.selection.subjects().first()?)
}
/// The graphic style of object `id` of the active document, as [`Self::selection_graphic_style`]
/// gives it for the first selected object.
pub fn graphic_style_of(&self, id: NodeId) -> Option<(&GraphicStyle, bool)> {
let st = self.active()?;
let n = super::appearance::look_holder(&st.doc, st.doc.node(*st.selection.subjects().first()?)?);
let n = super::appearance::look_holder(&st.doc, st.doc.node(id)?);
let g = st.doc.graphic_style_by_id(n.extras().graphic_style?)?;
Some((g, in_sync(n, g)))
}
+50 -1
View File
@@ -20,7 +20,7 @@ use super::clipboard::Clipboard;
use super::clipboard::resources::SwatchChoices;
use super::swatch::str_list;
use super::swatchlib::{FileData, LibraryFile, LibraryInfo, concealed_library_id, concealed_library_ids, shown_id, shown_library_id, stem};
use super::{CommandSpec, Result, Session, always, bad, bool_or, cmd, has_doc, number_or, str_param};
use super::{CommandSpec, Result, Session, always, bad, bool_or, cmd, has_doc, number_or, str_param, u64_req};
/// The extension of saved symbol libraries: native documents.
pub const SYMBOLS_EXT: &str = vectorcraft_format::EXTENSION;
@@ -54,6 +54,15 @@ pub fn specs() -> Vec<CommandSpec> {
has_doc,
add
),
cmd!(
"symbol.placeFromDocument",
"Place Symbol Instance",
[],
None,
"{sourceDocument: uid, name: a symbol of that document, x?, y?} place an instance of a symbol of another open document so its registration point is at (x, y) (default: the first artboard's center), as a symbol dragged from that document's Symbols panel onto the canvas is placed. The symbol, the symbols it nests and the resources they use are added as a drop of art from that document adds them, in the same undo step as the instance: a symbol the active document already has with the same name, art and Symbol Options is used, and one with the same name but other art or Symbol Options gets a number (\"Leaf 2\"); each symbol added takes its Symbol Options along. When sourceDocument is the active document, its own symbol is placed, as symbol.place places it. An error, with no edit, when that document is no longer open or has no symbol `name` → {id, name: the symbol's name in the active document}",
has_doc,
place_from_document
),
cmd!(
"symbol.saveLibrary",
"Save Symbol Library…",
@@ -630,6 +639,46 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
Ok(out)
}
/// `symbol.placeFromDocument`: an instance of symbol `name` of the open document `sourceDocument`
/// placed in the active document, with the symbol and the resources it uses added as a drop of
/// art from that document adds them, in one undo step. The source document is not changed.
fn place_from_document(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "symbol.placeFromDocument";
let uid = u64_req(p, "sourceDocument", C)?;
let name = str_param(p, "name").ok_or_else(|| bad(C, "missing `name`"))?;
let st = s.doc()?;
let centre = st.doc.artboards.first().map(|a| a.rect.center()).unwrap_or(Point::ZERO);
let at = Point::new(number_or(p, "x", centre.x, C)?, number_or(p, "y", centre.y, C)?);
let parent = st.target_parent()?;
let same = uid == st.uid;
let src = s.documents().iter().find(|d| d.uid == uid).map(|d| Arc::clone(&d.doc));
let src = src.ok_or_else(|| bad(C, "the document the symbol came from is no longer open"))?;
if !src.symbols.iter().any(|sym| sym.name == name) {
return Err(bad(C, format!("no symbol named `{name}` in the document it came from")));
}
// A symbol of the active document itself is placed as it is.
let clip = (!same).then(|| Clipboard::gather(&src, vec![instance(name)]));
// The source's colors are kept even where the active document has swatches of the same names.
let choices = SwatchChoices::parse(C, &json!({"swatchConflict": "add"}))?;
let (id, placed) = s.edit("Place Symbol Instance", |d, sel| {
let placed = match &clip {
// Each symbol added takes its Symbol Options along.
Some(clip) => {
let imported = clip.import_into(d, &choices, false)?;
let renamed = imported.renamed.iter().find(|r| r["kind"] == "symbol" && r["from"] == name).and_then(|r| r["to"].as_str());
renamed.unwrap_or(name).to_string()
}
None => name.to_string(),
};
let xf = place_xf(at, natural_size(d, &placed), d.symbol_registration(&placed));
let id = d.alloc_id();
d.insert(parent, usize::MAX, Node::new(id, NodeKind::SymbolInstance { symbol: placed.clone(), xf }))?;
sel.set([id]);
Ok((id, placed))
})?;
Ok(json!({ "id": id.0, "name": placed }))
}
fn save(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "symbol.saveLibrary";
let st = s.doc()?;
+1 -1
View File
@@ -95,7 +95,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Area Type Options…",
["Type"],
None,
"{ids?|id?, width?: pt, height?: pt, rows?, columns?, gutter?: pt (between rows and columns), rowGutter?: pt|null (between rows when it differs from gutter, which is then between columns; gutter given alone sets both; the reply gives the rows' gutter either way), inset?: pt, firstBaseline?: ascent|capHeight|xHeight|leading|fixed, firstBaselineMin?: pt, verticalAlign?: top|center|bottom|justify, flow?: columns|rows (Text Flow: down each column's rows, then across, the default; or across each row's columns, then down), fit?: none|autoHeight|shrinkText|block, fitMinPercent?: 10..100, wordGap?: % 0..1000, lineGap?: pt -1296..1296, …the keys of its own reply (it can be passed back; the values it only reports are ignored)} set the selected area type's options (each frame takes the options given over its own and keeps the rest; fit resolves against each frame's own; options that change nothing add no undo step); width and height size the type area from its top-left corner, along the type's own axes, and the text reflows at its size (with fit autoHeight, Auto Size, the frame's height follows the text after every edit and height is ignored; setting the height by hand turns it off); fit shrinkText scales overflowing text down (size, leading, baseline shift) by the largest factor down to fitMinPercent % (default 50) that makes it fit; fit block is Dynamic Text's Block, as type.dynamicText sets it (in place of Auto Size and Shrink Text to Fit; threaded frames are refused; another fit turns it off, keeping the sizes it wrote), and wordGap and lineGap set its gaps (kept while Block is off; out of range is an error) (none given: query) → the first object's options, plus wordGap and lineGap, overflow (the text doesn't fit its frame) and fitScale (Shrink Text's factor, 1 unshrunk)",
"{ids?|id?, width?: pt, height?: pt, rows?, columns?, gutter?: pt (between rows and columns), rowGutter?: pt|null (between rows when it differs from gutter, which is then between columns; gutter given alone sets both; the reply gives the rows' gutter either way), inset?: pt, firstBaseline?: ascent|capHeight|xHeight|leading|emBoxHeight|fixed (emBoxHeight: the top of the first line's ideographic em box, the largest on the line, touches the top of the type area inside the inset), firstBaselineMin?: pt (the least distance from that top to the first baseline; with fixed, the distance), verticalAlign?: top|center|bottom|justify, flow?: columns|rows (Text Flow: down each column's rows, then across, the default; or across each row's columns, then down), fit?: none|autoHeight|shrinkText|block, fitMinPercent?: 10..100, wordGap?: % 0..1000, lineGap?: pt -1296..1296, …the keys of its own reply (it can be passed back; the values it only reports are ignored)} set the selected area type's options (each frame takes the options given over its own and keeps the rest; fit resolves against each frame's own; options that change nothing add no undo step); width and height size the type area from its top-left corner, along the type's own axes, and the text reflows at its size (with fit autoHeight, Auto Size, the frame's height follows the text after every edit and height is ignored; setting the height by hand turns it off); fit shrinkText scales overflowing text down (size, leading, baseline shift) by the largest factor down to fitMinPercent % (default 50) that makes it fit; fit block is Dynamic Text's Block, as type.dynamicText sets it (in place of Auto Size and Shrink Text to Fit; threaded frames are refused; another fit turns it off, keeping the sizes it wrote), and wordGap and lineGap set its gaps (kept while Block is off; out of range is an error) (none given: query) → the first object's options, plus wordGap and lineGap, overflow (the text doesn't fit its frame) and fitScale (Shrink Text's factor, 1 unshrunk)",
has_selection,
area_options
),
@@ -2796,6 +2796,44 @@ fn area_options_columns_change_layout() {
assert!(s.execute("text.areaOptions", &json!({"firstBaseline": "nope"})).is_err());
}
/// First Baseline Em Box Height: set, reported and undone like the other kinds, with Min as the
/// least distance; setting it again adds no undo step, and the refusal of an unknown kind lists it.
#[test]
fn area_options_set_the_em_box_height_first_baseline() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
let id = s.execute("text.create", &json!({"x": 10, "y": 10, "text": "word ".repeat(20), "area": {"width": 300, "height": 120}})).unwrap()["id"]
.as_u64()
.unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let first = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
NodeKind::Text(t) => vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).lines[0].first_baseline,
_ => panic!("area type"),
};
let ascent = first(&s);
let r = s.execute("text.areaOptions", &json!({"firstBaseline": "emBoxHeight"})).unwrap();
assert_eq!((r["firstBaseline"].as_str(), r["firstBaselineMin"].as_f64()), (Some("emBoxHeight"), Some(0.0)));
let em_box = first(&s);
assert!(em_box > 0.0 && (em_box - ascent).abs() > 0.1, "{em_box} {ascent}");
let steps = s.doc().unwrap().history.undo.len();
s.execute("text.areaOptions", &json!({"firstBaseline": "emBoxHeight"})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), steps, "no change, no undo step");
// A Min nearer the top keeps the em box; one further down is the distance.
s.execute("text.areaOptions", &json!({"firstBaselineMin": em_box / 2.0})).unwrap();
assert!((first(&s) - em_box).abs() < 1e-9);
let r = s.execute("text.areaOptions", &json!({"firstBaselineMin": 30})).unwrap();
assert_eq!((r["firstBaseline"].as_str(), r["firstBaselineMin"].as_f64()), (Some("emBoxHeight"), Some(30.0)));
assert!((first(&s) - 30.0).abs() < 1e-9);
for _ in 0..3 {
s.execute("edit.undo", &json!({})).unwrap();
}
assert_eq!(s.execute("text.areaOptions", &json!({})).unwrap()["firstBaseline"], "ascent");
assert!((first(&s) - ascent).abs() < 1e-9);
let e = s.execute("text.areaOptions", &json!({"firstBaseline": "emBox"})).unwrap_err().to_string();
assert!(e.contains("emBoxHeight"), "{e}");
assert_eq!(s.execute("text.areaOptions", &json!({})).unwrap()["firstBaseline"], "ascent");
}
/// `rowGutter` sets a gutter between rows of its own, the reply passes it back, and a gutter
/// given alone is the rows' and the columns' again.
#[test]
+10
View File
@@ -25,6 +25,10 @@ pub struct DocState {
/// Panel state, not art selection: not saved, not undoable (`layer.setCurrent`,
/// `layer.highlight`).
pub layer_rows: Vec<NodeId>,
/// The row the last Locate Object or Locate Layer (`layer.locate`) highlighted, until the
/// Layers panel takes it: the panel opens the layers around that row and scrolls to it, also
/// when the row was already highlighted. Panel state: not saved, not undoable.
pub locate_reveal: Option<NodeId>,
/// The variable highlighted in the Variables panel: what its Delete, Options… and Select
/// Bound Object act on. Panel state, not art selection: not saved, not undoable
/// (`variable.highlight`). A name, so renaming a variable moves the highlight with it.
@@ -136,6 +140,10 @@ pub struct DocState {
/// same document comes to the front, its type set in them is not measured again. While this
/// reference lasts, its allocation holds no other document. Not saved.
pub(crate) measured_in_own: Option<(std::sync::Weak<Document>, std::collections::HashSet<String>)>,
/// The document as the last edit's refresh of inline graphics left it, and what that refresh
/// measured: the next refresh checks only the layer trees that differ from it
/// ([`cmd::inline::refresh`]). Not saved.
pub(crate) inline_resolved: Option<cmd::inline::Resolved>,
}
/// Whether a document has an artboard for Delete Empty Artboards to delete, with the document that
@@ -318,6 +326,7 @@ impl DocState {
revision: 1,
active_layer,
layer_rows: vec![],
locate_reveal: None,
variables_highlight: None,
variables_sort: Default::default(),
isolation: None,
@@ -355,6 +364,7 @@ impl DocState {
plugin_effects: Default::default(),
art_to_fit: Default::default(),
measured_in_own: None,
inline_resolved: None,
}
}
/// `measure`'s answer for the document now. `measure` runs once for each version of the document,
+245 -36
View File
@@ -25,7 +25,9 @@
//! guard against other programs on the computer.
//!
//! [`ScriptScope`] holds the folders a running script's own files (its includes and `$.evalFile`)
//! are read from, inside the roots.
//! are read from, and the places its `File` and `Folder` objects read and write, inside the roots.
//! [`ScriptGate`] holds the same places for the commands the script runs with `vc.run`, with the
//! files of the open documents.
use std::cell::RefCell;
use std::ffi::OsString;
@@ -174,7 +176,7 @@ fn with_scope<T>(scope: Option<Scope>, f: impl FnOnce() -> T) -> T {
/// Run `f` with `roots` in force on this thread (`None`: as things stand).
pub fn confine<T>(roots: Option<&Arc<AutomationRoots>>, f: impl FnOnce() -> T) -> T {
match roots {
Some(r) => with_scope(Some(Scope::Confined(r.clone())), f),
Some(r) => with_gate_reads_exempt(false, || with_scope(Some(Scope::Confined(r.clone())), f)),
None => f(),
}
}
@@ -182,25 +184,111 @@ pub fn confine<T>(roots: Option<&Arc<AutomationRoots>>, f: impl FnOnce() -> T) -
/// Run `f` with no roots in force on this thread: what the person at the keyboard does, and the
/// app's own folders.
pub fn unconfined<T>(f: impl FnOnce() -> T) -> T {
with_scope(Some(Scope::Unconfined), f)
with_gate_reads_exempt(true, || with_scope(Some(Scope::Unconfined), f))
}
/// This thread's scope, to carry to work it hands to another thread ([`ScopeHandle::run`]).
thread_local! {
/// Are reads on this thread exempt from the gate of the script command it runs? Only inside an
/// [`unconfined`] entered after the gate was put in force ([`with_script_gate`]).
static GATE_READS_EXEMPT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
/// Puts the exemption it replaced back when dropped (also when `f` panics).
struct RestoreExempt(bool);
impl Drop for RestoreExempt {
fn drop(&mut self) {
GATE_READS_EXEMPT.with(|e| e.set(self.0));
}
}
fn with_gate_reads_exempt<T>(exempt: bool, f: impl FnOnce() -> T) -> T {
let _restore = RestoreExempt(GATE_READS_EXEMPT.with(|e| e.replace(exempt)));
f()
}
/// This thread's scope, with the gate of the script command it runs, to carry to work it hands to
/// another thread ([`ScopeHandle::run`]).
#[derive(Clone, Debug)]
pub struct ScopeHandle(Option<Scope>);
pub struct ScopeHandle(Option<Scope>, Option<Arc<ScriptGate>>, bool);
impl ScopeHandle {
/// The scope of the calling thread.
pub fn capture() -> Self {
Self(SCOPE.with(|s| s.borrow().clone()))
Self(SCOPE.with(|s| s.borrow().clone()), GATE.with(|g| g.borrow().clone()), GATE_READS_EXEMPT.with(std::cell::Cell::get))
}
/// Run `f` in the captured scope.
pub fn run<T>(self, f: impl FnOnce() -> T) -> T {
with_scope(self.0, f)
let Self(scope, gate, exempt) = self;
with_gate(gate, || with_gate_reads_exempt(exempt, || with_scope(scope, f)))
}
}
/// What a command a running script runs (`vc.run`) may read and write: the places the script's
/// `File` and `Folder` objects may ([`ScriptScope`]), and the files the documents open in the app
/// were opened from or saved to. The automation roots apply as well. A path refused by its name
/// alone ([`ScriptScope::refused_by_name`]) is refused here too.
#[derive(Clone, Debug)]
pub(crate) struct ScriptGate {
pub(crate) read: ScriptScope,
pub(crate) write: ScriptScope,
/// The paths of the open documents' files, as the documents hold them.
pub(crate) documents: Vec<String>,
}
impl ScriptGate {
fn check(&self, path: &str, access: Access) -> Result<(), String> {
let real = if ScriptScope::refused_by_name(Path::new(path)) { None } else { resolve(path).ok() };
let allowed = real.is_some_and(|real| {
let scoped = match access {
Access::Read => self.read.allows(&real) || self.write.allows(&real),
Access::Write => self.write.allows(&real),
};
scoped || self.documents.iter().any(|d| resolve(d).is_ok_and(|d| d == real))
});
if allowed { Ok(()) } else { Err(format!("Script file access denied: {path}")) }
}
}
thread_local! {
/// The gate of the script command this thread runs ([`with_script_gate`]).
static GATE: RefCell<Option<Arc<ScriptGate>>> = const { RefCell::new(None) };
}
/// Puts the gate it replaced back when dropped (also when `f` panics).
struct RestoreGate(Option<Arc<ScriptGate>>);
impl Drop for RestoreGate {
fn drop(&mut self) {
let previous = self.0.take();
GATE.with(|g| *g.borrow_mut() = previous);
}
}
fn with_gate<T>(gate: Option<Arc<ScriptGate>>, f: impl FnOnce() -> T) -> T {
let _restore = RestoreGate(GATE.with(|g| g.replace(gate)));
f()
}
/// Runs `f`, a command a script runs, with `gate` in force on this thread: every path it reads or
/// writes must pass the gate as well as the automation roots, also when the run itself is
/// [`unconfined`] (one the person started). Reads of the app's own folders, inside an
/// [`unconfined`] the command enters, are not checked; writes there are, so a script's command
/// does not save into the app's libraries.
pub(crate) fn with_script_gate<T>(gate: ScriptGate, f: impl FnOnce() -> T) -> T {
with_gate(Some(Arc::new(gate)), || with_gate_reads_exempt(false, f))
}
/// May `path` be read (or written) by the script command this thread runs? Always outside one,
/// and for a read inside an [`unconfined`] the command entered.
fn check_gate(path: &str, access: Access) -> Result<(), String> {
if matches!(access, Access::Read) && GATE_READS_EXEMPT.with(std::cell::Cell::get) {
return Ok(());
}
GATE.with(|g| g.borrow().clone()).map_or(Ok(()), |g| g.check(path, access))
}
/// The roots in force on this thread, if any.
pub fn current() -> Option<Arc<AutomationRoots>> {
match SCOPE.with(|s| s.borrow().clone()) {
@@ -210,9 +298,11 @@ pub fn current() -> Option<Arc<AutomationRoots>> {
}
}
/// May `path` be read here? Always, without roots in force.
/// May `path` be read here? Always, without roots in force and outside a script's command
/// ([`with_script_gate`]).
pub fn check_read(path: &str) -> Result<(), String> {
current().map_or(Ok(()), |r| r.check(path, Access::Read))
current().map_or(Ok(()), |r| r.check(path, Access::Read))?;
check_gate(path, Access::Read)
}
/// Is `path`, under a read root, written as an absolute path of another platform: outside Windows, one
@@ -229,9 +319,11 @@ pub fn is_path_key(key: &str) -> bool {
crate::cmd::key_location(key).is_some()
}
/// May `path` be written here? Always, without roots in force.
/// May `path` be written here? Always, without roots in force and outside a script's command
/// ([`with_script_gate`]).
pub fn check_write(path: &str) -> Result<(), String> {
current().map_or(Ok(()), |r| r.check(path, Access::Write))?;
check_gate(path, Access::Write)?;
WRITES.with(|w| {
if let Some(paths) = w.borrow_mut().as_mut()
&& !paths.iter().any(|(p, _)| p == path)
@@ -323,6 +415,12 @@ fn inside(path: &Path, root: &Path) -> bool {
root.components().all(|r| path.next().is_some_and(|p| same_component(p, r)))
}
/// Is `path` `root` or inside it, both with their links followed, compared as [`AutomationRoots`]
/// compares them?
pub(crate) fn path_inside(path: &Path, root: &Path) -> bool {
inside(path, root)
}
fn same_component(a: Component, b: Component) -> bool {
if a == b {
return true;
@@ -374,10 +472,21 @@ fn windows_name_refusal(path: &str) -> Option<&'static str> {
/// The file opened is the path with its links followed, and after reading, the path is followed
/// again and must still lead to the same place: a process that changes the folders twice in between
/// can still win that race.
///
/// A scope can also be given more folders ([`ScriptScope::add`]) and single files
/// ([`ScriptScope::add_file`]), and folders it keeps out even inside a granted folder
/// ([`ScriptScope::fence`]), each but the places inside it that stay open. A granted file grants its
/// own path only, also when a folder later takes its place.
#[derive(Clone, Debug, Default)]
pub(crate) struct ScriptScope {
/// The granted folders, made absolute with their links followed.
roots: Vec<PathBuf>,
/// The granted files, made absolute with their links followed.
files: Vec<PathBuf>,
/// The folders kept out, with their links followed.
fenced: Vec<PathBuf>,
/// The places inside a fenced folder that are not kept out.
open: Vec<PathBuf>,
}
/// Why a script's file was not read.
@@ -396,18 +505,68 @@ pub(crate) enum ScriptRead {
impl ScriptScope {
/// The scope of a script run from a file in folder `dir`: that folder.
pub(crate) fn of_folder(dir: &Path) -> Self {
Self { roots: std::fs::canonicalize(dir).ok().into_iter().collect() }
Self { roots: std::fs::canonicalize(dir).ok().into_iter().collect(), ..Self::default() }
}
/// Grants the folder `real`, a path with its links followed, with everything inside it.
pub(crate) fn add(&mut self, real: PathBuf) {
if !self.roots.contains(&real) {
self.roots.push(real);
}
}
/// Grants the file `real`, a path with its links followed: that path and nothing below it.
pub(crate) fn add_file(&mut self, real: PathBuf) {
if !self.files.contains(&real) {
self.files.push(real);
}
}
/// Takes back the grant of the folder (`folder`) or file `real` that [`ScriptScope::add`] or
/// [`ScriptScope::add_file`] gave.
pub(crate) fn remove(&mut self, real: &Path, folder: bool) {
if folder { self.roots.retain(|r| r != real) } else { self.files.retain(|r| r != real) }
}
/// Is nothing granted?
fn is_empty(&self) -> bool {
self.roots.is_empty() && self.files.is_empty()
}
/// Keeps the folder `real` (links followed) and everything in it out, but for `open` and the
/// places inside it.
pub(crate) fn fence(&mut self, real: PathBuf, open: &[PathBuf]) {
self.fenced.push(real);
self.open.extend(open.iter().cloned());
}
/// Leaves the place `real` (links followed) and everything in it open inside a fenced folder.
pub(crate) fn fence_open(&mut self, real: PathBuf) {
self.open.push(real);
}
/// The granted folders, with their links followed.
pub(crate) fn roots(&self) -> &[PathBuf] {
&self.roots
}
/// Is the real path `real` a granted file or inside a granted folder, and not kept out? A place
/// left open counts only inside the fenced folder: one that holds the fenced folder opens none of it.
pub(crate) fn allows(&self, real: &Path) -> bool {
(self.files.iter().any(|f| inside(real, f) && real.components().count() == f.components().count())
|| self.roots.iter().any(|r| inside(real, r)))
&& !self.fenced.iter().any(|f| inside(real, f) && !self.open.iter().any(|o| inside(o, f) && inside(real, o)))
}
/// The scope of a script run from a file in the folder whose real path, with its links already
/// followed, is `real`: that folder, which is not looked up again.
pub(crate) fn of_real_folder(real: PathBuf) -> Self {
Self { roots: vec![real] }
Self { roots: vec![real], ..Self::default() }
}
/// Is `path` refused by its name alone: a `..` component, a NUL, a Windows device name or
/// stream, or a computer on the network?
fn refused_by_name(path: &Path) -> bool {
pub(crate) fn refused_by_name(path: &Path) -> bool {
let text = path.to_string_lossy();
text.contains('\0')
|| path.components().any(|c| c == Component::ParentDir)
@@ -417,7 +576,7 @@ impl ScriptScope {
/// The real path of the file at `path` and its first `max` bytes, at most.
pub(crate) fn read(&self, path: &Path, max: usize) -> Result<(PathBuf, Vec<u8>), ScriptRead> {
use std::io::Read;
if self.roots.is_empty() || Self::refused_by_name(path) || check_read(&path.to_string_lossy()).is_err() {
if self.is_empty() || Self::refused_by_name(path) || check_read(&path.to_string_lossy()).is_err() {
return Err(ScriptRead::Refused);
}
let real = match std::fs::canonicalize(path) {
@@ -428,7 +587,7 @@ impl ScriptScope {
}
Err(e) => return Err(ScriptRead::Failed(e.to_string())),
};
if !self.roots.iter().any(|r| inside(&real, r)) {
if !self.allows(&real) {
return Err(ScriptRead::Refused);
}
let file = std::fs::File::open(&real).map_err(|e| ScriptRead::Failed(e.to_string()))?;
@@ -456,24 +615,24 @@ impl ScriptScope {
self.roots.first().map(|r| crate::cmd::findfiles::plain(r.clone()))
}
/// Does the absolute path `path` name a granted folder or a place inside one, by its names
/// alone, without regard to case? A path that does not is refused before the file system is
/// asked anything about it.
/// Does the absolute path `path` name a granted file, a granted folder or a place inside one,
/// by its names alone, without regard to case? A path that does not is refused before the file
/// system is asked anything about it.
fn names_inside(&self, path: &Path) -> bool {
let lower = |c: Component| c.as_os_str().to_string_lossy().to_lowercase();
path.is_absolute()
&& self.roots.iter().any(|r| {
let root = crate::cmd::findfiles::plain(r.clone());
let mut names = path.components();
root.components().all(|c| names.next().is_some_and(|n| lower(n) == lower(c)))
})
let names_under = |r: &PathBuf| {
let root = crate::cmd::findfiles::plain(r.clone());
let mut names = path.components();
root.components().all(|c| names.next().is_some_and(|n| lower(n) == lower(c)))
};
path.is_absolute() && (self.roots.iter().any(names_under) || self.files.iter().any(names_under))
}
/// The real path of the file or folder at `path`, which must be absolute: refused as
/// [`ScriptScope::read`] refuses a path, and also when its names alone place it outside every
/// granted folder, in which case the file system is not asked about it.
pub(crate) fn locate(&self, path: &Path) -> Result<PathBuf, ScriptRead> {
if self.roots.is_empty() || Self::refused_by_name(path) || !self.names_inside(path) {
if self.is_empty() || Self::refused_by_name(path) || !self.names_inside(path) {
return Err(ScriptRead::Refused);
}
probed();
@@ -490,22 +649,72 @@ impl ScriptScope {
}
Err(e) => return Err(ScriptRead::Failed(e.to_string())),
};
if !self.roots.iter().any(|r| inside(&real, r)) {
if !self.allows(&real) {
return Err(ScriptRead::Refused);
}
Ok(real)
}
/// Is the missing `path` inside a granted folder: does the nearest folder above it that exists
/// lie inside one? On a file system where case matters, `MAIN/x` beside the granted `main` is
/// outside, whether `MAIN` exists or not. A link above it that leads to nothing is outside too,
/// so a script cannot tell whether the folder a link leads to exists.
/// The real path that writing to `path` writes: `path` with its links followed (the last
/// name's too only when `follow`), and for a path that does not exist yet, its nearest existing
/// folder's links followed and the rest appended. Refused as [`ScriptScope::locate`] refuses a
/// path, also when a link on the way leads nowhere, and when the automation write roots in force
/// ([`check_write`]) do not take it.
pub(crate) fn target(&self, path: &Path, follow: bool) -> Result<PathBuf, ScriptRead> {
if self.is_empty() || Self::refused_by_name(path) || !self.names_inside(path) {
return Err(ScriptRead::Refused);
}
probed();
if check_write(&path.to_string_lossy()).is_err() {
return Err(ScriptRead::Refused);
}
let (Some(parent), Some(name)) = (path.parent(), path.file_name()) else { return Err(ScriptRead::Refused) };
let real = match std::fs::symlink_metadata(path) {
Ok(_) if follow => std::fs::canonicalize(path).map_err(|_| ScriptRead::Refused)?,
Ok(m) => {
// Where case does not matter, the name given can differ in case from the name the
// file system keeps, so a file or folder that is not a link is checked under the
// kept name too.
if !m.file_type().is_symlink() && !std::fs::canonicalize(path).is_ok_and(|kept| self.allows(&kept)) {
return Err(ScriptRead::Refused);
}
std::fs::canonicalize(parent).map_err(|_| ScriptRead::Refused)?.join(name)
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
let mut missing = vec![name.to_os_string()];
let mut at = parent;
loop {
match std::fs::symlink_metadata(at) {
Ok(_) => break,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
missing.push(at.file_name().ok_or(ScriptRead::Refused)?.to_os_string());
at = at.parent().ok_or(ScriptRead::Refused)?;
}
Err(e) => return Err(ScriptRead::Failed(e.to_string())),
}
}
let mut real = std::fs::canonicalize(at).map_err(|_| ScriptRead::Refused)?;
real.extend(missing.iter().rev());
real
}
Err(e) => return Err(ScriptRead::Failed(e.to_string())),
};
// The automation write roots take the place written as well as the path named.
if !self.allows(&real) || check_write(&crate::cmd::findfiles::plain(real.clone()).to_string_lossy()).is_err() {
return Err(ScriptRead::Refused);
}
Ok(real)
}
/// Is the missing `path` inside a granted place: with the links of the nearest folder above it
/// that exists followed, and the rest of its names appended, is it granted? On a file system
/// where case matters, `MAIN/x` beside the granted `main` is outside, whether `MAIN` exists or
/// not. A link above it that leads to nothing is outside too, so a script cannot tell whether
/// the folder a link leads to exists.
fn missing_inside(&self, path: &Path) -> bool {
path.ancestors()
.skip(1)
.find(|a| std::fs::symlink_metadata(a).is_ok())
.and_then(|a| std::fs::canonicalize(a).ok())
.is_some_and(|real| self.roots.iter().any(|r| inside(&real, r)))
let Some(found) = path.ancestors().skip(1).find(|a| std::fs::symlink_metadata(a).is_ok()) else { return false };
let (Ok(real), Ok(rest)) = (std::fs::canonicalize(found), path.strip_prefix(found)) else { return false };
self.allows(&real.join(rest))
}
/// What the file or folder at `path` is, located as [`ScriptScope::locate`] locates it.
@@ -548,7 +757,7 @@ impl ScriptScope {
continue;
}
let Ok(target) = std::fs::canonicalize(entry.path()) else { continue };
if !self.roots.iter().any(|r| inside(&target, r)) || check_read(&entry.path().to_string_lossy()).is_err() {
if !self.allows(&target) || check_read(&entry.path().to_string_lossy()).is_err() {
continue;
}
if out.len() >= max {
+7
View File
@@ -32,6 +32,9 @@ pub struct HistoryEntry {
pub(crate) color_mode_paints: Option<(vectorcraft_tools::PaintDefaults, vectorcraft_tools::PaintDefaults)>,
/// Owned new-art snapshots included in both directional estimates.
color_mode_bytes: usize,
/// The state that changes without an undo step as the next state had it: undo and redo compare
/// it with `doc` to tell what the step changed.
pub(crate) unrecorded: Arc<crate::cmd::Unrecorded>,
}
impl Clone for HistoryEntry {
@@ -49,6 +52,7 @@ impl Clone for HistoryEntry {
serial: self.serial,
color_mode_paints: self.color_mode_paints.clone(),
color_mode_bytes: self.color_mode_bytes,
unrecorded: self.unrecorded.clone(),
}
}
}
@@ -94,6 +98,7 @@ impl HistoryEntry {
serial: next_serial(),
color_mode_paints: None,
color_mode_bytes: 0,
unrecorded: Arc::new(crate::cmd::Unrecorded::of(next)),
}
}
@@ -126,6 +131,7 @@ impl HistoryEntry {
serial: next_serial(),
color_mode_paints: None,
color_mode_bytes: 0,
unrecorded: Arc::new(crate::cmd::Unrecorded::of(now)),
}
}
@@ -337,6 +343,7 @@ impl History {
e.next_bytes = after.saturating_add(e.color_mode_bytes);
e.next = std::ptr::from_ref(now) as usize;
e.serial = next_serial();
e.unrecorded = Arc::new(crate::cmd::Unrecorded::of(now));
}
}
}
+5 -1
View File
@@ -28,7 +28,7 @@ use vectorcraft_tools::{PaintDefaults, Tool};
pub use cmd::clipboard::{Clipboard, SourceLayer};
pub use cmd::create::constrain_click;
pub use cmd::distortcmds::perspective_click;
pub use cmd::distortcmds::{perspective_click, width_point_pair};
pub use cmd::graph::{GraphTypeSubject, calculated_axes as graph_calculated_axes, graph_type_subject};
pub use cmd::params::{check_keys, check_params};
pub use cmd::pathops::auto_simplify_level;
@@ -185,6 +185,10 @@ pub struct Session {
/// The folder of the New Document profiles `file.new` starts documents from; `None`: none,
/// every document starts with the defaults ([`Session::attach_new_doc_profiles`]).
new_doc_profile_dir: Option<std::path::PathBuf>,
/// The folder of each script's data folder (`Folder.userData`), beside which the grants file
/// keeps the file access people allowed scripts; `None`: no folder
/// ([`Session::attach_script_data`]).
script_data_dir: Option<std::path::PathBuf>,
/// A filter's output that a run made in the background handed in for `plugin.run` to apply
/// ([`cmd::plugin::FilterRun::hand_in`]); the next `plugin.run` takes it.
plugin_output: Option<cmd::plugin::HandedIn>,
File diff suppressed because it is too large. Load diff
+152 -13
View File
@@ -38,7 +38,8 @@
//! `alert`, `confirm` and `prompt` open dialogs ([`dialogs`]): in the app the run waits for the
//! person's answer, and a run with nobody to ask takes its answers from `script.run`'s `answers`.
//!
//! `File` and `Folder` read files inside the script's own folder ([`files`]).
//! `File` and `Folder` read files inside the script's own folder, and write in the run's temporary
//! folder, the script's data folder and what a person allowed it in a file dialog ([`files`]).
//!
//! A script with `#targetengine name` runs in that named engine, which the session keeps with the
//! globals its runs leave, at most [`MAX_ENGINES`] of them with [`ENGINE_HEAP_BYTES`] of heap each
@@ -103,6 +104,31 @@ pub const MAX_ARGS_BYTES: usize = 1 << 20;
const SLICE_HOST_CALLS: u32 = 256;
/// The bytes that may cross between a script and the host in one run.
const MAX_BRIDGE_BYTES: u64 = 4 << 30;
/// The most files a run's report names in `written`; past them the report has `writtenMore`.
pub const MAX_WRITTEN: usize = 4096;
/// The files a run wrote, as its report names them: at most [`MAX_WRITTEN`], each once, in the
/// order they were first written, and whether it wrote more.
#[derive(Default)]
struct Written {
paths: Vec<String>,
seen: std::collections::HashSet<String>,
more: bool,
}
impl Written {
fn add(&mut self, path: String) {
if self.seen.contains(&path) {
return;
}
if self.paths.len() >= MAX_WRITTEN {
self.more = true;
return;
}
self.seen.insert(path.clone());
self.paths.push(path);
}
}
/// The version `vc.api.version` gives.
pub const API_VERSION: &str = "1.0";
@@ -259,9 +285,29 @@ struct KeptMap {
struct KeptMaps {
maps: std::collections::VecDeque<KeptMap>,
bytes: usize,
/// The SHA-256 of each source the engine's runs compiled (their scripts and what they
/// evaluated), at most [`MAX_ENGINE_CODE`], and whether there were more: a later run's kept file
/// grants are in force only for code they were kept for ([`files::Disk`]).
code: std::collections::BTreeSet<String>,
code_full: bool,
}
/// The most sources whose SHA-256 a named engine keeps.
pub const MAX_ENGINE_CODE: usize = 1024;
impl KeptMaps {
/// Adds the sources `code` (and whether a run had more than it counted) to the engine's code.
fn keep_code(&mut self, (code, more): (Vec<String>, bool)) {
self.code_full |= more;
for hash in code {
if self.code.len() >= MAX_ENGINE_CODE && !self.code.contains(&hash) {
self.code_full = true;
} else {
self.code.insert(hash);
}
}
}
fn keep(&mut self, tag: u32, map: include::SourceMap, script: Option<Arc<str>>) {
let bytes = map.bytes() + script.as_ref().map_or(0, |s| s.len());
let limit = kept_map_bytes();
@@ -705,7 +751,7 @@ struct Host {
waiting: Cell<bool>,
log: RefCell<Vec<Value>>,
log_bytes: Cell<usize>,
written: RefCell<Vec<String>>,
written: RefCell<Written>,
/// The run's number in its session, and the script's name, which its console lines carry.
run: u64,
name: Arc<str>,
@@ -822,6 +868,7 @@ impl Host {
return;
}
let mut kept = kept.borrow_mut();
kept.keep_code(self.disk.borrow().code());
kept.keep(tag, std::mem::take(&mut *self.script_map.borrow_mut()), Some(self.report_name.clone()));
for (n, map) in std::mem::take(&mut *self.eval_maps.borrow_mut()).into_iter().enumerate() {
match u32::try_from(n + 1).ok().and_then(|n| tag.checked_add(n)).filter(|t| *t != vectorcraft_js::UNKNOWN_SOURCE) {
@@ -944,6 +991,35 @@ impl Host {
Some(left)
}
/// Adds `paths`, files the script's `File` and `Folder` objects wrote, to the report's `written`.
fn note_written(&self, paths: Vec<String>) {
let mut written = self.written.borrow_mut();
for path in paths {
written.add(path);
}
}
/// Adds `writtenMore: true` to `report` when the run wrote more files than its `written` names.
fn more_written(&self, report: &mut Value) {
if self.written.borrow().more
&& let Some(o) = report.as_object_mut()
{
o.insert("writtenMore".into(), json!(true));
}
}
/// Writes the files the script left open and adds every file written to the report's `written`.
/// → the files it could not write.
fn flush_files(&self) -> Vec<String> {
let mut disk = self.disk.borrow_mut();
let failed = disk.flush_all();
disk.record_code();
let paths = disk.take_written();
drop(disk);
self.note_written(paths);
failed
}
fn over(&self, limit: &str) -> HostError {
HostError::Abort(limit.to_string())
}
@@ -1160,13 +1236,13 @@ fn step(s: &mut Session, host: &Host, id: &str, params: &Value) -> Result<(Value
let before: Vec<(u64, Arc<crate::Document>, u64)> =
if mutating { s.docs.iter().map(|d| (d.uid, d.doc.clone(), d.doc.peek_next_id())).collect() } else { Vec::new() };
crate::file_access::start_recording_writes();
let r = s.execute(id, params);
// The command reads and writes only where the script's own files may, and the open documents' files.
let gate = host.disk.borrow().gate(s.docs.iter().filter_map(|d| d.path.clone()).collect());
let r = crate::file_access::with_script_gate(gate, || s.execute(id, params));
// A file a command wrote before it failed is on disk all the same.
let mut written = host.written.borrow_mut();
for path in crate::file_access::finish_recording_writes(r.is_ok()) {
if !written.contains(&path) {
written.push(path);
}
written.add(path);
}
drop(written);
match r {
@@ -1733,6 +1809,32 @@ impl Session {
with_job(k, |j| j.host.dialogs.answer(&mut j.realm, answer)).unwrap_or(false)
}
/// The file dialog (`File.openDialog`, `File.saveDialog`, `Folder.selectDialog` and the objects'
/// `openDlg`, `saveDlg` and `selectDlg`) the running script waits at. A run asked to stop no
/// longer waits.
pub fn script_picker(&self) -> Option<files::ScriptPicker> {
if self.script_stop.is_set() {
return None;
}
self.script_key.as_ref().and_then(|k| with_job(k, |j| j.host.disk.borrow().picker.clone())).flatten()
}
/// Gives the file dialog the running script waits at its answer: the paths the person picked
/// and allowed, or a denial. The next [`Session::script_pump`] goes on from the call. → false
/// when no file dialog waits.
pub fn script_pick(&mut self, answer: files::PickAnswer) -> bool {
let Some(k) = self.script_key.as_ref().filter(|_| !self.script_stop.is_set()) else { return false };
with_job(k, |j| {
let Some(data) = j.host.disk.borrow_mut().answer(answer) else { return false };
j.host.note_written(j.host.disk.borrow_mut().take_written());
if let Err(e) = j.realm.answer(data) {
j.host.disk.borrow_mut().failed = Some(e);
}
true
})
.unwrap_or(false)
}
/// The name of the running script.
pub fn script_name(&self) -> Option<String> {
self.script_key.as_ref().and_then(|k| with_job(k, |j| j.name.clone()))
@@ -1859,7 +1961,17 @@ impl Session {
realm.set_limits(limits);
realm
}
None => Realm::with_options(options, limits),
None => {
let mut realm = Realm::with_options(options, limits);
// Code the run evaluates withdraws the kept file grants not kept for it, before it runs.
let l = link.clone();
realm.observe_code(move |units| {
if let Ok(h) = current(&l) {
h.disk.borrow_mut().saw_code(units);
}
});
realm
}
};
realm.share_interrupt(&self.script_stop);
realm.set_data_limits(DataLimits::default());
@@ -1879,7 +1991,7 @@ impl Session {
waiting: Cell::new(false),
log: RefCell::new(Vec::new()),
log_bytes: Cell::new(0),
written: RefCell::new(Vec::new()),
written: RefCell::new(Written::default()),
run: self.script_runs,
name: console::line_name(&name),
console: RefCell::default(),
@@ -1888,7 +2000,20 @@ impl Session {
commands: RefCell::default(),
run_nanos: Cell::new(0),
dialogs: dialogs::Dialogs::new(self.script_frames, &realm, request.answers),
disk: RefCell::new(files::Disk::new(files.scope())),
disk: RefCell::new(files::Disk::new(
files.scope(),
files::Setup {
framed: self.script_frames,
script: request.file.clone(),
// The text with its included files, so a changed included file asks again.
source: expanded.as_ref().map_or_else(|_| request.source.clone(), |e| e.source.clone()),
data_dir: self.script_data_dir.clone(),
engine_code: kept_maps.as_ref().map_or_else(Default::default, |m| {
let m = m.borrow();
(m.code.iter().cloned().collect(), m.code_full)
}),
},
)),
files: RefCell::new(files),
script_map: RefCell::default(),
eval_maps: RefCell::default(),
@@ -1978,14 +2103,16 @@ impl Session {
self.script_gone(key, console::Ending::Internal);
return Some(Err(EngineError::Other(JOB_GONE.to_string())));
};
if let Some(e) = job.host.dialogs.take_failure() {
let picker_failed = job.host.disk.borrow_mut().failed.take();
if let Some(e) = job.host.dialogs.take_failure().or(picker_failed) {
return Some(self.script_failed(job, &e));
}
// A canceled request ends a sleep or a wait at this pump.
if vectorcraft_doc::cancel::check().is_err() {
self.script_stop.set();
}
if (job.host.waiting.get() || job.host.asleep().is_some() || job.host.dialogs.is_waiting()) && !self.script_stop.is_set() {
let picking = job.host.disk.borrow().picker.is_some();
if (job.host.waiting.get() || job.host.asleep().is_some() || job.host.dialogs.is_waiting() || picking) && !self.script_stop.is_set() {
JOBS.with(|jobs| jobs.borrow_mut().insert(key.id, job));
self.script_key = Some(key);
return None;
@@ -2029,6 +2156,9 @@ impl Session {
fn script_failed(&mut self, job: Job, e: &RunError) -> Result<Value> {
job.host.dialogs.stopped();
job.host.disk.borrow_mut().picker = None;
// The run fails already; a file it could not write is left out of `written`.
let _ = job.host.flush_files();
let fuel_left = job.realm.fuel_left();
let (e, file) = located(&job.host, &job.realm, e);
let mut report = failure_report(&job.name, &e, file.as_deref(), &job.host, fuel_left, job.realm.limits().fuel.saturating_sub(fuel_left));
@@ -2046,6 +2176,12 @@ impl Session {
/// Makes the working copy the session's state: one undo step for each document whose art
/// changed, nothing for the others.
fn script_commit(&mut self, mut job: Job) -> Result<Value> {
let unwritten = job.host.flush_files();
if !unwritten.is_empty() {
let message = format!("{UNWRITTEN_FILES}: {}", unwritten.join(", "));
let e = RunError { kind: RunErrorKind::Thrown, message, line: 0, column: 0 };
return self.script_failed(job, &e);
}
// The working copy goes into the session; `job.world` holds the state before the run.
job.world.swap(self);
self.prefs = merged_prefs(&job.world.start_prefs, &self.prefs, &job.world.choices.prefs);
@@ -2109,11 +2245,12 @@ impl Session {
"ok": true,
"name": job.name,
"changed": changed_names,
"written": *host.written.borrow(),
"written": host.written.borrow().paths,
"log": *host.log.borrow(),
"fuelUsed": job.realm.limits().fuel - job.realm.fuel_left(),
"hostCalls": host.calls.get(),
});
host.more_written(&mut report);
close_run(self, host, &mut report, console::Ending::Finished);
self.end_job(job, false);
self.script_report = Some(report.clone());
@@ -2140,6 +2277,7 @@ impl Session {
const OPEN_EDIT: &str = "a drag or an undo group is open; finish it before running a script";
const INVALID_RESULT: &str = "the script left a document that cannot be kept";
const UNWRITTEN_FILES: &str = "Error: the script left open files that could not be written";
const JOB_GONE: &str = "the script's run is no longer available";
const HISTORY_LOST: &str = "a failed command changed undo steps that could not be put back, so the script was stopped";
// Text a script reads from the errors it catches, or that ends its run with its name and place.
@@ -2168,12 +2306,13 @@ fn failure_report(name: &str, e: &RunError, file: Option<&str>, host: &Host, fue
"name": name,
"line": e.line,
"column": e.column,
"written": *host.written.borrow(),
"written": host.written.borrow().paths,
"log": *host.log.borrow(),
"fuelLeft": fuel_left,
"fuelUsed": fuel_used,
"hostCalls": host.calls.get(),
});
host.more_written(&mut report);
if let (Some(file), Some(o)) = (file, report.as_object_mut()) {
o.insert("file".into(), json!(file));
}
+1
View File
@@ -98,6 +98,7 @@ impl Session {
scripts_dir: None,
metadata_templates_dir: None,
new_doc_profile_dir: None,
script_data_dir: None,
plugin_output: None,
plugin_install_approval: None,
plugin_grants_from_requests: false,
+7 -2
View File
@@ -53,7 +53,8 @@ impl Session {
let mut symbol_synced =
if st.doc.symbol_edit.is_some() { cmd::symboledit::sync(&before, Arc::make_mut(&mut st.doc)) } else { Ok(()) };
// Inline graphics in text follow their symbols.
cmd::inline::refresh(&before, Arc::make_mut(&mut st.doc));
let measured = cmd::inline::refresh(st.inline_resolved.as_ref(), &before, Arc::make_mut(&mut st.doc));
let mut resolved = measured.map(|m| (st.doc.clone(), m));
// The document the passes below start from, for the symbol to follow what they
// change on its editing layer.
let synced = st.doc.symbol_edit.is_some().then(|| st.doc.clone());
@@ -86,7 +87,10 @@ impl Session {
let new = art(&st.doc);
if symbol_synced.is_ok() && !matches!((&old, &new), (Some(a), Some(b)) if Arc::ptr_eq(a, b)) {
let resynced = st.doc.clone();
cmd::inline::refresh(synced, Arc::make_mut(&mut st.doc));
let last = resolved.as_ref().or(st.inline_resolved.as_ref());
if let Some(m) = cmd::inline::refresh(last, synced, Arc::make_mut(&mut st.doc)) {
resolved = Some((st.doc.clone(), m));
}
if !st.doc.text_threads.is_empty() {
cmd::threads::reflow(&resynced, Arc::make_mut(&mut st.doc));
}
@@ -100,6 +104,7 @@ impl Session {
if !st.doc.variables.bindings.is_empty() {
Arc::make_mut(&mut st.doc).prune_variable_bindings();
}
st.inline_resolved = resolved;
if let Err(e) = symbol_synced {
Err(e)
} else if st.doc.too_deep(Some(&before)) {
+6 -2
View File
@@ -122,6 +122,7 @@ mod paintproxy;
mod panelcmds;
mod paragraphs;
mod params;
mod params_cache;
mod path_menu_enabled;
mod pathfinder_clip;
mod pathops;
@@ -371,9 +372,12 @@ fn a_long_unknown_command_id_is_answered_at_once() {
fn action_batch_names_the_nearest_command_id() {
let mut s = session();
let e = s.execute("action.batch", &json!({"source": "dataSets", "commands": [{"command": "select.al"}]})).unwrap_err();
assert_eq!(e.to_string(), "invalid parameters for `action.batch`: commands[0]: unknown command `select.al`; did you mean `select.all`?");
assert_eq!(
e.to_string(),
"invalid parameters for `action.batch`: action step 1 (`select.al`) failed: unknown command `select.al`; did you mean `select.all`?"
);
let e = s.execute("action.batch", &json!({"source": "dataSets", "commands": [{"command": "nope"}]})).unwrap_err();
assert_eq!(e.to_string(), "invalid parameters for `action.batch`: commands[0]: unknown command `nope`");
assert_eq!(e.to_string(), "invalid parameters for `action.batch`: action step 1 (`nope`) failed: unknown command `nope`");
}
#[test]
+106
View File
@@ -227,6 +227,112 @@ fn stroke_options_on_a_group_with_its_own_stroke_edit_that_stroke() {
assert_eq!((st.paint, st.width), (Paint::solid(Color::BLACK), 3.0));
}
/// `brushed_strokes_profiled` reads the strokes `stroke.set` edits: a group's own stroke when it
/// has one, else its members'. It answers only while each of them draws with a brush, and not
/// while an object has no stroke row, which `stroke.set` would give a plain stroke.
#[test]
fn brushed_strokes_profiled_reads_the_strokes_stroke_set_edits() {
let mut s = session();
let (a, b) = (rect(&mut s, 100.0), rect(&mut s, 250.0));
run(&mut s, "brush.apply", json!({"ids": [a.0, b.0], "name": "3 pt. Round"}));
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
assert_eq!(s.brushed_strokes_profiled(), Some(false), "both draw with a brush, neither has a profile");
run(&mut s, "stroke.set", json!({"ids": [b.0], "profile": "lens"}));
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
assert_eq!(s.brushed_strokes_profiled(), Some(true), "one has a profile");
let g = NodeId(run(&mut s, "object.group", json!({"ids": [a.0, b.0]}))["id"].as_u64().unwrap());
run(&mut s, "select.set", json!({"ids": [g.0]}));
assert_eq!(s.brushed_strokes_profiled(), Some(true), "a group without its own stroke: its members'");
run(&mut s, "appearance.addStroke", json!({"ids": [g.0]}));
run(&mut s, "select.set", json!({"ids": [g.0]}));
assert_eq!(s.brushed_strokes_profiled(), None, "the group's own plain stroke takes the profile");
let c = rect(&mut s, 400.0);
run(&mut s, "appearance.removeItem", json!({"ids": [c.0], "index": 1}));
assert!(node(&s, c).appearance.stroke().is_none());
run(&mut s, "select.set", json!({"ids": [a.0, c.0]}));
assert_eq!(s.brushed_strokes_profiled(), None, "an object without a stroke row takes a plain stroke");
}
/// A compound shape's own stroke is the one `stroke.set` edits: brushed members do not count.
#[test]
fn brushed_strokes_profiled_reads_a_compound_shapes_own_stroke() {
let mut s = session();
let (a, b) = (rect(&mut s, 100.0), rect(&mut s, 120.0));
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
let c = NodeId(run(&mut s, "object.compoundShape.make", json!({"mode": "add"}))["id"].as_u64().unwrap());
assert!(node(&s, c).appearance.stroke().is_some_and(|st| st.brush.is_none()), "the compound shape's own plain stroke");
s.edit("Brush", |d, _| {
for id in [a, b] {
if let Some(st) = d.node_mut(id).and_then(|n| n.appearance.stroke_mut()) {
st.brush = Some("3 pt. Round".into());
}
}
Ok(())
})
.unwrap();
run(&mut s, "select.set", json!({"ids": [c.0]}));
assert_eq!(s.brushed_strokes_profiled(), None);
s.edit("Brush", |d, _| {
d.node_mut(c).unwrap().appearance.stroke_mut().unwrap().brush = Some("3 pt. Round".into());
Ok(())
})
.unwrap();
run(&mut s, "select.set", json!({"ids": [c.0]}));
assert_eq!(s.brushed_strokes_profiled(), Some(false));
}
/// A targeted layer with its own plain Stroke row active: `stroke.set` edits that row, so the
/// brushed path inside the layer does not count.
#[test]
fn brushed_strokes_profiled_reads_a_targeted_layers_active_stroke_row() {
let mut s = session();
let a = rect(&mut s, 100.0);
run(&mut s, "brush.apply", json!({"ids": [a.0], "name": "3 pt. Round"}));
let layer = s.doc().unwrap().doc.layers[0].id;
run(&mut s, "layer.target", json!({"id": layer.0}));
run(&mut s, "appearance.addStroke", json!({}));
let rows = &node(&s, layer).appearance.items;
let index = rows.iter().position(|it| matches!(it, AppearanceItem::Stroke(st) if st.brush.is_none())).expect("the layer's own stroke row");
run(&mut s, "appearance.setActiveItem", json!({"index": index}));
assert_eq!(s.brushed_strokes_profiled(), None, "the layer's plain stroke takes the profile");
run(&mut s, "stroke.set", json!({"profile": "lens"}));
assert!(node(&s, layer).appearance.items.get(index).is_some_and(|it| matches!(it, AppearanceItem::Stroke(st) if st.profile.is_some())));
assert!(node(&s, a).appearance.stroke().is_some_and(|st| st.profile.is_none()), "the brushed path is left as it was");
}
/// A symbol instance selected with a brushed path takes no stroke from `stroke.set`, so it does
/// not count; the brushed path alone decides.
#[test]
fn brushed_strokes_profiled_leaves_out_symbol_instances() {
let mut s = session();
let a = rect(&mut s, 100.0);
run(&mut s, "brush.apply", json!({"ids": [a.0], "name": "3 pt. Round"}));
let r = rect(&mut s, 300.0);
run(&mut s, "select.set", json!({"ids": [r.0]}));
let inst = NodeId(run(&mut s, "symbol.new", json!({"name": "Dot"}))["id"].as_u64().unwrap());
assert!(matches!(node(&s, inst).kind, NodeKind::SymbolInstance { .. }));
run(&mut s, "select.set", json!({"ids": [a.0, inst.0]}));
assert_eq!(s.brushed_strokes_profiled(), Some(false));
}
/// With the active row a stroke of the first object that another selected object has no equal
/// row for, `stroke.set` edits that object's top stroke, so its top stroke decides.
#[test]
fn brushed_strokes_profiled_falls_back_to_the_top_stroke_where_the_active_row_has_no_match() {
let mut s = session();
let (a, b) = (rect(&mut s, 100.0), rect(&mut s, 250.0));
run(&mut s, "select.set", json!({"ids": [a.0]}));
run(&mut s, "appearance.addStroke", json!({}));
run(&mut s, "brush.apply", json!({"ids": [a.0, b.0], "name": "3 pt. Round"}));
run(&mut s, "stroke.set", json!({"ids": [b.0], "weight": 5}));
let rows = &node(&s, a).appearance.items;
let index = rows.iter().position(|it| matches!(it, AppearanceItem::Stroke(st) if st.brush.is_some())).expect("a's brushed stroke");
assert!(index >= node(&s, b).appearance.items.len() || node(&s, b).appearance.items[index].is_fill(), "{rows:?}");
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
run(&mut s, "appearance.setActiveItem", json!({"index": index}));
assert_eq!(s.brushed_strokes_profiled(), Some(false), "b's top stroke has the brush too");
}
#[test]
fn text_items_take_item_paint() {
let mut s = session();
+17
View File
@@ -302,6 +302,23 @@ fn the_shared_settings_drive_the_export_and_arent_an_undo_step() {
assert_eq!(run(&mut s, "document.exportSettings", json!({}))["settings"]["formats"][0]["format"], "jpg");
}
/// The shared settings are not an undo step, so undo and redo of the steps before them leave them
/// as they are.
#[test]
fn undo_and_redo_keep_the_shared_settings() {
let mut s = session();
let a = rect(&mut s, 10.0, 10.0, 20.0, 20.0);
run(&mut s, "assets.add", json!({"ids": [a]}));
run(&mut s, "assets.settings.set", json!({"formats": [{"format": "svg"}], "prefix": "ic_"}));
let settings = run(&mut s, "document.exportSettings", json!({}))["settings"].clone();
run(&mut s, "edit.undo", json!({}));
assert_eq!(run(&mut s, "document.exportSettings", json!({}))["settings"], settings);
run(&mut s, "assets.settings.set", json!({"formats": [{"format": "jpg"}], "prefix": ""}));
let settings = run(&mut s, "document.exportSettings", json!({}))["settings"].clone();
run(&mut s, "edit.redo", json!({}));
assert_eq!(run(&mut s, "document.exportSettings", json!({}))["settings"], settings);
}
/// An export preset sets the shared settings as the Asset Export panel applies one: its rows (or
/// mobile/density), its format settings over the saved ones, its prefix and its sub-folders.
#[test]
Loaded 100 of 401 files, more files were not shown because too many files have changed in this diff. Show more