Merge main into feat/kurikaeshi-moji-shori

This commit is contained in:
dotCooCoo
2026-11-15 11:59:36 -08:00
163 changed files with 8268 additions and 404 deletions
+1
View File
@@ -133,6 +133,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
- 2026-11-14: Nest Shapes in the Cutting Tools add-on (Object › Plug-ins › Cutting Tools): the selected objects move close together onto an artboard, a sheet of a set size or a roll of a set width, packed by their bounding boxes with a margin inside the edges and a spacing between them, optionally turning objects 90° to fit; objects that do not fit go in a column beside the sheet; a dialog with Preview, one undo step (`addon.cutting.nest`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-05: Release Type on a Path joins the Type Tools add-on (Object › Plug-ins › Type Tools): each selected type on a path splits into point type with the same text and attributes, on one straight line starting where its first character sat, and the plain path it was set on, with its exact shape and place in the stacking order and no paint; or keeps only the path or only the text, optionally leaving the original. A dialog with Preview, one undo step (`addon.type.releasePath`, #5532). A VectorCraft addition: headline numbers unchanged.
- 2026-11-04: New Document: the units chosen in Preset Details now belong to the chosen document, as the pane's options are listed for the selected preset; the chosen card shows them, every other Recent and Saved card keeps the units its document or preset was made in, and the built-in tabs still follow the chosen units, so switching between inches and millimetres no longer restyles every recent template. Scores and estimates unchanged.
- 2026-11-14: Packaging Tools add-on (Object › Plug-ins › Packaging Tools): fold line roles for dielines (Cut, Crease, Partial Cut, Perforation), each carried by the swatch on a path's top stroke through a per-document role table that native files keep; PDF prints a role line on its swatch's separation when that swatch is a spot color, as the default role swatches are, and SVG, DXF and HP-GL keep the stroke's color. Make Cut Line, Make Crease Line, Make Partial Cut Line and Make Perforation Line give the selected paths a role, overprinting by default, and make a missing role swatch; the Fold Lines panel counts each role in the selection or the document, and its Role Swatches… picks another swatch for a role (`addon.packaging.setRole`, `addon.packaging.roles`, `addon.packaging.setRoleSwatch`). A VectorCraft addition: headline numbers unchanged.
- 2026-11-02: Mouse wheel over a closed font-family field in Character, Properties or Control changes selected text through the family list using saved font filters (excluding search text), one undo step per notch, stopping at the ends (#5253). Scores and estimates unchanged.
- 2026-10-31: Pattern libraries: Window › Swatch Libraries › Patterns and the Swatches panel's library menu open Geometric Patterns, a built-in library of eleven pattern swatches (dots, stripes, checks, a grid and shapes); clicking one adds its pattern and swatch to the document, once, and applies it to the active fill or stroke (`swatch.library.add`).
- 2026-11-11: Pattern libraries: Patterns › Grit Textures, a second built-in pattern library, holds eight seamless black textures (Fine Grain, Coarse Grit, Sand, Speckle, Stipple, Scratches, Sparse Flecks and Dense Flecks) on tiles of 18 to 36 pt, each drawn the same way every time; marks that reach past a tile edge continue on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
+17 -3
View File
@@ -664,9 +664,6 @@ pub fn jpeg_with_icc(bytes: &[u8], icc: &[u8]) -> Option<Vec<u8>> {
const CHUNK: usize = 0xFFFF - 2 - ICC_SEGMENT.len() - 2;
let chunks: Vec<&[u8]> = icc.chunks(CHUNK).collect();
let count = u8::try_from(chunks.len()).ok().filter(|n| *n > 0)?;
if !bytes.starts_with(&[0xFF, 0xD8]) {
return None;
}
let mut segments = Vec::with_capacity(icc.len() + 18 * chunks.len());
for (i, chunk) in chunks.iter().enumerate() {
let len = u16::try_from(chunk.len() + 2 + ICC_SEGMENT.len() + 2).ok()?;
@@ -676,6 +673,23 @@ pub fn jpeg_with_icc(bytes: &[u8], icc: &[u8]) -> Option<Vec<u8>> {
segments.extend_from_slice(&[u8::try_from(i + 1).ok()?, count]);
segments.extend_from_slice(chunk);
}
with_icc_segments(bytes, segments)
}
/// JPEG `bytes` without the ICC profile they carry: every `ICC_PROFILE` APP2 segment before the
/// scan taken out, and the other segments and the scan as they are. `None` for bytes whose
/// segments before the scan can't be read.
pub fn jpeg_without_icc(bytes: &[u8]) -> Option<Vec<u8>> {
with_icc_segments(bytes, vec![])
}
/// JPEG `bytes` with every `ICC_PROFILE` APP2 segment before the scan taken out and `segments`
/// written after the leading application segments; `None` when the bytes don't start a JPEG or
/// their segments before the scan can't be read.
fn with_icc_segments(bytes: &[u8], segments: Vec<u8>) -> Option<Vec<u8>> {
if !bytes.starts_with(&[0xFF, 0xD8]) {
return None;
}
let mut out = Vec::with_capacity(bytes.len() + segments.len());
out.extend_from_slice(&[0xFF, 0xD8]);
let mut icc_segments = Some(segments);
+39 -4
View File
@@ -1121,10 +1121,12 @@ fn on_type_path(n: &Node, t: &crate::TextObject, p: Point, tol: f64) -> bool {
stroke_contains(&path.to_bezpath(), 0.0, tol, p)
}
/// Hit anywhere in an evaluated subtree (groups recurse; leaves use [`hit_leaf`]).
/// Hit anywhere in an evaluated subtree (groups recurse; leaves use [`hit_leaf`]). In symbol art
/// placed by [`FindPart`], each object visited takes one object of the [`ArtWalk`] limit, and
/// nothing more is tested once the limit is used up.
fn hit_any(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Option<HitKind> {
// Hidden art does not hit.
if !n.visible {
if !n.visible || ArtWalk::charged() && !ArtWalk::take(1) {
return None;
}
// Nor art whose reach does not hold `p`, as in [`may_hit`]: a blend's steps far from `p` are
@@ -1257,8 +1259,12 @@ struct FindPart<'a> {
}
impl FindPart<'_> {
/// What a click at `p` hits on object `n` of the art, placed. [`hit_any`] takes `n` and each
/// object it visits inside `n` from the [`ArtWalk`] limit.
fn hit(&self, n: &Node, whole: Option<vectorcraft_geom::Affine>, opt: HitOptions) -> Option<HitKind> {
self.art.place(n, whole).and_then(|n| hit_any(&n, self.p, opt, self.symbols))
let placed = self.art.place(n, whole)?;
let _charged = ArtWalk::charge();
hit_any(&placed, self.p, opt, self.symbols)
}
fn skips_guide(&self, n: &Node) -> bool {
@@ -1268,7 +1274,7 @@ impl FindPart<'_> {
/// What a click at `p` hits on object `n` of the art, with `path` the child indices that lead
/// to what it hits. `outline`: the view is in Outline, or a layer around `n` has Preview off.
fn find(&self, n: &Node, path: &mut Vec<u32>, whole: Option<vectorcraft_geom::Affine>, outline: bool) -> Option<HitKind> {
if !n.visible || !self.whole_instance && (n.locked || n.is_template()) || self.skips_guide(n) || !ArtWalk::take(1) {
if !n.visible || !self.whole_instance && (n.locked || n.is_template()) || self.skips_guide(n) || ArtWalk::used_up() {
return None;
}
let outline = outline || previews_off(n);
@@ -1277,6 +1283,9 @@ impl FindPart<'_> {
if path.len() >= crate::symbol_overrides::MAX_PATH_DEPTH {
return self.hit(n, whole, opt);
}
if !ArtWalk::take(1) {
return None;
}
let whole = self.art.whole(n, whole);
if n.clips()
&& let Some(first) = children.first()
@@ -1370,6 +1379,8 @@ thread_local! {
/// How many more objects of symbol art the click or marquee under way may visit ([`ArtWalk`]),
/// `None` outside one.
static ART_WALK_LEFT: std::cell::Cell<Option<u64>> = const { std::cell::Cell::new(None) };
/// Whether [`hit_any`] is testing symbol art that [`FindPart`] placed ([`ArtWalk::charge`]).
static ART_WALK_CHARGED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
#[cfg(test)]
@@ -1420,6 +1431,19 @@ impl ArtWalk {
ART_WALK_LEFT.set(Some(rest.unwrap_or(0)));
rest.is_some()
}
/// While the guard lives, each object [`hit_any`] visits takes one object from what is left:
/// [`FindPart`] holds one while it tests a placed object of symbol art, so that the members of an
/// Intertwine group, and the objects of groups nested deeper than
/// [`crate::symbol_overrides::MAX_PATH_DEPTH`], count toward the limit.
fn charge() -> ArtWalkCharge {
ArtWalkCharge { was: ART_WALK_CHARGED.replace(true) }
}
/// Does [`hit_any`] take the objects it visits from what is left ([`Self::charge`])?
fn charged() -> bool {
ART_WALK_CHARGED.get()
}
}
impl Drop for ArtWalk {
@@ -1430,6 +1454,17 @@ impl Drop for ArtWalk {
}
}
/// The guard of [`ArtWalk::charge`].
struct ArtWalkCharge {
was: bool,
}
impl Drop for ArtWalkCharge {
fn drop(&mut self) {
ART_WALK_CHARGED.set(self.was);
}
}
/// Is `n` below a layer whose Preview is off, so that the canvas draws it in outline? As for clicks
/// ([`path_options`]), the Preview of the isolated container `scope` and of the layers around it
/// does not count.
+31
View File
@@ -2140,6 +2140,37 @@ fn a_click_and_a_marquee_walk_repeated_nested_symbol_instances_within_one_limit(
assert_eq!(with_art_limit(100, || marquee(&d, edge, None, false)).0, [inst], "marquee across the art's edge");
}
/// The members of an Intertwine group in symbol art count toward the art walk's limit of objects
/// for a click, as the members of a plain group do. A click on a member's path past the instance's
/// box is still found within the limit.
#[test]
fn a_click_counts_the_members_of_an_intertwine_group_in_symbol_art_toward_one_limit() {
set_clip_region(moved_clip_region);
// A clip group whose clipping region `test.move` moves to 100..200 × 0..100, past the 0..100
// box, over an Intertwine group of 200 squares at 140..160 × 40..60.
let mut d = Document::new(600.0, 400.0);
let l = d.layers[0].id;
let (mut mask, _) = half_clipped(&mut d);
mask.appearance.effects.push(test_move());
let squares = (0..200)
.map(|_| Arc::new(Node::path(d.alloc_id(), shapes::rectangle(Rect::new(140.0, 40.0, 160.0, 60.0)), Appearance::default_art())))
.collect();
let woven = Arc::new(Node::new(d.alloc_id(), NodeKind::Intertwine { children: squares }));
let mut clip = Node::group(d.alloc_id(), vec![Arc::new(mask), woven]);
clip.set_clips(true);
group_symbol(&mut d, "Woven", vec![Arc::new(clip)]);
let inst = instance_of(&mut d, "Woven");
let id = inst.id;
d.insert(Some(l), 0, Arc::unwrap_or_clone(inst)).unwrap();
let opt = HitOptions { path_only: true, ..HitOptions::default() };
let at = |x: f64| hit_test(&d, Point::new(x, 50.0), opt).map(|h| h.leaf);
// Inside the squares and away from their paths, every member is tested and none is hit.
let (hit, leaves, _) = with_art_limit(100, || at(150.0));
assert_eq!(hit, None);
assert!(leaves <= 100, "{leaves} leaves tested");
assert_eq!(with_art_limit(100, || at(140.0)).0, Some(id), "on the squares' paths");
}
/// In a dynamic symbol's art that placing through its 9-slice guides could make more than
/// [`crate::MAX_SYMBOL_NODES`] objects of, Direct Selection picks and outlines nothing, as the
/// canvas draws nothing of it. At the art's natural size the same art is picked.
+2 -2
View File
@@ -18,8 +18,8 @@ mod wrap;
pub use area::{AreaFit, AreaOptions, PathAlign, PathEffect, TextFlow, TextWrap, VerticalAlign, WrapShape};
use char_style::yes;
pub use char_style::{
CharAlign, CharPosition, CharStyle, Digits, FontHeightReference, GlyphChoice, GlyphForm, MAX_AKI, MAX_TSUME, MAX_WARICHU_GAP, ScriptMetrics,
WARICHU_LINES, WARICHU_SCALE, WarichuAlign,
CharAlign, CharPosition, CharStyle, Digits, FontHeightReference, GlyphChoice, GlyphForm, MAX_AKI, MAX_DIACRITIC_POSITION, MAX_TSUME,
MAX_WARICHU_GAP, ScriptMetrics, WARICHU_LINES, WARICHU_SCALE, WarichuAlign,
};
pub use composite::{
COMPOSITE_BASELINE, COMPOSITE_FONTS_MAX, COMPOSITE_NAME_MAX, COMPOSITE_SCALE, COMPOSITE_SIZE, CUSTOM_CHARS_MAX, CUSTOM_SETS_MAX, CharClass,
+23 -1
View File
@@ -180,6 +180,18 @@ pub struct CharStyle {
/// these characters are drawn in, whatever digits were typed.
#[serde(default, skip_serializing_if = "crate::skip::is_default")]
pub digits: Digits,
/// Adjust Horizontal Diacritic Position (Character panel, Middle Eastern options): the font's
/// mark glyphs among these characters (GDEF class 3, such as Arabic harakat and Hebrew points)
/// move right by a positive value and left by a negative one, relative to their letters, in
/// 1/1000 em of the size, from -[`MAX_DIACRITIC_POSITION`] to [`MAX_DIACRITIC_POSITION`].
/// Saved only when not 0.
/// <https://web.archive.org/web/20210601162814/https://helpx.adobe.com/pdf/illustrator_reference.pdf#page=549>
#[serde(default, rename = "diacriticHorizontal", skip_serializing_if = "crate::skip::is_default")]
pub diacritic_horizontal: f64,
/// Adjust Vertical Diacritic Position: the mark glyphs move up by a positive value and down by
/// a negative one, as [`Self::diacritic_horizontal`] moves them across.
#[serde(default, rename = "diacriticVertical", skip_serializing_if = "crate::skip::is_default")]
pub diacritic_vertical: f64,
/// Font height reference (Character panel menu › Show Font Height Options): the height of the
/// font that [`Self::size`] measures, the em box by default.
#[serde(default, rename = "fontHeightReference", skip_serializing_if = "crate::skip::is_default")]
@@ -553,6 +565,10 @@ pub const MAX_AKI: f64 = 1000.0;
/// The largest Tsume ([`CharStyle::tsume`]), in percent: all the blank space beside the ink.
pub const MAX_TSUME: f64 = 100.0;
/// The largest Adjust Horizontal or Vertical Diacritic Position either way
/// ([`CharStyle::diacritic_horizontal`]), in 1/1000 em: one em.
pub const MAX_DIACRITIC_POSITION: f64 = 1000.0;
/// The number of lines a warichu block may be stacked on ([`CharStyle::warichu_lines`]).
pub const WARICHU_LINES: std::ops::RangeInclusive<u8> = 1..=6;
@@ -684,6 +700,8 @@ impl Default for CharStyle {
warichu_align: WarichuAlign::Auto,
small_caps: None,
digits: Digits::Default,
diacritic_horizontal: 0.0,
diacritic_vertical: 0.0,
font_height_reference: FontHeightReference::EmBox,
no_break: false,
language: None,
@@ -707,7 +725,8 @@ impl CharStyle {
/// same way. The Warichu Settings Lines and Scale
/// are kept to [`WARICHU_LINES`] and [`WARICHU_SCALE`]; a gap or scale that is not a number becomes its default. The gap is kept to 0 to
/// [`crate::MAX_COORD`], as the baseline shift is, since a scaled type object holds it in its
/// own units.
/// own units. The Adjust Horizontal and Vertical Diacritic Positions are kept within
/// [`MAX_DIACRITIC_POSITION`] either way, and one that is not a number becomes 0.
pub fn keep_dimensions_in_range(&mut self) {
let default = Self::default();
let within = |v: f64, or: f64| if v > 0.0 { v.min(crate::MAX_COORD) } else { or };
@@ -723,6 +742,9 @@ impl CharStyle {
self.aki_left = aki(self.aki_left);
self.aki_right = aki(self.aki_right);
self.tsume = if self.tsume.is_nan() { 0.0 } else { self.tsume.clamp(0.0, MAX_TSUME) };
let diacritic = |v: f64| if v.is_nan() { 0.0 } else { v.clamp(-MAX_DIACRITIC_POSITION, MAX_DIACRITIC_POSITION) };
self.diacritic_horizontal = diacritic(self.diacritic_horizontal);
self.diacritic_vertical = diacritic(self.diacritic_vertical);
self.warichu_lines = self.warichu_lines.clamp(*WARICHU_LINES.start(), *WARICHU_LINES.end());
self.warichu_gap = if self.warichu_gap.is_nan() { default.warichu_gap } else { self.warichu_gap.clamp(0.0, crate::MAX_COORD) };
self.warichu_scale =
+4
View File
@@ -512,6 +512,8 @@ impl crate::Document {
st.aki_left = num("akiLeft").unwrap_or(st.aki_left);
st.aki_right = num("akiRight").unwrap_or(st.aki_right);
st.tsume = num("tsume").unwrap_or(st.tsume);
st.diacritic_horizontal = num("diacriticHorizontal").unwrap_or(st.diacritic_horizontal);
st.diacritic_vertical = num("diacriticVertical").unwrap_or(st.diacritic_vertical);
st.warichu_gap = num("warichuGap").unwrap_or(st.warichu_gap);
st.warichu_scale = num("warichuScale").unwrap_or(st.warichu_scale);
st.keep_dimensions_in_range();
@@ -538,6 +540,8 @@ impl crate::Document {
("akiLeft", Some(st.aki_left)),
("akiRight", Some(st.aki_right)),
("tsume", Some(st.tsume)),
("diacriticHorizontal", Some(st.diacritic_horizontal)),
("diacriticVertical", Some(st.diacritic_vertical)),
("leading", st.leading),
];
for (k, v) in kept {
+36
View File
@@ -129,6 +129,42 @@ fn insert_aki_is_saved_only_when_set() {
assert_eq!((d.char_styles[0].attrs["akiLeft"].as_f64(), d.char_styles[0].attrs["akiRight"].as_f64()), (Some(MAX_AKI), Some(0.0)));
}
/// Adjust Horizontal and Vertical Diacritic Position are 0 by default and saved only when not 0,
/// each on its own; styles written before them read as 0, and a value out of range from a file is
/// kept within one em either way.
#[test]
fn diacritic_positions_are_saved_only_when_set() {
let st = CharStyle::default();
assert_eq!((st.diacritic_horizontal, st.diacritic_vertical), (0.0, 0.0));
let saved = serde_json::to_value(&st).unwrap();
assert!(saved.get("diacriticHorizontal").is_none() && saved.get("diacriticVertical").is_none());
for set in [
CharStyle { diacritic_horizontal: -250.0, ..CharStyle::default() },
CharStyle { diacritic_vertical: 500.0, ..CharStyle::default() },
CharStyle { diacritic_horizontal: 12.5, diacritic_vertical: -1000.0, ..CharStyle::default() },
] {
let saved = serde_json::to_value(&set).unwrap();
assert_eq!(saved.get("diacriticHorizontal").and_then(serde_json::Value::as_f64).unwrap_or(0.0), set.diacritic_horizontal);
assert_eq!(saved.get("diacriticVertical").and_then(serde_json::Value::as_f64).unwrap_or(0.0), set.diacritic_vertical);
assert_eq!(saved.get("diacriticHorizontal").is_some(), set.diacritic_horizontal != 0.0);
assert_eq!(saved.get("diacriticVertical").is_some(), set.diacritic_vertical != 0.0);
assert_eq!(serde_json::from_value::<CharStyle>(saved).unwrap(), set);
}
let mut damaged = CharStyle { diacritic_horizontal: -4000.0, diacritic_vertical: 4000.0, ..CharStyle::default() };
damaged.keep_dimensions_in_range();
assert_eq!((damaged.diacritic_horizontal, damaged.diacritic_vertical), (-MAX_DIACRITIC_POSITION, MAX_DIACRITIC_POSITION));
let mut damaged = CharStyle { diacritic_horizontal: f64::NAN, diacritic_vertical: f64::NEG_INFINITY, ..CharStyle::default() };
damaged.keep_dimensions_in_range();
assert_eq!((damaged.diacritic_horizontal, damaged.diacritic_vertical), (0.0, -MAX_DIACRITIC_POSITION));
// A character style from a file is kept in range the same way.
let mut d = crate::Document::new(100.0, 100.0);
let attrs = serde_json::json!({"diacriticHorizontal": 5000, "diacriticVertical": -5000});
d.char_styles.push(TextStyleDef { name: "Moved".into(), attrs: attrs.as_object().cloned().unwrap_or_default() });
d.keep_type_values_in_range();
let kept = |key: &str| d.char_styles[0].attrs[key].as_f64();
assert_eq!((kept("diacriticHorizontal"), kept("diacriticVertical")), (Some(MAX_DIACRITIC_POSITION), Some(-MAX_DIACRITIC_POSITION)));
}
/// Tsume is 0 by default and saved only when not 0; styles written before it read as 0, and a
/// value out of range from a file, in a run or a character style, is kept from 0 to 100.
#[test]
+1 -1
View File
@@ -267,7 +267,7 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
"distort.transform",
"Transform…",
DT,
"{scaleH: % (100), scaleV: % (100), moveH: pt (0; right = +), moveV: pt (0; down = +), rotate: deg (0; counter-clockwise; when the effect turns, reflects or scales the object unevenly, a gradient fitted to the object is fixed to its fit and turns with the object and with each copy), copies: 0..1000 (0; each copy transforms the last again and is painted below it, the object on top; a group's copies each hold all its members, and a group with a member that carries a geometry, Pathfinder or 3D effect copies each member in its place; placed gradients transform with the object and with each copy), reflectX: bool (false; flips left to right), reflectY: bool (false; flips top to bottom), reference: 0..8 (4; the point of the bounds' 9-point grid it scales, rotates and reflects about: 0 top left, 4 centre, 8 bottom right), random: bool (false; each scale goes a random share of the way from 100 % to its value, each move and the angle a random share of theirs, differently for each object and the same on every redraw), objects: bool (true; Transform Objects: off, the geometry stays where it is and makes no copies, and only the two options below apply, once; on, without copies or random, the raster effects listed before this effect (Rasterize and SVG filters excepted) transform with the art whatever strokes says: their sizes scale by the mean scale and a Drop Shadow's offset turns, reflects and scales, while the angles and light directions of pixel filters stay as they are; so do the raster effects of the object's fills and strokes and, on a group, those of its members, of their fills and strokes and of their linked opacity masks' art, after their own Transform effects, including those that a member's own Transform effect with copies or random holds back), patterns: bool (false; Transform Patterns: pattern fills and strokes transform along; with copies the original keeps its pattern and copy k takes the transformation k times), strokes: bool (false; Scale Strokes & Effects: stroke weights and dashes, and the distances of the effects on the fills and strokes, scale by the mean scale √|scaleH·scaleV|, copy k by its k-th power; raster effects that transform with the art are not scaled again; on a fill or stroke, the effects listed after this effect in that fill's or stroke's own list keep their distances and apply to the transformed art, and with objects off so do the effects before it)}",
"{scaleH: % (100), scaleV: % (100), moveH: pt (0; right = +), moveV: pt (0; down = +), rotate: deg (0; counter-clockwise; when the effect turns, reflects or scales the object unevenly, a gradient fitted to the object is fixed to its fit and turns with the object and with each copy), copies: 0..1000 (0; each copy transforms the last again and is painted below it, the object on top; a group's copies each hold all its members, and a group with a member that carries a geometry, Pathfinder or 3D effect copies each member in its place; placed gradients transform with the object and with each copy), reflectX: bool (false; flips left to right), reflectY: bool (false; flips top to bottom), reference: 0..8 (4; the point of the bounds' 9-point grid it scales, rotates and reflects about: 0 top left, 4 centre, 8 bottom right), random: bool (false; each scale goes a random share of the way from 100 % to its value, each move and the angle a random share of theirs, differently for each object and the same on every redraw), objects: bool (true; Transform Objects: off, the geometry stays where it is and makes no copies, and only the two options below apply, once; on, without copies or random, the raster effects listed before this effect (Rasterize and SVG filters excepted) transform with the art whatever strokes says: their sizes scale by the mean scale, a Drop Shadow's offset turns, reflects and scales, a pixel filter's lightDirection or strokeDirection turns and reflects to the nearest choice (at a tie, the one clockwise of it; VectorCraft's own rule), and Color Halftone's channel angles turn and reflect with the art (0 to 360); so do the raster effects of the object's fills and strokes and, on a group, those of its members, of their fills and strokes and of their linked opacity masks' art, after their own Transform effects, including those that a member's own Transform effect with copies or random holds back), patterns: bool (false; Transform Patterns: pattern fills and strokes transform along; with copies the original keeps its pattern and copy k takes the transformation k times), strokes: bool (false; Scale Strokes & Effects: stroke weights and dashes, and the distances of the effects on the fills and strokes, scale by the mean scale √|scaleH·scaleV|, copy k by its k-th power; raster effects that transform with the art are not scaled again; on a fill or stroke, the effects listed after this effect in that fill's or stroke's own list keep their distances and apply to the transformed art, and with objects off so do the effects before it)}",
json!({"scaleH": 100.0, "scaleV": 100.0, "moveH": 0.0, "moveV": 0.0, "rotate": 0.0, "copies": 0, "reflectX": false, "reflectY": false, "reference": 4, "random": false, "objects": true, "patterns": false, "strokes": false}),
),
g(
+5 -1
View File
@@ -853,7 +853,11 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
}
if !fx.is_empty() {
m = crate::reshape::outlined_members(doc, &m);
members_as_drawn(doc, &mut m);
{
// The members' raster effects then follow the group's own Transform effects as well.
let _later = crate::raster::LaterGroups::enter(&n.appearance.effects);
members_as_drawn(doc, &mut m);
}
let carry = crate::reshape::reshape_leaves_carrying(&mut m, &fx, &n.appearance.effects, doc);
// The group's own fills and strokes paint the members as a whole: their gradients follow
// the effects as the members' do.
+113 -2
View File
@@ -29,6 +29,8 @@ mod sketch_ink;
mod texture;
mod video;
use std::f64::consts::{PI, TAU};
use serde_json::Value;
use vectorcraft_geom::{Affine, Point, Rect, Vec2};
@@ -332,6 +334,9 @@ pub struct PixelSpace {
pub extent: f64,
}
/// Color Halftone's screen angle parameters with their defaults (degrees).
const SCREEN_ANGLES: [(&str, f64); 4] = [("channel1", 108.0), ("channel2", 162.0), ("channel3", 90.0), ("channel4", 45.0)];
/// Effect `id`'s parameters `p` (defaults merged in) as a [`PixelFx`]; `None` for other effects.
pub(crate) fn parse(id: &str, p: &Value) -> Option<PixelFx> {
let quality = |levels: [(&str, u32); 3], default: u32| {
@@ -565,8 +570,7 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option<PixelFx> {
},
"pixelate.colorHalftone" => PixelFx::ColorHalftone {
max_radius: num(p, "maxRadius", 8.0).clamp(4.0, 127.0),
angles: [("channel1", 108.0), ("channel2", 162.0), ("channel3", 90.0), ("channel4", 45.0)]
.map(|(k, d)| num(p, k, d).clamp(-360.0, 360.0)),
angles: SCREEN_ANGLES.map(|(k, d)| num(p, k, d).clamp(-360.0, 360.0)),
},
"pixelate.crystallize" => PixelFx::Crystallize { cell: num(p, "cellSize", 10.0).clamp(3.0, 300.0) },
"pixelate.mezzotint" => PixelFx::Mezzotint { kind: Mezzotint::parse(text(p, "type", "fineDots")) },
@@ -855,6 +859,113 @@ fn pick<T: Clone>(table: &[(&str, &str)], all: &[T], value: &str, default: T) ->
table.iter().zip(all).find(|((_, v), _)| v.eq_ignore_ascii_case(value)).map_or(default, |(_, t)| t.clone())
}
/// The shortest that a direction's unit vector may become under a Transform effect and still give
/// a direction ([`turned_directions`]).
const MIN_TURNED: f64 = 1e-9;
/// How close (radians) two directions' angles to a turned direction must be to count as equally
/// near ([`nearest`]).
const TIE: f64 = 1e-9;
/// The parameters of pixel filter `id` (params `p`, defaults not merged in) that set a direction
/// on the page, as `a` turns them: `a` is the linear part of a Transform effect listed after the
/// filter, which turns, reflects and scales what the filter paints. A light direction or stroke
/// direction becomes the one nearest to where `a` takes it, the one clockwise of it when two are
/// equally near ([`snapped`]); `later` is the map the filter still goes through when it is drawn,
/// after `a`. Color Halftone's screen angles (degrees counterclockwise from the page's horizontal)
/// turn with `a`, from 0 up to 360. A direction that `a` takes to no direction (a zero scale) stays
/// as it is. Empty for filters with no such parameter.
pub(crate) fn turned_directions(id: &str, p: &Value, a: Affine, later: Affine) -> Vec<(&'static str, Value)> {
enum Kind {
Light(&'static str),
Stroke,
Screens,
}
let kind = match id {
"sketch.basRelief" => Kind::Light("bottom"),
"artistic.underpainting" | "artistic.roughPastels" | "sketch.conteCrayon" | "sketch.plaster" | "texture.texturizer" => Kind::Light("top"),
"brushStrokes.sprayedStrokes" | "sketch.graphicPen" => Kind::Stroke,
"pixelate.colorHalftone" => Kind::Screens,
_ => return Vec::new(),
};
let p = crate::merged_params(id, p);
match kind {
Kind::Light(default) => {
let light = Light::parse(text(&p, "lightDirection", default));
snapped(&Light::ALL, Light::toward, light, a, later, false)
.and_then(|t| name_of(&LIGHT_DIRECTIONS, &Light::ALL, t))
.map(|name| vec![("lightDirection", Value::from(name))])
.unwrap_or_default()
}
Kind::Stroke => {
let direction = StrokeDirection::parse(text(&p, "strokeDirection", "rightDiagonal"));
snapped(&StrokeDirection::ALL, StrokeDirection::along, direction, a, later, true)
.and_then(|t| name_of(&STROKE_DIRECTIONS, &StrokeDirection::ALL, t))
.map(|name| vec![("strokeDirection", Value::from(name))])
.unwrap_or_default()
}
// A screen at θ° runs along (cos θ, −sin θ) on the page (y down).
Kind::Screens => SCREEN_ANGLES
.iter()
.filter_map(|&(key, default)| {
let t = num(&p, key, default).clamp(-360.0, 360.0).to_radians();
let v = mapped(a, Vec2::new(t.cos(), -t.sin()))?;
let degrees = ((-v.y).atan2(v.x).to_degrees() * 1e6).round() / 1e6;
Some((key, Value::from(degrees.rem_euclid(360.0) + 0.0)))
})
.collect(),
}
}
/// Where the linear part of `a` takes direction `v`; `None` when it takes it to no direction.
fn mapped(a: Affine, v: Vec2) -> Option<Vec2> {
let w = (a * v.to_point()) - (a * Point::ORIGIN);
(w.is_finite() && w.hypot() > MIN_TURNED).then_some(w)
}
/// The entry of `all` to store for `from` (directions `dir`) once `a` turns it: the one nearest to
/// where `a` takes it ([`nearest`]). When the stored entry is still to be mapped by `later` and
/// rounded again as it is drawn, it is the entry nearest to that among those that `later` takes to
/// the entry nearest to where `later` after `a` takes `from`, so that the drawn direction is
/// rounded once. `None` when `a` takes `from` to no direction.
fn snapped<T: Copy + PartialEq>(all: &[T], dir: fn(T) -> Vec2, from: T, a: Affine, later: Affine, axis: bool) -> Option<T> {
let v = mapped(a, dir(from))?;
let turned = nearest(all, dir, v, axis)?;
if later == Affine::IDENTITY {
return Some(turned);
}
let Some(target) = mapped(later * a, dir(from)).and_then(|w| nearest(all, dir, w, axis)) else { return Some(turned) };
let fits: Vec<T> = all.iter().copied().filter(|&t| mapped(later, dir(t)).and_then(|w| nearest(all, dir, w, axis)) == Some(target)).collect();
nearest(&fits, dir, v, axis).or(Some(turned))
}
/// The entry of `all` whose direction (`dir`, page axes with y down) is nearest to `v` by angle,
/// a direction and its opposite counting as the same with `axis`. Of two equally near, the one
/// clockwise of `v` on the page.
fn nearest<T: Copy>(all: &[T], dir: impl Fn(T) -> Vec2, v: Vec2, axis: bool) -> Option<T> {
let period = if axis { PI } else { TAU };
let at = v.atan2();
let mut best: Option<(T, f64)> = None;
for &t in all {
// How far clockwise of `v` the entry lies, within half a period either way.
let d = (dir(t).atan2() - at).rem_euclid(period);
let d = if d > period / 2.0 { d - period } else { d };
let better = match best {
None => true,
Some((_, b)) => d.abs() < b.abs() - TIE || (d.abs() <= b.abs() + TIE && d > b),
};
if better {
best = Some((t, d));
}
}
best.map(|(t, _)| t)
}
/// The value in `table` of entry `t` of `all` (the same order).
fn name_of<T: PartialEq>(table: &[(&'static str, &'static str)], all: &[T], t: T) -> Option<&'static str> {
table.iter().zip(all).find(|(_, u)| **u == t).map(|((_, v), _)| *v)
}
/// `data` as `w` × `h` RGBA pixels, `None` when it isn't that size (or is empty).
fn pixels(data: &mut [u8], w: usize, h: usize) -> Option<&mut [[u8; 4]]> {
let (px, rest) = data.as_chunks_mut::<4>();
+2 -2
View File
@@ -43,7 +43,7 @@ pub enum StrokeDirection {
}
impl StrokeDirection {
const ALL: [StrokeDirection; 4] =
pub(super) const ALL: [StrokeDirection; 4] =
[StrokeDirection::RightDiagonal, StrokeDirection::Horizontal, StrokeDirection::LeftDiagonal, StrokeDirection::Vertical];
/// The direction of `value` (a [`STROKE_DIRECTIONS`] value, any case); Right Diagonal
@@ -53,7 +53,7 @@ impl StrokeDirection {
}
/// The unit vector along the strokes (document axes, y down).
fn along(self) -> Vec2 {
pub(super) fn along(self) -> Vec2 {
match self {
StrokeDirection::RightDiagonal => RIGHT,
StrokeDirection::Horizontal => Vec2::new(1.0, 0.0),
+1 -1
View File
@@ -137,7 +137,7 @@ pub enum Light {
}
impl Light {
const ALL: [Light; 8] =
pub(super) const ALL: [Light; 8] =
[Light::Bottom, Light::BottomLeft, Light::Left, Light::TopLeft, Light::Top, Light::TopRight, Light::Right, Light::BottomRight];
/// The direction of `value` (a [`LIGHT_DIRECTIONS`] value, any case); Top otherwise.
+49 -9
View File
@@ -452,7 +452,7 @@ pub(crate) fn followed(effects: &[Effect]) -> Cow<'_, [Effect]> {
let Some(a) = after.filter(|a| *a != Affine::IDENTITY && follows(&e.id)) else { continue };
let list = out.get_or_insert_with(|| effects.to_vec());
if let Some(e) = list.get_mut(i) {
follow_transform(e, a);
follow_transform(e, a, Affine::IDENTITY);
}
}
out.map_or(Cow::Borrowed(effects), Cow::Owned)
@@ -472,7 +472,7 @@ pub(crate) fn follow_one(effects: &mut [Effect], t: &Effect) -> bool {
let Some(a) = transform_step(t).filter(|a| *a != Affine::IDENTITY) else { return false };
let mut changed = false;
for e in effects.iter_mut().filter(|e| follows(&e.id)) {
follow_transform(e, a);
follow_transform(e, a, Affine::IDENTITY);
changed = true;
}
changed
@@ -519,7 +519,7 @@ pub(crate) fn follow_contents(effects: &mut [Effect], a: Affine, outer: Affine)
let det = b.determinant();
let c = if b == Affine::IDENTITY || !(det.is_finite() && det.abs() > 1e-12) { a } else { b.inverse() * a * b };
if c.is_finite() {
follow_transform(e, c);
follow_transform(e, c, b);
changed = true;
}
}
@@ -666,11 +666,44 @@ pub(crate) fn follows(id: &str) -> bool {
crate::is_raster(id) && id != crate::SVG_FILTER && id != RASTERIZE
}
thread_local! {
/// The linear part of the Transform effects of the groups and layers whose members are being
/// evaluated ([`LaterGroups`]), which those groups apply to the members' raster effects once
/// the members are evaluated: the members' light and stroke directions are rounded for them as
/// well ([`follow_transform`]).
static LATER_GROUPS: std::cell::Cell<Affine> = const { std::cell::Cell::new(Affine::IDENTITY) };
}
/// The Transform effects of a group or layer whose members are being evaluated before the group's
/// own effects are applied to them, added to [`LATER_GROUPS`] until it is dropped.
pub(crate) struct LaterGroups(Affine);
impl LaterGroups {
/// Add the Transform effects of `owner`, a group's or layer's own effects ([`contents_step`]),
/// to those the members will still go through.
pub(crate) fn enter(owner: &[Effect]) -> Self {
let was = LATER_GROUPS.with(|l| l.get());
if let Some(step) = contents_step(owner) {
LATER_GROUPS.with(|l| l.set(was * step));
}
LaterGroups(was)
}
}
impl Drop for LaterGroups {
fn drop(&mut self) {
LATER_GROUPS.with(|l| l.set(self.0));
}
}
/// Make raster effect `e` follow `a`, the linear part of a Transform effect listed after it, as
/// that effect transforms what `e` paints: its distances and raster sizes scale by `a`'s mean
/// scale ([`crate::scale_effect`]), and a Drop Shadow's offset turns, reflects and scales with
/// `a`. Effects that [`follows`] leaves out stay as they are.
fn follow_transform(e: &mut Effect, a: Affine) {
/// scale ([`crate::scale_effect`]), a Drop Shadow's offset turns, reflects and scales with `a`,
/// and a pixel filter's light direction, stroke direction or screen angles turn and reflect with
/// it ([`pixel::turned_directions`]; `later` is the map `e` still goes through when it is drawn,
/// before the Transform effects of the groups around it in [`LATER_GROUPS`]). Effects that
/// [`follows`] leaves out stay as they are.
fn follow_transform(e: &mut Effect, a: Affine, later: Affine) {
if !follows(&e.id) {
return;
}
@@ -678,15 +711,22 @@ fn follow_transform(e: &mut Effect, a: Affine) {
let p = merged_params(&e.id, &e.params);
a * Point::new(num(&p, "x", 7.0), num(&p, "y", 7.0))
});
let turned = pixel::turned_directions(&e.id, &e.params, a, LATER_GROUPS.with(|l| l.get()) * later);
if let Some(k) = vectorcraft_doc::Scaling::factor(a) {
crate::scale_effect(e, k);
}
if let Some(o) = offset.filter(|o| o.x.is_finite() && o.y.is_finite()) {
let mut set = |key: &str, value: Value| {
if !e.params.is_object() {
e.params = Value::Object(Map::new());
}
e.params["x"] = json!(o.x);
e.params["y"] = json!(o.y);
e.params[key] = value;
};
if let Some(o) = offset.filter(|o| o.x.is_finite() && o.y.is_finite()) {
set("x", json!(o.x));
set("y", json!(o.y));
}
for (key, value) in turned {
set(key, value);
}
}
+49 -4
View File
@@ -515,18 +515,62 @@ fn laid_out(t: &vectorcraft_doc::TextObject) -> (Vec<kurbo::BezPath>, kurbo::Bez
/// gradient fitted across the whole layout, and the transform also scales its stroke weights and
/// dashes and transforms its pattern tiles. Placed gradients keep their place in text space and
/// move with the type.
pub fn paint_type_piece(piece: &mut Node, style: &vectorcraft_doc::CharStyle, bounds: Rect, xf: Affine) {
///
/// When `xf` is not a similarity (it scales unevenly, shears or flattens), one weight can't give
/// the stroke the thickness the canvas paints in each direction: `piece` keeps only the run's fill,
/// and the returned path is the area the run's stroke paints around `piece` in text space
/// ([`crate::stroke::outline_region`]: dashes, caps, joins and alignment), placed by `xf` and
/// filled with the stroke's paint, to paint over `piece`. `None` under a similarity and for a run
/// without a stroke.
pub fn paint_type_piece(piece: &mut Node, style: &vectorcraft_doc::CharStyle, bounds: Rect, xf: Affine) -> Option<Node> {
let scaling = vectorcraft_doc::Scaling { strokes: true, patterns: true, ..Default::default() };
let mut ap = style.appearance();
ap.pin_gradients(bounds);
let stroke = if is_similarity(xf) { None } else { filled_stroke(piece, &mut ap) };
piece.appearance = ap.into();
piece.transform(xf, vectorcraft_doc::Scaling { strokes: true, patterns: true, ..Default::default() });
piece.transform(xf, scaling);
stroke.map(|mut s| {
s.transform(xf, scaling);
s
})
}
/// Does `xf` keep angles and scale every direction alike (a move, a rotation, a uniform scale or a
/// reflection), without flattening?
fn is_similarity(xf: Affine) -> bool {
let [a, b, c, d, ..] = xf.as_coeffs();
let (x, y) = (a.hypot(b), c.hypot(d));
let tol = 1e-9 * x.max(y);
x.is_finite() && y.is_finite() && x > 0.0 && y > 0.0 && (x - y).abs() <= tol && (a * c + b * d).abs() <= tol * x.max(y)
}
/// Takes the stroke out of `ap`, the appearance of `piece` (a path or compound path in text space),
/// and returns the area it paints there as a path filled with its paint, opacity, blend mode,
/// effects and overprint, with `piece`'s id. `None` when `ap` has no stroke or it paints nothing.
fn filled_stroke(piece: &Node, ap: &mut Appearance) -> Option<Node> {
let i = ap.items.iter().position(|i| matches!(i, AppearanceItem::Stroke(_)))?;
let AppearanceItem::Stroke(st) = ap.items.remove(i) else { return None };
let path = PathData::from_bezpath(&piece.stroke_path()?);
let region = crate::stroke::outline_region(&path, FillRule::NonZero, &st);
if region.is_empty() {
return None;
}
let fill = vectorcraft_doc::FillLayer {
opacity: st.opacity,
blend: st.blend,
effects: st.effects.clone(),
overprint: st.overprint,
..vectorcraft_doc::FillLayer::new(st.paint.stroke_as_fill())
};
Some(Node::path(piece.id, region, Appearance { items: vec![AppearanceItem::Fill(fill)], ..Default::default() }))
}
/// Type as glyph outlines in document space: one path per run with the run's fill and stroke,
/// over its colour glyphs (images, art), and (when the object has its own fills/strokes) the whole
/// outline with the object's items below the characters under them and the others over them, as
/// the renderer paints them. Each run's path is placed by the type's transform, which also scales its stroke
/// weights and dashes and transforms its pattern tiles; its unplaced gradients are first fixed to
/// weights and dashes and transforms its pattern tiles (a transform that is not a similarity puts
/// the run's stroke on a filled path over it, [`paint_type_piece`]); its unplaced gradients are first fixed to
/// the layout's bounds in text space. The object's own unplaced gradients are fixed to the
/// bounding box of those bounds in the document. The group is marked as type's outlines
/// ([`vectorcraft_doc::NodeExtras::type_outlines`]).
@@ -542,8 +586,9 @@ pub fn outline_text(n: &Node) -> Option<Node> {
continue;
}
let mut piece = Node::path(n.id, PathData::from_bezpath(bp), Appearance::default());
paint_type_piece(&mut piece, &run.style, bounds, t.xf);
let stroke = paint_type_piece(&mut piece, &run.style, bounds, t.xf);
children.push(Arc::new(piece));
children.extend(stroke.map(Arc::new));
}
if !n.appearance.items.is_empty() && !all.elements().is_empty() {
let (below, above) = n.appearance.split_contents();
+71 -56
View File
@@ -324,8 +324,7 @@ fn validate_solid_for(doc: Option<&Document>, n: &Node, id: &str, p: &Value, at:
reshape_members(n, before, &mut shapes);
let b = union_bounds(&shapes).ok_or_else(|| format!("{label} requires a group holding a shape with at least two anchors"))?;
check_profiles(id, p, &shapes, b)?;
check_solids(id, p, &shapes)?;
return check_cast(id, p, &shapes);
return check_solids(id, p, &shapes);
}
let (path, rule) = object_profile(n, label)?;
let anchors = || format!("{label} requires a shape with at least two anchors");
@@ -342,38 +341,68 @@ fn validate_solid_for(doc: Option<&Document>, n: &Node, id: &str, p: &Value, at:
let b = path.bounds().ok_or_else(anchors)?;
let shapes = [Profile { path, rule, items, opacity: 1.0, scopes: vec![] }];
check_profiles(id, p, &shapes, b)?;
check_solids(id, p, &shapes)?;
check_cast(id, p, &shapes)
check_solids(id, p, &shapes)
}
/// With the shadow of 3D effect `id` with parameters `p` on, an error when the shadow of `shapes`
/// is past the limits ([`cast_shadow`]). In wireframe mode no shadow is drawn, and none is checked.
fn check_cast(id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
if wireframe::wireframe_params(id, p) {
return Ok(());
}
cast_shadow(id, p, shapes).map(|_| ())
/// Does 3D effect `id` with parameters `p` cast a shadow: is it Extrude & Bevel, Inflate or Rotate
/// with Shadows on, shaded? In wireframe mode no shadow is drawn, and none is checked.
fn casts_shadow(id: &str, p: &Value) -> bool {
!is_classic_three_d(id) && shadow::options(p).is_some() && !wireframe::wireframe_params(id, p)
}
/// Does `item` of a shape with opacity `member` paint anything, and so cast a shadow?
fn visible(item: &AppearanceItem, member: f32) -> bool {
paint_of(item, member).1 > 0.0
}
/// Do the solids 3D effect `id` with parameters `p` builds from the profiles of `shapes` about `b`
/// build? Only the profiles no solid of [`check_solids`] is built from are built here: every
/// shape's for Rotate, and for Extrude & Bevel and Inflate the profile of a shape with no fill,
/// whose solids are its strokes' outlines or none. A filled shape's profile is its fill's solid,
/// which [`check_solids`] builds once, about the bounds the effect draws it about.
/// build? Only the profiles no solid of [`check_solids`] is built from are built here: for Rotate
/// every shape's, except with its shadow cast that of a shape with a visible fill, whose plane is
/// the fill's; for Extrude & Bevel and Inflate the profile of a shape with no fill, whose solids
/// are its strokes' outlines or none. A filled shape's profile is its fill's solid, which
/// [`check_solids`] builds once, about the bounds the effect draws it about.
fn check_profiles(id: &str, p: &Value, shapes: &[Profile], b: Rect) -> Result<(), String> {
shapes
.iter()
.filter(|s| is_plane(id) || !s.items.iter().any(|i| matches!(i, AppearanceItem::Fill(_))))
.try_for_each(|s| facets(id, &s.path, s.rule, b, p).map(|_| ()))
let cast = casts_shadow(id, p);
let fill = |s: &Profile| s.items.iter().any(|i| matches!(i, AppearanceItem::Fill(_)) && (!is_plane(id) || visible(i, s.opacity)));
shapes.iter().filter(|s| if is_plane(id) { !(cast && fill(s)) } else { !fill(s) }).try_for_each(|s| facets(id, &s.path, s.rule, b, p).map(|_| ()))
}
/// Do the solids 3D effect `id` with parameters `p` builds from the fills and strokes of `shapes`
/// fit, each on its own and all of them together ([`built_solids`])? Rotate's planes are not
/// counted.
/// fit, each on its own and all of them together ([`built_solids`]), and with its shadow cast, does
/// the shadow fit? The shadow is cast from the faces those same builds kept ([`cast_built`]), as
/// [`art_for`] casts it: Extrude & Bevel and Inflate build each solid once, and Rotate builds the
/// plane of each visible fill and stroke once. Rotate's planes are not counted, and without its
/// shadow Rotate builds no plane here.
fn check_solids(id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
let Some(b) = union_bounds(shapes).filter(|_| !is_plane(id)) else { return Ok(()) };
let Some(b) = union_bounds(shapes) else { return Ok(()) };
let cast = casts_shadow(id, p);
if is_plane(id) {
if !cast {
return Ok(());
}
let mut built = vec![];
for s in shapes {
for item in &s.items {
if !visible(item, s.opacity) {
built.push(None);
continue;
}
let (area, rule) = region(&s.path, s.rule, item);
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + 1));
built.push(facets_and_faces(ROTATE, &area, rule, b, p, true)?.1);
}
}
return cast_built(id, p, shapes, built).map(|_| ());
}
let (parts, bounds) = solid_parts(shapes, b);
built_solids(id, p, &parts, bounds, MAX_OBJECT_FACES).try_for_each(|r| r.map(|_| ()))
if !cast {
return built_solids(id, p, &parts, bounds, MAX_OBJECT_FACES).try_for_each(|r| r.map(|_| ()));
}
let built = built_solids_cast(id, p, &parts, bounds, MAX_OBJECT_FACES, true)
.map(|r| r.map(|solid| solid.and_then(|(_, faces)| faces)))
.collect::<Result<Vec<_>, String>>()?;
cast_built(id, p, shapes, built).map(|_| ())
}
/// [`profile`], or the error a command reports for object `n`: type with no outlines to build from
@@ -733,7 +762,8 @@ thread_local! {
/// surfaces count too.
pub(crate) static SOLIDS_BUILT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
/// How many Extrude & Bevel (Classic included) and Inflate solids [`facets`] and
/// [`built_solids`] have built on this thread, for the tests.
/// [`built_solids`] have built on this thread, for the tests. The solids built to cast a shadow
/// ([`cast_shadow`]) count too.
static SOLID_GEOMETRY_BUILT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
@@ -1435,7 +1465,7 @@ fn art_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile]) ->
return Some((vec![], wireframe::wire_surfaces(n.id, fx, shapes)?));
}
let p = crate::merged_params(&fx.id, &fx.params);
let cast = !is_classic_three_d(&fx.id) && shadow::options(&p).is_some();
let cast = casts_shadow(&fx.id, &p);
let (art, built) = surfaces_for(doc, n, fx, shapes, cast)?;
// A shadow past the limits draws the source path, as a solid past them does; commands report
// the error ([`validate_solid_in`]).
@@ -1500,12 +1530,16 @@ fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result<Option<
let casts: Vec<bool> = inks.iter().map(|i| i.casts()).collect();
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + shapes.len()));
#[cfg(test)]
SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + casts.iter().filter(|c| **c).count()));
caster.inflate(&shapes, &casts, bounds, inflate_options(p), view)
} else {
let mut added = vec![];
for ((_, _, area, rule, _, _), ink) in parts.iter().zip(&inks) {
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + usize::from(ink.casts())));
#[cfg(test)]
SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + usize::from(ink.casts())));
added.push(if ink.casts() { caster.extrude(area, *rule, bounds, extrude_options(p), view) } else { Ok(0..0) });
}
added
@@ -1529,16 +1563,14 @@ fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result<Option<
/// [`cast_shadow`] from `built`, the faces the solids drawn kept ([`surfaces_for`] with its shadow
/// cast), one entry for each solid in the order they are built: for Rotate each fill and stroke of
/// each shape, otherwise each part ([`solid_parts`]). A stroke's solid left out of the art (past its
/// own limits) kept no faces. Its Extrude & Bevel solid is built for the shadow alone, as
/// [`cast_shadow`] builds it, and when an Inflate solid of visible art kept no faces the whole
/// shadow is cast as [`cast_shadow`] casts it, since Inflate's solids share one eye.
/// each shape, otherwise each part ([`solid_parts`]). No solid is built here: an entry with no faces
/// (a stroke's solid left out of the art, past its own limits) casts nothing, as it draws nothing.
/// Only `built` of another length than the solids is cast as [`cast_shadow`] casts it.
fn cast_built<'a>(id: &str, p: &Value, shapes: &'a [Profile], built: Vec<Option<SolidFaces>>) -> Result<Option<Cast<'a>>, String> {
if id == CLASSIC_EXTRUDE || id == CLASSIC_ROTATE {
return Ok(None);
}
let (Some(settings), Some(b)) = (shadow::options(p), union_bounds(shapes)) else { return Ok(None) };
let view = view_options(p);
let mut caster = vectorcraft_three_d::ShadowCaster::new();
let mut cast: Vec<shadow::Cast> = vec![];
let ink = |item: &AppearanceItem, member: f32| {
@@ -1555,39 +1587,22 @@ fn cast_built<'a>(id: &str, p: &Value, shapes: &'a [Profile], built: Vec<Option<
if !ink.casts() {
continue;
}
let faces = match kept {
Some(kept) => caster.add_solid(kept)?,
None => {
let (area, rule) = region(&s.path, s.rule, item);
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + 1));
caster.plane(&area, rule, b, view)?
}
};
cast.push((s.scopes.as_slice(), ink, faces));
let Some(kept) = kept else { continue };
cast.push((s.scopes.as_slice(), ink, caster.add_solid(kept)?));
}
return Ok(Some((caster, settings, cast)));
}
let (parts, bounds) = solid_parts(shapes, b);
let inks: Vec<shadow::Ink> = parts.iter().map(|(item, member, ..)| ink(item, *member)).collect();
if parts.len() != built.len() || (id == INFLATE && inks.iter().zip(&built).any(|(ink, kept)| ink.casts() && kept.is_none())) {
let (parts, _) = solid_parts(shapes, b);
if parts.len() != built.len() {
return cast_shadow(id, p, shapes);
}
for (((item, _, area, rule, scopes, _), ink), kept) in parts.iter().zip(inks).zip(built) {
if !ink.casts() {
continue;
}
let faces = match kept {
Some(kept) => caster.add_solid(kept),
None => {
#[cfg(test)]
SOLIDS_BUILT.with(|n| n.set(n.get() + 1));
caster.extrude(area, *rule, bounds, extrude_options(p), view)
}
};
for ((item, member, _, _, scopes, _), kept) in parts.iter().zip(built) {
let ink = ink(item, *member);
// A fully transparent solid, or a stroke's solid left out of the art, casts nothing.
let Some(kept) = kept.filter(|_| ink.casts()) else { continue };
// A stroke whose own solid is past the limits is left out; past the shadow's limit for all
// the solids together, the shadow is refused.
let faces = match faces {
let faces = match caster.add_solid(kept) {
Ok(faces) => faces,
Err(e) if matches!(item, AppearanceItem::Stroke(_)) && e != vectorcraft_three_d::TOO_COMPLEX_SHADOW => continue,
Err(e) => return Err(e),
+7 -1
View File
@@ -1082,7 +1082,8 @@ fn geometry_builds(check: impl FnOnce() -> Result<(), String>) -> (usize, Result
/// The check builds each solid the effect draws once, about the bounds it draws it about: one for
/// a fill and one for each stroke, on an object, on a group's members and on an appearance item,
/// with the shadow on or off.
/// with the shadow on or off. With the shadow on, the shadow is cast from the faces those builds
/// kept, so no solid is built again for it.
#[test]
fn the_check_builds_each_drawn_solid_once() {
for id in [EXTRUDE, CLASSIC_EXTRUDE, INFLATE] {
@@ -1098,6 +1099,11 @@ fn the_check_builds_each_drawn_solid_once() {
assert_eq!(geometry_builds(|| validate_three_d_at(&n, id, &json!({}), (Some(0), 0))), (1, Ok(())), "{id}: on the fill");
let shadow = json!({"shadow": true});
assert_eq!(geometry_builds(|| validate_solid(&n, id, &shadow)), (2, Ok(())), "{id}: with the shadow on");
let mut other = square_node();
other.id = NodeId(2);
let g = Node::group(NodeId(9999), vec![Arc::new(square_node()), Arc::new(other)]);
assert_eq!(geometry_builds(|| validate_solid(&g, id, &shadow)), (4, Ok(())), "{id}: a group with the shadow on");
assert_eq!(geometry_builds(|| validate_three_d_at(&n, id, &shadow, (Some(0), 0))), (1, Ok(())), "{id}: the fill with the shadow on");
}
}
+62
View File
@@ -313,6 +313,68 @@ fn the_shadow_cast_from_the_solids_drawn_is_the_shadow_of_solids_built_for_it()
}
}
/// A stroke's solid left out of the art (past its own limits) keeps no faces, and the shadow cast
/// from the faces the solids kept leaves it out without building it: it casts nothing, as it draws
/// nothing, and the fill's solid still casts.
#[test]
fn a_stroke_left_out_of_the_art_casts_no_shadow() {
for id in [EXTRUDE, INFLATE] {
let n = stroked_square(1, 0.0, 1.0);
let (path, rule) = profile(&n).unwrap();
let shapes = [Profile { path, rule, items: solid_paints(&n), opacity: 1.0, scopes: vec![] }];
let p = crate::merged_params(id, &json!({"shadow": true}));
let (parts, bounds) = solid_parts(&shapes, union_bounds(&shapes).unwrap());
let mut built: Vec<Option<SolidFaces>> =
built_solids_cast(id, &p, &parts, bounds, MAX_OBJECT_FACES, true).map(|r| r.unwrap().and_then(|(_, faces)| faces)).collect();
let stroke = parts.iter().position(|(item, ..)| matches!(item, AppearanceItem::Stroke(_))).unwrap();
assert!(built.len() == 2 && built.iter().all(Option::is_some), "{id}");
let (both, _, cast) = cast_built(id, &p, &shapes, built.clone()).unwrap().unwrap();
assert_eq!(cast.len(), 2, "{id}: the fill and the stroke cast");
built[stroke] = None;
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
let (fill, _, cast) = cast_built(id, &p, &shapes, built).unwrap().unwrap();
assert_eq!(SOLIDS_BUILT.with(std::cell::Cell::get), start, "{id}: no solid is built for the shadow");
assert_eq!(cast.len(), 1, "{id}: the stroke left out casts nothing");
assert!(!fill.is_empty() && fill.len() < both.len(), "{id}: only the fill's faces are cast");
}
}
/// A command accepts each shadowed object that draws with its shadow, and with Rotate builds the
/// plane of each visible fill and stroke once for the shadow: a fully transparent one casts nothing.
#[test]
fn the_check_accepts_the_shadowed_objects_that_draw() {
for id in [EXTRUDE, INFLATE, ROTATE] {
for params in shadow_settings(id) {
for n in shadowed(id, &params) {
let mut drawn = 0;
art(&n, id).unwrap().walk(&mut |c| drawn += usize::from(shadow_opacity(c).is_some()));
assert!(drawn > 0, "{id} {params}");
assert_eq!(validate_solid(&n, id, &params), Ok(()), "{id} {params}");
}
}
}
let shadow = json!({"shadow": true});
for (stroke, planes) in [(1.0, 2), (0.5, 2), (0.0, 1)] {
let n = stroked_square(1, 0.0, stroke);
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
assert_eq!(validate_solid(&n, ROTATE, &shadow), Ok(()), "{stroke}");
assert_eq!(SOLIDS_BUILT.with(std::cell::Cell::get) - start, planes, "Rotate, a stroke at {stroke}");
}
}
/// In wireframe mode no shadow is drawn, so the check casts none: with Shadows on, Rotate builds no
/// plane for a shadow, and Extrude & Bevel and Inflate build each solid once, as with the shadow off.
#[test]
fn the_check_casts_no_shadow_in_wireframe_mode() {
let n = stroked_square(1, 0.0, 1.0);
let wire = json!({"shadow": true, "render": {"mode": "wireframe"}});
for (id, solids) in [(ROTATE, 0), (EXTRUDE, 2), (INFLATE, 2)] {
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
assert_eq!(validate_solid(&n, id, &wire), Ok(()), "{id}");
assert_eq!(SOLIDS_BUILT.with(std::cell::Cell::get) - start, solids, "{id}");
}
}
/// The opacity of each part of the shadow of `n` (its 3D effect's shadow on) and the shadow's art,
/// as [`cast_shadow`] casts it from solids built for the shadow alone and as [`cast_built`] casts
/// it from the faces the solids drawn kept.
+1
View File
@@ -11,6 +11,7 @@ mod rasterfollow;
mod scale;
mod solidcontext;
mod transformfx;
mod typestroke;
fn fx(id: &str, params: Value) -> Effect {
Effect { id: id.into(), params, visible: true }
+226 -1
View File
@@ -7,7 +7,8 @@ use vectorcraft_doc::{Appearance, Document, Effect, Node, NodeId};
use vectorcraft_geom::{Affine, Anchor, PathData, Point, Rect, SubPath, shapes};
use crate::geometry::{Budget, MAX_EFFECT_LINES, apply_geometry_carrying_within};
use crate::{Carry, GeomContext, RasterFx, apply_geometry_carrying, bake_document, expand_outlined, raster_effects};
use crate::pixel::{Light, StrokeDirection};
use crate::{Carry, GeomContext, PixelFx, RasterFx, apply_geometry_carrying, bake_document, expand_outlined, raster_effects};
fn fx(id: &str, params: Value) -> Effect {
Effect { id: id.into(), params, visible: true }
@@ -436,6 +437,230 @@ fn pixel_filter_sizes_scale_with_the_transform_after_them() {
assert!(matches!(drawn.get(1), Some(RasterFx::Pixel(crate::PixelFx::PaintDaubs { size, .. })) if (size - 20.0).abs() < 1e-9), "{drawn:?}");
}
/// The light direction of the first pixel filter `effects` draw, if it has one.
fn drawn_light(effects: &[Effect]) -> Option<Light> {
raster_effects(effects).into_iter().find_map(|r| match r {
RasterFx::Pixel(
PixelFx::Underpainting { light, .. }
| PixelFx::RoughPastels { light, .. }
| PixelFx::ConteCrayon { light, .. }
| PixelFx::BasRelief { light, .. }
| PixelFx::Plaster { light, .. }
| PixelFx::Texturizer { light, .. },
) => Some(light),
_ => None,
})
}
/// The stroke direction of the first pixel filter `effects` draw, if it has one.
fn drawn_strokes(effects: &[Effect]) -> Option<StrokeDirection> {
raster_effects(effects).into_iter().find_map(|r| match r {
RasterFx::Pixel(PixelFx::SprayedStrokes { direction, .. } | PixelFx::GraphicPen { direction, .. }) => Some(direction),
_ => None,
})
}
/// The screen angles of the first Color Halftone `effects` draw.
fn drawn_screens(effects: &[Effect]) -> [f64; 4] {
match raster_effects(effects).into_iter().next() {
Some(RasterFx::Pixel(PixelFx::ColorHalftone { angles, .. })) => angles,
other => panic!("expected a Color Halftone, got {other:?}"),
}
}
/// A Bas Relief lit from `light`, then a Transform effect with `params`: the light it draws with.
fn relief_then(light: &str, params: Value) -> Option<Light> {
drawn_light(&[fx("sketch.basRelief", json!({ "lightDirection": light })), transform(params)])
}
/// A light direction before a Transform effect turns and reflects with the art (y down on the
/// page), to the nearest of the eight directions, the clockwise one at a tie.
#[test]
fn bas_relief_light_follows_rotation_and_reflection() {
assert_eq!(relief_then("top", json!({"rotate": 90})), Some(Light::Left));
assert_eq!(relief_then("top", json!({"reflectY": true})), Some(Light::Bottom));
assert_eq!(relief_then("top", json!({"reflectX": true})), Some(Light::Top));
assert_eq!(relief_then("left", json!({"reflectX": true})), Some(Light::Right));
// 22.5° clockwise lies halfway between Top and Top Right; 22.5° counterclockwise halfway
// between Top and Top Left.
assert_eq!(relief_then("top", json!({"rotate": -22.5})), Some(Light::TopRight));
assert_eq!(relief_then("top", json!({"rotate": 22.5})), Some(Light::Top));
assert_eq!(relief_then("top", json!({"rotate": 30})), Some(Light::TopLeft));
// A turn of 90° counterclockwise, from each direction.
for (from, to) in [
("bottom", Light::Right),
("bottomLeft", Light::BottomRight),
("left", Light::Bottom),
("topLeft", Light::BottomLeft),
("top", Light::Left),
("topRight", Light::TopLeft),
("right", Light::Top),
("bottomRight", Light::TopRight),
] {
assert_eq!(relief_then(from, json!({"rotate": 90})), Some(to), "{from}");
}
// Every filter with a light direction, and Bas Relief's default light (Bottom).
for id in ["artistic.underpainting", "artistic.roughPastels", "sketch.conteCrayon", "sketch.basRelief", "sketch.plaster", "texture.texturizer"] {
let effects = [fx(id, json!({"lightDirection": "top"})), transform(json!({"rotate": 90}))];
assert_eq!(drawn_light(&effects), Some(Light::Left), "{id}");
}
assert_eq!(drawn_light(&[fx("sketch.basRelief", json!({})), transform(json!({"rotate": 90}))]), Some(Light::Right));
// The Transform effects after the filter turn it together, with one rounding at the end.
let twice = [fx("sketch.basRelief", json!({"lightDirection": "top"})), transform(json!({"rotate": -22.5})), transform(json!({"rotate": -22.5}))];
assert_eq!(drawn_light(&twice), Some(Light::TopRight));
}
/// A stroke direction before a Transform effect turns and reflects with the art, to the nearest
/// of the four, a stroke and its reverse being the same, the clockwise one at a tie.
#[test]
fn stroke_axis_follows_transform() {
let strokes = |id: &str, way: Option<&str>, params: Value| {
let p = way.map_or(json!({}), |w| json!({ "strokeDirection": w }));
drawn_strokes(&[fx(id, p), transform(params)])
};
let sprayed = "brushStrokes.sprayedStrokes";
let pen = "sketch.graphicPen";
assert_eq!(strokes(sprayed, Some("horizontal"), json!({"rotate": 90})), Some(StrokeDirection::Vertical));
assert_eq!(strokes(sprayed, Some("vertical"), json!({"rotate": 90})), Some(StrokeDirection::Horizontal));
assert_eq!(strokes(pen, Some("rightDiagonal"), json!({"rotate": 90})), Some(StrokeDirection::LeftDiagonal));
assert_eq!(strokes(pen, Some("rightDiagonal"), json!({"reflectX": true})), Some(StrokeDirection::LeftDiagonal));
assert_eq!(strokes(pen, Some("leftDiagonal"), json!({"reflectY": true})), Some(StrokeDirection::RightDiagonal));
assert_eq!(strokes(pen, None, json!({"rotate": 90})), Some(StrokeDirection::LeftDiagonal));
assert_eq!(strokes(sprayed, Some("horizontal"), json!({"rotate": -22.5})), Some(StrokeDirection::LeftDiagonal));
assert_eq!(strokes(sprayed, Some("horizontal"), json!({"rotate": 22.5})), Some(StrokeDirection::Horizontal));
assert_eq!(strokes(sprayed, Some("horizontal"), json!({"rotate": -44})), Some(StrokeDirection::LeftDiagonal));
assert_eq!(strokes(sprayed, Some("horizontal"), json!({"rotate": 180})), Some(StrokeDirection::Horizontal));
}
fn near4(a: [f64; 4], b: [f64; 4]) -> bool {
a.iter().zip(b).all(|(p, q)| (p - q).abs() < 1e-6)
}
/// Color Halftone's screen angles before a Transform effect turn and reflect with the art.
#[test]
fn halftone_channels_follow_rotation_and_reflection() {
let screens = |p: Value, transforms: &[Value]| {
let mut effects = vec![fx("pixelate.colorHalftone", p)];
effects.extend(transforms.iter().cloned().map(transform));
drawn_screens(&effects)
};
let defaults = screens(json!({}), &[json!({"rotate": 90})]);
assert!(near4(defaults, [198.0, 252.0, 180.0, 135.0]), "{defaults:?}");
let reflected = screens(json!({"channel1": 45, "channel2": 30, "channel3": 0, "channel4": 270}), &[json!({"reflectX": true})]);
assert!(near4(reflected, [135.0, 150.0, 180.0, 270.0]), "{reflected:?}");
let flipped = screens(json!({"channel1": 45, "channel2": 30, "channel3": 0, "channel4": 270}), &[json!({"reflectY": true})]);
assert!(near4(flipped, [315.0, 330.0, 0.0, 90.0]), "{flipped:?}");
// One Transform effect reflects, then turns; two apply in the order they are listed.
let p = json!({"channel1": 10.5, "channel2": -30, "channel3": 0, "channel4": 359.25});
let one = screens(p.clone(), &[json!({"rotate": 30, "reflectX": true})]);
assert!(near4(one, [199.5, 240.0, 210.0, 210.75]), "{one:?}");
let two = screens(p, &[json!({"rotate": 30}), json!({"reflectX": true})]);
assert!(near4(two, [139.5, 180.0, 150.0, 150.75]), "{two:?}");
}
/// Only the visible Transform effects listed after a filter that move the art once turn its
/// direction; a hidden filter turns too, and a zero scale leaves it as it is.
#[test]
fn only_earlier_visible_single_map_effects_follow() {
let relief = fx("sketch.basRelief", json!({"lightDirection": "top"}));
assert_eq!(drawn_light(&[transform(json!({"rotate": 90})), relief.clone()]), Some(Light::Top));
for params in [
json!({"rotate": 90, "objects": false}),
json!({"rotate": 90, "copies": 1}),
json!({"rotate": 90, "random": true}),
json!({"scaleH": 0, "scaleV": 0}),
] {
assert_eq!(drawn_light(&[relief.clone(), transform(params.clone())]), Some(Light::Top), "{params}");
}
let mut hidden = transform(json!({"rotate": 90}));
hidden.visible = false;
assert_eq!(drawn_light(&[relief.clone(), hidden]), Some(Light::Top));
let zero = [fx("pixelate.colorHalftone", json!({"channel1": 20})), transform(json!({"scaleH": 0, "scaleV": 0}))];
assert!(near4(drawn_screens(&zero), [20.0, 162.0, 90.0, 45.0]), "{:?}", drawn_screens(&zero));
// A hidden filter kept when the Transform effect is applied draws turned once it is shown.
let mut off = relief;
off.visible = false;
let kept = crate::raster::without_geometry(&[off, transform(json!({"rotate": 90}))]);
assert_eq!(kept.len(), 1);
let mut shown = kept[0].clone();
shown.visible = true;
assert_eq!(drawn_light(&[shown]), Some(Light::Left));
}
/// The light direction of every Bas Relief drawn on `n` and the nodes under it, from the object's
/// effects and from each fill's and stroke's.
fn lights_in(n: &Node) -> Vec<Light> {
let mut out = vec![];
n.walk(&mut |m| {
let lists = std::iter::once(&m.appearance.effects).chain(m.appearance.items.iter().map(|i| i.effects()));
for list in lists {
out.extend(drawn_light(list));
}
});
out
}
/// The canvas, a fill's own effects, a group's members and export turn the light the same way.
#[test]
fn nested_and_baked_directions_match_canvas() {
let relief = || fx("sketch.basRelief", json!({"lightDirection": "top"}));
let turn = || transform(json!({"rotate": 90}));
// A fill's own Transform effect, and the object's Transform effect over its fill.
let fill = fill_square(31, vec![relief(), turn()]);
let item = fill.appearance.items.first().unwrap();
assert_eq!(drawn_light(item.effects()), Some(Light::Left));
let mut over = fill_square(32, vec![relief()]);
over.appearance.effects = vec![turn()];
let item = over.appearance.items.first().unwrap();
assert_eq!(drawn_light(&crate::item_effects_in(&over.appearance.effects, item.effects())), Some(Light::Left));
// A fill's own turn of 30° and the object's turn of 30° make 60°, rounded once: Top Left, not
// Left (Top Left after the first turn, then Left after the second).
let thirty = || transform(json!({"rotate": 30}));
let mut both = fill_square(37, vec![relief(), thirty()]);
both.appearance.effects = vec![thirty()];
let item = both.appearance.items.first().unwrap();
assert_eq!(drawn_light(&crate::item_effects_in(&both.appearance.effects, item.effects())), Some(Light::TopLeft));
// A group's Transform effect over a member's own filter and its fill's.
let g = group(33, vec![square(34, vec![relief()]), fill_square(35, vec![relief()])], vec![turn()]);
let art = crate::evaluate_container(None, &g).unwrap();
assert_eq!(lights_in(&art), vec![Light::Left; 2]);
// Baked for export: the Transform effect is applied and the filter keeps the turned light.
let mut d = Document::new(800.0, 800.0);
let layer = d.layers[0].id;
d.insert(Some(layer), 0, square(36, vec![relief(), turn()])).unwrap();
d.insert(Some(layer), 1, g).unwrap();
let baked = bake_document(&d).unwrap();
let b = baked.node(NodeId(36)).unwrap();
assert!(!b.appearance.effects.iter().any(|e| e.id == "distort.transform"), "{:?}", b.appearance.effects);
assert_eq!(drawn_light(&b.appearance.effects), Some(Light::Left));
for id in [34, 35] {
assert_eq!(lights_in(baked.node(NodeId(id)).unwrap()), vec![Light::Left], "{id}");
}
}
/// A member's light under two nested groups that each turn 30° turns 60° in all, rounded once:
/// Top Left, not Left (Top Left after the inner group's turn, then Left after the outer one's).
#[test]
fn nested_group_turns_round_the_light_once() {
let relief = || fx("sketch.basRelief", json!({"lightDirection": "top"}));
let thirty = || transform(json!({"rotate": 30}));
let inner = group(41, vec![square(42, vec![relief()]), fill_square(43, vec![relief()])], vec![thirty()]);
let outer = group(40, vec![inner], vec![thirty()]);
let art = crate::evaluate_container(None, &outer).unwrap();
assert_eq!(lights_in(&art), vec![Light::TopLeft; 2]);
let mut d = Document::new(800.0, 800.0);
let layer = d.layers[0].id;
d.insert(Some(layer), 0, outer).unwrap();
let baked = bake_document(&d).unwrap();
for id in [42, 43] {
assert_eq!(lights_in(baked.node(NodeId(id)).unwrap()), vec![Light::TopLeft], "{id}");
}
// Three groups make 90°: Left, not Bottom Left.
let three = group(44, vec![group(45, vec![group(46, vec![square(47, vec![relief()])], vec![thirty()])], vec![thirty()])], vec![thirty()]);
let art = crate::evaluate_container(None, &three).unwrap();
assert_eq!(lights_in(&art), vec![Light::Left]);
}
/// A Transform effect after a 3D effect that makes copies or moves at random holds back the shadow
/// before the 3D effect, as it does without the 3D effect.
#[test]
+123
View File
@@ -0,0 +1,123 @@
//! Character strokes of outlined type under the type's transform ([`paint_type_piece`]): a live
//! stroke with a scaled weight under a similarity, otherwise the area the stroke paints in text
//! space, placed by the transform and filled.
use vectorcraft_color::{Color, Gradient, GradientKind, GradientPaint, GradientStop, Paint};
use vectorcraft_doc::{Appearance, CharStyle, Dash, LineJoin, Node, NodeId, StrokeAlign};
use vectorcraft_geom::{Affine, FillRule, Rect, shapes};
use crate::*;
const BOX: Rect = Rect::new(0.0, 0.0, 10.0, 10.0);
fn red() -> Color {
Color::rgb(1.0, 0.0, 0.0)
}
/// A black run with a red stroke of `width` and round joins.
fn style(width: f64) -> CharStyle {
CharStyle {
fill: Paint::solid(Color::BLACK),
stroke: Paint::solid(red()),
stroke_width: width,
stroke_join: LineJoin::Round,
..CharStyle::default()
}
}
/// A 10 x 10 square in text space standing in for a glyph.
fn square() -> Node {
Node::path(NodeId(7), shapes::rectangle(BOX), Appearance::default())
}
fn area(n: &Node) -> f64 {
vectorcraft_pathops::area(n.path_data().unwrap(), FillRule::NonZero).abs()
}
fn near(a: Rect, b: Rect) -> bool {
[a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1].iter().all(|d| d.abs() < 0.05)
}
#[test]
fn an_uneven_scale_fills_the_stroke_the_canvas_paints() {
let mut piece = square();
let stroke = paint_type_piece(&mut piece, &style(4.0), BOX, Affine::scale_non_uniform(3.0, 1.0)).expect("a filled stroke");
assert!(piece.appearance.stroke().is_none(), "the piece keeps only its fill");
assert_eq!(piece.appearance.fill_paint(), Paint::solid(Color::BLACK));
assert_eq!(piece.geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 30.0, 10.0));
assert!(stroke.appearance.stroke().is_none());
assert_eq!(stroke.appearance.fill_paint(), Paint::solid(red()));
assert_eq!(stroke.id, NodeId(7));
// 4 pt across in text space: 12 pt across the upright sides and 4 pt across the level ones.
let b = stroke.geometric_bounds().unwrap();
assert!(near(b, Rect::new(-6.0, -2.0, 36.0, 12.0)), "{b:?}");
// The ring of a 10 pt square stroked 4 pt with round joins (180 + 4π outside, 36 inside), 3 times as wide.
let ring = 180.0 + 4.0 * std::f64::consts::PI - 36.0;
assert!((area(&stroke) - 3.0 * ring).abs() < 0.5, "{}", area(&stroke));
}
#[test]
fn a_similarity_keeps_the_live_stroke_with_a_scaled_weight() {
for (xf, weight) in [
(Affine::translate((5.0, 5.0)), 4.0),
(Affine::scale(2.0), 8.0),
(Affine::rotate(0.5) * Affine::scale(2.0), 8.0),
(Affine::scale_non_uniform(-2.0, 2.0), 8.0),
] {
let mut piece = square();
assert!(paint_type_piece(&mut piece, &style(4.0), BOX, xf).is_none(), "{xf:?}");
let st = piece.appearance.stroke().expect("a live stroke");
assert!((st.width - weight).abs() < 1e-9, "{xf:?}: {}", st.width);
assert_eq!(st.join, LineJoin::Round);
}
}
#[test]
fn shears_and_flattening_transforms_fill_the_stroke() {
// A shear keeps the area.
let mut piece = square();
let stroke = paint_type_piece(&mut piece, &style(4.0), BOX, Affine::skew(0.5, 0.0)).expect("a filled stroke");
let ring = 180.0 + 4.0 * std::f64::consts::PI - 36.0;
assert!((area(&stroke) - ring).abs() < 0.5, "{}", area(&stroke));
// Flattened to a line or a point: no division by the determinant, nothing non-finite.
for xf in [Affine::scale_non_uniform(2.0, 0.0), Affine::scale(0.0)] {
let mut piece = square();
let stroke = paint_type_piece(&mut piece, &style(4.0), BOX, xf).expect("a filled stroke");
assert!(piece.appearance.stroke().is_none());
if let Some(b) = stroke.geometric_bounds() {
assert!([b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()) && b.height().abs() < 1e-9, "{xf:?}: {b:?}");
}
}
}
#[test]
fn the_stroke_options_shape_the_filled_stroke_in_text_space() {
let xf = Affine::scale_non_uniform(3.0, 1.0);
let filled = |st: CharStyle| paint_type_piece(&mut square(), &st, BOX, xf);
// No stroke, or no weight: nothing is filled.
assert!(filled(style(0.0)).is_none());
assert!(filled(CharStyle { stroke: Paint::None, ..style(4.0) }).is_none());
// Inside and outside alignment are kept to their side of the square before it is scaled.
let inside = filled(CharStyle { stroke_align: StrokeAlign::Inside, ..style(4.0) }).unwrap();
assert!(near(inside.geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 30.0, 10.0)));
assert!((area(&inside) - 3.0 * (100.0 - 4.0)).abs() < 0.5, "{}", area(&inside));
let outside = filled(CharStyle { stroke_align: StrokeAlign::Outside, ..style(4.0) }).unwrap();
assert!(near(outside.geometric_bounds().unwrap(), Rect::new(-12.0, -4.0, 42.0, 14.0)), "{:?}", outside.geometric_bounds());
// Dashes are laid out along the square in text space: half of each 10 pt is painted.
let solid = area(&filled(style(1.0)).unwrap());
let dash = Dash { pattern: vec![5.0, 5.0], ..Default::default() };
let dashed = area(&filled(CharStyle { stroke_dash: Some(dash), ..style(1.0) }).unwrap());
assert!(dashed < 0.7 * solid && dashed > 0.3 * solid, "{dashed} of {solid}");
}
#[test]
fn a_gradient_on_the_stroke_stays_where_the_stroke_had_it() {
let stops = vec![GradientStop::new(0.0, red()), GradientStop::new(1.0, Color::BLACK)];
let ramp = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
let mut piece = square();
let stroke = paint_type_piece(&mut piece, &CharStyle { stroke: ramp, ..style(4.0) }, BOX, Affine::scale_non_uniform(3.0, 1.0)).unwrap();
let Paint::Gradient(g) = stroke.appearance.fill_paint() else { panic!("a gradient fill") };
// Fitted across the stroke's box in text space (the square grown by half the weight), then scaled.
let geom = g.geom.expect("placed");
assert!((geom.start.x + 6.0).abs() < 1e-6 && (geom.end.x - 36.0).abs() < 1e-6, "{geom:?}");
}
+3
View File
@@ -8,6 +8,7 @@ mod contour;
mod cutting;
mod document;
mod image;
mod packaging;
mod pathtools;
mod pen;
mod select;
@@ -15,6 +16,7 @@ mod shapes;
mod typetools;
pub(crate) use image::{DecodedImages, refresh_color_masks};
pub(crate) use packaging::{role_swatch_edited, role_swatches_merged};
use super::CommandSpec;
@@ -27,6 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {
v.extend(cutting::specs());
v.extend(document::specs());
v.extend(image::specs());
v.extend(packaging::specs());
v.extend(pathtools::specs());
v.extend(pen::specs());
v.extend(select::specs());
+18
View File
@@ -0,0 +1,18 @@
//! Packaging Tools (`addon.packaging.*`), a built-in add-on for the dielines of boxes and other
//! folded packaging. A path is a fold line when its top stroke is painted with the swatch of a line
//! role: Cut, Crease, Partial Cut or Perforation ([`roles`]). The document's role table maps each
//! role to its swatch, so every format that keeps the stroke's swatch keeps the role. Its submenu
//! (Object › Plug-ins › Packaging Tools) and its Fold Lines panel are the UI's.
mod roles;
pub(crate) use roles::{role_swatch_edited, role_swatches_merged};
use super::super::CommandSpec;
pub fn specs() -> Vec<CommandSpec> {
roles::specs()
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,454 @@
//! Fold line roles (`addon.packaging.setRole`, `addon.packaging.roles`,
//! `addon.packaging.setRoleSwatch`). A path, compound path or live shape has a role when its top
//! stroke is painted with the swatch the document's role table gives that role, at any tint. The
//! table lives in [`Document::unknown`] under [`ROLES_KEY`], `{cut, crease, partialCut,
//! perforation}` each naming a swatch; a role it leaves out, or names with something other than a
//! string, takes its default swatch, named after the role.
use serde_json::{Map, Value, json};
use vectorcraft_color::swatch::REGISTRATION;
use vectorcraft_color::{Color, Paint, Swatch};
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use super::super::super::overprint::edit_counted;
use super::super::super::{CommandSpec, bad, checked_ids_or_selection, cmd, has_doc, has_selection, switch_or, text_param};
use crate::{Result, Session};
/// Document unknown key: the role table, `{role id: swatch name}`.
pub(crate) const ROLES_KEY: &str = "packagingRoles";
const SET_ROLE: &str = "addon.packaging.setRole";
const ROLES: &str = "addon.packaging.roles";
const SET_ROLE_SWATCH: &str = "addon.packaging.setRoleSwatch";
/// What a fold line does when the blank is cut and folded.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Role {
/// Separates the material.
Cut,
/// A fold.
Crease,
/// A fold cut part way through the board.
PartialCut,
/// A fold along a line of cuts.
Perforation,
}
impl Role {
pub(crate) const ALL: [Role; 4] = [Role::Cut, Role::Crease, Role::PartialCut, Role::Perforation];
/// The role's id in params and in the role table.
pub(crate) fn id(self) -> &'static str {
match self {
Role::Cut => "cut",
Role::Crease => "crease",
Role::PartialCut => "partialCut",
Role::Perforation => "perforation",
}
}
/// The role's name, which is also its default swatch's name.
pub(crate) fn name(self) -> &'static str {
match self {
Role::Cut => "Cut",
Role::Crease => "Crease",
Role::PartialCut => "Partial Cut",
Role::Perforation => "Perforation",
}
}
pub(crate) fn from_id(id: &str) -> Option<Role> {
Role::ALL.into_iter().find(|r| r.id() == id)
}
/// The color a missing role swatch is made with (VectorCraft's own values): Cut 100% magenta,
/// Crease 100% cyan, Partial Cut 100% yellow, Perforation 50% magenta and 50% cyan.
fn color(self) -> Color {
match self {
Role::Cut => Color::cmyk(0.0, 1.0, 0.0, 0.0),
Role::Crease => Color::cmyk(1.0, 0.0, 0.0, 0.0),
Role::PartialCut => Color::cmyk(0.0, 0.0, 1.0, 0.0),
Role::Perforation => Color::cmyk(0.5, 0.5, 0.0, 0.0),
}
}
fn index(self) -> usize {
Role::ALL.iter().position(|r| *r == self).unwrap_or(0)
}
}
/// The swatch each role is carried by, in [`Role::ALL`] order.
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct RoleTable([String; 4]);
impl RoleTable {
/// The document's role table, with each missing or damaged entry at its default. When a damaged
/// table names one swatch for two roles, the later role takes its default name instead, or
/// "Crease 2" and so on when an earlier role has that.
pub(crate) fn of(d: &Document) -> RoleTable {
let stored = d.unknown.get(ROLES_KEY).and_then(Value::as_object);
let mut names: Vec<String> = Vec::with_capacity(Role::ALL.len());
for r in Role::ALL {
let name = match stored.and_then(|m| m.get(r.id())).and_then(Value::as_str) {
Some(name) if !name.is_empty() && !names.iter().any(|n| n == name) => name.to_string(),
_ => {
let base = r.name();
std::iter::once(base.to_string())
.chain((2..).map(|i| format!("{base} {i}")))
.find(|n| !names.contains(n))
.unwrap_or_else(|| base.to_string())
}
};
names.push(name);
}
RoleTable(Role::ALL.map(|r| names.get(r.index()).cloned().unwrap_or_else(|| r.name().to_string())))
}
/// The swatch of `role`.
pub(crate) fn swatch(&self, role: Role) -> &str {
self.0.get(role.index()).map_or("", String::as_str)
}
/// The role swatch `name` carries.
pub(crate) fn role_of_swatch(&self, name: &str) -> Option<Role> {
Role::ALL.into_iter().find(|r| self.swatch(*r) == name)
}
/// The role of object `n`: the role of the swatch its top stroke is painted with.
pub(crate) fn role_of(&self, n: &Node) -> Option<Role> {
if !can_carry(n) {
return None;
}
match &n.appearance.stroke()?.paint {
Paint::Solid { swatch: Some(name), .. } => self.role_of_swatch(name),
_ => None,
}
}
fn to_value(&self) -> Value {
Value::Object(Role::ALL.into_iter().map(|r| (r.id().to_string(), json!(self.swatch(r)))).collect::<Map<_, _>>())
}
}
/// Swatch `from` of `d` is now named `to`, and `global` says whether it is still a global color.
/// A role it carried keeps it under the new name, as the strokes linked to it do; when it stopped
/// being global, which unlinks those strokes, the role moves to a new name that `setRole` makes a
/// swatch for. Another role that named `to` without such a swatch moves to a new name too, so no
/// two roles share a swatch.
pub(crate) fn role_swatch_edited(d: &mut Document, from: &str, to: &str, global: bool) {
let before = RoleTable::of(d);
let mut table = before.clone();
for r in Role::ALL {
let name = table.swatch(r).to_string();
let moved = if name == from && global {
Some(to.to_string())
} else if name == from || (name == to && from != to) {
Some(free_role_name(d, &table, r))
} else {
None
};
if let (Some(new), Some(slot)) = (moved, table.0.get_mut(r.index())) {
*slot = new;
}
}
if table != before {
d.unknown.insert(ROLES_KEY.to_string(), table.to_value());
}
}
/// Swatches `merged` of `d` were merged into swatch `kept`, and `linked` says whether their strokes
/// now link to it (it is a global color). When `kept` carries no role, it takes the role of the
/// first merged swatch that carried one, so the lines of that role keep it; a merged swatch's other
/// role keeps its name, which the next `setRole` makes a swatch for.
pub(crate) fn role_swatches_merged(d: &mut Document, merged: &[String], kept: &str, linked: bool) {
let mut table = RoleTable::of(d);
if !linked || table.role_of_swatch(kept).is_some() {
return;
}
let Some(role) = merged.iter().find_map(|m| table.role_of_swatch(m)) else { return };
if let Some(slot) = table.0.get_mut(role.index()) {
*slot = kept.to_string();
}
d.unknown.insert(ROLES_KEY.to_string(), table.to_value());
}
/// A name for `role`'s swatch that no swatch, color group or other role of `table` uses: the
/// role's name, else "Cut 2", "Cut 3"… The document holds finitely many names, so the search
/// always ends at a free one.
fn free_role_name(d: &Document, table: &RoleTable, role: Role) -> String {
let free = |n: &str| !d.swatch_name_taken(n) && Role::ALL.into_iter().all(|r| r == role || table.swatch(r) != n);
let base = role.name();
if free(base) {
return base.to_string();
}
(2usize..).map(|i| format!("{base} {i}")).find(|n| free(n)).unwrap_or_else(|| base.to_string())
}
/// Whether `n` can carry a role: a path (a live shape too) that is neither a clipping path nor a
/// guide, or a compound path.
fn can_carry(n: &Node) -> bool {
match &n.kind {
NodeKind::Path { clipping, guide, .. } => !clipping && !guide,
NodeKind::Compound { .. } => true,
_ => false,
}
}
/// The objects under the outermost objects `roots` that can carry a role, through groups and clip
/// groups, each once, and
/// how many of `roots` and their members can't (text, images, symbol instances and other objects).
/// With `editable`, objects that are locked or hidden, are in a locked or hidden group or layer, or
/// are on a locked artboard are left out and counted as skipped.
fn role_targets(d: &Document, roots: &[NodeId], editable: bool) -> (Vec<NodeId>, usize) {
fn walk(n: &Node, out: &mut Vec<NodeId>, skipped: &mut usize) {
match &n.kind {
NodeKind::Group { children, .. } => {
for c in children {
// A group's clipping path draws no stroke: it is skipped.
if matches!(c.kind, NodeKind::Path { clipping: true, .. }) {
*skipped += 1;
} else {
walk(c, out, skipped);
}
}
}
_ if can_carry(n) => out.push(n.id),
_ => *skipped += 1,
}
}
let (mut out, mut skipped) = (vec![], 0);
// A path of a compound path is painted with the compound's appearance: the compound takes the
// role. `roots` come from `checked_ids_or_selection`, which keeps only outermost objects, so a
// group and its member are never both roots.
let mut seen = std::collections::HashSet::new();
let compound_of = |id: NodeId| d.parent_of(id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. })));
for n in roots.iter().map(|id| compound_of(*id).unwrap_or(*id)).filter(|id| seen.insert(*id)).filter_map(|id| d.node(id)) {
walk(n, &mut out, &mut skipped);
}
if editable {
// Named directly or not, a locked or hidden object, or one in a locked or hidden group or
// layer or on a locked artboard, stays as it is.
let ok = d.editable();
let before = out.len();
out.retain(|id| ok(*id));
skipped += before - out.len();
}
(out, skipped)
}
/// Every object of the document that can carry a role, through layers and groups.
fn document_targets(d: &Document) -> Vec<NodeId> {
fn walk(n: &Node, out: &mut Vec<NodeId>) {
match &n.kind {
NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } => children.iter().for_each(|c| walk(c, out)),
_ if can_carry(n) => out.push(n.id),
_ => {}
}
}
let mut out = vec![];
d.layers.iter().for_each(|l| walk(l, &mut out));
out
}
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"addon.packaging.setRole",
"Make Fold Line",
["Object", "Plug-ins", "Packaging Tools"],
None,
"{role: cut|crease|partialCut|perforation|none, ids?: [id…] (default: the selection), overprint?: bool (true)} give each path, compound path and live shape among the objects (through groups and clip groups; objects that are locked or hidden, in a locked or hidden group or layer, or on a locked artboard are left out and counted as skipped, even when named in ids) a fold line role: its top stroke is painted with the role's swatch (addon.packaging.roles) at 100% and shown, a path without a stroke gets a 1 pt stroke, and the stroke overprints, or with overprint: false does not. A missing role swatch is made as a global spot swatch (Cut 100% magenta, Crease 100% cyan, Partial Cut 100% yellow, Perforation 50% magenta and 50% cyan, in the document's color mode; named \"Cut 2\" and so on, in the role table too, when a color group or a swatch that can't carry a role, such as a process color that is not global, has the name). none takes the role away: a role stroke keeps the color it shows, no longer linked to the swatch, and stops overprinting. Text, images, symbol instances and other objects are skipped and counted. One undo step, none when nothing changes → {ids (the objects that can carry a role), changed, skipped}",
has_selection,
set_role
),
cmd!(
query "addon.packaging.roles",
"Fold Lines",
[],
None,
"{ids?: [id…] (default: the selection)} the fold line roles → {roles: [{role: cut|crease|partialCut|perforation, name, swatch (the swatch that carries it), exists (the document has the swatch), count}], scope: ids|selection|document, selected (objects given or selected)}; count is how many of the paths, compound paths and live shapes among the objects (through groups, locked and hidden members included, each object once) have the role, or among every object of the document while nothing is selected and ids is left out",
has_doc,
roles
),
cmd!(
"addon.packaging.setRoleSwatch",
"Role Swatches…",
["Object", "Plug-ins", "Packaging Tools"],
None,
"{role: cut|crease|partialCut|perforation, swatch: a global or spot color swatch's name} make the swatch carry the role, in the document's role table, as one undo step (none when it already does). Objects stroked with the role's old swatch keep their color and no longer have the role. Refused: a missing swatch, a gradient or pattern swatch, a process color that is not global, a tint swatch, [None], [Registration], and a swatch another role has → {role, swatch, changed}",
has_doc,
set_role_swatch
),
]
}
/// The role `p` gives: `Some(None)` for `none` when `none` is allowed.
fn role_param(p: &Value, cmd: &str, none: bool) -> Result<Option<Role>> {
let id = text_param(p, "role", cmd)?.ok_or_else(|| bad(cmd, "missing `role`"))?;
match Role::from_id(id) {
Some(r) => Ok(Some(r)),
None if none && id == "none" => Ok(None),
None if none => Err(bad(cmd, format!("unknown role `{id}`: cut, crease, partialCut, perforation or none"))),
None => Err(bad(cmd, format!("unknown role `{id}`: cut, crease, partialCut or perforation"))),
}
}
/// Why swatch `name` of `d` can't carry a role, if it can't.
fn unfit_swatch(d: &Document, name: &str) -> Option<String> {
if name == REGISTRATION || name == "[None]" {
return Some(format!("`{name}` can't carry a role"));
}
let Some(sw) = d.swatch(name) else { return Some(format!("no swatch `{name}`")) };
match &sw.paint {
Paint::Solid { swatch: Some(_), .. } => Some(format!("`{name}` is a tint swatch: pick its base or another global or spot color")),
Paint::Solid { .. } if sw.global => None,
Paint::Solid { .. } => Some(format!("`{name}` is a process color: pick a global or spot color")),
_ => Some(format!("`{name}` isn't a color swatch")),
}
}
/// `role`'s swatch in `d`, made as a global spot swatch in the document's color mode when `d`
/// lacks it → its paint at 100%. When a color group or a swatch that can't carry a role (a process
/// color that is not global, a tint, a gradient) has the swatch's name, the swatch is made under a
/// free name, which the role table then gives the role.
fn role_paint(d: &mut Document, role: Role) -> Result<Paint> {
let mut table = RoleTable::of(d);
let current = table.swatch(role);
let taken = match d.swatch(current) {
Some(_) => unfit_swatch(d, current).is_some(),
None => d.swatch_name_taken(current),
};
if taken {
let free = free_role_name(d, &table, role);
if let Some(slot) = table.0.get_mut(role.index()) {
*slot = free;
}
d.unknown.insert(ROLES_KEY.to_string(), table.to_value());
}
let name = table.swatch(role);
if d.swatch(name).is_none() {
let model = d.color_mode.model();
let color = role.color();
let color = if color.model() == model {
color
} else {
let cms = vectorcraft_color::cms::active();
cms.convert(&color, model, cms.settings().intent)
};
d.swatches.push(Swatch { name: name.to_string(), paint: Paint::solid(color), global: true, spot: true });
}
if let Some(why) = unfit_swatch(d, name) {
return Err(bad(SET_ROLE, format!("{why} (the {} role's swatch; addon.packaging.setRoleSwatch picks another)", role.name())));
}
d.tint_paint(name, 1.0).ok_or_else(|| bad(SET_ROLE, format!("`{name}` isn't a global or spot color")))
}
/// Gives object `id` of `d` `role`'s `paint` (`None`: takes its role away) → whether it changed.
fn give_role(d: &mut Document, table: &RoleTable, id: NodeId, paint: Option<&Paint>, overprint: bool) -> bool {
let Some(n) = d.node_mut(id) else { return false };
let had = table.role_of(n);
let mut a = (*n.appearance).clone();
match paint {
Some(paint) => {
a.set_stroke(paint.clone());
if let Some(st) = a.stroke_mut() {
if st.width <= 0.0 {
st.width = 1.0;
}
// A hidden stroke would carry the role without drawing or printing the line.
st.visible = true;
st.overprint = overprint;
}
}
None => {
if had.is_none() {
return false;
}
if let Some(st) = a.stroke_mut() {
if let Paint::Solid { color, .. } = st.paint {
st.paint = Paint::solid(color);
}
st.overprint = false;
}
}
}
if a == *n.appearance {
return false;
}
n.appearance = vectorcraft_doc::Shared::new(a);
true
}
fn set_role(s: &mut Session, p: &Value) -> Result<Value> {
let role = role_param(p, SET_ROLE, true)?;
let overprint = switch_or(p, "overprint", true, SET_ROLE)?;
let roots = checked_ids_or_selection(s, p, SET_ROLE)?;
let (ids, skipped) = role_targets(&s.doc()?.doc, &roots, true);
if ids.is_empty() {
return Err(bad(SET_ROLE, "select a path that is neither locked nor hidden: text, images and symbol instances can't have a fold line role"));
}
let label = role.map_or("Remove Fold Line Role", |_| "Make Fold Line");
let mut changed = 0;
edit_counted(s, label, |d| {
let before = (d.swatches.len(), d.unknown.get(ROLES_KEY).cloned());
let paint = role.map(|r| role_paint(d, r)).transpose()?;
// A role swatch made again (its strokes may still name it) is a change of its own.
let made = (d.swatches.len(), d.unknown.get(ROLES_KEY).cloned()) != before;
let table = RoleTable::of(d);
changed = ids.iter().filter(|id| give_role(d, &table, **id, paint.as_ref(), overprint)).count();
Ok(changed + usize::from(made))
})?;
Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "changed": changed, "skipped": skipped }))
}
fn roles(s: &mut Session, p: &Value) -> Result<Value> {
let given = p.get("ids").is_some_and(|v| !v.is_null());
let roots = checked_ids_or_selection(s, p, ROLES)?;
let d = &s.doc()?.doc;
let (scope, ids) = match (given, roots.is_empty()) {
(true, _) => ("ids", role_targets(d, &roots, false).0),
(false, false) => ("selection", role_targets(d, &roots, false).0),
(false, true) => ("document", document_targets(d)),
};
let table = RoleTable::of(d);
let mut counts = [0usize; 4];
for r in ids.iter().filter_map(|id| d.node(*id)).filter_map(|n| table.role_of(n)) {
if let Some(c) = counts.get_mut(r.index()) {
*c += 1;
}
}
let rows: Vec<Value> = Role::ALL
.into_iter()
.zip(counts)
.map(|(r, count)| {
let swatch = table.swatch(r);
json!({ "role": r.id(), "name": r.name(), "swatch": swatch, "exists": d.swatch(swatch).is_some(), "count": count })
})
.collect();
Ok(json!({ "roles": rows, "scope": scope, "selected": roots.len() }))
}
fn set_role_swatch(s: &mut Session, p: &Value) -> Result<Value> {
let Some(role) = role_param(p, SET_ROLE_SWATCH, false)? else { return Err(bad(SET_ROLE_SWATCH, "missing `role`")) };
let name = text_param(p, "swatch", SET_ROLE_SWATCH)?.ok_or_else(|| bad(SET_ROLE_SWATCH, "missing `swatch`"))?;
let d = &s.doc()?.doc;
if let Some(why) = unfit_swatch(d, name) {
return Err(bad(SET_ROLE_SWATCH, why));
}
let mut table = RoleTable::of(d);
if let Some(other) = Role::ALL.into_iter().find(|r| *r != role && table.swatch(*r) == name) {
return Err(bad(SET_ROLE_SWATCH, format!("`{name}` already carries the {} role", other.name())));
}
if let Some(slot) = table.0.get_mut(role.index()) {
*slot = name.to_string();
}
let value = table.to_value();
let changed = RoleTable::of(d) != table;
if changed {
s.edit("Role Swatches", |d, _| {
d.unknown.insert(ROLES_KEY.to_string(), value);
Ok(())
})?;
}
Ok(json!({ "role": role.id(), "swatch": name, "changed": changed }))
}
@@ -0,0 +1,540 @@
//! Tests for Packaging Tools: fold line roles, their swatches and the role table.
use std::collections::BTreeSet;
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{AppearanceItem, Node, NodeKind};
use crate::*;
fn session(mode: &str) -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 600, "height": 400, "colorMode": mode})).unwrap();
s
}
fn id_of(v: &Value) -> NodeId {
NodeId(v["id"].as_u64().unwrap())
}
fn rect(s: &mut Session, x: f64) -> NodeId {
id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": 20, "width": 40, "height": 40})).unwrap())
}
fn node(s: &Session, id: NodeId) -> Node {
s.doc().unwrap().doc.node(id).cloned().unwrap()
}
fn steps(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
fn set_role(s: &mut Session, p: Value) -> Value {
s.execute("addon.packaging.setRole", &p).unwrap()
}
fn err(s: &mut Session, cmd: &str, p: Value) -> String {
s.execute(cmd, &p).unwrap_err().to_string()
}
fn b64(v: &Value) -> Vec<u8> {
vectorcraft_format::base64_decode(v["dataBase64"].as_str().expect("dataBase64")).unwrap()
}
/// The `roles` query's counts, in role order.
fn counts(s: &mut Session, p: Value) -> Vec<u64> {
let r = s.execute("addon.packaging.roles", &p).unwrap();
r["roles"].as_array().unwrap().iter().map(|r| r["count"].as_u64().unwrap()).collect()
}
#[test]
fn set_role_makes_the_spot_swatch_and_links_the_top_stroke() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
assert!(s.doc().unwrap().doc.swatch("Cut").is_none());
let before = steps(&s);
let r = set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert_eq!((r["changed"].as_u64(), r["skipped"].as_u64()), (Some(1), Some(0)));
assert_eq!(steps(&s), before + 1, "one undo step");
let d = &s.doc().unwrap().doc;
let sw = d.swatch("Cut").unwrap();
assert!(sw.global && sw.spot, "{sw:?}");
assert_eq!(sw.paint, Paint::solid(Color::cmyk(0.0, 1.0, 0.0, 0.0)), "100% magenta in a CMYK document");
let st = node(&s, a).appearance.stroke().cloned().unwrap();
assert!(matches!(&st.paint, Paint::Solid { swatch: Some(n), tint, .. } if n == "Cut" && *tint == 1.0), "{:?}", st.paint);
assert!(st.overprint, "role strokes overprint by default");
// Again: nothing changes, and no undo step is recorded.
let r = set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert_eq!(r["changed"].as_u64(), Some(0));
assert_eq!(steps(&s), before + 1);
// Undo takes the swatch away with the role.
s.execute("edit.undo", &json!({})).unwrap();
assert!(s.doc().unwrap().doc.swatch("Cut").is_none());
}
#[test]
fn each_role_gets_its_own_swatch_color_in_the_document_s_mode() {
let mut s = session("rgb");
for (i, role) in ["cut", "crease", "partialCut", "perforation"].into_iter().enumerate() {
let id = rect(&mut s, 20.0 + 60.0 * i as f64);
set_role(&mut s, json!({"role": role, "ids": [id.0]}));
}
let d = &s.doc().unwrap().doc;
let colors: Vec<Color> = ["Cut", "Crease", "Partial Cut", "Perforation"].iter().map(|n| d.swatch(n).unwrap().paint.color().unwrap()).collect();
assert!(colors.iter().all(|c| matches!(c, Color::Rgb { .. })), "an RGB document's swatches are RGB: {colors:?}");
assert_eq!(colors.iter().map(|c| c.to_hex()).collect::<BTreeSet<_>>().len(), 4, "four colors: {colors:?}");
}
#[test]
fn a_path_without_a_stroke_gets_one_and_overprint_can_be_left_off() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
s.edit("strip", |d, _| {
let n = d.node_mut(a).unwrap();
n.appearance.items.retain(AppearanceItem::is_fill);
Ok(())
})
.unwrap();
assert!(node(&s, a).appearance.stroke().is_none());
set_role(&mut s, json!({"role": "crease", "ids": [a.0], "overprint": false}));
let st = node(&s, a).appearance.stroke().cloned().unwrap();
assert_eq!(st.width, 1.0, "a 1 pt stroke");
assert!(!st.overprint);
assert!(matches!(&st.paint, Paint::Solid { swatch: Some(n), .. } if n == "Crease"));
assert!(err(&mut s, "addon.packaging.setRole", json!({"role": "cut", "ids": [a.0], "overprint": "yes"})).contains("overprint"));
}
#[test]
fn none_takes_the_role_away_and_keeps_the_color() {
let mut s = session("cmyk");
let (a, b) = (rect(&mut s, 20.0), rect(&mut s, 100.0));
set_role(&mut s, json!({"role": "perforation", "ids": [a.0]}));
let shown = node(&s, a).appearance.stroke().unwrap().paint.color().unwrap();
let before = steps(&s);
let r = set_role(&mut s, json!({"role": "none", "ids": [a.0, b.0]}));
assert_eq!(r["changed"].as_u64(), Some(1), "the plain rectangle has no role to take away");
assert_eq!(steps(&s), before + 1);
let st = node(&s, a).appearance.stroke().cloned().unwrap();
assert_eq!(st.paint, Paint::solid(shown));
assert!(!st.overprint);
assert_eq!(counts(&mut s, json!({"ids": [a.0, b.0]})), [0, 0, 0, 0]);
// Nothing left with a role: no undo step.
set_role(&mut s, json!({"role": "none", "ids": [a.0, b.0]}));
assert_eq!(steps(&s), before + 1);
}
#[test]
fn bad_roles_and_targets_are_refused() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
assert!(err(&mut s, "addon.packaging.setRole", json!({"role": "fold", "ids": [a.0]})).contains("unknown role"));
assert!(err(&mut s, "addon.packaging.setRole", json!({"ids": [a.0]})).contains("role"));
assert!(err(&mut s, "addon.packaging.setRole", json!({"role": 3, "ids": [a.0]})).contains("role"));
s.execute("select.none", &json!({})).unwrap();
assert!(s.execute("addon.packaging.setRole", &json!({"role": "cut"})).is_err(), "nothing selected");
let t = id_of(&s.execute("text.create", &json!({"x": 20, "y": 200, "text": "Lid", "size": 20})).unwrap());
let before = steps(&s);
assert!(err(&mut s, "addon.packaging.setRole", json!({"role": "cut", "ids": [t.0]})).contains("select a path"));
assert_eq!(steps(&s), before);
assert!(s.doc().unwrap().doc.swatch("Cut").is_none(), "a refused run makes no swatch");
// Text beside a path is skipped and counted.
let r = set_role(&mut s, json!({"role": "cut", "ids": [a.0, t.0]}));
assert_eq!((r["changed"].as_u64(), r["skipped"].as_u64()), (Some(1), Some(1)));
}
#[test]
fn groups_are_walked_and_their_locked_and_hidden_members_left_out() {
let mut s = session("cmyk");
let (a, b, c) = (rect(&mut s, 20.0), rect(&mut s, 100.0), rect(&mut s, 180.0));
s.execute("select.set", &json!({"ids": [a.0, b.0, c.0]})).unwrap();
let g = id_of(&s.execute("object.group", &json!({})).unwrap());
s.edit("lock", |d, _| {
d.node_mut(b).unwrap().locked = true;
d.node_mut(c).unwrap().visible = false;
Ok(())
})
.unwrap();
let r = set_role(&mut s, json!({"role": "crease", "ids": [g.0]}));
assert_eq!(r["ids"], json!([a.0]));
assert_eq!(r["skipped"].as_u64(), Some(2), "the locked and the hidden member");
assert_eq!(counts(&mut s, json!({"ids": [g.0]})), [0, 1, 0, 0]);
// Named directly, a locked or hidden path is left out too.
let r = set_role(&mut s, json!({"role": "cut", "ids": [a.0, b.0, c.0]}));
assert_eq!((r["ids"].clone(), r["skipped"].as_u64()), (json!([a.0]), Some(2)));
let before = steps(&s);
assert!(err(&mut s, "addon.packaging.setRole", json!({"role": "cut", "ids": [b.0]})).contains("locked"));
assert_eq!(steps(&s), before);
assert_eq!(counts(&mut s, json!({"ids": [b.0, c.0]})), [0, 0, 0, 0]);
}
#[test]
fn a_clip_group_s_clipping_path_is_skipped_and_counted() {
let mut s = session("cmyk");
let (art, mask) = (rect(&mut s, 20.0), rect(&mut s, 30.0));
s.execute("select.set", &json!({"ids": [art.0, mask.0]})).unwrap();
let g = id_of(&s.execute("object.clippingMask.make", &json!({})).unwrap());
let r = set_role(&mut s, json!({"role": "cut", "ids": [g.0]}));
assert_eq!((r["ids"].clone(), r["skipped"].as_u64()), (json!([art.0]), Some(1)), "the clipping path is left out and counted");
}
#[test]
fn a_group_and_its_member_count_once_and_locked_lines_count_in_every_scope() {
let mut s = session("cmyk");
let (a, b) = (rect(&mut s, 20.0), rect(&mut s, 100.0));
set_role(&mut s, json!({"role": "cut", "ids": [b.0]}));
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let g = id_of(&s.execute("object.group", &json!({})).unwrap());
let r = set_role(&mut s, json!({"role": "crease", "ids": [g.0, a.0]}));
assert_eq!(r["ids"], json!([a.0, b.0]), "each path once");
assert_eq!(counts(&mut s, json!({"ids": [g.0, a.0]})), [0, 2, 0, 0]);
set_role(&mut s, json!({"role": "cut", "ids": [b.0]}));
s.edit("lock", |d, _| {
d.node_mut(b).unwrap().locked = true;
Ok(())
})
.unwrap();
// A locked line keeps its role and is counted, whether its group is selected or not.
assert_eq!(counts(&mut s, json!({"ids": [g.0]})), [1, 1, 0, 0]);
s.execute("select.none", &json!({})).unwrap();
assert_eq!(counts(&mut s, json!({})), [1, 1, 0, 0]);
}
#[test]
fn a_process_swatch_named_like_a_role_swatch_keeps_its_name() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
s.execute("swatch.new", &json!({"name": "Cut", "color": "#ff0000"})).unwrap();
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
let d = &s.doc().unwrap().doc;
assert_eq!(d.unknown.get("packagingRoles").unwrap()["cut"], json!("Cut 2"));
assert!(d.swatch("Cut 2").is_some_and(|w| w.spot), "the role swatch is made beside it");
assert!(d.swatch("Cut").is_some_and(|w| !w.global), "the process swatch is left as it was");
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [1, 0, 0, 0]);
}
#[test]
fn the_free_role_swatch_name_is_searched_past_ten_thousand() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
let taken = std::iter::once("Cut".to_string()).chain((2..10_000).map(|i| format!("Cut {i}"))).chain(["Cut 10004".to_string()]);
let process = |name: String| vectorcraft_color::Swatch { name, paint: Paint::solid(Color::rgb(1.0, 0.0, 0.0)), global: false, spot: false };
Arc::make_mut(&mut s.doc_mut().unwrap().doc).swatches.extend(taken.map(process));
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
let d = &s.doc().unwrap().doc;
assert_eq!(d.unknown.get("packagingRoles").unwrap()["cut"], json!("Cut 10000"));
assert!(d.swatch("Cut 10000").is_some_and(|w| w.spot), "the role swatch is made under the first free name");
assert!(d.swatch("Cut 10004").is_some_and(|w| !w.global), "a taken name is left as it was");
}
#[test]
fn a_merged_role_swatch_hands_its_role_to_the_kept_swatch() {
let mut s = session("cmyk");
let (a, b) = (rect(&mut s, 20.0), rect(&mut s, 100.0));
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
set_role(&mut s, json!({"role": "crease", "ids": [b.0]}));
s.execute("swatch.new", &json!({"name": "Die", "color": {"model": "cmyk", "c": 0, "m": 0.8, "y": 0.2, "k": 0}, "spot": true})).unwrap();
s.execute("swatch.merge", &json!({"names": ["Die", "Cut"]})).unwrap();
assert_eq!(s.doc().unwrap().doc.unknown.get("packagingRoles").unwrap()["cut"], json!("Die"));
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [1, 0, 0, 0], "the cut line is still a cut line");
// A kept swatch that already carries a role keeps it; the merged role's lines take it.
s.execute("swatch.merge", &json!({"names": ["Crease", "Die"]})).unwrap();
let table = s.doc().unwrap().doc.unknown.get("packagingRoles").cloned().unwrap();
assert_eq!((&table["cut"], &table["crease"]), (&json!("Die"), &json!("Crease")), "{table}");
assert_eq!(counts(&mut s, json!({"ids": [a.0, b.0]})), [0, 2, 0, 0]);
// The next Make Cut Line makes the Cut role's swatch again.
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert!(s.doc().unwrap().doc.swatch("Die").is_some_and(|w| w.spot));
assert_eq!(counts(&mut s, json!({"ids": [a.0, b.0]})), [1, 1, 0, 0]);
}
#[test]
fn a_global_process_swatch_can_carry_a_role() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
s.execute("swatch.new", &json!({"name": "Die", "color": {"model": "cmyk", "c": 0, "m": 0.8, "y": 0.2, "k": 0}, "global": true})).unwrap();
s.execute("addon.packaging.setRoleSwatch", &json!({"role": "partialCut", "swatch": "Die"})).unwrap();
set_role(&mut s, json!({"role": "partialCut", "ids": [a.0]}));
assert!(matches!(&node(&s, a).appearance.stroke().unwrap().paint, Paint::Solid { swatch: Some(n), .. } if n == "Die"));
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [0, 0, 1, 0]);
}
#[test]
fn roles_counts_the_selection_or_the_whole_document() {
let mut s = session("cmyk");
let (a, b, c) = (rect(&mut s, 20.0), rect(&mut s, 100.0), rect(&mut s, 180.0));
set_role(&mut s, json!({"role": "cut", "ids": [a.0, b.0]}));
set_role(&mut s, json!({"role": "partialCut", "ids": [c.0]}));
s.execute("select.set", &json!({"ids": [a.0, c.0]})).unwrap();
let r = s.execute("addon.packaging.roles", &json!({})).unwrap();
assert_eq!((r["scope"].as_str(), r["selected"].as_u64()), (Some("selection"), Some(2)));
assert_eq!(counts(&mut s, json!({})), [1, 0, 1, 0]);
s.execute("select.none", &json!({})).unwrap();
let r = s.execute("addon.packaging.roles", &json!({})).unwrap();
assert_eq!((r["scope"].as_str(), r["selected"].as_u64()), (Some("document"), Some(0)));
assert_eq!(counts(&mut s, json!({})), [2, 0, 1, 0]);
let rows = r["roles"].as_array().unwrap();
assert_eq!(rows[0], json!({"role": "cut", "name": "Cut", "swatch": "Cut", "exists": true, "count": 2}));
assert_eq!(rows[1]["exists"], json!(false), "no Crease swatch yet");
}
#[test]
fn role_swatches_maps_a_role_to_another_swatch() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
s.execute("swatch.new", &json!({"name": "Die", "color": {"model": "cmyk", "c": 0, "m": 0.8, "y": 0.2, "k": 0}, "spot": true})).unwrap();
let before = steps(&s);
let r = s.execute("addon.packaging.setRoleSwatch", &json!({"role": "cut", "swatch": "Die"})).unwrap();
assert_eq!(r["changed"], json!(true));
assert_eq!(steps(&s), before + 1);
assert_eq!(s.doc().unwrap().doc.unknown.get("packagingRoles").unwrap()["cut"], json!("Die"));
// The old swatch's objects keep their color and lose the role.
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [0, 0, 0, 0]);
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert!(matches!(&node(&s, a).appearance.stroke().unwrap().paint, Paint::Solid { swatch: Some(n), .. } if n == "Die"));
// The same mapping again changes nothing.
let steps_now = steps(&s);
let r = s.execute("addon.packaging.setRoleSwatch", &json!({"role": "cut", "swatch": "Die"})).unwrap();
assert_eq!((r["changed"].clone(), steps(&s)), (json!(false), steps_now));
}
#[test]
fn a_renamed_role_swatch_keeps_its_role() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
set_role(&mut s, json!({"role": "crease", "ids": [a.0]}));
s.execute("swatch.edit", &json!({"name": "Crease", "newName": "Score"})).unwrap();
assert_eq!(s.doc().unwrap().doc.unknown.get("packagingRoles").unwrap()["crease"], json!("Score"));
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [0, 1, 0, 0]);
// A swatch that carries no role leaves the table alone.
s.execute("swatch.new", &json!({"name": "Ink", "color": {"model": "cmyk", "c": 0, "m": 1, "y": 1, "k": 0}, "spot": true})).unwrap();
s.execute("swatch.edit", &json!({"name": "Ink", "newName": "Red Ink"})).unwrap();
let table = s.doc().unwrap().doc.unknown.get("packagingRoles").cloned().unwrap();
assert_eq!(table, json!({"cut": "Cut", "crease": "Score", "partialCut": "Partial Cut", "perforation": "Perforation"}));
// Undo puts the old name back in the table with the swatch.
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert!(s.doc().unwrap().doc.unknown.get("packagingRoles").is_none());
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [0, 1, 0, 0]);
}
#[test]
fn a_role_swatch_renamed_to_another_role_s_name_leaves_each_role_its_own_swatch() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
// No Crease swatch exists yet, so the name is free for the Cut swatch.
s.execute("swatch.edit", &json!({"name": "Cut", "newName": "Crease"})).unwrap();
let table = s.doc().unwrap().doc.unknown.get("packagingRoles").cloned().unwrap();
assert_eq!((&table["cut"], &table["crease"]), (&json!("Crease"), &json!("Crease 2")), "{table}");
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [1, 0, 0, 0], "the line is still a cut line");
}
#[test]
fn a_role_swatch_that_stops_being_global_hands_its_role_to_a_new_swatch() {
let mut s = session("cmyk");
let (a, b) = (rect(&mut s, 20.0), rect(&mut s, 100.0));
set_role(&mut s, json!({"role": "perforation", "ids": [a.0]}));
s.execute("swatch.edit", &json!({"name": "Perforation", "spot": false, "global": false})).unwrap();
assert_eq!(s.doc().unwrap().doc.unknown.get("packagingRoles").unwrap()["perforation"], json!("Perforation 2"));
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [0, 0, 0, 0], "the unlinked stroke has no role");
set_role(&mut s, json!({"role": "perforation", "ids": [b.0]}));
assert!(s.doc().unwrap().doc.swatch("Perforation 2").is_some_and(|w| w.spot));
assert_eq!(counts(&mut s, json!({"ids": [b.0]})), [0, 0, 0, 1]);
}
#[test]
fn a_color_group_named_like_a_role_swatch_keeps_its_name() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
s.execute("swatch.newGroup", &json!({"name": "Cut", "colors": ["#ff0000"]})).unwrap();
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
let d = &s.doc().unwrap().doc;
assert_eq!(d.unknown.get("packagingRoles").unwrap()["cut"], json!("Cut 2"));
assert!(d.swatch("Cut 2").is_some_and(|w| w.spot) && d.swatch("Cut").is_none());
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [1, 0, 0, 0]);
}
#[test]
fn set_role_makes_a_deleted_role_swatch_again_for_strokes_that_still_name_it() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
s.execute("swatch.delete", &json!({"name": "Cut", "unlink": false})).unwrap();
assert!(s.doc().unwrap().doc.swatch("Cut").is_none());
let before = steps(&s);
let r = set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert_eq!(r["changed"].as_u64(), Some(0), "the stroke already names the swatch");
assert!(s.doc().unwrap().doc.swatch("Cut").is_some_and(|w| w.spot), "the swatch is back");
assert_eq!(steps(&s), before + 1, "as one undo step");
}
#[test]
fn a_hidden_stroke_is_shown_when_it_takes_a_role() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
s.edit("hide", |d, _| {
if let Some(AppearanceItem::Stroke(st)) = d.node_mut(a).unwrap().appearance.items.iter_mut().find(|i| !i.is_fill()) {
st.visible = false;
}
Ok(())
})
.unwrap();
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert!(node(&s, a).appearance.stroke().unwrap().visible);
}
#[test]
fn role_swatches_refuses_swatches_that_cannot_carry_a_role() {
let mut s = session("cmyk");
let ramp = json!({"type": "linear", "stops": [{"offset": 0, "color": "#000000"}, {"offset": 1, "color": "#ffffff"}]});
s.execute("swatch.new", &json!({"name": "Ramp", "gradient": ramp})).unwrap();
s.execute("swatch.new", &json!({"name": "Plain", "color": "#336699"})).unwrap();
s.execute("swatch.new", &json!({"name": "Ink", "color": {"model": "cmyk", "c": 0, "m": 1, "y": 1, "k": 0}, "spot": true})).unwrap();
s.execute("swatch.new", &json!({"name": "Ink Tint", "swatch": "Ink", "tint": 0.5})).unwrap();
s.execute("swatch.new", &json!({"name": "Crease", "color": {"model": "cmyk", "c": 1, "m": 0, "y": 0, "k": 0}, "spot": true})).unwrap();
let before = steps(&s);
for (swatch, says) in [
("Nope", "no swatch"),
("Ramp", "isn't a color swatch"),
("Plain", "process color"),
("Ink Tint", "tint swatch"),
("[None]", "can't carry a role"),
("[Registration]", "can't carry a role"),
("Crease", "already carries the Crease role"),
] {
let e = err(&mut s, "addon.packaging.setRoleSwatch", json!({"role": "cut", "swatch": swatch}));
assert!(e.contains(says), "{swatch}: {e}");
}
assert!(err(&mut s, "addon.packaging.setRoleSwatch", json!({"role": "none", "swatch": "Ink"})).contains("unknown role"));
assert!(err(&mut s, "addon.packaging.setRoleSwatch", json!({"role": "cut"})).contains("swatch"));
assert_eq!(steps(&s), before, "no refusal records an undo step");
}
#[test]
fn a_damaged_role_table_reads_as_the_defaults() {
let mut s = session("cmyk");
s.edit("damage", |d, _| {
d.unknown.insert("packagingRoles".into(), json!({"cut": 5, "crease": "", "partialCut": null, "extra": "x"}));
Ok(())
})
.unwrap();
let r = s.execute("addon.packaging.roles", &json!({})).unwrap();
let swatches: Vec<&str> = r["roles"].as_array().unwrap().iter().map(|r| r["swatch"].as_str().unwrap()).collect();
assert_eq!(swatches, ["Cut", "Crease", "Partial Cut", "Perforation"]);
s.edit("not an object", |d, _| {
d.unknown.insert("packagingRoles".into(), json!("Cut"));
Ok(())
})
.unwrap();
let a = rect(&mut s, 20.0);
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
assert_eq!(counts(&mut s, json!({"ids": [a.0]})), [1, 0, 0, 0]);
// One swatch named for two roles: the later role takes its own default.
s.edit("duplicate", |d, _| {
d.unknown.insert("packagingRoles".into(), json!({"cut": "Crease", "crease": "Crease", "partialCut": "Cut"}));
Ok(())
})
.unwrap();
let r = s.execute("addon.packaging.roles", &json!({})).unwrap();
let swatches: Vec<&str> = r["roles"].as_array().unwrap().iter().map(|r| r["swatch"].as_str().unwrap()).collect();
assert_eq!(swatches, ["Crease", "Crease 2", "Cut", "Perforation"]);
let b = rect(&mut s, 100.0);
set_role(&mut s, json!({"role": "crease", "ids": [b.0]}));
assert_eq!(counts(&mut s, json!({"ids": [b.0]})), [0, 1, 0, 0], "the crease line is a crease line");
}
#[test]
fn native_save_and_open_keep_the_role_table_and_the_roles() {
let mut s = session("cmyk");
let a = rect(&mut s, 20.0);
s.execute("swatch.new", &json!({"name": "Die", "color": {"model": "cmyk", "c": 0, "m": 0.8, "y": 0.2, "k": 0}, "spot": true})).unwrap();
s.execute("addon.packaging.setRoleSwatch", &json!({"role": "cut", "swatch": "Die"})).unwrap();
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
let saved = s.execute("document.export", &json!({"format": "vectorcraft"})).unwrap();
s.execute("document.open", &json!({"name": "box.vectorcraft", "dataBase64": saved["dataBase64"]})).unwrap();
assert_eq!(s.doc().unwrap().doc.unknown.get("packagingRoles").unwrap()["cut"], json!("Die"));
s.execute("select.none", &json!({})).unwrap();
assert_eq!(counts(&mut s, json!({})), [1, 0, 0, 0]);
}
/// A document with one rectangle of each of Cut and Crease.
fn two_roles() -> Session {
let mut s = session("cmyk");
let (a, b) = (rect(&mut s, 20.0), rect(&mut s, 100.0));
set_role(&mut s, json!({"role": "cut", "ids": [a.0]}));
set_role(&mut s, json!({"role": "crease", "ids": [b.0]}));
s
}
fn export(s: &mut Session, format: &str) -> String {
String::from_utf8_lossy(&b64(&s.execute("document.export", &json!({"format": format})).unwrap())).into_owned()
}
#[test]
fn pdf_prints_each_role_on_its_swatch_s_separation_and_overprints_it() {
let mut s = two_roles();
let c = rect(&mut s, 180.0);
set_role(&mut s, json!({"role": "partialCut", "ids": [c.0]}));
let bytes = vectorcraft_pdf::export(
&s.doc().unwrap().doc,
&vectorcraft_pdf::PdfOptions { created: Some(0), ..vectorcraft_pdf::PdfOptions::uncompressed() },
)
.unwrap();
let pdf = String::from_utf8_lossy(&bytes);
assert!(pdf.contains("/Separation/Cut"), "the Cut line prints on the Cut plate");
assert!(pdf.contains("/Separation/Crease"));
assert!(pdf.contains("/Separation/Partial#20Cut"), "a name with a space");
assert!(pdf.contains("/OP true"), "the role strokes overprint");
// Without overprint, nothing in the file overprints.
let mut plain = session("cmyk");
let (a, b) = (rect(&mut plain, 20.0), rect(&mut plain, 100.0));
set_role(&mut plain, json!({"role": "cut", "ids": [a.0], "overprint": false}));
set_role(&mut plain, json!({"role": "crease", "ids": [b.0], "overprint": false}));
let bytes = vectorcraft_pdf::export(
&plain.doc().unwrap().doc,
&vectorcraft_pdf::PdfOptions { created: Some(0), ..vectorcraft_pdf::PdfOptions::uncompressed() },
)
.unwrap();
assert!(!String::from_utf8_lossy(&bytes).contains("/OP true"));
assert!(!export(&mut s, "pdf").is_empty());
}
#[test]
fn svg_dxf_and_hpgl_keep_the_default_role_swatches_apart() {
let mut s = two_roles();
let svg = export(&mut s, "svg");
let strokes: BTreeSet<&str> = svg.split("stroke=\"").skip(1).filter_map(|t| t.split('"').next()).filter(|c| c.starts_with('#')).collect();
let strokes = if strokes.is_empty() {
svg.split("stroke:").skip(1).filter_map(|t| t.split([';', '"', '}']).next()).filter(|c| c.starts_with('#')).collect()
} else {
strokes
};
assert_eq!(strokes.len(), 2, "two stroke colors: {svg}");
let dxf = export(&mut s, "dxf");
let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
// The rectangles' white fills come out as true colors too.
let colors: BTreeSet<&str> = lines.windows(2).filter(|w| w[0] == "420" && w[1] != "16777215").map(|w| w[1]).collect();
assert_eq!(colors.len(), 2, "two stroke true colors: {colors:?}");
let plot = s.execute("document.export", &json!({"format": "hpgl", "hpglVersion": "hpgl2"})).unwrap();
let plot = String::from_utf8_lossy(&b64(&plot)).into_owned();
assert!(plot.contains("SP1") && plot.contains("SP2"), "a pen per role swatch color: {plot}");
}
#[test]
fn compound_paths_carry_a_role() {
let mut s = session("cmyk");
let (a, b) = (rect(&mut s, 20.0), rect(&mut s, 30.0));
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let c = id_of(&s.execute("object.compoundPath.make", &json!({})).unwrap());
assert!(matches!(node(&s, c).kind, NodeKind::Compound { .. }));
let r = set_role(&mut s, json!({"role": "cut", "ids": [c.0]}));
assert_eq!(r["ids"], json!([c.0]));
assert_eq!(counts(&mut s, json!({"ids": [c.0]})), [1, 0, 0, 0]);
// A member named by id gives its compound the role.
let r = set_role(&mut s, json!({"role": "crease", "ids": [a.0, b.0]}));
assert_eq!((r["ids"].clone(), r["changed"].as_u64()), (json!([c.0]), Some(1)));
assert_eq!(counts(&mut s, json!({"ids": [c.0]})), [0, 1, 0, 0]);
}
+1 -1
View File
@@ -126,7 +126,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Live Paint Bucket (Stroke)",
[],
None,
"{group: id, point: [x,y], color?|swatch?|none? (default: current stroke), width?: pt (default: current weight), tolerance?: pt (4), scope?: \"one\" (default: the edge alone) | \"connected\" (a double-click: also each edge joined to it, end to end, through edges that draw with stroke paint match) | \"samePaint\" (a triple-click: also every edge of the group that draws with stroke paint match), match?: paint (as the document stores it; scope connected or samePaint only; default: the stroke paint the edge draws with; an edge draws with the paint of its topmost stroke that is shown, with paint, above 0 pt and not fully transparent, and with none when the edge is fully transparent or has no such stroke), tint?: 0..100, keepModel?: bool (both as paint.setFill)} paint the edge nearest point, skipping hidden edges: each edge reached has its strokes replaced by one stroke with the paint and width, shown, fully opaque and blending normally, in the place of its topmost stroke and with the dashes, caps and arrowheads of its topmost shown stroke (a new stroke above the fills when it has none; none leaves one stroke of none), and its fills stay as they are; when every edge it reaches already has only that one stroke (at any width for none), nothing changes (no undo step, and the recent colors stay as they are) → {group, edge, count (edges reached)}",
"{group: id, point: [x,y], color?|swatch?|none? (default: current stroke), width?: pt (default: current weight), tolerance?: pt (4), scope?: \"one\" (default: the edge alone) | \"connected\" (a double-click: also each edge joined to it, end to end, through edges that draw with stroke paint match) | \"samePaint\" (a triple-click: also every edge of the group that draws with stroke paint match), match?: paint (as the document stores it; scope connected or samePaint only; default: the stroke paint the edge draws with; an edge draws with the paint of its topmost stroke that is shown, with paint, above 0 pt and not fully transparent, and with none when the edge is fully transparent or has no such stroke), through?: [id…] (scope connected only; at most 4096 edges counted as drawing with stroke paint match whatever they draw with, such as the edge a double-click's first click painted), tint?: 0..100, keepModel?: bool (both as paint.setFill)} paint the edge nearest point, skipping hidden edges: each edge reached has its strokes replaced by one stroke with the paint and width, shown, fully opaque and blending normally, in the place of its topmost stroke and with the dashes, caps and arrowheads of its topmost shown stroke (a new stroke above the fills when it has none; none leaves one stroke of none), and its fills stay as they are; when every edge it reaches already has only that one stroke (at any width for none), nothing changes (no undo step, and the recent colors stay as they are) → {group, edge, count (edges reached)}",
has_doc,
lp_stroke_edge
),
+11 -1
View File
@@ -567,6 +567,16 @@ pub(super) fn lp_stroke_edge(s: &mut Session, p: &Value) -> Result<Value> {
let tol = number_or(p, "tolerance", 4.0, C)?.clamp(0.0, 1000.0);
let scope = scope_param(p, C)?;
let like = match_param(p, C, scope != LpScope::One, "\"connected\" or \"samePaint\"")?;
let through: Vec<NodeId> = match p.get("through") {
None => vec![],
Some(_) if scope != LpScope::Connected => return Err(bad(C, "through applies to scope \"connected\"")),
Some(v) => {
let ids = v.as_array().filter(|ids| ids.len() <= 4096).ok_or_else(|| bad(C, "through must be an array of at most 4096 edge ids"))?;
ids.iter()
.map(|id| id.as_u64().map(NodeId).ok_or_else(|| bad(C, "through must be an array of at most 4096 edge ids")))
.collect::<Result<_>>()?
}
};
let (eid, count, changed) = {
let d = &s.doc()?.doc;
let n = d.node(g).filter(|n| is_live_paint(n)).ok_or_else(|| bad(C, format!("{g} is not a Live Paint group")))?;
@@ -575,7 +585,7 @@ pub(super) fn lp_stroke_edge(s: &mut Session, p: &Value) -> Result<Value> {
let like = like.unwrap_or_else(|| b::lp_stroke_paint(start));
let targets = match scope {
LpScope::One => vec![eid],
LpScope::Connected => b::connected_edges(n, eid, &like),
LpScope::Connected => b::connected_edges_through(n, eid, &like, &through),
LpScope::SamePaint => std::iter::once(eid)
.chain(b::edges(n).into_iter().filter(|e| e.visible && e.id != eid && b::lp_stroke_paint(e) == like).map(|e| e.id))
.collect(),
+29 -1
View File
@@ -595,6 +595,8 @@ struct Relink {
styles: BTreeMap<u32, u32>,
/// Swatch (its name in the document) → the colour linked colours show at 100 %.
colors: BTreeMap<String, Color>,
/// Leave graphic style links as they are ([`Clipboard::show_merged_colors`]).
keep_styles: bool,
}
impl Relink {
@@ -674,7 +676,9 @@ impl Relink {
/// Relink a node tree (the mirror of [`node_refs`]).
fn node(&self, n: &mut Node) {
self.appearance(&mut n.appearance);
n.extras_mut().graphic_style = n.extras().graphic_style.and_then(|id| self.styles.get(&id).copied());
if !self.keep_styles {
n.extras_mut().graphic_style = n.extras().graphic_style.and_then(|id| self.styles.get(&id).copied());
}
if let Some(m) = n.extras_if_any().and_then(|e| e.mask.as_mut()) {
self.node(Arc::make_mut(&mut m.art));
}
@@ -1109,6 +1113,30 @@ impl Clipboard {
self.import_used(d, &self.used(), choices, same_doc)
}
/// Give the objects' colors linked to a global or spot swatch whose conflict with `d`
/// `choices` merge the color that swatch has in `d`, as pasting into `d` gives them (Paste
/// without Formatting sets its pie legend labels' contrast from the wedge colors before it
/// pastes). Nothing changes for the document the objects came from (`same_doc`).
pub(crate) fn show_merged_colors(&mut self, d: &Document, choices: &SwatchChoices, same_doc: bool) {
if same_doc {
return;
}
let used = self.used();
let colors: BTreeMap<String, Color> = self
.conflicts(d, &used)
.into_iter()
.filter(|(w, _)| choices.of(&w.name) == SwatchChoice::Merge)
.filter_map(|(w, _)| d.global_color(&w.name).map(|c| (w.name.clone(), c)))
.collect();
if colors.is_empty() {
return;
}
let relink = Relink { colors, keep_styles: true, ..Default::default() };
for n in &mut self.nodes {
relink.node(n);
}
}
/// [`Self::import_into`] for the resources `used` names. Each style, symbol, pattern and brush
/// comes after the styles, symbols, patterns and brushes it uses ([`use_order`]), so that it is
/// compared and relinked with their names here, and each loop of definitions that use each
+8 -2
View File
@@ -227,12 +227,18 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
let Some(p0) = pts.first_mut() else { return Err(bad(C, "needs points")) };
*p0 = end;
if pts.len() < 2 {
// No stroke to add: the brush alone changes, when it is not the path's already.
// No stroke to add: the brush alone changes, when it is not the path's already, and the
// path is selected or deselected as a longer continuation leaves it.
if let Some(name) = brush_name
&& s.doc()?.doc.node(target).and_then(|n| n.appearance.stroke()).is_some_and(|st| st.brush.as_deref() != Some(name))
{
s.edit("Paintbrush", |d, _| {
s.edit("Paintbrush", |d, sel| {
set_brush(d, target, name);
if keep_selected {
sel.set([id]);
} else {
sel.remove(id);
}
Ok(())
})?;
}
+8 -2
View File
@@ -367,7 +367,8 @@ fn edit_effects(
/// [`edit_effects`] for several effects of one list (`indices`): `f` gets each target's list and
/// the positions of `indices` there, ascending; with `aligned`, a position a target doesn't share
/// is left out of it, and a target sharing none of them is left out.
/// is left out of it, and a target sharing none of them is left out. A position no target has is
/// an error with `none`, and nothing changes.
#[allow(clippy::too_many_arguments)]
fn edit_effects_at(
s: &mut Session,
@@ -396,7 +397,12 @@ fn edit_effects_at(
// Each target's list and the positions in it, in the order the targets first come up.
let mut targets: Vec<(NodeId, Option<usize>, Vec<usize>)> = vec![];
for &index in indices {
for (id, at, i) in effect_targets(s, p, item, index, cmd)? {
let found = effect_targets(s, p, item, index, cmd)?;
// An aligned effect of a design's art that no other object has is refused, as it is given alone.
if found.is_empty() {
return Err(EngineError::Other(none.into()));
}
for (id, at, i) in found {
match targets.iter_mut().find(|t| t.0 == id && t.1 == at) {
Some(t) => t.2.push(i),
None => targets.push((id, at, vec![i])),
+8 -5
View File
@@ -265,18 +265,21 @@ fn gradient_expands(d: &Document, l: &Node) -> bool {
/// Whether type `t` has a gradient fill that Fill expands once Object has outlined it: one of the
/// paths `type.createOutlines` makes of its glyphs, ruby glyphs and underline and strikethrough
/// bars, each painted as its run with its unplaced gradients fitted to the layout's bounds, has one
/// bars, each painted as its run with its unplaced gradients fitted to the layout's bounds, or the
/// path filled with its run's stroke under a transform that is not a similarity, has one
/// ([`gradient_expands`] on that path). Inline graphics and color glyphs become other art. Leaves
/// the document as it is and stops at the first such path.
fn text_gradient_expands(d: &Document, t: &TextObject) -> bool {
if !t.runs.iter().any(|r| matches!(r.style.fill, Paint::Gradient(_))) {
let gradient =
|st: &vectorcraft_doc::CharStyle| matches!(st.fill, Paint::Gradient(_)) || (st.has_stroke() && matches!(st.stroke, Paint::Gradient(_)));
if !t.runs.iter().any(|r| gradient(&r.style)) {
return false;
}
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
let first = t.first_style();
let expands = |run: usize, outline: &BezPath| {
let style = t.runs.get(run).map_or(&first, |r| &r.style);
if !matches!(style.fill, Paint::Gradient(_)) {
if !gradient(style) {
return false;
}
let path = PathData::from_bezpath(outline);
@@ -284,8 +287,8 @@ fn text_gradient_expands(d: &Document, t: &TextObject) -> bool {
return false;
}
let mut piece = Node::path(NodeId(u64::MAX), path, Appearance::default());
vectorcraft_render::effects::paint_type_piece(&mut piece, style, lay.bounds, t.xf);
gradient_expands(d, &piece)
let stroke = vectorcraft_render::effects::paint_type_piece(&mut piece, style, lay.bounds, t.xf);
gradient_expands(d, &piece) || stroke.is_some_and(|s| gradient_expands(d, &s))
};
let inline = |gi: usize| lay.inlines.iter().find(|i| i.glyph == gi).is_some_and(|i| t.runs.get(i.run).is_some_and(|r| r.inline.is_some()));
lay.glyphs.iter().enumerate().any(|(gi, g)| !inline(gi) && g.image.is_none() && g.colour.is_none() && expands(g.run, &g.outline))
File diff suppressed because one or more lines are too long
+40 -15
View File
@@ -174,23 +174,48 @@ pub fn resolution(bytes: &[u8]) -> Option<(f64, f64)> {
/// blocks whose signature is `8BIM` are given.
pub(super) fn resources(resources: &[u8], signed: bool) -> impl Iterator<Item = (u16, &[u8], &[u8])> {
let mut r = Reader::new(resources);
std::iter::from_fn(move || {
if r.rest().is_empty() {
return None;
std::iter::from_fn(move || if r.rest().is_empty() { None } else { block(&mut r).ok() })
.filter(move |(ours, ..)| *ours || !signed)
.map(|(_, id, name, data)| (id, name, data))
}
/// The data of the first `8BIM` image resource block `id` of `resources`. `None` when there is
/// none before the blocks end or before a block that is cut short ahead of it. An error when
/// that block itself is cut short.
pub(super) fn resource(resources: &[u8], id: u16) -> Result<Option<&[u8]>, String> {
let mut r = Reader::new(resources);
while !r.rest().is_empty() {
match block(&mut r) {
Ok((true, i, _, data)) if i == id => return Ok(Some(data)),
Ok(_) => {}
Err(Some((true, i))) if i == id => return Err(TRUNCATED.into()),
Err(_) => return Ok(None),
}
let ours = r.take(4).ok()? == b"8BIM";
let id = r.u16().ok()?;
}
Ok(None)
}
/// An image resource block: whether its signature is `8BIM`, its id, its name (the bytes of its
/// Pascal string) and its data.
type Block<'a> = (bool, u16, &'a [u8], &'a [u8]);
/// The image resource block that `r` starts with. When it is cut short, the error gives whether
/// its signature is `8BIM` and its id, when those were read.
fn block<'a>(r: &mut Reader<'a>) -> Result<Block<'a>, Option<(bool, u16)>> {
let ours = r.take(4).map_err(|_| None)? == b"8BIM";
let id = r.u16().map_err(|_| None)?;
let mut rest = || -> Result<(&'a [u8], &'a [u8]), String> {
// A Pascal string padded to an even size, length byte included.
let len = usize::from(r.u8().ok()?);
let name = r.take(len).ok()?;
r.take((len + 1) % 2).ok()?;
let size = usize::try_from(r.u32().ok()?).ok()?;
let data = r.take(size).ok()?;
r.take(size % 2).ok()?;
Some((ours, id, name, data))
})
.filter(move |(ours, ..)| *ours || !signed)
.map(|(_, id, name, data)| (id, name, data))
let len = usize::from(r.u8()?);
let name = r.take(len)?;
r.take((len + 1) % 2)?;
let size = usize::try_from(r.u32()?).map_err(|_| TRUNCATED.to_string())?;
let data = r.take(size)?;
r.take(size % 2)?;
Ok((name, data))
};
let (name, data) = rest().map_err(|_| Some((ours, id)))?;
Ok((ours, id, name, data))
}
/// The resource naming the document's clipping path.
+4 -4
View File
@@ -18,7 +18,7 @@
use vectorcraft_doc::{SliceKind, SliceOptions};
use vectorcraft_geom::Rect;
use super::psdread::{Reader, TRUNCATED, header, resources};
use super::psdread::{Reader, TRUNCATED, header, resource};
/// The image resource that holds the slices.
const SLICES: u16 = 1050;
@@ -51,12 +51,12 @@ struct Stored {
}
/// The slices PSD or PSB file `bytes` stores. `None` when it stores none (no `8BIM` resource 1050
/// before the image resources end or are cut short). An error when the file isn't a PSD or PSB
/// file, or its slices can't be read.
/// before the image resources end, or before a block that is cut short ahead of it). An error when
/// the file isn't a PSD or PSB file, resource 1050 is cut short, or its slices can't be read.
fn read(bytes: &[u8]) -> Result<Option<Stored>, String> {
let mut r = Reader::new(bytes);
let h = header(&mut r)?;
let Some((_, _, data)) = resources(h.resources, true).find(|(id, _, _)| *id == SLICES) else { return Ok(None) };
let Some(data) = resource(h.resources, SLICES)? else { return Ok(None) };
Ok(Some(Stored { slices: decode(data)?, size: (h.width, h.height) }))
}
@@ -38,3 +38,19 @@ fn export_pdf_converts_colours_writes_the_output_intent_and_real_text() {
let bad = s.execute("document.exportPdf", &json!({"output": {"conversion": "destination", "destination": "Missing"}}));
assert!(matches!(bad, Err(crate::EngineError::BadParams { .. })), "{bad:?}");
}
/// Over a saved preset whose Profiles setting is `none`, `"default"` leaves the setting unset,
/// while `null` keeps the preset's value; an unknown value is a bad parameter.
#[test]
fn profiles_default_unsets_a_presets_profiles_setting() {
use vectorcraft_pdf::{PdfPreset, PdfSettings, ProfileInclusion};
let mut settings = PdfSettings::default();
settings.output.profiles = Some(ProfileInclusion::None);
let saved = [PdfPreset { name: "No profiles".into(), description: String::new(), settings }];
let resolve = |output: Value| pdf::resolve("document.exportPdf", &json!({"preset": "No profiles", "output": output}), &saved);
assert_eq!(resolve(json!({"profiles": "default"})).unwrap().output.profiles, None);
assert_eq!(resolve(json!({"profiles": null})).unwrap().output.profiles, Some(ProfileInclusion::None));
assert_eq!(resolve(json!({"profiles": "all"})).unwrap().output.profiles, Some(ProfileInclusion::All));
let bad = resolve(json!({"profiles": "sometimes"}));
assert!(matches!(bad, Err(crate::EngineError::BadParams { .. })), "{bad:?}");
}
@@ -371,6 +371,29 @@ fn slices_that_cant_be_read_warn_and_the_file_still_opens() {
assert!(warnings(&r).is_empty() && slices(&s).is_empty(), "{r}");
}
#[test]
fn a_slices_resource_cut_short_warns_and_the_file_still_opens() {
let good = v6(&[user("a", [0, 0, 5, 5])], &[]);
// Image resource `id`, the last of the image resources, declares 10 bytes more than they hold.
let cut = |layers: bool, id: u16, data: &[u8]| {
let mut f = with_resource(&psd(layers), id, data);
let sig = [&b"8BIM"[..], &id.to_be_bytes()].concat();
let at = f.windows(6).rposition(|w| w == sig.as_slice()).unwrap() + 8;
f[at..at + 4].copy_from_slice(&(data.len() as u32 + 10).to_be_bytes());
f
};
for layers in [true, false] {
let (s, r) = open(&cut(layers, 1050, &good), json!({}));
let w = warnings(&r);
assert!(w.iter().any(|w| w.starts_with("the slices can't be read (") && w.contains("cut short")), "{w:?}");
assert!(slices(&s).is_empty());
assert!(s.doc().unwrap().doc.art_bounds().is_some());
// Another resource cut short says nothing about slices.
let (s, r) = open(&cut(layers, 1051, &[0, 1]), json!({}));
assert!(warnings(&r).is_empty() && slices(&s).is_empty(), "{r}");
}
}
#[test]
fn slices_are_clipped_to_the_canvas_and_those_outside_it_are_left_out() {
let data = v6(&[user("over", [-5, -5, 5, 30]), user("out", [25, 0, 30, 5]), user("empty", [4, 4, 4, 9]), user("in", [1, 1, 2, 2])], &[]);
+36
View File
@@ -1109,6 +1109,42 @@ fn aligned_effect_indices_past_the_end_of_a_graph_designs_art_are_refused() {
assert!(rows(&s, mark).effects.is_empty());
}
/// With a graph design's art given first and `aligned: true`, `effect.remove` and `effect.duplicate` with `indices` are an
/// error and change nothing when one of the art's effects is one no other object has, as with that index given alone.
#[test]
fn aligned_effect_indices_of_a_graph_designs_art_that_no_object_has_are_refused() {
let rows = |s: &Session, id: NodeId| (*s.doc().unwrap().doc.node(id).unwrap().appearance).clone();
let (mut s, _, art, mark) = aligned_design_art();
// The art has a shadow and a roughen, the mark the shadow only.
s.execute("effect.apply", &json!({"effect": "stylize.dropShadow", "ids": [mark.0], "item": null})).unwrap();
s.execute("effect.apply", &json!({"effect": "distort.roughen", "ids": [mark.0], "item": null})).unwrap();
s.edit("Effects", |d, _| {
let effects = d.node(mark).unwrap().appearance.effects.clone();
d.node_mut(art).unwrap().appearance.effects = effects;
d.node_mut(mark).unwrap().appearance.effects.pop();
Ok(())
})
.unwrap();
let (art_was, mark_was) = (rows(&s, art), rows(&s, mark));
let steps = s.doc().unwrap().history.undo.len();
for cmd in ["effect.remove", "effect.duplicate"] {
assert!(s.execute(cmd, &json!({"ids": [art.0, mark.0], "item": null, "index": 1, "aligned": true})).is_err(), "{cmd}");
let e = s.execute(cmd, &json!({"ids": [art.0, mark.0], "item": null, "indices": [0, 1], "aligned": true})).unwrap_err();
assert!(e.to_string().contains("no effects at indices 0, 1"), "{cmd}: {e}");
assert_eq!((rows(&s, art), rows(&s, mark)), (art_was.clone(), mark_was.clone()), "{cmd}");
assert_eq!(s.doc().unwrap().history.undo.len(), steps, "{cmd}");
}
// With the roughen on the mark too, both of its effects are removed.
s.edit("Roughen", |d, _| {
let roughen = d.node(art).unwrap().appearance.effects[1].clone();
d.node_mut(mark).unwrap().appearance.effects.push(roughen);
Ok(())
})
.unwrap();
s.execute("effect.remove", &json!({"ids": [art.0, mark.0], "item": null, "indices": [0, 1], "aligned": true})).unwrap();
assert!(rows(&s, mark).effects.is_empty());
}
/// A blur on a series group makes the whole group an image, which draws the design's art with the series' other art:
/// Expand Appearance does not put the art back beside the image.
#[test]
+16 -9
View File
@@ -555,9 +555,15 @@ pub(crate) fn apply_paint(s: &mut Session, p: &Value, paint: Paint, fill: bool)
let ids = super::graph::paint_targets(&s.doc()?.doc, &selected);
let of = super::appearance::reference_of(s, p, item, cmd)?;
let paint = if span {
// With a design's art, the gradient spans only the objects with a row equal to the art's, which take it.
let spanned: Vec<NodeId> = ids.iter().zip(item.per_target_of(s, of, &ids)).filter_map(|(id, it)| it.map(|_| *id)).collect();
placed_across(&s.doc()?.doc, &spanned, paint, p, fill)
// With a design's art, the gradient spans only the objects with a row equal to the art's, which take it. Each
// object's box is that of the row it edits.
let d = &s.doc()?.doc;
let mut spanned = Vec::with_capacity(ids.len());
for (id, it) in ids.iter().zip(item.per_target_of(s, of, &ids)) {
let (Some(it), Some(n)) = (it, d.node(*id)) else { continue };
spanned.push((*id, it.resolve(&n.appearance, fill, cmd)?));
}
placed_across(d, &spanned, paint, p, fill)
} else {
paint
};
@@ -730,14 +736,15 @@ fn spans_targets(p: &Value, paint: &Paint) -> std::result::Result<bool, String>
Ok(true)
}
/// `paint` placed once on the union of the bounds of `ids` (each one's fill box, or the box its
/// stroke paints), at the gradient's angle and aspect: every target gets the same vector in
/// document coordinates, so the ramp runs on across them (#2127).
fn placed_across(d: &Document, ids: &[NodeId], paint: Paint, p: &Value, fill: bool) -> Paint {
/// `paint` placed once on the union of the bounds of `ids` (each one's fill box, or the box the
/// stroke it edits paints: the row given with it, `None` for the topmost), at the gradient's angle
/// and aspect: every target gets the same vector in document coordinates, so the ramp runs on
/// across them (#2127).
fn placed_across(d: &Document, ids: &[(NodeId, Option<usize>)], paint: Paint, p: &Value, fill: bool) -> Paint {
let union = ids
.iter()
.filter_map(|id| d.node(*id))
.filter_map(|n| item_paint_bounds(n, None, fill).or_else(|| n.geometric_bounds()))
.filter_map(|(id, index)| Some((d.node(*id)?, *index)))
.filter_map(|(n, index)| item_paint_bounds(n, index, fill).or_else(|| n.geometric_bounds()))
.filter(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()))
.reduce(|a, b| a.union(b));
let (Some(union), Paint::Gradient(g)) = (union, &paint) else { return paint };
File diff suppressed because one or more lines are too long
@@ -40,6 +40,9 @@ pub(super) const ALLOWED: &[&str] = &[
"addon.image.colorMask",
"addon.image.removeBackground",
"addon.image.removeColorMask",
"addon.packaging.roles",
"addon.packaging.setRole",
"addon.packaging.setRoleSwatch",
"addon.pathtools.addPoints",
"addon.pathtools.close",
"addon.pathtools.corner",
+6 -2
View File
@@ -48,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Swatch Options",
["Window", "Swatches"],
None,
"{name, newName?, color? (e.g. {l, a, b} for a Lab colour; #rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill; the swatch's own color and a color given with mode keep their model), mode?: \"gray\"|\"rgb\"|\"hsb\"|\"lab\"|\"cmyk\"|\"web\" (convert the colour), global?, spot? (spot colours are always global), paint?: paint.setFill params ({color}, {gradient} or {swatch}) or {pattern: name} replacing the swatch's colour; gradient or pattern with one of the same kind (stored as swatch.new stores it: a gradient keeps its aspect with or without start/end and holds no swatch link; a pattern is untransformed)} edit a swatch in any colour group, as one undo step. Fills, strokes, text, gradient stops and tint swatches linked to a global swatch take its new colour (at their own tint) and name; turning Global off unlinks them (they keep their colour). Colour, mode and spot apply to solid colours only; a tint swatch only takes a new name (edit its base) → {name, relinked: paints changed}",
"{name, newName?, color? (e.g. {l, a, b} for a Lab colour; #rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill; the swatch's own color and a color given with mode keep their model), mode?: \"gray\"|\"rgb\"|\"hsb\"|\"lab\"|\"cmyk\"|\"web\" (convert the colour), global?, spot? (spot colours are always global), paint?: paint.setFill params ({color}, {gradient} or {swatch}) or {pattern: name} replacing the swatch's colour; gradient or pattern with one of the same kind (stored as swatch.new stores it: a gradient keeps its aspect with or without start/end and holds no swatch link; a pattern is untransformed)} edit a swatch in any colour group, as one undo step. Fills, strokes, text, gradient stops and tint swatches linked to a global swatch take its new colour (at their own tint) and name; turning Global off unlinks them (they keep their colour). A fold line role the swatch carries (addon.packaging.roles) stays with it under its new name, and moves to a new swatch name when Global is turned off. Colour, mode and spot apply to solid colours only; a tint swatch only takes a new name (edit its base) → {name, relinked: paints changed}",
has_doc,
swatch_edit
),
@@ -93,7 +93,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Merge Swatches",
["Window", "Swatches"],
None,
"{names: [two or more solid-colour swatches], name?: the merged swatch's name (one swatch kept)} keep the first (its name and colour) and delete the others; paints linked to them take its colour and link to it (or unlink when it isn't global), and gradient stops linked to them drop their process plates, as one undo step → {name, merged: [deleted names], relinked}",
"{names: [two or more solid-colour swatches], name?: the merged swatch's name (one swatch kept)} keep the first (its name and colour) and delete the others; paints linked to them take its colour and link to it (or unlink when it isn't global), and gradient stops linked to them drop their process plates, as one undo step. When the kept swatch is global and carries no fold line role (addon.packaging.roles), it takes the role of the first merged swatch that carried one → {name, merged: [deleted names], relinked}",
has_doc,
swatch_merge
),
@@ -937,6 +937,8 @@ fn swatch_edit(s: &mut Session, p: &Value) -> Result<Value> {
}
}
let relinked = map_swatch_links(d, &mut |c, l, t| relink.apply(c, l, t));
// A fold line role carried by the swatch follows its new name, as the strokes do.
super::addons::role_swatch_edited(d, &name, &to, global);
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(C, e))?;
Ok(relinked)
})?;
@@ -1139,6 +1141,8 @@ fn swatch_merge(s: &mut Session, p: &Value) -> Result<Value> {
take_swatches(d, merged, |_| true);
map_all_paints(d, &mut unplate);
let relinked = map_swatch_links(d, &mut relink);
// The lines of a merged role swatch link to the kept swatch, which takes that role.
super::addons::role_swatches_merged(d, merged, keep, link.is_some());
super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(C, e))?;
Ok(relinked)
})?;
File diff suppressed because one or more lines are too long
+13 -2
View File
@@ -223,6 +223,8 @@ pub fn char_attrs(v: &CharStyle) -> Map<String, Value> {
("akiLeft", json!(v.aki_left)),
("akiRight", json!(v.aki_right)),
("tsume", json!(v.tsume)),
("diacriticHorizontal", json!(v.diacritic_horizontal)),
("diacriticVertical", json!(v.diacritic_vertical)),
("standardVerticalRoman", json!(v.standard_vertical_roman)),
("noBreak", json!(v.no_break)),
("digits", json!(v.digits)),
@@ -585,6 +587,13 @@ fn attrs_param(d: &Document, p: &Value, kind: Kind, verb: &str, kept: Option<&Ma
if changed(key) && !(lo..=hi).contains(&st.tsume) {
return Err(bad(&c, format!("`{key}` must be from {lo} to {hi}")));
}
let hi = vectorcraft_doc::text::MAX_DIACRITIC_POSITION;
let lo = -hi;
for (key, value) in [("diacriticHorizontal", st.diacritic_horizontal), ("diacriticVertical", st.diacritic_vertical)] {
if changed(key) && !(lo..=hi).contains(&value) {
return Err(bad(&c, format!("`{key}` must be from {lo} to {hi}")));
}
}
let lines = vectorcraft_doc::text::WARICHU_LINES;
if changed("warichuLines") && !lines.contains(&st.warichu_lines) {
return Err(bad(&c, format!("`warichuLines` must be a whole number from {} to {}", lines.start(), lines.end())));
@@ -1082,12 +1091,12 @@ fn unused(s: &mut Session, kind: Kind) -> Result<Value> {
/// The styles of `kind` in `src` that load, with their source names so that art in the file keeps
/// referring to them: not the Normal style, and not one whose attributes don't read, whose sizes,
/// scales, leading, shifts, Insert Aki, Tsume, Warichu Settings or stroke width are out of the range `charStyle.new` takes, whose
/// scales, leading, shifts, Insert Aki, Tsume, diacritic positions, Warichu Settings or stroke width are out of the range `charStyle.new` takes, whose
/// indents, spacing, Hyphenation or Justification options or tab stops are out of the range
/// `paraStyle.new` takes, or whose name is empty, which are skipped. → (the styles, the names in
/// `src` of those skipped)
fn loadable(src: &Document, kind: Kind) -> (Vec<TextStyleDef>, Vec<String>) {
const RANGED: [&str; 22] = [
const RANGED: [&str; 24] = [
"size",
"h_scale",
"v_scale",
@@ -1096,6 +1105,8 @@ fn loadable(src: &Document, kind: Kind) -> (Vec<TextStyleDef>, Vec<String>) {
"akiLeft",
"akiRight",
"tsume",
"diacriticHorizontal",
"diacriticVertical",
"tcyUpDown",
"tcyLeftRight",
"warichuLines",
+4 -1
View File
@@ -399,6 +399,8 @@ fn character_style_dimensions_are_checked_before_a_definition_changes() {
json!({"akiRight": 1000.1}),
json!({"tsume": -0.1}),
json!({"tsume": 100.1}),
json!({"diacriticHorizontal": -1000.1}),
json!({"diacriticVertical": 1000.1}),
] {
let key = attrs.as_object().unwrap().keys().next().unwrap();
for cmd in ["charStyle.edit", "charStyle.setAttrs", "charStyle.new"] {
@@ -422,7 +424,8 @@ fn character_style_dimensions_are_checked_before_a_definition_changes() {
"baseline_shift": -1296.0,
"tcyUpDown": 1296.0, "tcyLeftRight": -1296.0,
"akiLeft": 0.0, "akiRight": 1000.0,
"tsume": 100.0
"tsume": 100.0,
"diacriticHorizontal": -1000.0, "diacriticVertical": 1000.0
}}),
)
.unwrap();
+18 -14
View File
@@ -41,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Create Outlines",
["Type"],
Some("Cmd+Shift+O"),
"{} convert the selected text to groups of compound paths (one per glyph); the type object's own fills and strokes (not its characters') go on paths of its whole outline, below or above the glyphs as its Characters row places them; the group keeps the object's transparency, opacity mask and effects, once; a frame of threaded text leaves its thread with the text it shows; a dimension whose label is outlined becomes a plain group of its art → {ids}",
"{} convert the selected text to groups of compound paths (one per glyph); on type scaled unevenly, sheared or flattened, each glyph's stroke becomes a filled path over it, shaped as the canvas strokes it; the type object's own fills and strokes (not its characters') go on paths of its whole outline, below or above the glyphs as its Characters row places them; the group keeps the object's transparency, opacity mask and effects, once; a frame of threaded text leaves its thread with the text it shows; a dimension whose label is outlined becomes a plain group of its art → {ids}",
has_selection,
create_outlines
),
@@ -619,16 +619,25 @@ fn scale_text_attributes(s: &mut Session, p: &Value) -> Result<Value> {
/// A path (or compound path) of `outline`, a piece of type `t`'s outline in text space, painted as
/// run `run` and placed in the document as the canvas paints it ([`paint_type_piece`]: unplaced
/// gradients fitted to `bounds`, the layout's bounds, stroke weights scaled by the type's
/// transform); `None` when the piece has no path.
fn type_piece(d: &mut Document, t: &TextObject, bounds: kurbo::Rect, run: usize, outline: &kurbo::BezPath) -> Option<Node> {
/// transform), followed by a path (or compound path) filled with the run's stroke when the type's
/// transform is not a similarity; empty when the piece has no path.
fn type_piece(d: &mut Document, t: &TextObject, bounds: kurbo::Rect, run: usize, outline: &kurbo::BezPath) -> Vec<Node> {
let path = PathData::from_bezpath(outline);
if path.is_empty() {
return None;
return vec![];
}
let st = t.runs.get(run).map(|r| r.style.clone()).unwrap_or_else(|| t.first_style());
let mut node = shape_node(d, path, None);
vectorcraft_render::effects::paint_type_piece(&mut node, &st, bounds, t.xf);
Some(node)
let stroke = vectorcraft_render::effects::paint_type_piece(&mut node, &st, bounds, t.xf);
let mut out = vec![node];
if let Some(s) = stroke
&& let Some(path) = s.path_data()
{
let mut filled = shape_node(d, path.clone(), None);
filled.appearance = s.appearance.clone();
out.push(filled);
}
out
}
fn create_outlines(s: &mut Session, _: &Value) -> Result<Value> {
@@ -675,9 +684,7 @@ fn create_outlines(s: &mut Session, _: &Value) -> Result<Value> {
children.push(Arc::new(d.reid(&art)));
break 'glyph;
}
if let Some(node) = type_piece(d, t, lay.bounds, g.run, &g.outline) {
children.push(Arc::new(node));
}
children.extend(type_piece(d, t, lay.bounds, g.run, &g.outline).into_iter().map(Arc::new));
}
run_end.insert(g.run, children.len());
}
@@ -686,10 +693,9 @@ fn create_outlines(s: &mut Session, _: &Value) -> Result<Value> {
// nothing there either).
let mut ruby: Vec<(usize, Arc<Node>)> = vec![];
for g in &lay.ruby {
let Some(node) = type_piece(d, t, lay.bounds, g.run, &g.outline) else { continue };
// After the glyphs of its run and of the runs before it.
let at = run_end.range(..=g.run).map(|(_, end)| *end).max().unwrap_or(0);
ruby.push((at, Arc::new(node)));
ruby.extend(type_piece(d, t, lay.bounds, g.run, &g.outline).into_iter().map(|node| (at, Arc::new(node))));
}
ruby.sort_by_key(|(at, _)| *at);
let mut ruby = ruby.into_iter().peekable();
@@ -711,9 +717,7 @@ fn create_outlines(s: &mut Session, _: &Value) -> Result<Value> {
// Underline and strikethrough bars become paths of their run's paint too (#847).
for (run, bar) in vectorcraft_text::decorations(&lay, vectorcraft_text::FontDb::global(), t) {
all.extend(bar.iter());
if let Some(node) = type_piece(d, t, lay.bounds, run, &bar) {
children.push(Arc::new(node));
}
children.extend(type_piece(d, t, lay.bounds, run, &bar).into_iter().map(Arc::new));
}
// The object's own fills and strokes (not its characters') paint the whole outline:
// those below the Characters row under the characters, the others over them, with
@@ -1977,6 +1977,66 @@ fn tsume_is_a_character_attribute() {
assert_eq!(s.doc().unwrap().history.undo.len(), undo, "no undo step for a refused call");
}
/// Adjust Horizontal and Vertical Diacritic Position (Character panel, Middle Eastern options):
/// character attributes in thousandths of an em, 0 by default and saved only when not 0. Both
/// commands set them in one undo step, setting one leaves the other, a call that gives the values
/// the text already has records none, and a value that is not a number or lies outside -1000 to
/// 1000 is refused, naming the key, before anything changes; the native file and a character style
/// captured from the characters carry them.
#[test]
fn diacritic_positions_are_character_attributes() {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "بَب"})).unwrap()["id"].as_u64().unwrap();
let runs = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
NodeKind::Text(t) => t.runs.clone(),
_ => panic!("text"),
};
let moved = |s: &Session| runs(s).iter().map(|r| (r.text.clone(), r.style.diacritic_horizontal, r.style.diacritic_vertical)).collect::<Vec<_>>();
let saved = serde_json::to_value(&runs(&s)[0].style).unwrap();
assert!(saved.get("diacriticHorizontal").is_none() && saved.get("diacriticVertical").is_none());
s.execute("select.set", &json!({"ids": [id]})).unwrap();
s.execute("text.setFormat", &json!({"diacriticHorizontal": -150})).unwrap();
s.execute("text.setFormat", &json!({"diacriticVertical": 250})).unwrap();
assert_eq!(moved(&s), [("بَب".to_string(), -150.0, 250.0)], "setting one leaves the other");
let undo = s.doc().unwrap().history.undo.len();
s.execute("text.setFormat", &json!({"diacriticHorizontal": -150, "diacriticVertical": 250})).unwrap();
assert_eq!(s.doc().unwrap().history.undo.len(), undo, "no undo step without a change");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(moved(&s), [("بَب".to_string(), -150.0, 0.0)], "one undo step");
s.execute("edit.redo", &json!({})).unwrap();
let mark = "بَ".len();
s.execute("text.setRangeStyle", &json!({"id": id, "start": "ب".len(), "end": mark, "diacriticVertical": -1000})).unwrap();
assert_eq!(moved(&s), [("ب".to_string(), -150.0, 250.0), ("\u{064E}".to_string(), -150.0, -1000.0), ("ب".to_string(), -150.0, 250.0)]);
let saved = serde_json::to_value(&runs(&s)[1].style).unwrap();
assert_eq!((saved["diacriticHorizontal"].clone(), saved["diacriticVertical"].clone()), (json!(-150.0), json!(-1000.0)));
let back = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
let NodeKind::Text(t) = &back.node(NodeId(id)).unwrap().kind else { panic!("text") };
let reopened: Vec<_> = t.runs.iter().map(|r| (r.text.clone(), r.style.diacritic_horizontal, r.style.diacritic_vertical)).collect();
assert_eq!(reopened, moved(&s));
let attrs = super::super::textstyles::char_attrs(&runs(&s)[1].style);
assert_eq!((attrs["diacriticHorizontal"].clone(), attrs["diacriticVertical"].clone()), (json!(-150.0), json!(-1000.0)));
let before = moved(&s);
let undo = s.doc().unwrap().history.undo.len();
for (cmd, p, want) in [
("text.setFormat", json!({"diacriticHorizontal": "50"}), "`diacriticHorizontal` must be a number"),
("text.setFormat", json!({"diacriticVertical": 1000.5}), "`diacriticVertical` must be from -1000 to 1000"),
("text.setRangeStyle", json!({"id": id, "diacriticVertical": true}), "`diacriticVertical` must be a number"),
(
"text.setRangeStyle",
json!({"id": id, "start": 0, "end": mark, "diacriticHorizontal": -1001}),
"`diacriticHorizontal` must be from -1000 to 1000",
),
] {
let e = s.execute(cmd, &p).unwrap_err();
assert!(matches!(&e, EngineError::BadParams { msg, .. } if msg == want), "{cmd} {p}: {e}");
}
assert_eq!(moved(&s), before);
assert_eq!(s.doc().unwrap().history.undo.len(), undo, "no undo step for a refused call");
}
/// Standard Vertical Roman Alignment (Character panel menu, East Asian options): a character
/// attribute, off by default and saved only when on. Documents written before it read as off; a
/// character style captured from the characters carries it.
+7
View File
@@ -1783,6 +1783,13 @@ fn strip_formatting(n: &mut vectorcraft_doc::Node) {
fn paste_plain(s: &mut Session, p: &Value) -> Result<Value> {
let saved = s.clipboard.nodes.clone();
// Pasted colors linked to a swatch merged with the document's show its color, so a pasted pie's legend labels take
// the contrast of the wedges as pasted. A `swatchConflict` the paste refuses is left to its error.
if let (Ok(choices), Ok(st)) = (super::clipboard::SwatchChoices::parse("edit.pasteWithoutFormatting", p), s.doc()) {
let same_doc = s.clipboard.source_doc == Some(st.uid);
let d = std::sync::Arc::clone(&st.doc);
s.clipboard.show_merged_colors(&d, &choices, same_doc);
}
for n in &mut s.clipboard.nodes {
strip_formatting(n);
}
+34
View File
@@ -1037,6 +1037,40 @@ fn brush_freehand_direct_call_has_one_undo_step() {
assert_eq!(s.doc().unwrap().history.undo.last().map(|e| e.label.as_str()), Some("Paintbrush"), "a stroke with a brush is a Paintbrush step");
}
/// A `brush.freehand` call that continues a path by one point changes only the path's brush, and
/// applies `keepSelected` as a longer continuation does: off, the path is deselected while the
/// rest of the selection stays; on, the path is selected. A call that leaves the brush as it is
/// changes neither the selection nor the undo history.
#[test]
fn brush_freehand_continued_by_one_point_follows_keep_selected() {
let mut s = session();
let r = s.execute("brush.freehand", &json!({"points": [[10, 10], [60, 40], [120, 10]], "style": "brush", "brush": "Charcoal"})).unwrap();
let p = NodeId(r["id"].as_u64().unwrap());
let a = rect(&mut s, 200.0, 200.0, 10.0, 10.0);
let extend = json!({"id": p.0, "end": "end"});
select(&mut s, &[p, a]);
let off = json!({"points": [[120, 10]], "extend": extend, "brush": "Dots", "keepSelected": false});
assert_eq!(s.execute("brush.freehand", &off).unwrap()["id"], json!(p.0));
assert_eq!(brush_of(&s, p).as_deref(), Some("Dots"));
assert_eq!(selected(&s), [a], "Keep selected off: the path is deselected and the rest stays");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(brush_of(&s, p).as_deref(), Some("Charcoal"), "one Undo takes back the brush");
assert_eq!(selected(&s), [p, a], "Undo gives back the earlier selection");
select(&mut s, &[a]);
let on = json!({"points": [[120, 10]], "extend": extend, "brush": "Dots"});
s.execute("brush.freehand", &on).unwrap();
assert_eq!(brush_of(&s, p).as_deref(), Some("Dots"));
assert_eq!(selected(&s), [p], "Keep selected on: the continued path is selected");
select(&mut s, &[a]);
let undo = s.doc().unwrap().history.undo.len();
s.execute("brush.freehand", &on).unwrap();
assert_eq!(selected(&s), [a], "the same brush again: the selection stays");
assert_eq!(s.doc().unwrap().history.undo.len(), undo, "the same brush again: no undo step");
}
/// `brush.freehand` refuses a brush for a path with no stroke (a continued path, a redrawn one
/// and a new filled pencil path while the stroke is None) instead of reporting it painted: the
/// document, the selection and the undo history stay as they were. Without a brush the path is
+370
View File
@@ -3908,6 +3908,266 @@ fn live_paint_bucket_triple_click_fills_every_face_of_the_same_fill() {
assert_eq!([a, b, c, d].map(|f| fill_of(&s, f)), [green.clone(), green, red.clone(), red]);
}
/// A triple-click whose first click is released across an edge, in the face it then clicks twice,
/// matches that face's fill from before the first click: the release painted it too.
#[test]
fn live_paint_bucket_triple_click_after_a_release_across_an_edge_matches_the_fill_before() {
let mut s = session();
let g = live_squares(&mut s, &[0.0, 50.0, 100.0, 150.0]);
let [a, b, c, d] = faces_at(&s, g, &[(25.0, 25.0), (75.0, 25.0), (125.0, 25.0), (175.0, 25.0)])[..] else { panic!("four faces") };
let (red, blue) = (Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let all = edges_in(&s, g, Rect::new(-1.0, -1.0, 201.0, 51.0));
paint_parts(&mut s, &all, &Paint::solid(Color::rgb(0.0, 0.0, 0.0)), &[(a, red.clone()), (b, red.clone()), (c, blue.clone()), (d, red.clone())]);
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 45.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 55.0, 25.0), v).unwrap();
assert_eq!([a, b].map(|f| fill_of(&s, f)), [green.clone(), green.clone()], "the release across x = 50 fills both faces");
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 55.0, 25.0), v).unwrap();
}
assert_eq!([a, b, c, d].map(|f| fill_of(&s, f)), [green.clone(), green.clone(), blue, green]);
}
/// A triple-click whose third press lands in another face and is released in the face its first
/// two clicks painted still matches that face's fill from before the first click.
#[test]
fn live_paint_bucket_triple_click_released_from_another_face_matches_the_fill_before() {
let mut s = session();
let g = live_squares(&mut s, &[0.0, 50.0, 100.0, 150.0]);
let [a, b, c, d] = faces_at(&s, g, &[(25.0, 25.0), (75.0, 25.0), (125.0, 25.0), (175.0, 25.0)])[..] else { panic!("four faces") };
let (red, blue) = (Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let all = edges_in(&s, g, Rect::new(-1.0, -1.0, 201.0, 51.0));
paint_parts(&mut s, &all, &Paint::solid(Color::rgb(0.0, 0.0, 0.0)), &[(a, red.clone()), (b, red.clone()), (c, blue.clone()), (d, red.clone())]);
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick] {
s.pointer(&PointerEvent::new(kind, 55.0, 25.0), v).unwrap();
}
s.pointer(&PointerEvent::new(PointerKind::Down, 45.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 55.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::TripleClick, 55.0, 25.0), v).unwrap();
assert_eq!([a, b, c, d].map(|f| fill_of(&s, f)), [green.clone(), green.clone(), blue, green]);
}
/// A triple-click whose first click makes the Live Paint group and is released across an edge, in
/// the face it then clicks twice, matches the fill that face was made with.
#[test]
fn live_paint_bucket_triple_click_after_making_the_group_across_an_edge_matches_the_made_fill() {
let mut s = session();
let ids: Vec<NodeId> = [0.0, 50.0, 200.0, 300.0].iter().map(|&x| rect(&mut s, x, 0.0, 50.0, 50.0)).collect();
let (red, blue) = (Color::rgb(1.0, 0.0, 0.0), Color::rgb(0.0, 0.0, 1.0));
for (id, c) in ids.iter().zip([red, red, blue, red]) {
set_fill(&mut s, *id, c);
}
s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap();
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 45.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 55.0, 25.0), v).unwrap();
let g = vectorcraft_tools::builder::live_paint_at(&s.doc().unwrap().doc, Point::new(25.0, 25.0)).expect("the click made a group");
let faces = faces_at(&s, g, &[(25.0, 25.0), (75.0, 25.0), (225.0, 25.0), (325.0, 25.0)]);
assert_eq!(faces[..2].iter().map(|f| fill_of(&s, *f)).collect::<Vec<_>>(), [green.clone(), green.clone()], "the release fills both faces");
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 55.0, 25.0), v).unwrap();
}
assert_eq!(faces.iter().map(|f| fill_of(&s, *f)).collect::<Vec<_>>(), [green.clone(), green.clone(), Paint::solid(blue), green]);
}
/// When the first click makes the Live Paint group and is released in a face covered by a source
/// path with no fill in front of a filled one, the face was made with the filled source's fill, as
/// Make gives it, so the triple-click there matches that fill and not none.
#[test]
fn live_paint_bucket_triple_click_after_making_the_group_under_an_unfilled_path_matches_the_made_fill() {
let mut s = session();
let red = Color::rgb(1.0, 0.0, 0.0);
let (a, b, d) = (rect(&mut s, 0.0, 0.0, 50.0, 50.0), rect(&mut s, 50.0, 0.0, 50.0, 50.0), rect(&mut s, 200.0, 0.0, 50.0, 50.0));
for id in [a, b, d] {
set_fill(&mut s, id, red);
}
let (c, e) = (rect(&mut s, 60.0, 10.0, 30.0, 30.0), rect(&mut s, 300.0, 0.0, 50.0, 50.0));
s.edit("t", |doc, _| {
for id in [c, e] {
doc.node_mut(id).unwrap().appearance.set_fill(Paint::None);
}
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [a.0, b.0, d.0, c.0, e.0]})).unwrap();
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 45.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 75.0, 25.0), v).unwrap();
let g = vectorcraft_tools::builder::live_paint_at(&s.doc().unwrap().doc, Point::new(25.0, 25.0)).expect("the click made a group");
let faces = faces_at(&s, g, &[(75.0, 25.0), (225.0, 25.0), (325.0, 25.0)]);
assert_eq!(fill_of(&s, faces[0]), green, "the release fills the face under the unfilled path");
assert_eq!([faces[1], faces[2]].map(|f| fill_of(&s, f)), [Paint::solid(red), Paint::None], "Make gave the far faces red and none");
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 75.0, 25.0), v).unwrap();
}
assert_eq!([faces[1], faces[2]].map(|f| fill_of(&s, f)), [green, Paint::None], "the triple-click matches the red the face was made with");
}
/// A triple-click whose first click adds paths to a selected Live Paint group and is released in a
/// face of that group matches the face's fill, not the edge around it.
#[test]
fn live_paint_bucket_triple_click_after_merging_across_an_edge_matches_the_face_fill() {
let mut s = session();
let g = live_squares(&mut s, &[0.0]);
let [a] = faces_at(&s, g, &[(25.0, 25.0)])[..] else { panic!("one face") };
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
let all = edges_in(&s, g, Rect::new(-1.0, -1.0, 51.0, 51.0));
paint_parts(&mut s, &all, &Paint::solid(Color::rgb(0.0, 0.0, 0.0)), &[(a, red.clone())]);
let (next, far) = (rect(&mut s, 50.0, 0.0, 50.0, 50.0), rect(&mut s, 200.0, 0.0, 50.0, 50.0));
set_fill(&mut s, next, Color::rgb(0.0, 0.0, 1.0));
set_fill(&mut s, far, Color::rgb(1.0, 0.0, 0.0));
s.execute("select.set", &json!({"ids": [g.0, next.0, far.0]})).unwrap();
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 55.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 45.0, 25.0), v).unwrap();
let g = vectorcraft_tools::builder::live_paint_at(&s.doc().unwrap().doc, Point::new(25.0, 25.0)).expect("the click merged the paths");
let faces = faces_at(&s, g, &[(25.0, 25.0), (225.0, 25.0)]);
assert_eq!(fill_of(&s, faces[0]), green, "the release fills the group's face");
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 45.0, 25.0), v).unwrap();
}
assert_eq!(fill_of(&s, faces[1]), green, "the far face had the red the face had");
}
/// When the first click merges two selected Live Paint groups, a face of the group in front takes
/// its source path's fill, so a triple-click there after a release across an edge matches that fill
/// and not the paint the face had before the merge.
#[test]
fn live_paint_bucket_triple_click_after_merging_two_groups_matches_the_merged_fill() {
let mut s = session();
let back = live_squares(&mut s, &[0.0]);
let source = rect(&mut s, 100.0, 0.0, 50.0, 50.0);
set_fill(&mut s, source, Color::rgb(1.0, 0.0, 0.0));
s.execute("select.set", &json!({"ids": [source.0]})).unwrap();
let front = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
let [f] = faces_at(&s, front, &[(125.0, 25.0)])[..] else { panic!("one face") };
let blue = Paint::solid(Color::rgb(0.0, 0.0, 1.0));
paint_parts(&mut s, &[], &Paint::None, &[(f, blue.clone())]);
let (next, far) = (rect(&mut s, 150.0, 0.0, 50.0, 50.0), rect(&mut s, 300.0, 0.0, 50.0, 50.0));
set_fill(&mut s, next, Color::rgb(1.0, 1.0, 0.0));
set_fill(&mut s, far, Color::rgb(1.0, 0.0, 0.0));
s.execute("select.set", &json!({"ids": [back.0, front.0, next.0, far.0]})).unwrap();
let merged = NodeId(s.execute("livePaint.merge", &json!({})).unwrap()["id"].as_u64().unwrap());
let [m] = faces_at(&s, merged, &[(125.0, 25.0)])[..] else { panic!("one face") };
assert_eq!(fill_of(&s, m), Paint::solid(Color::rgb(1.0, 0.0, 0.0)), "Merge gives the front group's face its source's fill");
s.execute("edit.undo", &json!({})).unwrap();
s.execute("select.set", &json!({"ids": [back.0, front.0, next.0, far.0]})).unwrap();
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 155.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 145.0, 25.0), v).unwrap();
let g = vectorcraft_tools::builder::live_paint_at(&s.doc().unwrap().doc, Point::new(125.0, 25.0)).expect("the click merged the groups");
let faces = faces_at(&s, g, &[(125.0, 25.0), (325.0, 25.0)]);
assert_eq!(fill_of(&s, faces[0]), green, "the release fills the front group's face");
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 145.0, 25.0), v).unwrap();
}
assert_eq!(fill_of(&s, faces[1]), green, "the far face had the red the merge gave the face");
}
/// When the first click merges paths into a selected Live Paint group whose face has an unplaced
/// gradient, Merge fixes the gradient to the face's fit, so a triple-click there after a release
/// across an edge matches the fixed gradient: a far face whose source has that same fixed gradient
/// takes the bucket's paint.
#[test]
fn live_paint_bucket_triple_click_after_merging_matches_the_fixed_gradient() {
use vectorcraft_color::{Gradient, GradientKind, GradientPaint, GradientStop};
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
let gradient = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
let mut s = session();
let g = live_squares(&mut s, &[0.0]);
let [f] = faces_at(&s, g, &[(25.0, 25.0)])[..] else { panic!("one face") };
paint_parts(&mut s, &[], &Paint::None, &[(f, gradient.clone())]);
let (next, far) = (rect(&mut s, 50.0, 0.0, 50.0, 50.0), rect(&mut s, 200.0, 0.0, 50.0, 50.0));
set_fill(&mut s, next, Color::rgb(1.0, 1.0, 0.0));
s.execute("select.set", &json!({"ids": [g.0, next.0]})).unwrap();
let merged = NodeId(s.execute("livePaint.merge", &json!({})).unwrap()["id"].as_u64().unwrap());
let [m] = faces_at(&s, merged, &[(25.0, 25.0)])[..] else { panic!("one face") };
let fixed = fill_of(&s, m);
assert_ne!(fixed, gradient, "Merge fixes the face's gradient to its fit");
s.execute("edit.undo", &json!({})).unwrap();
s.edit("t", |d, _| {
d.node_mut(far).unwrap().appearance.set_fill(fixed.clone());
Ok(())
})
.unwrap();
s.execute("select.set", &json!({"ids": [g.0, next.0, far.0]})).unwrap();
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 55.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 45.0, 25.0), v).unwrap();
let g = vectorcraft_tools::builder::live_paint_at(&s.doc().unwrap().doc, Point::new(45.0, 25.0)).expect("the click merged the paths");
let [far_face] = faces_at(&s, g, &[(225.0, 25.0)])[..] else { panic!("the far face") };
assert_eq!(fill_of(&s, far_face), fixed, "the far face keeps its source's fixed gradient");
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 45.0, 25.0), v).unwrap();
}
assert_eq!(fill_of(&s, far_face), green, "the far face had the fixed gradient the merge gave the face");
}
/// When the first click merges a line that splits a painted face of the selected Live Paint group,
/// Merge keeps the face's paint in one part only and the other part takes its source path's fill;
/// a triple-click in that other part after a release across an edge matches the source's fill.
#[test]
fn live_paint_bucket_triple_click_after_a_merge_splits_a_face_matches_the_part_fill() {
let mut s = session();
let source = rect(&mut s, 0.0, 0.0, 50.0, 50.0);
set_fill(&mut s, source, Color::rgb(1.0, 0.0, 0.0));
s.execute("select.set", &json!({"ids": [source.0]})).unwrap();
let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
let [f] = faces_at(&s, g, &[(25.0, 25.0)])[..] else { panic!("one face") };
paint_parts(&mut s, &[], &Paint::None, &[(f, Paint::solid(Color::rgb(0.0, 0.0, 1.0)))]);
let line = NodeId(s.execute("shape.line", &json!({"x1": 40, "y1": -10, "x2": 40, "y2": 60})).unwrap()["id"].as_u64().unwrap());
let next = rect(&mut s, 50.0, 0.0, 50.0, 50.0);
set_fill(&mut s, next, Color::rgb(1.0, 1.0, 0.0));
let (red_far, blue_far) = (rect(&mut s, 200.0, 0.0, 50.0, 50.0), rect(&mut s, 300.0, 0.0, 50.0, 50.0));
set_fill(&mut s, red_far, Color::rgb(1.0, 0.0, 0.0));
set_fill(&mut s, blue_far, Color::rgb(0.0, 0.0, 1.0));
let ids = json!({"ids": [g.0, line.0, next.0, red_far.0, blue_far.0]});
s.execute("select.set", &ids).unwrap();
let merged = NodeId(s.execute("livePaint.merge", &json!({})).unwrap()["id"].as_u64().unwrap());
let parts = faces_at(&s, merged, &[(20.0, 25.0), (45.0, 25.0)]);
assert_eq!(
parts.iter().map(|p| fill_of(&s, *p)).collect::<Vec<_>>(),
[Paint::solid(Color::rgb(0.0, 0.0, 1.0)), Paint::solid(Color::rgb(1.0, 0.0, 0.0))],
"Merge keeps the paint in the part that holds the face's inside point"
);
s.execute("edit.undo", &json!({})).unwrap();
s.execute("select.set", &ids).unwrap();
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
s.pointer(&PointerEvent::new(PointerKind::Down, 55.0, 25.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 45.0, 25.0), v).unwrap();
for kind in [PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick, PointerKind::Down, PointerKind::Up, PointerKind::TripleClick] {
s.pointer(&PointerEvent::new(kind, 45.0, 25.0), v).unwrap();
}
let g = vectorcraft_tools::builder::live_paint_at(&s.doc().unwrap().doc, Point::new(45.0, 25.0)).expect("the click merged the paths");
let far = faces_at(&s, g, &[(225.0, 25.0), (325.0, 25.0)]);
assert_eq!(far.iter().map(|p| fill_of(&s, *p)).collect::<Vec<_>>(), [green, Paint::solid(Color::rgb(0.0, 0.0, 1.0))]);
}
/// A triple-click whose first click makes the Live Paint group from the selected paths matches the
/// fill the face was made with.
#[test]
@@ -3978,6 +4238,116 @@ fn live_paint_bucket_double_and_triple_click_paint_joined_and_same_stroke_edges(
assert_eq!(node(&s, apart[0]).appearance.stroke_paint(), black);
}
/// A double-click whose two clicks land on two joined edges paints every edge joined to them that
/// had their stroke: the edge the first click painted still joins the others.
#[test]
fn live_paint_bucket_double_click_across_a_junction_paints_the_joined_edges() {
// A square with a line across its middle, cut at x = 30 and x = 70 by two lines from the top: the
// middle line's three edges join end to end.
let mut s = session();
let mut ids = vec![rect(&mut s, 0.0, 0.0, 100.0, 100.0).0];
for anchors in [
json!([{"x": 0, "y": 50}, {"x": 100, "y": 50}]),
json!([{"x": 30, "y": 0}, {"x": 30, "y": 70}]),
json!([{"x": 70, "y": 0}, {"x": 70, "y": 70}]),
] {
ids.push(s.execute("path.create", &json!({ "anchors": anchors })).unwrap()["id"].as_u64().unwrap());
}
s.execute("select.set", &json!({"ids": ids})).unwrap();
let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
let (black, red) = (Paint::solid(Color::rgb(0.0, 0.0, 0.0)), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let all = edges_in(&s, g, Rect::new(-1.0, -1.0, 101.0, 101.0));
paint_parts(&mut s, &all, &red, &[]);
let middle = edges_in(&s, g, Rect::new(-1.0, 49.0, 101.0, 51.0));
assert_eq!(middle.len(), 3, "the middle line's three edges");
paint_parts(&mut s, &middle, &black, &[]);
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.stroke = green.clone();
let shift = Mods { shift: true, ..Default::default() };
for (kind, x) in
[(PointerKind::Down, 50.0), (PointerKind::Up, 50.0), (PointerKind::Down, 85.0), (PointerKind::Up, 85.0), (PointerKind::DoubleClick, 85.0)]
{
s.pointer(&PointerEvent::new(kind, x, 50.0).with_mods(shift), v).unwrap();
}
assert_eq!(middle.iter().map(|e| node(&s, *e).appearance.stroke_paint()).collect::<Vec<_>>(), [green.clone(), green.clone(), green]);
// `through` takes edge ids, with scope "connected" only.
for p in [
json!({"group": g.0, "point": [15, 50], "scope": "connected", "through": "x"}),
json!({"group": g.0, "point": [15, 50], "scope": "connected", "through": [-1]}),
json!({"group": g.0, "point": [15, 50], "scope": "samePaint", "through": []}),
json!({"group": g.0, "point": [15, 50], "through": []}),
] {
assert!(s.execute("livePaint.strokeEdge", &p).is_err(), "{p}");
}
}
/// A double-click whose second press lands on the next joined edge and is released back on the
/// edge the first click painted (at the end of the line) matches that edge's stroke paint from
/// before the first click, and the edge the second press painted still joins the edge past it.
#[test]
fn live_paint_bucket_double_click_released_back_on_the_first_edge_paints_the_joined_edges() {
let mut s = session();
let mut ids = vec![rect(&mut s, 0.0, 0.0, 100.0, 100.0).0];
for anchors in [
json!([{"x": 0, "y": 50}, {"x": 100, "y": 50}]),
json!([{"x": 30, "y": 0}, {"x": 30, "y": 70}]),
json!([{"x": 70, "y": 0}, {"x": 70, "y": 70}]),
] {
ids.push(s.execute("path.create", &json!({ "anchors": anchors })).unwrap()["id"].as_u64().unwrap());
}
s.execute("select.set", &json!({"ids": ids})).unwrap();
let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
let (black, red) = (Paint::solid(Color::rgb(0.0, 0.0, 0.0)), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let all = edges_in(&s, g, Rect::new(-1.0, -1.0, 101.0, 101.0));
paint_parts(&mut s, &all, &red, &[]);
let middle = edges_in(&s, g, Rect::new(-1.0, 49.0, 101.0, 51.0));
assert_eq!(middle.len(), 3, "the middle line's three edges");
paint_parts(&mut s, &middle, &black, &[]);
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.stroke = green.clone();
let shift = Mods { shift: true, ..Default::default() };
for (kind, x) in
[(PointerKind::Down, 15.0), (PointerKind::Up, 15.0), (PointerKind::Down, 50.0), (PointerKind::Up, 15.0), (PointerKind::DoubleClick, 15.0)]
{
s.pointer(&PointerEvent::new(kind, x, 50.0).with_mods(shift), v).unwrap();
}
assert_eq!(middle.iter().map(|e| node(&s, *e).appearance.stroke_paint()).collect::<Vec<_>>(), [green.clone(), green.clone(), green]);
}
/// A triple-click whose second press holds Cmd (it goes to the selection tool Cmd lends) matches
/// the fill the face had before the first click: the lent press counts as one that paints nothing.
#[test]
fn live_paint_bucket_triple_click_with_a_cmd_press_between_matches_the_fill_before() {
let mut s = session();
let g = live_squares(&mut s, &[0.0, 50.0, 100.0, 150.0]);
let [a, b, c, d] = faces_at(&s, g, &[(25.0, 25.0), (75.0, 25.0), (125.0, 25.0), (175.0, 25.0)])[..] else { panic!("four faces") };
let (red, blue) = (Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
let green = Paint::solid(Color::from_hex("#00ff00").unwrap());
let all = edges_in(&s, g, Rect::new(-1.0, -1.0, 201.0, 51.0));
paint_parts(&mut s, &all, &Paint::solid(Color::rgb(0.0, 0.0, 0.0)), &[(a, red.clone()), (b, red.clone()), (c, blue.clone()), (d, red.clone())]);
let v = ViewInfo::default();
s.select_tool("livePaintBucket", v).unwrap();
s.paint.fill = green.clone();
let cmd = Mods { cmd: true, ..Default::default() };
for (kind, m) in [
(PointerKind::Down, Mods::default()),
(PointerKind::Up, Mods::default()),
(PointerKind::Down, cmd),
(PointerKind::Up, cmd),
(PointerKind::Down, Mods::default()),
(PointerKind::Up, Mods::default()),
(PointerKind::TripleClick, Mods::default()),
] {
s.pointer(&PointerEvent::new(kind, 25.0, 25.0).with_mods(m), v).unwrap();
}
assert_eq!(s.tool_id(), "livePaintBucket");
assert_eq!([a, b, c, d].map(|f| fill_of(&s, f)), [green.clone(), green.clone(), blue, green]);
}
/// A `scope` that is not one of the three, a `match` that is not a paint or is given with a scope
/// that compares none, and a scope with a drag's points are refused; nothing changes.
#[test]
+71
View File
@@ -188,6 +188,77 @@ fn align_stroke_reaches_the_characters_stroke() {
assert!(aligns.contains(&StrokeAlign::Inside) && aligns.contains(&StrokeAlign::Outside), "{aligns:?}");
}
/// The bounds of type `t`'s glyph outlines in text space.
fn glyph_bounds(t: &TextObject) -> kurbo::Rect {
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
let mut all = kurbo::BezPath::new();
for g in &lay.glyphs {
all.extend(g.outline.iter());
}
kurbo::Shape::bounding_box(&all)
}
/// Create Outlines on type scaled 300% across and 100% down: the canvas strokes the characters in
/// text space and then scales them, so the outlined stroke is filled art three times as thick
/// across upright stems as across level bars, not a live stroke of one mean weight.
#[test]
fn create_outlines_keeps_the_character_strokes_thickness_under_an_uneven_scale() {
let mut s = session();
let id = stroked_text(&mut s);
run(&mut s, "stroke.set", json!({"weight": 4, "join": "round", "cap": "round"}));
run(&mut s, "object.scale", json!({"ids": [id.0], "sx": 300, "sy": 100}));
let t = text(&s, id);
let [a, b, c, d, ..] = t.xf.as_coeffs();
assert!((a - 3.0).abs() < 1e-9 && b.abs() < 1e-9 && c.abs() < 1e-9 && (d - 1.0).abs() < 1e-9, "{:?}", t.xf);
let w = t.runs[0].style.stroke_width;
let gb = glyph_bounds(&t);
run(&mut s, "select.set", json!({ "ids": [id.0] }));
let g = run(&mut s, "type.createOutlines", json!({}))["ids"][0].as_u64().unwrap();
let doc = &s.doc().unwrap().doc;
let group = doc.node(NodeId(g)).unwrap();
let mut strokes: Option<kurbo::Rect> = None;
for c in group.children().unwrap() {
assert!(c.appearance.stroke().is_none(), "no live stroke of one weight is left");
if c.appearance.fill_paint() == Paint::solid(Color::rgb8(255, 0, 0)) {
let cb = c.geometric_bounds().unwrap();
strokes = Some(strokes.map_or(cb, |s| s.union(cb)));
}
}
// Round joins and caps reach half the weight past the glyphs in text space, then scale.
let want = t.xf.transform_rect_bbox(gb.inflate(w / 2.0, w / 2.0));
let got = strokes.expect("filled character strokes");
assert!((got.width() - want.width()).abs() < 0.1 && (got.height() - want.height()).abs() < 0.1, "{got:?} for {want:?}");
assert!((got.height() - (gb.height() + w)).abs() < 0.1, "level bars keep the weight: {got:?}");
}
/// Under a uniform scale and a rotation the outlined characters keep a live stroke, its weight
/// and dashes scaled with them.
#[test]
fn create_outlines_keeps_a_live_character_stroke_under_a_uniform_scale_and_rotation() {
let mut s = session();
let id = stroked_text(&mut s);
run(&mut s, "stroke.set", json!({"weight": 4, "dash": [6, 2]}));
run(&mut s, "object.scale", json!({"ids": [id.0], "sx": 200, "sy": 200}));
run(&mut s, "object.rotate", json!({"angle": 30}));
let t = text(&s, id);
let k = t.xf.determinant().abs().sqrt();
assert!((k - 2.0).abs() < 1e-9, "{:?}", t.xf);
let st = t.runs[0].style.clone();
let dash = st.stroke_dash.as_ref().unwrap().pattern.clone();
let glyphs = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).glyphs.len();
run(&mut s, "select.set", json!({ "ids": [id.0] }));
let g = run(&mut s, "type.createOutlines", json!({}))["ids"][0].as_u64().unwrap();
let doc = &s.doc().unwrap().doc;
let pieces = doc.node(NodeId(g)).unwrap().children().unwrap().to_vec();
assert_eq!(pieces.len(), glyphs, "one path for each glyph, no filled strokes");
for p in &pieces {
let ps = p.appearance.stroke().expect("a live stroke");
assert!((ps.width - st.stroke_width * k).abs() < 1e-6, "{} for {}", ps.width, st.stroke_width * k);
let got = &ps.dash.as_ref().unwrap().pattern;
assert!(got.iter().zip(&dash).all(|(g, d)| (g - d * k).abs() < 1e-6), "{got:?} for {dash:?}");
}
}
/// Copying type's appearance onto a path keeps its characters' stroke alignment (the Eyedropper's
/// own stroke attributes have none, on paths as on type).
#[test]
+62
View File
@@ -1034,6 +1034,68 @@ fn a_repainted_wedge_sets_its_label_color_when_pasted_without_formatting() {
assert_eq!(pasted, labels(&s, p), "copied as {before:?}");
}
/// Wedges linked to a global swatch that the destination document gives a dark color, merged on Paste without
/// Formatting, give their legend labels white characters, as a redraw does; added under a new name, they keep the
/// copied light color and black labels.
#[test]
fn wedges_merged_into_a_dark_swatch_give_white_labels_when_pasted_without_formatting() {
let csv = ",North,South\nP,1,1";
fn labels(s: &Session, id: NodeId) -> Vec<(String, Paint)> {
let mut out = vec![];
node(s, id).walk(&mut |n| {
if let NodeKind::Text(t) = &n.kind
&& ["North", "South"].contains(&t.plain_text().as_str())
{
out.push((t.plain_text(), t.first_style().fill.clone()));
}
});
out
}
let both = |c: Color| vec![("North".to_string(), Paint::solid(c)), ("South".to_string(), Paint::solid(c))];
for (conflict, expected) in [("merge", Color::WHITE), ("add", Color::BLACK)] {
let mut s = session();
let g = id_of(&s.execute("graph.create", &json!({"type": "pie", "x": 50, "y": 50, "width": 200, "height": 200, "csv": csv})).unwrap());
s.execute("graph.setType", &json!({"id": g.0, "pieLegend": "wedges"})).unwrap();
s.execute("swatch.new", &json!({"name": "Ink", "color": "#ffffff", "global": true})).unwrap();
let mut wedges = vec![];
node(&s, g).walk(&mut |m| {
if let NodeKind::Path { .. } = m.kind {
wedges.push(m.id.0);
}
});
s.execute("paint.setFill", &json!({"ids": wedges, "swatch": "Ink"})).unwrap();
s.execute("graph.setData", &json!({"id": g.0, "csv": csv})).unwrap();
assert_eq!(labels(&s, g), both(Color::BLACK), "light wedges have black labels");
copy(&mut s, &[g]);
new_doc(&mut s);
s.execute("swatch.new", &json!({"name": "Ink", "color": "#000000", "global": true})).unwrap();
let p = ids_of(&s.execute("edit.pasteWithoutFormatting", &json!({"swatchConflict": conflict})).unwrap())[0];
let pasted = labels(&s, p);
assert_eq!(pasted, both(expected), "{conflict}");
s.execute("graph.setData", &json!({"id": p.0, "csv": csv})).unwrap();
assert_eq!(pasted, labels(&s, p), "{conflict}: as a redraw sets them");
}
}
/// An object linked to a graphic style and to a swatch merged with the document's keeps its graphic style link when
/// pasted without formatting, and its color shows the document's swatch.
#[test]
fn a_merged_swatch_keeps_graphic_style_links_when_pasted_without_formatting() {
let mut s = session();
let r = swatched_rect(&mut s, "Ink", "#ffffff");
sel(&mut s, &[r]);
s.execute("graphicStyle.new", &json!({"name": "Sun"})).unwrap();
copy(&mut s, &[r]);
new_doc(&mut s);
s.execute("swatch.new", &json!({"name": "Ink", "color": "#000000", "global": true})).unwrap();
let v = s.execute("edit.pasteWithoutFormatting", &json!({})).unwrap();
assert_eq!(v["merged"], 1);
let p = ids_of(&v)[0];
let style = node(&s, p).extras().graphic_style.and_then(|id| doc(&s).graphic_style_by_id(id)).map(|g| g.name.clone());
assert_eq!(style.as_deref(), Some("Sun"));
assert_eq!(fill(&s, p), linked(hex("#000000"), "Ink", 1.0));
}
/// When one pie's wedge of a series is repainted and another pie's wedge of that series is not, each pasted legend label
/// takes the contrast of the wedge it is in.
#[test]
+22
View File
@@ -119,6 +119,28 @@ fn strokes_span_the_targets_too() {
assert!(ga.start.x < 0.0 && ga.end.x > 400.0, "the stroke's box, half its weight out: {ga:?}");
}
#[test]
fn a_lower_stroke_row_spans_the_box_that_row_paints() {
let mut s = session();
let a = rect(&mut s, 0.0, 50.0, 100.0, 100.0);
let b = rect(&mut s, 300.0, 50.0, 100.0, 100.0);
// [Fill, Stroke 40 pt, Stroke 1 pt] on both.
s.execute("appearance.addStroke", &json!({"ids": [a.0, b.0]})).unwrap();
s.execute("stroke.set", &json!({"ids": [a.0, b.0], "item": 1, "weight": 40})).unwrap();
for aligned in [false, true] {
s.execute("paint.setStroke", &json!({"ids": [a.0, b.0], "item": 1, "aligned": aligned, "gradient": black_to_white(), "span": "selection"}))
.unwrap();
for id in [a, b] {
let Paint::Gradient(g) = &s.doc().unwrap().doc.node(id).unwrap().appearance.stroke_at(Some(1)).unwrap().paint else {
panic!("expected a gradient on stroke row 1")
};
// The 40 pt row reaches 20 pt past the union 0..400, not the 1 pt topmost stroke's 0.5 pt.
let geom = g.geom.expect("placed in document coordinates");
assert!(near(geom.start, Point::new(-20.0, 100.0)) && near(geom.end, Point::new(420.0, 100.0)), "aligned {aligned}, {id:?}: {geom:?}");
}
}
}
#[test]
fn the_new_art_default_stays_unplaced() {
let mut s = session();
+23
View File
@@ -717,6 +717,29 @@ fn type_reports_a_gradient_when_any_glyph_expands() {
assert_eq!(gradients_and_type(&s), (1, 0), "the large glyph keeps its gradient");
}
/// Type scaled unevenly outlines its characters' stroke as a filled path, so a gradient on that
/// stroke becomes a gradient fill: the query reports it, and Expand turns it into art.
#[test]
fn type_reports_a_stroke_gradient_its_uneven_scale_turns_into_a_fill() {
let mut s = session();
let t = run(&mut s, "text.create", json!({"x": 50, "y": 100, "text": "Hi", "size": 48}))["id"].as_u64().unwrap();
run(&mut s, "select.set", json!({"ids": [t]}));
run(
&mut s,
"paint.setStroke",
json!({"gradient": {"kind": "linear", "spread": "repeat", "repeats": 100, "start": [50, 100], "end": [70, 100],
"stops": [{"offset": 0, "color": "#ffff00"}, {"offset": 1, "color": "#004080"}]}}),
);
run(&mut s, "stroke.set", json!({"weight": 4}));
let info = run(&mut s, "object.expand.info", json!({}));
assert_eq!(info["gradient"], json!(false), "a live stroke's gradient is not a fill");
run(&mut s, "object.scale", json!({"ids": [t], "sx": 300, "sy": 100}));
let info = run(&mut s, "object.expand.info", json!({}));
assert_eq!((info["gradient"].clone(), info["fill"].clone()), (json!(true), json!(true)));
run(&mut s, "object.expand", json!({}));
assert_eq!(gradients_and_type(&s), (0, 0), "the filled strokes' gradients became art");
}
/// The same rule for type in the art of a symbol instance that Object expands. The symbol's art
/// is the type scaled down (its "i" about 2.5 pt wide), so its glyphs need more runs than are
/// written with 0.002 pt runs (over a 0.2 pt vector).
+9
View File
@@ -255,6 +255,9 @@ impl Session {
}
// The Selection and Group Selection tools act on the instance whole.
self.select_whole_instance(id);
// The tool lent to does not see the press: it counts as a press elsewhere for the clicks a
// double-click or triple-click compares.
self.tool.press_elsewhere();
let lent = self.make_tool(id);
self.selection_at_lend = self.active().map(|d| (d.uid, d.selection.clone()));
self.lender = Some(std::mem::replace(&mut self.tool, lent));
@@ -1086,6 +1089,12 @@ impl Session {
self.with_tool_cx(view, |t, cx| t.hover_ended(cx));
}
/// A press on the canvas went to the view tools and not to the active tool
/// ([`vectorcraft_tools::Tool::press_elsewhere`]).
pub fn tool_press_elsewhere(&mut self) {
self.tool.press_elsewhere();
}
/// Whether the active tool's hover depends on what lies under a still pointer
/// ([`vectorcraft_tools::Tool::wants_rehover`]).
pub fn tool_wants_rehover(&self) -> bool {
+7
View File
@@ -993,6 +993,13 @@ fn structured_junk() {
("addon.document.symbolsFromLayers", json!({"layers": "x", "replace": 3})),
("addon.document.symbolsFromLayers", json!({"layers": [1e308, -1, null, u64::MAX], "replace": true})),
("addon.document.symbolsFromLayers", json!({"layers": [], "replace": true})),
// Packaging Tools add-on.
("addon.packaging.setRole", json!({"role": "cut", "ids": [u64::MAX], "overprint": "no"})),
("addon.packaging.setRole", json!({"role": ["crease"], "ids": "all"})),
("addon.packaging.setRole", json!({"role": "none", "overprint": null})),
("addon.packaging.roles", json!({"ids": [-1, 1e300]})),
("addon.packaging.setRoleSwatch", json!({"role": "perforation", "swatch": "[Registration]"})),
("addon.packaging.setRoleSwatch", json!({"role": "cut", "swatch": 5})),
// Smart Pen add-on.
("addon.pen.append", json!({"id": 2, "x": 1e308, "y": 0, "in": [1e308, -1e308]})),
("addon.pen.append", json!({"id": 2, "subpath": u64::MAX, "x": 0, "y": 0, "segment": "curved"})),
+6
View File
@@ -167,6 +167,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"",
"{} toggle a red underline under the words of the document's type its dictionaries don't know (text.spelling.check lists them), kept up to date as the type changes; type with effects isn't underlined → whether Auto Spell Check is on",
),
(
"ui.checkSpelling",
"Check Spelling…",
"Cmd+I",
"{} open the Check Spelling dialog to walk through unrecognized words with suggestions, ignore, change and dictionary options",
),
("shortcuts.set", "Set Keyboard Shortcut", "", "{id: command id or tool:<id>, shortcut: \"Cmd+Shift+K\" | \"\" (none) | null (default), force?}"),
("shortcuts.list", "List Keyboard Shortcuts", "", "{query?} → [{id, label, group, shortcut, default, overridden}]"),
("shortcuts.conflicts", "Keyboard Shortcut Conflicts", "", "{} → [{shortcut, ids}]"),
+31 -17
View File
@@ -3,6 +3,8 @@ use super::{Arc, BlendMode, Color, Exporter, Image, Node, NodeKind, Paint, Rect,
use krilla::color::device_n::{Colorant, DeviceNSpace, Process};
use krilla::image::{BitsPerComponent, CustomImage, ImageColorspace};
use crate::images::SourceProfiles;
/// The byte count of a repeated color channel, within [`vectorcraft_doc::MAX_RASTER_ALLOC`].
fn tinted_color_len(samples: usize, pixels: usize) -> Option<usize> {
let bytes = samples.checked_mul(pixels)?;
@@ -138,7 +140,7 @@ impl Exporter<'_> {
}
let doc = self.doc;
let out = self.out.clone();
let profiles = !out.standard.cmyk_only();
let profiles = out.source_profiles();
let to_srgb = out.image_srgb_intent().map(|intent| crate::images::ToSrgb { intent, sixteen_bit: self.sixteen_bit });
let img = doc.image_blob(im).filter(|_| !self.left_out.contains(key)).and_then(|blob| {
let cmyk_image = blob.is_cmyk();
@@ -147,7 +149,7 @@ impl Exporter<'_> {
}
let r = if cmyk_image {
let icc = out.cmyk_image_icc(blob);
crate::images::recode_cmyk(blob, size, c, interpolate, out.cmyk_pixels(), None, icc.as_deref())
crate::images::recode_cmyk(blob, size, c, interpolate, out.cmyk_pixels(), None, out.cmyk_tag(icc.as_deref()))
} else {
crate::images::recode(&blob.bytes, size, c, interpolate, out.pixels(), profiles, to_srgb)
};
@@ -197,7 +199,8 @@ impl Exporter<'_> {
let img = doc.image_blob(im).filter(|b| b.is_cmyk()).and_then(|blob| {
let alpha = crate::images::mask_alpha(doc.image_blob(mi)?, im.width, im.height, m.clip)?;
let icc = self.out.cmyk_image_icc(blob);
let r = crate::images::recode_cmyk(blob, size, self.compression, interpolate, self.out.cmyk_pixels(), Some(alpha), icc.as_deref());
let tag = self.out.cmyk_tag(icc.as_deref());
let r = crate::images::recode_cmyk(blob, size, self.compression, interpolate, self.out.cmyk_pixels(), Some(alpha), tag);
if let (Some(w), Some(_)) = (r.warning, &r.image) {
self.warn(w);
}
@@ -320,13 +323,15 @@ pub(super) fn png_8_bit(bytes: &[u8]) -> Option<Vec<u8>> {
}
/// Image `blob` as it is: PNG, JPEG, GIF and WebP through the PDF writer (JPEG data unchanged),
/// other formats (a TIFF) decoded with their 16-bit samples and, when `profiles` allows it (not in
/// PDF/X-1a), the ICC profile they carry ([`crate::images::decoded_image`]). Without `profiles`, an
/// image that carries a gray or RGB profile is written without it, and so is one whose gray or RGB
/// profile is malformed ([`crate::images::valid_icc`]): a JPEG with its data unchanged, an image of
/// another format decoded. Without `sixteen_bit` (a file before PDF 1.5), a PNG or another image of
/// 16 bits a sample is written at 8 bits ([`png_8_bit`]).
pub(super) fn embed(blob: &vectorcraft_doc::ImageBlob, interpolate: bool, sixteen_bit: bool, profiles: bool) -> Option<Image> {
/// other formats (a TIFF) decoded with their 16-bit samples and, when `profiles` keeps it (not in
/// PDF/X-1a), the ICC profile they carry ([`crate::images::decoded_image`]). When `profiles`
/// doesn't keep it, an image that carries a gray or RGB profile is written without it, and so is
/// one whose gray or RGB profile is malformed ([`crate::images::valid_icc`]): a JPEG with its data
/// unchanged, an image of another format decoded. With [`SourceProfiles::Remove`], an image that
/// carries any profile is written without it, a JPEG without its `ICC_PROFILE` segments (decoded
/// when those can't be taken out). Without `sixteen_bit` (a file before PDF 1.5), a PNG or another
/// image of 16 bits a sample is written at 8 bits ([`png_8_bit`]).
pub(super) fn embed(blob: &vectorcraft_doc::ImageBlob, interpolate: bool, sixteen_bit: bool, profiles: SourceProfiles) -> Option<Image> {
// The header's size first: the writer's decoders allocate what it declares, and the encoded
// bytes of an image that is far larger than any the app reads may be a few kilobytes.
let size = image::ImageReader::new(std::io::Cursor::new(blob.bytes.as_slice())).with_guessed_format().ok()?.into_dimensions();
@@ -334,16 +339,25 @@ pub(super) fn embed(blob: &vectorcraft_doc::ImageBlob, interpolate: bool, sixtee
return None;
}
let bytes = blob.bytes.as_ref().clone();
// The PDF writer keeps a gray or RGB image's ICC profile: without `profiles`, or when the
// profile is malformed, such a JPEG is written without its profile, and an image of another
// The PDF writer keeps a gray or RGB image's ICC profile: unless `profiles` keeps it, or when
// the profile is malformed, such a JPEG is written without its profile, and an image of another
// format is decoded and written without it. The color space is read from the header's bytes
// 16..20 even in a profile cut short, as the PDF writer reads it.
let strip = crate::images::source_icc(&bytes).is_some_and(|icc| match icc.get(16..20) {
Some(space @ (b"GRAY" | b"RGB ")) => !profiles || <[u8; 4]>::try_from(space).is_ok_and(|s| !crate::images::valid_icc(&icc, s)),
// 16..20 even in a profile cut short, as the PDF writer reads it. With `Remove`, a JPEG's
// `ICC_PROFILE` segments are taken out also when they don't make up a profile the decoder reads.
let remove = profiles == SourceProfiles::Remove;
let jpeg = matches!(blob.mime.as_str(), "image/jpeg" | "image/jpg");
let unkept = crate::images::source_icc(&bytes).is_some_and(|icc| match icc.get(16..20) {
_ if remove => true,
Some(space @ (b"GRAY" | b"RGB ")) => {
profiles != SourceProfiles::Keep || <[u8; 4]>::try_from(space).is_ok_and(|s| !crate::images::valid_icc(&icc, s))
}
_ => false,
});
let strip = (remove && jpeg) || unkept;
let direct = match blob.mime.as_str() {
"image/jpeg" | "image/jpg" if strip => Image::from_jpeg_with_icc(bytes.clone().into(), None, interpolate).ok(),
"image/jpeg" | "image/jpg" if strip => {
crate::images::jpeg_data(&bytes, remove).and_then(|data| Image::from_jpeg_with_icc(data.into(), None, interpolate).ok())
}
_ if strip => None,
"image/png" if !sixteen_bit && png_16_bit(&bytes) => png_8_bit(&bytes).and_then(|png| Image::from_png(png.into(), interpolate).ok()),
"image/png" => Image::from_png(bytes.clone().into(), interpolate).ok(),
@@ -371,7 +385,7 @@ mod tests {
let crc =
!png[12..29].iter().fold(!0u32, |c, b| (0..8).fold(c ^ u32::from(*b), |c, _| if c & 1 == 1 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 }));
png[29..33].copy_from_slice(&crc.to_be_bytes());
assert!(super::embed(&ImageBlob::png(png), false, true, true).is_none());
assert!(super::embed(&ImageBlob::png(png), false, true, super::SourceProfiles::Keep).is_none());
}
#[test]
+1 -1
View File
@@ -326,7 +326,7 @@ impl Exporter<'_> {
let img = match self.images.get(&cache) {
Some(img) => img.clone(),
None => {
let img = embed(&image.blob, self.interpolate, self.sixteen_bit, !self.out.standard.cmyk_only());
let img = embed(&image.blob, self.interpolate, self.sixteen_bit, self.out.source_profiles());
self.images.insert(cache, img.clone());
img
}
+71 -19
View File
@@ -20,6 +20,9 @@
//! inverted samples, which the PDF writer's Decode array undoes. A CMYK image whose numbers are
//! kept carries the CMYK profile it is given ([`cmyk_icc`]), whether it is embedded as it is or
//! written again; without one it is untagged, a JPEG's own `ICC_PROFILE` segments included.
//! With Don't Include Profiles set ([`SourceProfiles::Remove`], [`CmykTag::Removed`]), a JPEG
//! embedded as it is loses its `ICC_PROFILE` segments, its other segments and compressed samples
//! unchanged.
use std::io::Cursor;
use std::sync::Arc;
@@ -152,10 +155,10 @@ pub(crate) fn from_decoded(img: DynamicImage, icc: Option<Vec<u8>>, interpolate:
}
/// Image `bytes` decoded within [`limits`], with the ICC profile it carries ([`source_icc`]) when
/// `profiles` allows it (not in PDF/X-1a, which allows no ICC-based color spaces), as
/// [`from_decoded`] writes it. `None` when it can't be decoded.
pub(crate) fn decoded_image(bytes: &[u8], interpolate: bool, sixteen_bit: bool, profiles: bool) -> Option<Image> {
from_decoded(decoded(bytes)?, profiles.then(|| source_icc(bytes)).flatten(), interpolate, sixteen_bit)
/// `profiles` keeps it ([`SourceProfiles::Keep`]), as [`from_decoded`] writes it. `None` when it
/// can't be decoded.
pub(crate) fn decoded_image(bytes: &[u8], interpolate: bool, sixteen_bit: bool, profiles: SourceProfiles) -> Option<Image> {
from_decoded(decoded(bytes)?, (profiles == SourceProfiles::Keep).then(|| source_icc(bytes)).flatten(), interpolate, sixteen_bit)
}
/// Are all of the RGBA pixels `rgba` grey?
@@ -330,6 +333,47 @@ pub(crate) struct ToSrgb {
pub sixteen_bit: bool,
}
/// What happens to the ICC profile a gray or RGB image carries
/// ([`crate::output::ColorOut::source_profiles`]).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum SourceProfiles {
/// The image keeps a well-formed gray or RGB profile ([`valid_icc`]).
Keep,
/// The image is untagged; a JPEG embedded as it is keeps its data unchanged (PDF/X-1a).
Untag,
/// The image is untagged and a JPEG embedded as it is loses its `ICC_PROFILE` segments, its
/// other segments and compressed samples unchanged (Don't Include Profiles).
Remove,
}
/// The CMYK profile [`recode_cmyk`] tags a CMYK image that keeps its numbers with.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum CmykTag<'a> {
/// This profile ([`cmyk_icc`]).
Profile(&'a [u8]),
/// None; a JPEG embedded as it is keeps its data unchanged.
Untagged,
/// None, and a JPEG embedded as it is loses its `ICC_PROFILE` segments, its other segments
/// and compressed samples unchanged (Don't Include Profiles).
Removed,
}
impl<'a> CmykTag<'a> {
/// The profile the image is tagged with.
fn icc(self) -> Option<&'a [u8]> {
match self {
Self::Profile(icc) => Some(icc),
Self::Untagged | Self::Removed => None,
}
}
}
/// JPEG `bytes` as they are embedded: without their `ICC_PROFILE` segments with `remove`
/// ([`vectorcraft_doc::cmyk::jpeg_without_icc`]). `None` when those can't be taken out.
pub(crate) fn jpeg_data(bytes: &[u8], remove: bool) -> Option<Vec<u8>> {
if remove { vectorcraft_doc::cmyk::jpeg_without_icc(bytes) } else { Some(bytes.to_vec()) }
}
/// The ICC profile image `bytes` carries ([`source_icc`]), when it is a well-formed profile of
/// colour space `space` (`GRAY` or `RGB `, [`valid_icc`]): `None` without one, `Some(None)` when
/// the CMS can't read it.
@@ -474,8 +518,7 @@ fn resample_channels(img: DynamicImage, r: &Rule, (w, h): (u32, u32)) -> Dynamic
/// Encoded image `bytes` placed `size` points wide and high, as the Compression settings `c` ask:
/// resampled when its resolution is above the threshold, compressed with ZIP or JPEG, its colours
/// converted by `convert` (colour images). Pixels that keep their colours keep the ICC profile
/// they carry when `profiles` allows it (not in PDF/X-1a, which allows no ICC-based color spaces);
/// with `to_srgb`, pixels in a gray or RGB profile other than sRGB are converted from it to sRGB
/// they carry when `profiles` keeps it ([`SourceProfiles::Keep`]); with `to_srgb`, pixels in a gray or RGB profile other than sRGB are converted from it to sRGB
/// instead ([`ToSrgb`]), and colour ones then by `convert`; grey ones that `convert` leaves as
/// they are keep their profile. `interpolate` lets viewers smooth it. An image that can't be
/// decoded is kept as it is, with a warning when its pixels were to be converted to sRGB.
@@ -485,7 +528,7 @@ pub(crate) fn recode(
c: &CompressionSettings,
interpolate: bool,
convert: Option<&Pixels>,
profiles: bool,
profiles: SourceProfiles,
to_srgb: Option<ToSrgb>,
) -> Recoded {
let keep = Recoded { image: None, warning: None, note: None };
@@ -553,9 +596,14 @@ pub(crate) fn recode(
// Written as it is only when nothing converts it further.
let as_is = kept(&rule, dims, size, jpeg) && convert.is_none();
// A JPEG kept as JPEG whose samples the conversion leaves unchanged (an sRGB
// profile): its JPEG data, without the profile.
if !changed && as_is && jpeg {
let image = Image::from_jpeg_with_icc(bytes.to_vec().into(), None, interpolate).ok();
// profile): its JPEG data, without the profile (and, with `Remove`, without its
// segments: encoded again when those can't be taken out).
if !changed
&& as_is
&& jpeg
&& let Some(data) = jpeg_data(bytes, profiles == SourceProfiles::Remove)
{
let image = Image::from_jpeg_with_icc(data.into(), None, interpolate).ok();
return Recoded { image, warning: rule.instead, note: None };
}
// Not resampled and lossless: written at its own depth.
@@ -573,7 +621,8 @@ pub(crate) fn recode(
// Pixels that keep their colours keep the profile they are in; converted ones are in the
// destination's.
let want = if kind == Kind::Color { *b"RGB " } else { *b"GRAY" };
let icc = (profiles && convert.is_none() && source.is_none()).then(|| source_icc(bytes)).flatten().filter(|icc| valid_icc(icc, want));
let keeps = profiles == SourceProfiles::Keep && convert.is_none() && source.is_none();
let icc = keeps.then(|| source_icc(bytes)).flatten().filter(|icc| valid_icc(icc, want));
let rgb_icc = icc.is_some() && kind == Kind::Color;
let mut rgba = resample(img, &rule, sized(&rule, dims, size)).into_rgba8();
if kind == Kind::Mono {
@@ -630,8 +679,8 @@ pub(crate) fn coverage_sized(w: u32, h: u32, cover: Vec<u8>, size: (f64, f64), c
/// is when its numbers are (`convert` is `None`); otherwise its ink amounts are resampled,
/// converted by `convert` and compressed again. With `alpha` (one sample a pixel, see
/// [`mask_alpha`]) the image is lossless and carries it as its soft mask; `None` then when its
/// inks can't be read. When its numbers are kept, the image is tagged with CMYK profile `icc`
/// (see [`cmyk_icc`]), and is untagged without one; converted pixels are never tagged with it.
/// inks can't be read. When its numbers are kept, the image is tagged as `tag` says, and is
/// untagged without a profile; converted pixels are never tagged with it.
pub(crate) fn recode_cmyk(
blob: &ImageBlob,
size: (f64, f64),
@@ -639,18 +688,21 @@ pub(crate) fn recode_cmyk(
interpolate: bool,
convert: Option<&CmykPixels>,
alpha: Option<Vec<u8>>,
icc: Option<&[u8]>,
tag: CmykTag<'_>,
) -> Recoded {
let rule = rule(c, Kind::Color);
let jpeg = jpeg_components(&blob.bytes).is_some();
let icc = icc.filter(|_| convert.is_none());
let icc = tag.icc().filter(|_| convert.is_none());
if jpeg && convert.is_none() && alpha.is_none() {
let dims = ImageReader::new(Cursor::new(blob.bytes.as_slice())).with_guessed_format().ok().and_then(|r| r.into_dimensions().ok());
if let Some((w, h)) = dims.filter(|d| kept(&rule, *d, size, true)) {
// The JPEG data as it is, tagged with `icc` rather than with its own segments; one
// larger than [`MAX_EMBED_PIXELS`] is not written.
// The JPEG data as it is (without its `ICC_PROFILE` segments with `CmykTag::Removed`: its
// inks are encoded again when those can't be taken out), tagged with `icc` rather than
// with its own segments; one larger than [`MAX_EMBED_PIXELS`] is not written.
if let Some((w, h)) = dims.filter(|d| kept(&rule, *d, size, true))
&& let Some(data) = jpeg_data(&blob.bytes, tag == CmykTag::Removed)
{
let image = (u64::from(w) * u64::from(h) <= MAX_EMBED_PIXELS)
.then(|| Image::from_jpeg_with_icc(blob.bytes.as_ref().clone().into(), icc.map(|i| i.to_vec().into()), interpolate).ok())
.then(|| Image::from_jpeg_with_icc(data.into(), icc.map(|i| i.to_vec().into()), interpolate).ok())
.flatten();
return Recoded { image, warning: rule.instead, note: None };
}
+16 -2
View File
@@ -361,8 +361,9 @@ impl<'p> Builder<'p> {
Some(MaskSpec::Mask(m)) => (opacity, Some(m.clone())),
None => (opacity, None),
};
// Isolation only shows with blending inside; knockout with several objects.
let isolate = isolate && Node::children_blend(&children, &mut |c| c.blends_through());
// Isolation only shows with blending or overprinting inside; knockout with several
// objects.
let isolate = isolate && (Node::children_blend(&children, &mut |c| c.blends_through()) || children_overprint(&children));
let knockout = knockout && children.len() > 1;
let plain = opacity >= 0.999 && blend == BlendMode::Normal && mask.is_none() && !isolate && !knockout;
if children.is_empty() {
@@ -1183,3 +1184,16 @@ fn visual_glyph_text(text: String) -> String {
let chars: Vec<char> = text.chars().collect();
order.iter().filter_map(|&i| chars.get(i)).collect()
}
/// Whether a visible fill or stroke among `children` overprints, characters' too, directly or
/// through children that don't isolate. In an isolated group an overprinting object is drawn on
/// the group's empty backdrop, so it covers the inks of the art below the group that it does not
/// paint; without isolation it leaves them.
fn children_overprint(children: &[Arc<Node>]) -> bool {
children.iter().any(|c| {
c.visible
&& (c.appearance.items.iter().any(|i| i.visible() && i.overprint())
|| matches!(&c.kind, NodeKind::Text(t) if t.runs.iter().any(|r| r.style.overprint_fill || r.style.overprint_stroke))
|| (!c.isolate && c.children().is_some_and(|ch| children_overprint(ch))))
})
}
+45 -5
View File
@@ -24,7 +24,11 @@
//! always tag them, whatever `profiles` says; PDF/X-1a never does, and always converts to a
//! CMYK destination (see [`crate::pdfx`]). A CMYK image that keeps its numbers is tagged with
//! the CMYK profile it carries, if any, with `all` and `taggedSource`, and in PDF/A, PDF/X-3
//! and PDF/X-4 unless `profiles` is `destination` ([`ColorOut::cmyk_image_icc`]).
//! and PDF/X-4 unless `profiles` is `destination` ([`ColorOut::cmyk_image_icc`]). When
//! `profiles` isn't set, colors are written as with `none` and gray and RGB images keep the
//! profiles they carry (but in PDF/X-1a); when it is set to `none`, no image keeps its own
//! profile, a JPEG's `ICC_PROFILE` segments included, except in PDF/A, PDF/X-3 and PDF/X-4
//! ([`ColorOut::source_profiles`]).
//! - Output intent: the profile `outputIntent` names, embedded as the `/GTS_PDFX` output intent
//! of the catalog with the condition, identifier and registry; Trapped goes in the document
//! information (`/False` when an output intent is written untrapped). PDF/A files carry their
@@ -70,6 +74,9 @@ pub(crate) struct ColorOut {
/// CMYK images that keep their numbers are tagged with the CMYK profile they carry
/// ([`Self::cmyk_image_icc`]).
image_icc: bool,
/// Don't Include Profiles was set, in a file that doesn't tag every color: no image keeps its
/// own ICC profile, a JPEG's `ICC_PROFILE` segments included ([`Self::source_profiles`]).
no_profiles: bool,
/// The CMYK profile that tags CMYK colours.
cmyk_profile: String,
/// Tagged RGB colours are written as their sRGB equivalents: why (a warning), when their RGB
@@ -117,6 +124,7 @@ impl Default for ColorOut {
dest: None,
tagged: false,
image_icc: false,
no_profiles: false,
cmyk_profile,
srgb_note: None,
pixels: OnceLock::new(),
@@ -246,9 +254,11 @@ impl ColorOut {
}
out.dest = Some(Dest { srgb: name == cms::SRGB, cms, model, keep, destination });
}
out.tagged = matches!(set.standard, Standard::PdfA2b | Standard::PdfX3 | Standard::PdfX4)
let profiles = set.output.profiles.unwrap_or_default();
let tags_all = matches!(set.standard, Standard::PdfA2b | Standard::PdfX3 | Standard::PdfX4);
out.tagged = tags_all
|| (!set.standard.cmyk_only()
&& match set.output.profiles {
&& match profiles {
ProfileInclusion::None => false,
ProfileInclusion::All | ProfileInclusion::Destination => true,
ProfileInclusion::TaggedSource => !doc.color_profiles.is_empty(),
@@ -256,11 +266,14 @@ impl ColorOut {
// Source profiles: with `all` and `taggedSource`, and in the files that tag every colour
// unless only the destination profile is asked for; never in PDF/X-1a.
out.image_icc = !set.standard.cmyk_only()
&& match set.output.profiles {
&& match profiles {
ProfileInclusion::All | ProfileInclusion::TaggedSource => true,
ProfileInclusion::None => matches!(set.standard, Standard::PdfA2b | Standard::PdfX3 | Standard::PdfX4),
ProfileInclusion::None => tags_all,
ProfileInclusion::Destination => false,
};
// A set Don't Include Profiles leaves out every image's own profile, outside the files
// that tag every color.
out.no_profiles = set.output.profiles == Some(ProfileInclusion::None) && !tags_all;
let rgb = match &out.dest {
Some(d) if d.model == Model::Rgb => (d.srgb, d.cms.settings().rgb.clone()),
_ => (source.rgb_is_srgb(), st.rgb.clone()),
@@ -367,6 +380,33 @@ impl ColorOut {
crate::images::cmyk_icc(blob)
}
/// How CMYK image `blob` is tagged ([`crate::images::recode_cmyk`]): with the profile
/// [`Self::cmyk_image_icc`] gives (`icc`), else untagged, without a JPEG's own `ICC_PROFILE`
/// segments when Don't Include Profiles was set.
pub(crate) fn cmyk_tag<'a>(&self, icc: Option<&'a [u8]>) -> crate::images::CmykTag<'a> {
use crate::images::CmykTag;
match icc {
Some(icc) => CmykTag::Profile(icc),
None if self.no_profiles => CmykTag::Removed,
None => CmykTag::Untagged,
}
}
/// What happens to the ICC profile a gray or RGB image carries ([`crate::images::recode`]):
/// left out with its JPEG segments when Don't Include Profiles was set (not in PDF/A, PDF/X-3
/// and PDF/X-4), left out of the color space in PDF/X-1a, which allows no ICC-based color
/// spaces, and kept otherwise, also when the Profiles setting isn't set.
pub(crate) fn source_profiles(&self) -> crate::images::SourceProfiles {
use crate::images::SourceProfiles;
if self.no_profiles {
SourceProfiles::Remove
} else if self.standard.cmyk_only() {
SourceProfiles::Untag
} else {
SourceProfiles::Keep
}
}
/// How CMYK images' ink amounts are converted; `None` when they keep their numbers (no
/// conversion, or to a CMYK destination that keeps them).
pub(crate) fn cmyk_pixels(&self) -> Option<&CmykPixels> {
+19 -1
View File
@@ -387,7 +387,12 @@ pub struct OutputSettings {
/// Destination profile name (empty: the document's profile; [`DOCUMENT_CMYK`]: the CMYK
/// profile in effect, whatever the document's colour mode).
pub destination: String,
pub profiles: ProfileInclusion,
/// The Profile Inclusion setting; `None` (left out, `null` or `"default"`) when it isn't set:
/// colors are then written as with [`ProfileInclusion::None`], while gray and RGB images keep
/// the ICC profiles they carry. A set [`ProfileInclusion::None`] also leaves those out (see
/// [`crate::output`]).
#[serde(deserialize_with = "unset_or_choice")]
pub profiles: Option<ProfileInclusion>,
/// PDF/X output intent profile name.
pub output_intent: String,
pub output_condition: String,
@@ -397,6 +402,19 @@ pub struct OutputSettings {
pub trapped: bool,
}
/// The JSON id of a setting that isn't set ([`OutputSettings::profiles`]), as `null` is.
pub const UNSET_CHOICE: &str = "default";
/// A choice that may be left unset: `null` and [`UNSET_CHOICE`] are `None`, a choice's id is that
/// choice.
fn unset_or_choice<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>(d: D) -> Result<Option<T>, D::Error> {
match Option::<String>::deserialize(d)? {
None => Ok(None),
Some(id) if id == UNSET_CHOICE => Ok(None),
Some(id) => T::deserialize(serde::de::value::StringDeserializer::<D::Error>::new(id)).map(Some),
}
}
/// The Advanced section.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
+38 -1
View File
@@ -195,7 +195,8 @@ fn a_knockout_group_without_blending_inside_is_isolated_only_when_it_isolates()
/// An overprinting element of a knockout group that does not isolate is drawn in a `/K` group
/// without `/I true`, so it overprints the art below the group, and its graphics state still
/// overprints (`/OP`, `/op`, `/OPM 1`). An isolated group keeps `/I true`.
/// overprints (`/OP`, `/op`, `/OPM 1`). An isolated group keeps `/I true`, reads back isolated
/// and is written with `/I true` again.
#[test]
fn an_overprinting_element_of_a_knockout_group_that_does_not_isolate_overprints_the_art_below() {
for isolate in [false, true] {
@@ -219,6 +220,42 @@ fn an_overprinting_element_of_a_knockout_group_that_does_not_isolate_overprints_
});
assert_eq!(overprints, [false, false, false, true], "isolate {isolate}");
assert_eq!(knockout_groups(&back), [3], "isolate {isolate}");
let mut found = vec![];
back.walk(|n| {
if n.knockout == vectorcraft_doc::Knockout::On {
found.push(n.isolate);
}
});
assert_eq!(found, [isolate], "isolate {isolate}");
assert_eq!(text(&back).matches("/Itrue").count(), usize::from(isolate), "isolate {isolate}");
}
}
/// An isolated group with nothing blending inside but an overprinting fill reads back as an
/// isolated group and is written with `/I true` again; a group that does not isolate reads back
/// as its objects.
#[test]
fn an_isolated_group_with_an_overprinting_object_reads_back_isolated() {
for isolate in [false, true] {
let mut d = Document::new(200.0, 200.0);
add(&mut d, rect(Rect::new(0.0, 0.0, 200.0, 200.0), (0.9, 0.8, 0.2)));
let mut top = rect(Rect::new(60.0, 60.0, 160.0, 160.0), (0.0, 0.0, 1.0));
top.appearance.fill_mut().unwrap().overprint = true;
let mut below = rect(Rect::new(20.0, 20.0, 120.0, 120.0), (1.0, 0.0, 0.0));
(below.id, top.id) = (d.alloc_id(), d.alloc_id());
let mut g = Node::group(NodeId(0), vec![std::sync::Arc::new(below), std::sync::Arc::new(top)]);
g.isolate = isolate;
add(&mut d, g);
assert_eq!(text(&d).matches("/Itrue").count(), usize::from(isolate), "isolate {isolate}");
let back = import(&export(&d, &PdfOptions::default()).unwrap()).unwrap_or_else(|e| panic!("isolate {isolate}: {e}"));
let mut groups = vec![];
back.walk(|n| {
if matches!(n.kind, vectorcraft_doc::NodeKind::Group { .. }) {
groups.push(n.isolate);
}
});
assert_eq!(groups, if isolate { vec![true] } else { vec![] }, "isolate {isolate}");
assert_eq!(text(&back).matches("/Itrue").count(), usize::from(isolate), "isolate {isolate}");
}
}
+29
View File
@@ -573,6 +573,35 @@ fn a_cmyk_image_that_keeps_its_numbers_carries_its_cmyk_profile() {
assert!(!String::from_utf8_lossy(&bytes).contains("/S/Luminosity"), "no luminosity soft mask");
}
/// With Don't Include Profiles set, a CMYK JPEG kept as it is is DeviceCMYK without its own
/// `ICC_PROFILE` segments, its compressed inks unchanged; one resampled and compressed again is
/// written without a profile too. Left unset, the JPEG data stays as it is.
#[test]
fn a_set_dont_include_profiles_takes_a_cmyk_jpegs_profile_out() {
let ink = [0u8, 102, 255, 0];
let icc = cmyk_profile(|_| {});
let jpg = cmyk_jpeg_with(&flat(ink, 64 * 64), 64, 64, &icc);
let d = image_doc(ImageBlob::new("image/jpeg", jpg.clone()), 64, 64);
let export = |s: serde_json::Value| {
let out = export_with_report(&d, &opts(s.clone())).unwrap_or_else(|e| panic!("{s}: {e}"));
let w: Vec<Written> = written(&out.bytes).into_iter().filter(|w| w.space != "DeviceGray").collect();
assert_eq!(w.len(), 1, "{s}: {w:?}");
(w.into_iter().next().unwrap(), out.bytes)
};
let segment = |data: &[u8]| data.windows(12).any(|w| w == b"ICC_PROFILE\0");
let (w, _) = export(json!({}));
assert!(w.data == jpg && segment(&w.data), "unset: the JPEG data unchanged");
let s = json!({"output": {"profiles": "none"}});
let (w, bytes) = export(s.clone());
assert_eq!((w.space.as_str(), w.filter.as_deref()), ("DeviceCMYK", Some("DCTDecode")), "{s}");
assert!(!segment(&w.data) && w.data.len() < jpg.len(), "{s}: no ICC_PROFILE segment is left");
assert!(w.data == vectorcraft_doc::cmyk::jpeg_without_icc(&jpg).unwrap(), "{s}: the other segments and the scan unchanged");
assert_eq!(blobs(&import(&bytes).unwrap())[0].cmyk().unwrap().data, ImageBlob::new("image/jpeg", jpg.clone()).cmyk().unwrap().data);
let s = json!({"output": {"profiles": "none"}, "compression": {"color": {"downsample": "bicubic", "ppi": 72.0, "abovePpi": 100.0}}});
let (w, _) = export(s.clone());
assert!(w.icc.is_none() && !segment(&w.data), "{s}: {w:?}");
}
/// A CMYK JPEG kept as it is whose header declares far more pixels than the app reads is left out
/// with a warning, as other images that large are.
#[test]
+78 -3
View File
@@ -266,7 +266,7 @@ fn images_declaring_more_than_the_allowance_are_not_decoded() {
assert_eq!(crate::images::mask_alpha(&blob, 60_000, 60_000, false), None);
assert_eq!(crate::images::mask_alpha(&blob, 2, 2, false), None, "another size is not decoded at all");
let c: CompressionSettings = serde_json::from_value(json!({"gray": {"downsample": "bicubic", "ppi": 72, "abovePpi": 100}})).unwrap();
let r = crate::images::recode(&png, (10.0, 10.0), &c, false, None, true, None);
let r = crate::images::recode(&png, (10.0, 10.0), &c, false, None, crate::images::SourceProfiles::Keep, None);
assert!(r.image.is_none(), "kept as it is");
}
@@ -425,6 +425,80 @@ fn pdf_x1a_keeps_a_tagged_gray_jpeg_as_jpeg() {
}
}
/// With Don't Include Profiles set, a gray or RGB image is written without the ICC profile it
/// carries: a PNG, JPEG or TIFF embedded as it is, resampled or compressed with JPEG, with alpha and
/// at 16 bits. A JPEG kept as it is loses its `ICC_PROFILE` segments, its compressed samples
/// unchanged. Left unset, or `null`, the setting keeps the profiles. PDF/X-4 files keep them
/// whatever the setting says.
#[test]
fn a_set_dont_include_profiles_removes_image_profiles() {
let (rgb, gray) = (icc_profile(b"RGB ", 600), icc_profile(b"GRAY", 300));
let mut clear = colour().to_rgba8();
clear.put_pixel(0, 0, image::Rgba([10, 20, 30, 0]));
let deep = DynamicImage::ImageRgb16(colour().to_rgb16());
let export = |d: &Document, settings: Value| {
let mut settings: PdfSettings = serde_json::from_value(settings).unwrap();
settings.compression.compress_text = false;
export_with_report(d, &PdfOptions { settings, ..Default::default() }).unwrap()
};
let resampled =
json!({"color": {"downsample": "bicubic", "ppi": 150, "abovePpi": 225}, "gray": {"downsample": "bicubic", "ppi": 150, "abovePpi": 225}});
let jpeg = json!({"color": {"compression": "jpeg"}, "gray": {"compression": "jpeg"}});
let cases = [
("RGB PNG", tagged(&colour(), &rgb, ImageFormat::Png), "image/png", json!({}), "DeviceRGB"),
("gray PNG", tagged(&colour().grayscale(), &gray, ImageFormat::Png), "image/png", json!({}), "DeviceGray"),
("RGB JPEG", tagged(&colour(), &rgb, ImageFormat::Jpeg), "image/jpeg", json!({}), "DeviceRGB"),
("gray JPEG", tagged(&colour().grayscale(), &gray, ImageFormat::Jpeg), "image/jpeg", json!({}), "DeviceGray"),
("RGB TIFF", tagged(&colour(), &rgb, ImageFormat::Tiff), "image/tiff", json!({}), "DeviceRGB"),
("gray TIFF", tagged(&colour().grayscale(), &gray, ImageFormat::Tiff), "image/tiff", json!({}), "DeviceGray"),
("RGBA TIFF", tagged(&clear.into(), &rgb, ImageFormat::Tiff), "image/tiff", json!({}), "DeviceRGB"),
("16-bit TIFF", tagged(&deep, &rgb, ImageFormat::Tiff), "image/tiff", json!({}), "DeviceRGB"),
("RGB PNG, resampled", tagged(&colour(), &rgb, ImageFormat::Png), "image/png", resampled.clone(), "DeviceRGB"),
("gray JPEG, resampled", tagged(&colour().grayscale(), &gray, ImageFormat::Jpeg), "image/jpeg", resampled, "DeviceGray"),
("RGB TIFF as JPEG", tagged(&colour(), &rgb, ImageFormat::Tiff), "image/tiff", jpeg.clone(), "DeviceRGB"),
("gray TIFF as JPEG", tagged(&colour().grayscale(), &gray, ImageFormat::Tiff), "image/tiff", jpeg, "DeviceGray"),
];
for (what, bytes, mime, compression, device) in cases {
let d = doc(bytes.clone(), mime);
// Left unset, or null, the image keeps its profile.
for profiles in [json!({}), json!({"profiles": null})] {
let r = export(&d, json!({"compression": compression.clone(), "output": profiles}));
let spaces = image_spaces(&r.bytes);
assert!(spaces.len() == 1 && spaces[0].space == "ICCBased" && spaces[0].icc.is_some(), "{what}, {profiles}: {spaces:?}");
}
let none = export(&d, json!({"compression": compression.clone(), "output": {"profiles": "none"}}));
assert!(none.warnings.is_empty(), "{what}: {:?}", none.warnings);
let spaces = image_spaces(&none.bytes);
assert!(spaces.len() == 1 && spaces[0].space == device && spaces[0].icc.is_none(), "{what}: {spaces:?}");
let data = image_data(&none.bytes);
assert!(data.iter().all(|d| !d.windows(12).any(|w| w == b"ICC_PROFILE\0")), "{what}: no ICC_PROFILE segment is left");
if mime == "image/jpeg" && compression == json!({}) {
// The JPEG data without its profile segments: the image decoder reads the same pixels
// from it, and no profile.
assert!(data.len() == 1 && data[0].len() < bytes.len(), "{what}: the JPEG data kept");
let decode = |b: &[u8]| image::load_from_memory_with_format(b, ImageFormat::Jpeg).unwrap();
assert!(decode(&data[0]) == decode(&bytes), "{what}: the same pixels");
assert!(crate::images::source_icc(&data[0]).is_none() && crate::images::source_icc(&bytes).is_some(), "{what}");
}
// PDF/X-4 tags every colour: the image keeps its profile.
let x4 = export(&d, json!({"standard": "pdfX4", "compatibility": "1.6", "compression": compression, "output": {"profiles": "none"}}));
let spaces = image_spaces(&x4.bytes);
assert!(spaces.len() == 1 && spaces[0].space == "ICCBased", "{what}, PDF/X-4: {spaces:?}");
}
// A JPEG whose `ICC_PROFILE` segments don't make up a profile (the first of two, the second
// missing) loses them too.
let plain = encoded(colour(), ImageFormat::Jpeg);
let mut part = vec![0xFF, 0xD8, 0xFF, 0xE2, 0, 30];
part.extend_from_slice(b"ICC_PROFILE\0");
part.extend_from_slice(&[1, 2]);
part.extend_from_slice(&rgb[..14]);
part.extend_from_slice(&plain[2..]);
assert!(crate::images::source_icc(&part).is_none(), "the decoder reads no profile");
let none = export(&doc(part, "image/jpeg"), json!({"output": {"profiles": "none"}}));
let data = image_data(&none.bytes);
assert!(data == [plain], "an unreadable profile: the JPEG data without its segments");
}
/// A gray or RGB TIFF that carries an ICC profile of its colour space is written in an ICC-based
/// colour space holding the same profile, at 16 bits a sample from PDF 1.5 on, with its alpha as
/// a soft mask; and so is a tagged TIFF or PNG that is resampled or compressed with JPEG. Pixels
@@ -778,9 +852,10 @@ fn convert_to_srgb_converts_tagged_images_from_their_profile() {
let c: CompressionSettings = serde_json::from_value(json!({})).unwrap();
let srgb_out = Some(crate::images::ToSrgb { intent: Intent::RelativeColorimetric, sixteen_bit: true });
for (what, png) in [("RGB", declared(&colour(), &p3)), ("gray", declared(&colour().grayscale(), &gray))] {
let r = crate::images::recode(&png, (100.0, 100.0), &c, false, None, true, srgb_out);
let keep = crate::images::SourceProfiles::Keep;
let r = crate::images::recode(&png, (100.0, 100.0), &c, false, None, keep, srgb_out);
assert!(r.image.is_none() && r.warning.is_some_and(|w| w.contains("not converted to sRGB")), "{what}: {:?}", r.warning);
let r = crate::images::recode(&png, (100.0, 100.0), &c, false, None, true, None);
let r = crate::images::recode(&png, (100.0, 100.0), &c, false, None, keep, None);
assert!(r.image.is_none() && r.warning.is_none(), "{what}, no conversion: {:?}", r.warning);
// Too large to embed as it is too: the export leaves it out, and says only that.
let mut settings: PdfSettings = serde_json::from_value(to_srgb(json!({}))).unwrap();
+18
View File
@@ -41,6 +41,24 @@ fn json_is_camel_case_and_partial_objects_keep_defaults() {
}
}
/// The Profiles setting is unset when left out, `null` or `"default"` (written as `null`), and set
/// by a choice's id; another value is refused.
#[test]
fn the_profiles_setting_can_be_left_unset() {
assert_eq!(serde_json::to_value(PdfSettings::default()).unwrap()["output"]["profiles"], serde_json::Value::Null);
for unset in [json!({}), json!({"profiles": null}), json!({"profiles": "default"})] {
assert_eq!(settings(json!({"output": unset.clone()})).output.profiles, None, "{unset}");
}
for (id, want) in [("none", ProfileInclusion::None), ("all", ProfileInclusion::All), ("taggedSource", ProfileInclusion::TaggedSource)] {
let s = settings(json!({"output": {"profiles": id}}));
assert_eq!(s.output.profiles, Some(want), "{id}");
assert_eq!(serde_json::from_value::<PdfSettings>(serde_json::to_value(&s).unwrap()).unwrap(), s, "{id} round-trips");
}
for bad in [json!("Default"), json!("never"), json!(1)] {
assert!(serde_json::from_value::<PdfSettings>(json!({"output": {"profiles": bad.clone()}})).is_err(), "{bad}");
}
}
#[test]
fn passwords_are_never_serialized() {
let s = settings(json!({"security": {"openPassword": "secret", "permissionsPassword": "owner"}}));
+32
View File
@@ -337,6 +337,38 @@ fn a_transform_after_a_drop_shadow_scales_the_shadow_with_the_art() {
}
}
/// A Transform effect listed after a Bas Relief turns its light with the art: a group of a black
/// square centered on a white one, lit from the top and turned 90° counterclockwise about its
/// center, draws as the group lit from the left.
#[test]
fn a_transform_after_bas_relief_turns_its_light_with_the_art() {
let relieved = |effects: Vec<(&str, serde_json::Value)>| {
let mut d = Document::new(100.0, 100.0);
let mut square =
|r: Rect, c: Color| Arc::new(Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::basic(Paint::solid(c), Paint::None, 0.0)));
let members = vec![square(Rect::new(20.0, 20.0, 80.0, 80.0), Color::WHITE), square(Rect::new(40.0, 40.0, 60.0, 60.0), Color::BLACK)];
let mut g = Node::group(d.alloc_id(), members);
g.appearance.effects = effects.into_iter().map(|(id, p)| Effect { id: id.into(), params: p, visible: true }).collect();
let l = d.layers[0].id;
d.insert(Some(l), 0, g).unwrap();
render(&d)
};
let relief = |light: &str| ("sketch.basRelief", json!({"lightDirection": light}));
let turned = relieved(vec![relief("top"), ("distort.transform", json!({"rotate": 90}))]);
let left = relieved(vec![relief("left")]);
let top = relieved(vec![relief("top")]);
// The largest difference of a channel between two images.
let diff = |a: &Rendered, b: &Rendered| {
(0..100u32)
.flat_map(|y| (0..100u32).map(move |x| (x, y)))
.map(|(x, y)| a.pixel(x, y).iter().zip(b.pixel(x, y)).map(|(p, q)| p.abs_diff(q)).max().unwrap_or(0))
.max()
.unwrap_or(0)
};
assert!(diff(&left, &top) > 50, "the light's direction shows: {}", diff(&left, &top));
assert!(diff(&turned, &left) <= 2, "turned top light draws as a left light: {}", diff(&turned, &left));
}
/// An object's or a group's Transform effect transforms the raster effects of what it holds with
/// the art: halving a 40 pt square about its center halves the 10 pt offset of its fill's shadow,
/// and of a group member's own shadow, with Scale Strokes & Effects off or on.
+5 -1
View File
@@ -86,11 +86,15 @@ impl Writer<'_> {
// type with warichu, whose stacked lines a reader's <text> can't place either. So are
// small capitals, superscript and subscript and tab leaders, which SVG text doesn't draw (#3869),
// and a glyph chosen for a character, which a reader's <text> draws with the default glyph. So
// is type in one of the document's composite fonts, which a reader can't find by its name.
// is type in one of the document's composite fonts, which a reader can't find by its name,
// and type with an Adjust Diacritic Position, whose marks a reader's <text> draws where the
// font puts them.
let unwritable = t.runs.iter().any(|r| {
r.style.small_caps.is_some()
|| r.style.position != vectorcraft_doc::CharPosition::Normal
|| r.style.glyph_alternate.is_some()
|| r.style.diacritic_horizontal != 0.0
|| r.style.diacritic_vertical != 0.0
|| vectorcraft_doc::CompositeFont::named(&doc.composite_fonts, &r.style.font_family).is_some()
}) || std::iter::once(&t.para).chain(&t.paras).any(|p| p.tabs.iter().any(|tab| !tab.leader.is_empty()));
let outlined = self.opts.outline_text
+57 -12
View File
@@ -315,9 +315,51 @@ impl V {
}
}
/// σ of a blur with standard deviations `x`, `y` (their mean: the effects blur evenly).
fn sd(x: f32, y: f32) -> f64 {
(x as f64 + y as f64) / 2.0
/// σ of a blur with standard deviations `x`, `y` in a user space the document scales by the same
/// amount in every direction when `even` (turned, flipped or scaled alike along both axes). The
/// effects blur evenly: `None` when the blur differs by direction in the document, unless `blurs`
/// is [`Blurs::Nearest`], which takes the mean.
fn sd(x: f32, y: f32, even: bool, blurs: Blurs) -> Option<f64> {
let uneven = (x > 0.0 || y > 0.0) && (x != y || !even);
(blurs == Blurs::Nearest || !uneven).then_some((x as f64 + y as f64) / 2.0)
}
/// How [`effects`] reads a blur that differs by direction in the document, which the effects
/// draw the same in every direction.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Blurs {
/// Not as an effect: the filter is left for an SVG Filters effect ([`kept`]), which draws it.
Exact,
/// As the even blur of the mean standard deviation.
Nearest,
}
/// Whether the linear part of `ts` scales every direction by the same amount (a turn, a flip and
/// an even scale), so an even blur stays even in the document.
fn even_space(ts: Affine) -> bool {
let [a, b, c, d, _, _] = ts.as_coeffs();
let tol = 1e-9 * ts.determinant().abs().sqrt().max(1.0);
let near = |p: f64, q: f64| (p - q).abs() <= tol;
(near(a, d) && near(b, -c)) || (near(a, -d) && near(b, c))
}
/// `filters` (in the order they apply) imported in user space mapped to the document by `ts`: as
/// the live effects they draw as ([`effects`]), else as SVG Filters effects that keep their XML
/// ([`kept`]), else as the live effects nearest them (a blur that differs by direction drawn as
/// an even one). With whether they are live effects. `None` when none of these takes them.
pub(super) fn imported(
filters: &[Arc<Filter>],
ts: Affine,
blends: &HashMap<String, String>,
sources: &HashMap<String, Source>,
) -> Option<(Vec<Effect>, bool)> {
if let Some(fx) = effects(filters, ts, blends, Blurs::Exact) {
return Some((fx, true));
}
if let Some(fx) = kept(filters, ts, sources) {
return Some((fx, false));
}
effects(filters, ts, blends, Blurs::Nearest).map(|fx| (fx, true))
}
fn color(c: usvg::Color) -> Color {
@@ -364,9 +406,10 @@ fn transferred(v: V, [r, g, b, a]: [&TransferFunction; 4], srgb: bool) -> Option
}
}
/// Evaluate one filter's primitives, `k` the scale from its user space to the document.
/// Evaluate one filter's primitives, `k` the scale from its user space to the document, `even`
/// when that scale is the same in every direction ([`even_space`]), blurs read as `blurs` says.
/// `None` when one does something the effects cannot represent.
fn eval(f: &Filter, k: f64) -> Option<V> {
fn eval(f: &Filter, k: f64, even: bool, blurs: Blurs) -> Option<V> {
let mut results: HashMap<&str, V> = HashMap::new();
let mut last = V::Graphic;
for p in f.primitives() {
@@ -380,7 +423,7 @@ fn eval(f: &Filter, k: f64) -> Option<V> {
let v = match p.kind() {
Kind::GaussianBlur(b) => {
let linear = p.color_interpolation() == ColorInterpolation::LinearRGB;
input(b.input())?.blur(sd(b.std_dev_x().get(), b.std_dev_y().get()), linear)?
input(b.input())?.blur(sd(b.std_dev_x().get(), b.std_dev_y().get(), even, blurs)?, linear)?
}
Kind::Offset(o) => input(o.input())?.offset(o.dx() as f64, o.dy() as f64)?,
Kind::Flood(fl) => V::Flood(color(fl.color()), fl.opacity().get()),
@@ -450,8 +493,8 @@ fn eval(f: &Filter, k: f64) -> Option<V> {
}
}
Kind::DropShadow(d) if matches!(input(d.input())?, V::Graphic) => {
let shape =
Shape { sd: sd(d.std_dev_x().get(), d.std_dev_y().get()), dx: d.dx() as f64, dy: d.dy() as f64, moved: true, inverted: false };
let sd = sd(d.std_dev_x().get(), d.std_dev_y().get(), even, blurs)?;
let shape = Shape { sd, dx: d.dx() as f64, dy: d.dy() as f64, moved: true, inverted: false };
V::Stack(vec![V::Paint { shape, color: color(d.color()), opacity: d.opacity().get(), clipped: false }, V::Graphic])
}
_ => return None,
@@ -463,10 +506,12 @@ fn eval(f: &Filter, k: f64) -> Option<V> {
}
/// The live effects `filters` (in the order they apply) stand for, in user space mapped to the
/// document by `ts`; `blends`: the modes our export recorded ([`blends`]). `None` when one of
/// them isn't an effect the canvas draws.
pub(super) fn effects(filters: &[Arc<Filter>], ts: Affine, blends: &HashMap<String, String>) -> Option<Vec<Effect>> {
/// document by `ts`; `blends`: the modes our export recorded ([`blends`]); `blurs`: how a blur
/// that differs by direction reads ([`Blurs`]). `None` when one of them isn't an effect the
/// canvas draws.
fn effects(filters: &[Arc<Filter>], ts: Affine, blends: &HashMap<String, String>, blurs: Blurs) -> Option<Vec<Effect>> {
let k = ts.determinant().abs().sqrt();
let even = even_space(ts);
let [a, b, c, d, _, _] = ts.as_coeffs();
let along = |dx: f64, dy: f64| Vec2::new(a * dx + c * dy, b * dx + d * dy);
let num = |v: f64| (v * 1000.0).round() / 1000.0;
@@ -475,7 +520,7 @@ pub(super) fn effects(filters: &[Arc<Filter>], ts: Affine, blends: &HashMap<Stri
let blur = |sd: f64| num(2.0 * sd * k);
let mode = blends.get(f.id()).map_or("normal", String::as_str);
let paint = |c: Color, o: f32| (c.to_hex(), num(o as f64 * 100.0));
let (id, params) = match eval(f, k)? {
let (id, params) = match eval(f, k, even, blurs)? {
V::Graphic => continue,
// SVG blurs in linear light unless the filter asks for sRGB (`color-interpolation-filters`).
V::Blurred(sd, true) => ("blur.gaussian", json!({ "radius": blur(sd), "linear": true })),
+4 -4
View File
@@ -303,11 +303,11 @@ impl Importer {
(None, id) => format!("'{id}'"),
};
let mask = g.mask().and_then(|m| self.opacity_mask(m, ts, &label));
// Blurs, shadows and glows become live effects (see [`fx`]); other filters become Effect ›
// SVG Filters effects that keep their XML.
// Blurs, shadows and glows become live effects (see [`fx`]); other filters, and blurs that
// differ by direction in the document, become Effect › SVG Filters effects that keep their XML.
let effects = match g.filters() {
[] => vec![],
filters => fx::effects(filters, ts, &self.blends).or_else(|| fx::kept(filters, ts, &self.filter_sources)).unwrap_or_else(|| {
filters => fx::imported(filters, ts, &self.blends, &self.filter_sources).map(|(fx, _)| fx).unwrap_or_else(|| {
// usvg wraps a filtered element in a group of its own: name the element then.
let on = match g.children() {
[usvg::Node::Group(_)] | [] => label.clone(),
@@ -383,7 +383,7 @@ impl Importer {
/// (<https://www.w3.org/TR/SVG11/filters.html#FilterEffectsRegion>) cuts a filter's result at
/// its region. A filter that didn't import (drawn without it) clips nothing.
fn filter_regions(&mut self, g: &usvg::Group, ts: Affine, mut n: Node) -> Option<Node> {
if g.filters().is_empty() || fx::effects(g.filters(), ts, &self.blends).is_none() {
if g.filters().is_empty() || !fx::imported(g.filters(), ts, &self.blends, &self.filter_sources).is_some_and(|(_, live)| live) {
return Some(n);
}
for f in g.filters() {
+57
View File
@@ -284,6 +284,63 @@ fn a_gaussian_blur_becomes_the_effect_with_its_radius() {
assert_eq!(effects(&d)[0].params["radius"], json!(12.0));
}
/// A blur that differs by direction in the document (standard deviations that differ, or an even
/// one in a user space scaled unevenly or skewed) is kept as an SVG filter, which draws it as it
/// is, not as an even Gaussian Blur. In a turned, flipped or evenly scaled user space an even blur
/// stays the effect.
#[test]
fn a_blur_that_differs_by_direction_is_kept_as_its_filter() {
let ids = |body: &str| {
let (d, w) = open(body);
assert!(w.is_empty(), "{w:?}");
effects(&d).iter().map(|e| e.id.clone()).collect::<Vec<_>>()
};
let blur = |sd: &str, transform: &str| {
format!(
r##"<defs><filter id="b"><feGaussianBlur stdDeviation="{sd}"/></filter></defs><rect x="50" y="30" width="60" height="40" fill="#08f" transform="{transform}" filter="url(#b)"/>"##
)
};
assert_eq!(ids(&blur("4 1", "translate(0)")), ["svg.filter"]);
assert_eq!(ids(&blur("3", "scale(1 4)")), ["svg.filter"]);
assert_eq!(ids(&blur("3", "skewX(30)")), ["svg.filter"]);
assert_eq!(ids(&blur("3", "rotate(30) scale(2)")), ["blur.gaussian"]);
assert_eq!(ids(&blur("3", "scale(-2 2)")), ["blur.gaussian"]);
let shadow = |sd: &str| {
format!(
r##"<defs><filter id="s"><feDropShadow dx="2" dy="2" stdDeviation="{sd}"/></filter></defs><rect width="60" height="40" filter="url(#s)"/>"##
)
};
assert_eq!(ids(&shadow("3 1")), ["svg.filter"]);
assert_eq!(ids(&shadow("3")), ["stylize.dropShadow"]);
}
/// An SVG filter's blur in a user space scaled unevenly is written live and opens again as the
/// same effect, which blurs more along the stretched axis, not as an even Gaussian Blur.
#[test]
fn an_exported_blur_in_a_stretched_user_space_opens_as_the_same_effect() {
let xml = r#"<filter id="b" x="-1" y="-1" width="3" height="3"><feGaussianBlur stdDeviation="3"/></filter>"#;
let mut d = Document::new(200.0, 120.0);
let mut n = Node::path(
d.alloc_id(),
shapes::rectangle(Rect::new(60.0, 40.0, 140.0, 80.0)),
Appearance::basic(Paint::solid(Color::rgb(0.9, 0.1, 0.1)), Paint::None, 0.0),
);
let params = json!({ "xml": xml, "scale": 2.0, "origin": [0.0, 0.0], "axes": [0.5, 0.0, 0.0, 2.0] });
n.appearance.effects = vec![Effect { id: "svg.filter".into(), params, visible: true }];
let l = d.layers[0].id;
d.insert(Some(l), 0, n).unwrap();
let out = export(&d, &ExportOptions::default());
assert!(out.contains("<g filter=\"url(#") && !out.contains("<image"), "{out}");
let (back, w) = import_with_report(&out).unwrap();
assert!(w.is_empty(), "{w:?}");
let fx = effects(&back);
assert_eq!(fx.iter().map(|e| e.id.as_str()).collect::<Vec<_>>(), ["svg.filter"], "{out}");
let num = |v: &serde_json::Value| v.as_f64().unwrap();
let axes: Vec<f64> = fx[0].params["axes"].as_array().unwrap().iter().map(num).collect();
assert!(axes.iter().zip([0.5, 0.0, 0.0, 2.0]).all(|(a, b)| (a - b).abs() < 1e-6), "{axes:?}");
assert_similar(&render_artboard(&d), &render_artboard(&back), 40.0, 0.02);
}
/// `color-interpolation-filters` (SVG 1.1 §15.7.6, initially linearRGB:
/// https://www.w3.org/TR/SVG11/painting.html#ColorInterpolationFiltersProperty) picks whether the
/// blur mixes colours in linear light; sRGB, on the primitive or the filter, keeps them as they
+13
View File
@@ -357,6 +357,19 @@ fn a_chosen_glyph_is_written_as_outlines() {
assert!(!svg.contains("<text") && svg.contains("<path"), "{svg}");
}
/// Type with an Adjust Diacritic Position is written as outlines: a reader's `<text>` would draw
/// the marks where the font puts them.
#[test]
fn moved_diacritics_are_written_as_outlines() {
let svg = export(&area_doc(vec![run("re\u{301}sume\u{301}", style(12.0))], 280.0, Justify::Left), &ExportOptions::default());
assert!(svg.contains("<text"), "without a moved mark the text stays live: {svg}");
for moved in [CharStyle { diacritic_horizontal: 100.0, ..style(12.0) }, CharStyle { diacritic_vertical: -100.0, ..style(12.0) }] {
let d = area_doc(vec![run("re\u{301}", style(12.0)), run("sume\u{301}", moved)], 280.0, Justify::Left);
let svg = export(&d, &ExportOptions::default());
assert!(!svg.contains("<text") && svg.contains("<path"), "{svg}");
}
}
/// A run whose font size measures the cap height is written at the em size it is drawn at: 14 pt
/// measuring a 0.7 em cap height is `font-size="20"`, after a 12 pt run measuring the em box,
/// which takes the `<text>` element's 12.
+37 -4
View File
@@ -13,6 +13,12 @@
//! a mark on a ligature (for example Geeza Pro's Allah ligature) painted as its letter. Renderers
//! and exporters read the glyph's run as they always did, so they need no change. The text itself
//! is never changed.
//!
//! The Adjust Horizontal and Vertical Diacritic Positions ([`CharStyle::diacritic_horizontal`])
//! move the face's mark glyphs (GDEF class 3) by the values of the glyph's run. Runs that differ
//! only in paint and those positions stay one shaping cluster at an Arabic harakat or a Hebrew
//! point ([`diacritic_mark_boundary`]), so a mark set apart from its letter takes its own values
//! the same way it takes its own paint.
use skrifa::raw::TableProvider;
use skrifa::raw::tables::layout::ClassDef;
@@ -36,11 +42,24 @@ pub(crate) fn is_harakat(c: char) -> bool {
)
}
/// Is `c` a Hebrew point or cantillation mark (U+0591–U+05BD, U+05BF, U+05C1–U+05C2,
/// U+05C4–U+05C5, U+05C7)?
fn is_hebrew_mark(c: char) -> bool {
matches!(c as u32, 0x0591..=0x05BD | 0x05BF | 0x05C1..=0x05C2 | 0x05C4..=0x05C5 | 0x05C7)
}
/// Is `c` a diacritical mark the Adjust Diacritic Position fields set apart from its letter: an
/// Arabic harakat ([`is_harakat`]) or a Hebrew point?
pub(crate) fn is_diacritic(c: char) -> bool {
is_harakat(c) || is_hebrew_mark(c)
}
/// Do character styles `a` and `b` differ, if at all, only in paint: fill, stroke and how the
/// stroke is drawn, overprint, and the character style name? OpenType feature differences are
/// ignored here: they already apply to their own character ranges during shaping. Nor is the
/// space before a line's first character read inside a cluster, which takes it from its first
/// character (#5111). Stricter than [`crate::shape`]'s `shapes_alike` (which also ignores baseline
/// character (#5111), nor the Adjust Diacritic Positions, which move a mark glyph by its own run's
/// values. Stricter than [`crate::shape`]'s `shapes_alike` (which also ignores baseline
/// shift, tracking, underline, …).
pub(crate) fn paint_only(a: &CharStyle, b: &CharStyle) -> bool {
// Exhaustive: a new attribute must explicitly keep or relax this boundary rule.
@@ -82,6 +101,8 @@ pub(crate) fn paint_only(a: &CharStyle, b: &CharStyle) -> bool {
warichu_scale,
warichu_align,
digits,
diacritic_horizontal: _,
diacritic_vertical: _,
font_height_reference,
no_break,
language,
@@ -150,6 +171,16 @@ pub(crate) fn paint_only_mark_boundary(text: &str, at: usize, before: &CharStyle
(next.is_some_and(is_harakat) || previous.is_some_and(is_harakat)) && paint_only(before, after)
}
/// Is the run boundary at byte `at` of `text`, between styles `before` and `after`, one where the
/// Adjust Diacritic Positions differ, nothing but paint differs besides, and an Arabic harakat or a
/// Hebrew point is on either side? It stays inside a shaping cluster as a paint-only one does.
pub(crate) fn diacritic_mark_boundary(text: &str, at: usize, before: &CharStyle, after: &CharStyle) -> bool {
let next = text.get(at..).and_then(|s| s.chars().next());
let previous = text.get(..at).and_then(|s| s.chars().next_back());
let moved = before.diacritic_horizontal != after.diacritic_horizontal || before.diacritic_vertical != after.diacritic_vertical;
moved && (next.is_some_and(is_diacritic) || previous.is_some_and(is_diacritic)) && paint_only(before, after)
}
/// The byte ranges of the harakat in `text[range]`, each run of consecutive harakat as one range.
/// The range is normalised as [`crate::edit::style_range`] takes one: its ends clamped to the
/// text, each moved back to the start of the character it falls in, and put in order.
@@ -194,7 +225,8 @@ pub(crate) fn mark_classes(face: &FontFace) -> Option<ClassDef<'_>> {
/// by glyph): repeated glyph ids alone could hide a changed correspondence. A glyph whose character
/// lies outside its own shaping cluster of `raw` (from its cluster value up to the next larger one,
/// else `end`) gets its cluster's first character instead. A later in-cluster character is kept
/// only when the glyph is a GDEF mark and that character is a harakat; otherwise the cluster start
/// only when the glyph is a GDEF mark and that character is a harakat or a Hebrew point
/// ([`is_diacritic`]); otherwise the cluster start
/// is kept (conservative: a mark may miss its colour; a base must never take a mark's). `raw`'s
/// clusters are never changed. These are HarfBuzz shaping clusters, which can span more than one
/// grapheme (a ligature).
@@ -224,8 +256,9 @@ pub(crate) fn own_chars(
if c.1 == r.1 {
return c.1;
}
// Later in-cluster character: only a positively identified mark glyph on a harakat.
let mark_char = text.get(c.1 as usize..).and_then(|s| s.chars().next()).is_some_and(is_harakat);
// Later in-cluster character: only a positively identified mark glyph on a harakat or
// a Hebrew point.
let mark_char = text.get(c.1 as usize..).and_then(|s| s.chars().next()).is_some_and(is_diacritic);
if is_gdef_mark(r.0) && mark_char { c.1 } else { r.1 }
})
.collect()
+37 -10
View File
@@ -1126,6 +1126,10 @@ fn drawn_alike(a: &CharStyle, b: &CharStyle, vertical: bool) -> bool {
warichu_scale: _,
warichu_align: _,
digits,
// A mark glyph moves by its own run's values ([`shape_segment`]), so a mark keeps its
// letter whatever they are.
diacritic_horizontal: _,
diacritic_vertical: _,
font_height_reference,
no_break,
language,
@@ -1200,7 +1204,8 @@ pub(crate) fn warichu_alike(a: &CharStyle, b: &CharStyle) -> bool {
/// character style's name, leading, baseline shift, rotation, Character Alignment, Character
/// Direction (text is shaped apart where its bidi level changes), Kashidas, the kerning (each glyph takes its
/// run's, see [`shape_segment`]), the space before a line's first character ([`space_before`]),
/// Insert Aki ([`aki`]), Tsume ([`tighten`]), the OpenType features and the East Asian glyph form (each run's apply to its own characters, as features
/// Insert Aki ([`aki`]), Tsume ([`tighten`]), the Adjust Diacritic Positions (each mark glyph takes
/// its run's), the OpenType features and the East Asian glyph form (each run's apply to its own characters, as features
/// over a range of the one buffer) and the tracking, as long as the tracking keeps or drops
/// standard ligatures alike ([`crate::features::ligatures_suppressed_by`]).
fn shapes_alike(a: &CharStyle, b: &CharStyle) -> bool {
@@ -1259,6 +1264,8 @@ fn shapes_alike(a: &CharStyle, b: &CharStyle) -> bool {
warichu_scale: _,
warichu_align: _,
digits,
diacritic_horizontal: _,
diacritic_vertical: _,
font_height_reference,
no_break,
language,
@@ -1537,11 +1544,21 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
if !manual_ends.is_empty() {
return shape_apart(manual_ends, out);
}
// Harakat styled apart from their letters (paint only): shaped with them, each glyph then
// takes its own character's run ([`crate::harakat`]).
// Harakat styled apart from their letters (paint only), and harakat and Hebrew points with
// diacritic positions of their own: shaped with them, each glyph then takes its own
// character's run ([`crate::harakat`]).
let mark_boundaries: Vec<usize> = boundaries()
.filter(|&b| run_at(b - 1).1 != run_at(b).1 && crate::harakat::paint_only_mark_boundary(text, b, run_at(b - 1).1, run_at(b).1))
.filter(|&b| {
let (before, after) = (run_at(b - 1).1, run_at(b).1);
before != after
&& (crate::harakat::paint_only_mark_boundary(text, b, before, after)
|| crate::harakat::diacritic_mark_boundary(text, b, before, after))
})
.collect();
// The face's mark classes, read once when any of the segment's runs moves its marks.
let moves_marks =
runs.get(source_runs.clone()).unwrap_or_default().iter().any(|(_, s)| s.diacritic_horizontal != 0.0 || s.diacritic_vertical != 0.0);
let diacritic_classes = if moves_marks { crate::harakat::mark_classes(face) } else { None };
// Source run starts are sorted. Reuse their classification when checking cluster splits.
let styled_marks = !mark_boundaries.is_empty();
let char_level = std::cell::Cell::new(false);
@@ -1842,11 +1859,21 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
for (gi, &(gid, cl, xa, xo, yo)) in raw.iter().enumerate() {
let cl = cl as usize;
let (run, gst) = run_at(cl);
// A glyph of a harakat styled apart takes its own character's run (paint only).
let run = match chars.get(gi).map(|&c| run_at(c as usize)) {
Some((own, own_st)) if crate::harakat::paint_only(gst, own_st) => own,
_ => run,
// A glyph of a harakat styled apart takes its own character's run (paint and diacritic
// positions only).
let (run, run_st) = match chars.get(gi).map(|&c| run_at(c as usize)) {
Some((own, own_st)) if crate::harakat::paint_only(gst, own_st) => (own, own_st),
_ => (run, gst),
};
// A mark glyph (GDEF class 3) moves by its run's Adjust Diacritic Positions, thousandths
// of the em it is set in: right and up for positive values.
let (mut dx, mut dy) = (xo as f64 * k * hs, -(yo as f64) * k * vs);
if let Some(classes) = &diacritic_classes
&& classes.get(skrifa::GlyphId::new(gid)) == 3
{
dx += run_st.diacritic_horizontal / 1000.0 * size * hs;
dy -= run_st.diacritic_vertical / 1000.0 * size * vs;
}
let end = cluster_end(cl);
let last_in_cluster = gi + 1 == n || raw[gi + 1].1 as usize != cl;
let ch = first_char(cl);
@@ -1901,8 +1928,8 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
run,
adv,
tracking: tracked,
dx: xo as f64 * k * hs,
dy: -(yo as f64) * k * vs,
dx,
dy,
kern_shift,
aki_shift,
aki: aki_in_adv,
+72
View File
@@ -173,6 +173,8 @@ fn paint_only_keeps_every_drawing_attribute_and_partial_equality() {
b.style_name = a.style_name.clone();
b.kerning_before = a.kerning_before;
b.features = a.features.clone();
b.diacritic_horizontal = a.diacritic_horizontal;
b.diacritic_vertical = a.diacritic_vertical;
*a == b
}
@@ -226,6 +228,8 @@ fn paint_only_keeps_every_drawing_attribute_and_partial_equality() {
field!(tcy_left_right, 1.0, false);
field!(standard_vertical_roman, true, false);
field!(digits, Digits::Hindi, false);
field!(diacritic_horizontal, 100.0, true);
field!(diacritic_vertical, -100.0, true);
field!(font_height_reference, FontHeightReference::CapHeight, false);
field!(no_break, true, false);
field!(language, Some("ar".into()), false);
@@ -331,6 +335,74 @@ fn feature_only_harakat_boundaries_keep_attachment_and_ownership() {
}
}
/// Adjust Horizontal and Vertical Diacritic Position move the mark glyphs (GDEF class 3) by
/// thousandths of an em of the glyph size, right and up for positive values, and leave the letters
/// where they were. A mark styled apart from its letter takes its own values.
#[test]
fn diacritic_positions_move_marks_and_keep_letters() {
let db = FontDb::with_font_dirs(vec![]);
assert_eq!(db.add_font(crate::test_fonts::lam_alef_font(b"rlig").expect("the test font builds")), 1);
let family = crate::test_fonts::lam_alef_family(b"rlig");
let face = db.face(family, "Regular").expect("the test face");
const WORD: &str = "بَبَبَ";
let plain = TextObject::point(Point::ZERO, WORD, style(family));
let before = layout(&db, &plain);
assert_eq!(before.glyphs.len(), 6, "three bases with their attached marks");
let (h, v) = (200.0, 100.0);
let moved = (h / 1000.0 * 48.0, -v / 1000.0 * 48.0);
// (letters set, marks set): which glyphs move.
for (letters, marks) in [(true, true), (false, true), (true, false), (false, false)] {
let mut text = plain.clone();
for (byte, ch) in WORD.char_indices() {
if (is_harakat(ch) && marks) || (!is_harakat(ch) && letters) {
crate::edit::style_range(&mut text.runs, byte, byte + ch.len_utf8(), |st| {
st.diacritic_horizontal = h;
st.diacritic_vertical = v;
});
}
}
let after = layout(&db, &text);
assert_eq!(after.glyphs.len(), before.glyphs.len(), "letters {letters}, marks {marks}");
let mut marks_seen = 0;
for (a, b) in before.glyphs.iter().zip(&after.glyphs) {
assert_eq!((a.gid, a.byte, a.origin, a.advance), (b.gid, b.byte, b.origin, b.advance), "letters {letters}, marks {marks}");
let (ta, tb) = (a.xf.translation(), b.xf.translation());
let delta = (tb.x - ta.x, tb.y - ta.y);
let mark = is_gdef_mark(&face, a.gid);
marks_seen += usize::from(mark);
let want = if mark && marks { moved } else { (0.0, 0.0) };
assert!(
(delta.0 - want.0).abs() < 1e-9 && (delta.1 - want.1).abs() < 1e-9,
"letters {letters}, marks {marks}: glyph {} moved {delta:?}, want {want:?}",
a.gid
);
}
assert_eq!(marks_seen, 3, "the three fathas are marks");
}
}
/// Hebrew points count as diacritics as well as Arabic harakat; Latin accents and letters do not.
/// A boundary where only the diacritic positions differ asks for the character-level pass only
/// at such a mark.
#[test]
fn hebrew_points_and_harakat_are_diacritics() {
use crate::harakat::{diacritic_mark_boundary, is_diacritic};
for c in ['\u{05B8}', '\u{05C1}', '\u{05BC}', '\u{064E}', '\u{0651}'] {
assert!(is_diacritic(c), "{c:?}");
}
for c in ['\u{05D0}', '\u{0628}', '\u{0301}', 'a', '\u{05BE}'] {
assert!(!is_diacritic(c), "{c:?}");
}
let a = style(FAMILY);
let b = CharStyle { diacritic_vertical: 150.0, ..a.clone() };
assert!(diacritic_mark_boundary("שָׁ", 2, &a, &b), "a Hebrew point styled apart");
assert!(diacritic_mark_boundary("بَ", 2, &a, &b), "a fatha styled apart");
assert!(!diacritic_mark_boundary("e\u{301}", 1, &a, &b), "a Latin accent keeps its cluster's values");
assert!(!diacritic_mark_boundary("بَ", 2, &a, &a), "the same values");
let c = CharStyle { size: 20.0, ..b.clone() };
assert!(!diacritic_mark_boundary("بَ", 2, &a, &c), "a size change splits the run anyway");
}
/// A range is normalised as `edit::style_range` takes one: clamped, each end moved back to the
/// start of its character, put in order. Never a silent empty result for a usable range.
#[test]
+4 -3
View File
@@ -41,9 +41,10 @@ pub use live_paint::{
};
use live_paint::{check_live_paint_options, lp_color, lp_rgb_color};
pub use lookup::{
EDGE_NAME, FACE_NAME, Face, LIVE_PAINT_NAME, LIVE_PAINT_PREFIX, LP_JOIN_TOL, SOURCES_NAME, builder_members, connected_edges, drawn_outlines,
edge_near, edges, face_at, faces, flood_faces, is_live_paint, leaf_shapes, live_paint_at, live_paint_takes, lp_stroke_paint, node_outline,
outline_snap, path_contains, shape_builder_shapes, shapes_for, sources, visible_edge_near, visible_face_at,
EDGE_NAME, FACE_NAME, Face, LIVE_PAINT_NAME, LIVE_PAINT_PREFIX, LP_JOIN_TOL, SOURCES_NAME, builder_members, connected_edges,
connected_edges_through, drawn_outlines, edge_near, edges, face_at, faces, flood_faces, is_live_paint, leaf_shapes, live_paint_at,
live_paint_takes, lp_stroke_paint, node_outline, outline_snap, path_contains, shape_builder_shapes, shapes_for, sources, visible_edge_near,
visible_face_at,
};
pub use map::{
BuilderMap, HATCH, HIGHLIGHT_RED, Hit, MergeGeometry, MergeInput, PreparedMerge, Rest, Touched, hatch, maps_built, merge_geometry, merge_inputs,
+198 -25
View File
@@ -1,14 +1,15 @@
use super::cache::RegionCache;
use super::lookup::{
connected_edges, edges, faces, flood_faces, is_live_paint, leaf_shapes, live_paint_at, live_paint_at_where, lp_stroke_paint, node_outline,
visible_edge_near, visible_face_at,
connected_edges, connected_edges_through, edges, face_at, faces, flood_faces, is_live_paint, leaf_shapes, live_paint_at, live_paint_at_where,
lp_stroke_paint, node_outline, visible_edge_near, visible_face_at,
};
use super::map::{HIGHLIGHT_RED, sorted_roots};
use super::map::{BuilderMap, HIGHLIGHT_RED, sorted_roots};
use super::{
Action, Arc, BezPath, CLICK_TOL_PX, Cursor, Document, EDGE_NAME, FACE_NAME, FillRule, Mods, Node, NodeId, Overlay, Point, PointerEvent,
PointerKind, Rect, Tool, ToolContext, ToolKey, Value, color_swatches, json, json_ids, path_contains, pick_swatch, plain, swatch_chips,
};
use vectorcraft_color::Paint;
use vectorcraft_pathops as po;
// ---------- Live Paint Bucket ----------
@@ -178,10 +179,12 @@ enum LpPaint {
///
/// A double-click on a face fills it and the faces reached from it across edges that draw no
/// stroke (`scope: "connected"`); on an edge it paints the edges joined to it that have its stroke.
/// A triple-click on a face fills every face of the group with the face's fill, and on an edge it
/// paints every edge of the group with the edge's stroke (`scope: "samePaint"`). Each click of a
/// double-click or triple-click paints as it arrives, as its own undo step, and the paint compared
/// is the one the face or edge had before the first of its clicks that painted it. A first click
/// A triple-click on a face fills every face of the group that has the face's fill, and on an edge
/// it paints every edge of the group that draws with the edge's stroke paint (`scope:
/// "samePaint"`); each of them takes the bucket's paint. Each click of a double-click or
/// triple-click paints as it arrives, as its own undo step when it changes a paint, and the paint
/// compared is the one the face or edge had before the first of its clicks that painted it,
/// including a click whose drag or release crossed it. A first click
/// that made the Live Paint group counts when the face it filled is the clicked face. Shift and the
/// options choose a face or an edge as for a click; with Alt or Cmd/Ctrl held a double-click or
/// triple-click paints nothing. With Space held for the view tools, a click, double-click or triple-click paints
@@ -201,6 +204,8 @@ pub struct LivePaintBucketTool {
at: Option<(Point, Mods)>,
/// The fill command and polyline previewed from the press's snapshot.
fill_drag: Option<(Value, Vec<Vec<Point>>)>,
/// What a fill drag paints, as it was at its press.
drag_from: LpDragFrom,
/// The last [`LP_PRESSES`] presses, oldest first: the face or edge each one painted, with its
/// paint before that press, or None for a press that painted no face or edge.
presses: Vec<Option<LpPress>>,
@@ -229,22 +234,128 @@ struct LpPress {
/// The other faces or edges the double-click that followed the press reached, each with its
/// fill or drawn stroke paint before the double-click.
also: Vec<(NodeId, Paint)>,
/// The other faces the press's drag crossed, its release included, each with its fill before
/// the press.
dragged: Vec<(NodeId, Paint)>,
/// For a press that makes the Live Paint group: what the group is made from, with the path
/// chunks of the press's drag, its release included.
dragged_made: Option<Arc<(LpMade, Vec<Vec<Point>>)>>,
}
/// The fill of the face under `p` in the Live Paint group that `roots` make: the fill of the
/// front-most of their paths whose closed subpaths hold `p`, else none. Open subpaths bound no face.
fn made_face_fill(doc: &Document, roots: &[NodeId], p: Point) -> Paint {
let mut leaves = vec![];
for n in roots.iter().filter_map(|id| doc.node(*id)) {
leaf_shapes(n, &mut leaves);
/// What a Live Paint Bucket fill drag paints, as it was at the press.
#[derive(Default)]
enum LpDragFrom {
#[default]
None,
/// The faces of an existing Live Paint group.
Faces(Vec<Arc<Node>>),
/// What the group is made from, for a drag that makes the group.
Made(LpMade),
}
/// The faces among `faces` (a Live Paint group's faces, back to front) that a drag along the path
/// chunks `chunks` crosses, as `livePaint.fill` finds them, each with its fill.
fn crossed_faces(faces: &[Arc<Node>], chunks: &[Vec<Point>]) -> Vec<(NodeId, Paint)> {
let mut hit = vec![];
let mut regions = vec![];
// Front first, as visible_face_at looks.
for f in faces.iter().rev().filter(|f| f.visible) {
if let Some(path) = f.path_data()
&& let Some(bounds) = path.bounds()
{
hit.push(f);
regions.push((po::Region { path: path.clone(), sources: vec![] }, path.to_bezpath(), bounds));
}
}
let map = BuilderMap { regions, ..Default::default() };
let mut crossed: Vec<(NodeId, Paint)> = vec![];
for chunk in chunks {
for f in map.hits_along(chunk, None).regions.iter().filter_map(|i| hit.get(*i)) {
if !crossed.iter().any(|(id, _)| *id == f.id) {
crossed.push((f.id, f.appearance.fill_paint()));
}
}
}
crossed
}
/// What the Live Paint group a fill press makes from the selection is made from, as it was at the
/// press, following Live Paint Make and Merge.
#[derive(Debug, PartialEq)]
struct LpMade {
/// The paint Merge keeps from the faces of the first selected Live Paint group that draw: a
/// point inside each face with its fill, given to the made face that holds the point.
kept: Vec<(Point, Paint)>,
/// The paths the faces are made from, back to front: Merge's group's source paths first, then
/// the other objects', a Live Paint group giving its source paths.
sources: Vec<Node>,
}
/// What the Live Paint group the selected `roots` make is made from ([`LpMade`]).
fn made_leaves(doc: &Document, roots: &[NodeId]) -> LpMade {
let nodes: Vec<&Node> = roots.iter().filter_map(|id| doc.node(*id)).collect();
let target = nodes.iter().position(|n| is_live_paint(n));
let mut kept = vec![];
let mut sources = vec![];
for i in target.into_iter().chain((0..nodes.len()).filter(|i| Some(*i) != target)) {
let Some(n) = nodes.get(i) else { continue };
if !is_live_paint(n) {
leaf_shapes(n, &mut sources);
continue;
}
for s in super::lookup::sources(n).and_then(|g| g.children()).into_iter().flatten() {
leaf_shapes(s, &mut sources);
}
if Some(i) == target {
let draws = |f: &&Arc<Node>| f.visible && f.opacity > 0.0 && (f.appearance.has_drawn_fill() || f.appearance.has_drawn_stroke());
// Merge fixes a kept unplaced gradient to its fit on the face it comes from.
let kept_fill = |f: &Arc<Node>| {
let mut n = (**f).clone();
n.pin_gradients();
n.appearance.fill_paint()
};
kept.extend(faces(n).into_iter().filter(draws).filter_map(|f| Some((po::interior_point(f.path_data()?)?, kept_fill(f)))));
}
}
LpMade { kept, sources: sources.into_iter().cloned().collect() }
}
/// The fill a face made at `p` from the source paths of `made` gets: the topmost fill that draws
/// of the front-most source path whose closed subpaths hold `p` and that has such a fill, else
/// none. Open subpaths bound no face.
fn made_face_fill(made: &LpMade, p: Point) -> Paint {
let holds = |l: &Node| {
node_outline(l).is_some_and(|(path, rule)| {
let closed = vectorcraft_geom::PathData::new(path.subpaths.into_iter().filter(|sp| sp.closed && sp.anchors.len() >= 2).collect());
!closed.is_empty() && path_contains(&closed, rule, p)
})
};
leaves.iter().rev().find(|l| holds(l)).map_or(Paint::None, |l| l.appearance.fill_paint())
// As Make: the front-most covering source with a fill that draws (shown, with paint and an
// opacity above 0, on a source with an opacity above 0) gives the face its topmost such fill,
// an unplaced gradient fixed to its fit on the source.
made.sources
.iter()
.rev()
.filter(|l| l.opacity > 0.0 && l.appearance.has_drawn_fill() && holds(l))
.find_map(|l| {
let mut n = l.clone();
n.pin_gradients();
n.appearance.items.iter().rev().find_map(|i| match i {
vectorcraft_doc::AppearanceItem::Fill(f) if f.visible && !f.paint.is_none() && f.opacity > 0.0 => Some(f.paint.clone()),
_ => None,
})
})
.unwrap_or(Paint::None)
}
/// The fill face `face` of Live Paint group `group` was made with from `made`: the kept paint
/// whose point the face holds (the last one, as Merge applies them in order), else the fill of the
/// source path at a point inside the face.
fn made_part_fill(made: &LpMade, group: &Node, face: &Node) -> Paint {
if let Some((_, paint)) = made.kept.iter().rev().find(|(p, _)| face_at(group, *p).is_some_and(|f| f.id == face.id)) {
return paint.clone();
}
face.path_data().and_then(po::interior_point).map_or(Paint::None, |p| made_face_fill(made, p))
}
/// How many presses the Live Paint Bucket keeps: the three of a triple-click.
@@ -260,6 +371,7 @@ impl Default for LivePaintBucketTool {
hover: LpHover::None,
at: None,
fill_drag: None,
drag_from: LpDragFrom::None,
presses: Vec::new(),
fills: true,
strokes: false,
@@ -336,7 +448,26 @@ impl LivePaintBucketTool {
/// Note a press at `at` that paints face or edge (`edge`) `n`.
fn note_part(&mut self, n: &Node, edge: bool, at: Point) {
let before = if edge { lp_stroke_paint(n) } else { n.appearance.fill_paint() };
self.note_press(Some(LpPress { part: Some(n.id), at, before, also: vec![] }));
self.note_press(Some(LpPress { part: Some(n.id), at, before, also: vec![], dragged: vec![], dragged_made: None }));
}
/// End the fill drag, noting on the last press the other faces its drag crossed, with their
/// fills before the press (for a press that makes the group, what the group is made from and
/// the drag, for [`Self::before`] to look the faces up in the group made). → whether a fill
/// drag was on.
fn end_fill(&mut self) -> bool {
let from = std::mem::take(&mut self.drag_from);
let Some((_, chunks)) = self.fill_drag.take() else { return false };
let Some(Some(last)) = self.presses.last_mut() else { return true };
match from {
LpDragFrom::None => {}
LpDragFrom::Faces(faces) => {
let part = last.part;
last.dragged = crossed_faces(&faces, &chunks).into_iter().filter(|(id, _)| part != Some(*id)).collect();
}
LpDragFrom::Made(made) => last.dragged_made = Some(Arc::new((made, chunks))),
}
true
}
/// Note that the double-click after the last press also reaches `parts` of group `group`, with
@@ -356,12 +487,17 @@ impl LivePaintBucketTool {
/// The paint `part` had before the first press of a click sequence of `clicks` presses that
/// painted `part`, or before the double-click after a press when that double-click reached it
/// (the sequence's first press counts when it made the group `part` is in and the face it
/// filled there is `part`); `now` when the last press did not paint it.
/// filled there is `part`), a press's drag or release crossing `part` included; `now` when the
/// last press did not paint it.
fn before(&self, cx: &ToolContext, part: NodeId, clicks: usize, now: Paint) -> Paint {
let Some(run) = self.presses.len().checked_sub(clicks).and_then(|from| self.presses.get(from..)) else { return now };
let made_part = |q: &LpPress| live_paint_at(cx.doc, q.at).and_then(|g| visible_face_at(cx.doc.node(g)?, q.at)).is_some_and(|f| f.id == part);
let on_part = |i: usize, q: &LpPress| q.part == Some(part) || (i == 0 && q.part.is_none() && made_part(q));
if !run.last().and_then(Option::as_ref).is_some_and(|q| on_part(run.len() - 1, q)) {
let made_part = |at: Point| live_paint_at(cx.doc, at).and_then(|g| visible_face_at(cx.doc.node(g)?, at)).is_some_and(|f| f.id == part);
let on_part = |i: usize, q: &LpPress| q.part == Some(part) || (i == 0 && q.part.is_none() && made_part(q.at));
let dragged = |q: &LpPress| q.dragged.iter().any(|(id, _)| *id == part);
// An earlier press of the sequence that painted `part` counts too: a press on the next edge
// released back on `part` paints that edge, and the double-click targets `part`.
let painted = run.iter().enumerate().any(|(i, q)| q.as_ref().is_some_and(|q| on_part(i, q)));
if !painted && !run.last().and_then(Option::as_ref).is_some_and(dragged) {
return now;
}
for (i, q) in run.iter().enumerate() {
@@ -369,7 +505,17 @@ impl LivePaintBucketTool {
if on_part(i, q) {
return q.before.clone();
}
if let Some((_, paint)) = q.also.iter().find(|(id, _)| *id == part) {
// A face of the group the press made (the one under the press) that its drag crossed has
// the fill it was made with.
if i == 0
&& let Some(drag) = &q.dragged_made
&& let Some(group) = live_paint_at(cx.doc, q.at).and_then(|g| cx.doc.node(g))
&& let Some(face) = faces(group).into_iter().find(|f| f.id == part)
&& !crossed_faces(std::slice::from_ref(face), &drag.1).is_empty()
{
return made_part_fill(&drag.0, group, face);
}
if let Some((_, paint)) = q.dragged.iter().chain(&q.also).find(|(id, _)| *id == part) {
return paint.clone();
}
}
@@ -395,7 +541,23 @@ impl LivePaintBucketTool {
if clicks == 2
&& let Some(group) = cx.doc.node(g)
{
self.note_reached(group, connected_edges(group, e.id, &like), true);
// The other edge either click painted joins as the stroke paint it had before.
let through: Vec<NodeId> = self
.presses
.len()
.checked_sub(2)
.and_then(|i| self.presses.get(i..))
.into_iter()
.flatten()
.flatten()
.filter(|q| q.before == like)
.filter_map(|q| q.part)
.filter(|id| *id != e.id)
.collect();
self.note_reached(group, connected_edges_through(group, e.id, &like, &through), true);
if !through.is_empty() {
v["through"] = json_ids(&through);
}
}
if let Ok(like) = serde_json::to_value(like) {
v["match"] = like;
@@ -495,7 +657,7 @@ impl Tool for LivePaintBucketTool {
fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
let p = ev.pos;
// A second press finishes the preceding click, including callers without a release.
if ev.kind == PointerKind::Down && self.fill_drag.take().is_some() {
if ev.kind == PointerKind::Down && self.end_fill() {
let mut acts = vec![Action::Commit];
acts.extend(self.pointer(cx, ev));
return acts;
@@ -553,11 +715,15 @@ impl Tool for LivePaintBucketTool {
Some(f) => self.note_part(f, false, p),
None => self.note_press(None),
}
self.drag_from = LpDragFrom::Faces(cx.doc.node(g).map(|n| faces(n).into_iter().cloned().collect()).unwrap_or_default());
return self.begin_fill(json!({ "group": g.0, "point": point }), p);
}
if self.cache.at(cx, p).is_some() {
let roots = sorted_roots(cx.doc, &cx.selection.objects);
self.note_press(Some(LpPress { part: None, at: p, before: made_face_fill(cx.doc, &roots, p), also: vec![] }));
let made = made_leaves(cx.doc, &roots);
let before = made_face_fill(&made, p);
self.note_press(Some(LpPress { part: None, at: p, before, also: vec![], dragged: vec![], dragged_made: None }));
self.drag_from = LpDragFrom::Made(made);
return self.begin_fill(json!({ "ids": json_ids(&roots), "point": point }), p);
}
self.note_press(None);
@@ -568,7 +734,7 @@ impl Tool for LivePaintBucketTool {
// The swatch preview shows again at the release point.
self.at = Some((p, ev.mods));
let mut acts = self.drag_fill(p);
if self.fill_drag.take().is_some() {
if self.end_fill() {
acts.push(Action::Commit);
}
acts
@@ -586,6 +752,7 @@ impl Tool for LivePaintBucketTool {
/// the active paint, while no drag is on.
fn key(&mut self, cx: &ToolContext, key: ToolKey, mods: Mods) -> Vec<Action> {
if key == ToolKey::Escape {
self.drag_from = LpDragFrom::None;
return if self.fill_drag.take().is_some() { vec![Action::Cancel] } else { vec![] };
}
if !self.claims_key_with(cx, key, mods) {
@@ -621,7 +788,7 @@ impl Tool for LivePaintBucketTool {
fn deactivate(&mut self, _cx: &ToolContext) -> Vec<Action> {
self.presses.clear();
if self.fill_drag.take().is_some() { vec![Action::Commit] } else { vec![] }
if self.end_fill() { vec![Action::Commit] } else { vec![] }
}
/// The pointer hovers nothing for the tool: its highlight and its swatch preview go.
@@ -630,6 +797,12 @@ impl Tool for LivePaintBucketTool {
self.at = None;
}
/// A press the view tools took counts as a press that paints no face or edge, for the clicks
/// a double-click or triple-click compares.
fn press_elsewhere(&mut self) {
self.note_press(None);
}
fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
let mut out = lp_overlays(&self.hover, &self.cache, self.color, self.width as f32, (self.width * LP_BUCKET_EDGE_FRACTION) as f32);
// No chips during a fill drag, or while Alt makes the tool sample with the eyedropper.
+8 -1
View File
@@ -405,8 +405,15 @@ impl LpEdgeGrid {
/// end of an edge already reached.
/// Empty when `start` is not an edge of `group` that is not hidden.
pub fn connected_edges(group: &Node, start: NodeId, paint: &Paint) -> Vec<NodeId> {
connected_edges_through(group, start, paint, &[])
}
/// [`connected_edges`], with the edges in `through` counted as drawing with stroke paint `paint`
/// whatever paint they draw with now.
pub fn connected_edges_through(group: &Node, start: NodeId, paint: &Paint, through: &[NodeId]) -> Vec<NodeId> {
use std::collections::{HashMap, HashSet};
let es: Vec<&Arc<Node>> = edges(group).into_iter().filter(|e| e.visible && (e.id == start || lp_stroke_paint(e) == *paint)).collect();
let es: Vec<&Arc<Node>> =
edges(group).into_iter().filter(|e| e.visible && (e.id == start || through.contains(&e.id) || lp_stroke_paint(e) == *paint)).collect();
// The first and last points of each subpath of each edge.
let ends: Vec<Vec<Point>> = es
.iter()
+85
View File
@@ -1386,6 +1386,39 @@ fn bucket_triple_click_with_a_click_on_another_face_between_matches_the_first_fi
);
}
/// A triple-click whose second press the view tools take (held Space) matches the fill the face had
/// before the first click: that press counts as one that paints nothing. The pointer leaving the
/// canvas between three clicks adds no press.
#[test]
fn bucket_triple_click_with_a_view_tool_press_between_matches_the_first_fill() {
use vectorcraft_color::{Color, Paint};
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
let (d, gid, f2, _) = live_group_doc();
let mut painted = d.clone();
painted.node_mut(f2).unwrap().appearance.set_fill(red.clone());
let s = Selection::default();
let p = paint();
let (cx, later) = (cx(&d, &s, &p), cx(&painted, &s, &p));
let own = serde_json::to_value(d.node(f2).unwrap().appearance.fill_paint()).unwrap();
assert_ne!(own, serde_json::to_value(&red).unwrap());
let want = vec![Action::Exec("livePaint.fill".into(), json!({ "group": gid.0, "point": [75.0, 25.0], "scope": "samePaint", "match": own }))];
fn click(t: &mut LivePaintBucketTool, ctx: &ToolContext) {
t.pointer(ctx, &ev(PointerKind::Down, 75.0, 25.0));
t.pointer(ctx, &ev(PointerKind::Up, 75.0, 25.0));
}
let mut t = LivePaintBucketTool::default();
click(&mut t, &cx);
t.press_elsewhere();
click(&mut t, &later);
assert_eq!(t.pointer(&later, &ev(PointerKind::TripleClick, 75.0, 25.0)), want, "a view tool's press between");
let mut t = LivePaintBucketTool::default();
click(&mut t, &cx);
click(&mut t, &later);
t.hover_ended(&later);
click(&mut t, &later);
assert_eq!(t.pointer(&later, &ev(PointerKind::TripleClick, 75.0, 25.0)), want, "the pointer leaving between");
}
/// With Space held for the view tools, the pointer outlines no face or edge, as a press there
/// paints nothing.
#[test]
@@ -2736,6 +2769,58 @@ fn live_paint_selection_triple_click_series_ends_with_the_same_paint_parts() {
assert_eq!(sel, vec![c.0]);
}
/// A Shift-triple-click on a face whose double-click already reaches a joined face of the same
/// fill selects every face with that fill: the joined face the double-click toggled on is not
/// toggled off again.
#[test]
fn live_paint_selection_shift_triple_click_keeps_joined_faces_of_the_same_fill() {
let mut d = Document::new(500.0, 500.0);
let (_, [a, b, c], _) = live_strip(&mut d);
let red = Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0));
// A and B are joined across the unstroked edge AB; C is parted from them by the stroked edge BC.
for id in [a, b, c] {
d.node_mut(id).unwrap().appearance.set_fill(red.clone());
}
let s = Selection::default();
let p = paint();
let cx = cx(&d, &s, &p);
let shift = Mods { shift: true, ..Default::default() };
let mut t = LivePaintSelectionTool::default();
let mut sel: Vec<u64> = vec![];
for kind in [
PointerKind::Down,
PointerKind::Up,
PointerKind::Down,
PointerKind::Up,
PointerKind::DoubleClick,
PointerKind::Down,
PointerKind::Up,
PointerKind::TripleClick,
] {
for act in t.pointer(&cx, &ev(kind, 25.0, 25.0).with_mods(shift)) {
let Action::Exec(cmd, args) = act else { panic!("{act:?}") };
assert_eq!(cmd, "select.toggle");
let ids: Vec<u64> = match (args.get("ids"), args.get("id")) {
(Some(v), _) => v.as_array().unwrap().iter().map(|i| i.as_u64().unwrap()).collect(),
(None, Some(i)) => vec![i.as_u64().unwrap()],
(None, None) => vec![],
};
for i in ids {
match sel.iter().position(|x| *x == i) {
Some(k) => {
sel.remove(k);
}
None => sel.push(i),
}
}
}
}
sel.sort_unstable();
let mut want = vec![a.0, b.0, c.0];
want.sort_unstable();
assert_eq!(sel, want);
}
#[test]
fn live_paint_selection_double_click_skips_locked_groups_and_art_outside_isolation() {
let mut d = Document::new(500.0, 500.0);
+1 -1
View File
@@ -21,7 +21,7 @@ pub use curvature::{
CurvatureTool, EndCurve, curvature_close, curvature_extend, curvature_insert, curvature_move, curvature_remove, curvature_smooth,
};
pub use family::FamilyTool;
pub use gesture::GestureTool;
pub use gesture::{GestureTool, can_smooth};
/// Colour of tool feedback (Illustrator's selection blue).
pub const FEEDBACK: [u8; 3] = [0x4f, 0x9d, 0xff];
+9 -2
View File
@@ -791,9 +791,16 @@ fn redraw_targets(cx: &ToolContext, id: NodeId) -> Vec<NodeId> {
/// Whether the selection contains a path the Smooth command can act on: one with a subpath of three
/// or more anchors, or of two anchors joined by a curve.
fn has_selected_smooth_path(cx: &ToolContext) -> bool {
let editable = cx.doc.editable();
can_smooth(cx.doc, cx.selection)
}
/// Whether `selection` in `doc` holds an editable path, selected or inside a selected object, that
/// the Smooth tool can smooth: one with a subpath of three or more anchors, or of two anchors
/// joined by a curve.
pub fn can_smooth(doc: &vectorcraft_doc::Document, selection: &vectorcraft_doc::Selection) -> bool {
let editable = doc.editable();
let smoothable = |sp: &vectorcraft_geom::SubPath| sp.anchors.len() >= 3 || (0..sp.segment_count()).any(|i| !super::segment_is_straight(sp, i));
cx.selection.objects.iter().filter_map(|id| cx.doc.node(*id)).any(|n| {
selection.objects.iter().filter_map(|id| doc.node(*id)).any(|n| {
let mut found = false;
n.walk(&mut |child| {
if !found
+3
View File
@@ -291,6 +291,9 @@ pub trait Tool: Send {
/// another document became active. The Blend tool drops its first pick and stops adding to the
/// blend it just made.
fn history_moved(&mut self) {}
/// A press on the canvas went to the view tools (held Space, the middle button) and not to the
/// tool. The Live Paint Bucket counts it among the clicks a triple-click compares.
fn press_elsewhere(&mut self) {}
/// Time passes while the pointer button is held (`dt` seconds since the last tick, whether or
/// not the pointer moved): tools that keep working while the brush holds still (Twirl, Pucker,
/// Bloat) act on it. The host supplies the time, so tests and agents drive it exactly.
+2
View File
@@ -9,6 +9,7 @@ pub mod cutting;
pub mod document;
pub mod enclosing_lasso;
pub mod image;
pub mod packaging;
pub mod pathtools;
pub mod pen;
pub mod select;
@@ -30,6 +31,7 @@ pub fn plugin_menu() -> Vec<Item> {
Item::Sub("Document Tools", document::menu()),
Item::Sub("Enclosing Lasso", enclosing_lasso::menu()),
Item::Sub("Image Tools", image::menu()),
Item::Sub("Packaging Tools", packaging::menu()),
Item::Sub("Path Precision Tools", pathtools::menu()),
Item::Sub("Selection Tools", select::menu()),
Item::Sub("Smart Pen", pen::menu()),
+134
View File
@@ -0,0 +1,134 @@
//! Packaging Tools' submenu (Object › Plug-ins › Packaging Tools) and its Fold Lines panel. The
//! panel lists the fold line roles, each with its swatch's chip and how many of the selected objects
//! have it (of the whole document while nothing is selected); clicking a role gives the selected
//! paths that role (`addon.packaging.setRole`). Its menu's Role Swatches… picks the swatch that
//! carries a role (`addon.packaging.setRoleSwatch`).
use egui::{Align, Layout, Sense, Ui, vec2};
use serde_json::{Value, json};
use crate::VectorcraftApp;
use crate::menus::Item;
use crate::panels::{empty_state, pstate, set_pstate};
use crate::widgets::{self, dim_label};
/// The panel's id (`window.panel {panel: "foldLines"}`).
pub const ID: &str = "foldLines";
/// The command that gives objects a role.
pub const SET_ROLE: &str = "addon.packaging.setRole";
/// The command that picks a role's swatch.
pub const SET_ROLE_SWATCH: &str = "addon.packaging.setRoleSwatch";
/// The roles by name, as `addon.packaging.setRole` and Role Swatches… take them.
pub const ROLES: &[(&str, &str)] =
&[("Cut Line", "cut"), ("Crease Line", "crease"), ("Partial Cut Line", "partialCut"), ("Perforation Line", "perforation")];
/// Where the panel keeps the last `addon.packaging.roles` answer (panel state).
const STATE: &str = "fold-lines";
/// Object › Plug-ins › Packaging Tools.
pub fn menu() -> Vec<Item> {
let make = |label, role: &str| Item::Cmd(label, SET_ROLE, json!({ "role": role }));
vec![
Item::Cmd("Fold Lines", "window.panel", json!({ "panel": ID })),
Item::Sep,
make("Make Cut Line", "cut"),
make("Make Crease Line", "crease"),
make("Make Partial Cut Line", "partialCut"),
make("Make Perforation Line", "perforation"),
]
}
/// One role row: (role id, swatch name, the swatch's paint if the document has it, count).
type Row = (String, String, Option<vectorcraft_color::Paint>, u64);
/// The panel's rows for one document state.
#[derive(Clone, Default)]
struct Rows {
/// What they were read for: the document, its revision and its selection.
key: Option<(u64, u64, Vec<u64>)>,
rows: Vec<Row>,
}
/// The rows for the active document as it is now, read again only when it changed.
fn rows(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<Row> {
let Some(st) = app.session.active() else { return vec![] };
let key = (st.uid, st.revision, st.selection.objects.iter().map(|id| id.0).collect::<Vec<_>>());
let mut kept: Rows = pstate(ctx, STATE);
if kept.key.as_ref() == Some(&key) {
return kept.rows;
}
let answer = app.session.execute("addon.packaging.roles", &json!({})).unwrap_or(Value::Null);
let d = app.session.active().map(|st| st.doc.clone());
let row = |r: &Value| {
let swatch = r["swatch"].as_str()?.to_string();
let paint = d.as_ref().and_then(|d| d.swatch(&swatch)).map(|s| s.paint.clone());
Some((r["role"].as_str()?.to_string(), swatch, paint, r["count"].as_u64()?))
};
kept = Rows { key: Some(key), rows: answer["roles"].as_array().into_iter().flatten().filter_map(row).collect() };
set_pstate(ctx, STATE, kept.clone());
kept.rows
}
pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
let Some(st) = app.session.active() else {
empty_state(ui, "scissors", tl!("No document"), tl!("Open a document to mark its fold lines."));
return;
};
let selected = !st.selection.is_empty();
if !selected {
dim_label(ui, tl!("No objects are selected."));
ui.add_space(4.0);
}
let mut picked = None;
for (role, swatch, paint, count) in rows(app, ui.ctx()) {
let label = ROLES.iter().find(|(_, id)| *id == role).map_or(role.as_str(), |(l, _)| *l);
let clicked = ui
.add_enabled_ui(selected, |ui| {
ui.horizontal(|ui| {
let (chip, _) = ui.allocate_exact_size(vec2(14.0, 14.0), Sense::hover());
widgets::paint_chip(ui, chip, paint.as_ref().unwrap_or(&vectorcraft_color::Paint::None));
let resp = ui.selectable_label(false, tl!(label)).on_hover_text(swatch.as_str());
ui.with_layout(Layout::right_to_left(Align::Center), |ui| dim_label(ui, &count.to_string()));
resp.clicked()
})
.inner
})
.inner;
if clicked {
picked = Some(role);
}
}
if let Some(role) = picked
&& let Err(e) = app.run(SET_ROLE, json!({ "role": role }))
{
app.status(e);
}
}
/// Role Swatches… (the dialog of `addon.packaging.setRoleSwatch`): when another role is picked, its
/// Swatch field shows that role's current swatch. `__role` keeps the role the field was filled for.
pub(crate) fn follow_role(app: &mut VectorcraftApp, d: &mut crate::state::Dialog) {
let role = d.str("role");
if d.str("__role") == role {
return;
}
let answer = app.session.execute("addon.packaging.roles", &json!({})).unwrap_or(Value::Null);
let current = answer["roles"].as_array().into_iter().flatten().find(|r| r["role"] == role.as_str()).and_then(|r| r["swatch"].as_str());
if let Some(swatch) = current {
d.fields.insert("swatch".into(), json!(swatch));
}
d.fields.insert("__role".into(), json!(role));
}
/// The panel's ≡ menu: Role Swatches… opens the options of `addon.packaging.setRoleSwatch` on the
/// Cut role and its current swatch.
pub fn panel_menu(app: &mut VectorcraftApp, ui: &mut Ui) {
if widgets::menu_item(ui, tl!("Role Swatches…"), app.session.active().is_some(), false) {
let swatch = rows(app, ui.ctx()).into_iter().find(|r| r.0 == "cut").map_or_else(|| "Cut".to_string(), |r| r.1);
let (id, p) = crate::menus::click_target("Role Swatches…", SET_ROLE_SWATCH, &json!({ "role": "cut", "swatch": swatch }));
crate::menus::invoke(app, &id, p);
}
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,133 @@
use serde_json::json;
use vectorcraft_engine::Session;
use super::{ID, ROLES, SET_ROLE, SET_ROLE_SWATCH, show};
use crate::tests_labels::painted_text;
use crate::{VectorcraftApp, menus};
/// An app with two rectangles, nothing selected → (app, their ids).
fn app() -> (VectorcraftApp, u64, u64) {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
let rect = |app: &mut VectorcraftApp, x: f64| {
app.run("shape.rectangle", json!({"x": x, "y": 20, "width": 40, "height": 40})).unwrap()["id"].as_u64().unwrap()
};
let (a, b) = (rect(&mut app, 20.0), rect(&mut app, 100.0));
app.run("select.none", json!({})).unwrap();
(app, a, b)
}
#[test]
fn the_plugins_submenu_opens_the_panel_and_makes_each_kind_of_line() {
let (mut app, a, _) = app();
let entries = menus::menu_entries(&app);
let under = |label: &str| entries.iter().find(|e| e.path == ["Object", "Plug-ins", "Packaging Tools"] && e.label == label);
let item = under("Fold Lines").expect("listed");
assert_eq!((item.command.as_deref(), &item.params), (Some("window.panel"), &json!({ "panel": ID })));
for (label, role) in
[("Make Cut Line", "cut"), ("Make Crease Line", "crease"), ("Make Partial Cut Line", "partialCut"), ("Make Perforation Line", "perforation")]
{
let e = under(label).unwrap_or_else(|| panic!("{label} listed"));
assert_eq!((e.command.as_deref(), &e.params), (Some(SET_ROLE), &json!({ "role": role })), "{label}");
}
assert!(!crate::panel_docking::showing(&app.ui, ID));
menus::invoke(&mut app, "window.panel", item.params.clone());
assert!(crate::panel_docking::showing(&app.ui, ID), "the panel opens");
app.run("select.set", json!({"ids": [a]})).unwrap();
let make = under("Make Partial Cut Line").unwrap();
let (target, p) = menus::click_target(&make.label, SET_ROLE, &make.params);
menus::invoke(&mut app, &target, p);
let r = app.session.execute("addon.packaging.roles", &json!({"ids": [a]})).unwrap();
assert_eq!(r["roles"][2]["count"], json!(1), "{r}");
}
#[test]
fn the_panel_counts_the_roles_and_says_when_nothing_is_selected() {
let (mut app, a, b) = app();
app.run(SET_ROLE, json!({"role": "cut", "ids": [a, b]})).unwrap();
app.run("select.none", json!({})).unwrap();
let text = painted_text(&mut app, show);
assert!(text.contains("No objects are selected."), "{text}");
for (label, _) in ROLES {
assert!(text.contains(label), "{label}: {text}");
}
assert!(text.contains('2'), "the document's two cut lines: {text}");
app.run("select.set", json!({"ids": [a]})).unwrap();
let text = painted_text(&mut app, show);
assert!(!text.contains("No objects are selected."), "{text}");
assert!(text.contains('1') && !text.contains('2'), "the selection's one cut line: {text}");
}
/// A click on the panel row that screen readers name `label`. egui finds what the pointer is over
/// from the frame before, so the move gets a frame of its own.
fn click_row(app: &mut VectorcraftApp, label: &str) {
crate::i18n::set_current(crate::i18n::Lang::EN);
let ctx = egui::Context::default();
ctx.enable_accesskit();
crate::theme::install_fonts(&ctx);
let mut time = 0.0;
let mut frame = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
time += 0.1;
let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(300.0, 200.0));
let input = egui::RawInput { events, time: Some(time), screen_rect: Some(screen), ..Default::default() };
let mut out = ctx.run_ui(input, |ui| show(app, ui));
out.textures_delta.clear();
out
};
frame(app, vec![]);
let out = frame(app, vec![]);
let nodes = &out.platform_output.accesskit_update.as_ref().expect("an accessibility tree").nodes;
let node = nodes.iter().find(|(_, n)| n.label() == Some(label));
let b = node.unwrap_or_else(|| panic!("no row named {label:?}")).1.bounds().expect("bounds");
let at = egui::pos2((b.x0 + b.x1) as f32 * 0.5, (b.y0 + b.y1) as f32 * 0.5);
let button = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
frame(app, vec![egui::Event::PointerMoved(at)]);
frame(app, vec![button(true)]);
frame(app, vec![button(false)]);
}
#[test]
fn clicking_a_row_gives_the_selection_that_role_and_does_nothing_without_one() {
let (mut app, a, b) = app();
click_row(&mut app, "Crease Line");
let none = app.session.execute("addon.packaging.roles", &json!({"ids": [a, b]})).unwrap();
assert_eq!(none["roles"][1]["count"], json!(0), "nothing selected: {none}");
app.run("select.set", json!({"ids": [a]})).unwrap();
click_row(&mut app, "Crease Line");
let r = app.session.execute("addon.packaging.roles", &json!({"ids": [a, b]})).unwrap();
assert_eq!(r["roles"][1]["count"], json!(1), "{r}");
}
#[test]
fn role_swatches_opens_the_options_of_its_command() {
let (target, p) = menus::click_target("Role Swatches…", SET_ROLE_SWATCH, &json!({"role": "cut", "swatch": "Cut"}));
assert_eq!((target.as_str(), &p["command"]), ("ui.paramDialog", &json!(SET_ROLE_SWATCH)));
let doc = vectorcraft_engine::find_command(SET_ROLE_SWATCH).unwrap().params;
let ids: Vec<&str> = ROLES.iter().map(|(_, id)| *id).collect();
assert!(doc.contains(&format!("role: {}", ids.join("|"))), "{doc}");
}
#[test]
fn role_swatches_shows_the_swatch_of_the_role_picked() {
let (mut app, a, _) = app();
app.run(SET_ROLE, json!({"role": "crease", "ids": [a]})).unwrap();
app.run("swatch.edit", json!({"name": "Crease", "newName": "Score"})).unwrap();
let mut d = crate::state::Dialog::new("command", json!({"role": "cut", "swatch": "Cut"}));
super::follow_role(&mut app, &mut d);
assert_eq!(d.str("swatch"), "Cut");
d.fields.insert("role".into(), json!("crease"));
super::follow_role(&mut app, &mut d);
assert_eq!(d.str("swatch"), "Score", "the Crease role's swatch");
// A swatch typed for the same role stays.
d.fields.insert("swatch".into(), json!("Ink"));
super::follow_role(&mut app, &mut d);
assert_eq!(d.str("swatch"), "Ink");
assert_eq!(crate::dialogs::form::params(&d), json!({"role": "crease", "swatch": "Ink"}), "the dialog sends no __role");
}
#[test]
fn the_panel_without_a_document_asks_for_one() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
let text = painted_text(&mut app, show);
assert!(text.contains("No document"), "{text}");
}
+4
View File
@@ -121,6 +121,7 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo
{
// Middle-button drag pans the view whatever the tool.
ui.data_mut(|dd| dd.insert_temp(drag_id(), Drag::Pan { start, center: v.center, middle: true }));
app.session.tool_press_elsewhere();
app.session.tool_hover_ended(view);
} else if let Some(d) = drag {
// The pointer gone (a pen lifted with its press), the drag ends where it was last seen.
@@ -342,6 +343,9 @@ fn begin_drag(app: &mut VectorcraftApp, ui: &Ui, f: &Pointing, p: Pos2) {
if !space && matches!(d, Drag::ZoomBox { .. } | Drag::ZoomScrub { .. } | Drag::Pan { .. } | Drag::RotateView { .. }) {
crate::shortcuts::note_tool_use(app);
}
if !matches!(d, Drag::Tool) {
app.session.tool_press_elsewhere();
}
// Panning, zooming or turning the view takes the pointer from the tool's hover.
if !tool_holds(d) {
app.session.tool_hover_ended(view);
+114 -24
View File
@@ -75,6 +75,27 @@ fn shape_tool_on_shape(app: &VectorcraftApp) -> bool {
})
}
/// Whether the Smooth tool is in use with a selected path it can smooth
/// ([`vectorcraft_tools::draw2::can_smooth`]). The answer is kept in `ctx` for the document's
/// revision, which moves with every change of the document or the selection, so an unchanged
/// selection is not walked again each frame.
fn smooth_tool_on_paths(app: &VectorcraftApp, ctx: &egui::Context) -> bool {
if app.session.tool_id() != "smooth" {
return false;
}
let Some(st) = app.session.active() else { return false };
let id = task_bar_id().with("smooth");
let key = (st.uid, st.revision);
if let Some((k, found)) = ctx.data(|d| d.get_temp::<((u64, u64), bool)>(id))
&& k == key
{
return found;
}
let found = vectorcraft_tools::draw2::can_smooth(&st.doc, &st.selection);
ctx.data_mut(|d| d.insert_temp(id, (key, found)));
found
}
/// Whether the bar shows its blank canvas actions, Draw (Pencil) and Place Image: a selection tool is
/// in use and the active document has no artwork, only layers and guides.
fn blank_canvas(app: &VectorcraftApp) -> bool {
@@ -130,7 +151,9 @@ pub(crate) fn task_bar_shows_type(app: &VectorcraftApp) -> bool {
/// While a basic shape tool (Rectangle, Rounded Rectangle, Ellipse, Polygon or Star) has one closed
/// path selected, as after it draws one, the bar offers Edit Path, Fill and Stroke, and Shape
/// Properties for a live rectangle, rounded rectangle, ellipse or polygon; with nothing selected, or
/// any other selection, those tools show no bar. Selected type also shows the font family, font
/// any other selection, those tools show no bar. While the Smooth tool has a path it can smooth
/// selected, the bar shows the tool's Fidelity field and Tool Options…; with no such path it shows
/// no bar. Selected type also shows the font family, font
/// style and Font Size controls before its Fill.
/// While a Type tool edits type, or has type selected, the bar shows only those controls and the
/// Fill. When one row would be wider than the canvas, the font controls take a row of their own,
@@ -150,7 +173,10 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
// A basic shape tool with its shape selected offers Edit Path, Fill, Stroke and the shape's
// properties, as the same help page describes.
let shaping = shape_tool_on_shape(app);
if !(on_artboards || typing || blank || shaping || selection_tool_with_selection(app)) {
// The Smooth tool with a path to smooth offers its option, Fidelity, as the same help page
// describes for the Smooth tool, and Tool Options… for its dialog.
let smoothing = smooth_tool_on_paths(app, ui.ctx());
if !(on_artboards || typing || blank || shaping || smoothing || selection_tool_with_selection(app)) {
return;
}
// Selected type has the font controls too, as the help page describes
@@ -197,15 +223,7 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
// Edit Path: the Direct Selection tool, to edit the path's anchors.
let edit_path = || (tl!("Edit Path"), "dc-direct", "tool.select", json!({"tool": "directSelection"}));
if on_artboards {
// As in the reference app, the Artboard tool offers to resize, duplicate and export the
// artboards (<https://community.adobe.com/questions-652/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580>),
// and to rearrange them (<https://creativepro.com/managing-artboards-in-illustrator/>).
items.push((tl!("Resize"), "move-diagonal-2", TASK_BAR_ARTBOARD_OPTIONS, none()));
items.push((tl!("Duplicate"), "copy", TASK_BAR_DUPLICATE_ARTBOARDS, none()));
if st.doc.artboards.len() > 1 {
items.push((tl!("Rearrange All"), "dc-rearrange", TASK_BAR_REARRANGE_ARTBOARDS, none()));
}
items.push((tl!("Export"), "share-2", "file.exportForScreens", none()));
artboard_items(&mut items, st.doc.artboards.len());
} else if blank {
// Draw (Pencil) switches to the Pencil tool; Place Image picks files for the Place dialog.
items.push((tl!("Draw (Pencil)"), "pencil", "tool.select", json!({"tool": "pencil"})));
@@ -213,6 +231,10 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
} else if shaping {
// A basic shape tool's one action; its Fill, Stroke and Shape Properties follow as chips.
items.push(edit_path());
} else if smoothing {
// The Fidelity field, then Tool Options… for the dialog that shows it with its slider.
items.push((tl!("Fidelity:"), "", TASK_BAR_FIDELITY, none()));
items.push((tl!("Tool Options…"), "settings", "tool.options", json!({"tool": "smooth"})));
} else if !typing {
// The selection tools' object actions. A Type tool's bar leaves them out, Create Outlines
// and the type conversions included.
@@ -319,8 +341,9 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
// The selected objects' Fill, Stroke, Recolor Artwork (when they have colours to recolour) and
// Lock (a basic shape's properties instead), left out with the Artboard tool and on a blank
// canvas, which have no selected objects. A Type tool's bar has the Fill alone. A basic shape
// tool's bar has the Fill, the Stroke and a live shape's Shape Properties.
let objects = !on_artboards && !blank;
// tool's bar has the Fill, the Stroke and a live shape's Shape Properties. The Smooth tool's bar
// has none of them.
let objects = !on_artboards && !blank && !smoothing;
let chips: Vec<Chip> = [
(objects, Chip::Fill),
(objects && !typing, Chip::Stroke),
@@ -330,7 +353,8 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
.into_iter()
.filter_map(|(shown, chip)| shown.then_some(chip))
.collect();
let widths: Vec<f32> = items.iter().map(|(label, _, cmd, _)| if icon_only(cmd) { BAR_MORE } else { action_width(ui, label) }).collect();
let widths: Vec<f32> = items.iter().map(|(label, _, cmd, _)| item_width(ui, label, cmd)).collect();
let fidelity = app.session.tool_options()["fidelity"].as_f64();
let font_w = fonts.then(|| {
let w = crate::panels::character::TASK_BAR_WIDTHS;
w.iter().sum::<f32>() + BAR_GAP * (w.len() - 1) as f32
@@ -408,16 +432,7 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
if *at != Some(row) {
continue;
}
// The convert buttons show their icon alone, named by their hover text, as
// the Control bar's do.
let clicked = if icon_only(cmd) {
widgets::icon_button(ui, icon, label, false, BAR_MORE).clicked()
} else {
action_button(ui, &t, label, icon)
};
if clicked {
run = Some((*cmd, params.clone()));
}
run = bar_item(ui, &t, (*label, *icon, *cmd, params), fidelity).or(run.take());
}
// Type's font family, font style and Font Size, which act as the Character
// panel's do: on the characters a Type tool selects, else on the selected type.
@@ -510,6 +525,9 @@ pub(super) fn task_bar(app: &mut VectorcraftApp, ui: &mut Ui, xf: &Xf) {
// The convert buttons convert the direct-selected anchors, as the Control bar's buttons do.
Some((TASK_BAR_TO_CORNER, _)) => crate::menus::invoke(app, "path.convertAnchors", json!({"to": "corner"})),
Some((TASK_BAR_TO_SMOOTH, _)) => crate::menus::invoke(app, "path.convertAnchors", json!({"to": "smooth"})),
// Fidelity listed in More Options, on a canvas too narrow for its field: the Smooth tool's
// Tool Options, which show it.
Some((TASK_BAR_FIDELITY, _)) => crate::menus::invoke(app, "tool.options", json!({"tool": "smooth"})),
Some((c, p)) => crate::menus::invoke(app, c, p),
None => {}
}
@@ -658,6 +676,61 @@ fn action_width(ui: &Ui, label: &str) -> f32 {
ui.painter().layout_no_wrap(label.to_string(), egui::FontId::proportional(13.0), Color32::PLACEHOLDER).size().x + 38.0
}
/// The width of the Smooth tool's Fidelity on the Contextual Task Bar: its label, the gap and the
/// field.
fn fidelity_width(ui: &Ui) -> f32 {
widgets::text_width(ui, fidelity_label(tl!("Fidelity:"), &Tokens::get(ui.ctx()))) + BAR_GAP + crate::dialogs::freehand::FIDELITY_FIELD_W
}
/// The Fidelity field's label, `label`, as the bar draws it.
fn fidelity_label(label: &str, t: &Tokens) -> egui::RichText {
egui::RichText::new(label).size(13.0).color(t.text_strong)
}
/// The width of the Contextual Task Bar's item `label` that runs `cmd`.
fn item_width(ui: &Ui, label: &str, cmd: &str) -> f32 {
match cmd {
TASK_BAR_FIDELITY => fidelity_width(ui),
_ if icon_only(cmd) => BAR_MORE,
_ => action_width(ui, label),
}
}
/// One of the Contextual Task Bar's items, `label` with `icon`, which runs `cmd` with `params`, and
/// the Smooth tool's `fidelity`. Returns the command to run when it was used.
fn bar_item(
ui: &mut Ui,
t: &Tokens,
(label, icon, cmd, params): (&str, &str, &'static str, &serde_json::Value),
fidelity: Option<f64>,
) -> Option<(&'static str, serde_json::Value)> {
// The Smooth tool's Fidelity, labeled, sets the tool's option as it is typed or stepped.
if cmd == TASK_BAR_FIDELITY {
return fidelity_slot(ui, t, label, fidelity);
}
// The convert buttons show their icon alone, named by their hover text, as the Control bar's do.
let clicked = if icon_only(cmd) { widgets::icon_button(ui, icon, label, false, BAR_MORE).clicked() } else { action_button(ui, t, label, icon) };
clicked.then(|| (cmd, params.clone()))
}
/// The Smooth tool's Fidelity on the Contextual Task Bar, `label` and a field showing the tool's
/// `fidelity` (nothing without one). Returns the command that sets a new value typed or stepped to.
fn fidelity_slot(ui: &mut Ui, t: &Tokens, label: &str, fidelity: Option<f64>) -> Option<(&'static str, serde_json::Value)> {
let v = fidelity?;
let x = fidelity_field(ui, t, label, v).filter(|x| *x != v)?;
Some(("tool.setOption", json!({"tool": "smooth", "values": {"fidelity": x}})))
}
/// The Smooth tool's Fidelity on the Contextual Task Bar: `label` and a field showing `v`, centered
/// in a row of the bar. Returns the value typed or stepped to.
fn fidelity_field(ui: &mut Ui, t: &Tokens, label: &str, v: f64) -> Option<f64> {
ui.allocate_ui_with_layout(vec2(fidelity_width(ui), BAR_ROW), egui::Layout::left_to_right(egui::Align::Center), |ui| {
widgets::field_label(ui, fidelity_label(label, t));
crate::dialogs::freehand::fidelity_field(ui, "task-bar-fidelity", v, "smooth")
})
.inner
}
/// One of the Contextual Task Bar's action buttons: `icon` and `label`, named for screen readers.
/// Returns whether it was clicked.
fn action_button(ui: &mut Ui, t: &Tokens, label: &str, icon: &str) -> bool {
@@ -743,6 +816,20 @@ fn paint_chip(ui: &mut Ui, t: &Tokens, paint: &vectorcraft_color::Paint, mixed:
resp.on_hover_text(tip).clicked()
}
/// The Contextual Task Bar's items with the Artboard tool in a document of `artboards` artboards:
/// Resize, Duplicate, Rearrange All (with two or more) and Export.
fn artboard_items(items: &mut Vec<(&'static str, &'static str, &'static str, serde_json::Value)>, artboards: usize) {
// As in the reference app, the Artboard tool offers to resize, duplicate and export the
// artboards (<https://community.adobe.com/questions-652/contextual-task-bar-in-illustrator-2025-quick-actions-when-you-need-them-1546580>),
// and to rearrange them (<https://creativepro.com/managing-artboards-in-illustrator/>).
items.push((tl!("Resize"), "move-diagonal-2", TASK_BAR_ARTBOARD_OPTIONS, json!({})));
items.push((tl!("Duplicate"), "copy", TASK_BAR_DUPLICATE_ARTBOARDS, json!({})));
if artboards > 1 {
items.push((tl!("Rearrange All"), "dc-rearrange", TASK_BAR_REARRANGE_ARTBOARDS, json!({})));
}
items.push((tl!("Export"), "share-2", "file.exportForScreens", json!({})));
}
/// The Contextual Task Bar's Center on Top and Center on Bottom, as in the Type menu, for type on a
/// closed path.
fn center_on_path_items(app: &VectorcraftApp, items: &mut Vec<(&'static str, &'static str, &'static str, serde_json::Value)>) {
@@ -755,6 +842,9 @@ fn center_on_path_items(app: &VectorcraftApp, items: &mut Vec<(&'static str, &'s
}
}
/// The Contextual Task Bar's Fidelity field with the Smooth tool.
const TASK_BAR_FIDELITY: &str = "taskBar.fidelity";
/// The Contextual Task Bar's Image Trace button: a trace with the Default preset.
const TASK_BAR_IMAGE_TRACE: &str = "taskBar.imageTrace";
+2
View File
@@ -22,6 +22,7 @@ pub mod brush_options;
pub mod brush_replace_art;
pub mod bullets_numbering;
pub mod char_style_options;
pub mod check_spelling;
pub mod color_balance;
pub mod color_guide_options;
mod color_picker;
@@ -460,6 +461,7 @@ registry! {
EditSelection: [edit_selection::KIND] => edit_selection::SPEC,
EditViews: [edit_views::KIND] => edit_views::SPEC,
EditCustomDictionary: [custom_dictionary::KIND] => custom_dictionary::SPEC,
CheckSpelling: [check_spelling::KIND] => check_spelling::SPEC,
PerspectivePlane: [perspective_plane::KIND] => perspective_plane::SPEC,
LayerOptions: [layer_options::KIND] => layer_options::SPEC,
LayersPanelOptions: [layers_panel_options::KIND] => layers_panel_options::SPEC,
@@ -26,13 +26,40 @@ const NUMBERS: &[&str] = &["size", "leading", "kerning", "tracking"];
/// The on, off or unset checkboxes.
const SWITCHES: &[&str] = &["underline", "strikethrough", "standardVerticalRoman"];
/// The attributes of Advanced Character Formats, in the order the section shows them.
const ADVANCED: &[&str] =
&["h_scale", "v_scale", "baseline_shift", "tcyUpDown", "tcyLeftRight", "rotation", "akiLeft", "akiRight", "tsume", "language"];
const ADVANCED: &[&str] = &[
"h_scale",
"v_scale",
"baseline_shift",
"tcyUpDown",
"tcyLeftRight",
"rotation",
"akiLeft",
"akiRight",
"tsume",
"diacriticHorizontal",
"diacriticVertical",
"language",
];
/// The number fields of Advanced Character Formats.
const ADVANCED_NUMBERS: &[&str] = &["h_scale", "v_scale", "baseline_shift", "tcyUpDown", "tcyLeftRight", "rotation", "akiLeft", "akiRight", "tsume"];
const ADVANCED_NUMBERS: &[&str] = &[
"h_scale",
"v_scale",
"baseline_shift",
"tcyUpDown",
"tcyLeftRight",
"rotation",
"akiLeft",
"akiRight",
"tsume",
"diacriticHorizontal",
"diacriticVertical",
];
/// The Insert Aki Left and Right fields, which take the Character panel's presets and stop at
/// [`vectorcraft_doc::text::MAX_AKI`].
const AKI: [&str; 2] = ["akiLeft", "akiRight"];
/// The Adjust Horizontal and Vertical Diacritic Position fields, which take the Character panel's
/// presets and stop at [`vectorcraft_doc::text::MAX_DIACRITIC_POSITION`] either way.
const DIACRITIC: [&str; 2] = ["diacriticHorizontal", "diacriticVertical"];
/// The attributes of Character Color.
const COLOR: &[&str] = &["fill", "stroke", "stroke_width", "overprint_fill", "overprint_stroke"];
/// The fields of Character Color: the fill and stroke paints, their tints in percent, the stroke
@@ -103,6 +130,8 @@ pub(super) const SPEC: DialogSpec = DialogSpec {
"akiLeft",
"akiRight",
"tsume",
"diacriticHorizontal",
"diacriticVertical",
"language",
"fill",
"fill_tint",
@@ -295,6 +324,8 @@ fn optional_number(d: &Dialog, key: &str) -> Result<Option<Value>, String> {
"akiLeft" => tl!("Insert Aki Left"),
"akiRight" => tl!("Insert Aki Right"),
"tsume" => tl!("Tsume"),
"diacriticHorizontal" => tl!("Adjust Horizontal Diacritic Position"),
"diacriticVertical" => tl!("Adjust Vertical Diacritic Position"),
"fill_tint" => tl!("Fill Tint"),
"stroke_tint" => tl!("Stroke Tint"),
"stroke_width" => tl!("Weight"),
@@ -344,6 +375,9 @@ fn optional_number(d: &Dialog, key: &str) -> Result<Option<Value>, String> {
let n = if AKI.contains(&key) { n.clamp(0.0, vectorcraft_doc::text::MAX_AKI) } else { n };
// Tsume stops at 0% and 100% the same way.
let n = if key == "tsume" { n.clamp(0.0, vectorcraft_doc::text::MAX_TSUME) } else { n };
// The diacritic positions stop at the largest value the style takes either way.
let max = vectorcraft_doc::text::MAX_DIACRITIC_POSITION;
let n = if DIACRITIC.contains(&key) { n.clamp(-max, max) } else { n };
Ok(Some(json!(n)))
}
}
@@ -622,7 +656,7 @@ pub(crate) fn reset_basic(d: &mut Dialog) {
}
}
/// Reset Panel in Advanced Character Formats: its ten attributes become unset.
/// Reset Panel in Advanced Character Formats: its twelve attributes become unset.
pub(crate) fn reset_advanced(d: &mut Dialog) {
d.fields.insert("__resetAdvanced".into(), json!(true));
for key in ADVANCED_NUMBERS {
@@ -777,8 +811,9 @@ pub(crate) fn basic_body(ui: &mut egui::Ui, d: &mut Dialog) {
}
/// Advanced Character Formats: Horizontal Scale, Vertical Scale, Baseline Shift, the Tate-chu-yoko
/// Up/Down and Left/Right, Character Rotation, Insert Aki Left and Right and Tsume (with the
/// Character panel's presets) and Language, each empty (unset) or set.
/// Up/Down and Left/Right, Character Rotation, Insert Aki Left and Right, Tsume and the Adjust
/// Horizontal and Vertical Diacritic Positions (with the Character panel's presets) and Language,
/// each empty (unset) or set.
pub(crate) fn advanced_body(ui: &mut egui::Ui, d: &mut Dialog) {
egui::Grid::new("character-style-advanced").num_columns(2).spacing([18.0, 8.0]).show(ui, |ui| {
for (key, caption, unit) in [
@@ -820,6 +855,18 @@ pub(crate) fn advanced_body(ui: &mut egui::Ui, d: &mut Dialog) {
ui.label("%");
});
ui.end_row();
let presets: Vec<String> = crate::panels::character::DIACRITIC_PRESETS.iter().map(f64::to_string).collect();
let presets: Vec<&str> = presets.iter().map(String::as_str).collect();
for (key, caption) in
[("diacriticHorizontal", tl!("Adjust Horizontal Diacritic Position")), ("diacriticVertical", tl!("Adjust Vertical Diacritic Position"))]
{
let row = ui.label(caption);
let value = if d.fields.get(key).is_none_or(Value::is_null) { String::new() } else { d.str(key) };
if let Some(v) = ui.label_inputs_by(row.id, |ui| crate::widgets::text_presets(ui, (KIND, key), &value, &presets, 160.0)) {
d.fields.insert(key.into(), json!(v));
}
ui.end_row();
}
let row = ui.label(tl!("Language:"));
let names: Vec<&str> = std::iter::once(" ").chain(vectorcraft_doc::setup::LANGUAGES.iter().map(|(name, _, _)| *name)).collect();
let current = d.fields.get("language").and_then(Value::as_str).unwrap_or("").to_string();
@@ -1882,6 +1929,55 @@ mod tests {
assert!(t.runs.iter().all(|r| (r.style.aki_left, r.style.aki_right) == (250.0, 1000.0)));
}
/// The Adjust Diacritic Positions in Advanced Character Formats: empty is unset, a typed value
/// stops at -1000 and 1000, Reset Panel unsets them, and the fields are drawn and commit to the
/// style and the text set in it.
#[test]
fn diacritic_position_fields_show_set_reset_and_commit() {
let d = dialog_for(json!({"diacriticHorizontal": -250.0, "size": 12.0}));
assert_eq!((d.fields["diacriticHorizontal"].clone(), d.fields["diacriticVertical"].clone()), (json!(-250.0), json!("")));
assert_eq!(edited_attrs(&d).unwrap(), attrs(json!({"diacriticHorizontal": -250.0, "size": 12.0})));
let mut d = dialog_for(json!({"diacriticHorizontal": -250.0}));
d.fields.insert("diacriticHorizontal".into(), json!(""));
for (typed, kept) in [("0", 0.0), ("150", 150.0), ("5000", 1000.0), ("-5000", -1000.0)] {
d.fields.insert("diacriticVertical".into(), json!(typed));
assert_eq!(edited_attrs(&d).unwrap(), attrs(json!({"diacriticVertical": kept})), "{typed}");
}
d.fields.insert("diacriticHorizontal".into(), json!("left"));
assert_eq!(edited_attrs(&d).unwrap_err(), "Adjust Horizontal Diacritic Position must be a number");
let mut d = dialog_for(json!({"diacriticHorizontal": 100.0, "diacriticVertical": 200.0, "size": 12.0}));
d.fields.insert("section".into(), json!("advanced"));
reset_section(&mut d);
assert_eq!(edited_attrs(&d).unwrap(), attrs(json!({"size": 12.0})));
let mut app = app();
app.run("charStyle.new", json!({"name": "Body", "attrs": {"size": 24.0}})).unwrap();
let id = app.run("text.create", json!({"x": 10, "y": 40, "text": "بَب"})).unwrap()["id"].as_u64().unwrap();
app.run("charStyle.apply", json!({"name": "Body", "id": id})).unwrap();
open(&mut app, "Body").unwrap();
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(900.0, 900.0));
let mut d = app.ui.dialog.clone().unwrap();
let input = egui::RawInput { screen_rect: Some(screen), ..Default::default() };
let mut out = ctx.run_ui(input, |ui| advanced_body(ui, &mut d));
let texts = texts_of(&out);
out.textures_delta.clear();
for label in ["Adjust Horizontal Diacritic Position", "Adjust Vertical Diacritic Position"] {
assert!(texts.iter().any(|(text, _)| text == label), "{label} is drawn: {texts:?}");
}
{
let d = app.ui.dialog.as_mut().unwrap();
d.fields.insert("diacriticHorizontal".into(), json!("-120"));
d.fields.insert("diacriticVertical".into(), json!("3000"));
}
super::super::confirm(&mut app).unwrap();
let state = app.session.doc().unwrap();
assert_eq!(state.doc.char_styles[0].attrs, attrs(json!({"size": 24.0, "diacriticHorizontal": -120.0, "diacriticVertical": 1000.0})));
let vectorcraft_doc::NodeKind::Text(t) = &state.doc.node(vectorcraft_doc::NodeId(id)).unwrap().kind else { panic!("text") };
assert!(t.runs.iter().all(|r| (r.style.diacritic_horizontal, r.style.diacritic_vertical) == (-120.0, 1000.0)));
}
/// Tsume in Advanced Character Formats: empty is unset, an explicit 0 stays set, a typed value
/// stops at 0 and 100, Reset Panel unsets it, and the field is drawn and commits to the style
/// and the text set in it.
File diff suppressed because it is too large Load Diff
+5
View File
@@ -22,6 +22,9 @@ pub(super) const SPEC: DialogSpec = DialogSpec {
let cmyk = app.session.active().is_some_and(|s| s.doc.color_mode == vectorcraft_doc::ColorMode::Cmyk);
let choices = |k: &str| rasterize_color_models(&command, k, cmyk).or_else(|| choices(&command, k));
form::param_fields(ui, d, &|k| lengths.contains(&k), &choices, &rank, app.session.general_unit());
if command == crate::addons::packaging::SET_ROLE_SWATCH {
crate::addons::packaging::follow_role(app, d);
}
if linked
&& d.fields.get("rowGutter") == d.fields.get("__rowGutterLinked")
&& let Some(g) = d.fields.get("gutter").cloned()
@@ -159,6 +162,7 @@ fn order(command: &str) -> &'static [&'static str] {
&["background", "colors", "contiguous", "match", "tolerance", "softness"]
}
crate::addons::cutting::BRIDGES => &["width", "count", "direction", "keepOriginal"],
crate::addons::packaging::SET_ROLE_SWATCH => &["role", "swatch"],
_ => &[],
}
}
@@ -168,6 +172,7 @@ fn choices(command: &str, key: &str) -> Option<form::Choices> {
match (command, key) {
("type.pathOptions", "effect") => Some(crate::menus::PATH_EFFECTS),
("type.pathOptions", "alignToPath") => Some(PATH_ALIGN),
(crate::addons::packaging::SET_ROLE_SWATCH, "role") => Some(crate::addons::packaging::ROLES),
(crate::addons::typetools::RELEASE, "mode") => Some(crate::addons::typetools::RELEASE_MODES),
(crate::addons::cutting::BRIDGES, "direction") => Some(crate::addons::cutting::BRIDGE_DIRECTIONS),
("text.areaOptions", "fit") => Some(AREA_FIT),
+42 -5
View File
@@ -321,12 +321,12 @@ fn center_round(x: f64) -> f64 {
/// for Zoom, rings for Spin) drawn about the center. A press or a drag in the box puts the center
/// there; with the keyboard focus the arrow keys move it 1 % of the box (10 % with Shift). The
/// Horizontal and Vertical fields beside it type the same position in percent of the bounds' width
/// and height. Changes go to `d.fields["centerX"]` and `["centerY"]`.
/// and height. The center the box shows, kept within 0 to 1, goes to `d.fields["centerX"]` and
/// `["centerY"]`.
fn blur_center(ui: &mut egui::Ui, d: &mut Dialog) {
use egui::{Key, Modifiers, Sense, Stroke};
let [kx, ky] = BLUR_CENTER;
let mut c = [d.f64(kx, 0.5).clamp(0.0, 1.0), d.f64(ky, 0.5).clamp(0.0, 1.0)];
let before = c;
let t = Tokens::get(ui.ctx());
let zoom = d.str("method").eq_ignore_ascii_case("zoom");
form::caption(ui, "Blur Center");
@@ -404,9 +404,12 @@ fn blur_center(ui: &mut egui::Ui, d: &mut Dialog) {
});
});
});
if c != before {
d.fields.insert(kx.into(), json!(c[0]));
d.fields.insert(ky.into(), json!(c[1]));
// A saved center outside the bounds is drawn at the nearest edge, and the fields hold that
// edge too, so OK sends the center the box shows.
for (key, v) in [(kx, c[0]), (ky, c[1])] {
if d.fields.get(key).and_then(Value::as_f64) != Some(v) {
d.fields.insert(key.into(), json!(v));
}
}
}
@@ -1502,4 +1505,38 @@ mod tests {
"OK applies it"
);
}
/// A Radial Blur whose saved Blur Center lies outside the object's bounds (a document written
/// by hand or by another build) opens with the center at the nearest edge, and OK stores that
/// edge instead of sending the saved value, which `effect.setParams` refuses.
#[test]
fn radial_blur_center_outside_the_bounds_opens_at_the_edge_and_ok_keeps_it() {
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
app.run("select.all", json!({})).unwrap();
app.run("effect.apply", json!({"effect": RADIAL_BLUR, "params": {"amount": 20}})).unwrap();
{
let st = app.session.doc_mut().unwrap();
let d = std::sync::Arc::make_mut(&mut st.doc);
let fx = &mut d.node_mut(vectorcraft_doc::NodeId(id)).unwrap().appearance.effects[0];
fx.params["centerX"] = json!(1.5);
fx.params["centerY"] = json!(-0.25);
}
app.run("effect.dialog", json!({"effect": RADIAL_BLUR, "index": 0})).unwrap();
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
for k in 0..4 {
let input = egui::RawInput { time: Some(f64::from(k) * 0.05), ..Default::default() };
let mut out = ctx.run_ui(input, |ui| super::super::show(&mut app, ui.ctx()));
out.textures_delta.clear();
}
let field = |k: &str| app.ui.dialog.as_ref().unwrap().fields.get(k).and_then(Value::as_f64);
assert_eq!((field("centerX"), field("centerY")), (Some(1.0), Some(0.0)), "the fields hold the center the box shows");
super::super::confirm(&mut app).unwrap();
let st = app.session.doc().unwrap();
let fx = &st.doc.node(vectorcraft_doc::NodeId(id)).unwrap().appearance.effects[0];
assert_eq!((fx.params["centerX"].as_f64(), fx.params["centerY"].as_f64()), (Some(1.0), Some(0.0)), "OK stores the edge");
}
}
@@ -638,15 +638,16 @@ fn edit_artboard_name(
widgets::reject_dialog_commit(ui.ctx());
}
let response = ui.put(rect, egui::TextEdit::singleline(text).id(field).font(egui::FontId::proportional(11.0)).desired_width(rect.width()));
if *focus {
widgets::focus_field(ui, field, text);
*focus = false;
} else if cancel || enter || response.lost_focus() {
// Escape and Enter also end the edit in the first frame that draws the field.
if cancel || enter || (!*focus && response.lost_focus()) {
if !cancel {
*rename = Some((*b, std::mem::take(text)));
}
response.surrender_focus();
*editing = None;
} else if *focus {
widgets::focus_field(ui, field, text);
*focus = false;
}
(false, true)
} else {
@@ -654,6 +655,10 @@ fn edit_artboard_name(
if let Some(board) = board
&& response.double_clicked()
{
// A name still typed for an artboard whose field this frame has not drawn yet is kept.
if let Some((b, text, _)) = editing.take() {
*rename = Some((b, text));
}
*editing = Some((board, name.into(), true));
ui.ctx().request_repaint();
// If both releases arrived this frame, the first click did not toggle the row.
+19 -4
View File
@@ -104,6 +104,23 @@ fn fidelity_step(v: f64, n: f64) -> f64 {
v
}
/// The unit of tool `tool`'s Fidelity. The Pencil's, the Paintbrush's and the Smooth tool's
/// Fidelity is on screen, the same at any zoom (#5729); the Blob Brush's is in points.
fn fidelity_unit(tool: &str) -> &'static str {
if matches!(tool, "pencil" | "paintbrush" | "smooth") { "px" } else { "pt" }
}
/// Width of the Fidelity field.
pub(crate) const FIDELITY_FIELD_W: f32 = FIELD_W;
/// The Fidelity field of tool `tool`, showing `v` to two decimals from the tool's lowest Fidelity to
/// 100 and stepping by [`fidelity_step`], named by the label drawn just before it. Returns the value
/// typed or stepped to. The Contextual Task Bar shows the Smooth tool's.
pub(crate) fn fidelity_field(ui: &mut egui::Ui, id: &str, v: f64, tool: &str) -> Option<f64> {
let min = vectorcraft_tools::draw2::min_fidelity(tool);
widgets::range_field_stepped(ui, id, v, min..=100.0, fidelity_unit(tool), 2, FIELD_W, fidelity_step)
}
/// Where Fidelity `v` sits on a slider over `(min, max)`, from 0 to 1. The rail is logarithmic, so
/// the low values, where the stroke is followed closely, get as much of it as the high ones
/// (0.01–1 takes most of a 0.01–20 rail, in the tool's unit).
@@ -211,9 +228,7 @@ fn fidelity(ui: &mut egui::Ui, d: &mut Dialog) {
let v = d.f64("fidelity", 1.5);
let tool = d.str("tool");
let rail = (vectorcraft_tools::draw2::min_fidelity(&tool), FIDELITY_MAX);
// The Pencil's, the Paintbrush's and the Smooth tool's Fidelity is on screen, the same at any
// zoom (#5729).
let unit = if matches!(tool.as_str(), "pencil" | "paintbrush" | "smooth") { "px" } else { "pt" };
let unit = fidelity_unit(&tool);
let rail_w = label_w(ui);
let mut new = None;
ui.label(egui::RichText::new(tl!("Fidelity:")).size(12.5).color(t.text));
@@ -222,7 +237,7 @@ fn fidelity(ui: &mut egui::Ui, d: &mut Dialog) {
let (x, _, keyed) =
widgets::color_slider_stepped(ui, "freehand-fidelity", tl!("Fidelity:"), Some(shown), fidelity_at(v, rail), rail_w, &|_| t.input_border);
new = x.map(|x| fidelity_from(x, rail)).or(keyed);
if let Some(x) = widgets::range_field_stepped(ui, "freehand-fidelity-field", v, rail.0..=100.0, unit, 2, FIELD_W, fidelity_step) {
if let Some(x) = fidelity_field(ui, "freehand-fidelity-field", v, &tool) {
new = Some(x);
}
});
+43
View File
@@ -322,6 +322,49 @@ mod tests {
assert!(matches!(st.doc.node(id).unwrap().kind, NodeKind::Image(_)));
}
/// The OK of the dialog a drop on a canvas opened places in the document the file was dropped
/// on, made active again, even when another document became active meanwhile; it doesn't
/// place when that document has been reverted or closed since.
#[test]
fn a_dropped_files_ok_places_in_the_document_it_was_dropped_on() {
use crate::place::{DropAt, DropTarget};
let psd = layered();
let mut app = app();
for _ in 0..2 {
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
}
let drop_on_first = |app: &mut VectorcraftApp| {
app.session.set_active(0);
let st = app.session.doc().unwrap();
let target = DropTarget::Place(DropAt { doc: st.uid, reverts: st.reverts, at: vectorcraft_geom::Point::new(50.0, 50.0), embed: true });
crate::place::drop_files(app, vec![(target, ("poster.psd".into(), None, psd.clone()))]);
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(KIND));
// Another document becomes active while the dialog is open.
app.session.set_active(1);
};
let objects =
|app: &VectorcraftApp, i: usize| app.session.documents()[i].doc.layers.iter().map(|l| l.children().map_or(0, Vec::len)).sum::<usize>();
drop_on_first(&mut app);
super::super::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!((objects(&app, 0), objects(&app, 1)), (1, 0), "placed in the document it was dropped on");
assert_eq!(app.session.active_index(), Some(0), "which is active again");
// Reverted meanwhile: the dialog stays open with the reason, and nothing is placed.
drop_on_first(&mut app);
let first = app.session.documents()[0].uid;
app.session.document_mut(first).unwrap().reverts += 1;
let e = super::super::confirm(&mut app).unwrap_err();
assert!(e.contains("was reverted"), "{e}");
assert_eq!((objects(&app, 0), objects(&app, 1)), (1, 0));
// Closed meanwhile.
app.ui.dialog = None;
drop_on_first(&mut app);
app.session.close_document(0);
let e = super::super::confirm(&mut app).unwrap_err();
assert!(e.contains("was closed"), "{e}");
assert_eq!(objects(&app, 0), 0);
}
#[test]
fn several_files_placed_without_link_take_the_last_choices() {
let dir = std::env::temp_dir().join(format!("vc-psd-import-queue-{}", std::process::id()));
+283 -4
View File
@@ -11,7 +11,9 @@
//! model), New Row (a row with no current colors above the first selected row, or at the top,
//! with that row's new color; it recolors nothing until Merge moves colors into it), Merge and
//! Separate, Randomize order or
//! saturation and brightness, Reset, the Method and Limit to Library (its folder button imports a
//! saturation and brightness, Find (with it on, the art of the selected rows shows as the preview
//! shows it, their current colors with Preview off, and the rest of the selected art shows its
//! current colors dimmed; a second click shows the art as before), Reset, the Method and Limit to Library (its folder button imports a
//! library file and limits to it; a library's colours apply as its swatches: a spot colour stays a
//! spot colour, and joins the document's swatches). Edit tab: a hue and
//! saturation wheel with a marker per new colour (drag one; with linked handles they all turn and
@@ -50,7 +52,8 @@
//! `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
//! `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). Changing `colors`, a
//! `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
//! preserve flag or `limitTo` reduces the rows again (and drops `weights`).
use egui::{Rect, Sense, Ui, pos2, vec2};
@@ -163,7 +166,7 @@ pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
"preserveWhite": kept("preserveWhite", true), "preserveBlack": kept("preserveBlack", true),
"preserveGrays": kept("preserveGrays", false), "limitTo": limit,
"group": group, "groupName": if new_group { Some(NEW_GROUP) } else { group }, "tab": "assign", "rule": Harmony::Complementary.id(), "linked": true,
"preview": true, THEME_PICKER: false, THEME_PICKS: [], WEIGHTS: null, "__art": art, "__assign": assign, "__newGroup": new_group,
"preview": true, THEME_PICKER: false, THEME_PICKS: [], WEIGHTS: null, FIND: false, "__art": art, "__assign": assign, "__newGroup": new_group,
});
let mut d = Dialog::new(KIND, fields);
// Without art the rows are there from the start: limit them now (art's rows snap as they reduce).
@@ -217,6 +220,8 @@ fn sync(app: &mut VectorcraftApp, d: &mut Dialog) {
}
snap(app, d, &mut rows);
d.fields.insert("rows".into(), Value::Array(rows));
// Find dims the preserved colors with the rows that aren't selected.
d.fields.insert(PRESERVED.into(), r["preserved"].clone());
d.fields.insert("__sel".into(), json!([]));
// The new rows hold no slider edit.
d.fields.remove(COMPS);
@@ -590,6 +595,102 @@ fn apply_params(d: &Dialog) -> Value {
p
}
/// The Find button's field, and the tint of its current color that the art of the rows that
/// aren't selected shows while it is on (VectorCraft's own amount: [`Color::tinted`]).
const FIND: &str = "findColors";
const FIND_DIM: f32 = 0.25;
/// The tints tried when a dimmed color is one a selected row lists: [`FIND_DIM`] and each lighter
/// one a percent apart, down to 1%.
const FIND_TRIES: usize = 25;
/// The colors of the art that the rows leave out (Preserve White, Black and Grays), as
/// `recolor.reduce` returned them.
const PRESERVED: &str = "__preserved";
/// A row's current color as `recolor.apply` matches it: an exact color (its key, parsed whatever
/// its case or spacing), or `Err` with the hex of a "#rrggbb" entry, which matches every color
/// shown as that hex.
type FindEntry = Result<ColorKey, String>;
fn find_entry(k: &Value) -> Option<FindEntry> {
match k.as_str() {
Some(s) => ColorKey::parse(s).map(Ok).or_else(|| color_value(k).map(|c| Err(c.to_hex()))),
None => color_value(k).map(|c| Ok(ColorKey::of(&c))),
}
}
/// While Find is on, on the Assign tab with art and rows selected: what the art previews instead of
/// [`apply_params`], as `command.batch` parameters. A first `recolor.apply` gives each current color
/// of the rows that aren't selected, and each preserved color, its [`FIND_DIM`] tint, or the nearest lighter one when that is a
/// color a selected row lists (a color a selected row also lists stays);
/// with Preview on, a second recolors the selected rows as [`apply_params`] would (the other rows
/// excluded, no color group rewritten). None otherwise, and when there is nothing to dim with
/// Preview off. OK still applies [`apply_params`].
fn find_params(d: &Dialog) -> Option<Value> {
if !d.bool(FIND) || !d.bool("__art") || d.str("tab") == "edit" {
return None;
}
let rs = rows(d);
let sel: Vec<usize> = selection(d).into_iter().filter(|i| *i < rs.len()).collect();
if sel.is_empty() {
return None;
}
let keys = |r: &Value| r["from"].as_array().cloned().unwrap_or_default();
let found: Vec<Value> = sel.iter().flat_map(|&i| keys(&rs[i])).collect();
// The selected rows' entries as `recolor.apply` reads them: exact colors and "#rrggbb" ones.
let found: Vec<FindEntry> = found.iter().filter_map(find_entry).collect();
let found_keys: Vec<ColorKey> = found.iter().filter_map(|e| e.as_ref().ok().copied()).collect();
let found_hex_entries: Vec<String> = found.iter().filter_map(|e| e.as_ref().err().cloned()).collect();
let found_hex: Vec<String> = found.iter().map(|e| e.as_ref().map_or_else(Clone::clone, |k| k.color().to_hex())).collect();
// A dimmed color must not be one the second step recolors (by its key, or by its hex as a
// "#rrggbb" entry matches): the nearest lighter tint that is none of them is taken instead.
let dimmed = |c: Color| {
(0..FIND_TRIES)
.map(|n| c.tinted(FIND_DIM - n as f32 * 0.01))
.find(|t| !found_keys.contains(&ColorKey::of(t)) && !found_hex_entries.contains(&t.to_hex()))
.map(|t| key(&t))
};
// The current colors of the rows that aren't selected, and the preserved colors.
let preserved = d.fields.get(PRESERVED).and_then(Value::as_array).cloned().unwrap_or_default();
let others = rs.iter().enumerate().filter(|(i, _)| !sel.contains(i)).flat_map(|(_, r)| keys(r)).chain(preserved);
let mut dim = serde_json::Map::new();
// A color a selected row lists stays, and so does one shown as the same hex when either entry is
// "#rrggbb" (it matches both). Two keys of the same hex are separate colors.
let listed = |k: &Value| match find_entry(k) {
Some(Ok(key)) => found_keys.contains(&key) || found_hex_entries.contains(&key.color().to_hex()),
Some(Err(hex)) => found_hex.contains(&hex),
None => false,
};
for k in others.filter(|k| !listed(k)) {
// A string entry keeps its own form ("#rrggbb" matches by hex); a color value goes by its key.
let name = match k.as_str() {
Some(s) => Some(s.to_string()),
None => color_value(&k).map(|c| ColorKey::of(&c).to_string()),
};
if let (Some(to), Some(name)) = (color_value(&k).and_then(dimmed), name) {
dim.insert(name, to);
}
}
let mut commands = vec![];
if !dim.is_empty() {
commands.push(json!({"command": CMD, "params": {"map": dim}}));
}
if d.bool("preview") {
let mut p = apply_params(d);
let mut only = rs;
for (_, r) in only.iter_mut().enumerate().filter(|(i, _)| !sel.contains(i)) {
r["exclude"] = json!(true);
}
p["map"] = Value::Array(only);
if let Some(p) = p.as_object_mut() {
for k in ["group", "groupColors", "rename"] {
p.remove(k);
}
}
commands.push(json!({"command": CMD, "params": p}));
}
(!commands.is_empty()).then(|| json!({"commands": commands}))
}
fn body(app: &mut VectorcraftApp, ui: &mut Ui, d: &mut Dialog) -> bool {
sync(app, d);
sync_theme(app, d);
@@ -650,7 +751,15 @@ fn body(app: &mut VectorcraftApp, ui: &mut Ui, d: &mut Dialog) -> bool {
}
sync(app, d);
if d.bool("__art") {
form::preview(app, ui, d, "Recolor Artwork", CMD, apply_params(d));
match find_params(d) {
// Find shows the art so with Preview off too.
Some(p) => {
ui.add_space(8.0);
form::preview_check(ui, d);
form::preview_now(app, d, "Recolor Artwork", "command.batch", p);
}
None => form::preview(app, ui, d, "Recolor Artwork", CMD, apply_params(d)),
}
}
if let Some(c) = pick.and_then(|i| Some((i, to_color(rows(d).get(i)?)?))) {
*d = super::color_picker::over_recolor(d, c.1, c.0);
@@ -874,6 +983,10 @@ fn assign_tab(app: &mut VectorcraftApp, ui: &mut Ui, d: &mut Dialog, rows: &mut
}
}
}
let finding = d.bool(FIND);
if widgets::icon_button_enabled(ui, "search", tl!("Find the selected colors in the artwork"), finding, d.bool("__art"), 24.0).clicked() {
d.fields.insert(FIND.into(), json!(!finding));
}
if widgets::icon_button(ui, "rotate-ccw", tl!("Reset the rows to the artwork's colors"), false, 24.0).clicked() {
d.fields.remove("__reduced");
d.fields.remove(COMPS);
@@ -2104,6 +2217,172 @@ mod tests {
assert_eq!(new_colors(&app), [json!("rgb 0 255 0"), json!("rgb 255 255 0")]);
}
/// Find previews nothing of its own while it is off, on the Edit tab, without art or without a
/// selected row. On, a first `recolor.apply` dims each current color of the other rows (a color
/// a selected row also lists stays), and with Preview on a second recolors the selected rows
/// alone, without rewriting the color group.
#[test]
fn find_dims_the_colors_of_the_rows_not_selected() {
let mut d = Dialog::new(
KIND,
json!({"rows": rows(), "__art": true, "preview": true, "method": "exact", "limitTo": "", "group": "G", "groupName": "H", "__sel": [0]}),
);
assert_eq!(find_params(&d), None, "off");
d.fields.insert(FIND.into(), json!(true));
let dim = |k: &str| key(&color_value(&json!(k)).unwrap().tinted(FIND_DIM));
let p = find_params(&d).expect("on");
let cmds = p["commands"].as_array().unwrap();
assert_eq!(cmds.len(), 2);
assert_eq!(cmds[0]["command"], CMD);
assert_eq!(
cmds[0]["params"]["map"],
json!({"rgb 0 0 255": dim("rgb 0 0 255"), "rgb 0 0 128": dim("rgb 0 0 128"), "rgb 0 255 0": dim("rgb 0 255 0")})
);
assert_eq!(dim("rgb 0 0 255"), json!("rgb 191.25 191.25 255"), "a quarter of the color, the rest white");
let second = &cmds[1]["params"];
assert_eq!(second["map"][0], rows()[0], "the selected row recolors as it would");
assert_eq!((second["map"][1]["exclude"].clone(), second["map"][2]["exclude"].clone()), (json!(true), json!(true)));
assert!(second.get("group").is_none() && second.get("rename").is_none(), "{second}");
// A color that a selected row lists as a hex stays.
let mut e = d.clone();
let mut rs = rows();
rs[0]["from"] = json!(["#0000ff"]);
e.fields.insert("rows".into(), json!(rs));
let map = find_params(&e).unwrap()["commands"][0]["params"]["map"].clone();
assert!(map.get("rgb 0 0 255").is_none() && map.get("rgb 0 0 128").is_some(), "{map}");
// A color a selected row lists by its key keeps only that color: another key of the same hex
// dims, and a hex entry of it stays (it would dim the selected color too).
let mut e = d.clone();
let mut rs = rows();
rs[0]["from"] = json!(["rgb 191 191 255"]);
rs[1]["from"] = json!(["rgb 191.25 191.25 255", "#bfbfff"]);
e.fields.insert("rows".into(), json!(rs));
let map = find_params(&e).unwrap()["commands"][0]["params"]["map"].clone();
assert!(map.get("rgb 191.25 191.25 255").is_some() && map.get("#bfbfff").is_none(), "{map}");
// A key is read whatever its case or spacing, as `recolor.apply` reads it.
let mut e = d.clone();
let mut rs = rows();
rs[0]["from"] = json!(["RGB 191 191 255"]);
rs[1]["from"] = json!(["rgb 191 191 255", "rgb 0 0 128"]);
e.fields.insert("rows".into(), json!(rs));
let map = find_params(&e).unwrap()["commands"][0]["params"]["map"].clone();
assert!(map.get("rgb 191 191 255").is_none() && map.get("rgb 0 0 128").is_some(), "{map}");
// The preserved colors dim too.
let mut e = d.clone();
e.fields.insert(PRESERVED.into(), json!(["rgb 0 0 0"]));
assert_eq!(find_params(&e).unwrap()["commands"][0]["params"]["map"]["rgb 0 0 0"], dim("rgb 0 0 0"));
// A color given as a value instead of a string dims under its key, as `recolor.apply` reads it.
let mut e = d.clone();
let mut rs = rows();
rs[1]["from"] = json!([[0.0, 0.0, 1.0], {"c": 0, "m": 100, "y": 100, "k": 0}]);
e.fields.insert("rows".into(), json!(rs));
let map = find_params(&e).unwrap()["commands"][0]["params"]["map"].clone();
assert_eq!(map["rgb 0 0 255"], dim("rgb 0 0 255"), "{map}");
assert_eq!(map["cmyk 0 100 100 0"], dim("cmyk 0 100 100 0"), "{map}");
// A color a selected row lists is not dimmed; with Preview off only the dimming runs.
let mut rs = rows();
rs[2]["from"] = json!(["rgb 0 255 0", "rgb 255 0 0"]);
d.fields.insert("rows".into(), json!(rs));
d.fields.insert("preview".into(), json!(false));
let p = find_params(&d).unwrap();
assert_eq!(p["commands"].as_array().map(Vec::len), Some(1));
assert!(p["commands"][0]["params"]["map"].get("rgb 255 0 0").is_none(), "{p}");
// A dimmed color that a selected row lists would be recolored with it: a lighter tint is taken.
let mut rs = rows();
rs[0]["from"] = json!(["rgb 255 0 0", "rgb 191.25 191.25 255"]);
d.fields.insert("rows".into(), json!(rs));
let p = find_params(&d).unwrap();
let to = color_value(&p["commands"][0]["params"]["map"]["rgb 0 0 255"]).unwrap();
assert_eq!(to.to_hex(), "#c2c2ff", "{p}");
// So is one that a selected "#rrggbb" entry matches by its hex.
rs[0]["from"] = json!(["rgb 255 0 0", "#bfbfff"]);
d.fields.insert("rows".into(), json!(rs));
let p = find_params(&d).unwrap();
let to = color_value(&p["commands"][0]["params"]["map"]["rgb 0 0 255"]).unwrap();
assert_eq!(to.to_hex(), "#c2c2ff", "{p}");
// When the twenty tints from 25% through 6% are all listed, the 5% tint is taken.
let blue = color_value(&json!("rgb 0 0 255")).unwrap();
let tint = |n: usize| key(&blue.tinted(FIND_DIM - n as f32 * 0.01));
let mut from = vec![json!("rgb 255 0 0")];
from.extend((0..20).map(tint));
rs[0]["from"] = json!(from);
d.fields.insert("rows".into(), json!(rs));
let p = find_params(&d).unwrap();
assert_eq!(p["commands"][0]["params"]["map"]["rgb 0 0 255"], tint(20), "{p}");
// Another key of the same hex matches only itself, so the tint is kept.
rs[0]["from"] = json!(["rgb 255 0 0", "rgb 191 191 255"]);
d.fields.insert("rows".into(), json!(rs));
let p = find_params(&d).unwrap();
assert_eq!(p["commands"][0]["params"]["map"]["rgb 0 0 255"], dim("rgb 0 0 255"), "{p}");
// Every row selected with Preview off: nothing to show.
d.fields.insert("__sel".into(), json!([0, 1, 2]));
assert_eq!(find_params(&d), None);
for (k, v) in [("__sel", json!([])), ("__sel", json!([7])), ("tab", json!("edit")), ("__art", json!(false))] {
let mut e = d.clone();
e.fields.insert("preview".into(), json!(true));
e.fields.insert("__sel".into(), json!([0]));
e.fields.insert(k.into(), v.clone());
assert_eq!(find_params(&e), None, "{k}: {v}");
}
}
/// In the dialog, Find with the red art's row selected shows the red art's new color and the
/// blue art dimmed, with Preview off the red art's own color; off again, the art shows as the
/// preview has it. Cancel leaves the art as it was with no undo step, and OK with Find on
/// applies the rows to all the art, as one undo step.
#[test]
fn find_shows_the_selected_rows_art_and_dims_the_rest() {
let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
let ctx = egui::Context::default();
let [red, blue] = theme_setup(&mut app, &ctx);
let undo = app.session.doc().unwrap().history.undo.len();
let set = |app: &mut VectorcraftApp, k: &str, v: Value| {
app.ui.dialog.as_mut().unwrap().fields.insert(k.into(), v);
};
let rs = json!([{"from": ["rgb 255 0 0"], "to": "rgb 0 255 0"}, {"from": ["rgb 0 0 255"], "to": "rgb 255 255 0"}]);
set(&mut app, "rows", rs.clone());
set(&mut app, "__sel", json!([0]));
frame(&mut app, &ctx, 0.1, vec![], 0);
let fills = |app: &VectorcraftApp| (fill_hex(app, red), fill_hex(app, blue));
assert_eq!(fills(&app), ("#00ff00".into(), "#ffff00".into()), "off: the preview");
set(&mut app, FIND, json!(true));
frame(&mut app, &ctx, 0.2, vec![], 0);
assert_eq!(fills(&app), ("#00ff00".into(), "#bfbfff".into()), "on: the other art dimmed");
set(&mut app, "preview", json!(false));
frame(&mut app, &ctx, 0.3, vec![], 0);
assert_eq!(fills(&app), ("#ff0000".into(), "#bfbfff".into()), "Preview off: the current colors");
set(&mut app, "__sel", json!([1]));
frame(&mut app, &ctx, 0.4, vec![], 0);
assert_eq!(fills(&app), ("#ffbfbf".into(), "#0000ff".into()), "the other row selected");
set(&mut app, FIND, json!(false));
frame(&mut app, &ctx, 0.5, vec![], 0);
assert_eq!(fills(&app), ("#ff0000".into(), "#0000ff".into()), "off with Preview off: the art as it is");
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo, "Find records no undo step");
set(&mut app, FIND, json!(true));
frame(&mut app, &ctx, 0.6, vec![], 0);
crate::dialogs::cancel(&mut app);
assert!(app.ui.dialog.is_none());
assert_eq!(fills(&app), ("#ff0000".into(), "#0000ff".into()), "Cancel: the art as it was");
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo);
// A black square joins the selection: Preserve Black leaves it out of the rows.
let black = square(&mut app, 70.0, "#000000");
let undo = app.session.doc().unwrap().history.undo.len();
app.run("select.set", json!({"ids": [red, blue, black]})).unwrap();
app.run("ui.recolorDialog", json!({})).unwrap();
set(&mut app, "method", json!(Method::Exact.id()));
frame(&mut app, &ctx, 1.0, vec![], 0);
set(&mut app, "rows", rs);
set(&mut app, "__sel", json!([0]));
set(&mut app, FIND, json!(true));
frame(&mut app, &ctx, 1.1, vec![], 0);
assert_eq!(fills(&app), ("#00ff00".into(), "#bfbfff".into()));
assert_eq!(fill_hex(&app, black), "#bfbfbf", "the preserved black dims too");
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!(fills(&app), ("#00ff00".into(), "#ffff00".into()), "OK applies the rows to all the art");
assert_eq!(fill_hex(&app, black), "#000000", "and keeps the preserved black");
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
}
/// In a CMYK document colors opened alone are saved as a new color group in their own model.
#[test]
fn a_new_group_from_colors_keeps_their_model_in_a_cmyk_document() {
+5 -1
View File
@@ -262,7 +262,8 @@ fn extrude_controls(ui: &mut egui::Ui, d: &mut Dialog, unit: Unit) {
});
}
/// Rotation presets, rotation and perspective for Extrude & Bevel, Inflate and Rotate.
/// Rotation presets, rotation and perspective for Extrude & Bevel, Inflate and Rotate, and the
/// classic 3D effects, which have the track cube below the presets.
fn view_controls(ui: &mut egui::Ui, d: &mut Dialog) {
heading(ui, tl!("Rotation"));
let names = [
@@ -296,6 +297,9 @@ fn view_controls(ui: &mut egui::Ui, d: &mut Dialog) {
d.fields.extend([("rotationX".into(), json!(x)), ("rotationY".into(), json!(y)), ("rotationZ".into(), json!(z))]);
}
});
if vectorcraft_effects::is_classic_three_d(&d.str("__effect")) {
super::three_d_classic::track_cube(ui, d);
}
for (key, name) in [("rotationX", tl!("Rotation X")), ("rotationY", tl!("Rotation Y")), ("rotationZ", tl!("Rotation Z"))] {
number(ui, d, key, name, (-180.0, 180.0), "°", 2, None);
}
@@ -61,6 +61,11 @@ impl Harness {
self.ctx.read_response(Id::unique(id)).unwrap().rect
}
/// The open dialog's track cube.
fn cube_id(&self) -> Id {
super::super::three_d_classic::cube_id(&self.app.ui.dialog.as_ref().unwrap().kind)
}
fn click(&mut self, p: Pos2) {
self.frame(vec![Event::PointerMoved(p), button(p, true)]);
self.frame(vec![button(p, false)]);
@@ -460,6 +465,88 @@ fn classic_rotate_shows_its_options_and_applies_as_one_step() {
assert_eq!(h.app.session.doc().unwrap().doc, before);
}
/// The classic effects' track cube: a drag on its face turns the object live and the presets show
/// Custom, Escape during a drag puts the angles back, the ring turns Z alone, the arrow keys turn
/// it with the keyboard focus, and OK keeps it all as one undo step. The newer effects have no cube.
#[test]
fn the_track_cube_turns_the_classic_effects_live_in_one_undo_step() {
use vectorcraft_effects::{CLASSIC_EXTRUDE, CLASSIC_REVOLVE, CLASSIC_ROTATE, EXTRUDE, ROTATE};
let square = "M100 100 L200 100 L200 200 L100 200 Z";
for effect in [EXTRUDE, ROTATE] {
let mut h = Harness::with(square, effect, vec2(1400.0, 1000.0));
h.app.ui.dialog.as_mut().unwrap().fields.insert("__tab".into(), json!("rotation"));
h.settle();
assert!(!h.texts.iter().any(|(t, _)| t == "Track cube"), "{effect} has no track cube");
}
for effect in [CLASSIC_EXTRUDE, CLASSIC_REVOLVE] {
let mut h = Harness::with(square, effect, vec2(1400.0, 1000.0));
h.app.ui.dialog.as_mut().unwrap().fields.insert("__tab".into(), json!("rotation"));
h.settle();
h.rect("Track cube");
}
let mut h = Harness::with(square, CLASSIC_ROTATE, vec2(1400.0, 1000.0));
let before = h.app.session.doc().unwrap().doc.clone();
h.settle();
h.rect("Off-Axis Front");
let start = ["rotationX", "rotationY", "rotationZ"].map(|k| h.value(k));
let cube = h.ctx.read_response(h.cube_id()).unwrap().rect;
// A face, dragged right: the object turns, the document previews it, and the preset is Custom.
h.drag(cube.center(), vec2(30.0, 0.0));
let turned = ["rotationX", "rotationY", "rotationZ"].map(|k| h.value(k));
assert_ne!(turned, start, "the drag turned the object");
h.rect("Custom");
let fx = |h: &Harness| {
let state = h.app.session.doc().unwrap();
state.doc.node(state.selection.objects[0]).unwrap().appearance.effects[0].params.clone()
};
assert_eq!(fx(&h)["rotationY"].as_f64(), Some(turned[1]), "the preview follows the cube");
// Escape during a drag puts the angles back and keeps the dialog open.
let p = cube.center();
h.frame(vec![Event::PointerMoved(p), button(p, true)]);
h.frame(vec![Event::PointerMoved(p + vec2(0.0, 30.0))]);
h.frame(vec![Event::PointerMoved(p + vec2(0.0, 40.0))]);
assert_ne!(h.value("rotationX"), turned[0]);
h.frame(vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }]);
h.frame(vec![button(p + vec2(0.0, 40.0), false)]);
h.settle();
assert!(h.app.ui.dialog.is_some(), "Escape ends the drag, not the dialog");
assert_eq!(["rotationX", "rotationY", "rotationZ"].map(|k| h.value(k)), turned);
// The ring turns in the screen plane: Z alone.
let top = pos2(cube.center().x, cube.center().y - 53.5);
h.drag(top, vec2(12.0, 2.0));
assert_eq!((h.value("rotationX"), h.value("rotationY")), (turned[0], turned[1]));
assert!(h.value("rotationZ") > turned[2], "clockwise: {} -> {}", turned[2], h.value("rotationZ"));
// With the keyboard focus (the drags gave it), Right turns about the screen's vertical axis.
let z = h.value("rotationZ");
assert!(h.ctx.memory(|m| m.has_focus(h.cube_id())), "the drag gave the cube the keyboard focus");
h.frame(vec![Event::Key { key: egui::Key::PageUp, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }]);
h.settle();
assert!((h.value("rotationZ") - (z - 1.0)).abs() < 0.011, "Page Up turns 1° counterclockwise");
let y = h.value("rotationY");
h.frame(vec![Event::Key { key: egui::Key::ArrowRight, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }]);
h.settle();
assert_ne!(h.value("rotationY"), y, "Right turns the cube");
let last = h.value("rotationZ");
dialogs::confirm(&mut h.app).unwrap();
assert_eq!(fx(&h)["rotationZ"].as_f64(), Some(last));
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc().unwrap().doc, before);
}
/// A mixed rotation (the 3D and Materials panel's selected effects differ) leaves the cube off.
#[test]
fn the_track_cube_is_off_while_a_rotation_is_mixed() {
use vectorcraft_effects::CLASSIC_ROTATE;
let mut h = Harness::with("M100 100 L200 100 L200 200 L100 200 Z", CLASSIC_ROTATE, vec2(1400.0, 1000.0));
h.app.ui.dialog.as_mut().unwrap().fields.insert("rotationX".into(), Value::Null);
h.settle();
let cube = h.ctx.read_response(h.cube_id()).unwrap().rect;
h.drag(cube.center(), vec2(30.0, 0.0));
let d = h.app.ui.dialog.as_ref().unwrap();
assert_eq!(d.fields.get("rotationX"), Some(&Value::Null));
assert!(!h.ctx.read_response(h.cube_id()).unwrap().sense.senses_drag());
}
#[test]
fn extrude_bevel_options_enable_with_a_bevel_shape() {
let mut h = Harness::with("M100 100 L200 100 L200 200 L100 200 Z", vectorcraft_effects::EXTRUDE, vec2(1400.0, 1000.0));
+3 -1
View File
@@ -42,8 +42,10 @@ fn drag_id() -> Id {
Id::unique("revolve-gizmo-drag")
}
/// Is a rotation or light gesture in progress, on the artboard or on the classic 3D effects' track
/// cube?
pub(crate) fn dragging(ctx: &egui::Context) -> bool {
ctx.data(|m| m.get_temp::<Drag>(drag_id())).is_some()
ctx.data(|m| m.get_temp::<Drag>(drag_id())).is_some() || super::three_d_classic::cube_dragging(ctx)
}
pub(super) fn clear(ctx: &egui::Context) {
+16 -2
View File
@@ -325,6 +325,19 @@ pub(super) fn pick<T: Choice>(ui: &mut egui::Ui, d: &mut Dialog, path: &str, wid
true
}
/// [`pick`] with a first entry, `unset`, for a setting that isn't set: shown while the value at
/// `path` isn't one of the choices, and stored as [`vectorcraft_pdf::UNSET_CHOICE`] when chosen.
fn pick_or_unset<T: Choice>(ui: &mut egui::Ui, d: &mut Dialog, path: &str, width: f32, unset: &str) -> bool {
let current = choice_index::<T>(d, path).map_or(0, |i| i + 1);
let lang = crate::i18n::current();
let labels: Vec<&str> = std::iter::once(unset).chain(T::LABELS.iter().map(|label| choice_label(lang, path, label))).collect();
let label = labels.get(current).copied().unwrap_or(unset);
let Some(i) = widgets::dropdown_with(ui, path, label, &labels, width, |_| true) else { return false };
let id = i.checked_sub(1).and_then(|i| T::IDS.get(i)).copied().unwrap_or(vectorcraft_pdf::UNSET_CHOICE);
set(d, path, json!(id));
true
}
/// Printer mark styles use adjectives, separately from interface language names.
pub(super) fn choice_label<'a>(lang: crate::i18n::Lang, path: &str, label: &'a str) -> &'a str {
if path == "marks.kind" { crate::i18n::tr_ctx(lang, "mark-style", label) } else { crate::i18n::tr(lang, label) }
@@ -663,8 +676,9 @@ fn output(ui: &mut egui::Ui, d: &mut Dialog) {
.collect();
row(ui, tl!("Destination:"), |ui| profile_pick(ui, d, "output.destination", &destinations, 2, converting));
row(ui, tl!("Profile inclusion:"), |ui| {
// A standard decides whether colours are tagged.
ui.add_enabled_ui(standard == Standard::None, |ui| pick::<ProfileInclusion>(ui, d, "output.profiles", 300.0, |_| true));
// A standard decides whether colours are tagged. Not set, colors are untagged and gray and
// RGB images keep their profiles (shown as Default).
ui.add_enabled_ui(standard == Standard::None, |ui| pick_or_unset::<ProfileInclusion>(ui, d, "output.profiles", 300.0, tl!("Default")));
});
if standard.cmyk_only() {
note(ui, tl!("PDF/X-1a files are CMYK: every colour is converted to the destination (blank: the output intent's CMYK profile), untagged."));

Some files were not shown because too many files have changed in this diff Show More