Merge main into #8376

# Conflicts:
#	docs/target-app-parity.md
This commit is contained in:
bflatastic committed 2026-11-19 15:06:37 +07:00
commit f1bb326720
360 files changed
+37533 -1501

No files matched your search

+1
View File
@@ -135,6 +135,7 @@ Generated-in-code art is original and has no file to list. This covers the defau
| `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 | |
| `assets/icons/dc-crystallize.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-cube.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-curvature-circle.svg` | VectorCraft contributors | Original work, drawn for VectorCraft (an arch with the circle that touches it at its top, and that circle's center) | MIT OR Apache-2.0 | |
| `assets/icons/dc-dash-align.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-dash-exact.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-dimension.svg` | Osama Amin | Original work, drawn for VectorCraft: a dimension line with arrowheads between two extension lines | MIT OR Apache-2.0 | |
+3
View File
@@ -140,6 +140,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 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-17: Curvature Circle tool (after the Circle tool in its group): a click on a path draws the circle that touches it there and bends as it bends, on the side it bends toward, or with Shift on the other side; a segment that is the usual cubic of a circular arc of 90° or less gives the arc's own radius, so a click on a circle draws that circle; the tool shows the circle, its center and its radius (with an asterisk for an arc's radius) until the click, or "Straight segment", "Cusp", "Corner" or "Circle too large" where it draws none (`shape.curvatureCircle`). One undo step per circle. A VectorCraft addition: headline numbers 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`).
@@ -150,10 +151,12 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 2026-11-01: Randomize Opacity joins the Arrange Tools add-on (Object › Plug-ins › Arrange Tools): each selected object gets its own opacity at random between a minimum and a maximum percent, with a seed that repeats the result, as one undo step (`addon.arrange.randomizeOpacity`, #4925).
- 2026-11-01: Sort Objects joins the Arrange Tools add-on (Object › Plug-ins › Arrange Tools): the selected objects are sorted by width, height, area, position, opacity or stacking order (small to large, large to small or at random) and take another of those in that order, trading their values or stepping them evenly, as one undo step (`addon.arrange.sort`, #4917).
- 2026-11-15: Tangent Circle joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): the circles that touch two selected paths or compound paths at a set radius, or three of them (up to eight for three circles), touching each outline without crossing it; circles, rotated ellipses and other paths alike. A dialog that previews every circle or one picked by number, the current paint, one undo step (`addon.pathtools.tangentCircle`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-17: Add Bounding Rectangle and Add Bounding Circle join the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): a live rectangle on the selection's geometric bounding box, or the smallest live circle that holds its outlines, around the whole selection or around each object, with the current paint and one undo step; the menu items open a dialog with Offset, One per Object and Preview (`addon.pathtools.boundingRectangle`, `addon.pathtools.boundingCircle`, #6966). A VectorCraft addition: headline numbers unchanged.
- 2026-11-01: New Symbols from Layers joins the Document Tools add-on (Object › Plug-ins › Document Tools): one symbol of each top-level layer's art (the layers highlighted in the Layers panel when two or more are, else every layer), named after the layer, made as New Symbol makes one; Convert Layers to Symbols also puts an instance of each in place of its layer's art. Empty layers are skipped and reported; one undo step. A VectorCraft addition: headline numbers unchanged.
- 2026-11-01: Document Tools, a built-in add-on (Object › Plug-ins › Document Tools), starts with Save a Timestamped Copy: a copy of the document named `<name>_YYYY-MM-DD_HH-MM` (UTC; `-2`, `-3`… when that name is taken) goes next to it, or into a folder picked for a document never saved, written as File › Save a Copy writes it, so the document keeps its path, title and modified state. Off on the web, which has no clock. A VectorCraft addition: headline numbers unchanged.
- 2026-11-01: Divide into Dashes joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): the selected paths, or only their direct-selected segments, are cut into separate open paths of a dash length measured along the curve, with an optional gap (left empty, or kept as pieces), each keeping the path's appearance; Fit to Corners and Ends stretches or squeezes the lengths so every run starts and ends on a dash. A dialog with Preview, one undo step, at most 100000 pieces. A VectorCraft addition: headline numbers unchanged.
- 2026-11-15: Common Tangents in the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): the straight lines that touch two selected convex closed paths (ellipses at any rotation and scale, or convex Bézier paths) without crossing either are added as open paths with the current stroke: external, internal or all, and the line joining the centers if asked; a path inside the other has none unless the two touch, and a message says why; a dialog with Preview, one undo step (`addon.pathtools.commonTangents`, #7845). A VectorCraft addition: headline numbers unchanged.
- 2026-11-17: Tangent Circle Tool joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools, and the All Tools drawer): click a path segment, then another, to draw the circle tangent to the first where it was clicked that touches the second; Shift uses the tool's radius and a drag from the second segment sets the radius (Shift in round steps, Cmd/Ctrl slowly), the circle then touching the first segment anywhere along it. The circle shows with its center and radii before the click, one undo step (`tangentCircle`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-18: Common Tangents also takes a point (a path of one anchor) and a convex closed path: the lines from the point that touch the path, and the line from the point to the path's center if asked; a point on the outline gets the one tangent there, and a point inside gets none, with a message (#7846). A VectorCraft addition: headline numbers unchanged.
- 2026-11-15: With Smart Guides and Snap to Tangent on, a Line Segment drag pressed on one convex curved path and dragged near another lands on a common tangent of the two: both ends move to where the line touches the paths, each labeled "tangent" (#7845). A VectorCraft addition: headline numbers unchanged.
- 2026-11-15: Smooth Bridge joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): two selected circles become one closed outline joined by two concave arcs that touch both circles, so every anchor is smooth; the arcs' radius is a percentage of the smaller circle's radius (1 to 1000%, 100% by default), and Keep Originals adds the outline above the circles instead of replacing them. A dialog with Preview, one undo step (`addon.pathtools.bridge`). A VectorCraft addition: headline numbers unchanged.
+32 -2
View File
@@ -459,6 +459,8 @@ pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {
open_file: Some(Box::new(open_file)),
// Edit Original of a raster image with Use System Defaults for Edit Original off (#5236).
open_in_photocraft: Some(Box::new(open_in_photocraft)),
check_application: Some(Box::new(|p| check_app(std::path::Path::new(p)))),
open_in_application: Some(Box::new(open_in_application)),
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.
@@ -507,15 +509,32 @@ fn open_in_photocraft(path: &str) -> Result<bool, String> {
explorer_safe(path)?;
let home = std::env::var_os(if cfg!(windows) { "USERPROFILE" } else { "HOME" }).map(std::path::PathBuf::from);
let Some(app) = find_photocraft(home.as_deref(), std::env::var_os("PATH").as_deref()) else { return Ok(false) };
launch_application(&app, path)
}
/// A missing chosen editor falls back; invalid applications and failed launches remain errors.
fn open_in_application(app: &str, path: &str) -> Result<bool, String> {
explorer_safe(path)?;
let app = std::path::Path::new(app);
match std::fs::metadata(app) {
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(false),
Err(e) => return Err(format!("cannot inspect {}: {e}", app.display())),
Ok(_) => {}
}
check_app(app)?;
launch_application(app, path)
}
fn launch_application(app: &std::path::Path, path: &str) -> Result<bool, String> {
#[cfg(target_os = "macos")]
let mut c = {
let mut c = std::process::Command::new("open");
c.arg("-a").arg(&app).arg(path);
c.arg("-a").arg(app).arg(path);
c
};
#[cfg(not(target_os = "macos"))]
let mut c = {
let mut c = std::process::Command::new(&app);
let mut c = std::process::Command::new(app);
c.arg(path);
c
};
@@ -688,6 +707,17 @@ mod open_with_tests {
tempfile::Builder::new().prefix(&format!("vc-open-with-{name}-")).tempdir().unwrap()
}
#[test]
fn chosen_editor_only_falls_back_when_missing() {
let dir = scratch("chosen");
let missing = dir.path().join("Missing.exe");
assert!(!super::open_in_application(&missing.to_string_lossy(), "image with spaces.png").unwrap());
let doc = dir.path().join("notes.txt");
std::fs::write(&doc, "not an application").unwrap();
assert!(super::open_in_application(&doc.to_string_lossy(), "image.png").is_err());
assert!(super::open_in_application(&dir.path().to_string_lossy(), "image.png").is_err());
}
/// #5236: only an application counts as PhotoCraft, never a document, a folder or a missing
/// path.
#[test]
+70 -25
View File
@@ -1,4 +1,5 @@
//! macOS: a drawing tablet's pen pressure (#852), tilt and barrel rotation (#764). winit 0.30
//! macOS: a drawing tablet's pen pressure (#852), tilt and barrel rotation (#764), and an airbrush
//! pen's finger wheel. winit 0.30
//! hands a pen to the window there as a mouse, without them, so the app reads them from AppKit
//! itself and writes them into the UI's [`StylusFeed`] (`Services::stylus`), which the canvas
//! reads, as on X11 ([`crate::tablet`]).
@@ -14,8 +15,9 @@
//! (−1..1 on each axis, ±[`TILT_DEGREES`] at the ends) and its `rotation` go into the feed as the
//! pen's pose, kept for that move too. AppKit gives a rotation of 0 for a pen that does not read
//! one and a tilt of 0 for an upright pen, so one event cannot tell a pen without tilt or rotation
//! from one held upright and unturned. Each reads as none until the pen reports a value other
//! than 0 after it comes near ([`Pen`]).
//! from one held upright and unturned. Its `tangentialPressure` (−1..1, an airbrush pen's finger
//! wheel) goes into the pose as the wheel, 0 for a pen without one as well. Each reads as none
//! until the pen reports a value other than 0 after it comes near ([`Pen`]).
//! A mouse event of any other subtype is a mouse's or a trackpad's: the feed is set to `None`.
//! - An `NSEventTypeTabletPoint` event carries the same pressure, tilt and rotation without a move.
//! - A tablet proximity event (`NSEventTypeTabletProximity`, or a mouse event of that subtype) says
@@ -68,6 +70,8 @@ struct RawEvent {
tilt: (f64, f64),
/// `rotation`, in degrees (the same events as `pressure`).
rotation: f32,
/// `tangentialPressure`, −1..1 (the same events as `pressure`).
tangential: f32,
/// `pointingDeviceType` (proximity events only).
device: usize,
/// `isEnteringProximity` (proximity events only).
@@ -107,18 +111,42 @@ impl RawEvent {
/// and the pen's rotation is taken the same way. [`PenPose`]'s rotation runs clockwise, so the
/// angle is negated and brought into 0..360.
///
/// The tilt is left out unless `tilts`, and the rotation unless `turns` ([`Pen`]).
fn pose(&self, tilts: bool, turns: bool) -> PenPose {
/// AppKit's `tangentialPressure` is −1.0..1.0, the finger wheel of an airbrush pen on the
/// devices that have one (<https://developer.apple.com/documentation/appkit/nsevent/tangentialpressure>).
/// It becomes [`PenPose`]'s wheel of 0..1, −1.0 at 0 and 1.0 at 1; a value past either end is
/// clamped.
///
/// The tilt is left out unless `read.tilts`, the rotation unless `read.turns`, and the wheel
/// unless `read.wheels` ([`Pen`]).
fn pose(&self, read: Reads) -> PenPose {
let degrees = |v: f64| (v.clamp(-1.0, 1.0) * TILT_DEGREES) as f32;
// `0.0 - r` rather than `-r`: a rotation of 0 gives 0, not −0.
let rotation = turns.then(|| (0.0 - self.rotation).rem_euclid(360.0));
PenPose { tilt: tilts.then(|| [degrees(self.tilt.0), degrees(self.tilt.1)]), rotation }
let rotation = read.turns.then(|| (0.0 - self.rotation).rem_euclid(360.0));
let wheel = read.wheels.then(|| (self.tangential.clamp(-1.0, 1.0) + 1.0) / 2.0);
PenPose { tilt: read.tilts.then(|| [degrees(self.tilt.0), degrees(self.tilt.1)]), rotation, wheel }
}
/// Whether the event reports a tilt other than 0, and a rotation other than 0.
fn reads(&self) -> (bool, bool) {
/// Whether the event reports a tilt other than 0, a rotation other than 0, and a tangential
/// pressure other than 0.
fn reads(&self) -> Reads {
let read = |v: f64| v.is_finite() && v != 0.0;
(read(self.tilt.0) || read(self.tilt.1), read(f64::from(self.rotation)))
Reads { tilts: read(self.tilt.0) || read(self.tilt.1), turns: read(f64::from(self.rotation)), wheels: read(f64::from(self.tangential)) }
}
}
/// Which of a pen's tilt, rotation and finger wheel it has reported.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct Reads {
tilts: bool,
turns: bool,
wheels: bool,
}
impl Reads {
fn add(&mut self, other: Reads) {
self.tilts |= other.tilts;
self.turns |= other.turns;
self.wheels |= other.wheels;
}
}
@@ -148,14 +176,14 @@ impl Update {
}
}
/// Which end of the pen is near the tablet, and whether it has reported a tilt or a rotation other
/// than 0 since it came near: until it has, its tilt or rotation reads as none, since AppKit gives
/// 0 for a pen without one and for one held upright or unturned.
/// Which end of the pen is near the tablet, and whether it has reported a tilt, a rotation or a
/// tangential pressure other than 0 since it came near: until it has, that value reads as none,
/// since AppKit gives 0 for a pen without one and for one held upright, unturned or with its
/// wheel half way.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct Pen {
eraser: bool,
tilts: bool,
turns: bool,
read: Reads,
}
impl Pen {
@@ -163,16 +191,14 @@ impl Pen {
if e.proximity() {
// Entering with the tip or the eraser end: it hovers. A puck, or leaving, is a mouse.
self.eraser = e.entering && e.device == device::ERASER;
(self.tilts, self.turns) = (false, false);
self.read = Reads::default();
let pen = e.entering && e.device != device::CURSOR;
return Update::Set(pen.then_some(PenSample { pressure: 0.0, eraser: self.eraser, ..PenSample::default() }));
}
if e.point() {
let (tilts, turns) = e.reads();
self.tilts |= tilts;
self.turns |= turns;
self.read.add(e.reads());
}
let sample = PenSample { pressure: e.pressure, eraser: self.eraser, pose: e.pose(self.tilts, self.turns) };
let sample = PenSample { pressure: e.pressure, eraser: self.eraser, pose: e.pose(self.read) };
match (e.point(), e.mouse()) {
(true, true) => Update::Move(sample),
(true, false) => Update::Set(Some(sample)),
@@ -246,6 +272,7 @@ mod monitor {
let tilt = e.tilt();
raw.tilt = (tilt.x, tilt.y);
raw.rotation = e.rotation();
raw.tangential = e.tangentialPressure();
}
if raw.proximity() {
raw.device = e.pointingDeviceType().0;
@@ -326,26 +353,44 @@ mod tests {
let sample = |pressure, pose| PenSample { pressure, eraser: false, pose };
assert_eq!(p.handle(&pen(DRAG, 0.5)), Update::Move(tip(0.5)), "no tilt or rotation reported yet");
let leaning = RawEvent { tilt: (0.5, -0.25), rotation: 30.0, ..pen(DRAG, 0.5) };
let pose = PenPose { tilt: Some([30.0, -15.0]), rotation: Some(330.0) };
let pose = PenPose { tilt: Some([30.0, -15.0]), rotation: Some(330.0), wheel: None };
assert_eq!(p.handle(&leaning), Update::Move(sample(0.5, pose)));
let past_the_ends = RawEvent { tilt: (-4.0, 1.5), rotation: 270.0, ..pen(event_type::TABLET_POINT, 0.8) };
let pose = PenPose { tilt: Some([-60.0, 60.0]), rotation: Some(90.0) };
let pose = PenPose { tilt: Some([-60.0, 60.0]), rotation: Some(90.0), wheel: None };
assert_eq!(p.handle(&past_the_ends), Update::Set(Some(sample(0.8, pose))), "clamped");
let pose = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0) };
let pose = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0), wheel: None };
let Update::Move(upright) = p.handle(&pen(DRAG, 0.6)) else { panic!("a pen's drag is a move") };
assert_eq!(upright, sample(0.6, pose), "once reported, 0 is upright and unturned");
assert!(upright.pose.rotation.is_some_and(f32::is_sign_positive), "{upright:?}");
let feed = StylusFeed::default();
p.handle(&RawEvent { tilt: (f64::NAN, 0.0), rotation: -90.0, ..pen(DRAG, 0.3) }).apply(&feed);
assert_eq!(feed.pose(), Some(PenPose { tilt: None, rotation: Some(90.0) }), "a tilt that is not a number is left out");
assert_eq!(feed.pose(), Some(PenPose { rotation: Some(90.0), ..PenPose::default() }), "a tilt that is not a number is left out");
p.handle(&proximity(1, true));
let tilted = RawEvent { tilt: (0.0, 0.5), ..pen(event_type::TABLET_POINT, 0.8) };
let pose = PenPose { tilt: Some([0.0, 30.0]), rotation: None };
let pose = PenPose { tilt: Some([0.0, 30.0]), ..PenPose::default() };
assert_eq!(p.handle(&tilted), Update::Set(Some(sample(0.8, pose))), "no rotation reported since the pen came near");
p.handle(&RawEvent { kind: DRAG, ..Default::default() }).apply(&feed);
assert_eq!(feed.pose(), None, "a mouse moved");
}
/// An airbrush pen's finger wheel (AppKit's `tangentialPressure`, −1..1) reaches the feed as
/// 0..1, once the pen has reported a value other than 0 since it came near.
#[test]
fn an_airbrush_wheel_goes_into_the_feed() {
let mut p = Pen::default();
let wheel = |p: &mut Pen, tangential: f32| match p.handle(&RawEvent { tangential, ..pen(DRAG, 0.5) }) {
Update::Move(s) => s.pose.wheel,
u => panic!("a pen's drag is a move: {u:?}"),
};
assert_eq!(wheel(&mut p, 0.0), None, "no wheel reported yet");
assert_eq!(wheel(&mut p, -1.0), Some(0.0));
assert_eq!(wheel(&mut p, 0.5), Some(0.75));
assert_eq!(wheel(&mut p, 0.0), Some(0.5), "once reported, 0 is half way");
assert_eq!(wheel(&mut p, 3.0), Some(1.0), "clamped");
p.handle(&proximity(1, true));
assert_eq!(wheel(&mut p, 0.0), None, "not reported since the pen came near");
}
#[test]
fn the_feed_gets_each_moves_pressure_within_0_to_1() {
let feed = StylusFeed::default();
+56 -14
View File
@@ -1,4 +1,5 @@
//! Linux: a drawing tablet's pen pressure, tilt and barrel rotation under X11, XWayland included
//! Linux: a drawing tablet's pen pressure, tilt, barrel rotation and airbrush finger wheel under
//! X11, XWayland included
//! (#764). winit 0.30 hands a pen to the window there as a mouse, without any of them, so the app
//! reads them from XInput2 itself and writes them into the UI's [`StylusFeed`]
//! (`Services::stylus`), which the canvas reads.
@@ -14,11 +15,17 @@
//! - "Abs Tilt X" and "Abs Tilt Y" (a pen that has both), in degrees as they are when the range
//! fits in ±90, otherwise scaled to ±[`TILT_DEGREES`];
//! - "Abs Rotary Z" (the barrel rotation of an Art Pen), scaled to a turn with the middle of the
//! range at 0°.
//! range at 0°;
//! - "Abs Wheel" (the finger wheel of an airbrush pen), scaled from the valuator's range to 0..1.
//! XWayland also sends an Art Pen's barrel rotation on this valuator
//! (<https://github.com/mirror/xserver/blob/master/hw/xwayland/xwayland-input.c>), so under
//! XWayland it reads as the wheel. A tablet pad's wheel is on a device without a pressure axis,
//! which is not read.
//!
//! Any other pointer device moving sets the feed to `None`. Raw events carry only the valuators
//! that changed, so the last value of each axis of each pen is kept; an axis the pen has that no
//! event has carried yet reads 0 (upright, unturned), and an axis it lacks reads nothing.
//! event has carried yet reads 0 (upright, unturned), and an axis it lacks reads nothing. The
//! wheel reads nothing until an event carries it.
//!
//! The X server lists a pen's eraser end as a device of its own, whose name or XInput type contains
//! "eraser" (xf86-input-wacom's "… Pen eraser" of type `ERASER`, xf86-input-libinput's
@@ -60,6 +67,7 @@ enum AxisKind {
TiltX,
TiltY,
Rotation,
Wheel,
}
impl AxisKind {
@@ -70,6 +78,7 @@ impl AxisKind {
"Abs Tilt X" => Some(Self::TiltX),
"Abs Tilt Y" => Some(Self::TiltY),
"Abs Rotary Z" => Some(Self::Rotation),
"Abs Wheel" => Some(Self::Wheel),
_ => None,
}
}
@@ -81,6 +90,7 @@ impl AxisKind {
Self::TiltX => 1,
Self::TiltY => 2,
Self::Rotation => 3,
Self::Wheel => 4,
}
}
}
@@ -95,18 +105,22 @@ struct Axis {
}
impl Axis {
/// A raw value of this valuator as a pressure of 0..1, a tilt in degrees (−90..90) or a
/// rotation in degrees (−180..180, the middle of the range at 0). A value that is not a number
/// is a mouse's pressure, 1, or a tilt or rotation of 0.
/// A raw value of this valuator as a pressure of 0..1, a tilt in degrees (−90..90), a rotation
/// in degrees (−180..180, the middle of the range at 0) or a wheel of 0..1. A value that is not
/// a number is a mouse's pressure, 1, a tilt or rotation of 0, or a wheel half way.
fn map(&self, v: f64) -> f32 {
if !v.is_finite() {
return if self.kind == AxisKind::Pressure { 1.0 } else { 0.0 };
return match self.kind {
AxisKind::Pressure => 1.0,
AxisKind::Wheel => 0.5,
_ => 0.0,
};
}
let span = self.max - self.min;
let unit = if span.is_finite() && span > 0.0 { (v - self.min) / span } else { v };
let unit = unit.clamp(0.0, 1.0);
match self.kind {
AxisKind::Pressure => unit as f32,
AxisKind::Pressure | AxisKind::Wheel => unit as f32,
AxisKind::TiltX | AxisKind::TiltY if self.min >= -90.0 && self.max <= 90.0 && span > 0.0 => v.clamp(-90.0, 90.0) as f32,
AxisKind::TiltX | AxisKind::TiltY => ((unit * 2.0 - 1.0) * TILT_DEGREES) as f32,
AxisKind::Rotation => ((unit - 0.5) * 360.0) as f32,
@@ -173,7 +187,7 @@ enum Update {
#[derive(Debug, Default)]
struct Pens {
devices: HashMap<u16, Device>,
last: HashMap<u16, [Option<f32>; 4]>,
last: HashMap<u16, [Option<f32>; 5]>,
}
impl Pens {
@@ -200,10 +214,12 @@ impl Pens {
}
}
}
// An axis the pen has reads 0 until an event carries it; one it lacks reads nothing.
// An axis the pen has reads 0 until an event carries it; one it lacks reads nothing. The
// wheel reads nothing until an event carries it: XWayland lists the axis for every pen.
let value = |kind: AxisKind| device.axis(kind).map(|_| last.get(kind.slot()).copied().flatten().unwrap_or(0.0));
let tilt = value(AxisKind::TiltX).zip(value(AxisKind::TiltY)).map(|(x, y)| [x, y]);
let pose = PenPose { tilt, rotation: value(AxisKind::Rotation) };
let wheel = device.axis(AxisKind::Wheel).and_then(|_| last.get(AxisKind::Wheel.slot()).copied().flatten());
let pose = PenPose { tilt, rotation: value(AxisKind::Rotation), wheel };
Update::Set(Some(PenSample { pressure: value(AxisKind::Pressure).unwrap_or(0.0), eraser: device.eraser, pose }))
}
@@ -430,7 +446,7 @@ mod tests {
let mut pens = Pens::default();
pens.set_devices([pen(9), Device::new(10, "Wacom Intuos Pro M Pen eraser", Some("ERASER"), pen_valuators()), mouse(12)]);
let feed = StylusFeed::default();
let pose = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0) };
let pose = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0), wheel: None };
pens.raw_event(&feed, 9, &[0b100], &[32767.5]);
assert_eq!(pens.handle(9, []), Update::Set(Some(PenSample { pressure: 0.5, eraser: false, pose })));
assert_eq!(feed.eraser(), Some(false));
@@ -479,10 +495,36 @@ mod tests {
// A pen whose tilt and rotation no event has carried yet is upright and unturned.
let mut fresh = Pens::default();
fresh.set_devices([pen(9)]);
let upright = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0) };
let upright = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0), wheel: None };
assert_eq!(fresh.handle(9, [(2, 0.0)]), Update::Set(Some(PenSample { pressure: 0.0, eraser: false, pose: upright })));
}
/// An airbrush pen's "Abs Wheel" valuator goes into the feed as 0..1 of its range, once an
/// event carries it; a pen that lists it but has not moved it reads no wheel, and a device
/// without a pressure axis (a tablet pad's wheel) is not a pen.
#[test]
fn an_airbrush_wheel_goes_into_the_feed() {
let mut valuators = pen_valuators();
valuators.push((6, "Abs Wheel".to_string(), 0.0, 1023.0));
let airbrush = Device::new(9, "Wacom Intuos Pro M Pen stylus", Some("STYLUS"), valuators);
let pad = Device::new(13, "Wacom Intuos Pro M Pad pad", Some("PAD"), [(6, "Abs Wheel".to_string(), 0.0, 71.0)]);
let mut pens = Pens::default();
pens.set_devices([airbrush, pad, pen(10)]);
let feed = StylusFeed::default();
pens.raw_event(&feed, 9, &[0b100], &[32767.5]);
assert_eq!(feed.pose().and_then(|q| q.wheel), None, "no event has carried the wheel yet");
pens.raw_event(&feed, 9, &[0b100_0000], &[255.75]);
assert_eq!(feed.pose().and_then(|q| q.wheel), Some(0.25));
pens.raw_event(&feed, 9, &[0b100_0000], &[5000.0]);
assert_eq!(feed.pose().and_then(|q| q.wheel), Some(1.0), "clamped to the range");
pens.raw_event(&feed, 9, &[0b100], &[100.0]);
assert_eq!(feed.pose().and_then(|q| q.wheel), Some(1.0), "kept while other valuators move");
pens.raw_event(&feed, 13, &[0b100_0000], &[30.0]);
assert_eq!((feed.held(), feed.pose()), (None, None), "the pad is not a pen");
pens.raw_event(&feed, 10, &[0b100_0000], &[512.0]);
assert_eq!(feed.pose().and_then(|q| q.wheel), None, "a pen without the valuator");
}
/// A device listed again unchanged keeps its last tilt and rotation; another device listed
/// under the same id starts upright and unturned.
#[test]
@@ -495,7 +537,7 @@ mod tests {
assert_eq!(pose.tilt, Some([-30.0, 45.0]));
let other = Device::new(9, "HUION Kamvas Pen Pen (0x1)", Some("STYLUS"), pen_valuators());
pens.set_devices([other]);
let upright = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0) };
let upright = PenPose { tilt: Some([0.0, 0.0]), rotation: Some(0.0), wheel: None };
assert_eq!(pens.handle(9, [(2, 0.0)]), Update::Set(Some(PenSample { pressure: 0.0, eraser: false, pose: upright })));
}
+7 -6
View File
@@ -133,12 +133,13 @@ fn pen_sample(pressure: u32, pen_mask: u32, pen_flags: u32, in_contact: bool, po
/// How a pen whose `POINTER_PEN_INFO` holds `pen_mask`, `tilt_x`, `tilt_y` and `rotation` is
/// held: the tilt when the pen reports it along either axis (0 along an axis it doesn't), the
/// rotation when it reports one, each kept within [`PenPose`]'s ranges.
/// rotation when it reports one, each kept within [`PenPose`]'s ranges. `POINTER_PEN_INFO` has no
/// field for an airbrush pen's finger wheel, so the pose has none.
fn pen_pose(pen_mask: u32, tilt_x: i32, tilt_y: i32, rotation: u32) -> PenPose {
let along = |mask: u32, t: i32| if pen_mask & mask != 0 { t as f32 } else { 0.0 };
let tilt = (pen_mask & (PEN_MASK_TILT_X | PEN_MASK_TILT_Y) != 0).then(|| [along(PEN_MASK_TILT_X, tilt_x), along(PEN_MASK_TILT_Y, tilt_y)]);
let rotation = (pen_mask & PEN_MASK_ROTATION != 0).then_some(rotation as f32);
PenPose { tilt, rotation }.sanitized()
PenPose { tilt, rotation, wheel: None }.sanitized()
}
/// Whether a mouse message with this extra information (`GetMessageExtraInfo`) comes from a mouse,
@@ -426,12 +427,12 @@ mod tests {
#[test]
fn a_pens_tilt_and_rotation_come_where_it_reports_them() {
let all = PEN_MASK_TILT_X | PEN_MASK_TILT_Y | PEN_MASK_ROTATION;
assert_eq!(pen_pose(all, 30, -45, 90), PenPose { tilt: Some([30.0, -45.0]), rotation: Some(90.0) });
assert_eq!(pen_pose(all, 30, -45, 90), PenPose { tilt: Some([30.0, -45.0]), rotation: Some(90.0), wheel: None });
assert_eq!(pen_pose(PEN_MASK_PRESSURE, 30, -45, 90), PenPose::default(), "a pen that reports neither");
assert_eq!(pen_pose(PEN_MASK_TILT_X, 30, -45, 90), PenPose { tilt: Some([30.0, 0.0]), rotation: None }, "one axis");
assert_eq!(pen_pose(PEN_MASK_ROTATION, 0, 0, 359), PenPose { tilt: None, rotation: Some(359.0) }, "a 6D Art Pen's barrel");
assert_eq!(pen_pose(PEN_MASK_TILT_X, 30, -45, 90), PenPose { tilt: Some([30.0, 0.0]), ..PenPose::default() }, "one axis");
assert_eq!(pen_pose(PEN_MASK_ROTATION, 0, 0, 359), PenPose { rotation: Some(359.0), ..PenPose::default() }, "a 6D Art Pen's barrel");
let wild = pen_pose(all, 400, i32::MIN, 720);
assert_eq!(wild, PenPose { tilt: Some([90.0, -90.0]), rotation: Some(0.0) }, "kept within the ranges");
assert_eq!(wild, PenPose { tilt: Some([90.0, -90.0]), rotation: Some(0.0), wheel: None }, "kept within the ranges");
let pose = pen_pose(all, 10, 20, 180);
assert_eq!(pen_sample(512, PEN_MASK_PRESSURE | all, 0, true, pose).pose, pose);
}
+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"><path d="M3 19Q12 4 21 19"/><circle cx="12" cy="16.9" r="5.4"/><circle cx="12" cy="16.9" r="1" fill="currentColor"/></svg>

After

Width:  |  Height:  |  Size: 306 B

+34 -12
View File
@@ -160,7 +160,7 @@ impl Calligraphic {
pub fn uses_pressure(&self) -> bool {
self.modes().contains(&Variation::Pressure)
}
/// Does the pen (its pressure, tilt, bearing or rotation) change the nib?
/// Does the pen (its pressure, tilt, bearing, rotation or wheel) change the nib?
pub fn uses_pen(&self) -> bool {
self.modes().iter().any(|m| m.follows_pen())
}
@@ -202,11 +202,25 @@ pub enum Variation {
/// The value plus the variation times the pen barrel's rotation over 180°, counter-clockwise
/// from where the pen reports 0° round to ±180°.
Rotation,
/// From the value less the variation with an airbrush pen's finger wheel at one end of its
/// travel to the value plus the variation at the other (the value itself half way).
StylusWheel,
}
impl Variation {
pub const ALL: [Variation; 6] =
pub const ALL: [Variation; 7] =
[Variation::Fixed, Variation::Random, Variation::Pressure, Variation::Tilt, Variation::Bearing, Variation::Rotation, Variation::StylusWheel];
/// The modes Brush Options offers for a value other than a size (a Calligraphic brush's Angle
/// and Roundness, a Scatter brush's Spacing, Scatter and Rotation): all but
/// [`Variation::StylusWheel`], which drives a Calligraphic or Scatter brush's Size and an Art
/// brush's Width.
pub const OTHER: [Variation; 6] =
[Variation::Fixed, Variation::Random, Variation::Pressure, Variation::Tilt, Variation::Bearing, Variation::Rotation];
/// The modes Brush Options offers for a size (`true`: [`Self::ALL`]) or another value
/// ([`Self::OTHER`]).
pub fn offered(size: bool) -> &'static [Variation] {
if size { &Self::ALL } else { &Self::OTHER }
}
/// The name brush definitions use.
pub fn id(self) -> &'static str {
match self {
@@ -216,6 +230,7 @@ impl Variation {
Variation::Tilt => "tilt",
Variation::Bearing => "bearing",
Variation::Rotation => "rotation",
Variation::StylusWheel => "stylusWheel",
}
}
pub fn label(self) -> &'static str {
@@ -226,15 +241,16 @@ impl Variation {
Variation::Tilt => "Tilt",
Variation::Bearing => "Bearing",
Variation::Rotation => "Rotation",
Variation::StylusWheel => "Stylus Wheel",
}
}
pub fn parse(id: &str) -> Option<Self> {
Self::ALL.into_iter().find(|v| v.id() == id)
}
/// Does the value follow something the pen records along a stroke (Pressure, Tilt, Bearing,
/// Rotation)?
/// Rotation, Stylus Wheel)?
pub fn follows_pen(self) -> bool {
matches!(self, Variation::Pressure | Variation::Tilt | Variation::Bearing | Variation::Rotation)
matches!(self, Variation::Pressure | Variation::Tilt | Variation::Bearing | Variation::Rotation | Variation::StylusWheel)
}
}
@@ -251,12 +267,14 @@ pub(crate) struct PenAt {
bearing: f64,
/// ½ plus the counter-clockwise barrel rotation over 360°.
rotation: f64,
/// Where the airbrush finger wheel was set, 0 at one end of its travel to 1 at the other.
wheel: f64,
}
impl PenAt {
/// Every input at `c`.
pub(crate) fn uniform(c: f64) -> Self {
Self { pressure: c, tilt: c, bearing: c, rotation: c }
Self { pressure: c, tilt: c, bearing: c, rotation: c, wheel: c }
}
/// What `stroke` recorded at `f` (the fraction of its path's length).
pub(crate) fn of(stroke: &StrokeLayer, f: f64) -> Self {
@@ -267,6 +285,7 @@ impl PenAt {
tilt: 1.0 - stroke.tilt.as_ref().map_or(mid, |p| p.at(f)),
bearing: turn(stroke.bearing.as_ref()),
rotation: turn(stroke.rotation.as_ref()),
wheel: stroke.wheel.as_ref().map_or(mid, |p| p.at(f)),
}
}
/// The 0..1 a value on `mode` takes, or `None` for a mode that doesn't follow the pen.
@@ -277,6 +296,7 @@ impl PenAt {
Variation::Tilt => self.tilt,
Variation::Bearing => self.bearing,
Variation::Rotation => self.rotation,
Variation::StylusWheel => self.wheel,
};
Some(if c.is_finite() { c.clamp(0.0, 1.0) } else { 0.5 })
}
@@ -307,9 +327,10 @@ pub struct Scatter {
/// How size, spacing, scatter and rotation vary between their two values: Fixed takes the
/// first, Random any value between them, Pressure the first at the lightest pen pressure and
/// the second at the heaviest, Tilt the first with the pen lying flat and the second upright,
/// Bearing and Rotation the first at −180° and the second at 180° (half way at 0°). `None`
/// (brushes saved before there were modes): Random where the two differ, else Fixed (see
/// [`Scatter::modes`]).
/// Bearing and Rotation the first at −180° and the second at 180° (half way at 0°), and Stylus
/// Wheel (the size's only) the first at one end of an airbrush pen's finger wheel and the
/// second at the other. `None` (brushes saved before there were modes): Random where the two
/// differ, else Fixed (see [`Scatter::modes`]).
#[serde(skip_serializing_if = "Option::is_none")]
pub modes: Option<[Variation; 4]>,
}
@@ -384,11 +405,12 @@ pub struct ArtBrush {
/// How the width varies along a stroke: `None` (Fixed) always `width`; a mode that follows the
/// pen goes from `width` to [`Self::width_max`] over the ranges [`Variation`] gives: Pressure
/// from the lightest pressure to the heaviest, Tilt from the pen lying flat to upright, Bearing
/// and Rotation from −180° to 180° (half way at 0°).
/// and Rotation from −180° to 180° (half way at 0°), Stylus Wheel from one end of an airbrush
/// pen's finger wheel to the other.
#[serde(skip_serializing_if = "Option::is_none")]
pub width_mode: Option<Variation>,
/// The second width (%) of a mode that follows the pen: at the heaviest pressure, upright, or
/// at 180° (`width` without one).
/// The second width (%) of a mode that follows the pen: at the heaviest pressure, upright, at
/// 180° or at the wheel's far end (`width` without one).
#[serde(skip_serializing_if = "Option::is_none")]
pub width_max: Option<f64>,
pub flip_along: bool,
@@ -732,7 +754,7 @@ impl Brush {
}
BrushKind::Art(a) => {
a.width = within(a.width, ArtBrush::WIDTH_RANGE, 100.0);
// The width follows the pen (its pressure, tilt, bearing or rotation) or stays fixed.
// The width follows the pen (its pressure, tilt, bearing, rotation or wheel) or stays fixed.
if !a.width_mode.is_some_and(Variation::follows_pen) {
a.width_mode = None;
}
+66 -4
View File
@@ -1545,6 +1545,64 @@ fn pressure_varies_angle_and_roundness() {
assert!(near(h, expected, 0.05), "{h} vs {expected}");
}
/// A stroke that recorded an airbrush pen's finger wheel going from `from` to `to` along it.
fn wheeled(from: f64, to: f64) -> StrokeLayer {
StrokeLayer { wheel: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, from), (1.0, to)] }), ..stroke(1.0) }
}
/// Stylus Wheel: a Calligraphic brush's size goes from size − variation at one end of the finger
/// wheel to size + variation at the other, a Scatter brush's size from its first value to its
/// second, and an Art brush's width from Width to the second width. Each reads only the wheel: the
/// pressure, tilt, bearing or rotation recorded instead leaves the value half way.
#[test]
fn the_stylus_wheel_varies_sizes_and_widths() {
let doc = Document::new(1.0, 1.0);
let bp = line(0.0, 0.0, 100.0, 0.0);
let c = Calligraphic {
size: 6.0,
variation: [0.0, 0.0, 4.0],
modes: Some([Variation::Fixed, Variation::Fixed, Variation::StylusWheel]),
..Default::default()
};
let nib = Brush { name: "w".into(), kind: BrushKind::Calligraphic(c) };
let out = stroke_pieces(&doc, &nib, &bp, &wheeled(0.0, 1.0));
// Round nib: 2 pt across at the start, 10 pt at the end, 6 pt half way.
assert!(near(half_width(&out, 0.5, 1.5), 1.0, 0.1), "{}", half_width(&out, 0.5, 1.5));
assert!(near(half_width(&out, 98.5, 99.5), 5.0, 0.1), "{}", half_width(&out, 98.5, 99.5));
assert!(near(half_width(&out, 49.5, 50.5), 3.0, 0.1), "{}", half_width(&out, 49.5, 50.5));
let others = [
pressed(vec![(0.0, 0.0), (1.0, 1.0)]),
StrokeLayer { tilt: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] }), ..stroke(1.0) },
posed(None, Some(90.0), Some(-90.0)),
];
for st in &others {
let h = bounds(&stroke_pieces(&doc, &nib, &bp, st)).height();
assert!(near(h, 6.0, 0.05), "{st:?}: {h}");
}
// Scatter size 50 % to 300 % of 4 pt art: 2 pt at one end of the wheel, 12 pt at the other.
let spray = sized_scatter(50.0, 300.0, Variation::StylusWheel);
let h: Vec<f64> =
stroke_pieces(&doc, &spray, &line(0.0, 0.0, 400.0, 0.0), &wheeled(1.0, 0.0)).iter().map(|n| n.geometric_bounds().unwrap().height()).collect();
assert!(near(h[0], 12.0, 0.2) && h[h.len() - 1] < 3.0, "{h:?}");
// Art width 50 % to 300 % of 4 pt art.
let mut ribbon = art_brush(rect_art(10.0, 4.0), ArtScale::Stretch);
if let BrushKind::Art(a) = &mut ribbon.kind {
(a.width, a.width_mode, a.width_max) = (50.0, Some(Variation::StylusWheel), Some(300.0));
}
let out = stroke_pieces(&doc, &ribbon, &bp, &wheeled(1.0, 0.0));
assert!(near(half_width(&out, 0.0, 1.0), 6.0, 0.1), "{}", half_width(&out, 0.0, 1.0));
assert!(near(half_width(&out, 99.0, 100.0), 1.0, 0.1), "{}", half_width(&out, 99.0, 100.0));
for st in &others {
let h = bounds(&stroke_pieces(&doc, &ribbon, &bp, st)).height();
assert!(near(h, 7.0, 1e-6), "{st:?}: {h}");
}
// A definition keeps the mode by name.
let lib = parse_library(&serde_json::json!([
{"name": "a", "type": "art", "art": rect_art(10.0, 4.0), "width_mode": "stylusWheel", "width_max": 300.0},
]));
assert!(matches!(&lib[0].kind, BrushKind::Art(a) if a.width_mode == Some(Variation::StylusWheel)));
}
/// A stroke that recorded the pen's tilt (`tilt`: 0 upright to 1 flat), bearing and barrel
/// rotation (degrees counter-clockwise), each the same all along it where given.
fn posed(tilt: Option<f64>, bearing: Option<f64>, rotation: Option<f64>) -> StrokeLayer {
@@ -1611,7 +1669,7 @@ fn bearing_and_rotation_turn_the_nib() {
#[test]
fn pen_modes_without_a_recording_draw_the_value_itself() {
let horizontal = line(0.0, 0.0, 100.0, 0.0);
for mode in [Variation::Tilt, Variation::Bearing, Variation::Rotation] {
for mode in [Variation::Tilt, Variation::Bearing, Variation::Rotation, Variation::StylusWheel] {
let c = Calligraphic { angle: 90.0, roundness: 50.0, size: 10.0, variation: [90.0, 50.0, 6.0], modes: Some([mode; 3]) };
let b = Brush { name: "n".into(), kind: BrushKind::Calligraphic(c) };
let h = bounds(&stroke_pieces(&Document::new(1.0, 1.0), &b, &horizontal, &stroke(1.0))).height();
@@ -1658,7 +1716,7 @@ fn a_mouse_stroke_draws_pen_modes_as_pressure_did() {
};
let (calli_before, scatter_before) = (calli(Variation::Pressure), scattered(Variation::Pressure));
assert!(!calli_before.is_empty() && !scatter_before.is_empty());
for mode in [Variation::Tilt, Variation::Bearing, Variation::Rotation] {
for mode in [Variation::Tilt, Variation::Bearing, Variation::Rotation, Variation::StylusWheel] {
assert_eq!(calli(mode), calli_before, "{mode:?}");
assert_eq!(scattered(mode), scatter_before, "{mode:?}");
}
@@ -1726,8 +1784,12 @@ fn brushes_without_modes_vary_randomly_as_before() {
stroke_pieces(&Document::new(1.0, 1.0), &old, &bp, &pressed(vec![(0.0, 0.0), (1.0, 1.0)]))
);
// Modes are saved by name.
assert_eq!(serde_json::to_value(Variation::ALL).unwrap(), serde_json::json!(["fixed", "random", "pressure", "tilt", "bearing", "rotation"]));
assert!(Variation::ALL.iter().all(|v| Variation::parse(v.id()) == Some(*v)));
assert_eq!(
serde_json::to_value(Variation::ALL).unwrap(),
serde_json::json!(["fixed", "random", "pressure", "tilt", "bearing", "rotation", "stylusWheel"])
);
assert!(Variation::ALL.iter().all(|v| Variation::parse(v.id()) == Some(*v) && serde_json::to_value(v).unwrap() == v.id()));
assert!(!Variation::offered(false).contains(&Variation::StylusWheel) && Variation::offered(true).contains(&Variation::StylusWheel));
}
/// Junk definitions and pressure never panic and never draw non-finite art.
+13 -3
View File
@@ -198,14 +198,24 @@ pub fn export(doc: &Document, opts: &HpglOptions) -> Result<HpglOutput, String>
Ok(export_regions(doc, opts, &[opts.region])?.pop().unwrap_or_default())
}
/// An error unless a plot can cover `region`: its corners are finite and it has a width and a
/// height (either corner may come first).
pub fn check_region(region: Rect) -> Result<(), String> {
let r = region.abs();
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0 {
return Err("the export region is empty".into());
}
Ok(())
}
/// Write the visible art of `doc` over each of `regions` as an HP-GL plot, one per region, as
/// [`export`] does with `opts.region`. The plots share one pen numbering, so a color is the same
/// pen in each, and one point budget.
pub fn export_regions(doc: &Document, opts: &HpglOptions, regions: &[Rect]) -> Result<Vec<HpglOutput>, String> {
let regions: Vec<Rect> = regions.iter().map(|r| r.abs()).collect();
if regions.iter().any(|r| ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0) {
return Err("the export region is empty".into());
for r in regions {
check_region(*r)?;
}
let regions: Vec<Rect> = regions.iter().map(|r| r.abs()).collect();
if !TOLERANCE_RANGE.contains(&opts.tolerance) {
return Err("the curve tolerance must be from 0.01 to 10 points".into());
}
+25 -5
View File
@@ -185,6 +185,15 @@ pub struct ColorSettings {
/// The color management policy for CMYK profiles. Settings saved without one take the default.
#[serde(default)]
pub cmyk_policy: Policy,
/// Profile Mismatches: Ask When Opening. Off by default, as in settings saved without it.
#[serde(default)]
pub ask_mismatch_open: bool,
/// Profile Mismatches: Ask When Pasting.
#[serde(default)]
pub ask_mismatch_paste: bool,
/// Missing Profiles: Ask When Opening.
#[serde(default)]
pub ask_missing_open: bool,
}
impl Default for ColorSettings {
@@ -196,6 +205,9 @@ impl Default for ColorSettings {
bpc: true,
rgb_policy: Policy::default(),
cmyk_policy: Policy::default(),
ask_mismatch_open: false,
ask_mismatch_paste: false,
ask_missing_open: false,
}
}
}
@@ -589,10 +601,11 @@ impl Cms {
/// An RGB or CMYK colour of this context's space as the colour of the same model in `dest`'s
/// space that looks the same, converted with `intent` (Edit → Color Settings › Convert to
/// Working Space). RGB converts directly from profile to profile, and CMYK between two loaded
/// profiles through ProPhoto RGB ([`IccProfile::to_same_model_of`]), both with this context's
/// black-point compensation; CMYK goes through Lab when either space is built in. Grey and
/// Lab colours stay as they are.
/// Working Space). RGB converts directly from profile to profile, with this context's
/// black-point compensation. CMYK converts between two loaded profiles through ProPhoto RGB
/// ([`IccProfile::to_same_model_of`]), and through Lab when either space is built in: the Lab it
/// displays as ([`Self::cmyk_display_lab`]), or for Absolute Colorimetric its absolute Lab. Grey
/// and Lab colours stay as they are.
pub fn convert_into(&self, dest: &Cms, c: &Color, intent: Intent) -> Color {
match *c {
Color::Rgb { r, g, b } => {
@@ -612,9 +625,16 @@ impl Cms {
(CmykSpace::Icc(s), CmykSpace::Icc(d)) => s.to_same_model_of(d, &inks, intent, self.settings.bpc),
_ => None,
};
// Absolute colorimetry starts from the inks' absolute Lab, paper color included and
// without black-point compensation; the other intents from the Lab they display as.
let source_lab = || match (&self.cmyk, intent) {
(CmykSpace::Generic(g), Intent::AbsoluteColorimetric) => g.to_lab_abs(inks),
(_, Intent::AbsoluteColorimetric) => lab::srgb_to_lab(self.cmyk_to_srgb(inks, true)),
_ => self.cmyk_display_lab(inks),
};
let [c, m, y, k] = match direct.as_deref() {
Some(&[c, m, y, k]) => [c, m, y, k],
_ => dest.lab_to_cmyk(self.cmyk_to_lab(inks), intent),
_ => dest.lab_to_cmyk(source_lab(), intent),
};
Color::Cmyk { c, m, y, k }
}
+62
View File
@@ -459,6 +459,23 @@ fn policies_parse_and_default_in_saved_settings() {
assert_eq!((saved["rgbPolicy"].as_str(), saved["cmykPolicy"].as_str()), (Some("preserveEmbedded"), Some("preserveNumbers")));
}
/// The three Ask boxes are off by default and in settings saved before they existed, and save
/// under their own keys.
#[test]
fn ask_boxes_default_off_and_save() {
let old: ColorSettings =
serde_json::from_str(r#"{"rgb": "sRGB IEC61966-2.1", "cmyk": "Device CMYK (uncalibrated)", "intent": "perceptual", "bpc": false}"#).unwrap();
assert!(!old.ask_mismatch_open && !old.ask_mismatch_paste && !old.ask_missing_open);
let st = ColorSettings::default();
assert!(!st.ask_mismatch_open && !st.ask_mismatch_paste && !st.ask_missing_open);
let saved = serde_json::to_value(ColorSettings { ask_mismatch_paste: true, ..Default::default() }).unwrap();
assert_eq!(saved["askMismatchOpen"], false);
assert_eq!(saved["askMismatchPaste"], true);
assert_eq!(saved["askMissingOpen"], false);
let back: ColorSettings = serde_json::from_value(saved).unwrap();
assert!(back.ask_mismatch_paste);
}
/// Convert to Working Space keeps a color's appearance: an RGB color of a wide space converts into
/// sRGB, and a CMYK color of one CMYK space into another, with numbers that look the same. Grey and
/// Lab colors stay as they are.
@@ -478,3 +495,48 @@ fn convert_into_keeps_the_appearance() {
assert_eq!(wide.convert_into(&working, &c, Intent::RelativeColorimetric), c);
}
}
/// With black-point compensation on, Generic CMYK displays its press black as black, so dark inks
/// converted out of it keep that appearance: into Device CMYK, and into another document whose
/// CMYK space is also Generic CMYK.
#[test]
fn convert_into_keeps_compensated_dark_inks() {
let generic = cms();
let device = Cms::new(&ColorSettings { cmyk: DEVICE_CMYK.into(), ..Default::default() }).unwrap();
let other_generic = Cms::new(&ColorSettings { rgb: WIDE_GAMUT_RGB.into(), ..Default::default() }).unwrap();
for ink in [
Color::Cmyk { c: 0.6, m: 0.5, y: 0.5, k: 0.9 },
Color::Cmyk { c: 0.0, m: 0.0, y: 0.0, k: 1.0 },
Color::Cmyk { c: 0.3, m: 0.2, y: 0.2, k: 0.75 },
] {
for dest in [&device, &other_generic] {
let moved = generic.convert_into(dest, &ink, Intent::RelativeColorimetric);
assert!(matches!(moved, Color::Cmyk { .. }), "{ink:?} → {moved:?}");
let d = delta_e2000(generic.lab(&ink), dest.lab(&moved));
assert!(d < 2.0, "{ink:?} → {moved:?}: ΔE {d}");
}
}
}
/// Absolute Colorimetric converts CMYK out of Generic CMYK from the inks' absolute Lab (paper color
/// included, no black-point compensation): into another document whose CMYK space is also Generic
/// CMYK, the paper, dark inks and mid tones keep their absolute appearance.
#[test]
fn absolute_cmyk_conversion_keeps_the_absolute_appearance() {
let generic = cms();
let other_generic = Cms::new(&ColorSettings { rgb: WIDE_GAMUT_RGB.into(), ..Default::default() }).unwrap();
let absolute = |c: &Cms, ink: &Color| match (&c.cmyk, ink) {
(CmykSpace::Generic(g), Color::Cmyk { c, m, y, k }) => g.to_lab_abs([*c, *m, *y, *k]),
_ => panic!("Generic CMYK inks expected, not {ink:?}"),
};
for ink in [
Color::Cmyk { c: 0.0, m: 0.0, y: 0.0, k: 0.0 },
Color::Cmyk { c: 0.6, m: 0.5, y: 0.5, k: 0.9 },
Color::Cmyk { c: 0.3, m: 0.2, y: 0.2, k: 0.75 },
Color::Cmyk { c: 0.4, m: 0.1, y: 0.6, k: 0.1 },
] {
let moved = generic.convert_into(&other_generic, &ink, Intent::AbsoluteColorimetric);
let d = delta_e2000(absolute(&generic, &ink), absolute(&other_generic, &moved));
assert!(d < 2.0, "{ink:?} → {moved:?}: ΔE {d}");
}
}
+48 -5
View File
@@ -176,18 +176,33 @@ impl Harmony {
/// The rule's colours in the base colour's model, the base colour itself first.
pub fn apply(self, base: Color) -> Vec<Color> {
let [h, s, v] = base.to_hsb();
std::iter::once(base)
.chain(self.tones()[1..].iter().map(|tone| {
let rest = self.apply_hsb(base.to_hsb()).into_iter().skip(1);
std::iter::once(base).chain(rest.map(|[h, s, v]| keep_model(base, Color::from_hsb(h, s, v)))).collect()
}
/// The rule's colours as HSB from base HSB `hsb`, the base first: hue in degrees from 0 to 360,
/// saturation and brightness from 0 to 1. A gray base keeps its hue, so the colours keep their
/// places around a hue wheel.
pub fn apply_hsb(self, [h, s, v]: [f32; 3]) -> Vec<[f32; 3]> {
self.tones()
.iter()
.map(|tone| {
let b = match tone.bright {
Bright::Times(f) => v * f,
Bright::Contrast => contrast(v),
};
keep_model(base, Color::from_hsb(h + tone.turn, (s * tone.sat).clamp(0.0, 1.0), b.clamp(0.0, 1.0)))
}))
[(h + tone.turn).rem_euclid(360.0), (s * tone.sat).clamp(0.0, 1.0), b.clamp(0.0, 1.0)]
})
.collect()
}
/// Whether every colour of the rule has a hue of its own (Triad, but not Triad 2 or
/// Monochromatic), so that each can sit on a hue ring apart from the others.
pub fn hues_differ(self) -> bool {
let turns: Vec<f32> = self.tones().iter().map(|t| t.turn.rem_euclid(360.0)).collect();
turns.iter().enumerate().all(|(i, a)| turns[..i].iter().all(|b| a != b))
}
/// A [`THEME_SIZE`]-colour theme from `base`: the rule's colours, each followed by the lighter or
/// darker variations of it that fill the remaining places (the rule's first colours get them
/// first). The base colour comes first, every colour in its model.
@@ -409,6 +424,34 @@ mod tests {
assert_eq!(Harmony::parse("square"), None);
}
/// A rule's HSB colours match the colours `apply` gives, and a gray base keeps its hue, so its
/// colours turn around the hue ring from it.
#[test]
fn hsb_colours_match_and_keep_a_grays_hue() {
for h in Harmony::ALL {
let base = Color::rgb8(230, 120, 40);
let hsb = h.apply_hsb(base.to_hsb());
let colors = h.apply(base);
assert_eq!(hsb.len(), colors.len(), "{}", h.label());
for (a, c) in hsb.iter().zip(&colors).skip(1) {
assert_eq!(Color::from_hsb(a[0], a[1], a[2]).to_hex(), c.to_hex(), "{}", h.label());
}
}
let gray = Harmony::Triad.apply_hsb([40.0, 0.0, 0.5]);
assert_eq!(gray.iter().map(|c| c[0]).collect::<Vec<_>>(), [40.0, 160.0, 280.0]);
assert_eq!(Harmony::Analogous.apply_hsb([10.0, 1.0, 1.0])[2][0], 340.0, "hues wrap to 0..360");
}
/// Fifteen rules give every colour its own hue; the six that repeat a hue are left out.
#[test]
fn rules_whose_colours_all_have_their_own_hue() {
let differ: Vec<Harmony> = Harmony::ALL.into_iter().filter(|h| h.hues_differ()).collect();
assert_eq!(differ.len(), 15);
for h in [Harmony::Complementary2, Harmony::Monochromatic, Harmony::Shades, Harmony::Triad2, Harmony::Triad3, Harmony::HighContrast2] {
assert!(!h.hues_differ(), "{}", h.label());
}
}
#[test]
fn high_contrast_flips_brightness() {
let light = Harmony::HighContrast.apply(Color::rgb(0.9, 0.8, 0.2));
+3 -2
View File
@@ -127,8 +127,8 @@ impl Appearance {
pub fn stroke_mut(&mut self) -> Option<&mut StrokeLayer> {
self.items.iter_mut().rev().find_map(|i| if let AppearanceItem::Stroke(s) = i { Some(s) } else { None })
}
/// This appearance for other art: the pen pressure, tilt, bearing and rotation its strokes
/// were drawn with stay with them.
/// This appearance for other art: the pen pressure, tilt, bearing, rotation and wheel its
/// strokes were drawn with stay with them.
pub fn without_pressure(mut self) -> Self {
for it in &mut self.items {
if let AppearanceItem::Stroke(s) = it {
@@ -136,6 +136,7 @@ impl Appearance {
s.tilt = None;
s.bearing = None;
s.rotation = None;
s.wheel = None;
}
}
self
+6
View File
@@ -113,6 +113,11 @@ pub struct StrokeLayer {
/// pressure, it stays with this path.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rotation: Option<AngleProfile>,
/// Where the finger wheel of an airbrush pen was set along the stroke: 0 at one end of its
/// travel to 1 at the other. Brushes with Stylus Wheel variation vary with it. Like the
/// pressure, it stays with this path.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub wheel: Option<PressureProfile>,
}
/// How a gradient on a stroke is laid out (the Gradient panel's Stroke buttons). Saved by variant
@@ -187,6 +192,7 @@ impl StrokeLayer {
tilt: None,
bearing: None,
rotation: None,
wheel: None,
}
}
/// Weight of the start (`end == false`) or end arrowhead: stroke weight × its scale, at least
+3 -2
View File
@@ -130,8 +130,9 @@ impl WidthProfile {
/// Pen pressure recorded along a stroke (the Paintbrush with a graphics tablet): (position 0..1
/// along the path, pressure 0..1) samples in order, positions measured as a [`WidthProfile`]'s
/// are. The pen's tilt is kept the same way ([`StrokeLayer::tilt`]). Calligraphic and Scatter
/// brushes with Pressure or Tilt variation read them; everything else ignores them.
/// are. The pen's tilt and an airbrush pen's finger wheel are kept the same way
/// ([`StrokeLayer::tilt`], [`StrokeLayer::wheel`]). Brushes with Pressure, Tilt or Stylus Wheel
/// variation read them; everything else ignores them.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct PressureProfile {
pub points: Vec<(f64, f64)>,
+5 -3
View File
@@ -188,7 +188,7 @@ fn angle_profiles_join_samples_the_shorter_way_round() {
#[test]
fn strokes_without_pressure_round_trip_unchanged() {
let json = serde_json::to_value(StrokeLayer::new(Paint::None, 2.0)).unwrap();
for key in ["pressure", "tilt", "bearing", "rotation"] {
for key in ["pressure", "tilt", "bearing", "rotation", "wheel"] {
assert!(json.get(key).is_none(), "{key}");
}
let st: StrokeLayer = serde_json::from_value(json).unwrap();
@@ -199,19 +199,21 @@ fn strokes_without_pressure_round_trip_unchanged() {
let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
ap.stroke_mut().unwrap().pressure = Some(PressureProfile::sample());
assert_eq!(ap.without_pressure().stroke().unwrap().pressure, None);
// The pen's tilt, bearing and rotation load, save and stay behind the same way.
// The pen's tilt, bearing, rotation and wheel load, save and stay behind the same way.
let posed = StrokeLayer {
tilt: Some(PressureProfile::sample()),
bearing: Some(AngleProfile::sample()),
rotation: Some(AngleProfile { points: vec![(0.0, -45.0)] }),
wheel: Some(PressureProfile { points: vec![(0.0, 0.25), (1.0, 0.75)] }),
..back
};
assert_eq!(serde_json::to_value(&posed).unwrap()["wheel"], serde_json::json!({"points": [[0.0, 0.25], [1.0, 0.75]]}));
let again: StrokeLayer = serde_json::from_value(serde_json::to_value(&posed).unwrap()).unwrap();
assert_eq!(again, posed);
let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
*ap.stroke_mut().unwrap() = posed;
let st = ap.without_pressure().stroke().cloned().unwrap();
assert_eq!((st.pressure, st.tilt, st.bearing, st.rotation), (None, None, None, None));
assert_eq!((st.pressure, st.tilt, st.bearing, st.rotation, st.wheel), (None, None, None, None, None));
}
/// The Lens profile's widths at its middle, a quarter of the way along and past its end.
+52 -9
View File
@@ -6,7 +6,7 @@
//! tool clicked.
//! - **Paint**: colours, gradients (stops resampled to a common set when their counts differ),
//! opacity, stroke weight, dashes, miter limit, width profiles and the pen pressure, tilt,
//! bearing and rotation that brushes read interpolate; what can't
//! bearing, rotation and wheel that brushes read interpolate; what can't
//! (caps, joins, brushes, fonts, symbols, text content) switches halfway.
//! - **Groups** pair their children in stacking order; the children one group has more of grow
//! out of the other group's centre. Compound paths stay compound paths.
@@ -429,8 +429,8 @@ fn lerp_angle(x: Option<&AngleProfile>, y: Option<&AngleProfile>, t: f64) -> Opt
}
/// Interpolate a stroke's paint, weight, opacity, miter limit, dashes, arrowhead scale, width
/// profile and the pen pressure, tilt, bearing and rotation its brush reads into `o` (a copy of
/// the nearer stroke, so caps, joins, alignment, arrowheads and brushes switch halfway).
/// profile and the pen pressure, tilt, bearing, rotation and wheel its brush reads into `o` (a
/// copy of the nearer stroke, so caps, joins, alignment, arrowheads and brushes switch halfway).
fn lerp_stroke(o: &mut StrokeLayer, x: &StrokeLayer, y: &StrokeLayer, t: f64) {
let tf = t as f32;
o.paint = lerp_paint(&x.paint, &y.paint, tf);
@@ -444,6 +444,7 @@ fn lerp_stroke(o: &mut StrokeLayer, x: &StrokeLayer, y: &StrokeLayer, t: f64) {
o.tilt = lerp_pressure(x.tilt.as_ref(), y.tilt.as_ref(), t);
o.bearing = lerp_angle(x.bearing.as_ref(), y.bearing.as_ref(), t);
o.rotation = lerp_angle(x.rotation.as_ref(), y.rotation.as_ref(), t);
o.wheel = lerp_pressure(x.wheel.as_ref(), y.wheel.as_ref(), t);
}
/// Interpolate appearance stacks: item by item when their structure matches, else the top fill
@@ -755,9 +756,9 @@ fn reorient_dash(d: &mut Dash, o: Orient, lens: &[f64]) {
}
/// A key's stroke read along its subpaths turned as `o` says (`lens`: their lengths): its width
/// profile (whose sides swap when reversed), pen pressure, tilt, bearing and rotation, its dashes,
/// a gradient along the path or across it (whose sides swap when reversed). Its arrowheads stay as
/// they are.
/// profile (whose sides swap when reversed), pen pressure, tilt, bearing, rotation and wheel, its
/// dashes, a gradient along the path or across it (whose sides swap when reversed). Its arrowheads
/// stay as they are.
fn reorient_stroke(s: &mut StrokeLayer, o: Orient, lens: &[f64]) {
if o.is_identity() {
return;
@@ -805,7 +806,7 @@ fn reorient_stroke(s: &mut StrokeLayer, o: Orient, lens: &[f64]) {
let out = reoriented(&pts, o, |f| p.at(f), |v| v, |(l, r)| (r, l));
p.points = out.into_iter().map(|(t, (l, r))| (t, l, r)).collect();
}
for p in [&mut s.pressure, &mut s.tilt].into_iter().flatten() {
for p in [&mut s.pressure, &mut s.tilt, &mut s.wheel].into_iter().flatten() {
let out = reoriented(&p.points, o, |f| p.at(f), same, same);
p.points = out;
}
@@ -842,8 +843,8 @@ fn reorient_strokes(n: &mut Node, o: Orient) {
/// Turn the strokes of path or compound path `n` for Reverse Path Direction, before its subpaths
/// flagged in `reversed` are reversed with [`SubPath::reverse`] (a closed one then starts at its
/// last anchor): each stroke's width profile (sides swapped), pen pressure, tilt, bearing and
/// rotation then run the new way, so the stroke draws as it did. A compound path's subpaths are
/// last anchor): each stroke's width profile (sides swapped), pen pressure, tilt, bearing,
/// rotation and wheel then run the new way, so the stroke draws as it did. A compound path's subpaths are
/// its members' subpaths in order. A stroke reads one profile along every subpath, so it turns
/// only when all of them turn alike. Arrowheads stay at the path's start and end.
pub fn reverse_stroke_records(n: &mut Node, reversed: &[bool]) {
@@ -3014,6 +3015,48 @@ mod tests {
assert!((rot(0.5, 0.499) - rot(0.5, 0.501)).abs() < 1.0, "no jump where the key started: {:?}", stroke(&blend.at(0.5)).rotation);
}
#[test]
fn a_stylus_wheel_recording_turns_with_the_gradient_and_dashes_of_its_stroke() {
let keyed = |path: PathData, edit: &dyn Fn(&mut StrokeLayer)| {
let mut ap = Appearance::default();
ap.set_stroke(Paint::solid(Color::BLACK));
if let Some(s) = ap.stroke_mut() {
edit(s);
}
Node::path(NodeId(1), path, ap)
};
let stroke = |n: &Node| n.appearance.stroke().cloned().unwrap_or_else(|| panic!("a stroke"));
let wheel = |s: &StrokeLayer, f: f64| s.wheel.as_ref().map_or(PressureProfile::MID, |p| p.at(f));
let light = |s: &StrokeLayer, u: f32| match &s.paint {
Paint::Gradient(g) => g.gradient.sample(u).0.to_rgb().iter().sum::<f32>(),
p => panic!("a gradient: {p:?}"),
};
let recorded = |s: &mut StrokeLayer| {
s.wheel = Some(PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] });
s.paint = Paint::Gradient(Box::new(GradientPaint::new(Gradient::default())));
s.gradient_mode = StrokeGradientMode::Along;
s.dash = Some(Dash { pattern: vec![1.0, 2.0, 3.0, 1.5], offset: 0.75, align_corners: false });
};
// An open key clicked at its last anchor: the wheel runs the other way with the gradient
// along it, and the dashes are read from its end.
let line = |x: f64| PathData::single(SubPath::polyline(&[Point::new(x, 0.0), Point::new(x + 13.0, 0.0)], false));
let key = keyed(line(100.0), &recorded);
let s = stroke(&Lerp::new(&keyed(line(0.0), &|_| {}), &key, (None, Some(1))).at(1.0));
assert!((wheel(&s, 0.0) - 1.0).abs() < 1e-9 && wheel(&s, 1.0).abs() < 1e-9, "{:?}", s.wheel);
assert!(light(&s, 0.0) < 0.01 && light(&s, 1.0) > 2.99, "{:?}", s.paint);
assert_ne!(s.dash, stroke(&key).dash, "the dashes turn too");
// A closed key started half way round starts its wheel recording there, stepping where its
// own start was, as its gradient does.
let square = |x: f64| shapes::rectangle(Rect::new(x, 0.0, x + 10.0, 10.0));
let key = keyed(square(100.0), &recorded);
let s = stroke(&Lerp::new(&keyed(square(0.0), &|_| {}), &key, (Some(0), Some(2))).at(1.0));
assert!((wheel(&s, 0.25) - 0.75).abs() < 1e-9 && (wheel(&s, 0.75) - 0.25).abs() < 1e-9, "{:?}", s.wheel);
assert!((light(&s, 0.25) - 0.75).abs() < 0.02 && (light(&s, 0.75) - 2.25).abs() < 0.02, "{:?}", s.paint);
// Half way through, a key without a recording counts as the wheel half way.
let s = stroke(&Lerp::new(&keyed(square(0.0), &|_| {}), &key, (Some(0), Some(2))).at(0.5));
assert!((wheel(&s, 0.25) - 0.625).abs() < 1e-9, "{:?}", s.wheel);
}
#[test]
fn stroke_gradients_and_dashes_turn_with_a_key_path_started_elsewhere() {
let keyed = |path: PathData, edit: &dyn Fn(&mut StrokeLayer)| {
+3
View File
@@ -35,6 +35,7 @@ impl Document {
char_styles,
para_styles,
composite_fonts,
kinsoku_sets,
text_threads,
symbols,
graph_designs,
@@ -96,6 +97,7 @@ impl Document {
&& *char_styles == other.char_styles
&& *para_styles == other.para_styles
&& *composite_fonts == other.composite_fonts
&& *kinsoku_sets == other.kinsoku_sets
&& *text_threads == other.text_threads
&& symbols.len() == other.symbols.len()
&& symbols.iter().zip(&other.symbols).all(|(a, b)| a.name == b.name && Arc::ptr_eq(&a.art, &b.art))
@@ -221,6 +223,7 @@ impl Document {
char_styles: Default::default(),
para_styles: Default::default(),
composite_fonts: Default::default(),
kinsoku_sets: Default::default(),
text_threads: vec![],
symbols: vec![],
graph_designs: vec![],
+5 -1
View File
@@ -138,7 +138,7 @@ pub use text::{
RubyPosition, RubySpan, ScriptMetrics, SingleWordJustify, TabAlign, TabStop, TextFlow, TextKind, TextObject, TextRun, TextStyleDef, TextWrap,
VerticalAlign, WrapShape,
};
pub use text::{CharClass, CompositeClass, CompositeFont, CompositePart, CompositeParts, CustomCharSet};
pub use text::{CharClass, CompositeClass, CompositeFont, CompositePart, CompositeParts, CustomCharSet, KinsokuSet};
pub use trace::TraceView;
pub use variables::{DataSet, DataValue, Variable, VariableKind, Variables};
pub use vectorcraft_color as color;
@@ -218,6 +218,10 @@ pub struct Document {
/// Type › Composite Fonts…: the composite fonts defined in the document, by name.
#[serde(default, skip_serializing_if = "skip::is_empty_vec")]
pub composite_fonts: Shared<Vec<CompositeFont>>,
/// Type › Kinsoku Shori Settings…: the custom Kinsoku Shori sets defined in the document, by
/// name. A paragraph using one holds a copy of it ([`ParaStyle::kinsoku_set`]).
#[serde(default, skip_serializing_if = "skip::is_empty_vec", deserialize_with = "text::read_kinsoku_sets")]
pub kinsoku_sets: Shared<Vec<KinsokuSet>>,
/// Threaded text: area-type frames one story flows through, in order.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub text_threads: Vec<Vec<NodeId>>,
+36 -1
View File
@@ -113,6 +113,19 @@ impl Document {
.map(|f| f.name.capacity() + crate::CharClass::ALL.into_iter().map(|k| part(f.parts.get(k))).sum::<usize>() + custom(f))
.sum::<usize>()
});
n += shared(&self.kinsoku_sets, &newer.kinsoku_sets, |k| {
vec_bytes(k)
+ k.iter()
.map(|s: &crate::KinsokuSet| {
s.name.capacity()
+ vec_bytes(&s.cannot_start)
+ vec_bytes(&s.cannot_end)
+ vec_bytes(&s.hanging)
+ vec_bytes(&s.inseparable)
+ s.inseparable.iter().map(String::capacity).sum::<usize>()
})
.sum::<usize>()
});
n += shared(&self.saved_selections, &newer.saved_selections, |s| {
vec_bytes(s) + s.iter().map(|s: &SavedSelection| s.name.capacity() + vec_bytes(&s.objects)).sum::<usize>()
});
@@ -354,7 +367,8 @@ pub fn appearance_heap_bytes(a: &Appearance) -> usize {
AppearanceItem::Stroke(s) => {
s.dash.as_ref().map_or(0, |d| vec_bytes(&d.pattern))
+ s.profile.as_ref().map_or(0, |p| vec_bytes(&p.points))
+ s.pressure.as_ref().map_or(0, |p| vec_bytes(&p.points))
+ [&s.pressure, &s.tilt, &s.wheel].into_iter().flatten().map(|p| vec_bytes(&p.points)).sum::<usize>()
+ [&s.bearing, &s.rotation].into_iter().flatten().map(|p| vec_bytes(&p.points)).sum::<usize>()
+ s.brush.as_ref().map_or(0, String::capacity)
}
_ => 0,
@@ -425,6 +439,27 @@ mod tests {
d
}
#[test]
fn every_pen_recording_of_a_stroke_counts() {
use crate::{AngleProfile, PressureProfile};
let plain = Appearance::default_art();
let base = appearance_heap_bytes(&plain);
let ramp = || PressureProfile { points: (0..100).map(|i| (f64::from(i) / 99.0, 0.5)).collect() };
let turn = || AngleProfile { points: (0..100).map(|i| (f64::from(i) / 99.0, 10.0)).collect() };
for i in 0..5 {
let mut a = plain.clone();
let s = a.stroke_mut().unwrap();
match i {
0 => s.pressure = Some(ramp()),
1 => s.tilt = Some(ramp()),
2 => s.bearing = Some(turn()),
3 => s.rotation = Some(turn()),
_ => s.wheel = Some(ramp()),
}
assert!(appearance_heap_bytes(&a) >= base + 100 * size_of::<(f64, f64)>(), "recording {i}");
}
}
#[test]
fn an_unchanged_copy_keeps_nothing_of_its_own() {
let d = doc_with_rects(10);
+3 -2
View File
@@ -10,8 +10,9 @@ use super::{Node, PathData};
pub struct NodeExtras {
/// Opacity mask (Transparency panel). Its art lives here, outside the layer tree.
pub mask: Option<Box<OpacityMask>>,
/// Image Trace object: `{preset, params, view?}` it was traced with (the Image Trace panel shows
/// them; `view` is its [`crate::TraceView`] id, absent for the tracing result).
/// Image Trace object: `{preset, params, view?, split?}` it was traced with (the Image Trace
/// panel shows them; `view` is its [`crate::TraceView`] id, absent for the tracing result, and
/// `split` the Split view's divider, [`crate::TraceView::split_of`]).
pub trace: Option<Box<serde_json::Value>>,
/// Object → Text Wrap: area type below this object (in the same layer) flows around it.
pub wrap: Option<crate::text::TextWrap>,
+40
View File
@@ -157,6 +157,7 @@ pub const STYLE_LIBRARIES: &[BuiltinStyleLibrary] = &[
BuiltinStyleLibrary { id: "hand-drawn", name: "Hand-Drawn", make: hand_drawn },
BuiltinStyleLibrary { id: "textures", name: "Textures", make: textures },
BuiltinStyleLibrary { id: "painted-sketched", name: "Painted and Sketched", make: painted_sketched },
BuiltinStyleLibrary { id: "paper-cutouts", name: "Paper Cutouts", make: paper_cutouts },
BuiltinStyleLibrary { id: "gradient-finishes", name: "Gradient Finishes", make: gradient_finishes },
BuiltinStyleLibrary { id: "shape-effects", name: "Shape Effects", make: shape_effects },
BuiltinStyleLibrary { id: "blends-transparency", name: "Blends and Transparency", make: blends_transparency },
@@ -384,6 +385,25 @@ fn painted_sketched() -> Vec<GraphicStyle> {
]
}
/// Paper Cutouts: original layered paper colors with visible cut edges and crisp cast shadows.
fn paper_cutouts() -> Vec<GraphicStyle> {
let cutout = |name: &str, face: &str, edge: &str, rim: &str, shadow: &str, x: f64, y: f64| {
style(
name,
vec![F(fill(face)), S(stroke(edge, 7.0)), S(stroke(rim, 2.0))],
vec![fx("stylize.dropShadow", json!({"mode": "normal", "opacity": 100.0, "x": x, "y": y, "blur": 0.0, "color": shadow}))],
)
};
vec![
cutout("Coral Layers", "#ff6b6b", "#f9c74f", "#fff4e6", "#6d597a", 5.0, 5.0),
cutout("Mint Layers", "#80cbc4", "#2a9d8f", "#e9f5db", "#355070", 4.0, 6.0),
cutout("Midnight Layers", "#3d5a80", "#ee6c4d", "#e0fbfc", "#1b263b", 6.0, 4.0),
cutout("Sunflower Sheet", "#ffbe0b", "#fb5607", "#fff3b0", "#6a4c93", 3.0, 6.0),
cutout("Rose Layers", "#f28482", "#84a59d", "#f7ede2", "#4a4e69", 6.0, 3.0),
cutout("Monochrome Stack", "#f5f5f5", "#444444", "#ffffff", "#222222", 5.0, 5.0),
]
}
/// Textures: fills and strokes painted with the catalog's texture effects (grain, canvas and
/// burlap surfaces, craquelure, tiles, patchwork, stained glass and water paper).
fn textures() -> Vec<GraphicStyle> {
@@ -702,6 +722,26 @@ mod tests {
assert_eq!(ids.iter().position(|&i| i == "textures"), ids.iter().position(|&i| i == "hand-drawn").map(|i| i + 1), "after Hand-Drawn");
}
#[test]
fn paper_cutouts_have_layered_edges_and_crisp_shadows() {
let lib = builtin_style_library("paper-cutouts").unwrap();
assert_eq!(lib.name, "Paper Cutouts");
let names: Vec<&str> = lib.styles.iter().map(|g| g.name.as_str()).collect();
assert_eq!(names, ["Coral Layers", "Mint Layers", "Midnight Layers", "Sunflower Sheet", "Rose Layers", "Monochrome Stack"]);
for g in &lib.styles {
assert_eq!(g.appearance.items.len(), 3, "{} has a face and two cut edges", g.name);
assert!(matches!(g.appearance.items[0], AppearanceItem::Fill(_)));
assert!(matches!(g.appearance.items[1], AppearanceItem::Stroke(_)));
assert!(matches!(g.appearance.items[2], AppearanceItem::Stroke(_)));
assert_eq!(g.appearance.effects.len(), 1);
let shadow = &g.appearance.effects[0];
assert_eq!(shadow.id, "stylize.dropShadow");
assert_eq!(shadow.params["blur"], 0.0);
assert_eq!(shadow.params["opacity"], 100.0);
}
assert_eq!(read(&write(&lib), "Fallback").unwrap(), *lib);
}
/// The built-in styles' Warps draw with the map a new Warp takes.
#[test]
fn builtin_warp_styles_take_the_nets_map() {
+3
View File
@@ -9,6 +9,7 @@ use crate::appearance::{Appearance, AppearanceItem, Dash, FillLayer, LineCap, Li
mod area;
mod char_style;
mod composite;
mod kinsoku_set;
mod object;
mod para_style;
mod runs;
@@ -25,6 +26,8 @@ pub use composite::{
COMPOSITE_BASELINE, COMPOSITE_FONTS_MAX, COMPOSITE_NAME_MAX, COMPOSITE_SCALE, COMPOSITE_SIZE, CUSTOM_CHARS_MAX, CUSTOM_SETS_MAX, CharClass,
CompositeClass, CompositeClasses, CompositeFont, CompositePart, CompositeParts, CustomCharSet,
};
pub(crate) use kinsoku_set::read_sets as read_kinsoku_sets;
pub use kinsoku_set::{KINSOKU_BUILT_IN, KINSOKU_CATEGORY_MAX, KINSOKU_NAME_MAX, KINSOKU_SEQUENCE, KINSOKU_SETS_MAX, KinsokuSet};
pub use para_style::{
Burasagari, Composer, FirstBaseline, HyphenationOptions, JustificationOptions, Justify, Kashida, Kinsoku, KinsokuShoriType, LeadingModel,
Mojikumi, ParaDirection, ParaStyle, SingleWordJustify,
+382
View File
@@ -0,0 +1,382 @@
//! Type › Kinsoku Shori Settings…: a custom Kinsoku Shori set, saved with the document. Its four
//! categories hold the characters that may not start a line, those that may not end one, the
//! hanging punctuation that Burasagari lets stand outside a line, and the inseparable sequences
//! that Bunri-Kinshi keeps on one line. A paragraph that uses a set holds a copy of it
//! ([`super::ParaStyle::kinsoku_set`]).
//!
//! Behavior reference: the help page
//! <https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/use-kinsoku-for-japanese-line-breaking.html>.
//! The name rules and the limits are VectorCraft's own.
use serde::{Deserialize, Serialize};
/// The longest set name, in characters.
pub const KINSOKU_NAME_MAX: usize = 128;
/// The most custom sets a document keeps.
pub const KINSOKU_SETS_MAX: usize = 256;
/// The most characters one category holds (an inseparable sequence counts each of its characters).
pub const KINSOKU_CATEGORY_MAX: usize = 4096;
/// The fewest and most characters of an inseparable sequence.
pub const KINSOKU_SEQUENCE: std::ops::RangeInclusive<usize> = 2..=16;
/// The names of the built-in sets, which no custom set may take (in any case).
pub const KINSOKU_BUILT_IN: [&str; 3] = ["None", "Hard", "Soft"];
/// A custom Kinsoku Shori set. Each list of characters is sorted and holds each character once;
/// the inseparable sequences are sorted and unique.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(from = "KinsokuSetFile", into = "KinsokuSetFile")]
pub struct KinsokuSet {
pub name: String,
/// Cannot Start Line: characters that never start a line.
pub cannot_start: Vec<char>,
/// Cannot End Line: characters that never end a line.
pub cannot_end: Vec<char>,
/// Hanging Punctuation: characters that Burasagari lets hang outside a line's end.
pub hanging: Vec<char>,
/// Bunri-Kinshi: sequences of characters that a line never breaks inside while Bunri-Kinshi is
/// on.
pub inseparable: Vec<String>,
}
/// [`KinsokuSet`] as saved: each category of single characters as one string.
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct KinsokuSetFile {
#[serde(default, deserialize_with = "read_name")]
name: String,
#[serde(default, deserialize_with = "read_category")]
cannot_start: String,
#[serde(default, deserialize_with = "read_category")]
cannot_end: String,
#[serde(default, deserialize_with = "read_category")]
hanging: String,
#[serde(default, deserialize_with = "read_sequences")]
inseparable: Vec<String>,
}
/// The most characters of a name read from a file, spaces around it included; a longer name is
/// not read.
const NAME_READ_MAX: usize = KINSOKU_CATEGORY_MAX;
/// The most characters of a category read from a file, before control and space characters are
/// left out.
const CATEGORY_READ_MAX: usize = KINSOKU_CATEGORY_MAX * 4;
/// The longest inseparable sequence, as a constant for [`Capped`].
const SEQUENCE_MAX: usize = *KINSOKU_SEQUENCE.end();
/// Text read from a file, copied up to `N` characters: a longer text keeps its first `N + 1`, which
/// no rule that allows `N` takes, and is not copied whole.
struct Capped<const N: usize>(String);
impl<'de, const N: usize> Deserialize<'de> for Capped<N> {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Text<const N: usize>;
impl<const N: usize> serde::de::Visitor<'_> for Text<N> {
type Value = Capped<N>;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("text")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Capped<N>, E> {
Ok(Capped(v.chars().take(N + 1).collect()))
}
}
d.deserialize_str(Text::<N>)
}
}
/// A set's name as read from a file: empty, so not read, when it is longer than [`NAME_READ_MAX`].
fn read_name<'de, D: serde::Deserializer<'de>>(d: D) -> Result<String, D::Error> {
let Capped(name) = Capped::<NAME_READ_MAX>::deserialize(d)?;
Ok(if name.chars().count() > NAME_READ_MAX { String::new() } else { name })
}
/// A category of a set as read from a file: its first [`CATEGORY_READ_MAX`] characters.
fn read_category<'de, D: serde::Deserializer<'de>>(d: D) -> Result<String, D::Error> {
let Capped(text) = Capped::<CATEGORY_READ_MAX>::deserialize(d)?;
Ok(text.chars().take(CATEGORY_READ_MAX).collect())
}
/// Reads a list, keeping the items `keep` keeps up to `max` of them and skipping the rest of a
/// longer list without storing it.
struct Kept<T, F>(usize, F, std::marker::PhantomData<T>);
impl<'de, T: Deserialize<'de>, F: FnMut(&T) -> bool> serde::de::Visitor<'de> for Kept<T, F> {
type Value = Vec<T>;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("a list")
}
fn visit_seq<A: serde::de::SeqAccess<'de>>(mut self, mut seq: A) -> Result<Vec<T>, A::Error> {
let mut out = Vec::new();
while out.len() < self.0 {
match seq.next_element::<T>()? {
Some(item) if (self.1)(&item) => out.push(item),
Some(_) => {}
None => return Ok(out),
}
}
while seq.next_element::<serde::de::IgnoredAny>()?.is_some() {}
Ok(out)
}
}
/// A set's inseparable sequences as read from a file: those [`KinsokuSet::takes_sequence`] takes,
/// at most [`KINSOKU_CATEGORY_MAX`]. A text longer than a sequence is not copied whole.
fn read_sequences<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<String>, D::Error> {
let keep = |s: &Capped<SEQUENCE_MAX>| KinsokuSet::takes_sequence(&s.0);
let kept = d.deserialize_seq(Kept(KINSOKU_CATEGORY_MAX, keep, std::marker::PhantomData))?;
Ok(kept.into_iter().map(|Capped(s)| s).collect())
}
impl From<KinsokuSet> for KinsokuSetFile {
fn from(s: KinsokuSet) -> Self {
Self {
name: s.name,
cannot_start: s.cannot_start.into_iter().collect(),
cannot_end: s.cannot_end.into_iter().collect(),
hanging: s.hanging.into_iter().collect(),
inseparable: s.inseparable,
}
}
}
impl From<KinsokuSetFile> for KinsokuSet {
/// A set read from a file keeps what a set can hold: its name trimmed, or no name when
/// [`KinsokuSet::clean_name`] refuses it; each category's characters sorted and unique, without
/// control or space characters, up to [`KINSOKU_CATEGORY_MAX`]; and the inseparable sequences of
/// [`KINSOKU_SEQUENCE`] characters, up to the same count of characters.
fn from(f: KinsokuSetFile) -> Self {
let chars = |s: &str| s.chars().filter(|&c| KinsokuSet::takes_char(c)).take(KINSOKU_CATEGORY_MAX * 4).collect::<Vec<char>>();
let mut set = KinsokuSet {
name: KinsokuSet::clean_name(&f.name).unwrap_or_default(),
cannot_start: chars(&f.cannot_start),
cannot_end: chars(&f.cannot_end),
hanging: chars(&f.hanging),
inseparable: f.inseparable,
};
set.normalize();
set.cannot_start.truncate(KINSOKU_CATEGORY_MAX);
set.cannot_end.truncate(KINSOKU_CATEGORY_MAX);
set.hanging.truncate(KINSOKU_CATEGORY_MAX);
let mut total = 0;
set.inseparable.retain(|s| {
total += s.chars().count();
total <= KINSOKU_CATEGORY_MAX
});
set
}
}
/// A document's custom sets as read from a file: each set with a name, the first set of each name
/// (in any case), at most [`KINSOKU_SETS_MAX`]; the sets past those are skipped without being
/// stored.
pub(crate) fn read_sets<'de, D: serde::Deserializer<'de>>(d: D) -> Result<crate::Shared<Vec<KinsokuSet>>, D::Error> {
let mut seen = std::collections::HashSet::new();
let keep = move |s: &KinsokuSet| !s.name.is_empty() && seen.insert(s.name.to_lowercase());
Ok(crate::Shared::new(d.deserialize_seq(Kept(KINSOKU_SETS_MAX, keep, std::marker::PhantomData))?))
}
impl KinsokuSet {
/// Do `a` and `b` name the same set: equal in any case?
pub fn same_name(a: &str, b: &str) -> bool {
a == b || a.to_lowercase() == b.to_lowercase()
}
/// The set of `sets` (a document's custom sets) named `name`, in any case.
pub fn named<'a>(sets: &'a [KinsokuSet], name: &str) -> Option<&'a KinsokuSet> {
sets.iter().find(|s| Self::same_name(&s.name, name))
}
/// `name` trimmed, when it can name a custom set: not empty, at most [`KINSOKU_NAME_MAX`]
/// characters, without control characters, and none of [`KINSOKU_BUILT_IN`] in any case.
pub fn clean_name(name: &str) -> Option<String> {
let name = name.trim();
let ok = !name.is_empty()
&& name.chars().count() <= KINSOKU_NAME_MAX
&& !name.chars().any(char::is_control)
&& !KINSOKU_BUILT_IN.iter().any(|b| Self::same_name(b, name));
ok.then(|| name.to_string())
}
/// Can a category hold character `c`: not a control character nor a space?
pub fn takes_char(c: char) -> bool {
!c.is_control() && !c.is_whitespace()
}
/// Can `s` be an inseparable sequence: [`KINSOKU_SEQUENCE`] characters that
/// [`Self::takes_char`] takes?
pub fn takes_sequence(s: &str) -> bool {
KINSOKU_SEQUENCE.contains(&s.chars().count()) && s.chars().all(Self::takes_char)
}
/// Sort each category and keep each character or sequence once.
pub fn normalize(&mut self) {
for list in [&mut self.cannot_start, &mut self.cannot_end, &mut self.hanging] {
list.sort_unstable();
list.dedup();
}
self.inseparable.sort_unstable();
self.inseparable.dedup();
}
/// Why this set can't be used, if it can't: a name [`Self::clean_name`] refuses, a character
/// [`Self::takes_char`] refuses, a sequence [`Self::takes_sequence`] refuses, or a category of
/// more than [`KINSOKU_CATEGORY_MAX`] characters.
pub fn check(&self) -> Result<(), String> {
if Self::clean_name(&self.name).as_deref() != Some(self.name.as_str()) {
return Err(format!(
"`{}` can't name a Kinsoku set (1 to {KINSOKU_NAME_MAX} characters, no control characters, not None, Hard or Soft)",
self.name
));
}
for (key, list) in [("cannotStart", &self.cannot_start), ("cannotEnd", &self.cannot_end), ("hanging", &self.hanging)] {
if list.len() > KINSOKU_CATEGORY_MAX {
return Err(format!("{key}: at most {KINSOKU_CATEGORY_MAX} characters"));
}
if let Some(c) = list.iter().find(|&&c| !Self::takes_char(c)) {
return Err(format!("{key}: U+{:04X} is a control or space character", u32::from(*c)));
}
}
if let Some(s) = self.inseparable.iter().find(|s| !Self::takes_sequence(s)) {
return Err(format!(
"inseparable: `{s}` must be {} to {} characters, none of them control or space characters",
KINSOKU_SEQUENCE.start(),
KINSOKU_SEQUENCE.end()
));
}
if self.inseparable.iter().map(|s| s.chars().count()).sum::<usize>() > KINSOKU_CATEGORY_MAX {
return Err(format!("inseparable: at most {KINSOKU_CATEGORY_MAX} characters in all"));
}
Ok(())
}
/// May `c` not start a line?
pub fn cannot_start(&self, c: char) -> bool {
self.cannot_start.binary_search(&c).is_ok()
}
/// May `c` not end a line?
pub fn cannot_end(&self, c: char) -> bool {
self.cannot_end.binary_search(&c).is_ok()
}
/// May `c` hang outside a line's end (Burasagari)?
pub fn hangs(&self, c: char) -> bool {
self.hanging.binary_search(&c).is_ok()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::text::{Kinsoku, ParaStyle};
use serde_json::json;
use std::sync::Arc;
/// A set is saved with each category as one string and read back as it was; a paragraph saves
/// its copy of the set beside Hard, and a paragraph saved without one reads with none.
#[test]
fn kinsoku_sets_are_saved_with_the_paragraphs_that_use_them() {
let mut set = KinsokuSet {
name: "Tight".into(),
cannot_start: "」。、".chars().collect(),
cannot_end: vec!['「'],
hanging: vec!['、', '。'],
inseparable: vec!["——".into(), "あいう".into()],
};
set.normalize();
let saved = serde_json::to_value(&set).unwrap();
assert_eq!(saved, json!({"name": "Tight", "cannotStart": "、。」", "cannotEnd": "「", "hanging": "、。", "inseparable": ["——", "あいう"]}));
assert_eq!(serde_json::from_value::<KinsokuSet>(saved).unwrap(), set);
let p = ParaStyle { kinsoku_set: Some(Arc::new(set.clone())), ..ParaStyle::default() };
let v = serde_json::to_value(&p).unwrap();
assert_eq!(v["kinsoku_set"]["name"], "Tight");
assert!(v.get("kinsoku").is_none(), "Hard, the default, is left out");
let back: ParaStyle = serde_json::from_value(v).unwrap();
assert_eq!(back.kinsoku_set.as_deref(), Some(&set));
assert_eq!((back.kinsoku, back.kinsoku_name(), back.kinsoku_on()), (Kinsoku::Hard, "Tight", true));
let old: ParaStyle = serde_json::from_value(json!({"justify": "Left", "kinsoku": "soft"})).unwrap();
assert_eq!((old.kinsoku_set, old.kinsoku), (None, Kinsoku::Soft));
assert!(serde_json::to_value(ParaStyle::default()).unwrap().get("kinsoku_set").is_none());
}
/// A set read from a file keeps only what a set can hold: each character once, sorted, without
/// control or space characters, at most 4096 to a category, and sequences of 2 to 16
/// characters; a category left out is empty. Only the start of a longer text is read.
#[test]
fn kinsoku_sets_read_from_a_file_keep_what_a_set_can_hold() {
let long: String = (0x4E00..0x4E00 + 5000).filter_map(char::from_u32).collect();
let v = json!({
"name": "Odd",
"cannotStart": "ccba \t\u{0}a",
"cannotEnd": long,
"inseparable": ["a", "ab", "ab", "a b", "abcdefghijklmnopq", "abcdefghijklmnop"],
});
let set: KinsokuSet = serde_json::from_value(v).unwrap();
assert_eq!(set.cannot_start, ['a', 'b', 'c']);
assert_eq!(set.cannot_end.len(), KINSOKU_CATEGORY_MAX);
assert!(set.hanging.is_empty());
assert_eq!(set.inseparable, ["ab", "abcdefghijklmnop"]);
assert!(set.check().is_ok());
let empty: KinsokuSet = serde_json::from_value(json!({})).unwrap();
assert!(empty.check().is_err(), "a set needs a name");
// Only the start of a long text is read: a category's first 16384 characters, a name of at
// most 4096 characters, spaces included, and a sequence's first 17.
let spaces = " ".repeat(CATEGORY_READ_MAX);
let text = format!(
r#"{{"name": "{}Tight", "hanging": "{spaces}、", "cannotEnd": "、", "inseparable": ["{}あ"]}}"#,
" ".repeat(NAME_READ_MAX),
"あ".repeat(100)
);
let set: KinsokuSet = serde_json::from_str(&text).unwrap();
assert_eq!((set.name.as_str(), set.hanging.len(), set.cannot_end.len(), set.inseparable.len()), ("", 0, 1, 0));
let set: KinsokuSet = serde_json::from_str(&format!(r#"{{"name": "{}Tight"}}"#, " ".repeat(NAME_READ_MAX - 5))).unwrap();
assert_eq!(set.name, "Tight");
}
/// A set read from a file under a name a custom set can't take (a built-in name, a blank one)
/// is not read: a paragraph holding it keeps its Kinsoku Set, so it doesn't show as Hard while
/// composing by other characters, and a document's list drops it. The list also keeps the
/// first set of each name in any case, and a name read with spaces around it is trimmed. A
/// paragraph's set read beside None or Soft is not read either.
#[test]
fn kinsoku_sets_read_under_names_a_set_cannot_take_are_dropped() {
let p: ParaStyle = serde_json::from_value(json!({"kinsoku_set": {"name": "Hard", "cannotStart": "あ"}})).unwrap();
assert_eq!((p.kinsoku_set, p.kinsoku), (None, Kinsoku::Hard));
let p: ParaStyle = serde_json::from_value(json!({"kinsoku": "none", "kinsoku_set": {"name": "Tight", "cannotStart": "あ"}})).unwrap();
assert_eq!((p.kinsoku_set.is_none(), p.kinsoku_name()), (true, "None"));
let p: ParaStyle = serde_json::from_value(json!({"kinsoku_set": {"name": " Tight ", "cannotStart": "あ"}})).unwrap();
assert_eq!(p.kinsoku_name(), "Tight");
let mut v = serde_json::to_value(crate::Document::new(100.0, 100.0)).unwrap();
v["kinsoku_sets"] = json!([{"name": "soft"}, {"name": " "}, {"name": "Tight", "cannotEnd": "「"}, {"name": "TIGHT"}, {"name": "Loose"}]);
let d: crate::Document = serde_json::from_value(v).unwrap();
let names: Vec<&str> = d.kinsoku_sets.iter().map(|s| s.name.as_str()).collect();
assert_eq!(names, ["Tight", "Loose"]);
assert_eq!(d.kinsoku_sets[0].cannot_end, ['「']);
let mut v = serde_json::to_value(crate::Document::new(100.0, 100.0)).unwrap();
// The sets past the limit are skipped unread: one that isn't a set at all doesn't fail the
// file.
let mut list: Vec<serde_json::Value> = (0..KINSOKU_SETS_MAX + 5).map(|i| json!({"name": format!("S{i}")})).collect();
list.push(json!("not a set"));
v["kinsoku_sets"] = json!(list);
let d: crate::Document = serde_json::from_value(v).unwrap();
assert_eq!(d.kinsoku_sets.len(), KINSOKU_SETS_MAX);
let past: Vec<String> = (0..KINSOKU_CATEGORY_MAX + 1).map(|i| format!("あ{i}")).chain(["x".to_string()]).collect();
let mut seqs: Vec<serde_json::Value> = past.iter().map(|s| json!(s)).collect();
seqs.push(json!(7));
let set: KinsokuSet = serde_json::from_value(json!({"name": "Long", "inseparable": seqs})).unwrap();
assert!(set.check().is_ok());
}
/// A name is trimmed, 1 to 128 characters without control characters, and never None, Hard or
/// Soft in any case; names match in any case.
#[test]
fn kinsoku_set_names_are_checked() {
assert_eq!(KinsokuSet::clean_name(" Tight "), Some("Tight".into()));
for bad in ["", " ", "hard", "SOFT", "None", "a\u{7}b", &"x".repeat(KINSOKU_NAME_MAX + 1)] {
assert_eq!(KinsokuSet::clean_name(bad), None, "{bad:?}");
}
assert!(KinsokuSet::clean_name(&"漢".repeat(KINSOKU_NAME_MAX)).is_some());
assert!(KinsokuSet::same_name("Tight", "tIGHT"));
let sets = [KinsokuSet { name: "Tight".into(), ..Default::default() }];
assert!(KinsokuSet::named(&sets, "TIGHT").is_some() && KinsokuSet::named(&sets, "Loose").is_none());
}
}
+43 -8
View File
@@ -1,4 +1,7 @@
use std::sync::Arc;
use super::char_style::CharStyle;
use super::kinsoku_set::KinsokuSet;
use super::tabs_lists::{ParaList, TabStop};
use super::{Deserialize, Serialize};
@@ -256,14 +259,18 @@ pub struct ParaStyle {
/// How leading is measured (Paragraph panel menu): from baseline to baseline, or from the top
/// of one line's ideographic em box to the next.
pub leading_model: LeadingModel,
/// Hanging punctuation (Paragraph panel menu › Burasagari): a comma or full stop ending a line
/// may stand outside the frame. New type takes [`Burasagari::Standard`]; documents from before
/// Hanging punctuation (Paragraph panel menu › Burasagari): the Kinsoku Set's hanging
/// punctuation ending a line may stand outside the frame. New type takes [`Burasagari::Standard`]; documents from before
/// it and imported text keep [`Burasagari::None`], except legacy `.ai` type with binding
/// punctuation on, which opens with [`Burasagari::Forced`].
pub burasagari: Burasagari,
/// Kinsoku (Paragraph panel › Kinsoku Set): which Japanese characters may not start or end a
/// line.
pub kinsoku: Kinsoku,
/// A custom Kinsoku Shori set (Type › Kinsoku Shori Settings…) chosen in Kinsoku Set: a copy of
/// the document's set of that name, which takes the place of [`Self::kinsoku`]. A paragraph
/// with one keeps [`Kinsoku::Hard`] in `kinsoku`, which builds without custom sets read.
pub kinsoku_set: Option<Arc<KinsokuSet>>,
/// Kinsoku Shori Type (Paragraph panel menu): how a line keeps those characters off its start
/// and end, by pushing them in onto the line or out to the next one. No effect without kinsoku.
pub kinsoku_type: KinsokuShoriType,
@@ -310,6 +317,21 @@ impl ParaStyle {
}
}
/// Does kinsoku apply: a custom set, or a Kinsoku Set other than None?
pub fn kinsoku_on(&self) -> bool {
self.kinsoku_set.is_some() || self.kinsoku != Kinsoku::None
}
/// The name Kinsoku Set shows: the custom set's, or None, Hard or Soft.
pub fn kinsoku_name(&self) -> &str {
match (&self.kinsoku_set, self.kinsoku) {
(Some(set), _) => &set.name,
(None, Kinsoku::None) => "None",
(None, Kinsoku::Hard) => "Hard",
(None, Kinsoku::Soft) => "Soft",
}
}
/// The left indent the layout sets the paragraph at: its left indent, and for a paragraph in a
/// list at a level past the first, [`ParaList::level_indent`] more.
pub fn laid_out_left_indent(&self) -> f64 {
@@ -373,6 +395,8 @@ struct ParaStyleFile {
burasagari: Burasagari,
#[serde(default, skip_serializing_if = "crate::skip::is_default")]
kinsoku: Kinsoku,
#[serde(default, skip_serializing_if = "Option::is_none")]
kinsoku_set: Option<Arc<KinsokuSet>>,
#[serde(default, skip_serializing_if = "crate::skip::is_default")]
kinsoku_type: KinsokuShoriType,
#[serde(default, skip_serializing_if = "crate::skip::is_default")]
@@ -415,6 +439,7 @@ impl From<ParaStyle> for ParaStyleFile {
leading_model,
burasagari,
kinsoku,
kinsoku_set,
kinsoku_type,
bunri_kinshi,
kurikaeshi_moji_shori,
@@ -443,6 +468,7 @@ impl From<ParaStyle> for ParaStyleFile {
leading_model,
burasagari,
kinsoku,
kinsoku_set,
kinsoku_type,
bunri_kinshi,
kurikaeshi_moji_shori,
@@ -475,6 +501,7 @@ impl From<ParaStyleFile> for ParaStyle {
leading_model,
burasagari,
kinsoku,
kinsoku_set,
kinsoku_type,
bunri_kinshi,
kurikaeshi_moji_shori,
@@ -483,6 +510,11 @@ impl From<ParaStyleFile> for ParaStyle {
korean_line_break_anywhere,
..
} = f;
// A set whose saved name can't name a custom set (None, Hard or Soft, say) is read as no set:
// the paragraph keeps its Kinsoku Set. A paragraph with a custom set keeps Hard, so one read
// with None or Soft (a paragraph style written before custom sets, applied over one) has no
// custom set.
let kinsoku_set = kinsoku_set.filter(|s| !s.name.is_empty() && kinsoku == Kinsoku::Hard);
Self {
justify,
left_indent,
@@ -502,6 +534,7 @@ impl From<ParaStyleFile> for ParaStyle {
leading_model,
burasagari,
kinsoku,
kinsoku_set,
kinsoku_type,
bunri_kinshi,
kurikaeshi_moji_shori,
@@ -604,19 +637,21 @@ pub enum KinsokuShoriType {
PushOutOnly,
}
/// Hanging punctuation (burasagari): an East Asian comma or full stop ending a line (、。,.、。)
/// stands outside the line's measure, in the space its punctuation spacing gives it (half width
/// with Line-end Punctuation Half Width). Closing brackets and Latin punctuation don't hang. Shown
/// as None / Regular / Force.
/// Hanging punctuation (burasagari): hanging punctuation ending a line stands outside the line's
/// measure, in the space its punctuation spacing gives it (half width with Line-end Punctuation
/// Half Width). With the built-in Kinsoku Sets that is an East Asian comma or full stop
/// (、。,.、。), and closing brackets and Latin punctuation don't hang; a custom Kinsoku Set hangs
/// the characters in its hanging category. Shown as None / Regular / Force.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Burasagari {
/// A comma or full stop that doesn't fit goes to the next line with the character before it.
#[default]
None,
/// A comma or full stop that doesn't fit hangs outside the line; one that fits stays inside.
/// Hanging punctuation that doesn't fit hangs outside the line; punctuation that fits stays
/// inside.
Standard,
/// A comma or full stop ending a line always hangs, and the rest of the line fills the measure.
/// Hanging punctuation ending a line always hangs, and the rest of the line fills the measure.
Forced,
}
+54 -6
View File
@@ -20,11 +20,18 @@ pub enum TraceView {
OutlinesWithSource,
/// Only the source image.
Source,
/// The source image on the part of the image left of a divider across it, and the traced
/// shapes everywhere else ([`TraceView::split_of`]).
Split,
}
/// Where the Split view's divider is when the `trace` settings name no valid position: across the
/// middle of the source image.
pub const DEFAULT_TRACE_SPLIT: f64 = 0.5;
impl TraceView {
/// Panel order.
pub const ALL: [Self; 5] = [Self::Result, Self::ResultWithOutlines, Self::Outlines, Self::OutlinesWithSource, Self::Source];
pub const ALL: [Self; 6] = [Self::Result, Self::ResultWithOutlines, Self::Outlines, Self::OutlinesWithSource, Self::Source, Self::Split];
/// The id used in command params and in the saved `trace` object.
pub fn id(self) -> &'static str {
@@ -34,6 +41,7 @@ impl TraceView {
Self::Outlines => "outlines",
Self::OutlinesWithSource => "outlinesWithSourceImage",
Self::Source => "sourceImage",
Self::Split => "split",
}
}
@@ -48,14 +56,21 @@ impl TraceView {
trace.get("view").and_then(serde_json::Value::as_str).and_then(Self::from_id).unwrap_or_default()
}
/// Whether the source image shows.
pub fn shows_source(self) -> bool {
matches!(self, Self::OutlinesWithSource | Self::Source)
/// The Split view's divider in `trace` settings: the fraction of the source image's width, from
/// its left edge in its own pixels, that shows the source image ([`DEFAULT_TRACE_SPLIT`] when
/// `split` is missing, not a number or outside 0 to 1).
pub fn split_of(trace: &serde_json::Value) -> f64 {
trace.get("split").and_then(serde_json::Value::as_f64).filter(|f| (0.0..=1.0).contains(f)).unwrap_or(DEFAULT_TRACE_SPLIT)
}
/// Whether the traced shapes show filled.
/// Whether the source image shows (in the Split view, on one side of the divider).
pub fn shows_source(self) -> bool {
matches!(self, Self::OutlinesWithSource | Self::Source | Self::Split)
}
/// Whether the traced shapes show filled (in the Split view, on one side of the divider).
pub fn shows_result(self) -> bool {
matches!(self, Self::Result | Self::ResultWithOutlines)
matches!(self, Self::Result | Self::ResultWithOutlines | Self::Split)
}
/// Whether the traced shapes' outlines show.
@@ -69,6 +84,12 @@ impl Node {
pub fn trace_view(&self) -> TraceView {
self.extras().trace.as_deref().map(TraceView::of).unwrap_or_default()
}
/// The Split view's divider of an Image Trace object ([`TraceView::split_of`];
/// [`DEFAULT_TRACE_SPLIT`] for anything else).
pub fn trace_split(&self) -> f64 {
self.extras().trace.as_deref().map_or(DEFAULT_TRACE_SPLIT, TraceView::split_of)
}
}
#[cfg(test)]
@@ -89,6 +110,26 @@ mod tests {
g.extras_mut().trace = Some(Box::new(serde_json::json!({"view": "sepia"})));
assert_eq!(g.trace_view(), TraceView::Result);
}
#[test]
fn the_split_divider_reads_a_fraction_and_falls_back_to_the_middle() {
let mut g = Node::group(crate::NodeId(1), vec![]);
assert_eq!(g.trace_split(), DEFAULT_TRACE_SPLIT);
assert_eq!(TraceView::from_id("Split"), Some(TraceView::Split));
assert!(TraceView::Split.shows_source() && TraceView::Split.shows_result() && !TraceView::Split.shows_outlines());
for (split, want) in [
(serde_json::json!(0.25), 0.25),
(serde_json::json!(0), 0.0),
(serde_json::json!(1), 1.0),
(serde_json::json!(-0.1), DEFAULT_TRACE_SPLIT),
(serde_json::json!(1.5), DEFAULT_TRACE_SPLIT),
(serde_json::json!("0.3"), DEFAULT_TRACE_SPLIT),
(serde_json::Value::Null, DEFAULT_TRACE_SPLIT),
] {
g.extras_mut().trace = Some(Box::new(serde_json::json!({"view": "split", "split": split})));
assert_eq!(g.trace_split(), want, "{split}");
}
}
#[test]
fn live_trace_result_bounds_exclude_the_retained_bitmap_at_any_angle() {
use crate::{Appearance, Document, ImageObject, NodeId, NodeKind};
@@ -132,6 +173,13 @@ mod tests {
}
}
}
// The Split view measures the whole image wherever the divider is, so the selection box
// stays put while the divider moves.
for split in [0.0, 0.01, 1.0] {
let want = Rect::new(0.0, 0.0, 200.0, 200.0);
group.extras_mut().trace = Some(Box::new(serde_json::json!({"view": "split", "split": split})));
assert_eq!((group.geometric_bounds(), group.visual_bounds()), (Some(want), Some(want)), "split {split}");
}
group.extras_mut().trace = None;
assert_eq!(
group.geometric_bounds(),
+15
View File
@@ -81,6 +81,21 @@ impl Unit {
Unit::Ha => "H",
}
}
/// Whether this unit is a physical measurement unit (not points or pixels).
pub fn is_physical(self) -> bool {
self.svg_suffix().is_some() || matches!(self, Unit::FeetInches | Unit::Meters | Unit::Yards | Unit::Feet | Unit::Q | Unit::Ha)
}
/// The standard SVG length unit suffix, if this unit is a physical unit supported in SVG
/// (`mm`, `cm`, `in`, `pc`).
pub fn svg_suffix(self) -> Option<&'static str> {
match self {
Unit::Millimeters => Some("mm"),
Unit::Centimeters => Some("cm"),
Unit::Inches => Some("in"),
Unit::Picas => Some("pc"),
_ => None,
}
}
pub const fn label(self) -> &'static str {
match self {
Unit::Points => "Points",
+4 -4
View File
@@ -210,15 +210,15 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
CLASSIC_EXTRUDE,
"Extrude & Bevel (Classic)…",
&["Effect", "3D and Materials", "3D (Classic)"],
"{depth: pt (0..2000, 50), cap: bool (true: solid; false: hollow), bevel: none|classic|rounded|cove|step|ogee (none), bevelHeight: pt (1..100, 4; the bevel is as wide as it is tall), bevelInside: bool (false: added around the shape; true: carved into it), rotationX: degrees (-180..180, -21.88), rotationY: degrees (-180..180, -23.4), rotationZ: degrees (-180..180, 9.06; the defaults are the Off-Axis Front position), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), surface: wireframe|none|diffuse|plastic (plastic; wireframe draws the edges of every face, hidden ones included, and fills none; none keeps the paint unlit; diffuse lights the faces softly; plastic adds a glossy highlight), lights: null or array of 1..10 objects (intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, behind: bool; overrides the single-light fields; the lights add up; color and softness are not used), lightRotation: degrees (-180..180, 125.26; round the object on the page, 0 on its right, counterclockwise), lightHeight: degrees (0..90, 30; 0 beside the object, 90 straight in front), lightBehind: bool (false; true lights it from behind), lightIntensity: % (0..100, 100), ambient: % (0..100, 50; Ambient Light, every face whichever way it faces), highlightIntensity: % (0..100, 60; plastic only), highlightSize: % (0..100, 90; 100 broad, 0 a small spot; plastic only), blendSteps: integer (1..256, 25; how many levels the shading and the highlight are rounded to), shadingColor: black|custom|none|blackOverprint (black; the color the faces darken toward; none keeps the paint and adds only the highlight; blackOverprint keeps the paint and draws the shading over it as overprinting black, on the black plate, with no highlight), shadingCustom: #rrggbb (#000000; the color shadingColor custom darkens toward), preserveSpotColors: bool (false; a color linked to a spot or global swatch stays a tint of that swatch, lighter where the highlight is, with black multiplied and overprinting where the faces darken, so a spot color keeps its plate; it does nothing while shadingColor is custom, and with blackOverprint every face keeps its paint and swatch link whether it is on or off), drawHiddenFaces: bool (false; also draws the faces turned away, behind the others)}. The front face is the art, extruded backwards about the center of its bounds; a solid is built for the top fill and for each stroke, each in its own paint. The defaults are VectorCraft's own.",
json!({"depth":50.0,"cap":true,"bevel":"none","bevelHeight":4.0,"bevelInside":false,"rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"surface":"plastic","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":100.0,"ambient":50.0,"highlightIntensity":60.0,"highlightSize":90.0,"blendSteps":25,"shadingColor":"black","shadingCustom":"#000000","preserveSpotColors":false,"drawHiddenFaces":false}),
"{depth: pt (0..2000, 50), cap: bool (true: solid; false: hollow), bevel: none|classic|rounded|cove|step|ogee (none), bevelHeight: pt (1..100, 4; the bevel is as wide as it is tall), bevelInside: bool (false: added around the shape; true: carved into it), rotationX: degrees (-180..180, -21.88), rotationY: degrees (-180..180, -23.4), rotationZ: degrees (-180..180, 9.06; the defaults are the Off-Axis Front position), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), surface: wireframe|none|diffuse|plastic (plastic; wireframe draws the edges of every face, hidden ones included, and fills none; none keeps the paint unlit; diffuse lights the faces softly; plastic adds a glossy highlight), lights: null or array of 1..10 objects (intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, behind: bool; overrides the single-light fields; the lights add up; color and softness are not used), lightRotation: degrees (-180..180, 125.26; round the object on the page, 0 on its right, counterclockwise), lightHeight: degrees (0..90, 30; 0 beside the object, 90 straight in front), lightBehind: bool (false; true lights it from behind), lightIntensity: % (0..100, 100), ambient: % (0..100, 50; Ambient Light, every face whichever way it faces), highlightIntensity: % (0..100, 60; plastic only), highlightSize: % (0..100, 90; 100 broad, 0 a small spot; plastic only), blendSteps: integer (1..256, 25; how many levels the shading and the highlight are rounded to), shadingColor: black|custom|none|blackOverprint (black; the color the faces darken toward; none keeps the paint and adds only the highlight; blackOverprint keeps the paint and draws the shading over it as overprinting black, on the black plate, with no highlight), shadingCustom: #rrggbb (#000000; the color shadingColor custom darkens toward), preserveSpotColors: bool (false; a color linked to a spot or global swatch stays a tint of that swatch, lighter where the highlight is, with black multiplied and overprinting where the faces darken, so a spot color keeps its plate; it does nothing while shadingColor is custom, and with blackOverprint every face keeps its paint and swatch link whether it is on or off), drawHiddenFaces: bool (false; also draws the faces turned away, behind the others), mapArt: array of 0..64 objects ([]; Map Art, see threeD.mapArt: surface: integer (1..100000; the numbered surface, one map for a surface), symbol: name of a document symbol, x: pt (-1000000..1000000, 0; the offset of the art's center from the center of the surface laid out flat), y: pt (-1000000..1000000, 0), scaleX: % (1..10000, 100; of the symbol's own width), scaleY: % (1..10000, 100), rotation: degrees (-360..360, 0; counterclockwise); the surfaces are numbered through the object's solids in the order they are built: each solid's front cap and back cap (none on a hollow solid, cap false), then each side wall from corner to corner of the outline, then the bevel above each wall; a map past the object's surfaces draws nothing; wireframe draws no mapped art), mapShade: bool (false; Shade Artwork: the mapped art takes the tone and highlight of its face), mapInvisible: bool (false; Invisible Geometry: with at least one map, only the mapped art is drawn)}. The front face is the art, extruded backwards about the center of its bounds; a solid is built for the top fill and for each stroke, each in its own paint. The defaults, the surface numbering and the limits are VectorCraft's own.",
json!({"depth":50.0,"cap":true,"bevel":"none","bevelHeight":4.0,"bevelInside":false,"rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"surface":"plastic","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":100.0,"ambient":50.0,"highlightIntensity":60.0,"highlightSize":90.0,"blendSteps":25,"shadingColor":"black","shadingCustom":"#000000","preserveSpotColors":false,"drawHiddenFaces":false,"mapArt":[],"mapShade":false,"mapInvisible":false}),
),
g(
CLASSIC_REVOLVE,
"Revolve (Classic)…",
&["Effect", "3D and Materials", "3D (Classic)"],
"{angle: degrees (0..360, 360; how far the profile sweeps round the axis), cap: bool (true: solid, the open ends and a partial sweep's cut sides closed; false: hollow), offset: pt (0..1000, 0; the axis's distance from the profile, a ring past 0), edge: left|right (left; the axis is at the left or the right edge of the profile's bounds), rotationX: degrees (-180..180, -21.88), rotationY: degrees (-180..180, -23.4), rotationZ: degrees (-180..180, 9.06; the defaults are the Off-Axis Front position), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), surface: wireframe|none|diffuse|plastic (plastic; wireframe draws the edges of every face and fills none; none keeps the paint unlit; diffuse lights the faces softly; plastic adds a glossy highlight), lights: null or array of 1..10 objects (intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, behind: bool; overrides the single-light fields; the lights add up; color and softness are not used), lightRotation: degrees (-180..180, 125.26; round the object on the page, 0 on its right, counterclockwise), lightHeight: degrees (0..90, 30; 0 beside the object, 90 straight in front), lightBehind: bool (false; true lights it from behind), lightIntensity: % (0..100, 100), ambient: % (0..100, 50; Ambient Light, every face whichever way it faces), highlightIntensity: % (0..100, 60; plastic only), highlightSize: % (0..100, 90; 100 broad, 0 a small spot; plastic only), blendSteps: integer (1..256, 25; how many levels the shading and the highlight are rounded to), shadingColor: black|custom|none|blackOverprint (black; the color the faces darken toward; none keeps the paint and adds only the highlight; blackOverprint keeps the paint and draws the shading over it as overprinting black, on the black plate, with no highlight), shadingCustom: #rrggbb (#000000; the color shadingColor custom darkens toward), preserveSpotColors: bool (false; a color linked to a spot or global swatch stays a tint of that swatch, lighter where the highlight is, with black multiplied and overprinting where the faces darken, so a spot color keeps its plate; it does nothing while shadingColor is custom, and with blackOverprint every face keeps its paint and swatch link whether it is on or off)}. The profile sweeps round a vertical axis, as Revolve's does, painted with the top fill (else the top stroke); every face is drawn, back to front. The defaults are VectorCraft's own.",
json!({"angle":360.0,"cap":true,"offset":0.0,"edge":"left","rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"surface":"plastic","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":100.0,"ambient":50.0,"highlightIntensity":60.0,"highlightSize":90.0,"blendSteps":25,"shadingColor":"black","shadingCustom":"#000000","preserveSpotColors":false}),
"{angle: degrees (0..360, 360; how far the profile sweeps round the axis), cap: bool (true: solid, the open ends and a partial sweep's cut sides closed; false: hollow), offset: pt (0..1000, 0; the axis's distance from the profile, a ring past 0), edge: left|right (left; the axis is at the left or the right edge of the profile's bounds), rotationX: degrees (-180..180, -21.88), rotationY: degrees (-180..180, -23.4), rotationZ: degrees (-180..180, 9.06; the defaults are the Off-Axis Front position), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), surface: wireframe|none|diffuse|plastic (plastic; wireframe draws the edges of every face and fills none; none keeps the paint unlit; diffuse lights the faces softly; plastic adds a glossy highlight), lights: null or array of 1..10 objects (intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, behind: bool; overrides the single-light fields; the lights add up; color and softness are not used), lightRotation: degrees (-180..180, 125.26; round the object on the page, 0 on its right, counterclockwise), lightHeight: degrees (0..90, 30; 0 beside the object, 90 straight in front), lightBehind: bool (false; true lights it from behind), lightIntensity: % (0..100, 100), ambient: % (0..100, 50; Ambient Light, every face whichever way it faces), highlightIntensity: % (0..100, 60; plastic only), highlightSize: % (0..100, 90; 100 broad, 0 a small spot; plastic only), blendSteps: integer (1..256, 25; how many levels the shading and the highlight are rounded to), shadingColor: black|custom|none|blackOverprint (black; the color the faces darken toward; none keeps the paint and adds only the highlight; blackOverprint keeps the paint and draws the shading over it as overprinting black, on the black plate, with no highlight), shadingCustom: #rrggbb (#000000; the color shadingColor custom darkens toward), preserveSpotColors: bool (false; a color linked to a spot or global swatch stays a tint of that swatch, lighter where the highlight is, with black multiplied and overprinting where the faces darken, so a spot color keeps its plate; it does nothing while shadingColor is custom, and with blackOverprint every face keeps its paint and swatch link whether it is on or off), mapArt: array of 0..64 objects ([]; Map Art, see threeD.mapArt: surface: integer (the swept side is surface 1, the only one; in a group, the side of the member with the longest profile; a map of another surface draws nothing), symbol: name of a document symbol, x: pt (-1000000..1000000, 0; the offset of the art's center from the middle of the side unrolled flat, around the axis), y: pt (-1000000..1000000, 0; along the profile), scaleX: % (1..10000, 100; of the symbol's own width), scaleY: % (1..10000, 100), rotation: degrees (-360..360, 0; counterclockwise); the art wraps around the side and is drawn where its outside faces the viewer; wireframe draws no mapped art), mapShade: bool (false; Shade Artwork: the mapped art takes the tone and highlight of its face), mapInvisible: bool (false; Invisible Geometry: with at least one map, only the mapped art is drawn)}. The profile sweeps round a vertical axis, as Revolve's does, painted with the top fill (else the top stroke); every face is drawn, back to front. The defaults, the surface numbering and the limits are VectorCraft's own.",
json!({"angle":360.0,"cap":true,"offset":0.0,"edge":"left","rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"surface":"plastic","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":100.0,"ambient":50.0,"highlightIntensity":60.0,"highlightSize":90.0,"blendSteps":25,"shadingColor":"black","shadingCustom":"#000000","preserveSpotColors":false,"mapArt":[],"mapShade":false,"mapInvisible":false}),
),
g(
CLASSIC_ROTATE,
+4
View File
@@ -108,6 +108,10 @@ pub use solids::{
GRAPHIC_MAX_OFFSET, GRAPHIC_SCALE_RANGE, GRAPHICS_NOT_TAKEN, appearance_graphic_symbols, exports_three_d, graphic_fitting_scale,
graphic_frame_at, graphic_side_size, graphics_reshaped_after, rename_appearance_graphic_symbol,
};
pub use solids::{
MAP_ART, MAP_ART_NOT_TAKEN, MAP_INVISIBLE, MAP_SHADE, MAX_MAP_SURFACE, MAX_MAPS, MapSurface, SurfaceKind, SurfaceMap, map_surfaces_at,
map_surfaces_with, surface_maps, takes_map_art, with_surface_map,
};
pub use stylize::{ScribbleSetting, scribble_setting_id, scribble_settings};
pub use svg_filter::SVG_FILTER;
pub use trap::TRAP;
+149 -32
View File
@@ -113,7 +113,7 @@ pub fn revolve_options(p: &Value) -> Revolve {
/// The options Revolve (`id` [`REVOLVE`]) or Revolve (Classic) ([`CLASSIC_REVOLVE`]) with
/// parameters `p` sweeps its surface with. A Revolve with graphics lays out its side for them.
fn options_of(id: &str, p: &Value) -> Revolve {
pub(crate) fn options_of(id: &str, p: &Value) -> Revolve {
if id == CLASSIC_REVOLVE {
classic::options(p)
} else {
@@ -141,6 +141,7 @@ pub fn validate_revolve_in(doc: Option<&Document>, n: &Node, p: &Value) -> Resul
/// [`validate_revolve_in`] for Revolve or Revolve (Classic), `id`.
pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) -> Result<(), String> {
validate_params_of(id, p)?;
validate_map_symbols(doc, id, p)?;
let n = &*resolve_for(doc, n, "Revolve", false)?;
let effects = &n.appearance.effects;
// The profile is measured before the object's one Revolve, hidden or shown.
@@ -215,7 +216,7 @@ fn check_graphics(doc: Option<&Document>, id: &str, path: &PathData, b: Rect, op
/// The member of a group whose side takes the group's graphics: the first with the longest
/// profile among those with a fill or stroke.
fn graphics_member(shapes: &[Profile], b: Rect, options: Revolve) -> Option<usize> {
pub(crate) fn graphics_member(shapes: &[Profile], b: Rect, options: Revolve) -> Option<usize> {
shapes
.iter()
.enumerate()
@@ -237,6 +238,20 @@ fn check_shadow<'a>(p: &Value, paths: impl IntoIterator<Item = &'a PathData>, b:
/// [`validate_revolve`] for a Revolve with parameters `p` at index `index` of the effects of
/// appearance item `target` of `n` ([`validate_item_of`]).
/// An error when the symbols that Revolve (Classic)'s Map Art in `p` places, with the symbols of
/// `doc`, are past the limits of a graphic's art, as on Extrude & Bevel (Classic), or past the
/// limits of art unrolled onto its side, its only surface.
fn validate_map_symbols(doc: Option<&Document>, id: &str, p: &Value) -> Result<(), String> {
match doc.filter(|_| id == CLASSIC_REVOLVE) {
Some(doc) => {
crate::solids::graphics::validate_symbols(doc, p)?;
// The side is surface 1, laid out about the origin; a map past it draws nothing.
crate::solids::graphics::validate_unrolled_symbols(doc, p, &|surface| (surface == 1).then_some(Point::ZERO))
}
None => Ok(()),
}
}
#[cfg(test)]
pub(crate) fn validate_item_revolve(n: &Node, p: &Value, target: usize, index: usize) -> Result<(), String> {
validate_item_of(None, n, REVOLVE, p, target, index)
@@ -252,6 +267,7 @@ pub(crate) fn validate_item_of(doc: Option<&Document>, n: &Node, id: &str, p: &V
return validate_in(doc, n, id, p);
}
validate_params_of(id, p)?;
validate_map_symbols(doc, id, p)?;
const EMPTY: &str = "Revolve requires a shape with at least two anchors";
let (path, _) = object_profile(n, "Revolve")?;
if !has_two_anchors(&path) {
@@ -334,7 +350,7 @@ fn check_surface(path: &PathData, b: Rect, options: Revolve, item: Option<&Appea
/// `options` with one number of samples for every curve of `shapes`, the members of one group: the
/// members share Revolve's limits.
fn shared_options(shapes: &[Profile], options: Revolve) -> Result<Revolve, String> {
pub(crate) fn shared_options(shapes: &[Profile], options: Revolve) -> Result<Revolve, String> {
let samples = vectorcraft_three_d::revolve_curve_samples(shapes.iter().map(|s| &s.path), options)?;
Ok(Revolve { curve_samples: Some(samples), ..options })
}
@@ -463,10 +479,12 @@ fn group_shadow(
/// with its classic surface, as Extrude & Bevel (Classic) does. Revolve's graphics, with the
/// symbols of `doc`, are drawn on the faces of the side ([`crate::solids::graphics::surface_parts`]):
/// a face with a part of a graphic is a group of the face and that part. With `cast`, the sweep
/// that draws the surface also keeps the faces its shadow is cast from ([`SolidFaces`]). The last
/// value is whether the faces go over an underlay of themselves ([`seals`]): the caller seals them
/// ([`sealed_surface`], [`sealed_runs`]) in the order it draws them.
#[allow(clippy::too_many_arguments)]
/// that draws the surface also keeps the faces its shadow is cast from ([`SolidFaces`]). With
/// `hide`, a Revolve (Classic) surface without mapped art leaves its faces out, as Invisible
/// Geometry does ([`crate::solids::classic::surface`]). The last two values are whether the faces
/// go over an underlay of themselves ([`seals`]): the caller seals them ([`sealed_surface`],
/// [`sealed_runs`]) in the order it draws them; and whether the faces were left out.
#[allow(clippy::too_many_arguments, clippy::type_complexity)]
fn surface(
doc: Option<&Document>,
n: &Node,
@@ -480,7 +498,8 @@ fn surface(
expand: bool,
copies: &mut Copies,
cast: bool,
) -> Option<(Vec<Drawn>, Node, Option<SolidFaces>, bool)> {
hide: bool,
) -> Option<(Vec<Drawn>, Node, Option<SolidFaces>, bool, bool)> {
#[cfg(test)]
crate::solids::SOLIDS_BUILT.with(|n| n.set(n.get() + 1));
// A loaded file or a profile edited past the limits keeps drawing its source path instead
@@ -500,7 +519,23 @@ fn surface(
let drawn =
facets.iter().map(|f| Drawn { depth: f.depth, points: f.contours.first().cloned().unwrap_or_default(), plane: f.plane }).collect();
let p = merged_params(&fx.id, &fx.params);
return Some((drawn, crate::solids::classic::surface(n, facets, &paint, opacity, blend, &p), kept, false));
// Mapped art goes on the side, the surface's one numbered surface. Its paints' copies
// count with the graphics', and art past the limits is left out.
let map_art = crate::solids::graphics::map_art::MapArt::of(doc, &fx.id, &p);
let layout = map_art.as_ref().and_then(|_| {
let (width, height) = vectorcraft_three_d::revolve_surface_size(path, b, options)?;
let side = vectorcraft_three_d::SolidSurface { kind: vectorcraft_three_d::SurfaceKind::Side, width, height, center: None };
Some(crate::solids::graphics::map_art::SolidLayout { first: 0, surfaces: vec![side], ends: None })
});
let mut budget = crate::solids::graphics::map_art::MapBudget::default();
let mapped = map_art.as_ref().zip(layout.as_ref()).map(|(art, layout)| crate::solids::classic::Mapped {
art,
layout,
budget: &mut budget,
copies: &mut copies.graphics,
});
let (art, hidden, _) = crate::solids::classic::surface(n, &facets, &paint, (opacity, blend), &p, mapped, hide);
return Some((drawn, art, kept, false, hidden));
}
let colored = colored(&options);
let (faces, kept) = if cast {
@@ -632,7 +667,7 @@ fn surface(
let mut group = Node::group(n.id, children);
group.opacity = opacity;
group.blend = blend;
Some((keys, group, kept, seal))
Some((keys, group, kept, seal, false))
}
/// Plain `surface` ([`surface`]: a group of its faces) over an underlay of its faces when `seal`
@@ -722,8 +757,8 @@ fn object_surface(
let b = path.bounds()?;
let (paint, opacity, blend) = paint_of(item);
let cast = casts(fx, opacity);
surface(doc, n, path, b, rule_options(fx, rule), fx, paint, opacity, blend, expand, copies, cast)
.map(|(_, art, kept, seal)| (sealed_surface(n.id, art, seal), kept))
surface(doc, n, path, b, rule_options(fx, rule), fx, paint, opacity, blend, expand, copies, cast, false)
.map(|(_, art, kept, seal, _)| (sealed_surface(n.id, art, seal), kept))
}
/// The options effect `fx` sweeps the surface of a profile filled with `rule` with: its cut sides
@@ -797,11 +832,12 @@ pub(crate) fn revolve_meshes(n: &Node, total: &mut usize, limit: usize) -> Resul
}
let (path, rule) = object_profile(n, "Revolve")?;
let ctx = GeomContext::of(n);
let mesh = |path: &PathData, fx: &Effect, item: &AppearanceItem| -> Result<crate::SolidMesh, String> {
let mut keep = |out: &mut Vec<crate::SolidMesh>, path: &PathData, fx: &Effect, item: &AppearanceItem| -> Result<(), String> {
let b = path.bounds().ok_or("Revolve requires a shape with at least two anchors")?;
let (paint, opacity, _) = paint_of(item);
let mesh = vectorcraft_three_d::revolve_mesh(path, rule, b, fx_options(fx))?;
Ok(crate::SolidMesh::plain(mesh, crate::solids::mesh_color(&paint, opacity)))
surface_meshes(path, rule, b, fx, fx_options(fx), (&paint, opacity, 1.0), true)?
.into_iter()
.try_for_each(|m| crate::solids::keep_mesh(out, total, m, limit))
};
if let Some(index) = n.appearance.effects.iter().position(|e| e.visible && is_revolve(&e.id)) {
let before = n.appearance.effects.get(..index).unwrap_or_default();
@@ -810,7 +846,7 @@ pub(crate) fn revolve_meshes(n: &Node, total: &mut usize, limit: usize) -> Resul
let paints = solid_paints(n);
let item = surface_item(&paints).ok_or("the revolved object has no fill or stroke")?;
let mut out = vec![];
crate::solids::keep_mesh(&mut out, total, mesh(&path, fx, item)?, limit)?;
keep(&mut out, &path, fx, item)?;
return Ok(out);
}
let path = geometry(&path, &n.appearance.effects, &ctx);
@@ -820,12 +856,69 @@ pub(crate) fn revolve_meshes(n: &Node, total: &mut usize, limit: usize) -> Resul
&& let Some(fx) = item.effects().get(index)
{
let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(item));
crate::solids::keep_mesh(&mut out, total, mesh(&p, fx, item)?, limit)?;
keep(&mut out, &p, fx, item)?;
}
}
Ok(out)
}
/// The surface Revolve `fx` sweeps from `path` (filled under `rule`) about the axis of `b` with
/// `options`, painted `paint` at `opacity` in a group member of opacity `member` (1 for an object
/// of its own), as meshes. When `graphics` and `fx` maps graphics onto the side, the side's
/// triangles are a mesh of their own with the point of the unrolled side surface each corner shows
/// ([`crate::MeshGraphics`]), the points the canvas places the graphics by
/// ([`crate::solids::graphics::surface_parts`]), after a mesh of the rest (the end caps and the cut
/// sides). As on the canvas, the graphics take `opacity`, and `member` applies to the side and its
/// graphics together. Otherwise the surface is one plain mesh.
fn surface_meshes(
path: &PathData,
rule: FillRule,
b: Rect,
fx: &Effect,
options: Revolve,
(paint, opacity, member): (&Paint, f32, f32),
graphics: bool,
) -> Result<Vec<crate::SolidMesh>, String> {
let color = crate::solids::mesh_color(paint, opacity * member);
let list: Vec<crate::MappedGraphic> = if graphics && fx.id == REVOLVE && options.map_surface {
crate::solids::mapped_graphics(&merged_params(&fx.id, &fx.params)).into_iter().filter(|g| g.face == crate::PlanarFace::Front).collect()
} else {
vec![]
};
if list.is_empty() {
return Ok(vec![crate::SolidMesh::plain(vectorcraft_three_d::revolve_mesh(path, rule, b, options)?, color)]);
}
let (mesh, on) = vectorcraft_three_d::revolve_mesh_surface(path, rule, b, options)?;
let (mut side, mut rest, mut art) = (vectorcraft_three_d::Mesh::default(), vectorcraft_three_d::Mesh::default(), vec![]);
for (t, points) in mesh.triangles.iter().zip(&on) {
let corner = |i: u32| mesh.positions.get(i as usize).copied().zip(mesh.normals.get(i as usize).copied());
let Some(corners) = t.iter().map(|&i| corner(i)).collect::<Option<Vec<_>>>() else { continue };
let into = match points {
Some(points) => {
art.extend(points);
&mut side
}
None => &mut rest,
};
let base = into.positions.len() as u32;
for (p, n) in corners {
into.positions.push(p);
into.normals.push(n);
}
into.triangles.push([base, base + 1, base + 2]);
}
let mut out = vec![];
if !rest.is_empty() {
out.push(crate::SolidMesh::plain(rest, color));
}
if !side.is_empty() {
let graphics =
crate::MeshGraphics { face: crate::PlanarFace::Front, graphics: list, center: Point::ZERO, art, opacity, object: member.clamp(0.0, 1.0) };
out.push(crate::SolidMesh { mesh: side, color, graphics: Some(graphics) });
}
Ok(out)
}
/// The outline of every face [`revolve_art`] draws for `n`'s Revolve or Revolve (Classic) (its symbol
/// instances, blends and clipping groups already resolved), in document coordinates: with the
/// effect on the object, the surface in its top visible fill (else its stroke); with it on fills and strokes, one surface for each of
@@ -919,12 +1012,15 @@ fn group_meshes(n: &Node, total: &mut usize, limit: usize) -> Result<Vec<crate::
reshape_members(n, n.appearance.effects.get(..index).unwrap_or_default(), &mut shapes);
let b = union_bounds(&shapes).ok_or("Revolve requires a group holding a shape with at least two anchors")?;
let options = shared_options(&shapes, fx_options(fx))?;
// The graphics go on the side of the member with the longest profile, as the canvas draws them.
let longest = if options.map_surface { graphics_member(&shapes, b, options) } else { None };
let mut out = vec![];
for s in &shapes {
for (k, s) in shapes.iter().enumerate() {
let Some(item) = surface_item(&s.items) else { continue };
let (paint, opacity, _) = paint_of(item);
let mesh = vectorcraft_three_d::revolve_mesh(&s.path, s.rule, b, options)?;
crate::solids::keep_mesh(&mut out, total, crate::SolidMesh::plain(mesh, crate::solids::mesh_color(&paint, opacity * s.opacity)), limit)?;
for mesh in surface_meshes(&s.path, s.rule, b, fx, options, (&paint, opacity, s.opacity), longest == Some(k))? {
crate::solids::keep_mesh(&mut out, total, mesh, limit)?;
}
}
Ok(out)
}
@@ -1155,22 +1251,42 @@ fn group_art(doc: Option<&Document>, n: &Node, expand: bool) -> Option<Node> {
let mut opaque = true;
// The graphics go once, on the side of the member with the longest profile. Without graphics
// no member is measured for them.
let mapped = fx.id == REVOLVE && !crate::solids::mapped_graphics(&merged_params(&fx.id, &fx.params)).is_empty();
// Revolve (Classic)'s mapped art goes on that member's side too.
let p = merged_params(&fx.id, &fx.params);
let mapped = (fx.id == REVOLVE && !crate::solids::mapped_graphics(&p).is_empty())
|| (fx.id == CLASSIC_REVOLVE && !crate::solids::surface_maps(&p).is_empty());
let longest = if mapped { graphics_member(&shapes, b, options) } else { None };
for (k, s) in shapes.iter().enumerate() {
let Some(item) = surface_item(&s.items) else {
kept.push(None);
continue;
};
// Member `k`'s surface, its faces left out with `hide`, with its opacity and blending mode;
// `None` for a member with no fill or stroke.
let member = |k: usize, s: &Profile, hide: bool, copies: &mut Copies| {
let item = surface_item(&s.items)?;
// The opacity and blending of the member and the groups it is in apply through its scopes.
let (paint, opacity, blend) = paint_of(item);
opaque &= opacity >= 1.0 && blend == Default::default() && s.scopes.is_empty();
// A member with transparency of its own keeps every face, as a transparent object does.
let expand = expand && s.scopes.is_empty();
let doc = doc.filter(|_| longest == Some(k));
let cast = casts(fx, opacity * s.opacity);
let options = Revolve { fill_rule: s.rule, ..options };
let (depths, art, faces, seal) = surface(doc, n, &s.path, b, options, fx, paint, opacity, blend, expand, &mut copies, cast)?;
Some((opacity, blend, surface(doc, n, &s.path, b, options, fx, paint, opacity, blend, expand, copies, cast, hide)))
};
// With Invisible Geometry the other members leave their faces out too, once the mapped art on
// the longest member's side has left that member's faces out, so it is built first.
let invisible = fx.id == CLASSIC_REVOLVE && doc.is_some() && p.get(crate::solids::MAP_INVISIBLE).and_then(Value::as_bool).unwrap_or(false);
let mut first = None;
if let Some(l) = longest.filter(|_| invisible)
&& let Some(s) = shapes.get(l)
{
first = member(l, s, false, &mut copies);
}
let hide = matches!(first, Some((_, _, Some((_, _, _, _, true)))));
for (k, s) in shapes.iter().enumerate() {
let built = if longest == Some(k) && first.is_some() { first.take() } else { member(k, s, hide, &mut copies) };
let Some((opacity, blend, built)) = built else {
kept.push(None);
continue;
};
opaque &= opacity >= 1.0 && blend == Default::default() && s.scopes.is_empty();
let (depths, art, faces, seal, _) = built?;
surfaces.push((depths, art, s.scopes.as_slice()));
kept.push(faces);
seals.push(seal);
@@ -1870,8 +1986,9 @@ mod tests {
let path = n.path_data().unwrap();
let fx = n.appearance.effects.first().unwrap();
let (paint, opacity, blend) = paint_of(n.appearance.items.first().unwrap());
let (_, art, _, seal) =
surface(None, n, path, path.bounds().unwrap(), fx_options(fx), fx, paint, opacity, blend, false, &mut Copies::default(), false).unwrap();
let (_, art, _, seal, _) =
surface(None, n, path, path.bounds().unwrap(), fx_options(fx), fx, paint, opacity, blend, false, &mut Copies::default(), false, false)
.unwrap();
(art, seal)
}
@@ -2129,7 +2246,7 @@ mod tests {
.map(|s| {
let (paint, opacity, blend) = paint_of(surface_item(&s.items).unwrap());
let cast = casts(&fx, opacity * s.opacity);
surface(None, &g, &s.path, b, options, &fx, paint, opacity, blend, false, &mut Copies::default(), cast).unwrap().2
surface(None, &g, &s.path, b, options, &fx, paint, opacity, blend, false, &mut Copies::default(), cast, false).unwrap().2
})
.collect();
assert!(kept.iter().all(Option::is_some), "{id} {params}");
@@ -2165,7 +2282,7 @@ mod tests {
.map(|s| {
let (paint, opacity, blend) = paint_of(surface_item(&s.items).unwrap());
let cast = casts(&fx, opacity * s.opacity);
surface(None, g, &s.path, b, options, &fx, paint, opacity, blend, false, &mut Copies::default(), cast).unwrap().2
surface(None, g, &s.path, b, options, &fx, paint, opacity, blend, false, &mut Copies::default(), cast, false).unwrap().2
})
.collect();
[group_shadow(g.id, &fx, &shapes, b, options, kept).unwrap(), group_shadow(g.id, &fx, &shapes, b, options, vec![]).unwrap()]
+16 -5
View File
@@ -4,6 +4,8 @@
use serde_json::Value;
use vectorcraft_three_d::Revolve;
use crate::solids::graphics::map_art;
pub const CLASSIC_REVOLVE: &str = "threeD.classicRevolve";
/// The numeric parameters: (key, lowest, highest, whole numbers only).
@@ -23,19 +25,28 @@ const RANGES: [(&str, f64, f64, bool); 13] = [
("blendSteps", 1.0, 256.0, true),
];
const FLAGS: [&str; 3] = ["cap", "lightBehind", "preserveSpotColors"];
const FLAGS: [&str; 5] = ["cap", "lightBehind", "preserveSpotColors", map_art::MAP_SHADE, map_art::MAP_INVISIBLE];
/// The surface Revolve (Classic)'s parameters `p` sweep: Revolve's angle, cap, offset, edge,
/// rotation and perspective, built unshaded, since the classic surfaces light its faces.
/// rotation and perspective, built unshaded, since the classic surfaces light its faces. With
/// mapped art its side is laid out for it.
pub(crate) fn options(p: &Value) -> Revolve {
Revolve { shade: false, smooth_shading: false, lights: None, light_color: [1.0; 3], ..super::revolve_options(p) }
Revolve {
shade: false,
smooth_shading: false,
lights: None,
light_color: [1.0; 3],
map_surface: !map_art::surface_maps(p).is_empty(),
..super::revolve_options(p)
}
}
/// Check Revolve (Classic)'s parameters `p` (its defaults filled in) beyond the checks it shares
/// with Revolve: every key is one of its parameters, numbers are in range, flags are true or false,
/// and the surface and shading color are named.
/// the surface and shading color are named, and `mapArt` holds valid maps.
pub(crate) fn validate(p: &Value) -> Result<(), String> {
crate::solids::classic::validate_classic(CLASSIC_REVOLVE, p, &RANGES, &FLAGS)
crate::solids::classic::validate_classic(CLASSIC_REVOLVE, p, &RANGES, &FLAGS)?;
map_art::validate(CLASSIC_REVOLVE, p)
}
#[cfg(test)]
+238 -29
View File
@@ -24,6 +24,10 @@ mod source;
pub(crate) use source::{resolve, resolve_for};
pub(crate) mod graphics;
pub use graphics::map_art::{
MAP_ART, MAP_ART_NOT_TAKEN, MAP_INVISIBLE, MAP_SHADE, MAX_MAP_SURFACE, MAX_MAPS, SurfaceMap, surface_maps, takes_map_art, with_surface_map,
};
use graphics::map_art::{MapArt, MapBudget, SolidLayout};
pub use graphics::{
GRAPHICS, GraphicFrame, MAX_GRAPHICS, MappedGraphic, MeshGraphics, graphic_symbols, mapped_graphics, mesh_graphics_art, missing_symbol,
names_graphic_symbol, rename_graphic_symbol, rename_graphic_symbol_in, takes_graphics, with_graphic,
@@ -32,6 +36,7 @@ pub use graphics::{
MAX_OFFSET as GRAPHIC_MAX_OFFSET, NOT_TAKEN as GRAPHICS_NOT_TAKEN, SCALE_RANGE as GRAPHIC_SCALE_RANGE, appearance_graphic_symbols,
fitting as graphic_fitting_scale, rename_appearance_graphic_symbol,
};
pub use vectorcraft_three_d::SurfaceKind;
pub(crate) mod shadow;
@@ -180,6 +185,7 @@ pub fn extrude_options(p: &Value) -> Extrude {
both_sides: flag(p, "bevelBothSides", false),
}),
hidden: false,
map_surfaces: false,
map_surface: false,
}
}
@@ -431,11 +437,22 @@ fn visible(item: &AppearanceItem, member: f32) -> bool {
/// ([`side_carrier`]): their art, or the parts they draw on its pieces
/// ([`graphics::surface_parts`]), or when the object `n`'s surfaces can't be built at all. They are
/// built as the art builds them ([`surfaces_with`]), so its pieces are the ones the art draws, cuts
/// included. Without `doc` nothing is drawn, and nothing is checked.
/// included. On Extrude & Bevel (Classic), the art Map Art places on walls and bevels must also fit
/// ([`graphics::validate_unrolled_symbols`]). Without `doc` nothing is drawn, and nothing is checked.
fn check_side_graphics(doc: Option<&Document>, n: &Node, id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
let Some(doc) = doc else { return Ok(()) };
let Some(b) = union_bounds(shapes) else { return Ok(()) };
let (parts, bounds) = solid_parts(shapes, b);
// Map Art unrolls its art onto walls and bevels; the caps draw it as it is.
if id == CLASSIC_EXTRUDE && !surface_maps(p).is_empty() {
let options = vectorcraft_three_d::Extrude { map_surfaces: true, ..classic_extrude_options(p) };
let unrolled: Vec<Option<Point>> = parts
.iter()
.flat_map(|(_, _, area, rule, _, _)| vectorcraft_three_d::extrude_surfaces(area, *rule, bounds, options).unwrap_or_default())
.map(|s| (!matches!(s.kind, SurfaceKind::End(_))).then(|| graphics::map_art::flat_center(&s)))
.collect();
graphics::validate_unrolled_symbols(doc, p, &|surface| surface.checked_sub(1).and_then(|k| unrolled.get(k).copied().flatten()))?;
}
if side_carrier(id, p, &parts, bounds).is_none() {
return Ok(());
}
@@ -1924,8 +1941,11 @@ fn surfaces_with(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profil
filled.push(Filled { at: out.len(), member, caps, opacity, blend, masked: masks_surface(&paint, colored) });
}
}
let art =
if classic { classic::surface(n, f, &paint, opacity, blend, &p) } else { surface(n, f, &paint, opacity, blend, colored, false) };
let art = if classic {
classic::surface(n, &f, &paint, (opacity, blend), &p, None, false).0
} else {
surface(n, f, &paint, opacity, blend, colored, false)
};
out.push((s.scopes.as_slice(), Arc::new(art)));
}
}
@@ -1939,15 +1959,28 @@ fn surfaces_with(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profil
let carrier = if graphics_on { side_carrier(&fx.id, &p, &parts, bounds) } else { None };
let mut solids = vec![];
let mut built = vec![];
// With mapped art, each solid's place among the object's numbered surfaces: the surfaces are
// counted through the parts in order, those of a part whose solid is left out too.
let map_art = MapArt::of(doc, &fx.id, &p).filter(|_| fx.id == CLASSIC_EXTRUDE);
let mut layouts: Vec<SolidLayout> = vec![];
let mut surfaces_before = 0usize;
let made = built_solids_cast(&fx.id, &p, &parts, bounds, MAX_OBJECT_FACES, cast, carrier);
for (k, ((item, opacity, _, _, scopes, member), f)) in parts.iter().zip(made).enumerate() {
for (k, ((item, opacity, area, rule, scopes, member), f)) in parts.iter().zip(made).enumerate() {
let item: &AppearanceItem = item;
let layout = map_art.as_ref().map(|_| {
let options = classic_extrude_options(&p);
let surfaces = vectorcraft_three_d::extrude_surfaces(area, *rule, bounds, options).unwrap_or_default();
let first = surfaces_before;
surfaces_before += surfaces.len();
SolidLayout { first, surfaces, ends: Some((bounds, options, view_options(&p))) }
});
match f {
Ok(Some((f, _))) if !crate::revolve::paint_copies_add(&mut paint_bytes, facet_copies(&f, paint_ref(item), colored), paint_ref(item)) => {
return None;
}
Ok(Some((f, faces))) => {
solids.push((item, *opacity, *scopes, f, *member));
layouts.extend(layout);
built.push(faces);
}
// A stroke's outline past the limits is left out; the fill's solid still draws, and
@@ -2035,6 +2068,34 @@ fn surfaces_with(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profil
let split =
split && solids.iter().filter(|(item, _, _, f, _)| composite(item, f)).map(|(.., f, _)| f.len()).sum::<usize>() <= MAX_FACE_COMPOSITES;
let members: Vec<usize> = solids.iter().map(|s| s.4).collect();
// The classic surfaces of the solids, with mapped art when the effect has maps. When the art of
// any solid is past the limits the object's maps share, every solid draws without mapped art.
let mut classic_arts = if classic {
let draw = |with_art: bool, copies: &mut usize| {
let mut budget = MapBudget::default();
let mut dropped = false;
let mut arts = Vec::with_capacity(solids.len());
for (k, (item, member, _, f, _)) in solids.iter().enumerate() {
let (paint, opacity, blend) = paint_of(item, *member);
let mapped = map_art.as_ref().filter(|_| with_art).zip(layouts.get(k)).map(|(art, layout)| classic::Mapped {
art,
layout,
budget: &mut budget,
copies: &mut *copies,
});
let (art, _, left_out) = classic::surface(n, f, &paint, (opacity, blend), &p, mapped, false);
dropped |= left_out;
arts.push(art);
}
(arts, dropped)
};
let mut used = paint_bytes;
let (arts, dropped) = draw(map_art.is_some(), &mut used);
if dropped { draw(false, &mut paint_bytes).0 } else { arts }
} else {
vec![]
}
.into_iter();
// Which surfaces lie over an underlay of their facets, in one order or whole
// ([`in_one_order`], [`underlaid_surface`]).
let seals: Vec<bool> = solids.iter().map(|(.., f, _)| underlaid(f, colored)).collect();
@@ -2061,7 +2122,7 @@ fn surfaces_with(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profil
};
let drawn = parts.iter().any(|p| !p.is_empty());
let art = if classic {
classic::surface(n, f, &paint, opacity, blend, &p)
classic_arts.next().unwrap_or_else(|| Node::group(n.id, vec![]))
} else {
let faces = drawn || (split && shared.get(shape).copied().unwrap_or(false));
with_side_parts(n.id, surface(n, f, &paint, opacity, blend, colored, faces), parts)
@@ -2391,28 +2452,7 @@ pub fn graphic_side_size(doc: Option<&Document>, n: &Node, item: Option<usize>,
/// The 3D effect `pick` finds in the effects of `n` or its `item`, and the shapes it builds from.
fn frame_shapes(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'_>) -> Option<(Effect, Vec<Profile>)> {
let n = &*resolve(doc, n, "").ok()?;
let (fx, shapes) = if is_container(n) {
let (index, fx) = pick(&n.appearance.effects).filter(|_| item.is_none())?;
let mut shapes = members(n, "").ok()?;
reshape_members(n, n.appearance.effects.get(..index)?, &mut shapes);
(fx, shapes)
} else {
let (path, rule) = profile(n)?;
let ctx = GeomContext::of(n);
match item {
None => {
let (index, fx) = pick(&n.appearance.effects)?;
let path = geometry(&path, n.appearance.effects.get(..index)?, &ctx);
(fx, vec![Profile { path, rule, items: solid_paints(n), opacity: 1.0, scopes: vec![] }])
}
Some(k) => {
let it = n.appearance.items.get(k)?;
let (index, fx) = pick(it.effects())?;
let path = geometry(&geometry(&path, &n.appearance.effects, &ctx), it.effects().get(..index)?, &ctx.item(it));
(fx, vec![Profile { path, rule, items: vec![it.clone()], opacity: 1.0, scopes: vec![] }])
}
}
};
let (fx, shapes) = picked(n, item, pick)?;
Some((fx.clone(), shapes))
}
@@ -2459,6 +2499,175 @@ fn frame_of(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'
})
}
/// One numbered surface of a 3D object that takes Map Art: what it is, its size laid out flat in
/// points, whether the viewer sees any of it, and the edges of its outline on the page.
#[derive(Clone, Debug, PartialEq)]
pub struct MapSurface {
pub kind: SurfaceKind,
pub width: f64,
pub height: f64,
pub visible: bool,
pub outline: Vec<[Point; 2]>,
}
/// The numbered surfaces of the 3D effect at `index` of the effects of `n` (on the object itself
/// with `item` `None`, else on its fill or stroke `item`), which must be an Extrude & Bevel
/// (Classic) or Revolve (Classic), shown or hidden, in the order Map Art numbers them from 1.
/// `None` for any other effect, and when the object's art can't be built.
pub fn map_surfaces_at(doc: Option<&Document>, n: &Node, item: Option<usize>, index: usize) -> Option<Vec<MapSurface>> {
let n = &*resolve(doc, n, "").ok()?;
let (fx, shapes) = picked(n, item, &|fx: &[Effect]| fx.get(index).filter(|e| takes_map_art(&e.id)).map(|e| (index, e)))?;
let p = crate::merged_params(&fx.id, &fx.params);
let b = union_bounds(&shapes)?;
// The edges of `facets` on each local surface of `surfaces`, in one pass over the facets: every
// edge of an end, and the edges of the cells that lie along the sides of the flat surface.
let seen = |surfaces: &[vectorcraft_three_d::SolidSurface], facets: &[Facet]| -> Vec<Vec<[Point; 2]>> {
let mut edges: Vec<Vec<[Point; 2]>> = vec![vec![]; surfaces.len()];
// Each surface laid out flat, and how near a point must be to its side to lie along it.
let frames: Vec<(Rect, f64)> = surfaces
.iter()
.map(|s| {
let flat = match s.kind {
SurfaceKind::Side => Rect::new(-s.width / 2.0, -s.height / 2.0, s.width / 2.0, s.height / 2.0),
_ => Rect::new(0.0, 0.0, s.width, s.height),
};
(flat, (s.width.max(s.height) * 1e-6).max(1e-9))
})
.collect();
let ends: Vec<(usize, PlanarFace)> = surfaces
.iter()
.enumerate()
.filter_map(|(k, s)| match s.kind {
SurfaceKind::End(end) => Some((k, end)),
_ => None,
})
.collect();
for f in facets.iter().filter(|f| !f.away) {
if let Some(at) = f.end {
for &(k, end) in &ends {
if end == at
&& let Some(out) = edges.get_mut(k)
{
for c in &f.contours {
out.extend(c.iter().zip(c.iter().cycle().skip(1)).take(c.len()).map(|(a, b)| [*a, *b]));
}
}
}
}
let Some(cell) = f.cell.as_deref().filter(|c| c.uv.len() == c.page.len()) else { continue };
let k = cell.surface;
// A facet of an end adds to an end's surface only its own edges, above.
if f.end.is_some() && surfaces.get(k).is_some_and(|s| matches!(s.kind, SurfaceKind::End(_))) {
continue;
}
let (Some(&(flat, near)), Some(out)) = (frames.get(k), edges.get_mut(k)) else { continue };
let count = cell.uv.len();
for i in 0..count {
let j = (i + 1) % count;
let (Some(a), Some(c)) = (cell.uv.get(i), cell.uv.get(j)) else { continue };
let along = |at: f64, of: fn(&Point) -> f64| (of(a) - at).abs() <= near && (of(c) - at).abs() <= near;
let on_side = along(flat.x0, |p| p.x) || along(flat.x1, |p| p.x) || along(flat.y0, |p| p.y) || along(flat.y1, |p| p.y);
if let (true, Some(from), Some(to)) = (on_side, cell.page.get(i), cell.page.get(j)) {
out.push([*from, *to]);
}
}
}
edges
};
let listed = |surfaces: &[vectorcraft_three_d::SolidSurface], facets: &[Facet], out: &mut Vec<MapSurface>| {
for (s, outline) in surfaces.iter().zip(seen(surfaces, facets)) {
out.push(MapSurface { kind: s.kind, width: s.width, height: s.height, visible: !outline.is_empty(), outline });
}
};
let mut out = vec![];
if fx.id == crate::CLASSIC_REVOLVE {
// Revolve (Classic) has one surface: its side, in a group that of the member with the
// longest profile. A group's members share one sampling of their curves, and a group past
// those shared limits has no surface.
let mut options = vectorcraft_three_d::Revolve { map_surface: true, ..crate::revolve::options_of(&fx.id, &p) };
if is_container(n) {
options = crate::revolve::shared_options(&shapes, options).ok()?;
}
let shape = shapes.get(crate::revolve::graphics_member(&shapes, b, options)?)?;
let (width, height) = vectorcraft_three_d::revolve_surface_size(&shape.path, b, options)?;
let surfaces = [vectorcraft_three_d::SolidSurface { kind: SurfaceKind::Side, width, height, center: None }];
let facets = vectorcraft_three_d::revolve_facets(&shape.path, b, options).unwrap_or_default();
listed(&surfaces, &facets, &mut out);
return Some(out);
}
let (parts, bounds) = solid_parts(&shapes, b);
let options = vectorcraft_three_d::Extrude { map_surfaces: true, ..classic_extrude_options(&p) };
let view = view_options(&p);
// The faces of the solids count together against the limit the art draws within.
let mut kept = 0usize;
for (_, _, area, rule, _, _) in &parts {
let surfaces = vectorcraft_three_d::extrude_surfaces(area, *rule, bounds, options).unwrap_or_default();
let facets = vectorcraft_three_d::extrude(area, *rule, bounds, options, view).unwrap_or_default();
kept = kept.saturating_add(facets.len());
if kept > MAX_OBJECT_FACES {
return None;
}
listed(&surfaces, &facets, &mut out);
}
Some(out)
}
/// [`map_surfaces_at`] for `n` as it is with 3D effect `id` and parameters `p` among the effects of
/// the object itself (`item` `None`) or of its fill or stroke `item`: in place of the effect at
/// `index` when that is an effect `id`, else of the last effect `id` there, or after those effects
/// when there is none. A dialog lists the surfaces of the effect it edits with this, whether or not
/// its preview has changed the object.
pub fn map_surfaces_with(
doc: Option<&Document>,
n: &Node,
(item, index): (Option<usize>, Option<usize>),
id: &str,
p: &Value,
) -> Option<Vec<MapSurface>> {
let mut n = n.clone();
let effects = n.appearance.effects_mut(item)?;
let at = index.filter(|&k| effects.get(k).is_some_and(|e| e.id == id)).or_else(|| effects.iter().rposition(|e| e.id == id));
let index = match at {
Some(index) => {
effects.get_mut(index)?.params = p.clone();
index
}
None => {
effects.push(crate::new_effect(id, p)?);
effects.len() - 1
}
};
map_surfaces_at(doc, &n, item, index)
}
/// The 3D effect `pick` finds in the effects of `n` (resolved) or of its `item`, with the shapes
/// it builds from: the members of a group or layer, or the object's own profile after the geometry
/// effects before the 3D effect.
fn picked<'n>(n: &'n Node, item: Option<usize>, pick: &Pick<'_>) -> Option<(&'n Effect, Vec<Profile>)> {
Some(if is_container(n) {
let (index, fx) = pick(&n.appearance.effects).filter(|_| item.is_none())?;
let mut shapes = members(n, "").ok()?;
reshape_members(n, n.appearance.effects.get(..index)?, &mut shapes);
(fx, shapes)
} else {
let (path, rule) = profile(n)?;
let ctx = GeomContext::of(n);
match item {
None => {
let (index, fx) = pick(&n.appearance.effects)?;
let path = geometry(&path, n.appearance.effects.get(..index)?, &ctx);
(fx, vec![Profile { path, rule, items: solid_paints(n), opacity: 1.0, scopes: vec![] }])
}
Some(k) => {
let it = n.appearance.items.get(k)?;
let (index, fx) = pick(it.effects())?;
let path = geometry(&geometry(&path, &n.appearance.effects, &ctx), it.effects().get(..index)?, &ctx.item(it));
(fx, vec![Profile { path, rule, items: vec![it.clone()], opacity: 1.0, scopes: vec![] }])
}
}
})
}
/// The bounds of the art symbol `name` of `doc` draws as a graphic, in the symbol's coordinates.
pub fn graphic_bounds(doc: &Document, name: &str) -> Option<Rect> {
graphics::art_bounds(doc, name)
@@ -2501,8 +2710,8 @@ impl SolidMesh {
/// The parts of `mesh`, a solid that 3D effect `id` with parameters `p` built about `bounds`, painted
/// `color` from a fill or stroke at `opacity`: for each planar face that carries graphics (Extrude &
/// Bevel's caps, the plane), the triangles on it as a mesh of their own with the art point of each
/// corner ([`MeshGraphics`]), then the rest. Revolve's side, whose graphics are not mapped onto its
/// mesh, stays plain.
/// corner ([`MeshGraphics`]), then the rest. Revolve's meshes are split by their side instead
/// (`revolve::surface_meshes`), so a Revolve's mesh stays plain here.
fn split_graphics(id: &str, p: &Value, bounds: Rect, mesh: Mesh, (color, opacity): ([f32; 4], f32)) -> Vec<SolidMesh> {
let list = graphics::mapped_graphics(p);
if list.is_empty() || !takes_graphics(id) || id == crate::REVOLVE {
+123 -52
View File
@@ -9,6 +9,7 @@ use vectorcraft_doc::{Appearance, AppearanceItem, FillLayer, Node};
use vectorcraft_geom::Rect;
use vectorcraft_three_d::{Bevel, BevelShape, ClassicShading, ClassicSurface, Extrude, Facet, Light};
use super::graphics::map_art::{self, MapArt, MapBudget, SolidLayout};
use crate::util::{flag, num, text};
pub const CLASSIC_EXTRUDE: &str = "threeD.classicExtrude";
@@ -51,10 +52,21 @@ pub fn classic_extrude_options(p: &Value) -> Extrude {
..Bevel::default()
}),
hidden: flag(p, "drawHiddenFaces", false) || classic_shading(p).surface == ClassicSurface::Wireframe,
// The numbered surfaces are laid out only for an effect that maps art onto them.
map_surfaces: !map_art::surface_maps(p).is_empty(),
..Extrude::default()
}
}
/// The mapped art of one solid for [`surface`]: the effect's maps, the solid's place among the
/// object's numbered surfaces, and the limits the object's mapped art shares.
pub(crate) struct Mapped<'a, 'd> {
pub(crate) art: &'a MapArt<'d>,
pub(crate) layout: &'a SolidLayout,
pub(crate) budget: &'a mut MapBudget,
pub(crate) copies: &'a mut usize,
}
/// The color faces darken toward: black (for Black Overprint too), the custom color, or none (faces
/// keep their paint and only the highlight lightens them).
fn shading_color(p: &Value) -> Option<Color> {
@@ -102,13 +114,15 @@ const RANGES: [(&str, f64, f64, bool); 13] = [
("blendSteps", 1.0, 256.0, true),
];
const FLAGS: [&str; 5] = ["cap", "bevelInside", "lightBehind", "drawHiddenFaces", "preserveSpotColors"];
const FLAGS: [&str; 7] = ["cap", "bevelInside", "lightBehind", "drawHiddenFaces", "preserveSpotColors", map_art::MAP_SHADE, map_art::MAP_INVISIBLE];
/// Check Extrude & Bevel (Classic)'s parameters `p` (its defaults filled in): every key is one of
/// its parameters, numbers are in range, flags are true or false, and `surface`, `shadingColor` and
/// `shadingCustom` name a surface, a shading color and a #rrggbb color.
/// its parameters, numbers are in range, flags are true or false, `surface`, `shadingColor` and
/// `shadingCustom` name a surface, a shading color and a #rrggbb color, and `mapArt` holds valid
/// maps.
pub fn validate(p: &Value) -> Result<(), String> {
validate_classic(CLASSIC_EXTRUDE, p, &RANGES, &FLAGS)
validate_classic(CLASSIC_EXTRUDE, p, &RANGES, &FLAGS)?;
map_art::validate(CLASSIC_EXTRUDE, p)
}
/// Rotate (Classic)'s numeric parameters: (key, lowest, highest, whole numbers only).
@@ -261,66 +275,67 @@ pub(crate) fn stroke_width(face: &Facet, p: &Value) -> f64 {
/// is shaded opaque and then masked by its own transparency, so the shading follows the gradient's
/// coverage; without a placement of its own, it is placed once on all the faces
/// ([`crate::lighting::opaque_surface_paint`]).
pub(crate) fn surface(n: &Node, facets: Vec<Facet>, source: &Paint, opacity: f32, blend: BlendMode, p: &Value) -> Node {
///
/// With `mapped`, a face that carries mapped art is a group of the face and that art, which the
/// surface's opacity mask covers too. Shade Artwork gives the art its face's tone and highlight,
/// and Invisible Geometry leaves the faces out: a face is then a group of its art alone. Wireframe
/// draws no mapped art. Without `mapped`, `hide` leaves the faces out the same way, for a solid
/// that shares Invisible Geometry with another solid's mapped art; Wireframe still draws.
///
/// Returns the group, whether its faces were left out, and whether `mapped` art was left out past
/// the limits.
pub(crate) fn surface(
n: &Node,
facets: &[Facet],
source: &Paint,
(opacity, blend): (f32, BlendMode),
p: &Value,
mapped: Option<Mapped<'_, '_>>,
hide: bool,
) -> (Node, bool, bool) {
let shading = classic_shading(p);
let lights = lights(p);
let shade = shading_color(p);
let preserve = preserves_spot_colors(p);
let overprint = black_overprint(p);
let wire = shading.surface == ClassicSurface::Wireframe;
let (paint, mask) = if wire { (source.clone(), None) } else { crate::lighting::opaque_surface_paint(source, || super::facets_bounds(&facets)) };
let (paint, mask) = if wire { (source.clone(), None) } else { crate::lighting::opaque_surface_paint(source, || super::facets_bounds(facets)) };
let paint = &paint;
// The mapped art of each facet, and whether the faces themselves are left out. Art past the
// limits is left out, and the faces draw; the copies and the points of art left out do not
// count against the art of later solids.
let (mut parts, invisible, dropped) = match mapped.filter(|_| !wire) {
Some(m) => {
let shaded_as = |f: &Facet, c: Color| {
let (tone, spec) = shading.tone(f.normal, &lights);
shaded(c, tone, spec, shade)
};
let (mut used, mut budget) = (*m.copies, m.budget.clone());
match m.art.parts(n.id, facets, m.layout, &shaded_as, &mut budget, &mut used) {
Some(parts) => {
(*m.copies, *m.budget) = (used, budget);
(parts, m.art.invisible, false)
}
None => (vec![], false, true),
}
}
None => (vec![], hide && !wire, false),
};
let children = facets
.into_iter()
.map(|face| {
.iter()
.enumerate()
.map(|(k, face)| {
let art = parts.get_mut(k).map(std::mem::take).unwrap_or_default();
if !art.is_empty() || invisible {
let drawn = (!invisible).then(|| Arc::new(shaded_face(n, face, paint, &shading, &lights, shade, preserve, overprint)));
return Arc::new(Node::group(n.id, drawn.into_iter().chain(art).collect()));
}
if wire {
// A wire edge is drawn as a seam is: a round-joined stroke of the paint.
let edge = crate::lighting::seam_stroke(paint.clone(), WIRE);
return Arc::new(Node::path(n.id, face.path(), Appearance { items: vec![AppearanceItem::Stroke(edge)], ..Default::default() }));
}
let (tone, spec) = shading.tone(face.normal, &lights);
// A narrow stroke of the face's own paint closes the hairline seams between faces.
let seam = super::seam_width(&face);
if overprint {
let items = overprinted_face(paint, tone, seam);
return Arc::new(Node::path(n.id, face.path(), Appearance { items, ..Default::default() }));
}
let items = match paint.color() {
// Unshaded (No Shading, no shading color, or a face in full light) with no
// highlight: the paint itself, its color space and swatch kept.
Some(_) if (tone >= 1.0 || shade.is_none()) && spec <= 0.0 => {
vec![
AppearanceItem::Fill(FillLayer::new(paint.clone())),
AppearanceItem::Stroke(crate::lighting::seam_stroke(paint.clone(), seam)),
]
}
// Preserve Spot Colors: a color linked to a swatch stays a tint of that swatch.
Some(_) if preserve && matches!(paint, Paint::Solid { swatch: Some(_), .. }) && !paint.is_registration() => {
linked_face(paint, tone, spec, shade, seam)
}
Some(c) => {
let fill = Paint::solid(shaded(c, tone, spec, shade));
vec![AppearanceItem::Fill(FillLayer::new(fill.clone())), AppearanceItem::Stroke(crate::lighting::seam_stroke(fill, seam))]
}
// Gradients and patterns keep their paint, darkened by a layer of the shading color
// and lightened by one of white. As with the other 3D effects' pattern shadow, the
// layers cover the whole face, transparent pattern cells included.
None => {
let mut items = vec![
AppearanceItem::Fill(FillLayer::new(paint.clone())),
AppearanceItem::Stroke(crate::lighting::seam_stroke(paint.clone(), seam)),
];
for (color, share) in [(shade, 1.0 - tone), (Some(Color::WHITE), spec)] {
if let Some(color) = color.filter(|_| share > 0.0) {
let mut layer = FillLayer::new(Paint::solid(color));
layer.opacity = share as f32;
items.push(AppearanceItem::Fill(layer));
}
}
items
}
};
Arc::new(Node::path(n.id, face.path(), Appearance { items, ..Default::default() }))
Arc::new(shaded_face(n, face, paint, &shading, &lights, shade, preserve, overprint))
})
.collect();
let mut group = Node::group(n.id, children);
@@ -331,5 +346,61 @@ pub(crate) fn surface(n: &Node, facets: Vec<Facet>, source: &Paint, opacity: f32
let coverage = Node::path(n.id, vectorcraft_geom::shapes::rectangle(bounds), Appearance::basic(mask, Paint::None, 0.0));
group.extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(coverage, true)));
}
group
(group, invisible, dropped)
}
/// One face of a solid in paint `paint` (opaque: [`surface`] masks a gradient's transparency),
/// filled in the paint shaded by the face's tone and highlight under `lights`, toward shading
/// color `shade`. With `preserve` (Preserve Spot Colors), a color linked to a swatch is drawn as
/// [`linked_face`] draws it. With `overprint` (Black Overprint), the face is drawn as
/// [`overprinted_face`] draws it.
#[allow(clippy::too_many_arguments)]
fn shaded_face(
n: &Node,
face: &Facet,
paint: &Paint,
shading: &ClassicShading,
lights: &[([f64; 3], f64)],
shade: Option<Color>,
preserve: bool,
overprint: bool,
) -> Node {
let (tone, spec) = shading.tone(face.normal, lights);
// A narrow stroke of the face's own paint closes the hairline seams between faces.
let seam = super::seam_width(face);
if overprint {
let items = overprinted_face(paint, tone, seam);
return Node::path(n.id, face.path(), Appearance { items, ..Default::default() });
}
let items = match paint.color() {
// Unshaded (No Shading, no shading color, or a face in full light) with no
// highlight: the paint itself, its color space and swatch kept.
Some(_) if (tone >= 1.0 || shade.is_none()) && spec <= 0.0 => {
vec![AppearanceItem::Fill(FillLayer::new(paint.clone())), AppearanceItem::Stroke(crate::lighting::seam_stroke(paint.clone(), seam))]
}
// Preserve Spot Colors: a color linked to a swatch stays a tint of that swatch.
Some(_) if preserve && matches!(paint, Paint::Solid { swatch: Some(_), .. }) && !paint.is_registration() => {
linked_face(paint, tone, spec, shade, seam)
}
Some(c) => {
let fill = Paint::solid(shaded(c, tone, spec, shade));
vec![AppearanceItem::Fill(FillLayer::new(fill.clone())), AppearanceItem::Stroke(crate::lighting::seam_stroke(fill, seam))]
}
// Gradients and patterns keep their paint, darkened by a layer of the shading color
// and lightened by one of white. As with the other 3D effects' pattern shadow, the
// layers cover the whole face, transparent pattern cells included.
None => {
let mut items =
vec![AppearanceItem::Fill(FillLayer::new(paint.clone())), AppearanceItem::Stroke(crate::lighting::seam_stroke(paint.clone(), seam))];
for (color, share) in [(shade, 1.0 - tone), (Some(Color::WHITE), spec)] {
if let Some(color) = color.filter(|_| share > 0.0) {
let mut layer = FillLayer::new(Paint::solid(color));
layer.opacity = share as f32;
items.push(AppearanceItem::Fill(layer));
}
}
items
}
};
Node::path(n.id, face.path(), Appearance { items, ..Default::default() })
}
+59 -14
View File
@@ -170,6 +170,8 @@ pub fn mapped_graphics(p: &Value) -> Vec<MappedGraphic> {
/// Revolve take graphics; a plane has only a front, and Revolve's graphics go on its side, named
/// the front. Only Extrude & Bevel takes graphics on its side.
pub fn validate(id: &str, p: &Value) -> Result<(), String> {
// Map Art's maps are checked with the graphics: an effect that takes none refuses them.
map_art::validate(id, p)?;
let list = match p.get(GRAPHICS) {
None => return Ok(()),
Some(Value::Array(list)) => list,
@@ -200,21 +202,23 @@ pub fn validate(id: &str, p: &Value) -> Result<(), String> {
/// graphics in `old` (the effect's parameters before an edit) already name: a graphic whose symbol
/// was deleted may stay.
pub fn missing_symbol(doc: &Document, p: &Value, old: Option<&Value>) -> Option<String> {
let kept = old.map(mapped_graphics).unwrap_or_default();
mapped_graphics(p)
.into_iter()
.map(|g| g.symbol)
.find(|name| !doc.symbols.iter().any(|s| s.name == *name) && !kept.iter().any(|g| g.symbol == *name))
let names = |p: &Value| -> Vec<String> {
mapped_graphics(p).into_iter().map(|g| g.symbol).chain(map_art::surface_maps(p).into_iter().map(|m| m.symbol)).collect()
};
let kept = old.map(names).unwrap_or_default();
names(p).into_iter().find(|name| !doc.symbols.iter().any(|s| s.name == *name) && !kept.contains(name))
}
/// Does the art of the symbols the graphics in `p` name fit the limits? A graphic whose symbol
/// `doc` does not have draws nothing and is not counted. With a perspective, each curve counts as
/// the [`PERSPECTIVE_PIECES`] pieces it is cut into; without one, it counts once.
/// the [`PERSPECTIVE_PIECES`] pieces it is cut into; without one, it counts once. The symbols Map
/// Art places count with the graphics.
pub fn validate_symbols(doc: &Document, p: &Value) -> Result<(), String> {
let curve = if super::view_options(p).perspective > 0.0 { PERSPECTIVE_PIECES } else { 1 };
let mut elements = 0usize;
for g in mapped_graphics(p) {
let Some(symbol) = doc.symbols.iter().find(|s| s.name == g.symbol) else { continue };
let names = mapped_graphics(p).into_iter().map(|g| g.symbol).chain(map_art::surface_maps(p).into_iter().map(|m| m.symbol));
for name in names {
let Some(symbol) = doc.symbols.iter().find(|s| s.name == name) else { continue };
let pieces = pieces_of(doc, symbol)?;
elements = elements.saturating_add(pieces.iter().map(|p| drawn_elements(&p.path, curve)).sum());
if elements > MAX_ELEMENTS {
@@ -224,6 +228,30 @@ pub fn validate_symbols(doc: &Document, p: &Value) -> Result<(), String> {
Ok(())
}
/// Does the art Map Art in `p` places on the surfaces that `unrolled` gives a flat center for (by
/// number, from 1; [`map_art::flat_center`]), with the symbols of `doc`, fit the limits as a wall, a
/// bevel or Revolve's side draws it: each map's art placed about that center at its scale, cut into
/// straight pieces, at most [`MAX_ELEMENTS`] points together and within reach? A map whose symbol
/// `doc` does not have is not counted.
pub fn validate_unrolled_symbols(doc: &Document, p: &Value, unrolled: &dyn Fn(usize) -> Option<Point>) -> Result<(), String> {
const TOO_COMPLEX: &str = "The graphics are too complex: simplify the symbols' art";
let mut points = 0usize;
for m in map_art::surface_maps(p) {
let Some(center) = unrolled(m.surface) else { continue };
let Some(symbol) = doc.symbols.iter().find(|s| s.name == m.symbol) else { continue };
let pieces = pieces_of(doc, symbol)?;
let Some(bounds) = pieces.iter().filter_map(|p| p.path.bounds()).reduce(|a, b| a.union(b)) else { continue };
let place = m.placement(bounds, center, false);
for piece in &pieces {
straight_pieces(&(place * piece.path.to_bezpath()), &mut points).ok_or(TOO_COMPLEX)?;
}
if points > MAX_ELEMENTS {
return Err(TOO_COMPLEX.into());
}
}
Ok(())
}
/// The path elements `path` draws when each curve draws `curve` elements, before curves near the
/// eye are split further: one for each straight line, move and close.
fn drawn_elements(path: &PathData, curve: usize) -> usize {
@@ -844,7 +872,12 @@ pub(crate) fn surface_parts<F: SurfaceFace>(
for k in near {
let Some(piece) = pieces.get(k) else { continue };
let mut path = BezPath::new();
// Each contour is cut only where its own bounds reach the triangle.
// Each contour is cut only where its own bounds reach the triangle. Each bounds test
// counts as one point cut, whether or not the contour reaches it.
cut_points = cut_points.saturating_add(piece.boxes.len());
if cut_points > MAX_SURFACE_CUTS {
return None;
}
for (polygon, b) in piece.polygons.iter().zip(&piece.boxes) {
if b.x1 < reach.x0 || b.x0 > reach.x1 || b.y1 < reach.y0 || b.y0 > reach.y1 {
continue;
@@ -1225,9 +1258,11 @@ pub fn appearance_graphic_symbols(appearance: &Appearance) -> Vec<String> {
std::iter::once(&appearance.effects)
.chain(appearance.items.iter().map(AppearanceItem::effects))
.flatten()
.filter(|e| takes_graphics(&e.id))
.flat_map(|e| mapped_graphics(&e.params))
.map(|g| g.symbol)
.filter(|e| takes_graphics(&e.id) || map_art::takes_map_art(&e.id))
.flat_map(|e| {
let graphics = mapped_graphics(&e.params).into_iter().map(|g| g.symbol).filter(|_| takes_graphics(&e.id));
graphics.chain(map_art::surface_maps(&e.params).into_iter().map(|m| m.symbol).filter(|_| map_art::takes_map_art(&e.id)))
})
.collect()
}
@@ -1247,8 +1282,15 @@ pub fn rename_appearance_graphic_symbol(appearance: &mut Appearance, from: &str,
let (effects, items) = (&mut appearance.effects, &mut appearance.items);
lists.push(effects);
lists.extend(items.iter_mut().map(AppearanceItem::effects_mut));
for e in lists.into_iter().flatten().filter(|e| takes_graphics(&e.id)) {
if let Some(Value::Array(list)) = e.params.get_mut(GRAPHICS) {
for e in lists.into_iter().flatten() {
let key = if takes_graphics(&e.id) {
GRAPHICS
} else if map_art::takes_map_art(&e.id) {
map_art::MAP_ART
} else {
continue;
};
if let Some(Value::Array(list)) = e.params.get_mut(key) {
for g in list.iter_mut() {
if g.get("symbol").and_then(Value::as_str) == Some(from) {
g["symbol"] = json!(to);
@@ -1294,6 +1336,9 @@ pub fn with_graphic(p: &Value, g: &MappedGraphic) -> Value {
Value::Object(out)
}
#[path = "map_art.rs"]
pub(crate) mod map_art;
#[cfg(test)]
#[path = "tests_graphics.rs"]
mod tests;
+781
View File
@@ -0,0 +1,781 @@
//! Map Art: the art of a document symbol mapped onto the numbered surfaces of Extrude & Bevel
//! (Classic) and Revolve (Classic).
//!
//! The effect keeps its maps in its `mapArt` parameter, each `{surface, symbol, x, y, scaleX,
//! scaleY, rotation}`: the surface's number (from 1), the symbol's name, the offset of the art's
//! center from the center of the surface laid out flat (points, x to the right and y down as the
//! surface is seen from outside the solid), its size as a share of the symbol's own, and its turn
//! (degrees, counterclockwise). `mapShade` shades the mapped art with its surface, and
//! `mapInvisible` draws the mapped art without the solid's faces.
//!
//! The surfaces of Extrude & Bevel (Classic) are numbered through its solids in the order they are
//! built, each solid's as [`vectorcraft_three_d::extrude_surfaces`] lists them. Revolve (Classic)
//! has one surface, its swept side (in a group, the side of the member with the longest profile).
//! A map whose number is past the object's surfaces draws nothing.
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use serde_json::{Map, Value, json};
use vectorcraft_doc::color::{Color, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, Document, FillLayer, Node, NodeId, NodeKind};
use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect};
use vectorcraft_three_d::{Extrude, FaceMap, Facet, MapCell, PlanarFace, SolidSurface, SurfaceKind, View};
use super::{
MAX_ELEMENTS, MAX_SURFACE_CUTS, MAX_SURFACE_POINTS, NotMapped, SURFACE_SEAM, SURFACE_TOLERANCE, Unrolled, counterclockwise, map_path, pieces_of,
straight_pieces, takes_seam, triangle_map,
};
/// The effect parameter that holds the maps.
pub const MAP_ART: &str = "mapArt";
/// The effect parameter of Shade Artwork.
pub const MAP_SHADE: &str = "mapShade";
/// The effect parameter of Invisible Geometry.
pub const MAP_INVISIBLE: &str = "mapInvisible";
/// The most surfaces of one 3D effect that carry a map.
pub const MAX_MAPS: usize = 64;
/// The highest surface number a map may name.
pub const MAX_MAP_SURFACE: usize = 100_000;
/// The error for maps on a 3D effect that takes none.
pub const MAP_ART_NOT_TAKEN: &str = "Map Art maps symbols onto Extrude & Bevel (Classic) and Revolve (Classic)";
/// The symbol mapped onto one numbered surface of a 3D object.
#[derive(Clone, Debug, PartialEq)]
pub struct SurfaceMap {
/// The surface's number, from 1.
pub surface: usize,
pub symbol: String,
pub x: f64,
pub y: f64,
/// Percent of the symbol's own width.
pub scale_x: f64,
/// Percent of the symbol's own height.
pub scale_y: f64,
/// Degrees, counterclockwise.
pub rotation: f64,
}
impl SurfaceMap {
pub fn to_value(&self) -> Value {
json!({
"surface": self.surface,
"symbol": self.symbol,
"x": self.x,
"y": self.y,
"scaleX": self.scale_x,
"scaleY": self.scale_y,
"rotation": self.rotation,
})
}
/// The map `v` describes. `surface` and `symbol` are required: the offsets and the rotation
/// default to 0 and the scales to 100.
pub fn from_value(v: &Value) -> Result<Self, String> {
let Value::Object(m) = v else { return Err(format!("each of `{MAP_ART}` must be an object")) };
if let Some(k) = m.keys().find(|k| !matches!(k.as_str(), "surface" | "symbol" | "x" | "y" | "scaleX" | "scaleY" | "rotation")) {
return Err(format!("`{MAP_ART}` entries take surface, symbol, x, y, scaleX, scaleY and rotation, not `{k}`"));
}
let surface = m
.get("surface")
.and_then(Value::as_u64)
.and_then(|n| usize::try_from(n).ok())
.filter(|n| (1..=MAX_MAP_SURFACE).contains(n))
.ok_or_else(|| format!("each of `{MAP_ART}` needs `surface`, a whole number from 1 to {MAX_MAP_SURFACE}"))?;
let symbol = match m.get("symbol") {
Some(Value::String(s)) if !s.trim().is_empty() => s.clone(),
_ => return Err(format!("each of `{MAP_ART}` needs `symbol`, the name of a symbol")),
};
let number = |key: &str, default: f64, (lo, hi): (f64, f64)| -> Result<f64, String> {
match m.get(key) {
None => Ok(default),
Some(v) => v
.as_f64()
.filter(|n| n.is_finite() && (lo..=hi).contains(n))
.ok_or_else(|| format!("`{MAP_ART}` {key} must be a number from {lo} to {hi}")),
}
};
Ok(Self {
surface,
symbol,
x: number("x", 0.0, (-super::MAX_OFFSET, super::MAX_OFFSET))?,
y: number("y", 0.0, (-super::MAX_OFFSET, super::MAX_OFFSET))?,
scale_x: number("scaleX", 100.0, super::SCALE_RANGE)?,
scale_y: number("scaleY", 100.0, super::SCALE_RANGE)?,
rotation: number("rotation", 0.0, (-360.0, 360.0))?,
})
}
/// Where the symbol's art goes on the flat surface, for art whose bounds are `art` on a
/// surface with center `center`. With `mirrored` (the back cap) x runs to the right as the
/// surface is seen from behind the solid.
pub fn placement(&self, art: Rect, center: Point, mirrored: bool) -> Affine {
let place = Affine::translate((center.x + self.x, center.y + self.y))
* Affine::rotate(-self.rotation.to_radians())
* Affine::scale_non_uniform(self.scale_x / 100.0, self.scale_y / 100.0)
* Affine::translate(-art.center().to_vec2());
if mirrored {
Affine::translate(center.to_vec2()) * Affine::scale_non_uniform(-1.0, 1.0) * Affine::translate(-center.to_vec2()) * place
} else {
place
}
}
/// The scales (percent) at which art with bounds `art`, turned by the map's rotation, fills a
/// surface `width` by `height` points: Scale to Fit. `None` for art or a surface with no area.
pub fn fitting_scales(&self, art: Rect, (width, height): (f64, f64)) -> Option<(f64, f64)> {
let (w, h) = (art.width(), art.height());
if w <= 0.0 || h <= 0.0 || width <= 0.0 || height <= 0.0 {
return None;
}
// The box of the art turned by the rotation, at its own size.
let (sin, cos) = self.rotation.to_radians().sin_cos();
let (bw, bh) = (w * cos.abs() + h * sin.abs(), w * sin.abs() + h * cos.abs());
let clamp = |v: f64| v.clamp(super::SCALE_RANGE.0, super::SCALE_RANGE.1);
if sin.abs() < 1e-9 || cos.abs() < 1e-9 {
// Square to the surface, each side takes its own scale.
let (sx, sy) = if cos.abs() >= 0.5 { (width / w, height / h) } else { (height / w, width / h) };
return Some((clamp(sx * 100.0), clamp(sy * 100.0)));
}
let fit = (width / bw).min(height / bh);
Some((clamp(fit * 100.0), clamp(fit * 100.0)))
}
}
/// The 3D effects that take Map Art: Extrude & Bevel (Classic) and Revolve (Classic).
pub fn takes_map_art(id: &str) -> bool {
id == super::super::CLASSIC_EXTRUDE || id == crate::CLASSIC_REVOLVE
}
/// The maps in parameters `p`, leaving out entries that are not valid and, of two maps of one
/// surface, the later one (a file may hold anything; commands check every entry with
/// [`validate`]).
pub fn surface_maps(p: &Value) -> Vec<SurfaceMap> {
let Some(Value::Array(list)) = p.get(MAP_ART) else { return vec![] };
let mut seen = HashSet::new();
list.iter().filter_map(|v| SurfaceMap::from_value(v).ok()).filter(|m| seen.insert(m.surface)).take(MAX_MAPS).collect()
}
/// Are the maps in parameters `p` of 3D effect `id` valid? Only Extrude & Bevel (Classic) and
/// Revolve (Classic) take maps, at most [`MAX_MAPS`] of them, one for a surface.
pub fn validate(id: &str, p: &Value) -> Result<(), String> {
let list = match p.get(MAP_ART) {
None => return Ok(()),
Some(Value::Array(list)) => list,
Some(_) => return Err(format!("`{MAP_ART}` must be an array")),
};
if list.is_empty() {
return Ok(());
}
if !takes_map_art(id) {
return Err(MAP_ART_NOT_TAKEN.into());
}
if list.len() > MAX_MAPS {
return Err(format!("`{MAP_ART}` takes at most {MAX_MAPS} maps"));
}
let mut seen = HashSet::new();
for v in list {
let m = SurfaceMap::from_value(v)?;
if !seen.insert(m.surface) {
return Err(format!("`{MAP_ART}` maps surface {} more than once", m.surface));
}
}
Ok(())
}
/// `p` with the map of surface `surface` replaced by `map`, or removed with `None`. The maps stay
/// in the order of their surfaces.
pub fn with_surface_map(p: &Value, surface: usize, map: Option<&SurfaceMap>) -> Value {
let mut maps: Vec<SurfaceMap> = surface_maps(p).into_iter().filter(|m| m.surface != surface).collect();
maps.extend(map.cloned());
maps.sort_by_key(|m| m.surface);
let mut out = p.as_object().cloned().unwrap_or_else(Map::new);
out.insert(MAP_ART.into(), Value::Array(maps.iter().map(SurfaceMap::to_value).collect()));
Value::Object(out)
}
/// One solid's place among its object's numbered surfaces: the index of its first surface, its
/// surfaces, and for a solid with planar ends the bounds, options and view it was built with.
pub(crate) struct SolidLayout {
pub(crate) first: usize,
pub(crate) surfaces: Vec<SolidSurface>,
pub(crate) ends: Option<(Rect, Extrude, View)>,
}
/// What the mapped art of one object has drawn so far, against the limits its maps share.
#[derive(Clone, Debug, Default, PartialEq)]
pub(crate) struct MapBudget {
elements: usize,
/// The points of the maps' symbols cut into straight pieces, against [`MAX_ELEMENTS`].
input: usize,
/// The points the maps' art draws on the faces, against [`MAX_SURFACE_POINTS`].
points: usize,
cuts: usize,
}
/// The maps of one 3D effect, with the document whose symbols they place.
pub(crate) struct MapArt<'a> {
doc: &'a Document,
maps: Vec<SurfaceMap>,
/// Shade Artwork: the mapped art takes the shading of its surface.
pub(crate) shade: bool,
/// Invisible Geometry: only the mapped art is drawn.
pub(crate) invisible: bool,
}
impl<'a> MapArt<'a> {
/// The maps of 3D effect `id` with parameters `p`. `None` without a document, for an effect
/// that takes no maps and for one that has none.
pub(crate) fn of(doc: Option<&'a Document>, id: &str, p: &Value) -> Option<Self> {
let maps = surface_maps(p);
let flag = |key: &str| p.get(key).and_then(Value::as_bool).unwrap_or(false);
(takes_map_art(id) && !maps.is_empty()).then_some(Self { doc: doc?, maps, shade: flag(MAP_SHADE), invisible: flag(MAP_INVISIBLE) })
}
fn map_of(&self, index: usize) -> Option<&SurfaceMap> {
self.maps.iter().find(|m| m.surface == index + 1)
}
/// The mapped art that falls on each of `facets`, one solid's facets in drawing order, for an
/// object with id `id`: for each facet, the nodes to draw right after it. Only facets turned
/// toward the viewer carry art. `shade` gives a color as its facet shades it, for Shade
/// Artwork. A map whose symbol the document does not have, or whose art is past the limits of
/// a graphic's art, draws nothing. `None` when the art is past the limits the maps of one
/// object share, or the copies of its paints take `copies` past the object's allowance: the
/// solid then draws without mapped art.
pub(crate) fn parts(
&self,
id: NodeId,
facets: &[Facet],
layout: &SolidLayout,
shade: &dyn Fn(&Facet, Color) -> Color,
budget: &mut MapBudget,
copies: &mut usize,
) -> Option<Vec<Vec<Arc<Node>>>> {
let mut out: Vec<Vec<Arc<Node>>> = vec![vec![]; facets.len()];
let mut flat: HashMap<usize, Vec<Unrolled>> = HashMap::new();
for (f, parts) in facets.iter().zip(out.iter_mut()) {
if f.away {
continue;
}
let recolor = |c: Color| if self.shade { shade(f, c) } else { c };
if let Some(end) = f.end {
let Some(local) = layout.surfaces.iter().position(|s| s.kind == SurfaceKind::End(end)) else { continue };
let (Some(m), Some(center)) = (self.map_of(layout.first + local), layout.surfaces.get(local).and_then(|s| s.center)) else {
continue;
};
let Some((bounds, options, view)) = layout.ends else { continue };
let Some(map) = vectorcraft_three_d::extrude_face_map(bounds, options, view, end) else { continue };
parts.extend(self.end_art(id, m, (end, &map), center, f, &recolor, budget, copies)?);
} else if let Some(cell) = f.cell.as_deref() {
let (Some(m), Some(surface)) = (self.map_of(layout.first + cell.surface), layout.surfaces.get(cell.surface)) else { continue };
if let std::collections::hash_map::Entry::Vacant(e) = flat.entry(cell.surface) {
e.insert(self.unrolled(m, surface, budget)?);
}
let Some(pieces) = flat.get(&cell.surface) else { continue };
parts.extend(cell_art(id, pieces, cell, f, &recolor, budget, copies)?);
}
}
Some(out)
}
/// The art of map `m` on planar end `end` of a solid, drawn on its facet `f` through `map`,
/// for an end whose bounds have center `center`: one clipping group, as a graphic on a cap is
/// drawn. `None` past the limits.
#[allow(clippy::too_many_arguments)]
fn end_art(
&self,
id: NodeId,
m: &SurfaceMap,
(end, map): (PlanarFace, &FaceMap),
center: Point,
f: &Facet,
recolor: &dyn Fn(Color) -> Color,
budget: &mut MapBudget,
copies: &mut usize,
) -> Option<Vec<Arc<Node>>> {
let Some(symbol) = self.doc.symbols.iter().find(|s| s.name == m.symbol) else { return Some(vec![]) };
let Ok(pieces) = pieces_of(self.doc, symbol) else { return Some(vec![]) };
let Some(bounds) = pieces.iter().filter_map(|p| p.path.bounds()).reduce(|a, b| a.union(b)) else { return Some(vec![]) };
let place = m.placement(bounds, center, end == PlanarFace::Back);
let affine = map.local_affine(center).filter(|_| map.is_affine());
// Gradients follow the end's map as it is near the art's center, or near the middle of the
// part in front of the eye when the center is not.
let local = map.local_affine(place * bounds.center()).or_else(|| {
let part = map.mapped_part(place.transform_rect_bbox(bounds))?;
let sum = part.iter().fold(Point::ZERO, |s, p| s + p.to_vec2());
map.local_affine(Point::new(sum.x / part.len() as f64, sum.y / part.len() as f64))
});
let Some(local) = local else { return Some(vec![]) };
let gradient_map = local * place;
let mut children = vec![];
for piece in pieces {
let placed = piece.path.transformed(place);
let least: usize = placed.subpaths.iter().map(|s| s.anchors.len()).sum();
let before = budget.elements;
if before.saturating_add(least) > MAX_ELEMENTS {
return None;
}
let room = MAX_ELEMENTS - before;
let mut rule = piece.rule;
let mapped = match map_path(&placed, map, affine, room) {
Err(NotMapped::Behind) => {
// Part of it is at or behind the eye: the part in front is drawn.
let Some(part) = placed.bounds().and_then(|b| map.mapped_part(b)) else { continue };
let Some(&first) = part.first() else { continue };
let mut front = BezPath::new();
front.move_to(first);
part.iter().skip(1).for_each(|p| front.line_to(*p));
front.close_path();
let cut = vectorcraft_pathops::boolean(
&placed,
piece.rule,
&PathData::from_bezpath(&front),
FillRule::NonZero,
vectorcraft_pathops::BoolOp::Intersect,
);
rule = FillRule::NonZero;
map_path(&cut, map, affine, room)
}
done => done,
};
let mapped = match mapped {
Ok(mapped) => mapped,
Err(NotMapped::Full) => return None,
Err(NotMapped::Behind) => continue,
};
budget.elements = before.saturating_add(mapped.elements().len());
if !crate::revolve::paint_copies_add(copies, 1, &piece.paint) {
return None;
}
children.push(Arc::new(piece_node(id, piece.paint, (piece.opacity, piece.blend), (mapped, rule), gradient_map, recolor, None)));
}
if children.is_empty() {
return Some(vec![]);
}
// An end's holes are contours of the same path wound against its outline, so turning the
// whole path keeps them holes under the nonzero rule.
let mut outline = f.path().to_bezpath();
if vectorcraft_geom::kurbo::Shape::area(&outline) < 0.0 {
outline = outline.reverse_subpaths();
}
let clip = Node::path(id, PathData::from_bezpath(&outline), Appearance::default());
Some(vec![Arc::new(Node::new(id, NodeKind::Group { children: vec![Arc::new(clip), Arc::new(Node::group(id, children))], clip: true }))])
}
/// The areas of map `m`'s symbol placed on `surface` laid out flat, cut into straight pieces.
/// Empty for a symbol the document does not have or whose art is past the limits of a
/// graphic's art. `None` when the pieces of the object's maps take more than
/// [`MAX_ELEMENTS`] points together.
fn unrolled(&self, m: &SurfaceMap, surface: &SolidSurface, budget: &mut MapBudget) -> Option<Vec<Unrolled>> {
let Some(symbol) = self.doc.symbols.iter().find(|s| s.name == m.symbol) else { return Some(vec![]) };
let Ok(art) = pieces_of(self.doc, symbol) else { return Some(vec![]) };
let Some(bounds) = art.iter().filter_map(|p| p.path.bounds()).reduce(|a, b| a.union(b)) else { return Some(vec![]) };
let place = m.placement(bounds, flat_center(surface), false);
let mut pieces = vec![];
for piece in art {
let placed = place * piece.path.to_bezpath();
let mut polygons = straight_pieces(&placed, &mut budget.input)?;
polygons.retain(|p| p.len() >= 3 && p.iter().all(|q| q.is_finite()));
let boxes: Vec<Rect> = polygons.iter().filter_map(|polygon| box_of(polygon)).collect();
let Some(bounds) = boxes.iter().copied().reduce(|a, b| a.union(b)) else { continue };
pieces.push(Unrolled {
polygons,
boxes,
bounds,
rule: piece.rule,
paint: piece.paint,
opacity: piece.opacity,
blend: piece.blend,
place,
});
}
Some(pieces)
}
}
/// The center of `surface` laid out flat, which a map's offset is measured from: the middle of a
/// wall or a bevel, whose flat coordinates start at its corner, and the origin of Revolve's side,
/// whose flat coordinates start at its middle.
pub fn flat_center(surface: &SolidSurface) -> Point {
match surface.kind {
SurfaceKind::Side => Point::ZERO,
SurfaceKind::End(_) => surface.center.unwrap_or(Point::ZERO),
SurfaceKind::Wall | SurfaceKind::Bevel => Point::new(surface.width / 2.0, surface.height / 2.0),
}
}
fn box_of(points: &[Point]) -> Option<Rect> {
points.iter().map(|p| Rect::from_points(*p, *p)).reduce(|a, b| a.union(b))
}
/// A map from a region of a flat surface onto the page.
enum Mapper {
Affine(Affine),
/// The projective map that takes the rectangle with corner `origin` and size `size` onto a
/// quadrilateral: `rows` are its coefficients on the unit square.
Quad {
origin: Point,
size: (f64, f64),
rows: [f64; 8],
},
}
impl Mapper {
fn at(&self, p: Point) -> Point {
match self {
Mapper::Affine(a) => *a * p,
Mapper::Quad { origin, size, rows: [a, b, c, d, e, f, g, h] } => {
let (u, v) = ((p.x - origin.x) / size.0, (p.y - origin.y) / size.1);
let w = g * u + h * v + 1.0;
Point::new((a * u + b * v + c) / w, (d * u + e * v + f) / w)
}
}
}
/// The point of the flat surface this map takes to `p` on the page. `None` where there is none.
fn back(&self, p: Point) -> Option<Point> {
let q = match self {
Mapper::Affine(a) => a.inverse() * p,
Mapper::Quad { origin, size, rows: [a, b, c, d, e, f, g, h] } => {
// x (g u + h v + 1) = a u + b v + c, and the same for y, solved for u and v.
let (m00, m01, r0) = (a - g * p.x, b - h * p.x, p.x - c);
let (m10, m11, r1) = (d - g * p.y, e - h * p.y, p.y - f);
let det = m00 * m11 - m01 * m10;
let (u, v) = ((r0 * m11 - m01 * r1) / det, (m00 * r1 - r0 * m10) / det);
Point::new(origin.x + u * size.0, origin.y + v * size.1)
}
};
q.is_finite().then_some(q)
}
/// The affine map nearest this one around `p`, for gradients and patterns.
fn local(&self, p: Point, step: f64) -> Affine {
match self {
Mapper::Affine(a) => *a,
Mapper::Quad { .. } => {
let (o, x, y) = (self.at(p), self.at(Point::new(p.x + step, p.y)), self.at(Point::new(p.x, p.y + step)));
let (dx, dy) = ((x - o) / step, (y - o) / step);
Affine::new([dx.x, dx.y, dy.x, dy.y, o.x - dx.x * p.x - dy.x * p.y, o.y - dx.y * p.x - dy.y * p.y])
}
}
}
}
/// The projective map of `cell`, a cell whose flat corners are those of an upright rectangle, in
/// order along its edge nearest the origin and back: exact for a flat wall under a perspective. `None`
/// for any other cell and for a quadrilateral the map turns inside out.
fn quad_mapper(cell: &MapCell) -> Option<(Vec<Point>, Mapper)> {
let [mut u0, mut u1, mut u2, mut u3] = <[Point; 4]>::try_from(cell.uv.as_slice()).ok()?;
let [mut p0, mut p1, mut p2, mut p3] = <[Point; 4]>::try_from(cell.page.as_slice()).ok()?;
// A cell whose first edge runs from right to left is read from its other end.
if u1.x < u0.x {
(u0, u1, u2, u3) = (u1, u0, u3, u2);
(p0, p1, p2, p3) = (p1, p0, p3, p2);
}
let size = (u1.x - u0.x, u3.y - u0.y);
let upright = u1.y == u0.y && u2.x == u1.x && u2.y == u3.y && u3.x == u0.x && size.0 > 1e-9 && size.1 > 1e-9;
if !upright {
return None;
}
let (dx1, dx2, sx) = (p1.x - p2.x, p3.x - p2.x, p0.x - p1.x + p2.x - p3.x);
let (dy1, dy2, sy) = (p1.y - p2.y, p3.y - p2.y, p0.y - p1.y + p2.y - p3.y);
let den = dx1 * dy2 - dx2 * dy1;
let scale = dx1.abs() + dx2.abs() + dy1.abs() + dy2.abs();
if den.is_nan() || den.abs() <= 1e-12 * scale * scale {
return None;
}
let (g, h) = ((sx * dy2 - dx2 * sy) / den, (dx1 * sy - sx * dy1) / den);
let rows = [p1.x - p0.x + g * p1.x, p3.x - p0.x + h * p3.x, p0.x, p1.y - p0.y + g * p1.y, p3.y - p0.y + h * p3.y, p0.y, g, h];
let inside = g + 1.0 > 1e-6 && h + 1.0 > 1e-6 && g + h + 1.0 > 1e-6;
(inside && rows.iter().all(|v| v.is_finite())).then(|| (vec![u0, u1, u2, u3], Mapper::Quad { origin: u0, size, rows }))
}
/// The regions of `cell` on its flat surface, each a convex polygon wound as [`clip_convex`] reads
/// it, with its map onto the page: the whole of an upright rectangle ([`quad_mapper`]), else the
/// triangles the cell is cut into.
fn regions(cell: &MapCell) -> Vec<(Vec<Point>, Mapper)> {
if let Some(quad) = quad_mapper(cell) {
return vec![quad];
}
let triangles: &[[usize; 3]] = if cell.uv.len() == 3 { &[[0, 1, 2]] } else { &[[0, 1, 2], [0, 2, 3]] };
triangles
.iter()
.filter_map(|corners| {
let pick = |of: &[Point]| corners.iter().map(|k| of.get(*k).copied()).collect::<Option<Vec<Point>>>();
let (uv, page) = (pick(&cell.uv)?, pick(&cell.page)?);
Some((counterclockwise(&uv)?.to_vec(), Mapper::Affine(triangle_map(&uv, &page)?)))
})
.collect()
}
/// The part of `polygon` inside the convex `window` (one step of Sutherland and Hodgman's clip for
/// each of its edges), wound so that its inside is on the positive side of each edge.
fn clip_convex(polygon: &[Point], window: &[Point]) -> Vec<Point> {
let mut out = polygon.to_vec();
for (k, &a) in window.iter().enumerate() {
let Some(&b) = window.get((k + 1) % window.len()) else { continue };
let side = |p: Point| (b - a).cross(p - a);
let input = std::mem::take(&mut out);
for (i, &p) in input.iter().enumerate() {
let Some(&q) = input.get((i + 1) % input.len()) else { continue };
let (sp, sq) = (side(p), side(q));
if sp >= 0.0 {
out.push(p);
}
if (sp >= 0.0) != (sq >= 0.0) {
out.push(p.lerp(q, sp / (sp - sq)));
}
}
if out.len() < 3 {
return vec![];
}
}
out
}
/// How far `p` lies outside the convex `polygon`, wound with its inside on the positive side of each
/// edge, across the edges for which `counts` holds: 0 or less when it lies inside them.
fn beyond(polygon: &[Point], p: Point, counts: &dyn Fn(Point, Point) -> bool) -> f64 {
let mut most = f64::NEG_INFINITY;
for (k, &a) in polygon.iter().enumerate() {
let Some(&b) = polygon.get((k + 1) % polygon.len()) else { continue };
let length = (b - a).hypot();
if length > 0.0 && counts(a, b) {
most = most.max(-(b - a).cross(p - a) / length);
}
}
most
}
/// `regions` of `cell` ([`regions`]) with the edges they share with the cell's own outline moved out
/// on the flat surface, far enough that their maps reach the outline of facet `f` where its curved
/// edges bow out of the cell: each outline point is taken back onto the flat surface through the
/// region's own map. The edge between two triangles stays, so the regions do not overlap. A region
/// moves out at most four times the size of the cell, and one whose projective map would turn
/// inside out where it reaches stays as it is. Without a curved outline, or where the outline stays
/// inside the cell, the regions are returned unchanged.
fn reaching_outline(regions: Vec<(Vec<Point>, Mapper)>, cell: &MapCell, f: &Facet) -> Vec<(Vec<Point>, Mapper)> {
let Some(outline) = f.outline.as_ref() else { return regions };
let Some(uv) = box_of(&cell.uv) else { return regions };
// The cell on the page, wound with its inside on the positive side of each edge.
let mut around = cell.page.clone();
let turn: f64 = around.iter().zip(around.iter().cycle().skip(1)).map(|(a, b)| a.to_vec2().cross(b.to_vec2())).sum();
if turn < 0.0 {
around.reverse();
}
// The points of the outline that lie outside the cell on the page, or near enough that the
// curve between them may: the curve strays from its flattened points by up to the tolerance,
// so each point counts as the corners of a square of that half width around it.
let mut out = vec![];
let outline = outline.to_bezpath();
let t = SURFACE_TOLERANCE;
vectorcraft_geom::kurbo::flatten(outline.elements().iter().copied(), t, |el| {
if let vectorcraft_geom::kurbo::PathEl::MoveTo(p) | vectorcraft_geom::kurbo::PathEl::LineTo(p) = el
&& beyond(&around, p, &|_, _| true) > -2.0 * t
{
out.extend([(t, t), (t, -t), (-t, t), (-t, -t)].map(|(x, y)| p + vectorcraft_geom::Vec2::new(x, y)));
}
});
if out.is_empty() {
return regions;
}
let most = 4.0 * uv.width().hypot(uv.height());
let on_outline = |a: Point, b: Point| {
let at = |q: Point| cell.uv.iter().position(|u| *u == q);
let count = cell.uv.len();
matches!((at(a), at(b)), (Some(i), Some(j)) if (i + 1) % count == j || (j + 1) % count == i)
};
regions
.into_iter()
.map(|(window, mapper)| {
let reach = out.iter().filter_map(|p| mapper.back(*p)).map(|q| beyond(&window, q, &on_outline)).fold(0.0f64, f64::max);
if reach <= 0.0 {
return (window, mapper);
}
// A little past the farthest point, so the cut to the outline meets it.
let reach = (reach * 1.01 + 1e-9).min(most);
let grown = grown_window(&window, reach, &on_outline);
let holds = match &mapper {
Mapper::Affine(_) => true,
Mapper::Quad { origin, size, rows } => grown.iter().all(|p| {
let (u, v) = ((p.x - origin.x) / size.0, (p.y - origin.y) / size.1);
rows[6] * u + rows[7] * v + 1.0 > 1e-6
}),
};
(if holds && grown.len() == window.len() { grown } else { window }, mapper)
})
.collect()
}
/// The convex `window`, wound as [`clip_convex`] reads it, with each edge for which `moves` holds
/// moved out by `by`, and its corners where the moved edges meet.
fn grown_window(window: &[Point], by: f64, moves: &dyn Fn(Point, Point) -> bool) -> Vec<Point> {
let count = window.len();
// Each edge as a point on its line and its direction, moved out where it moves.
let lines: Vec<(Point, vectorcraft_geom::Vec2)> = (0..count)
.filter_map(|k| {
let (a, b) = (*window.get(k)?, *window.get((k + 1) % count)?);
let d = b - a;
let length = d.hypot();
let out = if moves(a, b) && length > 0.0 { vectorcraft_geom::Vec2::new(d.y, -d.x) * (by / length) } else { vectorcraft_geom::Vec2::ZERO };
Some((a + out, d))
})
.collect();
(0..count)
.filter_map(|k| {
let ((p1, d1), (p2, d2)) = (*lines.get((k + count - 1) % count)?, *lines.get(k)?);
let den = d1.cross(d2);
if den.abs() <= 1e-12 * d1.hypot() * d2.hypot() {
return Some(p2);
}
let t = (p2 - p1).cross(d2) / den;
let p = p1 + d1 * t;
p.is_finite().then_some(p)
})
.collect()
}
/// The parts of `pieces`, a map's art on its flat surface, that fall on `cell`, the cell of facet
/// `f`, drawn on the page. `None` past the limits.
fn cell_art(
id: NodeId,
pieces: &[Unrolled],
cell: &MapCell,
f: &Facet,
recolor: &dyn Fn(Color) -> Color,
budget: &mut MapBudget,
copies: &mut usize,
) -> Option<Vec<Arc<Node>>> {
if cell.uv.len() != cell.page.len() || !(3..=4).contains(&cell.uv.len()) {
return Some(vec![]);
}
let Some(reach) = box_of(&cell.uv) else { return Some(vec![]) };
// A facet cut after it was built, or one whose edges follow the profile's curves, draws only the
// part of the art inside its own outline, which the regions reach where it bows out of the cell.
let whole = f.outline.is_none() && f.contours.first() == Some(&cell.page);
let regions = if whole { regions(cell) } else { reaching_outline(regions(cell), cell, f) };
let within = regions.iter().filter_map(|(w, _)| box_of(w)).fold(reach, |a, b| a.union(b));
let apart = |b: &Rect| b.x1 < within.x0 || b.x0 > within.x1 || b.y1 < within.y0 || b.y0 > within.y1;
let mut out = vec![];
for piece in pieces.iter().filter(|p| !apart(&p.bounds)) {
// Each contour's bounds test counts as one point cut, whether or not the contour reaches
// the cell.
budget.cuts = budget.cuts.saturating_add(piece.boxes.len());
if budget.cuts > MAX_SURFACE_CUTS {
return None;
}
let near: Vec<&Vec<Point>> = piece.polygons.iter().zip(&piece.boxes).filter(|(_, b)| !apart(b)).map(|(p, _)| p).collect();
let mut path = BezPath::new();
for (window, mapper) in &regions {
for polygon in &near {
budget.cuts = budget.cuts.saturating_add(polygon.len());
if budget.cuts > MAX_SURFACE_CUTS {
return None;
}
let cut = clip_convex(polygon, window);
let Some((first, rest)) = cut.split_first() else { continue };
path.move_to(mapper.at(*first));
rest.iter().for_each(|q| path.line_to(mapper.at(*q)));
path.close_path();
budget.points = budget.points.saturating_add(cut.len());
}
}
if budget.points > MAX_SURFACE_POINTS {
return None;
}
if path.elements().is_empty() {
continue;
}
let (path, rule) = if whole {
(path, piece.rule)
} else {
let cut = vectorcraft_pathops::boolean(
&PathData::from_bezpath(&path),
piece.rule,
&f.path(),
FillRule::NonZero,
vectorcraft_pathops::BoolOp::Intersect,
);
(cut.to_bezpath(), FillRule::NonZero)
};
if path.elements().is_empty() || !path.elements().iter().all(el_is_finite) {
continue;
}
let seam = takes_seam(piece);
if !crate::revolve::paint_copies_add(copies, 1 + usize::from(seam), &piece.paint) {
return None;
}
// Gradients and patterns follow the cell's map as it is at the cell's middle.
let middle = reach.center();
let local = regions.first().map_or(Affine::IDENTITY, |(_, m)| m.local(middle, (reach.width().max(reach.height()) * 1e-3).max(1e-6)));
let node = piece_node(
id,
piece.paint.clone(),
(piece.opacity, piece.blend),
(path, rule),
local * piece.place,
recolor,
seam.then_some(SURFACE_SEAM),
);
out.push(Arc::new(node));
}
Some(out)
}
fn el_is_finite(el: &vectorcraft_geom::kurbo::PathEl) -> bool {
use vectorcraft_geom::kurbo::PathEl;
match *el {
PathEl::MoveTo(p) | PathEl::LineTo(p) => p.is_finite(),
PathEl::QuadTo(a, p) => a.is_finite() && p.is_finite(),
PathEl::CurveTo(a, b, p) => a.is_finite() && b.is_finite() && p.is_finite(),
PathEl::ClosePath => true,
}
}
/// One painted area of mapped art on the page: `path` filled under `rule` with `paint`, its
/// gradients and pattern tiles placed through `gradient_map`, its colors through `recolor`, and
/// with `seam` a stroke of that width in the same paint over the seams between neighboring parts.
fn piece_node(
id: NodeId,
mut paint: Paint,
(opacity, blend): (f32, vectorcraft_doc::color::BlendMode),
(path, rule): (BezPath, FillRule),
gradient_map: Affine,
recolor: &dyn Fn(Color) -> Color,
seam: Option<f64>,
) -> Node {
if let Paint::Pattern { xf, .. } = &mut paint {
*xf = gradient_map * *xf;
}
let mut fill = FillLayer::new(paint);
fill.opacity = opacity;
fill.blend = blend;
let mut appearance = Appearance { items: vec![AppearanceItem::Fill(fill)], ..Default::default() };
appearance.transform_gradients(gradient_map);
for item in appearance.items.iter_mut() {
if let AppearanceItem::Fill(f) = item {
// Pattern tiles keep their colors: the document's pattern draws them.
vectorcraft_doc::recolor::map_paint(&mut f.paint, recolor);
}
}
if let (Some(width), Some(AppearanceItem::Fill(f))) = (seam, appearance.items.first()) {
let mut stroke = vectorcraft_doc::StrokeLayer::new(f.paint.clone(), width);
stroke.join = vectorcraft_doc::LineJoin::Round;
appearance.items.push(AppearanceItem::Stroke(stroke));
}
let mut node = Node::path(id, PathData::from_bezpath(&path), appearance);
if let NodeKind::Path { rule: r, .. } = &mut node.kind {
*r = rule;
}
node
}
#[cfg(test)]
#[path = "tests_map_art.rs"]
mod tests;
+1
View File
@@ -776,6 +776,7 @@ fn a_stroke_face_through_a_fill_wall_is_cut_where_their_depths_meet() {
end: None,
surface: None,
plane: Some(DepthPlane { normal, offset, center: Point::ZERO, eye: None }),
cell: None,
};
let wall = facet(0.0, [0.0, 0.0, 1.0], 0.0);
// z = x - 8: behind the wall left of x = 8, in front of it right of it.
@@ -186,6 +186,7 @@ fn a_piece_cut_from_a_face_draws_its_own_part() {
end: None,
surface: Some(vectorcraft_three_d::SurfaceCell { page: square, uv, outward: true }),
plane: Some(vectorcraft_three_d::DepthPlane { normal, offset, center: Point::ZERO, eye: None }),
cell: None,
}
};
let wall = facet(0.0, [0.0, 0.0, 1.0], 0.0);
+707
View File
@@ -0,0 +1,707 @@
use serde_json::json;
use vectorcraft_doc::Symbol;
use vectorcraft_geom::shapes;
use super::super::super::{CLASSIC_EXTRUDE, CLASSIC_ROTATE, MapSurface, map_surfaces_at, solid_art_in, validate_three_d_at_in, validate_three_d_in};
use super::*;
use crate::CLASSIC_REVOLVE;
const RED: Color = Color::Rgb { r: 1.0, g: 0.0, b: 0.0 };
const GREEN: Color = Color::Rgb { r: 0.0, g: 1.0, b: 0.0 };
const BLUE: Color = Color::Rgb { r: 0.0, g: 0.0, b: 1.0 };
fn square(id: u64, r: Rect, c: Color) -> Node {
Node::path(NodeId(id), shapes::rectangle(r), Appearance::basic(Paint::solid(c), Paint::None, 0.0))
}
/// A document with symbol "Mark", a red 10 × 10 square, and symbol "Corner", 30 × 30: a red square
/// at its top left, a blue one to the right of it and a green one below it.
fn document() -> Document {
let mut d = Document::new(1000.0, 1000.0);
d.symbols.push(Symbol { dynamic: false, name: "Mark".into(), art: Arc::new(square(0, Rect::new(500.0, 500.0, 510.0, 510.0), RED)) });
let corner = Node::group(
NodeId(0),
vec![
Arc::new(square(0, Rect::new(0.0, 0.0, 10.0, 10.0), RED)),
Arc::new(square(0, Rect::new(20.0, 0.0, 30.0, 10.0), BLUE)),
Arc::new(square(0, Rect::new(0.0, 20.0, 10.0, 30.0), GREEN)),
],
);
d.symbols.push(Symbol { dynamic: false, name: "Corner".into(), art: Arc::new(corner) });
d
}
/// A gray 100 × 100 square at (0, 0) with effect `id`, its parameters `params` over a view
/// straight on with No Shading.
fn object(id: &str, params: Value) -> Node {
let mut p = json!({"rotationX": 0.0, "rotationY": 0.0, "rotationZ": 0.0, "surface": "none"});
if let (Some(p), Some(extra)) = (p.as_object_mut(), params.as_object()) {
p.extend(extra.clone());
}
let mut n = square(7, Rect::new(0.0, 0.0, 100.0, 100.0), Color::rgb(0.5, 0.5, 0.5));
n.appearance.effects.push(crate::new_effect(id, &p).unwrap());
n
}
/// The paths of `art` filled with color `c`, in drawing order.
fn filled(art: &Node, c: Color) -> Vec<PathData> {
let mut out = vec![];
art.walk(&mut |n| {
let fill = n.appearance.items.iter().find_map(|i| match i {
AppearanceItem::Fill(f) => f.paint.color(),
AppearanceItem::Stroke(_) => None,
});
if fill.is_some_and(|f| f.to_rgb().iter().zip(c.to_rgb()).all(|(a, b)| (a - b).abs() < 1e-4))
&& let Some(p) = n.path_data()
{
out.push(p.clone());
}
});
out
}
fn bounds_of(paths: &[PathData]) -> Rect {
paths.iter().filter_map(|p| p.bounds()).reduce(|a, b| a.union(b)).unwrap()
}
fn close(a: Rect, b: Rect) -> bool {
[(a.x0, b.x0), (a.y0, b.y0), (a.x1, b.x1), (a.y1, b.y1)].iter().all(|(p, q)| (p - q).abs() < 1e-6)
}
fn surfaces(n: &Node) -> Vec<MapSurface> {
map_surfaces_at(Some(&document()), n, None, 0).unwrap()
}
/// Which way round the "Corner" symbol reads in `art`: positive when its blue square is to the
/// right of its red one and its green one below, as the symbol is drawn, at any turn; negative
/// when it is mirrored.
fn handedness(art: &Node) -> f64 {
let at = |c: Color| bounds_of(&filled(art, c)).center();
(at(BLUE) - at(RED)).cross(at(GREEN) - at(RED))
}
#[test]
fn the_surfaces_are_the_caps_then_each_wall_then_each_bevel() {
let kinds = |n: &Node| surfaces(n).iter().map(|s| s.kind).collect::<Vec<_>>();
let (front, back) = (SurfaceKind::End(PlanarFace::Front), SurfaceKind::End(PlanarFace::Back));
let solid = object(CLASSIC_EXTRUDE, json!({}));
assert_eq!(kinds(&solid), [vec![front, back], vec![SurfaceKind::Wall; 4]].concat());
// Each wall runs from corner to corner of the square and is as deep as the solid.
for wall in surfaces(&solid).iter().skip(2) {
assert!((wall.width - 100.0).abs() < 1e-6 && (wall.height - 50.0).abs() < 1e-6, "{wall:?}");
}
assert_eq!(kinds(&object(CLASSIC_EXTRUDE, json!({"cap": false}))), vec![SurfaceKind::Wall; 4]);
let beveled = object(CLASSIC_EXTRUDE, json!({"bevel": "classic"}));
assert_eq!(kinds(&beveled), [vec![front, back], vec![SurfaceKind::Wall; 4], vec![SurfaceKind::Bevel; 4]].concat());
// With no depth the art is a plane, which has its front only.
assert_eq!(kinds(&object(CLASSIC_EXTRUDE, json!({"depth": 0}))), vec![front]);
// An outline with no corner has one wall.
let mut round = Node::path(NodeId(7), shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::basic(Paint::solid(RED), Paint::None, 0.0));
round.appearance.effects.push(crate::new_effect(CLASSIC_EXTRUDE, &json!({})).unwrap());
assert_eq!(kinds(&round), vec![front, back, SurfaceKind::Wall]);
// Revolve (Classic) has its side, and Rotate (Classic) takes no maps.
assert_eq!(kinds(&object(CLASSIC_REVOLVE, json!({}))), vec![SurfaceKind::Side]);
assert_eq!(map_surfaces_at(Some(&document()), &object(CLASSIC_ROTATE, json!({})), None, 0), None);
// Seen straight on, only the front cap is turned toward the viewer.
let seen: Vec<bool> = surfaces(&solid).iter().map(|s| s.visible).collect();
assert_eq!(seen, [true, false, false, false, false, false]);
}
#[test]
fn a_bevel_as_deep_as_the_solid_leaves_no_walls_and_its_bevels_take_their_maps() {
let (front, back) = (SurfaceKind::End(PlanarFace::Front), SurfaceKind::End(PlanarFace::Back));
let solid = |maps: Value| object(CLASSIC_EXTRUDE, json!({"depth": 10, "bevel": "classic", "bevelHeight": 10, "mapArt": maps}));
let kinds: Vec<SurfaceKind> = surfaces(&solid(json!([]))).iter().map(|s| s.kind).collect();
assert_eq!(kinds, [vec![front, back], vec![SurfaceKind::Bevel; 4]].concat());
// Seen straight on, the front bevels draw the art mapped onto them.
let bevels: Vec<Value> = (3..=6).map(|k| json!({"surface": k, "symbol": "Mark"})).collect();
let art = solid_art_in(Some(&document()), &solid(json!(bevels))).unwrap();
assert!(!filled(&art, RED).is_empty());
}
#[test]
fn a_map_on_the_front_cap_draws_the_symbol_at_its_offset_scales_and_turn() {
let d = document();
let map = |m: Value| solid_art_in(Some(&d), &object(CLASSIC_EXTRUDE, json!({"mapArt": [m]}))).unwrap();
// Without a map nothing red is drawn.
assert!(filled(&solid_art_in(Some(&d), &object(CLASSIC_EXTRUDE, json!({}))).unwrap(), RED).is_empty());
// The art's center is at the center of the cap, its size the symbol's own.
let centered = filled(&map(json!({"surface": 1, "symbol": "Mark"})), RED);
assert!(close(bounds_of(&centered), Rect::new(45.0, 45.0, 55.0, 55.0)), "{:?}", bounds_of(&centered));
// An offset moves it, and each scale sizes one side.
let moved = filled(&map(json!({"surface": 1, "symbol": "Mark", "x": 10, "y": -5, "scaleX": 200, "scaleY": 300})), RED);
assert!(close(bounds_of(&moved), Rect::new(50.0, 30.0, 70.0, 60.0)), "{:?}", bounds_of(&moved));
// A quarter turn swaps the sides.
let turned = filled(&map(json!({"surface": 1, "symbol": "Mark", "scaleX": 200, "rotation": 90})), RED);
assert!(close(bounds_of(&turned), Rect::new(45.0, 40.0, 55.0, 60.0)), "{:?}", bounds_of(&turned));
// The art is clipped to the cap.
let past = filled(&map(json!({"surface": 1, "symbol": "Mark", "x": 50})), RED);
assert_eq!(past.len(), 1);
let art = map(json!({"surface": 1, "symbol": "Mark", "x": 50}));
let mut clipped = false;
art.walk(&mut |n| clipped |= matches!(&n.kind, NodeKind::Group { clip: true, .. }));
assert!(clipped);
}
#[test]
fn a_map_on_a_side_wall_reads_the_right_way_round_from_outside() {
let d = document();
let all_walls: Vec<Value> = (3..=6).map(|k| json!({"surface": k, "symbol": "Corner"})).collect();
for turn in [-90.0, 90.0] {
// Seen from one side, one wall faces the viewer: it alone carries its map.
let n = object(CLASSIC_EXTRUDE, json!({"rotationY": turn, "mapArt": all_walls}));
let art = solid_art_in(Some(&d), &n).unwrap();
assert_eq!(filled(&art, RED).len(), 1, "one wall is seen at {turn}");
// The wall is 100 along the outline and 50 deep: the art keeps its size at its middle.
let whole = bounds_of(&[filled(&art, RED), filled(&art, BLUE), filled(&art, GREEN)].concat());
assert!((whole.width() - 30.0).abs() < 1e-6 && (whole.height() - 30.0).abs() < 1e-6, "{whole:?}");
assert!((whole.center().x - 50.0).abs() < 1e-6 && (whole.center().y - 50.0).abs() < 1e-6, "{whole:?}");
assert!(handedness(&art) > 0.0, "the art is mirrored at {turn}");
}
// The walls seen from above and below read the right way round too.
for turn in [-90.0, 90.0] {
let n = object(CLASSIC_EXTRUDE, json!({"rotationX": turn, "mapArt": all_walls}));
assert!(handedness(&solid_art_in(Some(&d), &n).unwrap()) > 0.0, "the art is mirrored at {turn}");
}
}
#[test]
fn a_wall_beside_a_bevel_is_laid_out_at_its_own_length() {
let d = document();
// A bevel 10 wide added around the square sets each wall 10 out, so each wall is 120 long; a
// bevel takes the length of the wall it sits above. Carved in, the walls are the square's own.
for (inside, length) in [(false, 120.0), (true, 100.0)] {
let solid = object(CLASSIC_EXTRUDE, json!({"bevel": "classic", "bevelHeight": 10, "bevelInside": inside}));
for side in surfaces(&solid).iter().skip(2) {
assert!((side.width - length).abs() < 1e-6, "inside {inside}: {side:?}");
}
// Seen from one side, the art on the wall that faces the viewer keeps its size.
let walls: Vec<Value> = (3..=6).map(|k| json!({"surface": k, "symbol": "Corner"})).collect();
let n = object(CLASSIC_EXTRUDE, json!({"bevel": "classic", "bevelHeight": 10, "bevelInside": inside, "rotationY": 90, "mapArt": walls}));
let art = solid_art_in(Some(&d), &n).unwrap();
let whole = bounds_of(&[filled(&art, RED), filled(&art, BLUE), filled(&art, GREEN)].concat());
assert!((whole.width() - 30.0).abs() < 1e-6 && (whole.height() - 30.0).abs() < 1e-6, "inside {inside}: {whole:?}");
}
}
#[test]
fn art_on_a_facet_with_a_curved_edge_is_clipped_to_that_edge() {
let quad = vec![Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(10.0, 10.0), Point::new(0.0, 10.0)];
// The facet's top edge follows a curve that bows into the quad, down to y = 2.
let mut curved = BezPath::new();
curved.move_to((0.0, 0.0));
curved.curve_to((10.0 / 3.0, 8.0 / 3.0), (20.0 / 3.0, 8.0 / 3.0), (10.0, 0.0));
curved.line_to((10.0, 10.0));
curved.line_to((0.0, 10.0));
curved.close_path();
let facet = Facet {
contours: vec![quad.clone()],
depth: 0.0,
brightness: 1.0,
illumination: [1.0; 3],
normal: [0.0, 0.0, 1.0],
rgb_gradient: None,
outline: Some(PathData::from_bezpath(&curved)),
side: true,
away: false,
end: None,
plane: None,
surface: None,
cell: None,
};
let cell = MapCell { surface: 0, page: quad.clone(), uv: quad.clone() };
let whole = Rect::new(0.0, 0.0, 10.0, 10.0);
let art = Unrolled {
polygons: vec![quad],
boxes: vec![whole],
bounds: whole,
rule: FillRule::NonZero,
paint: Paint::solid(RED),
opacity: 1.0,
blend: Default::default(),
place: Affine::IDENTITY,
};
let (mut budget, mut copies) = (MapBudget::default(), 0);
let out = cell_art(NodeId(1), &[art], &cell, &facet, &|c| c, &mut budget, &mut copies).unwrap();
let area: f64 = out.iter().filter_map(|n| n.path_data()).map(|p| vectorcraft_geom::kurbo::Shape::area(&p.to_bezpath()).abs()).sum();
let want = vectorcraft_geom::kurbo::Shape::area(&curved).abs();
assert!((area - want).abs() < 1e-2, "{area} drawn, {want} inside the curved edge");
}
#[test]
fn art_on_a_facet_whose_curved_edge_bows_out_covers_the_whole_facet() {
let quad = vec![Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(10.0, 10.0), Point::new(0.0, 10.0)];
// The facet's top edge follows a curve that bows out of the quad, up to y = -2.
let mut curved = BezPath::new();
curved.move_to((0.0, 0.0));
curved.curve_to((10.0 / 3.0, -8.0 / 3.0), (20.0 / 3.0, -8.0 / 3.0), (10.0, 0.0));
curved.line_to((10.0, 10.0));
curved.line_to((0.0, 10.0));
curved.close_path();
let facet = Facet {
contours: vec![quad.clone()],
depth: 0.0,
brightness: 1.0,
illumination: [1.0; 3],
normal: [0.0, 0.0, 1.0],
rgb_gradient: None,
outline: Some(PathData::from_bezpath(&curved)),
side: true,
away: false,
end: None,
plane: None,
surface: None,
cell: None,
};
let cell = MapCell { surface: 0, page: quad.clone(), uv: quad };
// Art that covers the facet and more.
let cover = vec![Point::new(-5.0, -5.0), Point::new(15.0, -5.0), Point::new(15.0, 15.0), Point::new(-5.0, 15.0)];
let whole = Rect::new(-5.0, -5.0, 15.0, 15.0);
let art = Unrolled {
polygons: vec![cover],
boxes: vec![whole],
bounds: whole,
rule: FillRule::NonZero,
paint: Paint::solid(RED),
opacity: 1.0,
blend: Default::default(),
place: Affine::IDENTITY,
};
let (mut budget, mut copies) = (MapBudget::default(), 0);
let out = cell_art(NodeId(1), &[art], &cell, &facet, &|c| c, &mut budget, &mut copies).unwrap();
let area: f64 = out.iter().filter_map(|n| n.path_data()).map(|p| vectorcraft_geom::kurbo::Shape::area(&p.to_bezpath()).abs()).sum();
let want = vectorcraft_geom::kurbo::Shape::area(&curved).abs();
assert!((area - want).abs() < 1e-2, "{area} drawn, {want} inside the curved edge");
}
#[test]
fn the_bounds_tests_of_contours_away_from_a_cell_count_as_cuts() {
let quad = vec![Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(10.0, 10.0), Point::new(0.0, 10.0)];
let facet = Facet {
contours: vec![quad.clone()],
depth: 0.0,
brightness: 1.0,
illumination: [1.0; 3],
normal: [0.0, 0.0, 1.0],
rgb_gradient: None,
outline: None,
side: true,
away: false,
end: None,
plane: None,
surface: None,
cell: None,
};
let cell = MapCell { surface: 0, page: quad.clone(), uv: quad };
// Small contours on either side of the cell: the piece's bounds reach across it, but no
// contour's own bounds do.
let polygons: Vec<Vec<Point>> = (0..2000)
.map(|k| {
let x = if k % 2 == 0 { -1000.0 } else { 1000.0 };
vec![Point::new(x, 0.0), Point::new(x + 1.0, 0.0), Point::new(x + 1.0, 1.0)]
})
.collect();
let boxes: Vec<Rect> = polygons.iter().filter_map(|p| box_of(p)).collect();
let art = Unrolled {
polygons,
boxes,
bounds: Rect::new(-1000.0, 0.0, 1001.0, 1.0),
rule: FillRule::NonZero,
paint: Paint::solid(RED),
opacity: 1.0,
blend: Default::default(),
place: Affine::IDENTITY,
};
let mut budget = MapBudget { cuts: MAX_SURFACE_CUTS - 10, ..MapBudget::default() };
assert!(cell_art(NodeId(1), &[art], &cell, &facet, &|c| c, &mut budget, &mut 0).is_none());
}
#[test]
fn a_map_on_the_back_cap_reads_the_right_way_round_from_behind() {
let d = document();
let n = object(CLASSIC_EXTRUDE, json!({"rotationY": 180, "mapArt": [{"surface": 1, "symbol": "Mark"}, {"surface": 2, "symbol": "Corner"}]}));
let art = solid_art_in(Some(&d), &n).unwrap();
// Only the back cap is seen, and it carries its own map's art.
assert_eq!(filled(&art, RED).len(), 1);
assert_eq!((filled(&art, BLUE).len(), filled(&art, GREEN).len()), (1, 1));
assert!(handedness(&art) > 0.0);
}
#[test]
fn art_past_the_shared_limits_leaves_out_the_mapped_art_of_every_solid() {
let mut d = document();
// A zigzag of half the straight sides one 3D effect's mapped art may draw.
let mut b = BezPath::new();
b.move_to((0.0, 0.0));
for i in 1..=MAX_ELEMENTS / 2 {
b.line_to((i as f64 * 0.00005, (i % 2) as f64));
}
b.close_path();
let half = Node::path(NodeId(0), PathData::from_bezpath(&b), Appearance::basic(Paint::solid(RED), Paint::None, 0.0));
d.symbols.push(Symbol { dynamic: false, name: "Half".into(), art: Arc::new(half) });
let gray = Color::rgb(0.5, 0.5, 0.5);
// A group of two squares: the first solid's front is surface 1, the second's surface 7.
let art = |maps: Value, invisible: bool| {
let members =
vec![Arc::new(square(8, Rect::new(0.0, 0.0, 100.0, 100.0), gray)), Arc::new(square(9, Rect::new(200.0, 0.0, 300.0, 100.0), gray))];
let mut g = Node::group(NodeId(7), members);
let p = json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0, "surface": "none", "mapInvisible": invisible, "mapArt": maps});
g.appearance.effects.push(crate::new_effect(CLASSIC_EXTRUDE, &p).unwrap());
solid_art_in(Some(&d), &g).unwrap()
};
// One solid's art fits.
assert!(!filled(&art(json!([{"surface": 1, "symbol": "Half"}]), false), RED).is_empty());
// Both together are past the limit: no solid draws its art, and with Invisible Geometry every
// solid's faces draw.
let both = json!([{"surface": 1, "symbol": "Half"}, {"surface": 7, "symbol": "Half"}]);
assert!(filled(&art(both.clone(), false), RED).is_empty());
let hidden = art(both, true);
assert!(filled(&hidden, RED).is_empty());
let faces = bounds_of(&filled(&hidden, gray));
assert!(faces.x0 < 1.0 && faces.x1 > 299.0, "{faces:?}");
}
#[test]
fn a_wall_under_a_perspective_maps_its_art_whole() {
let d = document();
let all_walls: Vec<Value> = (3..=6).map(|k| json!({"surface": k, "symbol": "Mark"})).collect();
let n = object(CLASSIC_EXTRUDE, json!({"rotationY": -60, "perspectiveAngle": 90, "mapArt": all_walls}));
let art = solid_art_in(Some(&d), &n).unwrap();
// The wall is one flat face: the square maps onto it as one four-cornered area, not as two
// pieces that meet along the face's diagonal.
let marks = filled(&art, RED);
assert_eq!(marks.len(), 1);
let mark = &marks[0];
assert_eq!((mark.subpaths.len(), mark.subpaths[0].anchors.len()), (1, 4), "{mark:?}");
// Nearer the viewer the square's side is longer.
let side = |i: usize| mark.subpaths[0].anchors[i].p.distance(mark.subpaths[0].anchors[(i + 1) % 4].p);
let uneven = (side(0) - side(2)).abs().max((side(1) - side(3)).abs());
assert!(uneven > 0.05, "{} {} {} {}", side(0), side(1), side(2), side(3));
}
#[test]
fn shade_artwork_and_invisible_geometry_change_what_is_drawn() {
let d = document();
let params = |extra: Value| {
let mut p = json!({"surface": "diffuse", "rotationY": -60, "lightIntensity": 0, "ambient": 20, "mapArt": [{"surface": 1, "symbol": "Mark"}]});
p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
solid_art_in(Some(&d), &object(CLASSIC_EXTRUDE, p)).unwrap()
};
// Unshaded, the art keeps its own color on a shaded face.
assert_eq!(filled(&params(json!({})), RED).len(), 1);
// Shaded, it darkens toward black with its face.
let shaded = params(json!({"mapShade": true}));
assert!(filled(&shaded, RED).is_empty());
let mut darkest = 1.0f32;
shaded.walk(&mut |n| {
for item in &n.appearance.items {
if let AppearanceItem::Fill(f) = item
&& let Some([r, g, b]) = f.paint.color().map(|c| c.to_rgb())
&& g < 1e-4
&& b < 1e-4
&& r > 0.0
{
darkest = darkest.min(r);
}
}
});
assert!(darkest < 0.999, "the art is as dark as its face: {darkest}");
// With Invisible Geometry only the art is drawn.
let count = |art: &Node| {
let mut paths = 0;
art.walk(&mut |n| paths += usize::from(n.path_data().is_some() && !n.appearance.items.is_empty()));
paths
};
assert!(count(&params(json!({}))) > 1);
assert_eq!(count(&params(json!({"mapInvisible": true}))), 1);
// Without a map Invisible Geometry leaves the solid as it is, and Wireframe draws no art.
let plain = object(CLASSIC_EXTRUDE, json!({"mapInvisible": true}));
assert!(count(&solid_art_in(Some(&d), &plain).unwrap()) > 0);
assert!(filled(&params(json!({"surface": "wireframe"})), RED).is_empty());
}
#[test]
fn a_map_past_the_surfaces_draws_nothing_and_a_missing_symbol_is_left_out() {
let d = document();
let art = |maps: Value| solid_art_in(Some(&d), &object(CLASSIC_EXTRUDE, json!({"mapArt": maps}))).unwrap();
assert!(filled(&art(json!([{"surface": 7, "symbol": "Mark"}])), RED).is_empty());
assert!(filled(&art(json!([{"surface": 1, "symbol": "Gone"}])), RED).is_empty());
// A hollow solid's first surface is its first wall, so the cap's map draws nothing there.
let hollow = object(CLASSIC_EXTRUDE, json!({"cap": false, "mapArt": [{"surface": 1, "symbol": "Mark"}]}));
assert!(filled(&solid_art_in(Some(&d), &hollow).unwrap(), RED).is_empty());
assert_eq!(missing(&d, &json!({"mapArt": [{"surface": 1, "symbol": "Gone"}]})), Some("Gone".to_string()));
assert_eq!(missing(&d, &json!({"mapArt": [{"surface": 1, "symbol": "Mark"}]})), None);
}
#[test]
fn the_points_drawn_on_earlier_surfaces_leave_the_next_symbol_its_own_allowance() {
let d = document();
let art = MapArt::of(Some(&d), CLASSIC_EXTRUDE, &json!({"mapArt": [{"surface": 3, "symbol": "Mark"}]})).unwrap();
let wall = SolidSurface { kind: SurfaceKind::Wall, width: 100.0, height: 50.0, center: None };
// Earlier surfaces drew more points on their faces than one symbol may take cut into pieces.
let mut budget = MapBudget { points: MAX_ELEMENTS + 1, ..MapBudget::default() };
let pieces = art.unrolled(&art.maps[0], &wall, &mut budget).expect("the symbol is cut into pieces");
assert_eq!(pieces.len(), 1);
}
#[test]
fn art_past_the_paint_copies_allowance_leaves_the_allowance_to_later_art() {
let d = document();
let mut b = BezPath::new();
b.move_to((100.0, 0.0));
b.line_to((100.0, 100.0));
let path = PathData::from_bezpath(&b);
let gray = Paint::solid(Color::rgb(0.5, 0.5, 0.5));
let n = Node::path(NodeId(7), path.clone(), Appearance::basic(Paint::None, gray.clone(), 1.0));
let p = crate::merged_params(
CLASSIC_REVOLVE,
&json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0, "surface": "none", "offset": 40, "mapArt": [{"surface": 1, "symbol": "Mark"}]}),
);
let art = MapArt::of(Some(&d), CLASSIC_REVOLVE, &p).unwrap();
let bounds = path.bounds().unwrap();
let options = vectorcraft_three_d::Revolve { map_surface: true, ..crate::revolve::options_of(CLASSIC_REVOLVE, &p) };
let (width, height) = vectorcraft_three_d::revolve_surface_size(&path, bounds, options).unwrap();
let layout = SolidLayout { first: 0, surfaces: vec![SolidSurface { kind: SurfaceKind::Side, width, height, center: None }], ends: None };
let facets = vectorcraft_three_d::revolve_facets(&path, bounds, options).unwrap();
// The side's art, with the copies of its paint and its points counted from `copies` and
// `budget` already used.
let draw = |copies: &mut usize, budget: &mut MapBudget| {
let mapped = crate::solids::classic::Mapped { art: &art, layout: &layout, budget, copies };
let blend = vectorcraft_doc::color::BlendMode::Normal;
crate::solids::classic::surface(&n, &facets, &gray, (1.0, blend), &p, Some(mapped), false).0
};
let (mut copies, mut budget) = (0, MapBudget::default());
assert!(!filled(&draw(&mut copies, &mut budget), RED).is_empty());
assert!(copies > 0 && budget != MapBudget::default());
// With the allowance used up, the art is left out, and so are the copies and the points it
// would have taken.
let full = crate::revolve::MAX_PAINT_COPIES;
let (mut copies, mut budget) = (full, MapBudget::default());
assert!(filled(&draw(&mut copies, &mut budget), RED).is_empty());
assert_eq!(copies, full);
assert_eq!(budget, MapBudget::default());
}
fn missing(d: &Document, p: &Value) -> Option<String> {
super::super::missing_symbol(d, p, None)
}
#[test]
fn revolve_classic_wraps_its_map_around_the_side() {
let d = document();
let mut b = BezPath::new();
b.move_to((100.0, 0.0));
b.line_to((100.0, 100.0));
let mut n = Node::path(NodeId(7), PathData::from_bezpath(&b), Appearance::basic(Paint::None, Paint::solid(Color::rgb(0.5, 0.5, 0.5)), 1.0));
let view =
json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0, "surface": "none", "offset": 40, "mapArt": [{"surface": 1, "symbol": "Corner"}]});
n.appearance.effects.push(crate::new_effect(CLASSIC_REVOLVE, &view).unwrap());
let art = crate::revolve_art_in(Some(&d), &n).unwrap();
// The art is drawn at the middle of the side that faces the viewer, the right way round.
assert!(!filled(&art, RED).is_empty());
assert!(handedness(&art) > 0.0);
let whole = bounds_of(&[filled(&art, RED), filled(&art, BLUE), filled(&art, GREEN)].concat());
assert!((whole.center().y - 50.0).abs() < 1.0, "{whole:?}");
// A map of another surface draws nothing.
n.appearance.effects[0].params["mapArt"] = json!([{"surface": 2, "symbol": "Corner"}]);
assert!(filled(&crate::revolve_art_in(Some(&d), &n).unwrap(), RED).is_empty());
}
#[test]
fn invisible_geometry_leaves_out_every_member_of_a_revolved_group() {
let d = document();
let gray = Color::rgb(0.5, 0.5, 0.5);
let line = |id: u64, x: f64, height: f64| {
let mut b = BezPath::new();
b.move_to((x, 0.0));
b.line_to((x, height));
Arc::new(Node::path(NodeId(id), PathData::from_bezpath(&b), Appearance::basic(Paint::None, Paint::solid(gray), 1.0)))
};
// The map goes on the side of the longer member; the shorter one has none.
let art = |extra: Value| {
let mut p =
json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0, "surface": "none", "offset": 40, "mapArt": [{"surface": 1, "symbol": "Mark"}]});
p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
let mut g = Node::group(NodeId(7), vec![line(8, 100.0, 100.0), line(9, 140.0, 30.0)]);
g.appearance.effects.push(crate::new_effect(CLASSIC_REVOLVE, &p).unwrap());
crate::revolve_art_in(Some(&d), &g).unwrap()
};
let shown = art(json!({}));
assert!(!filled(&shown, RED).is_empty() && !filled(&shown, gray).is_empty());
let hidden = art(json!({"mapInvisible": true}));
assert!(!filled(&hidden, RED).is_empty());
assert!(filled(&hidden, gray).is_empty(), "no member's faces are drawn");
// On Wireframe the members are drawn as they are without a map.
let wire = art(json!({"mapInvisible": true, "surface": "wireframe"}));
let mut strokes = 0;
wire.walk(&mut |n| strokes += usize::from(n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(_)))));
assert!(strokes > 0);
}
#[test]
fn a_revolved_group_past_its_shared_limits_lists_no_surface() {
let gray = Color::rgb(0.5, 0.5, 0.5);
// Profiles of five anchors each; one alone fits Revolve's limits.
let profile = |id: u64, x: f64| {
let mut b = BezPath::new();
b.move_to((x, 0.0));
for i in 1..5 {
b.line_to((x + f64::from(i % 2), f64::from(i) * 10.0));
}
Arc::new(Node::path(NodeId(id), PathData::from_bezpath(&b), Appearance::basic(Paint::None, Paint::solid(gray), 1.0)))
};
let group = |count: u64| {
let mut g = Node::group(NodeId(7), (0..count).map(|k| profile(k + 8, 100.0 + k as f64 * 0.01)).collect());
g.appearance.effects.push(crate::new_effect(CLASSIC_REVOLVE, &json!({})).unwrap());
g
};
let d = document();
assert_eq!(map_surfaces_at(Some(&d), &group(2), None, 0).map(|s| s.len()), Some(1));
// 4,000 of them together are past the anchors the members share.
assert!(map_surfaces_at(Some(&d), &group(4000), None, 0).is_none());
}
#[test]
fn an_extruded_group_past_the_faces_of_one_object_lists_no_surface() {
// Polygons of 1,000 corners: each solid alone has about 1,000 faces.
let polygon = |id: u64, x: f64| {
let mut b = BezPath::new();
for i in 0..1000 {
let a = f64::from(i) * std::f64::consts::TAU / 1000.0;
let p = (x + 40.0 * a.cos(), 40.0 * a.sin());
if i == 0 { b.move_to(p) } else { b.line_to(p) }
}
b.close_path();
Arc::new(Node::path(NodeId(id), PathData::from_bezpath(&b), Appearance::basic(Paint::solid(RED), Paint::None, 0.0)))
};
let group = |count: u64| {
let mut g = Node::group(NodeId(7), (0..count).map(|k| polygon(k + 8, k as f64 * 100.0)).collect());
g.appearance.effects.push(crate::new_effect(CLASSIC_EXTRUDE, &json!({"drawHiddenFaces": true})).unwrap());
g
};
let d = document();
assert!(map_surfaces_at(Some(&d), &group(2), None, 0).is_some());
// 200 of them together have more faces than one object draws.
assert!(map_surfaces_at(Some(&d), &group(200), None, 0).is_none());
}
#[test]
fn bad_maps_are_refused() {
let d = document();
let check = |id: &str, p: Value| {
let n = object(id, json!({}));
validate_three_d_in(Some(&d), &n, id, &crate::merged_params(id, &p))
};
assert_eq!(check(CLASSIC_EXTRUDE, json!({"mapArt": [{"surface": 3, "symbol": "Mark", "scaleX": 50}]})), Ok(()));
assert_eq!(check(CLASSIC_REVOLVE, json!({"mapArt": [{"surface": 1, "symbol": "Mark"}], "mapShade": true})), Ok(()));
for (p, error) in [
(json!({"mapArt": {}}), "`mapArt` must be an array"),
(json!({"mapArt": [7]}), "each of `mapArt` must be an object"),
(json!({"mapArt": [{"symbol": "Mark"}]}), "needs `surface`"),
(json!({"mapArt": [{"surface": 0, "symbol": "Mark"}]}), "needs `surface`"),
(json!({"mapArt": [{"surface": 1.5, "symbol": "Mark"}]}), "needs `surface`"),
(json!({"mapArt": [{"surface": 100001, "symbol": "Mark"}]}), "needs `surface`"),
(json!({"mapArt": [{"surface": 1}]}), "needs `symbol`"),
(json!({"mapArt": [{"surface": 1, "symbol": "Mark", "face": "front"}]}), "not `face`"),
(json!({"mapArt": [{"surface": 1, "symbol": "Mark", "scaleX": 0}]}), "scaleX must be a number from 1 to 10000"),
(json!({"mapArt": [{"surface": 1, "symbol": "Mark", "rotation": 361}]}), "rotation must be a number from -360 to 360"),
(json!({"mapArt": [{"surface": 1, "symbol": "Mark", "x": "left"}]}), "x must be a number"),
(json!({"mapArt": [{"surface": 1, "symbol": "Mark"}, {"surface": 1, "symbol": "Corner"}]}), "maps surface 1 more than once"),
(json!({"mapShade": 1}), "`mapShade` must be true or false"),
(json!({"mapInvisible": "yes"}), "`mapInvisible` must be true or false"),
] {
for id in [CLASSIC_EXTRUDE, CLASSIC_REVOLVE] {
let e = check(id, p.clone()).unwrap_err();
assert!(e.contains(error), "{id} {p}: {e}");
}
}
let many: Vec<Value> = (1..=65).map(|k| json!({"surface": k, "symbol": "Mark"})).collect();
assert!(check(CLASSIC_EXTRUDE, json!({"mapArt": many})).unwrap_err().contains("at most 64 maps"));
// Rotate (Classic) has no surface to map onto.
let e = check(CLASSIC_ROTATE, json!({"mapArt": [{"surface": 1, "symbol": "Mark"}]})).unwrap_err();
assert!(e.contains(MAP_ART_NOT_TAKEN), "{e}");
}
#[test]
fn a_mapped_symbol_past_the_limits_of_a_graphics_art_is_refused() {
let mut d = document();
// A zigzag of more straight sides than one 3D effect's graphics may draw.
let mut b = BezPath::new();
b.move_to((0.0, 0.0));
for i in 1..=MAX_ELEMENTS {
b.line_to((i as f64 * 0.001, (i % 2) as f64));
}
b.close_path();
let dense = Node::path(NodeId(0), PathData::from_bezpath(&b), Appearance::basic(Paint::solid(RED), Paint::None, 0.0));
d.symbols.push(Symbol { dynamic: false, name: "Dense".into(), art: Arc::new(dense) });
for id in [CLASSIC_EXTRUDE, CLASSIC_REVOLVE] {
let p = crate::merged_params(id, &json!({"mapArt": [{"surface": 1, "symbol": "Dense"}]}));
let e = validate_three_d_in(Some(&d), &object(id, json!({})), id, &p).unwrap_err();
assert!(e.contains("too complex"), "{id}: {e}");
}
// On a fill, as on the object.
let plain = square(7, Rect::new(0.0, 0.0, 100.0, 100.0), Color::rgb(0.5, 0.5, 0.5));
let p = crate::merged_params(CLASSIC_REVOLVE, &json!({"mapArt": [{"surface": 1, "symbol": "Dense"}]}));
let e = validate_three_d_at_in(Some(&d), &plain, CLASSIC_REVOLVE, &p, (Some(0), 0)).unwrap_err();
assert!(e.contains("too complex"), "{e}");
}
#[test]
fn a_mapped_symbol_whose_curves_cut_into_too_many_pieces_is_refused() {
let mut d = document();
// Large circles: a few curves each, but many straight pieces once they are cut.
let loops = |name: &str, count: usize| {
let mut b = BezPath::new();
for k in 0..count {
let r = 1e5;
let circle = vectorcraft_geom::kurbo::Circle::new((k as f64 * 2.1 * r, 0.0), r);
b.extend(vectorcraft_geom::kurbo::Shape::path_elements(&circle, 0.1));
}
let art = Node::path(NodeId(0), PathData::from_bezpath(&b), Appearance::basic(Paint::solid(RED), Paint::None, 0.0));
Symbol { dynamic: false, name: name.into(), art: Arc::new(art) }
};
d.symbols.push(loops("Loop", 1));
d.symbols.push(loops("Loops", 400));
let check = |id: &str, surface: usize, symbol: &str| {
let p = crate::merged_params(id, &json!({"mapArt": [{"surface": surface, "symbol": symbol}]}));
validate_three_d_in(Some(&d), &object(id, json!({})), id, &p)
};
// Extrude & Bevel's surface 3 is a wall, and Revolve's surface 1 its side.
for (id, surface) in [(CLASSIC_EXTRUDE, 3), (CLASSIC_REVOLVE, 1)] {
assert_eq!(check(id, surface, "Loop"), Ok(()), "{id}");
let e = check(id, surface, "Loops").unwrap_err();
assert!(e.contains("too complex"), "{id}: {e}");
}
// A cap draws the curves as they are, without cutting them.
assert_eq!(check(CLASSIC_EXTRUDE, 1, "Loops"), Ok(()));
}
#[test]
fn maps_are_set_cleared_and_renamed_with_their_symbols() {
let p = json!({"depth": 20});
let map =
|surface: usize, symbol: &str| SurfaceMap { surface, symbol: symbol.into(), x: 0.0, y: 0.0, scale_x: 100.0, scale_y: 100.0, rotation: 0.0 };
let p = with_surface_map(&p, 4, Some(&map(4, "Mark")));
let p = with_surface_map(&p, 2, Some(&map(2, "Corner")));
let p = with_surface_map(&p, 4, Some(&map(4, "Corner")));
// One map for a surface, in the order of the surfaces; the other parameters stay.
assert_eq!(surface_maps(&p), vec![map(2, "Corner"), map(4, "Corner")]);
assert_eq!(p["depth"], json!(20));
assert_eq!(surface_maps(&with_surface_map(&p, 2, None)), vec![map(4, "Corner")]);
// A file's maps: entries that are not valid and a surface's second map are left out.
let loaded = json!({"mapArt": [{"surface": 1, "symbol": "Mark"}, {"surface": 1, "symbol": "Corner"}, {"surface": 0, "symbol": "Mark"}, 3]});
assert_eq!(surface_maps(&loaded), vec![map(1, "Mark")]);
// Renaming a symbol renames it in the maps of the effects that take them.
let mut n = object(CLASSIC_EXTRUDE, json!({"mapArt": [{"surface": 1, "symbol": "Mark"}]}));
assert_eq!(super::super::graphic_symbols(&n), vec!["Mark".to_string()]);
assert!(super::super::rename_graphic_symbol(&mut n, "Mark", "Logo"));
assert_eq!(surface_maps(&n.appearance.effects[0].params)[0].symbol, "Logo");
// Scale to Fit fills the surface: each side by its own scale when the art is square to it.
assert_eq!(map(1, "Mark").fitting_scales(Rect::new(0.0, 0.0, 10.0, 10.0), (100.0, 50.0)), Some((1000.0, 500.0)));
let turned = SurfaceMap { rotation: 90.0, ..map(1, "Mark") };
assert_eq!(turned.fitting_scales(Rect::new(0.0, 0.0, 10.0, 20.0), (100.0, 50.0)), Some((500.0, 500.0)));
let aslant = SurfaceMap { rotation: 45.0, ..map(1, "Mark") };
let (sx, sy) = aslant.fitting_scales(Rect::new(0.0, 0.0, 10.0, 10.0), (100.0, 50.0)).unwrap();
assert!((sx - sy).abs() < 1e-9 && (sx - 50.0 / (20.0 * 0.5f64.sqrt()) * 100.0).abs() < 1e-6, "{sx} {sy}");
assert_eq!(map(1, "Mark").fitting_scales(Rect::new(0.0, 0.0, 0.0, 10.0), (100.0, 50.0)), None);
}
@@ -0,0 +1,164 @@
//! `cargo run --release -p vectorcraft-engine --example appearance_rows_bench` prints the time three Appearance row edits
//! take with every path of documents of 2,000, 10,000 and 20,000 squares selected, each square with one fill row and one
//! stroke row. For each size it first times the step that keeps the objects whose shown rows the edit wrote, on the same
//! ids, two ways: each id looked up in the list of written objects (a list of ids, and a list of ids with the kind of row,
//! as the commands held them), and each id looked up in a set built from that list. It checks that both ways keep the
//! same ids in the same order. Then it times the whole `appearance.setItem` (`index` 1, `weight` 2),
//! `appearance.duplicateItem` (`index` 0) and `stroke.set` (`item` 1, `weight` 2) commands, each on a fresh copy of the
//! document made before the clock starts.
//! 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. The two lookup
//! ways run in alternating order.
// 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};
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)
}
/// 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` closed 10 pt squares, each with a red fill row and a 1 pt black stroke row, and their ids in paint order.
fn document(n: usize) -> (Document, Vec<NodeId>) {
let mut doc = Document::new(4000.0, 4000.0);
let layer = doc.layers.first().map(|l| l.id);
let mut ids = Vec::with_capacity(n);
for i in 0..n {
let (x, y) = ((i % 200) as f64 * 12.0, (i / 200) 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();
let looks = Appearance::basic(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::solid(Color::BLACK), 1.0);
doc.insert(layer, usize::MAX, Node::path(id, path, looks)).unwrap();
ids.push(id);
}
(doc, ids)
}
/// The ids among `ids` that `wrote` holds, each looked up in the list: the lookup the row edits made.
fn in_list(ids: Vec<NodeId>, wrote: &[NodeId]) -> Vec<NodeId> {
ids.into_iter().filter(|id| wrote.contains(id)).collect()
}
/// [`in_list`] with each id looked up in a set built from `wrote`.
fn in_set(ids: Vec<NodeId>, wrote: &[NodeId]) -> Vec<NodeId> {
let wrote: HashSet<NodeId> = wrote.iter().copied().collect();
ids.into_iter().filter(|id| wrote.contains(id)).collect()
}
/// The ids among `ids` that `edited` holds with either kind of row, each looked up in the list, as `appearance.setItem`
/// did.
fn in_kind_list(ids: Vec<NodeId>, edited: &[(NodeId, bool)]) -> Vec<NodeId> {
ids.into_iter().filter(|id| edited.iter().any(|(e, _)| e == id)).collect()
}
/// [`in_kind_list`] with each id looked up in a set built from the ids of `edited`.
fn in_kind_set(ids: Vec<NodeId>, edited: &[(NodeId, bool)]) -> Vec<NodeId> {
let wrote: HashSet<NodeId> = edited.iter().map(|(id, _)| *id).collect();
ids.into_iter().filter(|id| wrote.contains(id)).collect()
}
fn row(name: &str, ms: f64) {
println!(" {name:<52} {ms:>10.3} ms");
}
/// The medians of `old` and `new` over [`iters`] runs, alternating which goes first; each run filters `ids` `reps` times
/// on copies made before the clock starts and gives the time of one.
fn time_both<W: ?Sized>(ids: &[NodeId], wrote: &W, old: fn(Vec<NodeId>, &W) -> Vec<NodeId>, new: fn(Vec<NodeId>, &W) -> Vec<NodeId>) -> (f64, f64) {
let reps = (200_000 / ids.len()).max(1);
let run = |f: fn(Vec<NodeId>, &W) -> Vec<NodeId>| {
let mut work: Vec<Vec<NodeId>> = (0..reps).map(|_| ids.to_vec()).collect();
ms(|| {
for it in &mut work {
black_box(f(black_box(std::mem::take(it)), wrote));
}
}) / reps as f64
};
let (mut a, mut b) = (vec![], vec![]);
for i in 0..iters() {
if i % 2 == 0 {
a.push(run(old));
b.push(run(new));
} else {
b.push(run(new));
a.push(run(old));
}
}
(median(a), median(b))
}
fn bench(n: usize) {
println!("{n} squares, all selected");
let (doc, ids) = document(n);
// Every object's topmost stroke row was written, as when every selected object takes the edit.
let edited: Vec<(NodeId, bool)> = ids.iter().map(|id| (*id, false)).collect();
// A list missing every other id, so lookups that fail are timed too.
let half: Vec<NodeId> = ids.iter().copied().step_by(2).collect();
for wrote in [&ids, &half] {
assert_eq!(in_list(ids.clone(), wrote), in_set(ids.clone(), wrote), "both ways keep the same ids");
}
assert_eq!(in_kind_list(ids.clone(), &edited), in_kind_set(ids.clone(), &edited), "both ways keep the same ids");
let (old, new) = time_both(&ids, ids.as_slice(), in_list, in_set);
row("keep written ids, every id in the list", old);
row("keep written ids, every id in a set", new);
let (old, new) = time_both(&ids, half.as_slice(), in_list, in_set);
row("keep written ids, half the ids in the list", old);
row("keep written ids, half the ids in a set", new);
let (old, new) = time_both(&ids, edited.as_slice(), in_kind_list, in_kind_set);
row("keep written ids, (id, kind) list", old);
row("keep written ids, (id, kind) set", new);
let all: Vec<u64> = ids.iter().map(|id| id.0).collect();
let commands: [(&str, Value); 3] = [
("appearance.setItem", json!({"ids": all, "index": 1, "weight": 2})),
("appearance.duplicateItem", json!({"ids": all, "index": 0})),
("stroke.set", json!({"ids": all, "item": 1, "weight": 2})),
];
for (cmd, p) in &commands {
let runs = (0..iters())
.map(|_| {
let mut s = Session::new();
s.add_document(doc.clone(), None);
let t = ms(|| drop(black_box(s.execute(cmd, p).unwrap())));
drop(black_box(s));
t
})
.collect();
row(&format!("{cmd}, whole command"), median(runs));
}
}
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);
}
}
+6
View File
@@ -48,6 +48,7 @@ mod info;
pub(crate) mod inline;
mod interactivity;
mod intertwine;
pub mod kinsokusets;
pub(crate) mod layer;
mod layerpanel;
pub mod library;
@@ -335,6 +336,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(textstyles::specs());
v.extend(fonts::specs());
v.extend(compositefonts::specs());
v.extend(kinsokusets::specs());
v.extend(fontfiles::specs());
v.extend(help::specs());
v.extend(toast::specs());
@@ -923,6 +925,10 @@ pub use buildcmds::live_paint_gaps;
/// Control bar enable it when it changes one).
pub use brushsym::reset_transformation_changes;
/// Whether an object is a symbol set (the Symbolism Tools Options' Symbol Set Density applies to
/// the selected ones).
pub use brushsym::is_symbol_set;
/// The Symbols panel's current symbol, as `symbol.list` answers it (the panel reads it on every
/// frame without running the command).
pub use brushsym::current_symbol;
+4 -2
View File
@@ -4,11 +4,12 @@
//! ([`corners`]), the Parametric Shape Tool's shapes ([`shape`]), the Shared Edge Merge Tool's
//! merges with Keep Shared Points Together ([`shared_edge`]), Divide into Dashes, Expand Dashes
//! into Paths, Trim at Crossings ([`trim`]), Smooth Bridge ([`bridge`]), Common Tangents
//! ([`tangents`]) and Tangent Circle
//! ([`tangent_circle`]).
//! ([`tangents`]), Tangent Circle ([`tangent_circle`]) and Add Bounding Rectangle and Add
//! Bounding Circle ([`bounding`]).
//! Its tools, panels and submenu (Object › Plug-ins › Path Precision Tools) are the tools crate's
//! and the UI's.
mod bounding;
mod bridge;
mod corners;
#[cfg(test)]
@@ -188,6 +189,7 @@ pub fn specs() -> Vec<CommandSpec> {
v.extend(bridge::specs());
v.extend(tangent_circle::specs());
v.extend(tangents::specs());
v.extend(bounding::specs());
v
}
@@ -0,0 +1,376 @@
//! Add Bounding Rectangle and Add Bounding Circle: a live rectangle on the selection's geometric
//! bounding box, or the smallest live circle around its outlines. The circle is the geometry crate's
//! ([`enclosing_circle`](vectorcraft_geom::shapes::enclosing_circle)).
use serde_json::{Value, json};
use vectorcraft_doc::{Document, LiveShape, Node, NodeId, NodeKind, SymbolBoxes};
use vectorcraft_geom::kurbo::ParamCurveExtrema;
use vectorcraft_geom::{Affine, CubicBez, FillRule, ParamCurve, PathSeg, Point, Rect, shapes};
use super::super::super::edit::{no_symbol_part, selected_roots_to_transform};
use super::super::super::{CommandSpec, bad, cmd, has_selection, number_or, switch_or};
use crate::sanity::rect_in_range;
use crate::{Result, Session};
#[cfg(test)]
mod tests;
/// Add Bounding Rectangle's command.
pub(crate) const RECTANGLE: &str = "addon.pathtools.boundingRectangle";
/// Add Bounding Circle's command.
pub(crate) const CIRCLE: &str = "addon.pathtools.boundingCircle";
/// How far a curve may stray from the points the circle is fitted to, in points. The circle's
/// radius grows by as much, so it holds the curves themselves.
const FLATNESS: f64 = 0.01;
pub(super) fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"addon.pathtools.boundingRectangle",
"Add Bounding Rectangle",
["Object", "Plug-ins", "Path Precision Tools"],
None,
"{each?: bool (default false: one rectangle around the whole selection; true: one around each selected object), offset?: pt (0 or more; default 0: added on every side)} draw a live rectangle on the geometric bounding box of the selected objects (strokes and effects left out; a path of a compound path selected on its own counts as an object), with the current paint, on top of the current layer or of the isolated group, as other new art; the rectangles are selected; one undo step. An object whose box has no width or no height (a straight horizontal or vertical line) gets no rectangle unless `offset` is more than 0, nor does an object with no bounds (an empty group); with `each` the result's `skipped` counts them. It is an error when no rectangle is left (\"the shape would have no size\" when a rectangle with no size was left out, else \"nothing to enclose\") and when an edge of a rectangle would lie more than 4,000,000 pt from the origin along either axis (\"the shape would reach past the edge of the canvas\"). The menu item Add Bounding Rectangle… opens a dialog with Offset and One per Object (`each`) and a Preview → {id: the first rectangle, ids, skipped?}",
whole_objects,
bounding_rectangle
),
cmd!(
"addon.pathtools.boundingCircle",
"Add Bounding Circle",
["Object", "Plug-ins", "Path Precision Tools"],
None,
"{each?: bool (default false: one circle around the whole selection; true: one around each selected object), offset?: pt (0 or more; default 0: added to the radius)} draw the smallest live circle that holds the outlines of the selected objects (paths and compound paths by their curves, clip groups and sublayers that clip their contents by their clipping paths, other sublayers by their shown objects, images by their corners, type and other objects by the corners of their bounding box; strokes and effects left out; a path of a compound path selected on its own counts as an object), with the radius 0.01 pt larger so it holds the curves themselves, with the current paint, on top of the current layer or of the isolated group, as other new art; the circles are selected; one undo step. An object at a single point gets no circle unless `offset` is more than 0, nor does an object with no outline (an empty group); with `each` the result's `skipped` counts them. It is an error when no circle is left (\"the shape would have no size\" when a circle with no size was left out, else \"nothing to enclose\") and when an edge of a circle's bounding box would lie more than 4,000,000 pt from the origin along either axis (\"the shape would reach past the edge of the canvas\"). The menu item Add Bounding Circle… opens a dialog with Offset and One per Object (`each`) and a Preview → {id: the first circle, ids, skipped?}",
whole_objects,
bounding_circle
),
]
}
/// Enabled with a selection that is not an object of a symbol instance's art, which
/// [`selected_roots_to_transform`] refuses.
fn whole_objects(s: &Session) -> std::result::Result<(), String> {
has_selection(s)?;
no_symbol_part(s)
}
/// The shape a command draws.
#[derive(Clone, Copy, PartialEq)]
enum Kind {
Rectangle,
Circle,
}
fn bounding_rectangle(s: &mut Session, p: &Value) -> Result<Value> {
add(s, p, Kind::Rectangle)
}
fn bounding_circle(s: &mut Session, p: &Value) -> Result<Value> {
add(s, p, Kind::Circle)
}
fn add(s: &mut Session, p: &Value, kind: Kind) -> Result<Value> {
let (c, label) = match kind {
Kind::Rectangle => (RECTANGLE, "Add Bounding Rectangle"),
Kind::Circle => (CIRCLE, "Add Bounding Circle"),
};
let each = switch_or(p, "each", false, c)?;
let offset = number_or(p, "offset", 0.0, c)?;
if !(offset.is_finite() && offset >= 0.0) {
return Err(bad(c, "`offset` must be 0 or more"));
}
// The objects `object.transform` moves: a path of a compound path selected on its own is one.
let roots = selected_roots_to_transform(s)?;
let d = &s.doc()?.doc;
let symbols = d.symbol_boxes();
let groups: Vec<Vec<NodeId>> = if each { roots.iter().map(|id| vec![*id]).collect() } else { vec![roots] };
let mut made: Vec<LiveShape> = vec![];
// Objects that get no shape: no outline, or a shape with no size.
let mut skipped = 0;
let mut no_size = false;
// The shapes share the halvings, so the work stays bounded however many objects are selected.
let splits = split_share(groups.len());
for ids in &groups {
match shape_around(d, &symbols, ids, kind, offset, splits) {
Around::Shape(live) => made.push(live),
Around::NoOutline => skipped += 1,
Around::NoSize => {
skipped += 1;
no_size = true;
}
Around::PastCanvas => return Err(bad(c, "the shape would reach past the edge of the canvas")),
}
}
if made.is_empty() {
return Err(bad(c, if no_size { "the shape would have no size" } else { "nothing to enclose" }));
}
let parent = s.doc()?.target_parent()?;
let look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
let ids = s.edit(label, |d, sel| {
let mut ids = vec![];
for live in made {
let kind = NodeKind::Path { path: live.to_path(), rule: FillRule::NonZero, live: Some(Box::new(live)), clipping: false, guide: false };
let mut n = Node::new(d.alloc_id(), kind);
look.apply(d, &mut n);
ids.push(n.id);
d.insert(parent, usize::MAX, n)?;
}
sel.set(ids.iter().copied());
Ok(ids)
})?;
let first = ids.first().map_or(0, |id| id.0);
let mut out = json!({ "id": first, "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() });
if skipped > 0 {
out["skipped"] = json!(skipped);
}
Ok(out)
}
/// What [`shape_around`] finds.
enum Around {
Shape(LiveShape),
/// The objects have no bounds or no outline.
NoOutline,
/// The rectangle would have no width or no height, or the circle no radius.
NoSize,
/// An edge of the shape would lie more than [`MAX_COORD`](crate::MAX_COORD) from the origin
/// along either axis.
PastCanvas,
}
/// The live rectangle or circle around `ids`, grown by `offset`. A circle halves its curves as
/// `splits` allows.
fn shape_around(d: &Document, symbols: &SymbolBoxes, ids: &[NodeId], kind: Kind, offset: f64, splits: Splits) -> Around {
match kind {
Kind::Rectangle => {
let Some(r) = d.bounds_of_with(ids, false, symbols) else { return Around::NoOutline };
let r = r.inflate(offset, offset);
if !rect_in_range(r) {
return Around::PastCanvas;
}
if r.width() <= 0.0 || r.height() <= 0.0 {
return Around::NoSize;
}
Around::Shape(LiveShape::Rectangle {
w: r.width(),
h: r.height(),
radii: [0.0; 4],
kinds: Default::default(),
radii_relative: false,
xf: Affine::translate(r.origin().to_vec2()),
})
}
Kind::Circle => {
let mut gathered = Gathered::new();
gathered.splits = splits;
for n in ids.iter().filter_map(|id| d.node(*id)) {
outline_points(n, symbols, &mut gathered, 0);
gathered.compact();
}
let Some((center, radius)) = shapes::enclosing_circle(&gathered.points) else { return Around::NoOutline };
if radius + offset <= 0.0 {
return Around::NoSize;
}
let r = radius + FLATNESS + offset;
let b = Rect::new(center.x - r, center.y - r, center.x + r, center.y + r);
if !rect_in_range(b) {
return Around::PastCanvas;
}
Around::Shape(LiveShape::Ellipse { w: b.width(), h: b.height(), pie: (0.0, 360.0), xf: Affine::translate(b.origin().to_vec2()) })
}
}
}
/// Adds to `out` points on the outline of `n`, as its geometric bounds measure it: the points of
/// its paths ([`curve_points`]); the clipping path of a clip group or of a sublayer that clips its
/// contents; the shown contents of a sublayer (a layer that an opened file put inside a group); the
/// corners of an image; and the corners of the geometric bounding box of anything else. A group or
/// layer `depth` levels below the selected object that is nested deeper than a document holds
/// ([`vectorcraft_doc::MAX_DEPTH`]) counts by the corners of its geometric bounding box.
fn outline_points(n: &Node, symbols: &SymbolBoxes, out: &mut Gathered, depth: usize) {
let nests = matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. } | NodeKind::Compound { .. });
if nests && depth >= vectorcraft_doc::MAX_DEPTH {
out.points.extend(n.geometric_bounds_with(symbols).map(corners).into_iter().flatten());
return;
}
match &n.kind {
NodeKind::Path { path, .. } => {
// The anchors count too, so a path of one anchor, which has no segments, is held.
for p in path.subpaths.iter().flat_map(|sp| sp.anchors.iter().map(|a| a.p)) {
out.points.push(p);
out.compact();
}
for seg in path.to_bezpath().segments() {
match seg {
PathSeg::Line(l) => out.points.extend([l.p0, l.p1]),
_ => curve_points(seg.to_cubic(), 0, &mut out.points, &mut out.splits),
}
out.compact();
}
}
NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => {
if let Some(c) = children.first() {
outline_points(c, symbols, out, depth + 1);
}
}
NodeKind::Layer { .. } | NodeKind::Group { .. } | NodeKind::Compound { .. } => {
let layer = matches!(n.kind, NodeKind::Layer { .. });
for c in n.editing_children().iter().filter(|c| c.visible || !layer) {
outline_points(c, symbols, out, depth + 1);
out.compact();
}
}
NodeKind::Image(im) => {
let r = Rect::new(0.0, 0.0, im.width as f64, im.height as f64);
out.points.extend(corners(r).map(|p| im.xf * p));
}
_ => out.points.extend(n.geometric_bounds_with(symbols).map(corners).into_iter().flatten()),
}
}
/// Adds to `out` points whose convex hull, grown by [`FLATNESS`], holds the curve `c`: the ends of
/// pieces whose control points lie within [`FLATNESS`] of their chord, and for pieces still curved
/// after [`MAX_SPLITS`] halvings, or when `splits` allows no more ([`Splits::take`]), the corners of
/// [`held`]. A flat piece that ends where it starts adds its control points too, so a small loop is
/// not taken for a single point. A curve with a point that is not finite adds nothing.
fn curve_points(c: CubicBez, depth: u32, out: &mut Vec<Point>, splits: &mut Splits) {
if ![c.p0, c.p1, c.p2, c.p3].iter().all(|p| p.is_finite()) {
return;
}
let flat = [c.p1, c.p2].iter().all(|p| distance_to_segment(*p, c.p0, c.p3) <= FLATNESS);
if flat {
out.extend([c.p0, c.p3]);
if c.p0 == c.p3 {
out.extend([c.p1, c.p2]);
}
} else if depth >= MAX_SPLITS || !splits.take(depth) {
out.extend(held(c));
} else {
let (a, b) = c.subdivide();
curve_points(a, depth + 1, out, splits);
curve_points(b, depth + 1, out, splits);
}
}
/// The corners of the convex hull of `c`'s control points cut down to `c`'s bounding box. Each of
/// the two holds the curve, so the part they share holds it too. When the cut leaves nothing, which
/// rounding can cause, it gives the box's corners.
fn held(c: CubicBez) -> Vec<Point> {
let b = ParamCurveExtrema::bounding_box(&c);
let mut poly = shapes::convex_hull(vec![c.p0, c.p1, c.p2, c.p3]);
for (x, bound, below) in [(true, b.x0, false), (true, b.x1, true), (false, b.y0, false), (false, b.y1, true)] {
poly = clip(&poly, x, bound, below);
}
if poly.is_empty() { corners(b).to_vec() } else { poly }
}
/// The convex polygon `poly` cut at `bound` on the x axis (`x`) or the y axis: the part at or below
/// `bound` when `below`, else at or above it.
fn clip(poly: &[Point], x: bool, bound: f64, below: bool) -> Vec<Point> {
let v = |p: Point| if x { p.x } else { p.y };
let inside = |p: Point| if below { v(p) <= bound } else { v(p) >= bound };
let mut out = vec![];
for (&a, &b) in poly.iter().zip(poly.iter().cycle().skip(1)) {
if inside(a) {
out.push(a);
}
if inside(a) != inside(b) {
let mut p = a.lerp(b, (bound - v(a)) / (v(b) - v(a)));
if x {
p.x = bound;
} else {
p.y = bound;
}
out.push(p);
}
}
out
}
/// How many halvings [`curve_points`] makes for one command, over every curve it measures, before
/// it halves each further curve [`MIN_SPLITS`] times only; with `each`, every shape gets an equal
/// share ([`split_share`]).
const TOTAL_SPLITS: usize = 1 << 20;
/// How many more halvings [`curve_points`] makes for one command once [`TOTAL_SPLITS`] is used up,
/// each within the first [`MIN_SPLITS`] halvings of a curve; with `each`, shared as
/// [`TOTAL_SPLITS`] is. After that, curves count by [`held`] whole.
const EARLY_SPLITS: usize = 7 << 20;
/// How many times [`curve_points`] halves a curve once [`TOTAL_SPLITS`] is used up: 8 pieces, which
/// keeps the circle fitted to a circle of four curves less than 0.3% larger than that circle.
const MIN_SPLITS: u32 = 3;
/// The halvings [`curve_points`] may still make.
#[derive(Clone, Copy, Debug, PartialEq)]
struct Splits {
/// Halvings at any depth.
any: usize,
/// Halvings within the first [`MIN_SPLITS`] of a curve, once `any` is used up.
early: usize,
}
impl Splits {
/// Takes one halving of a piece `depth` halvings into its curve; false when none is left.
fn take(&mut self, depth: u32) -> bool {
if self.any > 0 {
self.any -= 1;
} else if depth < MIN_SPLITS && self.early > 0 {
self.early -= 1;
} else {
return false;
}
true
}
}
/// The halvings each of `shapes` shapes may make: an equal share of [`TOTAL_SPLITS`] and of
/// [`EARLY_SPLITS`].
fn split_share(shapes: usize) -> Splits {
let n = shapes.max(1);
Splits { any: TOTAL_SPLITS / n, early: EARLY_SPLITS / n }
}
/// How many points [`outline_points`] gathers before it keeps only the corners of their convex hull.
const COMPACT_AT: usize = 1 << 16;
/// Points gathered for a circle, kept down to the corners of their convex hull whenever they grow
/// past `limit`: only the hull decides the circle. The points held stay within about twice the
/// hull's corners, and grow only with the anchors and objects measured and the halvings
/// ([`TOTAL_SPLITS`] and [`EARLY_SPLITS`]).
struct Gathered {
points: Vec<Point>,
limit: usize,
/// The halvings [`curve_points`] may still make (one shape's whole share at first).
splits: Splits,
}
impl Gathered {
fn new() -> Self {
Self { points: vec![], limit: COMPACT_AT, splits: split_share(1) }
}
/// Keeps only the hull's corners once there are more than `limit` points; the next time waits
/// until there are twice as many as the hull has, so each point is sorted a few times at most.
fn compact(&mut self) {
if self.points.len() > self.limit {
self.points = shapes::convex_hull(std::mem::take(&mut self.points));
self.limit = (self.points.len() * 2).max(COMPACT_AT);
}
}
}
/// How many times [`curve_points`] halves a curve at most: up to 1,024 pieces.
const MAX_SPLITS: u32 = 10;
/// The distance from `p` to the segment from `a` to `b`.
fn distance_to_segment(p: Point, a: Point, b: Point) -> f64 {
let ab = b - a;
let len2 = ab.hypot2();
let t = if len2 > 0.0 { ((p - a).dot(ab) / len2).clamp(0.0, 1.0) } else { 0.0 };
(p - (a + ab * t)).hypot()
}
fn corners(r: Rect) -> [Point; 4] {
[Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)]
}
@@ -0,0 +1,557 @@
//! Add Bounding Rectangle and Add Bounding Circle: the box and the smallest circle, the current
//! paint and placement on top of the current layer or the isolated group, `each` and `skipped`,
//! shapes of no size, clip groups and clipping sublayers, paths of compound paths, huge curves and
//! small loops, and the errors that leave the document as it was.
use serde_json::{Value, json};
use vectorcraft_doc::{LiveShape, Node, NodeId, NodeKind};
use vectorcraft_geom::{CubicBez, Point, Rect, Vec2, shapes};
use super::{CIRCLE, COMPACT_AT, Gathered, RECTANGLE, Splits};
use crate::Session;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
s
}
fn node(s: &Session, id: NodeId) -> Node {
s.doc().unwrap().doc.node(id).unwrap().clone()
}
fn id_of(v: &Value) -> NodeId {
NodeId(v["id"].as_u64().unwrap())
}
fn ids_of(v: &Value) -> Vec<NodeId> {
v["ids"].as_array().unwrap().iter().map(|i| NodeId(i.as_u64().unwrap())).collect()
}
fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64) -> NodeId {
id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap())
}
fn undo_len(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
fn object_count(s: &Session) -> usize {
let mut n = 0;
s.doc().unwrap().doc.walk(|_| n += 1);
n
}
/// Whether two rectangles agree to within `tol` on every edge.
fn rect_near(b: Rect, want: Rect, tol: f64) -> bool {
[(b.x0, want.x0), (b.y0, want.y0), (b.x1, want.x1), (b.y1, want.y1)].iter().all(|(a, w)| (a - w).abs() < tol)
}
/// The live shape of `id`.
fn live(s: &Session, id: NodeId) -> LiveShape {
match &node(s, id).kind {
NodeKind::Path { live: Some(live), .. } => live.as_ref().clone(),
other => panic!("not a live shape: {other:?}"),
}
}
/// The geometric bounds of `id`.
fn bounds(s: &Session, id: NodeId) -> Rect {
s.doc().unwrap().doc.bounds_of(&[id], false).unwrap()
}
/// The last child of `parent`, the top of its stacking order.
fn top_of(s: &Session, parent: NodeId) -> NodeId {
node(s, parent).children().unwrap().last().unwrap().id
}
/// Runs `command` with `p` and checks that it fails and leaves the document as it was.
fn refused(s: &mut Session, command: &str, p: Value) -> String {
let (undo, objects) = (undo_len(s), object_count(s));
let e = s.execute(command, &p).unwrap_err().to_string();
assert_eq!((undo_len(s), object_count(s)), (undo, objects), "{p} changed the document");
e
}
/// A live rectangle on the selection's geometric bounding box, strokes left out, with the current
/// paint, on top of the current layer, selected; one undo removes it.
#[test]
fn a_bounding_rectangle_is_the_geometric_box_on_top_of_the_layer() {
let mut s = session();
s.execute("stroke.set", &json!({"weight": 10})).unwrap();
let a = rect(&mut s, 10.0, 20.0, 30.0, 40.0);
let b = id_of(&s.execute("shape.ellipse", &json!({"x": 100, "y": 50, "width": 60, "height": 80})).unwrap());
assert_eq!(node(&s, a).appearance.stroke_width(), 10.0, "the strokes reach past the geometric box");
s.execute("select.none", &json!({})).unwrap();
s.execute("paint.setFill", &json!({"color": "#ff0000"})).unwrap();
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let (before, undo) = (object_count(&s), undo_len(&s));
let out = s.execute(RECTANGLE, &json!({})).unwrap();
let id = id_of(&out);
assert_eq!(ids_of(&out), vec![id]);
assert!(out.get("skipped").is_none(), "{out}");
assert!(matches!(live(&s, id), LiveShape::Rectangle { .. }));
assert!(rect_near(bounds(&s, id), Rect::new(10.0, 20.0, 160.0, 130.0), 1e-9), "{:?}", bounds(&s, id));
let layer = s.doc().unwrap().current_layer().unwrap();
assert_eq!(top_of(&s, layer), id);
assert_eq!(s.doc().unwrap().selection.objects, vec![id]);
assert_eq!(undo_len(&s), undo + 1);
assert_eq!(object_count(&s), before + 1);
// The current paint, as a shape drawn now gets it.
let reference = rect(&mut s, 300.0, 300.0, 5.0, 5.0);
let (n, r) = (node(&s, id), node(&s, reference));
assert_eq!((n.appearance.fill_paint(), n.appearance.stroke_paint()), (r.appearance.fill_paint(), r.appearance.stroke_paint()));
assert_eq!(n.appearance.stroke_width(), r.appearance.stroke_width());
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(object_count(&s), before);
}
/// A bounding circle around a right triangle stands on its hypotenuse; around a circle it is that
/// circle, grown by at most the flattening allowance; `offset` grows the radius, and a rectangle's
/// sides, by that much.
#[test]
fn a_bounding_circle_is_the_smallest_circle_around_the_outlines() {
let mut s = session();
let tri =
id_of(&s.execute("path.create", &json!({"anchors": [{"x": 0, "y": 0}, {"x": 80, "y": 0}, {"x": 0, "y": 60}], "closed": true})).unwrap());
s.execute("select.set", &json!({"ids": [tri.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
match live(&s, c) {
LiveShape::Ellipse { w, h, pie, .. } => {
assert!((w - 100.02).abs() < 1e-9 && (h - 100.02).abs() < 1e-9 && pie == (0.0, 360.0), "{w} {h}");
}
other => panic!("not a circle: {other:?}"),
}
assert!(rect_near(bounds(&s, c), Rect::new(-10.01, -20.01, 90.01, 80.01), 1e-9), "{:?}", bounds(&s, c));
// A circle of radius 50 and a dot inside it: the bounding circle is the circle itself.
let round = id_of(&s.execute("shape.ellipse", &json!({"x": 200, "y": 200, "width": 100, "height": 100})).unwrap());
let dot = rect(&mut s, 240.0, 240.0, 2.0, 2.0);
s.execute("select.set", &json!({"ids": [round.0, dot.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({"offset": 5})).unwrap());
let got = bounds(&s, c);
let want = Rect::new(195.0, 195.0, 305.0, 305.0);
assert!(rect_near(got, want, 0.03), "{got:?}");
assert!(got.x0 <= want.x0 + 1e-9 && got.x1 >= want.x1 - 1e-9 && got.y0 <= want.y0 + 1e-9 && got.y1 >= want.y1 - 1e-9, "{got:?}");
s.execute("select.set", &json!({"ids": [tri.0]})).unwrap();
let r = id_of(&s.execute(RECTANGLE, &json!({"offset": 4})).unwrap());
assert!(rect_near(bounds(&s, r), Rect::new(-4.0, -4.0, 84.0, 64.0), 1e-9));
}
/// A shape with no size is not drawn: a straight horizontal line gets no rectangle and a path of
/// one anchor no circle, unless `offset` gives them room; with `each` they are counted in
/// `skipped`, and alone they are an error.
#[test]
fn shapes_of_no_size_are_skipped_unless_offset_gives_them_room() {
let mut s = session();
let line = id_of(&s.execute("path.create", &json!({"anchors": [{"x": 10, "y": 50}, {"x": 90, "y": 50}]})).unwrap());
let lone = id_of(&s.execute("path.create", &json!({"anchors": [{"x": 50, "y": 70}]})).unwrap());
let box_ = rect(&mut s, 200.0, 200.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [line.0]})).unwrap();
assert!(refused(&mut s, RECTANGLE, json!({})).contains("the shape would have no size"));
let r = id_of(&s.execute(RECTANGLE, &json!({"offset": 2})).unwrap());
assert!(rect_near(bounds(&s, r), Rect::new(8.0, 48.0, 92.0, 52.0), 1e-9), "{:?}", bounds(&s, r));
// The line has length, so its circle has size.
s.execute("select.set", &json!({"ids": [line.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
assert!(rect_near(bounds(&s, c), Rect::new(9.99, 9.99, 90.01, 90.01), 1e-9), "{:?}", bounds(&s, c));
s.execute("select.set", &json!({"ids": [lone.0]})).unwrap();
assert!(refused(&mut s, CIRCLE, json!({})).contains("the shape would have no size"));
let c = id_of(&s.execute(CIRCLE, &json!({"offset": 3})).unwrap());
assert!(rect_near(bounds(&s, c), Rect::new(46.99, 66.99, 53.01, 73.01), 1e-9), "{:?}", bounds(&s, c));
s.execute("select.set", &json!({"ids": [line.0, lone.0, box_.0]})).unwrap();
let out = s.execute(RECTANGLE, &json!({"each": true})).unwrap();
assert_eq!((ids_of(&out).len(), out["skipped"].as_u64()), (1, Some(2)), "{out}");
assert!(rect_near(bounds(&s, id_of(&out)), Rect::new(200.0, 200.0, 210.0, 210.0), 1e-9));
s.execute("select.set", &json!({"ids": [line.0, lone.0, box_.0]})).unwrap();
let out = s.execute(CIRCLE, &json!({"each": true})).unwrap();
assert_eq!((ids_of(&out).len(), out["skipped"].as_u64()), (2, Some(1)), "{out}");
}
/// With `each`, every selected object gets a shape of its own, all in one undo step, on top of the
/// layer in the selection's stacking order, and the new shapes are selected.
#[test]
fn each_draws_one_shape_around_each_object() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
let b = rect(&mut s, 100.0, 0.0, 20.0, 30.0);
s.execute("select.set", &json!({"ids": [b.0, a.0]})).unwrap();
let undo = undo_len(&s);
let out = s.execute(RECTANGLE, &json!({"each": true})).unwrap();
let ids = ids_of(&out);
assert_eq!(ids.len(), 2);
assert!(rect_near(bounds(&s, ids[0]), Rect::new(0.0, 0.0, 10.0, 10.0), 1e-9));
assert!(rect_near(bounds(&s, ids[1]), Rect::new(100.0, 0.0, 120.0, 30.0), 1e-9));
let layer = s.doc().unwrap().current_layer().unwrap();
let order: Vec<NodeId> = node(&s, layer).children().unwrap().iter().map(|n| n.id).collect();
assert_eq!(order, vec![a, b, ids[0], ids[1]]);
assert_eq!(s.doc().unwrap().selection.objects.len(), 2);
assert_eq!(undo_len(&s), undo + 1);
}
/// An object with no outline (an empty group) gets no shape and the result counts it; with only
/// such objects selected the command draws nothing.
#[test]
fn each_counts_the_objects_without_an_outline() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
let empty = s
.edit("Group", |d, _| {
let id = d.alloc_id();
d.insert(d.default_layer(), 0, Node::group(id, vec![]))?;
Ok(id)
})
.unwrap();
s.execute("select.set", &json!({"ids": [a.0, empty.0]})).unwrap();
let out = s.execute(CIRCLE, &json!({"each": true})).unwrap();
assert_eq!((ids_of(&out).len(), out["skipped"].as_u64()), (1, Some(1)), "{out}");
s.execute("select.set", &json!({"ids": [a.0, empty.0]})).unwrap();
let out = s.execute(CIRCLE, &json!({})).unwrap();
assert!(out.get("skipped").is_none(), "{out}");
s.execute("select.set", &json!({"ids": [empty.0]})).unwrap();
assert!(refused(&mut s, RECTANGLE, json!({"each": true})).contains("nothing to enclose"));
}
/// Curves over a hundred thousand points across are held by their circle: every point along the
/// curves is inside the circle, whose radius is the 0.01 pt allowance larger than the circle around
/// the flattened points. The farthest point of the lopsided arc lies between two flattened points,
/// about 0.001 pt outside the circle around them, so it needs that allowance.
#[test]
fn the_circle_holds_huge_curves() {
let mut s = session();
let d = "M 0 0 C 0 -90000 120000 -90000 120000 0 C 60000 40000 30000 70000 0 0 Z";
let blob = id_of(&s.execute("path.create", &json!({"d": d})).unwrap());
let arc = id_of(&s.execute("path.create", &json!({"d": "M 0 0 C 20 400 380 500 400 0"})).unwrap());
for big in [blob, arc] {
s.execute("select.set", &json!({"ids": [big.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
let LiveShape::Ellipse { w, xf, .. } = live(&s, c) else { panic!("not a circle") };
let (center, r) = (xf * Point::new(w / 2.0, w / 2.0), w / 2.0);
let path = node(&s, big).path_data().unwrap().to_bezpath();
let mut farthest: f64 = 0.0;
for seg in path.segments() {
for i in 0..=4000 {
let p = vectorcraft_geom::ParamCurve::eval(&seg, f64::from(i) / 4000.0);
farthest = farthest.max(p.distance(center));
}
}
assert!(farthest <= r + 1e-6, "a point {farthest} from the center is outside the circle of radius {r}");
}
}
/// Clip groups count by their clipping paths; for art inside one, the shape goes on top of the
/// current layer, never into the clip group.
#[test]
fn clip_groups_count_by_their_clipping_paths() {
let mut s = session();
let art = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
let clip = id_of(&s.execute("shape.ellipse", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap());
s.execute("select.set", &json!({"ids": [art.0, clip.0]})).unwrap();
let group = id_of(&s.execute("object.clippingMask.make", &json!({})).unwrap());
s.execute("select.set", &json!({"ids": [group.0]})).unwrap();
let id = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
let b = bounds(&s, id);
assert!((b.width() / 2.0 - 25.01).abs() < 0.03 && b.center().distance(Point::new(35.0, 35.0)) < 0.03, "{b:?}");
let layer = s.doc().unwrap().current_layer().unwrap();
assert_eq!(s.doc().unwrap().doc.parent_of(id), Some(layer));
s.execute("select.set", &json!({"ids": [clip.0]})).unwrap();
let id = id_of(&s.execute(RECTANGLE, &json!({})).unwrap());
assert_eq!(s.doc().unwrap().doc.parent_of(id), Some(layer));
assert!(rect_near(bounds(&s, id), Rect::new(10.0, 10.0, 60.0, 60.0), 1e-6));
}
/// A sublayer that clips its contents counts by its clipping path, and the hidden objects of a
/// sublayer are left out; a sublayer inside a selected group (as an opened file can put one there)
/// counts the same way.
#[test]
fn sublayers_count_by_their_clipping_path_and_shown_art() {
let mut s = session();
let top = s.doc().unwrap().current_layer().unwrap();
let sub = id_of(&s.execute("layer.newSublayer", &json!({"parent": top.0})).unwrap());
s.execute("layer.setCurrent", &json!({"id": sub.0})).unwrap();
let art = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
let hidden = rect(&mut s, 300.0, 300.0, 10.0, 10.0);
assert_eq!(s.doc().unwrap().doc.parent_of(art), Some(sub), "the art is in the sublayer");
s.execute("select.set", &json!({"ids": [hidden.0]})).unwrap();
s.execute("object.hide", &json!({})).unwrap();
let d = &s.doc().unwrap().doc;
let (sub_node, symbols) = (d.node(sub).unwrap().clone(), d.symbol_boxes());
let mut g = Gathered::new();
super::outline_points(&sub_node, &symbols, &mut g, 0);
let (center, r) = shapes::enclosing_circle(&g.points).unwrap();
assert!(center.distance(Point::new(50.0, 50.0)) < 1e-9 && (r - 50.0 * 2f64.sqrt()).abs() < 1e-9, "{center:?} {r}");
// The top object of the sublayer becomes its clipping path.
s.execute("select.none", &json!({})).unwrap();
let clip = rect(&mut s, 20.0, 20.0, 10.0, 10.0);
assert_eq!(s.doc().unwrap().doc.parent_of(clip), Some(sub));
s.execute("select.none", &json!({})).unwrap();
assert!(s.execute("layer.clippingMask.toggle", &json!({"id": sub.0})).unwrap()["clip"].as_bool().unwrap());
let d = &s.doc().unwrap().doc;
let sub_node = d.node(sub).unwrap().clone();
let mut g = Gathered::new();
super::outline_points(&sub_node, &d.symbol_boxes(), &mut g, 0);
let (center, r) = shapes::enclosing_circle(&g.points).unwrap();
assert!(center.distance(Point::new(25.0, 25.0)) < 1e-9 && (r - 5.0 * 2f64.sqrt()).abs() < 1e-9, "{center:?} {r}");
let group = s
.edit("Group", |d, _| {
let layer = d.remove(sub)?;
let id = d.alloc_id();
d.insert(Some(top), usize::MAX, Node::group(id, vec![layer]))?;
Ok(id)
})
.unwrap();
s.execute("select.set", &json!({"ids": [group.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
let b = bounds(&s, c);
assert!(b.center().distance(Point::new(25.0, 25.0)) < 1e-9 && (b.width() / 2.0 - (5.0 * 2f64.sqrt() + 0.01)).abs() < 1e-9, "{b:?}");
}
/// A path of a compound path selected on its own is an object, as `object.transform` moves it:
/// the shape goes around that path only, and with `each` each selected path gets a shape. The
/// compound path selected whole is one object.
#[test]
fn a_path_of_a_compound_path_selected_on_its_own_is_an_object() {
let mut s = session();
let a = rect(&mut s, 100.0, 100.0, 10.0, 10.0);
let b = rect(&mut s, 120.0, 100.0, 10.0, 20.0);
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let compound = id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap());
let members: Vec<NodeId> = node(&s, compound).children().unwrap().iter().map(|n| n.id).collect();
assert_eq!(members.len(), 2);
for kind in [RECTANGLE, CIRCLE] {
s.execute("select.set", &json!({"ids": [members[0].0]})).unwrap();
let id = id_of(&s.execute(kind, &json!({})).unwrap());
let (got, want) = (bounds(&s, id), bounds(&s, members[0]));
if kind == RECTANGLE {
assert!(rect_near(got, want, 1e-9), "{got:?} on {want:?}");
} else {
let d = want.width().hypot(want.height()) + 0.02;
assert!(got.center().distance(want.center()) < 1e-9 && (got.width() - d).abs() < 1e-9, "{got:?} around {want:?}");
}
s.execute("select.set", &json!({"ids": [members[0].0, members[1].0]})).unwrap();
assert_eq!(ids_of(&s.execute(kind, &json!({"each": true})).unwrap()).len(), 2, "{kind}");
s.execute("select.set", &json!({"ids": [compound.0]})).unwrap();
assert_eq!(ids_of(&s.execute(kind, &json!({"each": true})).unwrap()).len(), 1, "{kind}");
}
}
/// A small closed curve whose handles lie within the 0.01 pt allowance of its one anchor is not a
/// single point: it gets a circle.
#[test]
fn a_small_loop_gets_a_circle() {
let mut s = session();
let lp = id_of(&s.execute("path.create", &json!({"d": "M 0 0 C 0.005 0 0 0.005 0 0"})).unwrap());
s.execute("select.set", &json!({"ids": [lp.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
let LiveShape::Ellipse { w, .. } = live(&s, c) else { panic!("not a circle") };
assert!(w > 0.02, "{w}");
}
/// Once the command has used up both kinds of halvings, a curve counts by its control points' hull
/// cut down to its bounding box: the points stay inside both and reach no farther than the curve
/// along either axis, while its handles may.
#[test]
fn a_curve_past_the_halvings_counts_by_its_hull_inside_its_bounding_box() {
// With nothing left, `curve_points` takes no halving, so `none` stays as it is.
let mut none = Splits { any: 0, early: 0 };
let c = CubicBez::new((0.0, 0.0), (20.0, 400.0), (380.0, 500.0), (400.0, 0.0));
let b = vectorcraft_geom::kurbo::ParamCurveExtrema::bounding_box(&c);
let mut out = vec![];
super::curve_points(c, 0, &mut out, &mut none);
assert!(out.len() >= 4 && out.iter().all(|p| b.inflate(1e-9, 1e-9).contains(*p)), "{out:?} in {b:?}");
assert!(out.iter().any(|p| (p.y - b.y1).abs() < 1e-9), "the curve's lowest point is reached: {out:?}");
let (center, r) = shapes::enclosing_circle(&out).unwrap();
for i in 0..=1000 {
let p = vectorcraft_geom::ParamCurve::eval(&c, f64::from(i) / 1000.0);
assert!(p.distance(center) <= r + 1e-9, "{p:?} outside");
}
// The handle at x = 4,000,000 stays out: the curve reaches x = 16,000,000 / 9.
let reach = CubicBez::new((0.0, 0.0), (4.0e6, 0.0), (0.0, 0.0), (0.0, 0.0));
out.clear();
super::curve_points(reach, 0, &mut out, &mut none);
let far = out.iter().map(|p| p.x).fold(0.0, f64::max);
assert!((far - 16.0e6 / 9.0).abs() < 1e-6, "{far}");
out.clear();
let mut splits = Splits { any: 3, early: 0 };
super::curve_points(c, 0, &mut out, &mut splits);
assert_eq!(splits, Splits { any: 0, early: 0 });
assert!(out.len() > 4, "{out:?}");
}
/// The circle fitted to a circle of four curves: less than 0.3% larger with only the early halvings
/// left, and up to about 14% larger by the curves' hulls once those are used up too.
#[test]
fn a_circle_measured_past_the_halvings_stays_close() {
let fitted = |mut splits: Splits| {
let circle = shapes::ellipse(Rect::new(-100.0, -100.0, 100.0, 100.0)).to_bezpath();
let mut out = vec![];
for seg in circle.segments() {
super::curve_points(seg.to_cubic(), 0, &mut out, &mut splits);
}
shapes::enclosing_circle(&out).unwrap()
};
let (center, r) = fitted(Splits { any: 0, early: 1000 });
assert!(center.to_vec2().hypot() < 0.1 && (100.0..100.3).contains(&r), "{center:?} {r}");
let (_, r) = fitted(Splits { any: 0, early: 0 });
assert!((110.0..115.0).contains(&r), "{r}");
}
/// Past the halvings at any depth, only the first [`super::MIN_SPLITS`] halvings of a curve take
/// from the early ones; with `each`, every shape gets an equal share of both.
#[test]
fn early_halvings_are_taken_near_the_start_of_a_curve_and_shared() {
let mut s = Splits { any: 1, early: 1 };
assert!(s.take(super::MIN_SPLITS + 1));
assert!(!s.take(super::MIN_SPLITS));
assert!(s.take(0));
assert!(!s.take(0));
let whole = Splits { any: super::TOTAL_SPLITS, early: super::EARLY_SPLITS };
assert_eq!(super::split_share(0), whole);
assert_eq!(super::split_share(1), whole);
assert_eq!(super::split_share(4), Splits { any: super::TOTAL_SPLITS / 4, early: super::EARLY_SPLITS / 4 });
}
/// In an isolated group the shape goes on top of the group's art; in an isolated compound path it
/// goes beside the compound path, never into it.
#[test]
fn shapes_go_into_an_isolated_group_but_not_an_isolated_compound_path() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
let b = rect(&mut s, 20.0, 0.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let group = id_of(&s.execute("object.group", &json!({})).unwrap());
s.execute("object.isolate", &json!({"id": group.0})).unwrap();
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let id = id_of(&s.execute(RECTANGLE, &json!({})).unwrap());
assert_eq!(s.doc().unwrap().doc.parent_of(id), Some(group));
assert_eq!(top_of(&s, group), id);
s.execute("object.exitIsolation", &json!({})).unwrap();
let c = rect(&mut s, 100.0, 100.0, 10.0, 10.0);
let e = rect(&mut s, 120.0, 100.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [c.0, e.0]})).unwrap();
let compound = id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap());
s.execute("object.isolate", &json!({"id": compound.0})).unwrap();
let members: Vec<u64> = node(&s, compound).children().unwrap().iter().map(|n| n.id.0).collect();
s.execute("select.set", &json!({"ids": members})).unwrap();
let id = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
let d = &s.doc().unwrap().doc;
assert_ne!(d.parent_of(id), Some(compound), "the circle does not join the compound path");
assert_eq!(d.parent_of(id), d.parent_of(compound));
assert_eq!(node(&s, compound).children().unwrap().len(), 2);
}
/// An offset or each that is not one the commands take is an error, and nothing is drawn; with
/// nothing selected the commands are not available.
#[test]
fn bad_params_and_an_empty_selection_draw_nothing() {
let mut s = session();
assert!(s.execute(RECTANGLE, &json!({})).is_err(), "nothing selected");
assert!(s.execute(CIRCLE, &json!({})).is_err(), "nothing selected");
let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
for command in [RECTANGLE, CIRCLE] {
for p in [json!({"offset": -1}), json!({"offset": "5"}), json!({"each": "yes"})] {
refused(&mut s, command, p);
}
assert!(refused(&mut s, command, json!({"offset": -1})).contains("`offset` must be 0 or more"));
}
}
/// An offset that would put an edge of the shape more than 4,000,000 pt from the origin along
/// either axis is an error that names the canvas edge, and nothing is drawn; the largest offsets
/// that stay inside are drawn, for the rectangle and for the circle.
#[test]
fn an_offset_past_the_canvas_edge_draws_nothing() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
for command in [RECTANGLE, CIRCLE] {
for offset in [1e308, 4.0e6] {
let e = refused(&mut s, command, json!({ "offset": offset }));
assert!(e.contains("the shape would reach past the edge of the canvas"), "{command} {offset}: {e}");
}
}
let r = id_of(&s.execute(RECTANGLE, &json!({"offset": 3.99e6})).unwrap());
assert!(rect_near(bounds(&s, r), Rect::new(-3.99e6, -3.99e6, 3.99e6 + 10.0, 3.99e6 + 10.0), 1e-3));
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({"offset": 3.99e6})).unwrap());
// The circle around the square from (0, 0) to (10, 10), 0.01 pt larger, then the offset.
let radius = 50.0f64.sqrt() + 0.01 + 3.99e6;
assert!(rect_near(bounds(&s, c), Rect::new(5.0 - radius, 5.0 - radius, 5.0 + radius, 5.0 + radius), 1e-3));
}
/// The limit holds along each axis on its own: a shape whose right edge would pass 4,000,000 pt is
/// refused although its other edges, and its distance along the other axis, are small.
#[test]
fn one_edge_past_the_canvas_edge_is_enough_to_refuse() {
let mut s = session();
let a = rect(&mut s, 3_999_980.0, 0.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
for command in [RECTANGLE, CIRCLE] {
let e = refused(&mut s, command, json!({"offset": 20}));
assert!(e.contains("the shape would reach past the edge of the canvas"), "{command}: {e}");
}
assert!(s.execute(RECTANGLE, &json!({"offset": 5})).is_ok(), "the right edge at 3,999,995 pt is inside");
}
/// A large circle close to the canvas edge, whose arcs stay curved after the most halvings, gets a
/// circle within 0.05 pt of the farthest point of its curves, which stays inside the edge.
#[test]
fn a_large_circle_near_the_canvas_edge_gets_a_close_circle() {
let mut s = session();
let e = id_of(&s.execute("shape.ellipse", &json!({"x": 3_799_950.0, "y": 0.0, "width": 200_000.0, "height": 200_000.0})).unwrap());
s.execute("select.set", &json!({"ids": [e.0]})).unwrap();
let c = id_of(&s.execute(CIRCLE, &json!({})).unwrap());
let LiveShape::Ellipse { w, xf, .. } = live(&s, c) else { panic!("not a circle") };
let center = xf * Point::new(w / 2.0, w / 2.0);
let mut farthest: f64 = 0.0;
for seg in node(&s, e).path_data().unwrap().to_bezpath().segments() {
for i in 0..=4000 {
farthest = farthest.max(vectorcraft_geom::ParamCurve::eval(&seg, f64::from(i) / 4000.0).distance(center));
}
}
assert!(w / 2.0 >= farthest && w / 2.0 < farthest + 0.05, "radius {} for curves reaching {farthest}", w / 2.0);
}
/// The commands are dimmed while an object of a symbol instance's art is selected, which they
/// refuse, and available again once it is not.
#[test]
fn a_selected_symbol_part_dims_the_commands() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
let enabled = |s: &Session, id: &str| (crate::find_command(id).unwrap().enabled)(s);
for command in [RECTANGLE, CIRCLE] {
assert!(enabled(&s, command).is_ok(), "{command}");
}
s.doc_mut().unwrap().selection.symbol_part = Some(vectorcraft_doc::SymbolPart { instance: a, path: vec![0] });
for command in [RECTANGLE, CIRCLE] {
assert!(enabled(&s, command).is_err(), "{command} with a symbol part selected");
}
s.doc_mut().unwrap().selection.symbol_part = None;
assert!(enabled(&s, RECTANGLE).is_ok());
}
/// Many points keep only their hull's corners, and the circle around them is the one around all
/// of the points.
#[test]
fn gathered_points_keep_their_hull_and_circle() {
let mut g = Gathered::new();
let c = Point::new(500.0, 300.0);
for i in 0..200_000 {
let angle = f64::from(i) * 0.618;
let r = if i % 1000 == 0 { 250.0 } else { f64::from(i % 200) };
g.points.push(c + Vec2::from_angle(angle) * r);
g.compact();
}
assert!(g.points.len() <= COMPACT_AT + 1, "{} points kept", g.points.len());
let (center, radius) = shapes::enclosing_circle(&g.points).unwrap();
assert!(center.distance(c) < 1e-6 && (radius - 250.0).abs() < 1e-6, "{center:?} {radius}");
}
@@ -31,7 +31,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
"Common Tangents",
["Object", "Plug-ins", "Path Precision Tools"],
None,
"{tangents?: \"external\" (both paths on the same side of each line) | \"internal\" (the lines that run between them) | \"all\" (\"all\"), centerline?: bool (false: true also adds the line joining the two centers, an ellipse's center or a path's center of area), ids?: [id, id] (default: the selection)} add the common tangent lines of two convex closed paths as separate open paths, each from where it touches the first path to where it touches the second (the whole stretch where a straight side lies along it), stroked with the current stroke color and weight (black when the stroke is None) and unfilled, directly above the upper of the two, as one undo step; the new lines are selected. An ellipse drawn with the Ellipse tool, turned or scaled, is measured as an exact ellipse; any other path must be closed, have one outline, bend the same way all around and have at most 10000 segments. Separate paths have two external and two internal tangents; overlapping paths only external ones; one path inside the other has none. Paths that touch, from outside or from inside, share one tangent there instead: a line centered on the point where they touch and as long as the narrower path is wide along it; paths that meet at a corner or along a shared stretch of outline get one such line, at the middle of the directions that touch both. Paths count as touching when the gap between them is less than a billionth of the larger of their sizes and the distance between their centers. One of the two may be a point (a path of one anchor): the lines then run from the point to where they touch the path, two when the point lies outside it (one that lies along a straight side covers the whole side), one when the point lies on its outline, that is, less than the touching tolerance from it, with the point's distance from the path's center in place of the distance between centers (centered on the point and as long as the path is wide along it, or the whole straight side the point lies on), none when it lies inside; every `tangents` value gives the same lines, counted as internal when `tangents` is \"internal\" and as external otherwise, and the centerline runs from the point to the path's center; two points are refused. When there is no tangent of the kind asked for, nothing changes and the result has a `warning` → {ids, external, internal, centerline (its id or null), warning?}",
"{tangents?: \"external\" (both paths on the same side of each line) | \"internal\" (the lines that run between them) | \"all\" (\"all\"), centerline?: bool (false: true also adds the line joining the two centers, an ellipse's center or a path's center of area), ids?: [id, id] (default: the selection)} add the common tangent lines of two convex closed paths as separate open paths, each from where it touches the first path to where it touches the second (the whole stretch where a straight side lies along it), stroked with the current stroke color and weight (black when the stroke is None) and unfilled, directly above the upper of the two, as one undo step; the new lines are selected. An ellipse drawn with the Ellipse tool, turned or scaled, is measured as an exact ellipse; any other path must be closed, have one outline, bend the same way all around and have at most 10000 segments. Separate paths have two external and two internal tangents; overlapping paths only external ones; one path inside the other has none. Paths that touch, from outside or from inside, share one tangent there instead: a line centered on the point where they touch and as long as the narrower path is wide along it; paths that meet at a corner or along a shared stretch of outline get one such line, at the middle of the directions that touch both. Paths count as touching when the gap between them is at most a billionth of the larger of their sizes and the distance between their centers. One of the two may be a point (a path of one anchor): the lines then run from the point to where they touch the path, two when the point lies outside it (one that lies along a straight side covers the whole side), one when the point lies on its outline, that is, at most the touching tolerance from it, with the point's distance from the path's center in place of the distance between centers (centered on the point and as long as the path is wide along it, or the whole straight side the point lies on), none when it lies inside; every `tangents` value gives the same lines, counted as internal when `tangents` is \"internal\" and as external otherwise, and the centerline runs from the point to the path's center; two points are refused. When there is no tangent of the kind asked for, nothing changes and the result has a `warning` → {ids, external, internal, centerline (its id or null), warning?}",
has_selection,
common_tangents
)]
@@ -7,7 +7,7 @@ use serde_json::{Value, json};
use vectorcraft_doc::{LiveCorners, LiveShape, NodeId};
use vectorcraft_geom::shapes::CornerKind;
use vectorcraft_geom::{AnchorKind, PathData, Point, SubPath};
use vectorcraft_tools::{PointerEvent, PointerKind};
use vectorcraft_tools::{Action, Overlay, PointerEvent, PointerKind};
use crate::{Session, ViewInfo};
@@ -1055,6 +1055,37 @@ fn the_slide_tool_previews_and_commits_one_step() {
assert_eq!(at(&s), Point::new(200.0, 100.0));
}
/// The Tangent Circle tool's release draws the circle and then tells the tool, which forgets the
/// first segment. When the command fails the session does not tell the tool, so the first segment
/// stays picked: the circle shows again over the second segment. The second click draws it in one
/// undo step.
#[test]
fn the_tangent_circle_tool_keeps_its_first_segment_when_drawing_fails() {
let mut s = session();
line(&mut s, &[(100.0, 100.0), (300.0, 100.0)], false);
line(&mut s, &[(100.0, 140.0), (300.0, 140.0)], false);
let view = ViewInfo { smart_guides: false, ..ViewInfo::default() };
s.select_tool("tangentCircle", view).unwrap();
let at = |s: &mut Session, kind, x, y| s.pointer(&PointerEvent::new(kind, x, y), view);
let shown = |s: &mut Session| {
at(s, PointerKind::Move, 200.0, 139.0).unwrap();
s.overlays(view).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text.starts_with("R: 20.00")))
};
at(&mut s, PointerKind::Down, 150.0, 101.0).unwrap();
at(&mut s, PointerKind::Up, 150.0, 101.0).unwrap();
assert!(shown(&mut s), "the first segment is picked");
// The tool's release with a command that fails: three points on one line.
let n = steps(&s);
let failing = Action::Exec("shape.circleThroughPoints".into(), json!({"points": [[0, 0], [10, 0], [20, 0]]}));
assert!(s.apply_actions(vec![failing, Action::Notify("tangentCircle.drawn".into())]).is_err());
assert_eq!(steps(&s), n, "nothing drawn");
assert!(shown(&mut s), "the first segment is still picked");
at(&mut s, PointerKind::Down, 200.0, 139.0).unwrap();
at(&mut s, PointerKind::Up, 200.0, 139.0).unwrap();
assert_eq!(steps(&s), n + 1, "one undo step");
assert!(!shown(&mut s), "the first segment is forgotten once the circle is drawn");
}
fn ids(v: &Value) -> Vec<NodeId> {
v["ids"].as_array().unwrap().iter().map(|i| NodeId(i.as_u64().unwrap())).collect()
}
+5 -4
View File
@@ -772,7 +772,7 @@ fn edit_items_writing_then(
// The objects whose rows `f` edited: on type, no row means its characters.
let mut rows = Vec::new();
// The objects where `f` wrote the topmost visible row of its kind.
let mut wrote = Vec::new();
let mut wrote = HashSet::new();
// The row of each object `f` wrote: its index, else the topmost row of the kind.
let mut written = Vec::new();
for (id, item) in ids.iter().zip(&per) {
@@ -785,7 +785,7 @@ fn edit_items_writing_then(
rows.push(*id);
}
if index.is_none_or(|i| is_top_shown(n, i)) {
wrote.push(*id);
wrote.insert(*id);
}
written.extend(index.or_else(|| n.appearance.items.iter().rposition(|it| it.is_fill() == fill)).map(|at| (*id, at)));
}
@@ -1341,7 +1341,8 @@ fn set_item(s: &mut Session, p: &Value) -> Result<Value> {
let mut rows = top_paint_changed(&before, d, &ids);
rows.extend(painted_rows(d, written));
let painted = super::graph::capture_series_top_paints(d, &rows);
let reached = shown_rows_edited(&before, d, reached, |id| edited.iter().any(|(e, _)| *e == id));
let wrote: HashSet<NodeId> = edited.iter().map(|(id, _)| *id).collect();
let reached = shown_rows_edited(&before, d, reached, |id| wrote.contains(&id));
let labels = capture_row_edits(&before, d, &reached);
// A graph line keeps what was written to its topmost visible row, also when it already showed it.
let tops: Vec<(NodeId, usize)> = ids.iter().zip(&per).filter_map(|(id, at)| Some((*id, *at.first()?))).collect();
@@ -1503,7 +1504,7 @@ fn duplicate_item(s: &mut Session, p: &Value) -> Result<Value> {
}
super::graph::capture_series_opacity(d, &top_opacity_changed(&before, d, &ids));
let mut rows = top_paint_changed(&before, d, &ids);
let top_copies: Vec<NodeId> = added.iter().map(|(id, _)| *id).collect();
let top_copies: HashSet<NodeId> = added.iter().map(|(id, _)| *id).collect();
rows.extend(painted_rows(d, added));
super::graph::capture_series_top_paints(d, &rows);
capture_row_edits(&before, d, &shown_rows_edited(&before, d, reached, |id| top_copies.contains(&id)));
+1 -1
View File
@@ -80,7 +80,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export 3D Assets",
[],
None,
"{assets?: [asset id…] (default every 3D asset), folder?, zip?, textureSize?: 128…4096 (default 1024: the pixels along the longer side of each face's texture)} each 3D asset's object as a mesh file in its format (assets.set3DFormat), named after the asset: USDA or USDZ, glTF 2.0 (one .gltf, its buffer embedded) or OBJ with its .mtl (whitespace and # in an OBJ's name become _). Every solid of the object (the fill's, each stroke's, a group's members') is a mesh with a material in the color it is painted; faces turned away from the viewer are included, at the object's 3D rotation, y up, about the point it turns about, in points (glTF: meters). The graphics mapped onto a plane or onto Extrude & Bevel's front or back cap (threeD.mapGraphic) are a PNG texture of that face: its color with the graphics drawn over it, flat and unlit, on a mesh of the face's own with texture coordinates; glTF embeds it, USDZ stores it after the layer, and OBJ and USDA write it beside them as <name>-texture-1.png… (whitespace, # and @ become _); a face that is not opaque keeps its opacity in the texture's alpha, and an OBJ also gets <name>-texture-1-opacity.png…, the alpha as gray levels for its map_d. Graphics on Revolve's side are not exported. Files that would share a name get -2, -3…; an object with a hole that crosses its face's outline or another hole, or with more than 2,000,000 triangles, or textures of more than 67,108,864 pixels in one export, is refused → {files: [path…]} (no folder: {files: [{name, dataBase64}]}, or with zip one zip as {name, dataBase64, files})",
"{assets?: [asset id…] (default every 3D asset), folder?, zip?, textureSize?: 128…4096 (default 1024: the pixels along the longer side of each face's texture)} each 3D asset's object as a mesh file in its format (assets.set3DFormat), named after the asset: USDA or USDZ, glTF 2.0 (one .gltf, its buffer embedded) or OBJ with its .mtl (whitespace and # in an OBJ's name become _). Every solid of the object (the fill's, each stroke's, a group's members') is a mesh with a material in the color it is painted; faces turned away from the viewer are included, at the object's 3D rotation, y up, about the point it turns about, in points (glTF: meters). The graphics mapped onto a plane or onto Extrude & Bevel's front or back cap (threeD.mapGraphic) are a PNG texture of that face: its color with the graphics drawn over it, flat and unlit, on a mesh of the face's own with texture coordinates; glTF embeds it, USDZ stores it after the layer, and OBJ and USDA write it beside them as <name>-texture-1.png… (whitespace, # and @ become _); a face that is not opaque keeps its opacity in the texture's alpha, and an OBJ also gets <name>-texture-1-opacity.png…, the alpha as gray levels for its map_d. Graphics on Revolve's side (in a group, the side of the member with the longest profile) are a texture of the side unrolled as the canvas lays it out, on a mesh of the side's triangles; its end caps and cut sides stay plain. Files that would share a name get -2, -3…; an object with a hole that crosses its face's outline or another hole, or with more than 2,000,000 triangles, or textures of more than 67,108,864 pixels in one export, is refused → {files: [path…]} (no folder: {files: [{name, dataBase64}]}, or with zip one zip as {name, dataBase64, files})",
has_doc,
export_3d
),
+39
View File
@@ -177,6 +177,7 @@ pub const BUILTIN: &[BuiltinBrushLibrary] = &[
BuiltinBrushLibrary { id: "bristle-brushes", name: "Bristle Brushes", make: bristle_brushes },
BuiltinBrushLibrary { id: "pattern-borders", name: "Pattern Borders", make: pattern_borders },
BuiltinBrushLibrary { id: "scatter-shapes", name: "Scatter Shapes", make: scatter_shapes },
BuiltinBrushLibrary { id: "stipple", name: "Stipple", make: stipple },
BuiltinBrushLibrary { id: "game-trails", name: "Game Trails", make: game_trails },
BuiltinBrushLibrary { id: "energy-beams", name: "Energy Beams", make: energy_beams },
BuiltinBrushLibrary { id: "dry-media", name: "Dry Media", make: dry_media },
@@ -627,6 +628,44 @@ fn scatter_shapes() -> BrushLibrary {
built("Scatter Shapes", doc, brushes)
}
/// Stipple: original dot-based scatter brushes for fine and broad shading along a path.
fn stipple() -> BrushLibrary {
let dot = |x: f64, y: f64, r: f64, opacity: f32| {
Node::path(
NodeId(0),
shapes::ellipse(Rect::new(x - r, y - r, x + r, y + r)),
Appearance {
items: vec![AppearanceItem::Fill(FillLayer { opacity, ..FillLayer::new(Paint::solid(Color::BLACK)) })],
..Default::default()
},
)
};
let base = Scatter { colorization: Colorization::Tints, ..Default::default() };
let brushes = vec![
scatter(
"Fine Stipple",
dot(0.0, 0.0, 0.8, 1.0),
Scatter { size: (70.0, 110.0), spacing: (80.0, 130.0), scatter: (-100.0, 100.0), ..base.clone() },
),
scatter(
"Dense Stipple",
group(vec![dot(-1.7, -1.4, 1.0, 1.0), dot(1.5, 0.5, 0.8, 1.0), dot(-0.5, 1.8, 0.65, 1.0)]),
Scatter { size: (80.0, 120.0), spacing: (55.0, 90.0), scatter: (-70.0, 70.0), ..base.clone() },
),
scatter(
"Soft Stipple",
group(vec![dot(-1.2, -0.8, 1.0, 0.45), dot(1.2, 1.1, 0.7, 0.35)]),
Scatter { size: (55.0, 135.0), spacing: (80.0, 140.0), scatter: (-140.0, 140.0), ..base.clone() },
),
scatter(
"Bold Stipple",
group(vec![dot(-1.5, -1.0, 1.8, 1.0), dot(1.6, 1.3, 1.4, 1.0)]),
Scatter { size: (80.0, 125.0), spacing: (75.0, 115.0), scatter: (-95.0, 95.0), ..base },
),
];
built("Stipple", Document::new(100.0, 100.0), brushes)
}
/// Game Trails: art brushes for motion lines and impact streaks (original game HUD / VFX art).
fn game_trails() -> BrushLibrary {
let speed = {
+19 -5
View File
@@ -27,11 +27,15 @@ use crate::EngineError;
/// Whether Reset Transformation changes a symbol instance.
pub use symbols::reset_transformation_changes;
/// Whether an object is a symbol set.
pub use symbols::is_symbol_set;
/// The Symbols panel's current symbol, as `symbol.list` answers it.
pub use symbols::current_symbol;
mod brushes;
mod dynamic;
mod symbolism;
mod symbols;
pub(crate) use brushes::{apply_brush, brush_targets, stroke_paint};
@@ -41,6 +45,7 @@ use brushes::{
};
pub(crate) use dynamic::{edit_part, fit_parts, part_only, selected_part};
use dynamic::{symbol_instance_reset, symbol_instance_select_part, symbol_instance_set_appearance};
use symbolism::symbol_set_density;
use symbols::selected_instances;
pub(crate) use symbols::{
expand_instances_under, expandable_instances, instance_in_place, natural_size, normalize, place_xf, set_natural_size, store_symbol,
@@ -165,7 +170,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Brush Options…",
[],
None,
"{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180° (counter-clockwise from level), roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure|tilt|bearing|rotation for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest; tilt from value − variation with the pen lying flat to value + variation with it upright; bearing and rotation add variation × the pen's bearing (which way it leans, counter-clockwise from leaning right) or its barrel's counter-clockwise rotation over 180°; the angle turns on past ±180°). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180° (counter-clockwise), modes: [fixed|random|pressure|tilt|bearing|rotation for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest; tilt: a with the pen lying flat to b upright; bearing and rotation: a at −180° to b at 180°), rotation_relative_to_path, hue_jitter 0..180° (each copy turns the hue of its solid colors, after the colorization, by its own amount up to this far either way, the same on every redraw; colors without a hue stay; 0: off). art: width 1..1000%, width_mode: null (fixed)|pressure|tilt|bearing|rotation, width_max 1..1000% (pressure: width at the lightest pen pressure to width_max at the heaviest; tilt: width with the pen lying flat to width_max upright; bearing and rotation: width at −180° to width_max at 180°; half way on a stroke drawn without that input), scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across, overlap. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across, outer_corner and inner_corner: corner tile art (drawn as the corner that joins a side tile on its right to one below it) or null, outer_source and inner_source: what that kind of corner draws without its art: none|autoCentered|autoBetween|autoSliced|autoOverlap (a tile made from the side tile), or null (the other kind of corner's art); side_tile, outer_corner_tile, inner_corner_tile, start_tile, end_tile: a document pattern name, original, or none (side refuses none); corner tiles also take autoCentered|autoBetween|autoSliced|autoOverlap. Each tile also accepts {pattern: name} to select a swatch whose name is a reserved choice. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour; without a key: the solid color the art's fills and strokes use most, black when they use none)}; colorization and the art brush's scale change only the fields given}, newName? (trimmed; blank: the name is kept; a new bristle brush name has at most 31 characters, and a longer name the brush has is kept)} edit a brush definition (strokes using it update) → {name}",
"{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180° (counter-clockwise from level), roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure|tilt|bearing|rotation|stylusWheel for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest; tilt from value − variation with the pen lying flat to value + variation with it upright; bearing and rotation add variation × the pen's bearing (which way it leans, counter-clockwise from leaning right) or its barrel's counter-clockwise rotation over 180°; stylusWheel from value − variation at one end of an airbrush pen's finger wheel to value + variation at the other; the angle turns on past ±180°). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180° (counter-clockwise), modes: [fixed|random|pressure|tilt|bearing|rotation|stylusWheel for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest; tilt: a with the pen lying flat to b upright; bearing and rotation: a at −180° to b at 180°; stylusWheel: a at one end of an airbrush pen's finger wheel to b at the other), rotation_relative_to_path, hue_jitter 0..180° (each copy turns the hue of its solid colors, after the colorization, by its own amount up to this far either way, the same on every redraw; colors without a hue stay; 0: off). art: width 1..1000%, width_mode: null (fixed)|pressure|tilt|bearing|rotation|stylusWheel, width_max 1..1000% (pressure: width at the lightest pen pressure to width_max at the heaviest; tilt: width with the pen lying flat to width_max upright; bearing and rotation: width at −180° to width_max at 180°; stylusWheel: width at one end of the finger wheel to width_max at the other; half way on a stroke drawn without that input), scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across, overlap. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across, outer_corner and inner_corner: corner tile art (drawn as the corner that joins a side tile on its right to one below it) or null, outer_source and inner_source: what that kind of corner draws without its art: none|autoCentered|autoBetween|autoSliced|autoOverlap (a tile made from the side tile), or null (the other kind of corner's art); side_tile, outer_corner_tile, inner_corner_tile, start_tile, end_tile: a document pattern name, original, or none (side refuses none); corner tiles also take autoCentered|autoBetween|autoSliced|autoOverlap. Each tile also accepts {pattern: name} to select a swatch whose name is a reserved choice. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour; without a key: the solid color the art's fills and strokes use most, black when they use none)}; colorization and the art brush's scale change only the fields given}, newName? (trimmed; blank: the name is kept; a new bristle brush name has at most 31 characters, and a longer name the brush has is kept)} edit a brush definition (strokes using it update) → {name}",
has_doc,
brush_options
),
@@ -220,7 +225,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Symbol Options…",
[],
None,
"{name?, newName?, registration?: 0..8, exportType?: movieClip|graphic, nineSlice?: bool, nineSliceGuides?: array, type?: static|dynamic, alignToPixelGrid?: bool} rename a symbol (its instances and the graphics mapped onto 3D objects follow the new name) and/or set Symbol Options › Registration, Export Type, 9-slice guides (nineSliceGuides [left, top, right, bottom] fractions in from each edge, each -16..16, with left + right < 1 and top + bottom < 1), Symbol Type (a dynamic symbol's instances may change the appearance of objects in its art and stay linked; making it static drops those changes) and Align to Pixel Grid (on: the horizontal and vertical straight segments of the paths in the symbol's art snap to whole points, or half points for an odd centered stroke, at the symbol's natural size, its stroke weights become whole points, and every instance placed at that size, reflected across one axis or not, moves to whole points and goes back to them after each move; a scaled, rotated (a half turn included) or sheared instance, and an instance in another symbol's art, is left where it is; the art snaps again after it is edited); alignToPixelGrid alone with the value the symbol already has changes nothing and adds no undo step; default name: current → {name, registration, exportType, nineSlice, type, alignToPixelGrid}",
"{name?, newName?, registration?: 0..8, exportType?: movieClip|graphic, nineSlice?: bool, nineSliceGuides?: array, type?: static|dynamic, alignToPixelGrid?: bool} rename a symbol (its instances and the graphics and Map Art maps on 3D objects follow the new name) and/or set Symbol Options › Registration, Export Type, 9-slice guides (nineSliceGuides [left, top, right, bottom] fractions in from each edge, each -16..16, with left + right < 1 and top + bottom < 1), Symbol Type (a dynamic symbol's instances may change the appearance of objects in its art and stay linked; making it static drops those changes) and Align to Pixel Grid (on: the horizontal and vertical straight segments of the paths in the symbol's art snap to whole points, or half points for an odd centered stroke, at the symbol's natural size, its stroke weights become whole points, and every instance placed at that size, reflected across one axis or not, moves to whole points and goes back to them after each move; a scaled, rotated (a half turn included) or sheared instance, and an instance in another symbol's art, is left where it is; the art snaps again after it is edited); alignToPixelGrid alone with the value the symbol already has changes nothing and adds no undo step; default name: current → {name, registration, exportType, nineSlice, type, alignToPixelGrid}",
has_doc,
symbol_options
),
@@ -338,7 +343,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Select All Unused",
[],
None,
"{} → {names: [the symbols nothing places, in panel order]} (the Symbols panel selects them): instances in the art (opacity masks included), graphics mapped onto 3D objects (threeD.mapGraphic), graph designs, pattern tiles (with the tiles that pattern editing's Cancel puts back) and brush art count, and so do instances in the art of a symbol that is used",
"{} → {names: [the symbols nothing places, in panel order]} (the Symbols panel selects them): instances in the art (opacity masks included), graphics and Map Art maps on 3D objects (threeD.mapGraphic, threeD.mapArt), graph designs, pattern tiles (with the tiles that pattern editing's Cancel puts back) and brush art count, and so do instances in the art of a symbol that is used",
has_doc,
symbol_unused
),
@@ -357,16 +362,25 @@ pub fn specs() -> Vec<CommandSpec> {
"Symbol Sprayer",
[],
None,
"{points: [[x,y]…], name?, radius?: 40, density?: 1..10 (5), scale?: 1, alt?: bool (remove instances)} spray instances into a symbol set → {id, count}",
"{points: [[x,y]…] (a third number is not used; one that isn't a number is an error), name?, radius?: 40, density?: 1..10 (5), scale?: 1, alt?: bool (remove instances), attributes?: {scrunch?, size?, spin?, screen?, stain?, style?: average|userDefined (average)}, color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name} spray instances into a symbol set → {id, count}. Each of `attributes` says what a new instance takes: average, the mean of the selected set's instances within `radius` of the stroke point (their spacing along the stroke, size, rotation, opacity, and the stain or style of the nearest one that has one at the mean amount), and with none there the symbol's size, no rotation, full opacity and no stain or style; or userDefined: spacing from the symbol's size and `density`, the symbol's size times `scale`, turned the way the stroke runs there (not turned for one point), full opacity, stained in full with `color` (default: the fill color), and the fill of graphic style `style` (default: the first style after the default one) in full; a `style` the document does not have is then an error. The stain and the style are both the instance's fill, and the style replaces the stain. Another key or value in `attributes` is an error",
has_doc,
symbol_spray
),
cmd!(
"symbol.setDensity",
"Symbol Set Density",
[],
None,
"{from: 1..10, to: 1..10, ids?|id?} space the instances of the selected symbol sets (or those in `ids`) as Symbol Set Density `to` packs them, from the density each set was created at or last given (`from` for a set without one, such as one grouped by hand): each instance moves along the line from the middle of its set's instances, to (1.15 − 0.1·to) / (1.15 − 0.1·from) of its distance from it (each factor at least 0.1), as one undo step, and every set then has density `to`, also one whose instances do not move (one instance, or each locked); a higher density packs them closer, and a locked or hidden instance stays where it is. No undo step is added when no instance moves and every set already has density `to`. A `from` or `to` left out, not a number or outside 1..10, an id naming no object, or no symbol set among the objects is an error → {ids: the sets changed, count: the instances moved}",
has_doc,
symbol_set_density
),
cmd!(
"symbol.adjust",
"Symbolism Tool",
[],
None,
"{tool: shift|scrunch|size|spin|stain|screen|style, points: [[x,y]…], radius?: 40, intensity?: 1..10 (5), alt?: bool, color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name} adjust instances near the points (selection, else all) → {count}",
"{tool: shift|scrunch|size|spin|stain|screen|style, points: [[x,y,pressure?]…] (pen pressure 0..1, default 1), radius?: 40, intensity?: 1..10 (5), usePressure?: bool (each point's pressure is the intensity there, in place of `intensity`), method?: userDefined|average|random (userDefined; not used by shift), proportional?: bool (size; true), affectsDensity?: bool (size; false), alt?: bool, color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name} adjust instances near the points (selection, else all) → {count}. `method` userDefined changes each instance by the tool's amount at its distance from the point; random gives each instance its own share of that amount for the whole stroke, from none to twice it (spin: a turn either way); average moves each instance's value toward the mean of the instances within `radius` of the point (scrunch: its distance from their middle toward their mean distance; size: the geometric mean of their sizes; spin: their mean direction; stain and style: their mean amount; screen: their mean opacity), and `alt` does not reverse it; average leaves an instance without a size (a scale of 0) as it is. With `proportional` false a drag resizes along its own direction (a level drag the width, an upright one the height; the first point takes the direction to the second) and one point resizes both; average resizes both whatever `proportional` is. With `affectsDensity` an instance also moves away from the point as it grows and toward it as it shrinks. An instance counts only when it changes, and no undo step is added when none does (none under the brush, average with each already at the mean, or each already at the tool's limit). A `method` that is none of the three, or a pressure that isn't a number, is an error",
has_doc,
symbol_adjust
),
+442
View File
@@ -0,0 +1,442 @@
//! What the symbolism commands share: the Method and the Symbol Sprayer options of the Symbolism
//! Tools Options, what an instance shows of the values the tools change ([`Look`]), the mean of
//! those values under the brush ([`mean`]), and `symbol.setDensity`.
use std::collections::HashMap;
use super::symbols::{instance_center, is_symbol_set, stored_natural_size};
use super::{
Affine, Document, EngineError, HALF, Node, NodeId, NodeKind, Paint, Point, Result, Session, Value, Vec2, bad, ids_json, json, named_ids,
};
/// Method: how the Scruncher, Sizer, Spinner, Stainer, Screener and Styler adjust instances.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Method {
/// Gradually, in relation to the position of the pointer.
UserDefined,
/// Toward the mean of the instances under the brush.
Average,
/// By an amount that differs from instance to instance.
Random,
}
/// The `method` of `symbol.adjust` (User Defined when left out or null).
pub(super) fn method_param(p: &Value, cmd: &str) -> Result<Method> {
match p.get("method") {
None | Some(Value::Null) => Ok(Method::UserDefined),
Some(Value::String(s)) if s == "userDefined" => Ok(Method::UserDefined),
Some(Value::String(s)) if s == "average" => Ok(Method::Average),
Some(Value::String(s)) if s == "random" => Ok(Method::Random),
Some(v) => Err(bad(cmd, format!("`method` must be userDefined, average or random, not {v}"))),
}
}
/// The Symbol Sprayer options: whether each value of a new instance is the average of the
/// instances under the brush (true) or the User Defined value (false).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct SprayModes {
pub scrunch: bool,
pub size: bool,
pub spin: bool,
pub screen: bool,
pub stain: bool,
pub style: bool,
}
impl SprayModes {
/// Whether any value is an average.
pub fn any_average(self) -> bool {
self.scrunch || self.size || self.spin || self.screen || self.stain || self.style
}
}
/// The `attributes` of `symbol.spray`: `{scrunch?, size?, spin?, screen?, stain?, style?}`, each
/// `average` (also when left out or null) or `userDefined`. Another key or value is an error.
pub(super) fn spray_modes(p: &Value, cmd: &str) -> Result<SprayModes> {
let mut m = SprayModes { scrunch: true, size: true, spin: true, screen: true, stain: true, style: true };
let map = match p.get("attributes") {
None | Some(Value::Null) => return Ok(m),
Some(Value::Object(map)) => map,
Some(v) => return Err(bad(cmd, format!("`attributes` must be an object, not {v}"))),
};
for (key, v) in map {
let slot = match key.as_str() {
"scrunch" => &mut m.scrunch,
"size" => &mut m.size,
"spin" => &mut m.spin,
"screen" => &mut m.screen,
"stain" => &mut m.stain,
"style" => &mut m.style,
_ => return Err(bad(cmd, format!("unknown attribute `{key}`"))),
};
*slot = match v {
Value::Null => true,
Value::String(s) if s == "average" => true,
Value::String(s) if s == "userDefined" => false,
v => return Err(bad(cmd, format!("attribute `{key}` must be average or userDefined, not {v}"))),
};
}
Ok(m)
}
/// How far apart the Symbol Sprayer keeps instances at Symbol Set Density `density` (1..10), as a
/// share of the symbol's size: a denser set is packed closer.
pub(super) fn spacing(density: f64) -> f64 {
(1.15 - density * 0.1).max(0.1)
}
/// The document key that holds each symbol set's Symbol Set Density: `{set id: density}`, written
/// when the Symbol Sprayer creates a set and when `symbol.setDensity` spaces it.
const SET_DENSITY_KEY: &str = "symbolSetDensity";
/// The Symbol Set Density symbol set `set` was created at or last given (None when not recorded).
fn set_density_of(d: &Document, set: NodeId) -> Option<f64> {
d.unknown.get(SET_DENSITY_KEY)?.get(set.0.to_string())?.as_f64().filter(|v| (1.0..=10.0).contains(v))
}
/// Record `density` as the Symbol Set Density of `sets`, and drop the records of ids that are no
/// longer symbol sets.
pub(super) fn record_set_density(d: &mut Document, sets: &[NodeId], density: f64) {
let mut map = match d.unknown.get(SET_DENSITY_KEY) {
Some(Value::Object(m)) => m.clone(),
_ => serde_json::Map::new(),
};
for set in sets {
map.insert(set.0.to_string(), json!(density));
}
map.retain(|k, _| k.parse::<u64>().ok().and_then(|id| d.node(NodeId(id))).is_some_and(is_symbol_set));
if map.is_empty() {
d.unknown.remove(SET_DENSITY_KEY);
} else {
d.unknown.insert(SET_DENSITY_KEY.into(), Value::Object(map));
}
}
/// What a symbol instance shows of the values the symbolism tools change.
#[derive(Clone, Debug)]
pub(super) struct Look {
pub center: Point,
/// Its size on the page: the side of a square with its area, the same measure for every symbol.
pub size: f64,
/// Its rotation in radians.
pub angle: f64,
pub opacity: f64,
/// The fill the Symbol Stainer or the Symbol Styler gave it, with its amount (0..1).
pub fill: Option<(Paint, f64)>,
}
/// The [`natural_side`] of each symbol measured so far in one command, so that one measure serves
/// every instance of the symbol.
pub(super) type Sides = HashMap<String, f64>;
/// The [`Look`] of instance `n` (None for another object, or an instance without a size).
pub(super) fn look(d: &Document, n: &Node, sides: &mut Sides) -> Option<Look> {
let NodeKind::SymbolInstance { symbol, xf } = &n.kind else { return None };
let [a, b, c, e, ..] = xf.as_coeffs();
let natural = d.symbol_natural_xf(symbol).as_coeffs();
let (sx, sy) = (natural[0].abs().max(1e-9), natural[3].abs().max(1e-9));
let scale = ((a * e - b * c) / (sx * sy)).abs().sqrt();
if !(scale.is_finite() && scale > 0.0) {
return None;
}
let side = match sides.get(symbol) {
Some(side) => *side,
None => *sides.entry(symbol.clone()).or_insert_with(|| natural_side(d, symbol)),
};
let size = scale * side;
if !(size.is_finite() && size > 0.0) {
return None;
}
Some(Look {
center: instance_center(n)?,
size,
angle: b.atan2(a),
opacity: f64::from(n.opacity),
fill: n.appearance.fill().map(|f| (f.paint.clone(), f64::from(f.opacity))),
})
}
/// The [`Look::size`] of an instance of symbol `name` at the symbol's own size. A symbol without a
/// recorded size draws its art at the art's own size, so its art is measured.
pub(super) fn natural_side(d: &Document, name: &str) -> f64 {
let recorded = stored_natural_size(d, name).is_some_and(|(w, h)| w.is_finite() && h.is_finite() && w > 0.0 && h > 0.0);
// Each side's root first, so that a huge size does not overflow.
let art = (!recorded).then(|| d.symbol_art_bounds(name)).flatten().map(|r| r.width().sqrt() * r.height().sqrt());
if let Some(side) = art.filter(|s| s.is_finite() && *s > 0.0) {
return side;
}
let natural = d.symbol_natural_xf(name).as_coeffs();
2.0 * HALF * natural[0].abs().max(1e-9).sqrt() * natural[3].abs().max(1e-9).sqrt()
}
/// The mean of the [`Look`]s of the instances under the brush.
#[derive(Clone, Debug)]
pub(super) struct Mean {
/// The geometric mean of the sizes ([`Look::size`]).
pub size: f64,
/// The mean direction of the rotations.
pub angle: f64,
pub opacity: f64,
/// The mean stain or style amount; an instance without one counts as 0.
pub amount: f64,
/// The stain or style of the instance nearest the brush's center that has one.
pub paint: Option<Paint>,
/// The middle of the instances.
pub middle: Point,
/// Their mean distance from [`Mean::middle`].
pub reach: f64,
/// The mean distance from each of them to the nearest of the others (None for one instance, or
/// when not asked for).
pub gap: Option<f64>,
}
/// The x (`axis` 0) or y (`axis` 1) of `p`.
fn coord(p: Point, axis: usize) -> f64 {
if axis == 0 { p.x } else { p.y }
}
/// Arrange `order` (indices into `pts`) as a k-d tree: the middle entry of each slice splits the
/// rest by x at even depths and by y at odd ones, the smaller values before it.
fn kd_build(order: &mut [usize], pts: &[Point], axis: usize) {
if order.len() <= 1 {
return;
}
let mid = order.len() / 2;
let at = |i: &usize| pts.get(*i).map_or(0.0, |p| coord(*p, axis));
order.select_nth_unstable_by(mid, |a, b| at(a).total_cmp(&at(b)));
let (left, right) = order.split_at_mut(mid);
kd_build(left, pts, 1 - axis);
kd_build(right.get_mut(1..).unwrap_or_default(), pts, 1 - axis);
}
/// The distance from `pts[i]` to the nearest of the others in k-d tree `order`, if nearer than
/// `best`. Instances on top of each other end the search: none can be nearer.
fn kd_nearest(order: &[usize], pts: &[Point], axis: usize, i: usize, best: &mut f64) {
let (Some(&j), Some(&p)) = (order.get(order.len() / 2), pts.get(i)) else { return };
let Some(&q) = pts.get(j) else { return };
if j != i {
*best = best.min(p.distance(q));
}
if *best == 0.0 {
return;
}
let (left, right) = order.split_at(order.len() / 2);
let right = right.get(1..).unwrap_or_default();
let diff = coord(p, axis) - coord(q, axis);
let (near, far) = if diff < 0.0 { (left, right) } else { (right, left) };
kd_nearest(near, pts, 1 - axis, i, best);
// The other side holds nothing nearer than the split line.
if diff.abs() < *best {
kd_nearest(far, pts, 1 - axis, i, best);
}
}
/// For each of `looks`, the distance to the nearest of the others (infinite for one alone), found
/// through a k-d tree of their centers.
fn nearest_gaps(looks: &[&Look]) -> Vec<f64> {
let pts: Vec<Point> = looks.iter().map(|l| l.center).collect();
let mut order: Vec<usize> = (0..pts.len()).collect();
kd_build(&mut order, &pts, 0);
(0..pts.len())
.map(|i| {
let mut best = f64::INFINITY;
kd_nearest(&order, &pts, 0, i, &mut best);
best
})
.collect()
}
/// The [`Mean`] of `looks`, the instances under a brush centered on `at` (None for none), with
/// [`Mean::gap`] when `with_gap` is set.
pub(super) fn mean(looks: &[&Look], at: Point, with_gap: bool) -> Option<Mean> {
if looks.is_empty() {
return None;
}
let n = looks.len() as f64;
let (mut log_size, mut sin, mut cos, mut opacity, mut amount, mut middle) = (0.0, 0.0, 0.0, 0.0, 0.0, Vec2::ZERO);
let mut paint: Option<(&Paint, f64)> = None;
for l in looks {
log_size += l.size.ln();
sin += l.angle.sin();
cos += l.angle.cos();
opacity += l.opacity;
middle += l.center.to_vec2();
if let Some((p, o)) = &l.fill {
amount += o;
let far = l.center.distance(at);
if paint.is_none_or(|(_, nearest)| far < nearest) {
paint = Some((p, far));
}
}
}
let middle = (middle / n).to_point();
// Rotations that cancel out have no mean direction: the first instance's stands for it.
let angle = if sin.hypot(cos) > 1e-9 { sin.atan2(cos) } else { looks[0].angle };
// One instance under the brush has no spacing there.
let gap = (with_gap && looks.len() > 1).then(|| nearest_gaps(looks).iter().sum::<f64>() / n);
Some(Mean {
size: (log_size / n).exp(),
angle,
opacity: opacity / n,
amount: amount / n,
paint: paint.map(|(p, _)| p.clone()),
middle,
reach: looks.iter().map(|l| l.center.distance(middle)).sum::<f64>() / n,
gap,
})
}
/// `angle` (radians) brought into −π..π.
pub(super) fn wrap_angle(angle: f64) -> f64 {
let turn = std::f64::consts::TAU;
let a = angle.rem_euclid(turn);
if a > std::f64::consts::PI { a - turn } else { a }
}
/// The instances of a symbol set by where they are, to find those under a brush without looking at
/// every one for every point of a stroke.
pub(super) struct Grid {
cell: f64,
looks: Vec<Look>,
cells: HashMap<(i64, i64), Vec<usize>>,
}
fn key(p: Point, cell: f64) -> (i64, i64) {
((p.x / cell).floor() as i64, (p.y / cell).floor() as i64)
}
/// The indices in the cell of `at`, then in the eight around it. Saturating: a point far out on the
/// canvas has a key at the end of the range.
fn around(cells: &HashMap<(i64, i64), Vec<usize>>, at: Point, cell: f64) -> impl Iterator<Item = usize> + '_ {
let (cx, cy) = key(at, cell);
let ring = (cx.saturating_sub(1)..=cx.saturating_add(1))
.flat_map(move |x| (cy.saturating_sub(1)..=cy.saturating_add(1)).map(move |y| (x, y)))
.filter(move |c| *c != (cx, cy));
std::iter::once((cx, cy)).chain(ring).flat_map(move |c| cells.get(&c).into_iter().flatten().copied())
}
impl Grid {
/// `looks` in cells `cell` points wide (the brush's radius).
pub fn new(looks: Vec<Look>, cell: f64) -> Self {
let cell = cell.max(1.0);
let mut cells: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
for (i, l) in looks.iter().enumerate() {
cells.entry(key(l.center, cell)).or_default().push(i);
}
Self { cell, looks, cells }
}
/// The mean of the instances within `radius` (at most the cell width) of `at`, with
/// [`Mean::gap`] when `with_gap` is set.
pub fn mean(&self, at: Point, radius: f64, with_gap: bool) -> Option<Mean> {
let near: Vec<&Look> =
around(&self.cells, at, self.cell).filter_map(|i| self.looks.get(i)).filter(|l| l.center.distance(at) <= radius).collect();
mean(&near, at, with_gap)
}
}
/// `symbol.setDensity {from, to, ids?|id?}`: space the instances of the selected symbol sets as
/// Symbol Set Density `to` packs them, from the density each set was created at or last given
/// (`from` for a set without one): each instance moves along the line from the middle of its set's
/// instances, to [`spacing`]`(to) / `[`spacing`]` of the set's density` of its distance from it.
/// Every selected set then has density `to`, also one whose instances do not move. One undo step,
/// and none when no instance moves and every set already has density `to`.
pub(super) fn symbol_set_density(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "symbol.setDensity";
let density = |key: &str| match p.get(key) {
Some(v) => v.as_f64().filter(|d| (1.0..=10.0).contains(d)).ok_or_else(|| bad(C, format!("`{key}` must be a number from 1 to 10, not {v}"))),
None => Err(bad(C, format!("missing `{key}`"))),
};
let (from, to) = (density("from")?, density("to")?);
crate::cmd::edit::refuse_symbol_part(s)?;
let st = s.doc()?;
let d = &st.doc;
let named = named_ids(p)?;
let ids: Vec<NodeId> = named.clone().unwrap_or_else(|| st.selection.objects.clone());
if let Some(missing) = named.iter().flatten().find(|id| d.node(**id).is_none()) {
return Err(EngineError::Other(format!("no object {}", missing.0)));
}
let editable = d.editable();
let mut sets: Vec<NodeId> = vec![];
for id in ids {
if d.node(id).is_some_and(is_symbol_set) && editable(id) && !sets.contains(&id) {
sets.push(id);
}
}
if sets.is_empty() {
return Err(EngineError::Other("no symbol set selected".into()));
}
let mut moves: Vec<(NodeId, Vec2)> = vec![];
let mut changed: Vec<NodeId> = vec![];
for set in &sets {
// A set packs from the density it was created at or last given, else from `from`.
let own = set_density_of(d, *set);
let ratio = spacing(to) / spacing(own.unwrap_or(from));
// A set takes density `to` even when none of its instances moves (one instance, or each
// locked or on top of the others), so a later change packs it from `to`.
let restamp = own != Some(to);
let centers: Vec<(NodeId, Point)> =
d.node(*set).and_then(|n| n.children()).into_iter().flatten().filter_map(|c| Some((c.id, instance_center(c)?))).collect();
if centers.len() < 2 {
if restamp {
changed.push(*set);
}
continue;
}
let middle = (centers.iter().fold(Vec2::ZERO, |sum, (_, c)| sum + c.to_vec2()) / centers.len() as f64).to_point();
let before = moves.len();
// A locked or hidden instance stays where it is.
moves.extend(
centers.iter().filter(|(id, _)| editable(*id)).map(|(id, c)| (*id, (*c - middle) * (ratio - 1.0))).filter(|(_, v)| v.hypot() > 1e-9),
);
if moves.len() > before || restamp {
changed.push(*set);
}
}
drop(editable);
if !changed.is_empty() {
s.edit("Symbol Set Density", |d, _| {
for (id, v) in &moves {
if let Some(n) = d.node_mut(*id) {
n.transform(Affine::translate(*v), false);
}
}
record_set_density(d, &changed, to);
Ok(())
})?;
}
Ok(json!({ "ids": ids_json(&changed), "count": moves.len() }))
}
#[cfg(test)]
mod tests {
use super::*;
fn at(x: f64, y: f64) -> Look {
Look { center: Point::new(x, y), size: 20.0, angle: 0.0, opacity: 1.0, fill: None }
}
/// The distance from each instance in `from` to the nearest other one in `refs`, measured
/// against every other instance.
fn brute(refs: &[&Look], from: impl Iterator<Item = usize>) -> Vec<f64> {
from.map(|i| (0..refs.len()).filter(|j| *j != i).map(|j| refs[i].center.distance(refs[j].center)).fold(f64::INFINITY, f64::min)).collect()
}
/// The gaps are each instance's distance to its nearest neighbor, measured against every other
/// instance: close pairs whose members are far apart in the order, instances on top of each
/// other, instances far from all others, many instances close together, and many on one line.
#[test]
fn nearest_gaps_match_measuring_every_pair() {
let mut looks: Vec<Look> = (0..300).map(|i| at(f64::from(i % 20) * 9.0, f64::from(i / 20) * 7.0)).collect();
// The second member of each pair comes 300 places later.
looks.extend((0..300).map(|i| at(f64::from(i % 20) * 9.0 + 0.5, f64::from(i / 20) * 7.0)));
looks.extend([at(500.0, 500.0), at(500.0, 500.0), at(900.0, 40.0)]);
// 400 instances within one point of each other, and 200 on one upright line.
looks.extend((0..400).map(|i| at(700.0 + f64::from(i % 20) * 0.05, 700.0 + f64::from(i / 20) * 0.05)));
looks.extend((0..200).map(|i| at(-50.0, f64::from(i) * 1.5)));
let refs: Vec<&Look> = looks.iter().collect();
assert_eq!(nearest_gaps(&refs), brute(&refs, 0..refs.len()));
assert_eq!(nearest_gaps(&refs[..1]), [f64::INFINITY]);
assert_eq!(nearest_gaps(&refs[..0]), Vec::<f64>::new());
}
}
+248 -42
View File
@@ -1,4 +1,5 @@
use super::dynamic::{fit_overrides, type_id, type_param};
use super::symbolism::{Grid, Mean, Method, Sides, look, mean, method_param, natural_side, record_set_density, spacing, spray_modes, wrap_angle};
use super::{
Affine, AppearanceItem, Arc, CURRENT_SYMBOL, Color, Document, EngineError, FillLayer, HALF, Node, NodeId, NodeKind, Paint, Point, Result,
SIZES_KEY, Session, Symbol, SymbolExportType, SymbolNineSlice, SymbolRegistration, Value, Vec2, bad, brush, color_param, ids_json, json,
@@ -906,16 +907,40 @@ pub(super) fn symbol_select_instances(s: &mut Session, p: &Value) -> Result<Valu
// ---------- symbolism tools ----------
fn points(p: &Value, cmd: &str) -> Result<Vec<Point>> {
Ok(samples(p, cmd)?.into_iter().map(|(q, _)| q).collect())
}
/// The stroke's points, each with its pen pressure: the third number of `[x, y, pressure]`, kept
/// within 0..1, and 1 for a point that gives none (or null). A pressure that isn't a number is an
/// error.
fn samples(p: &Value, cmd: &str) -> Result<Vec<(Point, f64)>> {
let a = p.get("points").and_then(Value::as_array).ok_or_else(|| bad(cmd, "missing points [[x,y]…]"))?;
let v: Vec<Point> = a.iter().filter_map(|q| Some(Point::new(q.get(0)?.as_f64()?, q.get(1)?.as_f64()?))).collect();
if v.is_empty() || v.iter().any(|q| !q.x.is_finite() || !q.y.is_finite()) {
let mut v = Vec::with_capacity(a.len());
for q in a {
let (Some(x), Some(y)) = (q.get(0).and_then(Value::as_f64), q.get(1).and_then(Value::as_f64)) else { continue };
let pressure = match q.get(2) {
None | Some(Value::Null) => 1.0,
Some(f) => f.as_f64().filter(|f| f.is_finite()).ok_or_else(|| bad(cmd, format!("a point's pressure must be a number, not {f}")))?,
};
v.push((Point::new(x, y), pressure.clamp(0.0, 1.0)));
}
if v.is_empty() || v.iter().any(|(q, _)| !q.x.is_finite() || !q.y.is_finite()) {
return Err(bad(cmd, "points must be finite [x,y] pairs"));
}
Ok(v)
}
/// The fill of the graphic style `p` names with `style`, else of the document's first style after
/// the default one.
fn style_paint(d: &Document, p: &Value) -> Option<Paint> {
match str_param(p, "style") {
Some(n) => d.graphic_styles.iter().find(|g| g.name == n).map(|g| g.appearance.fill_paint()),
None => d.graphic_styles.get(1).or(d.graphic_styles.first()).map(|g| g.appearance.fill_paint()),
}
}
/// Deterministic per-point jitter in [-1, 1]² (so previews re-applied on the snapshot agree).
fn jitter(i: usize, q: Point) -> (f64, f64, f64) {
pub(super) fn jitter(i: usize, q: Point) -> (f64, f64, f64) {
let mut h: u64 = 0xcbf2_9ce4_8422_2325 ^ i as u64;
for v in [(q.x * 16.0).round() as i64 as u64, (q.y * 16.0).round() as i64 as u64] {
h ^= v;
@@ -926,7 +951,8 @@ fn jitter(i: usize, q: Point) -> (f64, f64, f64) {
(f(0), f(1), f(2))
}
fn is_symbol_set(n: &Node) -> bool {
/// Whether `n` is a symbol set: the group the Symbol Sprayer sprays instances into.
pub fn is_symbol_set(n: &Node) -> bool {
matches!(n.kind, NodeKind::Group { clip: false, .. }) && n.name.as_deref() == Some("Symbol Set")
}
@@ -939,6 +965,20 @@ pub(super) fn symbol_spray(s: &mut Session, p: &Value) -> Result<Value> {
let density = number_or(p, "density", 5.0, C)?.clamp(1.0, 10.0);
let scale = number_or(p, "scale", 1.0, C)?.clamp(0.01, 100.0);
let alt = switch_or(p, "alt", false, C)?;
let modes = spray_modes(p, C)?;
crate::cmd::paint::check_keep_model(p, C)?;
let stain = match color_param(p, "color", C)? {
Some(c) => crate::cmd::paint::new_color(s, p, c),
None => s.paint.fill.color().unwrap_or(Color::BLACK),
};
if let Some(v) = p.get("style").filter(|v| !v.is_string()) {
return Err(bad(C, format!("`style` must be a graphic style's name, not {v}")));
}
let style = style_paint(&st.doc, p);
// Style: User Defined uses the style `style` names, so one the document does not have is an error.
if let Some(n) = str_param(p, "style").filter(|_| !modes.style && style.is_none()) {
return Err(bad(C, format!("unknown graphic style `{n}`")));
}
let size = natural_size(&st.doc, &name);
let set = st.selection.objects.first().copied().filter(|id| st.selection.len() == 1 && st.doc.node(*id).is_some_and(is_symbol_set));
// Only a new Symbol Set needs a layer that takes new art.
@@ -965,26 +1005,82 @@ pub(super) fn symbol_spray(s: &mut Session, p: &Value) -> Result<Value> {
}
return Ok(json!({ "count": n }));
}
// Keep instances at least this far apart along the stroke (denser = closer).
let min_gap = size.0.max(size.1) * scale * (1.15 - density * 0.1).max(0.1);
let mut placed: Vec<Point> = vec![];
let side = natural_side(&st.doc, &name);
// The symbol's longest side as drawn at its own size: its art's, when it has no recorded size.
let recorded = stored_natural_size(&st.doc, &name).filter(|(w, h)| w.is_finite() && h.is_finite() && *w > 0.0 && *h > 0.0);
let extent = match recorded {
Some((w, h)) => w.max(h),
None => {
let art = st.doc.symbol_art_bounds(&name).map(|r| r.width().max(r.height()));
art.filter(|e| e.is_finite() && *e > 0.0).unwrap_or(size.0.max(size.1))
}
};
// The scale a new instance is placed at, before the User Defined size jitter. Size: Average is
// the mean size on the page under the brush, of any symbol, or the symbol's own size with none
// there (not `scale`).
let placed_scale = |near: Option<&Mean>| {
if modes.size { near.map(|m| m.size / side).filter(|k| k.is_finite() && *k > 0.0).unwrap_or(1.0) } else { scale }
};
// The instances the selected set has, for the values a new one takes as their average.
let existing = set.filter(|_| modes.any_average()).map(|g| {
let d = &st.doc;
let mut sides = Sides::new();
let looks = d.node(g).and_then(|n| n.children()).into_iter().flatten().filter_map(|c| look(d, c, &mut sides)).collect();
Grid::new(looks, radius)
});
// Each instance to add: where, the mean of the set's instances under the brush there, and the
// direction of the stroke there (None while the pointer has not moved).
let mut placed: Vec<(Point, Option<Mean>, Option<Vec2>)> = vec![];
for (i, q) in pts.iter().enumerate() {
let (jx, jy, _) = jitter(i, *q);
let c = Point::new(q.x + jx * radius * 0.5, q.y + jy * radius * 0.5);
if placed.last().is_some_and(|l| l.distance(c) < min_gap) && i > 0 {
let near = existing.as_ref().and_then(|g| g.mean(*q, radius, modes.scrunch));
// Keep instances at least this far apart along the stroke (denser = closer), by the size
// the instance is placed at.
let min_gap = extent * placed_scale(near.as_ref()) * spacing(density);
// Scrunch: Average spaces new instances as the ones under the brush are spaced.
let gap = near.as_ref().and_then(|m| m.gap).filter(|_| modes.scrunch).unwrap_or(min_gap);
if placed.last().is_some_and(|(l, ..)| l.distance(c) < gap) && i > 0 {
continue;
}
placed.push(c);
let along = pts.get(i + 1).unwrap_or(q).to_vec2() - pts.get(i.saturating_sub(1)).unwrap_or(q).to_vec2();
placed.push((c, near, (along.hypot() > 1e-9).then_some(along)));
}
let count = placed.len();
let reg = s.doc()?.doc.symbol_registration(&name);
let id = s.edit("Symbol Sprayer", |d, sel| {
let mut nodes = vec![];
for (i, c) in placed.iter().enumerate() {
for (i, (c, near, along)) in placed.iter().enumerate() {
let (_, _, js) = jitter(i + 7, *c);
let k = scale * (1.0 + js * 0.1);
let near = near.as_ref();
// User Defined: the symbol's own size, turned the way the stroke runs, opaque, stained
// with the fill color and given the style, each in full. Size: Average has no size jitter.
let k = if modes.size { placed_scale(near) } else { scale * (1.0 + js * 0.1) };
let angle = if modes.spin { near.map_or(0.0, |m| m.angle) } else { along.map_or(0.0, |v| v.atan2()) };
let turn = Affine::translate(c.to_vec2()) * Affine::rotate(angle) * Affine::translate(-c.to_vec2());
let id = d.alloc_id();
nodes.push(Node::new(id, NodeKind::SymbolInstance { symbol: name.clone(), xf: place_xf(*c, size, reg) * Affine::scale(k) }));
let mut n = Node::new(id, NodeKind::SymbolInstance { symbol: name.clone(), xf: turn * place_xf(*c, size, reg) * Affine::scale(k) });
if modes.screen
&& let Some(m) = near
{
n.opacity = (m.opacity as f32).clamp(0.0, 1.0);
}
// The stain and the style are both the instance's fill: the style, set last, replaces
// the stain, an averaged one too when the instances under the brush have a fill.
let averaged = near.filter(|m| m.amount > 0.0).and_then(|m| Some((m.paint.clone()?, m.amount as f32)));
let mut fill = if modes.stain { averaged.clone() } else { Some((Paint::solid(stain), 1.0)) };
if modes.style {
fill = averaged.or(fill);
} else if let Some(paint) = style.as_ref().filter(|p| !matches!(p, Paint::None)) {
// A style without a fill (the default style) gives none.
fill = Some((paint.clone(), 1.0));
}
if let Some((paint, amount)) = fill {
let mut f = FillLayer::new(paint);
f.opacity = amount.clamp(0.0, 1.0);
n.appearance.items.insert(0, AppearanceItem::Fill(f));
}
nodes.push(n);
}
let gid = match set {
Some(g) => {
@@ -1001,13 +1097,18 @@ pub(super) fn symbol_spray(s: &mut Session, p: &Value) -> Result<Value> {
gid
}
};
// A new set has the density it is sprayed at; more instances sprayed into a set leave the
// density the set has.
if set.is_none() {
record_set_density(d, &[gid], density);
}
sel.set([gid]);
Ok(gid)
})?;
Ok(json!({ "id": id.0, "count": count }))
}
fn instance_center(n: &Node) -> Option<Point> {
pub(super) fn instance_center(n: &Node) -> Option<Point> {
match &n.kind {
NodeKind::SymbolInstance { xf, .. } => Some(*xf * Point::ZERO),
_ => None,
@@ -1021,10 +1122,15 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad(C, format!("unknown tool `{tool}`")));
}
crate::cmd::paint::check_keep_model(p, C)?;
let pts = points(p, C)?;
let pts = samples(p, C)?;
let radius = number_or(p, "radius", 40.0, C)?.clamp(1.0, 2000.0);
let intensity = number_or(p, "intensity", 5.0, C)?.clamp(1.0, 10.0) / 10.0;
let alt = switch_or(p, "alt", false, C)?;
let use_pressure = switch_or(p, "usePressure", false, C)?;
let proportional = switch_or(p, "proportional", true, C)?;
let affects_density = switch_or(p, "affectsDensity", false, C)?;
// The Symbol Shifter has no Method.
let method = if tool == "shift" { method_param(p, C).map(|_| Method::UserDefined)? } else { method_param(p, C)? };
// Refused while an object of a dynamic instance's art is selected: the instance stays as it is.
crate::cmd::edit::refuse_symbol_part(s)?;
let st = s.doc()?;
@@ -1032,10 +1138,7 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
Some(c) => crate::cmd::paint::new_color(s, p, c),
None => s.paint.fill.color().unwrap_or(Color::BLACK),
};
let style_paint = match str_param(p, "style") {
Some(n) => st.doc.graphic_styles.iter().find(|g| g.name == n).map(|g| g.appearance.fill_paint()),
None => st.doc.graphic_styles.get(1).or(st.doc.graphic_styles.first()).map(|g| g.appearance.fill_paint()),
};
let style_paint = style_paint(&st.doc, p);
let candidates: Vec<NodeId> = {
let d = &st.doc;
let mut v = vec![];
@@ -1065,62 +1168,165 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
"screen" => "Symbol Screener",
_ => "Symbol Styler",
};
let count = s.edit(label, |d, _| {
// Random: each instance's share of the tool's change, from none of it to twice it, the same
// for the whole stroke (and for every preview of it).
let first = pts.first().map_or(Point::ZERO, |(q, _)| *q);
let share = |id: NodeId| if method == Method::Random { jitter(id.0 as usize, first).0 + 1.0 } else { 1.0 };
// No undo step when no instance changes (none under the brush, or Average with each at the mean).
let count = crate::cmd::colorcmds::edit_if_changed(s, label, |orig, d| {
let mut touched = std::collections::BTreeSet::new();
for (j, q) in pts.iter().enumerate() {
let delta = if j > 0 { *q - pts[j - 1] } else { Vec2::ZERO };
let mut sides = Sides::new();
for (j, (q, pressure)) in pts.iter().enumerate() {
let delta = if j > 0 { *q - pts[j - 1].0 } else { Vec2::ZERO };
// Use Pressure Pen: the pen's pressure at the point is the intensity there.
let strength = if use_pressure { *pressure } else { intensity };
// Average: the mean of the instances under the brush, as they are at this point.
let target = (method == Method::Average)
.then(|| {
let under = |n: &&Node| instance_center(n).is_some_and(|c| c.distance(*q) <= radius);
let looks: Vec<_> = candidates.iter().filter_map(|id| d.node(*id).filter(under).and_then(|n| look(d, n, &mut sides))).collect();
mean(&looks.iter().collect::<Vec<_>>(), *q, false)
})
.flatten();
for id in &candidates {
let Some(n) = d.node_mut(*id) else { continue };
let Some(c) = instance_center(n) else { continue };
let Some(c) = d.node(*id).and_then(instance_center) else { continue };
let dist = c.distance(*q);
if dist > radius {
continue;
}
let w = intensity * (1.0 - dist / radius).max(0.0);
let w = strength * (1.0 - dist / radius).max(0.0);
if w <= 0.0 {
continue;
}
touched.insert(*id);
// Average needs the instance's own values, so it leaves an instance without a size
// as it is; the other methods change it as before.
// The instance's own values are read for Average only.
let own = (method == Method::Average).then(|| d.node(*id).and_then(|n| look(d, n, &mut sides))).flatten();
let avg = match (method, &target, own) {
(Method::Average, Some(t), Some(cur)) => Some((t, cur)),
// No mean under the brush (every instance there without a size), or none of
// its own.
(Method::Average, ..) => continue,
_ => None,
};
// Average leaves an instance that already has the mean as it is.
let at_mean = avg.as_ref().is_some_and(|(t, cur)| match tool.as_str() {
"scrunch" => {
let out = (c - t.middle).hypot();
out <= 1e-9 || (t.reach - out).abs() < 1e-9
}
"size" => (t.size / cur.size - 1.0).abs() < 1e-9,
"spin" => wrap_angle(t.angle - cur.angle).abs() < 1e-9,
"stain" | "style" => {
(t.amount - cur.fill.as_ref().map_or(0.0, |f| f.1)).abs() < 1e-6 && (cur.fill.is_some() || t.paint.is_none())
}
"screen" => (t.opacity - cur.opacity).abs() < 1e-6,
_ => false,
});
if at_mean {
continue;
}
let Some(n) = d.node_mut(*id) else { continue };
// Counted only when it changes: Random can give an instance no share of the change.
let before = n.clone();
let about = |m: Affine| Affine::translate(c.to_vec2()) * m * Affine::translate(-c.to_vec2());
let share = share(*id);
match tool.as_str() {
"shift" => n.transform(Affine::translate(delta * w.min(1.0)), false),
"scrunch" => {
let v = (*q - c) * (0.15 * w) * if alt { -1.0 } else { 1.0 };
let v = match &avg {
// Toward the instances' mean distance from their middle.
Some((t, _)) => {
let out = c - t.middle;
if out.hypot() > 1e-9 { out * ((t.reach - out.hypot()) / out.hypot() * w.min(1.0)) } else { Vec2::ZERO }
}
None => (*q - c) * (0.15 * w * share) * if alt { -1.0 } else { 1.0 },
};
n.transform(Affine::translate(v), false);
}
"size" => {
let k = 1.0 + 0.08 * w;
n.transform(about(Affine::scale(if alt { 1.0 / k } else { k })), false);
let k = match &avg {
Some((t, cur)) => (t.size / cur.size).powf(w.min(1.0)),
None => (1.0 + 0.08 * w).powf(if alt { -share } else { share }),
};
// Without Proportional Resizing a drag resizes along its own direction: a
// level drag the width, an upright one the height. A click resizes both.
// The first point of a drag takes the direction to the second.
let along = if j > 0 { delta } else { pts.get(1).map_or(Vec2::ZERO, |(next, _)| *next - *q) };
let (kx, ky) = if proportional || avg.is_some() || along.hypot() <= 1e-9 {
(k, k)
} else {
let level = along.x.abs() / (along.x.abs() + along.y.abs());
(k.powf(2.0 * level), k.powf(2.0 * (1.0 - level)))
};
n.transform(about(Affine::scale_non_uniform(kx, ky)), false);
// Resizing Affects Density: instances move away from the brush's center as
// they grow and toward it as they shrink.
if affects_density {
n.transform(Affine::translate((c - *q) * ((kx * ky).sqrt() - 1.0)), false);
}
}
"spin" => {
// Turn towards the drag direction; a click spins a little.
let a = if delta.hypot() > 1e-9 { (c - *q).cross(delta).signum() * 0.1 * w } else { 0.05 * w };
n.transform(about(Affine::rotate(if alt { -a } else { a })), false);
let a = match (&avg, method) {
(Some((t, cur)), _) => wrap_angle(t.angle - cur.angle) * w.min(1.0),
// A turn either way, whichever way the drag runs.
(None, Method::Random) => 0.1 * w * (share - 1.0),
// Turn towards the drag direction; a click spins a little.
(None, _) if delta.hypot() > 1e-9 => (c - *q).cross(delta).signum() * 0.1 * w,
(None, _) => 0.05 * w,
};
n.transform(about(Affine::rotate(if alt && avg.is_none() { -a } else { a })), false);
}
"stain" | "style" => {
let paint = if tool == "style" { style_paint.clone().unwrap_or(Paint::solid(color)) } else { Paint::solid(color) };
if tool == "style" && alt {
n.appearance.items.clear();
continue;
}
let cur = n.appearance.fill().filter(|f| f.paint == paint).map(|f| f.opacity).unwrap_or(0.0);
let step = if tool == "style" { 1.0 } else { 0.15 * w as f32 };
let o = if alt { (cur - step).max(0.0) } else { (cur + step).min(1.0) };
let (paint, o) = match &avg {
// Toward the mean amount, keeping the stain or style the instance has.
Some((t, look)) => {
let (own, cur) = look.fill.clone().map_or((None, 0.0), |(p, o)| (Some(p), o));
(own.or(t.paint.clone()).unwrap_or(paint), (cur + (t.amount - cur) * w.min(1.0)) as f32)
}
// Alt with the Symbol Styler removes the instance's appearance.
None if tool == "style" && alt => {
n.appearance.items.clear();
(paint, 0.0)
}
None => {
let cur = n.appearance.fill().filter(|f| f.paint == paint).map(|f| f.opacity).unwrap_or(0.0);
let step = match (tool.as_str(), method) {
// Random: the instance's share of the style, scaled by the
// brush strength there.
("style", Method::Random) => (share / 2.0 * w.min(1.0)) as f32,
("style", _) => 1.0,
_ => (0.15 * w * share) as f32,
};
(paint, if alt { cur - step } else { cur + step })
}
};
n.appearance.items.retain(|i| !matches!(i, AppearanceItem::Fill(_)));
if o > 0.0 {
let mut f = FillLayer::new(paint);
f.opacity = o;
f.opacity = o.min(1.0);
n.appearance.items.insert(0, AppearanceItem::Fill(f));
}
}
_ => {
let step = (0.1 * w) as f32;
n.opacity = if alt { (n.opacity + step).min(1.0) } else { (n.opacity - step).max(0.05) };
let step = (0.1 * w * share) as f32;
n.opacity = match &avg {
// The mean may be below the 5% the Screener otherwise stops at.
Some((t, _)) => (n.opacity + ((t.opacity - f64::from(n.opacity)) * w.min(1.0)) as f32).clamp(0.0, 1.0),
None if alt => (n.opacity + step).min(1.0),
None => (n.opacity - step).max(0.05),
};
}
}
if *n != before {
touched.insert(*id);
}
}
}
Ok(touched.len())
// An instance the stroke moved away and back again is not counted.
touched.retain(|id| d.node(*id) != orig.node(*id));
Ok((touched.len(), !touched.is_empty()))
})?;
Ok(json!({ "count": count }))
}
+2 -2
View File
@@ -145,7 +145,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Make",
["Object", "Image Trace"],
None,
"{id?: image or Image Trace group (default: selection), preset?: name (imageTrace.presets), savedPreset?: {settings} (a saved preset's settings, which the journal records so a replay traces with them after the preset is changed, renamed or deleted; used in place of the saved preset `preset` names), enhanced?: false (the preset's enhanced version: with Auto Grouping, and with Shapes in all but High Fidelity Photo; Flat Logo has none and is traced as it is), params?: {mode: \"blackAndWhite\"|\"grayscale\"|\"color\"|\"logo\", threshold: 0-255, palette: \"limited\"|\"fullTone\"|\"automatic\"|\"documentLibrary\" (color mode; limited: the `colors` best colours, fullTone: as many as the tones need, more with colorDetail, split into at least colorDetail colors where the image has that many before colors that look alike merge (less than 5 apart in Oklab × 100 and thoroughly mixed, or less than 1.5 and mixed in patches), automatic: flat art with its own colours, else as many as the tones need without fullTone's least count, merging close RGB colors, documentLibrary: at most `colors` of the library's colours, as they are), colors: 2-256, colorDetail: 0-100 (fullTone, automatic), library: \"document\" (the document's swatches) or a swatch library id or name (swatch.library.list; documentLibrary), colorGroup?: name (color mode, documentLibrary with library \"document\": the colors of that document color group instead of every swatch; \"\" is every swatch), paths: 0-100, corners: 0-100, noise: px (an area smaller than this joins the color it shares the longest border with; when that color is far from its own and the area is 2 px or more, or a single pixel whose longest border is not tied between colors, it joins the neighboring color nearest its pixels among those sharing at least a tenth of that border), method: \"abutting\"|\"overlapping\" (abutting with fills, not mode logo: a \"Seam Fills\" clip group under the paths holds strokes along the edges two filled paths share, 1.5 image pixels wide (VectorCraft's own width), in the color of the lower path (on an image stretched more one way than another, each stroke's outline in image pixels as a filled path), clipped to the image's box within the traced paths' box; paths that became live shapes get none; the paths are not changed), ignoreWhite (leave out white areas), ignoreColor?: \"#rrggbb\" (with ignoreWhite: the colour left out instead of white), ignoreBackground: false (with ignoreWhite: only the areas of the ignored color that reach the image's edge are left out), keepColors?: [\"#rrggbb\"…] (not mode logo: only the palette colors within about 30 levels of a listed color are traced; empty: every color), snapCurvesToLines, shapes: false (filled outlines that are a circle, an ellipse, a rectangle or a regular polygon come out as that live shape), autoGrouping: false (each path that has others inside it is grouped with them), gradients: false (grayscale and color: an area whose colour changes evenly along one direction is one path with a linear gradient fill), fills: true, strokes: false (Create: lines up to strokeWidth wide become stroked centre lines; without fills, wider areas become stroked outlines), strokeWidth: px (10), logoColors?: [\"#rrggbb\"…] (mode logo: flat-colour logos only; colours found automatically or named here, at most ten; white is its own color, and a named color with every channel 245 or more is taken as that white, except with logoColors named, logoWhite false and no ignoreWhite; noise = areas under noise/10 px ignored; edges to a fraction of a pixel, sharp corners restored, lines and circles snapped; enclosed transparent areas are painted white while white is its own color, and stay holes with ignoreWhite or without a white of its own; fills/strokes are ignored; gradients and photos are refused, judged by the image's own colors also when logoColors are named), logoWhite: true (mode logo with logoColors named; false traces the named colors only: white areas take the nearest of them, a named white is kept and enclosed transparent areas stay holes; with ignoreWhite, white areas are left out either way)}, view?: as imageTrace.setView (default: the traced object's own, else tracingResult), ids?: [id…] (instead of id)} → {id, paths, anchors, colors, warnings: [text…] (the image is over 1500 px on a side, so it traces more slowly; or it was traced scaled down; Flat Logo names only the size it traced a larger image at; or a keepColors color matches none the trace found, or nothing was traced)}",
"{id?: image or Image Trace group (default: selection), preset?: name (imageTrace.presets), savedPreset?: {settings} (a saved preset's settings, which the journal records so a replay traces with them after the preset is changed, renamed or deleted; used in place of the saved preset `preset` names), enhanced?: false (the preset's enhanced version: with Auto Grouping, and with Shapes in all but High Fidelity Photo; Flat Logo has none and is traced as it is), params?: {mode: \"blackAndWhite\"|\"grayscale\"|\"color\"|\"logo\", threshold: 0-255, palette: \"limited\"|\"fullTone\"|\"automatic\"|\"documentLibrary\" (color mode; limited: the `colors` best colours, fullTone: as many as the tones need, more with colorDetail, split into at least colorDetail colors where the image has that many before colors that look alike merge (less than 5 apart in Oklab × 100 and thoroughly mixed, or less than 1.5 and mixed in patches), automatic: flat art with its own colours, else as many as the tones need without fullTone's least count, merging close RGB colors, documentLibrary: at most `colors` of the library's colours, as they are), colors: 2-256, colorDetail: 0-100 (fullTone, automatic), library: \"document\" (the document's swatches) or a swatch library id or name (swatch.library.list; documentLibrary), colorGroup?: name (color mode, documentLibrary with library \"document\": the colors of that document color group instead of every swatch; \"\" is every swatch), paths: 0-100, corners: 0-100, noise: px (an area smaller than this joins the color it shares the longest border with; when that color is far from its own and the area is 2 px or more, or a single pixel whose longest border is not tied between colors, it joins the neighboring color nearest its pixels among those sharing at least a tenth of that border), method: \"abutting\"|\"overlapping\" (abutting with fills, not mode logo: a \"Seam Fills\" clip group under the paths holds strokes along the edges two filled paths share, 1.5 image pixels wide (VectorCraft's own width), in the color of the lower path (on an image stretched more one way than another, each stroke's outline in image pixels as a filled path), clipped to the image's box within the traced paths' box; paths that became live shapes get none; the paths are not changed), ignoreWhite (leave out white areas), ignoreColor?: \"#rrggbb\" (with ignoreWhite: the colour left out instead of white), ignoreBackground: false (with ignoreWhite: only the areas of the ignored color that reach the image's edge are left out), keepColors?: [\"#rrggbb\"…] (not mode logo: only the palette colors within about 30 levels of a listed color are traced; empty: every color), snapCurvesToLines, shapes: false (filled outlines that are a circle, an ellipse, a rectangle or a regular polygon come out as that live shape), autoGrouping: false (each path that has others inside it is grouped with them), gradients: false (grayscale and color: an area whose colour changes evenly along one direction is one path with a linear gradient fill), fills: true, strokes: false (Create: lines up to strokeWidth wide become stroked centre lines; without fills, wider areas become stroked outlines), strokeWidth: px (10), logoColors?: [\"#rrggbb\"…] (mode logo: flat-colour logos only; colours found automatically or named here, at most ten; white is its own color, and a named color with every channel 245 or more is taken as that white, except with logoColors named, logoWhite false and no ignoreWhite; noise = areas under noise/10 px ignored; edges to a fraction of a pixel, sharp corners restored, lines and circles snapped; enclosed transparent areas are painted white while white is its own color, and stay holes with ignoreWhite or without a white of its own; fills/strokes are ignored; gradients and photos are refused, judged by the image's own colors also when logoColors are named), logoWhite: true (mode logo with logoColors named; false traces the named colors only: white areas take the nearest of them, a named white is kept and enclosed transparent areas stay holes; with ignoreWhite, white areas are left out either way)}, view?: as imageTrace.setView (default: the traced object's own, else tracingResult; the Split view keeps the traced object's divider, else 0.5, and imageTrace.setView sets it), ids?: [id…] (instead of id)} → {id, paths, anchors, colors, warnings: [text…] (the image is over 1500 px on a side, so it traces more slowly; or it was traced scaled down; Flat Logo names only the size it traced a larger image at; or a keepColors color matches none the trace found, or nothing was traced)}",
has_selection_or_ids,
|s, p| trace_make(s, p, false)
),
@@ -181,7 +181,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Image Trace View",
[],
None,
"{id?|ids?: Image Trace objects (default: selection), view: \"tracingResult\"|\"tracingResultWithOutlines\"|\"outlines\"|\"outlinesWithSourceImage\"|\"sourceImage\"} how they draw on screen; exports, printing and Expand keep the tracing result → {ids, view}",
"{id?|ids?: Image Trace objects (default: selection), view: \"tracingResult\"|\"tracingResultWithOutlines\"|\"outlines\"|\"outlinesWithSourceImage\"|\"sourceImage\"|\"split\" (the source image on the part of the image left of a divider across it, and the tracing result everywhere else), split?: 0-1 (the divider: the fraction of the source image's width, from its left edge, that shows the image; kept as it was when omitted, 0.5 for a new one)} how they draw on screen; exports, printing and Expand keep the tracing result, and tracing again keeps the view and the divider → {ids, view, split (view split: the first object's divider)}",
has_selection_or_ids,
trace_set_view
),
+57 -14
View File
@@ -37,7 +37,7 @@ fn check_live_paint_takes(d: &Document, roots: &[NodeId]) -> Result<()> {
fn make_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result<(NodeId, usize, usize)> {
check_live_paint_takes(d, roots)?;
if roots.iter().any(|r| d.node(*r).is_some_and(is_live_paint)) {
return merge_live(d, sel, roots);
return merge_live(d, sel, roots, false);
}
let mut sources = vec![];
for r in roots {
@@ -178,8 +178,10 @@ impl Carried {
/// Add the other `roots` (back → front) to the first Live Paint group among them, which keeps its
/// id, the paint of its faces and edges, and its own properties apart from the Gap Options, which
/// are merged; returns (group, faces, edges).
fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result<(NodeId, usize, usize)> {
/// are merged; returns (group, faces, edges). When the groups and paths hold no path outline
/// between them, `keep_empty` leaves the group with its paths in its sources group and no faces or
/// edges; without it, that is an error.
fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId], keep_empty: bool) -> Result<(NodeId, usize, usize)> {
let target = roots
.iter()
.copied()
@@ -212,7 +214,14 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
// Merge applies the Gap Options' merge rules to the groups' options, bottom-most first.
let groups: Vec<GapOptions> = roots.iter().filter_map(|r| d.node(*r)).filter(|n| is_live_paint(n)).map(Node::gap_options).collect();
let options = merged_gap_options(&groups);
let (children, nf, ne) = build_children(d, sources, options.max_gap())?;
let (children, nf, ne) = if keep_empty && source_shapes(&sources).0.is_empty() {
let mut src = Node::group(d.alloc_id(), sources);
src.name = Some(SOURCES_NAME.into());
src.visible = false;
(vec![Arc::new(src)], 0, 0)
} else {
build_children(d, sources, options.max_gap())?
};
// The group keeps its name, lock, visibility, transparency, appearance, opacity mask, graphic
// style link and the rest; its children are made again and its Gap Options set to the merged ones.
let mut g = old;
@@ -266,7 +275,7 @@ pub(super) fn lp_merge(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(reply) = lone_live_group(s, &roots)? {
return Ok(reply);
}
let (id, faces, edges) = s.edit("Merge Live Paint", |d, sel| merge_live(d, sel, &roots))?;
let (id, faces, edges) = s.edit("Merge Live Paint", |d, sel| merge_live(d, sel, &roots, false))?;
Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
}
@@ -301,7 +310,7 @@ pub(crate) fn merge_drawn_in_isolation(s: &mut Session, g: NodeId) -> Result<boo
return Ok(false);
}
let roots: Vec<NodeId> = std::iter::once(g).chain(drawn).collect();
s.edit("Merge Live Paint", |d, sel| merge_live(d, sel, &roots))?;
s.edit("Merge Live Paint", |d, sel| merge_live(d, sel, &roots, false))?;
Ok(true)
}
@@ -346,12 +355,31 @@ fn enclosing_live_paints(d: &Document, g: NodeId) -> Vec<NodeId> {
out
}
/// Whether a shown row whose parent is `parent`, among Live Paint group `g`'s paths, gives `g` faces
/// and edges: every group between it and `g`'s sources group is shown.
fn shown_in_sources(d: &Document, parent: Option<NodeId>, g: NodeId) -> bool {
let src = d.node(g).and_then(b::sources).map(|s| s.id);
let mut at = parent;
while let Some(x) = at {
if Some(x) == src {
return true;
}
if !d.node(x).is_some_and(|n| n.visible) {
return false;
}
at = d.parent_of(x);
}
true
}
/// What moving rows in the Layers panel (`layer.move`, `node.move`) does to Live Paint groups.
/// Rows that go into a Live Paint group from elsewhere are added to it as `livePaint.merge` adds
/// paths. Rows that go into or leave a group's paths (its sources group) change those paths, and
/// the group's faces and edges are made again from them, keeping the paint of the faces and edges
/// that stay, and so are those of every Live Paint group that holds a changed group among its
/// paths. Rows moved within one group's paths, or among a group's own children, change no faces.
/// paths. Rows moved within one group's paths change no faces unless a shown row goes into or out
/// of a hidden group there; rows moved among a group's own children change no faces. A group's
/// sources group itself stays in the group.
pub(crate) struct LivePaintMove {
/// The Live Paint group the rows go into, and for each row whether it joins the group's paths.
join: Option<(NodeId, Vec<bool>)>,
@@ -365,16 +393,29 @@ pub(crate) struct LivePaintMove {
impl LivePaintMove {
/// Plan moving `rows` (with `copy`, copies of them) into `parent`, before anything changes.
/// Refuses rows Live Paint can't take ([`b::live_paint_takes`]) that would go among a group's
/// paths, with the message Make and Merge give.
/// paths, with the message Make and Merge give, and a group's sources group moved out of the
/// group.
pub(crate) fn plan(d: &Document, rows: &[NodeId], parent: Option<NodeId>, copy: bool) -> Result<Self> {
if !copy {
for r in rows {
if let Some(g) = d.parent_of(*r)
&& parent != Some(g)
&& d.node(g).filter(|n| is_live_paint(n)).and_then(b::sources).is_some_and(|s| s.id == *r)
{
return Err(EngineError::Other("a Live Paint group's sources group stays in the group: move the paths in it instead".into()));
}
}
}
let to = spot_in(d, parent);
let from: Vec<Spot> = rows.iter().map(|r| if copy { Spot::Outside } else { spot_in(d, d.parent_of(*r)) }).collect();
let mut rebuild = vec![];
for f in &from {
if let Spot::Source(g) = *f
&& *f != to
&& !rebuild.contains(&g)
{
for (r, f) in rows.iter().zip(&from) {
let Spot::Source(g) = *f else { continue };
// A shown row that goes into or out of a hidden group among the same paths starts or
// stops giving the group faces and edges.
let shown_changes =
*f == to && d.node(*r).is_some_and(|n| n.visible) && shown_in_sources(d, d.parent_of(*r), g) != shown_in_sources(d, parent, g);
if (*f != to || shown_changes) && !rebuild.contains(&g) {
rebuild.push(g);
}
}
@@ -444,7 +485,9 @@ impl LivePaintMove {
for g in groups {
if Some(g) == join_group {
let roots: Vec<NodeId> = std::iter::once(g).chain(joined.iter().copied()).collect();
merge_live(d, sel, &roots)?;
// Rows that join a group with no path outline among them keep the move: the group
// is left with no faces or edges, as when its last path leaves it.
merge_live(d, sel, &roots, true)?;
} else if d.node(g).is_some() {
rebuild_paths(d, g)?;
}
+32 -7
View File
@@ -58,6 +58,12 @@ fn view_param(cmd: &str, p: &Value) -> Result<Option<TraceView>> {
v.as_str().and_then(TraceView::from_id).map(Some).ok_or_else(|| bad(cmd, format!("view must be one of {}", ids())))
}
/// The `split` param (the Split view's divider, 0 to 1), if given.
fn split_param(cmd: &str, p: &Value) -> Result<Option<f64>> {
let Some(v) = p.get("split").filter(|v| !v.is_null()) else { return Ok(None) };
v.as_f64().filter(|f| (0.0..=1.0).contains(f)).map(Some).ok_or_else(|| bad(cmd, "split must be a number from 0 to 1"))
}
/// A saved Image Trace preset ([`crate::Prefs::trace_presets`]): a name and its settings.
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
@@ -1026,9 +1032,14 @@ pub(super) fn trace_make(s: &mut Session, p: &Value, expand: bool) -> Result<Val
let mut g = Node::group(gid, children);
g.name = if expand { None } else { Some(TRACE_NAME.into()) };
if !expand {
// Tracing again keeps the object's view unless another is asked for.
// Tracing again keeps the object's view unless another is asked for, and the Split
// view's divider.
let view = view.unwrap_or_else(|| src.trace_view());
g.extras_mut().trace = Some(Box::new(json!({ "preset": preset_label, "params": params_json, "view": view.id() })));
let mut t = json!({ "preset": preset_label, "params": params_json, "view": view.id() });
if let Some(split) = src.extras().trace.as_deref().and_then(|t| t.get("split")).filter(|v| !v.is_null()) {
t["split"] = split.clone();
}
g.extras_mut().trace = Some(Box::new(t));
}
let (par, idx, _) = d.position(target).ok_or(EngineError::NoNode(target))?;
d.remove(target)?;
@@ -1127,23 +1138,37 @@ fn trace_targets(s: &Session, p: &Value) -> Result<Vec<NodeId>> {
pub(super) fn trace_set_view(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "imageTrace.setView";
let view = view_param(C, p)?.ok_or_else(|| bad(C, "view is required"))?;
let split = split_param(C, p)?;
let targets = trace_targets(s, p)?;
let d = &s.doc()?.doc;
if targets.iter().all(|g| d.node(*g).is_some_and(|n| n.trace_view() == view)) {
return Ok(json!({ "ids": ids_json(&targets), "view": view.id() }));
let result = |d: &vectorcraft_doc::Document| {
let mut r = json!({ "ids": ids_json(&targets), "view": view.id() });
if view == TraceView::Split
&& let Some(n) = targets.first().and_then(|g| d.node(*g))
{
r["split"] = json!(split.unwrap_or_else(|| n.trace_split()));
}
r
};
if targets.iter().all(|g| d.node(*g).is_some_and(|n| n.trace_view() == view && split.is_none_or(|f| n.trace_split() == f))) {
return Ok(result(d));
}
s.edit("Image Trace View", |d, _| {
for g in &targets {
let n = d.node_mut(*g).ok_or(EngineError::NoNode(*g))?;
if n.extras_if_any().and_then(|e| e.trace.as_deref()).is_none_or(|t| !t.is_object()) {
n.extras_mut().trace = Some(Box::new(json!({ "preset": "Custom" })));
}
if let Some(t) = n.extras_if_any().and_then(|e| e.trace.as_deref_mut()).and_then(Value::as_object_mut) {
t.insert("view".into(), json!(view.id()));
} else {
n.extras_mut().trace = Some(Box::new(json!({ "preset": "Custom", "view": view.id() })));
if let Some(f) = split {
t.insert("split".into(), json!(f));
}
}
}
Ok(())
})?;
Ok(json!({ "ids": ids_json(&targets), "view": view.id() }))
Ok(result(&s.doc()?.doc))
}
pub(super) fn trace_release(s: &mut Session, p: &Value) -> Result<Value> {
+92 -6
View File
@@ -47,10 +47,19 @@ pub fn specs() -> Vec<CommandSpec> {
"Swatch Conflicts",
[],
None,
"{} → {swatches: [{name, document, clipboard, spot}]} the global or spot swatches the copied objects use whose name the active document gives another colour (`document`/`clipboard`: #rrggbb): Paste asks Merge or Add for each (pass the answer as edit.paste* {swatchConflict}). Pasting back into the document the objects came from raises none",
"{profileMismatch?: as edit.paste} → {swatches: [{name, document, clipboard, spot}]} the global or spot swatches the copied objects use whose name the active document gives another colour (`document`/`clipboard`: #rrggbb, the pasted colour as the paste brings it, converted when profileMismatch or the policy converts it): Paste asks Merge or Add for each (pass the answer as edit.paste* {swatchConflict}). Pasting back into the document the objects came from raises none, unless the paste converts its colours",
has_doc,
conflicts
),
cmd!(
query "clipboard.profileMismatch",
"Paste Profile Mismatch",
[],
None,
"{sourceDocument?, ids?: as edit.dropSelection, allArtboards?: false (true: for edit.pasteOnAllArtboards, which leaves the background colors of copied artboards behind)} → {mismatches: [{model: \"rgb\"|\"cmyk\", clipboard, document, default: \"preserveNumbers\"|\"convert\", convertible}]} the color models whose colors the copied objects (with sourceDocument and ids: the objects edit.dropSelection drops) use and whose profile in the document they were copied from (its assigned profile, else the working space then; an assigned profile removed since: the working space) is not the active document's: Paste keeps their numbers or converts them into the document's profile as edit.paste* and edit.dropSelection {profileMismatch} say, else as the model's policy of edit.colorSettings does (convert: converts; the others: keeps the numbers). convertible: false when either profile is not available (removed with color.removeProfile): the colors then keep their numbers whatever the choice, and default is preserveNumbers. With askMismatchPaste on, the desktop app asks first. Objects from outside an open document have none",
has_doc,
profile_mismatch
),
];
v.extend(flavours::specs());
v
@@ -100,6 +109,15 @@ pub struct Clipboard {
/// The selected ruler guides copied with (or without) the objects (#3226), as canvas guides on
/// no layer: pasting puts them on the layer new art goes to, moved as the objects are.
pub guides: Vec<vectorcraft_doc::Guide>,
/// The RGB and CMYK profiles the objects' colors showed through in the document they were
/// copied from (its assigned profiles, else the working spaces then), by name; none for objects
/// from outside an open document. Paste compares them with the destination's
/// ([`super::colormgmt::paste_mismatches`]).
pub source_profiles: Option<[String; 2]>,
/// The colors were converted for this paste ([`super::colormgmt::paste_profiles`]): back in the
/// source document its resources of the same names are compared with them, as another
/// document's are, while its layers are still found by id.
pub colors_converted: bool,
}
/// The layer an object was copied from, as Paste Remembers Layers finds it again: the top-level
@@ -264,6 +282,7 @@ impl Clipboard {
pub fn from_node(st: &DocState, node: Node) -> Self {
let mut clip = Self::gather(&st.doc, vec![node]);
clip.source_doc = Some(st.uid);
clip.source_profiles = Some(super::colormgmt::effective_profiles(&st.doc));
clip
}
@@ -335,6 +354,7 @@ impl Clipboard {
source_artboard: board.and_then(|i| d.artboards.get(i)).map(|a| a.rect),
source_layers,
source_doc: Some(st.uid),
source_profiles: Some(super::colormgmt::effective_profiles(d)),
..Self::gather(d, nodes)
}
}
@@ -369,7 +389,7 @@ impl Clipboard {
/// The swatch name conflicts pasting into `st` raises, as (pasted, document) swatches: none
/// back in the document the objects came from.
pub fn swatch_conflicts<'a>(&'a self, st: &'a DocState) -> Vec<(&'a Swatch, &'a Swatch)> {
if self.source_doc == Some(st.uid) {
if self.source_doc == Some(st.uid) && !self.colors_converted {
return vec![];
}
self.conflicts(&st.doc, &self.used())
@@ -419,6 +439,56 @@ impl Clipboard {
d
}
/// The clipboard with every color of its objects and of the resources it carries (swatches,
/// symbols, patterns, graphic styles, brushes, character and paragraph styles, the background
/// colors of copied artboards) mapped by `conv`, as Document Color Mode maps a document's
/// ([`super::colormgmt::convert_art_and_style_colors`]).
/// Images keep their pixels.
pub(crate) fn with_colors(&self, conv: &dyn Fn(&vectorcraft_color::Color) -> vectorcraft_color::Color) -> Self {
let mut d = self.to_document();
// Only what the clipboard carries: not the swatches, graphic styles and brushes every new
// document starts with.
d.swatches = self.swatches.clone().into();
d.swatch_groups = Default::default();
d.graphic_styles = self.graphic_styles.clone().into();
vectorcraft_brush::store(&mut d, &self.brushes);
// Not the stand-in document's own artboard and Document Setup colors: only what the
// clipboard carries is mapped.
super::colormgmt::convert_art_and_style_colors(&mut d, conv);
// `to_document` puts the objects in its one layer.
let nodes = d.layers.first().and_then(|l| l.children()).map(|ch| ch.iter().map(|n| (**n).clone()).collect()).unwrap_or_default();
Self {
nodes,
symbols: d.symbols.clone(),
patterns: d.patterns.clone(),
swatches: d.swatches.to_vec(),
graphic_styles: d.graphic_styles.to_vec(),
char_styles: d.char_styles.to_vec(),
para_styles: d.para_styles.to_vec(),
brushes: vectorcraft_brush::library(&d),
images: self.images.clone(),
symbol_options: self.symbol_options.clone(),
source_artboard: self.source_artboard,
source_layers: self.source_layers.clone(),
source_doc: self.source_doc,
// The background colors of copied artboards map too.
artboards: self
.artboards
.iter()
.map(|a| {
let mut a = a.clone();
if let Some(c) = a.color.as_mut() {
*c = conv(c);
}
a
})
.collect(),
guides: self.guides.clone(),
source_profiles: self.source_profiles.clone(),
colors_converted: self.colors_converted,
}
}
/// The objects as standalone SVG (`None` when there are none).
pub fn svg(&self) -> Option<String> {
if !self.has_art() {
@@ -486,17 +556,33 @@ fn import_svg(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "count": s.load_clipboard(clip, p)? }))
}
fn conflicts(s: &mut Session, _: &Value) -> Result<Value> {
fn conflicts(s: &mut Session, p: &Value) -> Result<Value> {
let hex = |w: &Swatch| w.paint.color().map(|c| c.to_hex());
let list: Vec<Value> = s
.clipboard
.swatch_conflicts(s.doc()?)
// The swatches as the paste brings them: converted from another profile when it converts.
let profile = super::colormgmt::PasteProfile::param(p, "clipboard.conflicts")?;
let st = s.doc()?;
let (converted, _) = super::colormgmt::paste_profiles(&s.clipboard, &st.doc, profile, true);
let list: Vec<Value> = converted
.as_ref()
.unwrap_or(&s.clipboard)
.swatch_conflicts(st)
.into_iter()
.map(|(c, t)| json!({"name": c.name, "document": hex(t), "clipboard": hex(c), "spot": c.spot}))
.collect();
Ok(json!({ "swatches": list }))
}
fn profile_mismatch(s: &mut Session, p: &Value) -> Result<Value> {
const CMD: &str = "clipboard.profileMismatch";
// With `sourceDocument` and `ids`, the objects a drop brings, else the clipboard's.
let dropped = if p.get("sourceDocument").is_some() || p.get("ids").is_some() { Some(super::edit::drop_clip(s, p, CMD)?) } else { None };
let clip = dropped.as_ref().unwrap_or(&s.clipboard);
// Paste on All Artboards leaves the copied artboards, and so their backgrounds, behind.
let all_artboards = super::switch_or(p, "allArtboards", false, CMD)?;
let list: Vec<Value> = super::colormgmt::paste_mismatches(clip, &s.doc()?.doc, !all_artboards).iter().map(|m| m.to_json()).collect();
Ok(json!({ "mismatches": list }))
}
#[cfg(test)]
mod tests {
use super::*;
+175 -8
View File
@@ -20,12 +20,14 @@ use std::sync::Arc;
use serde_json::{Map, Value, json};
use vectorcraft_brush::Brush;
use vectorcraft_color::{Color, Paint, Swatch};
use vectorcraft_doc::text::{KINSOKU_NAME_MAX, KINSOKU_SETS_MAX};
use vectorcraft_doc::{
Appearance, AppearanceItem, Document, Effect, GraphicStyle, Node, NodeKind, PatternDef, Symbol, SymbolExportType, SymbolNineSlice,
SymbolRegistration, TextStyleDef,
Appearance, AppearanceItem, Document, Effect, GraphicStyle, Kinsoku, KinsokuSet, Node, NodeKind, PatternDef, Symbol, SymbolExportType,
SymbolNineSlice, SymbolRegistration, TextStyleDef,
};
use super::super::brushsym::{set_natural_size, stored_natural_size};
use super::super::typecmd::refresh_bounds;
use super::super::patterncmds::add_pattern;
use super::super::{EngineError, Result, bad, unique_name};
@@ -517,6 +519,36 @@ fn copy_of(base: &str, name: &str) -> bool {
name == base || name.strip_prefix(base).and_then(|r| r.strip_prefix(' ')).is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()))
}
/// The `i`th numbered copy of a Kinsoku Shori set's name `base` ("name 2"), within
/// [`KINSOKU_NAME_MAX`]: when it would be too long, the number takes the place of the name's last
/// characters, and spaces left at the end of what remains are dropped.
fn numbered_kinsoku_name(base: &str, i: usize) -> String {
let number = format!(" {i}");
let head: String = base.chars().take(KINSOKU_NAME_MAX.saturating_sub(number.chars().count())).collect();
format!("{}{number}", head.trim_end())
}
/// [`unique_name`] for a pasted Kinsoku Shori set among `sets` (a document's custom sets, any
/// case), with names that fit [`KINSOKU_NAME_MAX`] ([`numbered_kinsoku_name`]).
fn unique_kinsoku_name(base: &str, sets: &[KinsokuSet]) -> String {
let taken = |n: &str| KinsokuSet::named(sets, n).is_some();
if !taken(base) {
return base.to_string();
}
(2..).map(|i| numbered_kinsoku_name(base, i)).find(|n| !taken(n)).unwrap_or_else(|| base.to_string())
}
/// Is `name` (any case) the Kinsoku Shori set name `base` or a numbered copy of it, as
/// [`unique_kinsoku_name`] names one?
fn kinsoku_copy_of(base: &str, name: &str) -> bool {
KinsokuSet::same_name(base, name)
|| name.rsplit_once(' ').is_some_and(|(_, n)| {
!n.is_empty()
&& n.bytes().all(|b| b.is_ascii_digit())
&& n.parse::<usize>().is_ok_and(|i| i >= 2 && KinsokuSet::same_name(&numbered_kinsoku_name(base, i), name))
})
}
/// The document's own resource for pasted resource `name`, among the document's `names`: the
/// one of that name when `same` holds for it (or, pasting back into the source document, at all),
/// else a numbered copy of it (added by an earlier paste) that is the same. `None`: add it.
@@ -600,6 +632,9 @@ struct Relink {
styles: BTreeMap<u32, u32>,
/// Swatch (its name in the document) → the colour linked colours show at 100 %.
colors: BTreeMap<String, Color>,
/// A custom Kinsoku set the pasted paragraphs and paragraph styles hold → the document's set
/// they take, or none (Hard) when the document has no room for it ([`Clipboard::import_kinsoku_sets`]).
kinsoku: HashMap<KinsokuSet, Option<Arc<KinsokuSet>>>,
/// Leave graphic style links as they are ([`Clipboard::show_merged_colors`]).
keep_styles: bool,
}
@@ -646,11 +681,19 @@ impl Relink {
}
}
}
// A 3D effect's mapped graphics follow their symbols' names in the document. Each name is
// looked up once, so renames that chain (A to B, B to C) do not apply twice.
// A 3D effect's mapped graphics and Map Art maps follow their symbols' names in the
// document. Each name is looked up once, so renames that chain (A to B, B to C) do not
// apply twice.
let items = a.items.iter_mut().flat_map(|i| i.effects_mut().iter_mut());
for e in a.effects.iter_mut().chain(items).filter(|e| vectorcraft_render::effects::takes_graphics(&e.id)) {
let list = e.params.get_mut(vectorcraft_render::effects::GRAPHICS).and_then(Value::as_array_mut);
for e in a.effects.iter_mut().chain(items) {
let key = if vectorcraft_render::effects::takes_graphics(&e.id) {
vectorcraft_render::effects::GRAPHICS
} else if vectorcraft_render::effects::takes_map_art(&e.id) {
vectorcraft_render::effects::MAP_ART
} else {
continue;
};
let list = e.params.get_mut(key).and_then(Value::as_array_mut);
for g in list.into_iter().flatten() {
if let Some(Value::String(s)) = g.get_mut("symbol") {
self.name(Res::Symbol, s);
@@ -667,6 +710,17 @@ impl Relink {
}
}
fn attrs(&self, a: &mut Map<String, Value>) {
if let Some(to) =
a.get("kinsoku_set").and_then(|v| serde_json::from_value::<KinsokuSet>(v.clone()).ok()).and_then(|set| self.kinsoku.get(&set))
{
match to {
Some(set) => a.insert("kinsoku_set".into(), json!(set)),
None => {
a.insert("kinsoku".into(), json!(Kinsoku::Hard));
a.insert("kinsoku_set".into(), Value::Null)
}
};
}
for k in STYLE_PAINTS {
let Some(before) = style_paint(a, k) else { continue };
let mut p = before.clone();
@@ -707,6 +761,10 @@ impl Relink {
if let Some(s) = &mut pa.style_name {
self.name(Res::ParaStyle, s);
}
// A graph draws its labels again from the paragraph attributes it keeps for them.
if let Some(to) = pa.kinsoku_set.as_deref().and_then(|set| self.kinsoku.get(set)) {
pa.kinsoku_set = to.clone();
}
}
for r in [&mut l.values_rows, &mut l.categories_rows, &mut l.legend_rows, &mut l.axis_rows, &mut l.ring_rows].into_iter().flatten() {
r.paint.fill.iter_mut().chain(r.paint.stroke.iter_mut()).for_each(|p| self.paint(p));
@@ -721,10 +779,21 @@ impl Relink {
self.name(Res::CharStyle, s);
}
}
// Lines break anew when a paragraph's set takes other characters or Hard.
let mut relaid = false;
for pa in t.para_styles_mut() {
if let Some(s) = &mut pa.style_name {
self.name(Res::ParaStyle, s);
}
if let Some(set) = pa.kinsoku_set.as_deref()
&& let Some(to) = self.kinsoku.get(set)
{
relaid |= to.as_deref().is_none_or(|to| kinsoku_chars(to) != kinsoku_chars(set));
pa.kinsoku_set = to.clone();
}
}
if relaid {
refresh_bounds(t);
}
}
NodeKind::Image(im) => self.name(Res::Image, &mut im.key),
@@ -738,6 +807,11 @@ impl Relink {
}
}
/// The characters and sequences of Kinsoku set `s`, without its name.
fn kinsoku_chars(s: &KinsokuSet) -> (&[char], &[char], &[char], &[String]) {
(&s.cannot_start, &s.cannot_end, &s.hanging, &s.inseparable)
}
/// Is `ours` (a document definition's art) the art of `theirs` (a pasted one's) once that is
/// relinked by `r`? Graphic style links don't count: they are relinked last.
fn same_art(r: &Relink, ours: &[Arc<Node>], theirs: &[Arc<Node>]) -> bool {
@@ -1121,8 +1195,11 @@ impl Clipboard {
/// uses, as [`import_text_styles`] places them, so that a style that paints with a pattern added
/// under a free name ("Dots 2") is compared and added with that name. An error, with `d`
/// unchanged, when a pasted SVG filter finds no free name ([`Self::filter_links`]).
/// `same_doc`: `d` is the document the objects were copied from. With colors converted for the
/// paste ([`Self::colors_converted`]), its color-bearing resources are compared as another
/// document's are, while its image blobs are still the document's own under their keys.
pub(crate) fn import_into(&self, d: &mut Document, choices: &SwatchChoices, same_doc: bool) -> Result<Imported> {
self.import_used(d, &self.used(), choices, same_doc)
self.import_used_with_images(d, &self.used(), choices, same_doc && !self.colors_converted, same_doc)
}
/// Give the objects' colors linked to a global or spot swatch whose conflict with `d`
@@ -1155,10 +1232,24 @@ impl Clipboard {
/// other is matched on its own ([`loop_groups`]). Pasted back into its own document
/// (`same_doc`), each definition of a loop is the document's of its name.
fn import_used(&self, d: &mut Document, used: &Used, choices: &SwatchChoices, same_doc: bool) -> Result<Imported> {
self.import_used_with_images(d, used, choices, same_doc, same_doc)
}
/// [`Self::import_used`], with the image blobs matched as those of the document they came
/// from when `same_doc_images`.
fn import_used_with_images(
&self,
d: &mut Document,
used: &Used,
choices: &SwatchChoices,
same_doc: bool,
same_doc_images: bool,
) -> Result<Imported> {
let mut out = Imported::default();
out.relink.filters = self.filter_links(d, same_doc)?;
self.import_images(d, used, same_doc, &mut out);
self.import_images(d, used, same_doc_images, &mut out);
self.import_swatches(d, used, choices, same_doc, &mut out);
self.import_kinsoku_sets(d, used, same_doc, &mut out);
let mut defs: Vec<Def<'_>> = vec![];
for (r, list) in [(Res::CharStyle, &self.char_styles), (Res::ParaStyle, &self.para_styles)] {
defs.extend(list.iter().filter(|s| used.has(r, &s.name)).map(|s| Def::Style(r, s)));
@@ -1305,10 +1396,86 @@ impl Clipboard {
&& out.relink.filters.is_empty()
&& out.relink.styles.is_empty()
&& out.relink.colors.is_empty()
&& out.relink.kinsoku.is_empty()
&& used.styles.is_empty());
Ok(out)
}
/// Add the custom Kinsoku sets that the pasted paragraphs and the used paragraph styles hold
/// to `d`'s sets, and record in [`Relink::kinsoku`] which set of `d` each one takes. A set
/// takes `d`'s set of its name (in any case) when that has the same characters, or, pasted
/// back into its own document, in any case; else a numbered copy of it ("Tight 2") with the
/// same characters. Any other set is added under a free name that fits [`KINSOKU_NAME_MAX`]
/// ([`unique_kinsoku_name`]), so editing `d`'s set of that name leaves the pasted paragraphs
/// alone. When `d` already holds [`KINSOKU_SETS_MAX`] sets, or the pasted set's own name is
/// longer than a name can be, the paragraphs and styles take Hard.
fn import_kinsoku_sets(&self, d: &mut Document, used: &Used, same_doc: bool, out: &mut Imported) {
let mut found: Vec<KinsokuSet> = vec![];
let mut seen: HashSet<KinsokuSet> = HashSet::new();
let mut note = |set: &KinsokuSet| {
if !seen.contains(set) {
seen.insert(set.clone());
found.push(set.clone());
}
};
let mut nodes = |n: &Node| {
// Opacity-mask art included.
vectorcraft_doc::swatches::walk_with_masks(n, &mut |m| {
if let NodeKind::Text(t) = &m.kind {
t.para_styles().filter_map(|p| p.kinsoku_set.as_deref()).for_each(&mut note);
}
// The paragraph attributes a graph keeps for its labels.
if let Some(spec) = m.extras().graph.as_deref() {
let l = &spec.label_styles;
[&l.values_para, &l.categories_para, &l.legend_para]
.into_iter()
.flatten()
.filter_map(|p| p.kinsoku_set.as_deref())
.for_each(&mut note);
}
});
};
self.nodes.iter().for_each(&mut nodes);
self.symbols.iter().filter(|s| used.has(Res::Symbol, &s.name)).for_each(|s| nodes(s.art.as_ref()));
self.patterns.iter().filter(|p| used.has(Res::Pattern, &p.name)).flat_map(|p| p.art.iter()).for_each(|a| nodes(a.as_ref()));
self.brushes.iter().filter(|b| used.has(Res::Brush, &b.name)).flat_map(Brush::art).for_each(&mut nodes);
let styles = self.para_styles.iter().filter(|s| used.has(Res::ParaStyle, &s.name));
for set in styles.filter_map(|s| s.attrs.get("kinsoku_set")).filter_map(|v| serde_json::from_value::<KinsokuSet>(v.clone()).ok()) {
note(&set);
}
for set in found {
let lower = set.name.to_lowercase();
let mut copies: Vec<&KinsokuSet> =
d.kinsoku_sets.iter().filter(|x| copy_of(&lower, &x.name.to_lowercase()) || kinsoku_copy_of(&set.name, &x.name)).collect();
// The set of its name first.
copies.sort_by_key(|x| !KinsokuSet::same_name(&x.name, &set.name));
let own = copies.first().copied().filter(|x| same_doc && KinsokuSet::same_name(&x.name, &set.name));
let to = match own.or_else(|| copies.iter().copied().find(|x| kinsoku_chars(x) == kinsoku_chars(&set))) {
Some(x) => {
if !KinsokuSet::same_name(&x.name, &set.name) {
out.renamed.push(json!({"kind": "kinsokuSet", "from": set.name, "to": x.name}));
}
Some(Arc::new(x.clone()))
}
None => {
let name = unique_kinsoku_name(&set.name, &d.kinsoku_sets);
(d.kinsoku_sets.len() < KINSOKU_SETS_MAX && name.chars().count() <= KINSOKU_NAME_MAX).then(|| {
let added = KinsokuSet { name: name.clone(), ..set.clone() };
d.kinsoku_sets.push(added.clone());
out.added += 1;
if name != set.name {
out.renamed.push(json!({"kind": "kinsokuSet", "from": set.name, "to": name}));
}
Arc::new(added)
})
}
};
if to.as_deref() != Some(&set) {
out.relink.kinsoku.insert(set, to);
}
}
}
/// How the pasted SVG filter effects relink ([`Relink::filters`]). Each names the document's
/// filter of its name; one that draws another definition than that filter takes the document's
/// filter when pasted back into the document it came from, and elsewhere keeps its own under a
+466 -28
View File
@@ -37,7 +37,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Color Settings…",
["Edit"],
Some("Cmd+Shift+K"),
"{rgb?: profile, cmyk?: profile, intent?: \"perceptual\"|\"relative\"|\"saturation\"|\"absolute\", bpc?: bool, rgbPolicy?: \"off\"|\"preserveEmbedded\"|\"convert\", cmykPolicy?: \"off\"|\"preserveEmbedded\"|\"convert\"|\"preserveNumbers\"} set the working spaces and the color management policies → {rgb, cmyk, intent, bpc, rgbPolicy, cmykPolicy, profiles: [{name, kind, builtin}]}. A policy decides what opening a document (document.open, file.newFromTemplate, file.revert) does with an RGB or CMYK profile it is tagged with that is not the working space: preserveEmbedded (default) keeps it; off and preserveNumbers take it off and keep the color numbers; convert converts the colors of that model into the working space with the intent and bpc and takes it off. The open reply's warnings name each profile taken off or converted, and a document a policy changed opens with unsaved changes. The desktop app and vectorcraft-cli keep them in `Color Settings.json` next to the preferences and use them again at the next start (not with VECTORCRAFT_NO_PREFS); saved settings naming a profile that is gone leave the defaults",
"{rgb?: profile, cmyk?: profile, intent?: \"perceptual\"|\"relative\"|\"saturation\"|\"absolute\", bpc?: bool, rgbPolicy?: \"off\"|\"preserveEmbedded\"|\"convert\", cmykPolicy?: \"off\"|\"preserveEmbedded\"|\"convert\"|\"preserveNumbers\", askMismatchOpen?: bool, askMismatchPaste?: bool, askMissingOpen?: bool (all false by default)} set the working spaces, the color management policies and the Ask boxes → {rgb, cmyk, intent, bpc, rgbPolicy, cmykPolicy, askMismatchOpen, askMismatchPaste, askMissingOpen, profiles: [{name, kind, builtin}]}. With askMismatchOpen or askMissingOpen on, the desktop app's File › Open asks what to do when the profile of a document's color mode is not the working space, or it has none (document.open takes the answer as profileChoice; it never asks); with askMismatchPaste on, Paste asks whether colors copied from a document with another profile keep their numbers or convert (edit.paste takes it as profileMismatch; see clipboard.profileMismatch). A policy decides what opening a document (document.open, file.newFromTemplate, file.revert) does with an RGB or CMYK profile it is tagged with that is not the working space: preserveEmbedded (default) keeps it; off and preserveNumbers take it off and keep the color numbers; convert converts the colors of that model into the working space with the intent and bpc and takes it off. The open reply's warnings name each profile taken off or converted, and a document a policy changed opens with unsaved changes. The desktop app and vectorcraft-cli keep them in `Color Settings.json` next to the preferences and use them again at the next start (not with VECTORCRAFT_NO_PREFS); saved settings naming a profile that is gone leave the defaults",
always,
color_settings
),
@@ -183,6 +183,9 @@ fn settings_json(st: &ColorSettings) -> Value {
"bpc": st.bpc,
"rgbPolicy": st.rgb_policy.id(),
"cmykPolicy": st.cmyk_policy.id(),
"askMismatchOpen": st.ask_mismatch_open,
"askMismatchPaste": st.ask_mismatch_paste,
"askMissingOpen": st.ask_missing_open,
"profiles": cms::profiles().iter().map(|p| json!({"name": p.name, "kind": p.kind, "builtin": p.builtin})).collect::<Vec<_>>(),
})
}
@@ -225,6 +228,9 @@ fn color_settings(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(v) = policy_param(p, "cmykPolicy", &Policy::CMYK, C)? {
st.cmyk_policy = v;
}
st.ask_mismatch_open = switch_or(p, "askMismatchOpen", st.ask_mismatch_open, C)?;
st.ask_mismatch_paste = switch_or(p, "askMismatchPaste", st.ask_mismatch_paste, C)?;
st.ask_missing_open = switch_or(p, "askMissingOpen", st.ask_missing_open, C)?;
if st != before {
cms::set_active(&st).map_err(|e| bad(C, e.to_string()))?;
// Saved for the next start when the app attached a settings file (#6335).
@@ -659,39 +665,259 @@ fn convert_colors(d: &mut vectorcraft_doc::Document, conv: &dyn Fn(&Color) -> Co
/// by Off and Preserve Numbers and kept by Convert to Working Space, which has nothing to convert
/// from. → a note for each profile, and whether `d` changed.
pub(crate) fn apply_open_policies(d: &mut vectorcraft_doc::Document) -> (Vec<String>, bool) {
// Without a choice nothing can fail.
apply_open_policies_choosing(d, None).unwrap_or_default()
}
/// What opening a document can ask about its profile (Edit › Color Settings' Ask When Opening
/// boxes): the profile of its color mode differs from the working space, or it has none.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProfileIssue {
/// Profile Mismatches: tagged with a profile other than the working space.
Mismatch,
/// Missing Profiles: not tagged with a profile.
Missing,
}
impl ProfileIssue {
pub fn id(self) -> &'static str {
match self {
ProfileIssue::Mismatch => "mismatch",
ProfileIssue::Missing => "missing",
}
}
}
/// The answer to a [`ProfileQuestion`] (`document.open`'s `profileChoice`).
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ProfileChoice {
/// Mismatch: keep the profile (as Preserve Embedded Profiles).
UseEmbedded,
/// Mismatch: convert the colors of that model into the working space and take the profile off
/// (as Convert to Working Space).
Convert,
/// Mismatch: take the profile off and keep the color numbers (as Off).
Discard,
/// Missing: leave the document untagged (it follows the working space).
Leave,
/// Missing: tag the document with the working space of its color mode.
AssignWorking,
/// Missing: tag the document with this profile.
Assign(String),
}
impl ProfileChoice {
/// The ids `profileChoice` takes.
pub const IDS: [&'static str; 6] = ["useEmbedded", "convert", "discard", "leave", "assignWorking", "assign"];
pub fn id(&self) -> &'static str {
match self {
ProfileChoice::UseEmbedded => "useEmbedded",
ProfileChoice::Convert => "convert",
ProfileChoice::Discard => "discard",
ProfileChoice::Leave => "leave",
ProfileChoice::AssignWorking => "assignWorking",
ProfileChoice::Assign(_) => "assign",
}
}
/// The question kind this choice answers.
pub fn issue(&self) -> ProfileIssue {
match self {
ProfileChoice::UseEmbedded | ProfileChoice::Convert | ProfileChoice::Discard => ProfileIssue::Mismatch,
_ => ProfileIssue::Missing,
}
}
/// The choice `id` (`profile`, which only `assign` takes, for `assign`), or an error naming
/// `cmd`.
pub fn parse(id: &str, profile: Option<&str>, cmd: &str) -> Result<Self> {
let key = "profileChoice";
let choice = match id {
"useEmbedded" => ProfileChoice::UseEmbedded,
"convert" => ProfileChoice::Convert,
"discard" => ProfileChoice::Discard,
"leave" => ProfileChoice::Leave,
"assignWorking" => ProfileChoice::AssignWorking,
"assign" => match profile.filter(|p| !p.is_empty()) {
Some(p) => ProfileChoice::Assign(cms::canonical_name(p).to_string()),
None => {
let path = "assignProfile";
return Err(bad(cmd, format!("missing `{path}`")));
}
},
_ => return Err(bad(cmd, format!("`{key}` must be one of {}", Self::IDS.join(", ")))),
};
// `assignProfile` goes with `assign` only.
if profile.is_some() && !matches!(choice, ProfileChoice::Assign(_)) {
let path = "assignProfile";
return Err(bad(cmd, format!("`{path}` goes with `{key}`: \"assign\" only")));
}
Ok(choice)
}
/// `document.open`'s `profileChoice` and `assignProfile` in `p` (`None` when left out).
pub(crate) fn param(p: &Value, cmd: &str) -> Result<Option<Self>> {
let profile = text_param(p, "assignProfile", cmd)?;
match text_param(p, "profileChoice", cmd)? {
Some(id) => Self::parse(id, profile, cmd).map(Some),
None if profile.is_some() => {
let path = "profileChoice";
Err(bad(cmd, format!("missing `{path}`")))
}
None => Ok(None),
}
}
}
/// What opening document `d` could ask about the profile of its color mode, with the working
/// settings `st`: none when it is tagged with the working space.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProfileQuestion {
pub issue: ProfileIssue,
/// The model of the document's color mode.
pub model: ColorMode,
/// The profile the document is tagged with (none when it is missing).
pub profile: Option<String>,
/// The working space of that model.
pub working: String,
/// What the policy of that model does, the choice the prompt starts on.
pub default: ProfileChoice,
}
impl ProfileQuestion {
/// The question for document `d` under the working settings `st` (whether or not they ask it).
pub fn of(d: &vectorcraft_doc::Document, st: &ColorSettings) -> Option<Self> {
let (rgb, cmyk) = doc_profiles(d);
let (tag, working, policy) = match d.color_mode {
ColorMode::Rgb => (rgb, cms::canonical_name(&st.rgb).to_string(), st.rgb_policy),
ColorMode::Cmyk => (cmyk, cms::canonical_name(&st.cmyk).to_string(), st.cmyk_policy),
};
let (issue, default) = match &tag {
Some(t) if *t == working => return None,
Some(_) => (
ProfileIssue::Mismatch,
match policy {
Policy::PreserveEmbedded => ProfileChoice::UseEmbedded,
Policy::Convert => ProfileChoice::Convert,
Policy::Off | Policy::PreserveNumbers => ProfileChoice::Discard,
},
),
// VectorCraft's own rule: Convert to Working Space starts on assigning the working
// space, the other policies on leaving the document as it is.
None => (ProfileIssue::Missing, if policy == Policy::Convert { ProfileChoice::AssignWorking } else { ProfileChoice::Leave }),
};
Some(Self { issue, model: d.color_mode, profile: tag, working, default })
}
/// Do the settings `st` ask it (the Ask When Opening box of its kind is on)?
pub fn asked(&self, st: &ColorSettings) -> bool {
match self.issue {
ProfileIssue::Mismatch => st.ask_mismatch_open,
ProfileIssue::Missing => st.ask_missing_open,
}
}
/// The model's name as the UI shows it ("RGB", "CMYK").
pub fn model_label(&self) -> &'static str {
match self.model {
ColorMode::Rgb => "RGB",
ColorMode::Cmyk => "CMYK",
}
}
pub fn to_json(&self) -> Value {
json!({
"issue": self.issue.id(),
"model": self.model_label().to_ascii_lowercase(),
"profile": self.profile,
"working": self.working,
"default": self.default.id(),
})
}
}
/// [`apply_open_policies`] with the answer `choice` to the document's [`ProfileQuestion`]: a
/// mismatch choice takes the place of the policy of the document's color mode, and a missing
/// choice tags the document after the policies ran. A choice for the other kind of question, or
/// for a document with none, is not used. → as [`apply_open_policies`]; an error when the profile
/// to assign is not a profile of that model.
pub(crate) fn apply_open_policies_choosing(d: &mut vectorcraft_doc::Document, choice: Option<&ProfileChoice>) -> Result<(Vec<String>, bool)> {
let working = cms::working_settings();
let question = ProfileQuestion::of(d, &working);
let choice = choice.filter(|c| question.as_ref().is_some_and(|q| q.issue == c.issue()));
// A mismatch answer stands in for the policy of the document's color mode.
let chosen = |model: ColorMode, policy: Policy| -> (Policy, bool) {
match choice {
Some(c) if d.color_mode == model => match c {
ProfileChoice::UseEmbedded => (Policy::PreserveEmbedded, true),
ProfileChoice::Convert => (Policy::Convert, true),
ProfileChoice::Discard => (Policy::Off, true),
_ => (policy, false),
},
_ => (policy, false),
}
};
let (rgb_policy, rgb_chosen) = chosen(ColorMode::Rgb, working.rgb_policy);
let (cmyk_policy, cmyk_chosen) = chosen(ColorMode::Cmyk, working.cmyk_policy);
// The profile a missing answer assigns, checked before anything changes.
let assign = match (choice, &question) {
(Some(ProfileChoice::AssignWorking), Some(q)) => Some(q.working.clone()),
(Some(ProfileChoice::Assign(name)), Some(q)) => {
let kind = if q.model == ColorMode::Rgb { cms::ProfileKind::Rgb } else { cms::ProfileKind::Cmyk };
let (key, n) = (q.model_label().to_ascii_lowercase(), name);
let info = cms::profile(name).filter(|p| p.kind == kind).ok_or_else(|| bad("document.open", format!("unknown {key} profile `{n}`")))?;
Some(info.name)
}
_ => None,
};
let (rgb, cmyk) = doc_profiles(d);
let mut notes = Vec::new();
// What each model's policy does with its profile: `None` keeps it; `Some` takes it off, after
// converting the colors from the profile it holds.
let mut decide = |label: &str, tag: Option<String>, working: &str, policy: Policy, kind: cms::ProfileKind| -> Option<Option<String>> {
let tag = tag.filter(|t| t != working)?;
let available = cms::profile(&tag).is_some_and(|p| p.kind == kind);
match policy {
Policy::PreserveEmbedded => None,
Policy::Off | Policy::PreserveNumbers => {
notes.push(format!(
"the {label} profile “{tag}” the file is tagged with was not used: Color Settings' {label} policy is {}",
policy.label()
));
Some(None)
}
Policy::Convert if available => {
notes.push(format!(
"the {label} colors were converted from the profile “{tag}” the file is tagged with into the working space “{working}”"
));
Some(Some(tag))
}
Policy::Convert => {
notes.push(format!("the {label} profile “{tag}” the file is tagged with is not available, so its colors were not converted"));
None
// converting the colors from the profile it holds. `by_choice`: the prompt's answer decided.
let mut decide =
|label: &str, tag: Option<String>, working: &str, policy: Policy, by_choice: bool, kind: cms::ProfileKind| -> Option<Option<String>> {
let tag = tag.filter(|t| t != working)?;
let available = cms::profile(&tag).is_some_and(|p| p.kind == kind);
match policy {
Policy::PreserveEmbedded => None,
Policy::Off | Policy::PreserveNumbers if by_choice => {
notes.push(format!("the {label} profile “{tag}” the file is tagged with was discarded, as chosen when it was opened"));
Some(None)
}
Policy::Off | Policy::PreserveNumbers => {
notes.push(format!(
"the {label} profile “{tag}” the file is tagged with was not used: Color Settings' {label} policy is {}",
policy.label()
));
Some(None)
}
Policy::Convert if available => {
notes.push(format!(
"the {label} colors were converted from the profile “{tag}” the file is tagged with into the working space “{working}”"
));
Some(Some(tag))
}
Policy::Convert => {
notes.push(format!("the {label} profile “{tag}” the file is tagged with is not available, so its colors were not converted"));
None
}
}
};
let rgb_do = decide("RGB", rgb, &working.rgb, rgb_policy, rgb_chosen, cms::ProfileKind::Rgb);
let cmyk_do = decide("CMYK", cmyk, &working.cmyk, cmyk_policy, cmyk_chosen, cms::ProfileKind::Cmyk);
let mut changed = false;
if let (Some(name), Some(q)) = (assign, &question) {
let label = q.model_label();
notes.push(format!("the document was assigned the {label} profile “{name}”, as chosen when it was opened"));
match q.model {
ColorMode::Rgb => d.color_profiles.rgb = Some(name),
ColorMode::Cmyk => d.color_profiles.cmyk = Some(name),
}
};
let rgb_do = decide("RGB", rgb, &working.rgb, working.rgb_policy, cms::ProfileKind::Rgb);
let cmyk_do = decide("CMYK", cmyk, &working.cmyk, working.cmyk_policy, cms::ProfileKind::Cmyk);
changed = true;
}
if rgb_do.is_none() && cmyk_do.is_none() {
return (notes, false);
return Ok((notes, changed));
}
let (from_rgb, from_cmyk) = (rgb_do.clone().flatten(), cmyk_do.clone().flatten());
if from_rgb.is_some() || from_cmyk.is_some() {
@@ -713,7 +939,214 @@ pub(crate) fn apply_open_policies(d: &mut vectorcraft_doc::Document) -> (Vec<Str
if cmyk_do.is_some() {
d.color_profiles.cmyk = None;
}
(notes, true)
Ok((notes, true))
}
/// The colors of `d`'s art and resources ([`convert_colors`]) and of its character and paragraph
/// styles, converted with `conv`; not its artboards' backgrounds or Document Setup's colors.
pub(crate) fn convert_art_and_style_colors(d: &mut vectorcraft_doc::Document, conv: &dyn Fn(&Color) -> Color) {
convert_colors(d, conv);
convert_style_colors(d, conv);
}
/// The RGB and CMYK profiles the colors of `d` show through, by name: those it is assigned, else
/// the working spaces. An assigned profile that is not available (removed since) is the working
/// space, as the document draws through it ([`cms::for_document`]).
pub(crate) fn effective_profiles(d: &vectorcraft_doc::Document) -> [String; 2] {
let working = cms::working_settings();
let (rgb, cmyk) = doc_profiles(d);
let available = |name: Option<String>, kind: cms::ProfileKind| name.filter(|n| cms::profile(n).is_some_and(|p| p.kind == kind));
[
available(rgb, cms::ProfileKind::Rgb).unwrap_or_else(|| cms::canonical_name(&working.rgb).to_string()),
available(cmyk, cms::ProfileKind::Cmyk).unwrap_or_else(|| cms::canonical_name(&working.cmyk).to_string()),
]
}
/// What Paste does with the colors of a model when the document they were copied from showed them
/// through another profile than the document they go into (`profileMismatch`).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PasteProfile {
/// The colors keep their numbers.
PreserveNumbers,
/// The colors convert from the source profile into the destination's, which keeps their
/// appearance.
Convert,
}
impl PasteProfile {
pub fn id(self) -> &'static str {
match self {
PasteProfile::PreserveNumbers => "preserveNumbers",
PasteProfile::Convert => "convert",
}
}
/// What a model's policy does to pasted colors (VectorCraft's own mapping): Convert to Working
/// Space converts them, the other policies keep their numbers.
pub fn of(policy: Policy) -> Self {
if policy == Policy::Convert { PasteProfile::Convert } else { PasteProfile::PreserveNumbers }
}
/// The `profileMismatch` param of paste command `cmd` (`None` when left out): one choice for
/// both models, or `{rgb?, cmyk?}` with a choice for each (a model left out follows its policy).
pub(crate) fn param(p: &Value, cmd: &str) -> Result<Option<PasteChoice>> {
let key = "profileMismatch";
let refuse = || bad(cmd, format!("`{key}` must be one of {}", "preserveNumbers, convert, {rgb?, cmyk?} of those"));
let one = |v: &Value| match v.as_str() {
Some("preserveNumbers") => Ok(PasteProfile::PreserveNumbers),
Some("convert") => Ok(PasteProfile::Convert),
_ => Err(refuse()),
};
match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(Value::Object(o)) => {
if o.keys().any(|k| k != "rgb" && k != "cmyk") {
return Err(refuse());
}
let model = |m: &str| o.get(m).map(&one).transpose();
Ok(Some(PasteChoice { rgb: model("rgb")?, cmyk: model("cmyk")? }))
}
Some(v) => {
let c = one(v)?;
Ok(Some(PasteChoice { rgb: Some(c), cmyk: Some(c) }))
}
}
}
}
/// What Paste does with the mismatched colors of each model (`profileMismatch`); a model without a
/// choice follows its policy ([`PasteProfile::of`]).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PasteChoice {
pub rgb: Option<PasteProfile>,
pub cmyk: Option<PasteProfile>,
}
impl PasteChoice {
/// The choice for the colors of `model`, if any.
pub fn of(&self, model: ColorMode) -> Option<PasteProfile> {
match model {
ColorMode::Rgb => self.rgb,
ColorMode::Cmyk => self.cmyk,
}
}
}
/// A model whose colors a paste brings from another profile than the destination's.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PasteMismatch {
pub model: ColorMode,
/// The profile the colors showed through where they were copied.
pub from: String,
/// The profile they show through in the document they go into.
pub to: String,
/// What the model's policy does with them; Preserve Numbers when they can't convert.
pub default: PasteProfile,
/// Both profiles are available, so the colors can convert; otherwise they keep their numbers
/// whatever the choice.
pub convertible: bool,
}
impl PasteMismatch {
pub fn to_json(&self) -> Value {
let model = if self.model == ColorMode::Rgb { "rgb" } else { "cmyk" };
json!({ "model": model, "clipboard": self.from, "document": self.to, "default": self.default.id(), "convertible": self.convertible })
}
}
/// The models whose colors pasting `clip` into `d` brings from another profile: RGB, CMYK or both,
/// each only when the copied objects or the resources they carry hold a color of that model. The
/// background colors of copied artboards count only with `boards` (Paste on All Artboards doesn't
/// paste the artboards).
pub(crate) fn paste_mismatches(clip: &super::clipboard::Clipboard, d: &vectorcraft_doc::Document, boards: bool) -> Vec<PasteMismatch> {
let Some([from_rgb, from_cmyk]) = &clip.source_profiles else { return vec![] };
let [to_rgb, to_cmyk] = effective_profiles(d);
let working = cms::working_settings();
let mut out: Vec<PasteMismatch> =
[(ColorMode::Rgb, from_rgb, to_rgb, working.rgb_policy), (ColorMode::Cmyk, from_cmyk, to_cmyk, working.cmyk_policy)]
.into_iter()
.filter(|(_, from, to, _)| cms::canonical_name(from) != cms::canonical_name(to))
.map(|(model, from, to, policy)| {
let kind = if model == ColorMode::Rgb { cms::ProfileKind::Rgb } else { cms::ProfileKind::Cmyk };
// Both profiles must be here to convert between them.
let here = |name: &str| cms::profile(name).is_some_and(|p| p.kind == kind);
let convertible = here(from) && here(&to);
let default = if convertible { PasteProfile::of(policy) } else { PasteProfile::PreserveNumbers };
PasteMismatch { model, from: from.clone(), to, default, convertible }
})
.collect();
if out.is_empty() {
return out;
}
// Without the artboards when their backgrounds don't paste.
let without_boards;
let clip = if !boards && !clip.artboards.is_empty() {
without_boards = super::clipboard::Clipboard { artboards: vec![], ..clip.clone() };
&without_boards
} else {
clip
};
// Which models the pasted colors use.
let seen = std::cell::Cell::new((false, false));
let _ = clip.with_colors(&|c: &Color| {
let (rgb, cmyk) = seen.get();
seen.set((rgb || matches!(c, Color::Rgb { .. }), cmyk || matches!(c, Color::Cmyk { .. })));
*c
});
let (rgb, cmyk) = seen.get();
out.retain(|m| if m.model == ColorMode::Rgb { rgb } else { cmyk });
out
}
/// The clipboard `clip` as pasting it into `d` brings it: for each mismatched model
/// ([`paste_mismatches`]), its colors keep their numbers or convert from the source profile into
/// the destination's with the working intent, as `choice` says for that model (default: the
/// model's policy, [`PasteProfile::of`]). A source or destination profile that is not available
/// keeps the numbers. `boards`: as [`paste_mismatches`].
/// → the converted clipboard (`None` when nothing converts; its resources paste as another
/// document's) and a line for each mismatched model (`{model, clipboard, document, choice}`).
pub(crate) fn paste_profiles(
clip: &super::clipboard::Clipboard,
d: &vectorcraft_doc::Document,
choice: Option<PasteChoice>,
boards: bool,
) -> (Option<super::clipboard::Clipboard>, Vec<Value>) {
let mismatches = paste_mismatches(clip, d, boards);
let mut report = Vec::new();
let (mut rgb_on, mut cmyk_on) = (false, false);
for m in &mismatches {
let picked = if m.convertible { choice.and_then(|c| c.of(m.model)).unwrap_or(m.default) } else { PasteProfile::PreserveNumbers };
if picked == PasteProfile::Convert {
match m.model {
ColorMode::Rgb => rgb_on = true,
ColorMode::Cmyk => cmyk_on = true,
}
}
let mut line = m.to_json();
if let Some(o) = line.as_object_mut() {
o.remove("default");
o.remove("convertible");
o.insert("choice".into(), json!(picked.id()));
}
report.push(line);
}
if !rgb_on && !cmyk_on {
return (None, report);
}
let Some([from_rgb, from_cmyk]) = &clip.source_profiles else { return (None, report) };
let source = cms::for_document(Some(from_rgb), Some(from_cmyk));
let dest = doc_cms(d);
let intent = cms::working_settings().intent;
let conv = |c: &Color| match c {
Color::Rgb { .. } if rgb_on => source.convert_into(&dest, c, intent),
Color::Cmyk { .. } if cmyk_on => source.convert_into(&dest, c, intent),
_ => *c,
};
let mut converted = clip.with_colors(&conv);
// Converted colors are not the source document's own: its resources of the same names are
// compared with them, as another document's are.
converted.colors_converted = true;
(Some(converted), report)
}
/// The colors of `d` outside its art that [`convert_colors`] leaves, converted with `conv`: each
@@ -726,6 +1159,11 @@ fn convert_setting_colors(d: &mut vectorcraft_doc::Document, conv: &dyn Fn(&Colo
for c in &mut d.setup.grid_colors {
*c = conv(c);
}
convert_style_colors(d, conv);
}
/// The fill and stroke colors of `d`'s character and paragraph styles, converted with `conv`.
fn convert_style_colors(d: &mut vectorcraft_doc::Document, conv: &dyn Fn(&Color) -> Color) {
// A tint of a global swatch is the converted swatch's color at its tint, which
// [`convert_colors`] already gave it.
let bases = global_bases(d);
+58 -2
View File
@@ -1,14 +1,16 @@
//! Creating art: shapes, paths, text.
use serde_json::{Value, json};
use vectorcraft_doc::{Appearance, CharStyle, LiveShape, Node, NodeKind, TextObject};
use vectorcraft_doc::{Appearance, CharStyle, LiveShape, MAX_COORD, Node, NodeKind, TextObject};
use vectorcraft_geom::curvature::{self, NoCircle};
use vectorcraft_geom::{Affine, Anchor, AnchorKind, FillRule, PathData, Point, Rect, SubPath, shapes};
use super::newart::NewArt;
use super::{
CommandSpec, NodeId, Result, Session, bad, bool_or, check_numbers, check_switches, cmd, color_value, f64_or, f64_req, finite_numbers, has_doc,
number_or, str_param, switch_or,
index_opt, number_or, object_param, str_param, switch_or,
};
use crate::EngineError;
pub fn specs() -> Vec<CommandSpec> {
vec![
@@ -75,6 +77,15 @@ pub fn specs() -> Vec<CommandSpec> {
has_doc,
circle_through_points
),
cmd!(
"shape.curvatureCircle",
"Curvature Circle",
[],
None,
"{id, subpath?=0, segment, t: 0..1, convex?=false} → {id, cx, cy, radius, nominal}: a circle with the current paint that touches path `id` at `t` on the segment and bends as the path bends there (its circle of curvature), on the side the path bends toward, or on the other side with convex; a segment that is the usual cubic of a circular arc of 90° or less gives a circle of that arc's own radius (nominal: true), on the concave side the arc's own circle; not pixel-aligned even while Align New Objects to Pixel Grid is on; a straight stretch, a cusp, a corner anchor (t 0 or 1 where two segments meet at an angle of more than half a degree and the anchor is not marked smooth with both handles pulled out, or where they turn by 90° or more; segments of no length between them are passed over, and an anchor reached past one is treated as not marked smooth), a guide, or a circle reaching past the canvas is an error, and nothing is drawn",
has_doc,
curvature_circle
),
cmd!("shape.line", "Line Segment", [], None, "{x1, y1, x2, y2, fill?: bool (Fill Line: the current fill, else none)} → {id}", has_doc, line),
cmd!(
"shape.spiral",
@@ -485,6 +496,51 @@ fn selected_anchor_points(s: &Session) -> Result<Option<Vec<Point>>> {
Ok(matches!(points.len(), 2 | 3).then_some(points))
}
/// A live ellipse that touches a path at a point with the path's curvature there
/// ([`curvature::curvature_circle_on`]). One undo step, named as an Ellipse tool drag is.
fn curvature_circle(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "shape.curvatureCircle";
let id = object_param(p, "id", C)?.ok_or_else(|| bad(C, "missing id"))?;
let si = index_opt(p, "subpath", C)?.unwrap_or(0);
let seg = index_opt(p, "segment", C)?.ok_or_else(|| bad(C, "missing segment"))?;
let t = f64_req(p, "t", C)?;
if !(0.0..=1.0).contains(&t) {
return Err(bad(C, "`t` must be from 0 to 1"));
}
let convex = switch_or(p, "convex", false, C)?;
let found = {
let st = s.doc()?;
let node = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
if node.is_guide() {
return Err(bad(C, "a guide has no curvature circle"));
}
let path = node.path_data().ok_or_else(|| bad(C, format!("object {id} is not a path")))?;
let sp = path.subpaths.get(si).ok_or_else(|| bad(C, "no such subpath"))?;
if seg >= sp.segment_count() {
return Err(bad(C, "no such segment"));
}
curvature::curvature_circle_on(sp, seg, t, convex)
};
let circle = found.map_err(|e| match e {
NoCircle::Straight => bad(C, "the path is straight there, so no circle matches its curvature"),
NoCircle::Cusp => bad(C, "the path has a cusp there, so it has no single curvature"),
NoCircle::Corner => bad(C, "the path has a corner there, so it has no single curvature"),
})?;
let (center, radius) = (circle.center, circle.radius);
let r = Rect::new(center.x - radius, center.y - radius, center.x + radius, center.y + radius);
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.abs() <= MAX_COORD) {
return Err(bad(C, "the circle that matches the path there would reach past the canvas"));
}
let live = LiveShape::Ellipse { w: r.width(), h: r.height(), pie: (0.0, 360.0), xf: Affine::translate(r.origin().to_vec2()) };
// Not pixel-aligned: the circle stays on the path.
let mut out = add_art_unaligned(s, "Ellipse", path_kind(live.to_path(), Some(live)))?;
out["cx"] = json!(center.x);
out["cy"] = json!(center.y);
out["radius"] = json!(radius);
out["nominal"] = json!(circle.nominal);
Ok(out)
}
/// The whole-number count `p` gives for `key` (`5` or `5.0`), or `default` when it is left out or
/// null. A fraction, a negative, a non-finite or a non-number is an error rather than the default.
fn count_or(p: &Value, key: &str, default: u64, cmd: &str) -> Result<u64> {
+145 -16
View File
@@ -18,7 +18,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Document Info",
["Window", "Document Info"],
None,
"{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document: {…, units (English), unitId: the units' Preferences › Units id (points, millimeters, feetInches, …), rasterEffectsPpi, transparency: {gridSize: small|medium|large, gridColors: [#rrggbb, #rrggbb], gridColorsName (a preset's name or Custom), simulatePaper, flattenerPreset} (File › Document Setup's transparency settings, which the document category lists), selectedArtboards: [{index, name, width, height, x, y}] (while the Artboard tool is the current tool, the artboards it has selected, in the document's units, x and y those of the top-left corner from the ruler origin of its active artboard, which the document category lists after the artboards; else empty)}, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts (the type in opacity masks and in the art of symbols and patterns included; with selectionOnly: the selected type's), fontDetails: [{font, match: exact|style|missingWithFallback|missing, family, style, file, embedding: allowed|editing|previewPrint|forbidden|null}] (each font of fonts, in order: how it was found, the face shown (null when none), that face's file name (null for a built-in face) and what its license allows), images, imageObjects: [{name, width, height, linked, file}] (the image objects in the order Linked Images and Embedded Images list them; file: what a linked image's row shows, null for an embedded one), swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the brushes the art's drawn strokes use, each once; with selectionOnly: those the selected objects' strokes use), brushes: [{name, type: calligraphic|scatter|art|pattern|bristle|null}] (those brushes with their types; null: not in the Brushes panel), panelBrushNames (the Brushes panel's brushes), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient that color a part of it above opacity 0 (a stop at opacity 0 counts only where it mixes with a stop above opacity 0 over a stretch of some width), at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients, kinds}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else its kind's name, such as Linear gradient; kinds gives each one's kind, linear|radial|conic|diamond|freeform, when it is named by its kind, else null; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone. brushNames, brushes, spotObjects, patternObjects and gradientObjects leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0 (with selectionOnly too), their characters' paints and colorized images included; objects still counts them as paths, groups and the other kinds",
"{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document: {…, units (English), unitId: the units' Preferences › Units id (points, millimeters, feetInches, …), rasterEffectsPpi, transparency: {gridSize: small|medium|large, gridColors: [#rrggbb, #rrggbb], gridColorsName (a preset's name or Custom), simulatePaper, flattenerPreset} (File › Document Setup's transparency settings, which the document category lists), selectedArtboards: [{index, name, width, height, x, y}] (while the Artboard tool is the current tool, the artboards it has selected, in the document's units, x and y those of the top-left corner from the ruler origin of its active artboard, which the document category lists after the artboards; else empty)}, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts (the type in opacity masks and in the art of symbols and patterns included; with selectionOnly: the selected type's), fontUses: [{font, type: truetype|opentype|unknown, uses}] (each font of fonts, in order: truetype or opentype by the outlines (glyf, or CFF or CFF2) of the face its type is drawn in, unknown for a font not installed in the family and style it names; uses: the text objects set in it, each once however many of its runs use the font, the type in a mask or in a symbol's or pattern's art once however many objects show it; the fonts category's rows give them as `TrueType; 2 uses`), fontDetails: [{font, match: exact|style|missingWithFallback|missing, family, style, file, embedding: allowed|editing|previewPrint|forbidden|null}] (each font of fonts, in order: how it was found, the face shown (null when none), that face's file name (null for a built-in face) and what its license allows), images, imageObjects: [{name, width, height, linked, file}] (the image objects in the order Linked Images and Embedded Images list them; file: what a linked image's row shows, null for an embedded one), swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the brushes the art's drawn strokes use, each once; with selectionOnly: those the selected objects' strokes use), brushes: [{name, type: calligraphic|scatter|art|pattern|bristle|null}] (those brushes with their types; null: not in the Brushes panel), panelBrushNames (the Brushes panel's brushes), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient that color a part of it above opacity 0 (a stop at opacity 0 counts only where it mixes with a stop above opacity 0 over a stretch of some width), at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients, kinds}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else its kind's name, such as Linear gradient; kinds gives each one's kind, linear|radial|conic|diamond|freeform, when it is named by its kind, else null; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone. brushNames, brushes, spotObjects, patternObjects and gradientObjects leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0 (with selectionOnly too), their characters' paints and colorized images included; objects still counts them as paths, groups and the other kinds",
has_doc,
info
),
@@ -144,6 +144,45 @@ fn font_detail(used: &super::fonts::UsedFont) -> (Value, (String, String)) {
(entry, (label, detail))
}
/// The type of a font as Fonts lists it: `truetype` or `opentype` by the outlines of the face the
/// type is drawn in (in the version the type names), `unknown` for a font that is not installed in
/// the family and style it names, or whose face holds neither kind of outline.
fn font_type(used: &super::fonts::UsedFont) -> &'static str {
let db = vectorcraft_text::FontDb::global();
let (family, style, version) = used;
match db.resolve(family, style) {
Some((f, vectorcraft_text::FontMatch::Exact)) => match db.face_version(family, style, version.as_deref()).unwrap_or(f).outline_format() {
Some(vectorcraft_text::OutlineFormat::TrueType) => "truetype",
Some(vectorcraft_text::OutlineFormat::Cff) => "opentype",
None => "unknown",
},
_ => "unknown",
}
}
/// A font as Fonts lists it: its `fontUses` entry and its row, which gives the font's type and its
/// number of uses (`uses`: the text objects set in it).
fn font_use(used: &super::fonts::UsedFont, uses: usize) -> (Value, (String, String)) {
let label = super::fonts::font_label(used);
let kind = font_type(used);
let name = match kind {
"truetype" => "TrueType",
"opentype" => "OpenType",
_ => "unknown type",
};
let count = if uses == 1 { "1 use".to_string() } else { format!("{uses} uses") };
(json!({ "font": label, "type": kind, "uses": uses }), (label, format!("{name}; {count}")))
}
/// Counts text object `t` once for each font its runs are drawn in, a composite font's parts in
/// place of its name ([`super::fonts::run_fonts`]).
fn count_fonts(fonts: &mut BTreeMap<super::fonts::UsedFont, usize>, t: &vectorcraft_doc::TextObject) {
let own: BTreeSet<super::fonts::UsedFont> = t.runs.iter().flat_map(super::fonts::run_fonts).collect();
for font in own {
*fonts.entry(font).or_default() += 1;
}
}
/// An image object as Document Info lists it: (name, width, height, linked file).
type ImageRow = (String, u32, u32, Option<String>);
@@ -221,16 +260,16 @@ fn selected_artboard_rows(d: &Document, picked: &[usize], active: usize) -> (Vec
}
/// The Document Info categories of `d` (only `category` when given) from `info` (what
/// `document.info` reports), the rows of the artboards the Artboard tool has selected, its fonts
/// and their Font Details rows, its image objects, the rows of the brushes its art uses, the rows
/// of its Repeat objects and the rows of its objects filled or stroked with a spot color, with a
/// pattern and with a gradient.
/// `document.info` reports), the rows of the artboards the Artboard tool has selected, the rows of
/// its fonts and their Font Details rows, its image objects, the rows of the brushes its art uses,
/// the rows of its Repeat objects and the rows of its objects filled or stroked with a spot color,
/// with a pattern and with a gradient.
#[allow(clippy::too_many_arguments)]
fn sections(
d: &Document,
info: &Value,
selected_artboards: &[(String, String)],
fonts: &BTreeSet<super::fonts::UsedFont>,
fonts: &[(String, String)],
font_details: &[(String, String)],
images: &[ImageRow],
brushes: &[(String, String)],
@@ -296,7 +335,7 @@ fn sections(
"patterns" => pattern_objects.to_vec(),
"gradients" => gradient_objects.to_vec(),
"symbols" => names("symbols"),
"fonts" => fonts.iter().map(|f| (super::fonts::font_label(f), String::new())).collect(),
"fonts" => fonts.to_vec(),
"fontDetails" => font_details.to_vec(),
"linkedImages" => {
images.iter().filter_map(|(name, w, h, link)| Some((name.clone(), format!("{w} × {h} px — {}", link.as_ref()?)))).collect()
@@ -627,7 +666,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
// The paths' total length, as Document Info › Objects shows it (the length of a cut line, a
// strip of LEDs along the letters, #1958).
let mut path_length = 0.0;
let mut fonts = BTreeSet::new();
// Each font with the number of text objects set in it.
let mut fonts: BTreeMap<super::fonts::UsedFont, usize> = BTreeMap::new();
let mut images: BTreeMap<String, Value> = BTreeMap::new();
let mut image_rows: Vec<ImageRow> = vec![];
// Whether the request being served may read each linked file (a relative path read from the
@@ -702,9 +742,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
}
NodeKind::Compound { .. } => Some("compoundPaths"),
NodeKind::Text(t) => {
for run in &t.runs {
fonts.insert((run.style.font_family.clone(), run.style.font_style.clone(), run.style.font_version.clone()));
}
count_fonts(&mut fonts, t);
Some("textObjects")
}
NodeKind::Image(im) => {
@@ -787,12 +825,16 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
}
}
// The document's fonts include those of the type in opacity masks and in the art of its
// symbols and patterns, as Find Font lists them.
// symbols and patterns, as Find Font lists them. Each of those text objects counts once, however
// many objects show it.
if !selection_only {
fonts.extend(super::fonts::art_texts_of(d).into_iter().flat_map(|(_, t, _)| t.runs.iter().map(|r| super::fonts::font_of(&r.style))));
for (_, t, _) in super::fonts::art_texts_of(d) {
count_fonts(&mut fonts, t);
}
}
let font_names: Vec<String> = fonts.iter().map(super::fonts::font_label).collect();
let (font_entries, font_rows): (Vec<Value>, Vec<(String, String)>) = fonts.iter().map(font_detail).unzip();
let font_names: Vec<String> = fonts.keys().map(super::fonts::font_label).collect();
let (font_uses, font_use_rows): (Vec<Value>, Vec<(String, String)>) = fonts.iter().map(|(f, n)| font_use(f, *n)).unzip();
let (font_entries, font_rows): (Vec<Value>, Vec<(String, String)>) = fonts.keys().map(font_detail).unzip();
// The image objects in walk order, as Linked Images and Embedded Images list them: `file` is a
// linked image's row value (its path, or its file name alone when the request may not read it),
// and null for an embedded one.
@@ -820,6 +862,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
"objects": counts,
"pathLength": path_length,
"fonts": font_names,
"fontUses": font_uses,
"fontDetails": font_entries,
"images": images,
"imageObjects": image_objects,
@@ -850,7 +893,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
d,
&out,
&selected_rows,
&fonts,
&font_use_rows,
&font_rows,
&image_rows,
&brush_rows,
@@ -1083,6 +1126,92 @@ mod tests {
assert_eq!(fonts(&mut s, json!({"selectionOnly": true})), json!(["Source Sans 3 Regular"]));
}
/// Fonts gives each font's type and its number of uses: the text objects set in it, each once
/// however many of its runs use the font. The type in a symbol's art counts once however many
/// instances show it, and the type in an opacity mask once. With Selection Only it counts the
/// selected type alone. A font that is not installed has an unknown type. The rows, the report
/// and `fontUses` give the same facts, in the order of `fonts`.
#[test]
fn info_fonts_give_each_font_s_type_and_uses() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
let id = |v: Value| NodeId(v["id"].as_u64().unwrap());
let text =
|s: &mut Session, font: &str, y: f64| id(s.execute("text.create", &json!({"x": 10, "y": y, "text": "Hello", "font": font})).unwrap());
// Two runs in Source Sans 3 Regular in one text object, a second object in it, and one in Inter.
let twice = text(&mut s, "Source Sans 3", 20.0);
s.execute("text.setRangeStyle", &json!({"id": twice.0, "start": 0, "end": 2, "size": 30})).unwrap();
assert!(matches!(&s.doc().unwrap().doc.node(twice).unwrap().kind, NodeKind::Text(t) if t.runs.len() == 2));
let other = text(&mut s, "Source Sans 3", 50.0);
text(&mut s, "Inter", 80.0);
text(&mut s, "Qx Absent Family", 110.0);
// A symbol whose art holds type in Inter, shown by two instances, and a mask holding type in Inter.
let in_symbol = text(&mut s, "Inter", 140.0);
s.execute("symbol.new", &json!({"name": "Mark", "ids": [in_symbol.0]})).unwrap();
s.execute("symbol.place", &json!({"name": "Mark", "x": 100, "y": 100})).unwrap();
let masked = id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap());
let in_mask = text(&mut s, "Inter", 170.0);
s.edit("Mask", |d, _| {
let art = d.remove(in_mask)?;
d.node_mut(masked).unwrap().extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new((*art).clone(), true)));
Ok(())
})
.unwrap();
let i = s.execute("document.info", &json!({"category": "fonts"})).unwrap();
assert_eq!(i["fonts"], json!(["Inter Regular", "Qx Absent Family Regular", "Source Sans 3 Regular"]));
assert_eq!(
i["fontUses"],
json!([
{"font": "Inter Regular", "type": "truetype", "uses": 3},
{"font": "Qx Absent Family Regular", "type": "unknown", "uses": 1},
{"font": "Source Sans 3 Regular", "type": "truetype", "uses": 2},
])
);
assert_eq!(
i["sections"][0]["rows"],
json!([
["Inter Regular", "TrueType; 3 uses"],
["Qx Absent Family Regular", "unknown type; 1 use"],
["Source Sans 3 Regular", "TrueType; 2 uses"],
])
);
let report = s.execute("document.info", &json!({"category": "fonts", "format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
assert!(report.contains("\nFONTS\nInter Regular: TrueType; 3 uses\nQx Absent Family Regular: unknown type; 1 use\n"), "{report}");
// Selection Only: the selected type's fonts and uses.
s.execute("select.set", &json!({"ids": [other.0]})).unwrap();
let i = s.execute("document.info", &json!({"selectionOnly": true, "category": "fonts"})).unwrap();
assert_eq!(i["fontUses"], json!([{"font": "Source Sans 3 Regular", "type": "truetype", "uses": 1}]));
assert_eq!(i["sections"][0]["rows"], json!([["Source Sans 3 Regular", "TrueType; 1 use"]]));
s.execute("select.none", &json!({})).unwrap();
let i = s.execute("document.info", &json!({"selectionOnly": true, "category": "fonts"})).unwrap();
assert_eq!((i["fontUses"].clone(), i["sections"][0]["rows"].clone()), (json!([]), json!([])));
}
/// Type set in a composite font counts as a use of the fonts of the parts its characters fall
/// in, as Find Font lists them, not of the composite font's name.
#[test]
fn info_fonts_count_the_parts_of_a_composite_font() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
let font = json!({"name": "DI Uses Composite", "parts": {
"kanji": {"font": "Source Sans 3"},
"roman": {"font": "JetBrains Mono"},
"numerals": {"font": "Inter"},
}});
s.execute("type.compositeFonts.set", &json!({"fonts": [font]})).unwrap();
s.execute("text.create", &json!({"x": 10, "y": 20, "text": "Ab1", "font": "DI Uses Composite"})).unwrap();
s.execute("text.create", &json!({"x": 10, "y": 50, "text": "12", "font": "DI Uses Composite"})).unwrap();
let i = s.execute("document.info", &json!({"category": "fonts"})).unwrap();
assert_eq!(i["fonts"], json!(["Inter Regular", "JetBrains Mono Regular"]));
assert_eq!(
i["fontUses"],
json!([
{"font": "Inter Regular", "type": "truetype", "uses": 2},
{"font": "JetBrains Mono Regular", "type": "truetype", "uses": 1},
])
);
}
/// Document Info › Objects gives the paths' total length in the document's units (#1958): an
/// open line, a closed rectangle's perimeter and a compound path's pieces count, a guide doesn't.
#[test]
+2 -2
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\"} (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",
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation,wheel]…] (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. An airbrush pen's finger wheel 0..1: the stroke keeps it for brushes with Stylus Wheel variation, a point without one half way; null for what a point lacks. A pressure, tilt, rotation or wheel outside its range, or a point array of more than seven 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
),
@@ -92,7 +92,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Eraser",
[],
None,
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths and filled open paths without a visible painted stroke lose its area, and other open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] or [[x,y,pressure,tiltX,tiltY,rotation,wheel]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise, finger wheel 0..1; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" | \"stylusWheel\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn; stylusWheel from less at one end of an airbrush pen's finger wheel travel to more at the other. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths and filled open paths without a visible painted stroke lose its area, and other open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
has_doc,
erase_region
),
+37 -16
View File
@@ -22,15 +22,17 @@ pub(super) struct Sample {
tilt: Option<[f64; 2]>,
/// Barrel rotation, degrees clockwise.
rotation: Option<f64>,
/// The airbrush finger wheel, 0..1.
wheel: Option<f64>,
}
/// The keys of a point's pen values, in the order a point given as an array holds them after its
/// x and y.
const PEN_KEYS: [&str; 4] = ["pressure", "tiltX", "tiltY", "rotation"];
const PEN_KEYS: [&str; 5] = ["pressure", "tiltX", "tiltY", "rotation", "wheel"];
/// The range each of [`PEN_KEYS`] takes: pressure 0..1, each tilt −90..90 degrees and rotation
/// 0..360 degrees (360 is the same direction as 0).
const PEN_RANGES: [(f64, f64); PEN_KEYS.len()] = [(0.0, 1.0), (-90.0, 90.0), (-90.0, 90.0), (0.0, 360.0)];
/// The range each of [`PEN_KEYS`] takes: pressure 0..1, each tilt −90..90 degrees, rotation
/// 0..360 degrees (360 is the same direction as 0) and the wheel 0..1.
const PEN_RANGES: [(f64, f64); PEN_KEYS.len()] = [(0.0, 1.0), (-90.0, 90.0), (-90.0, 90.0), (0.0, 360.0), (0.0, 1.0)];
/// Blob Brush and Eraser Tool Options' Size, in points.
pub(super) const SIZES: (f64, f64) = (0.1, 1000.0);
@@ -61,11 +63,11 @@ pub(super) fn point_entry(v: &Value, cmd: &str) -> Result<Point> {
}
/// [`points_param`] with what a pen read at each point, as far as it is given:
/// `[[x,y,pressure,tiltX,tiltY,rotation]…]` or `[{x,y,pressure,tiltX,tiltY,rotation}…]`. Pressure
/// is 0..1; tilt in degrees, each −90..90 (one of the two without the other is 0); rotation in
/// degrees clockwise, 0..360. A point whose x or y is not a number, whose pressure, tilt or
/// rotation is neither a number nor null or is outside its range, or an array of more than six
/// numbers, is an error.
/// `[[x,y,pressure,tiltX,tiltY,rotation,wheel]…]` or `[{x,y,pressure,tiltX,tiltY,rotation,wheel}…]`.
/// Pressure is 0..1; tilt in degrees, each −90..90 (one of the two without the other is 0);
/// rotation in degrees clockwise, 0..360; the wheel 0..1. A point whose x or y is not a number,
/// whose pressure, tilt, rotation or wheel is neither a number nor null or is outside its range,
/// or an array of more than seven numbers, is an error.
pub(super) fn samples_param(p: &Value, key: &str, cmd: &str) -> Result<Vec<Sample>> {
let a = p.get(key).and_then(Value::as_array).ok_or_else(|| bad(cmd, format!("missing array `{key}`")))?;
let pts: Vec<Sample> = a
@@ -79,7 +81,7 @@ pub(super) fn samples_param(p: &Value, key: &str, cmd: &str) -> Result<Vec<Sampl
let key = format!("{key}[{at}]");
return Err(bad(cmd, format!("`{key}` must be an array of at most {MAX_ITEMS} entries")));
}
let mut pen = [None; 4];
let mut pen = [None; PEN_KEYS.len()];
for (i, ((key, range), slot)) in PEN_KEYS.iter().zip(PEN_RANGES).zip(&mut pen).enumerate() {
let given = match v {
Value::Array(xy) => xy.get(i + 2),
@@ -91,9 +93,9 @@ pub(super) fn samples_param(p: &Value, key: &str, cmd: &str) -> Result<Vec<Sampl
Some(v) => return Err(bad(cmd, format!("`{key}` must be a number, not {v}"))),
};
}
let [pressure, tx, ty, rotation] = pen;
let [pressure, tx, ty, rotation, wheel] = pen;
let tilt = (tx.is_some() || ty.is_some()).then(|| [tx, ty].map(|t| t.unwrap_or(0.0)));
Ok(Sample { pt: point_entry(v, cmd)?, pressure, tilt, rotation })
Ok(Sample { pt: point_entry(v, cmd)?, pressure, tilt, rotation, wheel })
})
.collect::<Result<_>>()?;
if pts.is_empty() {
@@ -126,6 +128,15 @@ fn stroke_pressure(samples: &[Sample]) -> Option<PressureProfile> {
PressureProfile::from_samples(along(samples).into_iter().zip(samples).map(|(t, s)| (t, s.pressure.unwrap_or(1.0))))
}
/// Where an airbrush pen's finger wheel was set along a freehand stroke, when any of its samples
/// has it; samples without it count as the middle of its travel, which draws a brush's own value.
fn stroke_wheel(samples: &[Sample]) -> Option<PressureProfile> {
if samples.iter().all(|s| s.wheel.is_none()) {
return None;
}
PressureProfile::from_samples(along(samples).into_iter().zip(samples).map(|(t, s)| (t, s.wheel.unwrap_or(PressureProfile::MID))))
}
/// A pen that leans less than this many degrees from upright leans no way in particular: its
/// bearing is the one before it.
const UPRIGHT: f64 = 1.0;
@@ -165,24 +176,31 @@ fn stroke_pose(samples: &[Sample]) -> (Option<PressureProfile>, Option<AngleProf
(tilt.flatten(), bearing.flatten(), rotation.flatten())
}
/// What a pen recorded along a stroke ([`StrokeLayer`]'s `pressure`, `tilt`, `bearing` and
/// `rotation`).
/// What a pen recorded along a stroke ([`StrokeLayer`]'s `pressure`, `tilt`, `bearing`,
/// `rotation` and `wheel`).
#[derive(Clone, Debug, Default, PartialEq)]
pub(super) struct PenRecord {
pressure: Option<PressureProfile>,
tilt: Option<PressureProfile>,
bearing: Option<AngleProfile>,
rotation: Option<AngleProfile>,
wheel: Option<PressureProfile>,
}
impl PenRecord {
/// What a freehand stroke's samples recorded.
pub(super) fn of_samples(samples: &[Sample]) -> Self {
let (tilt, bearing, rotation) = stroke_pose(samples);
Self { pressure: stroke_pressure(samples), tilt, bearing, rotation }
Self { pressure: stroke_pressure(samples), tilt, bearing, rotation, wheel: stroke_wheel(samples) }
}
pub(super) fn of(st: &StrokeLayer) -> Self {
Self { pressure: st.pressure.clone(), tilt: st.tilt.clone(), bearing: st.bearing.clone(), rotation: st.rotation.clone() }
Self {
pressure: st.pressure.clone(),
tilt: st.tilt.clone(),
bearing: st.bearing.clone(),
rotation: st.rotation.clone(),
wheel: st.wheel.clone(),
}
}
pub(super) fn is_empty(&self) -> bool {
*self == Self::default()
@@ -195,6 +213,7 @@ impl PenRecord {
tilt: PressureProfile::extended(self.tilt.as_ref(), old_len, added.tilt.as_ref(), added_len),
bearing: AngleProfile::extended(self.bearing.as_ref(), old_len, added.bearing.as_ref(), added_len),
rotation: AngleProfile::extended(self.rotation.as_ref(), old_len, added.rotation.as_ref(), added_len),
wheel: PressureProfile::extended(self.wheel.as_ref(), old_len, added.wheel.as_ref(), added_len),
}
}
/// The record along the path reversed.
@@ -204,6 +223,7 @@ impl PenRecord {
tilt: self.tilt.as_ref().map(PressureProfile::reversed),
bearing: self.bearing.as_ref().map(AngleProfile::reversed),
rotation: self.rotation.as_ref().map(AngleProfile::reversed),
wheel: self.wheel.as_ref().map(PressureProfile::reversed),
}
}
/// Keep the record on stroke `st`.
@@ -212,6 +232,7 @@ impl PenRecord {
st.tilt = self.tilt;
st.bearing = self.bearing;
st.rotation = self.rotation;
st.wheel = self.wheel;
}
}
+1 -1
View File
@@ -438,7 +438,7 @@ fn erase_rect(s: &mut Session, r: Rect) -> Result<Value> {
/// The variation modes `path.eraseRegion` takes for each of `angleMode`, `roundnessMode` and
/// `sizeMode`.
const ERASER_MODES: &str = "\"fixed\", \"random\", \"pressure\", \"tilt\", \"bearing\" or \"rotation\"";
const ERASER_MODES: &str = "\"fixed\", \"random\", \"pressure\", \"tilt\", \"bearing\", \"rotation\" or \"stylusWheel\"";
/// Eraser Tool Options' Angle, Roundness and Size variations: for each of angle (`angleMode` with
/// `angleVariation` in degrees, at most 180), roundness (`roundnessMode` with `roundnessVariation`
+57 -25
View File
@@ -115,7 +115,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Drop Artwork",
[],
None,
"{sourceDocument: uid, ids: [id…], grab: [x,y], at: [x,y]} copy 1–10000 editable source objects from an open document to the active document, preserving the grab point and clipboard, as one undo step",
"{sourceDocument: uid, ids: [id…], grab: [x,y], at: [x,y], profileMismatch?: as edit.paste} copy 1–10000 editable source objects from an open document to the active document, preserving the grab point and clipboard, as one undo step; colors from a document with another RGB or CMYK profile keep their numbers or convert as profileMismatch says, else as edit.colorSettings' policy of their model says (as edit.paste; clipboard.profileMismatch {sourceDocument, ids} lists them, and with askMismatchPaste on the desktop app asks first) → {ids, added, merged, renamed, profileMismatch?}",
has_doc,
drop_selection
),
@@ -180,7 +180,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Paste",
["Edit"],
Some("Cmd+V"),
"{center?: [x, y], artboardsAt?: [x, y], dx?, dy?, swatchConflict?} paste centred on `center` (the app passes the view centre), else offset by dx/dy (default: the Paste Offset preference). Pasting brings the image blobs, symbols, patterns, global and spot swatches (with the tint swatches of the tints used), gradient swatches, graphic styles, character and paragraph styles and brushes the objects use; one of the same name that differs comes in renamed. swatchConflict, for a swatch whose name the document gives another colour (clipboard.conflicts): \"merge\" (default: the objects take the document's swatch; legend labels in a pie's wedges that it turns dark or light take a redraw's contrast, unless their fill is their own) | \"add\" (the pasted swatch comes in renamed) | {name: \"merge\"|\"add\"}. With Paste Remembers Layers on (layer.pasteRemembersLayers), objects go back into the layers and sublayers they came from (by the names of the layer and the layers around it in another document; a missing sublayer is made inside its layer; a hidden or locked one is an error and nothing is pasted). Artboards copied with artboard.copy come with their art, together right of the last artboard as they lay, or centered on `artboardsAt` (the Artboard tool's canvas menu passes the right-click point; a value that is not [x, y] is an error) (the other paste commands but Paste on All Artboards: where they were), their art back in the layers it came from, and the Artboard tool, when chosen, selects them. In Draw Inside (view.drawMode) the objects go inside the object drawn into, as new art does, and Paste Remembers Layers doesn't apply; edit.pasteInPlace and edit.pasteOnAllArtboards do the same, and in Draw Behind they go behind the selection as edit.pasteInBack puts them; edit.pasteInFront and edit.pasteInBack ignore the drawing mode → {ids, artboard: the first new artboard's index or null, artboards: the new artboards' indices, added: resources added, merged: conflicts merged, renamed: [{kind, from, to}]}",
"{center?: [x, y], artboardsAt?: [x, y], dx?, dy?, swatchConflict?, profileMismatch?: \"preserveNumbers\"|\"convert\"|{rgb?, cmyk?}} paste centred on `center` (the app passes the view centre), else offset by dx/dy (default: the Paste Offset preference). Pasting brings the image blobs, symbols, patterns, global and spot swatches (with the tint swatches of the tints used), gradient swatches, graphic styles, character and paragraph styles and brushes the objects use; one of the same name that differs comes in renamed. swatchConflict, for a swatch whose name the document gives another colour (clipboard.conflicts): \"merge\" (default: the objects take the document's swatch; legend labels in a pie's wedges that it turns dark or light take a redraw's contrast, unless their fill is their own) | \"add\" (the pasted swatch comes in renamed) | {name: \"merge\"|\"add\"}. profileMismatch, for colors copied from a document whose RGB or CMYK profile is not this document's (clipboard.profileMismatch): \"preserveNumbers\" keeps their numbers, \"convert\" converts them into this document's profile with the working intent, and {rgb?, cmyk?} gives one of those for each model (default, also for a model left out and for null: as the model's policy of edit.colorSettings says; any other value is an error; colors whose source or destination profile is not available keep their numbers, also with \"convert\" (clipboard.profileMismatch's convertible: false); every paste command takes it, and the reply's profileMismatch lists [{model, clipboard, document, choice}]). With Paste Remembers Layers on (layer.pasteRemembersLayers), objects go back into the layers and sublayers they came from (by the names of the layer and the layers around it in another document; a missing sublayer is made inside its layer; a hidden or locked one is an error and nothing is pasted). Artboards copied with artboard.copy come with their art, together right of the last artboard as they lay, or centered on `artboardsAt` (the Artboard tool's canvas menu passes the right-click point; a value that is not [x, y] is an error) (the other paste commands but Paste on All Artboards: where they were), their art back in the layers it came from, and the Artboard tool, when chosen, selects them. In Draw Inside (view.drawMode) the objects go inside the object drawn into, as new art does, and Paste Remembers Layers doesn't apply; edit.pasteInPlace and edit.pasteOnAllArtboards do the same, and in Draw Behind they go behind the selection as edit.pasteInBack puts them; edit.pasteInFront and edit.pasteInBack ignore the drawing mode → {ids, artboard: the first new artboard's index or null, artboards: the new artboards' indices, added: resources added, merged: conflicts merged, renamed: [{kind, from, to}]}",
has_clipboard,
|s, p| paste(s, p, PasteMode::Offset)
),
@@ -189,7 +189,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Paste in Front",
["Edit"],
Some("Cmd+F"),
"{swatchConflict?, artboard?: index (the active artboard: the objects go where they were on the artboard they were copied from, on this one), artboards?: [index…] (a copy on each of these artboards, placed as on `artboard`, the copies in artboard order; `artboard` wins when both are given; default while the Artboard tool is chosen with several artboards selected: those; art copied from no artboard keeps its place on the first and its offset to it on the others; an index the document lacks, a repeated one or an empty list is an error)} paste in place just above the top selected object, or on top of the current layer when nothing is selected (resources and layers as edit.paste) → {ids, added, merged, renamed}",
"{swatchConflict?, profileMismatch? (as edit.paste), artboard?: index (the active artboard: the objects go where they were on the artboard they were copied from, on this one), artboards?: [index…] (a copy on each of these artboards, placed as on `artboard`, the copies in artboard order; `artboard` wins when both are given; default while the Artboard tool is chosen with several artboards selected: those; art copied from no artboard keeps its place on the first and its offset to it on the others; an index the document lacks, a repeated one or an empty list is an error)} paste in place just above the top selected object, or on top of the current layer when nothing is selected (resources and layers as edit.paste) → {ids, added, merged, renamed}",
has_clipboard,
|s, p| paste(s, p, PasteMode::Front)
),
@@ -198,7 +198,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Paste in Back",
["Edit"],
Some("Cmd+B"),
"{swatchConflict?, artboard?: index, artboards?: [index…] (both as edit.pasteInFront)} paste in place just below the bottom selected object, or at the bottom of the current layer when nothing is selected (resources and layers as edit.paste) → {ids, added, merged, renamed}",
"{swatchConflict?, profileMismatch?, artboard?: index, artboards?: [index…] (as edit.pasteInFront)} paste in place just below the bottom selected object, or at the bottom of the current layer when nothing is selected (resources and layers as edit.paste) → {ids, added, merged, renamed}",
has_clipboard,
|s, p| paste(s, p, PasteMode::Back)
),
@@ -207,7 +207,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Paste in Place",
["Edit"],
Some("Cmd+Shift+V"),
"{swatchConflict?, artboard?: index, artboards?: [index…] (both as edit.pasteInFront)} paste where the objects were copied (resources, layers and drawing modes as edit.paste) → {ids, added, merged, renamed}",
"{swatchConflict?, profileMismatch?, artboard?: index, artboards?: [index…] (as edit.pasteInFront)} paste where the objects were copied (resources, layers and drawing modes as edit.paste) → {ids, added, merged, renamed}",
has_clipboard,
|s, p| paste(s, p, PasteMode::InPlace)
),
@@ -216,7 +216,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Paste on All Artboards",
["Edit"],
Some("Cmd+Alt+Shift+V"),
"{swatchConflict?} paste a copy on every artboard at the offset the objects had to the artboard they were copied from (resources, layers and drawing modes as edit.paste) → {ids, added, merged, renamed}",
"{swatchConflict?, profileMismatch? (as edit.paste)} paste a copy on every artboard at the offset the objects had to the artboard they were copied from (resources, layers and drawing modes as edit.paste) → {ids, added, merged, renamed}",
has_clipboard,
|s, p| paste(s, p, PasteMode::AllArtboards)
),
@@ -1278,26 +1278,12 @@ fn clear(s: &mut Session, p: &Value) -> Result<Value> {
/// Document ids scope node ids: two tabs may contain objects with the same node id.
fn drop_selection(s: &mut Session, p: &Value) -> Result<Value> {
const CMD: &str = "edit.dropSelection";
let uid = u64_req(p, "sourceDocument", CMD)?;
u64_req(p, "sourceDocument", CMD)?;
let point = |key: &str| finite_numbers::<2>(&p[key]).ok_or_else(|| bad(CMD, format!("{key} must be [x, y] with finite coordinates")));
let grab = point("grab")?;
let at = point("at")?;
let source = s.documents().iter().find(|d| d.uid == uid).ok_or_else(|| bad(CMD, "that document is no longer open"))?;
let key = "ids";
let values = p[key].as_array().ok_or_else(|| bad(CMD, format!("{key} must be an array of non-negative integer object ids")))?;
if values.is_empty() || values.len() > 10000 {
return Err(bad(CMD, "ids must contain 1–10000 object ids"));
}
let ids = values
.iter()
.map(|value| value.as_u64().map(NodeId).ok_or_else(|| bad(CMD, format!("invalid object id {value}: expected a non-negative integer"))))
.collect::<Result<Vec<_>>>()?;
// Validate the entire batch in one walk; node ids are local to the source document.
let paths = source.doc.index_paths(ids.iter().copied());
if let Some(id) = ids.iter().find(|id| !paths.contains_key(id)) {
return Err(EngineError::NoNode(*id));
}
let clip = Clipboard::copy(source, &roots_of(&source.doc, ids), false);
let profile = super::colormgmt::PasteProfile::param(p, CMD)?;
let clip = drop_clip(s, p, CMD)?;
let bounds = clip.bounds().ok_or_else(|| bad(CMD, "the art has no bounds"))?;
let center = bounds.center() + Vec2::new(at[0] - grab[0], at[1] - grab[1]);
if !center.x.is_finite() || !center.y.is_finite() {
@@ -1305,7 +1291,38 @@ fn drop_selection(s: &mut Session, p: &Value) -> Result<Value> {
}
// A drop preserves the source colours even when the flyer has same-named swatches.
let choices = SwatchChoices::parse(PasteMode::Drag.label(), &json!({"swatchConflict": "add"}))?;
paste_clip(s, &json!({"center": [center.x, center.y]}), PasteMode::Drag, &clip, &choices)
// Colors from another profile keep their numbers or convert, as `profileMismatch` says, else as
// the policies say.
let (converted, report) = super::colormgmt::paste_profiles(&clip, &s.doc()?.doc, profile, true);
let mut r = paste_clip(s, &json!({"center": [center.x, center.y]}), PasteMode::Drag, converted.as_ref().unwrap_or(&clip), &choices);
if let Ok(v) = &mut r
&& !report.is_empty()
{
v["profileMismatch"] = json!(report);
}
r
}
/// The objects `ids` of the open document `sourceDocument` that `edit.dropSelection` drops, copied
/// as a clipboard is (errors name command `cmd`).
pub(crate) fn drop_clip(s: &Session, p: &Value, cmd: &str) -> Result<Clipboard> {
let uid = u64_req(p, "sourceDocument", cmd)?;
let source = s.documents().iter().find(|d| d.uid == uid).ok_or_else(|| bad(cmd, "that document is no longer open"))?;
let key = "ids";
let values = p[key].as_array().ok_or_else(|| bad(cmd, format!("{key} must be an array of non-negative integer object ids")))?;
if values.is_empty() || values.len() > 10000 {
return Err(bad(cmd, "ids must contain 1–10000 object ids"));
}
let ids = values
.iter()
.map(|value| value.as_u64().map(NodeId).ok_or_else(|| bad(cmd, format!("invalid object id {value}: expected a non-negative integer"))))
.collect::<Result<Vec<_>>>()?;
// Validate the entire batch in one walk; node ids are local to the source document.
let paths = source.doc.index_paths(ids.iter().copied());
if let Some(id) = ids.iter().find(|id| !paths.contains_key(id)) {
return Err(EngineError::NoNode(*id));
}
Ok(Clipboard::copy(source, &roots_of(&source.doc, ids), false))
}
#[derive(Clone, Copy, PartialEq, Eq)]
@@ -1340,10 +1357,23 @@ fn paste(s: &mut Session, p: &Value, mode: PasteMode) -> Result<Value> {
if mode == PasteMode::Offset {
check_numbers(p, &["dx", "dy"], "edit.paste")?;
}
let profile = super::colormgmt::PasteProfile::param(p, mode.label())?;
// Taken out of the session for the edit (and put back whatever happens).
let clip = std::mem::take(&mut s.clipboard);
let r = paste_clip(s, p, mode, &clip, &choices);
// Colors copied from a document with other profiles keep their numbers or convert
// (Edit › Color Settings' policies, or `profileMismatch`). Paste on All Artboards leaves the
// copied artboards, and so their backgrounds, behind.
let (converted, report) = match s.doc() {
Ok(st) => super::colormgmt::paste_profiles(&clip, &st.doc, profile, mode != PasteMode::AllArtboards),
Err(_) => (None, vec![]),
};
let mut r = paste_clip(s, p, mode, converted.as_ref().unwrap_or(&clip), &choices);
s.clipboard = clip;
if let Ok(v) = &mut r
&& !report.is_empty()
{
v["profileMismatch"] = json!(report);
}
r
}
@@ -1520,6 +1550,8 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
vec![Affine::IDENTITY]
};
let (ids, imported, artboards, into) = s.edit(mode.label(), |d, sel| {
// Converted colors are compared with the document's resources, as another document's are
// (`Clipboard::import_into`); its images are still the document's own.
let imported = clip.import_into(d, choices, same_doc)?;
// Draw Inside: the clip group of the object drawn into, made on the first paste.
let into = inside.map(|t| super::create::draw_inside_group(d, t)).transpose()?;
+181
View File
@@ -32,6 +32,15 @@ pub(super) fn specs() -> Vec<CommandSpec> {
has_doc,
map_graphic
),
cmd!(
"threeD.mapArt",
"Map Art",
[],
None,
"{surface?: integer (1..the object's surface count: Extrude & Bevel (Classic) numbers each solid's front cap and back cap (none on a hollow solid, cap false), then each side wall from corner to corner of the outline, then the bevel above each wall; Revolve (Classic)'s swept side is surface 1, in a group the side of the member with the longest profile, and the other members take no map), symbol?: name of a document symbol|null (with surface: the symbol mapped onto it; null removes the surface's map, also a map kept past the surface count, and is refused with x, y, scaleX, scaleY, rotation or fit true; omitted: the surface's map keeps its symbol, and a surface with no map is refused), x?: pt, y?: pt (-1000000..1000000; the offset of the art's center from the center of the surface laid out flat; a new map starts at 0, 0), scaleX?: %, scaleY?: % (1..10000; of the symbol's own width and height; a new map starts at 100), rotation?: degrees (-360..360; counterclockwise; a new map starts at 0), fit?: bool (false; true is Scale to Fit: the art is centered and scaled to fill the surface, each side on its own when the art is square to the surface, else in proportion; art with no area keeps its scales), clearAll?: bool (false; true removes every map first, so with surface only that surface's map is left), shade?: bool (Shade Artwork: the mapped art takes the tone and highlight of its face), invisible?: bool (Invisible Geometry: with at least one map, only the mapped art is drawn), index?: int (the 3D effect's position; default: each object's first Extrude & Bevel (Classic) or Revolve (Classic), its own before its fills' and strokes'), item?: appearance item index|null (refused without index; as effect.setParams), ids?|id?} set, edit or remove the art mapped onto the numbered surfaces of each selected object's 3D effect, which must be Extrude & Bevel (Classic) or Revolve (Classic) (Rotate (Classic) takes no map); one of surface, clearAll, shade or invisible is required; the maps are the effect's mapArt, mapShade and mapInvisible parameters; one undo step, and none when nothing changes → {ids: [the objects changed], maps: [the first object's maps]}",
has_doc,
map_art
),
]
}
@@ -158,6 +167,178 @@ fn map_graphic(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "ids": ids_json(&ids), "graphic": first }))
}
/// The effect of `n` that Map Art edits when none is named: its first Extrude & Bevel (Classic) or
/// Revolve (Classic), its own before its fills' and strokes'.
fn first_mapped(n: &Node) -> Option<(Option<usize>, usize)> {
let at = |fx: &[Effect]| fx.iter().position(|e| effects::takes_map_art(&e.id));
at(&n.appearance.effects)
.map(|i| (None, i))
.or_else(|| n.appearance.items.iter().enumerate().find_map(|(k, item)| at(item.effects()).map(|i| (Some(k), i))))
}
/// `threeD.mapArt`: sets, edits or removes the maps of each target's classic 3D effect, after
/// checking that every target takes the change. Nothing is recorded when no target changes.
fn map_art(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "threeD.mapArt";
const PLACING: [&str; 6] = ["symbol", "x", "y", "scaleX", "scaleY", "rotation"];
const KEYS: [&str; 15] =
["surface", "symbol", "x", "y", "scaleX", "scaleY", "rotation", "fit", "clearAll", "shade", "invisible", "index", "item", "ids", "id"];
if let Some(key) = p.as_object().and_then(|m| m.keys().find(|k| !KEYS.contains(&k.as_str()))) {
return Err(bad(C, format!("unknown parameter `{key}`")));
}
if p.get("item").is_some() && p.get("index").is_none() {
return Err(bad(C, "`item` needs `index`"));
}
let surface = match p.get("surface") {
None => None,
Some(v) => Some(
v.as_u64()
.and_then(|n| usize::try_from(n).ok())
.filter(|n| (1..=effects::MAX_MAP_SURFACE).contains(n))
.ok_or_else(|| bad(C, "`surface` must be a whole number from 1 to the object's surface count"))?,
),
};
let fit = super::super::switch_or(p, "fit", false, C)?;
let clear_all = super::super::switch_or(p, "clearAll", false, C)?;
let flag = |key: &str| -> Result<Option<bool>> {
match p.get(key) {
None => Ok(None),
Some(_) => super::super::switch_or(p, key, false, C).map(Some),
}
};
let (shade, invisible) = (flag("shade")?, flag("invisible")?);
match surface {
None if fit || PLACING.iter().any(|k| p.get(*k).is_some()) => {
return Err(bad(C, "`symbol`, `x`, `y`, `scaleX`, `scaleY`, `rotation` and `fit` need `surface`"));
}
None if !clear_all && shade.is_none() && invisible.is_none() => {
return Err(bad(C, "give `surface`, `clearAll`, `shade` or `invisible`"));
}
_ => {}
}
let removes = p.get("symbol").is_some_and(Value::is_null);
if removes && (fit || PLACING[1..].iter().any(|k| p.get(*k).is_some())) {
return Err(bad(C, "`symbol: null` removes the map: leave out `x`, `y`, `scaleX`, `scaleY`, `rotation` and `fit`"));
}
let d = &s.doc()?.doc;
let targets: Vec<(NodeId, Option<usize>, usize)> = if p.get("index").is_some() {
let index = index_param(p, "index", C)?;
let item = item_target(s, p, C)?;
effect_targets(s, p, item, index, C)?
} else {
let mut out = vec![];
for id in edit_targets(s, p, C)? {
let found = d.node(id).and_then(first_mapped);
let (item, index) = found.ok_or_else(|| bad(C, format!("object {}: {}", id.0, effects::MAP_ART_NOT_TAKEN)))?;
out.push((id, item, index));
}
out
};
if targets.is_empty() {
return Err(bad(C, "select an object with a 3D effect"));
}
let mut edits = Vec::with_capacity(targets.len());
for &(id, item, index) in &targets {
let n = d.node(id).ok_or(EngineError::NoNode(id))?;
let Some(effect) = n.appearance.effects_at(item).and_then(|fx| fx.get(index)).filter(|e| effects::is_three_d(&e.id)) else {
return Err(bad(C, format!("object {} needs a 3D effect at index {index}", id.0)));
};
if !effects::takes_map_art(&effect.id) {
return Err(bad(C, format!("object {}: {}", id.0, effects::MAP_ART_NOT_TAKEN)));
}
let merged = effects::merged_params(&effect.id, &effect.params);
let mut params = merged.clone();
if clear_all {
params[effects::MAP_ART] = json!([]);
}
if let Some(surface) = surface {
// Art that can't be built has no surfaces: the effect's own check says why.
let surfaces = match effects::map_surfaces_at(Some(d), n, item, index) {
Some(surfaces) => surfaces,
None => {
effects::validate_three_d_at_in(Some(d), n, &effect.id, &merged, (item, index)).map_err(|e| bad(C, e))?;
vec![]
}
};
// Read before clearAll empties the list, so with clearAll the surface keeps its map.
let current = effects::surface_maps(&merged).into_iter().find(|m| m.surface == surface);
// A map kept past the surface count (the solid lost surfaces) can still be removed.
let flat = surfaces.get(surface - 1);
if flat.is_none() && !(removes && current.is_some()) {
return Err(bad(C, format!("object {}: `surface` must be from 1 to {}, the object's surface count", id.0, surfaces.len())));
}
if removes {
params = effects::with_surface_map(&params, surface, None);
} else if let Some(flat) = flat {
// The values given go over the surface's map, or over a new map's defaults.
let mut given = match (&current, p.get("symbol")) {
(Some(m), _) => m.to_value(),
(None, Some(_)) => json!({ "surface": surface }),
(None, None) => return Err(bad(C, format!("object {}: surface {surface} has no map: give `symbol`", id.0))),
};
for key in PLACING {
if let Some(v) = p.get(key) {
given[key] = v.clone();
}
}
let mut map = effects::SurfaceMap::from_value(&given).map_err(|e| bad(C, e))?;
// A map whose symbol was deleted keeps it while the request leaves `symbol` out; a
// symbol the request names must exist.
if !d.symbols.iter().any(|sym| sym.name == map.symbol) && (p.get("symbol").is_some() || current.is_none()) {
return Err(bad(C, format!("no symbol named `{}`", map.symbol)));
}
if fit {
// Art or a surface with no area has no size to fit: the map is centered and
// keeps its scales.
let scales = effects::graphic_bounds(d, &map.symbol).and_then(|art| map.fitting_scales(art, (flat.width, flat.height)));
let (scale_x, scale_y) = scales.unwrap_or((map.scale_x, map.scale_y));
map = effects::SurfaceMap { x: 0.0, y: 0.0, scale_x, scale_y, ..map };
}
params = effects::with_surface_map(&params, surface, Some(&map));
}
}
for (key, value) in [(effects::MAP_SHADE, shade), (effects::MAP_INVISIBLE, invisible)] {
if let Some(on) = value {
params[key] = json!(on);
}
}
effects::validate_three_d_at_in(Some(d), n, &effect.id, &params, (item, index)).map_err(|e| bad(C, e))?;
let state = |p: &Value| {
let on = |key: &str| p.get(key).and_then(Value::as_bool).unwrap_or(false);
(effects::surface_maps(p), on(effects::MAP_SHADE), on(effects::MAP_INVISIBLE))
};
let maps: Vec<Value> = effects::surface_maps(&params).iter().map(effects::SurfaceMap::to_value).collect();
let changed = state(&params) != state(&merged);
edits.push((id, item, index, params, changed, maps));
}
let first = edits.first().map(|(.., maps)| maps.clone()).unwrap_or_default();
if !edits.iter().any(|(.., changed, _)| *changed) {
return Ok(json!({ "ids": [], "maps": first }));
}
let ids = s.edit("Map Art", |d, _| {
let mut done = vec![];
for (id, item, index, params, changed, _) in &edits {
let Some(e) = d.node_mut(*id).and_then(|n| n.appearance.effects_mut(*item)).and_then(|fx| fx.get_mut(*index)).filter(|_| *changed) else {
continue;
};
let mut current = effects::upgrade_params(&e.id, &e.params);
for key in [effects::MAP_ART, effects::MAP_SHADE, effects::MAP_INVISIBLE] {
if let (Some(v), Some(m)) = (params.get(key), current.as_object_mut()) {
m.insert(key.into(), v.clone());
}
}
e.params = current;
done.push(*id);
}
Ok(done)
})?;
Ok(json!({ "ids": ids_json(&ids), "maps": first }))
}
#[cfg(test)]
#[path = "graphics_tests.rs"]
mod tests;
#[cfg(test)]
#[path = "map_art_tests.rs"]
mod map_art_tests;
@@ -0,0 +1,258 @@
#![allow(clippy::unwrap_used, clippy::panic)]
use serde_json::{Value, json};
use vectorcraft_doc::NodeId;
use crate::Session;
/// A 100 × 100 square with `effect` seen straight on, and a 10 × 20 red rectangle beside it kept
/// as symbol "Mark" (11 × 21 with its stroke).
fn setup(effect: &str) -> (Session, NodeId) {
let mut s = Session::new();
s.execute("file.new", &json!({"width":400,"height":400})).unwrap();
let mark = s.execute("path.create", &json!({"d":"M300 300L310 300L310 320L300 320Z"})).unwrap()["id"].clone();
s.execute("paint.setFill", &json!({"color":"#ff0000"})).unwrap();
s.execute("threeD.addGraphic", &json!({"name": "Mark", "ids": [mark]})).unwrap();
let id = NodeId(s.execute("path.create", &json!({"d":"M100 100L200 100L200 200L100 200Z"})).unwrap()["id"].as_u64().unwrap());
s.execute("paint.setFill", &json!({"color":"#338ad6"})).unwrap();
s.execute("effect.apply", &json!({"effect":effect,"item":null,"params":{"rotationX":0.0,"rotationY":0.0,"rotationZ":0.0}})).unwrap();
(s, id)
}
fn params(s: &Session, id: NodeId) -> Value {
s.doc().unwrap().doc.node(id).unwrap().appearance.effects[0].params.clone()
}
fn undo_len(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
fn map(surface: u64, x: f64, scale: (f64, f64), rotation: f64) -> Value {
json!({"surface": surface, "symbol": "Mark", "x": x, "y": 0.0, "scaleX": scale.0, "scaleY": scale.1, "rotation": rotation})
}
#[test]
fn map_art_sets_edits_and_removes_a_surfaces_map_one_undo_step_each() {
let (mut s, id) = setup("threeD.classicExtrude");
let before = s.doc().unwrap().doc.clone();
let history = undo_len(&s);
let r = s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark", "x": 5.0, "rotation": 30.0})).unwrap();
assert_eq!(r["ids"], json!([id.0]));
assert_eq!(r["maps"], json!([map(1, 5.0, (100.0, 100.0), 30.0)]));
assert_eq!(params(&s, id)["mapArt"], json!([map(1, 5.0, (100.0, 100.0), 30.0)]));
assert_eq!(undo_len(&s), history + 1);
// Without a symbol the surface's map keeps its own, and only the values given change.
s.execute("threeD.mapArt", &json!({"surface": 1, "scaleX": 50.0})).unwrap();
assert_eq!(params(&s, id)["mapArt"], json!([map(1, 5.0, (50.0, 100.0), 30.0)]));
// Another surface takes a map of its own, kept in the order of the surfaces.
s.execute("threeD.mapArt", &json!({"surface": 4, "symbol": "Mark"})).unwrap();
s.execute("threeD.mapArt", &json!({"surface": 2, "symbol": "Mark"})).unwrap();
let surfaces: Vec<u64> = params(&s, id)["mapArt"].as_array().unwrap().iter().map(|m| m["surface"].as_u64().unwrap()).collect();
assert_eq!(surfaces, [1, 2, 4]);
// Shade Artwork and Invisible Geometry are the effect's own flags.
s.execute("threeD.mapArt", &json!({"shade": true, "invisible": true})).unwrap();
assert_eq!((params(&s, id)["mapShade"].clone(), params(&s, id)["mapInvisible"].clone()), (json!(true), json!(true)));
// A null symbol clears one surface, and clearAll every surface.
s.execute("threeD.mapArt", &json!({"surface": 2, "symbol": null})).unwrap();
assert_eq!(params(&s, id)["mapArt"].as_array().unwrap().len(), 2);
let r = s.execute("threeD.mapArt", &json!({"clearAll": true})).unwrap();
assert_eq!((r["maps"].clone(), params(&s, id)["mapArt"].clone()), (json!([]), json!([])));
// With a surface, clearAll leaves that surface's new map alone.
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
s.execute("threeD.mapArt", &json!({"surface": 3, "symbol": "Mark", "clearAll": true})).unwrap();
assert_eq!(params(&s, id)["mapArt"], json!([map(3, 0.0, (100.0, 100.0), 0.0)]));
// Without a symbol, clearAll keeps the surface's own map and edits it.
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
s.execute("threeD.mapArt", &json!({"surface": 3, "x": 4.0, "clearAll": true})).unwrap();
assert_eq!(params(&s, id)["mapArt"], json!([map(3, 4.0, (100.0, 100.0), 0.0)]));
assert_eq!(undo_len(&s), history + 11);
for _ in 0..11 {
s.execute("edit.undo", &json!({})).unwrap();
}
assert_eq!(s.doc().unwrap().doc.layers, before.layers);
}
#[test]
fn a_map_past_the_surface_count_can_still_be_removed() {
let (mut s, id) = setup("threeD.classicExtrude");
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
s.execute("threeD.mapArt", &json!({"surface": 6, "symbol": "Mark"})).unwrap();
// With no depth the solid is a plane with fewer surfaces, and the map of surface 6 stays.
s.execute("effect.setParams", &json!({"index": 0, "item": null, "params": {"depth": 0}})).unwrap();
let e = s.execute("threeD.mapArt", &json!({"surface": 6, "symbol": "Mark", "x": 3.0})).unwrap_err().to_string();
assert!(e.contains("the object's surface count"), "{e}");
s.execute("threeD.mapArt", &json!({"surface": 6, "symbol": null})).unwrap();
assert_eq!(params(&s, id)["mapArt"], json!([map(1, 0.0, (100.0, 100.0), 0.0)]));
// A surface past the count with no map is still refused.
let e = s.execute("threeD.mapArt", &json!({"surface": 9, "symbol": null})).unwrap_err().to_string();
assert!(e.contains("the object's surface count"), "{e}");
}
#[test]
fn a_map_of_a_deleted_symbol_keeps_it_only_while_the_request_leaves_symbol_out() {
let (mut s, id) = setup("threeD.classicExtrude");
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
s.execute("symbol.delete", &json!({"name": "Mark"})).unwrap();
let ids = json!([id.0]);
// Naming the deleted symbol is refused, and nothing changes.
let e = s.execute("threeD.mapArt", &json!({"ids": ids, "surface": 1, "symbol": "Mark", "x": 10.0})).unwrap_err().to_string();
assert!(e.contains("no symbol named `Mark`"), "{e}");
assert_eq!(params(&s, id)["mapArt"], json!([map(1, 0.0, (100.0, 100.0), 0.0)]));
// Leaving it out edits the map and keeps its symbol, and `symbol: null` removes the map.
s.execute("threeD.mapArt", &json!({"ids": ids, "surface": 1, "x": 10.0})).unwrap();
assert_eq!(params(&s, id)["mapArt"], json!([map(1, 10.0, (100.0, 100.0), 0.0)]));
s.execute("threeD.mapArt", &json!({"ids": ids, "surface": 1, "symbol": null})).unwrap();
assert_eq!(params(&s, id)["mapArt"], json!([]));
}
#[test]
fn scale_to_fit_centers_the_art_and_fills_the_surface() {
let (mut s, id) = setup("threeD.classicExtrude");
// The cap is 100 × 100 and the symbol's art 11 × 21.
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark", "x": 20.0, "y": 3.0, "fit": true})).unwrap();
let m = &params(&s, id)["mapArt"][0];
assert_eq!((m["x"].as_f64(), m["y"].as_f64()), (Some(0.0), Some(0.0)));
assert!((m["scaleX"].as_f64().unwrap() - 100.0 / 11.0 * 100.0).abs() < 1e-6, "{m}");
assert!((m["scaleY"].as_f64().unwrap() - 100.0 / 21.0 * 100.0).abs() < 1e-6, "{m}");
// A side wall is 100 along the outline and as deep as the solid, 50.
s.execute("threeD.mapArt", &json!({"surface": 3, "symbol": "Mark", "fit": true})).unwrap();
let m = &params(&s, id)["mapArt"][1];
assert!((m["scaleY"].as_f64().unwrap() - 50.0 / 21.0 * 100.0).abs() < 1e-6, "{m}");
}
#[test]
fn a_change_that_changes_nothing_records_no_undo_step() {
let (mut s, id) = setup("threeD.classicExtrude");
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
let history = undo_len(&s);
let same = params(&s, id);
for p in [
json!({"surface": 1, "symbol": "Mark"}),
json!({"surface": 1, "x": 0.0, "scaleX": 100.0}),
json!({"surface": 2, "symbol": null}),
json!({"shade": false}),
json!({"invisible": false}),
] {
let r = s.execute("threeD.mapArt", &p).unwrap();
assert_eq!(r["ids"], json!([]), "{p}");
assert_eq!((undo_len(&s), params(&s, id)), (history, same.clone()), "{p}");
}
// Clearing an object with no map records nothing either.
let (mut s, _) = setup("threeD.classicRevolve");
let history = undo_len(&s);
assert_eq!(s.execute("threeD.mapArt", &json!({"clearAll": true})).unwrap()["ids"], json!([]));
assert_eq!(undo_len(&s), history);
}
#[test]
fn bad_surfaces_symbols_and_values_are_refused() {
let (mut s, id) = setup("threeD.classicExtrude");
let history = undo_len(&s);
let maps = params(&s, id)["mapArt"].clone();
for (p, error) in [
(json!({}), "give `surface`, `clearAll`, `shade` or `invisible`"),
(json!({"surface": 0, "symbol": "Mark"}), "`surface` must be a whole number"),
(json!({"surface": 1.5, "symbol": "Mark"}), "`surface` must be a whole number"),
(json!({"surface": "front", "symbol": "Mark"}), "`surface` must be a whole number"),
// The fill's solid has 6 surfaces and the stroke's, a square ring, 10: two caps and the
// four walls of each of its two outlines.
(json!({"surface": 17, "symbol": "Mark"}), "`surface` must be from 1 to 16"),
(json!({"surface": 1, "symbol": "Gone"}), "no symbol named `Gone`"),
(json!({"surface": 1, "symbol": 3}), "needs `symbol`"),
(json!({"surface": 1}), "surface 1 has no map: give `symbol`"),
(json!({"surface": 1, "symbol": "Mark", "scaleX": 0}), "scaleX must be a number from 1 to 10000"),
(json!({"surface": 1, "symbol": "Mark", "scaleY": 10001}), "scaleY must be a number from 1 to 10000"),
(json!({"surface": 1, "symbol": "Mark", "rotation": -361}), "rotation must be a number from -360 to 360"),
(json!({"surface": 1, "symbol": "Mark", "x": 1e7}), "x must be a number"),
(json!({"surface": 1, "symbol": "Mark", "y": "up"}), "y must be a number"),
(json!({"surface": 1, "symbol": "Mark", "fit": 1}), "fit"),
(json!({"surface": 1, "symbol": null, "x": 4.0}), "`symbol: null` removes the map"),
(json!({"surface": 1, "symbol": null, "rotation": 30.0}), "`symbol: null` removes the map"),
(json!({"surface": 1, "symbol": null, "fit": true}), "`symbol: null` removes the map"),
(json!({"symbol": "Mark"}), "need `surface`"),
(json!({"fit": true}), "need `surface`"),
(json!({"shade": "on"}), "shade"),
(json!({"invisible": 1}), "invisible"),
(json!({"clearAll": "yes"}), "clearAll"),
(json!({"surface": 1, "symbol": "Mark", "face": "front"}), "unknown parameter `face`"),
(json!({"surface": 1, "symbol": "Mark", "item": null}), "`item` needs `index`"),
(json!({"surface": 1, "symbol": "Mark", "index": 3}), "needs a 3D effect at index 3"),
] {
let e = s.execute("threeD.mapArt", &p).unwrap_err().to_string();
assert!(e.contains(error), "{p}: {e}");
}
assert_eq!((undo_len(&s), params(&s, id)["mapArt"].clone()), (history, maps));
// Revolve (Classic) has one surface, and the other 3D effects take no map.
let (mut s, _) = setup("threeD.classicRevolve");
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
let e = s.execute("threeD.mapArt", &json!({"surface": 2, "symbol": "Mark"})).unwrap_err().to_string();
assert!(e.contains("`surface` must be from 1 to 1"), "{e}");
for effect in ["threeD.classicRotate", "threeD.extrude", "threeD.revolve"] {
let (mut s, _) = setup(effect);
for p in [json!({"surface": 1, "symbol": "Mark"}), json!({"surface": 1, "symbol": "Mark", "index": 0})] {
let e = s.execute("threeD.mapArt", &p).unwrap_err().to_string();
assert!(e.contains("Map Art maps symbols onto Extrude & Bevel (Classic) and Revolve (Classic)"), "{effect}: {e}");
}
// The effect's own parameters refuse a map too.
let e = s.execute("effect.setParams", &json!({"index": 0, "item": null, "params": {"mapArt": [{"surface": 1, "symbol": "Mark"}]}}));
assert!(e.is_err(), "{effect}");
}
}
#[test]
fn a_mapped_symbol_is_drawn_expanded_renamed_and_kept_in_use() {
let (mut s, id) = setup("threeD.classicExtrude");
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark", "scaleX": 300.0})).unwrap();
// effect.setParams takes the same maps and refuses a symbol the document does not have.
let e = s.execute("effect.setParams", &json!({"index": 0, "item": null, "params": {"mapArt": [{"surface": 1, "symbol": "Gone"}]}}));
assert!(e.unwrap_err().to_string().contains("Gone"));
// The symbol counts as used, and renaming it renames it in the map.
assert_eq!(s.execute("symbol.unused", &json!({})).unwrap()["names"], json!([]));
s.execute("symbol.options", &json!({"name": "Mark", "newName": "Logo"})).unwrap();
assert_eq!(params(&s, id)["mapArt"][0]["symbol"], "Logo");
// Expand Appearance keeps the mapped art: the red fill is among the expanded paths.
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
s.execute("effect.expandAppearance", &json!({})).unwrap();
let d = &s.doc().unwrap().doc;
let mut red = 0;
for l in &d.layers {
l.walk(&mut |n| {
for item in &n.appearance.items {
if let vectorcraft_doc::AppearanceItem::Fill(f) = item
&& f.paint.color().is_some_and(|c| c.to_rgb()[0] > 0.9 && c.to_rgb()[1] < 0.1 && c.to_rgb()[2] < 0.1)
&& n.visual_bounds().is_some_and(|b| b.x0 < 250.0)
{
red += 1;
}
}
});
}
assert!(red > 0, "the expanded art holds the mapped symbol's red fill");
}
#[test]
fn pasted_into_another_document_a_map_brings_its_symbol() {
let (mut s, id) = setup("threeD.classicExtrude");
s.execute("threeD.mapArt", &json!({"surface": 1, "symbol": "Mark"})).unwrap();
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
s.execute("edit.copy", &json!({})).unwrap();
// The symbol the pasted object's map names, and the size of that symbol's art.
let pasted = |s: &mut Session| {
s.execute("edit.paste", &json!({})).unwrap();
let st = s.doc().unwrap();
let n = st.doc.node(st.selection.objects[0]).unwrap();
let name = n.appearance.effects[0].params["mapArt"][0]["symbol"].as_str().unwrap().to_string();
let size = vectorcraft_render::effects::graphic_bounds(&st.doc, &name).map(|r| (r.width(), r.height()));
(name, size)
};
// A document without the symbol gets it.
s.execute("file.new", &json!({"width":400,"height":400})).unwrap();
assert_eq!(pasted(&mut s), ("Mark".to_string(), Some((11.0, 21.0))));
// A document whose symbol "Mark" is other art gets the copied symbol under a free name, and
// the map names it.
s.execute("file.new", &json!({"width":400,"height":400})).unwrap();
let other = s.execute("path.create", &json!({"d":"M0 0L50 0L50 50L0 50Z"})).unwrap()["id"].clone();
s.execute("threeD.addGraphic", &json!({"name": "Mark", "ids": [other]})).unwrap();
let (name, size) = pasted(&mut s);
assert_ne!(name, "Mark");
assert_eq!(size, Some((11.0, 21.0)));
}
+3 -3
View File
@@ -41,7 +41,7 @@ mod load;
mod mesh3d;
pub(crate) use load::{MAX_RASTER_ALLOC, file_clipped, image_clip, size_note};
mod heifread;
mod hpgl;
pub mod hpgl;
mod jp2read;
mod metafile;
mod naming;
@@ -84,7 +84,7 @@ pub(crate) use load::page_or_editing_data;
pub(crate) use load::source;
pub use load::{
Loaded, RasterImage, ReadFile, detect, file_name, load, load_with, open_bytes, open_bytes_with, open_read, open_template, raster_image,
read_for_open, texture_image,
read_for_open, read_for_open_asking, texture_image,
};
pub(crate) use load::{check_files_not_lossy_overwrite, check_not_lossy_overwrite, lossy_source};
pub use load::{losses_summary, overwrite_losses};
@@ -98,7 +98,7 @@ pub use native::with_compression_pref;
pub(crate) use pdfimport::opened_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 use psdlayers::{LAYER_WARNINGS as PSD_LAYER_WARNINGS, MERGED_WARNING as PSD_MERGED_WARNING, PsdInfo, info as psd_info};
pub(crate) use psdslices::over as psd_slices;
pub(crate) use save::job_for;
pub(crate) use save::save as save_document;
+1
View File
@@ -68,6 +68,7 @@ pub(super) fn batch(s: &mut Session, p: &Value) -> Result<Value> {
o.insert("commands".into(), Value::Array(cmds));
}
if !s.previewing {
s.note_shape_drawn("command.batch", &entry);
s.journal.push(("command.batch".into(), entry));
}
Ok(json!({ "results": results }))
+1 -1
View File
@@ -9,7 +9,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Open Document",
[],
None,
"{path | name | dataBase64 (a file's path, or its name with its bytes), pages?: \"2-3, 5\" (PDF/.ai: 1-based, default all; one artboard each) | page?: n, cropTo?: bounding|art|crop (default)|trim|bleed|media (the box each artboard gets; bounding: the art's bounds; trim: the bleed box round it becomes the document's bleed, and the artboards are 36 pt apart plus that bleed on both sides; a PDF-compatible .ai or a PDF saved with its editing data opens on its trim boxes for crop), password? (encrypted PDFs; see document.pdfInfo), textAs?: text (default: point type per line, lines wrapped in a frame as area type where they lay out the same, in the file's fonts by name; missing ones are listed in warnings) | outlines (glyph paths), layers?: true (default: optional content groups become layers with their visibility, print state and lock — art that is off comes in as a hidden layer; other art goes to a layer per page; a PSD file's layers become layers holding their pixels, with their names, visibility, opacity and blend modes, groups as layers of sublayers, layer masks as opacity masks, clipped layers and layers in blend modes VectorCraft doesn't have merged with the layers below) | false (one layer per page, without the art that is off; Save then asks for a name; a PSD file opens as its merged image), hiddenLayers?: false (a PSD file's hidden layers come in hidden instead of being left out), importSlices?: true (a PSD file's slices become user slices over its canvas, with its layers or its merged image; slices the file generated automatically are left out, and slices that can't be read are left out with a warning), editingData?: true (default: an EPS, .ai or PDF that carries its editor's own copy of the art opens from it, with its layers, hidden objects, guides, artboards and the art outside them; a .ai or PDF whose type shows opens from its PDF part with textAs: outlines) | \"always\" (as true, and a .ai's editing copy is used even where it draws differently from its PDF part, which can be older; the warnings say so) | false (only what its page or PDF part prints, for print pipelines; a .ai saved without PDF compatibility then can't be opened), legacyNameEncoding?: windows-1252 (default) | macintosh | windows-949 (also euc-kr) | shift_jis | gbk | big5 (the code page names in the editing data of a .ai or an EPS are read in when they aren't UTF-8: layers, objects, artboards, colors, gradients, patterns, graphic styles, swatches, brushes, symbols, variables and data sets, and data sets' text values; warnings list the first three such names as read, and count the rest), colorMode?: rgb|cmyk (the mode the document opens in, its colours converted as file.documentColorMode does, through the profiles the document keeps after the color management policies of edit.colorSettings, grays? as there; default: the file's — a PDF keeps CMYK, Gray and spot inks (spot swatches at a tint) and opens in CMYK when painted mostly in CMYK), grays?: as file.documentColorMode, dxf?: {layout?: \"Model\" (default) | a paper layout's name (document.dxfInfo lists them), unit?, scale? (the ratio: 1 unit of the art = scale drawing units; default: the drawing at 1:1 in its own unit), fit?: false (scale to fit an artboard of fitTo?: [612, 792], turned to the art's orientation), scaleLineweights?: false (lineweights scale with the art), center?: true (false: the drawing's origin on the artboard's bottom-left corner; fitted art's bottom-left corner), mergeLayers?: false (all art on one layer)} (DXF), crop?: as cropTo (its older name), linkPages?: false (true: each page `pages` picks of a PDF or PDF-compatible .ai opens as a placed document linked to that page of the file, as file.place with link places one, on an artboard of its cropTo box (bounding: its art's bounds; a blank page: its crop box; a PDF-compatible .ai: its trim box for crop; on its trim box a page shows its bleed box round the artboard and gives the document its bleed), in a row 36 pt apart (on trim boxes, plus the bleed on both sides), and a layer named after the page; links.embed makes a page editable art; refused for any other file, without a path, with a password or with textAs: outlines; Save then asks for a name), importer?: \"plugin.<id>\" (an importer plug-in's format id, see document.formats: it opens the file, which must have an extension it lists, also one a built-in format reads), params?: {…} (the importer's own parameters, see plugin.info)} → {index, title, format, warnings, restored, missingLinks, modifiedLinks, updatedLinks: [{name, path, ids}]}; the color management policies of edit.colorSettings keep, take off or convert from the profiles the file is tagged with, their notes go to warnings, and a document they changed opens with unsaved changes; any readable format (see document.formats): .vectorcraft/.drawcraft, .svg/.svgz, .pdf/.ai, .ait, ASCII .dxf (each DXF layer with art a layer; blocks symbols; what can't come in is listed in warnings), PNG Line truncated
"{path | name | dataBase64 (a file's path, or its name with its bytes), pages?: \"2-3, 5\" (PDF/.ai: 1-based, default all; one artboard each) | page?: n, cropTo?: bounding|art|crop (default)|trim|bleed|media (the box each artboard gets; bounding: the art's bounds; trim: the bleed box round it becomes the document's bleed, and the artboards are 36 pt apart plus that bleed on both sides; a PDF-compatible .ai or a PDF saved with its editing data opens on its trim boxes for crop), password? (encrypted PDFs; see document.pdfInfo), textAs?: text (default: point type per line, lines wrapped in a frame as area type where they lay out the same, in the file's fonts by name; missing ones are listed in warnings) | outlines (glyph paths), layers?: true (default: optional content groups become layers with their visibility, print state and lock — art that is off comes in as a hidden layer; other art goes to a layer per page; a PSD file's layers become layers holding their pixels, with their names, visibility, opacity and blend modes, groups as layers of sublayers, layer masks as opacity masks, clipped layers and layers in blend modes VectorCraft doesn't have merged with the layers below) | false (one layer per page, without the art that is off; Save then asks for a name; a PSD file opens as its merged image), hiddenLayers?: false (a PSD file's hidden layers come in hidden instead of being left out), importSlices?: true (a PSD file's slices become user slices over its canvas, with its layers or its merged image; slices the file generated automatically are left out, and slices that can't be read are left out with a warning), editingData?: true (default: an EPS, .ai or PDF that carries its editor's own copy of the art opens from it, with its layers, hidden objects, guides, artboards and the art outside them; a .ai or PDF whose type shows opens from its PDF part with textAs: outlines) | \"always\" (as true, and a .ai's editing copy is used even where it draws differently from its PDF part, which can be older; the warnings say so) | false (only what its page or PDF part prints, for print pipelines; a .ai saved without PDF compatibility then can't be opened), legacyNameEncoding?: windows-1252 (default) | macintosh | windows-949 (also euc-kr) | shift_jis | gbk | big5 (the code page names in the editing data of a .ai or an EPS are read in when they aren't UTF-8: layers, objects, artboards, colors, gradients, patterns, graphic styles, swatches, brushes, symbols, variables and data sets, and data sets' text values; warnings list the first three such names as read, and count the rest), colorMode?: rgb|cmyk (the mode the document opens in, its colours converted as file.documentColorMode does, through the profiles the document keeps after the color management policies of edit.colorSettings, grays? as there; default: the file's — a PDF keeps CMYK, Gray and spot inks (spot swatches at a tint) and opens in CMYK when painted mostly in CMYK), grays?: as file.documentColorMode, dxf?: {layout?: \"Model\" (default) | a paper layout's name (document.dxfInfo lists them), unit?, scale? (the ratio: 1 unit of the art = scale drawing units; default: the drawing at 1:1 in its own unit), fit?: false (scale to fit an artboard of fitTo?: [612, 792], turned to the art's orientation), scaleLineweights?: false (lineweights scale with the art), center?: true (false: the drawing's origin on the artboard's bottom-left corner; fitted art's bottom-left corner), mergeLayers?: false (all art on one layer)} (DXF), crop?: as cropTo (its older name), linkPages?: false (true: each page `pages` picks of a PDF or PDF-compatible .ai opens as a placed document linked to that page of the file, as file.place with link places one, on an artboard of its cropTo box (bounding: its art's bounds; a blank page: its crop box; a PDF-compatible .ai: its trim box for crop; on its trim box a page shows its bleed box round the artboard and gives the document its bleed), in a row 36 pt apart (on trim boxes, plus the bleed on both sides), and a layer named after the page; links.embed makes a page editable art; refused for any other file, without a path, with a password or with textAs: outlines; Save then asks for a name), profileChoice?: \"useEmbedded\"|\"convert\"|\"discard\" (the profile of the document's color mode is not the working space: keep it, convert that model's colors into the working space and take it off, or take it off and keep the numbers) | \"leave\"|\"assignWorking\"|\"assign\" (the document has no profile of its color mode: leave it untagged, tag it with the working space, or with assignProfile?: a profile of that model) (default: what the model's policy of edit.colorSettings does; a choice for the other case, or for a document tagged with the working space, is not used; the reply's profileChoice gives {issue: mismatch|missing, model, choice} when one was given for the document's question: it names the choice, not what it did, so \"convert\" from a pr Line truncated
always,
load::open
),
+1 -1
View File
@@ -878,7 +878,7 @@ fn without_nodes(n: &Arc<Node>, left_out: &dyn Fn(&Node) -> bool, changed: Optio
/// absent; an error when it is not four finite numbers with a positive size, when the format isn't
/// a raster one, or when it comes with an artboard choice (`rect` is the area, so those would
/// contradict it). The image size limits are checked with the scale, as for an artboard.
fn page_rect(f: &Format, p: &Value) -> Result<Option<Rect>> {
pub(super) fn page_rect(f: &Format, p: &Value) -> Result<Option<Rect>> {
let v = match p.get("rect") {
None | Some(Value::Null) => return Ok(None),
Some(v) => v,
+68 -7
View File
@@ -6,6 +6,7 @@ use serde_json::Value;
use vectorcraft_cad::hpgl::write::{DEFAULT_TOLERANCE, MAX_PENS, TOLERANCE_RANGE};
use vectorcraft_cad::hpgl::{HpglOptions, Origin, Version};
use vectorcraft_doc::Document;
use vectorcraft_geom::Rect;
use super::super::{Result, bad, number_or, switch_or, text_param};
use super::{ArtboardPick, Encoded, FormatOption};
@@ -92,10 +93,58 @@ fn hex(v: &Value) -> Option<[u8; 3]> {
Some([byte(0)?, byte(2)?, byte(4)?])
}
/// Encode `doc` as HP-GL: a plot of the chosen artboard (default the first), or with
/// `use_artboards` one plot per chosen artboard (default all), with one pen numbering for them all.
pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) -> Result<Encoded> {
let opts = parse(p)?;
/// Check the HP-GL options and the artboard choice in `p` for an export of `doc`, as the export
/// reads them, without exporting (dialogs keep themselves open on an error).
pub fn check(doc: &Document, p: &Value) -> std::result::Result<(), String> {
let run = || -> Result<()> {
parse(p)?;
with_plotted(doc, p, |_, _| Ok(()))
};
run().map_err(|e| e.to_string())
}
/// The pen table an export of `doc` with the options and artboard choice in `p`, and no `pens`,
/// uses: pen 1's color first, as `#rrggbb` colors. Empty when nothing is plotted; an error when
/// the options or the artboard choice are refused.
pub fn automatic_pens(doc: &Document, p: &Value) -> std::result::Result<Vec<String>, String> {
let run = || -> Result<Vec<[u8; 3]>> {
let mut q = p.clone();
if let Some(o) = q.as_object_mut() {
o.remove("pens");
}
// The order the paths are drawn in doesn't change which pen a color gets.
let opts = HpglOptions { sort: false, inside_first: false, ..parse(&q)? };
with_plotted(doc, &q, |doc, regions| {
let plots = vectorcraft_cad::hpgl::export_regions(doc, &opts, &regions).map_err(|e| bad(C, e))?;
Ok(plots.first().map(|o| o.pens.clone()).unwrap_or_default())
})
};
let pens = run().map_err(|e| e.to_string())?;
Ok(pens.iter().map(|[r, g, b]| format!("#{r:02x}{g:02x}{b:02x}")).collect())
}
/// Run `f` on the document an export of `doc` with `p` plots and the regions of its plots: with
/// `useArtboards: false`, a copy of `doc` whose one artboard is the bounds of the visible art.
/// Like the export, it refuses `rect`, leaves out an opacity-mask or symbol editing layer, and
/// measures the bounds without the art a plot draws nothing for.
fn with_plotted<T>(doc: &Document, p: &Value, f: impl FnOnce(&Document, Vec<Rect>) -> Result<T>) -> Result<T> {
let format = super::format("hpgl").ok_or_else(|| bad(C, "no HP-GL format"))?;
super::encode::page_rect(format, p)?;
let doc = &*doc.without_edit_modes();
let use_artboards = super::encode::use_artboards(C, p)?;
if use_artboards == Some(false)
&& let Some((art, q)) = super::encode::art_page(C, doc, p, |n| vectorcraft_cad::hpgl::write::plots_nothing(doc, n))?
{
let (_, regions) = boards(&art, &q, None)?;
return f(&art, regions);
}
let (_, regions) = boards(doc, p, use_artboards)?;
f(doc, regions)
}
/// The artboards a plot of `doc` covers and their regions: the chosen artboard (default the
/// first), or with `use_artboards` each chosen one (default all).
fn boards(doc: &Document, p: &Value, use_artboards: Option<bool>) -> Result<(Vec<usize>, Vec<Rect>)> {
let f = super::format("hpgl").ok_or_else(|| bad(C, "no HP-GL format"))?;
let pick: ArtboardPick = super::encode::options(f, p)?;
let n = doc.artboards.len();
@@ -103,10 +152,25 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) ->
Some(true) => pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect()),
_ => vec![pick.one(n).map_err(|e| bad(C, e))?],
};
if boards.is_empty() {
return Err(bad(C, "the document has no artboard"));
}
let regions = 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<_>>>()?;
// The writer's own region check, so a dialog's check refuses what the writer refuses.
for r in &regions {
vectorcraft_cad::hpgl::write::check_region(*r).map_err(|e| bad(C, e))?;
}
Ok((boards, regions))
}
/// Encode `doc` as HP-GL: a plot of the chosen artboard (default the first), or with
/// `use_artboards` one plot per chosen artboard (default all), with one pen numbering for them all.
pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) -> Result<Encoded> {
let opts = parse(p)?;
let (boards, regions) = boards(doc, p, use_artboards)?;
let plots = vectorcraft_cad::hpgl::export_regions(doc, &opts, &regions).map_err(|e| bad(C, e))?;
let mut enc = Encoded::default();
for (b, out) in boards.into_iter().zip(plots) {
@@ -118,9 +182,6 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) ->
}
enc.add_setting_notes(out.setting_notes);
}
if enc.files.is_empty() {
return Err(bad(C, "the document has no artboard"));
}
let regions: Vec<vectorcraft_geom::Rect> = enc.files.iter().filter_map(|(b, _)| b.and_then(|b| doc.artboards.get(b))).map(|a| a.rect).collect();
enc.warnings.extend(crate::cmd::fonts::export_overflow_warning(doc, &doc.layers, Some(&regions)));
Ok(enc)
+166 -27
View File
@@ -686,6 +686,29 @@ pub struct ReadFile {
links: Resolved,
/// Whether the color management policies changed the document ([`apply_policies`]).
policy_changed: bool,
/// The answer to the document's profile question (`profileChoice`, or the app's prompt).
choice: Option<crate::cmd::colormgmt::ProfileChoice>,
/// What opening still has to do while the app asks about the profile ([`ReadFile::question`]):
/// the policies, the color mode, the linked files and the type are left for
/// [`ReadFile::answer`] or [`open_read`].
rest: Option<Rest>,
/// The answer that was used and the question it answered (`document.open`'s `profileChoice`
/// reply).
answered: Option<Value>,
/// The profile question as it was last asked ([`ReadFile::ask`]): an answer is taken only while
/// the question is still the same.
asked: Option<crate::cmd::colormgmt::ProfileQuestion>,
/// Update Links and the low-resolution EPS proxy setting, while the linked files and the type
/// are left to do after the answer ([`ReadFile::finish_read`]).
links_left: Option<(bool, bool)>,
}
/// The part of [`read_for_open`] a file waiting for a profile answer has left to do.
struct Rest {
update_links: bool,
low_res_proxy_eps: bool,
/// The color mode `colorMode` asks for, converted after the policies.
color_mode: Option<vectorcraft_doc::ColorMode>,
}
/// Edit › Color Settings: the color management policies keep, take off or convert from the
@@ -714,36 +737,145 @@ impl ReadFile {
/// reads (`importer` in `p`, or an extension only an importer lists) is read by it
/// ([`super::importer`]).
pub fn read_for_open(name: &str, bytes: &[u8], path: Option<String>, p: &Value, update_links: bool, low_res_proxy_eps: bool) -> Result<ReadFile> {
read_for_open_asking(name, bytes, path, p, update_links, low_res_proxy_eps, false)
}
/// [`read_for_open`]; with `ask` (the desktop app's File › Open), a document whose profile
/// question ([`ReadFile::question`]) Edit › Color Settings asks, and that `p` gives no
/// `profileChoice` for, stops after it is decoded: the app asks, and [`ReadFile::answer`] (or
/// [`open_read`], with the policy's choice) does the rest.
pub fn read_for_open_asking(
name: &str,
bytes: &[u8],
path: Option<String>,
p: &Value,
update_links: bool,
low_res_proxy_eps: bool,
ask: bool,
) -> Result<ReadFile> {
let opts = LoadOptions::from_params("document.open", p)?;
let (mut loaded, policy_changed) = if opts.link_pages {
let mut loaded = linked_pages(name, bytes, path.as_deref(), &opts)?;
let changed = apply_policies(&mut loaded);
(loaded, changed)
let choice = crate::cmd::colormgmt::ProfileChoice::param(p, "document.open")?;
let (loaded, color_mode) = if opts.link_pages {
(linked_pages(name, bytes, path.as_deref(), &opts)?, None)
} else {
match super::importer::pick(name, bytes, p)? {
Some(plugin) => {
let mut loaded = super::importer::load(name, bytes, &plugin, p)?;
let changed = apply_policies(&mut loaded);
(loaded, changed)
}
None => {
// The color mode `p` asks for converts the colors after the policies did, through
// the profiles the document keeps.
let mut loaded = load_with(name, bytes, &LoadOptions { color_mode: None, ..opts.clone() })?;
let changed = apply_policies(&mut loaded);
if let Some(mode) = opts.color_mode.filter(|m| *m != loaded.doc.color_mode) {
let doc = &mut loaded.doc;
vectorcraft_color::cms::with_active(super::super::colormgmt::doc_cms(doc), || {
super::super::colormgmt::set_color_mode(doc, mode, true, None, opts.grays);
});
}
(loaded, changed)
}
Some(plugin) => (super::importer::load(name, bytes, &plugin, p)?, None),
// The color mode `p` asks for converts the colors after the policies did, through the
// profiles the document keeps.
None => (load_with(name, bytes, &LoadOptions { color_mode: None, ..opts.clone() })?, opts.color_mode),
}
};
let links = crate::cmd::links::resolve(&mut loaded.doc, crate::cmd::links::LinkBase::file(path.as_deref()), update_links, low_res_proxy_eps);
Session::refresh_text_bounds(&mut loaded.doc);
Ok(ReadFile { loaded, opts, path, links, policy_changed })
let mut file = ReadFile {
loaded,
opts,
path,
links: Resolved::default(),
policy_changed: false,
choice,
rest: Some(Rest { update_links, low_res_proxy_eps, color_mode }),
answered: None,
asked: None,
links_left: None,
};
if ask && file.choice.is_none() && file.ask().is_some() {
return Ok(file);
}
file.finish_read()?;
Ok(file)
}
impl ReadFile {
/// The file's name, for a prompt.
pub fn name(&self) -> String {
self.path.as_deref().map(file_name).unwrap_or_else(|| self.loaded.doc.title.clone())
}
/// The profile question Edit › Color Settings asks about this file before it opens (its Ask
/// When Opening box of that kind is on), while the file waits for the answer
/// ([`read_for_open_asking`]); none once it is answered or read through.
pub fn question(&self) -> Option<crate::cmd::colormgmt::ProfileQuestion> {
self.rest.as_ref()?;
let st = vectorcraft_color::cms::working_settings();
crate::cmd::colormgmt::ProfileQuestion::of(&self.loaded.doc, &st).filter(|q| q.asked(&st))
}
/// [`Self::question`], kept as the question asked: [`Self::answer`] takes an answer only while
/// the question is still the same. The app calls it when it shows the question.
pub fn ask(&mut self) -> Option<crate::cmd::colormgmt::ProfileQuestion> {
self.asked = self.question();
self.asked.clone()
}
/// Answer the profile question with `choice` and apply it: the policies (the answer in place of
/// the one of the document's color mode) and the color mode. The linked files and the type are
/// left for [`Self::finish_read`] or [`open_read`]. An error leaves the file waiting: a profile
/// to assign that is not one of that model, or Color Settings changed since the question was
/// asked ([`Self::ask`]) so that the question, its model, the profile it is about or the working
/// space differ.
pub fn answer(&mut self, choice: crate::cmd::colormgmt::ProfileChoice) -> Result<()> {
if let Some(asked) = &self.asked
&& self.rest.is_some()
{
let now = crate::cmd::colormgmt::ProfileQuestion::of(&self.loaded.doc, &vectorcraft_color::cms::working_settings());
let key = |q: &crate::cmd::colormgmt::ProfileQuestion| (q.issue, q.model, q.profile.clone(), q.working.clone());
if now.as_ref().map(key) != Some(key(asked)) {
return Err(bad("document.open", "the profile question changed since it was asked: answer the question it asks now"));
}
}
let before = self.choice.replace(choice);
let r = self.apply_answer();
if r.is_err() {
self.choice = before;
}
r
}
/// The rest of [`read_for_open_asking`], once: the color management policies with the profile
/// answer (or as the policy says without one), the color mode `colorMode` asks for, the linked
/// files and the type. The app runs it off the UI thread once the question is answered.
pub fn finish_read(&mut self) -> Result<()> {
self.apply_answer()?;
self.finish_links();
Ok(())
}
/// Read the linked files and lay out the type of a file whose profile answer is applied
/// ([`Self::answer`]), once. A file still waiting for its answer is left as it is.
fn finish_links(&mut self) {
let Some((update_links, low_res_proxy_eps)) = self.links_left.take() else { return };
let base = crate::cmd::links::LinkBase::file(self.path.as_deref());
self.links = crate::cmd::links::resolve(&mut self.loaded.doc, base, update_links, low_res_proxy_eps);
Session::refresh_text_bounds(&mut self.loaded.doc);
}
/// The policies with the profile answer and the color mode `colorMode` asks for, once; the
/// linked files and the type are left for [`Self::finish_read`].
fn apply_answer(&mut self) -> Result<()> {
if self.rest.is_none() {
return Ok(());
}
// The question the answer was given to, for the reply's `profileChoice`.
let question = crate::cmd::colormgmt::ProfileQuestion::of(&self.loaded.doc, &vectorcraft_color::cms::working_settings());
let answered = match (&self.choice, &question) {
(Some(c), Some(q)) if c.issue() == q.issue => Some(json!({ "issue": q.issue.id(), "model": q.to_json()["model"], "choice": c.id() })),
_ => None,
};
// A failure leaves the file waiting, unchanged.
let (notes, changed) = crate::cmd::colormgmt::apply_open_policies_choosing(&mut self.loaded.doc, self.choice.as_ref())?;
let Some(rest) = self.rest.take() else { return Ok(()) };
self.answered = answered;
self.loaded.warnings.extend(notes);
self.policy_changed = changed;
if let Some(mode) = rest.color_mode.filter(|m| *m != self.loaded.doc.color_mode) {
let doc = &mut self.loaded.doc;
let grays = self.opts.grays;
vectorcraft_color::cms::with_active(super::super::colormgmt::doc_cms(doc), || {
super::super::colormgmt::set_color_mode(doc, mode, true, None, grays);
});
}
self.links_left = Some((rest.update_links, rest.low_res_proxy_eps));
Ok(())
}
}
/// The PDF `name` (`bytes`, read from `path`) opened with `linkPages`: its pages as placed documents
@@ -757,8 +889,15 @@ fn linked_pages(name: &str, bytes: &[u8], path: Option<&str>, opts: &LoadOptions
/// The second half of [`open_bytes_with`]: open a file [`read_for_open`] read as the new active
/// document → `document.open`'s result.
pub fn open_read(s: &mut Session, file: ReadFile) -> Result<Value> {
open_loaded(s, file.loaded, file.links, file.path, &file.opts, false, file.policy_changed)
/// A file still waiting for its profile answer ([`ReadFile::question`]) opens as its policy says.
pub fn open_read(s: &mut Session, mut file: ReadFile) -> Result<Value> {
file.finish_read()?;
let answered = file.answered.take();
let mut r = open_loaded(s, file.loaded, file.links, file.path, &file.opts, false, file.policy_changed)?;
if let Some(a) = answered {
r["profileChoice"] = a;
}
Ok(r)
}
/// File → New from Template: any readable file (at `path`, if it is one: its links are looked for
+4 -3
View File
@@ -636,8 +636,8 @@ pub const DEFAULT_FLATTENER: &str = "High Resolution";
/// `doc` with its transparency flattened for a PDF 1.3 file (asked for, or PDF/X-1a and PDF/X-3,
/// whose files have none), with `flattenerPreset` (default High Resolution) and `p`'s `flattener`
/// options over it; images with see-through pixels and colorized images, including those in
/// pattern tiles, count as transparency. Rasterized areas are clipped to their regions, and
/// discarded overprints are dropped. Layers the pages leave out (non-printing ones, unless asked
/// pattern tiles, count as transparency. Rasterized areas are clipped to their regions and keep no
/// alpha, and discarded overprints are dropped. Layers the pages leave out (non-printing ones, unless asked
/// for) are left out of the flattening, hidden. → the document to write (`None`: `doc` as it is)
/// and whether its transparency was flattened.
fn flatten_for(cmd: &str, doc: &Document, set: &PdfSettings, p: &Value) -> Result<(Option<Document>, Option<FlattenOptions>)> {
@@ -655,8 +655,9 @@ fn flatten_for(cmd: &str, doc: &Document, set: &PdfSettings, p: &Value) -> Resul
o.preserve_overprints &= set.advanced.overprint == Overprint::Preserve;
o.no_transparency = Some(see_through_images(doc));
// Without soft masks a rasterized area can't be a rectangle with see-through pixels around
// its art: it is clipped to its regions (opaque inside them).
// its art: it is clipped to its regions (opaque inside them). Rasters keep no alpha either.
o.clip_complex_regions = true;
o.preserve_alpha = false;
Ok(match flatten_document(shown.as_ref().unwrap_or(doc), &o)? {
Some(flat) => (Some(flat), Some(o)),
None => (shown, None),
+51 -44
View File
@@ -684,57 +684,64 @@ struct Counts {
clipped_out: usize,
}
/// `n` things: "1 layer was", "2 layers were".
fn count(n: usize, one: &str, many: &str) -> String {
if n == 1 { format!("1 {one} was") } else { format!("{n} {many} were") }
/// Adds the warning for `n` things to `out`: `one` when `n` is 1, `many` with the count in place
/// of `{n}` when it is more, none when it is 0. Each form is a whole sentence, the key of its own
/// catalog row.
fn note(out: &mut Vec<String>, n: usize, (one, many): (&str, &str)) {
match n {
0 => {}
1 => out.push(one.to_string()),
n => out.push(many.replace("{n}", &n.to_string())),
}
}
/// The layer warnings in English, the form for one layer and the form for more, in the order a
/// file's warnings list them.
pub const LAYER_WARNINGS: [(&str, &str); 10] = [
("1 type layer came in as pixels: the text isn't editable", "{n} type layers came in as pixels: the text isn't editable"),
("1 adjustment layer was not applied", "{n} adjustment layers were not applied"),
(
"1 fill layer was not drawn (a gradient or pattern fill, a color that can't be read, or a shape that stores no pixels)",
"{n} fill layers were not drawn (a gradient or pattern fill, a color that can't be read, or a shape that stores no pixels)",
),
("the layer effects of 1 layer weren't drawn", "the layer effects of {n} layers weren't drawn"),
("the vector masks of 1 layer weren't applied", "the vector masks of {n} layers weren't applied"),
("the knockout of 1 layer wasn't applied", "the knockout of {n} layers wasn't applied"),
(
"1 layer was left out (hidden layers and the layers clipped to them)",
"{n} layers were left out (hidden layers and the layers clipped to them)",
),
("1 layer clipped to a fill layer that wasn't drawn was left out", "{n} layers clipped to fill layers that weren't drawn were left out"),
(
"1 layer in blend modes VectorCraft doesn't have came in as Normal: the merge needs more memory than allowed",
"{n} layers in blend modes VectorCraft doesn't have came in as Normal: the merge needs more memory than allowed",
),
(
"1 layer clipped to the layer below came in unclipped: the merge needs more memory than allowed",
"{n} layers clipped to the layer below came in unclipped: the merge needs more memory than allowed",
),
];
/// The warning for layers merged with the layers below them, `{modes}` the blend modes' names.
pub const MERGED_WARNING: &str = "layers in blend modes VectorCraft doesn't have ({modes}) were merged with the layers below them";
impl Notes {
fn warnings(self) -> Vec<String> {
let [types, adjustments, fills, effects, masks, knockouts, hidden, clipped_out, unmerged, unclipped] = LAYER_WARNINGS;
let mut out = vec![];
if self.types > 0 {
let n = if self.types == 1 { "1 type layer".to_string() } else { format!("{} type layers", self.types) };
out.push(format!("{n} came in as pixels: the text isn't editable"));
}
if self.adjustments > 0 {
out.push(format!("{} not applied", count(self.adjustments, "adjustment layer", "adjustment layers")));
}
if self.fills > 0 {
out.push(format!(
"{} not drawn (a gradient or pattern fill, a color that can't be read, or a shape that stores no pixels)",
count(self.fills, "fill layer", "fill layers")
));
}
let layers = |n: usize| if n == 1 { "1 layer".to_string() } else { format!("{n} layers") };
if self.effects > 0 {
out.push(format!("the layer effects of {} weren't drawn", layers(self.effects)));
}
if self.vector_masks > 0 {
out.push(format!("the vector masks of {} weren't applied", layers(self.vector_masks)));
}
if self.knockouts > 0 {
out.push(format!("the knockout of {} wasn't applied", layers(self.knockouts)));
}
if self.hidden > 0 {
out.push(format!("{} left out (hidden layers and the layers clipped to them)", count(self.hidden, "layer", "layers")));
}
if self.clipped_out == 1 {
out.push("1 layer clipped to a fill layer that wasn't drawn was left out".into());
} else if self.clipped_out > 1 {
out.push(format!("{} layers clipped to fill layers that weren't drawn were left out", self.clipped_out));
}
note(&mut out, self.types, types);
note(&mut out, self.adjustments, adjustments);
note(&mut out, self.fills, fills);
note(&mut out, self.effects, effects);
note(&mut out, self.vector_masks, masks);
note(&mut out, self.knockouts, knockouts);
note(&mut out, self.hidden, hidden);
note(&mut out, self.clipped_out, clipped_out);
if !self.merged.is_empty() {
out.push(format!("layers in blend modes VectorCraft doesn't have ({}) were merged with the layers below them", self.merged.join(", ")));
}
if self.unmerged > 0 {
out.push(format!(
"{} in blend modes VectorCraft doesn't have came in as Normal: the merge needs more memory than allowed",
layers(self.unmerged)
));
}
if self.unclipped > 0 {
out.push(format!("{} clipped to the layer below came in unclipped: the merge needs more memory than allowed", layers(self.unclipped)));
out.push(MERGED_WARNING.replace("{modes}", &self.merged.join(", ")));
}
note(&mut out, self.unmerged, unmerged);
note(&mut out, self.unclipped, unclipped);
out
}
+3 -2
View File
@@ -175,8 +175,9 @@ fn skip_record(r: &mut Reader<'_>) -> Result<(), String> {
/// Versions 7 and 8: the descriptor's `slices` list, each slice an object.
fn from_descriptor(d: &[(String, Value)]) -> Result<Vec<PsdSlice>, String> {
let Some(Value::List(list)) = field(d, "slices") else { return Err("the slices' descriptor has no list of slices".into()) };
if list.len() > MAX_SLICES {
return Err(format!("the file has {} slices, more than the {MAX_SLICES} read", list.len()));
let count = list.len();
if count > MAX_SLICES {
return Err(format!("the file has {count} slices, more than the {MAX_SLICES} read"));
}
let mut out = vec![];
for s in list {
@@ -534,6 +534,104 @@ fn export_options_are_checked() {
let p = json!({"format": "hpgl", "origin": "CENTER", "pens": ["#ff0000", "#000000"], "curveTolerance": 10, "sortPaths": true});
let plot = String::from_utf8(bytes(&s.execute("document.export", &p).unwrap())).unwrap();
assert_eq!(plot, "IN;PU;SP2;PU-141,141;PD-564,141,-564,564,-141,564,-141,141;PU;SP0;");
// The check a dialog runs refuses the same options, and passes the given ones.
let doc = s.doc().unwrap().doc.clone();
assert!(hpgl::check(&doc, &json!({"pens": ["#ff0000", "red"]})).unwrap_err().contains("`pens`"));
assert!(hpgl::check(&doc, &json!({"curveTolerance": 11})).unwrap_err().contains("`curveTolerance`"));
assert_eq!(hpgl::check(&doc, &p), Ok(()));
// It checks the artboard choice as the export does: an artboard or range past the document's,
// a `useArtboards` that isn't true or false, and the art's bounds when no art shows.
let mut blank = Session::new();
blank.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let blank_doc = blank.doc().unwrap().doc.clone();
for (on_blank, p) in [
(false, json!({"format": "hpgl", "artboard": 2})),
(false, json!({"format": "hpgl", "useArtboards": true, "range": "1-3"})),
(false, json!({"format": "hpgl", "artboards": [0, 1]})),
(false, json!({"format": "hpgl", "useArtboards": "yes"})),
(true, json!({"format": "hpgl", "useArtboards": false})),
] {
let (session, d) = if on_blank { (&mut blank, &blank_doc) } else { (&mut s, &doc) };
assert!(hpgl::check(d, &p).is_err(), "{p}");
assert!(session.execute("document.export", &p).is_err(), "{p}");
}
// An artboard with no width is refused before the writer refuses it.
let mut flat = vectorcraft_doc::Document::clone(&doc);
flat.artboards[1].rect = vectorcraft_geom::Rect::new(200.0, 0.0, 200.0, 100.0);
assert_eq!(hpgl::check(&flat, &json!({"artboard": 1})).unwrap_err(), hpgl::check(&flat, &json!({"useArtboards": true})).unwrap_err());
assert!(hpgl::check(&flat, &json!({"artboard": 1})).unwrap_err().contains("the export region is empty"));
assert_eq!(hpgl::check(&flat, &json!({})), Ok(()));
// A document with no artboard has nothing to plot on one, or on each.
flat.artboards.clear();
for p in [json!({}), json!({"useArtboards": true})] {
assert!(hpgl::check(&flat, &p).unwrap_err().contains("the document has no artboard"), "{p}");
}
// An area of the page is a raster export's option: the export refuses it, and so does the check.
let rect = json!({"format": "hpgl", "rect": [0, 0, 10, 10]});
assert!(s.execute("document.export", &rect).is_err());
assert!(hpgl::check(&doc, &rect).unwrap_err().contains("rect applies to raster formats"));
assert_eq!(hpgl::check(&doc, &json!({"useArtboards": true, "range": "2"})), Ok(()));
assert_eq!(hpgl::check(&doc, &json!({"useArtboards": false})), Ok(()));
}
/// The pens an export without a pen table uses: one per color the plotted art draws in, in the
/// order it first draws in each, over the artboards or the art's bounds the export plots.
#[test]
fn automatic_pens_list_the_plotted_art_s_colors_in_pen_order() {
let s = two_boards();
let doc = &s.doc().unwrap().doc;
let pens = |p: Value| hpgl::automatic_pens(doc, &p).unwrap();
assert_eq!(pens(json!({})), ["#000000"], "the first artboard");
assert_eq!(pens(json!({"artboard": 1})), ["#ff0000"]);
assert_eq!(pens(json!({"useArtboards": true})), ["#000000", "#ff0000"], "one numbering for every file");
assert_eq!(pens(json!({"useArtboards": false})), ["#000000", "#ff0000"], "the art's bounds");
// The pens given and the path order are not the export's own pens.
assert_eq!(pens(json!({"useArtboards": true, "pens": ["#00ff00"], "sortPaths": true})), ["#000000", "#ff0000"]);
// A refused artboard choice or option is an error, not an empty table.
assert!(hpgl::automatic_pens(doc, &json!({"artboard": 5})).is_err());
assert!(hpgl::automatic_pens(doc, &json!({"curveTolerance": 20})).unwrap_err().contains("`curveTolerance`"));
// So is an area of the page, which the export and the check refuse for HP-GL.
assert!(hpgl::automatic_pens(doc, &json!({"rect": [0, 0, 10, 10]})).unwrap_err().contains("rect applies to raster formats"));
// Art outside every artboard is plotted only with the art's bounds.
let mut off = Session::new();
off.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
off.execute("paint.setFill", &json!({"none": true})).unwrap();
off.execute("paint.setStroke", &json!({"color": "#0000ff"})).unwrap();
off.execute("shape.rectangle", &json!({"x": 500, "y": 500, "width": 30, "height": 30})).unwrap();
let doc = &off.doc().unwrap().doc;
assert_eq!(hpgl::automatic_pens(doc, &json!({})), Ok(vec![]));
assert_eq!(hpgl::automatic_pens(doc, &json!({"useArtboards": false})), Ok(vec!["#0000ff".to_string()]));
}
/// A placed document opened with only its preview is plotted with its file's art (the plot reads
/// the file), so the check and the pens of a dialog measure that art as the export does.
#[test]
fn a_placed_document_s_pens_are_those_of_its_file_s_art() {
use crate::tests_links::{Folder, open, save, session, write};
let dir = Folder::new("hpgl-placed");
let src = dir.file("logo.vectorcraft");
let mut d = vectorcraft_doc::Document::new(100.0, 50.0);
let layer = d.layers[0].id;
let id = d.alloc_id();
let red = vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb8(255, 0, 0));
let look = vectorcraft_doc::Appearance::basic(red, vectorcraft_color::Paint::None, 0.0);
let rect = vectorcraft_geom::shapes::rectangle(vectorcraft_geom::Rect::new(0.0, 0.0, 100.0, 50.0));
d.insert(Some(layer), 0, vectorcraft_doc::Node::path(id, rect, look)).unwrap();
write(&src, &vectorcraft_format::save_file(&d));
let mut s = session();
s.execute("file.place", &json!({"path": src, "at": [200, 150]})).unwrap();
let poster = dir.file("poster.vectorcraft");
save(&mut s, &poster);
open(&mut s, &poster);
let doc = &s.doc().unwrap().doc;
assert!(doc.images.values().any(vectorcraft_doc::ImageBlob::is_proxy), "opened with the preview only");
for p in [json!({}), json!({"useArtboards": false})] {
assert_eq!(hpgl::automatic_pens(doc, &p), Ok(vec!["#ff0000".to_string()]), "{p}");
assert_eq!(hpgl::check(doc, &p), Ok(()), "{p}");
}
let plot = String::from_utf8(bytes(&s.execute("document.export", &json!({"format": "hpgl"})).unwrap())).unwrap();
assert!(plot.contains("SP1;") && plot.contains("PD"), "{plot}");
}
/// `insideFirst` draws the square inside the other one first, though it was made last.
@@ -166,6 +166,14 @@ fn the_flattener_preset_and_options_apply() {
assert!(!transparency(&kept).is_empty() && !warnings.iter().any(|w| w.contains("flattened")));
}
#[test]
fn pdf_1_3_files_flatten_without_alpha_whatever_the_options() {
let mut s = session();
let p = json!({"compatibility": "1.3", "preserveEditing": false, "flattener": {"balance": 0, "preserveAlpha": true}});
let (pdf, _) = export(&mut s, p);
assert!(pdf.starts_with(b"%PDF-1.3") && transparency(&pdf).is_empty());
}
#[test]
fn pdf_1_3_files_are_encrypted_with_40_bit_rc4_and_can_be_linearised() {
let mut s = session();
+45
View File
@@ -437,3 +437,48 @@ fn svg_darkness_uses_rendered_shadow_in_non_srgb_working_space() {
assert!(a.iter().zip(b).all(|(a, b)| a.abs_diff(b) <= 8), "at {x}: {a:?} vs {b:?}");
}
}
/// #864 / G11: SVG export preserves the document's physical units on the root `width`/`height` so
/// that the unit setting survives a save/open round-trip. The engine-level test covers the full
/// stack (file.new → document.setUnits → document.serialize → document.open).
#[test]
fn svg_round_trip_preserves_document_units() {
// (unit name the engine accepts, expected unit after re-import)
let cases: &[(&str, vectorcraft_doc::Unit)] = &[
("millimeters", vectorcraft_doc::Unit::Millimeters),
("centimeters", vectorcraft_doc::Unit::Centimeters),
("inches", vectorcraft_doc::Unit::Inches),
("picas", vectorcraft_doc::Unit::Picas),
// Points and pixels both serialise as bare user-unit numbers, so both import as Pixels.
("pixels", vectorcraft_doc::Unit::Pixels),
];
for (name, expected) in cases {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 1})).unwrap();
s.execute("document.setUnits", &json!({"units": name})).unwrap();
let r = s.execute("document.serialize", &json!({"format": "svg"})).unwrap();
let svg_text = r["text"].as_str().unwrap();
match *expected {
vectorcraft_doc::Unit::Millimeters => assert!(svg_text.contains("mm\""), "mm suffix missing: {svg_text}"),
vectorcraft_doc::Unit::Centimeters => assert!(svg_text.contains("cm\""), "cm suffix missing: {svg_text}"),
vectorcraft_doc::Unit::Inches => assert!(svg_text.contains("in\""), "in suffix missing: {svg_text}"),
vectorcraft_doc::Unit::Picas => assert!(svg_text.contains("pc\""), "pc suffix missing: {svg_text}"),
_ => {}
}
let b64 = vectorcraft_format::base64_encode(svg_text.as_bytes());
s.execute("document.open", &json!({"name": "test.svg", "dataBase64": b64})).unwrap();
let doc_state = s.doc().unwrap();
assert_eq!(doc_state.doc.units, *expected, "unit mismatch after round-trip for '{name}'");
}
// Points serialise without suffix and re-open as Pixels (equivalent in user units).
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100, "artboards": 1})).unwrap();
s.execute("document.setUnits", &json!({"units": "points"})).unwrap();
let r = s.execute("document.serialize", &json!({"format": "svg"})).unwrap();
let svg_text = r["text"].as_str().unwrap();
assert!(svg_text.contains("width=\"200\" height=\"100\""), "{svg_text}");
let b64 = vectorcraft_format::base64_encode(svg_text.as_bytes());
s.execute("document.open", &json!({"name": "test.svg", "dataBase64": b64})).unwrap();
assert_eq!(s.doc().unwrap().doc.units, vectorcraft_doc::Unit::Pixels);
}
+3 -2
View File
@@ -746,8 +746,8 @@ fn give_appearance(a: &Appearance, b: &Appearance, m: &Appearance, n: &mut Share
}
/// Give the member's fill or stroke `n` the settings of the model's that changed from `a` to `b`,
/// with the values of `m` (`b` placed on the member). A stroke's pen pressure, tilt, bearing and
/// rotation stay its own.
/// with the values of `m` (`b` placed on the member). A stroke's pen pressure, tilt, bearing,
/// rotation and wheel stay its own.
fn give_item(a: &AppearanceItem, b: &AppearanceItem, m: &AppearanceItem, n: &mut AppearanceItem) {
use AppearanceItem::{Fill, Stroke};
match (a, b, m, n) {
@@ -781,6 +781,7 @@ fn give_item(a: &AppearanceItem, b: &AppearanceItem, m: &AppearanceItem, n: &mut
tilt: _,
bearing: _,
rotation: _,
wheel: _,
} = m;
give_fields!(a, b, n: paint, width, cap, join, miter_limit, align, dash, start_arrow, end_arrow, arrow_scale, profile, brush, brush_options, opacity, blend, visible, effects, arrow_align, overprint, gradient_mode);
// A stroke's own brush settings go with the brush they set: a new brush takes the model's.
+75
View File
@@ -7406,6 +7406,81 @@ fn the_last_label_of_a_kind_edited_together_sets_what_it_keeps() {
assert_eq!(kept(&s), "#ff0000");
}
/// A column graph, a 10 pt square with one red fill row, and the category labels Q1, Q2 and Q3: Q1 and Q3 have one red
/// fill row, Q2 a hidden red fill row under a green one, and Q1's row is then painted blue, which the kind keeps.
/// Returns the graph, the square and the three labels.
fn labels_with_hidden_and_shown_rows(s: &mut Session) -> (NodeId, NodeId, [NodeId; 3]) {
use vectorcraft_doc::{AppearanceItem, FillLayer};
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
let id = graph(s, "column");
let square = NodeId(s.execute("shape.rectangle", &json!({"x": 600, "y": 600, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap());
let labels = ["Q1", "Q2", "Q3"].map(|t| text_id(s, id, "Axes", t));
let fill = |hex: &str, visible: bool| {
AppearanceItem::Fill(FillLayer { visible, ..FillLayer::new(Paint::solid(vectorcraft_color::Color::from_hex(hex).unwrap())) })
};
s.edit("Rows", |d, _| {
for (l, items) in [
(square, vec![fill("#ff0000", true)]),
(labels[0], vec![fill("#ff0000", true)]),
(labels[1], vec![fill("#ff0000", false), fill("#00ff00", true)]),
(labels[2], vec![fill("#ff0000", true)]),
] {
d.node_mut(l).unwrap().appearance.items = items;
}
Ok(())
})
.unwrap();
s.execute("appearance.setItem", &json!({"ids": [labels[0].0], "index": 0, "color": "#0000ff"})).unwrap();
assert_eq!(kept_category_fill(s, id), Some("#0000ff".into()));
(id, square, labels)
}
/// The fill of the category label rows graph `id` keeps, as a hex color.
fn kept_category_fill(s: &Session, id: NodeId) -> Option<String> {
spec(s, id).label_styles.categories_rows.and_then(|r| r.paint.fill).and_then(|p| p.color()).map(|c| c.to_hex())
}
/// Row edits on several labels at once, with a plain object among them, keep for the kind what the last label whose shown
/// row the edit wrote shows, also when that row comes out as it was; a label whose hidden row the edit wrote is left out.
/// One undo takes it back. Covers `appearance.setItem`, `appearance.duplicateItem` and `paint.setFill` with `item`.
#[test]
fn row_edits_on_several_labels_keep_the_last_written_shown_row() {
let edits = [
("appearance.setItem", json!({"index": 0, "color": "#ff0000"})),
("appearance.duplicateItem", json!({"index": 0})),
("paint.setFill", json!({"item": 0, "color": "#ff0000"})),
];
for (cmd, mut p) in edits {
let mut s = Session::new();
let (id, square, [_, q2, q3]) = labels_with_hidden_and_shown_rows(&mut s);
// Q3 shows red before and after the edit; Q2 shows green over the hidden row the edit writes.
p["ids"] = json!([q3.0, square.0, q2.0]);
s.execute(cmd, &p).unwrap();
assert_eq!(kept_category_fill(&s, id), Some("#ff0000".into()), "{cmd}");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(kept_category_fill(&s, id), Some("#0000ff".into()), "{cmd}: undo");
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(kept_category_fill(&s, id), Some("#ff0000".into()), "{cmd}: redo");
s.execute("edit.undo", &json!({})).unwrap();
// Only the hidden row of a label: the kind keeps blue.
let steps = s.doc().unwrap().history.undo.len();
p["ids"] = json!([square.0, q2.0]);
s.execute(cmd, &p).unwrap();
assert_eq!(kept_category_fill(&s, id), Some("#0000ff".into()), "{cmd}: hidden row only");
while s.doc().unwrap().history.undo.len() > steps {
s.execute("edit.undo", &json!({})).unwrap();
}
// Q2's shown green row, written as it was: the kind keeps green.
p["ids"] = json!([q2.0]);
p[if cmd == "paint.setFill" { "item" } else { "index" }] = json!(1);
if cmd != "appearance.duplicateItem" {
p["color"] = json!("#00ff00");
}
s.execute(cmd, &p).unwrap();
assert_eq!(kept_category_fill(&s, id), Some("#00ff00".into()), "{cmd}: the shown row written as it was");
}
}
/// A label's object opacity and blend mode set without a row (`transparency.set` without `item`) are kept for its kind.
#[test]
fn a_labels_object_opacity_and_blend_mode_are_kept_for_its_kind() {
+353
View File
@@ -0,0 +1,353 @@
//! Type › Kinsoku Shori Settings…: the document's custom Kinsoku Shori sets
//! ([`vectorcraft_doc::KinsokuSet`]). Each set lists the characters that may not start a line,
//! those that may not end one, the hanging punctuation Burasagari hangs, and the inseparable
//! sequences Bunri-Kinshi keeps together. A paragraph chooses one by name in Kinsoku Set
//! (`text.setFormat {kinsoku: name}`) and holds a copy of it, which an edit of the set replaces.
//!
//! Behavior reference: the help page
//! <https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/use-kinsoku-for-japanese-line-breaking.html>.
//! The name rules, the limits and Hard as the set a deleted set's paragraphs take are VectorCraft's
//! own.
use std::collections::HashMap;
use std::sync::Arc;
use serde_json::{Map, Value, json};
use vectorcraft_doc::graph::LabelStyles;
use vectorcraft_doc::text::{KINSOKU_CATEGORY_MAX, KINSOKU_NAME_MAX, KINSOKU_SEQUENCE, KINSOKU_SETS_MAX};
use vectorcraft_doc::{Document, Kinsoku, KinsokuSet, Node, NodeKind, ParaStyle};
use super::textstyles::each_node_with_text_mut;
use super::typecmd::refresh_bounds;
use super::{CommandSpec, Result, Session, bad, cmd, has_doc};
/// The command Type › Kinsoku Shori Settings…'s OK runs, and the menu item's.
pub const SET: &str = "type.kinsokuSets.set";
/// The keys a set may give.
const SET_KEYS: [&str; 6] = ["name", "from", "cannotStart", "cannotEnd", "hanging", "inseparable"];
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
query "type.kinsokuSets.list",
"Kinsoku Sets",
[],
None,
"{} the active document's custom Kinsoku Shori sets, and the paragraphs, paragraph styles and graphs (in the paragraph attributes they keep for their labels) using each → {sets: [{name, cannotStart: characters, cannotEnd: characters, hanging: characters, inseparable: [sequence], paragraphs, styles, graphs}]}",
has_doc,
list
),
cmd!(
query "type.kinsokuSets.base",
"Kinsoku Set Base",
[],
None,
"{base: \"none\"|\"hard\"|\"soft\"|name of a custom set (any case), name?} the categories of a built-in or custom set, as a new set based on it starts (Type › Kinsoku Shori Settings…'s New Set): Hard and Soft list the characters they keep off a line's start and end, the East Asian comma and full stop as hanging punctuation, and the pairs Bunri-Kinshi keeps together; None lists nothing → {set: {name, cannotStart, cannotEnd, hanging, inseparable}}",
has_doc,
base
),
cmd!(
"type.kinsokuSets.set",
"Kinsoku Shori Settings…",
["Type"],
None,
"{sets: [{name, from?: the name the set had (rename), cannotStart?: characters, cannotEnd?: characters, hanging?: characters, inseparable?: [sequence of 2..16 characters]}]} replace the active document's custom Kinsoku Shori sets (Type › Kinsoku Shori Settings…'s OK), as one undo step, none when nothing changes. Cannot Start Line characters never start a line and Cannot End Line characters never end one; Hanging Punctuation characters hang outside a line's end with Burasagari; while Bunri-Kinshi is on, a line never breaks inside an inseparable sequence. cannotStart, cannotEnd and hanging keep each character once, sorted, and inseparable keeps each sequence once, sorted (a sequence may repeat a character); each category holds at most 4096 characters (the sequences count each of their characters); a control or space character fails the call, as do an unknown key and a `from` the document has no set of. Names are trimmed, unique in any case, at most 128 characters, never None, Hard or Soft; at most 256 sets. A set given the name of a set the document has (any case) and no `from` is that set. Every paragraph and paragraph style using a set takes its new characters and name; one using a set left out takes Hard. The built-in None, Hard and Soft can't be changed or deleted → {sets}",
has_doc,
set
),
]
}
/// Call `f` with every node in `d`'s layers (opacity masks included), symbols, graph designs,
/// pattern tiles and brush art, the trees [`each_node_with_text_mut`] reaches.
fn each_node(d: &Document, f: &mut impl FnMut(&Node)) {
let brushes = vectorcraft_brush::library(d);
let trees = d.layers.iter().map(|l| &**l).chain(d.symbols.iter().map(|s| &*s.art)).chain(d.graph_designs.iter().map(|g| &*g.art));
let patterns = d.patterns.iter().chain(d.pattern_edit.iter().filter_map(|pe| pe.original.as_ref()));
let trees = trees.chain(patterns.flat_map(|p| p.art.iter().map(|a| &**a))).chain(brushes.iter().flat_map(|b| b.art()));
for tree in trees {
vectorcraft_doc::swatches::walk_with_masks(tree, &mut |n| f(n));
}
}
/// Call `f` with every paragraph of the type [`each_node`] reaches.
fn each_paragraph(d: &Document, f: &mut impl FnMut(&ParaStyle)) {
each_node(d, &mut |node| {
if let NodeKind::Text(t) = &node.kind {
(0..t.paragraph_count()).for_each(|i| f(t.para_at(i)));
}
});
}
/// How many paragraphs, paragraph styles and graphs (in the paragraph attributes they keep for
/// their labels) use each set of the document, by lowercased name.
fn uses(s: &Session) -> Result<HashMap<String, (usize, usize, usize)>> {
let mut n: HashMap<String, (usize, usize, usize)> = HashMap::new();
let d = &s.doc()?.doc;
each_paragraph(d, &mut |p| {
if let Some(set) = &p.kinsoku_set {
n.entry(set.name.to_lowercase()).or_default().0 += 1;
}
});
for st in d.para_styles.iter() {
if let Some(name) = st.attrs.get("kinsoku_set").and_then(|v| v.get("name")).and_then(Value::as_str) {
n.entry(name.to_lowercase()).or_default().1 += 1;
}
}
each_node(d, &mut |node| {
let Some(g) = node.extras().graph.as_deref() else { return };
let mut l = g.label_styles.clone();
let mut names: Vec<String> = label_paras(&mut l).filter_map(|p| p.kinsoku_set.as_ref().map(|k| k.name.to_lowercase())).collect();
names.sort();
names.dedup();
for name in names {
n.entry(name).or_default().2 += 1;
}
});
Ok(n)
}
fn list(s: &mut Session, _: &Value) -> Result<Value> {
let uses = uses(s)?;
let sets: Vec<Value> = s
.doc()?
.doc
.kinsoku_sets
.iter()
.map(|set| {
let (paragraphs, styles, graphs) = uses.get(&set.name.to_lowercase()).copied().unwrap_or_default();
let mut v = json!(set);
if let Some(o) = v.as_object_mut() {
o.insert("paragraphs".into(), json!(paragraphs));
o.insert("styles".into(), json!(styles));
o.insert("graphs".into(), json!(graphs));
}
v
})
.collect();
Ok(json!({ "sets": sets }))
}
/// The set `name` names: a built-in one (`none`, `hard`, `soft`) or a custom set of `sets` (any
/// case).
fn named_base(sets: &[KinsokuSet], name: &str) -> Option<KinsokuSet> {
match name {
"none" => Some(vectorcraft_text::kinsoku_set_from(Kinsoku::None, "")),
"hard" => Some(vectorcraft_text::kinsoku_set_from(Kinsoku::Hard, "")),
"soft" => Some(vectorcraft_text::kinsoku_set_from(Kinsoku::Soft, "")),
_ => KinsokuSet::named(sets, name.trim()).cloned(),
}
}
fn base(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "type.kinsokuSets.base";
let from = p.get("base").and_then(Value::as_str).ok_or_else(|| bad(C, "give base: \"none\", \"hard\", \"soft\" or a set's name"))?;
let mut set = named_base(&s.doc()?.doc.kinsoku_sets, from).ok_or_else(|| bad(C, format!("no Kinsoku set named `{from}`")))?;
set.name = match p.get("name") {
None | Some(Value::Null) => String::new(),
Some(Value::String(n)) => n.clone(),
Some(_) => return Err(bad(C, "name must be text")),
};
Ok(json!({ "set": set }))
}
/// A category of single characters from `v` (text, one character after another): empty when left
/// out. Text far longer than a category holds is refused before it is read.
fn chars(v: Option<&Value>, key: &str, name: &str, c: &str) -> Result<Vec<char>> {
match v {
None | Some(Value::Null) => Ok(Vec::new()),
Some(Value::String(text)) => {
if text.chars().count() > KINSOKU_CATEGORY_MAX * 4 {
return Err(bad(c, format!("`{name}`: {key} must be at most {KINSOKU_CATEGORY_MAX} characters")));
}
Ok(text.chars().collect())
}
Some(_) => Err(bad(c, format!("`{name}`: {key} must be text, one character after another"))),
}
}
/// Set `v` from command parameters, its name trimmed, with the name it had (`from`, trimmed) when
/// it gives one.
fn parse_set(v: &Value, c: &str) -> Result<(KinsokuSet, Option<String>)> {
let o = v.as_object().ok_or_else(|| bad(c, "each set must be {name, cannotStart?, cannotEnd?, hanging?, inseparable?}"))?;
if let Some(k) = o.keys().find(|k| !SET_KEYS.contains(&k.as_str())) {
return Err(bad(c, format!("unknown key `{k}`; a set takes {}", SET_KEYS.join(", "))));
}
// A null value is refused rather than read as a key left out.
if let Some(k) = o.iter().find_map(|(k, v)| v.is_null().then_some(k)) {
return Err(bad(c, format!("`{k}` can't be null; leave it out instead")));
}
let raw = o.get("name").and_then(Value::as_str).ok_or_else(|| bad(c, "each set needs a name"))?;
let name = KinsokuSet::clean_name(raw).ok_or_else(|| {
bad(c, format!("`{raw}` can't name a Kinsoku set (1 to {KINSOKU_NAME_MAX} characters, no control characters, not None, Hard or Soft)"))
})?;
let from = match o.get("from") {
None | Some(Value::Null) => None,
Some(Value::String(f)) => Some(f.trim().to_string()),
Some(_) => return Err(bad(c, format!("`{name}`: from must be text"))),
};
let inseparable = match o.get("inseparable") {
None | Some(Value::Null) => Vec::new(),
Some(Value::Array(list)) => {
if list.len() > KINSOKU_CATEGORY_MAX {
return Err(bad(c, format!("`{name}`: inseparable: at most {KINSOKU_CATEGORY_MAX} characters in all")));
}
list.iter()
.map(|s| {
s.as_str().map(str::to_string).ok_or_else(|| {
bad(
c,
format!(
"`{name}`: inseparable must be a list of {} to {} characters each",
KINSOKU_SEQUENCE.start(),
KINSOKU_SEQUENCE.end()
),
)
})
})
.collect::<Result<Vec<_>>>()?
}
Some(_) => return Err(bad(c, format!("`{name}`: inseparable must be a list of sequences"))),
};
let mut set = KinsokuSet {
cannot_start: chars(o.get("cannotStart"), "cannotStart", &name, c)?,
cannot_end: chars(o.get("cannotEnd"), "cannotEnd", &name, c)?,
hanging: chars(o.get("hanging"), "hanging", &name, c)?,
inseparable,
name,
};
set.normalize();
set.check().map_err(|e| bad(c, format!("`{}`: {e}", set.name)))?;
Ok((set, from))
}
/// Make `after` the active document's custom sets, as one undo step (none when nothing changes).
/// `renamed` maps the lowercased name of each set of the document that is kept to the index in
/// `after` of what it becomes; a set it leaves out is deleted, and its paragraphs and paragraph
/// styles take Hard.
fn replace(s: &mut Session, after: Vec<KinsokuSet>, renamed: HashMap<String, usize>) -> Result<()> {
let before = s.doc()?.doc.kinsoku_sets.to_vec();
let after_arcs: Vec<Arc<KinsokuSet>> = after.iter().cloned().map(Arc::new).collect();
// The paragraph value of each set of the document as it was: the new set, or none (Hard).
let next = |old: &KinsokuSet| -> Option<Option<Arc<KinsokuSet>>> {
let key = old.name.to_lowercase();
before.iter().any(|b| b.name.to_lowercase() == key).then(|| renamed.get(&key).and_then(|&i| after_arcs.get(i).cloned()))
};
let fix = |p: &mut ParaStyle| -> bool {
let Some(old) = p.kinsoku_set.as_deref() else { return false };
let Some(new) = next(old) else { return false };
if new.as_deref() == Some(old) {
return false;
}
if new.is_none() {
p.kinsoku = Kinsoku::Hard;
}
p.kinsoku_set = new;
true
};
let mut texts_change = false;
each_paragraph(&s.doc()?.doc, &mut |p| texts_change |= !texts_change && fix(&mut p.clone()));
// A graph draws its labels again from the paragraph attributes it keeps for them.
let fix_labels = |l: &mut LabelStyles| label_paras(l).fold(false, |changed, p| fix(p) | changed);
each_node(&s.doc()?.doc, &mut |n| {
texts_change |= !texts_change && n.extras().graph.as_deref().is_some_and(|g| fix_labels(&mut g.label_styles.clone()));
});
let style_attrs = |attrs: &Map<String, Value>| -> Option<Map<String, Value>> {
let old: KinsokuSet = serde_json::from_value(attrs.get("kinsoku_set")?.clone()).ok()?;
let new = next(&old)?;
if new.as_deref() == Some(&old) {
return None;
}
let mut m = attrs.clone();
match new {
Some(set) => m.insert("kinsoku_set".into(), json!(set)),
None => {
m.insert("kinsoku".into(), json!(Kinsoku::Hard));
m.insert("kinsoku_set".into(), Value::Null)
}
};
Some(m)
};
let styles_change = s.doc()?.doc.para_styles.iter().any(|st| style_attrs(&st.attrs).is_some());
if before == after && !texts_change && !styles_change {
return Ok(());
}
s.edit("Kinsoku Shori Settings", |d, _| {
*d.kinsoku_sets = after.clone();
for st in d.para_styles.iter_mut() {
if let Some(m) = style_attrs(&st.attrs) {
st.attrs = m;
}
}
each_node_with_text_mut(d, &mut |n| {
if let Some(g) = n.extras_if_any().and_then(|e| e.graph.as_deref_mut()) {
fix_labels(&mut g.label_styles);
}
if let NodeKind::Text(t) = &mut n.kind {
let mut changed = false;
for p in t.para_styles_mut() {
changed |= fix(p);
}
if changed {
refresh_bounds(t);
}
}
Ok(())
})
})
}
/// The paragraph attributes graph label styles `l` keep: the value axis, the categories and the
/// legend.
fn label_paras(l: &mut LabelStyles) -> impl Iterator<Item = &mut ParaStyle> {
[&mut l.values_para, &mut l.categories_para, &mut l.legend_para].into_iter().flatten()
}
fn set(s: &mut Session, p: &Value) -> Result<Value> {
let list =
p.get("sets").and_then(Value::as_array).ok_or_else(|| bad(SET, "give sets: [{name, cannotStart?, cannotEnd?, hanging?, inseparable?}…]"))?;
if list.len() > KINSOKU_SETS_MAX {
return Err(bad(SET, format!("a document keeps at most {KINSOKU_SETS_MAX} Kinsoku sets")));
}
let parsed = list.iter().map(|v| parse_set(v, SET)).collect::<Result<Vec<_>>>()?;
let mut names = std::collections::HashSet::new();
for (set, _) in &parsed {
if !names.insert(set.name.to_lowercase()) {
return Err(bad(SET, format!("two Kinsoku sets are named `{}`", set.name)));
}
}
let before = s.doc()?.doc.kinsoku_sets.to_vec();
let has = |n: &str| before.iter().any(|b| KinsokuSet::same_name(&b.name, n));
// Which set of the document each given set continues: the one `from` names, else the one of
// its own name that no other set's `from` claims.
let mut renamed: HashMap<String, usize> = HashMap::new();
for (i, (set, from)) in parsed.iter().enumerate() {
if let Some(f) = from {
if !has(f) {
return Err(bad(SET, format!("`{}`: the document has no Kinsoku set named `{f}`", set.name)));
}
if renamed.insert(f.to_lowercase(), i).is_some() {
return Err(bad(SET, format!("two Kinsoku sets come from `{f}`")));
}
}
}
for (i, (set, from)) in parsed.iter().enumerate() {
let key = set.name.to_lowercase();
if from.is_none() && has(&set.name) && !renamed.contains_key(&key) {
renamed.insert(key, i);
}
}
let after: Vec<KinsokuSet> = parsed.into_iter().map(|(set, _)| set).collect();
replace(s, after.clone(), renamed)?;
Ok(json!({ "sets": after }))
}
/// The custom set of the active document that `text.setFormat`'s `kinsoku` names (any case), as a
/// paragraph holds it.
pub(crate) fn chosen(s: &Session, name: &str) -> Result<Option<Arc<KinsokuSet>>> {
Ok(KinsokuSet::named(&s.doc()?.doc.kinsoku_sets, name.trim()).cloned().map(Arc::new))
}
#[cfg(test)]
mod tests;
+458
View File
@@ -0,0 +1,458 @@
use serde_json::{Value, json};
use vectorcraft_doc::{Kinsoku, NodeId, NodeKind};
use crate::Session;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
s
}
fn names(s: &Session) -> Vec<String> {
s.doc().unwrap().doc.kinsoku_sets.iter().map(|k| k.name.clone()).collect()
}
fn steps(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
fn text(s: &Session, id: u64) -> vectorcraft_doc::TextObject {
match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
NodeKind::Text(t) => (**t).clone(),
_ => panic!("not text"),
}
}
/// Two paragraphs of area type, the second one selected by its range.
fn type_object(s: &mut Session) -> u64 {
s.execute("text.create", &json!({"x": 10, "y": 10, "text": "あいう\nかきく", "area": {"width": 100, "height": 100}})).unwrap()["id"]
.as_u64()
.unwrap()
}
fn tight() -> Value {
json!({"name": "Tight", "cannotStart": "」。、う", "cannotEnd": "「", "hanging": "、。", "inseparable": ["——"]})
}
/// Kinsoku Shori Settings' OK replaces the document's custom sets as one undo step (none when
/// nothing changes); each category keeps each character once, sorted; the sets are listed with
/// their users, saved with the document and undone with it.
#[test]
fn kinsoku_sets_are_set_as_one_undo_step_and_saved() {
let mut s = session();
let before = steps(&s);
let r = s.execute("type.kinsokuSets.set", &json!({"sets": [tight(), {"name": " Loose ", "cannotStart": "ーーッ"}]})).unwrap();
assert_eq!(r["sets"][1]["name"], "Loose");
assert_eq!(r["sets"][1]["cannotStart"], "ッー");
assert_eq!(names(&s), ["Tight", "Loose"]);
assert_eq!(steps(&s), before + 1);
s.execute("type.kinsokuSets.set", &json!({"sets": [tight(), {"name": "Loose", "cannotStart": "ッー"}]})).unwrap();
assert_eq!(steps(&s), before + 1, "the same sets again change nothing");
let listed = s.execute("type.kinsokuSets.list", &json!({})).unwrap();
assert_eq!((listed["sets"][0]["name"].clone(), listed["sets"][0]["paragraphs"].clone()), (json!("Tight"), json!(0)));
let reopened = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
assert_eq!(*reopened.kinsoku_sets, *s.doc().unwrap().doc.kinsoku_sets);
s.execute("edit.undo", &json!({})).unwrap();
assert!(names(&s).is_empty());
// A document without sets saves none.
let saved = vectorcraft_format::save(&s.doc().unwrap().doc, false);
assert!(!String::from_utf8_lossy(&saved).contains("kinsoku_sets"));
}
/// The sets are checked before anything changes: a built-in name, a blank or too-long name, two
/// sets of one name in any case, an unknown key, a sequence of one character or with a space, a
/// control character, a `from` the document has no set of, a null value, and more than 256 sets
/// all fail.
#[test]
fn kinsoku_sets_refuse_what_a_set_cannot_hold() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
let before = steps(&s);
let long = "x".repeat(129);
for bad in [
json!([{"name": "Hard"}]),
json!([{"name": "soft"}]),
json!([{"name": " "}]),
json!([{"name": long}]),
json!([{"name": "A"}, {"name": "a"}]),
json!([{"name": "A", "strict": true}]),
json!([{"name": "A", "inseparable": ["あ"]}]),
json!([{"name": "A", "inseparable": ["あ い"]}]),
json!([{"name": "A", "inseparable": "あい"}]),
json!([{"name": "A", "cannotStart": "あ\u{7}"}]),
json!([{"name": "A", "cannotStart": ["あ"]}]),
json!([{"name": "A", "from": "Missing"}]),
json!([{"name": "A", "from": "Tight"}, {"name": "B", "from": "tight"}]),
json!([{"name": "Tight", "from": "Tight", "cannotStart": null}]),
json!([{"name": "Tight", "from": null}]),
json!([{"name": "A", "inseparable": null}]),
json!((0..257).map(|i| json!({"name": format!("S{i}")})).collect::<Vec<_>>()),
] {
assert!(s.execute("type.kinsokuSets.set", &json!({"sets": bad})).is_err(), "{bad}");
}
assert!(s.execute("type.kinsokuSets.set", &json!({})).is_err());
assert_eq!((names(&s), steps(&s)), (vec!["Tight".to_string()], before), "a refused call changes nothing");
}
/// Kinsoku Set chooses a custom set by name (any case) for the paragraphs `text.setFormat` sets: each
/// holds a copy of it beside Hard, in one undo step; a name the document has no set of fails the call
/// and changes nothing; a built-in set takes the custom one's place. Paragraph styles carry it.
#[test]
fn text_set_format_chooses_a_custom_set_per_paragraph() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
let id = type_object(&mut s);
s.execute("select.set", &json!({"ids": [id]})).unwrap();
assert!(s.execute("text.setFormat", &json!({"kinsoku": "Missing"})).is_err());
assert!(text(&s, id).para_at(0).kinsoku_set.is_none(), "a refused call changes nothing");
let before = steps(&s);
let second = "あいう\n".len();
s.execute("text.setFormat", &json!({"kinsoku": "tight", "start": second, "end": second})).unwrap();
assert_eq!(steps(&s), before + 1);
let t = text(&s, id);
assert!(t.para_at(0).kinsoku_set.is_none());
let p = t.para_at(1);
assert_eq!((p.kinsoku_name(), p.kinsoku), ("Tight", Kinsoku::Hard));
s.execute("text.setFormat", &json!({"kinsoku": "Tight", "start": second, "end": second})).unwrap();
assert_eq!(steps(&s), before + 1, "the set the paragraph already has records nothing");
// The file keeps the paragraph's copy.
let reopened = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
let Some(NodeKind::Text(back)) = reopened.node(NodeId(id)).map(|n| &n.kind) else { panic!("text") };
assert_eq!(back.para_at(1).kinsoku_name(), "Tight");
// A paragraph style captured from it carries the set; Soft replaces it.
s.execute("paraStyle.new", &json!({"name": "Tight Body", "id": id, "start": second, "end": second})).unwrap();
s.execute("text.setFormat", &json!({"kinsoku": "soft"})).unwrap();
assert!(text(&s, id).para_at(1).kinsoku_set.is_none());
assert_eq!(text(&s, id).para_at(1).kinsoku, Kinsoku::Soft);
s.execute("paraStyle.apply", &json!({"name": "Tight Body", "id": id})).unwrap();
assert_eq!(text(&s, id).para_at(0).kinsoku_name(), "Tight");
assert_eq!(text(&s, id).para_at(1).kinsoku_name(), "Tight");
}
/// A paragraph style that gives only a built-in Kinsoku Set replaces a custom set on the paragraphs
/// it is applied to: the style keeps Kinsoku Set's custom set with its built-in choice. One whose
/// attributes give only a custom set (written by hand into a file) brings Hard with it.
#[test]
fn a_style_with_a_built_in_kinsoku_set_replaces_a_custom_set() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
let id = type_object(&mut s);
s.execute("select.set", &json!({"ids": [id]})).unwrap();
for (style, kinsoku, name) in [("Soft Only", "soft", "Soft"), ("None Only", "none", "None"), ("Hard Only", "hard", "Hard")] {
s.execute("text.setFormat", &json!({"kinsoku": "Tight"})).unwrap();
assert_eq!(text(&s, id).para_at(0).kinsoku_name(), "Tight");
s.execute("paraStyle.new", &json!({"name": style, "attrs": {"kinsoku": kinsoku}})).unwrap();
s.execute("paraStyle.apply", &json!({"name": style, "id": id})).unwrap();
let t = text(&s, id);
assert_eq!((t.para_at(0).kinsoku_name(), t.para_at(1).kinsoku_name()), (name, name), "{style}");
}
s.execute("text.setFormat", &json!({"kinsoku": "soft"})).unwrap();
let only_set = serde_json::Map::from_iter([("kinsoku_set".to_string(), tight_set(&s))]);
let def = vectorcraft_doc::TextStyleDef { name: "Set Only".into(), attrs: only_set };
std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).para_styles.push(def);
s.execute("paraStyle.apply", &json!({"name": "Set Only", "id": id})).unwrap();
assert_eq!(text(&s, id).para_at(0).kinsoku_name(), "Tight");
}
fn tight_set(s: &Session) -> Value {
json!(s.doc().unwrap().doc.kinsoku_sets[0])
}
/// Redefining a paragraph style's Kinsoku Set changes the paragraphs that use the style's set and
/// keeps a paragraph's own custom set: the set and Hard beside it change together.
#[test]
fn redefining_a_style_keeps_a_paragraphs_own_custom_set() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight(), {"name": "Loose"}]})).unwrap();
let id = type_object(&mut s);
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"kinsoku_set": tight_set(&s)}})).unwrap();
s.execute("paraStyle.apply", &json!({"name": "Body", "id": id})).unwrap();
let second = "あいう\n".len();
s.execute("text.setFormat", &json!({"kinsoku": "Loose", "start": second, "end": second})).unwrap();
s.execute("paraStyle.setAttrs", &json!({"name": "Body", "attrs": {"kinsoku": "soft"}})).unwrap();
let t = text(&s, id);
assert_eq!((t.para_at(0).kinsoku_name(), t.para_at(1).kinsoku_name()), ("Soft", "Loose"));
}
/// A paragraph style's custom set is one of the document's, by name in any case, with the
/// document's characters; a name the document has no set of fails the call.
#[test]
fn a_styles_custom_set_is_one_of_the_documents() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
assert!(s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"kinsoku_set": {"name": "Missing"}}})).is_err());
s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"kinsoku_set": {"name": "tight", "cannotStart": "x"}}})).unwrap();
let listed = s.execute("paraStyle.list", &json!({})).unwrap();
let body = listed["styles"].as_array().unwrap().iter().find(|st| st["name"] == "Body").unwrap().clone();
assert_eq!(body["attrs"]["kinsoku_set"], tight_set(&s));
assert!(s.execute("paraStyle.setAttrs", &json!({"name": "Body", "attrs": {"kinsoku_set": {"name": "Missing"}}})).is_err());
}
/// A custom set goes with Hard and has a name a custom set can have: a paragraph style call that
/// gives one beside None or Soft, or with a blank or built-in name, fails and leaves the styles as
/// they were, and one beside Hard is kept.
#[test]
fn a_styles_custom_set_given_beside_none_or_soft_fails_the_call() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"kinsoku_set": tight_set(&s)}})).unwrap();
let styles = |s: &Session| s.doc().unwrap().doc.para_styles.clone();
let before = styles(&s);
for kinsoku in ["none", "soft"] {
let attrs = json!({"kinsoku": kinsoku, "kinsoku_set": tight_set(&s)});
assert!(s.execute("paraStyle.new", &json!({"name": "Other", "attrs": attrs})).is_err(), "new with {kinsoku}");
assert!(s.execute("paraStyle.setAttrs", &json!({"name": "Body", "attrs": attrs})).is_err(), "setAttrs with {kinsoku}");
assert_eq!(styles(&s), before, "{kinsoku}");
}
for name in ["", " ", "Hard", "soft"] {
let attrs = json!({"kinsoku_set": {"name": name}});
assert!(s.execute("paraStyle.new", &json!({"name": "Other", "attrs": attrs})).is_err(), "new named `{name}`");
assert!(s.execute("paraStyle.setAttrs", &json!({"name": "Body", "attrs": attrs})).is_err(), "setAttrs named `{name}`");
assert_eq!(styles(&s), before, "`{name}`");
}
let attrs = json!({"kinsoku": "hard", "kinsoku_set": tight_set(&s)});
s.execute("paraStyle.new", &json!({"name": "Other", "attrs": attrs})).unwrap();
let other = styles(&s).into_iter().find(|st| st.name == "Other").unwrap();
assert_eq!(other.attrs["kinsoku_set"], tight_set(&s));
}
/// Editing a set gives every paragraph and paragraph style using it the new characters, renaming it
/// (`from`) the new name too, and deleting it sets them to Hard: each in one undo step, which undo
/// takes back with the set. Paragraphs using no set, or another set, stay as they are.
#[test]
fn editing_renaming_and_deleting_a_set_updates_its_users() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight(), {"name": "Other", "cannotStart": "ー"}]})).unwrap();
let id = type_object(&mut s);
s.execute("select.set", &json!({"ids": [id]})).unwrap();
let second = "あいう\n".len();
s.execute("text.setFormat", &json!({"kinsoku": "Tight", "start": 0, "end": 0})).unwrap();
s.execute("text.setFormat", &json!({"kinsoku": "Other", "start": second, "end": second})).unwrap();
s.execute("paraStyle.new", &json!({"name": "Uses Tight", "id": id, "start": 0, "end": 0})).unwrap();
let style_set = |s: &Session| s.doc().unwrap().doc.para_styles.iter().find(|st| st.name == "Uses Tight").unwrap().attrs["kinsoku_set"].clone();
assert_eq!(style_set(&s)["name"], "Tight");
let listed = s.execute("type.kinsokuSets.list", &json!({})).unwrap();
assert_eq!((listed["sets"][0]["paragraphs"].clone(), listed["sets"][0]["styles"].clone()), (json!(1), json!(1)));
// Edit: 「 may end a line now, and う may start one.
let before = steps(&s);
let edited = json!({"name": "Tight", "cannotStart": "」。、", "hanging": "、。", "inseparable": ["——"]});
s.execute("type.kinsokuSets.set", &json!({"sets": [edited, {"name": "Other", "cannotStart": "ー"}]})).unwrap();
assert_eq!(steps(&s), before + 1);
let p = text(&s, id).para_at(0).clone();
assert_eq!(p.kinsoku_set.as_ref().unwrap().cannot_start, ['、', '。', '」']);
assert!(p.kinsoku_set.as_ref().unwrap().cannot_end.is_empty());
assert_eq!(style_set(&s)["cannotStart"], "、。」");
assert_eq!(text(&s, id).para_at(1).kinsoku_name(), "Other", "another set's paragraph stays");
// Rename: the users take the new name.
let renamed = json!({"name": "Strict", "from": "Tight", "cannotStart": "」。、", "hanging": "、。", "inseparable": ["——"]});
s.execute("type.kinsokuSets.set", &json!({"sets": [renamed, {"name": "Other", "cannotStart": "ー"}]})).unwrap();
assert_eq!(names(&s), ["Strict", "Other"]);
assert_eq!(text(&s, id).para_at(0).kinsoku_name(), "Strict");
assert_eq!(style_set(&s)["name"], "Strict");
// Delete: its users take Hard, in one step that undo takes back.
let before = steps(&s);
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "Other", "cannotStart": "ー"}]})).unwrap();
assert_eq!(steps(&s), before + 1);
let p = text(&s, id).para_at(0).clone();
assert_eq!((p.kinsoku_set.is_none(), p.kinsoku), (true, Kinsoku::Hard));
assert_eq!(style_set(&s), Value::Null);
assert_eq!(text(&s, id).para_at(1).kinsoku_name(), "Other");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(text(&s, id).para_at(0).kinsoku_name(), "Strict");
assert_eq!(style_set(&s)["name"], "Strict");
assert_eq!(names(&s), ["Strict", "Other"]);
}
/// Type pasted into another document brings its custom sets: a missing set is added, the
/// document's set of that name with the same characters is used, and one with other characters
/// keeps its own and the pasted set comes in under a free name, so editing the document's set
/// leaves the pasted paragraphs alone. A paragraph style that comes along takes the same set. A
/// document with no room for another set gives the pasted paragraphs Hard.
#[test]
fn pasted_type_brings_its_kinsoku_sets() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
let id = type_object(&mut s);
s.execute("paraStyle.new", &json!({"name": "Tight Body", "attrs": {"kinsoku_set": tight_set(&s)}})).unwrap();
s.execute("paraStyle.apply", &json!({"name": "Tight Body", "id": id})).unwrap();
let source = s.doc().unwrap().doc.kinsoku_sets[0].clone();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("edit.copy", &json!({})).unwrap();
let pasted = |s: &mut Session| -> (vectorcraft_doc::TextObject, Value) {
let v = s.execute("edit.paste", &json!({})).unwrap();
(text(s, v["ids"][0].as_u64().unwrap()), v)
};
let style_set = |s: &Session| s.doc().unwrap().doc.para_styles.iter().find(|st| st.name == "Tight Body").unwrap().attrs["kinsoku_set"].clone();
// Pasted back after the set was edited: the document's set as it is now, laid out anew.
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "Tight", "cannotStart": "いうかきく"}]})).unwrap();
let (t, _) = pasted(&mut s);
let now = s.doc().unwrap().doc.kinsoku_sets[0].clone();
assert_eq!(t.para_at(0).kinsoku_set.as_deref(), Some(&now));
let mut fresh = t.clone();
crate::cmd::typecmd::refresh_bounds(&mut fresh);
assert!(fresh == t, "the pasted type is laid out with the document's set");
// A document without the set.
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
let (t, _) = pasted(&mut s);
assert_eq!(names(&s), ["Tight"]);
assert_eq!(t.para_at(1).kinsoku_set.as_deref(), Some(&source));
assert_eq!(style_set(&s), json!(source));
let (_, again) = pasted(&mut s);
assert_eq!((again["added"].clone(), names(&s)), (json!(0), vec!["Tight".to_string()]), "a second paste uses the set the first added");
// A document whose set of that name has other characters.
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "TIGHT", "cannotStart": "ー"}]})).unwrap();
let (t, v) = pasted(&mut s);
assert_eq!(names(&s), ["TIGHT", "Tight 2"]);
let p = t.para_at(0);
assert_eq!((p.kinsoku_name(), p.kinsoku_set.as_deref().map(|k| &k.cannot_start)), ("Tight 2", Some(&source.cannot_start)));
assert_eq!(style_set(&s)["name"], "Tight 2");
assert!(v["renamed"].as_array().unwrap().contains(&json!({"kind": "kinsokuSet", "from": "Tight", "to": "Tight 2"})), "{v}");
let kept = json!(s.doc().unwrap().doc.kinsoku_sets[1]);
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "TIGHT", "cannotStart": "ッ"}, kept]})).unwrap();
let users = s.execute("type.kinsokuSets.list", &json!({})).unwrap();
assert_eq!(users["sets"][0]["paragraphs"], 0, "editing the document's own set leaves the pasted paragraphs alone: {users}");
// A document with no room for another set.
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
let full: Vec<Value> = (0..256).map(|i| json!({"name": format!("Set {i}")})).collect();
s.execute("type.kinsokuSets.set", &json!({"sets": full})).unwrap();
let (t, _) = pasted(&mut s);
assert_eq!(names(&s).len(), 256);
let p = t.para_at(0);
assert_eq!((p.kinsoku_set.is_none(), p.kinsoku), (true, Kinsoku::Hard));
assert_eq!(style_set(&s), Value::Null);
}
/// A pasted set whose name, at the longest a name can be, the document's set with other
/// characters already has comes in under a free name that fits: the number takes the place of the
/// name's last characters, and a space left at the end of them is dropped. A second paste uses
/// the set the first added.
#[test]
fn a_pasted_set_with_the_longest_name_comes_in_under_a_name_that_fits() {
for (long, fitted) in
[("あ".repeat(128), format!("{} 2", "あ".repeat(126))), (format!("{} いい", "あ".repeat(125)), format!("{} 2", "あ".repeat(125)))]
{
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": long, "cannotStart": "」"}]})).unwrap();
let id = type_object(&mut s);
s.execute("text.setFormat", &json!({"ids": [id], "kinsoku": long})).unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("edit.copy", &json!({})).unwrap();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": long, "cannotStart": "ー"}]})).unwrap();
let v = s.execute("edit.paste", &json!({})).unwrap();
assert_eq!(names(&s), [long.clone(), fitted.clone()]);
let t = text(&s, v["ids"][0].as_u64().unwrap());
let p = t.para_at(0);
assert_eq!((p.kinsoku_name(), p.kinsoku_set.as_deref().map(|k| k.cannot_start.clone())), (fitted.as_str(), Some(vec!['」'])));
let again = s.execute("edit.paste", &json!({})).unwrap();
assert_eq!(
(again["added"].clone(), names(&s)),
(json!(0), vec![long.clone(), fitted.clone()]),
"a second paste uses the set the first added"
);
}
}
/// The Kinsoku Sets a graph keeps for its labels (value axis, categories, legend), and those its
/// labels are drawn with now.
fn graph_label_sets(s: &Session, id: u64) -> (Vec<String>, Vec<String>) {
let n = s.doc().unwrap().doc.node(NodeId(id)).unwrap().clone();
let l = n.extras().graph.as_deref().unwrap().label_styles.clone();
let kept = [l.values_para, l.categories_para, l.legend_para].into_iter().flatten().map(|p| p.kinsoku_name().to_string()).collect();
let mut drawn = vec![];
n.walk(&mut |m| {
if let NodeKind::Text(t) = &m.kind {
drawn.push(t.para_at(0).kinsoku_name().to_string());
}
});
(kept, drawn)
}
/// A graph's labels keep a custom set as type does. Pasted into a document whose set of that name
/// has other characters, they take the copy the paste adds, also once the graph is drawn again.
/// Editing a set gives the graph's kept attributes the new characters, and deleting it gives them
/// Hard.
#[test]
fn graph_labels_keep_their_custom_set() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
let csv = ",2024,2025\nQ1,3,2\nQ2,5,4";
let id = s.execute("graph.create", &json!({"type": "column", "x": 10, "y": 10, "width": 300, "height": 200, "csv": csv})).unwrap()["id"]
.as_u64()
.unwrap();
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("text.setFormat", &json!({"kinsoku": "Tight"})).unwrap();
let (kept, drawn) = graph_label_sets(&s, id);
assert_eq!(kept, ["Tight"; 3]);
assert!(!drawn.is_empty() && drawn.iter().all(|k| k == "Tight"), "{drawn:?}");
s.execute("edit.copy", &json!({})).unwrap();
// Pasted where the set of that name has other characters: the labels take the added copy.
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "TIGHT", "cannotStart": "ー"}]})).unwrap();
let pasted = s.execute("edit.paste", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
assert_eq!(names(&s), ["TIGHT", "Tight 2"]);
s.execute("graph.setData", &json!({"id": pasted, "csv": csv})).unwrap();
let (kept, drawn) = graph_label_sets(&s, pasted);
assert_eq!(kept, ["Tight 2"; 3]);
assert!(drawn.iter().all(|k| k == "Tight 2"), "the labels drawn again keep the copy: {drawn:?}");
// A second copy becomes a symbol's art.
let in_symbol = s.execute("edit.paste", &json!({})).unwrap()["ids"][0].clone();
s.execute("symbol.new", &json!({"name": "Chart", "ids": [in_symbol]})).unwrap();
let symbol_starts = |s: &Session| {
let mut out = vec![];
s.doc().unwrap().doc.symbols.iter().find(|x| x.name == "Chart").unwrap().art.walk(&mut |n| {
if let Some(g) = n.extras().graph.as_deref() {
out.push(g.label_styles.values_para.as_ref().unwrap().kinsoku_set.as_deref().unwrap().cannot_start.clone());
}
});
out
};
assert_eq!(symbol_starts(&s).len(), 1);
let listed = s.execute("type.kinsokuSets.list", &json!({})).unwrap();
assert_eq!((listed["sets"][1]["name"].clone(), listed["sets"][1]["graphs"].clone()), (json!("Tight 2"), json!(2)), "{listed}");
assert_eq!(listed["sets"][0]["graphs"], 0);
// Edited, then deleted: the kept attributes follow the set, so the labels drawn again do too.
let edited = json!({"name": "Tight 2", "cannotStart": "ー"});
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "TIGHT", "cannotStart": "ー"}, edited]})).unwrap();
let l = &s.doc().unwrap().doc.node(NodeId(pasted)).unwrap().extras().graph.as_deref().unwrap().label_styles;
assert_eq!(l.values_para.as_ref().unwrap().kinsoku_set.as_deref().unwrap().cannot_start, ['ー']);
assert_eq!(symbol_starts(&s), [vec!['ー']], "a graph in a symbol's art too");
s.execute("type.kinsokuSets.set", &json!({"sets": [{"name": "TIGHT", "cannotStart": "ー"}]})).unwrap();
s.execute("graph.setData", &json!({"id": pasted, "csv": csv})).unwrap();
let (kept, drawn) = graph_label_sets(&s, pasted);
assert_eq!(kept, ["Hard"; 3]);
assert!(drawn.iter().all(|k| k == "Hard"), "{drawn:?}");
}
/// New Set's starting point: Hard and Soft give their characters, None gives an empty set, and a
/// custom set (any case) gives its own; an unknown base fails.
#[test]
fn a_new_set_starts_from_a_built_in_or_custom_set() {
let mut s = session();
s.execute("type.kinsokuSets.set", &json!({"sets": [tight()]})).unwrap();
let hard = s.execute("type.kinsokuSets.base", &json!({"base": "hard", "name": "New"})).unwrap();
let soft = s.execute("type.kinsokuSets.base", &json!({"base": "soft"})).unwrap();
let start = |v: &Value| v["set"]["cannotStart"].as_str().unwrap().to_string();
assert!(start(&hard).contains('ー') && !start(&soft).contains('ー') && start(&soft).contains('」'));
assert_eq!(hard["set"]["name"], "New");
assert_eq!(hard["set"]["hanging"], "、。,.。、");
assert_eq!(hard["set"]["inseparable"].as_array().unwrap().len(), 5);
let none = s.execute("type.kinsokuSets.base", &json!({"base": "none"})).unwrap();
assert_eq!(none["set"]["cannotStart"], "");
let custom = s.execute("type.kinsokuSets.base", &json!({"base": "TIGHT"})).unwrap();
assert_eq!(custom["set"]["cannotEnd"], "「");
assert!(s.execute("type.kinsokuSets.base", &json!({"base": "Missing"})).is_err());
}
+1 -1
View File
@@ -132,7 +132,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Locate Object",
["Window", "Layers"],
None,
"{id?, layersOnly?} (default: the frontmost selected object in the stacking order) highlight the object's row; the Layers panel opens the layers around it and scrolls to it, also when the row was already highlighted → {id, ancestry: [layer…, id]}. layersOnly (default false; the panel sends true while Show Layers Only is on, as Locate Layer) highlights the innermost layer or sublayer holding the object instead, or a layer id itself → {id: layer, objectId, ancestry: [layer…]}",
"{id?, layersOnly?} (default: the frontmost selected object in the stacking order) highlight the object's row; the Layers panel opens the layers around it, and scrolls to its row when the row is in the list, also when the row was already highlighted (Show Layers Only, a search, the filter, or editing an opacity mask on another layer can leave the row out) → {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
),
+3
View File
@@ -334,6 +334,9 @@ pub(super) fn isolate(s: &mut Session, p: &Value) -> Result<Value> {
if matches!(st.doc.node(id).ok_or(EngineError::NoNode(id))?.kind, NodeKind::Text(_)) {
return Err(bad("object.isolate", "type objects can't be isolated"));
}
if st.doc.node(id).is_some_and(|n| n.is_ruler_guide()) {
return Err(bad("object.isolate", "ruler guides can't be isolated"));
}
let isolation =
st.doc.node(id).filter(|n| n.extras().shaper.is_some()).and_then(|n| n.children()).and_then(|c| c.first()).map_or(id, |n| n.id);
// A hidden or locked object, one in a hidden or locked group or layer, and a guide path while
+1 -1
View File
@@ -241,7 +241,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Enter Isolation Mode",
[],
None,
"{id?} isolate a group, a layer or a single object (default: the first selected object); type, a hidden or locked object, an object in a hidden or locked group or layer, and a guide path while Lock Guides is on are refused, and so is every object while an opacity mask is edited",
"{id?} isolate a group, a layer or a single object (default: the first selected object); type, a ruler guide, a hidden or locked object, an object in a hidden or locked group or layer, and a guide path while Lock Guides is on are refused, and so is every object while an opacity mask is edited",
crate::cmd::maskedit::outside_mask_editing,
isolate
),
+18 -7
View File
@@ -67,7 +67,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Character / Paragraph",
[],
None,
"{ids?|id?, kerning?: 1/1000 em|\"auto\"|\"optical\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), antiAlias?: \"none\"|\"sharp\"|\"crisp\"|\"strong\" (Character panel › Anti-aliasing Method, how the type's edges are drawn as pixels; it sets each targeted type object, with or without a range; each frame of a thread keeps its own method; graph labels keep it for every label of their kind when the graph is drawn again; new type: \"sharp\"), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt (±1296), list?: \"none\"|\"bullet\"|\"number\", bullet?: \"none\"|\"dot\"|\"dash\"|\"circle\"|\"square\", number?: \"none\"|\"arabic\"|\"upperLetters\"|\"lowerLetters\"|\"upperRoman\"|\"lowerRoman\"|\"twoDigits\"|\"threeDigits\", listAlign?: \"left\"|\"right\", listLevel?: 1..9 (Paragraph panel › Bullets and Numbered List: each paragraph of a list starts with its marker, drawn in the font, size and color of the paragraph's first character, and its text starts at the next tab stop after the marker, the left indent counting as a stop; a bulleted list's marker is its bullet, and a numbered list's is the paragraph's number and a period: 1, 2, 3; A to Z, then AA, BB; a to z, then aa, bb; I, II, III; i, ii, iii; 01 to 99, then 100; 001 to 999, then 1000; letters and roman numerals past 3999 in Arabic digits; the numbers count the story's numbered paragraphs, its threaded frames included, from 1 after a paragraph in no list, and an empty or bulleted paragraph is not counted; list \"bullet\" keeps a list's bullet, else a dot, and list \"number\" keeps a numbered list's style, else arabic; without list, a number style makes a numbered list and a bullet makes a bulleted one; \"none\" in any of the three turns the list off; a paragraph that joins a list with left and first-line indents of 0 gets 18 and -18 unless the call sets an indent; a horizontal right-to-left list paragraph has its indents mirrored, measured from the right; listAlign \"right\" (Bullets and Numbering…'s Alignment) puts the marker against the text, and \"left\" (the default) puts it at the first line's start, the text starting at the same place with either; it sets the paragraphs that are in a list or that the call puts in one, and a list keeps it when it changes between bullets and numbers; listLevel (Tab and Shift+Tab at the start of a list paragraph, Bullets and Numbering…'s Level) is a whole number from 1 to 9 that sets the paragraphs in a list or that the call puts in one, a list keeping it when it changes between bullets and numbers, and a list turned on without listLevel starting at level 1; each level past the first sets the paragraph 18 pt further in than its left indent, and each level counts its own numbers: a list paragraph with text sets the counts of the levels deeper than its own back to 0, so a deeper numbered paragraph after it counts from 1, and a paragraph back at a shallower level goes on with that level's count), startNumber?: 1..999999999, restartNumbering?: bool (Bullets and Numbering…'s Start At, VectorCraft's own: startNumber gives the first numbered paragraph the call touches, the first that holds text or else the first, taking the type objects in the order of `ids` and passing over a threaded frame's first paragraph when it continues from the frame before, that number, and the numbered paragraphs after it at its level count on from it, through the story's threaded frames; restartNumbering true gives it 1, and false takes the number away from every paragraph the call touches but such a continued first paragraph, which then count on from the paragraph before; giving both fails the call, and when the call touches no numbered paragraph nothing changes; a paragraph made with Return does not take the number, a paragraph made bulleted keeps none, and a paragraph style made from the paragraph does not keep it, nor does a graph label when the graph is drawn again), hyphenate?: bool, wordsLongerThan?: letters 1..25 (5), afterFirst?, beforeLast?: letters 1..15 (3), hyphenLimit?: lines 0..25 (0: no limit), hyphenationZone?: pt 0..1296 (0; Single-line Composer only), hyphenateCapitalized?: bool (true) (Paragraph panel menu › Hyphenation…: only words longer than wordsLongerThan break, keeping afterFirst letters before the hyphen and beforeLast after it; at most hyphenLimit lines in a row end with a hyphen; a line whose text already ends within hyphenationZone of its right edge breaks before the next word instead of hyphenating it; the counts are rounded, and every value is clamped to its range), wordSpacing?: % 0..1000 (80, 100, 133), letterSpacing?: % of a word space -100..500 (0, 0, 0), glyphScaling?: % 50..200 (100, 100, 100): each [min, desired, max] or {min?, desired?, max?} (Paragraph panel menu › Justification Line truncated
"{ids?|id?, kerning?: 1/1000 em|\"auto\"|\"optical\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), antiAlias?: \"none\"|\"sharp\"|\"crisp\"|\"strong\" (Character panel › Anti-aliasing Method, how the type's edges are drawn as pixels; it sets each targeted type object, with or without a range; each frame of a thread keeps its own method; graph labels keep it for every label of their kind when the graph is drawn again; new type: \"sharp\"), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt (±1296), list?: \"none\"|\"bullet\"|\"number\", bullet?: \"none\"|\"dot\"|\"dash\"|\"circle\"|\"square\", number?: \"none\"|\"arabic\"|\"upperLetters\"|\"lowerLetters\"|\"upperRoman\"|\"lowerRoman\"|\"twoDigits\"|\"threeDigits\", listAlign?: \"left\"|\"right\", listLevel?: 1..9 (Paragraph panel › Bullets and Numbered List: each paragraph of a list starts with its marker, drawn in the font, size and color of the paragraph's first character, and its text starts at the next tab stop after the marker, the left indent counting as a stop; a bulleted list's marker is its bullet, and a numbered list's is the paragraph's number and a period: 1, 2, 3; A to Z, then AA, BB; a to z, then aa, bb; I, II, III; i, ii, iii; 01 to 99, then 100; 001 to 999, then 1000; letters and roman numerals past 3999 in Arabic digits; the numbers count the story's numbered paragraphs, its threaded frames included, from 1 after a paragraph in no list, and an empty or bulleted paragraph is not counted; list \"bullet\" keeps a list's bullet, else a dot, and list \"number\" keeps a numbered list's style, else arabic; without list, a number style makes a numbered list and a bullet makes a bulleted one; \"none\" in any of the three turns the list off; a paragraph that joins a list with left and first-line indents of 0 gets 18 and -18 unless the call sets an indent; a horizontal right-to-left list paragraph has its indents mirrored, measured from the right; listAlign \"right\" (Bullets and Numbering…'s Alignment) puts the marker against the text, and \"left\" (the default) puts it at the first line's start, the text starting at the same place with either; it sets the paragraphs that are in a list or that the call puts in one, and a list keeps it when it changes between bullets and numbers; listLevel (Tab and Shift+Tab at the start of a list paragraph, Bullets and Numbering…'s Level) is a whole number from 1 to 9 that sets the paragraphs in a list or that the call puts in one, a list keeping it when it changes between bullets and numbers, and a list turned on without listLevel starting at level 1; each level past the first sets the paragraph 18 pt further in than its left indent, and each level counts its own numbers: a list paragraph with text sets the counts of the levels deeper than its own back to 0, so a deeper numbered paragraph after it counts from 1, and a paragraph back at a shallower level goes on with that level's count), startNumber?: 1..999999999, restartNumbering?: bool (Bullets and Numbering…'s Start At, VectorCraft's own: startNumber gives the first numbered paragraph the call touches, the first that holds text or else the first, taking the type objects in the order of `ids` and passing over a threaded frame's first paragraph when it continues from the frame before, that number, and the numbered paragraphs after it at its level count on from it, through the story's threaded frames; restartNumbering true gives it 1, and false takes the number away from every paragraph the call touches but such a continued first paragraph, which then count on from the paragraph before; giving both fails the call, and when the call touches no numbered paragraph nothing changes; a paragraph made with Return does not take the number, a paragraph made bulleted keeps none, and a paragraph style made from the paragraph does not keep it, nor does a graph label when the graph is drawn again), hyphenate?: bool, wordsLongerThan?: letters 1..25 (5), afterFirst?, beforeLast?: letters 1..15 (3), hyphenLimit?: lines 0..25 (0: no limit), hyphenationZone?: pt 0..1296 (0; Single-line Composer only), hyphenateCapitalized?: bool (true) (Paragraph panel menu › Hyphenation…: only words longer than wordsLongerThan break, keeping afterFirst letters before the hyphen and beforeLast after it; at most hyphenLimit lines in a row end with a hyphen; a line whose text already ends within hyphenationZone of its right edge breaks before the next word instead of hyphenating it; the counts are rounded, and every value is clamped to its range), wordSpacing?: % 0..1000 (80, 100, 133), letterSpacing?: % of a word space -100..500 (0, 0, 0), glyphScaling?: % 50..200 (100, 100, 100): each [min, desired, max] or {min?, desired?, max?} (Paragraph panel menu › Justification Line truncated
has_doc,
set_format
),
@@ -755,11 +755,21 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
};
let kinsoku = match p.get("kinsoku") {
None | Some(Value::Null) => None,
// A custom set (Type › Kinsoku Shori Settings…) by name: the paragraph holds a copy of it
// and keeps Hard, which builds without custom sets read.
Some(v) => Some(match v.as_str() {
Some("none") => vectorcraft_doc::Kinsoku::None,
Some("hard") => vectorcraft_doc::Kinsoku::Hard,
Some("soft") => vectorcraft_doc::Kinsoku::Soft,
_ => return Err(bad(C, "`kinsoku` must be \"none\", \"hard\" or \"soft\"")),
Some("none") => (vectorcraft_doc::Kinsoku::None, None),
Some("hard") => (vectorcraft_doc::Kinsoku::Hard, None),
Some("soft") => (vectorcraft_doc::Kinsoku::Soft, None),
name => match name.map(|n| super::kinsokusets::chosen(s, n)).transpose()?.flatten() {
Some(set) => (vectorcraft_doc::Kinsoku::Hard, Some(set)),
None => {
return Err(bad(
C,
"`kinsoku` must be \"none\", \"hard\", \"soft\" or the name of a Kinsoku set of the document (type.kinsokuSets.list)",
));
}
},
}),
};
let kinsoku_type = match p.get("kinsokuType") {
@@ -1058,8 +1068,9 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(v) = mojikumi {
para.mojikumi = v;
}
if let Some(v) = kinsoku {
para.kinsoku = v;
if let Some((v, set)) = &kinsoku {
para.kinsoku = *v;
para.kinsoku_set = set.clone();
}
if let Some(v) = kinsoku_type {
para.kinsoku_type = v;
@@ -46,6 +46,8 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.packaging.setRole",
"addon.packaging.setRoleSwatch",
"addon.pathtools.addPoints",
"addon.pathtools.boundingCircle",
"addon.pathtools.boundingRectangle",
"addon.pathtools.bridge",
"addon.pathtools.close",
"addon.pathtools.commonTangents",
@@ -557,6 +559,7 @@ pub(super) const ALLOWED: &[&str] = &[
"select.update",
"shape.arc",
"shape.circleThroughPoints",
"shape.curvatureCircle",
"shape.editFlare",
"shape.ellipse",
"shape.flare",
@@ -600,6 +603,7 @@ pub(super) const ALLOWED: &[&str] = &[
"swatch.move",
"swatch.new",
"swatch.newGroup",
"swatch.renameGroup",
"swatch.resetDefaults",
"swatch.setSpot",
"swatch.sortByKind",
@@ -623,6 +627,7 @@ pub(super) const ALLOWED: &[&str] = &[
"symbol.replace",
"symbol.selectInstances",
"symbol.setCurrent",
"symbol.setDensity",
"symbol.sortByName",
"symbol.spray",
"symbol.unused",
@@ -661,6 +666,7 @@ pub(super) const ALLOWED: &[&str] = &[
"text.thread.remove",
"text.touchType",
"threeD.addGraphic",
"threeD.mapArt",
"threeD.mapGraphic",
"transparency.disableOpacityMask",
"transparency.editOpacityMask",
@@ -684,6 +690,9 @@ pub(super) const ALLOWED: &[&str] = &[
"type.fillPlaceholder",
"type.fitHeadline",
"type.insert",
"type.kinsokuSets.base",
"type.kinsokuSets.list",
"type.kinsokuSets.set",
"type.opticalMarginAlignment",
"type.orientation.horizontal",
"type.orientation.vertical",
+3
View File
@@ -142,6 +142,7 @@ pub const PREF_SPECS: &[PrefSpec] = &[
p!("interpolateControlPoints", "General", "Options", "Interpolate Control Points When Moving Anchors", bool),
p!("usePreciseCursors", "General", "Options", "Use Precise Cursors", bool),
p!("showToolTips", "General", "Options", "Show Tool Tips", bool),
p!("showToolCards", "General", "Options", "Show Tool Cards", bool),
p!("showExternalScriptWarning", "General", "Options", "Show External Script Warning", bool),
p!("antiAliasedArtwork", "General", "Options", "Anti-aliased Artwork", bool),
p!("selectSameTintPercent", "General", "Options", "Select Same Tint %", bool),
@@ -455,6 +456,8 @@ pub const PREF_SPECS: &[PrefSpec] = &[
choice(&[("default", "Default"), ("object", "Transform Object Only"), ("pattern", "Transform Pattern Only"), ("both", "Transform Both")])
),
p!("useRegistrationPointForSymbol", "General", "Transform Panel", "Use Registration Point for Symbol", bool),
// The Transform panel menu: drawing a shape shows the panel.
p!("showOnShapeCreation", "General", "Transform Panel", "Show on Shape Creation", bool),
// The Align panel menu's Align to Glyph Bounds: Align and Distribute measure type by its glyphs' ink.
p!("alignGlyphBoundsPoint", "Type", "Align to Glyph Bounds", "Point Text", bool),
p!("alignGlyphBoundsArea", "Type", "Align to Glyph Bounds", "Area Text", bool),
+41 -1
View File
@@ -9,7 +9,9 @@ use vectorcraft_doc::swatches::{LinkFn, PaintFn, color_name, map_node_paints, ma
use vectorcraft_doc::{Document, NodeId};
use super::paint::paint_from;
use super::{CommandSpec, Result, Session, bad, bool_or, check_numbers, check_switches, cmd, color_value, has_doc, index, ok, str_param, switch_or};
use super::{
CommandSpec, Result, Session, bad, bool_or, check_numbers, check_switches, cmd, color_value, has_doc, index, ok, str_param, switch_or, text_param,
};
use crate::EngineError;
pub fn specs() -> Vec<CommandSpec> {
@@ -106,6 +108,15 @@ pub fn specs() -> Vec<CommandSpec> {
has_doc,
swatch_ungroup
),
cmd!(
"swatch.renameGroup",
"Color Group Options",
["Window", "Swatches"],
None,
"{group: color group, name: its new name (trimmed)} rename a color group, as one undo step; its swatches, their colors and the art linked to them stay as they are. Swatches and color groups share one set of names, so a name another color group or a swatch has is an error, as is an empty name; the group's own name records no undo step. A drag still in progress becomes an undo step of its own first → {name}",
has_doc,
swatch_rename_group
),
cmd!(
"swatch.sortByKind",
"Sort by Kind",
@@ -1200,6 +1211,35 @@ fn swatch_ungroup(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "swatches": moved }))
}
fn swatch_rename_group(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "swatch.renameGroup";
let group = text_param(p, "group", C)?.ok_or_else(|| bad(C, "missing `group`"))?.to_string();
let name = text_param(p, "name", C)?.ok_or_else(|| bad(C, "missing `name`"))?.trim().to_string();
if name.is_empty() {
return Err(bad(C, "`name` is empty"));
}
let d = &s.doc()?.doc;
if !d.swatch_groups.iter().any(|g| g.name == group) {
return Err(bad(C, format!("no colour group `{group}`")));
}
if name == group {
return Ok(json!({ "name": name }));
}
if d.swatch_name_taken(&name) {
return Err(bad(C, format!("a swatch or color group named `{name}` already exists")));
}
// A drag still in progress is a step of its own, so canceling or undoing it leaves the rename.
if !s.previewing && s.batch_stash.is_none() && s.in_interaction() {
super::settle_interaction(s)?;
}
s.edit("Color Group Options", |d, _| {
let g = d.swatch_groups.iter_mut().find(|g| g.name == group).ok_or_else(|| bad(C, format!("no colour group `{group}`")))?;
g.name.clone_from(&name);
Ok(())
})?;
Ok(json!({ "name": name }))
}
fn swatch_sort_by_kind(s: &mut Session, _: &Value) -> Result<Value> {
let rank = |w: &Swatch| match &w.paint {
Paint::None => 0,
+96 -6
View File
@@ -39,13 +39,37 @@ impl Kind {
/// Attributes of style `name` (the Normal style is built in: empty unless redefined).
fn attrs(self, d: &Document, name: &str) -> Option<Map<String, Value>> {
match self.defs(d).iter().find(|s| s.name == name) {
Some(s) => Some(s.attrs.clone()),
Some(s) => {
let mut attrs = s.attrs.clone();
if self == Kind::Para {
kinsoku_pair(&mut attrs);
}
Some(attrs)
}
None if name == self.normal() => Some(Map::new()),
None => None,
}
}
}
/// The two keys of Kinsoku Set: a built-in set (`kinsoku`) and a custom set (`kinsoku_set`), which
/// goes with Hard.
const KINSOKU: [&str; 2] = ["kinsoku", "kinsoku_set"];
/// Paragraph style attributes `attrs` with Kinsoku Set as one attribute: one that gives only
/// `kinsoku` gets no custom set, and one that gives only `kinsoku_set` gets Hard beside it.
fn kinsoku_pair(attrs: &mut Map<String, Value>) {
match (attrs.contains_key(KINSOKU[0]), attrs.contains_key(KINSOKU[1])) {
(true, false) => {
attrs.insert(KINSOKU[1].into(), Value::Null);
}
(false, true) => {
attrs.insert(KINSOKU[0].into(), json!(vectorcraft_doc::Kinsoku::Hard));
}
_ => {}
}
}
/// One command spec (the `cmd!` macro wants literals; these ids are built with `concat!`).
const fn spec(id: &'static str, label: &'static str, menu: &'static [&'static str], params: &'static str, run: Run, journal: bool) -> CommandSpec {
CommandSpec { id, label, menu, shortcut: None, params, enabled: has_doc, run, journal, schema: None }
@@ -253,6 +277,7 @@ pub fn para_attrs(v: &ParaStyle) -> Map<String, Value> {
("leading_model", json!(v.leading_model)),
("burasagari", json!(v.burasagari)),
("kinsoku", json!(v.kinsoku)),
("kinsoku_set", json!(v.kinsoku_set)),
("kinsoku_type", json!(v.kinsoku_type)),
("bunri_kinshi", json!(v.bunri_kinshi)),
("kurikaeshi_moji_shori", json!(v.kurikaeshi_moji_shori)),
@@ -325,6 +350,8 @@ fn restyle<T: Serialize + DeserializeOwned + Clone>(
// Starts from every key `cur` writes, so values no style sets (a glyph choice) are kept.
let Some(mut m) = to_map(cur) else { return cur.clone() };
m.extend(attrs(cur));
let pair = |m: &Map<String, Value>| KINSOKU.map(|k| m.get(k).cloned());
let own = pair(&m);
for (k, v) in new {
if old.get(k).is_none_or(|o| m.get(k) == Some(o)) {
m.insert(k.clone(), v.clone());
@@ -338,6 +365,25 @@ fn restyle<T: Serialize + DeserializeOwned + Clone>(
m.insert(k.clone(), base_value.clone());
}
}
// Kinsoku Set's two keys change together: a paragraph whose Kinsoku Set is not the old
// style's keeps its own.
let has = |m: &Map<String, Value>| KINSOKU.iter().any(|k| m.contains_key(*k));
if has(old) || has(new) {
let follows = !has(old) || pair(old) == own;
let to = if !follows {
own
} else if has(new) {
pair(new)
} else {
pair(base)
};
for (k, v) in KINSOKU.into_iter().zip(to) {
match v {
Some(v) => m.insert(k.to_string(), v),
None => m.remove(k),
};
}
}
serde_json::from_value(Value::Object(m)).unwrap_or_else(|_| cur.clone())
}
@@ -359,16 +405,27 @@ fn font_change(before: &CharStyle, mut st: CharStyle, attrs: &Map<String, Value>
/// Change text in layers, symbols, graph designs, pattern tiles, saved pattern tiles restored by
/// Cancel, and brush art, including opacity masks in those trees.
pub(crate) fn each_text_mut(d: &mut Document, f: &mut impl FnMut(&mut vectorcraft_doc::TextObject) -> Result<()>) -> Result<()> {
each_node_with_text_mut(d, &mut |n| match &mut n.kind {
NodeKind::Text(t) => f(t),
_ => Ok(()),
})
}
/// Change the nodes [`each_text_mut`] reaches: each type object and each node holding one, and each
/// graph keeping paragraph attributes for its labels, with or without labels drawn.
pub(crate) fn each_node_with_text_mut(d: &mut Document, f: &mut impl FnMut(&mut Node) -> Result<()>) -> Result<()> {
fn has_text(n: &Node) -> bool {
matches!(n.kind, NodeKind::Text(_))
|| n.extras().graph.as_deref().is_some_and(|g| {
let l = &g.label_styles;
l.values_para.is_some() || l.categories_para.is_some() || l.legend_para.is_some()
})
|| n.extras().mask.as_ref().is_some_and(|mask| has_text(&mask.art))
|| n.children().is_some_and(|children| children.iter().any(|child| has_text(child)))
}
fn visit(n: &mut Node, f: &mut impl FnMut(&mut vectorcraft_doc::TextObject) -> Result<()>) -> Result<()> {
if let NodeKind::Text(t) = &mut n.kind {
f(t)?;
}
fn visit(n: &mut Node, f: &mut impl FnMut(&mut Node) -> Result<()>) -> Result<()> {
f(n)?;
if let Some(mask) = n.extras_if_any().and_then(|e| e.mask.as_mut())
&& has_text(&mask.art)
{
@@ -654,10 +711,43 @@ fn attrs_param(d: &Document, p: &Value, kind: Kind, verb: &str, kept: Option<&Ma
}
para_ranges(&st, m, kept, &c)?;
sort_tabs(&mut st, m, kept);
// A custom Kinsoku set goes with Hard and has a name a custom set can have: one
// given beside None or Soft, or with a blank or built-in name, fails the call
// instead of being dropped.
if m.get("kinsoku_set").is_some_and(|v| !v.is_null()) && KINSOKU.iter().any(|k| kept.and_then(|kept| kept.get(*k)) != m.get(*k)) {
if st.kinsoku != vectorcraft_doc::Kinsoku::Hard {
return Err(bad(&c, "`kinsoku_set` goes with `kinsoku` Hard: give `kinsoku` as `hard` or leave it out"));
}
if st.kinsoku_set.is_none() {
return Err(bad(&c, "`kinsoku_set` needs the name of one of the document's Kinsoku sets"));
}
}
// A custom Kinsoku set is one of the document's, by name (any case), as
// `text.setFormat` chooses it; one the style already holds stays.
if let Some(set) = &st.kinsoku_set
&& kept.and_then(|k| k.get("kinsoku_set")) != m.get("kinsoku_set")
{
let name = set.name.clone();
let found = vectorcraft_doc::KinsokuSet::named(&d.kinsoku_sets, &name).cloned().map(std::sync::Arc::new);
st.kinsoku_set =
Some(found.ok_or_else(|| bad(&c, format!("`kinsoku_set`: the document has no Kinsoku set named `{name}`")))?);
}
para_attrs(&st)
}
};
Ok(Some(m.keys().filter_map(|k| full.get(k).map(|v| (k.clone(), v.clone()))).collect()))
let mut out: Map<String, Value> = m.keys().filter_map(|k| full.get(k).map(|v| (k.clone(), v.clone()))).collect();
// A paragraph style giving one key of Kinsoku Set keeps both, so applying it replaces a
// paragraph's custom set or built-in set.
if kind == Kind::Para {
for k in KINSOKU {
if KINSOKU.iter().any(|g| m.contains_key(*g))
&& let Some(v) = full.get(k)
{
out.insert(k.into(), v.clone());
}
}
}
Ok(Some(out))
}
Some(_) => Err(bad(&kind.cmd(verb), "attrs must be an object")),
}
+1 -1
View File
@@ -147,7 +147,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Paste without Formatting",
["Edit"],
Some("Cmd+Alt+V"),
"{center?, dx?, dy?, swatchConflict?} paste as edit.paste; pasted text takes the default character style (one run) and leaves its character and paragraph styles behind, as do the labels of pasted graphs, which take a new graph's label character style and paragraph attributes (keeping their alignment); a pasted graph no longer keeps its labels' character and paragraph formats, so a later redraw sets them the same way → {ids, added, merged, renamed}",
"{center?, dx?, dy?, swatchConflict?, profileMismatch?} paste as edit.paste; pasted text takes the default character style (one run) and leaves its character and paragraph styles behind, as do the labels of pasted graphs, which take a new graph's label character style and paragraph attributes (keeping their alignment); a pasted graph no longer keeps its labels' character and paragraph formats, so a later redraw sets them the same way → {ids, added, merged, renamed}",
has_clipboard,
paste_plain
),
+5
View File
@@ -24,6 +24,11 @@ pub const ON_ACTIVE_ARTBOARD: [&str; 8] = [
/// `indices` instead.
pub const FIT_ACTIVE_ARTBOARD: [&str; 2] = ["artboard.fitToArt", "artboard.fitToSelection"];
/// The commands that the Rectangle, Rounded Rectangle, Ellipse, Polygon, Star and Line Segment
/// tools and their dialogs, and the Shaper tool for a shape it recognizes, run to draw a shape
/// ([`crate::Session::take_shape_drawn`]).
pub const DRAWS_SHAPE: [&str; 5] = ["shape.rectangle", "shape.ellipse", "shape.polygon", "shape.star", "shape.line"];
/// `(command, param)` pairs the journal records only so a replay reproduces the original run
/// (dates from the clock: `cmd::clock_date`; the artboards the app passes to the
/// [`ON_ACTIVE_ARTBOARD`] and [`FIT_ACTIVE_ARTBOARD`] commands and to a batch; the artboards the
+134 -1
View File
@@ -48,7 +48,7 @@ pub struct AutomationRoots {
write: Vec<Root>,
}
#[derive(Debug)]
#[derive(Clone, Debug)]
struct Root {
/// The folder made absolute, links followed: what paths are compared with.
resolved: PathBuf,
@@ -128,6 +128,25 @@ impl AutomationRoots {
}
}
/// The roots that grant only what both `self` and `other` grant: for each kind, every root of
/// one that lies inside a root of the other. A kind left with none grants no access of its kind.
pub fn intersect(&self, other: &Self) -> Arc<Self> {
let both = |a: &[Root], b: &[Root]| {
let mut out: Vec<Root> = Vec::new();
for r in a
.iter()
.filter(|r| b.iter().any(|o| inside(&r.resolved, &o.resolved)))
.chain(b.iter().filter(|o| a.iter().any(|r| inside(&o.resolved, &r.resolved))))
{
if !out.iter().any(|o| o.resolved == r.resolved) {
out.push(r.clone());
}
}
out
};
Arc::new(Self { read: both(&self.read, &other.read), write: both(&self.write, &other.write) })
}
/// The roots for people: `read A, B; write C` (`none` for a kind without any).
pub fn describe(&self) -> String {
let list = |roots: &[Root]| {
@@ -223,6 +242,36 @@ impl ScopeHandle {
let Self(scope, gate, exempt) = self;
with_gate(gate, || with_gate_reads_exempt(exempt, || with_scope(scope, f)))
}
/// The roots in force in this scope, if any (as [`current`] gives them on its thread).
fn roots(&self) -> Option<Arc<AutomationRoots>> {
match &self.0 {
Some(Scope::Confined(r)) => Some(r.clone()),
Some(Scope::Unconfined) => None,
None => PROCESS.get().cloned(),
}
}
/// The captured scope narrowed to what the calling thread may reach as well: the roots of both
/// are in force ([`AutomationRoots::intersect`]), and without roots in either, none are. The
/// script gates of both are in force too, and reads are exempt from them only where both are.
pub fn within_current(self) -> Self {
let here = Self::capture();
let gate = match (self.1.clone(), here.1.clone()) {
(None, None) => None,
(Some(g), None) | (None, Some(g)) => Some(g),
(Some(a), Some(b)) if Arc::ptr_eq(&a, &b) => Some(a),
(Some(a), Some(b)) => Some(Arc::new(a.followed_by(b))),
};
let exempt = self.2 && here.2;
let scope = match (self.roots(), here.roots()) {
(None, None) => self.0,
(Some(r), None) | (None, Some(r)) => Some(Scope::Confined(r)),
(Some(a), Some(b)) if Arc::ptr_eq(&a, &b) => Some(Scope::Confined(a)),
(Some(a), Some(b)) => Some(Scope::Confined(a.intersect(&b))),
};
Self(scope, gate, exempt)
}
}
/// What a command a running script runs (`vc.run`) may read and write: the places the script's
@@ -235,10 +284,26 @@ pub(crate) struct ScriptGate {
pub(crate) write: ScriptScope,
/// The paths of the open documents' files, as the documents hold them.
pub(crate) documents: Vec<String>,
/// Another gate a path must pass as well ([`ScopeHandle::within_current`]).
pub(crate) also: Option<Arc<ScriptGate>>,
}
impl ScriptGate {
/// This gate with `next` at the end of its chain of `also` gates, so a path must pass every
/// gate already in the chain as well as `next`.
fn followed_by(&self, next: Arc<ScriptGate>) -> ScriptGate {
let also = match &self.also {
None => next,
Some(also) if Arc::ptr_eq(also, &next) => next,
Some(also) => Arc::new(also.followed_by(next)),
};
ScriptGate { also: Some(also), ..self.clone() }
}
fn check(&self, path: &str, access: Access) -> Result<(), String> {
if let Some(also) = &self.also {
also.check(path, access)?;
}
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 {
@@ -824,6 +889,74 @@ mod tests {
p.to_string_lossy().into_owned()
}
/// The roots both grant: the deeper of two nested roots, nothing for roots apart, and a kind
/// only one grants is not granted.
#[test]
fn intersected_roots_grant_what_both_grant() {
let (base, roots) = folders("intersect");
let narrow = AutomationRoots::new(&[&base.join("in/sub"), &base.join("in2")], &[]).unwrap().unwrap();
let both = roots.intersect(&narrow);
assert_eq!(both.check(&s(base.join("in/sub/x.svg")), Access::Read), Ok(()));
assert!(both.check(&s(base.join("in/a.svg")), Access::Read).is_err(), "only the narrow root grants it");
assert!(both.check(&s(base.join("in2")), Access::Read).is_err(), "only the narrow roots grant it");
assert!(both.check(&s(base.join("out/x.svg")), Access::Write).is_err(), "only the first grants writes");
assert_eq!(both.describe(), narrow.intersect(&roots).describe(), "either order");
let unconfined = ScopeHandle(Some(Scope::Unconfined), None, false);
let within = |saved: ScopeHandle, here: Option<&Arc<AutomationRoots>>| {
confine(here, || saved.within_current()).run(|| current().map(|r| r.describe()))
};
assert_eq!(within(unconfined.clone(), Some(&narrow)), Some(narrow.describe()), "a confined caller keeps its roots");
assert_eq!(within(ScopeHandle(Some(Scope::Confined(roots.clone())), None, false), None), Some(roots.describe()), "the saved roots stay");
assert_eq!(within(ScopeHandle(Some(Scope::Confined(roots.clone())), None, false), Some(&narrow)), Some(both.describe()));
assert!(unconfined.run(|| current().is_none()));
let _ = std::fs::remove_dir_all(base);
}
/// A scope narrowed to the calling thread keeps the script gate of both: a script command that
/// carries on work saved without a gate reads only what its gate allows, and with a gate saved
/// too, only what both allow; reads are exempt only where both scopes exempt them.
#[test]
fn a_narrowed_scope_keeps_the_script_gates_of_both() {
let (base, _) = folders("narrowed-gate");
let gate =
|dir: &str| ScriptGate { read: ScriptScope::of_folder(&base.join(dir)), write: ScriptScope::default(), documents: vec![], also: None };
let (inside, other) = (s(base.join("in/a.svg")), s(base.join("outside/secret.svg")));
let reads = |saved: ScopeHandle, gate_here: Option<ScriptGate>| {
let narrowed = match gate_here {
Some(g) => with_script_gate(g, || saved.within_current()),
None => saved.within_current(),
};
narrowed.run(|| (check_read(&inside).is_ok(), check_read(&other).is_ok()))
};
let plain = ScopeHandle(None, None, false);
assert_eq!(reads(plain.clone(), Some(gate("in"))), (true, false), "the confirming command's gate");
assert_eq!(reads(ScopeHandle(None, Some(Arc::new(gate("in"))), false), None), (true, false), "the saved gate");
assert_eq!(reads(ScopeHandle(None, Some(Arc::new(gate("in"))), false), Some(gate("outside"))), (false, false), "both gates");
assert_eq!(reads(ScopeHandle(None, None, true), Some(gate("in"))), (true, false), "exempt only where both are");
assert_eq!(reads(plain, None), (true, true));
let _ = std::fs::remove_dir_all(base);
}
/// A scope narrowed again and again keeps every gate it was narrowed by: a gate an earlier
/// narrowing joined to the chain still refuses what it refused before.
#[test]
fn a_scope_narrowed_several_times_keeps_every_gate() {
let (base, _) = folders("narrowed-thrice");
let gate = |dir: &Path| ScriptGate { read: ScriptScope::of_folder(dir), write: ScriptScope::default(), documents: vec![], also: None };
let (inside, other) = (s(base.join("in/a.svg")), s(base.join("outside/secret.svg")));
let narrow = |saved: ScopeHandle, g: ScriptGate| with_script_gate(g, || saved.within_current());
let reads = |h: &ScopeHandle| h.clone().run(|| (check_read(&inside).is_ok(), check_read(&other).is_ok()));
let first = narrow(ScopeHandle(None, None, false), gate(&base));
assert_eq!(reads(&first), (true, true));
let second = narrow(first, gate(&base.join("in")));
assert_eq!(reads(&second), (true, false), "the second gate refuses the outside file");
let third = narrow(second, gate(&base));
assert_eq!(reads(&third), (true, false), "the second gate is kept after a third narrowing");
let fourth = narrow(third, gate(&base));
assert_eq!(reads(&fourth), (true, false), "and after a fourth");
let _ = std::fs::remove_dir_all(base);
}
#[test]
fn network_paths_are_told_by_name() {
for p in [r"\\server\share\x.svg", "//server/share/x.svg", r"\\?\UNC\server\share\x.svg", r"\\?\unc\server\share"] {
+4 -1
View File
@@ -110,6 +110,9 @@ pub struct Session {
/// Set while saved steps play ([`Session::replay`]): [`Session::execute`] then takes keys the
/// command's params description doesn't name instead of refusing them.
replaying: bool,
/// Set when a command that draws a shape was journaled outside saved steps
/// ([`Session::take_shape_drawn`]).
shape_drawn: bool,
/// Set when the active tool panicked (see [`guard`]); reported by the next tool event.
tool_panic: Option<EngineError>,
/// How many times switching or closing documents, or replacing the active one, has started the
@@ -411,7 +414,7 @@ mod session;
pub(crate) use command_sets::SELECTS_GIVEN_IDS;
#[cfg(test)]
use command_sets::given_ids;
pub use command_sets::{FIT_ACTIVE_ARTBOARD, ON_ACTIVE_ARTBOARD, waits_for_tool_edit};
pub use command_sets::{DRAWS_SHAPE, FIT_ACTIVE_ARTBOARD, ON_ACTIVE_ARTBOARD, waits_for_tool_edit};
pub use doc_state::{DocState, OpenRows, RecalledSelection};
pub use error::{EngineError, READ_ONLY_LOCATION, Result, SCRIPT_BUSY};
#[cfg(test)]
+10
View File
@@ -57,6 +57,9 @@ pub struct Prefs {
pub interpolate_control_points: bool,
pub use_precise_cursors: bool,
pub show_tool_tips: bool,
/// General › Show Tool Cards: with tool tips on, a tool button's tool tip is a card with what the
/// tool does and its keys, for tools that have a description.
pub show_tool_cards: bool,
/// Other Script… warns before it runs a chosen script.
pub show_external_script_warning: bool,
pub anti_aliased_artwork: bool,
@@ -400,6 +403,11 @@ pub struct Prefs {
/// selected, the panel and the Properties panel's Transform section measure and transform it
/// from its symbol's registration point instead of the reference point.
pub use_registration_point_for_symbol: bool,
/// The Transform panel menu's Show on Shape Creation: drawing a shape with the Rectangle,
/// Rounded Rectangle, Ellipse, Polygon, Star or Line Segment tool (a drag or OK in the tool's
/// dialog, also on the active perspective plane), a shape the Shaper tool recognizes, or running
/// one of [`crate::DRAWS_SHAPE`], shows the Transform panel.
pub show_on_shape_creation: bool,
/// The tools' persistent options by store (a tool id, or a store a family shares: `liquify`
/// holds the Liquify tools' Global Brush Dimensions), see [`vectorcraft_tools::settings`]:
/// kept across tool switches and saved with the preferences. Not a Preferences dialog field:
@@ -453,6 +461,7 @@ impl Default for Prefs {
interpolate_control_points: false,
use_precise_cursors: false,
show_tool_tips: true,
show_tool_cards: false,
show_external_script_warning: true,
anti_aliased_artwork: true,
select_same_tint_percent: false,
@@ -621,6 +630,7 @@ impl Default for Prefs {
single_corner_radius: true,
transform_panel_patterns: "default".to_string(),
use_registration_point_for_symbol: false,
show_on_shape_creation: false,
tool_settings: Default::default(),
perspective_presets: vec![],
blend_options: None,
+2 -1
View File
@@ -49,7 +49,8 @@ pub(crate) fn doc_sane(d: &Document, sel: &Selection) -> bool {
&& objects_in_range(d, &sel.objects)
}
fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {
/// Is every edge of `r` finite and within [`MAX_COORD`] of the origin?
pub(crate) fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {
[r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_COORD)
}
+1 -1
View File
@@ -457,7 +457,7 @@ impl Disk {
/// The gate for a command the script runs: the places it reads and writes now, and the files of
/// the open documents, `documents`.
pub(crate) fn gate(&self, documents: Vec<String>) -> crate::file_access::ScriptGate {
crate::file_access::ScriptGate { read: self.scope.clone(), write: self.writes.clone(), documents }
crate::file_access::ScriptGate { read: self.scope.clone(), write: self.writes.clone(), documents, also: None }
}
/// The files written since this was last asked, to name in the report.
+1 -1
View File
@@ -1,4 +1,4 @@
use super::command_sets::{JOURNALED_READS, SELECTS_GIVEN_IDS, TAKES_GUIDE_IDS, given_ids, strip_replay_only, waits_for_tool_edit};
use super::command_sets::{DRAWS_SHAPE, JOURNALED_READS, SELECTS_GIVEN_IDS, TAKES_GUIDE_IDS, given_ids, strip_replay_only, waits_for_tool_edit};
use super::doc_state::DocState;
use super::error::{EngineError, Result};
use super::history::NamedStep;
+1
View File
@@ -68,6 +68,7 @@ impl Session {
preview_memo: Default::default(),
depth: 0,
replaying: false,
shape_drawn: false,
tool_panic: None,
tool_resets: 0,
tool_set_since_reset: false,
+1
View File
@@ -458,6 +458,7 @@ impl Session {
st.last_perspective = perspective_again;
}
let (doc, journal, grouped) = (self.active().map(|d| d.uid), self.journal.len(), self.undo_group_docs());
self.note_shape_drawn(&preview.0, &preview.1);
self.journal.push(preview);
self.journal_in_undo_groups(doc, &grouped, journal);
if self.depth == 0 {
Loaded 100 of 360 files, more files were not shown because too many files have changed in this diff. Show more