Merge main into feat/3d-classic-map-art

This commit is contained in:
dotCooCoo committed 2026-11-15 22:08:30 -08:00
commit 6e80aa6fc2
133 files changed
+6749 -866

No files matched your search

+2
View File
@@ -147,6 +147,8 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 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-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-03: Text Tweaker, the first tool of the Type Tools add-on (Object › Plug-ins › Type Tools): one character attribute (size, baseline shift, rotation, horizontal or vertical scale, tracking, leading or stroke weight) goes letter by letter from a start value to an end value along a straight ramp, an ease, a bow, a spike or at random with a seed, set as the Character panel sets it, while the text stays live; a dialog with Preview, one undo step (`addon.type.textTweaker`, #4924). A VectorCraft addition: headline numbers unchanged.
- 2026-11-01: Group Overlapping Objects joins the Arrange Tools add-on (Object › Plug-ins › Arrange Tools): the selected objects whose visual bounds overlap or touch, chains included, go into one group each, within their own layer or group, at the stacking place of their frontmost member; objects that overlap nothing stay as they are. One undo step, a sweep along x so thousands of loose pieces group quickly (at most 20000 objects). A VectorCraft addition: headline numbers unchanged.
- 2026-10-31: Export for Screens works as the reference app's dialog: Artboards and Assets tabs with a grid or list of thumbnails, Clear Selection and Prefix, Create Sub-folders by Scale or Format (on by default), Export PDFs As Single File (the chosen artboards as one PDF's pages, `pdfs: "single"`) or Multiple Files, iOS and Android rows, format presets in a ☰ menu, and a count of the files the export writes (#4895). About 55 community PRs and fixes landed the same day: Find Font, Replace Font, Outline Stroke and Expand leave hidden and locked art alone (with a warning); DXF export writes LINE and ELLIPSE entities and outlines only the strokes a CAD line can't draw; Blob Brush Angle and Roundness; Shift-constrained Perspective Selection; Grid Repeat Options Preview; a gradient mesh from a file budgeted at about a million quads; width-profile strokes keep their shape zoomed out; `.ai`/EPS import fidelity (area type, envelopes, transparency in dictionaries, character styles); PDF import finds hyphenated and CMap-suffixed font names; Windows renders follow the process's core affinity; Enter or Escape in a floating panel's field no longer reaches the canvas (#4803); Properties shows Blend Options for any selected blend (#4817); Artwork Cleanup finds doubled type (#4835) and joins stacked lines into one object (Join Point Text, #4826). Headline numbers unchanged.
+20
View File
@@ -491,6 +491,10 @@ pub struct GraphSpec {
pub first_column_in_front: bool,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub filled_lines: bool,
/// Graph Type › Line Width: how wide Draw Filled Lines draws a line, in points. `None` draws
/// [`DEFAULT_FILLED_LINE_WIDTH`]; see [`Self::filled_line_width`].
#[serde(skip_serializing_if = "Option::is_none")]
pub line_width: Option<f64>,
/// Graph Type › Add Drop Shadow (behind columns, bars, lines and pie wedges) and Add Legend Across Top (the
/// legend in rows above the plot instead of a column on its right).
#[serde(skip_serializing_if = "std::ops::Not::not")]
@@ -565,6 +569,21 @@ fn is_zero(n: &usize) -> bool {
*n == 0
}
/// Graph Type › Line Width: the width Draw Filled Lines draws a line at when the graph sets none, and the least and
/// greatest widths a graph takes, in points.
pub const DEFAULT_FILLED_LINE_WIDTH: f64 = 3.0;
pub const MIN_FILLED_LINE_WIDTH: f64 = 0.01;
pub const MAX_FILLED_LINE_WIDTH: f64 = 1000.0;
impl GraphSpec {
/// How wide Draw Filled Lines draws a line, in points: [`Self::line_width`], else [`DEFAULT_FILLED_LINE_WIDTH`]. A
/// width a file gives outside [`MIN_FILLED_LINE_WIDTH`] to [`MAX_FILLED_LINE_WIDTH`], or not finite, draws the
/// default.
pub fn filled_line_width(&self) -> f64 {
self.line_width.filter(|w| (MIN_FILLED_LINE_WIDTH..=MAX_FILLED_LINE_WIDTH).contains(w)).unwrap_or(DEFAULT_FILLED_LINE_WIDTH)
}
}
/// Edge-to-Edge Lines for a graph saved before the option existed: on, as it was drawn then.
fn edge_to_edge_before_the_option() -> bool {
true
@@ -704,6 +723,7 @@ impl Default for GraphSpec {
first_row_in_front: false,
first_column_in_front: false,
filled_lines: false,
line_width: None,
drop_shadow: false,
legend_across_top: false,
pie_legend_in_wedges: false,
+2 -2
View File
@@ -96,8 +96,8 @@ pub use compound_shape::ShapeMode;
pub use corners::LiveCorners;
pub use depth::{MAX_DEPTH, MAX_SYMBOL_NODES};
pub use graph::{
ColumnDesign, ColumnType, Fractions, GraphDesign, GraphKind, GraphSpec, LabelRows, LabelStyles, MAX_GRAPH_CATEGORIES, MAX_GRAPH_SERIES,
PiePosition, PieSort, SeriesPaint, TickLength, ValueAxisSide,
ColumnDesign, ColumnType, DEFAULT_FILLED_LINE_WIDTH, Fractions, GraphDesign, GraphKind, GraphSpec, LabelRows, LabelStyles, MAX_FILLED_LINE_WIDTH,
MAX_GRAPH_CATEGORIES, MAX_GRAPH_SERIES, MIN_FILLED_LINE_WIDTH, PiePosition, PieSort, SeriesPaint, TickLength, ValueAxisSide,
};
pub use hit::{Hit, HitKind};
pub use links::{LinkInfo, PlacementOptions};
+5 -5
View File
@@ -50,10 +50,10 @@ pub struct Selection {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key_guide: Option<NodeId>,
/// The key anchor for Align: one of two or more anchor points selected with Direct Selection,
/// the last one a Shift-click added (path, anchor in [`Self::anchors`]). Align and Distribute
/// move the other selected points relative to it, and it stays in place. Never set with `key`
/// or `key_guide`; [`Self::prune`] clears it when the point is no longer a selected anchor, or
/// fewer than two points are selected.
/// designated by clicking an already-selected anchor point without modifiers (path, anchor in
/// [`Self::anchors`]). Align and Distribute move the other selected points relative to it, and
/// it stays in place. Never set with `key` or `key_guide`; [`Self::prune`] clears it when the
/// point is no longer a selected anchor, or fewer than two points are selected.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key_anchor: Option<(NodeId, AnchorRef)>,
/// The new art on a locked artboard that this selection keeps editable
@@ -311,7 +311,7 @@ impl Selection {
let anchor_kept = self.key_anchor.is_some_and(|(id, (si, ai))| {
self.objects.contains(&id)
&& !self.segments.contains_key(&id)
&& self.anchors.get(&id).is_some_and(|set| set.contains(&(si, ai)))
&& (self.anchors.get(&id).is_some_and(|set| set.contains(&(si, ai))) || !self.anchors.contains_key(&id))
&& found
.get(&id)
.and_then(|p| doc.node_at(p))
+4 -4
View File
@@ -182,28 +182,28 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
REVOLVE,
"Revolve…",
&["Effect", "3D and Materials"],
"{angle: degrees (0..360, 360), offset: pt (0..100000, 0), edge: left|right, rotationX: degrees (0), rotationY: degrees (0), rotationZ: degrees (0), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), segments: integer (8..128, 64), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a hard-edged shadow, black at 50% times the art's opacity), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), cap: bool (true: solid, closing circular ends of open profiles and a partial sweep's cut sides; false: hollow), expandVisibleOnly: bool (true, trim covered opaque solid surfaces only on Expand Appearance; surfaces with graphics keep every face), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the swept side, see threeD.mapGraphic: symbol: name of a document symbol, face: front (the side), x: pt (0; the offset of the graphic's center from the middle of the side, around the axis: the angle times the profile's distance from the axis at that point), y: pt (0; along the profile, toward its lower end), scale: % (1..10000, 100), rotation: degrees (-360..360, 0; counterclockwise); wrapped around the side at its own size, so it reaches farther around where the profile comes nearer the axis, shaded with it and drawn only where the side's outside faces the viewer; a full turn cuts it at the back; nothing on the caps), render: object ({mode: shaded}; mode: shaded|wireframe, wireframe draws the edges of the faces the effect draws, each once, stroked 0.5 pt black with round joins, with no fill, shadow or graphics, whatever the opacity of the fills, strokes and group members, while the effect stays live; the stroke is VectorCraft's own)}. Shaded surfaces use smooth vector gradients automatically; intersecting profiles use approximate painter visibility.",
"{angle: degrees (0..360, 360), offset: pt (0..100000, 0), edge: left|right, rotationX: degrees (0), rotationY: degrees (0), rotationZ: degrees (0), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), segments: integer (8..128, 64), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches, and how much it blurs the shadow), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a shadow, black at 50% times the art's opacity, hard-edged at the first light's softness 0 and blurred above it), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), cap: bool (true: solid, closing circular ends of open profiles and a partial sweep's cut sides; false: hollow), expandVisibleOnly: bool (true, trim covered opaque solid surfaces only on Expand Appearance; surfaces with graphics keep every face), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the swept side, see threeD.mapGraphic: symbol: name of a document symbol, face: front (the side), x: pt (0; the offset of the graphic's center from the middle of the side, around the axis: the angle times the profile's distance from the axis at that point), y: pt (0; along the profile, toward its lower end), scale: % (1..10000, 100), rotation: degrees (-360..360, 0; counterclockwise); wrapped around the side at its own size, so it reaches farther around where the profile comes nearer the axis, shaded with it and drawn only where the side's outside faces the viewer; a full turn cuts it at the back; nothing on the caps), render: object ({mode: shaded}; mode: shaded|wireframe, wireframe draws the edges of the faces the effect draws, each once, stroked 0.5 pt black with round joins, with no fill, shadow or graphics, whatever the opacity of the fills, strokes and group members, while the effect stays live; the stroke is VectorCraft's own)}. Shaded surfaces use smooth vector gradients automatically; intersecting profiles use approximate painter visibility.",
json!({"angle":360.0,"offset":0.0,"edge":"left","rotationX":0.0,"rotationY":0.0,"rotationZ":0.0,"perspectiveAngle":0.0,"segments":64,"shade":true,"lightColor":"#ffffff","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":80.0,"lightSoftness":0.0,"ambient":25.0,"shadow":false,"shadowPosition":"behind","shadowDistance":0.0,"shadowBounds":100.0,"cap":true,"expandVisibleOnly":true,"graphics":[],"render":{"mode":"shaded"}}),
),
g(
EXTRUDE,
"Extrude & Bevel…",
&["Effect", "3D and Materials"],
"{depth: pt (0..2000, 50), twist: degrees (0..360, 0; the back turned against the front), taper: % (1..100, 100; the back's size), cap: bool (true: solid; false: hollow), bevel: none|classic|rounded|cove|step|ogee (none), bevelWidth: pt (0..1000, 4), bevelHeight: pt (0..1000, 4), bevelRepeat: integer (1..32, 1), bevelSpace: % (0..90, 0; flat between repeats), bevelInside: bool (false: added around the shape; true: carved into it), bevelBothSides: bool (false), 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), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a hard-edged shadow, black at 50% times the art's opacity), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the caps, see threeD.mapGraphic: symbol: name of a document symbol, face: front|back (front; the back reads left to right as seen from behind), x: pt (0; the offset of the graphic's center from the center of the object's bounds, in the face's own plane), y: pt (0), scale: % (1..10000, 100; of the symbol's own size), rotation: degrees (-360..360, 0; counterclockwise); drawn turned, foreshortened and shaded with the cap and clipped to it, on a solid cap only), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. The front face is the art, extruded backwards about the centre of its bounds; painted with the top fill (else the top stroke).",
"{depth: pt (0..2000, 50), twist: degrees (0..360, 0; the back turned against the front), taper: % (1..100, 100; the back's size), cap: bool (true: solid; false: hollow), bevel: none|classic|rounded|cove|step|ogee (none), bevelWidth: pt (0..1000, 4), bevelHeight: pt (0..1000, 4), bevelRepeat: integer (1..32, 1), bevelSpace: % (0..90, 0; flat between repeats), bevelInside: bool (false: added around the shape; true: carved into it), bevelBothSides: bool (false), 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), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches, and how much it blurs the shadow), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a shadow, black at 50% times the art's opacity, hard-edged at the first light's softness 0 and blurred above it), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the caps, see threeD.mapGraphic: symbol: name of a document symbol, face: front|back (front; the back reads left to right as seen from behind), x: pt (0; the offset of the graphic's center from the center of the object's bounds, in the face's own plane), y: pt (0), scale: % (1..10000, 100; of the symbol's own size), rotation: degrees (-360..360, 0; counterclockwise); drawn turned, foreshortened and shaded with the cap and clipped to it, on a solid cap only), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. The front face is the art, extruded backwards about the centre of its bounds; painted with the top fill (else the top stroke).",
json!({"depth":50.0,"twist":0.0,"taper":100.0,"cap":true,"bevel":"none","bevelWidth":4.0,"bevelHeight":4.0,"bevelRepeat":1,"bevelSpace":0.0,"bevelInside":false,"bevelBothSides":false,"rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"shade":true,"lightColor":"#ffffff","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":80.0,"lightSoftness":0.0,"ambient":25.0,"shadow":false,"shadowPosition":"behind","shadowDistance":0.0,"shadowBounds":100.0,"graphics":[],"render":{"mode":"shaded"}}),
),
g(
INFLATE,
"Inflate…",
&["Effect", "3D and Materials"],
"{depth: pt (0..2000, 0; flat depth between front and back), twist: degrees (0..360, 0; the back turned against the front), taper: % (1..100, 100; the back's size), cap: bool (true: solid; false: no back, a shell open behind), volume: % (0..100, 50; 50 rounds the edge like a half sphere), bothSides: bool (false: flat back), 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), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a hard-edged shadow, black at 50% times the art's opacity), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. Painted with the top fill (else the top stroke).",
"{depth: pt (0..2000, 0; flat depth between front and back), twist: degrees (0..360, 0; the back turned against the front), taper: % (1..100, 100; the back's size), cap: bool (true: solid; false: no back, a shell open behind), volume: % (0..100, 50; 50 rounds the edge like a half sphere), bothSides: bool (false: flat back), 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), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches, and how much it blurs the shadow), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a shadow, black at 50% times the art's opacity, hard-edged at the first light's softness 0 and blurred above it), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. Painted with the top fill (else the top stroke).",
json!({"depth":0.0,"twist":0.0,"taper":100.0,"cap":true,"volume":50.0,"bothSides":false,"rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"shade":true,"lightColor":"#ffffff","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":80.0,"lightSoftness":0.0,"ambient":25.0,"shadow":false,"shadowPosition":"behind","shadowDistance":0.0,"shadowBounds":100.0,"render":{"mode":"shaded"}}),
),
g(
ROTATE,
"Rotate…",
&["Effect", "3D and Materials"],
"{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), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a hard-edged shadow, black at 50% times the art's opacity), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the plane, as Extrude & Bevel's, with face front only), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. Turns the flat art in 3D about the centre of its bounds; every fill and stroke keeps its paint, shaded as one plane.",
"{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), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), 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, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches, and how much it blurs the shadow), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a shadow, black at 50% times the art's opacity, hard-edged at the first light's softness 0 and blurred above it), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the plane, as Extrude & Bevel's, with face front only), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. Turns the flat art in 3D about the centre of its bounds; every fill and stroke keeps its paint, shaded as one plane.",
json!({"rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"shade":true,"lightColor":"#ffffff","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":80.0,"lightSoftness":0.0,"ambient":25.0,"shadow":false,"shadowPosition":"behind","shadowDistance":0.0,"shadowBounds":100.0,"graphics":[],"render":{"mode":"shaded"}}),
),
g(
+3 -3
View File
@@ -86,9 +86,9 @@ pub use raster::{
without_geometry,
};
pub use reshape::{
SYMBOL_ART_MAX_NODES, expand_outlined, follows_image_pixels, gives_image_shape, has_gradient_copies, has_instance_row_raster, has_item_geometry,
has_painted_effects, has_transform_art, has_transform_copies, has_transform_options, image_paint, instance_as_art, needs_outline, outer_effects,
outline_art, outline_text, paint_type_piece, reshape,
SYMBOL_ART_MAX_NODES, expand_outlined, follows_image_pixels, gives_image_shape, has_copied_row_raster, has_gradient_copies,
has_instance_row_raster, has_item_geometry, has_painted_effects, has_transform_art, has_transform_copies, has_transform_options, image_paint,
instance_as_art, needs_outline, outer_effects, outline_art, outline_text, paint_type_piece, reshape,
};
pub use revolve::{
CLASSIC_REVOLVE, REVOLVE, has_revolve, is_revolve, revolve_art, revolve_art_in, revolve_options, validate_revolve, validate_revolve_in,
+227 -31
View File
@@ -107,15 +107,66 @@ fn reaches_appearance(e: &Effect) -> bool {
}
/// Is `n` a path or compound path that its Transform effects make into art of separate objects
/// ([`has_gradient_copies`], [`has_layered_copies`], [`has_transform_options`], [`copied_raster_at`]),
/// or whose live-effect plug-ins paint what they return ([`has_painted_effects`])? It is drawn,
/// baked and expanded through that art ([`reshape`]).
/// ([`has_gradient_copies`], [`has_layered_copies`], [`has_transform_options`], [`copied_raster_at`],
/// [`has_copied_row_raster`]), or whose live-effect plug-ins paint what they return
/// ([`has_painted_effects`])? It is drawn, baked and expanded through that art ([`reshape`]).
pub fn has_transform_art(n: &Node) -> bool {
has_gradient_copies(n)
|| has_layered_copies(n)
|| has_transform_options(n)
|| has_painted_effects(n)
|| (matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) && copied_raster_at(n).is_some())
|| has_copied_row_raster(n)
}
/// Is `n` a path or compound path with a fill or stroke that paints and whose raster effects are
/// carried by copies: one whose own effects list a Transform effect that makes copies after a
/// raster effect that follows it ([`copied_row_raster_at`]), or one with a raster effect that
/// follows a Transform effect ([`crate::raster::follows`]) on a path whose own Transform effect makes
/// copies ([`has_transform_copies`])? Each copy is then an object of its own carrying that fill's or
/// stroke's raster effects, moved, turned, reflected and scaled with it ([`transform_item_leaf`],
/// [`follow_copies`]).
pub fn has_copied_row_raster(n: &Node) -> bool {
if !matches!(n.kind, NodeKind::Path { guide: false, clipping: false, .. } | NodeKind::Compound { .. }) {
return false;
}
// Checked first: this runs for every object drawn.
if !n.appearance.items.iter().any(follows_row_raster) {
return false;
}
n.appearance.items.iter().any(|i| crate::paints(i) && copied_row_raster_at(i.effects()).is_some()) || has_transform_copies(n)
}
/// Does `item` paint and carry a visible raster effect that follows a Transform effect
/// ([`crate::raster::follows`])?
fn follows_row_raster(item: &AppearanceItem) -> bool {
crate::paints(item) && item.effects().iter().any(|e| e.visible && crate::raster::follows(&e.id))
}
/// Where a fill's or stroke's own effects `fx` split so that each copy of a Transform effect carries
/// the raster effects listed before it: the index of the first visible Transform effect that makes
/// copies (an earlier one that makes copies included) for which a visible raster effect that
/// follows a Transform effect ([`crate::raster::follows`]) is listed before it, every other visible
/// effect before it is a geometry effect or such a raster effect, and no Transform effect before it
/// that makes copies or moves at random holds those raster effects back
/// ([`crate::raster::held_back`]). `None` otherwise, and when a raster effect is listed after it
/// and before a later Transform effect that makes copies or moves at random, which would apply to
/// the art that raster effect paints.
fn copied_row_raster_at(fx: &[Effect]) -> Option<usize> {
let copying =
|e: &Effect| e.visible && e.id == "distort.transform" && crate::distort::transform_map(Rect::ZERO, &merged_params(&e.id, &e.params), 0).1 > 0;
// Is a visible raster effect in `rest` listed before its last Transform effect that holds back?
let raster_held = |rest: &[Effect]| {
rest.iter().rposition(crate::raster::holds_back).is_some_and(|k| rest[..k].iter().any(|e| e.visible && crate::is_raster(&e.id)))
};
(0..fx.len()).find(|&t| {
let before = &fx[..t];
copying(&fx[t])
&& !raster_held(&fx[t + 1..])
&& crate::raster::held_back(before) == 0
&& before.iter().any(|e| e.visible && crate::raster::follows(&e.id))
&& before.iter().all(|e| !e.visible || is_geometry(&e.id) || crate::raster::follows(&e.id))
})
}
/// Where the own effects of `n`, a path, compound path, type, image or symbol instance, split so
@@ -999,7 +1050,7 @@ fn as_art_opts(
}
_ => outline_art_with(symbols, paint_doc, n, symbol_art, outline, nodes, apart)?,
};
reshape_leaves_apart(&mut art, &fx, &n.appearance.effects, Budget::EFFECTS, apart, paint_doc);
reshape_leaves_apart(&mut art, &fx, &n.appearance.effects, Budget::EFFECTS, (apart, has_copied_row_raster(n)), paint_doc);
if apart {
hoist_copies(&mut art);
}
@@ -1068,7 +1119,8 @@ fn copied_raster_art(doc: Option<&Document>, n: &Node, t: usize, apart: bool, ou
}
None => {
let mut art = one_piece(&source);
let carry = reshape_leaves_apart(&mut art, &geometry_effects(&source), &source.appearance.effects, Budget::EFFECTS, apart, doc);
let rows = has_copied_row_raster(&source);
let carry = reshape_leaves_apart(&mut art, &geometry_effects(&source), &source.appearance.effects, Budget::EFFECTS, (apart, rows), doc);
if apart {
hoist_copies(&mut art);
}
@@ -1109,7 +1161,7 @@ fn copied_raster_art(doc: Option<&Document>, n: &Node, t: usize, apart: bool, ou
}
}
let later: Vec<&Effect> = rest.iter().skip(1).filter(|e| e.visible && is_geometry(&e.id)).collect();
let carry = reshape_leaves_apart(&mut art, &later, &n.appearance.effects, Budget::EFFECTS, apart, doc);
let carry = reshape_leaves_apart(&mut art, &later, &n.appearance.effects, Budget::EFFECTS, (apart, has_copied_row_raster(n)), doc);
let mut ran = n.appearance.effects.clone();
if carry.skipped() {
carry.hide_skipped(&mut ran);
@@ -1240,19 +1292,19 @@ pub(crate) fn geometry_effects(n: &Node) -> Vec<&Effect> {
/// that live-effect plug-ins painting their pieces name are looked up in `doc`, and a deferred one
/// is listed by its index in `owner`, the effect list `fx` was taken from ([`reshape_leaves_apart`]).
pub(crate) fn reshape_leaves(art: &mut Node, fx: &[&Effect], owner: &[Effect], doc: Option<&Document>) {
reshape_leaves_apart(art, fx, owner, Budget::EFFECTS, false, doc);
reshape_leaves_apart(art, fx, owner, Budget::EFFECTS, (false, false), doc);
}
/// [`reshape_leaves`], and how gradients that paint the art as a whole (a group's own fills and
/// strokes) follow the effects ([`crate::Carry`]).
pub(crate) fn reshape_leaves_carrying(art: &mut Node, fx: &[&Effect], owner: &[Effect], doc: Option<&Document>) -> crate::Carry {
reshape_leaves_apart(art, fx, owner, Budget::EFFECTS, false, doc)
reshape_leaves_apart(art, fx, owner, Budget::EFFECTS, (false, false), doc)
}
/// [`reshape_leaves_carrying`] whose paths keep to `budget` together, or to what they cost.
#[cfg(test)]
pub(crate) fn reshape_leaves_within(art: &mut Node, fx: &[&Effect], budget: Budget, doc: Option<&Document>) -> crate::Carry {
reshape_leaves_apart(art, fx, &[], budget, false, doc)
reshape_leaves_apart(art, fx, &[], budget, (false, false), doc)
}
/// `art`, the group of the one piece a path's copies are made from ([`outline_art_with`]), holding
@@ -1273,7 +1325,10 @@ fn hoist_copies(art: &mut Node) {
/// [`reshape_leaves_carrying`] whose paths keep to `budget` together, or to what they cost; with
/// `apart`, a Transform effect's copies of each path are objects
/// of their own ([`copy_leaf`]) whatever paints them, as Expand Appearance makes them. A live-effect
/// of their own ([`copy_leaf`]) whatever paints them, as Expand Appearance makes them. With `rows`,
/// so are the copies of a path with a fill or stroke whose raster effects follow a Transform effect
/// ([`crate::raster::follows`]), and each copy's fills and strokes carry those raster effects moved,
/// turned, reflected and scaled with it ([`follow_copies`]). A live-effect
/// plug-in that paints what it returns makes each path a group of its pieces ([`paint_leaf`]),
/// whose swatches and patterns must be in `doc` (without one, pieces that name one are refused).
/// Returns how gradients that paint the art as a whole follow the effects, and the Transform
@@ -1284,7 +1339,14 @@ fn hoist_copies(art: &mut Node) {
/// type and live objects in it outlined and evaluated first ([`outlined_members`]). When a mask
/// stays as it was, or a Transform effect makes fewer copies than it asks for, art with linked
/// masks keeps its shape under that effect.
fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget: Budget, apart: bool, doc: Option<&Document>) -> crate::Carry {
fn reshape_leaves_apart(
art: &mut Node,
fx: &[&Effect],
owner: &[Effect],
budget: Budget,
(apart, rows): (bool, bool),
doc: Option<&Document>,
) -> crate::Carry {
let mut whole = crate::Carry::default();
if fx.is_empty() {
return whole;
@@ -1321,7 +1383,7 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], owner: &[Effect], budget
let params = merged_params(&e.id, &e.params);
// Where a live-effect plug-in sits, which it is listed by when it is deferred.
let effect = owner.iter().position(|x| std::ptr::eq(x, *e)).or_else(|| listed.iter().position(|x| std::ptr::eq(*x, *e)));
let step = Step { e, params: &params, bounds, seed, effect, apart, doc, wholes: &wholes, held };
let step = Step { e, params: &params, bounds, seed, effect, apart, rows, doc, wholes: &wholes, held };
// Art with linked masks keeps its shape under an effect that a mask in it could not take
// as the art it masks did, so no mask is left apart from its art.
let before = masked.then(|| (art.clone(), used));
@@ -1365,6 +1427,7 @@ struct Step<'a> {
seed: u64,
effect: Option<usize>,
apart: bool,
rows: bool,
doc: Option<&'a Document>,
wholes: &'a HashMap<NodeId, bool>,
held: bool,
@@ -1529,8 +1592,12 @@ impl Step<'_> {
// make together; and Expand Appearance (`apart`) makes each copy an object.
// Fills and strokes that stack paint each copy below the one before (#5920, #6316).
// Each copy of a path with a linked mask carries the mask, moved with it.
// With `rows`, each copy carries the raster effects of its fills and strokes,
// following that copy's map.
let rows = self.rows && copies > 0 && leaf.appearance.items.iter().any(follows_row_raster);
let separate = copies > 0
&& (self.apart
|| rows
|| leaf.appearance.has_unplaced_gradient()
|| leaf.appearance.has_placed_gradient()
|| paints_copies_apart(&leaf.appearance, rule)
@@ -1538,9 +1605,12 @@ impl Step<'_> {
// The copies of a path replace it by a group of them, the path included.
let copied = |leaf: &Node| leaf.children().map_or(0, Vec::len);
if options.reach_appearance() {
let (made, moved) = transform_leaf(leaf, &path, map, copies, options, room, raster_map.is_some(), None);
let (made, moved) = transform_leaf(leaf, &path, map, copies, options, room, raster_map.is_some() || rows, None);
*used = used.minus(before).plus(made);
took |= moved;
if moved && rows {
follow_copies(leaf, map, None);
}
if moved {
// With Transform Objects off the path stays, and its mask takes the
// effect's stroke and pattern changes as its own art.
@@ -1556,6 +1626,9 @@ impl Step<'_> {
if separate {
let scaling = vectorcraft_doc::Scaling { keep_fit_when_flat: true, ..Default::default() };
let made = copy_leaf(leaf, &path, m, copies, scaling, room, None);
if rows {
follow_copies(leaf, m, None);
}
*used = used.minus(before).plus(made);
took = true;
moved_ids.insert(leaf.id);
@@ -1947,7 +2020,7 @@ fn transform_leaf(
kept: Kept,
) -> (Budget, bool) {
let mut scaling = copy_scaling(options);
if follows && copies == 0 {
if follows {
scaling.effects = options.strokes.then_some(scale_unfollowed as fn(&mut Effect, f64));
}
if !options.objects {
@@ -2263,7 +2336,8 @@ fn paint_piece(
/// Every path and compound path under `art` (other than clipping paths) with a fill or stroke whose
/// own Transform effect has Transform Patterns or Scale Strokes & Effects on
/// ([`item_transform_options`]), or whose own live-effect plug-in paints what it returns
/// ([`item_transform_options`]) or makes copies that carry the raster effects before it
/// ([`copied_row_raster_at`]), or whose own live-effect plug-in paints what it returns
/// ([`painted_plugin`]), made into a group of objects of its own ([`transform_item_leaf`]). The
/// new paths keep to one [`Budget::EFFECTS`] together (or to what `art` costs, when that is more).
/// The swatches and patterns painted pieces name must be in `doc`; without one they may name none.
@@ -2280,9 +2354,20 @@ fn makes_piece(e: &Effect) -> bool {
reaches_appearance(e) || painted_plugin(e).is_some()
}
/// Does `item` paint and carry an effect that [`makes_piece`]?
/// Where the fill's or stroke's own effects `fx` make its piece of a path an object of its own: the
/// index of the first effect that [`makes_piece`], or of the Transform effect whose copies carry the
/// raster effects before it ([`copied_row_raster_at`]), whichever is listed first.
fn piece_at(fx: &[Effect]) -> Option<usize> {
let copied = copied_row_raster_at(fx);
match fx.iter().position(makes_piece) {
Some(at) => Some(copied.map_or(at, |t| t.min(at))),
None => copied,
}
}
/// Does `item` paint and carry an effect that makes its piece an object of its own ([`piece_at`])?
fn item_makes_piece(item: &AppearanceItem) -> bool {
crate::paints(item) && item.effects().iter().any(makes_piece)
crate::paints(item) && piece_at(item.effects()).is_some()
}
/// `leaf`, a path or compound path with a fill or stroke whose own Transform effect has Transform
@@ -2292,12 +2377,17 @@ fn item_makes_piece(item: &AppearanceItem) -> bool {
/// as [`transform_leaf`] transforms an object with that effect's map, copies and options, so the
/// stroke's weight and dashes, the distances of the effects before the Transform effect and its
/// pattern follow the map, and the raster effects before it that follow it take their followed
/// values ([`follow_piece`]). The effects after it keep their values and apply to what it made
/// values ([`follow_piece`]), on each copy the values that copy's map gives them
/// ([`follow_copies`]). The effects after it keep their values and apply to what it made
/// ([`keep_listed`]), and with Transform Objects off so do the effects before it. The reference box
/// is that geometry's bounds and the seed is the leaf's id, as the renderer draws a fill's or
/// stroke's own effects. The geometry effects after the Transform effect then
/// stroke's own effects. A fill or stroke whose first such Transform effect makes copies that carry
/// the raster effects before it ([`copied_row_raster_at`]) becomes a path of its own the same way,
/// with neither option. The geometry effects after the Transform effect then
/// apply to the transformed path and its copies as one piece ([`transform_piece`]), and its other
/// effects stay on each of them. The other fills and strokes stay together on paths of the leaf's
/// effects stay on each of them, except that without either option the raster effects after a
/// Transform effect that makes copies paint once around all of them ([`lift_later_raster`]). The
/// other fills and strokes stay together on paths of the leaf's
/// geometry between them, with their own effects. `max` is the budget of the whole art and `used`
/// what it has spent.
///
@@ -2343,7 +2433,7 @@ fn transform_item_leaf(leaf: &mut Node, max: Budget, used: &mut Budget, doc: Opt
let later = |i: usize| (i + 1..transformed.len()).filter(|&j| transformed[j] || j == i + 1 || transformed[j - 1]).count();
for (i, item) in original.appearance.items.iter().enumerate() {
let fx = item.effects();
let Some(at) = fx.iter().position(makes_piece).filter(|_| crate::paints(item)) else {
let Some(at) = piece_at(fx).filter(|_| crate::paints(item)) else {
plain.push(item.clone());
continue;
};
@@ -2421,13 +2511,24 @@ fn transform_item_leaf(leaf: &mut Node, max: Budget, used: &mut Budget, doc: Opt
set_geometry(&mut p, g.clone(), rule);
let after = kept_before.len();
let keep = |k: usize| k >= after || !options.objects;
let (made, moved) = transform_leaf(&mut p, &g, map, copies, options, room, false, Some((&rest, &keep)));
*used = used.plus(made);
let from = crate::raster::held_back(before);
if moved && !held_later {
// Each copy carries the raster effects before the Transform effect, following that copy's
// map, unless a Transform effect before or after it holds them back.
let copied = copies > 0 && !held_later && from == 0;
let (made, moved) = transform_leaf(&mut p, &g, map, copies, options, room, copied, Some((&rest, &keep)));
*used = used.plus(made);
if moved && copied {
follow_copies(&mut p, map, Some(0..after));
} else if moved && !held_later {
follow_piece(&mut p, kept_before.get(from..).unwrap_or_default(), from, &fx[at]);
}
transform_piece(&mut p, (ctx.seed, i, &kept), crate::raster::held_back(&fx[..=at]), false, limit, used, doc);
// Without Transform Patterns and Scale Strokes & Effects, the raster effects after the
// Transform effect paint once around all the copies, as they paint around the one path of
// every copy.
if copies > 0 && !options.reach_appearance() {
lift_later_raster(&mut p, after);
}
pieces.push(Arc::new(p));
}
if !plain.is_empty() {
@@ -2478,6 +2579,7 @@ fn transform_piece(
count = count.max(item.effects().len());
}
});
let outer = held;
// The effects before a Transform effect among the piece's effects that makes copies or moves at
// random are held back from the Transform effects before it too.
let mut held = held;
@@ -2498,7 +2600,7 @@ fn transform_piece(
let from = held.min(j);
let mut holds = false;
let stage = vectorcraft_plugins::deferred::Stage { object: seed, effect: kept.get(j).copied().unwrap_or(j), item: Some(source) };
let at = PieceStage { j, from, seed, bounds, doc, stage };
let at = PieceStage { j, from, outer, seed, bounds, doc, stage };
// Stage `j` on `leaf`, a path `used` counts at `piece_cost` when `share`: whether `used`
// counts each path it became so, or `None` when it stays as it was.
let mut on_leaf = |leaf: &mut Node, share: bool| -> Option<Vec<bool>> {
@@ -2719,12 +2821,14 @@ thread_local! {
/// Where a stage of [`transform_piece`] runs: `j`, the index of its effect among the piece's
/// effects; `from`, the first of the effects before it whose raster effects follow a Transform
/// effect; the object's `seed`; the reference box `bounds` of all the piece's paths; the document
/// that painted pieces' swatches and patterns must be in; and the `stage` a deferred live-effect
/// plug-in is listed by.
/// effect; `outer`, how many of the piece's effects a Transform effect before them holds back; the
/// object's `seed`; the reference box `bounds` of all the piece's paths; the document that painted
/// pieces' swatches and patterns must be in; and the `stage` a deferred live-effect plug-in is
/// listed by.
struct PieceStage<'a> {
j: usize,
from: usize,
outer: usize,
seed: u64,
bounds: Rect,
doc: Option<&'a Document>,
@@ -2767,15 +2871,30 @@ fn piece_stage(leaf: &mut Node, e: &Effect, at: &PieceStage, (appearance, index)
let params = merged_params(&e.id, &e.params);
return paint_piece(leaf, &item, (appearance, index), (plugin, &params), at.bounds, room, at.doc, Some(at.stage));
}
if reaches_appearance(e) {
let copied = copies_carry(item.effects(), e, at);
if reaches_appearance(e) || copied {
let params = merged_params(&e.id, &e.params);
let (_, copies) = crate::distort::transform_map(at.bounds, &params, at.seed);
let options = crate::distort::TransformOptions::of(&params);
let map = crate::distort::transform_affine(at.bounds, &params, at.seed);
let j = at.j;
let keep = |k: usize| k > j || (k < j && !options.objects);
let (made, moved) = transform_leaf(leaf, &path, map, copies, options, room, false, Some((item.effects(), &keep)));
if moved {
let (made, moved) = transform_leaf(leaf, &path, map, copies, options, room, copied, Some((item.effects(), &keep)));
if moved && copied {
// Each copy's raster effects before the Transform effect follow that copy's map. The
// Transform effects before it have already moved them, so each run between two of
// them follows on its own.
let fx = item.effects();
let mut start = 0;
for k in 0..=j {
if k == j || fx.get(k).is_some_and(|f| f.id == "distort.transform") {
if start < k {
follow_copies(leaf, map, Some(start..k));
}
start = k + 1;
}
}
} else if moved {
follow_piece(leaf, was, at.from, e);
}
return Some(made);
@@ -2800,6 +2919,37 @@ fn piece_stage(leaf: &mut Node, e: &Effect, at: &PieceStage, (appearance, index)
Some(made)
}
/// Does Transform effect `e`, at stage `at` of [`transform_piece`] of a fill or stroke whose effects
/// are `fx`, make copies that each carry the raster effects listed before it, following that copy's
/// map ([`follow_copies`]), as the copies of the piece's first Transform effect do
/// ([`transform_item_leaf`])? It does when it makes copies with Transform Objects on, a visible
/// raster effect that follows a Transform effect ([`crate::raster::follows`]) is listed before it,
/// and no Transform effect that makes copies or moves at random holds those raster effects back:
/// none before the piece's effects, none listed before it after such a raster effect, and none
/// after it. Without Transform Patterns and Scale Strokes & Effects, every other visible effect
/// before it must also be a geometry effect or such a raster effect, and no visible raster effect
/// may be listed after it, as for [`copied_row_raster_at`].
fn copies_carry(fx: &[Effect], e: &Effect, at: &PieceStage) -> bool {
if !e.visible || e.id != "distort.transform" || at.outer > 0 {
return false;
}
let params = merged_params(&e.id, &e.params);
if !crate::distort::TransformOptions::of(&params).objects || crate::distort::transform_map(Rect::ZERO, &params, 0).1 == 0 {
return false;
}
let before = fx.get(..at.j).unwrap_or_default();
let after = fx.get(at.j + 1..).unwrap_or_default();
if crate::raster::held_back(before) > 0
|| !before.iter().any(|f| f.visible && crate::raster::follows(&f.id))
|| after.iter().any(crate::raster::holds_back)
{
return false;
}
reaches_appearance(e)
|| (before.iter().all(|f| !f.visible || is_geometry(&f.id) || crate::raster::follows(&f.id))
&& !after.iter().any(|f| f.visible && crate::is_raster(&f.id)))
}
/// Are `a` and `b` paths or compound paths that differ only in their fills and strokes?
fn same_path(a: &Node, b: &Node) -> bool {
let leaf = |n: &Node| matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. });
@@ -2872,6 +3022,52 @@ fn follow_piece(leaf: &mut Node, was: &[Effect], from: usize, t: &Effect) {
}
}
/// Make the raster effects that follow a Transform effect ([`crate::raster::follows`]) on the fills
/// and strokes of each copy [`copy_leaf`] made of `leaf` with map `m` follow that copy's map: the
/// copy `k` places below the original takes the linear part of `m` `k` times
/// ([`crate::raster::follow_contents`]), and the original, on top, keeps its effects. `range`, when
/// given, is which of each fill's or stroke's effects follow; the others keep their values.
fn follow_copies(leaf: &mut Node, m: Affine, range: Option<std::ops::Range<usize>>) {
let step = m.with_translation(vectorcraft_geom::Vec2::ZERO);
let Some(children) = leaf.children_mut() else { return };
let mut a = Affine::IDENTITY;
for c in children.iter_mut().rev().skip(1) {
a *= step;
for item in &mut Arc::make_mut(c).appearance.items {
let fx = item.effects_mut();
let fx = match &range {
Some(r) => fx.get_mut(r.clone()).unwrap_or_default(),
None => fx.as_mut_slice(),
};
crate::raster::follow_contents(fx, a, Affine::IDENTITY);
}
}
}
/// Move the raster effects from index `after` on of the fills and strokes of the paths under `p`,
/// a group of copies of one fill or stroke with the same effects, onto `p` itself, so they paint
/// once around all of the copies. The other effects stay where they are.
fn lift_later_raster(p: &mut Node, after: usize) {
if p.children().is_none() {
return;
}
let mut lifted: Option<Vec<Effect>> = None;
for_each_leaf(p, &mut |l| {
for item in &mut l.appearance.items {
let fx = item.effects_mut();
if fx.len() <= after {
continue;
}
let (raster, other): (Vec<Effect>, Vec<Effect>) = fx.split_off(after).into_iter().partition(|e| crate::is_raster(&e.id));
fx.extend(other);
lifted.get_or_insert(raster);
}
});
if let Some(raster) = lifted {
p.appearance.effects.extend(raster);
}
}
/// The bounds of each group of type's outlines under `n` ([`outline_text`]), `n` included, in
/// order. A group inside one of them is part of it.
fn type_outline_bounds(n: &Node, out: &mut Vec<Option<Rect>>) {
+2 -1
View File
@@ -1022,7 +1022,8 @@ fn art(doc: Option<&Document>, n: &Node, expand: bool) -> Option<Node> {
if let Some(b) = p.bounds()
&& let Some(mut shadow) = shadow_of(n.id, fx, &p, item, b, rule_options(fx, rule), kept).ok()?
{
shadow.appearance.effects = art.appearance.effects.clone();
// The shadow keeps its own blur (the light's Softness) below the later effects.
shadow.appearance.effects.extend(art.appearance.effects.iter().cloned());
shadows.push(Arc::new(shadow));
}
children.push(Arc::new(art));
+5 -1
View File
@@ -2207,7 +2207,11 @@ pub fn solid_art_in(doc: Option<&Document>, n: &Node) -> Option<Node> {
Arc::make_mut(&mut art).appearance.effects = later.clone();
art
};
shadows.extend(shadow.into_iter().map(with_later));
// A shadow keeps its own blur (the light's Softness) below the later effects.
shadows.extend(shadow.into_iter().map(|mut art| {
Arc::make_mut(&mut art).appearance.effects.extend(later.iter().cloned());
art
}));
children.extend(surfaces.into_iter().map(with_later));
} else {
let flat = Appearance { items: vec![item.clone()], ..Default::default() };
+17 -8
View File
@@ -1,12 +1,12 @@
//! The shadow of the 3D and Materials effects (Extrude & Bevel, Inflate, Rotate and Revolve): the
//! `shadow` switch with `shadowPosition`, `shadowDistance` and `shadowBounds`, and the shape it
//! draws behind the solids.
//! draws behind the solids, blurred by the first light's Softness.
use std::ops::Range;
use std::sync::Arc;
use serde_json::Value;
use serde_json::{Value, json};
use vectorcraft_doc::color::{BlendMode, Color, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, FillLayer, Node, NodeId};
use vectorcraft_doc::{Appearance, AppearanceItem, Effect, FillLayer, Node, NodeId};
use vectorcraft_three_d::{Shadow, ShadowCaster, ShadowPlane, ShadowPosition};
use super::Scope;
@@ -15,15 +15,21 @@ use crate::util::{flag, num, text};
/// The shadow's paint: black at this opacity. VectorCraft's own values.
const SHADOW_OPACITY: f32 = 0.5;
/// Blur radii below this, in points, leave the shadow hard-edged.
const MIN_BLUR: f64 = 0.01;
/// The shadow `p` asks for, or `None` with the switch off or when the first light lights nothing
/// (Shading is off or its intensity is 0), so that no shadow is built.
/// (Shading is off or its intensity is 0), so that no shadow is built. Its softness is the first
/// light's.
pub(crate) fn options(p: &Value) -> Option<Shadow> {
let intensity = crate::lighting::lights(p).and_then(|l| l.iter().next().map(|l| l.intensity)).unwrap_or_else(|| num(p, "lightIntensity", 80.0));
let first = crate::lighting::lights(p).and_then(|l| l.iter().next().copied());
let intensity = first.map_or_else(|| num(p, "lightIntensity", 80.0), |l| l.intensity);
let lit = flag(p, "shade", true) && intensity > 0.0;
(lit && flag(p, "shadow", false)).then(|| Shadow {
position: ShadowPosition::parse(text(p, "shadowPosition", "behind")).unwrap_or_default(),
distance: num(p, "shadowDistance", 0.0) / 100.0,
bounds: num(p, "shadowBounds", 100.0) / 100.0,
softness: first.map_or_else(|| num(p, "lightSoftness", 0.0) / 100.0, |l| l.softness),
})
}
@@ -64,8 +70,9 @@ pub(crate) fn casts(opacity: f32) -> bool {
}
/// The shadow of the faces in `caster` as a path of object `id`, cast by art in `ink`: filled
/// black at [`SHADOW_OPACITY`] times its opacity, in its blending mode, with the nonzero rule;
/// `None` when it casts nothing.
/// black at [`SHADOW_OPACITY`] times its opacity, in its blending mode, with the nonzero rule, and
/// with the light's Softness a Gaussian Blur of the plane's radius ([`ShadowPlane::blur`]), which
/// is drawn, measured, exported and expanded as that effect is; `None` when it casts nothing.
pub(crate) fn art(id: NodeId, caster: &ShadowCaster, shadow: Shadow, ink: Ink) -> Option<Node> {
let all = 0..caster.len();
let all = std::slice::from_ref(&all);
@@ -78,7 +85,9 @@ fn piece(id: NodeId, caster: &ShadowCaster, plane: &ShadowPlane, faces: &[Range<
let mut fill = FillLayer::new(Paint::solid(Color::BLACK));
fill.opacity = SHADOW_OPACITY * ink.opacity.clamp(0.0, 1.0);
fill.blend = ink.blend;
Some(Node::path(id, path, Appearance { items: vec![AppearanceItem::Fill(fill)], ..Default::default() }))
let blur = plane.blur();
let effects = if blur >= MIN_BLUR { vec![Effect { id: "blur.gaussian".into(), params: json!({"radius": blur}), visible: true }] } else { vec![] };
Some(Node::path(id, path, Appearance { items: vec![AppearanceItem::Fill(fill)], effects, ..Default::default() }))
}
/// Whether `a` and `b` are the same objects' scopes (each member holds its own copies).
+54
View File
@@ -87,6 +87,40 @@ fn the_shadow_moves_with_its_settings() {
}
}
/// The radius of the Gaussian Blur on shadow `n`; `None` without one.
fn shadow_blur(n: &Node) -> Option<f64> {
match n.appearance.effects.as_slice() {
[] => None,
[e] if e.id == "blur.gaussian" && e.visible => e.params["radius"].as_f64(),
other => panic!("unexpected effects on the shadow: {other:?}"),
}
}
/// The first light's Softness blurs the shadow, more with Softness and with Distance from Object;
/// at 0 % it stays the hard-edged path. A list of lights takes the first light's Softness.
#[test]
fn the_first_lights_softness_blurs_the_shadow() {
for id in CASTING {
let blur = |params: Value| {
let mut n = square_node(1, 0.0);
n.appearance.effects.push(crate::new_effect(id, &params).unwrap());
let lit = art(&n, id).unwrap();
let shadow = &lit.children().unwrap()[0];
assert!(is_shadow(shadow), "{id} {params}");
shadow_blur(shadow)
};
assert_eq!(blur(json!({"shadow": true})), None, "{id}: hard at 0 %");
let soft = blur(json!({"shadow": true, "lightSoftness": 50})).unwrap_or_else(|| panic!("{id}"));
let softer = blur(json!({"shadow": true, "lightSoftness": 100})).unwrap();
let far = blur(json!({"shadow": true, "lightSoftness": 100, "shadowDistance": 100})).unwrap();
assert!(soft > 0.0 && softer > soft && far > softer, "{id}: {soft} {softer} {far}");
let first = json!({"shadow": true, "lightSoftness": 0, "lights": [{"softness": 100}, {"softness": 0}]});
assert_eq!(blur(first), Some(softer), "{id}: the first light's");
let second = json!({"shadow": true, "lightSoftness": 100, "lights": [{"softness": 0}, {"softness": 100}]});
assert_eq!(blur(second), None, "{id}: only the first light casts");
}
}
#[test]
fn shadow_settings_out_of_range_or_of_the_wrong_kind_are_refused() {
for id in CASTING {
@@ -203,6 +237,26 @@ fn the_shadows_of_every_fill_go_behind_every_fill_s_solid() {
}
}
/// A fill's own 3D effect blurs its shadow by the light's Softness too, and the effects after it
/// in the fill's list follow the blur.
#[test]
fn a_fills_own_3d_effect_keeps_the_blur_below_its_later_effects() {
for id in CASTING {
for later in [None, Some(crate::new_effect("distort.roughen", &json!({})).unwrap())] {
let mut n = square_node(1, 0.0);
let fill = n.appearance.items.iter_mut().find(|i| matches!(i, AppearanceItem::Fill(_))).unwrap();
fill.effects_mut().push(crate::new_effect(id, &json!({"shadow": true, "lightSoftness": 100})).unwrap());
fill.effects_mut().extend(later.clone());
let lit = art(&n, id).unwrap_or_else(|| panic!("{id}"));
let shadow = &lit.children().unwrap()[0];
assert!(is_shadow(shadow), "{id}");
let ids: Vec<&str> = shadow.appearance.effects.iter().map(|e| e.id.as_str()).collect();
let want: Vec<&str> = std::iter::once("blur.gaussian").chain(later.as_ref().map(|e| e.id.as_str())).collect();
assert_eq!(ids, want, "{id}");
}
}
}
#[test]
fn expand_appearance_keeps_the_shadow_as_a_path() {
for id in CASTING {
+206 -3
View File
@@ -816,8 +816,8 @@ fn a_groups_transform_applies_after_its_members_own() {
}
/// An object's Transform effect transforms the raster effects of its fills and strokes with the
/// art, whatever its options: drawn, drawn through the art an option makes, and baked. One that
/// makes copies leaves them.
/// art, whatever its options: drawn, drawn through the art an option makes, and baked. For one that
/// makes copies, see [`each_copy_of_an_objects_transform_carries_its_fills_or_strokes_shadow`].
#[test]
fn an_objects_transform_moves_its_fills_shadows() {
let cases = [
@@ -825,7 +825,6 @@ fn an_objects_transform_moves_its_fills_shadows() {
(json!({"scaleH": 200, "scaleV": 100, "strokes": true}), (20.0, 10.0)),
(json!({"rotate": 90, "patterns": true}), (10.0, -10.0)),
(json!({"rotate": 90, "strokes": true}), (10.0, -10.0)),
(json!({"scaleH": 200, "scaleV": 200, "copies": 1}), (10.0, 10.0)),
];
for (params, want) in cases {
let mut n = fill_square(40, vec![shadow(10.0, 10.0, 0.0)]);
@@ -1217,6 +1216,169 @@ fn copies_past_the_budget_each_keep_their_shadow() {
assert_eq!(shadows_in(&art).len(), paths);
}
/// `n` with only its fill (or only a 4 pt blue stroke, with `stroke`), whose own effects are
/// `effects`.
fn one_row(mut n: Node, stroke: bool, effects: Vec<Effect>) -> Node {
let mut item = if stroke {
vectorcraft_doc::AppearanceItem::Stroke(vectorcraft_doc::StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 4.0))
} else {
n.appearance.items.remove(0)
};
*item.effects_mut() = effects;
n.appearance.items = vec![item];
n
}
/// A case of [`copying_cases`]: the params, each copy's offset and each copy's blur.
type CopyingCase = (Value, Vec<(f64, f64)>, Vec<f64>);
/// The cases of a Transform effect that makes copies with a drop shadow (10, 0) and a blur of 4
/// before it: the params, each copy's offset and each copy's blur, the last copy first.
fn copying_cases() -> Vec<CopyingCase> {
vec![
(json!({"moveH": 100, "copies": 2}), vec![(10.0, 0.0), (10.0, 0.0), (10.0, 0.0)], vec![4.0, 4.0, 4.0]),
// A turn of 90° counterclockwise on screen takes an offset to the right to one upward.
(json!({"rotate": 90, "copies": 2}), vec![(-10.0, 0.0), (0.0, -10.0), (10.0, 0.0)], vec![4.0, 4.0, 4.0]),
(json!({"reflectX": true, "moveH": 100, "copies": 1}), vec![(-10.0, 0.0), (10.0, 0.0)], vec![4.0, 4.0]),
(json!({"scaleH": 200, "scaleV": 200, "moveH": 100, "copies": 1}), vec![(20.0, 0.0), (10.0, 0.0)], vec![8.0, 4.0]),
// Scale Strokes & Effects does not scale the shadow a second time, nor leave it unturned.
(
json!({"scaleH": 200, "scaleV": 200, "rotate": 90, "moveH": 100, "copies": 1, "strokes": true}),
vec![(0.0, -20.0), (10.0, 0.0)],
vec![8.0, 4.0],
),
(
json!({"scaleH": 200, "scaleV": 200, "rotate": 90, "moveH": 100, "copies": 1, "patterns": true}),
vec![(0.0, -20.0), (10.0, 0.0)],
vec![8.0, 4.0],
),
]
}
/// Check that `n` is drawn, expanded and baked as `want.len()` paths, each with one shadow at the
/// offset and blur `want` and `blurs` give it, the last copy first.
fn assert_copies_carry(n: &Node, want: &[(f64, f64)], blurs: &[f64], what: &str) {
assert!(crate::has_transform_art(n), "{what}");
for (how, art) in
[("drawn", crate::reshape(None, n, None).unwrap()), ("expanded", expand_outlined(None, n, None).unwrap()), ("baked", baked(n.clone()))]
{
assert_eq!(paths_in(&art), want.len(), "{what}: {how} {art:?}");
let drawn = shadows_in(&art);
assert!(near(&drawn, want), "{what}: {how} {drawn:?}");
let b = shadow_blurs_in(&art);
assert!(b.len() == blurs.len() && b.iter().zip(blurs).all(|(x, y)| (x - y).abs() < 1e-9), "{what}: {how} blurs {b:?}");
}
}
/// A fill's or stroke's own Transform effect that makes copies gives each copy the shadow listed
/// before it in that fill's or stroke's effects, moved, turned, reflected and scaled with that copy,
/// the last copy lowest: drawn, expanded and baked. The original keeps the shadow as it is.
#[test]
fn each_copy_of_a_fills_or_strokes_own_transform_carries_the_shadow_before_it() {
for stroke in [false, true] {
for (params, want, blurs) in copying_cases() {
let n = one_row(square(95, vec![]), stroke, vec![shadow(10.0, 0.0, 4.0), transform(params.clone())]);
assert_copies_carry(&n, &want, &blurs, &format!("stroke {stroke}: {params}"));
}
// A Transform effect that makes copies before the shadow: its copies make one piece, which
// the Transform effect after the shadow copies, each copy with its own shadow.
let effects =
vec![transform(json!({"moveV": 100, "copies": 1})), shadow(10.0, 0.0, 4.0), transform(json!({"rotate": 90, "moveH": 200, "copies": 1}))];
let n = one_row(square(95, vec![]), stroke, effects);
assert!(crate::has_transform_art(&n), "stroke {stroke}");
for (how, art) in
[("drawn", crate::reshape(None, &n, None).unwrap()), ("expanded", expand_outlined(None, &n, None).unwrap()), ("baked", baked(n.clone()))]
{
let drawn = shadows_in(&art);
assert!(near(&drawn, &[(0.0, -10.0), (10.0, 0.0)]), "stroke {stroke}: two copying Transform effects, {how} {drawn:?}");
}
}
}
/// A Transform effect that makes copies, listed after a fill's or stroke's first Transform effect
/// with Transform Patterns on, gives each copy the shadow listed before it, as the first one's
/// copies do, with or without options of its own: drawn, expanded and baked.
#[test]
fn each_copy_of_a_later_copying_transform_carries_the_shadow_before_it() {
for stroke in [false, true] {
for (params, want, blurs) in copying_cases() {
let effects = vec![transform(json!({"patterns": true})), shadow(10.0, 0.0, 4.0), transform(params.clone())];
let n = one_row(square(102, vec![]), stroke, effects);
assert_copies_carry(&n, &want, &blurs, &format!("stroke {stroke}: {params}"));
}
}
}
/// A fill's or stroke's shadow under its object's Transform effect that makes copies is carried by
/// each copy, moved, turned, reflected and scaled with it: for a single fill, a single stroke, and
/// a fill and a stroke that paint each copy below the one before. Drawn, expanded and baked.
#[test]
fn each_copy_of_an_objects_transform_carries_its_fills_or_strokes_shadow() {
for (params, want, blurs) in copying_cases() {
for stroke in [false, true] {
let mut n = one_row(square(96, vec![]), stroke, vec![shadow(10.0, 0.0, 4.0)]);
n.appearance.effects = vec![transform(params.clone())];
assert_copies_carry(&n, &want, &blurs, &format!("stroke {stroke}: {params}"));
}
// Both a fill and a stroke: only the fill has the shadow.
let mut n = square(97, vec![transform(params.clone())]);
if let Some(vectorcraft_doc::AppearanceItem::Stroke(s)) = n.appearance.items.get_mut(1) {
s.paint = Paint::solid(Color::BLACK);
s.width = 2.0;
}
*n.appearance.items[0].effects_mut() = vec![shadow(10.0, 0.0, 4.0)];
assert!(crate::has_transform_art(&n), "{params}");
for (how, art) in
[("drawn", crate::reshape(None, &n, None).unwrap()), ("expanded", expand_outlined(None, &n, None).unwrap()), ("baked", baked(n.clone()))]
{
let drawn = shadows_in(&art);
assert!(near(&drawn, &want), "layered {params}: {how} {drawn:?}");
}
}
}
/// A shadow listed after a fill's own Transform effect that makes copies paints once around all of
/// them, and one listed before it on each copy. A Transform effect that makes no copies, or has
/// Transform Objects off, draws the fill as before, without art.
#[test]
fn a_fills_shadow_after_its_own_copying_transform_paints_once_around_the_copies() {
let effects = vec![shadow(10.0, 0.0, 0.0), transform(json!({"rotate": 90, "copies": 1})), shadow(0.0, 5.0, 0.0)];
let n = one_row(square(98, vec![]), false, effects);
for (how, art) in
[("drawn", crate::reshape(None, &n, None).unwrap()), ("expanded", expand_outlined(None, &n, None).unwrap()), ("baked", baked(n.clone()))]
{
assert!(near(&shadows_in(&art), &[(0.0, 5.0), (0.0, -10.0), (10.0, 0.0)]), "{how}: {:?}", shadows_in(&art));
assert_eq!(paths_in(&art), 2, "{how}");
}
for params in [json!({"rotate": 90}), json!({"rotate": 90, "copies": 1, "objects": false})] {
let n = one_row(square(99, vec![]), false, vec![shadow(10.0, 0.0, 0.0), transform(params.clone())]);
assert!(!crate::has_transform_art(&n), "{params}");
assert!(!crate::has_copied_row_raster(&n), "{params}");
}
// A shadow between two Transform effects that make copies paints on what the second one
// copies, so the fill is drawn as before, without art.
let copies = transform(json!({"rotate": 90, "copies": 1}));
let n = one_row(square(99, vec![]), false, vec![shadow(10.0, 0.0, 0.0), copies.clone(), shadow(0.0, 5.0, 0.0), copies]);
assert!(!crate::has_copied_row_raster(&n));
assert!(!crate::has_transform_art(&n));
}
/// Copies of a fill's own Transform effect that stop at the effect budget each keep their shadow,
/// and so do those of an object's Transform effect for its fill's shadow.
#[test]
fn row_copies_past_the_budget_each_keep_their_shadow() {
let copies = transform(json!({"moveV": 50, "copies": 1000}));
let own = one_row(path_node(100, wavy(30_000), vec![]), false, vec![shadow(1.0, 0.5, 0.0), copies.clone()]);
let mut owner = one_row(path_node(101, wavy(30_000), vec![]), false, vec![shadow(1.0, 0.5, 0.0)]);
owner.appearance.effects = vec![copies];
for n in [own, owner] {
let art = crate::reshape(None, &n, None).unwrap();
let paths = paths_in(&art);
assert!(paths > 1 && paths < 1001, "{paths}");
assert_eq!(shadows_in(&art).len(), paths);
}
}
/// Black 40 pt "IIII" with its baseline at (5, 60) and `effects`.
fn type_node(id: u64, effects: Vec<Effect>) -> Node {
use vectorcraft_doc::text::{CharStyle, TextObject};
@@ -1309,3 +1471,44 @@ fn type_with_a_reshaped_fill_keeps_one_shadow_around_its_copies() {
}));
assert_eq!(crate::outer_effects(&filled).len(), 2);
}
/// Type whose own fill's Transform effect makes copies is drawn as its outlines, and each copy
/// carries the shadow listed before that Transform effect, as a path's copies do: for the fill's
/// first Transform effect and for one listed after a Transform effect with Transform Patterns on.
/// Drawn, expanded and baked.
#[test]
fn type_carries_its_fills_shadow_on_each_copy() {
let filled = |mut n: Node, effects: Vec<Effect>| {
n.appearance.items.push(vectorcraft_doc::AppearanceItem::Fill(vectorcraft_doc::FillLayer {
effects,
..vectorcraft_doc::FillLayer::new(Paint::solid(Color::BLACK))
}));
n
};
let copying = vec![shadow(10.0, 0.0, 0.0), transform(json!({"moveH": 100, "copies": 1}))];
if !crate::outline_text(&type_node(95, vec![])).is_some_and(|o| paths_in(&o) > 0) {
eprintln!("type skipped: built without fonts (enable vectorcraft-text's bundled-fonts to run it)");
return;
}
let later = vec![transform(json!({"patterns": true})), shadow(10.0, 0.0, 0.0), transform(json!({"moveH": 100, "copies": 1}))];
for (what, effects) in [("first", copying), ("later", later)] {
let n = filled(type_node(95, vec![]), effects);
for (how, art) in
[("drawn", crate::reshape(None, &n, None)), ("expanded", expand_outlined(None, &n, None)), ("baked", Some(baked(n.clone())))]
{
let art = art.unwrap_or_else(|| panic!("{what}: {how}"));
assert!(near(&shadows_in(&art), &[(10.0, 0.0), (10.0, 0.0)]), "{what}: {how} {:?}", shadows_in(&art));
// The two shadows are on two objects 100 pt apart: the type and its copy.
let mut lefts = vec![];
art.walk(&mut |m| {
let lists = std::iter::once(&m.appearance.effects).chain(m.appearance.items.iter().map(|i| i.effects()));
let shadows = lists.map(|l| l.iter().filter(|e| e.id == "stylize.dropShadow").count()).sum::<usize>();
if let Some(b) = m.geometric_bounds() {
lefts.extend(std::iter::repeat_n(b.x0, shadows));
}
});
lefts.sort_by(f64::total_cmp);
assert!(lefts.len() == 2 && (lefts[1] - lefts[0] - 100.0).abs() < 1e-6, "{what}: {how} {lefts:?}");
}
}
}
+4 -1
View File
@@ -3,7 +3,8 @@
//! anchor edits, Split / Add Points at Crossings, Slide Anchor Along Path, the Corner Tool's corners
//! ([`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`]) and Tangent Circle ([`tangent_circle`]).
//! into Paths, Trim at Crossings ([`trim`]), Common Tangents ([`tangents`]) and Tangent Circle
//! ([`tangent_circle`]).
//! Its tools, panels and submenu (Object › Plug-ins › Path Precision Tools) are the tools crate's
//! and the UI's.
@@ -13,6 +14,7 @@ mod effect_tests;
mod shape;
mod shared_edge;
mod tangent_circle;
mod tangents;
#[cfg(test)]
mod tests;
mod trim;
@@ -182,6 +184,7 @@ pub fn specs() -> Vec<CommandSpec> {
v.extend(shared_edge::specs());
v.extend(trim::specs());
v.extend(tangent_circle::specs());
v.extend(tangents::specs());
v
}
@@ -0,0 +1,130 @@
//! Common Tangents (`addon.pathtools.commonTangents`): the straight lines that touch two selected
//! convex closed paths (ellipses at any rotation and scale, and convex Bézier paths) without
//! crossing into either, added as separate open paths, with the line joining their centers if
//! asked. The geometry is `vectorcraft_pathops::addons::pathtools::common_tangents`.
#[cfg(test)]
mod tests;
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{AppearanceItem, Document, LiveShape, Node, NodeId, NodeKind};
use vectorcraft_geom::kurbo::Affine;
use vectorcraft_geom::{FillRule, PathData, Point, SubPath};
use vectorcraft_pathops::addons::pathtools as pt;
use super::super::super::object::choice;
use super::super::super::{CommandSpec, bad, checked_ids_or_selection, cmd, has_selection, switch_or};
use crate::{EngineError, Result, Session};
/// The command's id.
pub const COMMON_TANGENTS: &str = "addon.pathtools.commonTangents";
/// The undo step's name.
const LABEL: &str = "Common Tangents";
/// The kinds of tangent `tangents` picks.
const KINDS: [&str; 3] = ["external", "internal", "all"];
pub(super) fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"addon.pathtools.commonTangents",
"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. 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
)]
}
/// The outline of path `id` as the geometry takes it: an exact ellipse for a whole live ellipse,
/// else the path's one closed convex subpath.
fn outline_of(d: &Document, id: NodeId) -> Result<pt::Outline> {
const C: &str = COMMON_TANGENTS;
let n = d.node(id).ok_or(EngineError::NoNode(id))?;
let NodeKind::Path { path, live, .. } = &n.kind else { return Err(bad(C, "select two closed paths")) };
let [sp] = path.subpaths.as_slice() else { return Err(bad(C, "select two closed paths")) };
if let Some(LiveShape::Ellipse { w, h, pie, xf }) = live.as_deref() {
let span = (pie.1 - pie.0).rem_euclid(360.0);
if span < 1e-9 || 360.0 - span < 1e-9 {
let unit = *xf * Affine::new([w / 2.0, 0.0, 0.0, h / 2.0, w / 2.0, h / 2.0]);
return pt::Outline::ellipse(unit).map_err(refusal);
}
}
pt::Outline::convex(sp).map_err(refusal)
}
fn refusal(e: pt::OutlineError) -> EngineError {
bad(
COMMON_TANGENTS,
match e {
pt::OutlineError::Open => "a selected path is open",
pt::OutlineError::NotConvex => "a selected path is not convex",
pt::OutlineError::Empty => "a selected path has no area",
pt::OutlineError::TooComplex => "a selected path has more than 10000 segments",
},
)
}
fn common_tangents(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = COMMON_TANGENTS;
let kinds = choice(p, C, "tangents", &KINDS)?.unwrap_or("all");
let centerline = switch_or(p, "centerline", false, C)?;
let roots = checked_ids_or_selection(s, p, C)?;
let d = &s.doc()?.doc;
let ordered = d.paint_order(roots.iter().copied());
let [first, second] = ordered.as_slice() else { return Err(bad(C, "select two closed paths")) };
let (a, b) = (outline_of(d, *first)?, outline_of(d, *second)?);
let all = pt::common_tangents(&a, &b).map_err(|_| bad(C, "the two paths have the same outline"))?;
let external = all.iter().filter(|t| t.kind == pt::TangentKind::External).count();
let keep = |t: &&pt::Tangent| match kinds {
"external" => t.kind == pt::TangentKind::External,
"internal" => t.kind == pt::TangentKind::Internal,
_ => true,
};
let kept: Vec<&pt::Tangent> = all.iter().filter(keep).collect();
let count = |kind: pt::TangentKind| kept.iter().filter(|t| t.kind == kind).count();
let (external_kept, internal_kept) = (count(pt::TangentKind::External), count(pt::TangentKind::Internal));
let lines: Vec<(Point, Point)> = kept.iter().map(|t| (t.from, t.to)).collect();
if lines.is_empty() {
// Written as `EngineError::Other` so that the i18n message scan finds them. Exactly one
// external tangent means one path lies inside the other and touches it there; paths that
// overlap without one inside the other have at least two.
let warning = match external {
0 => EngineError::Other("One path lies inside the other, so they have no common tangents".into()),
1 => EngineError::Other("One path lies inside the other, so they have no internal tangents".into()),
_ => EngineError::Other("The paths overlap, so they have no internal tangents".into()),
};
return Ok(json!({ "ids": [], "external": 0, "internal": 0, "centerline": null, "warning": warning.to_string() }));
}
let center = (centerline && (a.center() - b.center()).hypot() > 1e-9).then(|| (a.center(), b.center()));
let fill = Paint::None;
let stroke = if s.paint.stroke.is_none() { Paint::solid(Color::BLACK) } else { s.paint.stroke.clone() };
let mut look = s.new_art_look(fill, stroke, s.paint.stroke_width.max(0.1));
// The new art's look may carry more fills than the top one: none of them is kept.
look.appearance.items.retain(|i| !matches!(i, AppearanceItem::Fill(_)));
let top = *second;
let (ids, center_id) = s.edit(LABEL, |d, sel| {
let (parent, idx, _) = d.position(top).ok_or(EngineError::NoNode(top))?;
let mut ids = vec![];
let mut center_id = None;
for (k, (from, to)) in lines.iter().copied().chain(center).enumerate() {
let id = d.alloc_id();
let path = PathData::single(SubPath::polyline(&[from, to], false));
let mut n = Node::new(id, NodeKind::Path { path, rule: FillRule::NonZero, live: None, clipping: false, guide: false });
look.apply(d, &mut n);
d.insert(parent, idx + 1 + k, n)?;
if k == lines.len() {
center_id = Some(id);
}
ids.push(id);
}
sel.set(ids.iter().copied());
Ok((ids, center_id))
})?;
Ok(json!({
"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(),
"external": external_kept,
"internal": internal_kept,
"centerline": center_id.map(|i| i.0),
}))
}
@@ -0,0 +1,265 @@
//! Common Tangents: the lines for circles, turned ellipses and convex paths, the centerline,
//! the paint, one undo step, the cases with no tangent, and refused selections and params.
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{AppearanceItem, NodeId, NodeKind};
use vectorcraft_geom::{Point, Vec2};
use crate::Session;
const C: &str = super::COMMON_TANGENTS;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 600, "height": 400})).unwrap();
s
}
fn id_of(v: &Value) -> NodeId {
NodeId(v["id"].as_u64().unwrap())
}
fn circle(s: &mut Session, cx: f64, cy: f64, r: f64) -> NodeId {
id_of(&s.execute("shape.ellipse", &json!({"x": cx - r, "y": cy - r, "width": 2.0 * r, "height": 2.0 * r})).unwrap())
}
fn select(s: &mut Session, ids: &[NodeId]) {
s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap();
}
fn steps(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
/// The ends of each new line, as `ids` lists them.
fn lines(s: &Session, r: &Value) -> Vec<(Point, Point)> {
let d = &s.doc().unwrap().doc;
r["ids"]
.as_array()
.unwrap()
.iter()
.map(|v| {
let n = d.node(NodeId(v.as_u64().unwrap())).unwrap();
let NodeKind::Path { path, .. } = &n.kind else { panic!("not a path") };
assert_eq!(path.subpaths.len(), 1);
let sp = &path.subpaths[0];
assert!(!sp.closed);
assert_eq!(sp.anchors.len(), 2);
(sp.anchors[0].p, sp.anchors[1].p)
})
.collect()
}
fn near(p: Point, q: Point) -> bool {
p.distance(q) < 1e-6
}
fn has_line(found: &[(Point, Point)], p: Point, q: Point) -> bool {
found.iter().any(|(a, b)| (near(*a, p) && near(*b, q)) || (near(*a, q) && near(*b, p)))
}
#[test]
fn two_circles_get_four_tangents_at_the_exact_points_as_one_undo_step() {
let mut s = session();
let a = circle(&mut s, 100.0, 200.0, 20.0);
let b = circle(&mut s, 300.0, 200.0, 40.0);
select(&mut s, &[a, b]);
let before = steps(&s);
let r = s.execute(C, &json!({})).unwrap();
assert_eq!((r["external"].as_u64(), r["internal"].as_u64(), r["centerline"].is_null()), (Some(2), Some(2), true), "{r}");
assert_eq!(steps(&s), before + 1);
let found = lines(&s, &r);
assert_eq!(found.len(), 4);
let (c1, c2) = (Point::new(100.0, 200.0), Point::new(300.0, 200.0));
// External: (c1 - c2) · n = r2 - r1, n.x = -0.1; internal: (c1 - c2) · n = -(r1 + r2), n.x = 0.3.
for (nx, external) in [(-0.1f64, true), (0.3, false)] {
for sy in [1.0, -1.0] {
let n = Vec2::new(nx, sy * (1.0 - nx * nx).sqrt());
let far = if external { c2 + n * 40.0 } else { c2 - n * 40.0 };
assert!(has_line(&found, c1 + n * 20.0, far), "{n:?} in {found:?}");
}
}
// The lines are the selection, above the two circles.
let st = s.doc().unwrap();
assert_eq!(st.selection.objects.len(), 4);
let ids: Vec<NodeId> = r["ids"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
let order = st.doc.paint_order([a, b].into_iter().chain(ids.iter().copied()));
assert_eq!(&order[..2], &[a, b]);
s.execute("edit.undo", &json!({})).unwrap();
assert!(ids.iter().all(|id| s.doc().unwrap().doc.node(*id).is_none()), "one undo step removes them all");
}
#[test]
fn turned_ellipses_are_measured_exactly() {
let mut s = session();
let a = id_of(&s.execute("shape.ellipse", &json!({"x": 60, "y": 170, "width": 80, "height": 30})).unwrap());
select(&mut s, &[a]);
s.execute("object.rotate", &json!({"angle": 30, "origin": [100, 185]})).unwrap();
let b = id_of(&s.execute("shape.ellipse", &json!({"x": 330, "y": 120, "width": 50, "height": 120})).unwrap());
select(&mut s, &[b]);
s.execute("object.rotate", &json!({"angle": -70, "origin": [355, 180]})).unwrap();
select(&mut s, &[a, b]);
let r = s.execute(C, &json!({"tangents": "all"})).unwrap();
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(2), Some(2)), "{r}");
// Each end lies on its ellipse, where the ellipse runs along the line: turned back about the
// center, (x/rx)² + (y/ry)² = 1 and the gradient is square to the line.
let on = |p: Point, center: Point, rx: f64, ry: f64, deg: f64, dir: Vec2| {
let turn = vectorcraft_geom::kurbo::Affine::rotate(-deg.to_radians());
// `object.rotate` turns counter-clockwise on the page (y down): undo it in page terms.
let page = |v: Vec2| Vec2::new(v.x, -v.y);
let q = page((turn * page(p - center).to_point()).to_vec2());
let d = page((turn * page(dir).to_point()).to_vec2());
let value = (q.x / rx).powi(2) + (q.y / ry).powi(2);
let grad = Vec2::new(q.x / (rx * rx), q.y / (ry * ry));
(value - 1.0).abs() < 1e-9 && (grad.dot(d) / (grad.hypot() * d.hypot())).abs() < 1e-7
};
for (p, q) in lines(&s, &r) {
let dir = q - p;
assert!(on(p, Point::new(100.0, 185.0), 40.0, 15.0, 30.0, dir), "{p:?} on the first ellipse");
assert!(on(q, Point::new(355.0, 180.0), 25.0, 60.0, -70.0, dir), "{q:?} on the second ellipse");
}
}
#[test]
fn a_convex_bezier_path_and_the_centerline() {
let mut s = session();
let anchors = json!([
{"x": 0, "y": 40, "in": [0, 70], "out": [0, 10]},
{"x": 50, "y": 0, "in": [20, 0], "out": [90, 0]},
{"x": 110, "y": 50, "in": [110, 20], "out": [110, 90]},
{"x": 40, "y": 100, "in": [80, 100], "out": [10, 100]}
]);
let blob = id_of(&s.execute("path.create", &json!({"anchors": anchors, "closed": true})).unwrap());
let round = circle(&mut s, 300.0, 200.0, 30.0);
let r = s.execute(C, &json!({"ids": [blob.0, round.0], "centerline": true})).unwrap();
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(2), Some(2)), "{r}");
let found = lines(&s, &r);
assert_eq!(found.len(), 5, "four tangents and the centerline");
// The centerline is the last line and its id is given: from the blob's center of area to the
// circle's center.
assert_eq!(r["centerline"], r["ids"][4]);
let (from, to) = found[4];
assert!(near(to, Point::new(300.0, 200.0)), "{to:?}");
assert!(from.x > 30.0 && from.x < 80.0 && from.y > 30.0 && from.y < 70.0, "{from:?}");
// A tangent touches without crossing: every point of both paths is on one side of it.
let d = &s.doc().unwrap().doc;
let points = |id: NodeId| {
let sp = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
let segments: Vec<_> = (0..sp.segment_count()).map(|k| sp.segment(k)).collect();
segments.iter().flat_map(|seg| (0..200).map(|j| vectorcraft_geom::kurbo::ParamCurve::eval(seg, j as f64 / 200.0))).collect::<Vec<_>>()
};
let (pa, pb) = (points(blob), points(round));
for (p, q) in &found[..4] {
let n = Vec2::new(-(q.y - p.y), q.x - p.x).normalize();
for pts in [&pa, &pb] {
let side: Vec<f64> = pts.iter().map(|x| (*x - *p).dot(n)).collect();
let (lo, hi) = side.iter().fold((f64::MAX, f64::MIN), |(lo, hi), v| (lo.min(*v), hi.max(*v)));
// The circle is measured as an exact circle, which its four curves follow to within
// about 0.03% of the radius.
assert!(lo > -1e-2 || hi < 1e-2, "crosses: {lo} .. {hi}");
}
}
}
#[test]
fn the_lines_take_the_current_stroke_and_no_fill() {
let mut s = session();
let a = circle(&mut s, 100.0, 100.0, 20.0);
let b = circle(&mut s, 300.0, 100.0, 20.0);
s.execute("select.none", &json!({})).unwrap();
s.execute("paint.setStroke", &json!({"none": true})).unwrap();
let r = s.execute(C, &json!({"ids": [a.0, b.0], "tangents": "external"})).unwrap();
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(2), Some(0)), "{r}");
let d = &s.doc().unwrap().doc;
for v in r["ids"].as_array().unwrap() {
let n = d.node(NodeId(v.as_u64().unwrap())).unwrap();
assert!(n.appearance.fill().is_none_or(|f| f.paint.is_none()), "no fill");
let st = n.appearance.stroke().expect("stroked");
assert!(!st.paint.is_none(), "black when the stroke is None");
}
// A new-art appearance with two fills and a stroke: the lines keep the stroke and neither fill.
let mut look = vectorcraft_doc::Appearance::basic(Paint::solid(Color::BLACK), Paint::solid(Color::BLACK), 2.0);
let fill = look.items.iter().find(|i| matches!(i, AppearanceItem::Fill(_))).cloned().unwrap();
look.items.push(fill);
s.paint.appearance = Some(look);
s.paint.inherited = false;
let r2 = s.execute(C, &json!({"ids": [a.0, b.0], "tangents": "external"})).unwrap();
let d2 = &s.doc().unwrap().doc;
for v in r2["ids"].as_array().unwrap() {
let n = d2.node(NodeId(v.as_u64().unwrap())).unwrap();
assert!(!n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Fill(_))), "no fill at all");
assert!(n.appearance.stroke().is_some());
}
// Two equal circles: the external tangents run along their tops and bottoms.
assert!(has_line(&lines(&s, &r), Point::new(100.0, 80.0), Point::new(300.0, 80.0)));
assert!(has_line(&lines(&s, &r), Point::new(100.0, 120.0), Point::new(300.0, 120.0)));
}
#[test]
fn nested_and_overlapping_paths_change_nothing_and_say_why() {
let mut s = session();
let big = circle(&mut s, 200.0, 200.0, 100.0);
let small = circle(&mut s, 220.0, 200.0, 20.0);
let before = (steps(&s), s.doc().unwrap().doc.node_count());
let r = s.execute(C, &json!({"ids": [big.0, small.0]})).unwrap();
assert_eq!(r["ids"], json!([]));
assert!(r["warning"].as_str().unwrap().contains("inside the other"), "{r}");
assert_eq!((steps(&s), s.doc().unwrap().doc.node_count()), before, "nothing changes");
// Overlapping circles have external tangents only.
let a = circle(&mut s, 100.0, 100.0, 30.0);
let b = circle(&mut s, 140.0, 100.0, 30.0);
let before = (steps(&s), s.doc().unwrap().doc.node_count());
let r = s.execute(C, &json!({"ids": [a.0, b.0], "tangents": "internal"})).unwrap();
assert!(r["warning"].as_str().unwrap().contains("overlap"), "{r}");
assert_eq!((steps(&s), s.doc().unwrap().doc.node_count()), before);
let r = s.execute(C, &json!({"ids": [a.0, b.0]})).unwrap();
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(2), Some(0)), "{r}");
// Circles that touch share the tangent where they touch.
let c = circle(&mut s, 100.0, 300.0, 10.0);
let e = circle(&mut s, 130.0, 300.0, 20.0);
let r = s.execute(C, &json!({"ids": [c.0, e.0], "tangents": "internal"})).unwrap();
assert_eq!(r["internal"].as_u64(), Some(1), "{r}");
let (p, q) = lines(&s, &r)[0];
assert!((p.x - 110.0).abs() < 1e-5 && (q.x - 110.0).abs() < 1e-5 && (p.distance(q) - 20.0).abs() < 1e-5, "{p:?} {q:?}");
// A circle touching the inside of a larger one: no internal tangent, and the message says the
// one lies inside the other rather than that they overlap.
let outer = circle(&mut s, 400.0, 200.0, 50.0);
let inner = circle(&mut s, 430.0, 200.0, 20.0);
let before = (steps(&s), s.doc().unwrap().doc.node_count());
let r = s.execute(C, &json!({"ids": [outer.0, inner.0], "tangents": "internal"})).unwrap();
assert_eq!(r["ids"], json!([]));
assert!(r["warning"].as_str().unwrap().contains("inside the other, so they have no internal"), "{r}");
assert_eq!((steps(&s), s.doc().unwrap().doc.node_count()), before);
let r = s.execute(C, &json!({"ids": [outer.0, inner.0]})).unwrap();
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(1), Some(0)), "{r}");
}
#[test]
fn bad_selections_and_params_are_refused() {
let mut s = session();
let a = circle(&mut s, 100.0, 100.0, 20.0);
let b = circle(&mut s, 300.0, 100.0, 20.0);
let star = id_of(&s.execute("shape.star", &json!({"cx": 200, "cy": 300, "radius1": 40, "radius2": 15, "points": 5})).unwrap());
let open = id_of(&s.execute("path.create", &json!({"anchors": [{"x": 0, "y": 0}, {"x": 50, "y": 0}, {"x": 50, "y": 50}]})).unwrap());
let group_of = |s: &mut Session, ids: &[NodeId]| {
select(s, ids);
id_of(&s.execute("object.group", &json!({})).unwrap())
};
let before = (steps(&s), s.doc().unwrap().doc.node_count());
let err = |s: &mut Session, p: Value| s.execute(C, &p).unwrap_err().to_string();
assert!(err(&mut s, json!({"ids": [a.0, b.0], "tangents": "both"})).contains("tangents"));
assert!(err(&mut s, json!({"ids": [a.0, b.0], "tangents": 3})).contains("tangents"));
assert!(err(&mut s, json!({"ids": [a.0, b.0], "centerline": "yes"})).contains("centerline"));
assert!(err(&mut s, json!({"ids": [a.0, b.0], "which": "all"})).contains("which"), "unknown keys are refused");
assert!(err(&mut s, json!({"ids": [a.0]})).contains("select two closed paths"));
assert!(err(&mut s, json!({"ids": [a.0, b.0, star.0]})).contains("select two closed paths"));
assert!(err(&mut s, json!({"ids": [a.0, star.0]})).contains("not convex"));
assert!(err(&mut s, json!({"ids": [a.0, open.0]})).contains("open"));
assert!(s.execute(C, &json!({"ids": [a.0, a.0]})).is_err(), "the same path twice");
assert_eq!((steps(&s), s.doc().unwrap().doc.node_count()), before, "nothing changes");
let copy = id_of(&s.execute("shape.ellipse", &json!({"x": 80, "y": 80, "width": 40, "height": 40})).unwrap());
assert!(err(&mut s, json!({"ids": [a.0, copy.0]})).contains("same outline"));
let g = group_of(&mut s, &[b]);
assert!(err(&mut s, json!({"ids": [a.0, g.0]})).contains("select two closed paths"));
}
+1 -1
View File
@@ -711,7 +711,7 @@ impl Relink {
self.name(Res::ParaStyle, s);
}
}
for r in [&mut l.values_rows, &mut l.categories_rows, &mut l.legend_rows].into_iter().flatten() {
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));
}
}
+2 -2
View File
@@ -74,7 +74,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Split Path",
[],
None,
"{id, subpath?, segment, t} or {id, subpath?, anchor}: closed paths open there, open paths become two; one of the two new end points is left selected → {ids}",
"{id, subpath?, segment, t: 0–1 (0.5)} or {id, subpath?, anchor}: closed paths open there, open paths become two; one of the two new end points is left selected → {ids}. A t outside 0–1 is refused with an error, and nothing changes",
has_doc,
split
),
@@ -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: the tip's long axis counter-clockwise from level), roundness?: % (100, kept within 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 unknown mode, or a variation below 0 or past its range, is an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths lose its area, and open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths lose its area, and open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
has_doc,
erase_region
),
+10 -1
View File
@@ -196,6 +196,9 @@ pub(super) fn split(s: &mut Session, p: &Value) -> Result<Value> {
if !t.is_finite() || p.get("t").is_some_and(|v| !v.is_f64() && !v.is_i64() && !v.is_u64()) {
return Err(bad(C, "invalid t"));
}
if !(0.0..=1.0).contains(&t) {
return Err(bad(C, "`t` must be from 0 to 1"));
}
let ids = s.edit("Split Path", |d, sel| {
let path = path_mut(d, id)?;
let mut sp = path.subpaths.get(si).cloned().ok_or_else(|| EngineError::Other("no such subpath".into()))?;
@@ -295,7 +298,13 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
let samples = samples_param(p, "points", C)?;
let size = ranged(p, "size", 10.0, SIZES, C)?;
let angle = number_or(p, "angle", 0.0, C)?;
if !(-180.0..=180.0).contains(&angle) {
return Err(bad(C, "`angle` must be from -180 to 180 degrees"));
}
let roundness = number_or(p, "roundness", 100.0, C)?;
if !(1.0..=100.0).contains(&roundness) {
return Err(bad(C, "`roundness` must be from 1 to 100%"));
}
let vary = eraser_variations(p, C)?;
if varies_beyond_size_pressure(&vary) {
return erase_varied(s, &samples, [angle, roundness, size], vary);
@@ -305,7 +314,7 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
let r = size / 2.0;
// The tip's short axis (its narrowest with Pressure): an open path is sampled at least every half of it.
let narrowest = pressure.as_ref().map_or(size, |(_, v)| vectorcraft_tools::draw2::pressure_size(size, *v, 0.0));
let short = narrowest * roundness.clamp(1.0, 100.0) / 100.0;
let short = narrowest * roundness / 100.0;
let st = s.doc()?;
// A point is under the tip when, with the tip squashed back into a circle, it is within the
// circle's radius of the squashed drag.
+24
View File
@@ -1089,6 +1089,27 @@ fn expand_pieces(
expanded
}
/// `m`, the art a 3D effect expanded into, with each object in it that has effects of its own (a
/// shadow blurred by the light's Softness) expanded as Expand Appearance expands it on its own:
/// a blurred shadow becomes an image. Groups in `m` without effects that hold such an object are
/// looked into; the rest are left as they are. The objects `skip` lists are not expanded.
fn expand_raster_pieces(d: &mut Document, mut m: Node, brushes: &[vectorcraft_brush::Brush], skip: &[NodeId], raster: &mut RasterBudget) -> Node {
for c in m.children_mut().into_iter().flatten() {
if !c.appearance.effects.is_empty() {
if let Some(e) = expanded_node(d, (**c).clone(), brushes, skip, &mut vec![], raster) {
*c = Arc::new(e);
}
} else if c.children().is_some() {
let mut holds = false;
c.walk(&mut |n| holds |= !n.appearance.effects.is_empty());
if holds {
*c = Arc::new(expand_raster_pieces(d, (**c).clone(), brushes, skip, raster));
}
}
}
m
}
/// Replace each symbol instance in `m`, art an instance placed (`depth` instances deep), whose
/// active fill or stroke has a geometry or raster effect ([`effects::has_item_geometry`],
/// [`effects::has_instance_row_raster`]) by its art ([`expanded_instance`]), and the instances in
@@ -1353,6 +1374,9 @@ fn expanded_node(
m
})
};
// A 3D effect's shadow blurred by the light's Softness keeps its blur in the art: it
// expands in turn, to an image.
let m = if effects::has_solid(&v) || effects::has_revolve(&v) { m.map(|m| expand_raster_pieces(d, m, brushes, skip, raster)) } else { m };
match image {
Some((image, _)) => {
let mut m = m.unwrap_or(v);
+43
View File
@@ -1017,6 +1017,49 @@ fn a_3d_shadow_is_one_undo_step_saved_exported_and_expanded() {
assert_eq!(shadows, 1);
}
/// With the light's Softness, the 3D shadow is blurred: the canvas paints past the hard shadow's
/// edge, the object's bounds take the blur in, SVG export blurs it as it does a Gaussian Blur
/// effect, and Expand Appearance keeps it as an image with no live effect left.
#[test]
fn a_soft_3d_shadow_is_drawn_measured_exported_and_expanded_blurred() {
let (mut s, id) = session_with_rect();
s.execute("effect.apply", &json!({"effect": effects::EXTRUDE, "ids": [id.0], "item": null})).unwrap();
let set = |s: &mut Session, params: serde_json::Value| {
s.execute("effect.setParams", &json!({"ids": [id.0], "index": 0, "item": null, "params": params})).unwrap();
};
let draw = |s: &Session| {
vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 400, 400, vectorcraft_geom::Affine::IDENTITY, &Default::default()).pixels
};
let bounds = |s: &Session| {
let doc = &s.doc().unwrap().doc;
vectorcraft_render::effect_bounds(&doc.symbol_boxes(), doc.node(id).unwrap()).unwrap()
};
let blurs = |s: &mut Session| {
let svg = s.execute("document.serialize", &json!({"format": "svg"})).unwrap();
let svg = svg["data"].as_str().or_else(|| svg["text"].as_str()).map(str::to_string).unwrap_or_else(|| svg.to_string());
svg.matches("<feGaussianBlur").count()
};
let none = draw(&s);
set(&mut s, json!({"shadow": true, "shadowDistance": 50}));
let (hard, hard_bounds, hard_blurs) = (draw(&s), bounds(&s), blurs(&mut s));
let undo = s.doc().unwrap().history.undo.len();
set(&mut s, json!({"lightSoftness": 100}));
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
let (soft, soft_bounds) = (draw(&s), bounds(&s));
// Pixels the hard shadow leaves as they are, the soft one paints.
let spread = none.chunks(4).zip(hard.chunks(4)).zip(soft.chunks(4)).filter(|((n, h), s)| n == h && n != s).count();
assert!(spread > 100, "{spread}");
assert!(soft_bounds.contains_rect(hard_bounds) && soft_bounds.area() > hard_bounds.area(), "{hard_bounds:?} {soft_bounds:?}");
assert_eq!(blurs(&mut s), hard_blurs + 1, "SVG export blurs the shadow as a Gaussian Blur effect");
s.execute("effect.expandAppearance", &json!({"ids": [id.0]})).unwrap();
let (mut live, mut pictures) = (0, 0);
s.doc().unwrap().doc.walk(|n| {
live += usize::from(!n.appearance.effects.is_empty() || n.appearance.items.iter().any(|i| !i.effects().is_empty()));
pictures += usize::from(matches!(n.kind, NodeKind::Image(_)));
});
assert_eq!((live, pictures), (0, 1), "the blurred shadow expands to an image");
}
/// Radial Blur's Blur Center: stored as given, drawn about that point of the object's bounds, and
/// a value outside 0 to 1 (or not a number) is refused with nothing changed and no undo step.
#[test]
+1 -1
View File
@@ -129,9 +129,9 @@ mod commands;
mod export_names;
mod formats;
pub(crate) use access::check_images_in;
#[cfg(not(target_arch = "wasm32"))]
pub(crate) use access::list_dir;
pub(crate) use access::{check_images_in, check_scripts_of};
pub use access::{check_linked_images, check_linked_scripts, write_file_with, write_save_file, write_save_file_with};
#[cfg(all(test, not(target_arch = "wasm32")))]
+43 -11
View File
@@ -121,22 +121,54 @@ pub(crate) fn naming_in_message(msg: &str, path: &str, name: &str) -> String {
out
}
/// The error for an SVG of a document that links a JavaScript file outside the read roots.
/// The error for a file that would name a JavaScript file the document links outside the read roots.
pub(crate) const SCRIPT_OUTSIDE: &str = "a linked JavaScript file is outside the read roots";
/// `cmd` may write `st`'s document in format `format` (a format id): any format but SVG and SVGZ,
/// and those too unless read roots are in force and the document links a JavaScript file outside
/// them (`svg_scripts`, a relative path taken from the document's folder; a URL is not checked),
/// which the file's `<script>` element would name. The error names no file or folder.
pub fn check_linked_scripts(cmd: &str, format: &str, st: &crate::DocState) -> Result<()> {
if !matches!(format, "svg" | "svgz") || crate::file_access::current().is_none() {
/// `cmd` may write `st`'s document in format `format` (a format id) with options `p` (presets
/// written out): always, unless read roots are in force, the document links a JavaScript file
/// outside them (`svg_scripts`, a relative path taken from the document's folder; a URL is not
/// checked) and the file names it ([`names_linked_scripts`], with the artboards `p` picks counted
/// in `st`'s document): an SVG's `<script>` element, or the native document that a native file, a
/// `.ai` file, an EPS file or a PDF with Preserve Editing carries. The error names no file or folder.
pub fn check_linked_scripts(cmd: &str, format: &str, st: &crate::DocState, p: &Value) -> Result<()> {
check_scripts_of(cmd, &st.doc, st.path.as_deref(), || names_linked_scripts(cmd, format, p, st.doc.artboards.len()))
}
/// `doc`, saved at `doc_path`, may be written by `cmd` in a file that names its linked JavaScript
/// files when `names` says so: as [`check_linked_scripts`] allows it.
pub(crate) fn check_scripts_of(cmd: &str, doc: &vectorcraft_doc::Document, doc_path: Option<&str>, names: impl FnOnce() -> bool) -> Result<()> {
if crate::file_access::current().is_none() || !doc.svg_scripts.iter().any(|f| crate::cmd::links::script_hidden(f, doc_path)) || !names() {
return Ok(());
}
let doc_path = st.path.as_deref();
if st.doc.svg_scripts.iter().any(|f| crate::cmd::links::script_hidden(f, doc_path)) {
return Err(bad(cmd, SCRIPT_OUTSIDE));
Err(bad(cmd, SCRIPT_OUTSIDE))
}
/// Does a file of a document with `artboards` artboards, written in format `format` with options
/// `p`, name the JavaScript files the document links? SVG, SVGZ, native files, native templates and
/// EPS files always do. A `.ai` or `.ait` file does unless it is a legacy version 7 `.ai` file or `p`
/// picks only some of the artboards; a PDF does with Preserve Editing on (as its preset, standard and
/// options leave it) unless `p` picks only some of the artboards. Neither a `.ai` file nor a PDF
/// does when `useArtboards` is false in `p` (one page, the bounds of the art). Options the encoder
/// refuses count as naming them.
pub(crate) fn names_linked_scripts(cmd: &str, format: &str, p: &Value, artboards: usize) -> bool {
use serde::Deserialize;
let every_artboard = || {
let pick = if p.is_object() { super::ArtboardPick::deserialize(p).ok() } else { Some(super::ArtboardPick::default()) };
pick.and_then(|pick| pick.resolve(artboards).ok()).is_none_or(|v| v.is_none_or(|v| v.iter().copied().eq(0..artboards)))
};
let art_page = || super::encode::use_artboards(cmd, p).is_ok_and(|u| u == Some(false));
match format {
"svg" | "svgz" | "vectorcraft" | "template" | "eps" => true,
"ai" | "ait" => {
let legacy = super::format(format).is_some_and(|f| super::legacy_ai::wanted(cmd, f, p).unwrap_or(false));
!legacy && !(format == "ai" && art_page()) && every_artboard()
}
"pdf" => {
let editing = super::pdf::settings(cmd, p).ok().is_none_or(|s| s.preserve_editing);
editing && !art_page() && every_artboard()
}
_ => false,
}
Ok(())
}
/// The error for an SVG that would name a linked image's file outside the read roots.
+4 -4
View File
@@ -27,7 +27,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Serialize Document",
[],
None,
"{format?: vectorcraft (default)|template|svg|svgz|pdf|ai|png|jpg|webp|gif|png8|txt|dxf|eps|emf|wmf|hpgl|tiff|bmp|tga|psd (ait, a .ait template, is written by file.saveAsTemplate), …the format's options (see document.formats; SVG ones also as svg: {…}), selectedOnly?: false (the selected objects alone, in the layers and groups that hold them; an object of a blend, envelope, repeat or intertwine on its own)} → {text, warnings} for svg (plus dataBase64, the file, when its encoding isn't UTF-8), else {dataBase64, warnings}; an SVG of several artboards also gives files: [{name, text}], linked images linked: [{name, dataBase64}]. A key no format takes, and an unknown key inside a PDF or EPS option's object, are refused; a key only another format takes is not used, and warnings name it. Under automation read roots, svg and svgz are refused while the document links a JavaScript file outside them (svgInteractivity; a URL is not checked), or while the file would name a linked image's file outside them (images: link, preserveEditing, or an image whose pixels the document doesn't hold; a URL is not checked)",
"{format?: vectorcraft (default)|template|svg|svgz|pdf|ai|png|jpg|webp|gif|png8|txt|dxf|eps|emf|wmf|hpgl|tiff|bmp|tga|psd (ait, a .ait template, is written by file.saveAsTemplate), …the format's options (see document.formats; SVG ones also as svg: {…}), selectedOnly?: false (the selected objects alone, in the layers and groups that hold them; an object of a blend, envelope, repeat or intertwine on its own)} → {text, warnings} for svg (plus dataBase64, the file, when its encoding isn't UTF-8), else {dataBase64, warnings}; an SVG of several artboards also gives files: [{name, text}], linked images linked: [{name, dataBase64}]. A key no format takes, and an unknown key inside a PDF or EPS option's object, are refused; a key only another format takes is not used, and warnings name it. Under automation read roots, svg and svgz, and the files that carry the native document (vectorcraft, template, eps, ai of every artboard with useArtboards not false but a version 7 file, pdf of every artboard with preserveEditing on and useArtboards not false), are refused while the document links a JavaScript file outside them (svgInteractivity; a URL is not checked), or while the file would name a linked image's file outside them (images: link, preserveEditing, or an image whose pixels the document doesn't hold; a URL is not checked)",
has_doc,
export::serialize
),
@@ -36,7 +36,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export Document",
[],
None,
"{path?, format?: svg|svgz|pdf|ai|png|jpg|webp|gif|png8|txt|dxf|eps|emf|wmf|hpgl|tiff|bmp|tga|psd|vectorcraft|template (default: from the path's extension, else png; png8 writes an indexed .png; ait, a .ait template, is written by file.saveAsTemplate; an exporter plug-in's format is plugin.<plug-in id>, which an extension only it lists picks too), params?: {…} (an exporter plug-in's parameters; missing ones take their defaults, see plugin.info), selectedOnly?: false (the selected objects alone, in the layers and groups that hold them; an object of a blend, envelope, repeat or intertwine on its own), includeArtboardFill?: true (raster, PDF, SVG and EPS draw each exported artboard's background color behind its art, a transparent background too; false leaves it out), artboard?: 0, artboards?: [i…], rect?: [x, y, width, height] (raster formats: that area of the page in points, y down, instead of an artboard; not with artboard, artboards, range or useArtboards), range?: \"1-3, 5\" | \"all\" (1-based; PDF and .ai write one page per artboard, default all; SVG writes one file per artboard, {stem}-{artboard}.svg; raster formats write one artboard), useArtboards?: true (raster: one file per chosen artboard, default all, {stem}-{artboard}.{ext}; pdf/ai: every page) | false (pdf/ai/raster: the bounds of the visible art; pdf/ai: of the layers the file draws, without editing data, with a warning, and ai refuses pdfCompatible: false; SVG has it as an SVG option), ppi?: number (raster formats: pixels per inch, stored in the file; wins over scale; without either, the document's raster effects resolution), scale?: number (pixels per point), background?: transparent|white|black|\"#rrggbb\" (jpg: white when transparent; #rrggbbaa and #rgba are refused here and in matte), antiAlias?: none|art (default)|type (text snapped to pixels), interlaced?: false (png, Adam7), embedIcc?: true (png: an sRGB chunk marks the colours as sRGB), quality?: 90 (jpg: 0–100), colorModel?: rgb|cmyk|gray (jpg), method?: baseline|optimized|progressive, scans?: 3 (3–5, progressive), embedIcc?: true, imageMap?: none|client|server (an HTML or NCSA map of the objects with a URL, written as <stem>.html / <stem>.map), colors?: 256 (gif/png8: 2–256), reduction?: perceptual|selective (default)|adaptive|web|blackWhite|gray, dither?: none|diffusion (default)|pattern|noise, ditherAmount?: 100, transparency?: true, matte?: white|\"#rrggbb\"|none, interlaced?, lossless?: true (webp: lossy WebP isn't available yet: written lossless, with a warning), encoding?: utf8|utf16 (txt: the stories in stacking order, back to front, a thread once; utf16 with a byte order mark), lineEndings?: lf|crlf, selectionOnly?: false, svg?: {styling, outlineText, images, objectIds, decimals, minify, responsive, useArtboards, preserveEditing, metadata, fewerTspans, hiddenLayers, encoding, profile, embedFonts, variableData} (see document.formats), …the SVG options given flat instead, …the PDF options of document.exportPdf, …the DXF options of document.exportDxf (useArtboards: one drawing per artboard), …the EPS options of document.exportEps (useArtboards: one file per artboard, {stem}_{artboard}.eps, after a central {stem}.eps of the whole document when there are two or more and art shows; else the visible art), …emf and wmf write one picture of the artboard (useArtboards: true one file per chosen artboard, false the bounds of the visible art; EMF keeps curves, clipping, transparent images and gradients as images clipped to their shape; WMF flattens curves into polygons behind a placeable header; what a format leaves out comes back in warnings), …hpgl writes a plot of the artboard as pen moves for plotters and cutters (each visible path once along its line in plotter units; useArtboards: true one file per chosen artboard, false the bounds of the art it plots, without placed images, unpainted paths and art at 0% opacity), hpglVersion?: hpgl (default: IN, SP, PU, PD) | hpgl2 (also NP and PC pen colors, each pen's paths as one encoded polyline PE), curveTolerance?: 0.1 (points, 0.01 to 10), pens?: [\"#rrggbb\"…] (pen 1 first, up to 255; each path takes the nearest; default a pen per color in the order the art first draws in it, numbered alike in every file), origin?: bottomLeft (default) | center, sortPaths?: false (each pen's next path the nearest), insideFirst?: false (a path after the pen's paths that lie inside it), colorModel?: rgb|cmyk|gray (tiff: rgb keeps transparency as an alpha channel), lzw?: true, byteOrder?: little|big, embedIcc?: true, colorModel?: rgb|gray (bmp), depth?: 24 (bmp: 1 black and white, 4|8 a palette by reduction and dither, 16, 24, 32 with alpha), fileFormat?: windows|os2 (1, 4, 8 or 24 bits), rle?: false (4 and 8 bits, windows), flipRows?: false (top-down rows), depth?: 24 (tga: 16 one-bit alpha, 24, 32 with alpha), colorModel?: rgb|cmyk|gray (psd), layers?: true (each top-level layer a pixel layer with its opacity and blend mod Line truncated
"{path?, format?: svg|svgz|pdf|ai|png|jpg|webp|gif|png8|txt|dxf|eps|emf|wmf|hpgl|tiff|bmp|tga|psd|vectorcraft|template (default: from the path's extension, else png; png8 writes an indexed .png; ait, a .ait template, is written by file.saveAsTemplate; an exporter plug-in's format is plugin.<plug-in id>, which an extension only it lists picks too), params?: {…} (an exporter plug-in's parameters; missing ones take their defaults, see plugin.info), selectedOnly?: false (the selected objects alone, in the layers and groups that hold them; an object of a blend, envelope, repeat or intertwine on its own), includeArtboardFill?: true (raster, PDF, SVG and EPS draw each exported artboard's background color behind its art, a transparent background too; false leaves it out), artboard?: 0, artboards?: [i…], rect?: [x, y, width, height] (raster formats: that area of the page in points, y down, instead of an artboard; not with artboard, artboards, range or useArtboards), range?: \"1-3, 5\" | \"all\" (1-based; PDF and .ai write one page per artboard, default all; SVG writes one file per artboard, {stem}-{artboard}.svg; raster formats write one artboard), useArtboards?: true (raster: one file per chosen artboard, default all, {stem}-{artboard}.{ext}; pdf/ai: every page) | false (pdf/ai/raster: the bounds of the visible art; pdf/ai: of the layers the file draws, without editing data, with a warning, and ai refuses pdfCompatible: false; SVG has it as an SVG option), ppi?: number (raster formats: pixels per inch, stored in the file; wins over scale; without either, the document's raster effects resolution), scale?: number (pixels per point), background?: transparent|white|black|\"#rrggbb\" (jpg: white when transparent; #rrggbbaa and #rgba are refused here and in matte), antiAlias?: none|art (default)|type (text snapped to pixels), interlaced?: false (png, Adam7), embedIcc?: true (png: an sRGB chunk marks the colours as sRGB), quality?: 90 (jpg: 0–100), colorModel?: rgb|cmyk|gray (jpg), method?: baseline|optimized|progressive, scans?: 3 (3–5, progressive), embedIcc?: true, imageMap?: none|client|server (an HTML or NCSA map of the objects with a URL, written as <stem>.html / <stem>.map), colors?: 256 (gif/png8: 2–256), reduction?: perceptual|selective (default)|adaptive|web|blackWhite|gray, dither?: none|diffusion (default)|pattern|noise, ditherAmount?: 100, transparency?: true, matte?: white|\"#rrggbb\"|none, interlaced?, lossless?: true (webp: lossy WebP isn't available yet: written lossless, with a warning), encoding?: utf8|utf16 (txt: the stories in stacking order, back to front, a thread once; utf16 with a byte order mark), lineEndings?: lf|crlf, selectionOnly?: false, svg?: {styling, outlineText, images, objectIds, decimals, minify, responsive, useArtboards, preserveEditing, metadata, fewerTspans, hiddenLayers, encoding, profile, embedFonts, variableData} (see document.formats), …the SVG options given flat instead, …the PDF options of document.exportPdf, …the DXF options of document.exportDxf (useArtboards: one drawing per artboard), …the EPS options of document.exportEps (useArtboards: one file per artboard, {stem}_{artboard}.eps, after a central {stem}.eps of the whole document when there are two or more and art shows; else the visible art), …emf and wmf write one picture of the artboard (useArtboards: true one file per chosen artboard, false the bounds of the visible art; EMF keeps curves, clipping, transparent images and gradients as images clipped to their shape; WMF flattens curves into polygons behind a placeable header; what a format leaves out comes back in warnings), …hpgl writes a plot of the artboard as pen moves for plotters and cutters (each visible path once along its line in plotter units; useArtboards: true one file per chosen artboard, false the bounds of the art it plots, without placed images, unpainted paths and art at 0% opacity), hpglVersion?: hpgl (default: IN, SP, PU, PD) | hpgl2 (also NP and PC pen colors, each pen's paths as one encoded polyline PE), curveTolerance?: 0.1 (points, 0.01 to 10), pens?: [\"#rrggbb\"…] (pen 1 first, up to 255; each path takes the nearest; default a pen per color in the order the art first draws in it, numbered alike in every file), origin?: bottomLeft (default) | center, sortPaths?: false (each pen's next path the nearest), insideFirst?: false (a path after the pen's paths that lie inside it), colorModel?: rgb|cmyk|gray (tiff: rgb keeps transparency as an alpha channel), lzw?: true, byteOrder?: little|big, embedIcc?: true, colorModel?: rgb|gray (bmp), depth?: 24 (bmp: 1 black and white, 4|8 a palette by reduction and dither, 16, 24, 32 with alpha), fileFormat?: windows|os2 (1, 4, 8 or 24 bits), rle?: false (4 and 8 bits, windows), flipRows?: false (top-down rows), depth?: 24 (tga: 16 one-bit alpha, 24, 32 with alpha), colorModel?: rgb|cmyk|gray (psd), layers?: true (each top-level layer a pixel layer with its opacity and blend mod Line truncated
has_doc,
export::export
),
@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export Selection…",
["File"],
None,
"{path?, format?: png|jpg|webp|svg|svgz|pdf|ai|gif|png8|tiff|bmp|tga|psd|txt|dxf|eps|emf|wmf|hpgl|vectorcraft|template (default: from the extension, else png), ppi?: number (raster formats: pixels per inch, stored in the file; wins over scale; without either, the document's raster effects resolution), scale?: number (pixels per point), …the format's options} the selected objects (template layers left out), each in the layers and groups that hold it, whose clipping paths, opacity masks, effects, opacity and blend modes apply as on the canvas (an object of a blend, envelope, repeat or intertwine on its own; txt: the selected type alone), cropped to the bounds the renderer measures for that art (a clip group by its clip) → {path, format, bytes, warnings, bounds} (no path → {dataBase64, format, bytes, warnings, bounds}); warnings say what the format approximated or left out, as for document.export. A key no format takes, and an unknown key inside a PDF or EPS option's object, are refused; a key only another format takes is not used, and warnings name it. Under automation read roots, svg and svgz are refused while the document links a JavaScript file outside them, or while the file would name a linked image's file outside them (an image among the selected objects), as document.export refuses them. In the app, with no params or {}, the save panel picks the file and its format's options dialog follows (Save PDF, SVG Options, the raster options, EPS Options, DXF Options, Text Export Options or an exporter plug-in's parameters; other formats are written at once), whose OK writes the selection: the call returns null while the dialog is open, and OK returns what file.exportAs returns, without format or bounds (Text Export Options: {path})",
"{path?, format?: png|jpg|webp|svg|svgz|pdf|ai|gif|png8|tiff|bmp|tga|psd|txt|dxf|eps|emf|wmf|hpgl|vectorcraft|template (default: from the extension, else png), ppi?: number (raster formats: pixels per inch, stored in the file; wins over scale; without either, the document's raster effects resolution), scale?: number (pixels per point), …the format's options} the selected objects (template layers left out), each in the layers and groups that hold it, whose clipping paths, opacity masks, effects, opacity and blend modes apply as on the canvas (an object of a blend, envelope, repeat or intertwine on its own; txt: the selected type alone), cropped to the bounds the renderer measures for that art (a clip group by its clip) → {path, format, bytes, warnings, bounds} (no path → {dataBase64, format, bytes, warnings, bounds}); warnings say what the format approximated or left out, as for document.export. A key no format takes, and an unknown key inside a PDF or EPS option's object, are refused; a key only another format takes is not used, and warnings name it. Under automation read roots, svg, svgz and the files that carry the native document are refused while the document links a JavaScript file outside them, or while the file would name a linked image's file outside them (an image among the selected objects), as document.export refuses them. In the app, with no params or {}, the save panel picks the file and its format's options dialog follows (Save PDF, SVG Options, the raster options, EPS Options, DXF Options, Text Export Options or an exporter plug-in's parameters; other formats are written at once), whose OK writes the selection: the call returns null while the dialog is open, and OK returns what file.exportAs returns, without format or bounds (Text Export Options: {path})",
has_selection,
export::export_selection
),
@@ -54,7 +54,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export for Screens",
["File", "Export"],
None,
"{folder?, zip?: false (one .zip of every file, each deflated or stored, whichever is smaller: no folder → {name, dataBase64, bytes, files: [name…]}; with a folder it is written there → {path, bytes, files}), artboard?: index | artboards?: [index…] | range?: \"1-3\" (default all), assets?: [asset id…] (instead of artboards: each asset's art alone, cropped to its bounds and named after the asset; see assets.list), layers?: [layer id…] (instead of artboards: each layer's art alone, sublayers included, named after the layer), selection?: one|each (instead of artboards: the selected art as one file, or a file per selected object, named after it), fullDocument?: false (one file per format instead: a PDF of every artboard, other formats the bounds of all visible art, named after the document), includeBleed?: false (artboards grown by the document's bleed), includeArtboardFill?: true (Include Artboard Fill: each artboard's background color behind its art; false leaves it out), pdfs?: multiple|single (Export PDFs As: with several artboards, single writes them as the pages of one PDF per PDF row, named after the document), exportPreset?: (a preset of document.exportPresets.list: its settings, under these params), subfolders?: false (each row's files in a sub-folder: its folder, else its size for raster (1x, 2x, 100w…) or its format (SVG, PDF)), folders?: none|rows (as subfolders)|format (a folder per extension: png, svg, pdf…)|item (a folder per artboard, asset, layer or object)|itemFormat (item/extension) (default: rows with subfolders or a preset, else none), name?: (a file name pattern instead of the item's name, with <filename> for the document, <name> for the artboard, asset, layer or object, <index> from 1, #### for the counter zero-padded to the run of #, <format>, <scale>, <suffix> (else the row's suffix ends the name), YYYYMMDD, YYYY-MM-DD, YYYY, <date>, <time>, <YYYY>, <MM>, <DD>, <hh>, <mm> and <ss>; a trailing .ext is dropped, as in `COMPANY-Logo-<filename>-####-YYYYMMDD`; different files it names alike get -2, -3…), counterStart?: 1, counterPer?: item (every file of an item has its number)|file, date?: YYYY-MM-DD (the date the pattern uses; default today, UTC), preset?: mobile (PNG 1x, 2x, 3x) | density (PNG 0.75x–4x in ldpi…xxxhdpi sub-folders) instead of formats (turns subfolders on), formats?: [{format: png|png8|jpg|webp|gif|tiff|bmp|tga|psd|svg|svgz|pdf|eps|ai|vectorcraft, scale?: 1 | \"2x\" | \"100w\" | \"100h\" | \"72ppi\", width?: px | height?: px | ppi? (raster only; width, then height, then ppi win over scale), suffix?: (raster default: @2x, @100w, @100h, none at 1x; vector formats drop size suffixes), folder?: (its sub-folder), quality?: (jpg 0–100), …the format's options (antiAlias, background, preset (pdf)…)}], settings?: {png|png8|jpg|webp|gif|tiff|bmp|tga|psd|svg|svgz|pdf|eps|ai|vectorcraft: {…options for every row of that format}} (rows' own options win), prefix?, antiAlias?: none|art|type (raster rows without their own), openLocation?: (remembered; the app shows the files after exporting)} one file per artboard and format (a PDF holds its artboard alone; artboards with the same name, in any case, get -2, -3…; an unnamed one is Artboard-N; a row whose file would take a name another row's file has, in any case, gets -2, -3… too, and identical rows write one file; row folders that differ only in case are one folder, spelled as the first row spells it) → {files: [path…]} (into the folder of exportPreset, outside the automation read roots: no ZIP path, and files relative to that folder); no folder → {files: [{name, dataBase64}]} (names include sub-folders: 2x/Icon@2x.png); every reply has warnings: [the encoders' warnings for the files, each once: an image that couldn't be decoded, type written in the fallback font…]. eps, ai and vectorcraft rows write a document of the item alone (its one artboard). The params (but zip and assets) are remembered in the document (document.exportSettings; not an undo step). A key it doesn't take, a key no format takes in a format row or in settings, settings for a format it doesn't write, and an unknown key inside a PDF, EPS or SVG option's object, are refused; a key only another format takes in a row or in settings is not used, and warnings name it as given (formats[0].quality; a key in settings only when no row of that format reads it; not a key of an exportPreset). Under automation read roots, an svg or svgz row is refused, before the folder is made or any file is written, while the document links a JavaScript file outside them, or while the row's file would name a linked image's file outside them, as document.export refuses it",
"{folder?, zip?: false (one .zip of every file, each deflated or stored, whichever is smaller: no folder → {name, dataBase64, bytes, files: [name…]}; with a folder it is written there → {path, bytes, files}), artboard?: index | artboards?: [index…] | range?: \"1-3\" (default all), assets?: [asset id…] (instead of artboards: each asset's art alone, cropped to its bounds and named after the asset; see assets.list), layers?: [layer id…] (instead of artboards: each layer's art alone, sublayers included, named after the layer), selection?: one|each (instead of artboards: the selected art as one file, or a file per selected object, named after it), fullDocument?: false (one file per format instead: a PDF of every artboard, other formats the bounds of all visible art, named after the document), includeBleed?: false (artboards grown by the document's bleed), includeArtboardFill?: true (Include Artboard Fill: each artboard's background color behind its art; false leaves it out), pdfs?: multiple|single (Export PDFs As: with several artboards, single writes them as the pages of one PDF per PDF row, named after the document), exportPreset?: (a preset of document.exportPresets.list: its settings, under these params), subfolders?: false (each row's files in a sub-folder: its folder, else its size for raster (1x, 2x, 100w…) or its format (SVG, PDF)), folders?: none|rows (as subfolders)|format (a folder per extension: png, svg, pdf…)|item (a folder per artboard, asset, layer or object)|itemFormat (item/extension) (default: rows with subfolders or a preset, else none), name?: (a file name pattern instead of the item's name, with <filename> for the document, <name> for the artboard, asset, layer or object, <index> from 1, #### for the counter zero-padded to the run of #, <format>, <scale>, <suffix> (else the row's suffix ends the name), YYYYMMDD, YYYY-MM-DD, YYYY, <date>, <time>, <YYYY>, <MM>, <DD>, <hh>, <mm> and <ss>; a trailing .ext is dropped, as in `COMPANY-Logo-<filename>-####-YYYYMMDD`; different files it names alike get -2, -3…), counterStart?: 1, counterPer?: item (every file of an item has its number)|file, date?: YYYY-MM-DD (the date the pattern uses; default today, UTC), preset?: mobile (PNG 1x, 2x, 3x) | density (PNG 0.75x–4x in ldpi…xxxhdpi sub-folders) instead of formats (turns subfolders on), formats?: [{format: png|png8|jpg|webp|gif|tiff|bmp|tga|psd|svg|svgz|pdf|eps|ai|vectorcraft, scale?: 1 | \"2x\" | \"100w\" | \"100h\" | \"72ppi\", width?: px | height?: px | ppi? (raster only; width, then height, then ppi win over scale), suffix?: (raster default: @2x, @100w, @100h, none at 1x; vector formats drop size suffixes), folder?: (its sub-folder), quality?: (jpg 0–100), …the format's options (antiAlias, background, preset (pdf)…)}], settings?: {png|png8|jpg|webp|gif|tiff|bmp|tga|psd|svg|svgz|pdf|eps|ai|vectorcraft: {…options for every row of that format}} (rows' own options win), prefix?, antiAlias?: none|art|type (raster rows without their own), openLocation?: (remembered; the app shows the files after exporting)} one file per artboard and format (a PDF holds its artboard alone; artboards with the same name, in any case, get -2, -3…; an unnamed one is Artboard-N; a row whose file would take a name another row's file has, in any case, gets -2, -3… too, and identical rows write one file; row folders that differ only in case are one folder, spelled as the first row spells it) → {files: [path…]} (into the folder of exportPreset, outside the automation read roots: no ZIP path, and files relative to that folder); no folder → {files: [{name, dataBase64}]} (names include sub-folders: 2x/Icon@2x.png); every reply has warnings: [the encoders' warnings for the files, each once: an image that couldn't be decoded, type written in the fallback font…]. eps, ai and vectorcraft rows write a document of the item alone (its one artboard). The params (but zip and assets) are remembered in the document (document.exportSettings; not an undo step). A key it doesn't take, a key no format takes in a format row or in settings, settings for a format it doesn't write, and an unknown key inside a PDF, EPS or SVG option's object, are refused; a key only another format takes in a row or in settings is not used, and warnings name it as given (formats[0].quality; a key in settings only when no row of that format reads it; not a key of an exportPreset). Under automation read roots, an svg or svgz row, and a row whose files carry the native document (vectorcraft, eps, ai but a version 7 file, a pdf with preserveEditing on that holds every artboard of the document it is written from), is refused, before the folder is made or any file is written, while the document links a JavaScript file outside them, or while the row's file would name a linked image's file outside them, as document.export refuses it",
has_doc,
screens::export_for_screens
),
+4 -3
View File
@@ -53,10 +53,10 @@ pub(super) fn export_reads(f: &Format, legacy: bool, key: &str) -> bool {
pub(super) fn serialize(s: &mut Session, p: &Value) -> Result<Value> {
let f = writable("document.serialize", Some(text_param(p, "format", "document.serialize")?.unwrap_or("vectorcraft")), None)?;
check_linked_scripts("document.serialize", f.id, s.doc()?)?;
let unused = unused_option_notes("document.serialize", f, p);
let expanded = expand_presets(s, "document.serialize", p)?;
let p = with_black_output(s, &expanded);
check_linked_scripts("document.serialize", f.id, s.doc()?, &p)?;
let (doc, display_doc_title) = source(s, f, &p, "document.serialize")?;
let doc = &*doc;
let mut q = p.clone();
@@ -97,10 +97,10 @@ pub(super) fn export(s: &mut Session, p: &Value) -> Result<Value> {
super::check_not_lossy_overwrite(s.doc()?, path, p, "document.export")?;
}
let f = writable("document.export", text_param(p, "format", "document.export")?, path)?;
check_linked_scripts("document.export", f.id, s.doc()?)?;
let unused = unused_option_notes("document.export", f, p);
let expanded = expand_presets(s, "document.export", p)?;
let p = with_black_output(s, &expanded);
check_linked_scripts("document.export", f.id, s.doc()?, &p)?;
let (doc, display_doc_title) = source(s, f, &p, "document.export")?;
let doc = &*doc;
let mut q = p.clone();
@@ -375,10 +375,11 @@ pub(super) fn export_selection(s: &mut Session, p: &Value) -> Result<Value> {
super::check_not_lossy_overwrite(s.doc()?, path, p, C)?;
}
let f = writable(C, text_param(p, "format", C)?, path)?;
check_linked_scripts(C, f.id, s.doc()?)?;
let unused = unused_option_notes(C, f, p);
let expanded = expand_presets(s, C, p)?;
let p = with_black_output(s, &expanded);
// The selection is written on one artboard of its own: every artboard, whatever `p` picks.
check_linked_scripts(C, f.id, s.doc()?, &without_artboards(&p))?;
let (d, bounds) = selection(s, C, f.id == "txt")?;
// The selected objects' links are looked for from the document they are in.
check_images_in(C, f.id, &d, crate::cmd::links::LinkBase::of(s.doc()?), &without_artboards(&p))?;
+1 -1
View File
@@ -308,7 +308,7 @@ const PSD_LAYERS: FormatOption = FormatOption {
name: "layers",
ty: "boolean",
default: "true",
description: "write layers: each top-level layer a pixel layer with its opacity and blend mode (a background colour is a Background layer); false: one flat image, on white where transparent",
description: "write layers: each top-level layer a pixel layer with its opacity and blend mode (a background colour is a Background layer); false: one flat image, on white where transparent. The user and object slices are written either way",
};
const MAX_EDITABILITY: FormatOption = FormatOption {
+2 -1
View File
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Export PDF",
[],
None,
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged with an ICC profile is converted from it and written untagged; with destination and a CMYK destinatio Line truncated
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged with an ICC profile is converted from it and written untagged; with destination and a CMYK destinatio Line truncated
has_doc,
export_pdf
),
@@ -499,6 +499,7 @@ fn export_pdf(s: &mut Session, p: &Value) -> Result<Value> {
let expanded = expand_preset(s, C, p)?;
let p = &*expanded;
let st = s.doc()?;
super::check_linked_scripts(C, "pdf", st, p)?;
let display_doc_title = super::has_own_title(&st.doc);
let titled = super::titled_for_export(&st.doc, st.path.as_deref(), "pdf");
let mut q = p.clone();
+10 -3
View File
@@ -889,7 +889,6 @@ pub(crate) fn job_for(s: &Session, st: &DocState, plan: SavePlan) -> Result<Save
fn job_for_stamped(s: &Session, st: &DocState, plan: SavePlan, stamped: Option<i64>) -> Result<SaveJob> {
let cmd = plan.mode.command();
super::check_linked_scripts(cmd, plan.format.id, st)?;
let mut own = doc_to_save(st, plan.format);
let mut params = plan.options.clone();
if is_svg(plan.format) {
@@ -934,6 +933,14 @@ fn job_for_stamped(s: &Session, st: &DocState, plan: SavePlan, stamped: Option<i
o.insert("range".into(), json!("all"));
}
}
// A saved `.ai` or `.ait` file has the artboards as its pages, whatever `useArtboards` says.
let checked = match (&params, plan.format.id) {
(Value::Object(o), "ai" | "ait") => {
std::borrow::Cow::Owned(Value::Object(o.iter().filter(|(k, _)| *k != "useArtboards").map(|(k, v)| (k.clone(), v.clone())).collect()))
}
_ => std::borrow::Cow::Borrowed(&params),
};
super::check_linked_scripts(cmd, plan.format.id, st, &checked)?;
Ok(SaveJob { plan, doc, params, snapshot, source: st.doc.clone(), stamped, boards })
}
@@ -1318,7 +1325,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
"Save Document",
[],
None,
"{path?, format?: vectorcraft|template|pdf|svg|svgz|ai|eps (default: the path's extension, else the document's own format), options?: {…the format's options, see file.formatOptions; default: as last saved}, svg?: {…SVG options} (an SVG save keeps hidden layers, display:none, unless hiddenLayers is false), …the SVG and PDF options given flat instead (an option given flat or in svg and in options with different values is an error), compress?: bool (native, also in options: gzip; default: the useCompression preference; warnings name an option given flat or in options that the file doesn't read: a legacy .ai reads only its own options, and other .ai files don't read outlineText, hiddenObjects, transparentImages or preserveEditing), version?: 4 (3, 2 or 1: for older VectorCraft versions; 1 and 2 are never compressed), preview?: false (embed a PNG of the first artboard, at most 256 px), precision?: 0..9 (native: round path anchors and handles to this many decimal places, a smaller file; colors, transforms and type stay exact; default: exact, and a later save without it writes exactly again), separateArtboards?: false (native and .ai: also save each artboard of `range` to <name>-<artboard>.<ext> beside the file, holding that artboard and the art touching it; the result's files lists every file written), range?: \"1-3, 5\"|\"all\" (default; with separateArtboards), includeLinked?: false (keep linked files' own pixels, not just their previews; they stay linked), embedProfiles?: true (carry the ICC profiles loaded from files that the document is tagged with; opening the file installs them where missing), pdfCompatible?: true (native: also carry a PDF of every artboard; false omits it) | true for .ai (false: blank pages, only the native document; a .ai file's compress, default true, is its compression.compressText), modified?: Unix seconds|null (the File Info modified date, and created date when there is none, a save to a file stamps; default now, recorded in the journal so a replay matches; null: leave the dates)} → {path, format, bytes, warnings, files?: [path…] (the file and its artboards' files), linked?: [path…] (images an SVG links to)}. Save writes one artboard, except a .ai file and EPS (below): a .ai file is a PDF-compatible file of every artboard carrying the native document (preserveEditing always on; PDF options flat or in options), which document.open restores exactly, on the active artboard (the app's, else the one the document opened on; with editingData: false, the first); separateArtboards writes more files, one per artboard. EPS takes the options of document.exportEps: by default one file whose bounding box fits the visible art (the first artboard when no art shows), carrying the whole editable document; useArtboards: true (also when artboard, artboards or range names artboards; file.formatOptions then reports it true) makes the chosen artboard the page, drawn with its background color (without Use Artboards, only the first artboard's page when no art shows has its color), and with two or more chosen the file at the path is the central file of the visible art (again the first artboard when none shows) and each artboard is also written to <name>_<artboard>.eps beside it, holding that artboard; selectedOnly is refused; its PostScript appearance flattens transparency, as EPS requires. Without a path it writes the document's own file in its own format: a document opened from or saved as SVG/PDF/EPS saves as that again (warnings name what the format loses). No path known (never saved, converted from an older version, restored by Data Recovery, or another format) → {dataBase64, format, name, folder?, warnings} and the document stays modified. Under automation read roots, a reply leaves out the document's own file outside them when no path is given (files and linked then name the files by their file names), and a suggested folder outside them; an svg or svgz save (a document whose own format is SVG or SVGZ included) is refused, before any file is written, while the document links a JavaScript file outside them (svgInteractivity; a URL is not checked), or while the file would name a linked image's file outside them (images: link, preserveEditing, or an image whose pixels the document doesn't hold; a URL is not checked), also by file.saveAs and file.saveCopy. A key that no save format takes, beside the path or in options, and an unknown key inside a PDF option's object or svg, are refused. A terminal filesystem permission/read-only refusal returns READ_ONLY_LOCATION: followed by the reason; recovery-copy failures keep their original error. Non-UI callers never open a save panel",
"{path?, format?: vectorcraft|template|pdf|svg|svgz|ai|eps (default: the path's extension, else the document's own format), options?: {…the format's options, see file.formatOptions; default: as last saved}, svg?: {…SVG options} (an SVG save keeps hidden layers, display:none, unless hiddenLayers is false), …the SVG and PDF options given flat instead (an option given flat or in svg and in options with different values is an error), compress?: bool (native, also in options: gzip; default: the useCompression preference; warnings name an option given flat or in options that the file doesn't read: a legacy .ai reads only its own options, and other .ai files don't read outlineText, hiddenObjects, transparentImages or preserveEditing), version?: 4 (3, 2 or 1: for older VectorCraft versions; 1 and 2 are never compressed), preview?: false (embed a PNG of the first artboard, at most 256 px), precision?: 0..9 (native: round path anchors and handles to this many decimal places, a smaller file; colors, transforms and type stay exact; default: exact, and a later save without it writes exactly again), separateArtboards?: false (native and .ai: also save each artboard of `range` to <name>-<artboard>.<ext> beside the file, holding that artboard and the art touching it; the result's files lists every file written), range?: \"1-3, 5\"|\"all\" (default; with separateArtboards), includeLinked?: false (keep linked files' own pixels, not just their previews; they stay linked), embedProfiles?: true (carry the ICC profiles loaded from files that the document is tagged with; opening the file installs them where missing), pdfCompatible?: true (native: also carry a PDF of every artboard; false omits it) | true for .ai (false: blank pages, only the native document; a .ai file's compress, default true, is its compression.compressText), modified?: Unix seconds|null (the File Info modified date, and created date when there is none, a save to a file stamps; default now, recorded in the journal so a replay matches; null: leave the dates)} → {path, format, bytes, warnings, files?: [path…] (the file and its artboards' files), linked?: [path…] (images an SVG links to)}. Save writes one artboard, except a .ai file and EPS (below): a .ai file is a PDF-compatible file of every artboard carrying the native document (preserveEditing always on; PDF options flat or in options), which document.open restores exactly, on the active artboard (the app's, else the one the document opened on; with editingData: false, the first); separateArtboards writes more files, one per artboard. EPS takes the options of document.exportEps: by default one file whose bounding box fits the visible art (the first artboard when no art shows), carrying the whole editable document; useArtboards: true (also when artboard, artboards or range names artboards; file.formatOptions then reports it true) makes the chosen artboard the page, drawn with its background color (without Use Artboards, only the first artboard's page when no art shows has its color), and with two or more chosen the file at the path is the central file of the visible art (again the first artboard when none shows) and each artboard is also written to <name>_<artboard>.eps beside it, holding that artboard; selectedOnly is refused; its PostScript appearance flattens transparency, as EPS requires. Without a path it writes the document's own file in its own format: a document opened from or saved as SVG/PDF/EPS saves as that again (warnings name what the format loses). No path known (never saved, converted from an older version, restored by Data Recovery, or another format) → {dataBase64, format, name, folder?, warnings} and the document stays modified. Under automation read roots, a reply leaves out the document's own file outside them when no path is given (files and linked then name the files by their file names), and a suggested folder outside them; an svg or svgz save (a document whose own format is SVG or SVGZ included), and a save whose file carries the native document (vectorcraft, template, eps, ai but a version 7 file, pdf of every artboard with preserveEditing on and useArtboards not false), is refused, before any file is written, while the document links a JavaScript file outside them (svgInteractivity; a URL is not checked), or while the file would name a linked image's file outside them (images: link, preserveEditing, or an image whose pixels the document doesn't hold; a URL is not checked), also by file.saveAs and file.saveCopy. A key that no save format takes, beside the path or in options, and an unknown key inside a PDF option's object or svg, are refused. A terminal filesystem permission/read-only refusal returns READ_ONLY_LOCATION: followed by the reason; recovery-copy failures keep their original error. Non-UI callers never open a save panel",
has_doc,
|s, p| save(s, SaveMode::Save, p)
),
@@ -1345,7 +1352,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
"Save as Template…",
["File"],
None,
"{…as document.save} {path? (saved with the format's extension: one naming another format is replaced, and one is added to a name without it), format?: template (default) | ait (also when format is not given and the path ends in .ait), compress?, version?, preview?, precision?} a template that opens as a new untitled document: a native template (.vctemplate), or a PDF-compatible .ait written as a .ai file is (the .ai options and the PDF options, as document.save takes them for .ai; aiVersion 7 is an error); the document is unchanged → {path, format, bytes, warnings}; no path → {dataBase64, format, name: \"<name> template.<ext>\", folder: the Templates folder (preference templatesFolder), warnings}",
"{…as document.save} {path? (saved with the format's extension: one naming another format is replaced, and one is added to a name without it), format?: template (default) | ait (also when format is not given and the path ends in .ait), compress?, version?, preview?, precision?} a template that opens as a new untitled document: a native template (.vctemplate), or a PDF-compatible .ait written as a .ai file is (the .ai options and the PDF options, as document.save takes them for .ai; aiVersion 7 is an error); the document is unchanged → {path, format, bytes, warnings}; no path → {dataBase64, format, name: \"<name> template.<ext>\", folder: the Templates folder (preference templatesFolder), warnings}. Under automation read roots, it is refused, before any file is written, while the document links a JavaScript file outside them, as document.save refuses it",
has_doc,
|s, p| save(s, SaveMode::Template, p)
),
+27 -4
View File
@@ -1089,6 +1089,29 @@ pub(crate) fn with_export_preset(s: &Session, cmd: &str, settings: &mut Map<Stri
Ok(())
}
/// Does the file of `item` that row `r` writes carry the native document, and with it the
/// JavaScript files the document links ([`super::access::names_linked_scripts`])? A PDF holds the
/// artboards it is written with: those of `single` (Export PDFs As › Single file), every artboard
/// (Full Document), else the item's artboard of its document.
fn names_scripts(item: &Item, r: &Row, single: Option<&[usize]>) -> bool {
if r.format.id != "pdf" {
return super::access::names_linked_scripts(C, r.format.id, &r.options, item.doc.artboards.len());
}
let (doc, options) = match (single, &item.every_artboard) {
(Some(boards), _) => {
let mut options = r.options.clone();
options["range"] = json!(boards.iter().map(|b| (b + 1).to_string()).collect::<Vec<_>>().join(", "));
(&item.doc, options)
}
(None, Some(all)) => (all, r.options.clone()),
(None, None) => match r.options_for(item.region, item.artboard) {
Ok(options) => (&item.doc, options),
Err(_) => return true,
},
};
super::access::names_linked_scripts(C, "pdf", &options, doc.artboards.len())
}
/// Every chosen artboard (asset, layer, selected object) in every format row, one file each (a PDF
/// holds its artboard alone), or with `fullDocument` one file per row (a PDF of every artboard,
/// else the bounds of all art). Items that share a name get `-2`, `-3`… instead of overwriting, and
@@ -1105,10 +1128,6 @@ pub(crate) fn export(s: &mut Session, p: &Value, asked: &Value) -> Result<Value>
o.one_source()?;
// `<filename>`: the document's file, as Save names it, or its title before it is saved.
let st = s.doc()?;
// Before the folder is made or any row is written.
for r in &rows {
super::check_linked_scripts(C, r.format.id, st)?;
}
let naming = Naming::of(&o, st.path.as_deref().unwrap_or(&st.doc.title))?;
let selection = o.selection_mode()?;
let selected = if selection.is_some() { selected_artwork(s)? } else { vec![] };
@@ -1125,6 +1144,10 @@ pub(crate) fn export(s: &mut Session, p: &Value, asked: &Value) -> Result<Value>
};
let crop = rows.iter().any(|r| r.format.id != "pdf");
let items = items(&doc, &o, selection, &selected, &naming.filename, crop, true)?;
// Before the folder is made or any row is written, with the artboards each file holds.
let single: Option<Vec<usize>> = items.iter().map(|i| i.artboard).collect::<Option<Vec<_>>>().filter(|a| naming.single_pdf && a.len() > 1);
let st = s.doc()?;
super::check_scripts_of(C, &st.doc, st.path.as_deref(), || rows.iter().any(|r| items.iter().any(|i| names_scripts(i, r, single.as_deref()))))?;
// The file each item writes for each SVG row, before the folder is made or any row is written.
let base = crate::cmd::links::LinkBase::of(s.doc()?);
for r in rows.iter().filter(|r| matches!(r.format.id, "svg" | "svgz")) {
@@ -511,3 +511,75 @@ fn damaged_slices_never_panic() {
}
}
}
/// The PSD file `document.export` writes from `s`, with its layers or flat.
fn export(s: &mut Session, layers: bool) -> Vec<u8> {
let r = s.execute("document.export", &json!({"format": "psd", "layers": layers})).unwrap();
vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
}
#[test]
fn an_opened_files_slices_survive_a_psd_export() {
let link =
S { url: "https://example.com/", target: "_blank", message: "Go", alt: "Logo", argb: [255, 0x12, 0x34, 0x56], ..user("logo", [2, 4, 10, 8]) };
let plain = S { kind: 0, cell: "a < b & c", ..user("note", [10, 10, 20, 20]) };
let html = S { kind: 0, html: true, cell: "<b>Hi</b>", argb: [0, 1, 2, 3], ..user("", [0, 12, 6, 18]) };
let auto = S { origin: 0, ..user("auto", [0, 0, 20, 2]) };
let f = with_resource(&psd(true), 1050, &v6(&[link, plain, html, auto], &[]));
let (mut s, _) = open(&f, json!({}));
let opened = slices(&s);
assert_eq!(opened.len(), 3);
for layers in [true, false] {
let out = export(&mut s, layers);
let (again, r) = open(&out, json!({}));
assert!(warnings(&r).is_empty(), "{r}");
// The same rectangles and options; the auto slices are laid out again around them.
let mut got = slices(&again);
let mut want = opened.clone();
let order = |v: &mut Vec<(Rect, SliceOptions)>| v.sort_by(|a, b| a.0.y0.total_cmp(&b.0.y0).then(a.0.x0.total_cmp(&b.0.x0)));
order(&mut got);
order(&mut want);
assert_eq!(got, want);
let layout = again.doc().unwrap().doc.slice_layout();
assert!(layout.iter().any(|a| a.source == vectorcraft_doc::SliceSource::Auto));
assert_eq!(s.execute("document.psdInfo", &json!({"dataBase64": b64(&out)})).unwrap()["slices"], json!(3));
}
}
#[test]
fn object_slices_are_written_as_user_slices_and_html_text_as_its_type() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
let r = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 40, "height": 30})).unwrap();
let rect = r["id"].as_u64().unwrap();
s.execute("object.slice.make", &json!({"ids": [rect]})).unwrap();
s.execute("select.set", &json!({"ids": [rect]})).unwrap();
s.execute("object.slice.options", &json!({"kind": "noImage", "name": "box", "text": "<i>x</i>", "background": "#00ff00"})).unwrap();
let t = s.execute("text.create", &json!({"x": 100, "y": 50, "text": "A & B"})).unwrap()["id"].as_u64().unwrap();
s.execute("object.slice.make", &json!({"ids": [t]})).unwrap();
s.execute("select.set", &json!({"ids": [t]})).unwrap();
s.execute("object.slice.options", &json!({"kind": "htmlText"})).unwrap();
let (again, _) = open(&export(&mut s, false), json!({}));
let got = slices(&again);
assert_eq!(got.len(), 2, "{got:?}");
let doc = &s.doc().unwrap().doc;
let rb = doc.slice_bounds(vectorcraft_doc::NodeId(rect)).unwrap();
let boxed = got.iter().find(|g| g.1.name == "box").unwrap();
// Within a pixel of the object's bounds.
for (a, b) in [(boxed.0.x0, rb.x0), (boxed.0.y0, rb.y0), (boxed.0.x1, rb.x1), (boxed.0.y1, rb.y1)] {
assert!((a - b).abs() <= 1.0, "{:?} against {rb:?}", boxed.0);
}
assert_eq!((boxed.1.kind, boxed.1.text.as_str(), boxed.1.background.as_str()), (SliceKind::NoImage, "<i>x</i>", "#00ff00"));
let text = got.iter().find(|g| g.1.name.is_empty()).unwrap();
assert_eq!((text.1.kind, text.1.text.as_str()), (SliceKind::NoImage, "A &amp; B"));
}
#[test]
fn twenty_exported_slices_open_again_with_the_one_whose_id_is_16() {
let columns: Vec<S> = (0..20).map(|x| user("", [x, 0, x + 1, 20])).collect();
let (mut s, _) = open(&with_resource(&psd(false), 1050, &v6(&columns, &[])), json!({}));
assert_eq!(slices(&s).len(), 20);
let (again, r) = open(&export(&mut s, true), json!({}));
assert!(warnings(&r).is_empty(), "{r}");
assert_eq!(slices(&again), slices(&s));
}
+1 -1
View File
@@ -30,7 +30,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Type…",
["Object", "Graph"],
None,
"{id?, type?, seriesIndexes?: [index], columnWidth?: % (1–1000; past 100 columns overlap), clusterWidth?: % (1–1000), legend?: bool, markPoints?: bool, connectPoints?: bool, edgeToEdge?: bool (line graphs: true runs the lines across the whole plot, false puts the points at the centres of their categories), ticks?: n, axisMin?: number|null (null = calculated), axisMax?: number|null, valueAxis?: left|right|both (the bar graphs' value axis stays along the bottom), separateScales?: bool, rightTicks?: n, rightAxisMin?, rightAxisMax?, tickLength?: none|short|full, tickMarks?: n per division, rightTickLength?, rightTickMarks?, categoryTickLength?: none|short|full, categoryTickMarks?: n, ticksBetweenLabels?: bool, prefix?, suffix?, rightPrefix?, rightSuffix?: text around the value axis numbers, firstRowInFront?: bool, firstColumnInFront?: bool (which overlapping columns are drawn on top: the first category over the next within each series, the first series over the others), filledLines?: bool (Draw Filled Lines: connecting lines as 3 pt bands filled with the series colour), dropShadow?: bool (Add Drop Shadow: a translucent black shadow down and right of the columns, bars, lines and pie wedges), legendAcrossTop?: bool (Add Legend Across Top: the legend in rows above the plot), pieLegend?: none|standard|wedges (Legends in Wedges: the series labels inside their wedges), piePosition?: ratio|even|stacked (several pies sized by their totals, at one size (the default), or stacked), pieSort?: all|first|none (wedges largest first in each pie, in the first pie's order, or in data order (the default)); the query lists the pie options for pie graphs} change the graph type and options; with `seriesIndexes`, or (no `id`) with only series selected with Group Selection, `type` goes to those series only and `valueAxis` (left|right; both is refused) puts them on that value axis, while the other options still apply to the whole graph (Combine different graph types: column, stacked column, line and area mix, and so do bar and stacked bar; a series given the graph's type follows the graph again) (axisMin and axisMax together override the calculated value axis: exactly that range in `ticks` divisions, 5 when 0; with the value axis on both sides, separateScales gives the series on the right axis a scale of their own, set the same way with rightTicks, rightAxisMin and rightAxisMax); a value of the wrong type, such as \"10\" for a number or \"true\" for a bool, or a negative count, is refused and the graph stays as it was; a null is read as a key left out, except that a null axis bound goes back to the calculated value; no options → the current ones",
"{id?, type?, seriesIndexes?: [index], columnWidth?: % (1–1000; past 100 columns overlap), clusterWidth?: % (1–1000), legend?: bool, markPoints?: bool, connectPoints?: bool, edgeToEdge?: bool (line graphs: true runs the lines across the whole plot, false puts the points at the centres of their categories), ticks?: n, axisMin?: number|null (null = calculated), axisMax?: number|null, valueAxis?: left|right|both (the bar graphs' value axis stays along the bottom), separateScales?: bool, rightTicks?: n, rightAxisMin?, rightAxisMax?, tickLength?: none|short|full, tickMarks?: n per division, rightTickLength?, rightTickMarks?, categoryTickLength?: none|short|full, categoryTickMarks?: n, ticksBetweenLabels?: bool, prefix?, suffix?, rightPrefix?, rightSuffix?: text around the value axis numbers, firstRowInFront?: bool, firstColumnInFront?: bool (which overlapping columns are drawn on top: the first category over the next within each series, the first series over the others), filledLines?: bool (Draw Filled Lines: connecting lines as bands `lineWidth` wide filled with the series colour), lineWidth?: pt (Line Width of Draw Filled Lines: 0.01–1000; 3), dropShadow?: bool (Add Drop Shadow: a translucent black shadow down and right of the columns, bars, lines and pie wedges), legendAcrossTop?: bool (Add Legend Across Top: the legend in rows above the plot), pieLegend?: none|standard|wedges (Legends in Wedges: the series labels inside their wedges), piePosition?: ratio|even|stacked (several pies sized by their totals, at one size (the default), or stacked), pieSort?: all|first|none (wedges largest first in each pie, in the first pie's order, or in data order (the default)); the query lists the pie options for pie graphs} change the graph type and options; with `seriesIndexes`, or (no `id`) with only series selected with Group Selection, `type` goes to those series only and `valueAxis` (left|right; both is refused) puts them on that value axis, while the other options still apply to the whole graph (Combine different graph types: column, stacked column, line and area mix, and so do bar and stacked bar; a series given the graph's type follows the graph again) (axisMin and axisMax together override the calculated value axis: exactly that range in `ticks` divisions, 5 when 0; with the value axis on both sides, separateScales gives the series on the right axis a scale of their own, set the same way with rightTicks, rightAxisMin and rightAxisMax); a value of the wrong type, such as \"10\" for a number or \"true\" for a bool, or a negative count, is refused and the graph stays as it was; options that leave the graph as it is record no step of history; a null is read as a key left out, except that a null axis bound goes back to the calculated value; no options → the current ones",
has_selection,
set_type
),
+17
View File
@@ -230,6 +230,7 @@ fn query_type_options(spec: &GraphSpec, count: usize, picked: &[usize]) -> Value
"prefix": one_line(&spec.prefix), "suffix": one_line(&spec.suffix), "rightPrefix": one_line(&spec.right_prefix),
"rightSuffix": one_line(&spec.right_suffix), "dropShadow": spec.drop_shadow, "legendAcrossTop": spec.legend_across_top,
"firstRowInFront": spec.first_row_in_front, "firstColumnInFront": spec.first_column_in_front, "filledLines": spec.filled_lines,
"lineWidth": spec.filled_line_width(),
});
// Only the options this graph's types use: overlap order for columns and bars, filled lines for lines.
let kinds: Vec<GraphKind> = (0..count.max(1)).map(|i| spec.series_kind(i)).collect();
@@ -241,6 +242,7 @@ fn query_type_options(spec: &GraphSpec, count: usize, picked: &[usize]) -> Value
}
if !has(&[GraphKind::Line, GraphKind::Scatter, GraphKind::Radar]) {
o.remove("filledLines");
o.remove("lineWidth");
}
}
// Pie graphs: Legend, Position and Sort (their Legend stands for the legend checkbox).
@@ -266,6 +268,7 @@ pub(super) fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "graph.setType";
let id = target(s, p, C)?;
let mut spec = spec_of(s, id)?;
let stored = spec.clone();
// The series to retype: `seriesIndexes`, else, with no `id`, a selection made only of this graph's series (Group
// Selection). Anything else selected, the graph itself for one, is the whole graph.
let count = spec.rows.iter().map(Vec::len).max().unwrap_or(0).min(vectorcraft_doc::MAX_GRAPH_SERIES);
@@ -311,6 +314,7 @@ pub(super) fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
"firstRowInFront",
"firstColumnInFront",
"filledLines",
"lineWidth",
"pieLegend",
"piePosition",
"pieSort",
@@ -404,6 +408,15 @@ pub(super) fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
spec.first_row_in_front = switch_or(p, "firstRowInFront", spec.first_row_in_front, C)?;
spec.first_column_in_front = switch_or(p, "firstColumnInFront", spec.first_column_in_front, C)?;
spec.filled_lines = switch_or(p, "filledLines", spec.filled_lines, C)?;
if let Some(w) = p.get("lineWidth").filter(|v| !v.is_null()) {
let w = w.as_f64().ok_or_else(|| bad(C, format!("`lineWidth` must be a number, not {w}")))?;
let (min, max) = (vectorcraft_doc::MIN_FILLED_LINE_WIDTH, vectorcraft_doc::MAX_FILLED_LINE_WIDTH);
if !(min..=max).contains(&w) {
return Err(bad(C, format!("`lineWidth` must be from {min} to {max} pt, not {w}")));
}
// The default width is stored as no width.
spec.line_width = (w != vectorcraft_doc::DEFAULT_FILLED_LINE_WIDTH).then_some(w);
}
spec.legend_across_top = switch_or(p, "legendAcrossTop", spec.legend_across_top, C)?;
// After `legend`, which the Graph Type dialog sends too.
if let Some(v) = text_param(p, "pieLegend", C)? {
@@ -418,6 +431,10 @@ pub(super) fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
spec.connect_points = switch_or(p, "connectPoints", spec.connect_points, C)?;
spec.edge_to_edge = switch_or(p, "edgeToEdge", spec.edge_to_edge, C)?;
spec.ticks = count_given(p, "ticks", 100, C)?.unwrap_or(spec.ticks);
// Options that leave the graph as it is record no step of history.
if spec == stored {
return Ok(json!({ "id": id.0 }));
}
let label = format!("{} Graph", spec.kind.label());
s.edit("Graph Type", |d, sel| {
regenerate(d, id, spec)?;
+3 -5
View File
@@ -230,10 +230,11 @@ impl Gen<'_> {
Arc::new(g)
}
/// A series' line joining its data points (Connect Data Points): a 1 pt stroke in the series colour, or with Draw
/// Filled Lines a band FILLED_LINE_WIDTH wide filled with it and outlined in black.
/// Filled Lines a band as wide as the graph's Line Width ([`GraphSpec::filled_line_width`]) filled with it and outlined
/// in black.
pub(super) fn data_line(&mut self, g: &GraphSpec, s: usize, pd: PathData, filled: bool) -> Arc<Node> {
let band = if filled {
vectorcraft_pathops::outline_stroke(&pd, FILLED_LINE_WIDTH, vectorcraft_pathops::Cap::Butt, vectorcraft_pathops::Join::Miter, 4.0)
vectorcraft_pathops::outline_stroke(&pd, g.filled_line_width(), vectorcraft_pathops::Cap::Butt, vectorcraft_pathops::Join::Miter, 4.0)
} else {
PathData::default()
};
@@ -287,9 +288,6 @@ const SHADOW_OFFSET: f64 = 2.0;
pub(super) const SHADOW_OPACITY: f32 = 0.35;
/// Draw Filled Lines: how wide a filled line is.
const FILLED_LINE_WIDTH: f64 = 3.0;
const FILLED_LINE_BUDGET: usize = 20_000;
/// Does graph `g`, with `series` series, draw Filled Lines (up to FILLED_LINE_BUDGET data points)?
+28 -2
View File
@@ -1492,7 +1492,11 @@ pub(crate) fn capture_line_changes(before: &Document, doc: &mut Document, ids: &
let Some(spec) = doc.node_mut(graph).and_then(|n| n.extras_if_any().and_then(|e| e.graph.as_deref_mut())) else { continue };
let slot = line_slot(&mut spec.label_styles, line);
let mut rows = slot.clone().unwrap_or_else(|| line.default_rows());
let was_unpainted = stroke_unpainted(&rows);
merge_row_edits(&mut rows, &old, &new);
if old.paint.stroke != new.paint.stroke {
keep_painted_stroke_weight(&mut rows, was_unpainted, &new.paint);
}
let kept = (rows != line.default_rows()).then_some(rows);
changed |= *slot != kept;
*slot = kept;
@@ -1547,9 +1551,10 @@ pub(crate) fn capture_line_row_writes(doc: &mut Document, written: &[(NodeId, us
let Some(spec) = doc.node_mut(graph).and_then(|n| n.extras_if_any().and_then(|e| e.graph.as_deref_mut())) else { continue };
let slot = line_slot(&mut spec.label_styles, line);
let mut rows = slot.clone().unwrap_or_else(|| line.default_rows());
let was_unpainted = stroke_unpainted(&rows);
let k = &mut rows.paint;
if on_fill.paint {
k.fill = shown.fill;
k.fill = shown.fill.clone();
}
if on_fill.opacity {
k.fill_opacity = shown.fill_opacity;
@@ -1558,7 +1563,7 @@ pub(crate) fn capture_line_row_writes(doc: &mut Document, written: &[(NodeId, us
k.fill_blend = shown.fill_blend;
}
if on_stroke.paint {
k.stroke = shown.stroke;
k.stroke = shown.stroke.clone();
}
if on_stroke.weight {
k.stroke_width = shown.stroke_width;
@@ -1569,6 +1574,9 @@ pub(crate) fn capture_line_row_writes(doc: &mut Document, written: &[(NodeId, us
if on_stroke.blend {
k.stroke_blend = shown.stroke_blend;
}
if on_stroke.paint {
keep_painted_stroke_weight(&mut rows, was_unpainted, &shown);
}
let kept = (rows != line.default_rows()).then_some(rows);
changed |= *slot != kept;
*slot = kept;
@@ -1576,6 +1584,24 @@ pub(crate) fn capture_line_row_writes(doc: &mut Document, written: &[(NodeId, us
changed
}
/// Give kept line rows whose stroke an edit painted the painted line's stroke weight (`shown`) when the kind kept no
/// stroke paint before the edit (`was_unpainted`) and keeps the zero weight a stroke set to None left. A non-zero kept
/// weight stays, and so do a zero weight kept with a painted stroke and a zero weight the painted line shows.
fn keep_painted_stroke_weight(rows: &mut vectorcraft_doc::LabelRows, was_unpainted: bool, shown: &vectorcraft_doc::SeriesPaint) {
if was_unpainted
&& !stroke_unpainted(rows)
&& rows.paint.stroke_width.is_some_and(|w| w <= 0.0)
&& let Some(w) = shown.stroke_width.filter(|w| *w > 0.0)
{
rows.paint.stroke_width = Some(w);
}
}
/// Do kept line rows keep no stroke paint?
fn stroke_unpainted(rows: &vectorcraft_doc::LabelRows) -> bool {
rows.paint.stroke.as_ref().is_none_or(Paint::is_none)
}
/// Is `id` a graph line: a path directly in a graph's Axes group?
pub(crate) fn is_graph_line(doc: &Document, id: NodeId) -> bool {
graph_line(doc, id).is_some()
+121
View File
@@ -6700,6 +6700,54 @@ fn filled_lines_keep_the_line_colour_and_fall_back_to_thin_lines() {
assert!(series_parts(&s, big, 0)[0].appearance.fill_paint().is_none());
}
/// Line Width sets how wide Draw Filled Lines draws the bands and is kept through save and open. A width outside 0.01
/// to 1000 pt is refused, the same width again records no undo step, and the default 3 pt is stored as no width.
#[test]
fn filled_lines_take_a_line_width() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
let id = make(&mut s, "line", ",a\nQ1,2\nQ2,2\nQ3,2");
s.execute("graph.setType", &json!({"id": id.0, "filledLines": true})).unwrap();
let height = |s: &Session| series_parts(s, id, 0)[0].geometric_bounds().unwrap().height();
assert!((height(&s) - 3.0).abs() < 1e-6, "3 pt by default: {}", height(&s));
assert_eq!(s.execute("graph.setType", &json!({"id": id.0})).unwrap()["lineWidth"], json!(3.0));
s.execute("graph.setType", &json!({"id": id.0, "lineWidth": 8})).unwrap();
assert!((height(&s) - 8.0).abs() < 1e-6, "{}", height(&s));
assert_eq!(s.execute("graph.setType", &json!({"id": id.0})).unwrap()["lineWidth"], json!(8.0));
let steps = |s: &Session| s.doc().unwrap().history.undo.len();
let before = steps(&s);
for p in [json!({"id": id.0, "lineWidth": 8}), json!({"id": id.0, "lineWidth": 8.0, "filledLines": true}), json!({"id": id.0, "lineWidth": null})]
{
s.execute("graph.setType", &p).unwrap();
assert_eq!(steps(&s), before, "nothing changed: {p}");
}
for w in [json!(0), json!(-2), json!(0.005), json!(1000.5)] {
let e = s.execute("graph.setType", &json!({"id": id.0, "lineWidth": w})).unwrap_err().to_string();
assert!(e.contains(&format!("`lineWidth` must be from 0.01 to 1000 pt, not {}", w.as_f64().unwrap())), "{e}");
assert_eq!((steps(&s), spec(&s, id).line_width), (before, Some(8.0)), "{w}");
}
s.execute("graph.setType", &json!({"id": id.0, "lineWidth": 0.01})).unwrap();
assert_eq!(spec(&s, id).line_width, Some(0.01));
s.execute("graph.setType", &json!({"id": id.0, "lineWidth": 1000})).unwrap();
assert_eq!(spec(&s, id).line_width, Some(1000.0));
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(spec(&s, id).line_width, Some(8.0));
// Kept through save and open.
let dir = vectorcraft_testkit::TempDir::new("graph-line-width");
let path = dir.join("width.vectorcraft");
s.execute("document.save", &json!({"path": path})).unwrap();
s.execute("document.open", &json!({"path": path})).unwrap();
assert_eq!(spec(&s, id).line_width, Some(8.0));
assert!((height(&s) - 8.0).abs() < 1e-6, "{}", height(&s));
// The default width is stored as no width, so the file keeps no `lineWidth`.
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
s.execute("graph.setType", &json!({"id": id.0, "lineWidth": 3})).unwrap();
assert_eq!(spec(&s, id).line_width, None);
assert!(serde_json::to_value(spec(&s, id)).unwrap().get("lineWidth").is_none());
assert!((height(&s) - 3.0).abs() < 1e-6, "{}", height(&s));
}
#[test]
fn overlapping_columns_keep_clear_of_the_legend_and_options_follow_the_graph_type() {
let mut s = Session::new();
@@ -7857,6 +7905,28 @@ fn recoloring_a_graph_keeps_its_axis_lines_paint() {
assert!(!label_paint.is_empty() && label_paint.iter().all(|l| *l == ("#ffffff".to_string(), true)), "{label_paint:?}");
}
/// Swap Fill and Stroke on an axis line keeps the swapped paint for every axis line and leaves the fill opacity the axis
/// lines keep from another line, though the line swapped still shows 100%.
#[test]
fn swapping_an_axis_lines_paint_keeps_the_fill_opacity_its_kind_keeps() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
let id = graph(&mut s, "column");
let lines = line_nodes(&s, id);
let (first, second) = (lines[0].id, lines[1].id);
s.execute("paint.setFill", &json!({"ids": [first.0], "color": "#00ff00"})).unwrap();
s.execute("transparency.set", &json!({"ids": [first.0], "item": top_row(&s, first, true), "opacity": 40})).unwrap();
let shown = s.doc().unwrap().doc.node(second).unwrap().appearance.fill().map(|f| f.opacity);
assert!(shown.is_none_or(|o| o == 1.0), "the other lines show 100% until the graph is drawn again: {shown:?}");
s.execute("paint.swap", &json!({"ids": [second.0]})).unwrap();
s.execute("graph.setData", &json!({"id": id.0, "csv": ",2024,2025\nQ1,3,2\nQ2,5,4\nQ3,-1,6"})).unwrap();
for n in line_nodes(&s, id) {
let fill = n.appearance.fill().map(|f| (f.paint.color().map(|c| c.to_hex()), f.opacity));
assert!(fill.as_ref().is_some_and(|(c, o)| c.as_deref() == Some("#000000") && (*o - 0.4).abs() < 1e-6), "{fill:?}");
assert!(n.appearance.stroke_paint().is_none(), "the swapped line had no fill, so the lines have no stroke");
}
}
/// A stroke given the whole graph, or its Axes group, is kept for its axis lines.
#[test]
fn a_stroke_given_the_whole_graph_or_its_axes_group_is_kept_for_its_axis_lines() {
@@ -7999,6 +8069,56 @@ fn an_object_opacity_on_an_axis_line_keeps_the_stroke_its_kind_keeps() {
}
}
/// A stroke painted on an axis line after another axis line's stroke was set to None is kept for every axis line with
/// the painted line's weight, not the zero weight the unpainted stroke left on its kind.
#[test]
fn a_stroke_painted_after_an_axis_line_lost_its_stroke_keeps_a_weight() {
let cases = ["paint.setStroke", "addon.color.fillToStroke", "appearance.setItem"];
every_case(cases, |cmd| {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
let id = graph(&mut s, "column");
let lines = line_nodes(&s, id);
let weight = line_look(&lines[1]).1;
assert!(weight > 0.0, "{cmd}: the line has a stroke weight: {weight}");
s.execute("paint.setStroke", &json!({"ids": [lines[0].id.0], "none": true})).unwrap();
let b = lines[1].id.0;
match *cmd {
"paint.setStroke" => s.execute(cmd, &json!({"ids": [b], "color": "#ff0000"})).unwrap(),
"addon.color.fillToStroke" => {
s.execute("paint.setFill", &json!({"ids": [b], "color": "#ff0000"})).unwrap();
s.execute(cmd, &json!({"ids": [b]})).unwrap()
}
_ => s.execute(cmd, &json!({"ids": [b], "index": top_row(&s, lines[1].id, false), "color": "#ff0000"})).unwrap(),
};
let looks = redrawn_line_looks(&mut s, id);
assert!(looks.iter().all(|l| l.0 == "#ff0000" && (l.1 - weight).abs() < 1e-9), "{cmd}: {looks:?}");
});
}
/// A zero stroke weight set together with a stroke color on an axis line is kept for every axis line as set, also when
/// a stroke is painted on another axis line before the graph is drawn again.
#[test]
fn a_zero_weight_set_with_a_stroke_color_on_an_axis_line_is_kept() {
every_case([false, true], |repaint| {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
let id = graph(&mut s, "column");
let lines = line_nodes(&s, id);
s.execute("paint.setStroke", &json!({"ids": [lines[0].id.0], "none": true})).unwrap();
let at = top_row(&s, lines[1].id, false);
s.execute("appearance.setItem", &json!({"ids": [lines[1].id.0], "index": at, "color": "#ff0000", "weight": 0})).unwrap();
let color = if *repaint {
s.execute("paint.setStroke", &json!({"ids": [lines[2].id.0], "color": "#0000ff"})).unwrap();
"#0000ff"
} else {
"#ff0000"
};
let looks = redrawn_line_looks(&mut s, id);
assert!(looks.iter().all(|l| l.0 == color && l.1 == 0.0), "repaint {repaint}: {looks:?}");
});
}
/// A reorder that leaves an axis line's rows as they were keeps what its kind keeps from another line and is no edit.
#[test]
fn a_reorder_that_changes_nothing_on_an_axis_line_keeps_the_stroke_its_kind_keeps() {
@@ -9216,6 +9336,7 @@ fn graph_commands_refuse_params_of_the_wrong_type() {
("firstRowInFront", json!("yes"), "`firstRowInFront` must be true or false"),
("firstColumnInFront", json!(0), "`firstColumnInFront` must be true or false"),
("filledLines", json!("on"), "`filledLines` must be true or false"),
("lineWidth", json!("4"), "`lineWidth` must be a number, not \"4\""),
("dropShadow", json!(1), "`dropShadow` must be true or false"),
("legendAcrossTop", json!("x"), "`legendAcrossTop` must be true or false"),
("type", json!(5), "`type` must be a string"),
+1 -1
View File
@@ -260,7 +260,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Align",
["Window", "Align"],
None,
"{horizontal?: \"left\"|\"center\"|\"right\", vertical?: \"top\"|\"center\"|\"bottom\", to?: \"selection\"|\"artboard\"|\"key\" (default: the key object when the selection has one, select.key, else the selection; a key guide, select.key {guide}, stays put and the objects line up on its line: a vertical guide sets where left, center and right go and vertical alignment leaves them, a horizontal one the other way round; aligning to the key, the other selected ruler guides move too: a vertical guide to the key's left edge, center or right edge, a horizontal one to its top, center or bottom; aligning to the artboard moves selected guides to its edges too (#3463), and with only guides selected aligning to the selection moves them to their collective bounds), artboard?: index (0-based; with to: \"artboard\", the artboard to align to; the app passes the active one; default: the artboard under the center of the selection, else the first), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} With anchor points selected (Direct Selection), the points align instead: to their own bounds, to the artboard (#1180), or, aligning to the key with a key anchor (select.key {id, anchor}, the last point a Shift-click added), to the key anchor, which stays put",
"{horizontal?: \"left\"|\"center\"|\"right\", vertical?: \"top\"|\"center\"|\"bottom\", to?: \"selection\"|\"artboard\"|\"key\" (default: the key object when the selection has one, select.key, else the selection; a key guide, select.key {guide}, stays put and the objects line up on its line: a vertical guide sets where left, center and right go and vertical alignment leaves them, a horizontal one the other way round; aligning to the key, the other selected ruler guides move too: a vertical guide to the key's left edge, center or right edge, a horizontal one to its top, center or bottom; aligning to the artboard moves selected guides to its edges too (#3463), and with only guides selected aligning to the selection moves them to their collective bounds), artboard?: index (0-based; with to: \"artboard\", the artboard to align to; the app passes the active one; default: the artboard under the center of the selection, else the first), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} With anchor points selected (Direct Selection), the points align instead: to their own bounds, to the artboard (#1180), or, aligning to the key with a key anchor (select.key {id, anchor}), to the key anchor, which stays put",
has_selection_or_guides,
align
),
+28 -1
View File
@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Package",
[],
None,
"{folder?, name?: (default: \"<document> Folder\"), copyLinks?: true, linksFolder?: true (the linked files go in Links/, else next to the document), relink?: true (the packaged document links to the copies), copyFonts?: true (the fonts its type uses go in Fonts/; fonts whose licence doesn't allow embedding are left out), report?: true (<document> Report.txt)} copy the saved document as it is now into folder/name as <document>.vectorcraft with its linked files and fonts; the open document doesn't change → {folder, files: [paths relative to folder/name], links, fonts (counts copied), missingLinks: [file names not found], skippedFonts: [{font, reason}], warnings: [nested files copied unchanged or cycles/depth stopped]}; no folder → the same with {name: \"<name>.zip\", dataBase64} (a zip of the files in <name>/) instead of folder. The warnings and the report name a file outside the automation read roots by its file name",
"{folder?, name?: (default: \"<document> Folder\"), copyLinks?: true, linksFolder?: true (the linked files go in Links/, else next to the document), relink?: true (the packaged document links to the copies), copyFonts?: true (the fonts its type uses go in Fonts/; fonts whose licence doesn't allow embedding are left out), report?: true (<document> Report.txt)} copy the saved document as it is now into folder/name as <document>.vectorcraft with its linked files and fonts; the open document doesn't change → {folder, files: [paths relative to folder/name], links, fonts (counts copied), missingLinks: [file names not found], skippedFonts: [{font, reason}], warnings: [nested files copied unchanged or cycles/depth stopped]}; no folder → the same with {name: \"<name>.zip\", dataBase64} (a zip of the files in <name>/) instead of folder. The warnings and the report name a file outside the automation read roots by its file name. Under automation read roots, the package is refused, before any file is written, while the document, or a linked native document or a linked PDF, .ai or EPS file's native document, links a JavaScript file outside them (svgInteractivity; a URL is not checked)",
has_doc,
package
)]
@@ -113,6 +113,30 @@ thread_local! {
pub(crate) static PARTS_READ: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// The native document that the linked file `name` (`bytes`) is, or carries as the editing data of
/// a PDF, `.ai` or EPS file; `None` for other files and for data that can't be read.
fn carried_document(name: &str, bytes: &[u8]) -> Option<Document> {
if super::place::document::is_native(name, bytes) {
return vectorcraft_format::load_file(bytes).ok().map(|f| f.doc);
}
let data =
if super::place::document::is_pdf(name, bytes) { vectorcraft_pdf::editing(bytes).map(|e| e.data) } else { vectorcraft_eps::native(bytes) };
vectorcraft_format::load(&data?).ok()
}
/// Under read roots, the linked file `name` (`bytes`, found at `path`) is copied only when the
/// native document it is or carries ([`carried_document`]) links no JavaScript file outside them (a
/// relative path taken from the file's folder): the copy would name it.
fn check_carried_scripts(name: &str, bytes: &[u8], path: &str) -> Result<()> {
if crate::file_access::current().is_none() {
return Ok(());
}
match carried_document(name, bytes) {
Some(carried) => super::fileio::check_scripts_of(C, &carried, Some(path), || true),
None => Ok(()),
}
}
/// The fonts of the type on `pages` of the PDF or `.ai` file `name` (`bytes`, found at `path`);
/// none for other files.
fn page_fonts(name: &str, bytes: &[u8], path: &str, pages: &PlacedPages) -> BTreeSet<super::fonts::UsedFont> {
@@ -291,6 +315,7 @@ impl<'a> Collector<'a> {
// read from its editing data links are copied beside it.
let pages = placed.get(&file.path);
let placed_file = pages.is_some();
check_carried_scripts(&file.name, &bytes, found_path)?;
if placed_file && let Some(mut art) = super::place::document::editing_data(&file.name, &bytes) {
if depth >= vectorcraft_doc::placed_document::MAX_DEPTH {
self.warn(&mut lines, format!("{shown}: nesting limit reached; copied unchanged without collecting its own links"));
@@ -471,6 +496,8 @@ fn prepare(s: &mut Session, p: &Value) -> Result<Package> {
let given_name = text_param(p, "name", C)?;
let folder = text_param(p, "folder", C)?;
let doc_path = s.doc()?.path.clone().ok_or_else(|| bad(C, "save the document first: Package collects a saved document"))?;
// Before anything is collected or written, here where the request's read roots are in force.
super::fileio::check_linked_scripts(C, "vectorcraft", s.doc()?, &Value::Null)?;
let stem = Path::new(&doc_path).file_stem().map_or_else(|| "Untitled".into(), |s| s.to_string_lossy().into_owned());
let name = given_name.map_or_else(|| format!("{stem} Folder"), str::to_string);
if name.trim().is_empty() || name == "." || name == ".." || name.contains(['/', '\\', ':', '*', '?', '"', '<', '>', '|']) {
+1 -1
View File
@@ -39,7 +39,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Swap Fill and Stroke",
[],
Some("Shift+X"),
"{ids?|id?} swap the fill and stroke of the selection (type too) and of the defaults. On a path directly in a graph series, the graph also stores the swapped paints and the stroke weight, and on a graph label the swapped paints of its characters for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (exceptions: docs/mcp.md)",
"{ids?|id?} swap the fill and stroke of the selection (type too) and of the defaults. On a path directly in a graph series, the graph also stores the swapped paints and the stroke weight, and on a graph label the swapped paints of its characters for every label of its kind, and on a graph's axis line, tick mark or radar ring what the swap changes on its rows for every line of its kind (exceptions: docs/mcp.md)",
has_doc,
swap
),
@@ -45,6 +45,7 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.packaging.setRoleSwatch",
"addon.pathtools.addPoints",
"addon.pathtools.close",
"addon.pathtools.commonTangents",
"addon.pathtools.corner",
"addon.pathtools.cornerRemove",
"addon.pathtools.cornerSet",
+59 -16
View File
@@ -34,7 +34,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Recolor Artwork",
["Edit", "Edit Colors"],
None,
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex); may be empty: an empty row recolours nothing, adds no library swatch and gives `group` no colour], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour] (what `group` is rewritten with; default: the rows' new colours, in order, excluded and empty rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke, and on a graph label the new paint of its characters and rows for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
"{map: rows [{from: [colour keys (recolor.colors) or \"#rrggbb\" (every colour shown as that hex); may be empty: an empty row recolours nothing, adds no library swatch and gives `group` no colour unless `added`], to: colour (hex, key, {c,m,y,k} or {l,a,b}) | null (in from, to and groupColors, #rrggbbaa and #rgba are refused), exclude?: false (the row's colours are kept), tint?: 100 (percent; with limitTo, art linked to the global or spot swatch the new color is takes this share of its tint), added?: false (an empty row's new color is a color added to `group`)}] | {\"key or #rrggbb\": colour, …} (one row per colour), method?: \"exact\" (default)|\"preserveTints\"|\"scaleTints\"|\"tintsShades\"|\"hueShift\" (how a row's colours take its new colour, relative to the row's darkest, average or most saturated colour), limitTo?: swatch library id or name; or \"document\" (the document's swatches): new colours snap to its nearest colour, group?: colour group to rewrite, groupColors?: [colour | null] (what `group` is rewritten with, a null removing the group's swatch at its place; default: the new colors of the rows with current colors, in order, then those of the empty rows with `added`, excluded rows left out), rename?: the group's new name, includeImages?: true, includePatterns?: true, globalAdjust?: {saturation?: 0, brightness?: 0, temperature?: 0, luminosity?: 0} (Global Adjust: percent from -100 to 100, 0 changes nothing; every colour a row that isn't excluded recolours, and the group's new colours, take the same change after the row's new colour: saturation scales HSB saturation by 1 + saturation/100, brightness moves HSB brightness that share of the way to full or to black, temperature adds 0.2 × temperature/100 to red and takes it from blue, luminosity moves Lab lightness that share of the way to 100 or 0 keeping a and b; with limitTo each row's new colour takes the change before it snaps to the library)} recolour the selection (gradients, text, meshes, image pixels and pattern tiles included; each new colour keeps the model of the one it replaces (model?: \"keep\" default | \"new\" (the new colour's own model, so a CMYK colour replacing RGB art gives CMYK art) | \"document\" (the document's colour mode)), except a library swatch's with limitTo: art takes the swatch itself, linked to a global or spot colour at its tints, and the swatch joins the document's swatches; art linked to a global swatch of `group` that is rewritten with its row's new color stays linked to it, at its tint, unless the row converts the color into the art's model; other recolored art, and art in a row linked to a global swatch of `group` that is rewritten with another color, keeps its row's new color and loses its swatch link) and the group, as one undo step (none when nothing changes). On a path directly in a graph series, the graph also stores the new paint of the topmost visible fill and stroke, and on a graph label the new paint of its characters and rows for every label of its kind, and on a graph's axis line, tick mark or radar ring its rows for every line of its kind (docs/mcp.md) → {changed, swatches: [names added to the document's swatches], relinked?: with group, the other paints linked to its global swatches that took their new colors, note?: set when a colour kept a model other than its new colour's (see model), notChanged: {locked, hidden} (as edit.colors.invert), warning?: set when notChanged counts any object}",
has_doc,
apply
),
@@ -1384,6 +1384,9 @@ struct Row {
tint: f32,
/// The row's own `model`, which takes the place of the command's for its colors.
model: Option<ModelRule>,
/// `added`: with no current colors, the new color is a color added to the group, which it
/// joins after the colors of the rows with current colors.
added: bool,
}
/// The color model a row's colors take (`model`): each color's own, the new color's, or the
@@ -1437,9 +1440,10 @@ fn parse_rows(p: &Value, cmd: &str) -> Result<Vec<Row>> {
};
let cur = |v: &Value| Match::of(v).ok_or_else(|| bad(cmd, format!("bad current colour {v}")));
match p.get("map") {
Some(Value::Object(m)) => {
m.iter().map(|(k, v)| Ok(Row { from: vec![cur(&json!(k))?], to: new(Some(v))?, exclude: false, tint: 1.0, model: None })).collect()
}
Some(Value::Object(m)) => m
.iter()
.map(|(k, v)| Ok(Row { from: vec![cur(&json!(k))?], to: new(Some(v))?, exclude: false, tint: 1.0, model: None, added: false }))
.collect(),
Some(Value::Array(rows)) => rows
.iter()
.map(|r| {
@@ -1450,7 +1454,8 @@ fn parse_rows(p: &Value, cmd: &str) -> Result<Vec<Row>> {
};
let tint = (super::number_or(r, "tint", 100.0, cmd)? / 100.0).clamp(0.0, 1.0) as f32;
let model = ModelRule::param(r, cmd)?;
Ok(Row { from, to: new(r.get("to"))?, exclude: switch_or(r, "exclude", false, cmd)?, tint, model })
let added = switch_or(r, "added", false, cmd)?;
Ok(Row { from, to: new(r.get("to"))?, exclude: switch_or(r, "exclude", false, cmd)?, tint, model, added })
})
.collect(),
_ => Err(bad(cmd, "missing `map` (rows [{from, to}] or {current: new})")),
@@ -1487,6 +1492,10 @@ struct ColorMap {
group: Vec<GroupSwatch>,
keys: HashMap<ColorKey, usize>,
hexes: HashMap<String, usize>,
/// The current colors of the rows whose new color was removed (`to: null`, not excluded),
/// which keep their colors.
removed_keys: std::collections::HashSet<ColorKey>,
removed_hexes: std::collections::HashSet<String>,
/// Set when a colour took a new colour of another model in its own model.
converted: std::cell::Cell<bool>,
/// The Global Adjust every mapped colour takes after its row's new colour.
@@ -1505,11 +1514,23 @@ impl ColorMap {
group,
keys: HashMap::new(),
hexes: HashMap::new(),
removed_keys: Default::default(),
removed_hexes: Default::default(),
converted: Default::default(),
adjust,
};
for (n, r) in rows.iter().enumerate().filter(|(_, r)| !r.from.is_empty()) {
let Some(to) = r.new_color() else { continue };
let Some(to) = r.new_color() else {
if !r.exclude {
for m in &r.from {
match m {
Match::Key(k) => out.removed_keys.insert(*k),
Match::Hex(h) => out.removed_hexes.insert(h.clone()),
};
}
}
continue;
};
let i = out.rows.len();
let colors: Vec<Color> = r.from.iter().map(Match::color).collect();
let link = links.get(n).cloned().flatten();
@@ -1550,9 +1571,18 @@ impl ColorMap {
/// the row gives it the new color in that color's model and the Global Adjust gives it the
/// swatch's new color at that tint;
/// other rows map the colour, which loses its link when it changes or when the group's rewrite
/// would change it. True when anything changed.
/// would change it; a color of a row whose new color was removed keeps its color and loses its
/// link to a swatch of the group whose rewrite would change it. True when anything changed.
fn map_link(&self, c: &mut Color, link: &mut Option<String>, tint: &mut f32) -> bool {
let Some(i) = self.row_of(*c) else { return false };
let Some(i) = self.row_of(*c) else {
let removed = self.removed_keys.contains(&ColorKey::of(c)) || self.removed_hexes.contains(&c.to_hex());
let rewritten = link.as_deref().and_then(|n| self.group.iter().find(|g| g.name == n)).is_some_and(|g| g.shown.tinted(*tint) != *c);
if removed && rewritten {
*link = None;
return true;
}
return false;
};
let (Some(row), Some(l)) = (self.rows.get(i), self.links.get(i)) else { return false };
if l.is_none()
&& let Some(g) = link.as_deref().and_then(|n| self.group.iter().find(|g| g.name == n))
@@ -1650,18 +1680,27 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
Some(Value::Array(cs)) => Some(cs),
Some(_) => return Err(bad(C, "`groupColors` must be an array")),
};
let new: Vec<Color> = match group_colors {
// A null in groupColors removes the group's swatch at its place.
let new: Vec<Option<Color>> = match group_colors {
Some(cs) => cs
.iter()
.map(|v| {
color_value(v)
.map(|v| match v {
Value::Null => Ok(None),
v => color_value(v)
.map(|c| adjust.apply(c))
.map(|c| in_doc_model(palette.as_ref().map_or(c, |pl| pl.nearest(c))))
.ok_or_else(|| bad(C, format!("bad colour {v} in groupColors")))
.map(|c| Some(in_doc_model(palette.as_ref().map_or(c, |pl| pl.nearest(c)))))
.ok_or_else(|| bad(C, format!("bad colour {v} in groupColors"))),
})
.collect::<Result<_>>()?,
// A row with no current colors gives the group no color.
None => rows.iter().filter(|r| !r.from.is_empty()).filter_map(Row::new_color).map(|c| mapped_adjust.apply(c)).collect(),
// A row with no current colors gives the group no color, unless it is a color added to
// the group: those follow the colors of the rows with current colors.
None => rows
.iter()
.filter(|r| !r.from.is_empty())
.chain(rows.iter().filter(|r| r.from.is_empty() && r.added))
.filter_map(Row::new_color)
.map(|c| Some(mapped_adjust.apply(c)))
.collect(),
};
let rename = text_param(p, "rename", C)?;
let colorized_ok = super::paint::check_colorized(&s.doc()?.doc).is_ok();
@@ -1696,7 +1735,8 @@ fn apply(s: &mut Session, p: &Value) -> Result<Value> {
.iter()
.zip(&new)
.filter(|(w, _)| w.global && !w.is_reserved())
.map(|(w, c)| GroupSwatch { name: w.name.clone(), color: *c, shown: d.linked_color(*c, w.spot) })
.filter_map(|(w, c)| Some((w, (*c)?)))
.map(|(w, c)| GroupSwatch { name: w.name.clone(), color: c, shown: d.linked_color(c, w.spot) })
.collect()
})
.unwrap_or_default();
@@ -1779,6 +1819,9 @@ fn randomize(_: &mut Session, p: &Value) -> Result<Value> {
if let Some(m) = model {
row["model"] = json!(m.id());
}
if r.added {
row["added"] = json!(true);
}
row
})
.collect();
+21 -22
View File
@@ -82,19 +82,11 @@ pub fn specs() -> Vec<CommandSpec> {
"Cancel Key Object",
[],
None,
"{id?: a selected top-level object (not a layer, a compound-path member or an object inside another selected object); one of two or more or the only one with ruler guides selected (the Selection tool: a click on one object of a selection of several, or of one with guides; on the key again: no id), guide?: index (a selected ruler guide, guide.list, with one or more objects selected: the Selection tool's click on a selected guide; Align lines the objects up on it and the guide stays put), anchor?: [subpath, anchor] with `id` the path (an anchor point selected with Direct Selection beside at least one other point becomes the key anchor: Align and Distribute move the other points relative to it and it stays put; select.anchors add or toggle of one point makes it the key anchor, as a Shift-click does)} the key object Align aligns to and Distribute Spacing spaces from; without `id` or `guide` it cancels the key, as does a selection that holds only the key and objects inside it (one object, or a group key and its own members) and no ruler guide, or a key guide with no object selected or taken out of the selection, or a key anchor that is deselected, deleted or left as the only selected point; any other id, guide or anchor is an error that leaves the key as it was → {key, guide?, keyAnchor?} (the resulting key object, or null; guide: the key guide, left out without one; keyAnchor: {id, anchor}, left out without one)",
"{id?: a selected top-level object (not a layer, a compound-path member or an object inside another selected object); one of two or more or the only one with ruler guides selected (the Selection tool: a click on one object of a selection of several, or of one with guides; on the key again: no id), guide?: index (a selected ruler guide, guide.list, with one or more objects selected: the Selection tool's click on a selected guide; Align lines the objects up on it and the guide stays put), anchor?: [subpath, anchor] with `id` the path (an anchor point selected with Direct Selection beside at least one other point becomes the key anchor: Align and Distribute move the other points relative to it and it stays put; a click without modifiers on an already-selected anchor point makes it the key anchor)} the key object Align aligns to and Distribute Spacing spaces from; without `id` or `guide` it cancels the key, as does a selection that holds only the key and objects inside it (one object, or a group key and its own members) and no ruler guide, or a key guide with no object selected or taken out of the selection, or a key anchor that is deselected, deleted or left as the only selected point; any other id, guide or anchor is an error that leaves the key as it was → {key, guide?, keyAnchor?} (the resulting key object, or null; guide: the key guide, left out without one; keyAnchor: {id, anchor}, left out without one)",
has_doc,
key
),
cmd!(
"select.anchors",
"Select Anchors",
[],
None,
"{id, anchors: [[subpath, anchor]…], mode: \"set\"|\"add\"|\"toggle\"}; add or toggle that selects one point makes it the key anchor while another point is selected too (see select.key)",
has_doc,
anchors
),
cmd!("select.anchors", "Select Anchors", [], None, "{id, anchors: [[subpath, anchor]…], mode: \"set\"|\"add\"|\"toggle\"}", has_doc, anchors),
cmd!(
"select.segments",
"Select Segments",
@@ -734,17 +726,32 @@ fn key_anchor(s: &mut Session, id: Option<NodeId>, guide: Option<usize>, v: &Val
let st = s.doc()?;
let sel = &st.selection;
let on_path = st.doc.node(id).and_then(|n| n.path_data()).is_some_and(|p| p.subpaths.get(r.0).is_some_and(|sp| r.1 < sp.anchors.len()));
if !on_path || sel.segments.contains_key(&id) || !sel.anchors.get(&id).is_some_and(|set| set.contains(&r)) {
let is_selected_anchor = on_path
&& !sel.segments.contains_key(&id)
&& (sel.anchors.get(&id).is_some_and(|set| set.contains(&r)) || (!sel.anchors.contains_key(&id) && sel.contains(id)));
if !is_selected_anchor {
return Err(bad(C, format!("anchor [{}, {}] of object {id} is not a selected anchor point", r.0, r.1)));
}
// Check the new key on a copy first, so a request that fails leaves the key as it was.
let mut trial = sel.clone();
if !trial.anchors.contains_key(&id)
&& let Some(p) = st.doc.node(id).and_then(|n| n.path_data())
{
trial.anchors.insert(id, p.anchors().map(|(s, a, _)| (s, a)).collect());
}
trial.key_anchor = Some((id, r));
trial.prune(&st.doc);
if trial.key_anchor.is_none() {
return Err(bad(C, "select another anchor point to align to the key anchor"));
}
s.select(|_, sel| sel.key_anchor = Some((id, r)))?;
s.select(|d, sel| {
if !sel.anchors.contains_key(&id)
&& let Some(p) = d.node(id).and_then(|n| n.path_data())
{
sel.anchors.insert(id, p.anchors().map(|(s, a, _)| (s, a)).collect());
}
sel.key_anchor = Some((id, r));
})?;
key_result(s)
}
@@ -891,23 +898,15 @@ fn anchors(s: &mut Session, p: &Value) -> Result<Value> {
if whole && let Some(path) = d.node(id).and_then(|n| n.path_data()) {
e.extend(path.anchors().map(|(s, i, _)| (s, i)));
}
// One point that add or toggle selects becomes the key anchor (a Shift-click with Direct
// Selection); `prune` drops it unless another point is selected too.
let single = refs.len() == 1;
let mut newest = None;
for r in refs {
if mode == "toggle" && e.contains(&r) {
e.remove(&r);
} else if e.insert(r) && single {
newest = Some(r);
} else {
e.insert(r);
}
}
if e.is_empty() {
sel.remove(id);
} else if mode != "set"
&& let Some(r) = newest
{
sel.key_anchor = Some((id, r));
}
})?;
ok()
+27 -15
View File
@@ -1255,43 +1255,54 @@ impl GroupEdit {
}
/// Rewrite colour group `group` with `colors`: its swatches take them in order (keeping their
/// names, kinds and global or spot flags), extra colours are added as new swatches and swatches
/// past the end are removed. Paints linked to its global swatches follow (a removed swatch's are
/// unlinked); `rename` renames the group. A built-in swatch (None, Registration) it would change or
/// remove is refused.
pub(super) fn rewrite_group(d: &mut Document, group: &str, colors: &[Color], rename: Option<&str>, cmd: &str) -> Result<GroupEdit> {
/// names, kinds and global or spot flags), a `None` removes the swatch at its place, extra colors
/// are added as new swatches and swatches past the end are removed. Paints linked to its global
/// swatches follow (a removed swatch's are unlinked); `rename` renames the group. A built-in swatch
/// (None, Registration) it would change or remove is refused.
pub(super) fn rewrite_group(d: &mut Document, group: &str, colors: &[Option<Color>], rename: Option<&str>, cmd: &str) -> Result<GroupEdit> {
let gi = d.swatch_groups.iter().position(|g| g.name == group).ok_or_else(|| bad(cmd, format!("no colour group `{group}`")))?;
let name = match rename.map(str::trim).filter(|n| !n.is_empty() && *n != group) {
Some(n) => d.free_swatch_name(n),
None => group.to_string(),
};
let old = &d.swatch_groups[gi].swatches;
if let Some(w) = old.iter().enumerate().find(|(i, w)| w.is_reserved() && colors.get(*i).is_none_or(|c| w.paint.color() != Some(*c))).map(|x| x.1)
if let Some(w) = old
.iter()
.enumerate()
.find(|(i, w)| w.is_reserved() && colors.get(*i).copied().flatten().is_none_or(|c| w.paint.color() != Some(c)))
.map(|x| x.1)
{
return Err(bad(cmd, format!("`{}` can't be edited or removed", w.name)));
}
let colorized_ok = super::paint::check_colorized(d).is_ok();
let mut relinks = vec![];
let mut swatches = std::mem::take(&mut d.swatch_groups[gi].swatches);
for gone in swatches.split_off(colors.len().min(swatches.len())) {
if gone.global {
relinks.push(Relink { from: gone.name.clone(), to: gone.name, color: None, keep: false });
let old = std::mem::take(&mut d.swatch_groups[gi].swatches);
let old_len = old.len();
// The swatches that stay, each with its new color.
let mut kept: Vec<(Swatch, Color)> = vec![];
for (i, w) in old.into_iter().enumerate() {
match colors.get(i).copied().flatten() {
Some(c) => kept.push((w, c)),
None if w.global => relinks.push(Relink { from: w.name.clone(), to: w.name, color: None, keep: false }),
None => {}
}
}
for (w, c) in swatches.iter_mut().zip(colors) {
if w.paint.color() != Some(*c) {
let mut swatches = Vec::with_capacity(kept.len());
for (mut w, c) in kept {
if w.paint.color() != Some(c) {
// A tint swatch becomes a colour of its own.
w.paint = Paint::solid(*c);
w.paint = Paint::solid(c);
if w.global {
// Art linked to a Lab spot shows it as the Spot Colors options say.
relinks.push(Relink { from: w.name.clone(), to: w.name.clone(), color: Some(d.linked_color(*c, w.spot)), keep: true });
relinks.push(Relink { from: w.name.clone(), to: w.name.clone(), color: Some(d.linked_color(c, w.spot)), keep: true });
}
}
swatches.push(w);
}
let mut free = d.free_swatch_names();
free.insert(&name);
swatches.iter().for_each(|w| free.insert(&w.name));
for c in colors.iter().skip(swatches.len()) {
for c in colors.iter().skip(old_len).flatten() {
let nm = free.take(&color_name(*c));
swatches.push(Swatch { name: nm, paint: Paint::solid(*c), global: false, spot: false });
}
@@ -1320,6 +1331,7 @@ fn swatch_edit_group(s: &mut Session, p: &Value) -> Result<Value> {
let colors: Vec<Color> =
colors.into_iter().enumerate().map(|(i, c)| if old.get(i) == Some(&Some(c)) { c } else { super::paint::new_color(s, p, c) }).collect();
let rename = str_param(p, "rename");
let colors: Vec<Option<Color>> = colors.into_iter().map(Some).collect();
let e = s.edit("Edit Color Group", |d, _| rewrite_group(d, group, &colors, rename, C))?;
e.defaults(s)?;
Ok(json!({"name": e.name, "swatches": e.swatches, "relinked": e.relinked}))
+1
View File
@@ -196,6 +196,7 @@ mod symbol_nine_slice;
mod symbolbounds;
mod symboledit;
mod symbollib;
mod tangent_line;
mod targeting;
mod textcombos;
mod textedit;
+10 -9
View File
@@ -468,7 +468,7 @@ fn styles_symbols_and_images_of_the_same_name_are_renamed() {
assert_eq!(key(&s, img2), src_key);
}
/// A graph whose series fill, value labels and legend rows paint with global swatch "Brand" and
/// A graph whose series fill, value labels, legend rows and axis and ring line rows paint with global swatch "Brand" and
/// whose value labels are set in character style "Emphasis" and paragraph style "Body", as a
/// later redraw would give them to its marks and labels.
fn styled_graph(s: &mut Session) -> NodeId {
@@ -484,8 +484,9 @@ fn styled_graph(s: &mut Session) -> NodeId {
let l = &mut g.label_styles;
l.values = Some(vectorcraft_doc::CharStyle { fill: brand.clone(), style_name: Some("Emphasis".into()), ..Default::default() });
l.values_para = Some(vectorcraft_doc::ParaStyle { style_name: Some("Body".into()), ..Default::default() });
let rows = vectorcraft_doc::SeriesPaint { stroke: Some(brand), ..Default::default() };
l.legend_rows = Some(vectorcraft_doc::graph::LabelRows { paint: rows, ..Default::default() });
let paint = vectorcraft_doc::SeriesPaint { stroke: Some(brand), ..Default::default() };
let rows = vectorcraft_doc::graph::LabelRows { paint, ..Default::default() };
(l.legend_rows, l.axis_rows, l.ring_rows) = (Some(rows.clone()), Some(rows.clone()), Some(rows));
id
}
@@ -515,7 +516,7 @@ fn a_pasted_graph_brings_and_follows_its_label_styles_and_paints() {
let d = doc(&s);
assert!(d.swatch("Brand").is_some(), "{v}");
assert!(d.char_styles.iter().any(|x| x.name == "Emphasis") && d.para_styles.iter().any(|x| x.name == "Body"), "{v}");
let brand = vec!["Brand".to_string(); 3];
let brand = vec!["Brand".to_string(); 5];
assert_eq!(graph_links(&s, ids_of(&v)[0]), (brand.clone(), Some("Emphasis".into()), Some("Body".into())));
// Into a document that gives each name something else: they come in renamed.
@@ -524,15 +525,15 @@ fn a_pasted_graph_brings_and_follows_its_label_styles_and_paints() {
s.execute("charStyle.new", &json!({"name": "Emphasis", "attrs": {"size": 8.0}})).unwrap();
s.execute("paraStyle.new", &json!({"name": "Body", "attrs": {"space_after": 2.0}})).unwrap();
let v = s.execute("edit.pasteInPlace", &json!({"swatchConflict": "add"})).unwrap();
let brand2 = vec!["Brand 2".to_string(); 3];
let brand2 = vec!["Brand 2".to_string(); 5];
assert_eq!(graph_links(&s, ids_of(&v)[0]), (brand2, Some("Emphasis 2".into()), Some("Body 2".into())), "{v}");
// Without formatting: the labels' text styles stay behind.
new_doc(&mut s);
let v = s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap();
assert!(doc(&s).char_styles.is_empty() && doc(&s).para_styles.is_empty(), "{v}");
// The value labels' red characters stay behind too; the series fill and the legend rows keep Brand.
assert_eq!(graph_links(&s, ids_of(&v)[0]), (vec!["Brand".to_string(); 2], None, None));
// The value labels' red characters stay behind too; the series fill, the legend rows and the line rows keep Brand.
assert_eq!(graph_links(&s, ids_of(&v)[0]), (vec!["Brand".to_string(); 4], None, None));
}
/// Each label of graph `id` (the text of its Axes and Legend groups) with its size and its first paragraph's format.
@@ -596,8 +597,8 @@ fn a_graph_pasted_without_formatting_keeps_plain_labels_when_drawn_again() {
let r = node(&s, p).extras().graph.as_deref().unwrap().rect;
let off = [r.x0 - plot.x0 - 10.0, r.y0 - plot.y0 - 20.0, r.x1 - plot.x1 - 10.0, r.y1 - plot.y1 - 20.0];
assert!(off.iter().all(|d| d.abs() < 1e-6), "the plot moves by the offset and keeps its size: {plot:?} → {r:?}");
s.execute("graph.setType", &json!({"id": p.0, "type": "column"})).unwrap();
assert_eq!(graph_label_looks(&s, p), pasted, "a change of type draws them the same way");
s.execute("graph.setType", &json!({"id": p.0, "type": "column", "dropShadow": true})).unwrap();
assert_eq!(graph_label_looks(&s, p), pasted, "a change of graph type options draws them the same way");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
+70 -3
View File
@@ -1504,9 +1504,76 @@ fn the_eraser_tip_takes_its_angle_and_roundness() {
// At 45°, half axes 10 and 2.5: the band is 2·√((10² + 2.5²) / 2), about 14.58 pt, and the
// chord 2 / √(0.5 / 10² + 0.5 / 2.5²), about 6.86 pt.
close(erase(json!({"angle": 45, "roundness": 25})), 2.0 * ((100.0f64 + 6.25) / 2.0).sqrt(), 2.0 / (0.5f64 / 100.0 + 0.5 / 6.25).sqrt());
// A roundness past 100 is kept to 100, and one below 1 to 1.
close(erase(json!({"angle": 90, "roundness": 400})), 20.0, 20.0);
close(erase(json!({"angle": 90, "roundness": 0})), 0.2, 0.2);
// The ends of the Roundness range: 100% is round, and 1% leaves a tip 0.2 pt across.
close(erase(json!({"angle": 90, "roundness": 100})), 20.0, 20.0);
close(erase(json!({"angle": 90, "roundness": 1})), 0.2, 0.2);
}
/// The Eraser refuses an `angle` outside -180 to 180 degrees and a `roundness` outside 1 to 100%,
/// naming the key and the range, and erases nothing. The ends of each range erase, and a key left
/// out or null takes its default: 0 degrees and 100%.
#[test]
fn the_eraser_refuses_an_angle_or_roundness_outside_its_range() {
let mut s = session();
rect(&mut s, 100.0, 100.0, 100.0, 100.0);
s.execute("select.none", &json!({})).unwrap();
let stroke = json!({"points": [[90, 150], [210, 150]], "size": 10});
for angle in [json!(-181), json!(-180.001), json!(180.001), json!(200), json!(1e300), json!(-1e300)] {
refuses_with(&mut s, "path.eraseRegion", &with(&stroke, json!({"angle": angle})), "`angle` must be from -180 to 180 degrees");
}
for roundness in [json!(0), json!(0.999), json!(-25), json!(100.001), json!(400), json!(1e300)] {
refuses_with(&mut s, "path.eraseRegion", &with(&stroke, json!({"roundness": roundness})), "`roundness` must be from 1 to 100%");
}
// A key out of its range is refused when the other key is in range.
refuses_with(&mut s, "path.eraseRegion", &with(&stroke, json!({"angle": 90, "roundness": 400})), "`roundness` must be from 1 to 100%");
refuses_with(&mut s, "path.eraseRegion", &with(&stroke, json!({"angle": 540, "roundness": 25})), "`angle` must be from -180 to 180 degrees");
// The pieces a stroke leaves, undone again.
let mut erased = |tip: serde_json::Value| {
let r = s.execute("path.eraseRegion", &with(&stroke, tip.clone())).unwrap();
assert_eq!(r["ids"].as_array().map(Vec::len), Some(2), "{tip}: the stroke cuts the square in two: {r}");
let pieces: Vec<PathData> = paths(&s).into_iter().map(|p| p.1).collect();
s.execute("edit.undo", &json!({})).unwrap();
s.execute("select.none", &json!({})).unwrap();
pieces
};
// Both ends of each range are inside it.
for tip in [json!({"angle": -180}), json!({"angle": 180}), json!({"angle": 90, "roundness": 1}), json!({"roundness": 100})] {
erased(tip);
}
let default = erased(json!({}));
assert_eq!(erased(json!({"angle": 0, "roundness": 100})), default, "left out, the tip is round at 0 degrees");
assert_eq!(erased(json!({"angle": null, "roundness": null})), default, "null is read as a key left out");
assert!(erased(json!({"angle": 0, "roundness": 25})) != default, "a quarter-round level tip erases a narrower band");
}
/// The Scissors command refuses a `t` outside 0 to 1 instead of cutting at the nearer end of the
/// segment, with or without an `anchor` beside it; 0 and 1 cut at the segment's two anchors.
#[test]
fn scissors_refuse_a_t_outside_the_segment() {
let mut s = session();
let id = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
let before = path(&s, id);
for t in [json!(-0.1), json!(-1e-9), json!(1.000001), json!(1.1), json!(1e300), json!(-1e300)] {
refuses_with(&mut s, "path.split", &json!({"id": id.0, "segment": 0, "t": t}), "`t` must be from 0 to 1");
refuses_with(&mut s, "path.split", &json!({"id": id.0, "anchor": 1, "t": t}), "`t` must be from 0 to 1");
}
// 0 opens the square at the segment's first anchor, 1 at its second, and 0.5 at a new anchor
// between them.
for (t, anchors, start) in [
(json!(0), 5, before.subpaths[0].anchors[0].p),
(json!(1), 5, before.subpaths[0].anchors[1].p),
(json!(0.5), 6, before.subpaths[0].anchors[0].p.midpoint(before.subpaths[0].anchors[1].p)),
] {
s.execute("path.split", &json!({"id": id.0, "segment": 0, "t": t})).unwrap();
let cut = path(&s, id);
assert!(!cut.subpaths[0].closed && cut.subpaths[0].anchors.len() == anchors, "t {t}: {cut:?}");
assert!((cut.subpaths[0].anchors[0].p - start).hypot() < 1e-9, "t {t}: the cut starts at {:?}", cut.subpaths[0].anchors[0].p);
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(path(&s, id), before, "t {t}: undo");
}
// Left out, `t` is 0.5.
s.execute("path.split", &json!({"id": id.0, "segment": 0})).unwrap();
assert_eq!(path(&s, id).subpaths[0].anchors.len(), 6);
}
#[test]
+136
View File
@@ -341,3 +341,139 @@ fn svg_output_keeps_linked_javascript_files_a_caller_may_read() {
let text = run(&mut s, "document.serialize", json!({"format": "svg"}))["text"].as_str().unwrap().to_string();
assert!(text.contains(&format!("<script xlink:href=\"{outside}\"/>")), "{text}");
}
/// The JavaScript files that the native document a `document.serialize` reply carries links.
fn carried_scripts(r: &Value) -> Vec<String> {
let bytes = vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap();
let native = if bytes.starts_with(b"%PDF") { vectorcraft_pdf::editing(&bytes).expect("editing data").data } else { bytes };
vectorcraft_format::load(&native).unwrap().svg_scripts
}
/// A caller confined to read roots: every output that carries the native document (a native file
/// or template, a `.ai` or EPS file, a PDF with Preserve Editing, a package) of a document that
/// links a JavaScript file outside them is refused before a file or folder is written, with an
/// error that names no file or folder, and the document keeps the link.
#[test]
fn confined_native_output_refuses_a_linked_javascript_file_outside_the_read_roots() {
let away = Folder::new("native-script-away");
let home = Folder::new("native-script-home");
let script = away.file("menu.js");
let mut s = session();
let a = rect(&mut s, 10.0);
run(&mut s, "svgInteractivity.addFile", json!({"file": script}));
run(&mut s, "assets.add", json!({"ids": [a.0]}));
let own = home.file("own.vectorcraft");
run(&mut s, "file.saveAs", json!({"path": own}));
let before = std::fs::read(&own).unwrap();
rect(&mut s, 50.0);
let roots = crate::file_access::AutomationRoots::new(&[&home.0], &[&home.0]).unwrap().unwrap();
let hidden = [away.0.to_string_lossy().into_owned(), home.0.to_string_lossy().into_owned(), "menu.js".to_string()];
let refused = |s: &mut Session, cmd: &str, p: Value| {
let e = crate::file_access::confine(Some(&roots), || s.execute(cmd, &p)).expect_err(cmd);
assert!(matches!(e, EngineError::BadParams { .. }), "{cmd} {p}: {e:?}");
let e = e.to_string();
assert!(e.contains("a linked JavaScript file is outside the read roots"), "{cmd} {p}: {e}");
for h in &hidden {
assert!(!e.contains(h.as_str()), "{cmd} {p} names {h}: {e}");
}
};
let file = |name: &str| home.file(name);
let out = file("out");
refused(&mut s, "document.serialize", json!({}));
for format in ["vectorcraft", "template", "pdf", "ai", "eps"] {
refused(&mut s, "document.serialize", json!({"format": format}));
refused(&mut s, "document.export", json!({"format": format}));
refused(&mut s, "document.export", json!({"format": format, "selectedOnly": true}));
refused(&mut s, "document.exportSelection", json!({"format": format}));
}
// Every artboard picked, and Preserve Editing asked for.
refused(&mut s, "document.serialize", json!({"format": "pdf", "range": "1", "preserveEditing": true}));
refused(&mut s, "document.serialize", json!({"format": "ai", "artboards": [0], "pdfCompatible": false}));
refused(&mut s, "document.export", json!({"format": "pdf", "path": file("export.pdf")}));
refused(&mut s, "document.export", json!({"format": "ai", "path": file("export.ai")}));
refused(&mut s, "document.export", json!({"format": "eps", "path": file("export.eps")}));
refused(&mut s, "document.export", json!({"format": "vectorcraft", "path": file("export.vectorcraft")}));
refused(&mut s, "document.exportPdf", json!({}));
refused(&mut s, "document.exportPdf", json!({"path": file("direct.pdf")}));
refused(&mut s, "document.exportEps", json!({"path": file("direct.eps")}));
refused(&mut s, "document.save", json!({}));
refused(&mut s, "document.save", json!({"path": file("save.pdf")}));
refused(&mut s, "file.saveAs", json!({"path": file("save-as.ai")}));
// A saved `.ai` file has the artboards as its pages, whatever `useArtboards` says.
refused(&mut s, "file.saveAs", json!({"path": file("save-as-art.ai"), "useArtboards": false}));
refused(&mut s, "file.saveAs", json!({"path": file("save-as.eps")}));
refused(&mut s, "file.saveCopy", json!({"path": file("copy.vectorcraft")}));
refused(&mut s, "file.saveAsTemplate", json!({}));
refused(&mut s, "file.saveAsTemplate", json!({"format": "ait"}));
refused(&mut s, "document.exportForScreens", json!({"folder": out, "formats": [{"format": "png"}, {"format": "vectorcraft"}]}));
refused(&mut s, "document.exportForScreens", json!({"zip": true, "formats": [{"format": "pdf", "preserveEditing": true}]}));
refused(&mut s, "assets.export", json!({"folder": out, "formats": [{"format": "ai"}]}));
refused(&mut s, "assets.export", json!({"folder": out, "formats": [{"format": "eps"}]}));
refused(&mut s, "file.package", json!({"folder": out}));
refused(&mut s, "file.package", json!({}));
assert_eq!(std::fs::read(&own).unwrap(), before, "the document's own file is left as it was");
let written: Vec<_> = std::fs::read_dir(&home.0).unwrap().map(|e| e.unwrap().file_name()).collect();
assert_eq!(written, ["own.vectorcraft"]);
assert_eq!(s.doc().unwrap().doc.svg_scripts, [script]);
}
/// A confined caller still writes the outputs that carry no native document (a PDF without
/// Preserve Editing, a PDF or `.ai` file of the art's bounds or of some artboards, a legacy `.ai`
/// file, an image), and
/// native outputs that link only JavaScript files it may read keep them as stored. A caller without
/// roots writes a file outside them too.
#[test]
fn confined_output_without_the_document_or_with_scripts_the_caller_may_read_is_written() {
let away = Folder::new("native-script-kept-away");
let home = Folder::new("native-script-kept-home");
let outside = away.file("menu.js");
let mut s = session();
rect(&mut s, 10.0);
run(&mut s, "artboard.new", json!({"x": 200, "y": 0, "width": 100, "height": 100}));
run(&mut s, "svgInteractivity.addFile", json!({"file": outside}));
let roots = crate::file_access::AutomationRoots::new(&[&home.0], &[&home.0]).unwrap().unwrap();
let written = |s: &mut Session, cmd: &str, p: Value| {
crate::file_access::confine(Some(&roots), || s.execute(cmd, &p)).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"))
};
for p in [
json!({"format": "pdf", "preserveEditing": false}),
json!({"format": "pdf", "useArtboards": false}),
json!({"format": "pdf", "range": "2"}),
json!({"format": "ai", "artboards": [1]}),
json!({"format": "ai", "useArtboards": false}),
json!({"format": "ai", "aiVersion": "7"}),
json!({"format": "png"}),
] {
written(&mut s, "document.serialize", p);
}
written(&mut s, "document.exportPdf", json!({"preserveEditing": false}));
written(&mut s, "document.exportForScreens", json!({"zip": true, "formats": [{"format": "pdf"}]}));
// A PDF of each artboard leaves the editing data out: it holds one of the two.
written(&mut s, "document.exportForScreens", json!({"zip": true, "formats": [{"format": "pdf", "preserveEditing": true}]}));
let refused = |s: &mut Session, p: Value| {
let e = crate::file_access::confine(Some(&roots), || s.execute("document.exportForScreens", &p)).expect_err("refused").to_string();
assert!(e.contains("a linked JavaScript file is outside the read roots"), "{p}: {e}");
};
// One PDF of both artboards, and Full Document's PDF of every artboard, carry it.
refused(&mut s, json!({"zip": true, "pdfs": "single", "formats": [{"format": "pdf", "preserveEditing": true}]}));
refused(&mut s, json!({"zip": true, "fullDocument": true, "formats": [{"format": "pdf", "preserveEditing": true}]}));
// Without roots, the native document keeps a file outside them.
let r = run(&mut s, "document.serialize", json!({}));
assert_eq!(carried_scripts(&r), [outside.as_str()]);
// Files the caller may read: inside the read roots, relative to the document's folder, a URL.
let inside = home.file("menu.js");
let url = "https://example.com/scripts/menu.js";
let kept = [inside.as_str(), "lib/tools.js", url];
let mut s = session();
rect(&mut s, 10.0);
for file in kept {
run(&mut s, "svgInteractivity.addFile", json!({"file": file}));
}
run(&mut s, "file.saveAs", json!({"path": home.file("doc.vectorcraft")}));
for format in ["vectorcraft", "pdf"] {
let r = written(&mut s, "document.serialize", json!({"format": format}));
assert_eq!(carried_scripts(&r), kept, "{format}");
}
written(&mut s, "document.exportPdf", json!({"path": home.file("doc.pdf")}));
written(&mut s, "file.package", json!({}));
}
+116 -20
View File
@@ -1,6 +1,7 @@
//! #1636: the key anchor. With Direct Selection, the point a Shift-click adds to two or more
//! selected anchor points is the key anchor; Align moves the other points to it, Distribute with a
//! spacing places them from it, and it stays in place.
//! #1636: the key anchor. When multiple anchors are selected with Direct Selection,
//! clicking an already-selected anchor point without modifiers designates it as the key anchor;
//! Align moves the other points to it, Distribute with a spacing places them from it, and it stays in place.
//! Deselecting, pressing Escape, or clicking canvas clears the key anchor designation.
use serde_json::json;
use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
@@ -34,56 +35,148 @@ fn click(s: &mut Session, x: f64, y: f64, shift: bool) {
}
#[test]
fn a_shift_click_makes_the_key_anchor_and_a_plain_click_narrows_the_selection() {
fn clicking_an_already_selected_anchor_makes_it_the_key_anchor() {
let mut s = session();
let id = path(&mut s, "M100 40 L200 60 L150 160 Z");
s.select_tool("directSelection", ViewInfo::default()).unwrap();
// 1st click selects point (0, 0) alone.
click(&mut s, 100.0, 40.0, false);
assert_eq!(key_anchor(&s), None, "one point: no key anchor");
// Shift-click adds point (0, 2) to selection. No key anchor yet.
click(&mut s, 150.0, 160.0, true);
assert_eq!(key_anchor(&s), Some((id, (0, 2))), "the point the Shift-click added");
assert_eq!(key_anchor(&s), None, "Shift-click only adds to selection");
// Shift-click adds point (0, 1) to selection. No key anchor yet.
click(&mut s, 200.0, 60.0, true);
assert_eq!(key_anchor(&s), Some((id, (0, 1))), "the last point added");
assert_eq!(key_anchor(&s), None, "Shift-click only adds to selection");
// Clicking an already-selected anchor without modifiers designates it as the Key Anchor.
click(&mut s, 200.0, 60.0, false);
assert_eq!(key_anchor(&s), Some((id, (0, 1))), "clicking selected anchor designates key anchor");
let inspect = s.execute("document.inspect", &json!({})).unwrap();
assert_eq!(inspect["keyAnchor"], json!({"id": id.0, "anchor": [0, 1]}));
// A Shift-click on the key anchor deselects it, and there is no key anchor.
click(&mut s, 200.0, 60.0, true);
assert_eq!(key_anchor(&s), None);
click(&mut s, 200.0, 60.0, true);
// A plain click on one of the selected points selects that point alone.
click(&mut s, 100.0, 40.0, false);
// Clicking the key anchor again cancels the key anchor.
click(&mut s, 200.0, 60.0, false);
assert_eq!(key_anchor(&s), None, "clicking key anchor again cancels it");
let inspect = s.execute("document.inspect", &json!({})).unwrap();
assert!(inspect["keyAnchor"].is_null());
// Clicking another selected anchor designates that one as the key anchor.
click(&mut s, 150.0, 160.0, false);
assert_eq!(key_anchor(&s), Some((id, (0, 2))));
// Pressing Escape cancels the key anchor designation while keeping points selected.
s.tool_key(vectorcraft_tools::ToolKey::Escape, Mods::default(), ViewInfo::default()).unwrap();
assert_eq!(key_anchor(&s), None, "Escape cancels key anchor");
let sel = &s.doc().unwrap().selection;
assert_eq!(sel.anchors.get(&id).map(|a| a.iter().copied().collect::<Vec<_>>()), Some(vec![(0, 0)]));
assert_eq!(sel.key_anchor, None);
assert_eq!(sel.anchors.get(&id).map(|a| a.len()), Some(3), "points remain selected");
// Designate key anchor:
click(&mut s, 150.0, 160.0, false);
assert_eq!(key_anchor(&s), Some((id, (0, 2))));
// Canvas click clears selection and key anchor.
click(&mut s, 500.0, 500.0, false); // canvas click
assert_eq!(key_anchor(&s), None, "canvas click clears key anchor");
assert!(s.doc().unwrap().selection.is_empty(), "canvas click clears selection");
// Re-select multiple anchors:
click(&mut s, 100.0, 40.0, false); // select (0, 0)
click(&mut s, 200.0, 60.0, true); // add (0, 1)
assert_eq!(key_anchor(&s), None);
click(&mut s, 200.0, 60.0, false); // make (0, 1) key anchor
assert_eq!(key_anchor(&s), Some((id, (0, 1))));
// Shift-click on the key anchor deselects it, clearing the key anchor.
click(&mut s, 200.0, 60.0, true);
assert_eq!(key_anchor(&s), None, "deselecting key anchor clears it");
}
#[test]
fn align_moves_the_other_points_to_the_key_anchor() {
let mut s = session();
let id = path(&mut s, "M100 40 L200 60 L150 160 L60 120 Z");
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0], [0, 1]], "mode": "set"})).unwrap();
assert_eq!(key_anchor(&s), None, "a set selects no key anchor");
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 2]], "mode": "add"})).unwrap();
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0], [0, 1], [0, 2]], "mode": "set"})).unwrap();
assert_eq!(key_anchor(&s), None, "set selects no key anchor");
s.execute("select.key", &json!({"id": id.0, "anchor": [0, 2]})).unwrap();
assert_eq!(key_anchor(&s), Some((id, (0, 2))));
// Horizontal Left aligns other selected points to key anchor's x (150).
s.execute("object.align", &json!({"horizontal": "left"})).unwrap();
assert_eq!(pts(&s, id), [(150.0, 40.0), (150.0, 60.0), (150.0, 160.0), (60.0, 120.0)], "to the key anchor's x");
// Vertical Bottom aligns other selected points to key anchor's y (160).
s.execute("object.align", &json!({"vertical": "bottom"})).unwrap();
assert_eq!(pts(&s, id), [(150.0, 160.0), (150.0, 160.0), (150.0, 160.0), (60.0, 120.0)], "the key anchor stays");
let steps = super::history(&s);
s.execute("object.align", &json!({"vertical": "top"})).unwrap();
assert_eq!(super::history(&s), steps, "nothing moved: no undo step");
// `to: "selection"` aligns to the points' bounds instead.
// `to: "selection"` aligns to the points' collective bounds instead.
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 3]], "mode": "add"})).unwrap();
s.execute("object.align", &json!({"horizontal": "left", "to": "selection"})).unwrap();
assert_eq!(pts(&s, id).iter().map(|p| p.0).collect::<Vec<_>>(), [60.0; 4]);
}
#[test]
fn align_commands_across_paths_without_moving_key_anchor() {
let mut s = session();
let a = path(&mut s, "M100 100 L200 100 L200 200 Z");
let b = path(&mut s, "M300 300 L400 350 Z");
// Select point (0, 1) on path a (at 200, 100) and point (0, 0) on path b (at 300, 300).
s.execute("select.anchors", &json!({"id": a.0, "anchors": [[0, 1]], "mode": "set"})).unwrap();
s.execute("select.anchors", &json!({"id": b.0, "anchors": [[0, 0]], "mode": "add"})).unwrap();
// Set point (0, 1) of a as the key anchor.
s.execute("select.key", &json!({"id": a.0, "anchor": [0, 1]})).unwrap();
assert_eq!(key_anchor(&s), Some((a, (0, 1))));
// Align Horizontal Center: point (0, 0) of b moves to x=200, while point on a does not move!
s.execute("object.align", &json!({"horizontal": "center"})).unwrap();
assert_eq!(pts(&s, a)[1], (200.0, 100.0), "key anchor on a does not move");
assert_eq!(pts(&s, b)[0].0, 200.0, "survivor point on b aligned to key anchor x");
assert_eq!(pts(&s, b)[1], (400.0, 350.0), "unselected point on b was not moved");
// Align Vertical Center / Middle: point (0, 0) of b moves to y=100.
s.execute("object.align", &json!({"vertical": "center"})).unwrap();
assert_eq!(pts(&s, a)[1], (200.0, 100.0), "key anchor on a still did not move");
assert_eq!(pts(&s, b)[0].1, 100.0, "survivor point on b aligned to key anchor y");
}
#[test]
fn single_step_undo_redo_for_key_anchor_alignment() {
let mut s = session();
let a = path(&mut s, "M100 100 L200 150 Z");
let b = path(&mut s, "M300 300 L400 350 Z");
s.execute("select.anchors", &json!({"id": a.0, "anchors": [[0, 0]], "mode": "set"})).unwrap();
s.execute("select.anchors", &json!({"id": b.0, "anchors": [[0, 0]], "mode": "add"})).unwrap();
s.execute("select.key", &json!({"id": a.0, "anchor": [0, 0]})).unwrap();
let initial_a = pts(&s, a);
let initial_b = pts(&s, b);
// Run align:
s.execute("object.align", &json!({"horizontal": "right"})).unwrap();
assert_eq!(pts(&s, a)[0], (100.0, 100.0), "key anchor did not move");
assert_eq!(pts(&s, b)[0].0, 100.0, "survivor moved to key anchor x");
// Undo reverts to initial in one step:
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(pts(&s, a), initial_a, "undo restored a");
assert_eq!(pts(&s, b), initial_b, "undo restored b");
// Redo re-aligns in one step:
s.execute("edit.redo", &json!({})).unwrap();
assert_eq!(pts(&s, a)[0], (100.0, 100.0));
assert_eq!(pts(&s, b)[0].0, 100.0);
}
#[test]
fn distribute_with_a_spacing_places_the_points_from_the_key_anchor() {
let mut s = session();
let id = path(&mut s, "M10 10 L20 50 L100 30 L60 90");
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0], [0, 1]], "mode": "set"})).unwrap();
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 2]], "mode": "toggle"})).unwrap();
s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0], [0, 1], [0, 2]], "mode": "set"})).unwrap();
s.execute("select.key", &json!({"id": id.0, "anchor": [0, 2]})).unwrap();
s.execute("object.distributeSpacing", &json!({"axis": "horizontal", "spacing": 20})).unwrap();
assert_eq!(pts(&s, id), [(60.0, 10.0), (80.0, 50.0), (100.0, 30.0), (60.0, 90.0)], "20 apart, outward from the key anchor");
s.execute("object.distribute", &json!({"vertical": "center", "spacing": 5})).unwrap();
@@ -100,6 +193,7 @@ fn the_key_anchor_goes_when_it_can_no_longer_be_one() {
let b = path(&mut s, "M300 300 L400 300");
s.execute("select.anchors", &json!({"id": a.0, "anchors": [[0, 0]], "mode": "set"})).unwrap();
s.execute("select.anchors", &json!({"id": b.0, "anchors": [[0, 1]], "mode": "add"})).unwrap();
s.execute("select.key", &json!({"id": b.0, "anchor": [0, 1]})).unwrap();
assert_eq!(key_anchor(&s), Some((b, (0, 1))), "a point of another path");
assert!(s.doc().unwrap().selection.has_key());
let r = s.execute("select.key", &json!({})).unwrap();
@@ -114,6 +208,7 @@ fn the_key_anchor_goes_when_it_can_no_longer_be_one() {
let c = path(&mut s, "M500 500 L600 500");
s.execute("select.set", &json!({"ids": [c.0]})).unwrap();
s.execute("select.anchors", &json!({"id": a.0, "anchors": [[0, 1]], "mode": "add"})).unwrap();
s.execute("select.key", &json!({"id": a.0, "anchor": [0, 1]})).unwrap();
assert_eq!(key_anchor(&s), Some((a, (0, 1))), "beside a path selected whole");
s.execute("select.key", &json!({"id": c.0})).unwrap();
let sel = &s.doc().unwrap().selection;
@@ -154,6 +249,7 @@ fn a_rejected_select_key_keeps_the_key_anchor() {
let a = path(&mut s, "M100 40 L200 60 L150 160 Z");
s.execute("select.anchors", &json!({"id": a.0, "anchors": [[0, 0], [0, 9]], "mode": "set"})).unwrap();
s.execute("select.anchors", &json!({"id": a.0, "anchors": [[0, 1]], "mode": "add"})).unwrap();
s.execute("select.key", &json!({"id": a.0, "anchor": [0, 1]})).unwrap();
assert_eq!(key_anchor(&s), Some((a, (0, 1))));
// [0, 9] is in the selection but not on the path.
let err = s.execute("select.key", &json!({"id": a.0, "anchor": [0, 9]})).expect_err("a point the path does not have").to_string();
+24
View File
@@ -278,6 +278,30 @@ fn each_copys_shadow_expands_as_the_canvas_draws_it() {
assert_eq!(diff, 0, "{diff} pixels differ");
}
/// Each copy of a fill's own Transform effect, and each copy of its object's Transform effect,
/// draws the fill's drop shadow under itself, scaled with it, and Expand Appearance keeps those
/// shadows: the copy (10..50 across, 90..130 down) has its own shadow 40 pt to its right.
#[test]
fn each_copys_fill_shadow_expands_as_the_canvas_draws_it() {
let shadow = json!({"x": 20, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"});
let copies = json!({"scaleH": 200, "scaleV": 200, "moveV": 80, "copies": 1});
for own in [true, false] {
let mut s = session();
run(&mut s, "shape.rectangle", json!({"x": 20, "y": 20, "width": 20, "height": 20}));
run(&mut s, "paint.setFill", json!({"color": "#ff0000"}));
run(&mut s, "paint.setStroke", json!({"none": true}));
run(&mut s, "effect.apply", json!({"effect": "stylize.dropShadow", "params": shadow, "item": 0}));
let item = if own { json!(0) } else { json!(null) };
run(&mut s, "effect.apply", json!({"effect": "distort.transform", "params": copies, "item": item}));
let before = render(&s);
assert_eq!(before.pixel(80, 110), [0, 255, 0, 255], "own {own}: the copy's shadow");
run(&mut s, "effect.expandAppearance", json!({}));
let after = render(&s);
let diff = differing(&before, &after, 64);
assert_eq!(diff, 0, "own {own}: {diff} pixels differ");
}
}
/// Each copy of type's Transform effect draws the drop shadow listed before the effect under
/// itself, scaled with it, and Expand Appearance keeps those shadows: the type's copy, scaled 200 %
/// and moved 80 pt down, has its shadow 40 pt to the right of its letters rather than the type's
+54
View File
@@ -351,6 +351,60 @@ fn a_confined_package_names_files_outside_the_read_root_by_name() {
assert!(info.to_string().contains(&dir.file("art/red.png")), "the person's: {info}");
}
/// A confined request packages no document that links, or places a native document or a PDF with
/// Preserve Editing that links, a JavaScript file outside its read roots: the package is refused
/// before anything is written, with an error that names no file or folder. A JavaScript file inside
/// them is packaged, and so is one outside them when the person packages.
#[test]
fn a_confined_package_refuses_a_linked_javascript_file_outside_the_read_root() {
let away = Folder::new("package-script-away");
let home = Folder::new("package-script-home");
let script = away.file("menu.js");
let roots = crate::file_access::AutomationRoots::new(&[&home.0], &[&home.0]).unwrap().unwrap();
let hidden = [away.0.to_string_lossy().into_owned(), home.0.to_string_lossy().into_owned(), "menu.js".to_string()];
let refused = |s: &mut Session, p: Value| {
let e = crate::file_access::confine(Some(&roots), || s.execute("file.package", &p)).expect_err("refused");
assert!(matches!(e, EngineError::BadParams { .. }), "{p}: {e:?}");
let e = e.to_string();
assert!(e.contains("a linked JavaScript file is outside the read roots"), "{p}: {e}");
for h in &hidden {
assert!(!e.contains(h.as_str()), "{p} names {h}: {e}");
}
};
let mut part = session();
run(&mut part, "shape.rectangle", json!({"x": 10, "y": 10, "width": 30, "height": 30}));
run(&mut part, "svgInteractivity.addFile", json!({"file": script}));
std::fs::create_dir_all(home.0.join("art")).unwrap();
let native = home.file("art/part.vectorcraft");
save(&mut part, &native);
let r = run(&mut part, "document.serialize", json!({"format": "pdf"}));
let pdf = home.file("art/part.pdf");
write(&pdf, &vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
let out = home.file("out");
refused(&mut part, json!({"folder": out}));
refused(&mut part, json!({}));
for placed in [&native, &pdf] {
let mut s = session();
let r = run(&mut s, "file.place", json!({"path": placed, "link": true}));
assert_eq!(r["linked"], true, "{r}");
save(&mut s, &home.file("poster.vectorcraft"));
refused(&mut s, json!({"folder": out}));
refused(&mut s, json!({}));
assert!(!std::path::Path::new(&out).exists(), "{placed}");
// The person's package copies it.
assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "{placed}");
}
// A JavaScript file inside the read roots.
run(&mut part, "svgInteractivity.removeFile", json!({"file": script}));
run(&mut part, "svgInteractivity.addFile", json!({"file": home.file("menu.js")}));
save(&mut part, &native);
let mut s = session();
run(&mut s, "file.place", json!({"path": native, "link": true}));
save(&mut s, &home.file("poster.vectorcraft"));
let r = crate::file_access::confine(Some(&roots), || s.execute("file.package", &json!({"folder": out}))).unwrap();
assert_eq!(r["links"], 1, "{r}");
}
/// A missing link stored as a path relative to the document names a file inside a confined
/// request's read root: the package report and Document Info give its stored path.
#[test]
+88
View File
@@ -359,6 +359,35 @@ fn an_empty_row_adds_no_swatch_and_no_group_color() {
assert_eq!(hexes, ["#ff0000", "#0000ff"]);
}
/// An empty row with `added` (a color the Add Color tool added) recolors nothing, and without
/// `groupColors` gives a rewritten group its new color after the colors of the rows with current
/// colors; randomize keeps the flag, and an `added` that is not true or false is refused.
#[test]
fn an_added_empty_row_gives_the_group_its_color_after_the_others() {
let mut s = session();
let red = rect(&mut s, json!("#ff0000"));
let blue = rect(&mut s, json!("#0000ff"));
run(&mut s, "swatch.newGroup", json!({"name": "Pair", "colors": ["#ff0000", "#0000ff"]}));
select_all(&mut s);
let map = json!([
{"from": [], "to": "rgb 0 255 0", "added": true},
{"from": [], "to": "rgb 9 9 9"},
{"from": ["rgb 255 0 0"], "to": "rgb 255 0 0"},
{"from": ["rgb 0 0 255"], "to": "rgb 0 0 255"},
]);
let shuffled = run(&mut s, "recolor.randomize", json!({"map": map, "seed": 1}));
assert_eq!(shuffled["map"][0]["added"], json!(true), "{shuffled}");
assert_eq!(shuffled["map"][1].get("added"), None, "{shuffled}");
run(&mut s, "recolor.apply", json!({"map": map, "group": "Pair"}));
let d = &s.doc().unwrap().doc;
let g = d.swatch_groups.iter().find(|g| g.name == "Pair").unwrap();
let hexes: Vec<String> = g.swatches.iter().map(|w| w.paint.color().unwrap().to_hex()).collect();
assert_eq!(hexes, ["#ff0000", "#0000ff", "#00ff00"]);
assert_eq!((fill(&s, red).to_hex(), fill(&s, blue).to_hex()), ("#ff0000".into(), "#0000ff".into()), "no art is recolored");
let bad = json!([{"from": [], "to": "rgb 0 255 0", "added": "yes"}]);
assert!(s.execute("recolor.apply", &json!({"map": bad})).is_err());
}
#[test]
fn randomize_shuffles_new_colours_and_skips_excluded_rows() {
let mut s = session();
@@ -765,6 +794,65 @@ fn recolor_of_everything_counts_locked_art_that_only_loses_its_group_swatch_link
assert_eq!(r["notChanged"], json!({"locked": 1, "hidden": 0}), "{r}");
}
#[test]
fn a_null_in_group_colors_removes_that_swatch_and_the_ones_after_it_keep_their_places() {
let mut s = session();
run(&mut s, "swatch.newGroup", json!({"name": "Brand", "colors": ["#2878f0", "#ff0000", "#00ff00"]}));
let group = |s: &Session| -> Vec<(String, String)> {
let g = s.doc().unwrap().doc.swatch_groups.iter().find(|g| g.name == "Brand").unwrap().swatches.clone();
g.iter().map(|w| (w.name.clone(), w.paint.color().unwrap().to_hex())).collect()
};
let names: Vec<String> = group(&s).into_iter().map(|(n, _)| n).collect();
for name in &names {
run(&mut s, "swatch.edit", json!({"name": name, "global": true}));
}
let red = rect(&mut s, json!("#000000"));
let green = rect(&mut s, json!("#000000"));
run(&mut s, "paint.setFill", json!({"ids": [red.0], "swatch": names[1]}));
run(&mut s, "paint.setFill", json!({"ids": [green.0], "swatch": names[2]}));
select_all(&mut s);
// The middle swatch goes; the last keeps its name and color, and a color added after them is new.
run(&mut s, "recolor.apply", json!({"map": [], "group": "Brand", "groupColors": ["#2878f0", null, "#00ff00", "#123456"]}));
let g = group(&s);
assert_eq!(g.len(), 3, "{g:?}");
assert_eq!(g[..2], [(names[0].clone(), "#2878f0".into()), (names[2].clone(), "#00ff00".into())]);
assert_eq!(g[2].1, "#123456");
let link = |s: &Session, id: NodeId| match s.doc().unwrap().doc.node(id).unwrap().appearance.fill_paint() {
vectorcraft_color::Paint::Solid { color, swatch, .. } => (color.to_hex(), swatch),
p => panic!("{p:?}"),
};
assert_eq!(link(&s, red), ("#ff0000".into(), None), "art linked to the removed swatch keeps its color, unlinked");
assert_eq!(link(&s, green), ("#00ff00".into(), Some(names[2].clone())), "art linked to a swatch that stays keeps its link");
}
/// A row whose new color was removed keeps its art's colors: art in it linked to another swatch of
/// the group, which the rewrite gives another color, loses the link instead of following it.
#[test]
fn art_of_a_row_without_a_new_color_keeps_its_color_when_its_swatch_takes_another() {
let mut s = session();
run(&mut s, "swatch.newGroup", json!({"name": "Brand", "colors": ["#ff0000", "#0000ff", "#00ff00"]}));
let names: Vec<String> =
s.doc().unwrap().doc.swatch_groups.iter().find(|g| g.name == "Brand").unwrap().swatches.iter().map(|w| w.name.clone()).collect();
for name in &names {
run(&mut s, "swatch.edit", json!({"name": name, "global": true}));
}
let blue = rect(&mut s, json!("#000000"));
let green = rect(&mut s, json!("#000000"));
run(&mut s, "paint.setFill", json!({"ids": [blue.0], "swatch": names[1]}));
run(&mut s, "paint.setFill", json!({"ids": [green.0], "swatch": names[2]}));
select_all(&mut s);
// The rows are blue, red and green; the blue row's new color is removed, so the group's first
// swatch goes and its second takes the red row's new color.
let map = json!([{"from": ["#0000ff"], "to": null}, {"from": ["#ff0000"], "to": "#ff0000"}, {"from": ["#00ff00"], "to": "#00ff00"}]);
run(&mut s, "recolor.apply", json!({"map": map, "group": "Brand", "groupColors": [null, "#ff0000", "#00ff00"]}));
let link = |s: &Session, id: NodeId| match s.doc().unwrap().doc.node(id).unwrap().appearance.fill_paint() {
vectorcraft_color::Paint::Solid { color, swatch, .. } => (color.to_hex(), swatch),
p => panic!("{p:?}"),
};
assert_eq!(link(&s, blue), ("#0000ff".into(), None), "the art keeps its color, unlinked");
assert_eq!(link(&s, green), ("#00ff00".into(), Some(names[2].clone())), "art of another row keeps its link");
}
#[test]
fn recolor_of_everything_does_not_count_locked_art_whose_pattern_the_group_rewrite_recolors() {
let mut s = session();
+40
View File
@@ -0,0 +1,40 @@
//! Snap to Tangent with the Line Segment tool: a line dragged from one circle to another lands on
//! their common tangent, drawn by `shape.line` as one undo step.
use serde_json::json;
use vectorcraft_doc::NodeKind;
use vectorcraft_geom::{Point, Vec2};
use vectorcraft_tools::{PointerEvent, PointerKind};
use crate::*;
use PointerKind::{Down, Drag, Up};
#[test]
fn a_line_segment_drag_draws_the_common_tangent_as_one_undo_step() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 500, "height": 500})).unwrap();
s.execute("shape.ellipse", &json!({"x": 60, "y": 210, "width": 80, "height": 80})).unwrap();
s.execute("shape.ellipse", &json!({"x": 240, "y": 190, "width": 120, "height": 120})).unwrap();
s.execute("select.none", &json!({})).unwrap();
let count = |s: &Session| s.doc().unwrap().doc.layers[0].children().map_or(0, |c| c.len());
assert_eq!(count(&s), 2);
// Circles about (100, 250), radius 40, and (300, 250), radius 60: the outer tangent above them
// has the normal (-0.1, -√0.99) and touches them at center + radius × normal.
let n = Vec2::new(-0.1, -(0.99f64).sqrt());
let (on_a, on_b) = (Point::new(100.0, 250.0) + n * 40.0, Point::new(300.0, 250.0) + n * 60.0);
s.select_tool("lineSegment", ViewInfo::default()).unwrap();
let to = on_b + Vec2::new(0.5, 0.7);
for (k, x, y) in [(Down, 100.0, 210.0), (Drag, 200.0, 200.0), (Drag, to.x, to.y), (Up, to.x, to.y)] {
s.pointer(&PointerEvent::new(k, x, y), ViewInfo::default()).unwrap();
}
assert_eq!(count(&s), 3);
let id = *s.doc().unwrap().selection.objects.first().unwrap();
let NodeKind::Path { path, .. } = &s.doc().unwrap().doc.node(id).unwrap().kind else { panic!("a path") };
let ends: Vec<Point> = path.subpaths[0].anchors.iter().map(|a| a.p).collect();
assert_eq!(ends.len(), 2);
// Within what the drawn circles' 0.03% radius error allows.
assert!((ends[0] - on_a).hypot() < 0.15 && (ends[1] - on_b).hypot() < 0.15, "{ends:?}, want {on_a:?} {on_b:?}");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(count(&s), 2, "one undo removes the line");
}
+4
View File
@@ -991,6 +991,10 @@ fn structured_junk() {
("addon.pathtools.divideDashes", json!({"dash": 1e-308, "gap": -1e308, "fit": "x"})),
("addon.pathtools.divideDashes", json!({"dash": 0.01, "gap": 1e6, "fit": true, "removeGaps": false})),
("addon.pathtools.divideDashes", json!({"dash": f64::MAX, "gap": [0], "removeGaps": null})),
("addon.pathtools.commonTangents", json!({"tangents": "all", "centerline": true})),
("addon.pathtools.commonTangents", json!({"tangents": "x", "centerline": "y", "ids": [u64::MAX, -1]})),
("addon.pathtools.commonTangents", json!({"tangents": null, "ids": [1, 2, 3, 4], "centerline": null})),
("addon.pathtools.commonTangents", json!({"tangents": ["external"], "ids": "all"})),
("addon.pathtools.expandDashes", json!({})),
("addon.pathtools.expandDashes", json!({"ids": [0, 1, 2, 3, u64::MAX]})),
("addon.pathtools.expandDashes", json!({"ids": "x", "junk": f64::MAX})),
+196
View File
@@ -12598,3 +12598,199 @@ fn a_clipping_objects_text_wrap_is_left_out_without_room() {
assert_eq!(carriers, if room >= 4 { vec![true] } else { vec![] }, "{room}\n{text}");
}
}
/// A clipping object written as art cut to it (one that isn't a path or compound path with points,
/// or any clipping object in art already cut to one) keeps its name, its opacity mask and its
/// visibility variable on one unpainted object, locked and hidden as it was: the reader reads the
/// name once, on that object, with the mask, and binds the variable to it. The fills and strokes the
/// clipping object paints keep its opacity mask, without its name.
#[test]
fn a_cut_clipping_object_keeps_its_name_mask_and_variables() {
use vectorcraft_doc::{TextObject, Variable, VariableKind};
// Each case, with the number of objects written for the clipping object's paint.
let cases = [
("group", 0),
("hidden", 0),
("locked", 0),
("image", 0),
("instance", 0),
("blend", 0),
("type", 1),
("unpainted path", 0),
("unpainted compound", 0),
("fill", 1),
("stroke", 1),
("fill and stroke", 2),
];
for (case, parts) in cases {
let mut doc = Document::new(200.0, 100.0);
let layer = doc.layers[0].id;
let art = square(&mut doc, Rect::new(0.0, 0.0, 10.0, 10.0), LEAF);
doc.symbols.push(Symbol { dynamic: false, name: "Leaf".into(), art: Arc::new(art) });
let rect = Rect::new(20.0, 20.0, 80.0, 80.0);
let mut cutter = match case {
"image" => image_node(&mut doc, ImageBlob::png(rgb_png()), (3, 2), Affine::new([20.0, 0.0, 0.0, 20.0, 30.0, 40.0]), None),
"instance" => instance(&mut doc, "Leaf", Affine::translate((40.0, 30.0))),
"blend" => {
let keys = vec![
Arc::new(square(&mut doc, Rect::new(20.0, 20.0, 30.0, 30.0), Color::gray(0.5))),
Arc::new(square(&mut doc, Rect::new(60.0, 20.0, 70.0, 30.0), Color::gray(0.5))),
];
let spec = vectorcraft_doc::BlendSpec { spacing: vectorcraft_doc::BlendSpacing::Distance(10.0), ..Default::default() };
Node::new(doc.alloc_id(), NodeKind::Blend { children: keys, spec: Box::new(spec) })
}
"type" => text_node(&mut doc, TextObject::point(vectorcraft_geom::Point::new(30.0, 50.0), "Clip", style(24.0, Color::BLACK))),
"unpainted path" => clipping(&mut doc, shapes::rectangle(rect)),
"unpainted compound" => {
let outer = Node::path(doc.alloc_id(), shapes::rectangle(rect), Appearance::default());
let inner = Node::path(doc.alloc_id(), shapes::rectangle(Rect::new(30.0, 30.0, 70.0, 70.0)), Appearance::default());
Node::new(doc.alloc_id(), NodeKind::Compound { children: vec![Arc::new(outer), Arc::new(inner)], rule: FillRule::EvenOdd })
}
"fill" | "stroke" | "fill and stroke" => {
let mut c = clipping(&mut doc, shapes::rectangle(rect));
let fill = if case == "stroke" { Paint::None } else { solid(Color::gray(0.5)) };
let stroke = if case == "fill" { Paint::None } else { solid(Color::rgb(0.0, 0.0, 1.0)) };
c.appearance = Appearance::basic(fill, stroke, if case == "fill" { 0.0 } else { 2.0 }).into();
c
}
_ => {
let members = vec![square(&mut doc, Rect::new(20.0, 20.0, 50.0, 60.0), Color::gray(0.5)), square(&mut doc, rect, Color::gray(0.5))];
group(&mut doc, members, false)
}
};
cutter.name = Some("Cutter".into());
cutter.visible = case != "hidden";
cutter.locked = case == "locked";
let veil = square(&mut doc, Rect::new(20.0, 20.0, 60.0, 60.0), Color::rgb(1.0, 1.0, 1.0));
cutter.extras_mut().mask = Some(Box::new(OpacityMask::new(veil, false)));
let id = cutter.id;
let member = square(&mut doc, Rect::new(30.0, 30.0, 70.0, 50.0), Color::rgb(1.0, 0.0, 0.0));
let mut top = group(&mut doc, vec![cutter, member], true);
if matches!(case, "unpainted path" | "unpainted compound" | "fill" | "stroke" | "fill and stroke") {
let frame = square(&mut doc, Rect::new(0.0, 0.0, 100.0, 100.0), Color::gray(0.9));
let frame = group(&mut doc, vec![frame], false);
top = group(&mut doc, vec![frame, top], true);
}
doc.insert(Some(layer), usize::MAX, top).unwrap();
doc.variables.variables.push(Variable { name: "show".into(), kind: VariableKind::Visibility });
doc.variables.bind(id, "show");
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().all(|w| w != writer::BINDINGS), "{case}: {:?}", out.warnings);
let text = String::from_utf8(out.program).unwrap().replace("\r\n", "\n");
assert_eq!(text.matches("%_/XMLUID : (Cutter) ; (AI10_ArtUID) ,").count(), 1, "{case}\n{text}");
assert_eq!(text.matches("(AI9_Mask)").count(), 1 + parts, "{case}\n{text}");
let back = read_back(&doc);
let (mut cutters, mut masked) = (vec![], 0);
back.layers[0].walk(&mut |n| {
masked += usize::from(n.extras().mask.is_some());
if n.name.as_deref() == Some("Cutter") {
let unpainted = matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) && n.appearance.items.is_empty();
cutters.push((n.id, unpainted, n.extras().mask.is_some(), n.locked, n.visible));
}
});
let [(carrier, unpainted, mask, locked, visible)] = cutters[..] else { panic!("{case}: {cutters:?}\n{text}") };
assert!(unpainted && mask, "{case}");
assert_eq!((locked, visible), (case == "locked", case != "hidden"), "{case}");
assert_eq!(masked, 1 + parts, "{case}");
assert_eq!(back.variables.objects_of("show"), vec![carrier], "{case}");
}
}
/// With too little room for the unpainted object that carries a cut clipping object's dictionary,
/// the dictionary is left out, never written on another object; with room for the object but not
/// for its opacity mask's art, only the mask is left out. The data stays readable.
#[test]
fn a_cut_clipping_objects_dictionary_is_left_out_without_room() {
let mut doc = Document::new(200.0, 100.0);
let layer = doc.layers[0].id;
let before = named(square(&mut doc, Rect::new(150.0, 10.0, 160.0, 20.0), Color::gray(0.2)), "Before");
doc.insert(Some(layer), usize::MAX, before).unwrap();
let members = vec![
square(&mut doc, Rect::new(20.0, 20.0, 50.0, 60.0), Color::gray(0.5)),
square(&mut doc, Rect::new(60.0, 30.0, 90.0, 70.0), Color::gray(0.5)),
];
let mut cutter = wrapped(named(group(&mut doc, members, false), "Cutter"), 2.0, false);
cutter.locked = true;
let veil = vec![
square(&mut doc, Rect::new(20.0, 20.0, 40.0, 40.0), Color::rgb(1.0, 1.0, 1.0)),
square(&mut doc, Rect::new(40.0, 40.0, 60.0, 60.0), Color::rgb(1.0, 1.0, 1.0)),
];
let veil = group(&mut doc, veil, false);
cutter.extras_mut().mask = Some(Box::new(OpacityMask::new(veil, false)));
let member = square(&mut doc, Rect::new(30.0, 30.0, 70.0, 50.0), Color::rgb(1.0, 0.0, 0.0));
let top = group(&mut doc, vec![cutter, member], true);
doc.insert(Some(layer), usize::MAX, top).unwrap();
let all = crate::import::objects_read(&export_ai_editing(&doc, &opts()).unwrap().program).unwrap();
let mut kept = vec![];
for room in 0..=all {
let out = export_within(&doc, &opts(), room).unwrap();
assert!(crate::import::objects_read(&out.program).unwrap() <= room);
let text = String::from_utf8_lossy(&out.program).replace("\r\n", "\n");
let (back, _) = crate::ai_alone(&out.program).unwrap();
let mut found = vec![];
back.layers[0].walk(&mut |n| {
let x = n.extras();
if !matches!(n.kind, NodeKind::Layer { .. }) && (n.name.is_some() || x.wrap.is_some() || x.mask.is_some()) {
let carrier = matches!(n.kind, NodeKind::Compound { .. }) && n.appearance.items.is_empty();
found.push((n.name.clone(), carrier, x.wrap.is_some(), x.mask.is_some(), n.locked));
}
});
let before = (Some("Before".to_string()), false, false, false, false);
let rest = match found.split_first() {
Some((b, rest)) if room > 0 => {
assert_eq!(b, &before, "{room}\n{text}");
rest
}
_ => &found[..],
};
match rest {
[] => kept.push((false, false)),
[(name, true, true, mask, true)] if name.as_deref() == Some("Cutter") => kept.push((true, *mask)),
_ => panic!("{room}: {found:?}\n{text}"),
}
}
assert_eq!(kept.last(), Some(&(true, true)));
// Once the carrier fits it stays, and once its mask fits it stays too.
let carrier = kept.iter().position(|k| k.0).unwrap();
let mask = kept.iter().position(|k| k.1).unwrap();
assert!(carrier < mask, "{kept:?}");
assert!(kept[carrier..].iter().all(|k| k.0) && kept[mask..].iter().all(|k| k.1), "{kept:?}");
}
/// A cut clipping object with an opacity mask alone gets no unpainted object when its mask's art
/// doesn't fit: an object without the dictionary it was written for would be extra art.
#[test]
fn a_cut_clipping_object_without_room_for_its_mask_gets_no_carrier() {
let mut doc = Document::new(200.0, 100.0);
let layer = doc.layers[0].id;
let members = vec![
square(&mut doc, Rect::new(20.0, 20.0, 50.0, 60.0), Color::gray(0.5)),
square(&mut doc, Rect::new(60.0, 30.0, 90.0, 70.0), Color::gray(0.5)),
];
let mut cutter = group(&mut doc, members, false);
let veil = vec![
square(&mut doc, Rect::new(20.0, 20.0, 40.0, 40.0), Color::rgb(1.0, 1.0, 1.0)),
square(&mut doc, Rect::new(40.0, 40.0, 60.0, 60.0), Color::rgb(1.0, 1.0, 1.0)),
];
let veil = group(&mut doc, veil, false);
cutter.extras_mut().mask = Some(Box::new(OpacityMask::new(veil, false)));
let top = group(&mut doc, vec![cutter], true);
doc.insert(Some(layer), usize::MAX, top).unwrap();
let all = crate::import::objects_read(&export_ai_editing(&doc, &opts()).unwrap().program).unwrap();
for room in 0..=all {
let out = export_within(&doc, &opts(), room).unwrap();
let text = String::from_utf8_lossy(&out.program).replace("\r\n", "\n");
let (back, _) = crate::ai_alone(&out.program).unwrap();
let mut carriers = vec![];
back.layers[0].walk(&mut |n| {
if matches!(n.kind, NodeKind::Compound { .. }) && n.appearance.items.is_empty() {
carriers.push(n.extras().mask.is_some());
}
});
assert!(carriers.is_empty() || carriers == [true], "{room}: {carriers:?}\n{text}");
assert_eq!(carriers.is_empty(), !text.contains("(AI9_Mask)"), "{room}\n{text}");
if room == all {
assert_eq!(carriers, [true], "{text}");
}
}
}
+39 -17
View File
@@ -1231,17 +1231,19 @@ impl<'a> Writer<'a> {
}
/// A container's members, the first one's outline cutting the others: its fills painted
/// behind them (cut to the region outside too), its strokes over them, not cut by it. Its text
/// wrap options are written once, under them all ([`Self::wrap_carrier`]), and not with its fills
/// or strokes, which may be cut or left out.
/// behind them (cut to the region outside too), its strokes over them, not cut by it. Its name,
/// variables and text wrap options are written once, under them all, with its opacity mask
/// ([`Self::object_carrier`]), and not with its fills or strokes, which may be cut or left out
/// and keep only the opacity mask they are drawn through.
fn clip_contents(&mut self, children: &[Arc<Node>]) {
let Some((first, rest)) = children.split_first() else { return };
self.wrap_carrier(first);
self.object_carrier(first);
// Nothing to clip by hides the clipped art.
let Some((outline, rule)) = vectorcraft_effects::clip_outline(first) else { return };
let mut paint = first.clip_paint();
for part in [&mut paint.fill, &mut paint.stroke].into_iter().flatten() {
part.extras_mut().wrap = None;
part.name = None;
}
let outer = self.clip.clone();
let region = self.cut(&PathData::from_bezpath(&outline), rule);
@@ -1258,26 +1260,46 @@ impl<'a> Writer<'a> {
}
}
/// The text wrap options of clipping object `first`, when it has them, on an unpainted path
/// (a compound path for several subpaths) of the outline area type wraps around
/// ([`vectorcraft_doc::text::wrap_outline`]), uncut, locked and hidden as `first` is. Nothing is
/// written for an empty outline or without room for the path ([`Self::take_objects`]).
fn wrap_carrier(&mut self, first: &Node) {
let Some(wrap) = first.extras().wrap.filter(|_| self.drawn == 0 && !self.in_look) else { return };
let outline = vectorcraft_doc::text::wrap_outline(first);
if outline.is_empty() {
/// The dictionary of clipping object `first` ([`Self::dictionary`]: its name, visibility
/// variables, text wrap options and opacity mask), when it has one, on an unpainted path (a
/// compound path for several subpaths), uncut, locked and hidden as `first` is. The path is the
/// outline area type wraps around when `first` has text wrap options
/// ([`vectorcraft_doc::text::wrap_outline`]); else, and without the options when that outline is
/// empty, `first`'s clipping outline, or the rectangle of its bounds when it has none. Nothing
/// is written without such a path, or without room for the path ([`Self::take_objects`]), or
/// when the dictionary would be empty (an opacity mask left out with nothing else in it).
fn object_carrier(&mut self, first: &Node) {
let points = |p: &PathData| p.subpaths.iter().any(|sp| !sp.anchors.is_empty());
let wrap = first.extras().wrap.filter(|_| self.drawn == 0 && !self.in_look);
let wrap_outline = wrap.map(|_| vectorcraft_doc::text::wrap_outline(first)).filter(points);
let named = first.name.as_deref().is_some_and(|s| !s.is_empty());
let bound = !self.bound_variables(first, false, false).is_empty();
if wrap_outline.is_none() && !named && !bound && first.extras().mask.is_none() {
return;
}
let wrapped = wrap_outline.is_some();
let outline = wrap_outline
.or_else(|| vectorcraft_effects::clip_outline(first).map(|(o, _)| PathData::from_bezpath(&o)).filter(points))
.or_else(|| finite_bounds(first).map(shapes::rectangle));
let Some(outline) = outline else { return };
let (start, state, gs, objects) = (self.body.len(), self.state, self.gs, self.objects);
self.state(first.locked, !first.visible);
let start = self.body.len();
self.plain_object(&outline, FillRule::NonZero, None, None, Xy::of(first).object());
if self.body.len() == start {
if self.objects == objects {
// Without the path, its lock and hidden lines are taken out too, and no dictionary follows.
self.body.truncate(start);
self.state = state;
return;
}
self.block_end = usize::MAX;
self.body.push_str("%_/ArtDictionary :\n");
self.text_wrap(wrap);
self.body.push_str("%_;\n%_\n");
let path_end = self.body.len();
// Text wrap options go only on the outline area type wraps around.
self.wrap_moved = !wrapped;
self.dictionary(first);
if self.body.len() == path_end {
self.body.truncate(start);
(self.state, self.gs, self.objects) = (state, gs, objects);
}
}
/// `path` (filled by `rule`) cut to the region the art is cut to, as a non-zero path.
+4 -1
View File
@@ -233,7 +233,8 @@ fn tick(t: TickLength) -> u8 {
}
/// Whether `g`'s settings are ones the records give and the reader keeps: a legend beside or across
/// the top, every series of the graph's type, one value axis on the left, lines not filled, no graph
/// the top, every series of the graph's type, one value axis on the left, lines not filled and no
/// Line Width of their own, no graph
/// designs, label formatting or pie settings, column and cluster widths of 1% to 1000%, and at most
/// [`MAX_TICK_MARKS`] tick marks a division.
fn settings_kept(g: &GraphSpec) -> bool {
@@ -244,6 +245,7 @@ fn settings_kept(g: &GraphSpec) -> bool {
&& !g.separate_scales
&& g.right_series.is_empty()
&& !g.filled_lines
&& g.line_width.is_none()
&& g.series_markers.iter().all(Option::is_none)
&& g.series_columns.iter().all(Option::is_none)
&& g.label_styles == LabelStyles::default()
@@ -514,6 +516,7 @@ pub(crate) mod sample {
cases.extend([
("no legend", with(&|g| g.legend = false)),
("filled lines", with(&|g| (g.kind, g.filled_lines) = (GraphKind::Line, true))),
("a filled line width", with(&|g| (g.kind, g.line_width) = (GraphKind::Line, Some(8.0)))),
("a series of another type", with(&|g| g.series_kinds = vec![None, Some(GraphKind::Line)])),
("a marker design", with(&|g| g.series_markers = vec![Some("Star".into())])),
("a column design", with(&|g| g.series_columns = vec![Some(Default::default())])),
+2
View File
@@ -1544,6 +1544,8 @@ fn headless_backend_methods() {
let selected = h.call("ui.tool.select", json!({"tool": tool.id})).unwrap();
assert_eq!(selected["tool"], tool.id);
}
let polygonal = groups.iter().flat_map(|group| group.as_array().unwrap()).find(|entry| entry["id"] == "polygonalLasso");
assert_eq!(polygonal.map(|entry| entry["label"].clone()), Some(json!("Polygonal Lasso Tool")));
assert!(h.call("ui.resize", json!({})).is_err());
}
+2 -2
View File
@@ -979,7 +979,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"tool.options",
"Tool Options…",
"",
"{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient|magicWand → the Gradient or Magic Wand panel (window.panel), artboard → Artboard Options of the active artboard (dialog `artboardOptions`, fields index, name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.setProps, and with other artboards selected with the Artboard tool a new width or height goes to each of them too, in its `artboards` list, each resized about the reference point the form used for that size, or about its top-left corner when the size was set in the fields directly), flare → Flare Tool Options (dialog `flareOptions`, fields diameter and pathLength (pt), opacity, brightness, growth, fuzziness, longest, rayFuzziness, largest (%), rays, rings, direction (°), raysOn, ringsOn; OK runs tool.setOption {tool: \"flare\", values}: the next flare dragged out uses them, and a Flare click's dialog, which also has x, y and preview (on initially), previews one there and accepts it as one Undo step; Cancel rolls back the preview), lineSegment|arc|rectangularGrid|polarGrid → that tool's Tool Options, its click dialog without x and y (dialog kind = the tool id, `__toolOptions: true`; lineSegment: length (pt), angle (°), fillLine; arc: lengthX, lengthY (pt), reference (0–8), arcType: open|closed, baseAlong: x|y, slope (−100…100), fillArc; rectangularGrid: width, height (pt, the Default Size), reference (0–8), rows, columns, rowSkew, columnSkew (%), frame, fill; polarGrid: the same with concentric, radial, concentricSkew, radialSkew and compound for rows, columns, the skews and frame; OK runs tool.setOption {tool, values} and draws nothing: the next drag uses them (Fill Line, the arc's type, base, slope and fill, the grids' dividers, skews and switches) and a click's dialog opens at them), columnGraph|stackedColumnGraph|barGraph|stackedBarGraph|lineGraph|areaGraph|scatterGraph|pieGraph|radarGraph → Graph Type for the selected graph, or for the series picked in it with Group Selection (dialog `graphType`, fields the options graph.setType {} returns under their names, with legend, pieLegend, piePosition, pieSort, firstRowInFront, firstColumnInFront and filledLines held for every type; overrideValues and rightOverrideValues, Override Calculated Values of the left or only value axis and of the right one: while one is on OK sends axisMin, axisMax and ticks, or rightAxisMin, rightAxisMax and rightTicks, filled with the calculated values where the graph has none, and one turned off sends null, null and 0; __page: options|valueAxis|rightAxis|categoryAxis, the page shown, options when the type picked has no such page; OK runs graph.setType, and with nothing changed closes without a step of history; an overridden value axis whose maximum is not more than its minimum is an error and the dialog stays open; an error without a selected graph), typeOnPath|verticalTypeOnPath → Type on a Path Options for the selected type on a path (dialog `command` running type.pathOptions; error `nothing selected` without a selection, and the command's error when no type on a path is selected),symbolSprayer|symbolShifter|symbolScruncher|symbolSizer|symbolSpinner|symbolStainer|symbolScreener|symbolStyler → Symbolism Tools Options (dialog `symbolismOptions`, fields tool, diameter (pt), intensity and density (1–10), shared by the eight tools; OK runs tool.setOption {tool, values}), blend → Blend Options, perspectiveGrid → Perspective Grid Options, eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (px for pencil, paintbrush and smooth, the same at any zoom; pt for blobBrush), fill, keepSelected (on for pencil and paintbrush, off for blobBrush), mergeOnlySelection (off), closeWithin and editWithin (px, 0 is off), livePreview (pencil, on: off draws a thin line while the stroke is drawn, and the path's fill and stroke on release), size (pt), angle (°, −180–180; 0) and roundness (%, 1–100; 100) of the eraser's tip; OK runs tool.setOption {tool, values}), li Line truncated
"{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient|magicWand → the Gradient or Magic Wand panel (window.panel), artboard → Artboard Options of the active artboard (dialog `artboardOptions`, fields index, name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.setProps, and with other artboards selected with the Artboard tool a new width or height goes to each of them too, in its `artboards` list, each resized about the reference point the form used for that size, or about its top-left corner when the size was set in the fields directly), flare → Flare Tool Options (dialog `flareOptions`, fields diameter and pathLength (pt), opacity, brightness, growth, fuzziness, longest, rayFuzziness, largest (%), rays, rings, direction (°), raysOn, ringsOn; OK runs tool.setOption {tool: \"flare\", values}: the next flare dragged out uses them, and a Flare click's dialog, which also has x, y and preview (on initially), previews one there and accepts it as one Undo step; Cancel rolls back the preview), lineSegment|arc|rectangularGrid|polarGrid → that tool's Tool Options, its click dialog without x and y (dialog kind = the tool id, `__toolOptions: true`; lineSegment: length (pt), angle (°), fillLine; arc: lengthX, lengthY (pt), reference (0–8), arcType: open|closed, baseAlong: x|y, slope (−100…100), fillArc; rectangularGrid: width, height (pt, the Default Size), reference (0–8), rows, columns, rowSkew, columnSkew (%), frame, fill; polarGrid: the same with concentric, radial, concentricSkew, radialSkew and compound for rows, columns, the skews and frame; OK runs tool.setOption {tool, values} and draws nothing: the next drag uses them (Fill Line, the arc's type, base, slope and fill, the grids' dividers, skews and switches) and a click's dialog opens at them), columnGraph|stackedColumnGraph|barGraph|stackedBarGraph|lineGraph|areaGraph|scatterGraph|pieGraph|radarGraph → Graph Type for the selected graph, or for the series picked in it with Group Selection (dialog `graphType`, fields the options graph.setType {} returns under their names, with legend, pieLegend, piePosition, pieSort, firstRowInFront, firstColumnInFront, filledLines and lineWidth held for every type; overrideValues and rightOverrideValues, Override Calculated Values of the left or only value axis and of the right one: while one is on OK sends axisMin, axisMax and ticks, or rightAxisMin, rightAxisMax and rightTicks, filled with the calculated values where the graph has none, and one turned off sends null, null and 0; __page: options|valueAxis|rightAxis|categoryAxis, the page shown, options when the type picked has no such page; OK runs graph.setType, and with nothing changed closes without a step of history; an overridden value axis whose maximum is not more than its minimum is an error and the dialog stays open; an error without a selected graph), typeOnPath|verticalTypeOnPath → Type on a Path Options for the selected type on a path (dialog `command` running type.pathOptions; error `nothing selected` without a selection, and the command's error when no type on a path is selected),symbolSprayer|symbolShifter|symbolScruncher|symbolSizer|symbolSpinner|symbolStainer|symbolScreener|symbolStyler → Symbolism Tools Options (dialog `symbolismOptions`, fields tool, diameter (pt), intensity and density (1–10), shared by the eight tools; OK runs tool.setOption {tool, values}), blend → Blend Options, perspectiveGrid → Perspective Grid Options, eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (px for pencil, paintbrush and smooth, the same at any zoom; pt for blobBrush), fill, keepSelected (on for pencil and paintbrush, off for blobBrush), mergeOnlySelection (off), closeWithin and editWithin (px, 0 is off), livePreview (pencil, on: off draws a thin line while the stroke is drawn, and the path's fill and stroke on release), size (pt), angle (°, −180–180; 0) and roundness (%, 1–100; 100) of the eraser's tip; OK runs tool.setOption {tool, v Line truncated
),
(
"ui.colorGuideOptions",
@@ -1390,7 +1390,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"file.exportAs",
"Export As…",
"",
"{format?, useArtboards?, range?} opens Export As (then the format's options); with {path, …document.export options} writes the file(s) → {path, warnings, files?}; exportSelection: true writes the selection alone, cropped to it, as document.exportSelection writes it (artboard options are not used); under automation read roots, an SVG or SVGZ is refused while the document links a JavaScript file outside them, or while the file would name a linked image's file outside them, as document.export refuses it",
"{format?, useArtboards?, range?} opens Export As (then the format's options); with {path, …document.export options} writes the file(s) → {path, warnings, files?}; exportSelection: true writes the selection alone, cropped to it, as document.exportSelection writes it (artboard options are not used); under automation read roots, an SVG or SVGZ, or a file that carries the native document, is refused while the document links a JavaScript file outside them, or while the file would name a linked image's file outside them, as document.export refuses it",
),
(
"ui.fileInfoDialog",
+5 -2
View File
@@ -4,8 +4,9 @@
//! tool shows over a path, open paths lengthened or shortened at an end ([`extend`]), the places
//! where paths cross ([`crossings`]), the stretches between them ([`spans`]), anchors slid along
//! their path ([`slide`]), touching edges merged ([`shared_edge`]), paths divided into dashes
//! ([`divide_dashes`]), the Parametric Shape Tool's shapes ([`shapes`]) and the circles that touch
//! two or three shapes ([`tangent_circles`]).
//! ([`divide_dashes`]), the common tangents of two convex outlines ([`common_tangents`]), the
//! Parametric Shape Tool's shapes ([`shapes`]) and the circles that touch two or three shapes
//! ([`tangent_circles`]).
mod crossings;
mod dashes;
@@ -14,6 +15,7 @@ pub mod shapes;
mod shared_edge;
mod slide;
mod tangent_circle;
mod tangents;
#[cfg(test)]
mod tests;
mod trim;
@@ -31,6 +33,7 @@ pub use shared_edge::{
};
pub use slide::{MAX_SLIDE, slide_anchor, slide_stops, slide_t_at};
pub use tangent_circle::{Circle, MAX_TANGENT_CIRCLE_SEGMENTS, MAX_TANGENT_CIRCLES, TangentCircleError, tangent_circle_segments, tangent_circles};
pub use tangents::{Coincide, MAX_TANGENT_SEGMENTS, Outline, OutlineError, Tangent, TangentKind, common_tangents};
pub use trim::{Span, slice, span_at, spans, without_spans};
use crate::fit::{end_tangent, start_tangent};
@@ -0,0 +1,895 @@
//! Common Tangents: the straight lines that touch two convex closed outlines (ellipses at any
//! rotation and scale, and convex Bézier paths) without crossing into either. An external tangent
//! has both outlines on the same side of it; an internal one runs between them.
//!
//! A line with unit normal `n` touches an outline from outside where `p · n` reaches the
//! outline's support value `h(n)`, the largest `p · n` over its points. External tangents are the
//! normals where both outlines have the same support value, internal ones where `h₁(n) = -h₂(-n)`.
//! Both are found as roots over the normal's angle: sampled, then refined by bisection, with
//! sampled minima refined too so that a double root (outlines that touch) or two roots between
//! neighboring samples are kept.
use std::f64::consts::TAU;
use kurbo::{Affine, CubicBez, ParamCurve, Point, Vec2};
use vectorcraft_geom::SubPath;
/// Most segments one outline may have.
pub const MAX_TANGENT_SEGMENTS: usize = 10_000;
/// Normal directions sampled around the circle before refining.
const SAMPLES: usize = 720;
/// Steps of bisection or golden-section search for each root.
const STEPS: usize = 64;
/// Straight pieces each segment is cut into to check that a path is convex and to find its center.
const FLATTEN: usize = 32;
/// Which side of a tangent the two outlines lie on.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TangentKind {
/// Both on the same side.
External,
/// One on each side.
Internal,
}
/// One common tangent: the stretch of the line from where it touches the first outline to where
/// it touches the second. Where the outlines touch each other at one point, the stretch is
/// centered on that point and as long as the narrower outline is wide along the line, and `from`
/// is the end with the lower position along the line.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Tangent {
pub kind: TangentKind,
pub from: Point,
pub to: Point,
}
/// Why [`Outline::convex`] or [`Outline::ellipse`] cannot take a shape.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OutlineError {
/// The path is open.
Open,
/// The path bends inward somewhere, or winds around more than once.
NotConvex,
/// No area, or not finite.
Empty,
/// More than [`MAX_TANGENT_SEGMENTS`] segments.
TooComplex,
}
/// The two outlines are the same, so every line touching one touches the other.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Coincide;
/// A convex closed outline that [`common_tangents`] takes.
#[derive(Clone, Debug)]
pub enum Outline {
/// The unit circle under an affine map: the center is the map's translation, `m` its linear
/// part (`[a, b, c, d]`, as kurbo orders them).
Ellipse { center: Point, m: [f64; 4] },
/// A convex closed path's segments, its center of area and the diagonal of its bounds. `ccw`
/// when the segments run counter-clockwise (y up); the segment where `p · n` is largest then
/// comes later in the list as the angle of `n` grows.
Convex { segments: Vec<CubicBez>, center: Point, size: f64, ccw: bool },
}
impl Outline {
/// The ellipse that `unit` maps the unit circle onto.
pub fn ellipse(unit: Affine) -> Result<Self, OutlineError> {
let [a, b, c, d, e, f] = unit.as_coeffs();
let norm = a.abs().max(b.abs()).max(c.abs()).max(d.abs());
if !unit.as_coeffs().iter().all(|v| v.is_finite()) || norm <= 0.0 || (a * d - b * c).abs() <= 1e-12 * norm * norm {
return Err(OutlineError::Empty);
}
Ok(Outline::Ellipse { center: Point::new(e, f), m: [a, b, c, d] })
}
/// A closed subpath that bends one way all around and winds around once.
pub fn convex(sp: &SubPath) -> Result<Self, OutlineError> {
if !sp.closed {
return Err(OutlineError::Open);
}
let n = sp.segment_count();
if n > MAX_TANGENT_SEGMENTS {
return Err(OutlineError::TooComplex);
}
let segments: Vec<CubicBez> = (0..n).map(|k| sp.segment(k)).collect();
let finite = |p: Point| p.x.is_finite() && p.y.is_finite();
if segments.iter().any(|s| ![s.p0, s.p1, s.p2, s.p3].into_iter().all(finite)) {
return Err(OutlineError::Empty);
}
let mut pts: Vec<Point> = Vec::with_capacity(n * FLATTEN);
for s in &segments {
pts.extend((0..FLATTEN).map(|k| s.eval(k as f64 / FLATTEN as f64)));
}
let (lo, hi) = pts.iter().fold((Point::new(f64::MAX, f64::MAX), Point::new(f64::MIN, f64::MIN)), |(lo, hi), p| {
(Point::new(lo.x.min(p.x), lo.y.min(p.y)), Point::new(hi.x.max(p.x), hi.y.max(p.y)))
});
let size = (hi - lo).hypot();
if !size.is_finite() || size <= 0.0 {
return Err(OutlineError::Empty);
}
// Points closer than this to the one before are dropped: a retracted handle or a segment
// of no length gives no direction.
pts.dedup_by(|b, a| (*b - *a).hypot() <= 1e-9 * size);
while pts.len() > 1 && pts.first().zip(pts.last()).is_some_and(|(f, l)| (*f - *l).hypot() <= 1e-9 * size) {
pts.pop();
}
let m = pts.len();
if m < 3 {
return Err(OutlineError::Empty);
}
// Area, center and turns are worked out on the points taken about the first one and
// divided by the size.
let origin = pts[0].to_vec2();
let unit: Vec<Vec2> = pts.iter().map(|p| (p.to_vec2() - origin) / size).collect();
let (mut area2, mut cx, mut cy) = (0.0, 0.0, 0.0);
for i in 0..m {
let (p, q) = (unit[i], unit[(i + 1) % m]);
let cross = p.cross(q);
area2 += cross;
cx += (p.x + q.x) * cross;
cy += (p.y + q.y) * cross;
}
if area2.abs() <= 1e-12 {
return Err(OutlineError::Empty);
}
let sign = area2.signum();
// Every turn the same way (straight runs allowed), and one turn in all.
let mut turning = 0.0;
for i in 0..m {
let (p, q, r) = (unit[(i + m - 1) % m], unit[i], unit[(i + 1) % m]);
let (u, v) = (q - p, r - q);
let cross = u.cross(v) * sign;
if cross < -1e-12 {
return Err(OutlineError::NotConvex);
}
turning += cross.atan2(u.dot(v));
}
if (turning - TAU).abs() > 1e-6 {
return Err(OutlineError::NotConvex);
}
// A short bend the other way can lie between two of the points: each segment is checked
// whole.
if segments.iter().any(|s| bends_against(s, sign)) {
return Err(OutlineError::NotConvex);
}
let center = (Vec2::new(cx / (3.0 * area2), cy / (3.0 * area2)) * size + origin).to_point();
if !center.x.is_finite() || !center.y.is_finite() {
return Err(OutlineError::Empty);
}
Ok(Outline::Convex { segments, center, size, ccw: sign > 0.0 })
}
/// The outline moved by `d`.
fn shifted(&self, d: Vec2) -> Self {
match self {
Outline::Ellipse { center, m } => Outline::Ellipse { center: *center + d, m: *m },
Outline::Convex { segments, center, size, ccw } => Outline::Convex {
segments: segments.iter().map(|s| CubicBez::new(s.p0 + d, s.p1 + d, s.p2 + d, s.p3 + d)).collect(),
center: *center + d,
size: *size,
ccw: *ccw,
},
}
}
/// Adds to `out` the normal angles where the point of largest `p · n` can pass from one
/// segment to the next: square to each segment's direction at its ends, on both sides.
fn breaks(&self, out: &mut Vec<f64>) {
let Outline::Convex { segments, .. } = self else { return };
let nonzero = |vs: [Vec2; 3]| vs.into_iter().find(|v| v.hypot2() > 0.0);
for s in segments {
let ends = [nonzero([s.p1 - s.p0, s.p2 - s.p0, s.p3 - s.p0]), nonzero([s.p3 - s.p2, s.p3 - s.p1, s.p3 - s.p0])];
for d in ends.into_iter().flatten() {
let a = d.y.atan2(d.x);
out.extend([a + TAU / 4.0, a - TAU / 4.0]);
}
}
}
/// The support value at `n` and the segment it is reached on, from every segment.
fn support_scan(&self, n: Vec2) -> (f64, usize) {
match self {
Outline::Ellipse { .. } => (self.support(n), 0),
Outline::Convex { segments, .. } => {
let mut best = (f64::MIN, 0);
for (i, s) in segments.iter().enumerate() {
each_extreme(s, n, |_, v| {
if v > best.0 {
best = (v, i);
}
});
}
best
}
}
}
/// The support value at `n` and the segment it is reached on, walking on from segment `from`,
/// where the support value was reached at a normal angle a little less than `n`'s.
fn support_from(&self, n: Vec2, from: usize) -> (f64, usize) {
match self {
Outline::Ellipse { .. } => (self.support(n), 0),
Outline::Convex { segments, ccw, .. } => {
let len = segments.len();
if len == 0 {
return (f64::MIN, 0);
}
let step = if *ccw { 1 } else { len - 1 };
let value = |i: usize| {
let mut best = f64::MIN;
if let Some(s) = segments.get(i) {
each_extreme(s, n, |_, v| best = best.max(v));
}
best
};
let mut i = from % len;
let mut v = value(i);
for _ in 0..len {
let j = (i + step) % len;
let w = value(j);
if w < v {
break;
}
(i, v) = (j, w);
}
(v, i)
}
}
}
/// The center: an ellipse's, or a path's center of area.
pub fn center(&self) -> Point {
match self {
Outline::Ellipse { center, .. } | Outline::Convex { center, .. } => *center,
}
}
/// The diagonal of the bounds (an ellipse's: of the box its axes span).
fn size(&self) -> f64 {
match self {
Outline::Ellipse { m, .. } => {
let [a, b, c, d] = *m;
2.0 * (a.hypot(c).powi(2) + b.hypot(d).powi(2)).sqrt()
}
Outline::Convex { size, .. } => *size,
}
}
/// The support value: the largest `p · n` over the outline's points.
fn support(&self, n: Vec2) -> f64 {
match self {
Outline::Ellipse { center, m: [a, b, c, d] } => center.to_vec2().dot(n) + Vec2::new(a * n.x + b * n.y, c * n.x + d * n.y).hypot(),
Outline::Convex { segments, .. } => {
let mut best = f64::MIN;
for s in segments {
each_extreme(s, n, |_, v| best = best.max(v));
}
best
}
}
}
/// The points of the outline on the line `p · n = h`, its support value: the point where
/// `p · n` is largest, and the ends of any straight side along the line. Another point counts
/// when it lies within `tol` of the line plus `slope` times its distance from that largest
/// point, where `slope` is how far off the normal's angle may be.
fn touching(&self, n: Vec2, h: f64, tol: f64, slope: f64) -> Vec<Point> {
match self {
Outline::Ellipse { center, m: [a, b, c, d] } => {
let w = Vec2::new(a * n.x + b * n.y, c * n.x + d * n.y);
let w = w / w.hypot();
vec![*center + Vec2::new(a * w.x + c * w.y, b * w.x + d * w.y)]
}
Outline::Convex { segments, .. } => {
let mut all = vec![];
for s in segments {
each_extreme(s, n, |p, v| all.push((p, v)));
}
let Some(&(peak, _)) = all.iter().max_by(|x, y| x.1.total_cmp(&y.1)) else { return vec![] };
all.into_iter().filter(|(p, v)| h - v <= tol + slope * (*p - peak).hypot()).map(|(p, _)| p).collect()
}
}
}
}
/// Calls `f` with each point of `s` where `p · n` can be largest (its ends and the places where
/// the curve runs square to `n`) and the value there.
/// Whether cubic `s` bends against `sign` (the way its outline turns) anywhere. The cross product
/// of its first and second derivatives is a quadratic in t; its lowest value on [0, 1] is compared
/// with the segment's control polygon length squared.
fn bends_against(s: &CubicBez, sign: f64) -> bool {
let (a, b, c) = (s.p1 - s.p0, s.p2 - s.p1, s.p3 - s.p2);
let q = |t: f64| {
let u = 1.0 - t;
let d1 = a * (u * u) + b * (2.0 * u * t) + c * (t * t);
let d2 = (b - a) * u + (c - b) * t;
d1.cross(d2) * sign
};
let (q0, half, q1) = (q(0.0), q(0.5), q(1.0));
// q(t) = q0 + k1 t + k2 t².
let k2 = 2.0 * (q0 + q1 - 2.0 * half);
let k1 = q1 - q0 - k2;
let mut low = q0.min(q1);
if k2 > 0.0 {
let t = -k1 / (2.0 * k2);
if t > 0.0 && t < 1.0 {
low = low.min(q(t));
}
}
let scale = (a.hypot() + b.hypot() + c.hypot()).powi(2);
low < -1e-9 * scale
}
fn each_extreme(s: &CubicBez, n: Vec2, mut f: impl FnMut(Point, f64)) {
let [v0, v1, v2, v3] = [s.p0, s.p1, s.p2, s.p3].map(|p| p.to_vec2().dot(n));
f(s.p0, v0);
f(s.p3, v3);
// The derivative of p(t) · n, divided by 3: a quadratic in t.
let (d0, d1, d2) = (v1 - v0, v2 - v1, v3 - v2);
let (qa, qb, qc) = (d0 - 2.0 * d1 + d2, 2.0 * (d1 - d0), d0);
let mut root = |t: f64| {
if t > 0.0 && t < 1.0 {
let p = s.eval(t);
f(p, p.to_vec2().dot(n));
}
};
let scale = qa.abs().max(qb.abs()).max(qc.abs());
if !scale.is_finite() || scale <= 0.0 {
return;
}
if qa.abs() <= 1e-12 * scale {
if qb != 0.0 {
root(-qc / qb);
}
return;
}
let disc = qb * qb - 4.0 * qa * qc;
if disc < 0.0 {
return;
}
// The stable form of the two roots; with `qb` zero the sign is taken as positive, so `q` is
// not zero.
let sign = if qb < 0.0 { -1.0 } else { 1.0 };
let q = -0.5 * (qb + sign * disc.sqrt());
root(q / qa);
if q != 0.0 {
root(qc / q);
}
}
/// The unit vector at `angle` radians.
fn dir(angle: f64) -> Vec2 {
Vec2::new(angle.cos(), angle.sin())
}
/// The common tangents of `a` and `b`: the external ones, then the internal ones, each in order of
/// the angle of its normal. Separate outlines have two of each; overlapping ones only external
/// ones (two for ellipses, possibly more for paths whose outlines cross more often); one inside the
/// other none; outlines that touch share one tangent where they touch.
pub fn common_tangents(a: &Outline, b: &Outline) -> Result<Vec<Tangent>, Coincide> {
// Worked out about the point between the two centers.
let origin = (a.center().to_vec2() + b.center().to_vec2()) / 2.0;
let (a, b) = (&a.shifted(-origin), &b.shifted(-origin));
let size = a.size().max(b.size()).max((a.center() - b.center()).hypot());
let tol = 1e-9 * size;
// The normal angles sampled: evenly spaced ones, and every angle where the support value of
// either outline passes to another segment. Between two neighboring samples each outline is
// then touched on one segment.
let mut at: Vec<f64> = (0..SAMPLES).map(|k| k as f64 * TAU / SAMPLES as f64).collect();
a.breaks(&mut at);
b.breaks(&mut at);
let mut at: Vec<f64> = at.into_iter().map(|t| t.rem_euclid(TAU)).map(|t| if t < TAU { t } else { 0.0 }).collect();
at.sort_by(f64::total_cmp);
at.dedup_by(|y, x| *y - *x <= 1e-12);
// The segment each outline is touched on at each sample, found by walking around once.
let hints = |o: &Outline, sign: f64| -> Vec<usize> {
let mut out = Vec::with_capacity(at.len());
let mut i = at.first().map_or(0, |t| o.support_scan(dir(*t) * sign).1);
for t in &at {
i = o.support_from(dir(*t) * sign, i).1;
out.push(i);
}
out
};
let (ha, hb, hb_back) = (hints(a, 1.0), hints(b, 1.0), hints(b, -1.0));
let hint = |h: &[usize], k: usize| h.get(k).copied().unwrap_or(0);
let external = roots(&at, &|t, k| a.support_from(dir(t), hint(&ha, k)).0 - b.support_from(dir(t), hint(&hb, k)).0, tol)?;
let internal = roots(&at, &|t, k| a.support_from(dir(t), hint(&ha, k)).0 + b.support_from(-dir(t), hint(&hb_back, k)).0, tol)?;
let mut out = Vec::with_capacity(external.len() + internal.len());
for (kind, list) in [(TangentKind::External, external), (TangentKind::Internal, internal)] {
for root in list {
let t = tangent_at(a, b, kind, dir(root.angle), root.double, size);
out.push(Tangent { from: t.from + origin, to: t.to + origin, ..t });
}
}
Ok(out)
}
/// A zero of a support-value difference: the normal's angle, and whether the difference only
/// touches zero there (outlines that touch) rather than crossing it.
#[derive(Clone, Copy, Debug)]
struct Root {
angle: f64,
double: bool,
}
/// The tangent of `kind` whose normal is `n`: `a` lies where `p · n` is at most the line's value,
/// and `b` on the same side (external) or the other side (internal). `double` when the outlines
/// touch there.
fn tangent_at(a: &Outline, b: &Outline, kind: TangentKind, n: Vec2, double: bool, size: f64) -> Tangent {
// The rounding allowed in `p · n` grows with each outline's own size and its distance from the
// origin.
let rounding = |o: &Outline| 1e-12 * o.size() + 1e-14 * (o.center().to_vec2().hypot() + o.size());
let (tol_a, tol_b) = (rounding(a), rounding(b));
// Bisection finds a simple root's angle to about the rounding of the support values; the
// golden-section search finds a double root's to about 1e-8 radians.
let slope = if double { 1e-7 } else { 1e-10 };
let ha = a.support(n);
let (on_a, on_b) = match kind {
TangentKind::External => (a.touching(n, ha, tol_a, slope), b.touching(n, b.support(n), tol_b, slope)),
TangentKind::Internal => (a.touching(n, ha, tol_a, slope), b.touching(-n, b.support(-n), tol_b, slope)),
};
// Positions along the line, which runs square to `n` through `n * ha`.
let t = Vec2::new(-n.y, n.x);
let along = |p: &Point| p.to_vec2().dot(t);
let mean = |v: &[Point]| v.iter().map(along).sum::<f64>() / v.len().max(1) as f64;
let all = on_a.iter().chain(&on_b).map(along);
let (lo, hi) = all.fold((f64::MAX, f64::MIN), |(lo, hi), s| (lo.min(s), hi.max(s)));
let at = |s: f64| (n * ha + t * s).to_point();
// A double root's angle is found less exactly than a simple one's, so touching points may
// stand a little apart.
let (from, to) = if double && hi - lo <= 1e-6 * size {
// Touching at one point: the narrower outline's width along the line, centered there.
let width = [a, b].map(|o| o.support(t) + o.support(-t)).into_iter().fold(f64::MAX, f64::min);
let mid = (lo + hi) / 2.0;
(mid - width / 2.0, mid + width / 2.0)
} else if mean(&on_a) <= mean(&on_b) {
(lo, hi)
} else {
(hi, lo)
};
Tangent { kind, from: at(from), to: at(to) }
}
/// The angles in `[0, 2π)` where `f` (periodic) is zero, within `tol`. An interval where it stays
/// zero (outlines that meet at a corner or along a shared stretch) gives the angle at its middle,
/// as a double root.
///
/// `at` holds the sampled angles in increasing order, in `[0, 2π)`; `f(t, k)` is `f` at an angle
/// `t` at or after sample `k` and before the sample two on.
fn roots(at: &[f64], f: &dyn Fn(f64, usize) -> f64, tol: f64) -> Result<Vec<Root>, Coincide> {
let n = at.len();
if n < 3 {
return Err(Coincide);
}
// The angle of sample `k + j`, counted on from sample `k` past 2π.
let ang = |k: usize, j: usize| at.get((k + j) % n).copied().unwrap_or(0.0) + TAU * ((k + j) / n) as f64;
let v: Vec<f64> = (0..n).map(|k| f(ang(k, 0), k)).collect();
let val = |k: usize| v.get(k % n).copied().unwrap_or(0.0);
let zero = |x: f64| x.abs() <= tol;
let Some(start) = v.iter().position(|x| !zero(*x)) else { return Err(Coincide) };
let simple = |angle: f64| Root { angle, double: false };
let mut out = vec![];
// Between `lo` (sample `k`) and `hi`, where `s * f` is positive at both ends: the least of
// `s * f`, a double root where it reaches zero, two roots where it goes past it, none where it
// stays above.
let dip = |out: &mut Vec<Root>, s: f64, k: usize, lo: f64, hi: f64| {
let g = |t: f64| f(t, k);
let (t, least) = golden(&|t| s * g(t), lo, hi);
if least < -tol {
out.push(simple(bisect(&g, lo, t)));
out.push(simple(bisect(&g, t, hi)));
} else if least <= tol {
out.push(Root { angle: t, double: true });
}
};
for i in 0..n {
let k = (start + i) % n;
let (prev, next) = ((k + n - 1) % n, k + 1);
let theta = ang(k, 0);
if zero(val(k)) {
continue;
}
if zero(val(next)) {
let len = (1..n).take_while(|j| zero(val(k + j))).count();
if len == 1 {
// One sample on zero: a crossing when the samples beside it differ in sign, else a
// dip between them.
let (lo, hi) = (theta, ang(k, 2));
let s = val(k).signum();
if val(k + 2).signum() == s {
dip(&mut out, s, k, lo, hi);
} else {
out.push(simple(bisect(&|t| f(t, k), lo, hi)));
}
} else {
out.push(Root { angle: (ang(k, 1) + ang(k, len)) / 2.0, double: true });
}
continue;
}
if val(k).signum() != val(next).signum() {
out.push(simple(bisect(&|t| f(t, k), theta, ang(k, 1))));
continue;
}
// A sampled minimum of |f|: the curve may dip to zero (a double root), or across it and
// back (two roots), between the neighboring samples.
let (vp, vk, vn) = (val(prev), val(k), val(next));
if !zero(vp) && vp.signum() == vk.signum() && vk.abs() < vp.abs() && vk.abs() <= vn.abs() {
let lo = if k == 0 { ang(prev, 0) - TAU } else { ang(prev, 0) };
dip(&mut out, vk.signum(), prev, lo, ang(k, 1));
}
}
let mut out: Vec<Root> = out.into_iter().map(|r| Root { angle: r.angle.rem_euclid(TAU), ..r }).collect();
out.sort_by(|a, b| a.angle.total_cmp(&b.angle));
out.dedup_by(|b, a| {
let same = (b.angle - a.angle).abs() < 1e-7;
a.double |= same && b.double;
same
});
if out.len() > 1
&& out.first().zip(out.last()).is_some_and(|(f, l)| f.angle + TAU - l.angle < 1e-7)
&& let Some(last) = out.pop()
&& let Some(first) = out.first_mut()
{
first.double |= last.double;
}
Ok(out)
}
/// A root of `f` between `lo` and `hi`, where it has opposite signs.
fn bisect(f: &dyn Fn(f64) -> f64, mut lo: f64, mut hi: f64) -> f64 {
let s = f(lo).signum();
for _ in 0..STEPS {
let mid = (lo + hi) / 2.0;
if f(mid).signum() == s {
lo = mid;
} else {
hi = mid;
}
}
(lo + hi) / 2.0
}
/// Where `g` is least between `lo` and `hi` (taken as having one minimum there), and its value.
fn golden(g: &dyn Fn(f64) -> f64, mut lo: f64, mut hi: f64) -> (f64, f64) {
let r = (5f64.sqrt() - 1.0) / 2.0;
let (mut x1, mut x2) = (hi - r * (hi - lo), lo + r * (hi - lo));
let (mut g1, mut g2) = (g(x1), g(x2));
for _ in 0..STEPS {
if g1 < g2 {
hi = x2;
(x2, g2) = (x1, g1);
x1 = hi - r * (hi - lo);
g1 = g(x1);
} else {
lo = x1;
(x1, g1) = (x2, g2);
x2 = lo + r * (hi - lo);
g2 = g(x2);
}
}
let t = (lo + hi) / 2.0;
(t, g(t))
}
#[cfg(test)]
mod tests {
use kurbo::Rect;
use vectorcraft_geom::shapes;
use super::*;
fn circle(cx: f64, cy: f64, r: f64) -> Outline {
Outline::ellipse(Affine::new([r, 0.0, 0.0, r, cx, cy])).unwrap()
}
/// An ellipse with semi-axes `rx`, `ry`, turned `deg` degrees, centered at (`cx`, `cy`).
fn ellipse_map(cx: f64, cy: f64, rx: f64, ry: f64, deg: f64) -> Affine {
Affine::translate((cx, cy)) * Affine::rotate(deg.to_radians()) * Affine::scale_non_uniform(rx, ry)
}
/// Whether `t` has its two ends at `p` and `q`, in either order.
fn ends_at(t: &Tangent, p: Point, q: Point) -> bool {
ends_within(t, p, q, 1e-7)
}
/// [`ends_at`] within `eps`: the angle of a tangent where outlines touch (a double root) is
/// found to about 1e-8 radians.
fn ends_within(t: &Tangent, p: Point, q: Point, eps: f64) -> bool {
let near = |a: Point, b: Point| (a - b).hypot() < eps;
(near(t.from, p) && near(t.to, q)) || (near(t.from, q) && near(t.to, p))
}
/// Checks `t` against dense samples of the two outlines, without support values: each lies on
/// one side of the line (the same side for an external tangent, opposite ones for an internal
/// one) and comes within `eps` of it.
fn check_against_samples(t: &Tangent, a: &[Point], b: &[Point], eps: f64) {
let d = t.to - t.from;
let n = Vec2::new(-d.y, d.x) / d.hypot();
let side = |pts: &[Point]| {
let dist: Vec<f64> = pts.iter().map(|p| (*p - t.from).dot(n)).collect();
let (lo, hi) = dist.iter().fold((f64::MAX, f64::MIN), |(lo, hi), s| (lo.min(*s), hi.max(*s)));
assert!(lo > -eps || hi < eps, "the line crosses the outline: {lo} .. {hi} ({t:?})");
assert!(lo.abs() < eps || hi.abs() < eps, "the line misses the outline: {lo} .. {hi} ({t:?})");
if hi < eps { -1.0 } else { 1.0 }
};
let (sa, sb) = (side(a), side(b));
match t.kind {
TangentKind::External => assert_eq!(sa, sb, "{t:?}"),
TangentKind::Internal => assert_ne!(sa, sb, "{t:?}"),
}
}
fn sample_ellipse(m: Affine, count: usize) -> Vec<Point> {
(0..count).map(|k| m * Point::new((TAU * k as f64 / count as f64).cos(), (TAU * k as f64 / count as f64).sin())).collect()
}
fn sample_path(sp: &SubPath, per_segment: usize) -> Vec<Point> {
(0..sp.segment_count()).flat_map(|k| (0..per_segment).map(move |j| sp.segment(k).eval(j as f64 / per_segment as f64))).collect()
}
#[test]
fn two_circles_have_four_tangents_at_the_closed_form_points() {
let (c1, r1, c2, r2) = (Point::new(0.0, 0.0), 10.0, Point::new(100.0, 0.0), 20.0);
let all = common_tangents(&circle(c1.x, c1.y, r1), &circle(c2.x, c2.y, r2)).unwrap();
assert_eq!(all.len(), 4, "{all:?}");
// External: (c1 - c2) · n = r2 - r1, so n.x = -0.1; the points are c + r n on each.
// Internal: (c1 - c2) · n = -(r1 + r2), so n.x = 0.3; c1 + r1 n and c2 - r2 n.
for (kind, nx) in [(TangentKind::External, -0.1f64), (TangentKind::Internal, 0.3)] {
for sy in [1.0, -1.0] {
let n = Vec2::new(nx, sy * (1.0 - nx * nx).sqrt());
let far = if kind == TangentKind::External { c2 + n * r2 } else { c2 - n * r2 };
let found = all.iter().filter(|t| t.kind == kind && ends_at(t, c1 + n * r1, far)).count();
assert_eq!(found, 1, "{kind:?} {n:?} in {all:?}");
}
}
// Each runs from the first outline to the second.
assert!(all.iter().all(|t| (t.from - c1).hypot() < (t.to - c1).hypot()));
}
#[test]
fn turned_ellipses_match_an_independent_numeric_solution() {
let (ma, mb) = (ellipse_map(0.0, 0.0, 40.0, 15.0, 30.0), ellipse_map(150.0, 60.0, 25.0, 60.0, -70.0));
let all = common_tangents(&Outline::ellipse(ma).unwrap(), &Outline::ellipse(mb).unwrap()).unwrap();
assert_eq!(all.iter().filter(|t| t.kind == TangentKind::External).count(), 2, "{all:?}");
assert_eq!(all.iter().filter(|t| t.kind == TangentKind::Internal).count(), 2, "{all:?}");
let (sa, sb) = (sample_ellipse(ma, 5_000), sample_ellipse(mb, 5_000));
for t in &all {
check_against_samples(t, &sa, &sb, 1e-3);
}
// A brute-force scan of the normal's angle with support values read off the samples finds
// the same normals.
let support = |pts: &[Point], n: Vec2| pts.iter().map(|p| p.to_vec2().dot(n)).fold(f64::MIN, f64::max);
let scan = |f: &dyn Fn(Vec2) -> f64| {
let steps = 7_200;
let g = |k: usize| f(dir(TAU * k as f64 / steps as f64));
(0..steps).filter(|&k| g(k).signum() != g((k + 1) % steps).signum()).map(|k| TAU * (k as f64 + 0.5) / steps as f64).collect::<Vec<_>>()
};
let ext = scan(&|n| support(&sa, n) - support(&sb, n));
let int = scan(&|n| support(&sa, n) + support(&sb, -n));
for (kind, expected) in [(TangentKind::External, ext), (TangentKind::Internal, int)] {
assert_eq!(expected.len(), 2);
for angle in expected {
let n = dir(angle);
let hit = all.iter().filter(|t| t.kind == kind).any(|t| {
let d = t.to - t.from;
let m = Vec2::new(d.y, -d.x) / d.hypot();
m.dot(n).abs() > 1.0 - 1e-6
});
assert!(hit, "{kind:?} normal at {angle} in {all:?}");
}
}
}
#[test]
fn nested_overlapping_and_touching_circles() {
// One inside the other: none.
assert!(common_tangents(&circle(0.0, 0.0, 50.0), &circle(5.0, 0.0, 10.0)).unwrap().is_empty());
// Overlapping: the two external ones only.
let over = common_tangents(&circle(0.0, 0.0, 30.0), &circle(40.0, 0.0, 30.0)).unwrap();
assert_eq!(over.len(), 2);
assert!(over.iter().all(|t| t.kind == TangentKind::External));
assert!(over.iter().any(|t| ends_at(t, Point::new(0.0, 30.0), Point::new(40.0, 30.0))));
// Touching from outside at (10, 0): two external ones and one shared internal one, square to
// the line of centers, as long as the smaller circle is wide.
let touch = common_tangents(&circle(0.0, 0.0, 10.0), &circle(30.0, 0.0, 20.0)).unwrap();
assert_eq!(touch.iter().filter(|t| t.kind == TangentKind::External).count(), 2, "{touch:?}");
let shared: Vec<_> = touch.iter().filter(|t| t.kind == TangentKind::Internal).collect();
assert_eq!(shared.len(), 1, "{touch:?}");
assert!(ends_within(shared[0], Point::new(10.0, -10.0), Point::new(10.0, 10.0), 1e-5), "{shared:?}");
// Touching along a direction between two sampled normals: the sampled minimum is refined
// down to the double root.
let along = dir(0.1234);
let off = common_tangents(&circle(0.0, 0.0, 10.0), &circle(30.0 * along.x, 30.0 * along.y, 20.0)).unwrap();
assert_eq!(off.iter().filter(|t| t.kind == TangentKind::Internal).count(), 1, "{off:?}");
// A hair apart: two internal tangents less than a sample apart, both kept.
let d = 30.000_01;
let near_miss = common_tangents(&circle(0.0, 0.0, 10.0), &circle(d * along.x, d * along.y, 20.0)).unwrap();
assert_eq!(near_miss.iter().filter(|t| t.kind == TangentKind::Internal).count(), 2, "{near_miss:?}");
// Inside with a clearance of 1e-6: no tangent.
assert!(common_tangents(&circle(0.0, 0.0, 50.0), &circle(40.0 - 1e-6, 0.0, 10.0)).unwrap().is_empty());
// Equal circles a hair apart: the two external tangents run between their real contact
// points, that hair apart, not as a touching tangent.
let hair = common_tangents(&circle(0.0, 0.0, 30.0), &circle(1e-5, 0.0, 30.0)).unwrap();
assert_eq!(hair.len(), 2, "{hair:?}");
assert!(hair.iter().all(|t| ((t.to - t.from).hypot() - 1e-5).abs() < 1e-9), "{hair:?}");
// Touching from inside at (50, 0): the one shared external tangent.
let inside = common_tangents(&circle(0.0, 0.0, 50.0), &circle(40.0, 0.0, 10.0)).unwrap();
assert_eq!(inside.len(), 1, "{inside:?}");
assert!(ends_within(&inside[0], Point::new(50.0, -10.0), Point::new(50.0, 10.0), 1e-5), "{inside:?}");
}
#[test]
fn a_convex_bezier_blob_and_an_ellipse_path() {
// A lopsided convex blob of four curves.
let a = |x: f64, y: f64, ix: f64, iy: f64, ox: f64, oy: f64| {
vectorcraft_geom::Anchor::with_handles(Point::new(x, y), Point::new(ix, iy), Point::new(ox, oy))
};
let blob = SubPath::new(
vec![
a(0.0, 40.0, 0.0, 70.0, 0.0, 10.0),
a(50.0, 0.0, 20.0, 0.0, 90.0, 0.0),
a(110.0, 50.0, 110.0, 20.0, 110.0, 90.0),
a(40.0, 100.0, 80.0, 100.0, 10.0, 100.0),
],
true,
);
let round = shapes::ellipse(Rect::new(200.0, 150.0, 260.0, 230.0)).subpaths[0].clone();
let (oa, ob) = (Outline::convex(&blob).unwrap(), Outline::convex(&round).unwrap());
let all = common_tangents(&oa, &ob).unwrap();
assert_eq!(all.iter().filter(|t| t.kind == TangentKind::External).count(), 2, "{all:?}");
assert_eq!(all.iter().filter(|t| t.kind == TangentKind::Internal).count(), 2, "{all:?}");
let (sa, sb) = (sample_path(&blob, 4000), sample_path(&round, 4000));
for t in &all {
check_against_samples(t, &sa, &sb, 1e-3);
}
// The path's center is its center of area: the ellipse path's is its box's center.
assert!((ob.center() - Point::new(230.0, 190.0)).hypot() < 1e-6, "{:?}", ob.center());
}
#[test]
fn flat_sides_give_the_whole_stretch_they_touch() {
let square =
|x: f64| SubPath::polyline(&[Point::new(x, 0.0), Point::new(x + 10.0, 0.0), Point::new(x + 10.0, 10.0), Point::new(x, 10.0)], true);
let all = common_tangents(&Outline::convex(&square(0.0)).unwrap(), &Outline::convex(&square(30.0)).unwrap()).unwrap();
let ext: Vec<_> = all.iter().filter(|t| t.kind == TangentKind::External).collect();
assert_eq!(ext.len(), 2, "{all:?}");
assert!(ext.iter().any(|t| ends_at(t, Point::new(0.0, 0.0), Point::new(40.0, 0.0))), "{ext:?}");
assert!(ext.iter().any(|t| ends_at(t, Point::new(0.0, 10.0), Point::new(40.0, 10.0))), "{ext:?}");
// Far apart, each diamond is still touched only at its top corner.
let diamond =
|x: f64| SubPath::polyline(&[Point::new(x - 5.0, 0.0), Point::new(x, -5.0), Point::new(x + 5.0, 0.0), Point::new(x, 5.0)], true);
let far = common_tangents(&Outline::convex(&diamond(0.0)).unwrap(), &Outline::convex(&diamond(1e9)).unwrap()).unwrap();
let top = far.iter().find(|t| t.kind == TangentKind::External && t.from.y > 0.0).unwrap();
assert!(ends_within(top, Point::new(0.0, 5.0), Point::new(1e9, 5.0), 1e-3), "{far:?}");
// Far from the origin the center of area and the tangents come out as near it.
let o = 1e9;
let away = |x: f64| SubPath::polyline(&[(x, o), (x + 10.0, o), (x + 10.0, o + 10.0), (x, o + 10.0)].map(Point::from), true);
let (sa, sb) = (Outline::convex(&away(o)).unwrap(), Outline::convex(&away(o + 30.0)).unwrap());
assert!((sa.center() - Point::new(o + 5.0, o + 5.0)).hypot() < 1e-6, "{:?}", sa.center());
let shifted = common_tangents(&sa, &sb).unwrap();
assert!(shifted.iter().any(|t| ends_within(t, Point::new(o, o), Point::new(o + 40.0, o), 1e-6)), "{shifted:?}");
// The internal ones are the diagonals between the near corners.
let int: Vec<_> = all.iter().filter(|t| t.kind == TangentKind::Internal).collect();
assert_eq!(int.len(), 2, "{all:?}");
assert!(int.iter().any(|t| ends_at(t, Point::new(10.0, 0.0), Point::new(30.0, 10.0))), "{int:?}");
assert!(int.iter().any(|t| ends_at(t, Point::new(10.0, 10.0), Point::new(30.0, 0.0))), "{int:?}");
// Squares meeting at the corner (10, 10): every line through the corner between their
// sides touches both, and the one internal line drawn is the one at the middle of those
// directions, as long as a square is wide along it.
let box_at = |x: f64, y: f64| {
SubPath::polyline(&[Point::new(x, y), Point::new(x + 10.0, y), Point::new(x + 10.0, y + 10.0), Point::new(x, y + 10.0)], true)
};
let corner = common_tangents(&Outline::convex(&box_at(0.0, 0.0)).unwrap(), &Outline::convex(&box_at(10.0, 10.0)).unwrap()).unwrap();
let shared: Vec<_> = corner.iter().filter(|t| t.kind == TangentKind::Internal).collect();
assert_eq!(shared.len(), 1, "{corner:?}");
assert!(ends_within(shared[0], Point::new(5.0, 15.0), Point::new(15.0, 5.0), 1e-6), "{shared:?}");
// Sides 1e-6 off parallel: each line ends at the corners it touches, not at the corners
// of the sides it nearly lies along.
let tilted = common_tangents(&Outline::convex(&box_at(0.0, 0.0)).unwrap(), &Outline::convex(&box_at(30.0, -1e-6)).unwrap()).unwrap();
let ext: Vec<_> = tilted.iter().filter(|t| t.kind == TangentKind::External).collect();
assert_eq!(ext.len(), 2, "{tilted:?}");
assert!(ext.iter().any(|t| ends_within(t, Point::new(10.0, 10.0), Point::new(40.0, 10.0 - 1e-6), 1e-6)), "{ext:?}");
assert!(ext.iter().any(|t| ends_within(t, Point::new(0.0, 0.0), Point::new(30.0, -1e-6), 1e-6)), "{ext:?}");
}
/// A circle path of four curves, radius 100 about the origin, with an anchor at (100, 0).
fn circle_path() -> SubPath {
shapes::ellipse(Rect::new(-100.0, -100.0, 100.0, 100.0)).subpaths[0].clone()
}
/// The point of `sp` where `p · n` is largest.
fn peak(sp: &SubPath, n: Vec2) -> Point {
let mut best = (Point::ORIGIN, f64::MIN);
for k in 0..sp.segment_count() {
each_extreme(&sp.segment(k), n, |p, v| {
if v > best.1 {
best = (p, v);
}
});
}
best.0
}
#[test]
fn a_curve_is_touched_only_at_its_peak_beside_an_anchor() {
// The line touches the circle path 5e-4 radians from its anchor at (100, 0), where the
// anchor lies about 1.25e-5 inside the line: the line still ends at the peak, not at the
// anchor 0.05 along it.
let path = circle_path();
let n = dir(5e-4);
let away = Vec2::new(n.y, -n.x) * 300.0;
let a = Outline::convex(&path).unwrap();
let all = common_tangents(&a, &a.shifted(away)).unwrap();
let top = all.iter().find(|t| t.kind == TangentKind::External && (t.from.to_vec2().dot(n) - 100.0).abs() < 1e-3).unwrap();
let p = peak(&path, n);
assert!(ends_within(top, p, p + away, 1e-6), "{top:?} {p:?}");
// An exact circle touching the path there from outside: one shared internal line, as long
// as that circle is wide, not a stub running to the anchor.
let b = circle(p.x + 20.0 * n.x, p.y + 20.0 * n.y, 20.0);
let touch = common_tangents(&a, &b).unwrap();
let shared: Vec<_> = touch.iter().filter(|t| t.kind == TangentKind::Internal).collect();
assert_eq!(shared.len(), 1, "{touch:?}");
assert!(((shared[0].to - shared[0].from).hypot() - 40.0).abs() < 1e-3, "{shared:?}");
assert!(((shared[0].from.midpoint(shared[0].to)) - p).hypot() < 1e-3, "{shared:?}");
}
#[test]
fn outlines_crossing_more_often_than_the_even_samples_keep_every_tangent() {
// Two regular 400-gons about one center, one turned half a step: their outlines cross 800
// times, and an external tangent runs across each crossing.
let gon = |turn: f64| {
let pts: Vec<Point> = (0..400).map(|k| (dir(turn + TAU * k as f64 / 400.0) * 100.0).to_point()).collect();
SubPath::polyline(&pts, true)
};
let all = common_tangents(&Outline::convex(&gon(0.0)).unwrap(), &Outline::convex(&gon(TAU / 800.0)).unwrap()).unwrap();
assert_eq!(all.iter().filter(|t| t.kind == TangentKind::External).count(), 800);
assert_eq!(all.iter().filter(|t| t.kind == TangentKind::Internal).count(), 0);
// Each runs between a corner of one and the next corner of the other, about 0.785 apart.
assert!(all.iter().all(|t| ((t.to - t.from).hypot() - 200.0 * (TAU / 1600.0).sin()).abs() < 1e-6), "{:?}", all.first());
}
#[test]
fn a_curve_peaking_inside_a_segment_is_measured_at_its_peak() {
// p(t) · n has the control values 0, 0.25, 0.5, -0.25: its derivative's linear term is
// zero, and the peak, 0.25 at t = 0.5, lies inside the segment.
let s = CubicBez::new((0.0, 0.0), (1.0, 0.25), (2.0, 0.5), (3.0, -0.25));
let mut best = f64::MIN;
each_extreme(&s, Vec2::new(0.0, 1.0), |_, v| best = best.max(v));
assert!((best - 0.25).abs() < 1e-12, "{best}");
}
#[test]
fn open_concave_empty_and_identical_outlines_are_refused() {
let open = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(10.0, 10.0)], false);
assert_eq!(Outline::convex(&open).err(), Some(OutlineError::Open));
let star = shapes::star(Point::new(0.0, 0.0), 50.0, 20.0, 5, 0.0).subpaths[0].clone();
assert_eq!(Outline::convex(&star).err(), Some(OutlineError::NotConvex));
// A half disk whose straight side is a cubic with crossed handles: it bends the other way
// for a short stretch between two of the points the outline is checked at.
let mut bp = vectorcraft_geom::BezPath::new();
let k = 0.5523 * 50.0;
bp.move_to((0.0, 0.0));
bp.curve_to((62.4, 43.4), (60.3, 44.2), (100.0, 0.0));
bp.curve_to((100.0, -k), (50.0 + k, -50.0), (50.0, -50.0));
bp.curve_to((50.0 - k, -50.0), (0.0, -k), (0.0, 0.0));
bp.close_path();
let bend = vectorcraft_geom::PathData::from_bezpath(&bp).subpaths[0].clone();
assert_eq!(Outline::convex(&bend).err(), Some(OutlineError::NotConvex));
// A square traced twice around winds around twice.
let twice: Vec<Point> = [(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)].repeat(2).into_iter().map(Point::from).collect();
assert_eq!(Outline::convex(&SubPath::polyline(&twice, true)).err(), Some(OutlineError::NotConvex));
let flat = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(10.0, 0.0), Point::new(20.0, 0.0)], true);
assert_eq!(Outline::convex(&flat).err(), Some(OutlineError::Empty));
assert_eq!(Outline::ellipse(Affine::scale_non_uniform(10.0, 0.0)).err(), Some(OutlineError::Empty));
assert_eq!(Outline::ellipse(Affine::new([f64::NAN, 0.0, 0.0, 1.0, 0.0, 0.0])).err(), Some(OutlineError::Empty));
let many: Vec<Point> = (0..=MAX_TANGENT_SEGMENTS).map(|k| dir(TAU * k as f64 / (MAX_TANGENT_SEGMENTS + 1) as f64).to_point()).collect();
assert_eq!(Outline::convex(&SubPath::polyline(&many, true)).err(), Some(OutlineError::TooComplex));
// A square 1e110 wide has a finite center.
let huge = SubPath::polyline(&[(0.0, 0.0), (1e110, 0.0), (1e110, 1e110), (0.0, 1e110)].map(Point::from), true);
let center = Outline::convex(&huge).unwrap().center();
assert!((center - Point::new(5e109, 5e109)).hypot() < 1e98, "{center:?}");
assert_eq!(common_tangents(&circle(1.0, 2.0, 3.0), &circle(1.0, 2.0, 3.0)), Err(Coincide));
}
}
+166 -7
View File
@@ -1,14 +1,15 @@
//! PSD export: a layered bitmap at 8 bits per channel, written from the format's public
//! specification. The file holds the header, the resolution and colour profile resources, the
//! layer records and their channels (PackBits row by row; groups as section dividers), then the
//! specification. The file holds the header, the resolution, colour profile and slices resources,
//! the layer records and their channels (PackBits row by row; groups as section dividers), then the
//! merged image, which readers that skip layers show. RGB, CMYK (stored as 255 − ink, as the
//! format keeps inks) or grayscale.
use std::collections::HashMap;
use std::sync::Arc;
use vectorcraft_color::{BlendMode, cms};
use vectorcraft_doc::text::TypeAntiAlias;
use vectorcraft_doc::{Document, Knockout, LayerColor, Node, NodeKind};
use vectorcraft_doc::{Document, Knockout, LayerColor, Node, NodeId, NodeKind, SliceKind, SliceOptions, SliceSource};
use vectorcraft_geom::{Point, Rect};
use super::jpeg::{self, ColorModel};
@@ -302,6 +303,8 @@ struct File {
records: Vec<Record>,
ppi: f64,
icc: Option<Arc<[u8]>>,
/// Image resource 1050's data, when the file has slices.
slices: Option<Vec<u8>>,
}
/// Refuse a size the format can't store.
@@ -332,7 +335,8 @@ impl File {
out.extend(mode(self.model).to_be_bytes());
// No colour mode data.
out.extend(0u32.to_be_bytes());
// Image resources: the resolution (16.16 fixed point, pixels per inch shown in inches), the profile.
// Image resources: the resolution (16.16 fixed point, pixels per inch shown in inches), the
// profile, the slices.
let ppi = if self.ppi.is_finite() && self.ppi > 0.0 { self.ppi } else { 72.0 };
let fixed = (ppi.min(30_000.0) * 65536.0).round() as u32;
let res = [fixed.to_be_bytes(), [0, 1, 0, 1], fixed.to_be_bytes(), [0, 1, 0, 1]].concat();
@@ -341,6 +345,9 @@ impl File {
if let Some(icc) = &self.icc {
resource(&mut resources, 1039, icc)?;
}
if let Some(slices) = &self.slices {
resource(&mut resources, SLICES, slices)?;
}
out.extend(len32(resources.len())?.to_be_bytes());
out.extend(resources);
self.write_layers(&mut out)?;
@@ -390,17 +397,20 @@ fn icc(o: &PsdOptions) -> Result<Option<Arc<[u8]>>, String> {
pub fn encode(img: &Rendered, ppi: f64, o: &PsdOptions) -> Result<Vec<u8>, String> {
let inks = (o.color_model == ColorModel::Cmyk).then(|| jpeg::separated(img));
let merged = planes(o.color_model, &img.to_straight(), inks.as_deref(), true, false);
File { width: img.width, height: img.height, model: o.color_model, merged, alpha: false, records: vec![], ppi, icc: icc(o)? }.write()
File { width: img.width, height: img.height, model: o.color_model, merged, alpha: false, records: vec![], ppi, icc: icc(o)?, slices: None }
.write()
}
/// `region` of `doc` as a PSD with `opts` (see [`PsdOptions`]). The merged image is the export's
/// render; with Write Layers each part is also drawn alone as its own layer, cropped to what it
/// paints, its opacity and blend mode in the layer's record.
/// paints, its opacity and blend mode in the layer's record. The user and object slices that reach
/// into `region` are written with or without layers ([`slices`]).
pub(crate) fn export(r: &mut Renderer, doc: &Document, region: Rect, opts: &RasterExportOptions) -> Result<Vec<u8>, String> {
let o = &opts.psd;
let scale = opts.scale();
let (width, height) = crate::region_pixels(region, scale);
check_size(width, height)?;
let slices = slices(doc, region, scale, (width, height))?;
let ro = opts.render_options(RasterFormat::Psd);
let (mut merged, mut alpha) = {
let px = r.render_region_with(doc, region, scale, &ro).to_straight();
@@ -426,7 +436,156 @@ pub(crate) fn export(r: &mut Renderer, doc: &Document, region: Rect, opts: &Rast
merged.pop();
alpha = false;
}
File { width, height, model: o.color_model, merged, alpha, records, ppi: opts.ppi, icc: icc(o)? }.write()
File { width, height, model: o.color_model, merged, alpha, records, ppi: opts.ppi, icc: icc(o)?, slices }.write()
}
/// The image resource that holds the slices.
const SLICES: u16 = 1050;
/// The most slices one file holds (as many as `document.open` reads).
pub(crate) const MAX_SLICES: usize = 10_000;
/// The longest text of a slice, in UTF-16 units (as long as `document.open` reads).
pub(crate) const MAX_SLICE_TEXT: usize = 65_536;
/// Resource 1050's data for the user and object slices of `doc` that reach into `region`, in the
/// "Slices resource format" of the Photoshop File Formats Specification
/// (<https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/>), version 6: the bounds of all
/// the slices, the group's name, the count, then one record per slice. `None` when no slice
/// reaches into `region`. Each rectangle is the slice as laid out ([`Document::slice_layout`]),
/// clipped to `region` and given in the `size` canvas's pixels at `scale`, at least one pixel
/// each way. Every slice is written as one the user made (origin 2): an object slice keeps its
/// rectangle and options. Auto slices aren't written; a reader lays them out again. An HTML Text
/// slice is written as No Image with its type's text as HTML. Text alignment is written as the
/// default. An error when a slice's bounds aren't finite, or there are more than [`MAX_SLICES`]
/// slices, a text longer than [`MAX_SLICE_TEXT`], or more than 4 GB of slices ([`room`]).
fn slices(doc: &Document, region: Rect, scale: f64, (w, h): (u32, u32)) -> Result<Option<Vec<u8>>, String> {
let users: HashMap<NodeId, &SliceOptions> = doc.slices.iter().map(|s| (s.id, &s.options)).collect();
let mut found = vec![];
for area in doc.slice_layout().iter().filter(|a| a.source != SliceSource::Auto) {
let Some(id) = area.id else { continue };
let r = area.rect;
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) {
let number = area.number;
return Err(format!("slice {number} has no finite bounds and can't be written to PSD"));
}
let Some(options) = users.get(&id).copied().or_else(|| doc.slice_options(id)) else { continue };
// The part inside `region`, found before the region is rounded to whole pixels.
let (x0, y0, x1, y1) = (r.x0.max(region.x0), r.y0.max(region.y0), r.x1.min(region.x1), r.y1.min(region.y1));
if !(x0 < x1 && y0 < y1) {
continue;
}
let edge = |v: f64, origin: f64, max: u32| ((v - origin) * scale).clamp(0.0, f64::from(max));
let (l, t, r, b) = (edge(x0, region.x0, w), edge(y0, region.y0, h), edge(x1, region.x0, w), edge(y1, region.y0, h));
// Whole pixels, at least one each way.
let span = |a: f64, b: f64, max: u32| {
let max = i64::from(max);
let (mut a, mut b) = ((a.round() as i64).clamp(0, max), (b.round() as i64).clamp(0, max));
if b <= a {
a = a.min(max - 1);
b = a + 1;
}
(a as i32, b as i32)
};
let ((l, r), (t, b)) = (span(l, r, w), span(t, b, h));
let text = match options.kind {
SliceKind::HtmlText => doc.node(id).map(html_text).unwrap_or_default(),
_ => options.text.clone(),
};
found.push(([l, t, r, b], options, text));
}
if found.is_empty() {
return Ok(None);
}
if found.len() > MAX_SLICES {
let count = found.len();
return Err(format!("the document has {count} slices, more than the {MAX_SLICES} a PSD file holds"));
}
let (mut top, mut left, mut bottom, mut right) = (i32::MAX, i32::MAX, 0, 0);
for ([l, t, r, b], _, _) in &found {
(left, top, right, bottom) = (left.min(*l), top.min(*t), right.max(*r), bottom.max(*b));
}
let mut out = 6u32.to_be_bytes().to_vec();
for v in [top, left, bottom, right] {
out.extend(v.to_be_bytes());
}
let stem = doc.title.rsplit_once('.').map_or(doc.title.as_str(), |(s, _)| s);
unicode(&mut out, stem)?;
out.extend((found.len() as u32).to_be_bytes());
// IDs from 1.
for ((rect, o, text), id) in found.into_iter().zip(1u32..) {
out.extend(id.to_be_bytes());
// Group 0; made by the user.
out.extend(0u32.to_be_bytes());
out.extend(2u32.to_be_bytes());
unicode(&mut out, &o.name)?;
out.extend(u32::from(o.kind == SliceKind::Image).to_be_bytes());
for v in rect {
out.extend(v.to_be_bytes());
}
for s in [&o.url, &o.target, &o.message, &o.alt] {
unicode(&mut out, s)?;
}
// The cell text is HTML, as a No Image slice shows it.
out.push(1);
unicode(&mut out, &text)?;
// The default horizontal and vertical alignment.
out.extend([0; 8]);
out.extend(background(o));
}
Ok(Some(out))
}
/// A slice's background as alpha, red, green and blue: none (all 0), the matte (alpha 0 over a
/// colour) or an opaque `#rrggbb`.
fn background(o: &SliceOptions) -> [u8; 4] {
let bg = o.background.trim();
if bg.eq_ignore_ascii_case("matte") {
return [0, 255, 255, 255];
}
let hex = bg.strip_prefix('#').filter(|h| h.len() == 6 && h.bytes().all(|b| b.is_ascii_hexdigit()));
match hex.and_then(|h| u32::from_str_radix(h, 16).ok()) {
Some(c) => {
let [_, r, g, b] = c.to_be_bytes();
[255, r, g, b]
}
None => [0; 4],
}
}
/// The text of type object `n` as the HTML an HTML Text slice shows: `&`, `<` and `>` escaped, a
/// line break as `<br>` (CR LF is one break). Empty for anything but type.
fn html_text(n: &Node) -> String {
let NodeKind::Text(t) = &n.kind else { return String::new() };
t.plain_text()
.replace("\r\n", "\n")
.split(['\n', '\r', '\u{2029}'])
.map(|l| l.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;"))
.collect::<Vec<_>>()
.join("<br>")
}
/// `s` as a Unicode string: a count of UTF-16 units, then the units. An error past
/// [`MAX_SLICE_TEXT`] units, or when the string would take `out` past [`room`].
fn unicode(out: &mut Vec<u8>, s: &str) -> Result<(), String> {
let units = s.encode_utf16().count();
if units > MAX_SLICE_TEXT {
return Err(format!("a slice's text has more than the {MAX_SLICE_TEXT} characters a PSD file holds"));
}
room(out.len(), units)?;
out.extend((units as u32).to_be_bytes());
out.extend(s.encode_utf16().flat_map(|u| u.to_be_bytes()));
Ok(())
}
/// An error when `units` UTF-16 units and their count, added to a slices resource of `len` bytes,
/// make it longer than the 4 GB a PSD resource holds.
pub(crate) fn room(len: usize, units: usize) -> Result<(), String> {
let end = units.checked_mul(2).and_then(|n| n.checked_add(4)).and_then(|n| n.checked_add(len));
match end.map(u32::try_from) {
Some(Ok(_)) => Ok(()),
_ => Err("the slices are too large for PSD (at most 4 GB)".into()),
}
}
/// Draws the parts of a document as layer records, bottom first.
+146 -3
View File
@@ -1,15 +1,16 @@
//! PSD export: the header, the layer records (names, bounds, opacity, blend modes, groups,
//! hidden layers), the merged image, the colour models, and a reader's view of the file.
//! hidden layers), the merged image, the colour models, the slices, and a reader's view of the
//! file.
use std::sync::Arc;
use vectorcraft_color::{BlendMode, Color};
use vectorcraft_doc::{Document, LayerColor, Node};
use vectorcraft_doc::{Document, LayerColor, Node, NodeId, Slice, SliceKind, SliceOptions};
use vectorcraft_geom::Rect;
use vectorcraft_testkit::fixtures::DocBuilder;
use super::jpeg::ColorModel;
use super::psd::{MAX_SIDE, PsdOptions};
use super::psd::{MAX_SIDE, MAX_SLICE_TEXT, MAX_SLICES, PsdOptions, room};
use super::*;
/// A 100 × 60 pt document: a red square on Layer 1, and on "Top" a half-opaque blue multiply
@@ -735,3 +736,145 @@ fn long_unicode_name_is_cut_on_a_character_boundary() {
let file = export(&b.build(), &opts(PsdOptions::default()));
assert_eq!(parse(&file).records.last().unwrap().name, "a".repeat(254));
}
/// `doc()` with a user slice over (20, 5)–(50, 15) and the red square made an object slice.
fn sliced() -> Document {
let mut d = doc();
let red = d.layers[0].children().unwrap()[0].id;
let user = SliceOptions {
name: "banner".into(),
url: "https://example.com/".into(),
target: "_blank".into(),
message: "Go".into(),
alt: "Banner".into(),
background: "#123456".into(),
..SliceOptions::default()
};
let id = d.alloc_id();
d.slices.push(Slice { id, rect: Rect::new(20.0, 5.0, 50.0, 15.0), options: user });
let cell = SliceOptions { kind: SliceKind::NoImage, text: "<b>Hi</b>".into(), background: "matte".into(), ..SliceOptions::default() };
d.node_mut(red).unwrap().extras_mut().slice = Some(Box::new(cell));
d
}
/// The slices resource of `file` as an independent reader reads it.
fn slices_of(file: &[u8]) -> Option<craft_psd::slices::SlicesResource> {
let psd = craft_psd::PsdFile::from_bytes(file).expect("a PSD a reader takes");
psd.resource(1050).map(|r| craft_psd::slices::SlicesResource::from_bytes(&r.data).expect("a slices resource a reader takes"))
}
#[test]
fn slices_are_written_with_or_without_layers() {
let d = sliced();
for layers in [true, false] {
let file = export(&d, &opts(PsdOptions { layers, ..PsdOptions::default() }));
let res = slices_of(&file).expect("the slices resource");
assert_eq!((res.version, res.bounds, res.group_name.as_str()), (6, [5, 10, 40, 50], "Untitled-1"));
let s = &res.slices;
assert_eq!(s.len(), 2, "{s:?}");
// Laid out top to bottom: the user slice, then the object slice, both written as made by
// the user.
let user = &s[0];
assert_eq!((user.id, user.origin, user.layer_id, user.kind, user.rect), (1, 2, None, 1, [20, 5, 50, 15]));
assert_eq!(
(user.name.as_str(), user.url.as_str(), user.target.as_str(), user.message.as_str(), user.alt.as_str()),
("banner", "https://example.com/", "_blank", "Go", "Banner")
);
assert_eq!(user.color, [255, 0x12, 0x34, 0x56]);
let cell = &s[1];
assert_eq!((cell.id, cell.origin, cell.kind, cell.rect), (2, 2, 0, [10, 10, 40, 40]));
assert_eq!((cell.name.as_str(), cell.cell_text.as_str(), cell.cell_text_is_html), ("", "<b>Hi</b>", true));
assert_eq!((cell.color[0], cell.color[1..].iter().any(|c| *c != 0)), (0, true), "the matte");
assert_eq!((cell.horizontal_align, cell.vertical_align), (0, 0));
}
// A document without slices has no slices resource.
assert!(slices_of(&export(&doc(), &opts(PsdOptions::default()))).is_none());
}
#[test]
fn slices_are_cut_to_the_exported_region_in_its_pixels() {
let doc = sliced();
// The right part at 2 px a point: the user slice is cut at the region's left edge, and the red
// square's slice ends at that edge.
let o = RasterExportOptions { ppi: 144.0, ..opts(PsdOptions::default()) };
let file = Renderer::new().export_region(&doc, Rect::new(40.0, 0.0, 100.0, 60.0), RasterFormat::Psd, &o).unwrap();
let res = slices_of(&file).unwrap();
assert_eq!(res.slices.iter().map(|s| s.rect).collect::<Vec<_>>(), [[0, 10, 20, 30]]);
assert_eq!(res.bounds, [10, 0, 30, 20]);
// A region no slice reaches has none.
let file = Renderer::new().export_region(&doc, Rect::new(60.0, 30.0, 100.0, 60.0), RasterFormat::Psd, &o).unwrap();
assert!(slices_of(&file).is_none());
// A slice thinner than a pixel keeps one pixel.
let mut thin = doc.clone();
thin.slices[0].rect = Rect::new(20.0, 5.0, 20.2, 15.0);
let res = slices_of(&export(&thin, &opts(PsdOptions::default()))).unwrap();
assert_eq!(res.slices[0].rect, [20, 5, 21, 15]);
// The overlap is found before the region is rounded to whole pixels: a slice inside a region
// that ends at 10.4 keeps its last pixel, and one past a region that ends at 10.6 isn't written.
let o = opts(PsdOptions::default());
let mut edge = doc.clone();
edge.slices[0].rect = Rect::new(10.1, 5.0, 10.3, 15.0);
edge.node_mut(edge.layers[0].children().unwrap()[0].id).unwrap().extras_mut().slice = None;
let file = Renderer::new().export_region(&edge, Rect::new(0.0, 0.0, 10.4, 60.0), RasterFormat::Psd, &o).unwrap();
assert_eq!(slices_of(&file).unwrap().slices.iter().map(|s| s.rect).collect::<Vec<_>>(), [[9, 5, 10, 15]]);
edge.slices[0].rect = Rect::new(10.7, 5.0, 10.9, 15.0);
let file = Renderer::new().export_region(&edge, Rect::new(0.0, 0.0, 10.6, 60.0), RasterFormat::Psd, &o).unwrap();
assert!(slices_of(&file).is_none());
}
#[test]
fn an_html_text_slice_writes_one_break_for_each_line_ending() {
use vectorcraft_doc::{CharStyle, NodeKind, TextObject};
use vectorcraft_geom::Point;
let mut d = DocBuilder::new(100.0, 60.0).build();
let t = TextObject::point(Point::new(10.0, 30.0), "A\r\nB\rC\nD\u{2029}E", CharStyle { size: 12.0, ..CharStyle::default() });
let mut n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(t)));
n.extras_mut().slice = Some(Box::new(SliceOptions { kind: SliceKind::HtmlText, ..SliceOptions::default() }));
let l = d.layers[0].id;
d.insert(Some(l), 0, n).unwrap();
let res = slices_of(&export(&d, &opts(PsdOptions::default()))).unwrap();
assert_eq!(res.slices[0].cell_text, "A<br>B<br>C<br>D<br>E");
}
#[test]
fn slice_ids_count_from_1_and_the_limits_are_errors() {
let mut doc = doc();
for i in 0..20 {
let id = doc.alloc_id();
let x = f64::from(i) * 5.0;
doc.slices.push(Slice { id, rect: Rect::new(x, 0.0, x + 5.0, 5.0), options: SliceOptions::default() });
}
let res = slices_of(&export(&doc, &opts(PsdOptions::default()))).unwrap();
let ids: Vec<u32> = res.slices.iter().map(|s| s.id).collect();
assert_eq!(ids, (1..=20).collect::<Vec<_>>());
let export_err = |d: &Document| {
Renderer::new().export_region(d, d.artboards[0].rect, RasterFormat::Psd, &opts(PsdOptions::default())).err().unwrap_or_default()
};
let mut long = doc.clone();
long.slices[0].options.alt = "a".repeat(MAX_SLICE_TEXT + 1);
let e = export_err(&long);
assert!(e.contains("characters"), "{e}");
let mut many = doc.clone();
many.slices = (0..=MAX_SLICES as u64)
.map(|i| Slice { id: NodeId(1_000_000 + i), rect: Rect::new(0.0, 0.0, 5.0, 5.0), options: SliceOptions::default() })
.collect();
let e = export_err(&many);
assert!(e.contains("slices"), "{e}");
// Not clipped to the artboard, a slice keeps bounds that aren't finite.
let mut bad = doc;
bad.slices_clip_to_artboard = false;
bad.slices[0].rect = Rect::new(f64::NAN, 0.0, 5.0, 5.0);
let e = export_err(&bad);
assert!(e.contains("finite"), "{e}");
}
#[test]
fn slices_past_4_gb_are_an_error_before_they_are_written() {
let max = u32::MAX as usize;
assert_eq!(room(0, MAX_SLICE_TEXT), Ok(()));
assert_eq!(room(max - 4 - 2 * 10, 10), Ok(()));
let e = room(max - 4 - 2 * 10, 11).err().unwrap_or_default();
assert!(e.contains("4 GB"), "{e}");
assert!(room(max, 0).is_err());
assert!(room(0, usize::MAX).is_err());
}
+3 -2
View File
@@ -96,8 +96,9 @@ pub(crate) fn visual_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
return art.visual_bounds_with(symbols).map(|r| with_raster_reach(symbols, n, r));
}
// Copies that each carry the raster effects listed before their Transform effect reach as far
// as each copy's raster effects paint, and the raster effects after it spread them all.
if effects::outer_effects(n).len() < n.appearance.effects.len()
// as each copy's raster effects paint, and the raster effects after it spread them all,
// as do copies whose fills and strokes each carry their own raster effects.
if (effects::outer_effects(n).len() < n.appearance.effects.len() || effects::has_copied_row_raster(n))
&& let Some(art) = effects::reshape(Some(symbols.document()), n, None)
{
return cull_bounds(symbols, &art);
+39
View File
@@ -1243,6 +1243,45 @@ fn each_copy_of_a_transform_effect_draws_its_own_shadow() {
assert!(b.x1 >= 80.0 - 1e-9, "{b:?}");
}
/// Each copy of a fill's own Transform effect, and each copy of its object's Transform effect,
/// draws the fill's drop shadow under itself, scaled with it: as for the object's own shadow
/// above, the copy's green shadow is 40 pt to its right. A 4 pt stroke's own Transform effect
/// gives each copy the shadow of its stroke: the copy's right edge (38..42 across) casts it at
/// 78..82. The bounds reach as far as the copy's shadow.
#[test]
fn each_copy_of_a_fills_or_strokes_transform_draws_its_own_shadow() {
let shadow = || fx("stylize.dropShadow", json!({"x": 20, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"}));
let copies = || fx("distort.transform", json!({"scaleH": 200, "scaleV": 200, "moveV": 60, "copies": 1}));
let square = |item: AppearanceItem| {
Node::path(NodeId(0), shapes::rectangle(Rect::new(10.0, 10.0, 30.0, 30.0)), Appearance { items: vec![item], ..Default::default() })
};
let mut red = FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
red.effects = vec![shadow(), copies()];
let own = square(AppearanceItem::Fill(red.clone()));
red.effects = vec![shadow()];
let mut owner = square(AppearanceItem::Fill(red));
owner.appearance.effects = vec![copies()];
for (what, n) in [("own", own), ("object's", owner)] {
let d = doc_with(Document::new(100.0, 100.0), n);
let img = render(&d);
assert_eq!(img.pixel(20, 20), [255, 0, 0, 255], "{what}: the square");
assert_eq!(img.pixel(45, 20), [0, 255, 0, 255], "{what}: the square's shadow");
assert_eq!(img.pixel(20, 80), [255, 0, 0, 255], "{what}: the copy");
assert_eq!(img.pixel(70, 80), [0, 255, 0, 255], "{what}: the copy's shadow, 40 pt to its right");
assert_eq!(img.pixel(85, 80), [255, 255, 255, 255], "{what}: past the copy's shadow");
let n = &d.layers[0].children().unwrap()[0];
let b = crate::fx::visual_bounds(&d.symbol_boxes(), n).unwrap();
assert!(b.x1 >= 80.0 - 1e-9, "{what}: {b:?}");
}
let mut blue = StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 4.0);
blue.effects = vec![shadow(), copies()];
let d = doc_with(Document::new(100.0, 100.0), square(AppearanceItem::Stroke(blue)));
let img = render(&d);
assert_eq!(img.pixel(50, 20), [0, 255, 0, 255], "the square's stroke shadow");
assert_eq!(img.pixel(80, 80), [0, 255, 0, 255], "the copy's stroke shadow, 40 pt to the right of its edge");
assert_eq!(img.pixel(60, 80), [255, 255, 255, 255], "inside the copy's stroke shadow");
}
/// Each copy of an image's Transform effect draws the drop shadow listed before the effect under
/// itself, scaled with it: the red image (20..50) has its green shadow 10 pt to its right, and its
/// copy scaled 50 % and moved 40 pt down (27.5..42.5 across, 67.5..82.5 down) has its own 5 pt to
+35 -5
View File
@@ -1,6 +1,7 @@
//! The shadow a 3D effect's solid casts: its faces projected along the first light onto a plane
//! behind the object (square to the view) or below it (under the object's own vertical axis, turned
//! with it), as one hard-edged vector shape.
//! with it), as one vector shape. The light's Softness gives the shape a blur radius
//! ([`ShadowPlane::blur`]); at 0 the shape stays hard-edged.
//!
//! Every face is projected whole, so the shape is the union of the projected faces: each contour is
//! turned so that its face winds the same way, and the shape is filled with the nonzero rule. The
@@ -48,20 +49,36 @@ pub struct Shadow {
/// How far the plane reaches, as a share (0.1..4): at 1 the plane is a square four times the
/// object's largest size across.
pub bounds: f64,
/// The casting light's Softness (0..1): at 0 the shadow is hard-edged, above it blurred
/// ([`ShadowPlane::blur`]).
pub softness: f64,
}
impl Default for Shadow {
fn default() -> Self {
Self { position: ShadowPosition::Behind, distance: 0.0, bounds: 1.0 }
Self { position: ShadowPosition::Behind, distance: 0.0, bounds: 1.0, softness: 0.0 }
}
}
impl Shadow {
fn sanitized(self) -> Self {
Self { distance: finite(self.distance, 0.0, 0.0, 1.0), bounds: finite(self.bounds, 1.0, 0.1, 4.0), ..self }
Self {
distance: finite(self.distance, 0.0, 0.0, 1.0),
bounds: finite(self.bounds, 1.0, 0.1, 4.0),
softness: finite(self.softness, 0.0, 0.0, 1.0),
..self
}
}
}
/// The blur radius at full Softness on a plane that touches the object, as a share of the object's
/// largest size, and what each share of Distance from Object adds to it. VectorCraft's own values.
const BLUR_NEAR: f64 = 0.05;
const BLUR_PER_DISTANCE: f64 = 0.2;
/// Most blur radius a shadow takes, in points (the Gaussian Blur effect's own limit).
pub const MAX_SHADOW_BLUR: f64 = 1000.0;
/// The rotation and projection a solid is drawn with.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct Projection {
@@ -119,6 +136,17 @@ pub struct ShadowPlane {
foot: V3,
/// Half the side of the square the plane ends at.
half: f64,
/// The blur radius of the shadow on the plane, in points ([`ShadowPlane::blur`]).
blur: f64,
}
impl ShadowPlane {
/// The radius, in points, of the blur that softens the edges of the shadow on this plane: 0 at
/// Softness 0, and with Softness a share of the object's largest size that grows with the
/// plane's distance from the object (VectorCraft's own mapping), at most [`MAX_SHADOW_BLUR`].
pub fn blur(&self) -> f64 {
self.blur
}
}
/// The faces of one object's solids, gathered to cast one shadow. The solids of one object share
@@ -254,13 +282,15 @@ impl ShadowCaster {
let level = corners().map(|v| n.dot(*v)).fold(f64::INFINITY, f64::min) - s.distance * size;
let centre = V3((lo.0 + hi.0) / 2.0, (lo.1 + hi.1) / 2.0, (lo.2 + hi.2) / 2.0);
let foot = add(centre, scale(n, level - n.dot(centre)));
Some(ShadowPlane { projection: p, light, reach, n, u, w, level, foot, half: 2.0 * s.bounds * size })
let blur = (s.softness * size * (BLUR_NEAR + BLUR_PER_DISTANCE * s.distance)).min(MAX_SHADOW_BLUR);
let blur = if blur.is_finite() { blur } else { 0.0 };
Some(ShadowPlane { projection: p, light, reach, n, u, w, level, foot, half: 2.0 * s.bounds * size, blur })
}
/// The shadow the faces in the ranges `faces` cast on `plane`, on the page, filled with the
/// nonzero rule; `None` when nothing of it falls within the plane.
pub fn path_on(&self, plane: &ShadowPlane, faces: &[Range<usize>]) -> Option<PathData> {
let &ShadowPlane { projection: p, light, reach, n, u, w, level, foot, half } = plane;
let &ShadowPlane { projection: p, light, reach, n, u, w, level, foot, half, .. } = plane;
// A corner's shadow, in the plane's axes about the foot.
let cast = |v: V3| {
let q = add(v, scale(light, -(n.dot(v) - level) / reach));
+31
View File
@@ -127,10 +127,41 @@ fn bad_settings_are_sanitized_and_an_empty_caster_casts_nothing() {
let wild = Shadow { distance: f64::NAN, bounds: f64::INFINITY, ..Shadow::default() };
assert_eq!(wild.sanitized(), Shadow { bounds: 1.0, ..Shadow::default() });
assert_eq!(Shadow { distance: -3.0, bounds: 99.0, ..Shadow::default() }.sanitized(), Shadow { bounds: 4.0, ..Shadow::default() });
assert_eq!(Shadow { softness: f64::NAN, ..Shadow::default() }.sanitized(), Shadow::default());
assert_eq!(Shadow { softness: 7.0, ..Shadow::default() }.sanitized(), Shadow { softness: 1.0, ..Shadow::default() });
assert_eq!(ShadowPosition::parse("below"), Some(ShadowPosition::Below));
assert_eq!(ShadowPosition::parse("under"), None);
}
/// Softness blurs the shadow by a radius that grows with Softness and with the plane's distance
/// from the object, and scales with the object; at 0 the shadow keeps its hard edge. The outline
/// itself does not change.
#[test]
fn softness_blurs_the_shadow_more_the_farther_the_plane_is() {
let blur = |s: f64, shadow: Shadow| {
let path = square(100.0, 100.0, s);
let mut caster = ShadowCaster::new();
caster.extrude(&path, FillRule::NonZero, Rect::new(100.0, 100.0, 100.0 + s, 100.0 + s), Extrude::default(), front()).unwrap();
let all = 0..caster.len();
let all = std::slice::from_ref(&all);
let plane = caster.shadow_plane(shadow, all).unwrap();
(plane.blur(), caster.path_on(&plane, all).unwrap())
};
let (hard, hard_path) = blur(100.0, Shadow::default());
assert_eq!(hard, 0.0);
let (half, half_path) = blur(100.0, Shadow { softness: 0.5, ..Shadow::default() });
let (full, _) = blur(100.0, Shadow { softness: 1.0, ..Shadow::default() });
let (far, _) = blur(100.0, Shadow { softness: 1.0, distance: 1.0, ..Shadow::default() });
assert!(half > 0.0 && full > half && far > full, "{half} {full} {far}");
assert_eq!(half_path, hard_path, "the outline stays");
// Twice the object, twice the blur.
let (twice, _) = blur(200.0, Shadow { softness: 1.0, ..Shadow::default() });
assert!((twice - 2.0 * full).abs() < 1e-9, "{twice} {full}");
// A huge object's blur stops at the Gaussian Blur effect's limit.
let (huge, _) = blur(1.0e7, Shadow { softness: 1.0, distance: 1.0, ..Shadow::default() });
assert_eq!(huge, MAX_SHADOW_BLUR);
}
#[test]
fn the_faces_one_shadow_is_cast_from_are_bounded() {
// An open profile of 500 points revolves into about 64,000 faces at 128 segments: five fit,
+14 -3
View File
@@ -10,6 +10,7 @@ pub mod enclosing_lasso;
pub mod extend_path;
pub mod measure_inspect;
pub mod parametric_shape;
pub mod polygonal_lasso;
pub mod shared_edge;
pub mod slide_anchor;
pub mod smart_pen;
@@ -38,13 +39,21 @@ pub const ENCLOSING_LASSO: &[ToolInfo] = &[ToolInfo { id: enclosing_lasso::ID, l
pub const BOX_3D: &[ToolInfo] = &[ToolInfo { id: box3d::ID, label: "3D Box Tool", shortcut: None, icon: "box" }];
pub const POLYGONAL_LASSO: &[ToolInfo] = &[ToolInfo { id: polygonal_lasso::ID, label: "Polygonal Lasso Tool", shortcut: None, icon: "tool-lasso" }];
/// The add-ons' tool groups, after the toolbar's own ([`crate::TOOL_GROUPS`]), each with the
/// heading the All Tools drawer lists it under (its add-on's name).
const HEADED: &[(&[ToolInfo], &str)] =
&[(PATH_TOOLS, "Path Precision Tools"), (SMART_PEN, "Smart Pen"), (ENCLOSING_LASSO, "Enclosing Lasso"), (CONTOUR, "Contour"), (BOX_3D, "3D Box")];
const HEADED: &[(&[ToolInfo], &str)] = &[
(PATH_TOOLS, "Path Precision Tools"),
(SMART_PEN, "Smart Pen"),
(ENCLOSING_LASSO, "Enclosing Lasso"),
(CONTOUR, "Contour"),
(BOX_3D, "3D Box"),
(POLYGONAL_LASSO, "Polygonal Lasso"),
];
/// The add-ons' tool groups, after the toolbar's own ([`crate::TOOL_GROUPS`]).
pub const GROUPS: &[&[ToolInfo]] = &[PATH_TOOLS, SMART_PEN, ENCLOSING_LASSO, CONTOUR, BOX_3D];
pub const GROUPS: &[&[ToolInfo]] = &[PATH_TOOLS, SMART_PEN, ENCLOSING_LASSO, CONTOUR, BOX_3D, POLYGONAL_LASSO];
/// The heading the All Tools drawer lists tool `id` under: its add-on's name.
pub fn heading(id: &str) -> Option<&'static str> {
@@ -66,6 +75,7 @@ pub fn create(id: &str) -> Option<Box<dyn Tool>> {
enclosing_lasso::ID => Box::new(enclosing_lasso::EnclosingLassoTool::default()),
contour::ID => Box::new(contour::ContourTool::default()),
box3d::ID => Box::new(box3d::Box3dTool::default()),
polygonal_lasso::ID => Box::new(polygonal_lasso::PolygonalLassoTool::default()),
_ => return None,
})
}
@@ -88,6 +98,7 @@ mod tests {
assert_eq!(heading(enclosing_lasso::ID), Some("Enclosing Lasso"));
assert_eq!(heading(contour::ID), Some("Contour"));
assert_eq!(heading(box3d::ID), Some("3D Box"));
assert_eq!(heading(polygonal_lasso::ID), Some("Polygonal Lasso"));
assert_eq!(GROUPS.len(), HEADED.len());
assert!(crate::catalog::all_tools().any(|t| t.id == extend_path::ID));
assert!(create("pen").is_none() && heading("pen").is_none());
+186
View File
@@ -0,0 +1,186 @@
//! Polygonal Lasso selects anchor points inside a straight-edged loop, as the Lasso does inside a
//! freehand one. Each click sets a vertex, and a segment from the last vertex follows the pointer.
//! A double-click, Enter or a click on the first vertex closes the loop; Backspace or Delete removes
//! the last vertex and Escape drops the loop. Shift keeps the next segment to 45° steps (from the Constrain
//! Angle). Shift held at the first click adds to the selection and Alt subtracts from it.
use vectorcraft_geom::{Point, constrain_angle_from};
use crate::meshedit::MeshEdit;
use crate::xform::lasso_select;
use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
pub const ID: &str = "polygonalLasso";
/// The most vertices a loop keeps; clicks past it are ignored.
pub(crate) const MAX_VERTICES: usize = 65_536;
#[derive(Default)]
pub struct PolygonalLassoTool {
vertices: Vec<Point>,
/// Where the segment from the last vertex ends: the pointer, constrained while Shift is held.
hover: Option<Point>,
/// Shift held at the first click: the loop adds to the selection.
add: bool,
/// Alt held at the first click: the loop subtracts from the selection.
sub: bool,
/// Whether the press in progress set a vertex (a dropped press takes it back).
pressed_vertex: bool,
/// The picked gradient mesh points (the tool's `meshPoints` option), as with the Lasso.
mesh: MeshEdit,
}
impl PolygonalLassoTool {
/// The next vertex for a pointer at `p`: with Shift and a vertex already set, at a 45° step
/// from the last vertex.
fn target(&self, cx: &ToolContext, p: Point, mods: Mods) -> Point {
match self.vertices.last() {
Some(&last) if mods.shift => last + constrain_angle_from(p - last, 45.0, cx.constrain_angle),
_ => p,
}
}
/// How near a vertex a click counts as a click on it.
fn reach(cx: &ToolContext) -> f64 {
cx.tol(5.0).max(cx.point_tol())
}
/// Removes the last vertex and hides the segment that followed the pointer until the pointer
/// moves again. A press in progress no longer owns a vertex, so dropping it removes nothing more.
fn take_back_vertex(&mut self) {
self.vertices.pop();
self.hover = None;
self.pressed_vertex = false;
}
fn clear(&mut self) {
self.vertices.clear();
self.hover = None;
self.pressed_vertex = false;
}
/// Closes the loop and selects inside it. A loop of fewer than three vertices selects nothing.
fn close(&mut self, cx: &ToolContext) -> Vec<Action> {
let vertices = std::mem::take(&mut self.vertices);
self.clear();
if vertices.len() < 3 {
return vec![];
}
vec![lasso_select(cx, &mut self.mesh, &vertices, self.add, self.sub)]
}
}
impl Tool for PolygonalLassoTool {
fn id(&self) -> &'static str {
ID
}
fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
if !ev.pos.is_finite() {
return vec![];
}
match ev.kind {
PointerKind::Move | PointerKind::Drag => {
self.hover = (!self.vertices.is_empty()).then(|| self.target(cx, ev.pos, ev.mods));
vec![]
}
PointerKind::Down => {
self.pressed_vertex = false;
let reach = Self::reach(cx);
let Some(&first) = self.vertices.first() else {
self.add = ev.mods.shift;
self.sub = ev.mods.alt;
self.vertices.push(ev.pos);
self.pressed_vertex = true;
return vec![];
};
if first.distance(ev.pos) <= reach {
// With fewer than three vertices, a click on the first one adds nothing.
return if self.vertices.len() >= 3 { self.close(cx) } else { vec![] };
}
let p = self.target(cx, ev.pos, ev.mods);
// The second click of a double-click lands on the vertex the first one set.
if self.vertices.last().is_some_and(|last| last.distance(p) > reach) && self.vertices.len() < MAX_VERTICES {
self.vertices.push(p);
self.pressed_vertex = true;
}
self.hover = Some(p);
vec![]
}
PointerKind::Up => {
self.pressed_vertex = false;
vec![]
}
PointerKind::DoubleClick => self.close(cx),
// The third click of a triple-click starts no loop of its own.
PointerKind::TripleClick => {
if self.vertices.len() == 1 {
self.clear();
}
vec![]
}
}
}
fn key(&mut self, cx: &ToolContext, key: ToolKey, _mods: Mods) -> Vec<Action> {
match key {
ToolKey::Enter => self.close(cx),
ToolKey::Escape => {
self.clear();
vec![]
}
ToolKey::Backspace | ToolKey::Delete => {
self.take_back_vertex();
vec![]
}
_ => vec![],
}
}
/// A dropped press (a second finger, a canceled touch) takes back only the vertex it set.
fn drop_press(&mut self, _cx: &ToolContext) -> Vec<Action> {
if std::mem::take(&mut self.pressed_vertex) {
self.take_back_vertex();
}
vec![]
}
fn claims_key(&self, _cx: &ToolContext, key: ToolKey) -> bool {
!self.vertices.is_empty() && matches!(key, ToolKey::Enter | ToolKey::Escape | ToolKey::Backspace | ToolKey::Delete)
}
/// A loop being drawn: Escape drops it. Keys the tool does not claim run their commands.
fn ends_on_escape(&self, _cx: &ToolContext) -> bool {
!self.vertices.is_empty()
}
fn deactivate(&mut self, _cx: &ToolContext) -> Vec<Action> {
self.clear();
vec![]
}
fn hover_ended(&mut self, _cx: &ToolContext) {
self.hover = None;
}
fn options(&self) -> serde_json::Value {
self.mesh.options()
}
fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
let mut out = self.mesh.overlays(cx, &|id| cx.selection.contains(id));
let mut line = self.vertices.clone();
line.extend(self.hover.filter(|_| !self.vertices.is_empty()));
if line.len() >= 2 {
out.push(Overlay::Path { path: crate::xform::polygon(&line, false), color: [0x40, 0x40, 0x40], width: 1.0, dashed: true });
}
out
}
fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {
Cursor::Lasso
}
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,243 @@
use super::*;
use crate::testutil::*;
use serde_json::Value;
use vectorcraft_doc::{Appearance, Document, Node, Selection};
use vectorcraft_geom::{Rect, shapes};
fn click(tool: &mut dyn Tool, cx: &ToolContext, (x, y): (f64, f64), mods: Mods) -> Vec<Action> {
let mut acts = tool.pointer(cx, &PointerEvent::new(PointerKind::Down, x, y).with_mods(mods));
acts.extend(tool.pointer(cx, &PointerEvent::new(PointerKind::Up, x, y).with_mods(mods)));
acts
}
/// Clicks each vertex in turn with `first` held at the first click only.
fn clicks(tool: &mut dyn Tool, cx: &ToolContext, vertices: &[(f64, f64)], first: Mods) {
for (i, v) in vertices.iter().enumerate() {
let acts = click(tool, cx, *v, if i == 0 { first } else { Mods::default() });
assert!(acts.is_empty(), "a vertex click selects nothing: {acts:?}");
}
}
/// The anchors each selected path has in a `select.anchorsMany` command, and its mode.
fn selected(acts: &[Action]) -> (Vec<(u64, usize)>, String) {
let [Action::Exec(c, v)] = acts else { panic!("one selection command: {acts:?}") };
assert_eq!(c, "select.anchorsMany");
let items = v["items"].as_array().unwrap();
let ids = items.iter().map(|it| (it["id"].as_u64().unwrap(), it["anchors"].as_array().unwrap().len())).collect();
(ids, v["mode"].as_str().unwrap().to_owned())
}
/// A triangle around the rectangle's top left corner (100, 100) only.
const CORNER: &[(f64, f64)] = &[(80.0, 80.0), (140.0, 80.0), (80.0, 140.0)];
#[test]
fn a_double_click_enter_or_a_click_on_the_first_vertex_closes_the_loop() {
let (d, id) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
type Closing<'a> = &'a dyn Fn(&mut dyn Tool) -> Vec<Action>;
let closings: [Closing; 3] = [
&|t| {
let mut acts = click(t, &cx, (80.0, 141.0), Mods::default());
acts.extend(t.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 80.0, 141.0)));
acts
},
&|t| t.key(&cx, ToolKey::Enter, Mods::default()),
&|t| click(t, &cx, (82.0, 81.0), Mods::default()),
];
for (i, close) in closings.iter().enumerate() {
let mut tool = crate::create(ID);
assert_eq!(tool.id(), ID);
clicks(tool.as_mut(), &cx, CORNER, Mods::default());
assert!(tool.ends_on_escape(&cx) && tool.claims_key(&cx, ToolKey::Enter), "closing {i}");
assert_eq!(selected(&close(tool.as_mut())), (vec![(id.0, 1)], "set".to_owned()), "closing {i}");
assert!(!tool.ends_on_escape(&cx), "closing {i}");
}
}
#[test]
fn a_double_click_at_a_new_point_sets_that_vertex_and_closes() {
let (d, id) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &CORNER[..2], Mods::default());
let mut acts = click(&mut tool, &cx, (80.0, 140.0), Mods::default());
acts.extend(click(&mut tool, &cx, (80.0, 140.0), Mods::default()));
assert!(acts.is_empty(), "{acts:?}");
assert_eq!(tool.vertices.len(), 3, "the second click of the double-click sets no vertex");
let acts = tool.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 80.0, 140.0));
assert_eq!(selected(&acts), (vec![(id.0, 1)], "set".to_owned()));
assert!(!tool.ends_on_escape(&cx));
}
#[test]
fn backspace_or_delete_removes_the_last_vertex() {
let (d, id) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
// (300, 300) would take in the corner at (200, 200) too.
clicks(&mut tool, &cx, &[(80.0, 80.0), (140.0, 80.0), (300.0, 300.0)], Mods::default());
assert!(tool.claims_key(&cx, ToolKey::Backspace));
assert!(tool.key(&cx, ToolKey::Backspace, Mods::default()).is_empty());
assert_eq!(tool.vertices.len(), 2);
// The preview runs along the two vertices left, not back to the removed one.
let overlays = tool.overlays(&cx);
let [Overlay::Path { path, .. }] = overlays.as_slice() else { panic!("one preview path") };
assert_eq!(path.elements().len(), 2);
clicks(&mut tool, &cx, &[(300.0, 300.0)], Mods::default());
assert!(tool.claims_key(&cx, ToolKey::Delete));
assert!(tool.key(&cx, ToolKey::Delete, Mods::default()).is_empty());
assert_eq!(tool.vertices.len(), 2);
clicks(&mut tool, &cx, &[(80.0, 140.0)], Mods::default());
assert_eq!(selected(&tool.key(&cx, ToolKey::Enter, Mods::default())), (vec![(id.0, 1)], "set".to_owned()));
assert!(!tool.claims_key(&cx, ToolKey::Delete), "with no loop open, Delete deletes");
}
#[test]
fn escape_drops_the_loop_and_leaves_the_selection() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, CORNER, Mods::default());
assert!(tool.claims_key(&cx, ToolKey::Escape));
assert!(tool.key(&cx, ToolKey::Escape, Mods::default()).is_empty());
assert!(!tool.ends_on_escape(&cx) && !tool.claims_key(&cx, ToolKey::Enter));
assert!(tool.overlays(&cx).is_empty());
assert!(tool.key(&cx, ToolKey::Enter, Mods::default()).is_empty());
assert!(tool.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 80.0, 140.0)).is_empty());
}
#[test]
fn shift_keeps_the_segment_to_45_degree_steps() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let shift = Mods { shift: true, ..Mods::default() };
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &[(100.0, 100.0)], Mods::default());
tool.pointer(&cx, &PointerEvent::new(PointerKind::Move, 200.0, 110.0).with_mods(shift));
let hover = tool.hover.unwrap();
assert!((hover.y - 100.0).abs() < 1e-9 && hover.x > 199.0, "{hover:?}");
assert_eq!(tool.overlays(&cx).len(), 1, "the segment follows the pointer");
click(&mut tool, &cx, (190.0, 175.0), shift);
let v = tool.vertices[1];
assert!(((v.x - 100.0) - (v.y - 100.0)).abs() < 1e-9 && v.x > 150.0, "on the 45° line: {v:?}");
tool.pointer(&cx, &PointerEvent::new(PointerKind::Move, 200.0, 110.0));
assert_eq!(tool.hover, Some(Point::new(200.0, 110.0)), "without Shift the segment goes to the pointer");
}
#[test]
fn shift_or_alt_at_the_first_click_adds_or_subtracts() {
let (d, id) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let shift = Mods { shift: true, ..Mods::default() };
let alt = Mods { alt: true, ..Mods::default() };
for (first, mode) in [(shift, "add"), (alt, "subtract"), (Mods::default(), "set")] {
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, CORNER, first);
assert_eq!(selected(&tool.key(&cx, ToolKey::Enter, Mods::default())), (vec![(id.0, 1)], mode.to_owned()));
}
// Shift held only at a later click constrains that segment and does not add.
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &CORNER[..2], Mods::default());
click(&mut tool, &cx, (80.0, 140.0), shift);
assert_eq!(selected(&tool.key(&cx, ToolKey::Enter, Mods::default())).1, "set");
}
#[test]
fn a_concave_loop_leaves_out_anchors_in_its_notch() {
let (d, id) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
// An L: the bottom left corner (100, 200) is in the notch.
clicks(&mut tool, &cx, &[(60.0, 60.0), (240.0, 60.0), (240.0, 240.0), (160.0, 240.0), (160.0, 170.0), (60.0, 170.0)], Mods::default());
let acts = tool.key(&cx, ToolKey::Enter, Mods::default());
assert_eq!(selected(&acts), (vec![(id.0, 3)], "set".to_owned()));
let Action::Exec(_, v) = &acts[0] else { panic!() };
let picked: Vec<Value> = v["items"][0]["anchors"].as_array().unwrap().clone();
// The rectangle's anchors run (100, 100), (200, 100), (200, 200), (100, 200).
assert!(!picked.contains(&serde_json::json!([0, 3])), "{picked:?}");
}
#[test]
fn fewer_than_three_vertices_select_nothing() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &CORNER[..2], Mods::default());
// A click on the first vertex of a two-vertex loop sets no vertex on top of it and closes nothing.
assert!(click(&mut tool, &cx, (81.0, 80.0), Mods::default()).is_empty());
assert_eq!(tool.vertices.len(), 2);
assert!(tool.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 81.0, 80.0)).is_empty());
assert!(!tool.ends_on_escape(&cx));
clicks(&mut tool, &cx, &CORNER[..2], Mods::default());
assert!(tool.key(&cx, ToolKey::Enter, Mods::default()).is_empty());
assert!(!tool.ends_on_escape(&cx));
// A double-click on empty canvas: its second click sets no second vertex.
assert!(click(&mut tool, &cx, (80.0, 80.0), Mods::default()).is_empty());
assert!(click(&mut tool, &cx, (81.0, 80.0), Mods::default()).is_empty());
assert!(tool.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 81.0, 80.0)).is_empty());
assert!(!tool.ends_on_escape(&cx));
}
#[test]
fn a_loop_that_crosses_itself_selects_by_the_even_odd_rule() {
// A small square in the middle of a five-pointed star, where the star's edges wind twice, and
// one in the star's top point, where they wind once.
let mut d = Document::new(500.0, 500.0);
let l = d.layers[0].id;
let (middle, point) = (d.alloc_id(), d.alloc_id());
d.insert(Some(l), 0, Node::path(middle, shapes::rectangle(Rect::new(140.0, 140.0, 160.0, 160.0)), Appearance::default_art())).unwrap();
d.insert(Some(l), 1, Node::path(point, shapes::rectangle(Rect::new(148.0, 78.0, 152.0, 82.0)), Appearance::default_art())).unwrap();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let star: Vec<(f64, f64)> = (0..5)
.map(|k| {
let a = f64::from(-90 + 144 * k).to_radians();
(150.0 + 100.0 * a.cos(), 150.0 + 100.0 * a.sin())
})
.collect();
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &star, Mods::default());
assert_eq!(selected(&tool.key(&cx, ToolKey::Enter, Mods::default())), (vec![(point.0, 4)], "set".to_owned()));
}
#[test]
fn a_dropped_press_takes_back_only_its_vertex() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &CORNER[..2], Mods::default());
tool.pointer(&cx, &PointerEvent::new(PointerKind::Down, 80.0, 140.0));
assert!(tool.drop_press(&cx).is_empty());
assert_eq!(tool.vertices, vec![Point::new(80.0, 80.0), Point::new(140.0, 80.0)]);
assert_eq!(tool.hover, None);
}
#[test]
fn a_dropped_press_after_backspace_keeps_the_earlier_vertices() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
let mut tool = PolygonalLassoTool::default();
clicks(&mut tool, &cx, &CORNER[..2], Mods::default());
tool.pointer(&cx, &PointerEvent::new(PointerKind::Down, 80.0, 140.0));
assert!(tool.key(&cx, ToolKey::Backspace, Mods::default()).is_empty());
assert!(tool.drop_press(&cx).is_empty());
assert_eq!(tool.vertices, vec![Point::new(80.0, 80.0), Point::new(140.0, 80.0)]);
}
#[test]
fn the_tool_shows_the_lasso_cursor() {
let (d, _) = doc_with_rect();
let (s, p) = (Selection::default(), paint());
let cx = cx(&d, &s, &p);
assert_eq!(PolygonalLassoTool::default().cursor(&cx, Point::new(10.0, 10.0), Mods::default()), Cursor::Lasso);
}
+4 -2
View File
@@ -209,9 +209,11 @@ pub struct ToolContext<'a> {
/// [`Self::snap_tolerance`].
pub snap_to_point: bool,
/// View → Snapping → Snap to Tangent: with Smart Guides on, a line drawn
/// from an anchor lands where it touches a nearby curve.
/// from an anchor lands where it touches a nearby curve, and a Line Segment
/// drag from one convex curved path to another lands on their common tangent.
pub snap_tangent: bool,
/// View → Snapping → Snap to Perpendicular: likewise where it meets a nearby segment square.
/// View → Snapping → Snap to Perpendicular: with Smart Guides on, a line drawn from an anchor
/// lands where it meets a nearby segment square.
pub snap_perpendicular: bool,
/// View → Snap to Glyph: drawn points snap to live-text glyph bounds, and on a single line of type
/// to its baseline, x-height, character widths and glyph anchor points (with Smart Guides).
+1 -1
View File
@@ -747,7 +747,7 @@ hotspot = "The tip."
[[cursor]]
id = "Lasso"
group = "Drawing and editing tools"
shown_when = ["The Lasso tool: drag a loop round anchor points and segments to select them; Shift adds to the selection, Alt takes from it.", "The Enclosing Lasso tool: draw a loop to select fully enclosed objects; Shift adds, Alt subtracts."]
shown_when = ["The Lasso tool: drag a loop round anchor points and segments to select them; Shift adds to the selection, Alt takes from it.", "The Enclosing Lasso tool: draw a loop to select fully enclosed objects; Shift adds, Alt subtracts.", "The Polygonal Lasso tool: click the corners of a loop around anchor points to select them; Shift or Alt at the first click adds or subtracts."]
hotspot = "Where the loop is drawn from."
[[cursor]]
+30 -1
View File
@@ -713,6 +713,23 @@ fn part_picked(cx: &ToolContext, id: NodeId) -> bool {
cx.selection.symbol_part.as_ref().is_some_and(|sp| sp.instance == id)
}
/// Whether multiple anchor points are selected (across one or more paths) with Direct Selection.
fn has_multiple_selected_anchors(cx: &ToolContext) -> bool {
let direct_count: usize = cx.selection.anchors.values().map(|s| s.len()).sum();
if direct_count >= 2 {
return true;
}
if direct_count >= 1 {
let has_whole_path = cx.selection.objects.iter().any(|id| {
!cx.selection.anchors.contains_key(id) && cx.doc.node(*id).and_then(|n| n.path_data()).is_some_and(|p| p.anchors().next().is_some())
});
if has_whole_path {
return true;
}
}
false
}
/// The segment of path `id` nearest to `p`, where the hit test found its stroke.
fn segment_at(cx: &ToolContext, id: NodeId, p: Point) -> Option<SegmentHit> {
let pd = cx.doc.node(id)?.path_data()?;
@@ -769,6 +786,9 @@ impl Tool for DirectSelectionTool {
if key == ToolKey::Escape && self.guide.busy() {
return self.guide.cancel();
}
if key == ToolKey::Escape && matches!(self.state, State::Idle) && cx.selection.key_anchor.is_some() {
return vec![Action::Exec("select.key".into(), json!({}))];
}
if key != ToolKey::Escape || matches!(self.state, State::Idle) {
return vec![];
}
@@ -788,6 +808,7 @@ impl Tool for DirectSelectionTool {
|| self.claims_letter(key)
|| self.mesh_nudge(cx, key, Mods::default()).is_some()
|| self.frame_nudge(cx, key, Mods::default()).is_some()
|| (key == ToolKey::Escape && (cx.selection.key_anchor.is_some() || !matches!(self.state, State::Idle)))
}
fn notify(&mut self, cx: &ToolContext, what: &str) {
if what == FRAME_PICKED {
@@ -1596,7 +1617,15 @@ impl DirectSelectionTool {
(true, ..) => vec![Action::Commit],
(false, Some(id), _, _) => vec![Action::Exec("select.toggle".into(), json!({"id": id.0}))],
(false, None, Some((id, si, ai)), _) => {
vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[si, ai]], "mode": "set"}))]
if has_multiple_selected_anchors(cx) {
if cx.selection.key_anchor == Some((id, (si, ai))) {
vec![Action::Exec("select.key".into(), json!({}))]
} else {
vec![Action::Exec("select.key".into(), json!({"id": id.0, "anchor": [si, ai]}))]
}
} else {
vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[si, ai]], "mode": "set"}))]
}
}
(false, None, None, Some((id, si, seg))) => {
vec![Action::Exec("select.segments".into(), json!({"id": id.0, "segments": [[si, seg]]}))]
+59 -17
View File
@@ -661,10 +661,9 @@ fn an_anchor_drag_follows_the_while_moving_option() {
assert!((m - Vec2::new(5.7, 4.6)).hypot() < 1e-9, "{m:?}");
}
/// A click (no drag) on an anchor that is selected with others, whether the whole path is or
/// some of its anchors, selects that anchor alone, as in Illustrator: a press keeps the
/// selection so a drag moves it all, the release without a drag narrows it. Shift still
/// toggles, and a click on a path's only selected anchor changes nothing visible.
/// A click (no drag) on an anchor of a path selected whole selects that anchor alone, as in
/// Illustrator: a press keeps the selection so a drag moves it all, the release without a drag
/// narrows it. An anchor not yet selected is selected on the press.
#[test]
fn a_click_on_a_selected_anchor_selects_it_alone() {
let (d, id) = doc_with_rect();
@@ -672,22 +671,65 @@ fn a_click_on_a_selected_anchor_selects_it_alone() {
let alone = vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[0, 0]], "mode": "set"}))];
let mut whole = Selection::default();
whole.set([id]);
for s in [whole, anchors_of(id, &[(0, 0), (0, 1)])] {
let cx = cx(&d, &s, &p);
let mut t = DirectSelectionTool::new(false);
assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty(), "{s:?}");
assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 100.0, 100.0)), alone, "{s:?}");
// Dragged instead: moved, selection kept.
assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty());
t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 120.0, 100.0));
assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 120.0, 100.0)), vec![Action::Commit], "{s:?}");
}
let cx_whole = cx(&d, &whole, &p);
let mut t = DirectSelectionTool::new(false);
assert!(t.pointer(&cx_whole, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty());
assert_eq!(t.pointer(&cx_whole, &PointerEvent::new(PointerKind::Up, 100.0, 100.0)), alone);
// Dragged instead: moved, selection kept.
assert!(t.pointer(&cx_whole, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty());
t.pointer(&cx_whole, &PointerEvent::new(PointerKind::Drag, 120.0, 100.0));
assert_eq!(t.pointer(&cx_whole, &PointerEvent::new(PointerKind::Up, 120.0, 100.0)), vec![Action::Commit]);
// An anchor not yet selected is selected on the press, and the release adds nothing.
let none = Selection::default();
let cx = cx(&d, &none, &p);
let cx_none = cx(&d, &none, &p);
let mut t = DirectSelectionTool::new(false);
assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)), alone);
assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 100.0, 100.0)).is_empty());
assert_eq!(t.pointer(&cx_none, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)), alone);
assert!(t.pointer(&cx_none, &PointerEvent::new(PointerKind::Up, 100.0, 100.0)).is_empty());
}
/// #1636: when multiple anchors are selected with Direct Selection, clicking an already-selected
/// anchor without modifiers designates it as the key anchor. Clicking it again, or pressing Escape,
/// clears the key anchor designation.
#[test]
fn clicking_selected_anchor_designates_and_clears_key_anchor() {
let (d, id) = doc_with_rect();
let p = paint();
let s = anchors_of(id, &[(0, 0), (0, 1)]);
let cx_base = cx(&d, &s, &p);
// Clicking already-selected anchor (0, 0) designates it as Key Anchor.
let mut t = DirectSelectionTool::new(false);
assert!(t.pointer(&cx_base, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty());
assert_eq!(
t.pointer(&cx_base, &PointerEvent::new(PointerKind::Up, 100.0, 100.0)),
vec![Action::Exec("select.key".into(), json!({"id": id.0, "anchor": [0, 0]}))]
);
// Dragging instead moves anchors, committing the move.
assert!(t.pointer(&cx_base, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty());
t.pointer(&cx_base, &PointerEvent::new(PointerKind::Drag, 120.0, 100.0));
assert_eq!(t.pointer(&cx_base, &PointerEvent::new(PointerKind::Up, 120.0, 100.0)), vec![Action::Commit]);
// When the anchor is already designated as the key anchor:
let mut with_key = s.clone();
with_key.key_anchor = Some((id, (0, 0)));
let cx_key = cx(&d, &with_key, &p);
// Clicking it again cancels the key anchor.
let mut t2 = DirectSelectionTool::new(false);
assert!(t2.pointer(&cx_key, &PointerEvent::new(PointerKind::Down, 100.0, 100.0)).is_empty());
assert_eq!(t2.pointer(&cx_key, &PointerEvent::new(PointerKind::Up, 100.0, 100.0)), vec![Action::Exec("select.key".into(), json!({}))]);
// Pressing Escape cancels the key anchor.
let mut t3 = DirectSelectionTool::new(false);
assert!(t3.claims_key(&cx_key, ToolKey::Escape));
assert_eq!(t3.key(&cx_key, ToolKey::Escape, Mods::default()), vec![Action::Exec("select.key".into(), json!({}))]);
// Clicking canvas clears selection and key anchor.
let mut t4 = DirectSelectionTool::new(false);
assert!(t4.pointer(&cx_key, &PointerEvent::new(PointerKind::Down, 500.0, 500.0)).is_empty());
assert_eq!(t4.pointer(&cx_key, &PointerEvent::new(PointerKind::Up, 500.0, 500.0)), vec![Action::Exec("select.none".into(), json!({}))]);
}
/// Alt-pressing an anchor picks the whole path, as Alt on a segment does, and the drag copies
+2
View File
@@ -20,9 +20,11 @@ use vectorcraft_text::{FontDb, layout as layout_text};
use crate::bbox::Handle;
use crate::{GlyphSnap, Overlay, ScreenFrame, ToolContext};
mod bitangent;
mod snap;
mod targets;
pub(crate) use bitangent::TangentLine;
pub(crate) use snap::hold_on_path;
pub use snap::{
DEFAULT_CONSTRUCTION_ANGLES, DrawSnap, HandleSnap, Leave, PointSnap, construction_angles, distance_guides, snap_draw, snap_pick, square,
+271
View File
@@ -0,0 +1,271 @@
//! Snap to Tangent for a line drawn from one curve to another (the Line Segment tool): when the
//! press lands on a convex closed path with curves and the pointer comes near another one, both
//! ends of the line move onto a common tangent of the two, the start sliding along the first path.
//! The tangents are [`vectorcraft_pathops::addons::pathtools::common_tangents`]'s.
//!
//! The closed subpaths in the window the line may end on are listed once, at the press, by their
//! bounds, up to as many segments as Smart Guides gather. Each pointer move looks only at the
//! [`MAX_NEAR`] nearest of them whose outline lies within the snapping tolerance of the pointer.
//! The tangents of each pair are worked out once, and the last [`MAX_KEPT`] pairs' are kept for
//! the rest of the drag.
use std::collections::HashSet;
use vectorcraft_pathops::addons::pathtools::{Outline, Tangent, common_tangents};
use super::snap::visible;
use super::targets::{BUDGET, walk_but};
use super::{Node, NodeId, NodeKind, Overlay, ParamCurveNearest, Point, Rect, SubPath, ToolContext};
use crate::PixelOp;
/// Most subpaths a pointer move takes tangents from: the nearest ones whose outline lies within
/// the snapping tolerance of the pointer.
const MAX_NEAR: usize = 16;
/// Most pairs whose tangents are kept during one drag.
const MAX_KEPT: usize = 64;
/// Most segments a subpath the line starts or ends on may have: the tangents of two paths take
/// time that grows with both paths' segment counts, and they are worked out during the drag.
const MAX_SEGMENTS: usize = 512;
/// A closed subpath with a curve the line may end on: its path, its index in the path, and the
/// bounds of its control points.
#[derive(Clone, Copy)]
struct Listed {
key: (NodeId, usize),
bounds: Rect,
}
/// The two-ended tangent snap of one Line Segment drag.
#[derive(Default)]
pub(crate) struct TangentLine {
/// The subpath the press landed on and its outline: none when the press was not on a convex
/// closed path with a curve, or the snap is off.
from: Option<((NodeId, usize), Outline)>,
/// The closed subpaths with a curve, listed at the press (none when it found no subpath to
/// start from).
listed: Vec<Listed>,
/// The common tangents of the press's subpath and each subpath the pointer came near.
kept: Vec<((NodeId, usize), Vec<Tangent>)>,
/// The line of the last snap.
line: Option<(Point, Point)>,
}
/// The snap applies: Smart Guides and Snap to Tangent on, and neither pixels nor the grid
/// snapping drawn points instead.
fn applies(cx: &ToolContext) -> bool {
cx.smart_guides && cx.snap_tangent && !cx.snaps_to_pixel(PixelOp::Drawing) && !cx.snap_to_grid
}
/// The subpath `key` of the document in `cx`.
fn subpath<'a>(cx: &'a ToolContext, key: (NodeId, usize)) -> Option<&'a SubPath> {
match &cx.doc.node(key.0)?.kind {
NodeKind::Path { path, .. } => path.subpaths.get(key.1),
_ => None,
}
}
/// The subpaths of path `id` a line may start or end on, with their indexes: closed, with at most
/// [`MAX_SEGMENTS`] segments.
fn closed_subpaths<'a>(cx: &'a ToolContext, id: NodeId) -> impl Iterator<Item = (usize, &'a SubPath)> {
let subpaths = match cx.doc.node(id).map(|n| &n.kind) {
Some(NodeKind::Path { path, .. }) => path.subpaths.as_slice(),
_ => &[],
};
subpaths.iter().enumerate().filter(|(_, sp)| sp.closed && sp.segment_count() <= MAX_SEGMENTS)
}
/// How far `p` lies from `sp` (its segments whose control bounds come within `reach` of `p`); none
/// when no segment comes that near.
fn distance(sp: &SubPath, p: Point, reach: f64) -> Option<f64> {
let mut best: Option<f64> = None;
for k in 0..sp.segment_count() {
let c = sp.segment(k);
let b = Rect::from_points(c.p0, c.p3).union_pt(c.p1).union_pt(c.p2);
if !b.inflate(reach, reach).contains(p) {
continue;
}
let d = c.nearest(p, 1e-9).distance_sq.sqrt();
if best.is_none_or(|e| d < e) {
best = Some(d);
}
}
best
}
/// Whether `sp` has a curved segment.
fn curved(sp: &SubPath) -> bool {
(0..sp.segment_count()).any(|k| !sp.segment_is_line(k))
}
impl TangentLine {
/// Start a drag pressed at `start` (where the pointer went down): the subpath under it, when it
/// is a convex closed path with a curve, and then the closed subpaths with a curve in the window
/// the line may end on, by their bounds. The press looks at the segments of the paths whose
/// bounds reach it only, and lists nothing when it lands on no such subpath, or when `held` (an
/// anchor, center or crossing the press snapped to) lies off that subpath.
pub(crate) fn press(&mut self, cx: &ToolContext, start: Point, held: Option<Point>) {
*self = Self::default();
if !applies(cx) || !start.x.is_finite() || !start.y.is_finite() {
return;
}
let tol = cx.snap_tol();
// The paths with a closed subpath, by their finite bounds.
let closed = |n: &Node| match &n.kind {
NodeKind::Path { path, .. } if path.subpaths.iter().any(|sp| sp.closed) => {
n.geometric_bounds().filter(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()))
}
_ => None,
};
// The subpaths under the press: at most as many segments as Smart Guides gather.
let mut on: Option<(f64, (NodeId, usize))> = None;
let mut budget = BUDGET;
walk_but(&cx.doc.layers, &HashSet::new(), &mut |n| {
if budget == 0 || !closed(n).is_some_and(|b| b.inflate(tol, tol).contains(start)) {
return;
}
for (si, sp) in closed_subpaths(cx, n.id) {
let Some(left) = budget.checked_sub(sp.segment_count()) else { return };
budget = left;
if let Some(d) = distance(sp, start, tol)
&& d <= tol
&& curved(sp)
&& on.is_none_or(|(e, _)| d < e)
{
on = Some((d, (n.id, si)));
}
}
});
// A path that bends inward somewhere has no tangent of this kind: the line keeps its start.
let Some(from) = on.and_then(|(_, key)| Some((key, Outline::convex(subpath(cx, key)?).ok()?))) else { return };
// A press held by an anchor, center or crossing off that path starts the line there.
if let Some(q) = held
&& !subpath(cx, from.0).and_then(|sp| distance(sp, q, tol)).is_some_and(|d| d <= 1e-6 * tol.max(1.0))
{
return;
}
let from_key = from.0;
self.from = Some(from);
// The subpaths the line may end on: closed ones with a curve, of the paths in the window,
// at most as many segments as Smart Guides gather.
let window = visible(cx);
let listed = &mut self.listed;
let mut budget = BUDGET;
walk_but(&cx.doc.layers, &HashSet::new(), &mut |n| {
if budget == 0 || !closed(n).is_some_and(|b| window.is_none_or(|v| b.intersect(v).area() > 0.0 || v.contains(b.center()))) {
return;
}
for (si, sp) in closed_subpaths(cx, n.id) {
let Some(left) = budget.checked_sub(sp.segment_count()) else { return };
budget = left;
let mut bounds: Option<Rect> = None;
for k in 0..sp.segment_count() {
let c = sp.segment(k);
let b = Rect::from_points(c.p0, c.p3).union_pt(c.p1).union_pt(c.p2);
bounds = Some(bounds.map_or(b, |r| r.union(b)));
}
if let Some(bounds) =
bounds.filter(|b| curved(sp) && (n.id, si) != from_key && [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()))
{
listed.push(Listed { key: (n.id, si), bounds });
}
}
});
}
/// The line for the pointer at `p`: on the nearest subpath whose outline lies within the
/// snapping tolerance of `p` and that has a common tangent with the press's subpath, the
/// tangent whose touch point on it is nearest `p`; none when there is none. A subpath farther
/// from `p` than `rival` (an anchor, center or crossing the pointer snaps to otherwise) gives
/// way to it; its own anchors, which lie on its outline, do not.
pub(crate) fn snap(&mut self, cx: &ToolContext, p: Point, rival: Option<f64>) -> Option<(Point, Point)> {
let line = self.find(cx, p, rival);
self.line = line;
line
}
fn find(&mut self, cx: &ToolContext, p: Point, rival: Option<f64>) -> Option<(Point, Point)> {
if self.from.is_none() || !applies(cx) || !p.x.is_finite() || !p.y.is_finite() {
return None;
}
let tol = cx.snap_tol();
let mut near: Vec<(f64, (NodeId, usize))> = vec![];
for l in self.listed.iter().filter(|l| l.bounds.inflate(tol, tol).contains(p)) {
// The nearest `MAX_NEAR`, in order, kept while scanning.
if let Some(d) = subpath(cx, l.key).and_then(|sp| distance(sp, p, tol)).filter(|d| *d <= tol) {
let at = near.partition_point(|(e, _)| *e <= d);
if at < MAX_NEAR {
near.insert(at, (d, l.key));
near.truncate(MAX_NEAR);
}
}
}
for (d, key) in near {
if rival.is_some_and(|r| r < d - 1e-6 * tol) {
return None;
}
let Some(sp) = subpath(cx, key) else { continue };
let mut best: Option<(f64, Point, Point)> = None;
for t in self.tangents(cx, key) {
// Where the paths touch each other, the tangent's ends are not both on the paths.
let on_b = distance(sp, t.to, tol).is_some_and(|e| e <= 1e-6 * tol.max(1.0));
if !on_b || t.from.distance(t.to) <= tol {
continue;
}
let dist = t.to.distance(p);
// On a tie the line of the last move stays, so it does not flicker.
let same = self.line == Some((t.from, t.to));
if best.is_none_or(|(e, ..)| dist < e - 1e-9 || (same && dist <= e + 1e-9)) {
best = Some((dist, t.from, t.to));
}
}
if let Some((_, a, b)) = best {
return Some((a, b));
}
}
None
}
/// The common tangents of the press's subpath and subpath `key`, worked out on first use.
fn tangents(&mut self, cx: &ToolContext, key: (NodeId, usize)) -> Vec<Tangent> {
if let Some((_, t)) = self.kept.iter().find(|(k, _)| *k == key) {
return t.clone();
}
let Some((_, from)) = &self.from else { return vec![] };
let all = subpath(cx, key).and_then(|sp| Outline::convex(sp).ok()).and_then(|o| common_tangents(from, &o).ok()).unwrap_or_default();
if self.kept.len() >= MAX_KEPT {
self.kept.remove(0);
}
self.kept.push((key, all.clone()));
all
}
/// The line of the last snap, if it found one.
pub(crate) fn line(&self) -> Option<(Point, Point)> {
self.line
}
/// Forget the last snap's line for a move that does not snap this way (a modifier is held),
/// keeping the press's subpath for the moves after it.
pub(crate) fn drop_line(&mut self) {
self.line = None;
}
/// End the drag.
pub(crate) fn clear(&mut self) {
*self = Self::default();
}
/// The guides of the last snap: the line, and the "tangent" label at both ends.
pub(crate) fn guides(&self, cx: &ToolContext) -> Vec<Overlay> {
let Some((a, b)) = self.line else { return vec![] };
let color = cx.smart_guide_color;
let mut out = vec![];
if cx.alignment_guides {
out.push(Overlay::Line { a, b, color, dashed: false });
}
if cx.anchor_path_labels {
out.extend([a, b].map(|p| Overlay::Label { p, text: "tangent".into(), color }));
}
out
}
}
+30 -1
View File
@@ -365,7 +365,7 @@ impl SnapKey {
}
/// The part of the document the window shows (none headless: all of it).
fn visible(cx: &ToolContext) -> Option<Rect> {
pub(super) fn visible(cx: &ToolContext) -> Option<Rect> {
let s = cx.screen?;
let (w, h) = s.size;
Some(Rect::from_points(s.at(0.0, 0.0), s.at(w, h)).union_pt(s.at(w, 0.0)).union_pt(s.at(0.0, h)))
@@ -446,6 +446,35 @@ impl DrawSnap {
self.snap(cx, p, from)
}
/// How far from `p` the nearest Smart Guides point (an anchor or a center) or crossing of the
/// targets lies, when one is within the snapping tolerance: none otherwise, and none while
/// pixels or the grid snap instead.
pub(crate) fn point_within_reach(&self, cx: &ToolContext, p: Point) -> Option<f64> {
let Some((_, PointSnap { targets: Some((t, tol)), .. })) = &self.targets else { return None };
if !cx.smart_guides {
return None;
}
let tol = cx.tol(*tol);
let point = t.nearest_point(p, tol).map(|(q, _)| q.distance(p));
let crossing = t.crossing(p, tol).map(|q| q.distance(p));
match (point, crossing) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
}
}
/// Whether `q`, where a point at `p` snapped to, is the nearest Smart Guides point (an anchor or
/// a center) or the nearest crossing of the targets within the snapping tolerance of `p`.
pub(crate) fn snapped_to_point(&self, cx: &ToolContext, p: Point, q: Point) -> bool {
let Some((_, PointSnap { targets: Some((t, tol)), .. })) = &self.targets else { return false };
if !cx.smart_guides {
return false;
}
let tol = cx.tol(*tol);
let at = |a: Point| a.distance(q) <= 1e-9 * tol.max(1.0);
t.nearest_point(p, tol).is_some_and(|(a, _)| at(a)) || t.crossing(p, tol).is_some_and(at)
}
/// The guides of the last snap.
pub fn guides(&self) -> &[Overlay] {
&self.guides
+3 -3
View File
@@ -64,7 +64,7 @@ pub struct Targets {
}
/// How many anchors, and how many segments, the targets gather at most.
const BUDGET: usize = 20_000;
pub(super) const BUDGET: usize = 20_000;
/// What [`Targets::collect_inner`] gathers from each path besides its anchors and bounds.
#[derive(Clone, Copy, PartialEq)]
@@ -88,7 +88,7 @@ fn within<T>(sorted: &[T], key: impl Fn(&T) -> f64, v: f64, tol: f64) -> &[T] {
/// Visit `nodes` and everything inside them, but the nodes in `skip`, the hidden nodes and
/// everything inside those: one pass, however many are skipped. A Shaper Group's original
/// shapes, its first child, are not shown and are skipped too.
fn walk_but<'a>(nodes: &'a [Arc<Node>], skip: &HashSet<NodeId>, f: &mut impl FnMut(&'a Node)) {
pub(super) fn walk_but<'a>(nodes: &'a [Arc<Node>], skip: &HashSet<NodeId>, f: &mut impl FnMut(&'a Node)) {
for n in nodes.iter().filter(|n| n.visible && !skip.contains(&n.id)) {
f(n);
if let Some(ch) = n.children() {
@@ -1049,7 +1049,7 @@ impl Targets {
/// Where two target paths, a path and a ruler guide, or two ruler guides cross, the crossing
/// nearest `p` within `tol` ("intersect", #1602).
fn crossing(&self, p: Point, tol: f64) -> Option<Point> {
pub(super) fn crossing(&self, p: Point, tol: f64) -> Option<Point> {
self.crossing_with(p, tol, &self.rulers)
}
+1
View File
@@ -686,6 +686,7 @@ mod cursor_tests {
for (id, c) in [
("lasso", Cursor::Lasso),
(addons::enclosing_lasso::ID, Cursor::Lasso),
(addons::polygonal_lasso::ID, Cursor::Lasso),
("magicWand", Cursor::MagicWand),
("paintbrush", Cursor::Paintbrush),
("blobBrush", Cursor::BlobBrush),
+36 -5
View File
@@ -5,7 +5,9 @@
//! Illustrator). ↑/↓ during a polygon/star drag change the side/point count; during a star drag,
//! Ctrl/Cmd keeps the inner radius where it is while the outer one follows the pointer, and Alt
//! keeps the star's shoulders straight (#812). The start point and
//! the dragged corner snap to Smart Guides ([`DrawSnap`]), hovering before the press too.
//! the dragged corner snap to Smart Guides ([`DrawSnap`]), hovering before the press too. With Snap
//! to Tangent on, a line pressed on one convex curved path and dragged near another lands on a
//! common tangent of the two, both its ends moving to the touch points ([`TangentLine`]).
//! Escape cancels the drag and puts back the options its keys and Ctrl/Cmd changed.
//!
//! The selection keeps its bounding box and its Live Shape widgets on show with the Rectangle,
@@ -26,7 +28,7 @@ use vectorcraft_geom::{Affine, Point, Rect, Vec2};
use crate::bbox::{Handle, move_delta, rotate_for_drag, scale_for_drag};
use crate::corners::{self, CornerDrag};
use crate::guides::{DrawSnap, Leave, PointSnap, Targets, square};
use crate::guides::{DrawSnap, Leave, PointSnap, TangentLine, Targets, square};
use crate::pie::{self, PieDrag};
use crate::select::{MoveSnap, handle_cursor, hit_center, is_area_type, matrix_json, rotate_zone, shown_box};
use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
@@ -106,6 +108,8 @@ pub struct ShapeTool {
pub line_angle: f64,
pub fill_line: bool,
snap: DrawSnap,
/// Snap to Tangent for a line from one curve to another: both ends on a common tangent.
tangent_line: TangentLine,
/// The options a drag's keys and Ctrl/Cmd change, as they were when the drag began: Escape
/// puts them back.
before_drag: Option<DragOptions>,
@@ -163,6 +167,7 @@ impl ShapeTool {
inner: None,
tangent_corner: None,
snap: DrawSnap::default(),
tangent_line: TangentLine::default(),
line_length: 100.0,
line_angle: 0.0,
fill_line: false,
@@ -581,6 +586,12 @@ impl Tool for ShapeTool {
return out;
}
let p = self.snap.press(cx, ev.pos, &[], None);
if self.id == "lineSegment" {
// The pressed spot finds the curve; a press that snapped to an anchor, center
// or crossing off that curve keeps the line's start there.
let held = self.snap.snapped_to_point(cx, ev.pos, p).then_some(p);
self.tangent_line.press(cx, ev.pos, held);
}
self.start = Some(p);
self.last = ev.pos;
self.began = false;
@@ -607,6 +618,10 @@ impl Tool for ShapeTool {
self.last = s + d;
}
space_moves(&mut s, &mut self.last, ev, self.began);
if ev.mods.space && self.began {
// The start no longer lies on the pressed path.
self.tangent_line.clear();
}
self.start = Some(s);
self.mods = ev.mods;
if self.id == "star" {
@@ -626,13 +641,25 @@ impl Tool for ShapeTool {
self.before_drag = Some(self.drag_options());
out.push(Action::Begin(self.label().into()));
}
let (c, v) = self.command_at(s, ev.pos, ev.mods, cx.constrain_angle);
// Snap to Tangent: a line pressed on one curve and ending near another moves both
// its ends onto a common tangent of the two, unless Shift, Alt or Space is held or
// an anchor or crossing nearer the pointer pulls it.
let tangent = if self.id == "lineSegment" && !(ev.mods.shift || ev.mods.alt || ev.mods.space) {
let rival = self.snap.point_within_reach(cx, raw);
self.tangent_line.snap(cx, raw, rival)
} else {
self.tangent_line.drop_line();
None
};
let (a, b) = tangent.unwrap_or((s, ev.pos));
let (c, v) = self.command_at(a, b, ev.mods, cx.constrain_angle);
out.push(Action::Preview(c, v));
out
}
PointerKind::Up => {
let Some(s) = self.start.take() else { return vec![] };
self.snap.clear();
self.tangent_line.clear();
self.inner = None;
self.before_drag = None;
if self.began {
@@ -706,6 +733,7 @@ impl Tool for ShapeTool {
self.restore_drag_options(o);
}
self.snap.clear();
self.tangent_line.clear();
vec![Action::Cancel]
} else {
vec![]
@@ -754,7 +782,9 @@ impl Tool for ShapeTool {
Some(WidgetDrag::Pie(d)) => return d.overlays(cx),
None => {}
}
let mut o = self.snap.guides().to_vec();
// A line on a common tangent shows that snap's guides, and its length and angle.
let tangent = self.tangent_line.line().filter(|_| self.start.is_some());
let mut o = if tangent.is_some() { self.tangent_line.guides(cx) } else { self.snap.guides().to_vec() };
o.extend(self.guides.iter().cloned());
if let Some((p, text)) = &self.measure {
o.push(Overlay::Measure { p: *p, text: text.clone() });
@@ -762,7 +792,8 @@ impl Tool for ShapeTool {
if let Some(s) = self.start.filter(|_| self.began && cx.measurement_labels) {
let p = self.last + Vec2::new(cx.tol(12.0), cx.tol(12.0));
let text = if self.id == "lineSegment" {
cx.segment_measure_label(s, self.last)
let (a, b) = tangent.unwrap_or((s, self.last));
cx.segment_measure_label(a, b)
} else {
// A box's size as drawn (from its centre with Alt, square with Shift).
match self.id {
+253
View File
@@ -780,6 +780,259 @@ fn line_segment_options_and_fill_line() {
assert_eq!(t.command(a, b, Mods::default()).1["fill"], json!(true));
}
/// A document holding the closed paths `paths`, unselected.
fn doc_with_paths(paths: Vec<vectorcraft_geom::PathData>) -> vectorcraft_doc::Document {
let mut d = vectorcraft_doc::Document::new(500.0, 500.0);
let l = d.layers[0].id;
for (k, path) in paths.into_iter().enumerate() {
let id = d.alloc_id();
d.insert(Some(l), k, vectorcraft_doc::Node::path(id, path, vectorcraft_doc::Appearance::default_art())).unwrap();
}
d
}
/// The circle of radius `r` about `c`, as the Ellipse tool draws it.
fn circle(c: Point, r: f64) -> vectorcraft_geom::PathData {
vectorcraft_geom::shapes::ellipse(Rect::new(c.x - r, c.y - r, c.x + r, c.y + r))
}
/// The ends of the line a Line Segment drag from `press` through `drag` to `to` (with `mods`)
/// previews last, and the drag's actions.
fn line_drag(c: &ToolContext, press: Point, drag: Point, to: Point, mods: Mods) -> ((Point, Point), Vec<Action>) {
let mut t = ShapeTool::new("lineSegment");
t.pointer(c, &PointerEvent::new(PointerKind::Down, press.x, press.y).with_mods(mods));
let mut all = t.pointer(c, &PointerEvent::new(PointerKind::Drag, drag.x, drag.y).with_mods(mods));
all.extend(t.pointer(c, &PointerEvent::new(PointerKind::Drag, to.x, to.y).with_mods(mods)));
let Some(Action::Preview(cmd, v)) = all.last().cloned() else { panic!("a preview: {all:?}") };
assert_eq!(cmd, "shape.line");
let f = |k: &str| v[k].as_f64().unwrap();
let line = (Point::new(f("x1"), f("y1")), Point::new(f("x2"), f("y2")));
all.extend(t.pointer(c, &PointerEvent::new(PointerKind::Up, to.x, to.y).with_mods(mods)));
(line, all)
}
/// Snap to Tangent: a line pressed on one circle and dragged near another lands on a common
/// tangent of the two, both ends moving to where it touches them. Near the second circle's top it
/// is the outer tangent, near its bottom left the one crossing between them, each against the
/// closed form (the drawn circles are within 0.03% of round). The guides show the line and a
/// "tangent" label at each end, and the length label measures the tangent line.
#[test]
fn a_line_from_one_circle_to_another_lands_on_their_common_tangent() {
let (c1, r1, c2, r2) = (Point::new(100.0, 250.0), 40.0, Point::new(300.0, 250.0), 60.0);
let d = doc_with_paths(vec![circle(c1, r1), circle(c2, r2)]);
let (s, p) = (Selection::default(), paint());
let c = cx(&d, &s, &p);
// A drawn circle's radius is off by up to 0.03%, which moves the touch points along the line by
// up to about 0.1 pt here; the line's distance from each center stays within 0.03 pt.
let near = |a: Point, b: Point| (a - b).hypot() < 0.15;
let off_by = |(a, b): (Point, Point), c: Point| ((b - a).cross(c - a) / (b - a).hypot()).abs();
let touches = |line: (Point, Point)| (off_by(line, c1) - r1).abs() < 0.03 && (off_by(line, c2) - r2).abs() < 0.03;
// A normal n with n · (c2 - c1) / |c2 - c1| = k: the line touches the first circle at
// c1 + r1 n, and the second at c2 + r2 n (outer, k = (r1 - r2) / d) or c2 - r2 n (crossing,
// k = (r1 + r2) / d).
let normal = |k: f64, up: bool| Vec2::new(k, if up { -1.0 } else { 1.0 } * (1.0 - k * k).sqrt());
let outer = normal((r1 - r2) / 200.0, true);
let (on_a, on_b) = (c1 + outer * r1, c2 + outer * r2);
let press = Point::new(100.0, 210.0);
let ((a, b), actions) = line_drag(&c, press, Point::new(200.0, 200.0), on_b + Vec2::new(0.5, 0.7), Mods::default());
assert!(near(a, on_a) && near(b, on_b) && touches((a, b)), "{a:?} {b:?}, want {on_a:?} {on_b:?}");
// One gesture: one undo step.
assert_eq!(actions.iter().filter(|a| matches!(a, Action::Begin(_))).count(), 1, "{actions:?}");
assert_eq!(actions.last(), Some(&Action::Commit));
let crossing = normal((r1 + r2) / 200.0, false);
let (on_a, on_b) = (c1 + crossing * r1, c2 - crossing * r2);
let ((a, b), _) = line_drag(&c, press, Point::new(200.0, 260.0), on_b + Vec2::new(-0.6, 0.4), Mods::default());
assert!(near(a, on_a) && near(b, on_b) && touches((a, b)), "{a:?} {b:?}, want {on_a:?} {on_b:?}");
// The guides and the length label while dragging.
let mut t = ShapeTool::new("lineSegment");
t.pointer(&c, &PointerEvent::new(PointerKind::Down, press.x, press.y));
let to = on_b + Vec2::new(-0.6, 0.4);
t.pointer(&c, &PointerEvent::new(PointerKind::Drag, to.x, to.y));
let o = t.overlays(&c);
let tangents: Vec<Point> = o
.iter()
.filter_map(|o| match o {
Overlay::Label { p, text, .. } if text == "tangent" => Some(*p),
_ => None,
})
.collect();
assert_eq!(tangents.len(), 2, "{o:?}");
assert!(near(tangents[0], on_a) && near(tangents[1], on_b), "{o:?}");
let (a, b) = t.tangent_line.line().unwrap();
assert!(o.iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &c.segment_measure_label(a, b))), "{o:?}");
// Escape ends it.
assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel]);
assert!(t.tangent_line.line().is_none() && t.overlays(&c).is_empty());
}
/// The tangent of a turned ellipse and a circle, against the ellipse's own closed form: the
/// support value of the ellipse x = c + M u (|u| = 1) along n is c · n + |Mᵀ n|, touched at
/// c + M Mᵀ n / |Mᵀ n|; the outer tangents are the n where it equals the circle's c₂ · n + r.
#[test]
fn a_line_from_a_turned_ellipse_lands_on_its_tangent_with_a_circle() {
let ce = Point::new(100.0, 250.0);
let turn = Affine::rotate_about(30f64.to_radians(), ce);
let ellipse = vectorcraft_geom::shapes::ellipse(Rect::new(40.0, 220.0, 160.0, 280.0)).transformed(turn);
let (c2, r2) = (Point::new(320.0, 260.0), 40.0);
let d = doc_with_paths(vec![ellipse, circle(c2, r2)]);
let (s, p) = (Selection::default(), paint());
let c = cx(&d, &s, &p);
// M maps the unit circle onto the ellipse's axes: 60 and 30 long, turned 30°.
let (cos, sin) = (30f64.to_radians().cos(), 30f64.to_radians().sin());
let m = [[60.0 * cos, -30.0 * sin], [60.0 * sin, 30.0 * cos]];
let mt_n = |n: Vec2| Vec2::new(m[0][0] * n.x + m[1][0] * n.y, m[0][1] * n.x + m[1][1] * n.y);
let g = |a: f64| {
let n = Vec2::new(a.cos(), a.sin());
ce.to_vec2().dot(n) + mt_n(n).hypot() - c2.to_vec2().dot(n) - r2
};
// The roots of g over the angle, by sampling and bisection; the one with n pointing up.
let mut roots = vec![];
let steps = 3600;
for k in 0..steps {
let (mut lo, mut hi) = (k as f64 * std::f64::consts::TAU / steps as f64, (k + 1) as f64 * std::f64::consts::TAU / steps as f64);
if g(lo).signum() == g(hi).signum() {
continue;
}
for _ in 0..80 {
let mid = (lo + hi) / 2.0;
if g(mid).signum() == g(lo).signum() { lo = mid } else { hi = mid }
}
roots.push(lo);
}
let n = roots.iter().map(|a| Vec2::new(a.cos(), a.sin())).find(|n| n.y < 0.0).unwrap();
let w = mt_n(n);
let on_a = ce + Vec2::new(m[0][0] * w.x + m[0][1] * w.y, m[1][0] * w.x + m[1][1] * w.y) / w.hypot();
let on_b = c2 + n * r2;
// The press on the ellipse's turned top anchor.
let press = turn * Point::new(100.0, 220.0);
let ((a, b), _) = line_drag(&c, press, Point::new(200.0, 200.0), on_b + Vec2::new(0.4, -0.5), Mods::default());
assert!((a - on_a).hypot() < 0.05 && (b - on_b).hypot() < 0.05, "{a:?} {b:?}, want {on_a:?} {on_b:?}");
}
/// The line keeps its start where it was pressed, as before, when Snap to Tangent is off, Smart
/// Guides are off, Shift or Alt is held, or the pressed path bends inward somewhere (it has no
/// tangent of this kind). Where the tangent touches the second circle at one of its anchors, the
/// tangent still wins over that anchor.
#[test]
fn a_line_keeps_its_start_without_a_tangent_snap() {
use vectorcraft_geom::{BezPath, PathData};
let (c1, c2, r) = (Point::new(100.0, 250.0), Point::new(300.0, 250.0), 50.0);
let d = doc_with_paths(vec![circle(c1, r), circle(c2, r)]);
let (s, p) = (Selection::default(), paint());
let on = cx(&d, &s, &p);
// The pointer next to the second circle's top anchor, where the outer tangent touches it.
let to = Point::new(300.6, 200.4);
// A press on the first circle 30° round from its top, away from its anchors.
let pressed = c1 + Vec2::new(r * 0.5, -r * 3f64.sqrt() / 2.0);
// With Snap to Tangent on, the start moves to the first circle's top.
let ((a, b), _) = line_drag(&on, pressed, Point::new(200.0, 190.0), to, Mods::default());
assert!((a - Point::new(100.0, 200.0)).hypot() < 0.05 && (b - Point::new(300.0, 200.0)).hypot() < 0.05, "{a:?} {b:?}");
let off = [ToolContext { snap_tangent: false, ..cx(&d, &s, &p) }, ToolContext { smart_guides: false, ..cx(&d, &s, &p) }];
for c in &off {
let ((a, _), _) = line_drag(c, pressed, Point::new(200.0, 190.0), to, Mods::default());
assert!((a - pressed).hypot() < 0.05, "{a:?}");
}
for mods in [Mods { shift: true, ..Mods::default() }, Mods { alt: true, ..Mods::default() }] {
let ((a, b), _) = line_drag(&on, pressed, Point::new(200.0, 190.0), to, mods);
// Alt draws the line from its middle.
let start = if mods.alt { a.midpoint(b) } else { a };
assert!((start - pressed).hypot() < 0.05, "{a:?} {b:?}");
}
// Space moves the line being drawn, its start off the pressed circle: the snap lets go.
let mut t = ShapeTool::new("lineSegment");
let space = Mods { space: true, ..Mods::default() };
t.pointer(&on, &PointerEvent::new(PointerKind::Down, pressed.x, pressed.y));
t.pointer(&on, &PointerEvent::new(PointerKind::Drag, 200.0, 170.0));
t.pointer(&on, &PointerEvent::new(PointerKind::Drag, 210.0, 160.0).with_mods(space));
let a = t.pointer(&on, &PointerEvent::new(PointerKind::Drag, to.x, to.y));
let Some(Action::Preview(_, v)) = a.last() else { panic!("a preview: {a:?}") };
let start = Point::new(v["x1"].as_f64().unwrap(), v["y1"].as_f64().unwrap());
assert!((start - (pressed + Vec2::new(10.0, -10.0))).hypot() < 1.0, "{start:?}");
// A crescent: closed and curved, but its lower side bends inward. The press on its top
// keeps its start.
let mut bp = BezPath::new();
bp.move_to((60.0, 250.0));
bp.curve_to((60.0, 190.0), (140.0, 190.0), (140.0, 250.0));
bp.curve_to((120.0, 220.0), (80.0, 220.0), (60.0, 250.0));
bp.close_path();
let d = doc_with_paths(vec![PathData::from_bezpath(&bp), circle(c2, r)]);
let c = cx(&d, &s, &p);
let crest = Point::new(100.0, 205.0);
let ((a, _), _) = line_drag(&c, crest, Point::new(200.0, 190.0), to, Mods::default());
assert!((a - crest).hypot() < 1e-6, "{a:?}");
}
/// The upper outer common tangent of the circles about `c1` and `c2` with radii `r1` and `r2`
/// (`c2` to the right): where it touches each.
fn upper_outer_tangent(c1: Point, r1: f64, c2: Point, r2: f64) -> (Point, Point) {
let d = c2 - c1;
let u = d / d.hypot();
let k = (r1 - r2) / d.hypot();
// n · u = k, with n pointing up (y down).
let n = u * k + Vec2::new(u.y, -u.x) * (1.0 - k * k).sqrt();
(c1 + n * r1, c2 + n * r2)
}
/// The pointer only has to come near the second path's outline: anywhere along it, the line takes
/// the tangent whose touch point is nearest the pointer, here one about 30 pt away. A press on a
/// straight side of a convex path with curves (a rounded rectangle's top edge) moves the start
/// onto the corner the tangent touches.
#[test]
fn a_line_near_the_second_path_takes_the_tangent_touching_it_nearest() {
let (c1, r1, c2, r2) = (Point::new(100.0, 250.0), 40.0, Point::new(300.0, 250.0), 60.0);
let d = doc_with_paths(vec![circle(c1, r1), circle(c2, r2)]);
let (s, p) = (Selection::default(), paint());
let c = cx(&d, &s, &p);
let (on_a, on_b) = upper_outer_tangent(c1, r1, c2, r2);
// On the second circle's outline, 25° round from its top.
let to = c2 + Vec2::new(r2 * 25f64.to_radians().sin(), -r2 * 25f64.to_radians().cos());
assert!((to - on_b).hypot() > 25.0);
let ((a, b), _) = line_drag(&c, Point::new(100.0, 210.0), Point::new(200.0, 200.0), to, Mods::default());
assert!((a - on_a).hypot() < 0.15 && (b - on_b).hypot() < 0.15, "{a:?} {b:?}, want {on_a:?} {on_b:?}");
// A rounded rectangle whose top right corner is a quarter circle of radius 20 about (140, 220).
let rounded = vectorcraft_geom::shapes::rounded_rectangle(Rect::new(40.0, 200.0, 160.0, 300.0), 20.0);
let (c2, r2) = (Point::new(320.0, 260.0), 40.0);
let d = doc_with_paths(vec![rounded, circle(c2, r2)]);
let c = cx(&d, &s, &p);
let (on_a, on_b) = upper_outer_tangent(Point::new(140.0, 220.0), 20.0, c2, r2);
let press = Point::new(90.0, 200.0);
let ((a, b), _) = line_drag(&c, press, Point::new(200.0, 200.0), Point::new(320.0, 220.5), Mods::default());
assert!((a - on_a).hypot() < 0.15 && (b - on_b).hypot() < 0.15, "{a:?} {b:?}, want {on_a:?} {on_b:?}");
}
/// No tangent snap when the second path bends inward somewhere (a crescent), or when the press
/// snapped to an anchor of other art lying beside the first circle: the start stays where the
/// press put it.
#[test]
fn a_line_to_a_crescent_or_from_an_anchor_beside_the_curve_keeps_its_start() {
use vectorcraft_geom::{BezPath, PathData};
let (c1, r) = (Point::new(100.0, 250.0), 50.0);
let mut bp = BezPath::new();
bp.move_to((260.0, 250.0));
bp.curve_to((260.0, 190.0), (340.0, 190.0), (340.0, 250.0));
bp.curve_to((320.0, 220.0), (280.0, 220.0), (260.0, 250.0));
bp.close_path();
let d = doc_with_paths(vec![circle(c1, r), PathData::from_bezpath(&bp)]);
let (s, p) = (Selection::default(), paint());
let c = cx(&d, &s, &p);
let pressed = c1 + Vec2::new(r * 0.5, -r * 3f64.sqrt() / 2.0);
// Beside the crescent's top, which lies at (300, 205).
let to = Point::new(300.4, 205.3);
let ((a, b), _) = line_drag(&c, pressed, Point::new(200.0, 190.0), to, Mods::default());
assert!((a - pressed).hypot() < 0.05 && (b - to).hypot() < 1.0, "{a:?} {b:?}");
// A square whose corner (99, 199) lies about 1 pt outside the first circle's top; a second
// circle to the right. The press snaps to that corner and the line starts there.
let (c2, r2) = (Point::new(300.0, 250.0), 50.0);
let square = vectorcraft_geom::shapes::rectangle(Rect::new(80.0, 180.0, 99.0, 199.0));
let d = doc_with_paths(vec![circle(c1, r), square, circle(c2, r2)]);
let c = cx(&d, &s, &p);
let corner = Point::new(99.0, 199.0);
let ((a, _), _) = line_drag(&c, Point::new(99.3, 199.3), Point::new(200.0, 190.0), Point::new(300.6, 200.4), Mods::default());
assert!((a - corner).hypot() < 1e-6, "{a:?}");
}
/// #5477: with a shape tool, a drag on a selected live rectangle's corner widget rounds its
/// corners (one undo step) and a drag on a live ellipse's pie widget sets its pie angle, as with
/// the Selection tool; the pointer over a widget is the Selection tool's. A press anywhere else, or
+1
View File
@@ -25,6 +25,7 @@ pub use gradient::GradientTool;
pub(crate) use measure::end_point as measure_end_point;
pub use measure::{MeasureTool, measure};
pub use transform::{TransformKind, TransformTool};
pub(crate) use wand::lasso_select;
pub use wand::{LassoTool, MagicWandTool};
/// Create a transform/utility tool by id (None = not one of ours).
+41 -34
View File
@@ -77,6 +77,46 @@ fn anchors_json(v: &BTreeSet<AnchorRef>) -> Value {
Value::Array(v.iter().map(|(s, a)| json!([s, a])).collect())
}
/// The selection a closed loop `poly` (even-odd) makes, for the Lasso and the Polygonal Lasso:
/// the anchor points inside it on every editable path a click can pick, and the gradient mesh
/// points inside it, which `mesh` keeps picked, with their meshes. `add` (Shift) adds to the
/// selection and `sub` (Alt) subtracts from it.
pub(crate) fn lasso_select(cx: &ToolContext, mesh: &mut MeshEdit, poly: &[Point], add: bool, sub: bool) -> Action {
// Anchors inside the loop for every editable path the Lasso may pick.
let mut hits: Vec<(NodeId, BTreeSet<AnchorRef>)> = vec![];
let mut inside: Vec<(NodeId, usize)> = vec![];
crate::draw2::walk_pickable(cx, |n| {
if let Some(grid) = grid_of(n) {
inside.extend(grid.points.iter().enumerate().filter(|(_, q)| point_in_polygon(poly, q.p)).map(|(i, _)| (n.id, i)));
}
if let NodeKind::Path { path, .. } = &n.kind {
let v: BTreeSet<AnchorRef> = path.anchors().filter(|(_, _, a)| point_in_polygon(poly, a.p)).map(|(s, i, _)| (s, i)).collect();
if !v.is_empty() {
hits.push((n.id, v));
}
}
});
let editable = cx.doc.editable();
hits.retain(|(id, _)| editable(*id) && cx.doc.is_visible(*id));
// The mesh points inside the loop are picked, and their meshes selected whole;
// Alt deselects a mesh only when it loses its last picked point.
inside.retain(|(id, _)| editable(*id) && cx.doc.is_visible(*id));
for (id, any) in mesh.lasso(&inside, add, sub) {
if any != sub {
hits.push((id, BTreeSet::new()));
}
}
let items: Vec<Value> = hits.iter().map(|(id, v)| json!({ "id": id.0, "anchors": anchors_json(v) })).collect();
let mode = if sub {
"subtract"
} else if add {
"add"
} else {
"set"
};
Action::Exec("select.anchorsMany".into(), json!({ "items": items, "mode": mode }))
}
impl Tool for LassoTool {
fn id(&self) -> &'static str {
"lasso"
@@ -107,40 +147,7 @@ impl Tool for LassoTool {
if poly.len() < 3 {
return if add || sub { vec![] } else { vec![Action::Exec("select.none".into(), json!({}))] };
}
// Anchors inside the loop for every editable path the Lasso may pick.
let mut hits: Vec<(NodeId, BTreeSet<AnchorRef>)> = vec![];
let mut inside: Vec<(NodeId, usize)> = vec![];
crate::draw2::walk_pickable(cx, |n| {
if let Some(grid) = grid_of(n) {
inside.extend(grid.points.iter().enumerate().filter(|(_, q)| point_in_polygon(&poly, q.p)).map(|(i, _)| (n.id, i)));
}
if let NodeKind::Path { path, .. } = &n.kind {
let v: BTreeSet<AnchorRef> =
path.anchors().filter(|(_, _, a)| point_in_polygon(&poly, a.p)).map(|(s, i, _)| (s, i)).collect();
if !v.is_empty() {
hits.push((n.id, v));
}
}
});
let editable = cx.doc.editable();
hits.retain(|(id, _)| editable(*id) && cx.doc.is_visible(*id));
// The mesh points inside the loop are picked, and their meshes selected whole;
// Alt deselects a mesh only when it loses its last picked point.
inside.retain(|(id, _)| editable(*id) && cx.doc.is_visible(*id));
for (id, any) in self.mesh.lasso(&inside, add, sub) {
if any != sub {
hits.push((id, BTreeSet::new()));
}
}
let items: Vec<Value> = hits.iter().map(|(id, v)| json!({ "id": id.0, "anchors": anchors_json(v) })).collect();
let mode = if sub {
"subtract"
} else if add {
"add"
} else {
"set"
};
vec![Action::Exec("select.anchorsMany".into(), json!({ "items": items, "mode": mode }))]
vec![lasso_select(cx, &mut self.mesh, &poly, add, sub)]
}
_ => vec![],
}
+2
View File
@@ -12,6 +12,7 @@ pub mod image;
pub mod packaging;
pub mod pathtools;
pub mod pen;
pub mod polygonal_lasso;
pub mod select;
pub mod shapes;
pub mod typetools;
@@ -33,6 +34,7 @@ pub fn plugin_menu() -> Vec<Item> {
Item::Sub("Image Tools", image::menu()),
Item::Sub("Packaging Tools", packaging::menu()),
Item::Sub("Path Precision Tools", pathtools::menu()),
Item::Sub("Polygonal Lasso", polygonal_lasso::menu()),
Item::Sub("Selection Tools", select::menu()),
Item::Sub("Smart Pen", pen::menu()),
Item::Sub("Type Tools", typetools::menu()),
+5
View File
@@ -31,6 +31,10 @@ pub const ID: &str = "anchorInspector";
const COUNT: &str = "anchor-inspector-count";
/// The tools' options dialog.
pub const KIND: &str = "pathToolOptions";
/// Common Tangents' command, whose menu item opens the command dialog with a Preview.
pub const COMMON_TANGENTS: &str = "addon.pathtools.commonTangents";
/// The kinds of tangent Common Tangents' `tangents` picks, and their labels.
pub const TANGENT_KINDS: &[(&str, &str)] = &[("All", "all"), ("External", "external"), ("Internal", "internal")];
/// The close modes, as `addon.pathtools.close` names them, and their labels.
const CLOSE_MODES: [(&str, &str); 3] = [("handles", "Keep Handles"), ("straight", "Straight"), ("smooth", "Smooth")];
const LABEL_W: f32 = 64.0;
@@ -72,6 +76,7 @@ pub fn menu() -> Vec<Item> {
Item::Cmd("Expand Dashes into Paths", "addon.pathtools.expandDashes", json!({})),
Item::Cmd("Convert to Parametric Shape", "addon.pathtools.shape.convert", json!({})),
Item::Cmd("Tangent Circle…", tangent_circle::COMMAND, Value::Null),
Item::Cmd("Common Tangents…", COMMON_TANGENTS, json!({ "tangents": "all", "centerline": false })),
]
}
@@ -258,3 +258,73 @@ fn effect_path_effects_lists_the_live_effects_and_their_dialogs_pick_from_their_
assert!(options.iter().all(|(_, value)| doc.params.contains(&format!("\"{value}\""))), "{effect} {key}");
}
}
/// Object › Plug-ins › Path Precision Tools › Common Tangents… opens the command dialog on all
/// tangents without the centerline, Preview off. With Preview on the lines show on the canvas;
/// Cancel takes them away with no step of history, and OK keeps them as one step. Nested circles
/// change nothing and say why.
#[test]
fn common_tangents_previews_cancels_and_runs_on_ok() {
let mut app = app();
let circle = |app: &mut VectorcraftApp, x: f64, r: f64| {
app.run("shape.ellipse", json!({"x": x - r, "y": 150.0 - r, "width": 2.0 * r, "height": 2.0 * r})).unwrap()["id"].as_u64().unwrap()
};
let (a, b) = (circle(&mut app, 60.0, 20.0), circle(&mut app, 220.0, 40.0));
app.run("select.set", json!({"ids": [a, b]})).unwrap();
let steps = |app: &VectorcraftApp| app.session.doc().unwrap().history.undo.len();
let count = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node_count();
let (start, n, nodes) = (app.session.doc().unwrap().doc.clone(), steps(&app), count(&app));
let open = |app: &mut VectorcraftApp| {
let entries = menus::menu_entries(app);
let item = entries.iter().find(|e| e.path == ["Object", "Plug-ins", "Path Precision Tools"] && e.label == "Common Tangents…").unwrap();
assert!(item.enabled);
let (cmd, p) = menus::click_target(&item.label, item.command.as_deref().unwrap(), &item.params);
menus::invoke(app, &cmd, p);
};
open(&mut app);
let d = app.ui.dialog.as_ref().expect("a dialog opens");
assert_eq!((d.str("__command"), d.str("__label")), (super::COMMON_TANGENTS.to_string(), "Common Tangents".to_string()));
assert_eq!((d.str("tangents"), d.bool("centerline"), d.bool("preview")), ("all".to_string(), false, false));
let shown = painted_text(&mut app, |app, ui| crate::dialogs::show(app, ui.ctx()));
for s in ["Common Tangents", "Tangents", "All", "Centerline", "Preview"] {
assert!(shown.contains(s), "{s} in {shown}");
}
// Each kind the list offers is one the command takes.
for (_, kind) in super::TANGENT_KINDS {
assert!(vectorcraft_engine::check_params(super::COMMON_TANGENTS, &json!({"tangents": kind})).is_ok(), "{kind}");
}
assert_eq!(count(&app), nodes, "no preview without the checkbox");
// Preview on: the four lines are on the canvas.
crate::dialogs::set_field(app.ui.dialog.as_mut().unwrap(), "preview".into(), json!(true));
painted_text(&mut app, |app, ui| crate::dialogs::show(app, ui.ctx()));
assert_eq!(count(&app), nodes + 4, "previewed");
// External only, with the centerline: two lines and the centerline.
let d = app.ui.dialog.as_mut().unwrap();
crate::dialogs::set_field(d, "tangents".into(), json!("external"));
crate::dialogs::set_field(d, "centerline".into(), json!(true));
painted_text(&mut app, |app, ui| crate::dialogs::show(app, ui.ctx()));
assert_eq!(count(&app), nodes + 3, "previewed again");
// Cancel: as it was, with no step of history.
crate::dialogs::cancel(&mut app);
assert_eq!(app.session.doc().unwrap().doc, start, "Cancel takes the preview away");
assert_eq!(steps(&app), n, "and adds no undo step");
// OK: one step.
open(&mut app);
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!(steps(&app), n + 1, "one undo step");
assert_eq!(count(&app), nodes + 4);
// A circle inside another: nothing changes, and a message says why.
let inner = circle(&mut app, 220.0, 10.0);
app.run("select.set", json!({"ids": [b, inner]})).unwrap();
let (n, nodes) = (steps(&app), count(&app));
open(&mut app);
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!((steps(&app), count(&app)), (n, nodes));
assert!(app.ui.status.contains("inside the other"), "{}", app.ui.status);
}
@@ -0,0 +1,8 @@
use serde_json::json;
use vectorcraft_tools::addons::polygonal_lasso;
use crate::menus::Item;
pub fn menu() -> Vec<Item> {
vec![Item::Cmd("Polygonal Lasso Tool", "tool.select", json!({"tool": polygonal_lasso::ID}))]
}
+6 -3
View File
@@ -66,8 +66,8 @@ pub(super) const SPEC: DialogSpec = DialogSpec {
/// grid options lists one, and the radial and mirror pages do not. Type on a Path Options does
/// too (#5360), as public tutorials of the dialog show, and Type Tools › Release Type on a Path
/// works the same way (#5532), and so do Image Tools › Remove Background and Color Mask and
/// Cutting Tools › Weed Box and Lines, Banner Hems and Grommets and Nest Shapes. (Cancel rolls a
/// preview back whichever dialog started it.)
/// Cutting Tools › Weed Box and Lines, Banner Hems and Grommets and Nest Shapes, and Path
/// Precision Tools › Common Tangents. (Cancel rolls a preview back whichever dialog started it.)
fn previews(d: &Dialog) -> bool {
match d.str("__command").as_str() {
"object.repeat.options" => d.fields.contains_key("gridType"),
@@ -77,7 +77,8 @@ fn previews(d: &Dialog) -> bool {
| crate::addons::image::COLOR_MASK
| crate::addons::cutting::WEED
| crate::addons::cutting::BANNER
| crate::addons::cutting::NEST => true,
| crate::addons::cutting::NEST
| crate::addons::pathtools::COMMON_TANGENTS => true,
_ => false,
}
}
@@ -163,6 +164,7 @@ fn order(command: &str) -> &'static [&'static str] {
}
crate::addons::cutting::BRIDGES => &["width", "count", "direction", "keepOriginal"],
crate::addons::packaging::SET_ROLE_SWATCH => &["role", "swatch"],
crate::addons::pathtools::COMMON_TANGENTS => &["tangents", "centerline"],
_ => &[],
}
}
@@ -179,6 +181,7 @@ fn choices(command: &str, key: &str) -> Option<form::Choices> {
("text.areaOptions", "firstBaseline") => Some(FIRST_BASELINE),
("text.areaOptions", "verticalAlign") => Some(VERTICAL_ALIGN),
(crate::addons::cutting::WEED, "direction") => Some(crate::addons::cutting::WEED_DIRECTIONS),
(crate::addons::pathtools::COMMON_TANGENTS, "tangents") => Some(crate::addons::pathtools::TANGENT_KINDS),
(crate::addons::image::REMOVE_BACKGROUND | crate::addons::image::COLOR_MASK, "background") => Some(crate::addons::image::BACKGROUNDS),
(crate::addons::image::REMOVE_BACKGROUND | crate::addons::image::COLOR_MASK, "match") => Some(crate::addons::image::MATCHES),
_ => None,
+38 -3
View File
@@ -10,8 +10,8 @@
//! without a step of history.
//!
//! Fields: the options `graph.setType {}` returns under the command's names for them, with
//! `legend`, `pieLegend`, `piePosition`, `pieSort`, `firstRowInFront`, `firstColumnInFront` and
//! `filledLines` held for every type, and `type` or `valueAxis` null while the picked series
//! `legend`, `pieLegend`, `piePosition`, `pieSort`, `firstRowInFront`, `firstColumnInFront`,
//! `filledLines` and `lineWidth` held for every type, and `type` or `valueAxis` null while the picked series
//! differ in it (OK then leaves each series as it is); `overrideValues` and `rightOverrideValues` (Override
//! Calculated Values of the left or only value axis and of the right one: while one is on, OK
//! sends `axisMin`, `axisMax` and `ticks`, or `rightAxisMin`, `rightAxisMax` and `rightTicks`); and
@@ -60,6 +60,8 @@ const WIDTHS: RangeInclusive<f64> = 1.0..=1000.0;
/// The divisions it takes for a value axis, and the tick marks it takes per division.
const DIVISIONS: RangeInclusive<f64> = 1.0..=100.0;
const TICK_MARKS: RangeInclusive<f64> = 1.0..=20.0;
/// The Line Width it takes for Draw Filled Lines, in points.
const LINE_WIDTHS: RangeInclusive<f64> = vectorcraft_doc::MIN_FILLED_LINE_WIDTH..=vectorcraft_doc::MAX_FILLED_LINE_WIDTH;
/// The characters it keeps of a prefix or suffix.
const AFFIX_CHARS: usize = 64;
/// The divisions it draws an overridden value axis in while the axis has no count of its own.
@@ -86,7 +88,7 @@ const PIE_SORTS: [(&str, &str); 3] = [("all", "All"), ("first", "First"), ("none
/// The options OK always sends. `valueAxis` is left out while the picked series are on both axes,
/// and the legend and the tick values follow the type and Override Calculated Values.
const SENT: [&str; 24] = [
const SENT: [&str; 25] = [
"type",
"valueAxis",
"separateScales",
@@ -100,6 +102,7 @@ const SENT: [&str; 24] = [
"connectPoints",
"edgeToEdge",
"filledLines",
"lineWidth",
"tickLength",
"tickMarks",
"rightTickLength",
@@ -183,6 +186,7 @@ pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
("firstRowInFront", json!(spec.first_row_in_front)),
("firstColumnInFront", json!(spec.first_column_in_front)),
("filledLines", json!(spec.filled_lines)),
("lineWidth", json!(spec.filled_line_width())),
("legend", json!(spec.legend)),
("pieLegend", json!(pie_legend)),
("piePosition", json!(spec.pie_position.id())),
@@ -672,6 +676,11 @@ fn type_options(ui: &mut egui::Ui, d: &mut Dialog, kind: GraphKind) {
check(ui, d, "filledLines", tl!("Draw Filled Lines"), connected);
ui.end_row();
});
// Line Width sets how wide Draw Filled Lines draws the lines.
let shown = number(d, "lineWidth").unwrap_or(vectorcraft_doc::DEFAULT_FILLED_LINE_WIDTH);
ui.add_enabled_ui(connected && d.bool("filledLines"), |ui| {
ranged(ui, d, "lineWidth", &colon(tl!("Line Width")), shown, (LINE_WIDTHS, " pt", 2));
});
}
if pie {
choice(ui, d, "pieLegend", &colon(tl!("Legend")), &PIE_LEGENDS);
@@ -1062,6 +1071,32 @@ mod tests {
assert!(!field(&h, "Column Width:") && !checkbox(&h, "Mark Data Points") && !menu(&h, "Legend:") && h.query_by_label("Options").is_none());
}
/// Line Width next to Draw Filled Lines shows the graph's width, is available only while Draw
/// Filled Lines and Connect Data Points are on, and OK gives the graph the width typed.
#[test]
fn line_width_goes_with_draw_filled_lines() {
let mut app = app_with_graph("line");
open(&mut app).unwrap();
assert_eq!(number(app.ui.dialog.as_ref().unwrap(), "lineWidth"), Some(vectorcraft_doc::DEFAULT_FILLED_LINE_WIDTH));
let mut h = harness(app);
let dimmed = |h: &Harness| h.get_by_role_and_label(Role::TextInput, "Line Width:").accesskit_node().is_disabled();
assert!(dimmed(&h), "Draw Filled Lines is off");
h.get_by_role_and_label(Role::CheckBox, "Draw Filled Lines").click();
h.run_steps(3);
assert!(!dimmed(&h));
h.check_accessibility();
set(h.state_mut(), "connectPoints", json!(false));
h.run_steps(3);
assert!(dimmed(&h), "no lines to fill");
set(h.state_mut(), "connectPoints", json!(true));
set(h.state_mut(), "lineWidth", json!(6.5));
let app = h.state_mut();
let before = steps(app);
crate::dialogs::confirm(app).unwrap();
assert_eq!((query(app)["filledLines"].clone(), query(app)["lineWidth"].clone()), (json!(true), json!(6.5)));
assert_eq!(steps(app), before + 1, "one step of history");
}
/// The menu at the top lists a page per axis of the type picked, and a second value axis page
/// while the value axis is on both sides.
#[test]
+212 -26
View File
@@ -24,7 +24,13 @@
//! show the new colors on the smooth wheel, on a segmented wheel (solid patches of 24 hues by 5
//! saturations; its markers move as freely) or as color bars (one per new color, in row order: click
//! one to select it for the sliders, drag one to move its row, which changes no color); the dialog
//! opens on the smooth wheel. With art, the Prominent Colors bar under the wheel shows the new
//! opens on the smooth wheel. Under them, the Add Color tool adds a click on either wheel as a new
//! color (the hue and saturation clicked, at the wheel's brightness; on the segmented wheel the
//! patch's color) in a new row with no current colors, which becomes the selected one, and the
//! Remove Color tool removes the color whose marker is clicked; a bar's right-click menu has Remove
//! Color too. The base color can't be removed. A removed color's row goes, unless it has current
//! colors and art or a group is open: it then keeps them, with no new color, so that art keeps its
//! colors and the group's swatch at that place goes. With art, the Prominent Colors bar under the wheel shows the new
//! colors, each part as wide as its row's share of the art's uses, the largest first; dragging the
//! edge between two parts moves width between them, and when the drag ends the rows' current
//! colors move toward those widths (`recolor.weigh`), and the art previews them. The New Color
@@ -39,19 +45,22 @@
//! The Color Theme Picker button beside the tabs turns on picking from the canvas: a click on an
//! object takes the palette of the object a Selection tool click takes, a drag takes the palette
//! of the art inside its marquee, and Shift adds to the picks so far (`recolor.pickTheme`). The
//! rows that aren't excluded and hold current colors take the picked colors as their new colors,
//! rows that aren't excluded and hold current colors (or were added on the Edit tab) take the
//! picked colors as their new colors,
//! the most used color first and repeating when the rows outnumber them, and the art previews
//! them; OK keeps them as one undo step. A new count of Colors keeps the picks: the new rows take them again.
//!
//! Fields (`ui.dialog.set`): `rows` ([{from: [keys], to: key, exclude?, tint?: percent of a spot
//! color}]), `colors` (null: Auto, or a count), `method`, `preserveWhite`, `preserveBlack`,
//! color, added?}]; a row with no current colors, `from: []`, recolors no art, and with `added: true`
//! (a color the Add Color tool added) adds its new color to the color group; `to: null`, no new color), `colors` (null: Auto, or a count), `method`, `preserveWhite`, `preserveBlack`,
//! `preserveGrays`, `limitTo` (library id, "document" for the document's swatches, "" for none),
//! `group`, `groupName`, `tab` (`assign` or `edit`), `rule` (harmony id), `linked`, `preview`,
//! `sliderMode` (`hsb`, `rgb`, `cmyk`, `lab` or `tint`; unset: the row color's own model, HSB for
//! a gray and Tint for a spot color; `global`: Global Adjust, on the Edit tab), `globalAdjust`
//! (`{saturation, brightness, temperature, luminosity}` in percent, sent as `recolor.apply`'s
//! `globalAdjust` in every slider mode), `display` (the Edit tab's `smooth`, `segmented` or `bars`;
//! unset: `smooth`), `themePicker` (the Color Theme Picker is on), `themePicks` (its picks, as
//! unset: `smooth`), `wheelTool` (`add`: the Add Color tool, `remove`: the Remove Color tool;
//! unset: neither, a click on the wheel selects a marker), `themePicker` (the Color Theme Picker is on), `themePicks` (its picks, as
//! `recolor.pickTheme`'s `picks`; a new list recolors the rows), `weights` (one per row, as
//! `recolor.weigh`'s; a new list moves the rows' current colors toward them), `findColors` (Find is
//! on; it shows the art so on the Assign tab, with art and rows selected). Changing `colors`, a
@@ -393,7 +402,7 @@ fn group_colors<'a>(app: &VectorcraftApp, d: &Dialog, rs: impl Iterator<Item = &
}
/// The New Color Group menu's request: save the new colors of the rows that aren't excluded and
/// hold current colors (Save All Colors, in row order; a row without one gives its first current
/// hold current colors or were added on the Edit tab (Save All Colors, in row order; a row without one gives its first current
/// color) or of the Prominent Colors bar (Save Prominent Colors, in its order) as a new color
/// group, a step of its own (`swatch.newGroup`).
fn save_group(app: &mut VectorcraftApp, d: &mut Dialog, which: &str) {
@@ -420,7 +429,7 @@ const THEME_PICKS: &str = "themePicks";
const THEME_DONE: &str = "__themePicked";
/// When the picks of the Color Theme Picker changed, give the rows that aren't excluded and hold
/// current colors the palette of the art picked (`recolor.pickTheme`, as many colors as those
/// current colors or were added on the Edit tab the palette of the art picked (`recolor.pickTheme`, as many colors as those
/// rows), in row order; with fewer colors than rows, the colors repeat. Picks that touch no art
/// leave the rows as they are.
fn sync_theme(app: &mut VectorcraftApp, d: &mut Dialog) {
@@ -561,14 +570,25 @@ fn excluded(row: &Value) -> bool {
row["exclude"].as_bool().unwrap_or(false)
}
/// Whether `row` holds no current colors: a row made with New Row, until colors are merged into it.
/// Its new color recolors nothing and is no color of a color group, the wheel or the harmony rules.
/// Whether `row` has no current colors (a row made with New Row, or a color added on the Edit tab).
fn no_current(row: &Value) -> bool {
row["from"].as_array().is_none_or(Vec::is_empty)
}
/// Whether `row` is a color added on the Edit tab (`added`), which joins the color group.
fn is_added(row: &Value) -> bool {
row["added"].as_bool().unwrap_or(false)
}
/// Whether `row` is a row made with New Row that holds no current colors, until colors are merged
/// into it. Its new color recolors nothing and is no color of a color group, the wheel or the
/// harmony rules. A color added on the Edit tab (`added`) is not empty: it joins the color group.
fn empty(row: &Value) -> bool {
row["from"].as_array().is_some_and(Vec::is_empty)
row["from"].as_array().is_some_and(Vec::is_empty) && !is_added(row)
}
/// Whether `row`'s new color is one of the colors a color group takes: the row isn't excluded and
/// holds current colors.
/// holds current colors or is a color added on the Edit tab.
fn in_group(row: &Value) -> bool {
!excluded(row) && !empty(row)
}
@@ -583,15 +603,19 @@ fn selection(d: &Dialog) -> Vec<usize> {
}
/// `recolor.apply` parameters: the rows, method, library and the group with its new name and
/// colours: the rows' new colours, then (with art) the group's colours no row took.
/// colors: the new colors of the rows with current colors, each in its swatch's place (`null`
/// for a row whose new color was removed, which removes its swatch), then (with art) the group's
/// colors no row took, then the colors added on the Edit tab.
fn apply_params(d: &Dialog) -> Value {
let rs = rows(d);
let group = d.fields.get("group").and_then(Value::as_str).map(|g| {
// A row made with New Row that holds no current colors gives the group no color.
let filled: Vec<&Value> = rs.iter().filter(|r| !empty(r)).map(|r| &r["to"]).collect();
// A row made with New Row that holds no current colors gives the group no color; a color
// added on the Edit tab (`added`) joins it after the others.
let took: Vec<&Value> = rs.iter().filter(|r| !no_current(r)).map(|r| &r["to"]).collect();
let assign = d.fields.get("__assign").and_then(Value::as_array).filter(|_| d.bool("__art"));
let rest = assign.map_or(&[][..], |a| a.get(filled.len()..).unwrap_or_default());
let colors: Vec<&Value> = filled.into_iter().chain(rest).collect();
let rest = assign.map_or(&[][..], |a| a.get(took.len()..).unwrap_or_default());
let added = rs.iter().filter(|r| no_current(r) && is_added(r) && !excluded(r)).map(|r| &r["to"]).filter(|c| !c.is_null());
let colors: Vec<&Value> = took.into_iter().chain(rest).chain(added).collect();
let name = d.str("groupName");
let rename = (!name.trim().is_empty() && name != g).then_some(name);
json!({"group": g, "groupColors": colors, "rename": rename})
@@ -921,15 +945,21 @@ fn assign_tab(app: &mut VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut
let (nr, _) = ui.allocate_exact_size(vec2(46.0, 20.0), Sense::hover());
let nresp = ui.interact(nr, egui::Id::unique((NEW_CHIP, i)), Sense::click());
let to = to_color(row).unwrap_or_default();
chip(ui, nr, shown.get(i).copied().unwrap_or_default(), off);
// A row whose new color was removed shows an empty frame and an empty hex field.
let has_new = to_color(row).is_some();
if has_new {
chip(ui, nr, shown.get(i).copied().unwrap_or_default(), off);
} else {
ui.painter().rect_stroke(nr, 1.0, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
}
if nresp.clicked() {
clicked = Some(i);
}
if nresp.double_clicked() {
if nresp.double_clicked() && has_new {
pick = Some(i);
}
ui.add_space(6.0);
let hex = crate::panels::color::hex_digits(&to);
let hex = if has_new { crate::panels::color::hex_digits(&to) } else { String::new() };
let hex_name = format!("{} {}", tl!("Color"), i + 1);
if let Some(h) = widgets::hex_field_named(ui, ("recolor-hex", i), Some(&hex_name), &hex)
&& let Some(c) = crate::panels::color::parse_hex(&h)
@@ -1383,7 +1413,7 @@ fn new_row(rows: &mut Vec<Value>, sel: &[usize]) -> usize {
}
/// The rows the Edit tab shows, the harmony rules fill and the Color Theme Picker recolors: those
/// with a new colour that aren't excluded and hold current colors.
/// with a new colour that aren't excluded and hold current colors or were added on the Edit tab.
fn active_rows(rows: &[Value]) -> Vec<usize> {
(0..rows.len()).filter(|i| in_group(&rows[*i]) && to_color(&rows[*i]).is_some()).collect()
}
@@ -1413,8 +1443,61 @@ fn move_color(rows: &mut [Value], i: usize, hsb: [f32; 3], linked: bool) {
/// The rows when a drag on the Edit tab's wheel started.
const DRAG: &str = "__drag";
/// The field of the Edit tab's wheel tools: `add` (Add Color) or `remove` (Remove Color).
const WHEEL_TOOL: &str = "wheelTool";
/// The new color the Add Color tool gives a click at hue `h` (degrees) and saturation `s`: at the
/// brightness of `base` (the base color, whose brightness the wheel shows; full without one), the
/// segmented wheel's patch color with `segmented`, in `base`'s model.
fn added_color(base: Option<Color>, h: f32, s: f32, segmented: bool) -> Color {
let v = base.map_or(1.0, |b| b.to_hsb()[2]);
let c = if segmented { widgets::segment_color(h, s, v) } else { Color::from_hsb(h, s, v) };
base.map_or(c, |b| keep_model(b, c))
}
/// Add new color `c` as a row with no current colors, marked `added`, after the others. Returns
/// its index.
fn add_color(rows: &mut Vec<Value>, c: &Color) -> usize {
rows.push(json!({"from": [], "to": key(c), "added": true}));
rows.len() - 1
}
/// Remove row `i`'s new color: a row with no current colors (or, without `keep`, any row) goes,
/// and with `keep` (art, or a color group whose swatches the rows are) a row with current colors
/// stays with no new color, so that its art keeps its colors and its group swatch is removed in
/// its place. The base row `base` stays. Returns the base row's index afterwards, or `None` when
/// nothing changed.
fn remove_color(rows: &mut Vec<Value>, i: usize, base: Option<usize>, keep: bool) -> Option<usize> {
if Some(i) == base || i >= rows.len() || to_color(&rows[i]).is_none() {
return None;
}
if keep && !no_current(&rows[i]) {
rows[i]["to"] = Value::Null;
if let Some(r) = rows[i].as_object_mut() {
r.remove("tint");
r.remove("model");
}
return Some(base.unwrap_or(0));
}
rows.remove(i);
Some(base.map_or(0, |b| if b > i { b - 1 } else { b }))
}
/// Whether Remove Color keeps a row with current colors (see [`remove_color`]): with art, or with a
/// color group.
fn keeps_rows(d: &Dialog) -> bool {
d.bool("__art") || d.fields.get("group").is_some_and(Value::is_string)
}
/// After Remove Color: select the base row at `base`; the slider values held were for a row index
/// that may now hold another row.
fn removed(d: &mut Dialog, base: usize) {
d.fields.insert("__sel".into(), json!([base]));
d.fields.remove(COMPS);
}
/// The Edit tab. Returns true when the rows changed.
fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut [Value]) -> bool {
fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut Vec<Value>) -> bool {
let top = ui.cursor().top();
let t = Tokens::get(ui.ctx());
let mut changed = false;
@@ -1468,6 +1551,9 @@ fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut [Value
let colors: Vec<Color> = active.iter().filter_map(|&i| to_color(&rows[i])).collect();
let marked = base.and_then(|b| active.iter().position(|&i| i == b));
let display = d.str("display");
let tool = d.str(WHEEL_TOOL);
// The tools act on either wheel, not on the color bars.
let on_wheel = display != "bars";
let mut w = widgets::WheelResponse::default();
ui.horizontal(|ui| {
// The display buttons, beside the wheel so the tab keeps its height.
@@ -1482,6 +1568,14 @@ fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut [Value
d.fields.insert("display".into(), json!(id));
}
}
// The wheel tools: a click on the button turns its tool on, or off again.
ui.add_space(8.0);
for (id, icon, tip) in [("add", "plus", tl!("Add Color Tool")), ("remove", "minus", tl!("Remove Color Tool"))] {
let on = tool == id;
if widgets::icon_button_enabled(ui, icon, tip, on && on_wheel, on_wheel, 24.0).clicked() {
d.fields.insert(WHEEL_TOOL.into(), if on { Value::Null } else { json!(id) });
}
}
});
ui.vertical(|ui| match display.as_str() {
"segmented" => w = widgets::segmented_wheel(ui, "recolor-wheel", WHEEL, &colors, marked),
@@ -1489,17 +1583,33 @@ fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut [Value
_ => w = widgets::harmony_wheel(ui, "recolor-wheel", WHEEL, &colors, marked),
});
});
// A click with a wheel tool adds a color there, or removes the color of the marker clicked.
let clicked = w.clicked.filter(|_| on_wheel && matches!(tool.as_str(), "add" | "remove"));
if let Some((hit, [h, s])) = clicked {
if tool == "add" {
let c = added_color(base.and_then(|b| to_color(&rows[b])), h, s, display == "segmented");
let i = add_color(rows, &c);
d.fields.insert("__sel".into(), json!([i]));
d.fields.remove(COMPS);
changed = true;
} else if let Some(b) = hit.and_then(|k| remove_color(rows, active[k], base, keeps_rows(d))) {
removed(d, b);
changed = true;
}
}
// Prominent Colors: the art's new colors, each as wide as its share of the art.
if art {
prominent_bar(ui, d, rows);
}
if let Some(k) = w.pressed {
// A tool's click selects no marker: Add Color selects the new row, and Remove Color keeps the
// base color.
if let Some(k) = w.pressed.filter(|_| clicked.is_none()) {
d.fields.insert("__sel".into(), json!([active[k]]));
}
// A drag (of a marker or the brightness slider) moves the rows as they were when it started:
// a new colour read back from its model (CMYK through the colour profile) isn't exactly the
// colour written, so building on last frame's rows drifted the linked colours (#1733).
if let Some((k, set)) = w.moved {
if let Some((k, set)) = w.moved.filter(|_| clicked.is_none()) {
let start = match d.fields.get(DRAG).and_then(Value::as_array) {
Some(s) if s.len() == rows.len() => s.clone(),
_ => rows.to_vec(),
@@ -1519,6 +1629,9 @@ fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut [Value
if !art {
ui.add_space(SLIDERS_GAP);
}
// A color added or removed above changed the rows, so the sliders and chips read them afresh.
let active = active_rows(rows);
let base = selection(d).into_iter().find(|i| active.contains(i)).or(active.first().copied());
if d.str("sliderMode") == GLOBAL {
let sample = base.and_then(|b| to_color(&rows[b])).unwrap_or(Color::rgb(0.8, 0.45, 0.25));
global_sliders(ui, d, sample);
@@ -1549,11 +1662,12 @@ fn edit_tab(app: &VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut [Value
/// The Edit tab's color bars: a solid bar per row of `active` with its new color, in row order, the
/// base row's framed, scrolling past the wheel's height. A click on a bar selects its row (the
/// sliders under it edit that row's new color); a drag moves the bar's row to where the line under
/// the pointer shows, keeping every new color. Returns true when the rows moved.
fn color_bars(ui: &mut Ui, d: &mut Dialog, rows: &mut [Value], active: &[usize], base: Option<usize>) -> bool {
/// the pointer shows, keeping every new color. A bar's right-click menu has Remove Color (not for the
/// base row's). Returns true when the rows moved or a color was removed.
fn color_bars(ui: &mut Ui, d: &mut Dialog, rows: &mut Vec<Value>, active: &[usize], base: Option<usize>) -> bool {
let t = Tokens::get(ui.ctx());
let mut rects: Vec<Rect> = Vec::with_capacity(active.len());
let (mut dragging, mut released, mut dropped) = (None, None, None);
let (mut dragging, mut released, mut dropped, mut remove) = (None, None, None, None);
// The area is given its full height first: in the row beside the display buttons a scroll area
// alone is only as tall as the room the row has.
let area = vec2(ui.available_width(), BARS_H);
@@ -1584,7 +1698,12 @@ fn color_bars(ui: &mut Ui, d: &mut Dialog, rows: &mut [Value], active: &[usize],
released = Some(n);
}
rects.push(r);
resp.on_hover_text(rows[i]["to"].as_str().unwrap_or_default());
let resp = resp.on_hover_text(rows[i]["to"].as_str().unwrap_or_default());
resp.context_menu(|ui| {
if widgets::menu_item_name(ui, tl!("Remove Color"), Some(i) != base, false) {
remove = Some(i);
}
});
}
// The place a dragged bar goes: before the first bar whose middle is below the pointer.
let at = ui.input(|i| i.pointer.latest_pos()).map(|p| rects.iter().filter(|r| r.center().y < p.y).count());
@@ -1599,6 +1718,10 @@ fn color_bars(ui: &mut Ui, d: &mut Dialog, rows: &mut [Value], active: &[usize],
dropped = released.zip(at);
});
});
if let Some(b) = remove.and_then(|i| remove_color(rows, i, base, keeps_rows(d))) {
removed(d, b);
return true;
}
let Some(moved) = dropped.and_then(|(n, to)| move_bar(rows, active, n, to)) else { return false };
d.fields.insert("__sel".into(), json!([moved]));
// The slider values held are those of a row index that may now hold another row.
@@ -1689,6 +1812,58 @@ mod tests {
assert!(c.to_hsb()[1] < 1e-3, "{c:?}");
}
/// Remove Color: a row with no current colors goes, with art or a group a row's current colors
/// stay with no new color, without either the row goes, and the base row stays; the base row's
/// index follows.
#[test]
fn remove_color_drops_added_rows_and_empties_rows_of_art() {
let mut r = rows();
assert_eq!(add_color(&mut r, &Color::rgb(0.0, 1.0, 1.0)), 3);
assert_eq!(r[3], json!({"from": [], "to": "rgb 0 255 255", "added": true}));
assert_eq!(remove_color(&mut r, 0, Some(0), true), None, "the base row stays");
r[1]["tint"] = json!(50);
assert_eq!(remove_color(&mut r, 1, Some(2), true), Some(2));
assert_eq!(r[1], json!({"from": ["rgb 0 0 255", "rgb 0 0 128"], "to": null}), "the art's colors stay, without a tint");
assert_eq!(remove_color(&mut r, 1, Some(2), true), None, "no new color left to remove");
assert_eq!(remove_color(&mut r, 3, Some(2), true), Some(2));
assert_eq!(r.len(), 3, "the added row goes");
assert_eq!(remove_color(&mut r, 9, Some(2), true), None);
let mut r = rows();
assert_eq!(remove_color(&mut r, 0, Some(2), false), Some(1), "without art the row goes, and the base row moves up");
assert_eq!(r.len(), 2);
assert_eq!(r[1]["from"], json!(["rgb 0 255 0"]));
}
/// An added color is the hue and saturation clicked at the base color's brightness (full without
/// one), the patch's color on the segmented wheel, in the base color's model.
#[test]
fn an_added_color_takes_the_base_colors_brightness_and_model() {
let near = |a: [f32; 3], b: [f32; 3]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-3);
let base = Color::from_hsb(10.0, 0.8, 0.6);
assert!(near(added_color(Some(base), 120.0, 0.5, false).to_hsb(), [120.0, 0.5, 0.6]));
assert!(near(added_color(None, 200.0, 0.25, false).to_hsb(), [200.0, 0.25, 1.0]));
assert!(near(added_color(None, 7.0, 0.95, true).to_hsb(), [0.0, 0.9, 1.0]), "the patch's color");
let cmyk = color_value(&json!("cmyk 0 100 100 0")).unwrap();
assert!(matches!(added_color(Some(cmyk), 120.0, 0.5, false), Color::Cmyk { .. }));
}
/// With a color group and art, a row without a new color removes its swatch in its place, the
/// group's colors no row of art took stay in theirs, and a color added on the Edit tab adds its
/// new color after them; a row made with New Row, which holds no current colors, adds none.
#[test]
fn apply_params_give_the_group_added_colors_and_keep_its_other_colors() {
let mut d = Dialog::new(KIND, json!({"group": "G", "groupName": "G", "__art": true, "__assign": ["rgb 1 1 1", "rgb 2 2 2", "rgb 3 3 3"]}));
let mut rs = vec![json!({"from": ["rgb 255 0 0"], "to": "rgb 1 1 1"}), json!({"from": ["rgb 0 0 255"], "to": null})];
new_row(&mut rs, &[]);
add_color(&mut rs, &Color::rgb(9.0 / 255.0, 9.0 / 255.0, 9.0 / 255.0));
d.fields.insert("rows".into(), json!(rs));
assert_eq!(apply_params(&d)["groupColors"], json!(["rgb 1 1 1", null, "rgb 3 3 3", "rgb 9 9 9"]));
// An added color whose row is excluded joins no group.
rs[3]["exclude"] = json!(true);
d.fields.insert("rows".into(), json!(rs));
assert_eq!(apply_params(&d)["groupColors"], json!(["rgb 1 1 1", null, "rgb 3 3 3"]));
}
#[test]
fn merge_and_separate_rows() {
let mut r = rows();
@@ -1816,6 +1991,17 @@ mod tests {
assert_eq!(edit_slider_row(&sel(json!([0])), &r, &[], None), None, "no row to edit");
}
/// A color added on the Edit tab holds no current colors but is not an empty row: the Edit tab
/// shows it and a color group takes it.
#[test]
fn an_added_color_is_not_an_empty_row() {
let added = json!({"from": [], "to": "rgb 0 255 255", "added": true});
assert!(!empty(&added) && in_group(&added));
let mut r = rows();
r.push(added);
assert_eq!(active_rows(&r), [0, 1, 2, 3]);
}
/// A rule or a wheel move that gives a row a new color drops the row's tint; a row whose
/// color stays keeps it.
#[test]
+1 -1
View File
@@ -300,7 +300,7 @@ fn code_view(app: &VectorcraftApp, ui: &mut egui::Ui, d: &Dialog) {
None => {
const MAX: usize = 200_000;
let params = json!({ "svg": opts });
let encoded = vectorcraft_engine::cmd::fileio::check_linked_scripts("document.export", "svg", st).and_then(|()| {
let encoded = vectorcraft_engine::cmd::fileio::check_linked_scripts("document.export", "svg", st, &params).and_then(|()| {
let selected;
let doc = if selection {
selected = vectorcraft_engine::cmd::fileio::selection_doc(st, "document.exportSelection", false)?.0;
+5 -2
View File
@@ -637,6 +637,7 @@ fn addon_tools_are_in_the_drawer_not_the_toolbars() {
let enclosing = vectorcraft_tools::addons::enclosing_lasso::ID;
let contour = vectorcraft_tools::addons::contour::ID;
let box3d = vectorcraft_tools::addons::box3d::ID;
let polygonal = vectorcraft_tools::addons::polygonal_lasso::ID;
let addon: Vec<&str> = vectorcraft_tools::addons::GROUPS.iter().flat_map(|g| g.iter().map(|t| t.id)).collect();
assert_eq!(
addon,
@@ -652,7 +653,8 @@ fn addon_tools_are_in_the_drawer_not_the_toolbars() {
"smartPen",
enclosing,
contour,
box3d
box3d,
polygonal
]
);
for advanced in [false, true] {
@@ -669,7 +671,8 @@ fn addon_tools_are_in_the_drawer_not_the_toolbars() {
assert_eq!(listed(enclosing), Some(("Enclosing Lasso", vec![enclosing])));
assert_eq!(listed(contour), Some(("Contour", vec![contour])));
assert_eq!(listed(box3d), Some(("3D Box", vec![box3d])));
for tool in ["extendPath", "smartPen", enclosing, contour, box3d] {
assert_eq!(listed(polygonal), Some(("Polygonal Lasso", vec![polygonal])));
for tool in ["extendPath", "smartPen", enclosing, contour, box3d, polygonal] {
app.run("toolbar.addTool", json!({"tool": tool})).unwrap();
assert!(slot_of(&app, tool).is_some(), "{tool}");
}
+22
View File
@@ -1416,6 +1416,7 @@ font-technology Variable Променливи
Connect Data Points Свързване на точките от данни
Edge-to-Edge Lines Линии от край до край
Draw Filled Lines Чертане на запълнени линии
Line Width Ширина на линията
Tick Values Стойности на отметките
Override Calculated Values Замяна на изчислените стойности
Divisions Деления
@@ -1514,6 +1515,9 @@ font-technology Variable Променливи
Show smooth color wheel Показване на плавно цветово колело
Show segmented color wheel Показване на сегментирано цветово колело
Show color bars Показване на цветни ленти
Add Color Tool Инструмент „Добавяне на цвят“
Remove Color Tool Инструмент „Премахване на цвят“
Remove Color Премахване на цвят
Find the selected colors in the artwork Намиране на избраните цветове в илюстрацията
Harmony Sets Набори от хармонии
Height Височина
@@ -1846,6 +1850,8 @@ font-technology Variable Променливи
Lasso Tool Инструмент „Ласо“
Enclosing Lasso Tool Инструмент „Обхващащо ласо“
Enclosing Lasso Обхващащо ласо
Polygonal Lasso Tool Инструмент „Многоъгълно ласо“
Polygonal Lasso Многоъгълно ласо
Last Effect: {name} Посл. ефект: {name}
Last Effect: {} Посл. ефект: {}
Last Effect… Посл. ефект…
@@ -6767,6 +6773,22 @@ breakText Glyphs Глифи
Remove Gaps Премахване на разстоянията
@msg that makes too many pieces (at most 100000): make the dashes longer така се получават твърде много части (най-много 100000): удължете тиретата
@msg select paths, or segments, to divide изберете пътища или сегменти за разделяне
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Общи допирателни…
Common Tangents Общи допирателни
Tangents Допирателни
Centerline Централна линия
External Външни
Internal Вътрешни
@msg select two closed paths изберете два затворени пътя
@msg a selected path is open избран път е отворен
@msg a selected path is not convex избран път не е изпъкнал
@msg a selected path has no area избран път няма площ
@msg a selected path has more than 10000 segments избран път има повече от 10000 сегмента
@msg the two paths have the same outline двата пътя имат еднакъв контур
@msg One path lies inside the other, so they have no common tangents Единият път е вътре в другия, затова нямат общи допирателни
@msg The paths overlap, so they have no internal tangents Пътищата се припокриват, затова нямат вътрешни допирателни
@msg One path lies inside the other, so they have no internal tangents Единият път е вътре в другия, затова нямат вътрешни допирателни
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Разширяване на тиретата в пътища
@msg select paths with dashed strokes to expand изберете пътища с прекъснат щрих за разширяване
Can't render this file because it is too large.
+22
View File
@@ -1424,6 +1424,8 @@ lighting Light Svjetlo
Lasso Tool Alat laso
Enclosing Lasso Tool Alat laso za obuhvatanje
Enclosing Lasso Laso za obuhvatanje
Polygonal Lasso Tool Alat poligonalni laso
Polygonal Lasso Poligonalni laso
Lasso Laso
Line Cut Tool Alat za rez linijom
Line Graph Tool Alat za linijski grafikon
@@ -2936,6 +2938,9 @@ digits Malayalam Malajalam
Show smooth color wheel Prikaži glatki kotač boja
Show segmented color wheel Prikaži segmentirani kotač boja
Show color bars Prikaži trake boja
Add Color Tool Alat za dodavanje boje
Remove Color Tool Alat za uklanjanje boje
Remove Color Ukloni boju
Find the selected colors in the artwork Pronađi odabrane boje u crtežu
Harmony Rules Pravila harmonije
Keep this row's colors (exclude) Zadrži boje ovog reda (isključi)
@@ -3646,6 +3651,7 @@ theme Appearance Izgled
Connect Data Points Poveži tačke podataka
Edge-to-Edge Lines Linije od ivice do ivice
Draw Filled Lines Crtaj ispunjene linije
Line Width Širina linije
Tick Values Vrijednosti crtica
Override Calculated Values Zamijeni izračunate vrijednosti
Divisions Podioci
@@ -6819,6 +6825,22 @@ shape Open Otvoren
Remove Gaps Ukloni razmake
@msg that makes too many pieces (at most 100000): make the dashes longer to daje previše dijelova (najviše 100000): produžite crtice
@msg select paths, or segments, to divide odaberite putanje ili segmente za dijeljenje
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Zajedničke tangente…
Common Tangents Zajedničke tangente
Tangents Tangente
Centerline Središnja linija
External Vanjske
Internal Unutrašnje
@msg select two closed paths odaberite dvije zatvorene putanje
@msg a selected path is open odabrana putanja je otvorena
@msg a selected path is not convex odabrana putanja nije konveksna
@msg a selected path has no area odabrana putanja nema površinu
@msg a selected path has more than 10000 segments odabrana putanja ima više od 10000 segmenata
@msg the two paths have the same outline obje putanje imaju isti obris
@msg One path lies inside the other, so they have no common tangents Jedna putanja leži unutar druge, pa nemaju zajedničkih tangenti
@msg The paths overlap, so they have no internal tangents Putanje se preklapaju, pa nemaju unutrašnjih tangenti
@msg One path lies inside the other, so they have no internal tangents Jedna putanja leži unutar druge, pa nemaju unutrašnjih tangenti
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Proširi crtice u putanje
@msg select paths with dashed strokes to expand odaberite putanje s isprekidanim potezom za proširivanje
Can't render this file because it contains an unexpected character in line 2 and column 73.
+24
View File
@@ -1954,6 +1954,7 @@ digits Malayalam Malaiàlam
Connect Data Points Connecta els punts de dades
Edge-to-Edge Lines Línies de vora a vora
Draw Filled Lines Dibuixa línies emplenades
Line Width Amplada de línia
Tick Values Valors de les marques
Override Calculated Values Substitueix els valors calculats
Divisions Divisions
@@ -2052,6 +2053,9 @@ digits Malayalam Malaiàlam
Show smooth color wheel Mostra la roda de color contínua
Show segmented color wheel Mostra la roda de color segmentada
Show color bars Mostra les barres de color
Add Color Tool Eina Afegeix color
Remove Color Tool Eina Elimina color
Remove Color Elimina el color
Find the selected colors in the artwork Troba els colors seleccionats a l’obra
Harmony Sets Conjunts d’harmonia
HDTV 1080p HDTV 1080p
@@ -2356,6 +2360,8 @@ digits Malayalam Malaiàlam
Lasso Tool Eina de llaç
Enclosing Lasso Tool Eina de llaç envoltant
Enclosing Lasso Llaç envoltant
Polygonal Lasso Tool Eina de llaç poligonal
Polygonal Lasso Llaç poligonal
Last Últim
Last Artboard Últim tauler
Status Bar Show Mostra a la barra d'estat
@@ -7468,6 +7474,22 @@ breakText Glyphs Glifs
Remove Gaps Elimina les separacions
@msg that makes too many pieces (at most 100000): make the dashes longer això fa massa trossos (com a màxim 100000): allargueu els guions
@msg select paths, or segments, to divide seleccioneu camins o segments per dividir
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Tangents comunes…
Common Tangents Tangents comunes
Tangents Tangents
Centerline Línia central
External Externes
Internal Internes
@msg select two closed paths seleccioneu dos camins tancats
@msg a selected path is open un camí seleccionat és obert
@msg a selected path is not convex un camí seleccionat no és convex
@msg a selected path has no area un camí seleccionat no té àrea
@msg a selected path has more than 10000 segments un camí seleccionat té més de 10000 segments
@msg the two paths have the same outline els dos camins tenen el mateix contorn
@msg One path lies inside the other, so they have no common tangents Un camí és dins de l’altre, per tant no tenen tangents comunes
@msg The paths overlap, so they have no internal tangents Els camins se superposen, per tant no tenen tangents internes
@msg One path lies inside the other, so they have no internal tangents Un camí és dins de l’altre, per tant no tenen tangents internes
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Expandeix els guions en camins
@msg select paths with dashed strokes to expand seleccioneu camins amb traç discontinu per expandir
@@ -7782,6 +7804,8 @@ breakText Glyphs Glifs
@msg No bridge of this width fits across the selected art Cap pont d’aquesta amplada no cap a la il·lustració seleccionada
@msg Some islands could not be joined to the area around the art Algunes illes no s’han pogut unir a l’àrea que envolta la il·lustració
@msg `width` must be from {lo} to {hi} pt `width` ha d’estar entre {lo} i {hi} pt
@msg `angle` must be from -180 to 180 degrees `angle` ha d’estar entre -180 i 180 graus
@msg `roundness` must be from 1 to 100% `roundness` ha d’estar entre 1 i 100%
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} `count` ha de ser un nombre enter d’1 a {MAX_BRIDGES_PER_ISLAND}
Weed Box and Lines… Caixa i línies de pelat…
Weed Box and Lines Caixa i línies de pelat
Can't render this file because it contains an unexpected character in line 2 and column 73.
+24
View File
@@ -1448,6 +1448,8 @@ lighting Light Světlo
Lasso Tool Nástroj Laso
Enclosing Lasso Tool Nástroj obklopující laso
Enclosing Lasso Obklopující laso
Polygonal Lasso Tool Nástroj Mnohoúhelníkové laso
Polygonal Lasso Mnohoúhelníkové laso
Lasso Laso
Line Cut Tool Nástroj Řez čarou
Line Graph Tool Nástroj Spojnicový graf
@@ -3019,6 +3021,9 @@ digits Malayalam Malajálamské
Show smooth color wheel Zobrazit plynulé barevné kolo
Show segmented color wheel Zobrazit segmentované barevné kolo
Show color bars Zobrazit barevné pruhy
Add Color Tool Nástroj Přidat barvu
Remove Color Tool Nástroj Odstranit barvu
Remove Color Odstranit barvu
Find the selected colors in the artwork Najít vybrané barvy v kresbě
Harmony Rules Pravidla harmonie
Keep this row's colors (exclude) Ponechat barvy tohoto řádku (vyloučit)
@@ -3747,6 +3752,7 @@ theme Appearance Motiv
Connect Data Points Spojit datové body
Edge-to-Edge Lines Čáry od okraje k okraji
Draw Filled Lines Kreslit vyplněné čáry
Line Width Šířka čáry
Tick Values Hodnoty značek
Override Calculated Values Přepsat vypočítané hodnoty
Divisions Dílky
@@ -7459,6 +7465,22 @@ breakText Glyphs Glyfy
Remove Gaps Odstranit mezery
@msg that makes too many pieces (at most 100000): make the dashes longer tím vznikne příliš mnoho dílů (nejvýše 100000): prodlužte čárky
@msg select paths, or segments, to divide vyberte cesty nebo segmenty k rozdělení
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Společné tečny…
Common Tangents Společné tečny
Tangents Tečny
Centerline Středová čára
External Vnější
Internal Vnitřní
@msg select two closed paths vyberte dvě uzavřené cesty
@msg a selected path is open vybraná cesta je otevřená
@msg a selected path is not convex vybraná cesta není konvexní
@msg a selected path has no area vybraná cesta nemá žádnou plochu
@msg a selected path has more than 10000 segments vybraná cesta má více než 10000 segmentů
@msg the two paths have the same outline obě cesty mají stejný obrys
@msg One path lies inside the other, so they have no common tangents Jedna cesta leží uvnitř druhé, takže nemají žádné společné tečny
@msg The paths overlap, so they have no internal tangents Cesty se překrývají, takže nemají žádné vnitřní tečny
@msg One path lies inside the other, so they have no internal tangents Jedna cesta leží uvnitř druhé, takže nemají žádné vnitřní tečny
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Rozložit čárky na cesty
@msg select paths with dashed strokes to expand vyberte cesty s čárkovaným tahem k rozložení
@@ -7876,6 +7898,8 @@ breakText Glyphs Glyfy
@msg No bridge of this width fits across the selected art Přes vybranou kresbu se nevejde žádný můstek této šířky
@msg Some islands could not be joined to the area around the art Některé ostrůvky nebylo možné připojit k oblasti kolem kresby
@msg `width` must be from {lo} to {hi} pt `width` musí být od {lo} do {hi} pt
@msg `angle` must be from -180 to 180 degrees `angle` musí být od -180 do 180 stupňů
@msg `roundness` must be from 1 to 100% `roundness` musí být od 1 do 100 %
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} `count` musí být celé číslo od 1 do {MAX_BRIDGES_PER_ISLAND}
Weed Box and Lines… Rámeček a linie pro vybírání…
Weed Box and Lines Rámeček a linie pro vybírání
Can't render this file because it is too large.
+24
View File
@@ -706,6 +706,8 @@ liquify-list-end {0}, {1} {0} og {1}
@msg No bridge of this width fits across the selected art Ingen bro med denne bredde passer hen over den markerede grafik
@msg Some islands could not be joined to the area around the art Nogle øer kunne ikke forbindes med området omkring grafikken
@msg `width` must be from {lo} to {hi} pt `width` skal være fra {lo} til {hi} pt
@msg `angle` must be from -180 to 180 degrees `angle` skal være fra -180 til 180 grader
@msg `roundness` must be from 1 to 100% `roundness` skal være fra 1 til 100 %
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} `count` skal være et heltal fra 1 til {MAX_BRIDGES_PER_ISLAND}
File Filer
@@ -4023,6 +4025,8 @@ lighting Light Lys
Lasso Tool Lassoværktøj
Enclosing Lasso Tool Omsluttende lassoværktøj
Enclosing Lasso Omsluttende lasso
Polygonal Lasso Tool Polygonlassoværktøj
Polygonal Lasso Polygonlasso
Lasso Lasso
Line Cut Tool Linjeskæringsværktøj
Line Graph Tool Linjediagramværktøj
@@ -5467,6 +5471,9 @@ digits Malayalam Malayalam
Show smooth color wheel Vis glat farvehjul
Show segmented color wheel Vis segmenteret farvehjul
Show color bars Vis farvebjælker
Add Color Tool Værktøjet Tilføj farve
Remove Color Tool Værktøjet Fjern farve
Remove Color Fjern farve
Find the selected colors in the artwork Find de valgte farver i grafikken
Harmony Rules Harmoniregler
Keep this row's colors (exclude) Behold farverne i denne række (ekskludér)
@@ -6144,6 +6151,7 @@ theme Appearance Udseende
Connect Data Points Forbind datapunkter
Edge-to-Edge Lines Linjer fra kant til kant
Draw Filled Lines Tegn udfyldte linjer
Line Width Linjebredde
Tick Values Afmærkningsværdier
Override Calculated Values Tilsidesæt beregnede værdier
Divisions Inddelinger
@@ -9512,6 +9520,22 @@ breakText Glyphs Glyffer
Remove Gaps Fjern mellemrum
@msg that makes too many pieces (at most 100000): make the dashes longer det giver for mange stykker (højst 100000): gør stregerne længere
@msg select paths, or segments, to divide vælg stier eller segmenter, der skal opdeles
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Fælles tangenter…
Common Tangents Fælles tangenter
Tangents Tangenter
Centerline Midterlinje
External Ydre
Internal Indre
@msg select two closed paths vælg to lukkede stier
@msg a selected path is open en valgt sti er åben
@msg a selected path is not convex en valgt sti er ikke konveks
@msg a selected path has no area en valgt sti har intet areal
@msg a selected path has more than 10000 segments en valgt sti har mere end 10000 segmenter
@msg the two paths have the same outline de to stier har samme omrids
@msg One path lies inside the other, so they have no common tangents Den ene sti ligger inden i den anden, så de har ingen fælles tangenter
@msg The paths overlap, so they have no internal tangents Stierne overlapper, så de har ingen indre tangenter
@msg One path lies inside the other, so they have no internal tangents Den ene sti ligger inden i den anden, så de har ingen indre tangenter
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Udvid streger til stier
@msg select paths with dashed strokes to expand vælg stier med stiplet streg, der skal udvides
Can't render this file because it is too large.
+24
View File
@@ -1464,6 +1464,7 @@ file-filter Templates Vorlagen
Connect Data Points Datenpunkte verbinden
Edge-to-Edge Lines Linien von Kante zu Kante
Draw Filled Lines Gefüllte Linien zeichnen
Line Width Linienbreite
Tick Values Teilstrichwerte
Override Calculated Values Berechnete Werte überschreiben
Divisions Teilungen
@@ -1562,6 +1563,9 @@ file-filter Templates Vorlagen
Show smooth color wheel Stufenlosen Farbkreis anzeigen
Show segmented color wheel Segmentierten Farbkreis anzeigen
Show color bars Farbbalken anzeigen
Add Color Tool Farbe-hinzufügen-Werkzeug
Remove Color Tool Farbe-entfernen-Werkzeug
Remove Color Farbe entfernen
Find the selected colors in the artwork Ausgewählte Farben in der Grafik finden
Harmony Sets Harmoniesätze
Height Höhe
@@ -1910,6 +1914,8 @@ file-filter Templates Vorlagen
Lasso Tool Lasso-Werkzeug
Enclosing Lasso Tool Umschließendes Lasso-Werkzeug
Enclosing Lasso Umschließendes Lasso
Polygonal Lasso Tool Polygon-Lasso-Werkzeug
Polygonal Lasso Polygon-Lasso
Last Effect: {name} Letzter Effekt: {name}
Last Effect: {} Letzter Effekt: {}
Last Effect… Letzter Effekt…
@@ -7050,6 +7056,22 @@ breakText Glyphs Glyphen
Remove Gaps Lücken entfernen
@msg that makes too many pieces (at most 100000): make the dashes longer das ergibt zu viele Teile (höchstens 100000): machen Sie die Striche länger
@msg select paths, or segments, to divide wählen Sie Pfade oder Segmente zum Aufteilen aus
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Gemeinsame Tangenten…
Common Tangents Gemeinsame Tangenten
Tangents Tangenten
Centerline Mittellinie
External Äußere
Internal Innere
@msg select two closed paths wählen Sie zwei geschlossene Pfade aus
@msg a selected path is open ein ausgewählter Pfad ist offen
@msg a selected path is not convex ein ausgewählter Pfad ist nicht konvex
@msg a selected path has no area ein ausgewählter Pfad hat keine Fläche
@msg a selected path has more than 10000 segments ein ausgewählter Pfad hat mehr als 10000 Segmente
@msg the two paths have the same outline die beiden Pfade haben denselben Umriss
@msg One path lies inside the other, so they have no common tangents Ein Pfad liegt im anderen, daher haben sie keine gemeinsamen Tangenten
@msg The paths overlap, so they have no internal tangents Die Pfade überlappen sich, daher haben sie keine inneren Tangenten
@msg One path lies inside the other, so they have no internal tangents Ein Pfad liegt im anderen, daher haben sie keine inneren Tangenten
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Striche in Pfade umwandeln
@msg select paths with dashed strokes to expand wählen Sie Pfade mit gestrichelter Kontur zum Umwandeln aus
@@ -7351,6 +7373,8 @@ breakText Glyphs Glyphen
@msg No bridge of this width fits across the selected art Kein Steg dieser Breite passt über das ausgewählte Bildmaterial
@msg Some islands could not be joined to the area around the art Einige Inseln konnten nicht mit der Fläche um das Bildmaterial verbunden werden
@msg `width` must be from {lo} to {hi} pt `width` muss zwischen {lo} und {hi} pt liegen
@msg `angle` must be from -180 to 180 degrees `angle` muss zwischen -180 und 180 Grad liegen
@msg `roundness` must be from 1 to 100% `roundness` muss zwischen 1 und 100 % liegen
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} `count` muss eine ganze Zahl von 1 bis {MAX_BRIDGES_PER_ISLAND} sein
Weed Box and Lines… Entgitterrahmen und -linien…
Weed Box and Lines Entgitterrahmen und -linien
Can't render this file because it is too large.
+24
View File
@@ -1396,6 +1396,7 @@ font-technology Variable Μεταβλητές
Connect Data Points Σύνδεση σημείων δεδομένων
Edge-to-Edge Lines Γραμμές από άκρη σε άκρη
Draw Filled Lines Σχεδίαση γεμισμένων γραμμών
Line Width Πλάτος γραμμής
Tick Values Τιμές υποδιαιρέσεων
Override Calculated Values Αντικατάσταση υπολογισμένων τιμών
Divisions Διαιρέσεις
@@ -1494,6 +1495,9 @@ font-technology Variable Μεταβλητές
Show smooth color wheel Εμφάνιση ομαλού χρωματικού τροχού
Show segmented color wheel Εμφάνιση τμηματοποιημένου χρωματικού τροχού
Show color bars Εμφάνιση χρωματικών ράβδων
Add Color Tool Εργαλείο προσθήκης χρώματος
Remove Color Tool Εργαλείο αφαίρεσης χρώματος
Remove Color Αφαίρεση χρώματος
Find the selected colors in the artwork Εύρεση των επιλεγμένων χρωμάτων στο σχέδιο
Harmony Sets Σύνολα χρωματικής αρμονίας
Height Ύψος
@@ -1814,6 +1818,8 @@ font-technology Variable Μεταβλητές
Lasso Tool Λάσο (Lasso Tool)
Enclosing Lasso Tool Εργαλείο περικλείοντος λάσου
Enclosing Lasso Περικλείον λάσο
Polygonal Lasso Tool Εργαλείο πολυγωνικού λάσου
Polygonal Lasso Πολυγωνικό λάσο
Last Effect: {name} Τελευταίο εφέ: {name}
Last Effect: {} Τελευταίο εφέ: {}
Last Effect… Τελευταίο εφέ…
@@ -7441,6 +7447,22 @@ breakText Glyphs Γλύφοι
Remove Gaps Αφαίρεση κενών
@msg that makes too many pieces (at most 100000): make the dashes longer αυτό δίνει πάρα πολλά κομμάτια (το πολύ 100000): κάντε τις παύλες μεγαλύτερες
@msg select paths, or segments, to divide επιλέξτε διαδρομές ή τμήματα για διαίρεση
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Κοινές εφαπτόμενες…
Common Tangents Κοινές εφαπτόμενες
Tangents Εφαπτόμενες
Centerline Κεντρική γραμμή
External Εξωτερικές
Internal Εσωτερικές
@msg select two closed paths επιλέξτε δύο κλειστές διαδρομές
@msg a selected path is open μια επιλεγμένη διαδρομή είναι ανοιχτή
@msg a selected path is not convex μια επιλεγμένη διαδρομή δεν είναι κυρτή
@msg a selected path has no area μια επιλεγμένη διαδρομή δεν έχει εμβαδόν
@msg a selected path has more than 10000 segments μια επιλεγμένη διαδρομή έχει περισσότερα από 10000 τμήματα
@msg the two paths have the same outline οι δύο διαδρομές έχουν το ίδιο περίγραμμα
@msg One path lies inside the other, so they have no common tangents Η μία διαδρομή βρίσκεται μέσα στην άλλη, επομένως δεν έχουν κοινές εφαπτόμενες
@msg The paths overlap, so they have no internal tangents Οι διαδρομές επικαλύπτονται, επομένως δεν έχουν εσωτερικές εφαπτόμενες
@msg One path lies inside the other, so they have no internal tangents Η μία διαδρομή βρίσκεται μέσα στην άλλη, επομένως δεν έχουν εσωτερικές εφαπτόμενες
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Επέκταση παυλών σε διαδρομές
@msg select paths with dashed strokes to expand επιλέξτε διαδρομές με διακεκομμένο περίγραμμα για επέκταση
@@ -7755,6 +7777,8 @@ breakText Glyphs Γλύφοι
@msg No bridge of this width fits across the selected art Καμία γέφυρα αυτού του πλάτους δεν χωράει στο επιλεγμένο γραφικό
@msg Some islands could not be joined to the area around the art Ορισμένες νησίδες δεν ήταν δυνατό να συνδεθούν με την περιοχή γύρω από το γραφικό
@msg `width` must be from {lo} to {hi} pt Το `width` πρέπει να είναι από {lo} έως {hi} pt
@msg `angle` must be from -180 to 180 degrees Το `angle` πρέπει να είναι από -180 έως 180 μοίρες
@msg `roundness` must be from 1 to 100% Το `roundness` πρέπει να είναι από 1 έως 100%
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} Το `count` πρέπει να είναι ακέραιος από 1 έως {MAX_BRIDGES_PER_ISLAND}
Weed Box and Lines… Πλαίσιο και γραμμές αφαίρεσης περισσευμάτων…
Weed Box and Lines Πλαίσιο και γραμμές αφαίρεσης περισσευμάτων
Can't render this file because it is too large.
+24
View File
@@ -1479,6 +1479,7 @@ font-technology Variable Variables
Connect Data Points Conectar puntos de datos
Edge-to-Edge Lines Líneas de borde a borde
Draw Filled Lines Dibujar líneas rellenas
Line Width Ancho de línea
Tick Values Valores de marcas
Override Calculated Values Sustituir valores calculados
Divisions Divisiones
@@ -1577,6 +1578,9 @@ font-technology Variable Variables
Show smooth color wheel Mostrar rueda de color continua
Show segmented color wheel Mostrar rueda de color segmentada
Show color bars Mostrar barras de color
Add Color Tool Herramienta Añadir color
Remove Color Tool Herramienta Eliminar color
Remove Color Eliminar color
Find the selected colors in the artwork Buscar los colores seleccionados en la ilustración
Harmony Sets Conjuntos de armonía
Height Altura
@@ -1911,6 +1915,8 @@ font-technology Variable Variables
Lasso Tool Herramienta Lazo
Enclosing Lasso Tool Herramienta Lazo envolvente
Enclosing Lasso Lazo envolvente
Polygonal Lasso Tool Herramienta Lazo poligonal
Polygonal Lasso Lazo poligonal
Last Effect: {name} Último efecto: {name}
Last Effect: {} Último efecto: {}
Last Effect… Último efecto…
@@ -7429,6 +7435,22 @@ breakText Glyphs Glifos
Remove Gaps Quitar separaciones
@msg that makes too many pieces (at most 100000): make the dashes longer eso da demasiados trozos (como máximo 100000): alargue los guiones
@msg select paths, or segments, to divide seleccione trazados o segmentos para dividir
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Tangentes comunes…
Common Tangents Tangentes comunes
Tangents Tangentes
Centerline Línea central
External Externas
Internal Internas
@msg select two closed paths seleccione dos trazados cerrados
@msg a selected path is open un trazado seleccionado está abierto
@msg a selected path is not convex un trazado seleccionado no es convexo
@msg a selected path has no area un trazado seleccionado no tiene área
@msg a selected path has more than 10000 segments un trazado seleccionado tiene más de 10000 segmentos
@msg the two paths have the same outline los dos trazados tienen el mismo contorno
@msg One path lies inside the other, so they have no common tangents Un trazado está dentro del otro, por lo que no tienen tangentes comunes
@msg The paths overlap, so they have no internal tangents Los trazados se superponen, por lo que no tienen tangentes internas
@msg One path lies inside the other, so they have no internal tangents Un trazado está dentro del otro, por lo que no tienen tangentes internas
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Expandir guiones en trazados
@msg select paths with dashed strokes to expand seleccione trazados con trazo discontinuo para expandir
@@ -7859,6 +7881,8 @@ breakText Glyphs Glifos
@msg No bridge of this width fits across the selected art Ningún puente de este ancho cabe en la ilustración seleccionada
@msg Some islands could not be joined to the area around the art Algunas islas no se pudieron unir al área que rodea la ilustración
@msg `width` must be from {lo} to {hi} pt `width` debe estar entre {lo} y {hi} pt
@msg `angle` must be from -180 to 180 degrees `angle` debe estar entre -180 y 180 grados
@msg `roundness` must be from 1 to 100% `roundness` debe estar entre 1 y 100 %
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} `count` debe ser un número entero entre 1 y {MAX_BRIDGES_PER_ISLAND}
Weed Box and Lines… Caja y líneas de pelado…
Weed Box and Lines Caja y líneas de pelado
Can't render this file because it contains an unexpected character in line 2 and column 73.
+24
View File
@@ -1424,6 +1424,8 @@ lighting Light Valo
Lasso Tool Lassotyökalu
Enclosing Lasso Tool Sulkeva lassotyökalu
Enclosing Lasso Sulkeva lasso
Polygonal Lasso Tool Monikulmiolassotyökalu
Polygonal Lasso Monikulmiolasso
Lasso Lasso
Line Cut Tool Viivaleikkaustyökalu
Line Graph Tool Viivakaaviotyökalu
@@ -2963,6 +2965,9 @@ digits Malayalam Malajalam
Show smooth color wheel Näytä liukuva väriympyrä
Show segmented color wheel Näytä segmentoitu väriympyrä
Show color bars Näytä väripalkit
Add Color Tool Lisää väri -työkalu
Remove Color Tool Poista väri -työkalu
Remove Color Poista väri
Find the selected colors in the artwork Etsi valitut värit kuvituksesta
Harmony Rules Harmoniasäännöt
Keep this row's colors (exclude) Säilytä tämän rivin värit (jätä pois)
@@ -3685,6 +3690,7 @@ theme Appearance Ulkoasu
Connect Data Points Yhdistä arvopisteet
Edge-to-Edge Lines Viivat reunasta reunaan
Draw Filled Lines Piirrä täytetyt viivat
Line Width Viivan leveys
Tick Values Asteikon arvot
Override Calculated Values Ohita lasketut arvot
Divisions Jaot
@@ -7517,6 +7523,22 @@ breakText Glyphs Merkit
Remove Gaps Poista välit
@msg that makes too many pieces (at most 100000): make the dashes longer siitä tulee liian monta osaa (enintään 100000): pidennä viivoja
@msg select paths, or segments, to divide valitse jaettavat polut tai segmentit
# Path Precision Tools add-on: Common Tangents.
Common Tangents… Yhteiset tangentit…
Common Tangents Yhteiset tangentit
Tangents Tangentit
Centerline Keskilinja
External Ulkoiset
Internal Sisäiset
@msg select two closed paths valitse kaksi suljettua polkua
@msg a selected path is open valittu polku on avoin
@msg a selected path is not convex valittu polku ei ole kupera
@msg a selected path has no area valitulla polulla ei ole pinta-alaa
@msg a selected path has more than 10000 segments valitussa polussa on yli 10000 segmenttiä
@msg the two paths have the same outline kahdella polulla on sama ääriviiva
@msg One path lies inside the other, so they have no common tangents Toinen polku on toisen sisällä, joten niillä ei ole yhteisiä tangentteja
@msg The paths overlap, so they have no internal tangents Polut ovat päällekkäin, joten niillä ei ole sisäisiä tangentteja
@msg One path lies inside the other, so they have no internal tangents Toinen polku on toisen sisällä, joten niillä ei ole sisäisiä tangentteja
# Path Precision Tools add-on: Expand Dashes into Paths.
Expand Dashes into Paths Laajenna viivat poluiksi
@msg select paths with dashed strokes to expand valitse laajennettavat polut, joissa on katkoviiva
@@ -7836,6 +7858,8 @@ breakText Glyphs Merkit
@msg No bridge of this width fits across the selected art Näin leveä silta ei mahdu valitun grafiikan poikki
@msg Some islands could not be joined to the area around the art Joitakin saarekkeita ei voitu yhdistää grafiikkaa ympäröivään alueeseen
@msg `width` must be from {lo} to {hi} pt `width`-arvon on oltava {lo}–{hi} pt
@msg `angle` must be from -180 to 180 degrees `angle`-arvon on oltava -180–180 astetta
@msg `roundness` must be from 1 to 100% `roundness`-arvon on oltava 1–100 %
@msg `count` must be a whole number from 1 to {MAX_BRIDGES_PER_ISLAND} `count` on oltava kokonaisluku 1–{MAX_BRIDGES_PER_ISLAND}
Weed Box and Lines… Karsintakehys ja -viivat…
Weed Box and Lines Karsintakehys ja -viivat
Can't render this file because it contains an unexpected character in line 2 and column 73.
File diff suppressed because it is too large. Load diff
+22
View File
@@ -1586,6 +1586,7 @@
Connect Data Points ડેટા પોઇન્ટ જોડો
Edge-to-Edge Lines કિનારીથી કિનારી સુધી રેખાઓ
Draw Filled Lines ભરેલી રેખાઓ દોરો
Line Width રેખાની પહોળાઈ
Tick Values ટિક મૂલ્યો
Override Calculated Values ગણતરી કરેલાં મૂલ્યો બદલો
Divisions વિભાગો
@@ -2743,6 +2744,8 @@
Polygon બહુકોણ
Polygon Properties: બહુકોણના ગુણધર્મો:
Polygon Tool બહુકોણ ટૂલ
Polygonal Lasso બહુકોણીય લાસો
Polygonal Lasso Tool બહુકોણીય લાસો ટૂલ
Portrait પોટ્રેટ
Portuguese પોર્ટુગીઝ
Position સ્થિતિ
@@ -3001,6 +3004,22 @@
Remove Effect ઇફેક્ટ દૂર કરો
Remove Effects ઇફેક્ટ્સ દૂર કરો
Remove Gaps ગેપ દૂર કરો
# Path Precision Tools add-on: Common Tangents.
Common Tangents… સામાન્ય સ્પર્શરેખાઓ…
Common Tangents સામાન્ય સ્પર્શરેખાઓ
Tangents સ્પર્શરેખાઓ
Centerline કેન્દ્ર રેખા
External બાહ્ય
Internal આંતરિક
@msg select two closed paths બે બંધ પાથ પસંદ કરો
@msg a selected path is open પસંદ કરેલો એક પાથ ખુલ્લો છે
@msg a selected path is not convex પસંદ કરેલો એક પાથ બહિર્ગોળ નથી
@msg a selected path has no area પસંદ કરેલા એક પાથનું કોઈ ક્ષેત્રફળ નથી
@msg a selected path has more than 10000 segments પસંદ કરેલા એક પાથમાં 10000 થી વધુ ખંડ છે
@msg the two paths have the same outline બંને પાથની રૂપરેખા સમાન છે
@msg One path lies inside the other, so they have no common tangents એક પાથ બીજાની અંદર છે, તેથી તેમની કોઈ સામાન્ય સ્પર્શરેખા નથી
@msg The paths overlap, so they have no internal tangents પાથ એકબીજા પર ચઢેલા છે, તેથી તેમની કોઈ આંતરિક સ્પર્શરેખા નથી
@msg One path lies inside the other, so they have no internal tangents એક પાથ બીજાની અંદર છે, તેથી તેમની કોઈ આંતરિક સ્પર્શરેખા નથી
Remove Guide ગાઇડ દૂર કરો
Remove Item આઇટમ દૂર કરો
Remove JavaScript File JavaScript ફાઇલ દૂર કરો
@@ -3597,6 +3616,9 @@
Show all plates બધી પ્લેટ બતાવો
Show axis અક્ષ બતાવો
Show color bars રંગ બાર બતાવો
Add Color Tool રંગ ઉમેરો સાધન
Remove Color Tool રંગ દૂર કરો સાધન
Remove Color રંગ દૂર કરો
Find the selected colors in the artwork પસંદ કરેલા રંગો આર્ટવર્કમાં શોધો
Show handles when multiple anchors are selected બહુવિધ એન્કર પસંદ હોય ત્યારે હૅન્ડલ બતાવો
Show in Folder ફોલ્ડરમાં બતાવો
Can't render this file because it contains an unexpected character in line 72 and column 5.
Loaded 100 of 133 files, more files were not shown because too many files have changed in this diff. Show more